diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..bf80177 Binary files /dev/null and b/.DS_Store differ diff --git a/lib/forge-std b/lib/forge-std index 978ac6f..1de6eec 160000 --- a/lib/forge-std +++ b/lib/forge-std @@ -1 +1 @@ -Subproject commit 978ac6fadb62f5f0b723c996f64be52eddba6801 +Subproject commit 1de6eecf821de7fe2c908cc48d3ab3dced20717f diff --git a/lib/openzeppelin-contracts b/lib/openzeppelin-contracts index dbb6104..5bb3f3e 160000 --- a/lib/openzeppelin-contracts +++ b/lib/openzeppelin-contracts @@ -1 +1 @@ -Subproject commit dbb6104ce834628e473d2173bbc9d47f81a9eec3 +Subproject commit 5bb3f3e788c6b2c806d562ef083b438354f969d7 diff --git a/src/Types.sol b/src/Types.sol deleted file mode 100644 index bc03c35..0000000 --- a/src/Types.sol +++ /dev/null @@ -1,11 +0,0 @@ -// SPDX-License-Identifier: UNLICENSED -pragma solidity 0.8.20; - -struct BlockHeader { - bytes32 merkleRootHash; - bytes4 nBits; - bytes4 nonce; - bytes32 previousBlockHash; - bytes4 timestamp; - bytes4 version; -} diff --git a/src/Utils.sol b/src/Utils.sol deleted file mode 100644 index 0c063be..0000000 --- a/src/Utils.sol +++ /dev/null @@ -1,53 +0,0 @@ -// SPDX-License-Identifier: UNLICENSED -pragma solidity ^0.8.20; - -import {BlockHeader} from "./Types.sol"; - -library Utils { - function convertBytesToUint(bytes memory b) internal pure returns (uint256) { - uint256 number; - uint256 length = b.length; - require(length <= 32, "SPVLib: length cannot be greater than 32 bytes"); - for (uint256 i = 0; i < length; i++) { - number = number + uint256(uint8(b[i])) * (2 ** (8 * (length - (i + 1)))); - } - return number; - } - - function convertToBigEndian(bytes memory bytesLE) internal pure returns (bytes memory) { - uint256 length = bytesLE.length; - bytes memory bytesBE = new bytes(length); - for (uint256 i = 0; i < length; i++) { - bytesBE[length - i - 1] = bytesLE[i]; - } - return bytesBE; - } - - function convertnBitsToTarget(bytes memory nBitsBytes) internal pure returns (uint256) { - uint256 nBits = convertBytesToUint(convertToBigEndian(nBitsBytes)); - uint256 exp = uint256(nBits) >> 24; - uint256 c = nBits & 0xffffff; - uint256 target = uint256((c * 2 ** (8 * (exp - 3)))); - return target; - } - - function doubleHash(bytes memory data) internal pure returns (bytes32) { - return sha256(abi.encodePacked(sha256(abi.encodePacked(data)))); - } - - function convertToBytes32(bytes memory data) internal pure returns (bytes32 result) { - assembly { - // Copy 32 bytes from data into result - result := mload(add(data, 32)) - } - } - - function parseBlockHeader(bytes calldata blockHeader) internal pure returns (BlockHeader memory parsedHeader) { - parsedHeader.version = bytes4(blockHeader[:4]); - parsedHeader.previousBlockHash = bytes32(blockHeader[4:36]); - parsedHeader.merkleRootHash = bytes32(blockHeader[36:68]); - parsedHeader.timestamp = bytes4(blockHeader[68:72]); - parsedHeader.nBits = bytes4(blockHeader[72:76]); - parsedHeader.nonce = bytes4(blockHeader[76:]); - } -} diff --git a/src/VerifySPV.sol b/src/VerifySPV.sol index 712c904..4b23e3c 100644 --- a/src/VerifySPV.sol +++ b/src/VerifySPV.sol @@ -1,48 +1,177 @@ -// SPDX-License-Identifier: UNLICENSED -pragma solidity 0.8.20; +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; import {IVerifySPV} from "./interfaces/IVerifySPV.sol"; -import {BlockHeader, SPVLib} from "./libraries/SPVLib.sol"; -import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; -import {Utils} from "./Utils.sol"; +import {LibSPV} from "./libraries/LibSPV.sol"; +import {BlockHeader, Prevout, Outpoint, LibBitcoin} from "./libraries/LibBitcoin.sol"; + +struct BlockRecord { + BlockHeader header; + uint256 confidence; + uint256 height; +} contract VerifySPV is IVerifySPV { - using SPVLib for BlockHeader; - using Utils for bytes; + using LibSPV for BlockHeader; + using LibBitcoin for bytes; - mapping(bytes32 => BlockHeader) public blockHeaders; + mapping(bytes32 => BlockRecord) public blockHeaders; + // reverse mapping for block number to block hashes + mapping(uint256 => bytes32) public blockHashes; // every difficulty epoch's block hash // updates for every 2016th block = every 28 epochs bytes32 public LDEBlockHash; - // epoch is incremented for every block register ,1 epoch = 72 blocks - uint256 public epoch; - event BlockRegistered(bytes32 blockHash); + bytes32 public LatestBlockHash; + + uint256 public minimumConfidence; + + bool public isTestnet; + + event BlockRegistered(bytes32 indexed blockHash, uint256 indexed height); - constructor(BlockHeader memory genesisHeader) { + // @dev Constructor to initialize the contract with the genesis block + // @dev Genesis block here means the first block in the SPV system + // @param genesisHeader - BlockHeader of the genesis block + // @param height - Height of the genesis block + // @param _minimumConfidence - Minimum number of blocks required to consider the latest block as confirmed + // @param _isTestnet - Boolean indicating if the chain is a testnet + // @notice The genesis block should be at the start of a difficulty epoch => height % 2016 == 0 + constructor( + BlockHeader memory genesisHeader, + uint256 height, + uint256 _minimumConfidence, + bool _isTestnet + ) { + require( + _isTestnet || height % 2016 == 0, + "VerifySPV: genesis block should be at the start of a difficulty epoch" + ); LDEBlockHash = genesisHeader.calculateBlockHash(); - blockHeaders[genesisHeader.calculateBlockHash()] = genesisHeader; - epoch = 0; + LatestBlockHash = LDEBlockHash; + blockHeaders[LDEBlockHash] = BlockRecord({ + header: genesisHeader, + confidence: 0, + height: height + }); + blockHashes[height] = LDEBlockHash; + minimumConfidence = _minimumConfidence; + isTestnet = _isTestnet; } - function registerBlock(BlockHeader[] calldata newEpoch) public { - require(newEpoch.length == 76, "VerifySPV: invalid epoch, should contain previous 72 blocks and next 3 blocks"); + // @dev Register a new block on the chain + // @param newEpoch - Array of block headers for the new epoch + // @param blockIndex - Index of the block to be registered in the new epoch + // @notice The blockIndex should be greater than 0 and less than the length of the newEpoch array + // @notice The newEpoch array should contain the current block and atleast minimumConfidence number of blocks + // @notice The newEpoch array should not contain more than 2016 blocks + // @notice The starting block of the newEpoch should be the latest block hash + // @notice To register a new block from new difficulty epoch, the first block of the newEpoch should be registered first + function registerLatestBlock( + BlockHeader[] calldata newEpoch, + uint256 blockIndex + ) public { + require( + blockIndex < newEpoch.length && blockIndex > 0, + "VerifySPV: invalid block index" + ); + require( + newEpoch.length >= blockIndex + minimumConfidence + 1, + "VerifySPV: invalid epoch, should contain the current block and atleast next block" + ); + + require( + newEpoch.length <= 2016 + minimumConfidence + 1, + "VerifySPV: invalid epoch, should not contain more than 2016 blocks" + ); require( - blockHeaders[newEpoch[0].calculateBlockHash()].previousBlockHash != bytes32(0x0), + newEpoch[0].calculateBlockHash() == LatestBlockHash, "VerifySPV: invalid epoch, starting block not on chain" ); - epoch++; + uint256 newHeight = blockHeaders[LatestBlockHash].height + blockIndex; + + require( + isTestnet || + newHeight % 2016 == 0 || + (newHeight % 2016 != 0 && + blockHashes[(newHeight / 2016) * 2016] == LDEBlockHash), + "VerifySPV: invalid epoch, last difficulty epoch block should be regostered before following blocks" + ); + + require( + blockHashes[newHeight] == bytes32(0x0), + "VerifySPV: block already registered" + ); - verifySequence(newEpoch); + verifySequence(newEpoch, newHeight, blockIndex); + + bytes32 newEpochBlockHash = newEpoch[blockIndex].calculateBlockHash(); + blockHeaders[newEpochBlockHash] = BlockRecord({ + header: newEpoch[blockIndex], + confidence: newEpoch.length - blockIndex - 1, + height: newHeight + }); + + LatestBlockHash = newEpochBlockHash; + + if (newHeight % 2016 == 0) { + LDEBlockHash = newEpochBlockHash; + } + + blockHashes[newHeight] = newEpochBlockHash; + + emit BlockRegistered(newEpochBlockHash, newHeight); + } + + // @dev Register a block between two blocks already on the chain + // @param blockSequence - Array of block headers for the new epoch + // @param blockIndex - Index of the block to be registered in the new epoch + // @notice The intended block should be between the first and last block of the blockSequence + // @notice This can be used to optimize the gas cost of verify function if demand for number of + // @notice tx inclusion proofs are higer between two already registered blocks which are undesirably far in height. + function registerInclusiveBlock( + BlockHeader[] calldata blockSequence, + uint256 blockIndex + ) public { + require( + blockIndex < blockSequence.length, + "VerifySPV: invalid block index" + ); + + require( + blockHeaders[blockSequence[0].calculateBlockHash()].height != 0, + "VerifySPV: invalid epoch, starting block not on chain" + ); + + require( + blockHeaders[ + blockSequence[blockSequence.length - 1].calculateBlockHash() + ].height != 0, + "VerifySPV: invalid epoch, ending block not on chain" + ); - bytes32 newEpochBlockHash = newEpoch[72].calculateBlockHash(); - blockHeaders[newEpochBlockHash] = newEpoch[72]; + verifySequence( + blockSequence, + blockHeaders[blockSequence[0].calculateBlockHash()].height + + blockIndex, + blockIndex + ); - emit BlockRegistered(newEpochBlockHash); + LatestBlockHash = blockSequence[blockIndex].calculateBlockHash(); + blockHashes[ + blockHeaders[blockSequence[0].calculateBlockHash()].height + + blockIndex + ] = LatestBlockHash; } + // @dev Verify the inclusion of a transaction in a block + // @param blockSequence - Array of block headers between two blocks already on the chain + // @param blockIndex - Index of the desired block in the blockSequence + // @param txIndex - Index of the transaction in the block + // @param txHash - Transaction hash to be verified + // @param proof - Array of merkle proof hashes function verifyTxInclusion( BlockHeader[] calldata blockSequence, uint256 blockIndex, @@ -50,60 +179,170 @@ contract VerifySPV is IVerifySPV { bytes32 txHash, bytes32[] memory proof ) public view returns (bool) { - require(blockSequence.length == 73, "VerifySPV: inclusion verification needs all 72 blocks in the epoch"); + require( + blockIndex < blockSequence.length, + "VerifySPV: invalid block index" + ); require( - blockHeaders[blockSequence[0].calculateBlockHash()].previousBlockHash != bytes32(0x0), + blockHeaders[blockSequence[0].calculateBlockHash()].height != 0, "VerifySPV: invalid epoch, starting block not on chain" ); require( - blockHeaders[blockSequence[72].calculateBlockHash()].previousBlockHash != bytes32(0x0), - "VerifySPV: invalid epoch, ending block not on chain" + blockHeaders[ + blockSequence[blockSequence.length - 1].calculateBlockHash() + ].height != 0, + "VerifySPV: invalid epoch, starting block not on chain" ); - uint256 target = (abi.encodePacked((blockSequence[0].nBits))).convertnBitsToTarget(); - verifySubSequence(blockSequence[0:72], target); + + verifySequence( + blockSequence, + blockHeaders[blockSequence[0].calculateBlockHash()].height + + blockIndex, + blockIndex + ); + return blockSequence[blockIndex].verifyProof(txHash, txIndex, proof); } - function verifySequence(BlockHeader[] calldata blockSequence) internal { - uint256 target = (abi.encodePacked((blockHeaders[LDEBlockHash].nBits))).convertnBitsToTarget(); - if (epoch % 28 == 0) { + // @dev Parse and verify the inclusion of a transaction in a block + // @param blockSequence - Array of block headers between two blocks already on the chain + // @param txHex - Transaction in raw hex bytes to be verified + // @param blockIndex - Index of the desired block in the blockSequence + // @param txIndex - Index of the transaction in the block + // @param proof - Array of merkle proof hashes + // @return success - Boolean indicating the success of the verification + // @return txHash - Hash of the transaction + // @return prevOuts - Array of previous outputs of inputs in the transaction + // @return outPoints - Array of outputs of the transaction + function parseAndVerifyTxInclusion( + BlockHeader[] calldata blockSequence, + bytes calldata txHex, + uint256 blockIndex, + uint256 txIndex, + bytes32[] memory proof + ) public view returns (bool, bytes32, Prevout[] memory, Outpoint[] memory) { + ( + bytes32 txHash, + Prevout[] memory prevOuts, + Outpoint[] memory outPoints + ) = txHex.parseTx(); + + return ( + verifyTxInclusion( + blockSequence, + blockIndex, + txIndex, + txHash, + proof + ), + txHash, + prevOuts, + outPoints + ); + } + + // @dev Get confidence of a block by its hash + // @dev Confidence is the number of blocks after the block in the longest chain + // @dev plus the minimum confidence used to consider the latest block as confirmed + // @param blockHash - Hash of the block + function confidenceByHash(bytes32 blockHash) public view returns (uint256) { + require( + blockHeaders[blockHash].height != 0, + "VerifySPV: block not registered" + ); + return + blockHeaders[LatestBlockHash].confidence + + (blockHeaders[LatestBlockHash].height - + blockHeaders[blockHash].height); + } + + // @dev Get confidence of a block by its height + function confidenceByHeight(uint256 height) public view returns (uint256) { + return confidenceByHash(blockHashes[height]); + } + + function verifySequence( + BlockHeader[] calldata blockSequence, + uint256 height, + uint256 blockIndex + ) internal view { + // Testnet3 difficulty adjustment is not as strict as mainnet + // Testnet4 has different consensus rules + if (isTestnet) { require( - verifySubSequence(blockSequence[:72], target), "VerifySPV: pre subsequence in difficulty epoch failed" + verifySubSequence(blockSequence, 1), + "VerifySPV: sequence verification failed" ); - uint256 adjustedTarget = blockSequence[72].calculateNewTarget(target, blockHeaders[LDEBlockHash].timestamp); - uint256 newTarget = (abi.encodePacked((blockSequence[72].nBits))).convertnBitsToTarget(); + } + + uint256 epochDivider = blockSequence.length; + if (height % 2016 == 0) { + epochDivider = blockIndex; + } else { + uint256 overFlow = (height % 2016) + + (blockSequence.length - blockIndex) - + 1; + if (overFlow > 2015) { + epochDivider -= (overFlow - 2015); + } + } + + uint256 target = ( + abi.encodePacked((blockHeaders[LDEBlockHash].header.nBits)) + ).convertnBitsToTarget(); + + require(verifySubSequence(blockSequence[:epochDivider], target)); + if (epochDivider < blockSequence.length) { + uint256 adjustedTarget = blockSequence[epochDivider] + .calculateNewTarget( + target, + blockHeaders[LDEBlockHash].header.timestamp + ); + uint256 newTarget = ( + abi.encodePacked((blockSequence[epochDivider].nBits)) + ).convertnBitsToTarget(); require( - SPVLib.verifyDifficultyEpochTarget(adjustedTarget, newTarget), + LibSPV.verifyDifficultyEpochTarget(adjustedTarget, newTarget), "VerifySPV: adjusted difficulty is not in allowed range" ); require( - blockSequence[71].calculateBlockHash() == blockSequence[72].previousBlockHash - && blockSequence[72].verifyWork(), + blockSequence[epochDivider - 1].calculateBlockHash() == + blockSequence[epochDivider].previousBlockHash && + blockSequence[epochDivider].verifyWork(), "VerifySPV: difficulty epoch validation failed" ); require( - verifySubSequence(blockSequence[73:], newTarget), + verifySubSequence(blockSequence[epochDivider:], newTarget), "VerifySPV: post subsequence in difficulty epoch failed" ); - LDEBlockHash = blockSequence[72].calculateBlockHash(); - } else { - require(verifySubSequence(blockSequence, target), "VerifySPV: sequence verification failed"); } } - function verifySubSequence(BlockHeader[] calldata blockSequence, uint256 target) internal pure returns (bool) { + function verifySubSequence( + BlockHeader[] calldata blockSequence, + uint256 target + ) internal view returns (bool) { for (uint256 i = 1; i < blockSequence.length; i++) { if ( - !( - blockSequence[i - 1].calculateBlockHash() == blockSequence[i].previousBlockHash - && blockSequence[i].verifyTarget(target) && blockSequence[i].verifyWork() - ) + !(blockSequence[i - 1].calculateBlockHash() == + blockSequence[i].previousBlockHash) + ) { + return false; + } + + if (isTestnet) { + return true; + } + if ( + !blockSequence[i].verifyTarget(target) && + blockSequence[i].verifyWork() ) { return false; } } + return true; } } diff --git a/src/interfaces/IVerifySPV.sol b/src/interfaces/IVerifySPV.sol index c036a98..1b7064f 100644 --- a/src/interfaces/IVerifySPV.sol +++ b/src/interfaces/IVerifySPV.sol @@ -1,10 +1,13 @@ // SPDX-License-Identifier: Unlicense pragma solidity ^0.8.20; -import {BlockHeader} from "../libraries/SPVLib.sol"; +import {BlockHeader} from "../libraries/LibSPV.sol"; interface IVerifySPV { - function registerBlock(BlockHeader[] calldata newEpoch) external; + function registerLatestBlock( + BlockHeader[] calldata newEpoch, + uint256 blockIndex + ) external; function verifyTxInclusion( BlockHeader[] calldata blockSequence, diff --git a/src/libraries/LibBitcoin.sol b/src/libraries/LibBitcoin.sol new file mode 100644 index 0000000..6f6c74a --- /dev/null +++ b/src/libraries/LibBitcoin.sol @@ -0,0 +1,249 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +struct BlockHeader { + bytes32 merkleRootHash; + bytes4 nBits; + bytes4 nonce; + bytes32 previousBlockHash; + bytes4 timestamp; + bytes4 version; +} + +struct Outpoint { + bytes spk; + uint32 amount; +} + +struct Prevout { + bytes32 txid; + uint32 vout; +} + +library LibBitcoin { + function convertToBigEndian( + bytes memory bytesLE + ) internal pure returns (bytes memory) { + uint256 length = bytesLE.length; + bytes memory bytesBE = new bytes(length); + for (uint256 i = 0; i < length; i++) { + bytesBE[length - i - 1] = bytesLE[i]; + } + return bytesBE; + } + + function convertnBitsToTarget( + bytes memory nBitsBytes + ) internal pure returns (uint256) { + uint256 nBits = bytesToUint256((convertToBigEndian(nBitsBytes))); + uint256 exp = uint256(nBits) >> 24; + uint256 c = nBits & 0xffffff; + uint256 target = uint256((c * 2 ** (8 * (exp - 3)))); + return target; + } + + function doubleHash(bytes memory data) internal pure returns (bytes32) { + return sha256(abi.encodePacked(sha256(abi.encodePacked(data)))); + } + + function convertToBytes32( + bytes memory data + ) internal pure returns (bytes32 result) { + assembly { + // Copy 32 bytes from data into result + result := mload(add(data, 32)) + } + } + + function parseBlockHeader( + bytes calldata blockHeader + ) internal pure returns (BlockHeader memory parsedHeader) { + parsedHeader.version = bytes4(blockHeader[:4]); + parsedHeader.previousBlockHash = bytes32(blockHeader[4:36]); + parsedHeader.merkleRootHash = bytes32(blockHeader[36:68]); + parsedHeader.timestamp = bytes4(blockHeader[68:72]); + parsedHeader.nBits = bytes4(blockHeader[72:76]); + parsedHeader.nonce = bytes4(blockHeader[76:]); + } + + function decodeVarint( + bytes calldata data, + uint256 offset + ) public pure returns (uint8, bytes memory) { + if (data[offset] < 0xfd) { + return (0x01, data[offset:offset + 1]); + } else if (data[offset] == 0xfd) { + return (0x03, convertToBigEndian(data[offset + 1:offset + 1 + 2])); + } else if (data[offset] == 0xfe) { + return (0x05, convertToBigEndian(data[offset + 1:offset + 1 + 4])); + } else { + return (0x09, convertToBigEndian(data[offset + 1:offset + 1 + 8])); + } + } + + function encodeVarint(uint64 number) public pure returns (bytes memory) { + if (number < 0xfd) { + return convertToBigEndian(abi.encodePacked(uint8(number))); + } else if (number <= 0xffff) { + return + abi.encodePacked( + bytes1(0xfd), + convertToBigEndian(abi.encodePacked(uint16(number))) + ); + } else if (number <= 0xffffffff) { + return + abi.encodePacked( + bytes1(0xfe), + convertToBigEndian(abi.encodePacked(uint32(number))) + ); + } else { + return + abi.encodePacked( + bytes1(0xff), + convertToBigEndian(abi.encodePacked(uint64(number))) + ); + } + } + + function bytesToUint256( + bytes memory data + ) public pure returns (uint256 result) { + require(data.length <= 32, "Input bytes length must be <= 32"); + + assembly { + let length := mload(data) + + if gt(length, 0) { + // Add 0x20 to skip the length prefix of the bytes array + result := mload(add(data, 0x20)) + + // Shift right to account for any bytes less than 32 + let shift := mul(sub(32, length), 8) + result := shr(shift, result) + } + } + } + + function parseTx( + bytes calldata txHex + ) public pure returns (bytes32, Prevout[] memory, Outpoint[] memory) { + (uint256 offset, Prevout[] memory prevouts) = parsePrevouts(txHex, 6); + (uint256 outPointoffset, Outpoint[] memory outpoints) = parseOutpoints( + txHex, + offset + ); + bytes32 txId = calculateTxId(txHex, outPointoffset); + + return (txId, prevouts, outpoints); + } + + // Parse transaction inputs (prevouts) + function parsePrevouts( + bytes calldata txHex, + uint256 startOffset + ) public pure returns (uint256 offset, Prevout[] memory prevouts) { + offset = startOffset; + + (uint8 bytesLength, bytes memory numInputs) = decodeVarint( + txHex, + offset + ); + offset += bytesLength; + + uint256 inputCount = bytesToUint256(numInputs); + prevouts = new Prevout[](inputCount); + + for (uint256 i = 0; i < inputCount; i++) { + (offset, prevouts[i]) = parseSinglePrevout(txHex, offset); + } + } + + // Parse a single prevout + function parseSinglePrevout( + bytes calldata txHex, + uint256 offset + ) public pure returns (uint256 newOffset, Prevout memory prevout) { + prevout.txid = bytes32( + convertToBigEndian(txHex[offset:offset + 32]) + ); + prevout.vout = uint32( + bytes4(convertToBigEndian(txHex[offset + 32:offset + 36])) + ); + offset += 36; + + // Handle scriptSig + (uint8 scriptSigLength, bytes memory scriptSigValue) = decodeVarint( + txHex, + offset + ); + offset += scriptSigLength; + offset += bytesToUint256(scriptSigValue); + + // Skip sequence + offset += 4; + + newOffset = offset; + } + + // Parse transaction outputs + function parseOutpoints( + bytes calldata txHex, + uint256 startOffset + ) public pure returns (uint256 offset, Outpoint[] memory outpoints) { + offset = startOffset; + + (uint8 outputsLength, bytes memory numOutputs) = decodeVarint( + txHex, + offset + ); + offset += outputsLength; + + uint256 outputCount = bytesToUint256(numOutputs); + outpoints = new Outpoint[](outputCount); + + for (uint256 i = 0; i < outputCount; i++) { + (offset, outpoints[i]) = parseSingleOutpoint(txHex, offset); + } + } + + // Parse a single outpoint + function parseSingleOutpoint( + bytes calldata txHex, + uint256 offset + ) public pure returns (uint256 newOffset, Outpoint memory outpoint) { + outpoint.amount = uint32( + bytesToUint256(convertToBigEndian(bytes(txHex[offset:offset + 8]))) + ); + offset += 8; + + (uint8 spkByteLength, bytes memory spkLength) = decodeVarint( + txHex, + offset + ); + offset += spkByteLength; + + uint256 spkLengthValue = bytesToUint256(spkLength); + outpoint.spk = txHex[offset:offset + spkLengthValue]; + offset += spkLengthValue; + + newOffset = offset; + } + + // Calculate transaction ID + function calculateTxId( + bytes calldata txHex, + uint256 offset + ) public pure returns (bytes32) { + bytes memory txWithoutWitness = bytes.concat( + txHex[:4], + txHex[6:offset], + txHex[txHex.length - 4:] + ); + + bytes memory txIdInNaturalByteOrder = abi.encodePacked( + sha256(abi.encodePacked(sha256(txWithoutWitness))) + ); + + return bytes32(convertToBigEndian(txIdInNaturalByteOrder)); + } +} diff --git a/src/libraries/LibEllipticCurve.sol b/src/libraries/LibEllipticCurve.sol new file mode 100644 index 0000000..d31a35a --- /dev/null +++ b/src/libraries/LibEllipticCurve.sol @@ -0,0 +1,329 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.2; + +/** + * @title Elliptic Curve Library + * @dev Library providing arithmetic operations over elliptic curves. + * This library does not check whether the inserted points belong to the curve + * `isOnCurve` function should be used by the library user to check the aforementioned statement. + * @author Witnet Foundation + * https://github.com/witnet/elliptic-curve-solidity + */ +library LibEllipticCurve { + // Pre-computed constant for 2 ** 255 + uint256 private constant U255_MAX_PLUS_1 = + 57896044618658097711785492504343953926634992332820282019728792003956564819968; + + /// @dev Modular euclidean inverse of a number (mod p). + /// @param _x The number + /// @param _pp The modulus + /// @return q such that x*q = 1 (mod _pp) + function invMod(uint256 _x, uint256 _pp) internal pure returns (uint256) { + require(_x != 0 && _x != _pp && _pp != 0, "Invalid number"); + uint256 q = 0; + uint256 newT = 1; + uint256 r = _pp; + uint256 t; + while (_x != 0) { + t = r / _x; + (q, newT) = (newT, addmod(q, (_pp - mulmod(t, newT, _pp)), _pp)); + (r, _x) = (_x, r - t * _x); + } + + return q; + } + + /// @dev Modular exponentiation, b^e % _pp. + /// Source: https://github.com/androlo/standard-contracts/blob/master/contracts/src/crypto/ECCMath.sol + /// @param _base base + /// @param _exp exponent + /// @param _pp modulus + /// @return r such that r = b**e (mod _pp) + function expMod(uint256 _base, uint256 _exp, uint256 _pp) internal pure returns (uint256) { + require(_pp != 0, "EllipticCurve: modulus is zero"); + + if (_base == 0) return 0; + if (_exp == 0) return 1; + + uint256 r = 1; + uint256 bit = U255_MAX_PLUS_1; + assembly { + for {} gt(bit, 0) {} { + r := mulmod(mulmod(r, r, _pp), exp(_base, iszero(iszero(and(_exp, bit)))), _pp) + r := mulmod(mulmod(r, r, _pp), exp(_base, iszero(iszero(and(_exp, div(bit, 2))))), _pp) + r := mulmod(mulmod(r, r, _pp), exp(_base, iszero(iszero(and(_exp, div(bit, 4))))), _pp) + r := mulmod(mulmod(r, r, _pp), exp(_base, iszero(iszero(and(_exp, div(bit, 8))))), _pp) + bit := div(bit, 16) + } + } + + return r; + } + + /// @dev Converts a point (x, y, z) expressed in Jacobian coordinates to affine coordinates (x', y', 1). + /// @param _x coordinate x + /// @param _y coordinate y + /// @param _z coordinate z + /// @param _pp the modulus + /// @return (x', y') affine coordinates + function toAffine(uint256 _x, uint256 _y, uint256 _z, uint256 _pp) internal pure returns (uint256, uint256) { + uint256 zInv = invMod(_z, _pp); + uint256 zInv2 = mulmod(zInv, zInv, _pp); + uint256 x2 = mulmod(_x, zInv2, _pp); + uint256 y2 = mulmod(_y, mulmod(zInv, zInv2, _pp), _pp); + + return (x2, y2); + } + + /// @dev Derives the y coordinate from a compressed-format point x [[SEC-1]](https://www.secg.org/SEC1-Ver-1.0.pdf). + /// @param _prefix parity byte (0x02 even, 0x03 odd) + /// @param _x coordinate x + /// @param _aa constant of curve + /// @param _bb constant of curve + /// @param _pp the modulus + /// @return y coordinate y + function deriveY(uint8 _prefix, uint256 _x, uint256 _aa, uint256 _bb, uint256 _pp) + internal + pure + returns (uint256) + { + require(_prefix == 0x02 || _prefix == 0x03, "EllipticCurve:innvalid compressed EC point prefix"); + + // x^3 + ax + b + uint256 y2 = addmod(mulmod(_x, mulmod(_x, _x, _pp), _pp), addmod(mulmod(_x, _aa, _pp), _bb, _pp), _pp); + y2 = expMod(y2, (_pp + 1) / 4, _pp); + // uint256 cmp = yBit ^ y_ & 1; + uint256 y = (y2 + _prefix) % 2 == 0 ? y2 : _pp - y2; + + return y; + } + + /// @dev Check whether point (x,y) is on curve defined by a, b, and _pp. + /// @param _x coordinate x of P1 + /// @param _y coordinate y of P1 + /// @param _aa constant of curve + /// @param _bb constant of curve + /// @param _pp the modulus + /// @return true if x,y in the curve, false else + function isOnCurve(uint256 _x, uint256 _y, uint256 _aa, uint256 _bb, uint256 _pp) internal pure returns (bool) { + if (0 == _x || _x >= _pp || 0 == _y || _y >= _pp) { + return false; + } + // y^2 + uint256 lhs = mulmod(_y, _y, _pp); + // x^3 + uint256 rhs = mulmod(mulmod(_x, _x, _pp), _x, _pp); + if (_aa != 0) { + // x^3 + a*x + rhs = addmod(rhs, mulmod(_x, _aa, _pp), _pp); + } + if (_bb != 0) { + // x^3 + a*x + b + rhs = addmod(rhs, _bb, _pp); + } + + return lhs == rhs; + } + + /// @dev Calculate inverse (x, -y) of point (x, y). + /// @param _x coordinate x of P1 + /// @param _y coordinate y of P1 + /// @param _pp the modulus + /// @return (x, -y) + function ecInv(uint256 _x, uint256 _y, uint256 _pp) internal pure returns (uint256, uint256) { + return (_x, (_pp - _y) % _pp); + } + + /// @dev Add two points (x1, y1) and (x2, y2) in affine coordinates. + /// @param _x1 coordinate x of P1 + /// @param _y1 coordinate y of P1 + /// @param _x2 coordinate x of P2 + /// @param _y2 coordinate y of P2 + /// @param _aa constant of the curve + /// @param _pp the modulus + /// @return (qx, qy) = P1+P2 in affine coordinates + function ecAdd(uint256 _x1, uint256 _y1, uint256 _x2, uint256 _y2, uint256 _aa, uint256 _pp) + internal + pure + returns (uint256, uint256) + { + uint256 x = 0; + uint256 y = 0; + uint256 z = 0; + + // Double if x1==x2 else add + if (_x1 == _x2) { + // y1 = -y2 mod p + if (addmod(_y1, _y2, _pp) == 0) { + return (0, 0); + } else { + // P1 = P2 + (x, y, z) = jacDouble(_x1, _y1, 1, _aa, _pp); + } + } else { + (x, y, z) = jacAdd(_x1, _y1, 1, _x2, _y2, 1, _pp); + } + // Get back to affine + return toAffine(x, y, z, _pp); + } + + /// @dev Substract two points (x1, y1) and (x2, y2) in affine coordinates. + /// @param _x1 coordinate x of P1 + /// @param _y1 coordinate y of P1 + /// @param _x2 coordinate x of P2 + /// @param _y2 coordinate y of P2 + /// @param _aa constant of the curve + /// @param _pp the modulus + /// @return (qx, qy) = P1-P2 in affine coordinates + function ecSub(uint256 _x1, uint256 _y1, uint256 _x2, uint256 _y2, uint256 _aa, uint256 _pp) + internal + pure + returns (uint256, uint256) + { + // invert square + (uint256 x, uint256 y) = ecInv(_x2, _y2, _pp); + // P1-square + return ecAdd(_x1, _y1, x, y, _aa, _pp); + } + + /// @dev Multiply point (x1, y1, z1) times d in affine coordinates. + /// @param _k scalar to multiply + /// @param _x coordinate x of P1 + /// @param _y coordinate y of P1 + /// @param _aa constant of the curve + /// @param _pp the modulus + /// @return (qx, qy) = d*P in affine coordinates + function ecMul(uint256 _k, uint256 _x, uint256 _y, uint256 _aa, uint256 _pp) + internal + pure + returns (uint256, uint256) + { + // Jacobian multiplication + (uint256 x1, uint256 y1, uint256 z1) = jacMul(_k, _x, _y, 1, _aa, _pp); + // Get back to affine + return toAffine(x1, y1, z1, _pp); + } + + /// @dev Adds two points (x1, y1, z1) and (x2 y2, z2). + /// @param _x1 coordinate x of P1 + /// @param _y1 coordinate y of P1 + /// @param _z1 coordinate z of P1 + /// @param _x2 coordinate x of square + /// @param _y2 coordinate y of square + /// @param _z2 coordinate z of square + /// @param _pp the modulus + /// @return (qx, qy, qz) P1+square in Jacobian + function jacAdd(uint256 _x1, uint256 _y1, uint256 _z1, uint256 _x2, uint256 _y2, uint256 _z2, uint256 _pp) + internal + pure + returns (uint256, uint256, uint256) + { + if (_x1 == 0 && _y1 == 0) return (_x2, _y2, _z2); + if (_x2 == 0 && _y2 == 0) return (_x1, _y1, _z1); + + // We follow the equations described in https://pdfs.semanticscholar.org/5c64/29952e08025a9649c2b0ba32518e9a7fb5c2.pdf Section 5 + uint256[4] memory zs; // z1^2, z1^3, z2^2, z2^3 + zs[0] = mulmod(_z1, _z1, _pp); + zs[1] = mulmod(_z1, zs[0], _pp); + zs[2] = mulmod(_z2, _z2, _pp); + zs[3] = mulmod(_z2, zs[2], _pp); + + // u1, s1, u2, s2 + zs = [mulmod(_x1, zs[2], _pp), mulmod(_y1, zs[3], _pp), mulmod(_x2, zs[0], _pp), mulmod(_y2, zs[1], _pp)]; + + // In case of zs[0] == zs[2] && zs[1] == zs[3], double function should be used + require(zs[0] != zs[2] || zs[1] != zs[3], "Use jacDouble function instead"); + + uint256[4] memory hr; + //h + hr[0] = addmod(zs[2], _pp - zs[0], _pp); + //r + hr[1] = addmod(zs[3], _pp - zs[1], _pp); + //h^2 + hr[2] = mulmod(hr[0], hr[0], _pp); + // h^3 + hr[3] = mulmod(hr[2], hr[0], _pp); + // qx = -h^3 -2u1h^2+r^2 + uint256 qx = addmod(mulmod(hr[1], hr[1], _pp), _pp - hr[3], _pp); + qx = addmod(qx, _pp - mulmod(2, mulmod(zs[0], hr[2], _pp), _pp), _pp); + // qy = -s1*z1*h^3+r(u1*h^2 -x^3) + uint256 qy = mulmod(hr[1], addmod(mulmod(zs[0], hr[2], _pp), _pp - qx, _pp), _pp); + qy = addmod(qy, _pp - mulmod(zs[1], hr[3], _pp), _pp); + // qz = h*z1*z2 + uint256 qz = mulmod(hr[0], mulmod(_z1, _z2, _pp), _pp); + return (qx, qy, qz); + } + + /// @dev Doubles a points (x, y, z). + /// @param _x coordinate x of P1 + /// @param _y coordinate y of P1 + /// @param _z coordinate z of P1 + /// @param _aa the a scalar in the curve equation + /// @param _pp the modulus + /// @return (qx, qy, qz) 2P in Jacobian + function jacDouble(uint256 _x, uint256 _y, uint256 _z, uint256 _aa, uint256 _pp) + internal + pure + returns (uint256, uint256, uint256) + { + if (_z == 0) return (_x, _y, _z); + + // We follow the equations described in https://pdfs.semanticscholar.org/5c64/29952e08025a9649c2b0ba32518e9a7fb5c2.pdf Section 5 + // Note: there is a bug in the paper regarding the m parameter, M=3*(x1^2)+a*(z1^4) + // x, y, z at this point represent the squares of _x, _y, _z + uint256 x = mulmod(_x, _x, _pp); //x1^2 + uint256 y = mulmod(_y, _y, _pp); //y1^2 + uint256 z = mulmod(_z, _z, _pp); //z1^2 + + // s + uint256 s = mulmod(4, mulmod(_x, y, _pp), _pp); + // m + uint256 m = addmod(mulmod(3, x, _pp), mulmod(_aa, mulmod(z, z, _pp), _pp), _pp); + + // x, y, z at this point will be reassigned and rather represent qx, qy, qz from the paper + // This allows to reduce the gas cost and stack footprint of the algorithm + // qx + x = addmod(mulmod(m, m, _pp), _pp - addmod(s, s, _pp), _pp); + // qy = -8*y1^4 + M(S-T) + y = addmod(mulmod(m, addmod(s, _pp - x, _pp), _pp), _pp - mulmod(8, mulmod(y, y, _pp), _pp), _pp); + // qz = 2*y1*z1 + z = mulmod(2, mulmod(_y, _z, _pp), _pp); + + return (x, y, z); + } + + /// @dev Multiply point (x, y, z) times d. + /// @param _d scalar to multiply + /// @param _x coordinate x of P1 + /// @param _y coordinate y of P1 + /// @param _z coordinate z of P1 + /// @param _aa constant of curve + /// @param _pp the modulus + /// @return (qx, qy, qz) d*P1 in Jacobian + function jacMul(uint256 _d, uint256 _x, uint256 _y, uint256 _z, uint256 _aa, uint256 _pp) + internal + pure + returns (uint256, uint256, uint256) + { + // Early return in case that `_d == 0` + if (_d == 0) { + return (_x, _y, _z); + } + + uint256 remaining = _d; + uint256 qx = 0; + uint256 qy = 0; + uint256 qz = 1; + + // Double and add algorithm + while (remaining != 0) { + if ((remaining & 1) != 0) { + (qx, qy, qz) = jacAdd(qx, qy, qz, _x, _y, _z, _pp); + } + remaining = remaining / 2; + (_x, _y, _z) = jacDouble(_x, _y, _z, _aa, _pp); + } + return (qx, qy, qz); + } +} diff --git a/src/libraries/LibSPV.sol b/src/libraries/LibSPV.sol new file mode 100644 index 0000000..a0a0264 --- /dev/null +++ b/src/libraries/LibSPV.sol @@ -0,0 +1,127 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; +import {LibBitcoin, BlockHeader} from "./LibBitcoin.sol"; + +library LibSPV { + using Math for uint256; + using LibBitcoin for bytes; + + uint256 internal constant DIFFICULTY_EPOCH_PERIOD = 2 * 7 * 24 * 60 * 60; // 2 weeks in seconds + uint256 internal constant DIFFICULTY_EPOCH_PERIOD_DIV_4 = + DIFFICULTY_EPOCH_PERIOD / 4; // DIFFICULTY_EPOCH_PERIOD divided by 4 + uint256 internal constant DIFFICULTY_EPOCH_PERIOD_MUL_4 = + DIFFICULTY_EPOCH_PERIOD * 4; // DIFFICULTY_EPOCH_PERIOD multiplied by 4 + uint256 internal constant DIFFICULTY_EPOCH_PERIOD_BLOCKS = 2016; // 2 weeks in blocks + + function calculateBlockHash( + BlockHeader memory header + ) internal pure returns (bytes32) { + bytes memory headerData = abi.encodePacked( + header.version, + header.previousBlockHash, + header.merkleRootHash, + header.timestamp, + header.nBits, + header.nonce + ); + + // Perform double SHA-256 hashing + return (headerData).doubleHash(); + } + + function verifyProof( + BlockHeader memory header, + bytes32 txHash, + uint256 txIndex, + bytes32[] memory proof + ) internal pure returns (bool) { + bytes32 result = abi + .encodePacked(txHash) + .convertToBigEndian() + .convertToBytes32(); + + for (uint256 i = 0; i < proof.length; i++) { + if (txIndex % 2 == 1) { + result = concatHash(proof[i], result); + } else { + result = concatHash(result, proof[i]); + } + txIndex /= 2; + } + + return header.merkleRootHash == result; + } + + // for modularity we expect the caller to handle the case in testnet4 if the difficulty is 1 + function verifyWork( + BlockHeader calldata header + ) internal pure returns (bool) { + return + ( + (abi.encodePacked(calculateBlockHash(header))) + .convertToBigEndian() + ).bytesToUint256() < + (abi.encodePacked(header.nBits)).convertnBitsToTarget(); + } + + function verifyTarget( + BlockHeader calldata header, + uint256 target + ) internal pure returns (bool) { + return + (abi.encodePacked(header.nBits)).convertnBitsToTarget() == target; + } + + function verifyDifficultyEpochTarget( + uint256 newTarget, + uint256 target + ) internal pure returns (bool) { + if (newTarget >= target) { + return (newTarget - target) * 100 <= target; + } else { + return (target - newTarget) * 100 <= target; + } + } + + function calculateNewTarget( + BlockHeader calldata header, + uint256 LDEtarget, + bytes4 LDETimestamp + ) internal pure returns (uint256 target) { + uint256 _elapsedTime; + (, _elapsedTime) = ( + abi + .encodePacked(header.timestamp) + .convertToBigEndian() + .bytesToUint256() + ).trySub( + abi + .encodePacked(LDETimestamp) + .convertToBigEndian() + .bytesToUint256() + ); + + if (_elapsedTime < DIFFICULTY_EPOCH_PERIOD_DIV_4) { + _elapsedTime = DIFFICULTY_EPOCH_PERIOD_DIV_4; + } + if (_elapsedTime > DIFFICULTY_EPOCH_PERIOD_MUL_4) { + _elapsedTime = DIFFICULTY_EPOCH_PERIOD_MUL_4; + } + + uint256 _adjusted; + (, _adjusted) = LDEtarget.tryDiv(65536); + (, _adjusted) = _adjusted.tryMul(_elapsedTime); + (, _adjusted) = _adjusted.tryDiv(DIFFICULTY_EPOCH_PERIOD); + (, _adjusted) = _adjusted.tryMul(65536); + return _adjusted; + } + + function concatHash( + bytes32 left, + bytes32 right + ) internal pure returns (bytes32) { + return abi.encodePacked(left, right).doubleHash(); + } +} diff --git a/src/libraries/LibTaproot.sol b/src/libraries/LibTaproot.sol new file mode 100644 index 0000000..7c2dd13 --- /dev/null +++ b/src/libraries/LibTaproot.sol @@ -0,0 +1,157 @@ +// SPDX-License-Identifier: GPL-3.0 + +pragma solidity ^0.8.5; + +import {LibEllipticCurve} from "./LibEllipticCurve.sol"; +import {LibBitcoin} from "./LibBitcoin.sol"; + +library LibTaproot { + uint256 public constant GX = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798; + uint256 public constant GY = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8; + uint256 public constant AA = 0; + uint256 public constant BB = 7; + uint256 public constant PP = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F; + uint256 public constant OO = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141; + + bytes32 public constant TAP_LEAF_HASH = 0xaeea8fdc4208983105734b58081d1e2638d35f1cb54008d4d357ca03be78e9ee; + bytes32 public constant TAP_BRANCH_HASH = 0x1941a1f2e56eb95fa2a9f194be5c01f7216f33ed82b091463490d05bf516a015; + bytes32 public constant TAP_TWEAK_HASH = 0xe80fe1639c9ca050e3af1b39c143c63e429cbceb15d940fbb5c5a1f4af57c5e9; + + uint256 public constant TAPROOT_NUMS_X = + 36444060476547731421425013472121489344383018981262552973668657287772036414144; + uint256 public constant TAPROOT_NUMS_Y = + 22537504475708154238330251540244790414456712057027634449505794721772594235652; + + bytes1 public constant LEAF_VERSION = 0xC0; + bytes32 public constant BIP340_CHALLENGE_HASH = + 0x7BB52D7A9FEF58323EB1BF7A407DB382D2F3F2D81BB1224F49FE518F6D48D37C; + + function pubkeyToAddress( + bytes memory pubkey + ) internal pure returns (address) { + bytes32 hash = keccak256(pubkey); + return address(uint160(uint256(hash))); + } + + function verifySchnorr( + uint8 parity, + uint256 PX, + bytes32[] memory signature, + bytes memory message + ) external pure returns (bool) { + require(parity < 2, "Parity should be 0 or 1"); + require( + signature.length == 2, + "Signature should be an array of length 2, [R, s]" + ); + + uint256 RX = uint256(signature[0]); + uint256 s = uint256(signature[1]); + + uint256 RY = LibEllipticCurve.deriveY(0x02, RX, AA, BB, PP); + + bytes32 messageChallenge = sha256( + bytes.concat( + BIP340_CHALLENGE_HASH, + BIP340_CHALLENGE_HASH, + bytes32(RX), + bytes32(PX), + message + ) + ); + + bytes32 sP_x = bytes32(OO - mulmod(s, PX, OO)); + bytes32 eP_x = bytes32(OO - mulmod(uint256(messageChallenge), PX, OO)); + + address computedAddress = ecrecover( + sP_x, + parity + 27, + bytes32(PX), + eP_x + ); + + require(computedAddress != address(0), "Invalid signature"); + + return pubkeyToAddress(abi.encodePacked(RX, RY)) == computedAddress; + } + + function tweak(uint256 PX, uint256 PY, uint256 tweakValue) internal pure returns (uint256, uint256) { + (uint256 TX, uint256 TY) = LibEllipticCurve.ecMul(tweakValue, GX, GY, AA, PP); + (uint256 QX, uint256 QY) = LibEllipticCurve.ecAdd(PX, PY, TX, TY, AA, PP); + + return (QX, QY); + } + + function taggedHashLeaf(bytes memory data) internal pure returns (bytes32) { + return precomputedTaggedHash(TAP_LEAF_HASH, data); + } + + function taggedHashBranch(bytes memory data) internal pure returns (bytes32) { + return precomputedTaggedHash(TAP_BRANCH_HASH, data); + } + + function taggedHashTweak(bytes memory data) internal pure returns (bytes32) { + return precomputedTaggedHash(TAP_TWEAK_HASH, data); + } + + function precomputedTaggedHash(bytes32 tagHash, bytes memory data) internal pure returns (bytes32) { + return sha256(bytes.concat(tagHash, tagHash, data)); + } + + function taggedHash(bytes memory tag, bytes memory data) internal pure returns (bytes32) { + bytes32 tagHash = sha256(tag); + + return precomputedTaggedHash(tagHash, data); + } + + function serializeScript(bytes calldata script) internal pure returns (bytes memory) { + require(script.length < 0xffffffff, "Taproot: Script too long"); + return bytes.concat(LEAF_VERSION, LibBitcoin.encodeVarint(uint64(script.length)), script); + } + + function computeMastRootFromMerkleProof(bytes calldata script, bytes32[] calldata merkleProof) + public + pure + returns (bytes32) + { + bytes32 hash = taggedHashLeaf(serializeScript(script)); + for (uint256 i = 0; i < merkleProof.length; i++) { + bytes memory data; + if (hash < merkleProof[i]) { + data = bytes.concat(hash, merkleProof[i]); + } else { + data = bytes.concat(merkleProof[i], hash); + } + hash = taggedHashBranch(data); + } + + return hash; + } + + // function verifyTaprootScriptPubKeyWithNumsTweak(bytes32 spk, bytes calldata script, bytes32[] calldata merkleProof, uint256 tweakValue) public pure returns (bool) { + // (uint tGX, uint tGY) = LibEllipticCurve.ecMul(tweakValue, GX, GY, AA, PP); + + // return verifyTaprootScriptPubKey(spk, script, merkleProof, tGX, tGY); + // } + + // function verifyTaprootScriptPubKeyWithNums(bytes32 spk, bytes calldata script, bytes32[] calldata merkleProof) public pure returns (bool) { + // return verifyTaprootScriptPubKey(spk, script, merkleProof, TAPROOT_NUMS_X); + // } + + function verifyTaprootScriptPubKey(bytes32 spk, bytes calldata script, bytes32[] calldata merkleProof, uint256 PX) + public + pure + returns (bool) + { + bytes32 mastRoot = computeMastRootFromMerkleProof(script, merkleProof); + uint256 tweakValue = uint256(taggedHashTweak(bytes.concat(abi.encodePacked(PX), mastRoot))); + + require(tweakValue < OO, "Taproot: tweak should be within the curve order"); + + uint256 PY = LibEllipticCurve.deriveY(0x02, PX, AA, BB, PP); + (uint256 QX,) = tweak(PX, PY, tweakValue); + + //check for parity as well + return uint256(spk) == QX; + } +} diff --git a/src/libraries/SPVLib.sol b/src/libraries/SPVLib.sol deleted file mode 100644 index 5804e56..0000000 --- a/src/libraries/SPVLib.sol +++ /dev/null @@ -1,95 +0,0 @@ -// SPDX-License-Identifier: UNLICENSED -pragma solidity 0.8.20; - -import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; -import {Utils} from "../Utils.sol"; -import {BlockHeader} from "../Types.sol"; - -library SPVLib { - using Math for uint256; - using Utils for bytes; - - uint256 internal constant DIFFICULTY_EPOCH_PERIOD = 2 * 7 * 24 * 60 * 60; // 2 weeks in seconds - uint256 internal constant DIFFICULTY_EPOCH_PERIOD_DIV_4 = DIFFICULTY_EPOCH_PERIOD / 4; // DIFFICULTY_EPOCH_PERIOD divided by 4 - uint256 internal constant DIFFICULTY_EPOCH_PERIOD_MUL_4 = DIFFICULTY_EPOCH_PERIOD * 4; // DIFFICULTY_EPOCH_PERIOD multiplied by 4 - uint256 internal constant DIFFICULTY_EPOCH_PERIOD_BLOCKS = 2016; // 2 weeks in blocks - - function calculateBlockHash(BlockHeader memory header) internal pure returns (bytes32) { - bytes memory headerData = abi.encodePacked( - header.version, - header.previousBlockHash, - header.merkleRootHash, - header.timestamp, - header.nBits, - header.nonce - ); - - // Perform double SHA-256 hashing - return (headerData).doubleHash(); - } - - function verifyProof(BlockHeader memory header, bytes32 txHash, uint256 txIndex, bytes32[] memory proof) - internal - pure - returns (bool) - { - bytes32 result = abi.encodePacked(txHash).convertToBigEndian().convertToBytes32(); - - for (uint256 i = 0; i < proof.length; i++) { - if (txIndex % 2 == 1) { - result = concatHash(proof[i], result); - } else { - result = concatHash(result, proof[i]); - } - txIndex /= 2; - } - - return header.merkleRootHash == result; - } - - function verifyWork(BlockHeader calldata header) internal pure returns (bool) { - return ((abi.encodePacked(calculateBlockHash(header))).convertToBigEndian()).convertBytesToUint() - < (abi.encodePacked(header.nBits)).convertnBitsToTarget(); - } - - function verifyTarget(BlockHeader calldata header, uint256 target) internal pure returns (bool) { - return (abi.encodePacked(header.nBits)).convertnBitsToTarget() == target; - } - - function verifyDifficultyEpochTarget(uint256 newTarget, uint256 target) internal pure returns (bool) { - if (newTarget >= target) { - return (newTarget - target) * 100 <= target; - } else { - return (target - newTarget) * 100 <= target; - } - } - - function calculateNewTarget(BlockHeader calldata header, uint256 LDEtarget, bytes4 LDETimestamp) - internal - pure - returns (uint256 target) - { - uint256 _elapsedTime; - (, _elapsedTime) = (abi.encodePacked(header.timestamp).convertToBigEndian().convertBytesToUint()).trySub( - abi.encodePacked(LDETimestamp).convertToBigEndian().convertBytesToUint() - ); - - if (_elapsedTime < DIFFICULTY_EPOCH_PERIOD_DIV_4) { - _elapsedTime = DIFFICULTY_EPOCH_PERIOD_DIV_4; - } - if (_elapsedTime > DIFFICULTY_EPOCH_PERIOD_MUL_4) { - _elapsedTime = DIFFICULTY_EPOCH_PERIOD_MUL_4; - } - - uint256 _adjusted; - (, _adjusted) = LDEtarget.tryDiv(65536); - (, _adjusted) = _adjusted.tryMul(_elapsedTime); - (, _adjusted) = _adjusted.tryDiv(DIFFICULTY_EPOCH_PERIOD); - (, _adjusted) = _adjusted.tryMul(65536); - return _adjusted; - } - - function concatHash(bytes32 left, bytes32 right) internal pure returns (bytes32) { - return abi.encodePacked(left, right).doubleHash(); - } -} diff --git a/test/Utils.t.sol b/test/LibBitcoin.t.sol similarity index 51% rename from test/Utils.t.sol rename to test/LibBitcoin.t.sol index 222de9c..320c53a 100644 --- a/test/Utils.t.sol +++ b/test/LibBitcoin.t.sol @@ -1,18 +1,31 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + import {Test} from "forge-std/Test.sol"; -import {BlockHeader} from "src/Types.sol"; -import {Utils} from "src/Utils.sol"; +import {BlockHeader, LibBitcoin} from "src/libraries/LibBitcoin.sol"; + +struct DecodeVarintFixture { + bytes input; + uint8 byteLength; + bytes expected; +} + +struct EncodeVarintFixture { + uint64 input; + bytes output; +} contract UtilsIndirection is Test { - function _parseBlockHeader (bytes calldata blockHeader) public pure returns (BlockHeader memory parsedHeader) { - return Utils.parseBlockHeader(blockHeader); + function _parseBlockHeader(bytes calldata blockHeader) public pure returns (BlockHeader memory parsedHeader) { + return LibBitcoin.parseBlockHeader(blockHeader); } - function parseBlockHeader (bytes memory blockHeader) public view returns (BlockHeader memory parsedHeader) { + function parseBlockHeader(bytes memory blockHeader) public view returns (BlockHeader memory parsedHeader) { return this._parseBlockHeader(blockHeader); } } -contract UtilsTest is Test { +contract UtilsTest is Test { uint256 MAX_TARGET = (0xffff) * (1 << 208); UtilsIndirection utilsIndirection; @@ -25,31 +38,31 @@ contract UtilsTest is Test { return bytes.concat(b[0], b[1], b[2], b[3]); } - function testShouldConvertBytesToUint() public pure { - bytes memory b = hex"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"; + // function testShouldConvertBytesToUint() public pure { + // bytes memory b = hex"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"; - uint256 number = Utils.convertBytesToUint(b); - assertEq(number, UINT256_MAX, "Number does not match"); - } + // uint256 number = LibBitcoin.convertBytesToUint(b); + // assertEq(number, UINT256_MAX, "Number does not match"); + // } - function testShouldNotConvertBytesToUintIfByteLengthGreaterThan32() public { - bytes memory b = hex"000000000000000000000000000000000000000000000000000000000000000100"; + // function testShouldNotConvertBytesToUintIfByteLengthGreaterThan32() public { + // bytes memory b = hex"000000000000000000000000000000000000000000000000000000000000000100"; - vm.expectRevert("SPVLib: length cannot be greater than 32 bytes"); - Utils.convertBytesToUint(b); - } + // vm.expectRevert("SPVLib: length cannot be greater than 32 bytes"); + // LibBitcoin.convertBytesToUint(b); + // } function testShouldConvertToBigEndian() public pure { bytes memory b = hex"ffab"; - bytes memory bBE = Utils.convertToBigEndian(b); + bytes memory bBE = LibBitcoin.convertToBigEndian(b); assertEq(bBE, hex"abff", "Big endian bytes do not match"); } function testShouldComputeDoubleHash() public pure { bytes memory b = hex"0000000000000000000000000000000000000000000000000000000000000000"; - bytes32 bHash = Utils.doubleHash(b); + bytes32 bHash = LibBitcoin.doubleHash(b); assertEq(bHash, hex"2b32db6c2c0a6235fb1397e8225ea85e0f0e6e8c7b126d0016ccbde0e667151e", "Hash does not match"); } @@ -57,7 +70,7 @@ contract UtilsTest is Test { function testShouldConvertToBytes32() public pure { bytes memory b = hex"000000000000000000000000000000000000000000000000000000000000000012121231"; - bytes32 b32 = Utils.convertToBytes32(b); + bytes32 b32 = LibBitcoin.convertToBytes32(b); assertEq(b32, hex"0000000000000000000000000000000000000000000000000000000000000000", "Bytes32 does not match"); } @@ -97,10 +110,46 @@ contract UtilsTest is Test { merkleRootHash: 0x1977fa84d0689f38821e19016cb32b3ca6ab93ec885dcda968b5f2998a76b7f3 }); - uint256 target = Utils.convertnBitsToTarget(bytes4ToBytes(header.nBits)); + uint256 target = LibBitcoin.convertnBitsToTarget(bytes4ToBytes(header.nBits)); uint256 difficulty = MAX_TARGET / target; assertEq(90666502495565, difficulty, "Difficulty does not match"); } -} \ No newline at end of file + + function testDecodeVaruintShouldComputeProperly() public pure { + DecodeVarintFixture[] memory fixtures = new DecodeVarintFixture[](4); + + fixtures[0] = DecodeVarintFixture({input: hex"fc", byteLength: 1, expected: hex"fc"}); + + fixtures[1] = DecodeVarintFixture({input: hex"fdfd00", byteLength: 3, expected: hex"00fd"}); + + fixtures[2] = DecodeVarintFixture({input: hex"fe00000100", byteLength: 5, expected: hex"00010000"}); + + fixtures[3] = + DecodeVarintFixture({input: hex"ff0000000001000000", byteLength: 9, expected: hex"0000000100000000"}); + + for (uint256 i = 0; i < 4; i++) { + (uint8 byteLength, bytes memory expected) = LibBitcoin.decodeVarint(fixtures[i].input, 0); + assertEq(fixtures[i].byteLength, byteLength, "Byte length does not match"); + assertEq(fixtures[i].expected, expected, "Expected bytes do not match"); + } + } + + function testEncodeVarintShouldComputeProperly() public pure { + EncodeVarintFixture[] memory fixtures = new EncodeVarintFixture[](4); + + fixtures[0] = EncodeVarintFixture({input: 0xfc, output: hex"fc"}); + + fixtures[1] = EncodeVarintFixture({input: 0x00fd, output: hex"fdfd00"}); + + fixtures[2] = EncodeVarintFixture({input: 0x00010000, output: hex"fe00000100"}); + + fixtures[3] = EncodeVarintFixture({input: 0x0000000100000000, output: hex"ff0000000001000000"}); + + for (uint256 i = 0; i < 4; i++) { + bytes memory expected = LibBitcoin.encodeVarint(fixtures[i].input); + assertEq(fixtures[i].output, expected, "Expected bytes do not match"); + } + } +} diff --git a/test/SPVLib.t.sol b/test/LibSPV.t.sol similarity index 75% rename from test/SPVLib.t.sol rename to test/LibSPV.t.sol index d4c3137..9fccbac 100644 --- a/test/SPVLib.t.sol +++ b/test/LibSPV.t.sol @@ -1,11 +1,9 @@ -// SPDX-License-Identifier: UNLICENSED +// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; -import {SPVLib} from "src/libraries/SPVLib.sol"; -import {Utils} from "src/Utils.sol"; -import {BlockHeader} from "src/Types.sol"; +import {LibSPV} from "src/libraries/LibSPV.sol"; +import {BlockHeader, LibBitcoin} from "src/libraries/LibBitcoin.sol"; import {Test} from "forge-std/Test.sol"; -import {console} from "forge-std/console.sol"; import "forge-std/StdJson.sol"; import "@openzeppelin/contracts/utils/Strings.sol"; @@ -15,48 +13,38 @@ struct VerifyTx { bytes32 txHash; } -contract SPVLibHarness is Test { - using SPVLib for BlockHeader; - - function _calculateNewTarget(BlockHeader calldata header, uint256 LDEtarget, bytes4 LDETimestamp) public pure returns (uint256) { - return header.calculateNewTarget(LDEtarget, LDETimestamp); - } -} - contract SPVLibIndirection is Test { - SPVLibHarness spvLibHarness = new SPVLibHarness(); - function _verifyWork(BlockHeader calldata header) public pure returns (bool) { - return SPVLib.verifyWork(header); + return LibSPV.verifyWork(header); } function verifyWork(BlockHeader memory header) public view returns (bool) { return this._verifyWork(header); } - function _calculateNewTarget(BlockHeader calldata header, uint256 LDEtarget, bytes4 LDETimestamp) public view returns (uint256) { - return spvLibHarness._calculateNewTarget(header, LDEtarget, LDETimestamp); + function _calculateNewTarget(BlockHeader calldata header, uint256 LDEtarget, bytes4 LDETimestamp) + public + pure + returns (uint256) + { + return LibSPV.calculateNewTarget(header, LDEtarget, LDETimestamp); } - function calculateNewTarget(BlockHeader memory header, uint256 LDEtarget, bytes4 LDETimestamp) public view returns (uint256) { + function calculateNewTarget(BlockHeader memory header, uint256 LDEtarget, bytes4 LDETimestamp) + public + view + returns (uint256) + { return this._calculateNewTarget(header, LDEtarget, LDETimestamp); } } -// contract SPVLibHarness is SPVLib { -// convertnBitsToTarget -// } - contract SPVLibTestTest is Test { using stdJson for string; - // SPVLib spvLib; - // UtilsIndirection utilsIndirection; SPVLibIndirection spvLibIndirection; function setUp() public { - // spvLib = new SPVLib(); - // utilsIndirection = new UtilsIndirection(); spvLibIndirection = new SPVLibIndirection(); } @@ -75,7 +63,7 @@ contract SPVLibTestTest is Test { merkleRootHash: 0x78ce8a1195d00b58c530046ec369868aa4cc856bf139ef2636192ced886ed412 }); - bytes32 blockHash = SPVLib.calculateBlockHash(header); + bytes32 blockHash = LibSPV.calculateBlockHash(header); assertEq( 0xaea988eb825ea493f3ae97679b674311f50922adcbd201000000000000000000, blockHash, "Block hash does not match" @@ -101,7 +89,7 @@ contract SPVLibTestTest is Test { for (uint256 i = 0; i < txs.length; i++) { assertEq( - SPVLib.verifyProof(header, txs[i].txHash, txs[i].pos, txs[i].merkle), + LibSPV.verifyProof(header, txs[i].txHash, txs[i].pos, txs[i].merkle), true, string.concat("Failed to verify proof for tx", Strings.toString(i)) ); @@ -122,7 +110,6 @@ contract SPVLibTestTest is Test { assertEq(spvLibIndirection.verifyWork(header), true, "Work verification failed"); } - //https://mempool.space/api/block/00000000000000000001d2cbad2209f51143679b6797aef393a45e82eb88a9ae //https://mempool.space/api/block/000000000000000000026b90d09b5e4fba615eadfc4ce2a19f6a68c9c18d4a2e function testCalculateNewTarget() public view { @@ -135,7 +122,7 @@ contract SPVLibTestTest is Test { merkleRootHash: 0x78ce8a1195d00b58c530046ec369868aa4cc856bf139ef2636192ced886ed412 }); - uint256 oldTarget = Utils.convertnBitsToTarget(bytes4ToBytes(oldHeader.nBits)); + uint256 oldTarget = LibBitcoin.convertnBitsToTarget(bytes4ToBytes(oldHeader.nBits)); BlockHeader memory newHeader = BlockHeader({ version: 0x00e0ff27, @@ -147,8 +134,10 @@ contract SPVLibTestTest is Test { }); uint256 actualNewTarget = spvLibIndirection.calculateNewTarget(newHeader, oldTarget, oldHeader.timestamp); - uint256 expectedNewTarget = Utils.convertnBitsToTarget(bytes4ToBytes(newHeader.nBits)); + uint256 expectedNewTarget = LibBitcoin.convertnBitsToTarget(bytes4ToBytes(newHeader.nBits)); - assertEq(SPVLib.verifyDifficultyEpochTarget(expectedNewTarget, actualNewTarget), true, "New target does not match"); + assertEq( + LibSPV.verifyDifficultyEpochTarget(expectedNewTarget, actualNewTarget), true, "New target does not match" + ); } } diff --git a/test/LibTaproot.t.sol b/test/LibTaproot.t.sol new file mode 100644 index 0000000..8e550ad --- /dev/null +++ b/test/LibTaproot.t.sol @@ -0,0 +1,212 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import {Test} from "forge-std/Test.sol"; +import {LibTaproot} from "src/libraries/LibTaproot.sol"; + +contract TaprootIndirection is Test { + uint256 public constant GX = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798; + uint256 public constant GY = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8; + + function _serializeScript(bytes calldata script) public pure returns (bytes memory) { + return LibTaproot.serializeScript(script); + } + + function serializeScript(bytes memory script) public view returns (bytes memory) { + return this._serializeScript(script); + } + + function _computeMastRootFromMerkleProof(bytes calldata script, bytes32[] calldata merkleProof) + public + pure + returns (bytes32) + { + return LibTaproot.computeMastRootFromMerkleProof(script, merkleProof); + } + + function computeMastRootFromMerkleProof(bytes memory script, bytes32[] memory merkleProof) + public + view + returns (bytes32) + { + return this._computeMastRootFromMerkleProof(script, merkleProof); + } + + function _verifyTaprootScriptPubKey(bytes32 spk, bytes calldata script, bytes32[] calldata merkleProof, uint256 PX) + public + pure + returns (bool) + { + return LibTaproot.verifyTaprootScriptPubKey(spk, script, merkleProof, PX); + } + + function verifyTaprootScriptPubKey(bytes32 spk, bytes memory script, bytes32[] memory merkleProof, uint256 PX) + public + view + returns (bool) + { + return this._verifyTaprootScriptPubKey(spk, script, merkleProof, PX); + } +} + +contract TaprootTest is Test { + TaprootIndirection taprootIndirection = new TaprootIndirection(); + + function testTaggedHashLeaf() public pure { + bytes memory data = abi.encodePacked("catalog"); + bytes32 hash = LibTaproot.taggedHashLeaf(data); + + assertEq( + hash, 0x45e902fa5b1984a5edb13825d5a941d8f16d48639bd58c736907a0a626afcb56, "TapLeaf hashes do not match" + ); + } + + function testTaggedHashBranch() public pure { + bytes memory data = abi.encodePacked("catalog"); + bytes32 hash = LibTaproot.taggedHashBranch(data); + + assertEq( + hash, 0xf5363e304245ba2654bbc21407264c4a475866277cdffbee745903c3f3d2b72a, "TapBranch hashes do not match" + ); + } + + function testTaggedHashTweak() public pure { + bytes memory data = abi.encodePacked("catalog"); + bytes32 hash = LibTaproot.taggedHashTweak(data); + + assertEq( + hash, 0x778572bda6aaed8577a1c62d9c48f5447c74132a6670ed83f112522632542954, "TapTweak hashes do not match" + ); + } + + function testPrecomputedTaggedHash() public pure { + bytes memory data = abi.encodePacked("catalog"); + bytes32 tagHash = sha256(data); + + bytes32 hash = LibTaproot.precomputedTaggedHash(tagHash, data); + + assertEq( + hash, + 0x782fabae45031960c095b43470f3bc3c6b4ee37dc22680838ebcff5c4a1b7bf5, + "precomputedTaggedHashes do not match" + ); + } + + function testTaggedHash() public pure { + bytes memory data = abi.encodePacked("catalog"); + bytes32 hash = LibTaproot.taggedHash(data, data); + assertEq(hash, 0x782fabae45031960c095b43470f3bc3c6b4ee37dc22680838ebcff5c4a1b7bf5, "taggedHashes do not match"); + } + + function testSerializeScript() public view { + bytes memory script = + hex"20f1835aa33781318112236f890ee427a9cea0c03b4e215900fd774c45dbc37111ac0063036f726401010a746578742f706c61696e00357b2270223a226272632d3230222c226f70223a226d696e74222c227469636b223a22646f6765222c22616d74223a2234323030227d68"; + + bytes memory serialized = taprootIndirection.serializeScript(script); + + assertEq( + serialized, + hex"c06d20f1835aa33781318112236f890ee427a9cea0c03b4e215900fd774c45dbc37111ac0063036f726401010a746578742f706c61696e00357b2270223a226272632d3230222c226f70223a226d696e74222c227469636b223a22646f6765222c22616d74223a2234323030227d68", + "serialized scripts do not match" + ); + } + + function testComputeMastRootFromMerkleProof() public view { + bytes memory script = hex"42"; + bytes32[] memory proof = new bytes32[](8); + + proof[0] = 0x3b6cd258390f82268b0f07266ac76ef888d94366b2d51161a9c76bc23525e9f3; + proof[1] = 0xab11f8cd97774853013f574bef5b8aa881d927273bd32af4f180f13008b21ff6; + proof[2] = 0x24cc9f09e387f8e256bd1f82c6b9fd12c19c1ca738dae49f409c4ebe46b0d76d; + proof[3] = 0xf3bc62b6bc8a4eb61d284dbae48f5ca6d6c59100b4d0504a0655a4d73d3b4b45; + proof[4] = 0xc350786781aec83736c548e62ac04427a1747036cb212292bc4011aecb275e63; + proof[5] = 0x10a8d82f2198b631baeb29e0674d716f1ef67c38cb0ee53b3da433df32652107; + proof[6] = 0x863cf7b41e01a9862674a679599abf9df0233f00d054a519bc8003690d3dd20b; + proof[7] = 0x4f288deeda1c2ab848a4a31cbeed7e102d711d6772a954fcd7506d9d388e5307; + + bytes32 root = taprootIndirection.computeMastRootFromMerkleProof(script, proof); + + assertEq( + root, 0x2d05475b9f86146bb6337d21cd1939215700a98f3e03daa0f40e9c390acf5272, "computed mast roots do not match" + ); + } + + function testShouldComputZeroSizeMerkleRoot() public view { + bytes memory script = + hex"205b1557b09c60a335f71e13269244abf7a5e08970d5adb5e1827864f449943c4bac0063036f7264010118746578742f706c61696e3b636861727365743d7574662d3800367b2270223a226272632d3230222c226f70223a226d696e74222c227469636b223a2261616161222c22616d74223a223130303030227d68"; + bytes32[] memory proof = new bytes32[](0); + + bytes32 root = taprootIndirection.computeMastRootFromMerkleProof(script, proof); + + assertEq( + root, 0x17b29f6c2cdc296723af89a0a4387daa7475b1e38b1518a1313c76bc10468526, "computed mast roots do not match" + ); + } + + function testShouldVerifyTaprootSpk() public view { + bytes memory script = + hex"205b1557b09c60a335f71e13269244abf7a5e08970d5adb5e1827864f449943c4bac0063036f7264010118746578742f706c61696e3b636861727365743d7574662d3800367b2270223a226272632d3230222c226f70223a226d696e74222c227469636b223a2261616161222c22616d74223a223130303030227d68"; + bytes32[] memory proof = new bytes32[](0); + bytes32 spk = 0x9c79fc28c5b3e354b584e39e57f9386c9137c1d58ef1644f0fbbd6724046f958; + uint256 PX = 0x5b1557b09c60a335f71e13269244abf7a5e08970d5adb5e1827864f449943c4b; + + bool isValidTaprootKey = taprootIndirection.verifyTaprootScriptPubKey(spk, script, proof, PX); + + assertEq(isValidTaprootKey, true, "should verify taproot script pub key"); + } + + + function pubkeyToAddress(bytes memory pubkey) internal pure returns (address) { + bytes32 hash = keccak256(pubkey); + return address(uint160(uint256(hash))); + } + + function testShouldVerifySchnorrSignature() public pure { + uint256 PX = 0x21ef19b8f9258d0b012d16112b2f4741d37f0da7c14a048b7c4209439b40c1ad; + bytes memory messageHash = hex"b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"; + + bytes32[] memory signature = new bytes32[](2); + signature[0] = 0x83df236a5434e4d710f70813f06c2e09730015323f7dbd9e27e111e4fc2a254e; + signature[1] = 0x78fc4e9e5b9d0f0c72c832fd2c5083b2d8a5121f57637774383e43453bbebc75; + + bool verified = LibTaproot.verifySchnorr(0, PX, signature, messageHash); + + assertEq(verified, true, "Schnorr signature verification failed"); + } + + function testShouldNotVerifyInvalidParities() public { + uint256 PX = 1; + bytes memory message = hex"00"; + + bytes32[] memory signature = new bytes32[](2); + signature[0] = 0x00; + signature[1] = 0x00; + + vm.expectRevert("Parity should be 0 or 1"); + LibTaproot.verifySchnorr(3, PX, signature, message); + } + + function testShouldNotVerifySignatureWithWrongParity() public pure { + uint256 PX = 0x21ef19b8f9258d0b012d16112b2f4741d37f0da7c14a048b7c4209439b40c1ad; + bytes memory messageHash = hex"b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"; + + bytes32[] memory signature = new bytes32[](2); + signature[0] = 0x83df236a5434e4d710f70813f06c2e09730015323f7dbd9e27e111e4fc2a254e; + signature[1] = 0x78fc4e9e5b9d0f0c72c832fd2c5083b2d8a5121f57637774383e43453bbebc75; + + bool verified = LibTaproot.verifySchnorr(1, PX, signature, messageHash); + + assertEq(verified, false, "Schnorr signature verification failed"); + } + + function testShouldNotAccessWrongSignatureLength() public { + uint256 PX = 0x21ef19b8f9258d0b012d16112b2f4741d37f0da7c14a048b7c4209439b40c1ad; + bytes memory messageHash = hex"b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"; + + bytes32[] memory signature = new bytes32[](1); + signature[0] = 0x83df236a5434e4d710f70813f06c2e09730015323f7dbd9e27e111e4fc2a254e; + + vm.expectRevert(); + LibTaproot.verifySchnorr(1, PX, signature, messageHash); + } +} diff --git a/test/VerifySPV.mainnet.t.sol b/test/VerifySPV.mainnet.t.sol new file mode 100644 index 0000000..c075b92 --- /dev/null +++ b/test/VerifySPV.mainnet.t.sol @@ -0,0 +1,417 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; +import {LibBitcoin, BlockHeader} from "src/libraries/LibBitcoin.sol"; +import {LibSPV} from "src/libraries/LibSPV.sol"; +import {VerifySPV} from "src/VerifySPV.sol"; +import {Test} from "forge-std/Test.sol"; + +import "forge-std/StdJson.sol"; + +struct FixtureBlockHeader { + bytes32 merkleRootHash; + bytes nBits; + bytes nonce; + bytes32 previousBlockHash; + bytes timestamp; + bytes version; +} + +contract VerifySPVTest is Test { + using stdJson for string; + using Math for uint256; + using LibSPV for BlockHeader; + + BlockHeader[] difficultyEpoch; + VerifySPV verifySPV; + + event BlockRegistered(bytes32 blockHash); + + function setUp() public { + string memory root = vm.projectRoot(); + string memory path = string.concat( + root, + "/test/fixtures/difficultyEpoch.json" + ); + string memory json = vm.readFile(path); + + FixtureBlockHeader[] memory f = abi.decode( + json.parseRaw(""), + (FixtureBlockHeader[]) + ); + for (uint256 i = 0; i < f.length; i++) { + difficultyEpoch.push(toBlockHeader(f[i])); + } + verifySPV = new VerifySPV(difficultyEpoch[0], 840672, 2, false); + } + + function toBlockHeader( + FixtureBlockHeader memory f + ) private pure returns (BlockHeader memory) { + return + BlockHeader({ + version: bytes4(f.version), + previousBlockHash: f.previousBlockHash, + merkleRootHash: f.merkleRootHash, + timestamp: bytes4(f.timestamp), + nBits: bytes4(f.nBits), + nonce: bytes4(f.nonce) + }); + } + + function testRegisterBlock() public { + BlockHeader[] memory epoch = new BlockHeader[](76); + for (uint256 j = 0; j < 76; j++) { + epoch[j] = difficultyEpoch[j]; + } + + vm.expectEmit(true, false, false, false, address(verifySPV)); + emit VerifySPV.BlockRegistered( + difficultyEpoch[72].calculateBlockHash(), + 840744 + ); + verifySPV.registerLatestBlock(epoch, 72); + (, , uint256 height) = verifySPV.blockHeaders( + verifySPV.LatestBlockHash() + ); + assertEq(height, 840744, "Height should be 840744"); + } + + // update to new version + // function testShouldntRegisterInvalidBlock() public { + // BlockHeader[] memory epoch = new BlockHeader[](76); + + // uint256 counter = 0; + + // while (counter < 76) { + // epoch[counter] = difficultyEpoch[counter]; + // counter++; + // } + + // epoch[2].previousBlockHash = epoch[3].previousBlockHash; + + // vm.expectRevert("VerifySPV: sequence verification failed"); + // verifySPV.registerBlock(epoch); + // } + + // function testRegisterBlockShouldRejectInvalidEpochLength() public { + // BlockHeader[] memory epoch = new BlockHeader[](3); + // vm.expectRevert( + // "VerifySPV: invalid epoch, should contain previous 72 blocks and next 3 blocks" + // ); + // verifySPV.registerBlock(epoch); + // } + + // function tesRegisterBlockShouldRejectIfStartingBlockNotOnChain() public { + // BlockHeader[] memory epoch = new BlockHeader[](76); + + // uint256 counter = 0; + + // while (counter < 76) { + // epoch[counter] = difficultyEpoch[counter + 1]; + // counter++; + // } + + // vm.expectRevert( + // "VerifySPV: invalid epoch, starting block not on chain" + // ); + // verifySPV.registerBlock(epoch); + // } + + // function testVerifyTransactionInBlock() public { + // BlockHeader[] memory epoch = new BlockHeader[](76); + // BlockHeader[] memory epochForTxVerification = new BlockHeader[](73); + // uint256 counter = 0; + + // while (counter < 76) { + // epoch[counter] = difficultyEpoch[counter]; + // if (counter < 73) + // epochForTxVerification[counter] = difficultyEpoch[counter]; + // counter++; + // } + + // verifySPV.registerBlock(epoch); + // bytes32[] memory proof = new bytes32[](12); + + // proof[0] = bytes32( + // 0x1a62992f9e3d1dcb699845cbee5d23569a13981ffbfd2c7c518be65821eaef06 + // ); + // proof[1] = bytes32( + // 0x0c7652d6747faf960a42ed0345112140ad26a5d9cb7f0955b6ddd5c70d8ae6f5 + // ); + // proof[2] = bytes32( + // 0xc7ba8b5b36d6eec2f350d0c72af6f1280e7fc05e767b5ac05d2bc606daebf065 + // ); + // proof[3] = bytes32( + // 0x2bb7498551304f67657656fabfc66f92e60775040775f93d616c91e9cbfcb1c4 + // ); + // proof[4] = bytes32( + // 0xaac8a3c0eac8f5a9eb25451a56bbf6134f4719c99460a7d892a4790fbc56d69f + // ); + // proof[5] = bytes32( + // 0xda071e5e721ac7a6eda6002feba70bf26700d3f39919b2dc5cf927a514b46fed + // ); + // proof[6] = bytes32( + // 0x50f4afabbecb0d3cfdcb2d19170a198662b78f00b9899ceaf5b270de0c52b4da + // ); + // proof[7] = bytes32( + // 0x75b5fc80d4bb258ef53691ad6eac624f6e274e85eec00f02aecf01bcf0947382 + // ); + // proof[8] = bytes32( + // 0x257cd93d8ac8a403e09290c8236bfe951bb6d5944799b141b095258f4e71a3ab + // ); + // proof[9] = bytes32( + // 0x8a3c6629f70a22d0dff99e6feff7516d729baf4bb52583673685e655aa80cf4c + // ); + // proof[10] = bytes32( + // 0x5f372e5db7d25a390f2cb62243acbe107023c262b13db2f329c6a6780e4ab3b4 + // ); + // proof[11] = bytes32( + // 0x5a3721a753244c9c41f44e4a41424f05dd8be93b97c518eb5f5286bc7ade3c7a + // ); + + // bool isIncluded = verifySPV.verifyTxInclusion( + // epochForTxVerification, + // 3, + // 636, + // 0x723026cc979bb3b82d1c1749450a66444e17f66bfe7bc2188bc2b2fc5ad8a8a3, + // proof + // ); + + // assertEq(isIncluded, true, "Transaction should be included in block"); + // } + + // function testShouldRejectIfInvalidEpochLength() public { + // BlockHeader[] memory epochForTxVerification = new BlockHeader[](1); + // epochForTxVerification[0] = difficultyEpoch[0]; + + // vm.expectRevert( + // "VerifySPV: inclusion verification needs all 72 blocks in the epoch" + // ); + // verifySPV.verifyTxInclusion( + // epochForTxVerification, + // 0, + // 0, + // 0x723026cc979bb3b82d1c1749450a66444e17f66bfe7bc2188bc2b2fc5ad8a8a3, + // new bytes32[](12) + // ); + // } + + // function testShouldntVerifyIfInvalidStartingBlock() public { + // BlockHeader[] memory epoch = new BlockHeader[](76); + // BlockHeader[] memory epochForTxVerification = new BlockHeader[](73); + + // uint256 counter = 0; + + // while (counter < 76) { + // epoch[counter] = difficultyEpoch[counter]; + // if (counter < 73) + // epochForTxVerification[counter] = difficultyEpoch[counter + 1]; + // counter++; + // } + + // verifySPV.registerBlock(epoch); + + // vm.expectRevert( + // "VerifySPV: invalid epoch, starting block not on chain" + // ); + // verifySPV.verifyTxInclusion( + // epochForTxVerification, + // 3, + // 636, + // 0x723026cc979bb3b82d1c1749450a66444e17f66bfe7bc2188bc2b2fc5ad8a8a3, + // new bytes32[](12) + // ); + // } + + // function testShouldntVerifyInvalidEndingBlock() public { + // BlockHeader[] memory epochForTxVerification = new BlockHeader[](73); + + // uint256 counter = 0; + + // while (counter < 76) { + // if (counter < 73) + // epochForTxVerification[counter] = difficultyEpoch[counter]; + // counter++; + // } + + // vm.expectRevert("VerifySPV: invalid epoch, ending block not on chain"); + // verifySPV.verifyTxInclusion( + // epochForTxVerification, + // 3, + // 636, + // 0x723026cc979bb3b82d1c1749450a66444e17f66bfe7bc2188bc2b2fc5ad8a8a3, + // new bytes32[](12) + // ); + // } + + // function testShouldntVerifyInvalidTransaction() public { + // BlockHeader[] memory epoch = new BlockHeader[](76); + // BlockHeader[] memory epochForTxVerification = new BlockHeader[](73); + // uint256 counter = 0; + + // while (counter < 76) { + // epoch[counter] = difficultyEpoch[counter]; + // if (counter < 73) + // epochForTxVerification[counter] = difficultyEpoch[counter]; + // counter++; + // } + + // verifySPV.registerBlock(epoch); + // bytes32[] memory proof = new bytes32[](12); + + // proof[0] = bytes32( + // 0x1a62992f9e3d1dcb699845cbee5d23569a13981ffbfd2c7c518be65821eaef06 + // ); + // proof[1] = bytes32( + // 0x0c7652d6747faf960a42ed0345112140ad26a5d9cb7f0955b6ddd5c70d8ae6f5 + // ); + // proof[2] = bytes32( + // 0xc7ba8b5b36d6eec2f350d0c72af6f1280e7fc05e767b5ac05d2bc606daebf065 + // ); + // proof[3] = bytes32( + // 0x2bb7498551304f67657656fabfc66f92e60775040775f93d616c91e9cbfcb1c4 + // ); + // proof[4] = bytes32( + // 0xaac8a3c0eac8f5a9eb25451a56bbf6134f4719c99460a7d892a4790fbc56d69f + // ); + // proof[5] = bytes32( + // 0xda071e5e721ac7a6eda6002feba70bf26700d3f39919b2dc5cf927a514b46fed + // ); + // proof[6] = bytes32( + // 0x50f4afabbecb0d3cfdcb2d19170a198662b78f00b9899ceaf5b270de0c52b4da + // ); + // proof[7] = bytes32( + // 0x75b5fc80d4bb258ef53691ad6eac624f6e274e85eec00f02aecf01bcf0947382 + // ); + // proof[8] = bytes32( + // 0x257cd93d8ac8a403e09290c8236bfe951bb6d5944799b141b095258f4e71a3ab + // ); + // proof[9] = bytes32( + // 0x8a3c6629f70a22d0dff99e6feff7516d729baf4bb52583673685e655aa80cf4c + // ); + // proof[10] = bytes32( + // 0x5f372e5db7d25a390f2cb62243acbe107023c262b13db2f329c6a6780e4ab3b4 + // ); + // proof[11] = bytes32( + // 0x5a3721a753244c9c41f44e4a41424f05dd8be93b97c518eb5f5286bc7ade3c7a + // ); + + // bool isIncluded = verifySPV.verifyTxInclusion( + // epochForTxVerification, + // 3, + // 636, + // bytes32( + // LibBitcoin.convertToBigEndian( + // bytes.concat( + // bytes32( + // 0x723026cc979bb3b82d1c1749450a66444e17f66bfe7bc2188bc2b2fc5ad8a8a3 + // ) + // ) + // ) + // ), + // proof + // ); + + // assertEq(isIncluded, false, "Transaction should be included in block"); + // } + + // function testShouldAdjustNewDifficulty() public { + // for (uint256 i = 0; i < 28; i++) { + // BlockHeader[] memory epoch = new BlockHeader[](76); + // for (uint256 j = 0; j < 76; j++) { + // epoch[j] = difficultyEpoch[i * 72 + j]; + // } + + // verifySPV.registerBlock(epoch); + // } + + // assertEq(verifySPV.epoch(), 28, "Epoch should be 28"); + // } + + // function testShouldntVerifyInvalidDifficultyEpoch() public { + // for (uint256 i = 0; i < 28; i++) { + // BlockHeader[] memory epoch = new BlockHeader[](76); + // for (uint256 j = 0; j < 76; j++) { + // epoch[j] = difficultyEpoch[i * 72 + j]; + // } + + // if (i == 27) { + // epoch[2].previousBlockHash = epoch[3].previousBlockHash; + // vm.expectRevert( + // "VerifySPV: pre subsequence in difficulty epoch failed" + // ); + // verifySPV.registerBlock(epoch); + // } else { + // verifySPV.registerBlock(epoch); + // } + // } + + // assertEq(verifySPV.epoch(), 27, "Epoch should be 27"); + // } + + // function testShouldntVerifyInvalidDifficultyEpochTarget() public { + // for (uint256 i = 0; i < 28; i++) { + // BlockHeader[] memory epoch = new BlockHeader[](76); + // for (uint256 j = 0; j < 76; j++) { + // epoch[j] = difficultyEpoch[i * 72 + j]; + // } + + // if (i == 27) { + // epoch[72].timestamp = difficultyEpoch[0].timestamp; + // vm.expectRevert( + // "VerifySPV: adjusted difficulty is not in allowed range" + // ); + // verifySPV.registerBlock(epoch); + // } else { + // verifySPV.registerBlock(epoch); + // } + // } + + // assertEq(verifySPV.epoch(), 27, "Epoch should be 27"); + // } + + // function testShouldntVerifyInvalidDifficultyBlockPreviousHash() public { + // for (uint256 i = 0; i < 28; i++) { + // BlockHeader[] memory epoch = new BlockHeader[](76); + // for (uint256 j = 0; j < 76; j++) { + // epoch[j] = difficultyEpoch[i * 72 + j]; + // } + + // if (i == 27) { + // epoch[72].previousBlockHash = difficultyEpoch[0] + // .previousBlockHash; + // vm.expectRevert( + // "VerifySPV: difficulty epoch validation failed" + // ); + // verifySPV.registerBlock(epoch); + // } else { + // verifySPV.registerBlock(epoch); + // } + // } + + // assertEq(verifySPV.epoch(), 27, "Epoch should be 27"); + // } + + // function testShouldntVerifyInvalidPostSequenceInDifficultyEpoch() public { + // for (uint256 i = 0; i < 28; i++) { + // BlockHeader[] memory epoch = new BlockHeader[](76); + // for (uint256 j = 0; j < 76; j++) { + // epoch[j] = difficultyEpoch[i * 72 + j]; + // } + + // if (i == 27) { + // epoch[74].previousBlockHash = epoch[3].previousBlockHash; + // vm.expectRevert( + // "VerifySPV: post subsequence in difficulty epoch failed" + // ); + // verifySPV.registerBlock(epoch); + // } else { + // verifySPV.registerBlock(epoch); + // } + // } + + // assertEq(verifySPV.epoch(), 27, "Epoch should be 27"); + // } +} diff --git a/test/VerifySPV.regtest.t.sol b/test/VerifySPV.regtest.t.sol new file mode 100644 index 0000000..188d625 --- /dev/null +++ b/test/VerifySPV.regtest.t.sol @@ -0,0 +1,78 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; +import {LibBitcoin, BlockHeader} from "src/libraries/LibBitcoin.sol"; +import {LibSPV} from "src/libraries/LibSPV.sol"; +import {VerifySPV} from "src/VerifySPV.sol"; +import {Test} from "forge-std/Test.sol"; + +import {console} from "forge-std/console.sol"; + +import "forge-std/StdJson.sol"; + +struct FixtureBlockHeader { + bytes32 merkleRootHash; + bytes nBits; + bytes nonce; + bytes32 previousBlockHash; + bytes timestamp; + bytes version; +} + +contract VerifySPVTest is Test { + using stdJson for string; + using Math for uint256; + using LibSPV for BlockHeader; + + BlockHeader[] difficultyEpoch; + VerifySPV verifySPV; + + event BlockRegistered(bytes32 blockHash); + + function setUp() public { + string memory root = vm.projectRoot(); + string memory path = string.concat( + root, + "/test/fixtures/difficultyEpoch_resgtest.json" + ); + string memory json = vm.readFile(path); + + FixtureBlockHeader[] memory f = abi.decode( + json.parseRaw(""), + (FixtureBlockHeader[]) + ); + console.log(f.length); + for (uint256 i = 0; i < f.length; i++) { + difficultyEpoch.push(toBlockHeader(f[i])); + } + verifySPV = new VerifySPV(difficultyEpoch[0], 0, 1, true); + } + + function toBlockHeader( + FixtureBlockHeader memory f + ) private pure returns (BlockHeader memory) { + return + BlockHeader({ + version: bytes4(f.version), + previousBlockHash: f.previousBlockHash, + merkleRootHash: f.merkleRootHash, + timestamp: bytes4(f.timestamp), + nBits: bytes4(f.nBits), + nonce: bytes4(f.nonce) + }); + } + + // function testShouldVerifyAnEpochInRegtest() public { + // for (uint256 i = 0; i < 29; i++) { + // (BlockHeader[] memory epoch) = new BlockHeader[](76); + // for (uint256 j = 0; j < 76; j++) { + // epoch[j] = difficultyEpoch[i * 72 + j]; + // } + + // verifySPV.registerBlock(epoch); + // } + + // assertEq(verifySPV.epoch(), 29, "Epoch should be 28"); + // } +} diff --git a/test/VerifySPV.t.sol b/test/VerifySPV.t.sol deleted file mode 100644 index 62fd80b..0000000 --- a/test/VerifySPV.t.sol +++ /dev/null @@ -1,325 +0,0 @@ -// SPDX-License-Identifier: UNLICENSED -pragma solidity ^0.8.20; - -import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; -import {Utils} from "src/Utils.sol"; -import {SPVLib} from "src/libraries/SPVLib.sol"; -import {BlockHeader} from "src/Types.sol"; -import {VerifySPV} from "src/VerifySPV.sol"; -import {Test} from "forge-std/Test.sol"; -import {console} from "forge-std/console.sol"; -import "forge-std/StdJson.sol"; - -struct FixtureBlockHeader { - bytes32 merkleRootHash; - bytes nBits; - bytes nonce; - bytes32 previousBlockHash; - bytes timestamp; - bytes version; -} - -contract VerifySPVTest is Test { - using stdJson for string; - using Math for uint256; - using SPVLib for BlockHeader; - - BlockHeader[] difficultyEpoch; - VerifySPV verifySPV; - - event BlockRegistered(bytes32 blockHash); - - function setUp() public { - string memory root = vm.projectRoot(); - string memory path = string.concat(root, "/test/fixtures/difficultyEpoch.json"); - string memory json = vm.readFile(path); - - (FixtureBlockHeader[] memory f) = abi.decode(json.parseRaw(""), (FixtureBlockHeader[])); - for (uint256 i = 0; i < f.length; i++) { - difficultyEpoch.push(toBlockHeader(f[i])); - } - verifySPV = new VerifySPV(difficultyEpoch[0]); - } - - function toBlockHeader(FixtureBlockHeader memory f) private pure returns (BlockHeader memory) { - return BlockHeader({ - version: bytes4(f.version), - previousBlockHash: f.previousBlockHash, - merkleRootHash: f.merkleRootHash, - timestamp: bytes4(f.timestamp), - nBits: bytes4(f.nBits), - nonce: bytes4(f.nonce) - }); - } - - function testRegisterBlock() public { - BlockHeader[] memory epoch1 = new BlockHeader[](76); - BlockHeader[] memory epoch2 = new BlockHeader[](76); - - uint256 counter = 0; - - while (counter < 76) { - epoch1[counter] = difficultyEpoch[counter]; - counter++; - } - - counter = 72; - while (counter < 72 + 76) { - epoch2[counter - 72] = difficultyEpoch[counter]; - counter++; - } - - vm.expectEmit(false, false, false, true, address(verifySPV)); - emit BlockRegistered(epoch1[72].calculateBlockHash()); - verifySPV.registerBlock(epoch1); - - vm.expectEmit(false, false, false, true, address(verifySPV)); - emit BlockRegistered(epoch2[72].calculateBlockHash()); - verifySPV.registerBlock(epoch2); - } - - function testShouldntRegisterInvalidBlock() public { - (BlockHeader[] memory epoch) = new BlockHeader[](76); - - uint256 counter = 0; - - while (counter < 76) { - epoch[counter] = difficultyEpoch[counter]; - counter++; - } - - epoch[2].previousBlockHash = epoch[3].previousBlockHash; - - vm.expectRevert("VerifySPV: sequence verification failed"); - verifySPV.registerBlock(epoch); - } - - function testRegisterBlockShouldRejectInvalidEpochLength() public { - (BlockHeader[] memory epoch) = new BlockHeader[](3); - vm.expectRevert("VerifySPV: invalid epoch, should contain previous 72 blocks and next 3 blocks"); - verifySPV.registerBlock(epoch); - } - - function tesRegisterBlockShouldRejectIfStartingBlockNotOnChain() public { - (BlockHeader[] memory epoch) = new BlockHeader[](76); - - uint256 counter = 0; - - while (counter < 76) { - epoch[counter] = difficultyEpoch[counter + 1]; - counter++; - } - - vm.expectRevert("VerifySPV: invalid epoch, starting block not on chain"); - verifySPV.registerBlock(epoch); - } - - function testVerifyTransactionInBlock() public { - BlockHeader[] memory epoch = new BlockHeader[](76); - BlockHeader[] memory epochForTxVerification = new BlockHeader[](73); - uint256 counter = 0; - - while (counter < 76) { - epoch[counter] = difficultyEpoch[counter]; - if (counter < 73) epochForTxVerification[counter] = difficultyEpoch[counter]; - counter++; - } - - verifySPV.registerBlock(epoch); - bytes32[] memory proof = new bytes32[](12); - - proof[0] = bytes32(0x1a62992f9e3d1dcb699845cbee5d23569a13981ffbfd2c7c518be65821eaef06); - proof[1] = bytes32(0x0c7652d6747faf960a42ed0345112140ad26a5d9cb7f0955b6ddd5c70d8ae6f5); - proof[2] = bytes32(0xc7ba8b5b36d6eec2f350d0c72af6f1280e7fc05e767b5ac05d2bc606daebf065); - proof[3] = bytes32(0x2bb7498551304f67657656fabfc66f92e60775040775f93d616c91e9cbfcb1c4); - proof[4] = bytes32(0xaac8a3c0eac8f5a9eb25451a56bbf6134f4719c99460a7d892a4790fbc56d69f); - proof[5] = bytes32(0xda071e5e721ac7a6eda6002feba70bf26700d3f39919b2dc5cf927a514b46fed); - proof[6] = bytes32(0x50f4afabbecb0d3cfdcb2d19170a198662b78f00b9899ceaf5b270de0c52b4da); - proof[7] = bytes32(0x75b5fc80d4bb258ef53691ad6eac624f6e274e85eec00f02aecf01bcf0947382); - proof[8] = bytes32(0x257cd93d8ac8a403e09290c8236bfe951bb6d5944799b141b095258f4e71a3ab); - proof[9] = bytes32(0x8a3c6629f70a22d0dff99e6feff7516d729baf4bb52583673685e655aa80cf4c); - proof[10] = bytes32(0x5f372e5db7d25a390f2cb62243acbe107023c262b13db2f329c6a6780e4ab3b4); - proof[11] = bytes32(0x5a3721a753244c9c41f44e4a41424f05dd8be93b97c518eb5f5286bc7ade3c7a); - - bool isIncluded = verifySPV.verifyTxInclusion( - epochForTxVerification, 3, 636, 0x723026cc979bb3b82d1c1749450a66444e17f66bfe7bc2188bc2b2fc5ad8a8a3, proof - ); - - assertEq(isIncluded, true, "Transaction should be included in block"); - } - - function testShouldRejectIfInvalidEpochLength() public { - BlockHeader[] memory epochForTxVerification = new BlockHeader[](1); - epochForTxVerification[0] = difficultyEpoch[0]; - - vm.expectRevert("VerifySPV: inclusion verification needs all 72 blocks in the epoch"); - verifySPV.verifyTxInclusion(epochForTxVerification, 0, 0, 0x723026cc979bb3b82d1c1749450a66444e17f66bfe7bc2188bc2b2fc5ad8a8a3, new bytes32[](12)); - } - - function testShouldntVerifyIfInvalidStartingBlock() public { - BlockHeader[] memory epoch = new BlockHeader[](76); - BlockHeader[] memory epochForTxVerification = new BlockHeader[](73); - - uint256 counter = 0; - - while (counter < 76) { - epoch[counter] = difficultyEpoch[counter]; - if (counter < 73) epochForTxVerification[counter] = difficultyEpoch[counter + 1]; - counter++; - } - - verifySPV.registerBlock(epoch); - - vm.expectRevert("VerifySPV: invalid epoch, starting block not on chain"); - verifySPV.verifyTxInclusion( - epochForTxVerification, 3, 636, 0x723026cc979bb3b82d1c1749450a66444e17f66bfe7bc2188bc2b2fc5ad8a8a3, new bytes32[](12) - ); - } - - function testShouldntVerifyInvalidEndingBlock() public { - BlockHeader[] memory epochForTxVerification = new BlockHeader[](73); - - uint256 counter = 0; - - while (counter < 76) { - if (counter < 73) epochForTxVerification[counter] = difficultyEpoch[counter]; - counter++; - } - - vm.expectRevert("VerifySPV: invalid epoch, ending block not on chain"); - verifySPV.verifyTxInclusion( - epochForTxVerification, 3, 636, 0x723026cc979bb3b82d1c1749450a66444e17f66bfe7bc2188bc2b2fc5ad8a8a3, new bytes32[](12) - ); - } - - function testShouldntVerifyInvalidTransaction() public { - BlockHeader[] memory epoch = new BlockHeader[](76); - BlockHeader[] memory epochForTxVerification = new BlockHeader[](73); - uint256 counter = 0; - - while (counter < 76) { - epoch[counter] = difficultyEpoch[counter]; - if (counter < 73) epochForTxVerification[counter] = difficultyEpoch[counter]; - counter++; - } - - verifySPV.registerBlock(epoch); - bytes32[] memory proof = new bytes32[](12); - - proof[0] = bytes32(0x1a62992f9e3d1dcb699845cbee5d23569a13981ffbfd2c7c518be65821eaef06); - proof[1] = bytes32(0x0c7652d6747faf960a42ed0345112140ad26a5d9cb7f0955b6ddd5c70d8ae6f5); - proof[2] = bytes32(0xc7ba8b5b36d6eec2f350d0c72af6f1280e7fc05e767b5ac05d2bc606daebf065); - proof[3] = bytes32(0x2bb7498551304f67657656fabfc66f92e60775040775f93d616c91e9cbfcb1c4); - proof[4] = bytes32(0xaac8a3c0eac8f5a9eb25451a56bbf6134f4719c99460a7d892a4790fbc56d69f); - proof[5] = bytes32(0xda071e5e721ac7a6eda6002feba70bf26700d3f39919b2dc5cf927a514b46fed); - proof[6] = bytes32(0x50f4afabbecb0d3cfdcb2d19170a198662b78f00b9899ceaf5b270de0c52b4da); - proof[7] = bytes32(0x75b5fc80d4bb258ef53691ad6eac624f6e274e85eec00f02aecf01bcf0947382); - proof[8] = bytes32(0x257cd93d8ac8a403e09290c8236bfe951bb6d5944799b141b095258f4e71a3ab); - proof[9] = bytes32(0x8a3c6629f70a22d0dff99e6feff7516d729baf4bb52583673685e655aa80cf4c); - proof[10] = bytes32(0x5f372e5db7d25a390f2cb62243acbe107023c262b13db2f329c6a6780e4ab3b4); - proof[11] = bytes32(0x5a3721a753244c9c41f44e4a41424f05dd8be93b97c518eb5f5286bc7ade3c7a); - - bool isIncluded = verifySPV.verifyTxInclusion( - epochForTxVerification, - 3, - 636, - bytes32( - Utils.convertToBigEndian( - bytes.concat(bytes32(0x723026cc979bb3b82d1c1749450a66444e17f66bfe7bc2188bc2b2fc5ad8a8a3)) - ) - ), - proof - ); - - assertEq(isIncluded, false, "Transaction should be included in block"); - } - - function testShouldAdjustNewDifficulty() public { - for(uint i = 0; i < 28; i++) { - (BlockHeader[] memory epoch) = new BlockHeader[](76); - for(uint j = 0; j < 76; j++) { - epoch[j] = difficultyEpoch[i * 72 + j]; - } - - verifySPV.registerBlock(epoch); - } - - assertEq(verifySPV.epoch(), 28, "Epoch should be 28"); - } - - function testShouldntVerifyInvalidDifficultyEpoch() public { - for(uint i = 0; i < 28; i++) { - (BlockHeader[] memory epoch) = new BlockHeader[](76); - for(uint j = 0; j < 76; j++) { - epoch[j] = difficultyEpoch[i * 72 + j]; - } - - if (i == 27) { - epoch[2].previousBlockHash = epoch[3].previousBlockHash; - vm.expectRevert("VerifySPV: pre subsequence in difficulty epoch failed"); - verifySPV.registerBlock(epoch); - }else { - verifySPV.registerBlock(epoch); - } - } - - assertEq(verifySPV.epoch(), 27, "Epoch should be 27"); - } - - function testShouldntVerifyInvalidDifficultyEpochTarget() public { - for(uint i = 0; i < 28; i++) { - (BlockHeader[] memory epoch) = new BlockHeader[](76); - for(uint j = 0; j < 76; j++) { - epoch[j] = difficultyEpoch[i * 72 + j]; - } - - if (i == 27) { - epoch[72].timestamp = difficultyEpoch[0].timestamp; - vm.expectRevert("VerifySPV: adjusted difficulty is not in allowed range"); - verifySPV.registerBlock(epoch); - }else { - verifySPV.registerBlock(epoch); - } - } - - assertEq(verifySPV.epoch(), 27, "Epoch should be 27"); - } - - function testShouldntVerifyInvalidDifficultyBlockPreviousHash() public { - for(uint i = 0; i < 28; i++) { - (BlockHeader[] memory epoch) = new BlockHeader[](76); - for(uint j = 0; j < 76; j++) { - epoch[j] = difficultyEpoch[i * 72 + j]; - } - - if (i == 27) { - epoch[72].previousBlockHash = difficultyEpoch[0].previousBlockHash; - vm.expectRevert("VerifySPV: difficulty epoch validation failed"); - verifySPV.registerBlock(epoch); - }else { - verifySPV.registerBlock(epoch); - } - } - - assertEq(verifySPV.epoch(), 27, "Epoch should be 27"); - } - - function testShouldntVerifyInvalidPostSequenceInDifficultyEpoch() public { - for(uint i = 0; i < 28; i++) { - (BlockHeader[] memory epoch) = new BlockHeader[](76); - for(uint j = 0; j < 76; j++) { - epoch[j] = difficultyEpoch[i * 72 + j]; - } - - if (i == 27) { - epoch[74].previousBlockHash = epoch[3].previousBlockHash; - vm.expectRevert("VerifySPV: post subsequence in difficulty epoch failed"); - verifySPV.registerBlock(epoch); - }else { - verifySPV.registerBlock(epoch); - } - } - - assertEq(verifySPV.epoch(), 27, "Epoch should be 27"); - } -} diff --git a/test/VerifySPV.testnet.t.sol b/test/VerifySPV.testnet.t.sol new file mode 100644 index 0000000..ddaf2e0 --- /dev/null +++ b/test/VerifySPV.testnet.t.sol @@ -0,0 +1,65 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; +import {LibBitcoin, BlockHeader} from "src/libraries/LibBitcoin.sol"; +import {LibSPV} from "src/libraries/LibSPV.sol"; +import {VerifySPV} from "src/VerifySPV.sol"; +import {Test} from "forge-std/Test.sol"; +import "forge-std/StdJson.sol"; + +struct FixtureBlockHeader { + bytes32 merkleRootHash; + bytes nBits; + bytes nonce; + bytes32 previousBlockHash; + bytes timestamp; + bytes version; +} + +contract VerifySPVTest is Test { + using stdJson for string; + using Math for uint256; + using LibSPV for BlockHeader; + + BlockHeader[] difficultyEpoch; + VerifySPV verifySPV; + + event BlockRegistered(bytes32 blockHash); + + function setUp() public { + string memory root = vm.projectRoot(); + string memory path = string.concat(root, "/test/fixtures/difficultyEpoch_testnet.json"); + string memory json = vm.readFile(path); + + (FixtureBlockHeader[] memory f) = abi.decode(json.parseRaw(""), (FixtureBlockHeader[])); + for (uint256 i = 0; i < f.length; i++) { + difficultyEpoch.push(toBlockHeader(f[i])); + } + verifySPV = new VerifySPV(difficultyEpoch[0],0,1, true); + } + + function toBlockHeader(FixtureBlockHeader memory f) private pure returns (BlockHeader memory) { + return BlockHeader({ + version: bytes4(f.version), + previousBlockHash: f.previousBlockHash, + merkleRootHash: f.merkleRootHash, + timestamp: bytes4(f.timestamp), + nBits: bytes4(f.nBits), + nonce: bytes4(f.nonce) + }); + } + + // function testShouldVerifyAnEpochInTestnet() public { + // for (uint256 i = 0; i < 28; i++) { + // (BlockHeader[] memory epoch) = new BlockHeader[](76); + // for (uint256 j = 0; j < 76; j++) { + // epoch[j] = difficultyEpoch[i * 72 + j]; + // } + + // verifySPV.registerBlock(epoch); + // } + + // assertEq(verifySPV.epoch(), 28, "Epoch should be 28"); + // } +} diff --git a/test/fixtures/difficultyEpoch_regtest.json b/test/fixtures/difficultyEpoch_regtest.json new file mode 100644 index 0000000..dca7e4b --- /dev/null +++ b/test/fixtures/difficultyEpoch_regtest.json @@ -0,0 +1 @@ +[{"version":"0x00000020","timestamp":"0x0e758f66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xa8a15c50db64434a4dca40daf815724e39825babbac6a1d6ad2ae6e54a858565","merkleRootHash":"0xb31452f2d17f6ae1c2b14505f284aae3f43aca106ecf1edb2f893162620518f2"},{"version":"0x00000020","timestamp":"0x0e758f66","nBits":"0xffff7f20","nonce":"0x08000000","previousBlockHash":"0x70f2d4d518abcbc8cf206407d0e350977707e4c9f544631bc53781f67bab8805","merkleRootHash":"0x14ae549ae521ce3d12f2141f41dab108335696b152fdc49666c5f52757486a07"},{"version":"0x00000020","timestamp":"0x0f758f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb67108fd5661e705a9f9ede0a0044a31e3edeb9b3ec382f254beb4709d47f10c","merkleRootHash":"0x1749efd1f53ad525c1f6a08c4e3d2279e6041e4a11e9de873c330389f9e54510"},{"version":"0x00000020","timestamp":"0x0f758f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0c0c3be6cb39fced0c9bec924f0bac254a6cb52674f42bb32ca3c012bc70de00","merkleRootHash":"0x94b2fc7ee7593635b936419d18fd56e17e23c93a986734b9b2995697bd65b67e"},{"version":"0x00000020","timestamp":"0x0f758f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2263725316e3e8b1bff542a7c75a55a5e2305c56a8e845330eea5a0f29790423","merkleRootHash":"0x5d986be423ffb735aefd464533f332d8f6928c814c530e436c05aefe78f0b45b"},{"version":"0x00000020","timestamp":"0x0f758f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe3458858aa786397f985d21fef94e367e277a75a37ae1dbb484c3863727b5669","merkleRootHash":"0xec42927dc5aa940418419ef5e57b3164a773be09ab80d4fc059add261c86829d"},{"version":"0x00000020","timestamp":"0x0f758f66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x582f8eaaa4e82b653f8bc23a51231951c71e4bc5bc931184fac2e4a838d59d2e","merkleRootHash":"0x906b6a724d197dab84a4467a54ba6b42a45fb56797ac0f282e734bab248f1cf2"},{"version":"0x00000020","timestamp":"0x0f758f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa27ab0038f6a36cf1a2412d76ea038784398d881eae7268ead8622431fd3902f","merkleRootHash":"0xa3bc135d4875ed259dc4560e86cbf0ba9d0d8afebf03de94e7ddb6fa96bb7906"},{"version":"0x00000020","timestamp":"0x10758f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xfac0efde7e3d42965698f9fe63b25d8f654e06073cbcc4055a62788c25c6e809","merkleRootHash":"0x283920294816d28d083aa255ec237f7c187894b622d83f9470f39d3046c8fdcf"},{"version":"0x00000020","timestamp":"0x10758f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7449cfd8932b25c765511548fdd8cd92f3f15a0ef96dda2594e30c6f3d61906c","merkleRootHash":"0x3e69a0a933bb5d0930626002c1119d794d5c3f9013bd2b4e87706e9939ba9247"},{"version":"0x00000020","timestamp":"0x10758f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdeef79d2a3ef6732c904675a6956d75598d75989fdf7bbdf70b3ee67987c967e","merkleRootHash":"0xc1ba85f858820dd225f5d586b62e0854bb6f4551802b3ca72059e4ca3fa06f4d"},{"version":"0x00000020","timestamp":"0x10758f66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xe6c3a5bec92f600c4021a895e7785140c7b1b061d06b7e9df98378f6e2e32075","merkleRootHash":"0xed036bb4e1de9b56041218106c9d19e1e5feb330f8712fa28d6d4aa53cb6f270"},{"version":"0x00000020","timestamp":"0x10758f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x47a81301079f3cee2125a82a9bce51c6f3f2766679997ce15368b5ab27cba37d","merkleRootHash":"0x9c38c086af56ba4c196179aa6e7f6e4bcf17e068a4d4c1ed87c46f8f9463b0b5"},{"version":"0x00000020","timestamp":"0x10758f66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x7dc755137f1c916b6686f7224a8c051b2182ce6c7f2b27d20bf6cc5a7fc8bb20","merkleRootHash":"0xa2a2b05127fb032ba3e7ce3153034282f462d08263ec13564f92f7c0bb895d29"},{"version":"0x00000020","timestamp":"0x11758f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf017a6185cdbeb0f12a795827f0d6c321733a9712d13ad959d2a26152b39df0f","merkleRootHash":"0x1dc791ec5738f175fc1a8155fdb9ba3730eaf9a5bc5692e559428c1b663f913d"},{"version":"0x00000020","timestamp":"0x11758f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2582ccead03c7f647d50b6d6aca46ef7ed0d8299f18b3d2a60afdbe3fdeb2d74","merkleRootHash":"0x322e14eeaa18814efec701eb82a1fb90273bf3f74381787243c129e62199de77"},{"version":"0x00000020","timestamp":"0x11758f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9c74fd7c1c1778dfe3f6818ec4a8affca673c6d9770de4f8a85bc1991b994212","merkleRootHash":"0x57cfe0b94e6f613469e40eaad7354b2e3ec7a89ed2740e0f2362a437e4e34201"},{"version":"0x00000020","timestamp":"0x11758f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x641d91478e6b3a3ef875a8af910f5d6078c56ad6df9c1af450caabb862360d2f","merkleRootHash":"0xc3e263624b940a8357d5356708fabcb3aa2913c73aa9f105c4bfbf969437b8b5"},{"version":"0x00000020","timestamp":"0x11758f66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x53de739765ff950c5807d1b6767412aeb172d65486188011bd5c5e915eb42d6d","merkleRootHash":"0x1dc612dee060ece32acdc5eaad863ba19e1fae6dd4ef94eed37c95cb4c2451c5"},{"version":"0x00000020","timestamp":"0x11758f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3466f0f03471758417e83ec106a821166f57006fbab1cb5023f15ce598a24040","merkleRootHash":"0x983cb1a3ea40e44407aa95625a667388350c74b8e782c117e0f51357dd8a60d2"},{"version":"0x00000020","timestamp":"0x12758f66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x93e3ccd19b67521d0cfe0f66ca2f42db10a6ace6a0add9351b2b2cf6834a6a74","merkleRootHash":"0x525228e8dfaac571ead70fcfa934df325d5935ec6c054c1f3939557dd3b045e5"},{"version":"0x00000020","timestamp":"0x12758f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4a9fdbf429d9f533468a59383afadd132933f146a7018a2dd22716da0fb5d300","merkleRootHash":"0x9c6708412444eca8dfd1a8ab58a6b1b4e3098b83fbb4adbd04079fd9233bd059"},{"version":"0x00000020","timestamp":"0x12758f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc135485866682672e3cecd3686efbe78960c1c1d721ee48a138cd8305d5fdc69","merkleRootHash":"0x479900eb3a4a6afe49d1daab5cd0320640560b205ab6f1c39dab3d012f27c02e"},{"version":"0x00000020","timestamp":"0x12758f66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xf2366e2c04559751a4c56649d8e1dbb34d57dbe2a45551aec2ea28f0d3e2760d","merkleRootHash":"0xa791e769a9b2f64bfedb8f673222a63d7dc8fe559988881b2990423bfa082ed2"},{"version":"0x00000020","timestamp":"0x12758f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8d2987d2a2b6bd6f5edf00efb60f3196e3459d61cd074506f2e6583965dfd171","merkleRootHash":"0x21b20e9773018f7af7ab6ace72c543843ed739a12f16365cc9382fa249b313c3"},{"version":"0x00000020","timestamp":"0x12758f66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x848bfac2d0a2ae6166d48d548611a5b7bf37bd7542476c09884c6f060aae8c43","merkleRootHash":"0xa1662b8db56d32d3dbb4a7a3852ca1e4a960cdccb189b8352f866f3236e2488c"},{"version":"0x00000020","timestamp":"0x13758f66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xe6c5c7de17e24b43a7bf6dd68f0b0aa4535fc97cb5b6124c046537179cd0b70f","merkleRootHash":"0xc55a4523cd06c4395a0c06acbcbe9633aa8aea5b5fecd466d390fe191463d6a3"},{"version":"0x00000020","timestamp":"0x13758f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0c3a0e1423c40a163b74270641e4f97cd0066fee0e8413427ae7c7597cbf0e0f","merkleRootHash":"0xe4a823c84d1a4c3df6f825c7e5dbe52236ae39ec15034e6cd616ab4138333b35"},{"version":"0x00000020","timestamp":"0x13758f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x13288820bf08bb361bdc462d98f6a1b69dd5bb31c1cc2a5a5add3fbb96686145","merkleRootHash":"0xe3a15d22ecbeb9c2bbe734c7d2b188d013f5b0b1aaf5c84942eab368016197f0"},{"version":"0x00000020","timestamp":"0x13758f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3f574284eaf13c1833e66facd1a4d831ede0e9a9d5637f73f368113eebe18351","merkleRootHash":"0xf9c34592585f1d3b25aef5f61e46493d1274c9ac29d51306cd7631adfcdf69fc"},{"version":"0x00000020","timestamp":"0x13758f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd70db111080256d9ba6d892f4fd876ad81c1282f428c890fc133eb1d31312f00","merkleRootHash":"0xdab982f96541faa441fced12a2dd877c97211fec9bb6e739df1f3df533a10eb2"},{"version":"0x00000020","timestamp":"0xf97c8f66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xfd7957f9cc78ec653f88926a24c24079e03508f3deb48381c80ab6c7bc497f32","merkleRootHash":"0x9007c2eff6b4fa3546501947888777efd620056c07bdc293ed80ec431787c33a"},{"version":"0x00000020","timestamp":"0xddd89066","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4572355cf7a090379281b105d1397accd83d24829b358d06fce03a9f7dd73565","merkleRootHash":"0xdaf3acba33b8d89cf58be7502b810a252c40f8d587b442bd3fb23927e0a246ff"},{"version":"0x00000020","timestamp":"0x74d99066","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0fc24fc45ca4809d0e7a8a3cbfe7ac19048bda987f6923d79b0ffa1d7c875a09","merkleRootHash":"0x86df6640f3277d12a22294a90be66e89c55b17c68979510418105f7259f59466"},{"version":"0x00000020","timestamp":"0x62c89566","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa49a4634fe42800694178dd3d939030712350865b90a1580cd3079d9480f1673","merkleRootHash":"0x52b20c371a26daf3fd4d635df8523c713fcf9f1aedc17690cb2a7ac838b88dbe"},{"version":"0x00000020","timestamp":"0x11ca9566","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x43789418dceececa379f2d81a304d673ef00f2983af602d7b2764a506a69c259","merkleRootHash":"0x2c253ee99a1e4fc23aa00211dbd8c26b87a3080c7e32b2c5b6511f0cd8ad2828"},{"version":"0x00000020","timestamp":"0x99cb9566","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3dda4c99e466201c80edbc34b083787a01bcd0315d2de57aa891414027208427","merkleRootHash":"0x705388b661c1a0d763e6ff2fb64847b0e305b053a2a853e7028199cbdd5cb243"},{"version":"0x00000020","timestamp":"0x95cc9566","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x27d0c2709f16857d96d720ecab1e2c3afa6e144c94ea176f72b29bcf5aedb73b","merkleRootHash":"0x521825be67070f4c1cf5c2b62b488a7f4aa431e7ad30d4d0ff83f387d2e583b1"},{"version":"0x00000020","timestamp":"0x3acd9566","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcbb29356a9fa858d3a28810b5c58d37a604ea8533064a6b56fe98490b1a65235","merkleRootHash":"0xe092d43ccc2d5649f28cdc5195d0a90c9d7de3d9e56615a68572cb6bc216dc18"},{"version":"0x00000020","timestamp":"0x62239e66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x61d874566b8787f10ee2c298c2ea3323f632d69a35acae3692ab335c34913602","merkleRootHash":"0x0ad5c22ca6ff54670ce1106b6c0a128c6f974209cb11a5c57357bcdd07331bb2"},{"version":"0x00000020","timestamp":"0x3a519f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0a41db078f7170c768623205bec4476ee14bd30f286065355fdccb8268a3141d","merkleRootHash":"0x34376923356e5d6aeffc5300c4046d7e0bd21703cf17e9ca3433cab4ab69c2a7"},{"version":"0x00000020","timestamp":"0x3f519f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xaa70d94a252ef9db53450415cae58434ae09b787062f2b787d6ff576a5369216","merkleRootHash":"0xb3b1663eb17951d6213e1870541b565ea067c2deb1a503ac109057e9f458da07"},{"version":"0x00000020","timestamp":"0x7a519f66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x584e9af4f31c76301d40999bcb2ae196c39a4cc44cabdaeafe974b20f032906c","merkleRootHash":"0xf1deb79164de182758c95b16106d52c26b20b8e27d99432f969dc2317ab1a4e1"},{"version":"0x00000020","timestamp":"0xac519f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd93cc5b5f759d15f1cda3490889199c4477c3d28e672dabec5e24907500eea4d","merkleRootHash":"0x619c96d7fa68091e21bf4ee6d8b7db2a527cfb484f40edace012751c1151e712"},{"version":"0x00000020","timestamp":"0xb5519f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1145c9af52c0b3754e4ce90ca521cfef82a2478d16195348e82fef1ae1648119","merkleRootHash":"0x47b41d0c11e6e47dc85307103e38d2c9255d03976711b3ef0aebd2f1680a7fd1"},{"version":"0x00000020","timestamp":"0xeb519f66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb9a966b3a522f14376f2062e5d7fc2be1b16eff82eea8c13979faa3690825d65","merkleRootHash":"0xeb7152204f67f4879c34be39916060183bcae8c036a577776f37ae01b419c3b0"},{"version":"0x00000020","timestamp":"0x0a739f66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf0c45b9bd7fae375eefa05ec4160135e6734755a58dd8f036e1340677aaeb150","merkleRootHash":"0x9aa50a4897a1c0a59206f7ca26998aacc276bba62ceda784194f762c4490b5e4"},{"version":"0x00000020","timestamp":"0x40fdb966","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x13b3980421a25b9a49c3eb79fc09b507a58d958dbb5da016ac2a4c191d046a42","merkleRootHash":"0x4519cc42d27621b2b7ae251d622ad6840748b48f6adb5e0e6fad1312ba3e293c"},{"version":"0x00000020","timestamp":"0x12ddba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xddb27aab793f6b58a9832829286a3a42371b545cc590f03596aea5177d1a4b51","merkleRootHash":"0x31963d64479b47a205c7e9197144a607b8251896f49be9c82e196c12cbea2551"},{"version":"0x00000020","timestamp":"0x2fe9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe5c3344ce3e4dc5d68a33f9a28bd129bf65c32116ad1df1b0f22911cbf4f4639","merkleRootHash":"0x7c1ce719afbbcdd3688e7a5a5c4eed6dfd82eb81333b49d70ab127c7aec4712c"},{"version":"0x00000020","timestamp":"0x35e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7eb28115b16332860e44cb2fa8065ba126d813f71735d86b8ae0ebda785d337a","merkleRootHash":"0x1037845e318d8746ab184bb36bfb5946fab46c933e18e588f4dccdb47c7f6405"},{"version":"0x00000020","timestamp":"0x35e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xeda390ebd0c853210503a35fceab335b90e15288e662c8795388b8949809cc01","merkleRootHash":"0x135169300456aa106c922fd7fffe61b6b2dfeb7a0920f750fb32a3d78c8883d5"},{"version":"0x00000020","timestamp":"0x35e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3e01af7274466a53775bf33a22b1941f388bfe9954b2e4aada26d368100f236d","merkleRootHash":"0x752ae13a7ebae7e311e9f625a0047d936c979a3adf1b1860ba660b970c0d4238"},{"version":"0x00000020","timestamp":"0x35e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1cb4a16d6727a7ce26365c71e830fab90a6755c679291f5bb29b21d4d36d3354","merkleRootHash":"0x77dd53d8b000aa3d8ebfe8acc0444fa37f6d50cc70c4dd24452ca7b2ad5cbedc"},{"version":"0x00000020","timestamp":"0x35e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7fbf9db9e9b2d5a48daea3effdf57a8e55dbfd9d5cfe46d728a825c09db6ce3c","merkleRootHash":"0xc31369d6fde11ab0f1cefda9b15f7e7731ba708d1c832f95a240ee91d80ed733"},{"version":"0x00000020","timestamp":"0x35e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xaeaacefa7058ff463752278590a86e0b9f674a2ee3824c5e36dc13cac805d849","merkleRootHash":"0xb2cc88dc3158372a7f21155f15d070d666bff73d898ab218a930b4a940d4fa32"},{"version":"0x00000020","timestamp":"0x36e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdc76e15768650c901267931790ef32e7c9b7bf2d16dcf4267c14c66cd0ca1e34","merkleRootHash":"0xbfa2c31bce6317962986e1f6285a0e721b378f48735c2bd8ee94bfd9eeccba33"},{"version":"0x00000020","timestamp":"0x36e9ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x05668e7666349779ac0db10c88f429445af00be47c8d997fc2fbd320c302636a","merkleRootHash":"0xc8df843aacb6ead21e9fb8e2590d21bd7bbc2b8ddaef9fb4c0d4bc63ce558ca4"},{"version":"0x00000020","timestamp":"0x36e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x65bb94761cac7a8c985ef98efb6fd22e5774ee49a4b9a5afe3652307e4c16b0c","merkleRootHash":"0x72b8dade9944bf5a2419d1dd8eac9f47783556110d48071ae2cd4cfb0f3ca67d"},{"version":"0x00000020","timestamp":"0x36e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9abee6d73ce717a41eef8d4638e6ba59a09e607be489a0631cb55e4b180d0b74","merkleRootHash":"0x15311c8d82814e1d4a8c2b8b4c205e5c8c8993f430588d3222835a4f891649cb"},{"version":"0x00000020","timestamp":"0x36e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9cdf0aefb1d021b8faf247662ad217e052bc7190209e88eaeed1728c12a0263b","merkleRootHash":"0x108b24264e84b2cec689cd1d26309462c9f510d9e9bcdeca2b1216b5ee3433f1"},{"version":"0x00000020","timestamp":"0x36e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf762ae3d99e4514b1338d6051d23e340d195b3358ab6067a65236831f97b2126","merkleRootHash":"0x00b80704c9f6f76a5abc025d4d30b364da739ed7345841ebde59337a1e8c52d8"},{"version":"0x00000020","timestamp":"0x37e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc37e1ebb05aed02cf6a5cfab1772e7fffcc2ef0cc1664c424e34ad87bdac313c","merkleRootHash":"0x22caa2f69cd1a989fc19dfeebdb13ab5796d1c452dcf407a216a9ad7452dba5d"},{"version":"0x00000020","timestamp":"0x37e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3b617bba12a13aec8ac799f3016e65d2ef5cafabedc6e8945a69c107d0a6874f","merkleRootHash":"0x882a87ef19a79f2cd591a7152c905b65535566b8944cbe4e0a683f1ca95f00b1"},{"version":"0x00000020","timestamp":"0x37e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x37112b904dea30c79d1c0759d5200016c4d8b0cb8ba80649a58b16dd53b80919","merkleRootHash":"0xd898220a4b3f93b5ee91ea47d8f74a6f13ce02f316e618ccbd3e46cfef56f891"},{"version":"0x00000020","timestamp":"0x37e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x576792a08d7f91ab8e2dd7552a0b6665571a90da1a533f8fce8f11559a975652","merkleRootHash":"0xf98d501445e154da597a7498992777fb2159f49cddac9b3c647470d5095ee632"},{"version":"0x00000020","timestamp":"0x37e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf983b09fd7e6b6ba8a3b1bad4ea419f43c7c3e522aafefcfe64bd048cac89e52","merkleRootHash":"0x910cfa42f0af7c4df1604079797955ccf9aa2220724398e9e91335be12a5044f"},{"version":"0x00000020","timestamp":"0x37e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4a47969f25b58ec7553481705d87975212dd030e21e162abb1911fac0ff81b27","merkleRootHash":"0x5733e3ca192d610d8f9222265a07f364b4f5c3e73390e425d4cb2772224e8785"},{"version":"0x00000020","timestamp":"0x38e9ba66","nBits":"0xffff7f20","nonce":"0x06000000","previousBlockHash":"0x0cb61897b7107f2390e6f4c104be5ed0eca2c3cfe0478c98a098f4a43dbb9f6e","merkleRootHash":"0xd1a70eb63146858934cda4c990d1b0dca0d40abcd79388b6e963b7a33de86e2c"},{"version":"0x00000020","timestamp":"0x38e9ba66","nBits":"0xffff7f20","nonce":"0x07000000","previousBlockHash":"0x4d8aad5f4d4c0db8fcc69112403992251ed4c8af64e89dae9bef71b5bbaf077b","merkleRootHash":"0xb7ca8e8051eb061ad5cb3f4b1c1b0c506b7d49c38be77d74b5e24c6700d0fefe"},{"version":"0x00000020","timestamp":"0x38e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xba4858220fddaac4c0012ad5969dc4f0cb56b8c6b3e0cd6dd72226c55366e676","merkleRootHash":"0xb41c7646436e457f287fc4f4e77ab34db2082aa3304bff81c036df5de8139910"},{"version":"0x00000020","timestamp":"0x38e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x58a924ea19f1d1253d619490d2dc41e116aac79a002ab0417f5fd9114cfd787e","merkleRootHash":"0x7a0668603b84044a6f9dff263caa5556130ca8342effc1562b804c94e163b118"},{"version":"0x00000030","timestamp":"0x38e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf0c9343e1bce48cfe893d136f4a842bfe37cd0f2dfa0943fed63628bfa677673","merkleRootHash":"0x1f6d41c328f9847f72d915d9057508a628706ff5bbf77e2778d87cf09b39e137"},{"version":"0x00000030","timestamp":"0x38e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x820cc1cc033873e9d0eef283198f10ab961bd07985e25ea8df5504154bfba247","merkleRootHash":"0xe1de9e2b0006a27218084aa1b4f959c200c14e422428332011708c5697a3cbb8"},{"version":"0x00000030","timestamp":"0x39e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4198afc060f10f04a6e8ff357e8c4f0adb68cec96338a99fcabed3335a55a15a","merkleRootHash":"0xae14ba2d395e21b4f6b4a3059c511501706231cd1ef71bdf2ce809b311b45750"},{"version":"0x00000030","timestamp":"0x39e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe2a6eabf3f7b5130c1eaa6fb7bd1f01c0e076f3f3e2f42945e8552fb739ab37f","merkleRootHash":"0xa0f3c3e6106cf4e1356e8a334df7961509c3ada4208e2eef76c81f97d468a0bb"},{"version":"0x00000030","timestamp":"0x39e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x40d5eacc85ef5b6b1651fa99a19e8932f88cf88ddbc5f42742b0ff0ca0cc342f","merkleRootHash":"0x03fd136ef38f4aa27afb4b936cc5d264db352bf75313fe160d99479c096b3c45"},{"version":"0x00000030","timestamp":"0x39e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4171bd8ad8ef8dc0ec8641fec698efb6de9bb0f95f37e8f778aa6f8a95bf6e24","merkleRootHash":"0x078156ba428af0e9d73b0a98b6320682c4b71f56bf81394781b0c64ef85fbbc6"},{"version":"0x00000030","timestamp":"0x39e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4e8083fd50f0c68cb141801b9c823e05251a7a04f64c04be4c9739964aece437","merkleRootHash":"0x46a4d2095805d4b130b85d6e0c05b6ec048041613f7e72cd5cf685d04f657f33"},{"version":"0x00000030","timestamp":"0x39e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x27271a02b2c734d59ba569620b5294752acfe913cec9a1b91bd95d58e97d0605","merkleRootHash":"0xfb551e80d4c799a7c3e6c97ca508a4a3d82acb9514a6b9078600e079abf9d9fc"},{"version":"0x00000030","timestamp":"0x3ae9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x97c691d3eaeade5cf012dc4ddbf32785b4eecd2700be6d3fe78c21eed43e075a","merkleRootHash":"0xddb876a4fef5929f68e8bdd724a9cdbac7e9afb3ca053ef64fa0ef8fee6e7d7e"},{"version":"0x00000030","timestamp":"0x3ae9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4ba689fa98ec78c8fe2a848a896a9e83785c884a89fbb3d3e3a86f1d467a061e","merkleRootHash":"0x93b2a435f98e4090bce517721491f8ae69821dafe958a5a117ef1a6d3469d419"},{"version":"0x00000030","timestamp":"0x3ae9ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x87fe1588c42d952e8769e73e5f4798fb7fc2e5dffbe63f6bf0df63e61e82d956","merkleRootHash":"0x8f9e66ca6f698a23de0bbf1f6254dfc6e6e084ef276fe5d0fb1a0fc5136ed291"},{"version":"0x00000030","timestamp":"0x3ae9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xfb03706cb69108c60e05637c13657d93f872c34fb74047fa6debbd5d28ac2331","merkleRootHash":"0xa2f66502bc16bab73bfbbd075c22ef1e26db595edc6516e7e59e78aab71ab024"},{"version":"0x00000030","timestamp":"0x3ae9ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x61f394f939ba019b2f0f0bae0dc2519c23fba8ea2aefa0b6304c0bf97784c443","merkleRootHash":"0xedf017b42d7b773498ab572b08626de95dfc74350f371d5b9f0b1df63b72853a"},{"version":"0x00000030","timestamp":"0x3ae9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x99388a7a27072d19ee5ea302a84c279d691ff1644d65dca0165f75ffea9f8d73","merkleRootHash":"0x4202cf8e6cca3354fb2bc5e82e935fd4533fded75d4ad4930e59f917704fba0d"},{"version":"0x00000030","timestamp":"0x3be9ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xc1c5aa617f1f1fbfda0b11d0e83319597a85d836723badf9576e0535e6432814","merkleRootHash":"0x7282f8d2f04885426cfd01dcc3802ab612edbf185ee57be1bc36336368bc5b3a"},{"version":"0x00000030","timestamp":"0x3be9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x12e918c29d65e1dbb8974ffcb3ef81c6345204f76f09e8e2ffc3ffce9c401420","merkleRootHash":"0x2574f98f6d760e05a1bf1b447b72722bb977bab4ac5aa6fd34baf3e607231a56"},{"version":"0x00000030","timestamp":"0x3be9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x49cb703ebbdf0518dca14ac4a588576442b85e46b6c8a8eae29d74dc570cb03c","merkleRootHash":"0xae444da449016250a9fb7571731b69267f4cac7a83538aa99181d2d271a9ee25"},{"version":"0x00000030","timestamp":"0x3be9ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xde9a0798a545598854a2063b3805baeafe8682ee02b118d9b1bc2ef5435cb744","merkleRootHash":"0xc0b3b16dfd05346b5c8b0d14b657bbd843b13153031ef9df3cf93af8cab552df"},{"version":"0x00000030","timestamp":"0x3be9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x03d727d1c0ba379eb679eb3154fcf0a8dc7da2459e3265fc283567709fb2ff32","merkleRootHash":"0x1403d8657b838c4f1ac80a7e14dc540f22567765b6a94fdda0b421f3f9365b07"},{"version":"0x00000030","timestamp":"0x3be9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5c1be5364e6582af64c0bafc156e0b46f39c134b5abe5aad49a87f8b980f0651","merkleRootHash":"0x6ce53f5971afbcfe65e92c75c2d302a8c9c9949867bcb1ca0af8ccc2d19284e3"},{"version":"0x00000030","timestamp":"0x3ce9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x33abcfbff74b663125d97cae868a026c9cc04a8fcebdaa53b715be398074320a","merkleRootHash":"0xec318dd9ce9778f0be3844d741cc4a3cf78a06d7d3142086104f3af6bc7af03c"},{"version":"0x00000030","timestamp":"0x3ce9ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xea65e62e9977ad5cc48647965e47cb7c605c18c967bd5223a92605e05146161f","merkleRootHash":"0x28f153ba1b45ca186ecc1952358d01e867b62d7e9fc917feaa0ccba3bbae27b1"},{"version":"0x00000030","timestamp":"0x3ce9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x146f52f3f1e21117865156dc49d11a1298107c3fc1eebb856ed6493a66411a66","merkleRootHash":"0x9c1d71898d59d826a3685a7e4592f4989467d1cc2680a6cd22d2ee0382f4b853"},{"version":"0x00000030","timestamp":"0x3ce9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x70e2d022de4a0f5b4adacc5711254386fb8069ae67b03549acdbb25c70630217","merkleRootHash":"0x2bd54b591746df814946cdf5d5bfc0a04239dc51ad9a0bc73de3f4c05f80d4d4"},{"version":"0x00000030","timestamp":"0x3ce9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8c822a3fe4acbb1594d5c183b5b0f0d0da0eeede39675f17327d3f79ad27d521","merkleRootHash":"0x158e13acb0e19040ec70d98f20fd2f186e3bf679d76e56b79228f00966f54836"},{"version":"0x00000030","timestamp":"0x3ce9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb7aed6bb2f4bb23a0527033f52340b61a1efd9c1811fd9a740f2b78fb0a8453e","merkleRootHash":"0xc8053ee1ccebab98175b72b5d9955b9a2c38d01b821a935acdc124297904c857"},{"version":"0x00000030","timestamp":"0x3de9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5d201791cadf22816185619b4080841ecc1088a73ec2044347c92d0dfcd4e11a","merkleRootHash":"0x7b8f202b2ab508db98baea20ea16ef0d27fcc9d2f08d80451ee1a11d5888c338"},{"version":"0x00000030","timestamp":"0x3de9ba66","nBits":"0xffff7f20","nonce":"0x06000000","previousBlockHash":"0xec043e05e8763c15c6e40fee99a255cec5097ec3f7fb3e206a064c713fee2c23","merkleRootHash":"0xd2b8e447cec3a8604a43f5da9a8eb7bbe15d655f0d15595614dbc6cbe5fb7022"},{"version":"0x00000030","timestamp":"0x3de9ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x9c5fdc4f7ecbc73650fcc7554c54b3d758303dcedbeb79865970247288585413","merkleRootHash":"0x10b40663f6cf0f99199533ecaaa62fd160ec4683d0df7a791f7e362d1040017f"},{"version":"0x00000030","timestamp":"0x3de9ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x27d025e7d8c33fc61ede7838723ab112dae0afa8d4df9af4e89014267da4544d","merkleRootHash":"0xebfa5d2aca70b78bf78fb95a16d23486af8b97252a75a0b4f814e133a2b82024"},{"version":"0x00000030","timestamp":"0x3de9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8425ca39735a8a401a2a3556bb1d2c1b0d607fb30c45880c86f69996459fbd5f","merkleRootHash":"0x5da8a530fd31380fe3a70526133a87d29f9eb50c11fa30f8a5751c7160b77a97"},{"version":"0x00000030","timestamp":"0x3de9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xac20e95b58b4ec71cea2f0a60d71216339542fdc8024043fa09e52558c55dc50","merkleRootHash":"0x3f07096f4817999c2e5c811740316c76d8b84968af2f928069d76f161dd1f4e1"},{"version":"0x00000030","timestamp":"0x3ee9ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x3f124f6af919365df63760e7dc7be008e72e3461dd980855e2f82bbed8303b47","merkleRootHash":"0xe77427f635a23b4111c8fdc0b4c877716adc7838f0b0c1a24c8a2071745f852e"},{"version":"0x00000030","timestamp":"0x3ee9ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x321a3ba420344e4ad7d03504c0ef1c6ea7f08a68fdde2b512dab650775c79c4b","merkleRootHash":"0x74abd1cd7293174f1dd4153e9a6f218184974b9e2086314795d65e6f4fa85563"},{"version":"0x00000030","timestamp":"0x3ee9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x50df58293b2294c8f59a9d3609040ecbf193b5a02e71c6311b03ff6fff85ae59","merkleRootHash":"0x58bc426acb03d593b36293b1a8aa9fd8b531e6ac836145353c4db0f3679e4949"},{"version":"0x00000030","timestamp":"0x3ee9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x760be0340c95cb511aa8c9005ac1fff236426581aa3270f149515cd386d00f6e","merkleRootHash":"0xd8e195a357b91a245603eb2da4b708b76dcff577a66237f37085a61d8f8d4989"},{"version":"0x00000030","timestamp":"0x3ee9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x066472e518a5db3e2afd7e27edbdc29fb10419cea11547b0a6f358ec271a3e53","merkleRootHash":"0x5ccacc4cfbbff0a4a8453b96e8b9f238a28fc2de63b4855da506d23afaa6550f"},{"version":"0x00000030","timestamp":"0x3ee9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa72c0c1bf3c8ee5a61bc0e0fe4f8bda7ba5f207ffa541f5f77824f061d4f5b33","merkleRootHash":"0x10c18c691a5ee374ea4528c52d35f83042ded7f17874790441e153082667466b"},{"version":"0x00000030","timestamp":"0x3fe9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe6f7a3ca0dacc7d86442a4a215eb4099f784fccb166e894bc2c54df2f1b7627f","merkleRootHash":"0x30827ec1e028f6cba54bc400f6450ace04728b58a9654eaff31f0fa35fbcdc9c"},{"version":"0x00000030","timestamp":"0x3fe9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0755a932bd11acc5c6a207a398ae08f32ba706dedf2059d55cf37a4135c5f133","merkleRootHash":"0x862867f9a720350e62ecad9fd05505ef34caf26e825302b612f8ca388efd8cc8"},{"version":"0x00000030","timestamp":"0x3fe9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x400309fa925e6a6188ce7784064af66b49455b1754431b376d8e5ef6e4be0d45","merkleRootHash":"0xd3444ffdc881cc4d788bce857c37226d9c37354f196317bcb2da946ed379fc1e"},{"version":"0x00000030","timestamp":"0x3fe9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1f7a967e37be7ce89963bb8e338db1e71e536b572a1190815abb461a1bfee148","merkleRootHash":"0x271dbd16c02a2438ee458df63d33393b873c219da647e2a49a4035325101fa24"},{"version":"0x00000030","timestamp":"0x3fe9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbf4bf3a80cbcd1ed7ef51ed9cfc1cbcd8ad46957b38c3cd9f2c607e80eccc67a","merkleRootHash":"0xb8c505e945f49ba0fec7a252c5973e742b53e410c4413fbd4090df0caa6e87fe"},{"version":"0x00000030","timestamp":"0x3fe9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x82d7dfa76ec23fbf70066ea40ab939d10d7a6d3ec6fbeabcc11725473a621232","merkleRootHash":"0x3c8f572befd55675cd797bb743b616ab15e2d8f9a04887bef06e2452c0c02952"},{"version":"0x00000030","timestamp":"0x40e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5a6edd1adc3a54adc9ddf35871a0b76afdc2ec0303b478a6a5b6467ce6507862","merkleRootHash":"0x7f52c9475acda1680aa5ab892a5d8f8218c38c7a270b5d7fe267c91b896f6c09"},{"version":"0x00000030","timestamp":"0x40e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xde8bf72b2b96cda9bc59133c5491fbf5c61ae119ccd08579fe35c772df30494d","merkleRootHash":"0xd95088d6d77f2750d63db727efbf004ae2d3abcf0b7a9607fb2872c44435d48e"},{"version":"0x00000030","timestamp":"0x40e9ba66","nBits":"0xffff7f20","nonce":"0x07000000","previousBlockHash":"0xab4235b977fee56b820115cd3adbcbdd910f2437c8ec162f792df4bd3c1aad15","merkleRootHash":"0xccbbf41a4b2a30eba8513bd0e81b13000e47c0895f95d72c97b4ccbddcdc7206"},{"version":"0x00000030","timestamp":"0x40e9ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xe3af92e556c18ec621592f3ddaa8a5082acc76a294e1898453df0a29e9a73543","merkleRootHash":"0x330d086a81288de9e65e4641118ddc2cc031f65610e5dfa426b326d14364a409"},{"version":"0x00000030","timestamp":"0x40e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x013ab89d80e6221bdfaffab065834ea587e0565c755039476b87259762c8dc64","merkleRootHash":"0x45bb15842049b18fdd6aa97edb6d49416b6c120017bec07bbe9a2d44af97d03b"},{"version":"0x00000030","timestamp":"0x40e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x01e5cdfce0705a9dd52b1da13da0df462d6e7fd37086028d4ca8d3910dc9dd4d","merkleRootHash":"0x22d0e153956f323da0439d6048467b407c83401d71bf975bac85fe7c00d3c96c"},{"version":"0x00000030","timestamp":"0x41e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x22aba9dc7efd1b7c330a9faa7bcae5ad50698fd7bb80aaf1052155f4118d7425","merkleRootHash":"0x9a421cf4a75a45ea9ffc60340cedc554df55720a5ca6c1e8356856bcf37d5d0a"},{"version":"0x00000030","timestamp":"0x41e9ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2a5fa21dad51e8716d6e8bff04df2a64f13d234872277c7e988245d8a6183c70","merkleRootHash":"0x22e11dac92ffb8f93c42710bb315733d73e19b89d164b4ca3b905b05b286936b"},{"version":"0x00000030","timestamp":"0x41e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x63e6f6d93b51c72efe42581b2beafcbad93697e9042c74577b25b71fc4ee3758","merkleRootHash":"0x6f6e02cc7f1cf1d9f23eedd0eda0e3b731d6580f674f9b86b51e03e40a63e068"},{"version":"0x00000030","timestamp":"0x41e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfdf7561365e6f7850ec064d8884d517106a5eb16f5b4b27ddb28296a1df0d338","merkleRootHash":"0xc3108ca5af94b68811822a21364af7813479ec780aa51900037fc6b4a1b2385f"},{"version":"0x00000030","timestamp":"0x41e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa39c4103840e6c0250616b4fb7a70dd19bc41c88b0075cbd07377daf664ab376","merkleRootHash":"0x37cac4443bbd2c4fd64fb23756c5b8386b1a5b826eeec65a3bac24f6dd247f8b"},{"version":"0x00000030","timestamp":"0x41e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcad43f232ac6baa0ba9a8f9e3a12821b732474962625c28ea19e4dbdb7d55d41","merkleRootHash":"0x78b4563a270a9e8c759335faa0e7eef01388cc462995e9234440db66db3b5859"},{"version":"0x00000030","timestamp":"0x42e9ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc2bdaba3ed32a8341e4fe90ca43bfdabdfb1ddf108bdb1cebc26fb48a7514102","merkleRootHash":"0x686734c9a705d86797a196651a72a000d13f359433731c18a4912501cd582336"},{"version":"0x00000030","timestamp":"0x42e9ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xb742bd04fd3774901d80f1da0acacc34ddcfcd09077e9cd33e634009225dbb16","merkleRootHash":"0x638607aaf92b8b711a3a2389bc2518e026134c7e41ca6412589c202cfa9ccadf"},{"version":"0x00000030","timestamp":"0x8deaba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xe096c315163ae6c8be1894ec722735e330f479ac5c73ecda68dfaa380bbd5d4f","merkleRootHash":"0xaf764b443323343b52b700aaa42c66c4f8483baae35fdca1cd6e5ed900c25281"},{"version":"0x00000030","timestamp":"0x8deaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe2e4d981943ea70a736464faf516a80a727331e32630ba5e1a51fec1ab44205f","merkleRootHash":"0xdb8938b29c2df13b0d28a6b4011c094a31265387e49cdce0caec817cbf2c054c"},{"version":"0x00000030","timestamp":"0x8deaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb75178d12d30705513c583be9df4e257b72832b91a6c1c5827cbe87df66f5513","merkleRootHash":"0xad5a67c86fad62f546488c73fd51e346353a03015ff2ce7fc32f071f81c525b0"},{"version":"0x00000030","timestamp":"0x8deaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9dc2e33b62b5cf5e6961a88e7c065366790cd8fe9ea2bb84a3a779570b028709","merkleRootHash":"0xaa78175edb8b66fc7bbb37fdd632077e6938db012ff65d8508a079dacdda1b09"},{"version":"0x00000030","timestamp":"0x8deaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0dcddfc11547260e55efe508b67328f901264fc8b2a45fbf861a34888a8b0e42","merkleRootHash":"0xf6c409de8f95256f81fa0531b42c8e846da28b3d6e47d7b7137254ccf0416019"},{"version":"0x00000030","timestamp":"0x8deaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1d142010f49f7d6c9afd31680a7da955e52516fa2f19305bebee985ed7669707","merkleRootHash":"0xe92f53161b7659cd8e164f85486903ea19f76b9442bde2c46178223ec031f877"},{"version":"0x00000030","timestamp":"0x8eeaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x81e2075fb444b7fbe1595eb57f85d47ebf6b51f66ce6072d7e02fe45d8b16e70","merkleRootHash":"0x0b0373c60a320fa41b95633963b9a5c219a41b53206e0e1730f8ee7ef292e9c5"},{"version":"0x00000030","timestamp":"0x8eeaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8248d720d7966366e35b20e8bc5b221f1c81b7d3d749f6a0aa05e87d9151011a","merkleRootHash":"0x2231a111f34f915ec97a6898c1c168c09ebbb25e812635d3786414e4041dfa27"},{"version":"0x00000030","timestamp":"0x8eeaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa72ba86647c8a1b8c602bc582b6d457aed6edb4b65d30904d1db32f77f1f1c45","merkleRootHash":"0x824e14599fc004ab1bd8fd355376d8a2bdd0d953fa7ad9b5c5985e9052a32024"},{"version":"0x00000030","timestamp":"0x8eeaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3ed846cdd5ec5367674234e250b75f969f0e5c79ddf1883d471ddbebc017472b","merkleRootHash":"0x75b0415bab5433cd756bde6610f352c514527c2e757a2a799e874cb8919b9ce4"},{"version":"0x00000030","timestamp":"0x8eeaba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xf17eb20e19871af2f8c1b4406ed6cfe4d11b6184013ecf7c0993ba55f4d8c070","merkleRootHash":"0xf91ef26dcad9c6960ed6fd7921f8347d87b4274162f4f017f0fc7384f79cdf59"},{"version":"0x00000030","timestamp":"0x8eeaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x55a8de0e2feb86a9b4df8267e50ebe2217cbdd8f35486f0131e9a25df6b4d542","merkleRootHash":"0x8fb89bc6783480bc3f22f0dc9a870a46f692da1a7a9cfbbc8f66446a332644af"},{"version":"0x00000030","timestamp":"0x8feaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf74a15bae72067b3334fae6aa446061a72a665cb9bfa989f15f3a7cbbb282019","merkleRootHash":"0x416c16feb19342305177c5b7559a01edf7a7a5512acfe598ee94ba1fc182d3cb"},{"version":"0x00000030","timestamp":"0x8feaba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x565d7b4eb0ea095c3d719253d685ac145139db25a797d3e8503bfbbccfe24e39","merkleRootHash":"0x4a562f428366ad6e95786a3cb0d114f0b51c472135f922b78286367f019a8e24"},{"version":"0x00000030","timestamp":"0x8feaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8bd208e568a3dabc91a8b57bf1c68bb282e92a59c594ed0b16fe831b1fef0b0b","merkleRootHash":"0x7b437aed97a12fe6590abedaa72cffc157e1d402d8a1d784801c7e3c62f0b6fe"},{"version":"0x00000030","timestamp":"0x8feaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x71a08e2bb2d5fa6b27a2e25dcc3a42bff83eb863d2753af4d0a0647e222e347e","merkleRootHash":"0x629ed7001680b8d332fbd6ab12136d1c1e67ffa12d54e81c89e49757d19e5e66"},{"version":"0x00000030","timestamp":"0x8feaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x97288ded2137efaf6a588e1f3f828c06a23ce50733327649aff88cdfec90df22","merkleRootHash":"0xa368a3c7b8da4b956afb9c853702a926e375f069443c10cf4b47fe9ce3ae763f"},{"version":"0x00000030","timestamp":"0x8feaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf398b472dc18f33c0d12d41abcd8645cb26a739d526fb736f14264b8ca2aed78","merkleRootHash":"0xdd719ce0018ca38e788f16eafc9bebe51dc7a3f76fb8155351c588238e9d87bd"},{"version":"0x00000030","timestamp":"0x90eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6f2c946d256a68e90b4a60f7b6e2949682bf1a29578f2087920d3917df44e14a","merkleRootHash":"0x9dac847c1d0e66d6fd38f95e1826ab49d5c940dd64bad821b65096ec8d61735a"},{"version":"0x00000030","timestamp":"0x90eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5cd115c973d4fb5058051a4bbd97d67fb7f78348abbc04d7f50648171e8aac6c","merkleRootHash":"0x741ee1c0fa475d21278adcd2e634371cac7cc3735d70254ea00c0f5aad7f73ad"},{"version":"0x00000030","timestamp":"0x90eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x23731d2a92946ec7607933558b52de8ed298bb474f365cf6eebb1593ac609a79","merkleRootHash":"0x605ed5c05e5bd15b17fd32ecaa43358300a610cd1eaddca30d2b560cbe482736"},{"version":"0x00000030","timestamp":"0x90eaba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x1f34e561faac10e66a662d4ca4d91229e589256fec2d75f611bf36432d3e4375","merkleRootHash":"0x4d2d34ba4bcf8e9e788a110432561cf6149c9d90c9ae28c0c74722b5f050ccd0"},{"version":"0x00000030","timestamp":"0x90eaba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x560bbb091632ef9382dbee1d61c236b7dd5aa17618faf458f6cb04a8f979fd5a","merkleRootHash":"0x6937dbab552f1c14870bf95e151c4f2c1cdc7b06dbc5513d43f4adb58daaae79"},{"version":"0x00000030","timestamp":"0x90eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2a3897e334b3ad22af799e7b44ea8227adb7df643d3337e1de0702360014d930","merkleRootHash":"0x2caa4822d00f413a9576ee9be5d0f6cda73127a88da5c39f1068f9ea83b21b38"},{"version":"0x00000030","timestamp":"0x91eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0239a6bce12af5680b37d939d21d3ea4de7fe59f8ed5d7ead56d929720c05726","merkleRootHash":"0xb4d3b0f9eb6246bdff6568ab9dbaabf3d2543b076757ff6c405f48c5ee2057d6"},{"version":"0x00000030","timestamp":"0x91eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6fa3b5988139b97f3e7e0afe7c7394b5544a128f07adbd53cc692ab760fed147","merkleRootHash":"0x8a5568c8b928b5ff7cf7523e56415a2349d69db8eb37c269df3e03c13cba8c8f"},{"version":"0x00000030","timestamp":"0x91eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6713ebef9576799dc03b23cef1773891afac7ceca794a32c12f90d58b00d6a64","merkleRootHash":"0x3e6bbdadedd2ff262f331db47d9a1af7049f6b9d64ed90e097216b1380366c5d"},{"version":"0x00000030","timestamp":"0x91eaba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x47605e0dffe26471d12364868cbdbf775184b00bdb3eb222cfbf9b4a3f9fc562","merkleRootHash":"0x09d66216f18cf6b1e27df65a4dd3453fcc98decedd3adf6cc285072a4b278d56"},{"version":"0x00000030","timestamp":"0x91eaba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x835ee378b48baed53928f98bf31fec7333fd0e3e589bc4df8cf4c510a2547221","merkleRootHash":"0xf7c192d40399a450004a95a2370d4a6354e24e389e83cc1d2764b0f0c3903d9c"},{"version":"0x00000030","timestamp":"0x91eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x5f00aa4cf3afe6a8f60f91da066de1ae21d105b25949ca4fedb15bf69a9ef24a","merkleRootHash":"0x1469d768a461ba8b92e830ef894e7a218bfa650c097324587bb863258d34d06d"},{"version":"0x00000030","timestamp":"0x92eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x180146610624bd431cb662d7a2264b8161c015289d3496052889d7f9b1ee9948","merkleRootHash":"0xe644ec5c97c723fe785664b73408deac16beed4e5440e2f259200fe721545076"},{"version":"0x00000030","timestamp":"0x92eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3a5be65403e7162ae49a9e31eb5f25dd82ae152e22f15445ac5e28de09d93117","merkleRootHash":"0xf655ec01a5ba4c1660bb4724a87d87e0cd4f097811cb914f31d77ed4875f77f4"},{"version":"0x00000030","timestamp":"0x92eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd908e16ed1ba2d000d75a480cbf390c6898520cf9be07e0652fd3c779770b17b","merkleRootHash":"0xc010616af620f5a6a8143502774a9576310860011a6a05de1cd72532c8f0c37b"},{"version":"0x00000030","timestamp":"0x92eaba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x8e5f25d881fe67be0570715a38830c3d5e80a69cdc2a81369a84205ff218d57e","merkleRootHash":"0xbe98186ff875dd7c70001c6242b3d2515bd17c2397ba47a871d3ea0ae662df5c"},{"version":"0x00000030","timestamp":"0x92eaba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x6c3cc8a021970aa64902eb0a1b66d7abcafc753978dcbcdd4d1136799ffa646d","merkleRootHash":"0x8e448e8a6c90e01bf6451428b5e68e2f953f37cac6827954cbb72f64a9fc6494"},{"version":"0x00000030","timestamp":"0x92eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x11765ade6c24b8de2523de9fac96da57666f7e729d08164d4ea0a987dcaa4251","merkleRootHash":"0x73ee59afb5dd4646965d9af41bab35298a267dcba2bf6bd8ad3ad78f356bd9e6"},{"version":"0x00000030","timestamp":"0x93eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc86293b63746efc7789e042718cf0005c8f13c0943e374d1a8d2fb461aa85d01","merkleRootHash":"0x8f31674e2dfb72f1d26485359a5a2eae810c78c3d52ef707a042dd937fcd69de"},{"version":"0x00000030","timestamp":"0x93eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4a4a6f6f0971883464566e83e4855e0cbf7daf014511d1770ba8526d5a8e3f08","merkleRootHash":"0x6b3faad5853dd919495d82b7daa9c3ac9a14051cfc5f42c9c0b98697141ab63a"},{"version":"0x00000030","timestamp":"0x93eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x00c5b16b0547ebeb5bacd1b042517c90b9edc6a061c86a0d093ec86f76e59521","merkleRootHash":"0xddabbbf5f894b29ad0516682211d793e890ed21b9a5f9441915cf5ecc84f54c9"},{"version":"0x00000030","timestamp":"0x93eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x70a0e667378f116c9d661122009c149fa9d7012eb6fa7eaad1366c8c4f547531","merkleRootHash":"0xc4c416db7a6e38ee37254cfdbe7a3bb91b486d5b22178724b6b989b72d835cb4"},{"version":"0x00000030","timestamp":"0x93eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x68a47107a417513a9e37ca8f9014859469f29cea8283264d6c1b1b2c373bfa23","merkleRootHash":"0x94a4e17c6d0fc2e4a3a1557b53340e8d306fac5906d291a713a7532d62f4952c"},{"version":"0x00000030","timestamp":"0x93eaba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x4a504129ecb54277d9b1620f67a6d8fa171b4cfc34bd0b5ce338227305509b76","merkleRootHash":"0xb00413e972303c6d7b0b3056f5f39df75396dc4aa47b5d40179a89c4a1151aba"},{"version":"0x00000030","timestamp":"0x94eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbd5a0723a0c9816b0339b60e8268107e76134f0dc96d198fad6be97f0a79b235","merkleRootHash":"0x97dcdb39bd3802b9abd4dbc58f735f8d45b128e508cd622a7e5487df3d28d3d1"},{"version":"0x00000030","timestamp":"0x94eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x37ff8292a309db890bd4a340eca812efe6d164f78860b18a6cb842fa18862e38","merkleRootHash":"0x22c908352291b798304685f74d315df764a0d38a9e95149ae4fce8639fcb3f78"},{"version":"0x00000030","timestamp":"0x94eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9267920725d3990700cef91602ad787edf2c89d6adf9cca019ac569b938a5f02","merkleRootHash":"0x9750a5cba02b500ba4e3895a3805adb8b5dd4970465068dff4843df0de861814"},{"version":"0x00000030","timestamp":"0x94eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa28db8a52d2c444501162c28f0b38f5d0742a47b8b2080ecc0ce1b5b90adf635","merkleRootHash":"0x38b762ca16fb8c7d216bd5ca4da833ab99b075d0867ed82f60cd026796ef13fd"},{"version":"0x00000030","timestamp":"0x94eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc9d54a280939bbd8bad815711b88cf135f8c1be3b620a074aeb7381e7d428079","merkleRootHash":"0xb8de3cca4d46829f3d1082044f0005ded30382e0f6de75b41c5dd8b0cb10b667"},{"version":"0x00000030","timestamp":"0x94eaba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xf6b76ae269ed30521bb29c1e398dc0291442b8bfcd344bc7ca7108ccf5d2e656","merkleRootHash":"0x3bed8c52ba67561199c4bdd8adeadb0d65563d7e37e5ec8c2fe3a97237d02a4b"},{"version":"0x00000030","timestamp":"0x95eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1c60262bb2cf0e6c6de19d23df65497d3dc0af8e3ecda788da4a80c08c0ad173","merkleRootHash":"0xa653656afc290d4cd3d497900e19bba46adfb08ceeb507a6aed53ed778d89261"},{"version":"0x00000030","timestamp":"0x95eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3f220ae9513e2737e5df721b54680f7f91271145be5c789b3c8f1d2dae7f1c6b","merkleRootHash":"0x4034bee3f6aa9e54db29200b174a28e6f0f33e3ec4ef6b279dd1d2a88bc79e15"},{"version":"0x00000030","timestamp":"0x95eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8312cfca6cfb3efc8d7755ac817de0a8b9b857d21bf354506458c155a0f1dd48","merkleRootHash":"0xd1e4fbeacc1e2d401662e3a329f0a97f5ec62b9a5ee2d90cd03f879e535bbc82"},{"version":"0x00000030","timestamp":"0x95eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xaa006a6ec62e534741e7380568038283290a7ddf2a84b9638b90e335fa2b2929","merkleRootHash":"0x16d104b3e61ebafbfb27c340a4f0ba0447f9a52e951086c0ce6b39cdc2e1bf45"},{"version":"0x00000030","timestamp":"0x95eaba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x1fe386504cb5c55435f3eacca085207cd34285fb3b2d8fb55fa5fcb66ce18715","merkleRootHash":"0x49d042c3335e36d43a323e625b9609b53d681f2155c38bf4febe34039d66d148"},{"version":"0x00000030","timestamp":"0x95eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x01d8b42a2c1a7d5ade707e7097825a8c6114fde29bcd388ebc4a85e32a0d0303","merkleRootHash":"0x03bc862847fe635b41531e90f5a56eca46f0c0e99f57516234a7f9ec0a35915c"},{"version":"0x00000030","timestamp":"0x96eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6c60dc5a1d823717f71d64f9d8fa89243e984948295e19b0d2054d8da4221f6f","merkleRootHash":"0xcfc27a674575a3dd45044c7bbbdae168b0f72088ca12f6259e8a5966e9f3640d"},{"version":"0x00000030","timestamp":"0x96eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x83ef2f8303eb25e781b2aa1c56ecfe9159e6197de50007bed66b13554c33d83f","merkleRootHash":"0xdc2ddccf5c14c2bfd341d4fa18f4f8fb7a70b8034535d43ce7074e09997b071a"},{"version":"0x00000030","timestamp":"0x96eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xff6557c5357ec7d11fddaed13522e35ea4a43e556c98f7f75d1ebb54cc45181b","merkleRootHash":"0x94e9b364791c05327d661a3ada94becbaa3bc677c01a3839adb5cb7d17cfd5d5"},{"version":"0x00000030","timestamp":"0x96eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2b8c5604a0da79d9f514e2126b8300b72b92ba801f0ee2fca22ee18533a0472f","merkleRootHash":"0x6c372ad1eb6fe31067c3c71fa21b2ebeb0bd169670b16381c3eec32e1af6cbc7"},{"version":"0x00000030","timestamp":"0x96eaba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xd786ee354348ef5cfe5da5b63d7926a923a8eaa55b35cbef8e0a1735ec794333","merkleRootHash":"0x69791a62cddaf288ccbde8633104a0739388156a9bfe0dbd2c14e10f0f04b219"},{"version":"0x00000030","timestamp":"0x96eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8889d81dda17f0c78306b8a0659a6215185d7ff650bfd64abbf0ec37a2abc819","merkleRootHash":"0xdb1f254b2625cb7b3fd9f3f114ae9b4db3b3f3cf57bc61a2bf4a948888f8da02"},{"version":"0x00000030","timestamp":"0x97eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xef62440f25d3159024e38073f6a95c664de0d639688e769fbd240b99228f326e","merkleRootHash":"0x0e9cac15dd671fd8c5512e3aa3590067b0a8b39e44af02b17d00b622b33e3577"},{"version":"0x00000030","timestamp":"0x97eaba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x53a80b357424dd314709fb46d191dbd12c2ef7623af7269d1b79d6a731eec81a","merkleRootHash":"0xf3de8ff916a1b828f7f5aa95c74bea274adaa971f1761e7fa4f51801bda32b92"},{"version":"0x00000030","timestamp":"0x97eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd2108ce596747180104f8a82f5caab2885533aaea3614eac6b7f525f989a0a37","merkleRootHash":"0x8b3dd939e9330533641a66f115d02d8407150ba1071ee03f6722199f7d7dab47"},{"version":"0x00000030","timestamp":"0x97eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf5ee8802cc1ee3a37aa0d1b2cb1442c26f971258d371f5091c93d641d045be50","merkleRootHash":"0x46ddd9c5b66c7b4fc1396f9ca4d0798d331ffdab2411f52fd9c6c0c47fedb9df"},{"version":"0x00000030","timestamp":"0x97eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf7c7a7bd49c6e3abd020c7e70439fee6dcb1df442aa8ee1233bd423aecfb3461","merkleRootHash":"0xf753b8d82f738f23d4d2644e2642e7b4ddad4c25221df99b4b8ec57e8087de5c"},{"version":"0x00000030","timestamp":"0x97eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xdd3e39dcf0cd40cf28e1e63c83121b213fb6868044886974517030657d395239","merkleRootHash":"0x36af628f70e562f7f0bfaf486876089a713429a417610547f66498b39e360946"},{"version":"0x00000030","timestamp":"0x98eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xece5d20cbf95ccb777063c98ac7ed3d65757ee108112d9d22b92251d3458d83a","merkleRootHash":"0x2d14290127d1911c9b1629ba4001492aea08de9a7bd3251be914a110476551dd"},{"version":"0x00000030","timestamp":"0x98eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x50928e02ff5b266ce6457a74851171f6d07457e54687473613b8e2b177996c4c","merkleRootHash":"0x370f44ef6ccb629f620d73860e04cee4f293c369c2f1c59a58ab16047b972d92"},{"version":"0x00000030","timestamp":"0x98eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7d30cd2586999e0d4ff80d21bb35fe6960b5bf73eefebd583d8292e2f74a0643","merkleRootHash":"0x02723736dbd0d7a2f45e09169945c0fab674c367471e553d9acd3e3253b99ccb"},{"version":"0x00000030","timestamp":"0x98eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe642dd53630a285ef6967570f1a1c2603d560f4aebe50a85b6ebd7a33fece356","merkleRootHash":"0x42f76cbfa0fc50d20c616434dc214e9e1da01259f0412e03a6653abb9891c7e0"},{"version":"0x00000030","timestamp":"0x98eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xbcf0da32b52ad2a15f00ec218bd4333442fc07933faab3976ea09bda63bc0f33","merkleRootHash":"0xad354f919cf68c1020abb97c3180b1dc8c8e015b61a6fce76f59d8d8adf4410e"},{"version":"0x00000030","timestamp":"0x98eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x91668cd2195abadc8d91a389a74110fcdcf16835091ad49dea68d435780daa72","merkleRootHash":"0xb4a4f57c5de18851efd0f2a9fb3d7a309059e6f60e0a2b1ddd062b81acb353f9"},{"version":"0x00000030","timestamp":"0x99eaba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x030f4fff3fd9849514f2c831ab3ded39a70d2aff1bc3fbd2a12de51130193126","merkleRootHash":"0x09fe7e97885d29278e42d4826263f74a2d9054f7b7abea6b58b6c8cd6f9333d7"},{"version":"0x00000030","timestamp":"0x99eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5350a4f963b187cefea304013ce848244d739e251aa073cb275414984c17b258","merkleRootHash":"0xdd9ac80ca81c54d8146c807884fe60913bef996fb6c863bf0757f801f1bbc1e2"},{"version":"0x00000030","timestamp":"0x99eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5e9c44ea2e18ac35e59d73f9a17447a2fb40d4eaae33e03e615d8e1bd4157834","merkleRootHash":"0x0aeb3bfca02b32386b61f60ae4c31eabe897b89ea3da3fdbb4900859a2b86e33"},{"version":"0x00000030","timestamp":"0x99eaba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x6b7aa2d50a466d6c12f4c239f00075465dac7dc69da77a5c95f8542ae93de666","merkleRootHash":"0x9cb5a4a3eaf68c78094740129752cfbd1d75e18998d0ec6997a2a52464b4b76d"},{"version":"0x00000030","timestamp":"0x99eaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x59faf727d607f68bb2a44b34dec1c0c01a9c235ab28929f5be879a1b68195632","merkleRootHash":"0x9c9d169c94d77c0993ddd24f7eb6b74e8f38a34cf27375fbd8f0d291dbd03840"},{"version":"0x00000030","timestamp":"0x99eaba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x21a0e3c3c3dc75f6b27526ab68831caf32fe77b814b50b7d59974ffc8a2d0f19","merkleRootHash":"0x05460f9496561802778b9b366f54c99536fc6eb1c3a6822849a7b21616187eef"},{"version":"0x00000030","timestamp":"0x9aeaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x070da23933828f1b7208b920165367abb058e409211359e4087ca47cd3351762","merkleRootHash":"0x8a047100b4611294e3b5b152558a56be4ad637604b6397054741d7270ac5631a"},{"version":"0x00000030","timestamp":"0x9aeaba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xaa43acbb75d52a8a0df955bfea5cc446cb80be4e4edc998fa9191a1f447e1310","merkleRootHash":"0x5f1e01c720308e03fd9203cfc8205e64e89c34f7f64c8bd437cfb0c30fe5ca9d"},{"version":"0x00000030","timestamp":"0xa0ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9e9b44b07f587279775605497e064ed5e1ac6369519641a863a49e8fa50ba811","merkleRootHash":"0x5c2d5e5b699c359a3f066b1db181db06ffc1e1d963202cf813d7718a16ee5002"},{"version":"0x00000030","timestamp":"0xa0ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x45b2cf495789271d64dc7d8696e49ac0445734f0dc21ee0a9357db342d962d77","merkleRootHash":"0x726ce45e42bab45805da8ec058ca8e6cd7babb6b37d782016f8cb1e6faa6a4ab"},{"version":"0x00000030","timestamp":"0xa0ebba66","nBits":"0xffff7f20","nonce":"0x06000000","previousBlockHash":"0x29c09aabbb64b52eedfe98dc4f1c7a232188e2a614b6f09b41235595beeee32b","merkleRootHash":"0xe5d040766e2a688db6d8af8fd65aaf65124e3ed63937a2f01c25e612e8f21cb6"},{"version":"0x00000030","timestamp":"0xa0ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x14e471245cd1f3c4f9e6769f90e50e23705591e754b29436da7607e051ff4b13","merkleRootHash":"0xdff831273abedb8c71c9be7231b380ff3bf31564d8714c919e509290608fdb79"},{"version":"0x00000030","timestamp":"0xa0ebba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x68cefcaf1fabff9a2541a3ec125a72758cd408804f34cdd395feab70aab91038","merkleRootHash":"0x998789ef9ee9a724fedbf89b679b846411ba34ff87660f7c03f6efa0b665e3b1"},{"version":"0x00000030","timestamp":"0xa0ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x798b38c22eed7623d66c5684c72e6732e0fc98bdcd64c96454929ef32ef5ae1e","merkleRootHash":"0x435635cdd0f600fb4022a4537f11ac097ca7ed57f13094a0b78599ceb30fced8"},{"version":"0x00000030","timestamp":"0xa1ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd0ec009a01501240898be5b05ad0c3a0d9728ce1c8c87a807edede6c77dcec55","merkleRootHash":"0x32cf839814fd6c9f5317cc9a080f2142b3673bdcf773662d3de361a30ae4419d"},{"version":"0x00000030","timestamp":"0xa1ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb2a9fd8943853a0faf117563ddb60ce951ee9beb8965d94f1db326a5c2a64409","merkleRootHash":"0x8b1354486cca92e5e2d62bd2b055b9e4d9c93a5157e2f9d973b1cf04722eb1d1"},{"version":"0x00000030","timestamp":"0xa1ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8661e9997337646f0373561ec816cff6a6f05453b2da6d38c98147123e60a321","merkleRootHash":"0xf918323a2b831eed94e5ba73f815dd0d45e1c68951a13f40e9328a0eee2d808d"},{"version":"0x00000030","timestamp":"0xa1ebba66","nBits":"0xffff7f20","nonce":"0x07000000","previousBlockHash":"0x1b0b230379ba6e801cacb561e6977e286747e5fac149fed6040ec30d952dfa2f","merkleRootHash":"0x71c4a0c449df0de6fefb9c8442c5ae9001abdadf94753eb76bf4224424b6b680"},{"version":"0x00000030","timestamp":"0xa1ebba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xd475fa79a59d63069e8234c23f90e00a7c5da65e3186e76b74a3ba457d60a64e","merkleRootHash":"0x6caa483d5c12cbd4d1a15fffa3941cefa766e118d98bf789adfd21c9d676d26e"},{"version":"0x00000030","timestamp":"0xa1ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x211ffb24951828b264f9ee833004ef7dcf99e81713c889659b6efb781237e15f","merkleRootHash":"0x4878eb8cc9c798a965ff6f92ef5f8f8ed06f52a6abd68db0d1d088743d7dec90"},{"version":"0x00000030","timestamp":"0xa2ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf209fbd095a944f4b4dcb445fe45502e5ff9efa10a20628d2fa58e5ed2aa8d51","merkleRootHash":"0x38d980c02674b36f854ac30cc1ab5da6606e5da475de591aa10d3935c7424a58"},{"version":"0x00000030","timestamp":"0xa2ebba66","nBits":"0xffff7f20","nonce":"0x0b000000","previousBlockHash":"0x0c7dda734c6591f4db5256f5d3248d4cbc012b7c70be94447c02c32d0870fd35","merkleRootHash":"0x9ad523656a5eb6f01990af8966b1f5ac417080917019d02ce09273b3c1937fc5"},{"version":"0x00000030","timestamp":"0xa2ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe16033d1cb051bf0a093d411d28d7f3fc8ed6e97a2b78972a5a5c047057caf62","merkleRootHash":"0x4714e29a8c6001915b5bb7ea77fb4fa82777d36f221c7d23809598d0ed446862"},{"version":"0x00000030","timestamp":"0xa2ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x80984726d92f5a6caf071dc7116b7b686d93b74cc44980bfabd5db3fd5ecdf64","merkleRootHash":"0x4af46081d9f61a6e6f2b394ed4386f766d9dbb78911a09af2c623639c0b6726a"},{"version":"0x00000030","timestamp":"0xa2ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb0ec281ebbf0f999a7a033c337a9f28688d1997a327fb406997a20bc51df0c1d","merkleRootHash":"0x605db40a8c2ff9b6d5d1a3a5300a8ebbf359003fd32e8fd4aa3a7db23b482b8e"},{"version":"0x00000030","timestamp":"0xa2ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x95547290b59bc3353f301e5a2f27ca922d17d58f3b42f72ade49a179cfa1f41f","merkleRootHash":"0xd984b19e84efbb04319337441d7026189011ccee8c0e431ae8ce82e6d3157072"},{"version":"0x00000030","timestamp":"0xa3ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xebeac821603634346aaf6b4fbdcc4a2f6a69f613f7141d0ae938db5684c5306d","merkleRootHash":"0xb0e15134b0b755f025a1d5809ba258a0d32147c074f7c10931479261d68a832f"},{"version":"0x00000030","timestamp":"0xa3ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x29e4246b4cdef8ae5e04f47232cf5266753215cf395636dddf921e1810e3b219","merkleRootHash":"0x0ac8b1642fc99630d5dbb41eb48363c54683341806b5c1a160f1a1b1581722c2"},{"version":"0x00000030","timestamp":"0xa3ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x17730795615c5507391e9f19fc77da9a76f990e732ed0a78bd2884ce32b1de13","merkleRootHash":"0x4ea49a20a38984d24d83be1d47d544e5d4f287ee5303226d148c3457861a1a76"},{"version":"0x00000030","timestamp":"0xa3ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x78b80af44a75586a805c66ff8ca5a5b84a23a1dc6241720cd6938cd3ab299d3b","merkleRootHash":"0xaff199fba579738af0098cfbe8f4693ff1ae289aec92ced6514d01879d7e8f1f"},{"version":"0x00000030","timestamp":"0xa3ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8ed43156a1cea83bc654d3c2bc88ba2b8ee8beb3178a924e80f7367119f06161","merkleRootHash":"0x4a306c492a288e3e8d5adb40590ba92de74133be26fe6730073c3deb876e6a6b"},{"version":"0x00000030","timestamp":"0xa3ebba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x32a9c3e8f2c40084def0a811b729470bec049a556c565681e1c154cb896fb123","merkleRootHash":"0x91fae1eba77b3d2b96c8579644bb6837aff307641d15569ea28b914c33d96b94"},{"version":"0x00000030","timestamp":"0xa4ebba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0xd3fd2f09f359fba46ea7e39303a2f80467a5ef4692c407a40b3b3e0a8afad256","merkleRootHash":"0x6f259816c37a736765f6d20100763eb478a8e24c257de3cda5f2e99856512a0b"},{"version":"0x00000030","timestamp":"0xa4ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x5b1f25987fd1410eb76a0132a3de20136cacc67aa73a7d3f518a20e36550f309","merkleRootHash":"0x9a8d370a5afa6a43916fb3f39ae1e335d4715bd20887eba331ebb956ad69df4f"},{"version":"0x00000030","timestamp":"0xa4ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x12ac8e4ce0a274fd6d782eb69e012f2f69d91ce0d5b3bec241d3254816d28f02","merkleRootHash":"0xb1d83183057e2d649866e062a0bc8277f7def58bcab1dbaba2becdd338a896a8"},{"version":"0x00000030","timestamp":"0xa4ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x686307d9efe218b415e800ed8d11dbe1041c8e9762d9f2a651034b06f5203d0c","merkleRootHash":"0x72c727d1fcc0e2129bae3483370b7a6d3b5d5bec09d0c1f1d1f01302eb19b621"},{"version":"0x00000030","timestamp":"0xa4ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdb003213f1a110df61ffd7f0d75bc89804177d6e55b7f6ecb1f583a37529e119","merkleRootHash":"0x808bbc27e9adf7f4f978eb24f07efb2f31518a8dbd1ba84c9e59259c3bb5a124"},{"version":"0x00000030","timestamp":"0xa4ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xeb56794a8c8d5d479954a60a48713b8a059f914786ee88839b9145232cdc844c","merkleRootHash":"0xfb7aef0237d7864d06565db939acb158de6115343e222e163cbb2f528c9ef4cd"},{"version":"0x00000030","timestamp":"0xa5ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x02214533f2cafdf8a1350d68ef4b24716f549bf80d9db1ad07667cd410f6e54d","merkleRootHash":"0xfe8d07336f14ee7c9a7eadfc547c807b482ae10dfd1f88bdcc8520a0f37dcc32"},{"version":"0x00000030","timestamp":"0xa5ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1821c1a422de3811270d8d4401b86d30810303ec122b434a805d94b435bcaa59","merkleRootHash":"0xf2ab38b5631380a0f3c564df234a076eb746035b2fc60d527075ffab07a8147a"},{"version":"0x00000030","timestamp":"0xa5ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd8233f2161a22a4d77a05f05174ffe01dc144cebbdd84b938e886a040a6aa02a","merkleRootHash":"0x37e7665d2aa2a9915140f7b0725b54370da6df77f08a23aee3c82189d6518cbb"},{"version":"0x00000030","timestamp":"0xa5ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb39b4865a5f91064c2599ebb73cc5062b8e3728df0b2af24a752ea9a0bbadd56","merkleRootHash":"0x2864758f130f6c9d88e40ff05a9310fc0e9ccdce8d577047679713a7457b1963"},{"version":"0x00000030","timestamp":"0xa5ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb319522c6655b35747edcf86e8d7a60d70ece407ed756e9a269d736b8bc4e641","merkleRootHash":"0x3f34c51f0f5299677bb1688625441aca50ca3a1923871b2fa7ab8e128258bce2"},{"version":"0x00000030","timestamp":"0xa5ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1d74a3fe0d81a87c93ce7b4b55b9bf37d644caed7a18df7fc74c1d5355197a49","merkleRootHash":"0x29dfae39d7b644c530bd74db195b5312cec110657b8bc9a78cac5f7437bd1dab"},{"version":"0x00000030","timestamp":"0xa6ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc028bf2db4db5893eae28889ee3e6629c05b0c53629debce840b275617fb5a38","merkleRootHash":"0x2ff35a54d2ae7fea5c64bd513938929a900fcf1f64d7874c51020e2e7588fa81"},{"version":"0x00000030","timestamp":"0xa6ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xae10061b66ed27267ed325ac990af932668b38b0b6c3e388b743aa8713419d18","merkleRootHash":"0xee77a6e314f59d7fcb07a630ca6cb51064ab996b30fd57737428b25e8154d76b"},{"version":"0x00000030","timestamp":"0xa6ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xaa78c138adadd844b8f1012ac13b90b5aae8025a160694a02f3f8c80da86aa21","merkleRootHash":"0xa2ade95041ead14a8cd43d78129f96239ae0cdb433f71f94142101be54987861"},{"version":"0x00000030","timestamp":"0xa6ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xee1bb9a059b1b33cab7078616ac62694998bb4568a97913856b39569cc416258","merkleRootHash":"0xc21b12bb544ad63f7c0245ce34709b5a1c197a7f60eda21d55415a39a1a64827"},{"version":"0x00000030","timestamp":"0xa6ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x87e538018d4f44d4a4c4b056b125518c71e784bbecc7999d56920426a73d8d40","merkleRootHash":"0xf387562fa46259dd21d4a24dd08310f1827798e9e5d3baad53a0a9af9102ce79"},{"version":"0x00000030","timestamp":"0xa6ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x90ab9dfdb2c61401ae59dc4ea87a15fbd9b0082f6da28d82ca675aa2c6e7233d","merkleRootHash":"0x997892c8ee9dfa910262930195796457549b62247abe8a66b8ee92e00d032603"},{"version":"0x00000030","timestamp":"0xa7ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe90c06b46b697ff4d34d2a129cf63f8188f471fde64a98e4131c5c79e1f1764b","merkleRootHash":"0x2f718c99dbdb7b04509b32722ca570cc0a0481e681272ac0146ba35cfea00c33"},{"version":"0x00000030","timestamp":"0xa7ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x19abf389c29be10582d5ff8e785337f4a8f3f5a3678a08345e1b85c02b2ab94a","merkleRootHash":"0xb7c6e6ffdf0bdaf65e9584c2fb418554bfeeac0386686261c4e1be99e3fbf7f1"},{"version":"0x00000030","timestamp":"0xa7ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x61c66d823675e55bac9e16790076b1c6dac8906e8812446b026140d60611ca04","merkleRootHash":"0x2a4332dba2f814e00056b6518f09fc842402e48de0d7e4edaa9cbbf76412aaf0"},{"version":"0x00000030","timestamp":"0xa7ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x465b7d3b0dfadb282fbbf63feff9139ad2935ca30ab19c46f5822d8075e46823","merkleRootHash":"0xaeedf0b1db2eb4d82d8f8fb597ab16e2faf45ba5c1ca6062be9a8810cbf2ba6c"},{"version":"0x00000030","timestamp":"0xa7ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7f6f1391bafaac5d78467bb9895953806bf7cf70c504329e328e9b59f0956170","merkleRootHash":"0xd31e3ed57bdeb2f194b9eee4c0fe91fca16920b62de4a86d7f336f1444a75b42"},{"version":"0x00000030","timestamp":"0xa7ebba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x344055bcc21560de56bad361c972b8f0af8d0f35a562f1238eba768331efe668","merkleRootHash":"0x6ec118be1f6b90a2f8fa29fd10fdcbac074606d45dc08b4ca8bc99b308a8e5b7"},{"version":"0x00000030","timestamp":"0xa8ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xed5ddf8fe211d0ab7d8a0ee4b93d07c5d40cf72640c2a416d7af99cd8889b236","merkleRootHash":"0xdb57bf393c16156536f45c811b27f9d904463e4a21898376fa01a5bdef7c13de"},{"version":"0x00000030","timestamp":"0xa8ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbb9ad2eb2e3aebda657a795d0534246c7ab64dfac11a2a63a19764a6b450b10a","merkleRootHash":"0x4e90c6ffa1a380ef52b10746daf3781b3deb6ecb722a125e003e6c1f21995a9d"},{"version":"0x00000030","timestamp":"0xa8ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2fec5d3295fa74cd3981267d89888e2fd837cfc580b04db141e6f33f34fd5562","merkleRootHash":"0x47f3715b5de9455a987d1e42752e5c1e43cd596c42d7a2e8a606dab69ed40068"},{"version":"0x00000030","timestamp":"0xa8ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4776c7c90e668b684e1e3ba4a1fd35f0d7a85ed45586cae25738ae124395732d","merkleRootHash":"0x6d1e15bc3c05d5a906cd5ccb34d66d013488e77092ddd08e0a51624f06f424eb"},{"version":"0x00000030","timestamp":"0xa8ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8d63d3469c883440d8bd22bf8bfcc3bd6c2f7c56b3b8d4f5b08af130ae2b6f5d","merkleRootHash":"0x35cc30f27fa2560509cc03831fa94b0f0902c2f9543fd3760bbff73864619579"},{"version":"0x00000030","timestamp":"0xa8ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x464455b7f7f18db3f596f2d6522f34d302cf6ec6fcaa1eb4067812af5478103a","merkleRootHash":"0x1d4c4717cda2732f8cbde010da8bf4b8b4b53af772ffb094dc5a28ca0187b4aa"},{"version":"0x00000030","timestamp":"0xa9ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0270fbdbbbdeb7a53a7d4d0f4271b43ba35955c468318f6477866d6e53e29c6f","merkleRootHash":"0xcfd82415c5a086100e14e36d51d159f030523ecec364b23a3a5c920b0df323e5"},{"version":"0x00000030","timestamp":"0xa9ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd1bb592a1b04db58298405904b50c4d2c8d2a884b563b65b0b14ce0f7bed4010","merkleRootHash":"0x6ad05143b5ed626f50465ec9e7ab4807061ab1de8bddc353e6fee29c9b475867"},{"version":"0x00000030","timestamp":"0xa9ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe1a5d6d09753c75b5bd2471ad26ff0d5d2ad41da9b8d822f1cc6fb575ad36709","merkleRootHash":"0xd1ea42abd513f92bd28d40eed14bc8c4cd4453b684eac5f1102e1227e7fd39e5"},{"version":"0x00000030","timestamp":"0xa9ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfd1d4237376fd0e142f39cf75ee2614afc1a041d0523e62f56074248842e3276","merkleRootHash":"0xb895030c36bb0505bcbb8282715e8837bfdab886fd2ed385135a92ce710443c1"},{"version":"0x00000030","timestamp":"0xa9ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x720141ec83962c1ed9097f0715cc54b4561067682380d8dcdb1ac55a55e8483c","merkleRootHash":"0x5f4d080a1273280aa2962af706de55344308c5af9974eda20c5ea0ecea0495e4"},{"version":"0x00000030","timestamp":"0xa9ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x01547f9af32cb831b395c8d23ae7475893b284770e200cc18f9bb5c50697af62","merkleRootHash":"0xca1e2e7f882d788a97ec11ec3fffc0d9999d98e73d10ebb0428281530001aa40"},{"version":"0x00000030","timestamp":"0xaaebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xbd4d04816f9e1531116d6bcf76af930002554d7e4fc0c158188a62abf94f745e","merkleRootHash":"0xb6dd8d0583187c5566b22b93e9898fe929cadf30842eeb9d48349fda1223a91e"},{"version":"0x00000030","timestamp":"0xaaebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4d64e2e09644230134304491405e4df2fe5d57aedbb751220d21cbef933d0912","merkleRootHash":"0x6f272e0fb13435b5d18a6e674362db73576075d287cbe006f88e5d821f212764"},{"version":"0x00000030","timestamp":"0xaaebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6bceb9dd353bafdeef7f67fa0d482e6605b11b736c1d7ae22ee41de5b00a247d","merkleRootHash":"0x406666b5fb8f72f6473855880aad35261a46ad9da16891f40c0f5319825a247d"},{"version":"0x00000030","timestamp":"0xaaebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x11df99728dc4d1ae1cf32ebf9bcc82da085dbc5cddabdc79d88964fd4b6d0b7e","merkleRootHash":"0x2c52ea713b47f2f58c19ac87418a2fa0bb974603f0c5379b56df5f102ee9d9f5"},{"version":"0x00000030","timestamp":"0xaaebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x99a248bca583a4cee7a58791a42cc9d7ca03fee70f7b79ad81eeb0d077ab0438","merkleRootHash":"0xa57827d448de8e6a7fd85c95c5c40158be49e557abd999378326da25b8d8ab0d"},{"version":"0x00000030","timestamp":"0xaaebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdc186627869146c1be3fa6c399bacc51f32c379346737cc5d5e3d114b981395b","merkleRootHash":"0x388796e5c5bdeb255b4b6c216fc9019472d18aca1d2f0feeb1da9c6c9dad40e0"},{"version":"0x00000030","timestamp":"0xabebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9bdab187ab6dfe274ac2e63642a41a7272f8f409edbd361e4423477e016fbe1b","merkleRootHash":"0xe792d498f73c223caeecf889503767668a48a00f4bad5bb18c807ca55ae4ed70"},{"version":"0x00000030","timestamp":"0xabebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4b4bb98a4c6e8886175c4144b725a553fd8b9aee8268f93e0ff9169e32bb0a5a","merkleRootHash":"0x02867fe902da1cf8bf338779974bceb24134b5d1ef4612eebe1fab371fc5ff4d"},{"version":"0x00000030","timestamp":"0xabebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x583708b713880e0e907fb48689c085c779e051f5c92f863f4e2cf7c4ff764305","merkleRootHash":"0x0c71a1f0ebc5f9a831fceb5f2dd3e4b10b0b87f1eefc5bebedbba460b852cc00"},{"version":"0x00000030","timestamp":"0xabebba66","nBits":"0xffff7f20","nonce":"0x07000000","previousBlockHash":"0xa7cb23275201635b786ed3a2fa328c92aeb1437e7e21ca622e9663c260ed561d","merkleRootHash":"0xd6a3bfc54b5408ac2529285d206a675f255bb0661da7223d966ffd9c05c08c70"},{"version":"0x00000030","timestamp":"0xabebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xff002e4502c20f904f6c67b7a26d5484f8d96fdcece9c5b885e4b97864056e7b","merkleRootHash":"0x1c629785d84c2c41b6afb02c92b69730efc6e1a2cb2f4feb9db168cf5f8888ba"},{"version":"0x00000030","timestamp":"0xabebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x01c7db397eaeb7608fd45c5acb69d3c7335658e33a9e27534e48e6eb2e64c544","merkleRootHash":"0x563dd2aeed0c8d3963d66b76d055167103297c82d8608da75ac29c3739b18245"},{"version":"0x00000030","timestamp":"0xacebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2a02bd5e2cbe9cc6d4318d1af640e4ba55b8bbecae62d8ec56dbd10e11703e23","merkleRootHash":"0x3ec35ae8abac3b2765067d533fa45a7daaea5131b9f38d82ed286c731525a5b0"},{"version":"0x00000030","timestamp":"0xacebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa320adfcf1679b0edb88f7b62cb213ce56c0626a933452c7070597ceaa92d061","merkleRootHash":"0x3dd6c1274c44ca9cd198805aa5d7306398198160d289bf9f51bd992988953cea"},{"version":"0x00000030","timestamp":"0xacebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x023fe0abfd5aac150b3550311dc1ac32421dd7a76091dc89f00dfb76f412af49","merkleRootHash":"0x3d564ed3ef0c6bfc486dd828b268024c428ed4227309cefb27239c5f796b6df3"},{"version":"0x00000030","timestamp":"0xacebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x62ea8023321d22a7b1dd808da99108b002f11acda9376c388f672b9ffd72f843","merkleRootHash":"0x523747fe8faa5470a8a766048bcab0bc3aba7a66ba5356a5c58b18f70d70dd2f"},{"version":"0x00000030","timestamp":"0xacebba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xd6701a5510a4eb37b4f77a66dc45eb04f01950d03e2081f4943a6b1db8bbd41f","merkleRootHash":"0x6387e37af29b8fe3ce8d00d92cf4d069b6ae2c92132e07b1105d0359ae32829a"},{"version":"0x00000030","timestamp":"0xacebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb3f3013bb971b59e4941c3b8cf541dc4545b7b5b82bb0804bc15eaf19c4ff637","merkleRootHash":"0x8a96cf1a3534a7792f9bccf0facf4cd4577b0d42312c753d7c30ef2393bf29c1"},{"version":"0x00000030","timestamp":"0xadebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd271b97e4fcf7ab7163e64649441f6745433d7670a0028f26599241df697257f","merkleRootHash":"0xa567efc335031d004254978473a4ad64ac7d36b7911b40ade127e84af0c3e3d4"},{"version":"0x00000030","timestamp":"0xadebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x90b8177386f1d8f06f77389fc41e6baa9721feb5cca3f057b753cb27a8083717","merkleRootHash":"0xb99277081001f2e3d0b04410f4e97ec05868e8738ac902297f7c4af7ffa676ec"},{"version":"0x00000030","timestamp":"0xe6ebba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x1c3fbb78363138da8b4aab7614a7e7f3c80db47698a441fc48bb35c75a081107","merkleRootHash":"0x787e37cda6815c161c5dcf2cec5a1147b91c01594abe1b572f00024c92303f0c"},{"version":"0x00000030","timestamp":"0xe9ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb8355878b317b6ac2f6c83e439f58cb66757b0557519750f49c2a02d52850a2d","merkleRootHash":"0x8ed08a487ed2c7a03c7ad0c4e97e890140892da715df55ee4823d90127df0e4e"},{"version":"0x00000030","timestamp":"0xe9ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe31ff604ce8fa9c6bd14319f895e50c4bed6a20b82dddb51f248862330cfca55","merkleRootHash":"0x36654ceef51efd8c5acc7a2bad5b25dcee87d644a42a8a4faa207ac746047978"},{"version":"0x00000030","timestamp":"0xe9ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x0fad47071df816bf6234fe3b2c3f95fe90f4e48bdb0af09a5c3ca88c5a09717b","merkleRootHash":"0x31f05ce931108a42f87a44d9855870422161f70df0477ba91cf999fd267739f1"},{"version":"0x00000030","timestamp":"0xe9ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xe4db605b1d25da77dcd41d01eba2059bf60751f52809868826cbe497b78e7710","merkleRootHash":"0x285687bfdf9fc368d965f45f43663c9ddf761f26c3f67da3dbc86e1e0c6250fe"},{"version":"0x00000030","timestamp":"0xe9ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xda75be5f9b7829a8cb775ae7d7dbbf2ca9cc4c9c3d6b808f79d10333e16b4100","merkleRootHash":"0xf6576c9930595cae527b82fc0daf0b9259bc433370b302be65295726b0237bed"},{"version":"0x00000030","timestamp":"0xe9ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xdbce9ffe652b419512d6bc585fb57839e4ca6d7a380308f94d6b27b63556754f","merkleRootHash":"0x96e419b7639ba81cb77726d091abbf7cd3dd160de51626f9464c6848cc19f977"},{"version":"0x00000030","timestamp":"0xeaebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x9b4cb77520a4b04b9a7a40afd6e92065f91a774a07be87662ae51719929fac3a","merkleRootHash":"0x46448281d98fafcc0ebf329dfafb003da019aebbf4cf4d0c06ae7b07a29a6264"},{"version":"0x00000030","timestamp":"0xeaebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x167ae06943f085d50befe2d8ef411c194b7d28267f0569f565e77ee0006e2827","merkleRootHash":"0x0a15224ca9b3825598ec8915952e18e0bc72781b3138727cbed1ea83cc6760a8"},{"version":"0x00000030","timestamp":"0xeaebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xccb9d6b54f7ca805722e57ae6326fa7201bfb724e475afa8b5c71a6c7834010f","merkleRootHash":"0xb967253810225a6b25c4540b1e6a614728b641f2c689e468db047d9a02731635"},{"version":"0x00000030","timestamp":"0xeaebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf331b0c808d7321c1cca056b9889bee1605c3b7914d381af5f129569f519ac6b","merkleRootHash":"0xbd1eebd6f5c4ffdd202626b283cd79464f5c3636c7d81c2e97d02c70cd6a2eaf"},{"version":"0x00000030","timestamp":"0xeaebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x62cbfe8b316fe65cc6cf86d4c498f619036c2b4279aaa11a5454a1587730e626","merkleRootHash":"0x9020de87ef57fdcb215efca6eda7a4f8ba8ab52f0bb60806bd618adb6153749e"},{"version":"0x00000030","timestamp":"0xeaebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0a5b6d216789de02f1890d728b813ea44fa9fd047eb1ad83a9f29cc653d16413","merkleRootHash":"0x42d51e9427a328f5478d0b856694e51d7f3a9628eb4cbc198e6a4b350c23233f"},{"version":"0x00000030","timestamp":"0xebebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x55825837d6396bb87ace72502c3b44c3ba00ddbe4bd0b0d93a646aa1ecfd9a31","merkleRootHash":"0xeffbc3af68b5765abed01ab2054add8c7741beccadd54db820a8c6d864980906"},{"version":"0x00000030","timestamp":"0xebebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x73d24a660329693836c4f29668685b2fa58e7e967eaee95392ae8244ef50d453","merkleRootHash":"0xe507941ddcd330f3de7c20e982cf2a61629ce6bec3d67dc9ce013e2cdd1078f1"},{"version":"0x00000030","timestamp":"0xebebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x854cc6387a0fa1a0eefdc7fd92231620adccff185d0e8cb760bf45a8da79e066","merkleRootHash":"0xd19b8444be387437d3edcec0c2e216c0595aea3312a794f34f02ae319a9eb3a0"},{"version":"0x00000030","timestamp":"0xebebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xbc5d894a59f1c75a87dfc544b87f00cae01f1ea47f9c31e1cb9b6ef92c121411","merkleRootHash":"0x04a9998ad462964960e7918e455ecf0b714bb466fb64a13153966ff04c31c4d0"},{"version":"0x00000030","timestamp":"0xebebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x585dc940fbfde7fefc9469776f4ecf68b854ee467a565d35fe96723b82f0795c","merkleRootHash":"0x6b672be2eb7c80c8a9088a9458b32647da904373da8206491ca7192841150070"},{"version":"0x00000030","timestamp":"0xebebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7f30d8a78ebca336962fbc65c6d88cf405e6185492eaa7a503287d0f3298c36a","merkleRootHash":"0x14e5cb1664fc8ff8254877b3a770ab94e5e28ca9db531cd4963f08cb0204e657"},{"version":"0x00000030","timestamp":"0xecebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3a88f16071103ea6cd3f657907bc30661f2a87b1e655ce9d90b2f85b8849256f","merkleRootHash":"0x94385443907ab5d5f1914acf9ec635f994d09dcd84b6d5d99820c16c711c6c56"},{"version":"0x00000030","timestamp":"0xecebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf949d4520063b0859b5bc6cd43993899269daf2ac36e66b0dd7e3807119e683a","merkleRootHash":"0x463bae76df73a960064610526090a4f2400b2915e1c95a09d172661df506e584"},{"version":"0x00000030","timestamp":"0xecebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf19a12a5e8a39c18e995d193a4ad314c4901cf0b7699dc2f995d211fa979cc52","merkleRootHash":"0xc87eeb1f92fb0f69326550be62ef19e45b101e04cbc23fba14d0e9ff7609845e"},{"version":"0x00000030","timestamp":"0xecebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf78f1ed4e978604b3b599ee447b6b24d8c1b36531f6e9244d527273317437e5d","merkleRootHash":"0x3fff3e667d6440a4c294f8496af7e7a744f7dc790c30162feb77bddde3d2d15e"},{"version":"0x00000030","timestamp":"0xecebba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xc5e6c40ba5e3d960076aebbc313d6e2b4179341b33094e2a777cc3bd5e15df0b","merkleRootHash":"0xda251dc02fca9c64dc793275ef3f69fa6879a41938fcc52d32921ae047931c0e"},{"version":"0x00000030","timestamp":"0xecebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x4fd0cec76ce2fbd53f79443bbf408ec2623582b7daa7012bb36fb872171aa35b","merkleRootHash":"0x94393c730fc0c82e4f9beb41bfde0936ecc5200bba5d9bff14e271dff121c2d5"},{"version":"0x00000030","timestamp":"0xedebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x287c1e56e9119ae16a29e733bb5beb2d152e0d2fa5730e9c2837e5dfe0e31045","merkleRootHash":"0xa57d96ccaa10a3600fccd7c14afc36401346979cf09159edf241cb4aabd6ddc7"},{"version":"0x00000030","timestamp":"0xedebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa372692a2b7ecfec44a39defdfe0bd02edeeb4e20546cfd52e4db3d92caef423","merkleRootHash":"0x310ec51bf317e0dc19951845d6412f62a8d0000e63b0583be1f8182e3d14e075"},{"version":"0x00000030","timestamp":"0xedebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x14a3b1297d41fcd998108c4e5684286c8fe646ccb8a328c84dbd93c5dade3a2e","merkleRootHash":"0x12ef92104fcc3e7db185ffd54c9a315879454fe355aa4b2515e43854fc12c804"},{"version":"0x00000030","timestamp":"0xedebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe27dba071a5a90fc40b7aae80a6eca46e17d9312d2bc4e06dbbd5c4cb903620f","merkleRootHash":"0xb069025eb947bc7e42ea2a4e51a319703725a6cbea454c4909a26daa4278068d"},{"version":"0x00000030","timestamp":"0xedebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xe4646b4f050086f8e83d9236b02a68b40e7bcc3730dddb6f61033cf16ba18c61","merkleRootHash":"0xac9c7b3e0842545601bc9e1576765d9ba7b151bb9afdcba2d781cf4d22cde13f"},{"version":"0x00000030","timestamp":"0xedebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd12a65e9d5125fe7d2ad092a581b2d6d91dd04380adc295d3088eb0b25073228","merkleRootHash":"0x143aec1a91eb756e4a55a7475ff0debc4d2586369fa97112ca2ea1cff26ffc02"},{"version":"0x00000030","timestamp":"0xeeebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xdb7ddb8884c685cf65f70df07fb894bf58ae7ffb79b08848fa5c77e4f5490832","merkleRootHash":"0x9078cd51f783f9fc951ac269eb1aa0f0c94786ee295c070c4f86a44d989399e0"},{"version":"0x00000030","timestamp":"0xeeebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xe0ad0878241b1f1026cc642e6e299d9ba8164b689d81c338b1ae430ba9da0433","merkleRootHash":"0xdda4d0daed2194293c1aa2361c2e111473ac7d538975ba31ad44e731c233a732"},{"version":"0x00000030","timestamp":"0xeeebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x15d96c919acf47f0509d111447ed71e7b1f00abe77e104330cac4a1049883377","merkleRootHash":"0x0f29b0ea0a13118f20699cb5778c585cf8d039f631862c916da5f28cdc313ca4"},{"version":"0x00000030","timestamp":"0xeeebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd94260019b2b48efa75f4e4404765f02d327fe322d677fda33f86513f4fdde4c","merkleRootHash":"0x01cc2797a211326421a4eb16adce07508d8c73b7a4c2b9a3f4dbfb2a9f25f633"},{"version":"0x00000030","timestamp":"0xeeebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xad65d2db211a270c4206c6bda4183e9a1bb92ca496b03177f72efe12eb9f7715","merkleRootHash":"0xe9d3761dee9900322bb8e1bbe4bfc8beb961fa55cb7baad68d0de97e9a10b46a"},{"version":"0x00000030","timestamp":"0xeeebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7183dd2206c122187b0052614388778f25f7098af18f03dedeb75533a61eaa0f","merkleRootHash":"0x566d7627d7d2f4a9d2579f6935a148a3ac24ae9f09bba557040c583a93d89619"},{"version":"0x00000030","timestamp":"0xefebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6deb6acb79ac7d41ee9ac7d6422ada0edfd43b960263b4e069cf5da27545356a","merkleRootHash":"0x91e430b88aa1ea080c9006c35be519daddadf308610b34cc27666caee967dddf"},{"version":"0x00000030","timestamp":"0xefebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5347ee619087be5ca7e39db8ff15873e071729df8572b718cbb8aa8a58088d4b","merkleRootHash":"0xf2eb72a40b5068ecf42fca0f93ba83a9d9a3f3de042b8d9bcd8a15e665ace160"},{"version":"0x00000030","timestamp":"0xefebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x342523e668f5a6489b695ecde0350696ff1db33fffc41aaf06369d9432ed9703","merkleRootHash":"0x9c5e018ca0d9e9004821622f6f46ca091ce87a760716784265395ee299a92745"},{"version":"0x00000030","timestamp":"0xefebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x18f181e864a3b199997ff9d74eee87db3c29c03deaafc76af94dfcae7848b938","merkleRootHash":"0x43fced880bd741021e863cd64d6bc2920ea50b9297b2efb22f7639b70267e120"},{"version":"0x00000030","timestamp":"0xefebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x659c950cbeef13ce4b6364430f2aee3095cf8a566463ccd51ac0332b9463b73d","merkleRootHash":"0xb0b93a6e37f9ad68d95aae8ef2d5b31d5bad6b9b340af0fb03e525d1aebcb051"},{"version":"0x00000030","timestamp":"0xefebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc5c255b0b8d832e27849a6aa370f43d6a3bc1b7f666d94666a097d5dc861e919","merkleRootHash":"0xe1f4a0cfafaa79045d9216d1b71ff5dd83d04c3332c3a7713b4e10f0839deef5"},{"version":"0x00000030","timestamp":"0xf0ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x614f8c9171cdb147f22c91496fefd966dbbfd0f447b04925b19ba6057d7f993a","merkleRootHash":"0x5ee147ebf6ca83373367249902b1203184bce9fa18e1e89247f49b0440356627"},{"version":"0x00000030","timestamp":"0xf0ebba66","nBits":"0xffff7f20","nonce":"0x07000000","previousBlockHash":"0xdf60aff5a5953fe4bfda9ab7bc70004ffdaed8d92d3a760928bbf1ac347d5939","merkleRootHash":"0x1b64828eb80461ff0c50fb6c849b4fb0d1bd4a83a69bdf50a76e1763019e7d2a"},{"version":"0x00000030","timestamp":"0xf0ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x087387206904fa944faedb1c25933686ecbabfb9483c72d01f1604f1e7b16c16","merkleRootHash":"0xe30b87fa1e13155d43ec78f495348cac180a6c16b63935dd7f46ef2232d654e6"},{"version":"0x00000030","timestamp":"0xf0ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x76852df37fe6bf686f7a9ca591fb85ab590c0a00a87eb3a37953dd52e1fe0f76","merkleRootHash":"0xa6292e81381623949f6b2082d1bbf04aee728002a543b9060477ce202b831e6b"},{"version":"0x00000030","timestamp":"0xf0ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdc4b4af4e11d28d7ee3cd1ec02a7cf6a0e9cf84b64a18bc72cb3e519a20efe79","merkleRootHash":"0x64b84c3102e6995dd9012e2cc2a5d83b5d87873208689960aca64664bc7edf38"},{"version":"0x00000030","timestamp":"0xf0ebba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x387fb70b6b473bb1e3cd1e93bf7a1740b24ff091ba319ef0ce1c9f73f3dce072","merkleRootHash":"0x7b5fda58de36f840a1b01f6f70acb48dad981117df5a07d91503506389c5f5e4"},{"version":"0x00000030","timestamp":"0xf1ebba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x2010fdaae975777625f4db0045f3ebb4dfbf11a1a11aa361b189a8d32362713a","merkleRootHash":"0xfe69e32de8dda82603e58266cbe537f3cf4a6d7e29e655a203df242a02a503bf"},{"version":"0x00000030","timestamp":"0xf1ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x1dc3ee7cc392869a8a22ebb5f59899e205c7e2b9279e1314f503b997791d3b64","merkleRootHash":"0x9840368b3df54427de52fd0beb1b19c5d2fab74f32343c3b6f3928fc249d3821"},{"version":"0x00000030","timestamp":"0xf1ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2df64e521ec2fae0ef6bd3ee9b1393a6c67da26e49ec8d2644d29a11b006e267","merkleRootHash":"0x672a00b0f360519187217e49093341b19c4be9bfa8a50245465bfd4230c40260"},{"version":"0x00000030","timestamp":"0xf1ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa08db93e28118aaedec3f44e87471be58e9973d44f853a6ddd84b8a4c7900e63","merkleRootHash":"0x9b672f4ba963b301c15840da4f0ca47e82e538500b2b08c6911657ce622b3536"},{"version":"0x00000030","timestamp":"0xf1ebba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x4d4d4979c776d3203e85da5ee476123867128c67d2f6166ecd9253fd09de5a42","merkleRootHash":"0xb63a1feb73951f909f1843cfb9b5d74d2224dc2e145669cde732d2562167d92d"},{"version":"0x00000030","timestamp":"0xf1ebba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x4a78c9cf67dcb31fbdd51751d2fde8ab6e284fa8ff19c2bb4dcea95a827cf052","merkleRootHash":"0x0d66dfe82300d5b5e14c71a395c9a0fcc7280439422dabab9cf56061ee9cef08"},{"version":"0x00000030","timestamp":"0xf2ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x527fae0122c7ab0719307328061395813a7d6549630908356011d36edba9854c","merkleRootHash":"0x305c1eee5c5df08af65234d4e11d1b764f2db9271cc781db567019b944753a90"},{"version":"0x00000030","timestamp":"0xf2ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x06af9cbf5a0b3c18b11fa016d1ffbccd4b129c132e283255bf82ddd6e0fdd765","merkleRootHash":"0x786338f7a866eb2c824f51d3924ae7d5dc8c03f3cbe250b47943bafb5b7dc98e"},{"version":"0x00000030","timestamp":"0xf2ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa0d8521803ac2b5b160716e4523bb2f42f31ec37838a58cbdf4f792e6ee24211","merkleRootHash":"0x77e6132a0a614d18947d38fcf52949ea9632166388de309bf0cd63592b1683bb"},{"version":"0x00000030","timestamp":"0xf2ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xd8510315060381f8d0bd0c541796b53195ccf2407bfdaa6019f7c9694a577d6f","merkleRootHash":"0x2210847acf80a30552abb29bc2b6bd29b9c1831293a415bc2cd24725147d1a83"},{"version":"0x00000030","timestamp":"0xf2ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x7923a4da7f902f41cccdc43278524d582629720f174a8a9552ae83ec348fe56b","merkleRootHash":"0xe1848750951a9303824474f0427dcad1519fbc4e6fc27db9a1560e6705e4abc1"},{"version":"0x00000030","timestamp":"0xf2ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb6106e58a2166477da4b4779db99c06576331cd7fc744551c54aa01676f3ad7d","merkleRootHash":"0x069fd2bf381011ce4be44894171d49e98252c41f312c0b2412b66d817eed7556"},{"version":"0x00000030","timestamp":"0xf3ebba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xb45be80686900778357d63ffd8cc1304b63736f9d4a9792e2dee9dc2cd3bc274","merkleRootHash":"0xc41f9010261b8080eb55cd6ad6b5a0f5a29b6f50619282c2b73720a424c343c7"},{"version":"0x00000030","timestamp":"0xf3ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x3a0e42cecc0cca412f55b70faec548a69002d9d88704a638a2646cf9156e7b69","merkleRootHash":"0x866195b6b8d73a71a2458f7d7acf011ab3d14e465c369a698f8e3e4e20cc1362"},{"version":"0x00000030","timestamp":"0xf3ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x366d38af1b8f2cb7f6ef637c45c4f7ac110e8825d15958c92648acb05c166f61","merkleRootHash":"0x15a0c8b406217711c08756aefaa0f315c6c40e461c3903a2f7e2dca369180883"},{"version":"0x00000030","timestamp":"0xf3ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa4fd6ae02af47918f86562f19dc73a4ca3d2e9804eab9c016cb230efb2296e79","merkleRootHash":"0x30714cb8d854929485646b6dd080c394d813d243cf1e7999c510615890e7d7a2"},{"version":"0x00000030","timestamp":"0xf3ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0e758dc080ddbb24cd2c3eb70bbe373ac7ac491940b1cd70645f9add8690575c","merkleRootHash":"0xbcc2fd2e745a8eccccd5e76d803413a53111dcab4a16308123274c988c3b4183"},{"version":"0x00000030","timestamp":"0xf3ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x08056067ec69b2761fca2e99f2a4f6d086a37e8771b00d0018a286587ae5753a","merkleRootHash":"0xa560e48c52e440b3bf61a63635085e621538f55a023dbfc703cdbcb5b9baff8f"},{"version":"0x00000030","timestamp":"0xf4ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xdd9968f4dcf96b8997269b6132202984264c2661f2b56cfc354388e2df975e57","merkleRootHash":"0x5b58534067efe938faba33b0fded2b3de7c9b57a8f36afaf187a613a7e6faa6a"},{"version":"0x00000030","timestamp":"0xf4ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x756ce3840a2663a4ecf6cc5ccb8d7318ac151a94b63ab52034828d8e4c6a1618","merkleRootHash":"0x7650f85778e6e85622c69fd08e00f21e0ff265d58e25f014285f94dfb2383c93"},{"version":"0x00000030","timestamp":"0xf4ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x625a99dee6b05bdb9efc6d46a5dcfab488d724589de004551a554958c2f5ac07","merkleRootHash":"0xfa35a7bc684fcdeade5a5ccbc4a4b020de79bb202453d453bd78e1c3b26ce508"},{"version":"0x00000020","timestamp":"0xf4ebba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xd615f6a9b2aad951c4603a20d3d21aad99d871f894c31b132c39ec94cd787839","merkleRootHash":"0x2b672420ebb4e7a2d8e3fc92a9ed0202bd6e2a0ae5019c5cc7bef8e03b112a87"},{"version":"0x00000020","timestamp":"0xf4ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x00f007f0db0fc47b10e34b96acd18bbf7392d3be719715df5d7d88348c393c5c","merkleRootHash":"0x824cd61f232707029bb4217d73353efe67e3c89776b2e4054829e5da60584a92"},{"version":"0x00000020","timestamp":"0xf4ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6a4f7fbe45009fc41f93c05fe8248710579052d740ffc4cf86fd7abdd15adb15","merkleRootHash":"0x4e8d8feb2ddcbf7a2f788be523bb4a3e01d036bc2c036100dce9b5194528fc30"},{"version":"0x00000020","timestamp":"0xf5ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x519495a8363ac9f91976944b888b9892f62c9a3bebd968f3a0edf1ddcc57621f","merkleRootHash":"0xb02ef7554d83fd33dd378fdba3571419b9c20c10c6ddd2f247945c469338643f"},{"version":"0x00000020","timestamp":"0xf5ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb89e4cce2ae0a947f3c44c750ed11da7b51322b38eaa4a5305836d0a01d73545","merkleRootHash":"0x274969e1b723a852af6fa291fc05e9f4fd2e9d1e6ea0378257593c5a331d9c2d"},{"version":"0x00000020","timestamp":"0xf5ebba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xc4747f6a86eb68c99ac64304943f85fe5c9fb95c49ba20560d0733b171c47b3b","merkleRootHash":"0x688e21d9510ce386b1ff323a33a2edff2f0609bfc2a6de3566b0d8fff05244ed"},{"version":"0x00000020","timestamp":"0xf5ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9867f7ec0d9472dd7fc90fccbf97242a34eac8754d3382ccaaf0a79f7abe9606","merkleRootHash":"0x5cbd6893fca7948d137898e6ebc04467b5553253ae30801d92c964f961bca358"},{"version":"0x00000020","timestamp":"0xf5ebba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf84d2919f474bc940a16e460903e5f2bd36d7a4f9a2fb60d1125a0e6b7432925","merkleRootHash":"0x0d401534a860ce6ee469ec28865341a38ba25c577ab0f5a5a1061123d86e956f"},{"version":"0x00000020","timestamp":"0xf5ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x5a5ac955f319c1fe87fba052d0d1715dac523b1f87d87d104258d2c1acb55d16","merkleRootHash":"0x710255cd047cb1f960db8508751d37b505b5f3a67aa100c15c1e8ec6c180a9f2"},{"version":"0x00000020","timestamp":"0xf6ebba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x674bdd82a1773a7c287e441c71304d48a6b3dac64d62a2b933c5ca3feae0cb58","merkleRootHash":"0xe07c09824ac39754bd0a1dc574418278064636365487387ba9462cea9a4820b1"},{"version":"0x00000020","timestamp":"0x2cecba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x1feb0fed621488c252820f3267ec4bb1c45ca18e26b9efa5240e61a6552e5239","merkleRootHash":"0x3133d38721c790b260ed0aea1dbd6d7eb630dd068625042c26282fbd5b3b8c72"},{"version":"0x00000020","timestamp":"0x2cecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xd12c2d2d8a1dd680ca2f231c3fc2b2d29a3a134c650105e5b16f8d890c75c212","merkleRootHash":"0x0fce06509958c2bfe80b95fb0f43dcef2ebb7b96e5439a4d4a2aa023373f320b"},{"version":"0x00000020","timestamp":"0x2cecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5290a2cb0e7a046b6b997e2d5c95ebbc97fbca7ad809901bab822812e9f7c10f","merkleRootHash":"0xcef0819010e7ee4d739a8fb7515d24582c825fc6efa5f22151f913391c51bdbc"},{"version":"0x00000020","timestamp":"0x2cecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf93c8ebff66af34cdb43b2359c69239b2fa683dddb5f8754b63362c6e471f365","merkleRootHash":"0xc6a8ffe04916da74030a58bae720d1f4af6810c9db2e9e1d55b9fdfeb9449717"},{"version":"0x00000020","timestamp":"0x2cecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x139683c073d10d4876a5a4ae1858705c1973dcb410d6c92f686b515ee847754f","merkleRootHash":"0x441f7db840dd80632b812d5f620e8263807212928ed6cead0a7a67961bcef016"},{"version":"0x00000020","timestamp":"0x2cecba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x285521247d04235aa0a08a583de6d88b01a1bab607b4e86d3bcc7051be12783d","merkleRootHash":"0xe6512e90522855fb95bab97b0a6cf7ffaf87e6e7f530ba0093cd4b459bd7c51e"},{"version":"0x00000020","timestamp":"0x2decba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x6ed6bf773932955d880340407c3e2cb6199616a956cb274d8bb2b2164e153b4d","merkleRootHash":"0x23f42d24b978e98a80ff83f2af64a2b74a04e5f48cfea5f16f862dcd618ed353"},{"version":"0x00000020","timestamp":"0x2decba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xde77dcb45d46f0eaa1c2e3904db7ac08b6edf1aa92efb2c61cef256b7ed2b406","merkleRootHash":"0xadb89c2f776957614eb2c9258a049cfdddf600446c2abad5c2b36dfae76873b1"},{"version":"0x00000020","timestamp":"0x2decba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8006ac3609394dde8f31ccead75f0e1d9cf7af620f95832a0a237a86dc5bea2a","merkleRootHash":"0x62a3c0fadad873d3fdf5d15f607aed7c3d22b254665c71a2e314d61f187e2704"},{"version":"0x00000020","timestamp":"0x2decba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9f19bcd736a9415bf7c49989fe0c44d0b0eb90aba8b5365074f18fa81f31fa2e","merkleRootHash":"0xcb5d2f43d090a97479c5e3f0638f076588d187009f71980aef37d4299f592e4e"},{"version":"0x00000020","timestamp":"0x2decba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x47dd2c3938c6e2f0d76a97040e3c81eb4280d7ab2319c63c85ee3d64a13ff969","merkleRootHash":"0xd72964222c3c534ba4a0f441799b8adfe6251fc3f6f6c7e2f8c0073e9a4ee068"},{"version":"0x00000020","timestamp":"0x2decba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf0c9d20d573b536492ac7f4eaae2f9cd9be68ec1c593e80dfcb6e67658917d4f","merkleRootHash":"0xd66db3e91a830be392ced445b67f87dfdf07f6af46027454bfdaaeda0aa7d10e"},{"version":"0x00000020","timestamp":"0x2eecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x7c4a55b7629a0a433691bad0b5ab59ff74beeaf07bdafff9a45a39b59dbf7971","merkleRootHash":"0xa4c2b88730353ec9e009da9e1192ab8b81b23b99c7ef7f5779ac0910393acf8f"},{"version":"0x00000020","timestamp":"0x2eecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x7659fa7cf0288af20284cc66cf55d4790f5680ffad239b0d6256be31cb6a817b","merkleRootHash":"0x0e01179d402e2262918e8f65b43aaca78aab37d9620d20225902aa2144d3a473"},{"version":"0x00000020","timestamp":"0x2eecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5e0bfd602ca76244d90801f3495eddc0f4ce72f76567b9b83764ed1443ecf95e","merkleRootHash":"0x90cae0e4b71f1853a22c5e2f010affeb8db2d8ac6c27e15e4e07a8755d6cb7d2"},{"version":"0x00000020","timestamp":"0x2eecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xcfea2a1c83e3e7e750c14408659f7119b31b34279a2eb6f518ed6d0a79966b0e","merkleRootHash":"0x7bbfb7f33c9f8a8dfe7366ac807010e67d25a6ca4bdfc5b29ee7e99089e46969"},{"version":"0x00000020","timestamp":"0x2eecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x31384d07a475b4eb4edef72ee3e0931eca6a8eef8acbb4ff2516f504733e095a","merkleRootHash":"0x7b0d8ce3fba4bedcfc8a989b2bed682e581bf2e45a557a49f2ff0f88a4ac4f3a"},{"version":"0x00000020","timestamp":"0x2eecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd3fde1c1a05258a1e981f70eb8c019211d3a4dd4e004ad80a61894292df98c10","merkleRootHash":"0x89fd6b8794bfaa0f64f733a9f129aad730a58a0d3499d67c0f2a0626df13a448"},{"version":"0x00000020","timestamp":"0x2fecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb88c1047d452cf250353257a3205013524da904afe0187545aada5e0e3d69f1d","merkleRootHash":"0xe9077539d14b2fccb5ef21ccc46d1e1346a465787f67d6bfae04519c70cacbaa"},{"version":"0x00000020","timestamp":"0x2fecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xaba783219996d4a62758f42460dd2f51af52b9e95a562bff073930c6d3934f47","merkleRootHash":"0x97ec859593251d7ce1d7f5cf1658cdb0d21a39e7a3aa098adb6934cc9ceef76d"},{"version":"0x00000020","timestamp":"0x2fecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x600e24ccf5f7a725eecd44fba07f57e9ffb7cbee0370aef013bd49d5af232018","merkleRootHash":"0x3bb4dafb4291662fbde4fd31ea8b6c6e4ba3103940cdbd8d59a9598fbb49b047"},{"version":"0x00000020","timestamp":"0x2fecba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xed6ad26764ec9ff986bce8290b3b3efb6c3b277ffd86eec4c0cea92aceaea705","merkleRootHash":"0x8efa6399e86decae6a416311e7493086d44f663f287c9712db4b611f24024774"},{"version":"0x00000020","timestamp":"0x2fecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2a06139f4ca60d1150d4f780ba1c85aaf74868dd7a2cf63ee8cca5ffcb83246f","merkleRootHash":"0x77348edf13c25c231721cfe6786fc01c4f8c2472685da0de86a3c3a473721b4c"},{"version":"0x00000020","timestamp":"0x2fecba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x8988515bc96da4565894d46e3fa4b7edfefd552f4c6eb3c5e03d051184640d4d","merkleRootHash":"0x3cfbc08875d0309ab5f6489f263f96d3ea410ece403e61a44cb3ff5f3d912165"},{"version":"0x00000020","timestamp":"0x30ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3ee65d1f799dfae66409389c1f5eeaa36d9eb562d8e88ed7af39f10003a7bc35","merkleRootHash":"0x1969ba4dfacfb1a9c41cf74143d56dc312792af0ba6e96ca4a54f96bfc1d2741"},{"version":"0x00000020","timestamp":"0x30ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbe70c1ef612eb38c27d62b53c90b817a0c27c7306c2cd0d6d4dcdd251468e03e","merkleRootHash":"0x904828359ff6f217f04538426a7ddeba03cafe5e2d5cc6edc548161fea529752"},{"version":"0x00000020","timestamp":"0x30ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8c7598b6620dbddf762f25a4814957e7ce4c60318dd29601ee35d3b667a1160a","merkleRootHash":"0x1583ee999fa6cd020cca00f2c1a585ae10a815f89e85546a9c953afea0f7f985"},{"version":"0x00000020","timestamp":"0x30ecba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x92525e2e0165c103b2ff8e81a2d3a909b9ab9380d27ca05f68e49499ae1a3930","merkleRootHash":"0xdce83f4080465ea7d5580e81b338c9c9d18177acb3d1d1191a20ac71aec7faea"},{"version":"0x00000020","timestamp":"0x30ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x96a774167ec13d99201064da6f8e72703bfbbbe340c9963be7741d7019264114","merkleRootHash":"0xda4e8a6f5ff803604419c773f899eed09076a023b954957cb678ddfc98b61589"},{"version":"0x00000020","timestamp":"0x30ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x6b715c798fe92e0f2ee23c517788fdd8a68dea8def3636a19fd177511d33b011","merkleRootHash":"0x7e1669540e7e392f439745ddfa448ecd550e532159ee2312d483543749c6d3c2"},{"version":"0x00000020","timestamp":"0x31ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc87d2c2c864ca7f63588539aec362b81b5ee10f7c546edbc4fbd2725ca0db878","merkleRootHash":"0xe72b903f0693dfbba97ec484c5fbc65e8395d687124ce67f3b41b419b2ed92c5"},{"version":"0x00000020","timestamp":"0x31ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xdbc0360ea72638d31c3a72249bceb104008c4454a29f172b6a3ee94e72ff1142","merkleRootHash":"0xa3f9ddb7746398193bf986022ae31a006f247dad4a83969e5833672da796338c"},{"version":"0x00000020","timestamp":"0x31ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6cdd84029cb15e881f35653200855271d852e004c830e95e3c4b47ea138bfb62","merkleRootHash":"0x3a48bec23afbcf6455d2553e22704694ea0700f6b99c7fee7488454b651eb039"},{"version":"0x00000020","timestamp":"0x31ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xaf47b7ecd00e6b2c4826d5d9c5b05892c491a5e74bcc8378662b742bb9aa9262","merkleRootHash":"0xe8ad606daa107777dd5de82b91cbdda04b497059d9e770ef29df6d949606500c"},{"version":"0x00000020","timestamp":"0x31ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x29cece0ff6d334de3e22130b92f9ce60630004bd4337e57ce4b32ce0f6d49363","merkleRootHash":"0x269ff3711e24604783e475aa066c0ef5d17d085e6b404a2586631e4996a46fdf"},{"version":"0x00000020","timestamp":"0x31ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x24a8994af922988cd30b942a5455d1f304bc24410b351aca6f5f32f41fb90c44","merkleRootHash":"0x51bc46b98502d873b9b142ac4bf911e12d204e53c7fa53c5303ff2dd193fa39f"},{"version":"0x00000020","timestamp":"0x32ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x65b15ba9e465a8d614f8db3e2e088853505a25f3367e397dff82436e15c2f31f","merkleRootHash":"0x6e1b678e2f96edd3c794b14d5e031583a48526f4be9d37d3e0854dea69dc3e9c"},{"version":"0x00000020","timestamp":"0x32ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x7a7e0f686831f2a04774020b1c01e51ed503971fef243cae8a6ac8cbd8dc3e2e","merkleRootHash":"0xd2b5333f3798c2dd2cb09aff20a060266f1d00c331c2071e8d79af4010ab77ca"},{"version":"0x00000020","timestamp":"0x32ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xaa358f6589a8c6963159d7fcfaa5f3a713bcaa0059829f0a31f015ef20afa505","merkleRootHash":"0x448877970dd8581501ce3aea5e59581093231012c7f519f3631c1006c88fba64"},{"version":"0x00000020","timestamp":"0x32ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd3b6c38a8ff289bfac3d19b901bcba6d894483221bca60d5e308c8f051c40120","merkleRootHash":"0xcba2ff5b7f20a6791f0a9167cea0e9e45b111329225c04fc11c83ebfcdb040ae"},{"version":"0x00000020","timestamp":"0x32ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4a9d0d95cc3875b09385e2264eb21a115d73b163fe3c882fcc0f1e020457147b","merkleRootHash":"0xd2f21efde96c0b0c87664a04f2de7c32a8583edde1e2964420f68d805c41560f"},{"version":"0x00000020","timestamp":"0x32ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6660780190d9f16c9dbf138e29826c29fe6d162bdc9bdb4134a895cd480d276d","merkleRootHash":"0x229415fcd0fd0cf65eefcd32422529331d97cc946252986417bf180e02ce4d5b"},{"version":"0x00000020","timestamp":"0x33ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf427bdb08542bc9ce1dc38ad9d92c11f17fa846826efde6419c7eab6ac965f06","merkleRootHash":"0xcb1a95c9cba96bbf98f7196e78f349be44fe47b35ff1d26896eb0dfeccab4f09"},{"version":"0x00000020","timestamp":"0x33ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb414d335a9432e26c56fb7a61538416abf5bcdcd0da8c2b84a215857b250ec3d","merkleRootHash":"0x9fd7b5b46960c673e49e0dab5ec7fa58015544af53d42087b31be547cee138c9"},{"version":"0x00000020","timestamp":"0x33ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1d917073e000a792359a2efcaf4e92facc6b36117a9be49040e00a3f5cff8f11","merkleRootHash":"0x9c906d5197eb5d1ad36f488fdec295b89308d04fbe57460abcfda2ba2f6348df"},{"version":"0x00000020","timestamp":"0x33ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6f65afadf448cd84559eb34c72e7c0299631b2252a284d8c95f20b5f6eb3d578","merkleRootHash":"0x120e9c534bc4186fad71172687c9a48be6c9d892de81a025b88a94bdbb4070ca"},{"version":"0x00000020","timestamp":"0x33ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9130b637aa77fea3efda6f8e7bb3014951fcbe3a963d8838d8c31b4e1a30875f","merkleRootHash":"0xad099d2a0f499c63f5bc88d5b4230a073c2d45b18a536ece797642febf05d210"},{"version":"0x00000020","timestamp":"0x33ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x14e7957636753f02ba7415206fa48faccc144e408e72549c4159d56557418a1a","merkleRootHash":"0x8416083ac80c68bcef0516aa7f5090d7d8a48f7758c9facf0ea5ce1241ecddbe"},{"version":"0x00000020","timestamp":"0x34ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x690edad469b06f6728f10df1942730dea9d222a198c56f77821665bd5fbb1619","merkleRootHash":"0x31feef4cef3bc74edf32c6a57291b1ab3943de6e34fc298218b5504a544e5611"},{"version":"0x00000020","timestamp":"0x34ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x59aa5829970f3f62e612f3c13c58c37905f46c6b258ab727b7855f4305cdc60c","merkleRootHash":"0xff40a65731aad6d116ff2604c72d6c82322ea04693dcb473cf6595f513e1da81"},{"version":"0x00000020","timestamp":"0x34ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6e2373c10e4583096a8a8cba29867f0518990254423c81a4f338f23c7b2e7045","merkleRootHash":"0xcb8abc63bf9a1d4a06cdf82700a0374857089f3b3dd9e96ec1b413991b4f59f3"},{"version":"0x00000020","timestamp":"0x34ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x52c3f44c0e98b4537100ceb031fe3c156b2af0defdcdea9df42c5c965a67b96d","merkleRootHash":"0x5ca032bfa44b17b71fa7777121f901c524c0e2ce81f96d3ec8393f9794a9a383"},{"version":"0x00000020","timestamp":"0x34ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf007a116e10e2a93cd75181a3cf0ce0327cc0e3df6cf3ba9d9f5dd34916a3267","merkleRootHash":"0xcb30542bb8bdf0ac9d0e56ba3a537411d5d71da4a6c80597bd8216b0255e9442"},{"version":"0x00000020","timestamp":"0x34ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb5bbe0357840cce478afc27507e75f279635e1449f7ede04f679cbe06fd79d4d","merkleRootHash":"0xd8c735cd9fc01294987b22bf5178a72de78be3e7505a5eb2e7389b83ef703010"},{"version":"0x00000020","timestamp":"0x35ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x12ebfbb77765d6b6d5d87e12122da75cd7b33164293eed9b8a8dc76c154e6456","merkleRootHash":"0xff42163b5bc85fa8d8e23e46bbac896eef1aed1ee4b4ac431cc170b88a97991e"},{"version":"0x00000020","timestamp":"0x35ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x4880d5cc6326b98eb9e77f73df71ac1d4ac094e5bd9f041f2bd3ed39af768f0a","merkleRootHash":"0xb0e2aa75491c174d68a3d542dd35bb128f939386e9b2b12a593f9ce6ee81b405"},{"version":"0x00000020","timestamp":"0x35ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1d2e37fd6934b17141967c366d68412b823e1c608e6b44d43dd65a0ae7e5f54a","merkleRootHash":"0xd55bc92c253daf2b860ca510057be3c5f750f4596dec81481d6190ff19a6f940"},{"version":"0x00000020","timestamp":"0x35ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x813866c39345b9a350dd35cbdb18d31008b9b681d89c2708b1f93ba120bdf741","merkleRootHash":"0x54e542193288eea11ada9b96a351853dc4ff4c63c002e4781529963bc7f602d4"},{"version":"0x00000020","timestamp":"0x35ecba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x65265fe2cae3e9c074b6b28f6723fca09fb805a2a072e89c708a662c005f0f45","merkleRootHash":"0xa1a972fad582ea7540be514657d304007334d18c35b56a7b4cc25a2e81145c41"},{"version":"0x00000020","timestamp":"0x35ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe03dcb04ae84fbe5f4032c617234899d77d1728fd93fdbac23b6a200a62f2257","merkleRootHash":"0xdd4790040f97b111865ee352b06f7579d22e7fa226ab1967479c5f3c1a8a02a1"},{"version":"0x00000020","timestamp":"0x36ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x00a6cbc2174eadf46ab4fd4d6e9ed410c2f8b8d234376ff68853ee2144e3d027","merkleRootHash":"0x6632f6b97313b93c8656984f2e30de713b2ca0000ca34861386d114b8901a7cc"},{"version":"0x00000020","timestamp":"0x36ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1ddbcc4fdb75bb906e92ff0970f8edade463fdb1add7698f285d14e16c7a237a","merkleRootHash":"0xbdf6eb9d21936dc519cfc069da43c5a1d3ffde4dd3478ed441ff04238e5009ef"},{"version":"0x00000020","timestamp":"0x36ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xb68151fa914d3ec235699c58e5da97b7ba68abaa2392a5458542581a25247a7e","merkleRootHash":"0x59a34c53f23377fcf5b1b51f50ea497e06ab80f949dc80f781b8d026bb7a6368"},{"version":"0x00000020","timestamp":"0x36ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc78c24b8442000d1dbf04b60d52ebecd4ee157efebd984e1c3984b7e31c48017","merkleRootHash":"0xce37ed08be003ece47f24257bf6ad2d3e9c7e213eadb70f43905efdd106271f4"},{"version":"0x00000020","timestamp":"0x36ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x21efdb9491b39d167b14a78561535cff1daa203ec47c7765b01c1853166e4033","merkleRootHash":"0x91076f9c7394809f28efa905bc2964310cbf9cc8aee717e3a87ec22c08ba07b9"},{"version":"0x00000020","timestamp":"0x36ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x648977c7fc1a7a8d7523627c136a65973680c0a0557ea27f83bdb9c28b7b937d","merkleRootHash":"0x9108a52fa15ce77d543b9f0f9cd4963c43d6338aecdc02ec0da2599cf2f310e6"},{"version":"0x00000020","timestamp":"0x37ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x061236bce28a761b7631de2a59f37610cc4d8258be17a56bdfdb0d717056b028","merkleRootHash":"0xbf79771ecf67c73ae7c5346ad84bf089b5ab28aa9988ac5094458a57f65975a0"},{"version":"0x00000020","timestamp":"0x37ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x615f9aa4ddc3da24953fc7b084f15de65b510aea264817c00257ffae4789163e","merkleRootHash":"0x3dbec20e64a15cfad90b10c05d0d0b4a765c5a1926cab3a908b30a89983c5e71"},{"version":"0x00000020","timestamp":"0x37ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0628cdcdb1ff8a0c033acc600d8e20371ca09eab009e4ea74f23eb768bb1592f","merkleRootHash":"0xe476545f1af81f5249a9f1822f23b4c25dcb4c204a42889d0c0be1b22d352196"},{"version":"0x00000020","timestamp":"0x37ecba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0xcbefb1f30da815fd20bb66fc9e3fdc9f3ef47a69d1c97950b37f1f30484e6944","merkleRootHash":"0x13d7f9f64709d4de97b29b005089ad2049eb1b2c2b9832fa7d5d62a49f8567b8"},{"version":"0x00000020","timestamp":"0x37ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5dfe4ffaf04b6521f1a4eaaa5f2d5bb7c8d4e1da98ada579ff1ddf341d305c66","merkleRootHash":"0x31a50072ec1e043a780281580afb4a72dd313b40eacea7304c2445e862d41672"},{"version":"0x00000020","timestamp":"0x37ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbf924a3b89aaabd43e464ba89d4cf749fab12634a3b058b61ff06f9700aa9a05","merkleRootHash":"0xa323aee9753e28a7f1e237f5edde2cfb9e9dbd1d6dae55c2950ea123c4fb57eb"},{"version":"0x00000020","timestamp":"0x38ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf8ab224d1abe97812d49667591c7682857a38ff952daf69fff73d37f6ce5ae61","merkleRootHash":"0xd31c53053df49238432f5a4672978161f6cfe37b55ac36bd2517ae300c57c1f1"},{"version":"0x00000020","timestamp":"0x38ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe31f171f8f22b4effa5cc9cfa1b3fead8b91d53fac39dbda5613788469a2e846","merkleRootHash":"0x9645685beced8331393b4ceef0c1b617728d57fb3d53dc6ad9f99644b546e4a1"},{"version":"0x00000020","timestamp":"0x38ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x93380a27118cd86a76dbf257cfb6d524c783522bb404830a7ad61f1d235d3c0b","merkleRootHash":"0xb21613a6e281ded106e3a29067fbb48173a51ca796357747158999ce3893fb99"},{"version":"0x00000020","timestamp":"0x38ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe85527398b43792838ab023ba1363e56bffdabcdfd9a91dee75cb12368d4a00e","merkleRootHash":"0xeb3af9d3836a47e27dc8597310504129be20bf8d11d0ed934d47c78ae389042a"},{"version":"0x00000020","timestamp":"0x38ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x605468c74058d5ef09d63024c1e4216d353ae98f057620e2f179b6a93be52f1a","merkleRootHash":"0x6c67c06591f5bd3e383ca68243fdcf15a48a10290f38e8837bdbb4ec38474813"},{"version":"0x00000020","timestamp":"0x38ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x598df3185b1129535e370814d4de9c65a0bb66b3ccf6b39c0220823624c77e23","merkleRootHash":"0x4b05e521ebb566f17c9aa434e39f97aa003645a66e8da7331283ac2bddb90360"},{"version":"0x00000020","timestamp":"0x39ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa3e873c1d9f9c56d8b0fe0709fbd3b84dfb26a6608308fd6b60f338406f2d742","merkleRootHash":"0xad4626de45389543bbe1b863df8913eb2b962c653b5429a3ce7896f7581edf58"},{"version":"0x00000020","timestamp":"0x39ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc84d07b51887883954034c7e15420d31e10ff0c0e70055a0e17f67acdc4feb50","merkleRootHash":"0x05a68fb683672c29208af3b7cdad389cbe64cd3643f807d327e2f33d1383a459"},{"version":"0x00000020","timestamp":"0x63ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x26289edd005085981eeff3ce66c673ce0b8fcc69842dabb5a8cbf9e1bd099320","merkleRootHash":"0xb4b9070ba1ea3c9f9d28fe2d37d66da5f5e009d534964cddf2d51385526b3522"},{"version":"0x00000020","timestamp":"0x63ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe4513f47510382148105b6a93bc714aec58f95084e0ad9bfac337f4b4c67a175","merkleRootHash":"0x941432e780e54b8e35d7f3dff91c47065b1b8634ddaf08c4e25db684d9e3359b"},{"version":"0x00000020","timestamp":"0x63ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x39ceab641b6a6597a43f61f221bce6b6ad8546f68ca0b9638523b7dad8747b5a","merkleRootHash":"0x99fe9fb1d8d2875d9c13d385306e920776007c53e9f968a6a44ddcf93a442ac6"},{"version":"0x00000020","timestamp":"0x63ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8c6df82026859dfc9294bc38279511b575dd5dd2e261b47284c578d0f3495635","merkleRootHash":"0x9a8ee82d5f87d817106e6b01beff4b822d6cf06804c0b54b4b61934ec3ff9472"},{"version":"0x00000020","timestamp":"0x63ecba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x2bc9b45e09ce14ea039f63534d992c9db12303de73287abd5a49c222bbb77a7d","merkleRootHash":"0xdb95761aedcf21b653652c8e7302628924bd2b7e4b90e42bb811e1da30ec2c9b"},{"version":"0x00000020","timestamp":"0x63ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x540d36b6ffe688ff4313f7c5a0f31ae4387894f88d2b9c89959368b10d80ec5f","merkleRootHash":"0x83f90649e62aa8a44c60d8ca38cd519ec73bfc3c9fc2053a8803a7c51142b7bf"},{"version":"0x00000020","timestamp":"0x64ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9451b03f754ad58ef074c2cce5ffd7fc6e25f4b9c5b4cc0d42a5e9a9e3cc9e3c","merkleRootHash":"0x2ac8af073db097c710150997770d9474a49a2eee9ef7598a42390547ddab375a"},{"version":"0x00000020","timestamp":"0x64ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x640bdeb9485a4ef3eb8c12d10334d820251f92864debaa2a5f56a8a470a2df0a","merkleRootHash":"0xd61028dfdc79ca38033801b4f96cc9259c3dc8a2786bb07e27c149436dadd38a"},{"version":"0x00000020","timestamp":"0x64ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4242552ccbd2682b696fc1d8ffbd96afb09b2f518561f2777b3972dd2d4a5d38","merkleRootHash":"0xe509ffecafdad4c3954c0294e5aa6599d21b28baffca1257664f189af5ac9b24"},{"version":"0x00000020","timestamp":"0x64ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd04af6966f591e6a0eb0f273cfdbcd286cb0e736691f66182700f233cd2dbd3d","merkleRootHash":"0xa8d545bcdfeed366c4cdaea177071e82851153f75cc2aa1ce2a72a0b7baa83ec"},{"version":"0x00000020","timestamp":"0x64ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x57369917022b59d1b7f5537deebf503804e2faf5e60a473ae4718479a118e41c","merkleRootHash":"0x9bfd7d94b890e381c21b980d3b2b84c1951c476ea031b75e2e0dcb224e25f5f2"},{"version":"0x00000020","timestamp":"0x64ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x30d4922a81aae607ba21528f403bdebccc0fe56fb0b55e757aa51905d473953d","merkleRootHash":"0x4c2792910fab21b64e7fecadb216eb218a09fa9f8d1f2006456c098667803bf0"},{"version":"0x00000020","timestamp":"0x65ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc6eaeb7370e9dbe434ec7c12f73951793114ab9a7b47cbed21af3f809999c823","merkleRootHash":"0xc8b5ee2b1f3668a3305947a15a181833ad45047a3aae6864e1160ef970b00100"},{"version":"0x00000020","timestamp":"0x65ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9359530d8d634104aee515f33d6a7f46a7c2b0afd3a54d408819a2b7304d3c68","merkleRootHash":"0x526f38ac781265d355e755650c28773314f484d8b26276caf76e539979175872"},{"version":"0x00000020","timestamp":"0x65ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x12aa8b1126c1e1caa4d7bd22e4417fc85e15a13dedb0105b93ba59fa335c602b","merkleRootHash":"0x5d1ddcd420ca64e7a67556ebbc6bbf921909e9ab31c22e0f4cd3a8ba89b0d0dd"},{"version":"0x00000020","timestamp":"0x65ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1b8b9662b3427a2e76ca4388d73bc1ccad38c3f601b5df8a7d286b9b49b6a463","merkleRootHash":"0x14da348275d902340383fc9744814dae4c00374f7042910d80577e567270c1ff"},{"version":"0x00000020","timestamp":"0x65ecba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xd90f4ea70148e2597c7b325eaafbf9b50c432097be79ef7eef0dee4a62b60251","merkleRootHash":"0x53eeb4cb0dd667eb755edc62921c941d5da20fc3e2abe9449196f19da1af2ddc"},{"version":"0x00000020","timestamp":"0x65ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x91fb8f074369aa9f0452f56c23d67a4f26998061f4562c9919b27fa75365a878","merkleRootHash":"0xe5c348135278a31e7fd85de2e1e4d59f4424391080891e5a6f4f9c948802f86d"},{"version":"0x00000020","timestamp":"0x66ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4a4cb712843863fdb769d3d8ad9187e1fbdb1374ec7be68c2fcb2422fdf0c65e","merkleRootHash":"0x5b61831f3b90db3c815d81736e930ed1699ce6309d7f84539356daa02d2c6a17"},{"version":"0x00000020","timestamp":"0x66ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x33434d1de57f5b34afc45090a66b9a688da3ee486fa0b594d6f30bd498d61f1d","merkleRootHash":"0x103019a5c7034177a734f617d5e84db1c9e4cc2d7bf662822313999f5bb42d0a"},{"version":"0x00000020","timestamp":"0x66ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x513a8e85d935ed2ecdfe1364f57237820fb9dd0cb76a17f7b9c4c2f258291a4e","merkleRootHash":"0x8c153cb99e942ecb2524a2d3e1cf8ef06147c668b443b87592b24ac372176516"},{"version":"0x00000020","timestamp":"0x66ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x193ab0d3057430fd033323f7bb73c556f6938b6517b2a4bb01bd12c7260da628","merkleRootHash":"0x1ba15d8d7474e315936c9c6df4c6e771056bf3c8b52d9b9fcb7a047b0e51e335"},{"version":"0x00000020","timestamp":"0x66ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xeb0f5a9a16a775b5eacd4002ff71e48dde22967798c7e022c2832f217eaa5b49","merkleRootHash":"0xf3b8d20e08669dc16d1705680abef2c8013a4b2c315b516e410f3723fca980ed"},{"version":"0x00000020","timestamp":"0x66ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x411786f42bd4d2adc83b8a19efd08fdd7f3c4fd785b57ad97e9f1ec67aae8a06","merkleRootHash":"0xfec87850c2f585bc55eea0d1184d913f911cfe27e1194ec49ad76acd79c2a16d"},{"version":"0x00000020","timestamp":"0x67ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x25c073490bb381454b46152bb74f4aff31ee5aa70d0833d59560348e2b3e2266","merkleRootHash":"0xc40f4ffeb0efe1af6572ab192e748c86bec9507128973c034b99fadc4d7bddf1"},{"version":"0x00000020","timestamp":"0x67ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x22b94176cc13385e457525db4055a2117f71d97184d9fd61ec968727b29e5014","merkleRootHash":"0x9c4a64b700b6816eb503fced4f7800bde2009d58646b71edf707a023edcdcbef"},{"version":"0x00000020","timestamp":"0x67ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4c6c405c3cb8a8350d4164890ec6727f750c61b3b500cd1d2b0ab1a0fc34c216","merkleRootHash":"0xbee6d6495f2a1991a034cf50f393d391afee9e6ffa13bd40141b8638ef8f39a1"},{"version":"0x00000020","timestamp":"0x67ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7a5c2280ac42bcd5aa2d059811fb2759d5c8885a91d8626c259adca113e50b26","merkleRootHash":"0x08a834061b93d37b1edc221e788c44681523c6f0a5e66ae70e3914ba7d1d52c6"},{"version":"0x00000020","timestamp":"0x67ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x27bc69d57c8718ae689c12925fcd39e9ff7783b1f6bdb9d7183aed8a4942250a","merkleRootHash":"0x4da4e8f386492dec27ec62e090d18e8ce3ac715f9549a8766b3e45ac6daec89c"},{"version":"0x00000020","timestamp":"0x67ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x216bf8396c824031aa63c8f8ef9b0e7d284ae8d6643551dfb18497ae4f3fec13","merkleRootHash":"0xefc0b3291583f75a9795713b11e40d3c6323dc3024e4653ebfc189979f5c2f6f"},{"version":"0x00000020","timestamp":"0x68ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9f2af3b58394b8812d4ae1ec49e9cb3673fe9a616871ab78d8cf10a9ecc5ef53","merkleRootHash":"0x25526b7766a17ea545bbcede8632fce106235cd99164fbce2563441e9a044a38"},{"version":"0x00000020","timestamp":"0x68ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x2983240c2bae3649ff69614901ec9eeec456285ec61e8edd10725a88a1316c15","merkleRootHash":"0xaf15808bd9f5406df8469f178dba0405270ddeea61fb22bcf856586b50ea2a0d"},{"version":"0x00000020","timestamp":"0x68ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf05debba92bc5a45de1550b3cde6498f836502141bf7b60550f965d41c589952","merkleRootHash":"0x2d0dd3fbe0a2fb3539c07ce0ca90d1ae82b133ae4d646ef55c174a2ffe2b6903"},{"version":"0x00000020","timestamp":"0x68ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfe61cee7a79c5fed3bff79816390b592dfd8e2079dcfd322e435adfb7e5a9b43","merkleRootHash":"0xe26c125c8f1f5edbac9ac999b5b1b7cfc77156666a15746ee65ddb930e2fb4ad"},{"version":"0x00000020","timestamp":"0x68ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x79a25dcea08f2fade55551dc4bb40b05af1dd638f8e9f14b74242ffe60c9496f","merkleRootHash":"0x64a11c2cb68aef3bf18e9ceb45b20cda053ecb36ed0187ef039f80462ff7cb64"},{"version":"0x00000020","timestamp":"0x68ecba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xb94ee5a24c31ef34d0e103e6f27403f0fda007008e4364a7d85bd1f9e5e1d27c","merkleRootHash":"0xc553866c2ad0177c0d82dc8056a4da540f60336d4afea59c2fca1b91c0e79360"},{"version":"0x00000020","timestamp":"0x69ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1735c015b26e4984545b101ac803896c5dbd37d47f670f63904c6c77cde99c38","merkleRootHash":"0x28de0ef6336b82d93e7906b73814c8b1b707600d764d913b968abc3a17ec3df9"},{"version":"0x00000020","timestamp":"0x69ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x2877a46d8a655b2efa80818ff35f9bd37d183478c9d6f7ba0320848ad7c5d74e","merkleRootHash":"0xa8fb5e9e78aefcfd963373b89b4adf610fd36bc786d052eb705c6ce5ee5f5c9e"},{"version":"0x00000020","timestamp":"0x69ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb642c802fb64bcb77d4550bbcd16c2cb6317dc490ccabd108825485b9b743520","merkleRootHash":"0x5ac5f0975ee8918117300c2a1136339d25ab47a0e02c7664d989327c5c4e4963"},{"version":"0x00000020","timestamp":"0x69ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x06e8baf8e567c55c74ac7a88c9a8e16c21ce57e1113b1cbcd658519ec906150f","merkleRootHash":"0x1115602f1bc51e5971d0f1d97076bb5faf990ec92b7b7c1e28f5c82fdf08119a"},{"version":"0x00000020","timestamp":"0x69ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x9108ae66256d852ca081de6063eca4f97b2eec82eab490ed5d89ad0fe8834954","merkleRootHash":"0x52acf46761f02d19d17a5e0373c6014b9cfb8654a15445e280b33d5b12c7e7e6"},{"version":"0x00000020","timestamp":"0x69ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2b5598bca89ed75fe8f4a51371970f38b4956b76b744374af5409525a8c1b746","merkleRootHash":"0x9efd6f00ecbb6477d37cfcb7c06fb282242900cd7cda203662db1b49db200675"},{"version":"0x00000020","timestamp":"0x6aecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8967b626e06ed5f187ac45ed6293b58bc238a2eb9d0d234e2f21ed93ea085c69","merkleRootHash":"0xfbc45e92e40c934e7425d8e9c9a65fc119f65765c0a085b96c041c425182ae43"},{"version":"0x00000020","timestamp":"0x6aecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9b9400de85cdbd231e821d2ebc047e877d496dd25dd164c180c4bb046de2a740","merkleRootHash":"0x4e57f89c718f664d441c9302cdab4947840c2f6f96d8d92c06c45e1a0e8819b0"},{"version":"0x00000020","timestamp":"0x6aecba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x5ab63e5424e545a583126aa71e82338cc9400f75fc3a7e7c8e8dbd1073bc7b6e","merkleRootHash":"0x12f37332261ca1461e02944e01a15b523d5e47eaee5d1aa75b476ccd1a550ac0"},{"version":"0x00000020","timestamp":"0x6aecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7d526da00ededa90f232dbad72721e946962a2538e5c28ed49aa0182d6aa6d1f","merkleRootHash":"0x12c0c294aa11388b77003ea246471554508a927128f936769d163b8cb875c802"},{"version":"0x00000020","timestamp":"0x6aecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x75b0c07c61a04d6708bb20223bb856f370651ece94add713da6108debe2f0029","merkleRootHash":"0x9bc92622dab502c8de74f48d18fa9774365810633e550bafa606594971a59464"},{"version":"0x00000020","timestamp":"0x6aecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xaeefbd232b3ffc05d9fdf938c2f91e9392b34c34369e892a210324f72b80cb14","merkleRootHash":"0x7a0aacc2bf0797c18c969ae12790dca7d99d9e24d622ae0f62c859a499ccb85c"},{"version":"0x00000020","timestamp":"0x6becba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x7db66f0c7c25495634a6d842e3830b657e7a8fe1a13db4dd6a91673fe1c67e13","merkleRootHash":"0xbf19a601cf9f5b3dd4bb45cb6e80ebb633e4d5de8f69f626ab6869faa71488ce"},{"version":"0x00000020","timestamp":"0x6becba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8f8f1b22644de83023d755d5be55a3afdbbc08484b5375c0f207b520e9860a56","merkleRootHash":"0x30bfa821b41d2dd2462330ef77a391af0045d05254d6251b097f3c5646d7c0ec"},{"version":"0x00000020","timestamp":"0x6becba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xa9c7c3bfee37c845d719598b297a9287e8124adb358fbc578667cf8b197dc16c","merkleRootHash":"0x5f6031c2d97e2151820662d44a0e22b907929c7e8af193800861ecfaab4fb149"},{"version":"0x00000020","timestamp":"0x6becba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfdea0d13a472261f3b14f01a83e2ee9205624218eebaf32e789179dd4909e218","merkleRootHash":"0x387e16d77486587b960e9c6363f5e1c8ab4977a93b6f191f1ed0cbafb8f23f8f"},{"version":"0x00000020","timestamp":"0x6becba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xddf3ecea4f783e49afa9ea2341dbfcb52a3a625cf363ef6d7ff9424ee7502513","merkleRootHash":"0x1b24ab04b12d73a411b6b71807e7a2dc9d09041c9fa3169a3a259c14ef598c83"},{"version":"0x00000020","timestamp":"0x6becba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x03c2a5976875484062e34ade098062424a0a19bdb3ae0355431507021fb51a34","merkleRootHash":"0xc1add59a368cf162bf3797e3d41c056ef9d2d51aabf5b113f1117b2a145e6370"},{"version":"0x00000020","timestamp":"0x6cecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x36197a67955d8e637d8178cf9459694be28465d835af2b2e01b191ce87070304","merkleRootHash":"0x851993624afda6b5bdf938fa96a2007bbc0fbd0a5a9c9cf65593fef7e16ef1d0"},{"version":"0x00000020","timestamp":"0x6cecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0542e98944b0103c7b7c6d3b286269278fc01ce6ce70cb439f7b6880c06a6d53","merkleRootHash":"0xaebaeb113616435d95c2b679949fa3cf655153a79cea87f26667d70545310fe9"},{"version":"0x00000020","timestamp":"0x6cecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x340c54a65247c94f52f2b03c1cfa41ef07455120baa4aac2c33f5603f628ae04","merkleRootHash":"0x1acafcc63fceb1624498a633cc8138e320871dc3829e8766e94620c6b577f25e"},{"version":"0x00000020","timestamp":"0x6cecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1a0914edf729171515ec7e5db0c7713cb44cc18b22cba1062195142ad3e43332","merkleRootHash":"0x2dc997c9ac95e8dce9b2223159e74f48b351ff2aedc13299f55b8fa386f7613d"},{"version":"0x00000020","timestamp":"0x6cecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2191aa70ab9209fc178880a9d14581d874753717cb24d4fd62304962770a0108","merkleRootHash":"0x31941d946af1933ba0364a00dbe84515f4e802017b2070d44bdd121b5b890055"},{"version":"0x00000020","timestamp":"0x6cecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcdc046d93148ab622d77062ba3d904483a1cf22bbff55caf992fd4b1dbd52728","merkleRootHash":"0x022290740dad9e790ad8e0df8f3c3e5daffeccd41b909e9bd1f4e778ac1eb1a3"},{"version":"0x00000020","timestamp":"0x6decba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x1400532375438389d82ec57def9374373920187ce58f1b3c8ee8767eae9b9d2f","merkleRootHash":"0xdd9c97984dc6ed63d298b6c00dc9278a7961bfccd2d3d1b5b2060ccc261cfad8"},{"version":"0x00000020","timestamp":"0x6decba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x0ced4aaa43610e861dc9d3d44d2c64a3472a5a110108755a8b303235c2ad0f7f","merkleRootHash":"0x2d0b37aac05bcf1cefc619d9f89224441c0a95a6c39ccfbdf0c7a8c2a8b255f8"},{"version":"0x00000020","timestamp":"0x6decba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xba05f60d1efec722f636210e1b08c16acd65d4b4e1426ff3cc15e1993c450d3c","merkleRootHash":"0x8c633d5dfdae37c498e6b199a8d83427697d8c9a2c180fe5a5d4b41d35ac9de8"},{"version":"0x00000020","timestamp":"0x6decba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x89e24e25727f3bef5bcc3f2c6b9bbd8e2c85980c7b586df19e7ff539b85cc95d","merkleRootHash":"0x73920fce6901fe6b693fb12b3e60517915b2befd9b258a1d34b7625e1ee2aaa2"},{"version":"0x00000020","timestamp":"0x6decba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa4ab1e7e405e321308b38bad737212037db1314514c9d938a38f2e87c3cfc922","merkleRootHash":"0x6ce18a5b36f7b1307fbe822b87d7f0e1b22dad8d2ee7233fbefef8d884d18a6b"},{"version":"0x00000020","timestamp":"0x6decba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8623c6094d27ddc38c1502b5127bd2cab38473c09e7a62b9cdcad54e44fb402b","merkleRootHash":"0x7707cced0904697bb24bf002bcb726ad0255a6f003a96f7aae1c9db69b102b6f"},{"version":"0x00000020","timestamp":"0x6eecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8c10b7eee7bd95486a0926405cdc51a35c8415621d7ad889743d3a30d60f1939","merkleRootHash":"0x8ceca09936781c420753d6ad8fe11d76ba19537d8a14a1d711f151181e65f5c4"},{"version":"0x00000020","timestamp":"0x6eecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd1116b5cf237e5fa586d6a5f492467b601dea363a7aa8736d53ec9137d7bbd28","merkleRootHash":"0x00025e1baa81bfcf6bdcb1564bf262a05dc413e41f88d37fbb338646fa7c4b22"},{"version":"0x00000020","timestamp":"0x6eecba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x3f6bb4ab2c40c4e4bbb3274e17c314e165d4603c58077e39b21bebc776e37c0e","merkleRootHash":"0xf0e3ab36ef1627aef54849cc8685832e0076cf0fccb5a2a467b590c821ada31e"},{"version":"0x00000020","timestamp":"0x6eecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x12f74e67b2afefd77c72ba06727c4f9a68a6babfa771dada8b2055d7fce66402","merkleRootHash":"0xde04bbc04ec3ebb362d0be2099d8955e0dd6cf40c25a58acd01fdd78338377cc"},{"version":"0x00000020","timestamp":"0x6eecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x8bb2341b3cd2fb834893104000a0536847736fafb5748cb63b66be656003863d","merkleRootHash":"0xb0ca6cf4bc6ea65cba7df8d26fa2e1e96ac43e94535e4c02dd3102210426bb2d"},{"version":"0x00000020","timestamp":"0x6eecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc3225a1fcb0b727a187e6b298b88ebbf4620ff72448fba5588a371017d919e65","merkleRootHash":"0xa454b52fc70547fde563b23e5fde25b8b9eb473465e3b8833b903d63bd39c495"},{"version":"0x00000020","timestamp":"0x6fecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5fb0dd68a41ace2eeaa47271eafc9dba4ba6cfd925bc82904c0c17ca07bbd56c","merkleRootHash":"0x6d78ddc02fd719f8fa39198847330b792a31c28fd2ebd2911e77ac4f71349cc4"},{"version":"0x00000020","timestamp":"0x6fecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6d247bd6c30cfab63bc36aefcb69fcf1ba91650cb9b512ee13b81b690b010724","merkleRootHash":"0xe318f2dda5695377dfbf495e366300fa6fdf961dab559a6e0ef204178c11fe40"},{"version":"0x00000020","timestamp":"0x6fecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x30881e817630b79e42f00598d92c016da769954fa2ffd80fe22527db2e956a38","merkleRootHash":"0xb91ff6a8c269c9bb88360b729ac3ab5bc4fd8f0bde2b2986e69161613485269e"},{"version":"0x00000020","timestamp":"0x6fecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa62651a378492340adef3d2ff3c0e108de82f51d1bdf78fbbee82c78c090d96b","merkleRootHash":"0xf551f213fc48fd5f7bc1358a11cd49aed13460b2e9879b993e81becb3a6005bc"},{"version":"0x00000020","timestamp":"0x6fecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4c86855504b7a0c190643ad962fa68d8b6dbcf3d53c5f797add8f0f5ff0ba50f","merkleRootHash":"0xa3887316e269467000bbd9eff116a82706a44cfe2181f88709fc3ae71cea056e"},{"version":"0x00000020","timestamp":"0x6fecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfe6783584526f317632a2faf1c5a7b7c04624414e322549174910c372e52ec4c","merkleRootHash":"0x171aae09e54ff1f60cc1abb0c7aeb4a9f09bda607a1d3f7524815116c500bb0a"},{"version":"0x00000020","timestamp":"0x70ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xbd802664f159d17ec7b3545dfa7e2d3daef2d0c2124080618cdede07127b9c1b","merkleRootHash":"0xe151434b2679477e2996e04cc0eeb67dfa3f5cab42c1de97b0af30464cb3c6cf"},{"version":"0x00000020","timestamp":"0xbbecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9eba49ee2dcb493019c3da40708d530463516613b099d281a51339b563b04d0f","merkleRootHash":"0x64aa9f1533b89dc6117bc8085da5088d7ee89bfae4e7331937c7f7dcaba72e24"},{"version":"0x00000020","timestamp":"0xbbecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xd5a622f2d9c815603b04f42a956dc7e75c814c2d196d3500421a62caecee7f3a","merkleRootHash":"0x2120222e217d1b5d2a1e95ac7ca592795225f3f635182f486a0443ebefb311f2"},{"version":"0x00000020","timestamp":"0xbbecba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xf85ea0d89f3e1bf4cb3bd5b975eee4376a4a3d48c1c69d874d9a675e2dda1f65","merkleRootHash":"0x8c790c9a4448a7e3b07b5e78272963e262db567b6bfe86cd18f6868a8b88a1ec"},{"version":"0x00000020","timestamp":"0xbbecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa5efe787bdc89108cbf928f789283e51c869d34eb795d68ee44a493079568800","merkleRootHash":"0xd15fd8c0f3ec099be49eafafa5d514d0fb0ba892255e7f95757c810534e2f49b"},{"version":"0x00000020","timestamp":"0xbbecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x918bfc2098b49a9b3e9e302651aae3591a14490bb13b4b7f77127630d3e3cd4f","merkleRootHash":"0x29a1c72b7742a7419c1a761e046788557f57214e5ee1c7a10f4dfbb9aa9e727f"},{"version":"0x00000020","timestamp":"0xbbecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc34a070f85763ed8ced77e9bb2a2ff498f1ce01623f3586794af7355ffb9760f","merkleRootHash":"0x89b7e2fe1f5509df24d2ed85367060e877ae5104a43525241ba62083ee20b392"},{"version":"0x00000020","timestamp":"0xbcecba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x8c288b33d21c54067d2e93974a374942940bb25c517008e501264df7a903bf4a","merkleRootHash":"0xed312cb47da90c9be0b39bdff931ee4e1a836c79613b9809ab581be5290595d7"},{"version":"0x00000020","timestamp":"0xbcecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x742678677026dc90f881e73657a46bcd9c3834851c8c4ef67ac7f652b0103a1f","merkleRootHash":"0x8ee0606072f692519ee6e4e31cabff80296fbc486f8a61de95d637d1c8427624"},{"version":"0x00000020","timestamp":"0xbcecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe98c8a7ac575c526f449dbe9e94f2ddceaae91578657d6e26c2da2003401b02a","merkleRootHash":"0x85b1e1d0f3c3f9f58ddbc5acd2b81046034a93a89a1496243c21fdc8bc26fa72"},{"version":"0x00000020","timestamp":"0xbcecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x070288a4b8aa50a9e21fd3d4192393b5c150c191bd122b097f8e1e1e3fa7af4c","merkleRootHash":"0x9bde29877ca4bd282b8a313c46880e5f54fbc008513ce4a23ac4baa79a0ac189"},{"version":"0x00000020","timestamp":"0xbcecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x85af1b0848044669fa3858b3d24cf579d0321e8a3512c5e8f6cb011621d8aa6c","merkleRootHash":"0x34d43ffc265c19f6a5eb7fa4a8315ee29bcb37d3079cf0110130e75d61bc3599"},{"version":"0x00000020","timestamp":"0xbcecba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xcbbddb453a5e4babeb0506c4e81a6a7fa3036bd4b5911759bae47c258c7a8b36","merkleRootHash":"0x9fa9ebe4fbf36dda8a3fa3ffcf19de59e9b0d13ecf8ab108dcd8df65503ec4df"},{"version":"0x00000020","timestamp":"0xbdecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1ebf38f5835b9c3c8559a8e24144870232cd665077749c532d041cae457f3e0c","merkleRootHash":"0x24352ec70488ccb6f6f14e682681481b4d6c3b54adc23baded4660e011d1cb6d"},{"version":"0x00000020","timestamp":"0xbdecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x93a88fbe0ce15bee1a6080b206b1992f1270befff06d8c7a62b314d07668892c","merkleRootHash":"0xd75068f80f45d0f13a8710e4e9d9e4f7d430555d1228eed1a7f6453ac5f0357b"},{"version":"0x00000020","timestamp":"0xbdecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6d17306efb0735eae8c535201a43bc841483c9de662959089a7aee5a0ccf832d","merkleRootHash":"0x0bbeca624120ee8711b9f8bd1b11de0b7906571fa79f3e1f7bb557f4159f95e0"},{"version":"0x00000020","timestamp":"0xbdecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xea3af2b78f294e2f86f1df2e6c44d4b756fdb9f8f0ef982582dd01c059dcd845","merkleRootHash":"0xe429d4289c48f8feb088c0a9251894639fc126bff1d4c903c642d93fe280ea09"},{"version":"0x00000020","timestamp":"0xbdecba66","nBits":"0xffff7f20","nonce":"0x06000000","previousBlockHash":"0xe0b434ada2dd894c245cd41bfb0b15b9e0fefe5eb2b6c1cc3de7297de422ec2d","merkleRootHash":"0x9a84425694229a55fd6cf2b94d70f693ae3470c63267f75191cbd0d71aacd36d"},{"version":"0x00000020","timestamp":"0xbdecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4ff4af9f989c4ffbce2cab82018a00ccf098bdbd13bee416af7715d8a0930e18","merkleRootHash":"0xf916cac6d34963279856c12244fe6f7d7303f349841c67f909222b612ad9e975"},{"version":"0x00000020","timestamp":"0xbeecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x120a64ee7b9c8dd26358ac354be3e14291b43a6f6fcad6757b7dd2b57bdad55e","merkleRootHash":"0x869ac6c1b9d32ec82b0031987315195f3968364a8f2d2eb16576796059bfc811"},{"version":"0x00000020","timestamp":"0xbeecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x482684e9d45051a1efabaef27a78fe0f4a5091b0c0678af90ca3f57fa1a9012f","merkleRootHash":"0x3d8156a99f49b1a0b2e35de8d6dbd705d2a5e48143d91ab676c488e8455789e8"},{"version":"0x00000020","timestamp":"0xbeecba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x9142a96cdc8cfbfed4f723a8b9b3907f1e3c73e654ec448665c3175ae48fef18","merkleRootHash":"0x80668785516c9ef97f4b170c47f9d722a5c390ff94188b5806f40d08274523a3"},{"version":"0x00000020","timestamp":"0xbeecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcde7b79e0e4b1009a4bee3cebea96337e8fc5afb385a42f011cac356abe1622b","merkleRootHash":"0xefb3bff4f9ed73b91f1c081a6135c982bf8f236061147859cf7a1176105cf1b5"},{"version":"0x00000020","timestamp":"0xbeecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x541293431c5732c68f6707991b55a3e91d4dc2b7bd31057cc1fab07183325b19","merkleRootHash":"0xb4bcaaa8947f412ff7386625abb9d60255e7dfcc2d577b49cd63160c96d98c28"},{"version":"0x00000020","timestamp":"0xbeecba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xd03d854289b8a04b6874caea134056cdf98aa2b687a806546e9b233bb1005131","merkleRootHash":"0x133486e97c80e21f95126dd1c3e5c1b9d2c91aa24c7fd5c0a1f0f28910bcead4"},{"version":"0x00000020","timestamp":"0xbfecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x737da57d2bc1962446b8feccfda9a134a0e8b5181de299f4d2fd6ef91aeab821","merkleRootHash":"0x0edcf45d169fe39d608a19945aefc11615dcdb793cbf940b7b1e67daac781de5"},{"version":"0x00000020","timestamp":"0xbfecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x37ca4d832853f8c4c24f74f8e150b5b9be5f233762fe81d7f12d5a1da69a0e76","merkleRootHash":"0xd788f282f4bba96cb29b75eba7938838557a570a9bca0c87ad76c20216b03ea9"},{"version":"0x00000020","timestamp":"0xbfecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x781f69ec56b77805b704a3494289182b0b1acd7bd592803ce7efb167fe481537","merkleRootHash":"0xc7a72e6101e08be876fa3cf679975c5394f738e6ba7f62c68c4b533f68d7c6dc"},{"version":"0x00000020","timestamp":"0xbfecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd6fc4fd2322ce3c9bf65262e716f7d954971f6c55ac2c8255e0dfe3f6395fd5e","merkleRootHash":"0xa7b80ccc2acf06440d7ae8301c482fbc462296af4227eb07e027c8ec0c90c979"},{"version":"0x00000020","timestamp":"0xbfecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb771a6803c924a255bc5ec5e62f02bad4c3efa43f645a889059b93f3f0ffc837","merkleRootHash":"0x7eff789b9d9b99898f2a84da620f318a80077bf8b7e212b53c957b8f9d2627b5"},{"version":"0x00000020","timestamp":"0xbfecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xea745a0cefff4e2660a847198160f49d2fb13c461f6ec8783e5ff0a0aef59a30","merkleRootHash":"0x69e5c3cf00e4926213d022850e3357544aa69f896e1fa80097b2a481d9501a40"},{"version":"0x00000020","timestamp":"0xc0ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb26a6efc3f8ec17b8a0bfc0f746d0af10c140a48b725aec1919937dfb85aa60f","merkleRootHash":"0x0877a385cc18357cd5da2f0a592d8215ae4e5d9a6846804af06804acbe5c593d"},{"version":"0x00000020","timestamp":"0xc0ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x835e563a5695ff7707e6c0bcd06eff65a4613a3ee645e17b1636d70bec7b3b08","merkleRootHash":"0x94c8180ea8ad9f8f9eefc70ea820b9cf55009a68317f76ec6c29e763138c60b3"},{"version":"0x00000020","timestamp":"0xc0ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x88443bff70ebb982e3e7ff90cb912f4ddc28e721ad6751f186940b01dd1f5011","merkleRootHash":"0x63695573ce4fd8cf6d063b98270cb71487bded4478eae72612d9084c5851baab"},{"version":"0x00000020","timestamp":"0xc0ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2bf7fa3a6daa06124b92fd56bd10fcdb5f7a5c1ddad528386345eb0b95fa2a07","merkleRootHash":"0x11e6374d96fb2a65da4bc252939e013b483335072b3cf0f9a47d21c65faa3c3b"},{"version":"0x00000020","timestamp":"0xc0ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3ad7b1c83a6cfd28d4a1d24e59be3f3dc68515259c820b1ad3daf600a41b2f07","merkleRootHash":"0x3debc7e36beeab067125200055e8be1cafb8f3530b52163afbf2303addb45be5"},{"version":"0x00000020","timestamp":"0xc0ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcbb245df50872df6280964c17ef67576c96240d70440cff51710595d8ed3724c","merkleRootHash":"0xe8d8aba88ae4c56e45a04f370b5a829f5ac7cb3dd93030df1ca44b38b15a9c79"},{"version":"0x00000020","timestamp":"0xc1ecba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0xe5f58a480fdf5c7b8c358dd9eaca6f5bdcfd804d46d254d52b11c46e294e7643","merkleRootHash":"0x8695dbe9a5b907b2d54bddb43826b23f3622edc64d3e25b75d58709379c989b4"},{"version":"0x00000020","timestamp":"0xc1ecba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xa909f0cee8f684766e12b104aebd426f7e5a0c038004f6973ea3589b3ff88438","merkleRootHash":"0x816911f596a89a0221e64daa6f052a273ec4581eb1c185e08f230362b6ecc456"},{"version":"0x00000020","timestamp":"0xc1ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8dbef1a92e553e43f5f001e4faae618ed7000e6afe4d08b7cfa61e943b7e8208","merkleRootHash":"0x4f3c933910fd1120330dc4b56e4702fd18343aa03246a0eb4aa2e84490b03484"},{"version":"0x00000020","timestamp":"0xc1ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x02709a87c2902eb69e16c53062a8a1b1e98d882ba1d3b7bb230734095d0b3e2c","merkleRootHash":"0xeff0cd998fde911db429ac31f0eb36d846c02145790b17ad053a67d4c9c2a3ab"},{"version":"0x00000020","timestamp":"0xc1ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x88b4d93cbda0b1b12b57e1cdf409921889a595a21f2eea4402f37e096ba45603","merkleRootHash":"0xeedef293a80142e0e59ffdbb48814728baedeb78f670cd21a27fe5b30fd68c42"},{"version":"0x00000020","timestamp":"0xc1ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x977f16b38a395328c41b927a9bda47675ade665c2de52965117a0ab9bb5dac52","merkleRootHash":"0x7fdfe1869d3dcb4a9182bbe71dc13b21fed7b255c2fb3d95b6e2615234ae895b"},{"version":"0x00000020","timestamp":"0xc2ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x24497206873950cfb5028a3dc34900f2a1b27518ac4bb3c809abc43ef9a49f45","merkleRootHash":"0xc4d134d1ab3f26d06ad6dd396108a1e26fb658530bfdad5ccf0ca62b9fa98aa6"},{"version":"0x00000020","timestamp":"0xc2ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb41b25f0d72596ef90fce69c1d448651b19952aefeeafed586385fdad7e8da28","merkleRootHash":"0x296a7decafb5b0a76639cf2eb56301c9a88937f3e6f8a7944d8b7b041e23f66b"},{"version":"0x00000020","timestamp":"0xc2ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x9fa7730872b83b9953eddc569446b3d8f85186689d0c6e60d4336f9269865644","merkleRootHash":"0xaaa08f957c97bc7a7451ba9e38953c64b4e38e7bee4203307ee7254cbc119ad7"},{"version":"0x00000020","timestamp":"0xc2ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x52fd137ccb98a5e273b565e5f900e7c4afb51d3ee871809668732ed5b0492879","merkleRootHash":"0xff53653a2f24661240f868e28e750841e8aa8dcb7c20d01dce89720c173e925b"},{"version":"0x00000020","timestamp":"0xc2ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6ed2377326151442930e59297127bc036839ba6961cf13ee4ee6f817f7236d71","merkleRootHash":"0x4895282725697dbecd53d14cd0f22af23fecdfeab90dbd9abe8dec25485c3842"},{"version":"0x00000020","timestamp":"0xc2ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0f2887a63e6ecbc65193526d4b3ca586a546ac3aea88377c925bfeee4709044e","merkleRootHash":"0x57a31ad618903847c96d5f1a53bee0dd0487725e8b27dfa334c1d7454fffd494"},{"version":"0x00000020","timestamp":"0xc3ecba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0xe02532d5336f52ac4fee75cc0273aadc0b62361fbccd6825df9341465af8357a","merkleRootHash":"0xbf6a871d8194ba476dfd47336f6ca7866b76c8122c1f7c86dab632d32c84e753"},{"version":"0x00000020","timestamp":"0xc3ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x61b7afaea72f6df5f42f451077e13d11d3c3f825a128ec53b6048bf9e3e2667b","merkleRootHash":"0x5b9eb9416cc97cbf412ad40b19e1dd3b01a23fee658b89ca9c51ada4e29a42bf"},{"version":"0x00000020","timestamp":"0xc3ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xab52970b05c4047afbc9310f4cf8c4a638782a7916b91e45452976f4ca2ded03","merkleRootHash":"0x7d51fd37e872a8a652e2078097de67ece5e795bd8542a8812ef738d88536641b"},{"version":"0x00000020","timestamp":"0xc3ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcc4a13eacfaa46e2b96d31e064c0ceabce9affcfef1aa0b36fed96504d1a9a7f","merkleRootHash":"0xa7d3bf69d253e3a2348af963706f4d4d7d105c6dbcae89912e6e29e6eeceb9bc"},{"version":"0x00000020","timestamp":"0xc3ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9f5a6bba8c21755c38d42aed0443a330fe319c16de48e1b1553ecef2d1041d24","merkleRootHash":"0xb7a124dc4a3e21a38df933fcabf52c4b8a62777aa3bd6b0c02622b48bc2b912f"},{"version":"0x00000020","timestamp":"0xc3ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf627f1828095d8df9a28e8a484acdbf54461405d8e02684a0dd7a6487ca46b27","merkleRootHash":"0x2280920215d16ba5b805d30b1aad724bbfca4bd655d6d940b811fe9c51101a4d"},{"version":"0x00000020","timestamp":"0xc4ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe4a5986b8c00d4aee5fc6df4139bd3648ee39b173a374e78394667aa6ff6a85f","merkleRootHash":"0x13039b88c047b7fdef83eabe79d2df909a4b497b09ae8613cbaf1d0f7f331adf"},{"version":"0x00000020","timestamp":"0xc4ecba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x4ced0df571560cd039d55837ae01c3b4351711b4133bd33bb49f10498eba2c1b","merkleRootHash":"0x970f2cd573293cd60fe2ac4cd1e5d8f04c9485aecb1d41767169c9fd3def96ae"},{"version":"0x00000020","timestamp":"0xc4ecba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x6ccbe4b0c960fbfab57e3963e507fa8136386b7a8e3d0eea6fd430d61b770d66","merkleRootHash":"0x1dc2ff1c6ea1922f561c86a30ac31dbd58022c3f28c7ad0504125998e754de65"},{"version":"0x00000020","timestamp":"0xc4ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xab67620eb62f6d5273241b7880d5a8e7c956c2203c31d83f0ea45e19942c3234","merkleRootHash":"0x9db0d05244f6e941b57d7b7ae7a7755253571f362a1eae93afb938c43a6dfa71"},{"version":"0x00000020","timestamp":"0xc4ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4461669e3d5ad9e7536b6b7cf8942264eafbb9c006e871df097a9e7b03a7ba42","merkleRootHash":"0x256b32349e679f81cbfc2ed265417fe24da2e2d415d6631b0018a1b8bf1f6467"},{"version":"0x00000020","timestamp":"0xc4ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd0ea740497db118bb83750c8577fae50875b5dab87196a1ad3cd967cf5dd9d18","merkleRootHash":"0xa66d0fb20e71e70cc6d90204aaaeba58b6cfc2128b124ccb9c7108f9e6627a46"},{"version":"0x00000020","timestamp":"0xc5ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xed664e971c2caf08da4027123c9e8fd068a799d57d2deeaf70f7e91f544e0d00","merkleRootHash":"0x638c35942aab548f03e4b4755e5358bf5fc35020a66c5c4d531bece264d15a48"},{"version":"0x00000020","timestamp":"0xc5ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd02f47eee9966d18052e0c3732fcb0500b09f2b3e46a1af9504b66bb95c8b15e","merkleRootHash":"0x78971c7ada8f83c30c2988d7ae3ee07cfaf074ab396251324c682a0b5e2de889"},{"version":"0x00000020","timestamp":"0xc5ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x86d5ab14f11f47604804f0e4cafc2eef1320b09fd1f54220de8bfafec0533d4e","merkleRootHash":"0xdf237f87572d52a2b25efc2cf75f484302ee351ec0f251e7d3d1cf8f6c89d4b2"},{"version":"0x00000020","timestamp":"0xc5ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa01d559d6329f3bdb49ac070e44aa5be6d54ed804e18f5fe092a593e05a14a56","merkleRootHash":"0x1ce5e9692a1442cbeb7fe0b3d0009a5baed8a2c602360e1a2fb44b2ce4ed3e0d"},{"version":"0x00000020","timestamp":"0xc5ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0ba31dbd7adef0aac92035b266d507be5b7b09fc80e4fb46625d98b127cf3b71","merkleRootHash":"0x3651cfaaba2cc63941848ea278c965105bb56790cdbc03dfdc918685e66998a6"},{"version":"0x00000020","timestamp":"0xc5ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x887ecdb98ce983f0c9c1429c775bb77f424477a03cdff0d0d1c8946fbfb07b13","merkleRootHash":"0xdf8cf37441bcff5378439d2b5483436e699610311e831c192482a5794d9a9607"},{"version":"0x00000020","timestamp":"0xc6ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x73817d5a19dfa3caa045c95c8f21998ec3af502bb8e0cb830d250a366cab033e","merkleRootHash":"0xdf53bf3da5e88858a182402bead32e9a60a74544d7f9382d437b6fb5b5d95292"},{"version":"0x00000020","timestamp":"0xc6ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb6a3d4bf0abacd889d84218e752cfb2de126feed61c70d0a2a3ccd4a2d21051a","merkleRootHash":"0x19111a2cc593996efb1b408fd7c2517cd795a55531da966da3ffbf925b18fcfa"},{"version":"0x00000020","timestamp":"0xc6ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe1e8a5077d9b337a26ad2cc38cc1016f23148790a690a9ddac62e07eca41c602","merkleRootHash":"0x5094384e19551c45c97a546f946563b97e0b832623960c772d858b7e468bf200"},{"version":"0x00000020","timestamp":"0xc6ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0abdb306f6aab66a59e6607a49748fb4f777f34abb5b3928cd451c2463113157","merkleRootHash":"0x0739bfca0e24ed42aecc5aa5a3a4de5340363f291245911c494cd95294034d8d"},{"version":"0x00000020","timestamp":"0xc6ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdb178e05709e1d273c6d82adf20a9c4ab0d2e5da7c9b8f83fd0e2e36d5e55b0e","merkleRootHash":"0x9d9966d9e8b82d566b3502480bc7dec90e331ccd16200d1adb14e8279feadf91"},{"version":"0x00000020","timestamp":"0xc6ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xac73d3af51cfce46310004ebcb95303546358edbe6122a8c43733d0e02dffa13","merkleRootHash":"0x936a7dde22611f10f6cbfd52aa4f4f070b4028a8374af98a96173c0676a730bc"},{"version":"0x00000020","timestamp":"0xc7ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3cd8667b160c0e59a6ba3969a391802bcc62da91fa8a71bb4d4e01a007177344","merkleRootHash":"0x8e1ccb06faf615dafccfb5f2ff79f1f8eb7b547f15dabcb56a7cce618193373b"},{"version":"0x00000020","timestamp":"0xc7ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe6a3a5c54e6354a020a199199f9ad9465f19886f4392f1b572145db277bbc440","merkleRootHash":"0x80b716c4ffe204011ae2497c3a593a6f8590980c28024397693ef6412f9e36c1"},{"version":"0x00000020","timestamp":"0xc7ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd4e66cbe5ba7c9ffed67c2e950ad8f8d44b20c5d6538c92a21ae73a8bca9a374","merkleRootHash":"0x28f240fb7dcefaac73a99d4cd5278765eed85bacce673afdf485930b200154d8"},{"version":"0x00000020","timestamp":"0xc7ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3f4227e64a1fae8660f0aad00add6b41b391d035d09a69e200d996f3f135334e","merkleRootHash":"0x923d7c37ed570f8a57d81e893052ffc51a3fe39fb36e9231e163659c647a4c04"},{"version":"0x00000020","timestamp":"0xc7ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe5e74684b8e03331e35a602ff077817a268d762fe837bdf2deeeeddc27bd5176","merkleRootHash":"0x908ef46c36646c8a73226421ad13a9a9e0b3ac2b9efb44a09488d6622331761f"},{"version":"0x00000020","timestamp":"0xc7ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb772d8976b2b03178019745eba957dbea0574c1d4b84acd72f296086ce35740c","merkleRootHash":"0xba1dbb8a0dae0c8ee4b97e0bb39e549688452791e83b61cfe5fb536a3818f1d4"},{"version":"0x00000020","timestamp":"0xc8ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x284f7912212f8314477634ca19f33c7e5b552e0b08ffb95703a72f402de80e14","merkleRootHash":"0x2e1fe6f9d95cdf1367274aef00d2e19a19d880b2fa261bdc68a8c454ab3b7d85"},{"version":"0x00000020","timestamp":"0xc8ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0a301cf61db8661e1fd2309c7beafad805f12d808388924c67575c610b151e4c","merkleRootHash":"0x8409daad0be5afb2349524a3323cfb9323be8690d24e4c9aa2e2c36d6fd4cbaf"},{"version":"0x00000020","timestamp":"0xf7ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8550eef3407abddd3d827eb9a43d7b4d3fb77a1fe7307967cd144fc5990d9a10","merkleRootHash":"0x2c47fa19febb250bb8b611a99aff209033a26bc925896639a3e73247b43901e4"},{"version":"0x00000020","timestamp":"0xf7ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x52e5c64a8c37cfcaf0d61fe0442f290f4670c3492abe2af95d65c0e3a0c52d07","merkleRootHash":"0x903304b2fc93eac0f7f710187e289153a068c1add1f9c1aa9244cfdd1a679101"},{"version":"0x00000020","timestamp":"0xf7ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x589941429082348533a42b064f926071a09aed441abb1f917c3b291d1a06be20","merkleRootHash":"0x5bfd7dcbd6f402c50da8e463490c5282358d14e294b0bc8fcb86603f238defb9"},{"version":"0x00000020","timestamp":"0xf7ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x456d97d00772560386d5dbf876399697d8e5dc91b3d02cc125514813d45f9436","merkleRootHash":"0xdb964bf75a02b5a433ae4b9fb52405c2f3f727b26679da3a83d87952f72f742f"},{"version":"0x00000020","timestamp":"0xf7ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf097811c8f9452fd68e0407cf2a2e6c1fe5f1ee31a02b13b3adf1b0fd04dda01","merkleRootHash":"0x19dd8efb2268638fa377bf1ab5a940af4b72b29b3ad68f2d18cf36cb2704e235"},{"version":"0x00000020","timestamp":"0xf7ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7da4292ff9cde68ec7df2e433b3e0e8dc9881e4e90558ccdb28d398910192145","merkleRootHash":"0xcee7200d42a8faec20be651a262baa28157d4fe393defec07025e3ee69cf2ef7"},{"version":"0x00000020","timestamp":"0xf8ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xdad44f721425044d4340da4a3eba30e915d446323ee5b8700d0a5e333f367400","merkleRootHash":"0x0bdbf7a36829dff45bbb7fb6ad1b9ac561bf5ccece8715bf875372ad88426801"},{"version":"0x00000020","timestamp":"0xf8ecba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x05535a711fb46efdaa04beeb7d7606cd9cdbdd149381d92692c5c57289232e0d","merkleRootHash":"0x19c898de64203e24fa23f9f23ca9889e7146450cd88a7159226e0e6665133905"},{"version":"0x00000020","timestamp":"0xf8ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xff52786ca0c54fb16deb8ad8b6fa637b6de2d266ea135da1016a973f8cdc8911","merkleRootHash":"0x4d76d409f26fd99c6d7b191ab151815c8b62578103e878fff6d6f6b72048aa89"},{"version":"0x00000020","timestamp":"0xf8ecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x13ca3842b4ddc4e167c608d2d39faf5da72d8dd6ea2f3d73aa03a1adc2ea4e40","merkleRootHash":"0x293c0ccd96fab8ba17210ac5d79e8ca9789c3f44299832ea7d68d0b26d797ba8"},{"version":"0x00000020","timestamp":"0xf8ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x74928749ad4c187fd9cbed5af7839dc1c03407c7d197b185db5260329a42b97d","merkleRootHash":"0x27474a0cc31b2f2955be26e4da1e7eaf32d71ac607d11babef0994cf542b304e"},{"version":"0x00000020","timestamp":"0xf8ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1392f8120f702af1489e5543cf47816df22662b97337620e9ee9f9d559d4d843","merkleRootHash":"0x7cd1f4465fb8e0a8bc2403e4b7f3e7d0e80525db4b42d4a9fd0911ef64eec3a5"},{"version":"0x00000020","timestamp":"0xf9ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb4b8a91328ba331651ae276549887ec35141b8b4068fd2cd540e4631db2eb91e","merkleRootHash":"0x21ea3b6cece79e1c34e8989f30c5bdf64e8d318339de38703eaca31ed00435ea"},{"version":"0x00000020","timestamp":"0xf9ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x851b236e1226158ac2dfdd9f13d7372e7737b3b8d40fb9c8219ed07d2a2a832d","merkleRootHash":"0xdf2a3ea65f97d802bd9bff233d180f37c6336966f49ba7c8a8379afb6e720d2d"},{"version":"0x00000020","timestamp":"0xf9ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1feaa34b86da92eed6d971f2acdf5963187e12303a6e15efc913e574d3c8bb23","merkleRootHash":"0xe77458cb45eae591e846160736ec35413789e210fd14a954d701538d4042f56f"},{"version":"0x00000020","timestamp":"0xf9ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x40738631401dbcd4742967787d459692b23e3758824b0675158890a40f3f912d","merkleRootHash":"0x107066690272a3226e03937a4bd475bc6545de97a2dd346d6ad7e0ab192cbaed"},{"version":"0x00000020","timestamp":"0xf9ecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x998fff0adc4c8759b1513a38fd70d2f5cf3bc053b39c6e014081110600b3d01a","merkleRootHash":"0xe82a8e4b27a422aa177c861a69ec6108f7194009bb1debc52ef18173ccdc48ad"},{"version":"0x00000020","timestamp":"0xf9ecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x9b44ddbc9650961249246aa6faf5a01df36239b861aa8a2c7fc7fa0520f9e064","merkleRootHash":"0xfacafbd503d0d026377007f757aeb26496515add92bddb686ec7b3fc9a96b017"},{"version":"0x00000020","timestamp":"0xfaecba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x29494fe56e43cdc3378588bc7ecb0e614eff3d4b67fdcae1b3f02f4aeb452167","merkleRootHash":"0xc1e3aa5355d99892a97220b9edeb68bc5690b5e8decff9010466698440995321"},{"version":"0x00000020","timestamp":"0xfaecba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x4e67e97b8d14c4252f27bbaad1b9b806853788cd708b830e6bebcccbf35cb32c","merkleRootHash":"0xbf50f12e58dbd15f1cdcece0c7a39073ae9df4b2cb404f1839c5e0faf7e9efdc"},{"version":"0x00000020","timestamp":"0xfaecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x284a428e98164c26b33f5a7bbd77cea657526bb571a24b5a1939cdcff2856572","merkleRootHash":"0xf0924659eec2f450c3c2a807f638e1192bf31d59bdc7454759e90a7c1757c888"},{"version":"0x00000020","timestamp":"0xfaecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xbf59b530f431c00db6d9a3652b239ee04b2224e3a647ea3870d08459b6bc9c76","merkleRootHash":"0xfcd626d80f10c720c7bd418c26117779214012a69e06dad22f1f1f82c624dcd7"},{"version":"0x00000020","timestamp":"0xfaecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9567cfb250f2b59c4a878a13a0e8dd505468819eda1a3b69acff6b0daedbbe41","merkleRootHash":"0xfe492b3cebd9b20db54f9115643d4235103dd59649b7cb8e8279ef54295ae7d8"},{"version":"0x00000020","timestamp":"0xfaecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7c72bb7c15a2de97327643c48844a3bcc8680893df15bd8953c47ca024d97742","merkleRootHash":"0xb3740a4efdb0a7854cc4ee48ff744fa89b0ab0a2634d2117e85c5bc30c00a39a"},{"version":"0x00000020","timestamp":"0xfbecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x98308126d430c67a3e58050cdea965b736a31867ebe01f92e069c1373af25d05","merkleRootHash":"0x4f4569f4bc4c3288709688a40949d66d363a7bae7e14922cd96951502bc094a9"},{"version":"0x00000020","timestamp":"0xfbecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8a5f82193e91a46c55d8c6cd33d4fd999ecfb12e6538dfe9ba8b0f07e437c350","merkleRootHash":"0x9b176d76c72f3bf24bf8452c83013057168ac48e30c6958e49d06108c489a739"},{"version":"0x00000020","timestamp":"0xfbecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd35b82c288e39eef7e3dcbd259fe3dc80188249b3678138d0fdf81752f22e10d","merkleRootHash":"0xd732f53a542f91d652cb8da321fc9c935f0ee47639c92fc50648b7d7ab114835"},{"version":"0x00000020","timestamp":"0xfbecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4e18b07cbd1c515de8adb694223586deef36962d9512d9b4a87c617adf5c7a1e","merkleRootHash":"0x535cac1e08f60a4b5e8a5a3674885c0c1923f66846f8b90aa8e5772f9b2b20ff"},{"version":"0x00000020","timestamp":"0xfbecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x84a18cb30e2e6eed0e3078fdc7b8f4b21b36cb40fbe774e572a076da90067a47","merkleRootHash":"0x1ad86d6ddc130ea732a49eeab14d2e9b2e6e51e83a0573af07a2467738d4e1dd"},{"version":"0x00000020","timestamp":"0xfbecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x35c79abf0c33eedfc5a1e2c9094c5826d214988edac7910b3c89d46e8d0fa238","merkleRootHash":"0xccf48e8d6879cf2936f62260954a297a459b51029da81475ea729e6b5724ffde"},{"version":"0x00000020","timestamp":"0xfcecba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xd55ca3e2ceea6f592ada2d47a0cdd756220acf4981742e255cbca5a7852c4400","merkleRootHash":"0x9f748b3632cba025ec02b19d251e1837faeab8307e04c3ec68d3d9b9a0885a5c"},{"version":"0x00000020","timestamp":"0xfcecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9c5fa3bd29acbe67db3ac3eef39cfa8a24c0dcf9fb10285a29a43ba9debc6513","merkleRootHash":"0x94b172dc02b7ce7f3af2f051742edfe3ca60bcb75e3dce4482f5275e534c11e7"},{"version":"0x00000020","timestamp":"0xfcecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x94699e0de3c72e7db7859d9d144a5e2f31cc28172da37937cd547401302b3355","merkleRootHash":"0x23b87c9c2d5684231e00150639d0ba6977e6f1fa731b2b0c85d952b469b244ce"},{"version":"0x00000020","timestamp":"0xfcecba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x4240f6ad102c67f8e48f3ebe2552c4c956590c15ceecd0f48aacf2a4d25f5e02","merkleRootHash":"0xdbe2e0162a7454fd1970bf781e90abd2ca639ee830c0a3bef6e1e1842ccb59ad"},{"version":"0x00000020","timestamp":"0xfcecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0f859c1e2600777e1bd7380aee3f728141753dea860f9ec45c69eaed77fb3c72","merkleRootHash":"0xa9d1ec02b277c0dcfb3e4c5e8724ddad00ef7121fe0aaafcb9ce981109762fdf"},{"version":"0x00000020","timestamp":"0xfcecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x306d577e8e91b3cc76327f8d7a24f298cd501bd6f1ae1cc605cc456274824a35","merkleRootHash":"0xc4264079aebebc4d2de57fdd0a842628a00b270847076ed95bc498f679ddde0d"},{"version":"0x00000020","timestamp":"0xfdecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x271592e2cc354480507956f85d9c737d34582d8d62b29d0c7596a8d26aa4d634","merkleRootHash":"0xc0adf7daade99177490fd14de1ba7652a64b98fb530c4ff8426de14a81988057"},{"version":"0x00000020","timestamp":"0xfdecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x507fd502dc85b8d17fa59252b45d9523b2ee4c20e723a4d5dceb169b507b2a7b","merkleRootHash":"0xb338d1822e22ea96201cd972406fa835e17c27f16656fe32a24ccd3abaf31c97"},{"version":"0x00000020","timestamp":"0xfdecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xec9e4570b9f25519229990453b558063912c8b6ac4d47659c90afc8caaf40c25","merkleRootHash":"0x3cc19569bc6cee35c3b0dcb5ef3d1f8b4f678ef5392f7912980cd097bb7693c5"},{"version":"0x00000020","timestamp":"0xfdecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x18068fcb024165c33f4bf85e4b3c1c88bb8f5b0abde5fdb22d633c4e56e2fb31","merkleRootHash":"0xdc74b87194470868985f8733c27c19ac5669767e7e7fda0f61e8ac415478ba3e"},{"version":"0x00000020","timestamp":"0xfdecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x025b7d56ae08c86c03d619ecb653ad3bff58241b41ca868b20b7da1a287e0e65","merkleRootHash":"0x0868c3fd57e2541574e3776a30d717d4334efbdf6f1a989ba9b47726d660bc2a"},{"version":"0x00000020","timestamp":"0xfdecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb8cd0a74f095ac1a6a65d62604d8e0dc3732f0adbdb5f5ca40153e1056b28f3b","merkleRootHash":"0x19c5e62778620eaaa616146a2b3eb2468b2ed7a19d2546508a34d9f87dbd4bb7"},{"version":"0x00000020","timestamp":"0xfeecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf1aa805ff4a81907a043f86a16410d300bdbccc2e6d48fa5ea6e15392dae5b06","merkleRootHash":"0x3c80a7c6ee146bb388b327993e54a4ba16eb102a5c9b1ed2296552347c876535"},{"version":"0x00000020","timestamp":"0xfeecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xab29b7a6e3f183cefce7d7f4bda1d02afb8dce0b3886b3bbe895b53e15374835","merkleRootHash":"0x2205231374b3889be99722e91b3e2ba58218851761f8717b5d4786c6a9d0320d"},{"version":"0x00000020","timestamp":"0xfeecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xea6adbc1bcbbb222310e74c7f9e8254affed55a8609bfd0d2c1f3b0310c6c942","merkleRootHash":"0xc09063ce5a53bd287226476abc3164f8e8a5f3173521429fabcfb3a11f95b742"},{"version":"0x00000020","timestamp":"0xfeecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb2194e73537aaa7a9ad5602f19dcd2df5dbeab63c063132f61c5e2e650f4724d","merkleRootHash":"0x54626ca1edc32e749674be3a81e04449e9e469bd94ec68311470c773016948ef"},{"version":"0x00000020","timestamp":"0xfeecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x17d3df74192ad1d6c3221b4169cffdbb2b9f471e91a2b6fbd2b1fdadcc78a50a","merkleRootHash":"0xcb77741713251d30cca49d3eae94ccef1a07409267ef4ebeab5d2fb984bba5c1"},{"version":"0x00000020","timestamp":"0xfeecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd3c256ac7afe33ef1cadcb4585f61bd2a3cfa972bae6bd20177f85c425d35e67","merkleRootHash":"0xc6789bfad4ca772b7ad3c6011320a49631294fa0c46e535765b2bfa3490b0ef7"},{"version":"0x00000020","timestamp":"0xffecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x30d7f6d8e893fb3216c6bfa4894ac302254c7ad2f1b05a8eb96f309ee70be175","merkleRootHash":"0xf7d94f04eba7e6d46a693a2ef1897d4f791c9663629a0c1a568190a09fe18732"},{"version":"0x00000020","timestamp":"0xffecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9bc3f2ad60a6755e36b1fcf512534b247b8177c454ceaaf85f4e191581d07709","merkleRootHash":"0x05ac01352788b83f3fc9bec5fdfa64d696135620a0e624989f46434055086b2f"},{"version":"0x00000020","timestamp":"0xffecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd83a3516f0e318e9fcb579e04862023bbac063b58ce1b1fa603f0f07da2e3a25","merkleRootHash":"0x65d6dc6510693e6fdf087efa248545de0c8ff00fc09aadf830835917db7c8255"},{"version":"0x00000020","timestamp":"0xffecba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe1668b99874c1a0ed419e2c13de00c485f2bc77298d702aeb7e3a8fa54a6ec08","merkleRootHash":"0xf7ba8fdd0ad656d3de1b4ac6b709b5f46d4ba081f14ac9f4c8649865c8b5a508"},{"version":"0x00000020","timestamp":"0xffecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa6e81e8f36a2450721138a0b38559b6b7f832dcf48a0ff85586bbe9371b8ed70","merkleRootHash":"0x552a0594e422602813178127d6907af27373e46206f0456a3cdfab8b02e82111"},{"version":"0x00000020","timestamp":"0xffecba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0bd456b5465398e60a2ca999e3605c47622975afaddfd97b32fd4bcd6f730577","merkleRootHash":"0xba6f7e1601155097c0d2c10b0503dd33a0867adb9e8eabb3db40a78051a08d21"},{"version":"0x00000020","timestamp":"0x00edba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x1dbc1b3d158d3bab1da5f72bf1910b361376bb668a164681daa0e09d1169d677","merkleRootHash":"0xffbd8152a31d699bc069af9ac6f6566daa3af4ea9c5b499ae7f94f62bd31aae0"},{"version":"0x00000020","timestamp":"0x00edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x551a299628fd4a5aafcc73c6d5dbec532d8981796c4374cac4e3dbdf1aaf8b3f","merkleRootHash":"0x96aac92f1739b96c15995c0791848b469d94d5d73c2606a869ed80057b02a2f6"},{"version":"0x00000020","timestamp":"0x00edba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe00db32d18eeb75236ae27776daf2cfa9761fe001f600c0aa1b3d151fce93864","merkleRootHash":"0x8d3c2ed33c191d0882d41e183d6fcdfc6102fe6f53781a3a9004d28e253eb501"},{"version":"0x00000020","timestamp":"0x00edba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x5176b1efc9a72042a7269de269cca80b593b8b93c29853da8f7fce65766b1523","merkleRootHash":"0xaae053f16a409806ce5ce27b18005fd72f4c231e42422367647fa90112217d63"},{"version":"0x00000020","timestamp":"0x00edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x27c577354831faf35df9e894712cd874c92f79e0cb2a0bde41f0f98c4cabfc3a","merkleRootHash":"0xf367562086313c65e22fd2a50d1f39d28a297dc2d816b7650ed8b95993e4b164"},{"version":"0x00000020","timestamp":"0x00edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x614b4ada86d914303f2edcb645da0d63b0f254c9b52bcd529e45137cd090fb32","merkleRootHash":"0x5f9653a6e91da4ae9cd6e51e7b9e13d1907b03ddee98eca87f7a1ea7f4b76400"},{"version":"0x00000020","timestamp":"0x01edba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4a72ca08133c35acf48b9fa335d2d5db75cd29a5721bd5df3710400be8a96516","merkleRootHash":"0x86096b24904adcd822bcbdc1f9bbc64aec157e14456e1a4cbf3d6cf56eb75aff"},{"version":"0x00000020","timestamp":"0x01edba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x17655f07dbe0767bf86df0d46be2b1949ef05841f04e80addbc411c167caab51","merkleRootHash":"0x80161b7f96b34257e3eddb65c725b8eb20b9eed659a150b9a1cc37b114d03e9c"},{"version":"0x00000020","timestamp":"0x01edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xda641c6c7db338912a46e137e7bdb55f5f01f8f215bf057f73bbbe0958e25766","merkleRootHash":"0x5b6adda0012f8441ff384edbb6970888c9807d500553083532cbccf474313542"},{"version":"0x00000020","timestamp":"0x01edba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xa7bc50f18392b9041625c4963ef8da3d9c1181b3c1e096c3f3ffdac175232519","merkleRootHash":"0xedf9f22cce38f5c089973e55e6526764b7a8ad0d1eeb919a50fba8b2291c1f93"},{"version":"0x00000020","timestamp":"0x01edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6a611c097d28e222f010d36dd8b93bc4dbc9c66adab53d2e789bd1c0232e1957","merkleRootHash":"0x1230a1c8ecd4a8100dcc2e52ab1aee3fc39fbcda015d412ce6b70c245d863ec7"},{"version":"0x00000020","timestamp":"0x01edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf1f1cce20b1d61a008d743759902b1e90137f3624ec27a02188100a13eddd717","merkleRootHash":"0x4ceade306f21e1686014891c8bfac8aac4581d0f40e4d7fb5b071c1ef32b79e0"},{"version":"0x00000020","timestamp":"0x02edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcd24e61462ac769b65d2ffd358dc5b63e2354aa280109323808bc22e965a543b","merkleRootHash":"0x290fe4f88b5e0ad5e3f14f411a0d1b7232949abb82a9dbfeec5fcb9734750220"},{"version":"0x00000020","timestamp":"0x02edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x51797c2f505f54819057646448cbe97ed6fe7e6cb1d59197912b414c724ad804","merkleRootHash":"0x3237736518a670c197793ec3f4023443c04e89f154401419f033978da0c1b85a"},{"version":"0x00000020","timestamp":"0x02edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6b1d818973c4b548bca9e8d2caa9c86429ec02f88af5a1bf164054c405973002","merkleRootHash":"0xe70fed38b12579ad976d2bc8e2fb144f4d429dd4eb169340609e6fbcbf05234a"},{"version":"0x00000020","timestamp":"0x02edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4f0047adb08b4c61a05ce2d0fa2f9141e207562bf3ceb30172fb60e1f90cc762","merkleRootHash":"0xf59fdfb2ea4bf264db0154e32cde78b718b386eed98952dd04e83462542d7687"},{"version":"0x00000020","timestamp":"0x02edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x35010407f5ccb1acf0979d45fa469152dbf4677e0e362eb9799eb9a0a19a8913","merkleRootHash":"0xa8e3df3f3f07980c17b716f0845ed718ad641d517f4271c88342ac943ccba990"},{"version":"0x00000020","timestamp":"0x02edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x47c4b4d85a192867f59877dc2aa5016d7f2e11b35ad513640393da3a966c9507","merkleRootHash":"0x9605e73d18cacce649c77cb9e2502c0615c745b4e3395a58cecfe085b551710a"},{"version":"0x00000020","timestamp":"0x03edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2a7490d10ab311255dbe1a82a2f65ee107310b69f9357e03184ab49012ce6526","merkleRootHash":"0x588039228e1a4f2364dc943d5a72256dc03b56c32b54b1b4411853b8e35b0970"},{"version":"0x00000020","timestamp":"0x03edba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4385284e87eb12a3c9a454533fa6c05d8038c7fb86b9f01b67859e753449f226","merkleRootHash":"0x311c0050ab5b004fb31ce06217d56e694db7de03d4eb770591e783f87edd75bb"},{"version":"0x00000020","timestamp":"0x03edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcfd17ae11d50ee35ffee081a9880cb1080829ffcc9efc80c1b59c4918e524f6d","merkleRootHash":"0x9dc0f77bd09e8dd6cff07dbba014e830759f5948ddce945a9f2947235cd682a7"},{"version":"0x00000020","timestamp":"0x03edba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x3f1ba5ee24e32cce76050eb8bc668f087ec6c880a59982f5a982a1a3ac529f3a","merkleRootHash":"0xe92dc5cca52c6175fdd7af036ca6d5641416e0b431b6a9c73d274b3c738d95bd"},{"version":"0x00000020","timestamp":"0x03edba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x079169f4e43b6588ba03a69cb9c717c862a28d231f3c87655b279b4d21bb5c0a","merkleRootHash":"0xc88816a36221cbecc6ce4d419a049c3303b857171b5e7a40d70038af092e6b17"},{"version":"0x00000020","timestamp":"0x03edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x928042d7ed1a229f9c3e529419de14ecfbc0dfa24c6d7662280b33164281ad5d","merkleRootHash":"0x3574d8468aed3b1bcd2232b0e3fd212b38621b472a0bda8585d5b24b11c32739"},{"version":"0x00000020","timestamp":"0x04edba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa4cb4a192a6e0629be10fac1cbdcfb3831af54ae9667af9ed88cb095aa39d577","merkleRootHash":"0xc784f8afed39519d29c0ab987c6c30a120506d5038dce46c99e9f4c2d411eaa9"},{"version":"0x00000020","timestamp":"0x82efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa43c28f5dae23399062645f80deb2888c7258a17b626ff8a9f1e11d0b9637a28","merkleRootHash":"0x03c5e904aa4e2bde102a2cb31e5cead449dff029b51eb8f777c2d1ab64ffa308"},{"version":"0x00000020","timestamp":"0x82efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd451ff48e03bd2d728380626265083f29064d0a232e35e88176d8c08015bef36","merkleRootHash":"0x506bdcf8ece983be4e0b987307bc48fbec05dfecf65c2eee1595c4b4853d441a"},{"version":"0x00000020","timestamp":"0x82efba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x066af92547998b62bf4cf32cd2d976af4cd63edd42b129103e15b783f96cc91d","merkleRootHash":"0x609de7650a4426dba1f1d164449011ed0ecd824c344550a6a8eb6ef7aa862f02"},{"version":"0x00000020","timestamp":"0x82efba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x762304a23b77090a6d4345810134cbc329d88ff1fe3098409f5a4b2fe2a81a57","merkleRootHash":"0x066db24a2d33e2a00889fb4ce1b3f27a729c1b60f3bcac7393a1ca2d14e86efe"},{"version":"0x00000020","timestamp":"0x82efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x76acca59260b4b0214818691773b757f096cb578ad452fa0bedc39ca813eea31","merkleRootHash":"0xd94891d5e55f6f5a4e4ee42d6eb7c55d27d3f52c27fd05fb8ee5262139cc80fa"},{"version":"0x00000020","timestamp":"0x82efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfb4379de6296b5afbe892494b144051b57f2268f0d4886ecaef2849cb1bbdd32","merkleRootHash":"0xb08605b071ba2d6e586e05eda8ca9c02ad8ba18cbf661a905133e01e483a51dc"},{"version":"0x00000020","timestamp":"0x83efba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xe94640dd3f5df85ec66123eede573f2efd1077777a8898ce8a55668c622a4727","merkleRootHash":"0x2c9b9c712f3253548aacf563c0214fdece6b2a57dd1cf7fde9681898cc4ca0b0"},{"version":"0x00000020","timestamp":"0x83efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3d742db8119e41afa793dc227796fff1e1665a8ec6ad2b934d189d734345d608","merkleRootHash":"0x91ef80fe266cd8ff448bea300f4fbb3be591e4aebd2997f3895bdf24a97e744a"},{"version":"0x00000020","timestamp":"0x83efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x51e73a9721f102b5b9f7acf0f5cd7e9bb78bbaaadd2f08e9d0e4505114ddaf14","merkleRootHash":"0x1992c3f29e9a428780a9011585ea630211b1c5327894423a37c88d35f75702b6"},{"version":"0x00000020","timestamp":"0x83efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8d6abaab7e3b8a0436d2ababcf3adfb6300d806bac806ade99c94bec67d32d30","merkleRootHash":"0xc77654c5ce5cc9498044531986d672306a8ba09e27fffce72f35a6e6f7010f2a"},{"version":"0x00000020","timestamp":"0x83efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4af1f1e92a7f36bf309a9586857abb83b12cf60b4c91202e7d7175ff92984667","merkleRootHash":"0x980abfd4cac4d261b4ca6a9c58948c14352a14637b8ea6339bd16ab30cea9d7f"},{"version":"0x00000020","timestamp":"0x83efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x68fee3707443c6623e15eec54136781ebb59e384986dac7e24ffc6f8c248f40f","merkleRootHash":"0x7ac2049b689fae106b2400c2ae2aa531003c7cf042970553acd38df688daef75"},{"version":"0x00000020","timestamp":"0x84efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x7f2436259670dac91b1e4166fb08ab47de2a1fef211aea05d2593b744c2d1613","merkleRootHash":"0xfd60cf1c107728e3958d604a7cd39957c8dd81133224447c48be5e66efa25a8d"},{"version":"0x00000020","timestamp":"0x84efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa2ed52f96e01ef9fb61fb72218cc36e124eca13332989e143384aa564b5d0c2a","merkleRootHash":"0xfb5bb2c6c7fb2ad3b542bc5a2cd7a0d34c7a3b0b4c2d4858aed964dfe93746bf"},{"version":"0x00000020","timestamp":"0x84efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe60c56e70ebf0a95c57185937f12cc43bc8f10d2faa75e9937c32b042aaa3841","merkleRootHash":"0x72539a3033872d05754adda972d5ef7090313466eb6188102565371883996844"},{"version":"0x00000020","timestamp":"0x84efba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x7a03040a07caf6ace6a2a60725a4b019b935be50b52c0bbfc6c1b576720f514d","merkleRootHash":"0xb853848207bb8c246d431504caa51080aefb0558d479fabd01318b46ca495d35"},{"version":"0x00000020","timestamp":"0x84efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3dac83b2b9eb4f0617b0a7de7f3507b16cf86ae6a14ec4bc6db3805d45d64d2e","merkleRootHash":"0xfabd2a15229b394a22ff869687940d86f5aea49f75b838ce4f0527f8bb5513fe"},{"version":"0x00000020","timestamp":"0x84efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x35a1013a4f5ccf44d6d3456b717cc1537529e4c8ee9abf65bb712b68266c213d","merkleRootHash":"0x06866decea4500749484d677e7df8baa862a04a47568e5df4ceba426aff72445"},{"version":"0x00000020","timestamp":"0x85efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x370de70acb7a7b497e3a7f8c409123eb0604bf9028849f712fedd14f58572a0d","merkleRootHash":"0x38cab990c35f5e1c7c6948d0c7d50180ddbe34c5bb7552ce3f7bb1adb390aa23"},{"version":"0x00000020","timestamp":"0x85efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x749a00582483e0cc1c0c49e7bc59e8e71cd498c0dc79ba81f8544eec5fb72c7f","merkleRootHash":"0x400eb342f90acc76e7f1ad999dfb810268f7f17282f936d1ac5a2cdcd9219f0b"},{"version":"0x00000020","timestamp":"0x85efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xabe211cd2724dbb09625bc1566859391ae2868c0e98cc949ad8796dabc722f56","merkleRootHash":"0xed887a187e3cf98f56babaae81088aaf6ecdd98b23714744378f10a94e736da8"},{"version":"0x00000020","timestamp":"0x85efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc3d484e594082f98acec23d9fcb70381ae71ea533183eb3b7b6a0eb1c41a4f2c","merkleRootHash":"0x75e9b496323093b088f2cb00bf5abfd80e35477a5fea00d702366523375e0480"},{"version":"0x00000020","timestamp":"0x85efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe1f104a66311f3a32b7d9f8d70d2b1177a06872561f6a4fe25e072927f7ce44b","merkleRootHash":"0x4a25c7fb283b6ffecbc9dcc30693e7f7422700e8e6ee24d3b8ca0f83f8201a9e"},{"version":"0x00000020","timestamp":"0x85efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x142bd5866621f481c2792abe368269fd6ae09f581306e942f8718aedbe79f20c","merkleRootHash":"0x280daff14bbb962e24f7badd3777f587abd97bbe72f25006c96ca3866cee595a"},{"version":"0x00000020","timestamp":"0x86efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4daad2045fae6477414dde8c198b83880c6bd8fd9d0d84e659482d27bbbd2872","merkleRootHash":"0x82e53d976770cb2c1aaa8af41b84a8672efdf18992661e928ea0860fe6563383"},{"version":"0x00000020","timestamp":"0x86efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x17fcb48c58c54d878f141ea1279e2defedef3c55c1cda4c4af3f23fe1bca8967","merkleRootHash":"0xf4882e8678da787eeccdf72162a7685c814eaa41ed75c91f06f64e977658ea2a"},{"version":"0x00000020","timestamp":"0x86efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9b6b5fd231982bfb71e0c123ef63fa6c2b97c3ef292295d542f5657171046a4a","merkleRootHash":"0x8580c95b58388b2e0a98b3506b5926732f5a15939ccaa3e5c4ac9ab0660c33c2"},{"version":"0x00000020","timestamp":"0x86efba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xa7ab59b704c090ed7c3f801a78ed8869c87d06684274fcfa7c6e82ba5efe641c","merkleRootHash":"0xa72136812971e6c78a169b2fd9ecc39ef250de56d8358d27b9af06c6155b4043"},{"version":"0x00000020","timestamp":"0x86efba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x4cd8f70f7f8e886fcb9119882e568b36b278ad83e99f886690404dc3a44e201a","merkleRootHash":"0x6a0d4c4b6667ba5af4a4f9669fee3f7eacc417e48df7b697239fb1b8b2fe4077"},{"version":"0x00000020","timestamp":"0x86efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xce802da534b7ed00d8aed2596b96afc681ab9be522463c74b3e91bf0a2dae038","merkleRootHash":"0xacec1bb694e121a3f2d550ea2f2134a487fab8bedb8eb41f2f05e11874462161"},{"version":"0x00000020","timestamp":"0x87efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9bc921b3d008cea91f5aaa1bc37714ce4cecbd168a358aeff694f02dea60035c","merkleRootHash":"0x7fa7dd8e24d5175b3d37f86d7281f6064cdf715d69cbe40adaca20b48b4e191a"},{"version":"0x00000020","timestamp":"0x87efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xefb5866fef22bcfe2d9be880c714ec830b8d7c2601f2f25bf0d1b4ff6a6c970e","merkleRootHash":"0x2161a793174fe7ca0025bd1dd20275204e629fcb9908120cceda7a41d6526610"},{"version":"0x00000020","timestamp":"0x87efba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x864c041a66441d546291afaa905118891f890a4cd30af6bcbdf265a0d7d63f4e","merkleRootHash":"0x839f18103aa7e99dd99c94a19082de58be2e378d5ab1419434d7724c88685721"},{"version":"0x00000020","timestamp":"0x87efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe66ddd201d6174d74447f9890436c7f72e9e2f704e7dd0078fdec5e3055bb466","merkleRootHash":"0x8da7d5feec8bf552392192a3bf21dfe226bcd5e8ae0cbdcfc4f288ce302e6bdd"},{"version":"0x00000020","timestamp":"0x87efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x48f778cc4f424ef72c0fafbb3e0de01e974d9b3b3074f76b1a7c216e2745e419","merkleRootHash":"0x4da916562a0b06f7487499fbfcbc5f47192d397a36d0555357872140b65e8596"},{"version":"0x00000020","timestamp":"0x87efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6f988dabded89b8e1a694254caf3e322a5e2b131e4ed3078291c6c94f9e6b737","merkleRootHash":"0x10a4f5e9578294621d50e2ab8cd1d8abf5e8285a792a9be49189413d58f48fec"},{"version":"0x00000020","timestamp":"0x88efba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x75004b8830cea396dda6003705b7a2bb8de8dc44b108a88e42a96ff4db54654c","merkleRootHash":"0xb2fb8ed64593022cee083ac8205acb985297802c1fc9354c58cd618db90b5430"},{"version":"0x00000020","timestamp":"0x88efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6bdf5dc14417731a93c5435f968f6e9c68e92e356544f4c78aaa7425c1283231","merkleRootHash":"0x7c761929d731196ef3d845143dd34039d1179b0e431fab102ab20034a2bc9089"},{"version":"0x00000020","timestamp":"0x88efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa182ad45b2f8141458b332e9ad31003a5da3fe2936d61c609b8db54522f33c16","merkleRootHash":"0xbd204cb0ab4b66c777a815e56862e54e7eb75a1aa2e5a09b262dc9111ce454ed"},{"version":"0x00000020","timestamp":"0x88efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa725a40f524ff09dbc42e638036cf88169026bb4af177b8ad0c4865b8cf13c0e","merkleRootHash":"0x64d568ae0d55d976a63d429086ff608278351dfce335ab5f1ceb753d0f8d20b9"},{"version":"0x00000020","timestamp":"0x88efba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xee8e1f04a18bf0954466945aae994cab56b5a62af5498f59f9112fb468011934","merkleRootHash":"0xb3f244685443a160dd172dd67613ab53dcdc38b2cc3898d9fb54d7d21d63f578"},{"version":"0x00000020","timestamp":"0x88efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6b7d69b7aed3518c4a658eca511b4edc5e3452e8eb0f48ebcf9d48c9b2954b44","merkleRootHash":"0x00c05fef66ddd79622e3ae69721b89c4a5e54bfba8e56955a020749c4a5b9f83"},{"version":"0x00000020","timestamp":"0x89efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1e6c6571cf59291915b421ead31763eac5668bf797008b6a3207083c70328c32","merkleRootHash":"0x3554da74cfb39b5b7a4ebdd5b69a8dbd099555f8dc7bdb167f530dd35f760eb9"},{"version":"0x00000020","timestamp":"0x89efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3a830edc7a3274684e521d7b22ce701c8400a8b63cb6ac9cc05837138a6ef614","merkleRootHash":"0x5b436f6695713747b00601c17a8f7a25f9053f31eaab74e773b9bf9c6dc0eb89"},{"version":"0x00000020","timestamp":"0x89efba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x26e1ee6351bc4f7456d1a34c5c827bd7098046a4ee4caf0aff35f10c0c124963","merkleRootHash":"0xd0805556f7315a4c7c523892333917d1ce73a083609bba30b05045c8db7db74b"},{"version":"0x00000020","timestamp":"0x89efba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xae87799cc233c7c700d997dd80a1f697a61e37396f0206672e013897227bf747","merkleRootHash":"0x2aa40d9fccff53693ca9005595e75a794cb302e3adc711a5183f2c492d2573a6"},{"version":"0x00000020","timestamp":"0x89efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3eb7d146f87d7e1eebf9ed05c35b859a0dd636fadb72ac820d2ad97dfa859b6a","merkleRootHash":"0xd96e82708d64b5204c4aa6f49f7f093ea282a9449a0c2b8e756adb371028764b"},{"version":"0x00000020","timestamp":"0x89efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x06a6d50e68ee862bbda7c46362afe706359130b70e3cab6045e92e91cd7c751e","merkleRootHash":"0x03a3288bec016814a4d7d0cd2ce1a0e77fc3cdfe9478bfd0c0270a72f3c20277"},{"version":"0x00000020","timestamp":"0x8aefba66","nBits":"0xffff7f20","nonce":"0x0a000000","previousBlockHash":"0x271f7cbdd38024053e27a560b71dd389d26bdd499dc14238b56fa7d929b3c802","merkleRootHash":"0xe7832884bee607494736472f90dbce8914852dc4d9930afe3420d05b8da99b35"},{"version":"0x00000020","timestamp":"0x8aefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3d8f357fe2da1bc80f6ddfaf79a05740afe9aced572cfebdcd0cb49345003006","merkleRootHash":"0xcb0f9b6bb653274c560d483b4601ec1cc9bec81c17cd3f9cd0c0831280fcb13a"},{"version":"0x00000020","timestamp":"0x8aefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc9180cf576a94031296af8a78a7d6ff3913097ba68bc73c5801f5f9d2113535e","merkleRootHash":"0x769371b89096f7aceebcdd532852dd632f0a4a76a46682bdca2aaeb417853780"},{"version":"0x00000020","timestamp":"0x8aefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6eaad68ac0cfbd41417f240946a8a76cd519692f3f16a7e053a70158653f7672","merkleRootHash":"0x8b55a2198b64dbbf402f8afbba0ea281d257dcc87ee96860c290123f8d22a2fc"},{"version":"0x00000020","timestamp":"0x8aefba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x57230c08e01be61eb35de2b9a5105140989fc0216ecec8ee9eccdb954b88de2e","merkleRootHash":"0x42ff2b2ab2dce36b68f0e4e69a72f577d7494224c72982ab621244c563372682"},{"version":"0x00000020","timestamp":"0x8aefba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x60325cb2c5cbf0cb33046ed04a8bc782ecaf16054a7863b2df27c513f26c6673","merkleRootHash":"0xcae618095986190c34d88c2265fba4acd43b6c54002efbc768ae143c0653ca76"},{"version":"0x00000020","timestamp":"0x8befba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x16949f5e06cfdc2238dc005c00523cf51fce5f97100af05dc3edcd9ebb96f222","merkleRootHash":"0x61690ed30e5cdcab7453f944c39fd43095324aa1da95b596780de56d4465043e"},{"version":"0x00000020","timestamp":"0x8befba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x85d7af2ffd7e762778698afdfd81af9e289e124ab2214c4387f355283e1ef12a","merkleRootHash":"0x27e0007c9e0848f4dc567b97832c1e947fd87188f529ba6b4bf59702e9b83083"},{"version":"0x00000020","timestamp":"0x8befba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x39a60f02015d820f51ec9e79a57db03a0070b3a543cfce4845ced4fd66a03015","merkleRootHash":"0x99d579e3e774bf2721598e9c1e8c6da1400827555da2ac943e1c2b10f7d3a1e5"},{"version":"0x00000020","timestamp":"0x8befba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x73de3437c345434d09ed193e4a30373a24d736827b8d00ed7f20bf800adbf947","merkleRootHash":"0xb97de6652dc9023845b2b3b882239a8bd4967595b5ccd9aa441703cde05f13f4"},{"version":"0x00000020","timestamp":"0x8befba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfde6fc026174e98f9fba34c7425013be147984fac50d39ce0c256a4da8ef3504","merkleRootHash":"0x08464b681aa950e3f59d7d461d94b5f782961ad9e1511aa970512553b243d578"},{"version":"0x00000020","timestamp":"0x8befba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd21a2bee2b04b9fa108fd546cbbc9644dad70daba178f1c512a497f8ede7bb2b","merkleRootHash":"0x7261566bbb61819d9f340f0147cd5eb99e1f841864397fdb2fc5e028547faf9c"},{"version":"0x00000020","timestamp":"0x8cefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3f736fdf62e208b1b20a0c74cf867ba908e19f8dcecdce0759cc1fa6f7800a4e","merkleRootHash":"0x66fac7d826933faa81ae7a3c04e549f1317667c2c244cddcf2befa2c03c239ea"},{"version":"0x00000020","timestamp":"0x8cefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0b8f21c89fb9b52740bbbafc0d71c107e73fabe6bfc2bd36e7a54071f6d4aa55","merkleRootHash":"0x6c61475447b9ba942f44e87d96206bb904a5f537b5a2c4c4d0029105f402fc48"},{"version":"0x00000020","timestamp":"0x8cefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x349d6b5c08646e1fa2dbd4bd5304f7e61e15f494d01421ec2f4beab0ab7a2d00","merkleRootHash":"0x9005c0903e1b9b8295b9018c5d7c9e30829a7adf28399644e5afa883308ad931"},{"version":"0x00000020","timestamp":"0x8cefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xbb0abd0162a365d40ec980aee3472b3a7fa51ae13780848e0ab7e3bffc1a0436","merkleRootHash":"0x66107c31da1a3378d7a2e2d188eaa7646e7d8ea5eded1e63982f1115a0e82ae2"},{"version":"0x00000020","timestamp":"0x8cefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe4de620ad6f052d17ca4f715e7c0f866847b426485411d5440d27b65a4fe3a41","merkleRootHash":"0x9a268c90a35ed7535d9952b5674b4afd863fb83ba5343c8c783fb5302aa1db2b"},{"version":"0x00000020","timestamp":"0x8cefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfd7f6263053e257d7eea85cbe6cdfa02bbb576e9cadf27efdc1066c5007e0f17","merkleRootHash":"0x03fe123ae875d3e194a9cc0f31d733b024f39a50fdab7c2616415934cf729987"},{"version":"0x00000020","timestamp":"0x8defba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x67489b4f6ffc2c862b8f3bf55e87515c30d0160f4694abc5c853eafb55352531","merkleRootHash":"0x92f38ac519f941d853c2b1ffe97c1b4ab8ee6e9c940b69c5a409208500b0a6c6"},{"version":"0x00000020","timestamp":"0x8defba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x69dea67efd7e2f85953870592a8d260f410ffe3d7d4ee8027ba6ad9d7c531d73","merkleRootHash":"0x709dfea9b11ac12877657b804e11eb4fe697d25a9a2934dda2cbe45b15e4e143"},{"version":"0x00000020","timestamp":"0x8defba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8c5b7824f35054d2f20b0336bb3b449230869b348a122a0ccb17c358b757c264","merkleRootHash":"0x575de458cc9edf5a33d1f18c3fc6f62e5f66898a1e12d0e187a17b33821d3a69"},{"version":"0x00000020","timestamp":"0x8defba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0901929289cb6246692d0553eb730682f4b18f7202c3259049e0bb38abe17235","merkleRootHash":"0x3adc8627a6bacf6620635c0eb67534055342571317a78d2d9326dab463c95c44"},{"version":"0x00000020","timestamp":"0x8defba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x59640b618f867b6d7231964c68ed65db97caabb9c3774cddf11f1f2ed2c36f46","merkleRootHash":"0x922485a0357a9f76cc3cede69c5ad3897b333951b82ab379579d1bf5135debb4"},{"version":"0x00000020","timestamp":"0x8defba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x35e99bf4b9a5be85a118c1b7244263603b080bcb4235e1e00ddf39ab86fdfb55","merkleRootHash":"0x5c8def33d876fcc8405504aeacfedc81668ea79403496115caeb41c29232142a"},{"version":"0x00000020","timestamp":"0x8eefba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x521802ee3620bf21e70dfc2d51b3776d10a2e27280fcd8d63ddadb6b9c2e4742","merkleRootHash":"0x748b4c4193c9a1f7b1777fabc2d7c7d900bb625adde1ce43cf6e81c2e1279784"},{"version":"0x00000020","timestamp":"0x8eefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe304cf1903a906d86541b94b0edac9d508e01eaceb320677a53c0a82940e1f74","merkleRootHash":"0xc94bf4fb56aba615779108f3e5d32b35e960e4469df41f2aae215e04dab3b758"},{"version":"0x00000020","timestamp":"0x8eefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x02c0f373a4815925ac18f9fd05a54f6ae4c48515857f43658fa2e6095192ab4b","merkleRootHash":"0x1248e5ed364775efb7f43bb360581b0ceaceb45062d6a8fdf73d686a9e2379a2"},{"version":"0x00000020","timestamp":"0x8eefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9d8e42d6bcfd58cf5030cdd53359655398193c22d76d50bf8aeb74002259c406","merkleRootHash":"0x8fbc75dc857f61df308aa253162c94e28bd7d88636bb19deea7838d3d613ea7b"},{"version":"0x00000020","timestamp":"0x8eefba66","nBits":"0xffff7f20","nonce":"0x06000000","previousBlockHash":"0x5d775b073db81eb724f809383fd2ce480cee52b39c950687dff0e3bcf8475c79","merkleRootHash":"0x9cfe2e9f99eea5a3674c3645b25fb00745bf072a3e7d5a0230307d4aee64322e"},{"version":"0x00000020","timestamp":"0x8eefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6180bbadaabbb302a23c77d1523a863d17281a6dbc604a4db55c343397c3cc4d","merkleRootHash":"0x3db38100c36612c7b59693d5ede4d9b0c717e85ec9a84ab28f3b911272cfadff"},{"version":"0x00000020","timestamp":"0x8fefba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x892c92f2d3f26431858daccd43c0c6b0877ce391d46c82a194ddff5321bf9e0a","merkleRootHash":"0xbdf0c68abd9227c386859e9c2d8feb99a1c754ceff1f35ab0f302494b2585c0f"},{"version":"0x00000020","timestamp":"0x8fefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9749eabf2c5fb6cc7c506454e2a81677dcd95c311c24b600b1cf6670c5f4022e","merkleRootHash":"0x7efb00346945cad60cec4df0076eb1b0f32b2187d0a59700623d8c1795442bb2"},{"version":"0x00000020","timestamp":"0xc2efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x24e922ac047cb0b45c7f2b7ffc698e2ab2f02184caf2936656a796304aefff43","merkleRootHash":"0x57534675a20eec49822f4a8d2ea26a88ad342a498cf80d9ef34540fac48a6ced"},{"version":"0x00000020","timestamp":"0xc2efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdeb21cfa26bd09c72041b21da15af4c86944139427a7a1aecb94e849d6a28a30","merkleRootHash":"0x19e3432a4399d325dde5d7d9457067e7d2d1c9f42178d090c7127f4614efbf00"},{"version":"0x00000020","timestamp":"0xc2efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbb85183102addf826858d83f1a863786d3c421a0135dde7c62dd650b46ba2248","merkleRootHash":"0x34cb3c24f1806d5a9aa51cf7e4abc49a616ae44fc395e6c91ff964ccba728d30"},{"version":"0x00000020","timestamp":"0xc2efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xab3631c968ddce826acbda7ff1cf6856bc0ff069dc0abfafccff22ba78356b25","merkleRootHash":"0x8dc9b4d80cc3a040a9c834c32d369eade2452fd21bb50f9accdef5540ae25664"},{"version":"0x00000020","timestamp":"0xc2efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbebf0fcf45b6a8b229c41dd2c3678c437b7e190f84eb5419535c29d562a1ea6d","merkleRootHash":"0x0217159e48e74cae4a3362e0b454299d292e00fc27eb2ec4433248d743549a8f"},{"version":"0x00000020","timestamp":"0xc2efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd5172cafcc4f521498fcca620668cc7a6f06ba2f9e36321e669cc188efa1800a","merkleRootHash":"0xcb078d5a186f00383d1f46889dc9556a8323d211d462cf8f2902316503067cc5"},{"version":"0x00000020","timestamp":"0xc3efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe081827a7db537e80fd935dbc105d9ad32bf81004f68213f2aafdd7822155420","merkleRootHash":"0x89b567cffa1ca074aa22d45742340de749476964bdc242bfe008eb271ff43103"},{"version":"0x00000020","timestamp":"0xc3efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1416bb266b826b5d0fd677de7f47133eb9c28c44e885bb2995d2e650db052674","merkleRootHash":"0xa8bceb4d03057212ae8f393169b843704989501dcecbe93e197ffe9e4a981779"},{"version":"0x00000020","timestamp":"0xc3efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4d485fb7f9e149943e9cb40bf64d1527d9d0bbb303a4e21cfff8a2737925c716","merkleRootHash":"0x1865a2e6d2d0612e264a45707cc7b003ff0426eb032c35e891c726e6cfbb2cef"},{"version":"0x00000020","timestamp":"0xc3efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x39d4c87df1d1fc4ff22d441fed157c79bb4d847fd1c8250d172f11a2a18b1e38","merkleRootHash":"0x26640d1a91a12c472eebc4421bec442f4ac7aec767e44a17c2044f7650794311"},{"version":"0x00000020","timestamp":"0xc3efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x05ba596f64b7b218a3947bd156b4dd8d8dcf6c80d89685d0aad677e303a6d46d","merkleRootHash":"0xd4cab84f98a22549bb69ed41822c3d063fdcd2b035148f09776f7c8b3b477559"},{"version":"0x00000020","timestamp":"0xc3efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x158285d8fe37ebc92e996eacf662cbabe107d9bae565849837fcc549def1721c","merkleRootHash":"0x877276c782fa1dd3ab1a88b8cbe956221b46f9a34cf193f3983aae4000a5fcf2"},{"version":"0x00000020","timestamp":"0xc4efba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x3cd174c3e8e3f77128369d3853251ac872c0901e2a0151051294b7b577ccfc65","merkleRootHash":"0xc748e129c80941b106643a613266ab83bbefe039df7316a273741a1538e948ca"},{"version":"0x00000020","timestamp":"0xc4efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc0bfb88cc956385756ebdd3366f8fe978cf4287bc408f3a6acbaec159c00dc72","merkleRootHash":"0x5765f11d01147046555e6d6e318273c36ce866887a80b50fccef071a1a828742"},{"version":"0x00000020","timestamp":"0xc4efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5f8e6b382b83dfb3621ebebf141eda87db48b216af053fd5f1edfaab5a105a26","merkleRootHash":"0xed22ae8d23c2005ee4be2225887c6e6d0f27f0bf1eab6a68e93fcae9b7622d10"},{"version":"0x00000020","timestamp":"0xc4efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x959aadecb503c53bd039f1b1cc74cbda93adaa2e00d57894c0a8118ccafe9934","merkleRootHash":"0xe0f69c4c1a08bdc5740e9423cfdcf9f3f43482a434ff6c2037f4ff5cdf3b0a72"},{"version":"0x00000020","timestamp":"0xc4efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x151b99ad27f98d195224b31486499b41fc38791e6a492a669eacebd7ffcf3a58","merkleRootHash":"0xa72ae34c60fd43d495d9bc1379e0f72c7d817e300d18ae7deb37f424b86a2678"},{"version":"0x00000020","timestamp":"0xc4efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9f2ca10b47ec53152928e550d6b4f59055e0cb785ad83a23e3e98126928db42e","merkleRootHash":"0xe2be6bcda406ab3720f721d835211661c74c5e257b5ac063705dec09e0ba77c3"},{"version":"0x00000020","timestamp":"0xc5efba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x0292ba62a762c093909ca6aa34d387bb92738d7aa2492b4470f6ea7919f4683d","merkleRootHash":"0xe6ed2b90498a7ea24501507e04af952fa9c268157f467ac02e8ab4c3089691c9"},{"version":"0x00000020","timestamp":"0xc5efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfc15a43ade195cd24f4144ba7d63f7eeb8654ae1e83e470b9b30512e1dabc446","merkleRootHash":"0xfedbf6344323eccc66e22014f3e3f13a04e007c571b108722e95e8d01606aac7"},{"version":"0x00000020","timestamp":"0xc5efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9cf05f77b6cfb3272926a388ef0d347bec874aa36ac84375c7555054cc455401","merkleRootHash":"0x1c79c86de2898a56b255e5510eec0f7991587c13e74985b25fb5a7bd14bac94d"},{"version":"0x00000020","timestamp":"0xc5efba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xea401090fe88fc22b77b07b6cc97a82c6d5688a1312c0bb281bfd91be513d322","merkleRootHash":"0x3031c12cf66ada070e33fbde08dbfa623711f47ab152ff6ab6059bc1c0d44183"},{"version":"0x00000020","timestamp":"0xc5efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc765c616445764c944ebee52ba0ec8ba79c5a7a67ab6b10b726ed23074665c4f","merkleRootHash":"0x66e6a41dde89bf34bdc6bf8a17033fbd6734dc06a4188eb7ebb6496aae8e7d2f"},{"version":"0x00000020","timestamp":"0xc5efba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x99ca955cc23853ac11f9602c436c440a8f2d63c9922353b6a248f3cebe9d6e52","merkleRootHash":"0x063174d2552c97545690ac67d333020ccdbb975321ab62525d87402e73cb117c"},{"version":"0x00000020","timestamp":"0xc6efba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xc7ca110a99258c33976fe314178b646e790318c81bc8f929853250636029131a","merkleRootHash":"0x962534102f92077284cec314ee41b5c867079851b29d3b60ef9db8a13befa0c9"},{"version":"0x00000020","timestamp":"0xc6efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x16e9d96b0ee37dd768ef1887371ad36793d6078b84aae6b6a84f16f8a6a05711","merkleRootHash":"0xbe6d1ea0b8882cc39d0ee5e6135388d0761708b98de51c3f2d64418b77115ea5"},{"version":"0x00000020","timestamp":"0xc6efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc73fc29cadee4d1076ed9947abe5ed39bf249e87e89c0b7460f1e062f96f4622","merkleRootHash":"0x89cf499717a816b7fe90262f8d86ebe3b8b73d2939ee1286f3983af093b4b651"},{"version":"0x00000020","timestamp":"0xc6efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0342f6f4e782a711bfe84a85f195bb7e55c7596913089c47c07c99f6bf13835b","merkleRootHash":"0x7777b2156f20b9c7cfd0aaec19e4a895cfac1e5594e1371fb96903931ba331b0"},{"version":"0x00000020","timestamp":"0xc6efba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x9caf83c7735f627b5bc45e4186dfca5181742ab5b6b013de46e4f4fadaaf067c","merkleRootHash":"0xe34f0f28f5eefae95446a20490bf1c85a7a09130341be4621642eb38a78f47d3"},{"version":"0x00000020","timestamp":"0xc6efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0b52c20dba2c277c5a4f3bbedd06df2b1ef68e04f6456021f0f2698bd8aed145","merkleRootHash":"0x43ff3ead5af11268cc644ea96ad6df8f16d4ab367fb32b0d5245e7a4ecd10fd4"},{"version":"0x00000020","timestamp":"0xc7efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x70874056da6b5fe61d288f50ebfdc72a4fdf4f9a5fdfd8fa3a05af79602dbb40","merkleRootHash":"0x6023776b82ba5314cf9f10b413ae6eb4375103157669c182f713f612d1e0698a"},{"version":"0x00000020","timestamp":"0xc7efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe26ec67f12fed00db0e310790ad9be34bd9b839a74b4f3bff3415451d9c81137","merkleRootHash":"0x2aae04bf05f0db0137c110c7df70a5e38a68b20ae78f035684b3d80f9286f749"},{"version":"0x00000020","timestamp":"0xc7efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd82f30831927617a912e9ccfe1543d9d89685c9d3d550e6fbcb2ce87e309c07f","merkleRootHash":"0x2e03a724e91475363340937454f427dec24cf21ae5b56bc2873368546bd3e5a9"},{"version":"0x00000020","timestamp":"0xc7efba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9762e9913610d888344e07bdfda2cfdda2715d7317a5d85ead46254e8d90ef00","merkleRootHash":"0x20f33e50f5af7dd4ef558e8d34396751154ca0fc14359926bc5192e8109c1f3c"},{"version":"0x00000020","timestamp":"0xc7efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2db4590ffeab1108d46f93386c7a6a19dd9861c10dd115dec9a61cc2328b1414","merkleRootHash":"0xf8bb370a97b9e92ae01c2f6c70e0b80cdc44842af89256694ebcbe9f7a844dae"},{"version":"0x00000020","timestamp":"0xc7efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7c4c3aa903ca9e87b9bc82d305c67388cbf076833b3dd5f834e28d4c36c3b87e","merkleRootHash":"0xbf961c30c9dbcdabf60a11f5f21c00bf10eefed481d615f4dfae36f42e9cacfa"},{"version":"0x00000020","timestamp":"0xc8efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x20bc7cd919c5e6610df7855280937361708a4915307300dd3565860695da6f05","merkleRootHash":"0x9ebd5ff299ee5138c03149d75d2a9bba857c6e493a4cf3e7d48fbec259a027ed"},{"version":"0x00000020","timestamp":"0xc8efba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x082052eaa18c35a31199f5e28bc97e159741b1b7337a7baff25bd8fd05ac955e","merkleRootHash":"0x55fe71a1f2e03a343035e7c8c54f7ccf6dcf24084995cbc96c8942dcd38a35b4"},{"version":"0x00000020","timestamp":"0xc8efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa11ae607a892e8ee219345e22616c2366eab1e28876ad3afd3cbe3630560381d","merkleRootHash":"0xf5a33af18e4220dc968c01252f4be20433885101bffcd84358c0f8fa687283cb"},{"version":"0x00000020","timestamp":"0xc8efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdb6cdf9c6ae21fddc86f7da2ed91404ca7a9ceff0f4c15a700d49fa79bc5dd24","merkleRootHash":"0xf5e1c987170a4c8e9938778a7e17a23366930a4fd7ae0fa3e40d6309c118d593"},{"version":"0x00000020","timestamp":"0xc8efba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x3f8555bf5db56bb563b790008c71aa390b2b2bd6061757fd45755f801c395119","merkleRootHash":"0x8481b77452a3999e8978858f430f1f5602a676576936c73a4c62e8596253d871"},{"version":"0x00000020","timestamp":"0xc8efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x046d46028a2d4203de1cd5d46668c2fc60f0bed2955a3e8fab08de39d3a5225d","merkleRootHash":"0x52712dd872efe16f36e05f0ae943746d9fa70ef1c4665e442efd25da9df4ad70"},{"version":"0x00000020","timestamp":"0xc9efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2bcbd00a06fb6c00438a09384c03e1ab5044573699168306834c1fff9cf23215","merkleRootHash":"0x37c47648322dd0df551cb44208e53661533803836cc0d8eb1c01fc17d06b4844"},{"version":"0x00000020","timestamp":"0xc9efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf94cc3078840ef11c6c9765c2fa65d69850ac5e19ba1c63de7e6e038e51b0710","merkleRootHash":"0xa9a01802924216c3049fccfc061895bace80e785afdc1bc226ae9376843dda80"},{"version":"0x00000020","timestamp":"0xc9efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa916a6f622557d81f85c4ee440c456cf911321295598a064829c3a955f947f59","merkleRootHash":"0x48f0411a294be180d1a8f4fc1d5794159d3b8017f9d9f260e94b808c3bc39426"},{"version":"0x00000020","timestamp":"0xc9efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xceb954a4adade1fd101d0d21000004110a5313d590a7c888ec61209dfbf0f07f","merkleRootHash":"0x09b2733ba1025e91e77635754bc2c1e8fecdddfbc3d47f19361967ea5ec16ca0"},{"version":"0x00000020","timestamp":"0xc9efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8e173e24ed62bf4c9ae14d4a143cc49c42e721fff4462f6e19bff09f06449816","merkleRootHash":"0x0878f804c06ad3804ef9e892f86d2f025097c1e91512f0bb19f572a3a63df56b"},{"version":"0x00000020","timestamp":"0xc9efba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xee1df9cdf9eea3f9354bd629acad1362080104526b377447776bc901ea970d76","merkleRootHash":"0xf0bf618539f12d041e2d23ac30d962ce639011698c2295e091787097ddd66391"},{"version":"0x00000020","timestamp":"0xcaefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xae06f98c080808833fe5dca21a67a44c13f135de3d30f075ac4f53e68e9a077e","merkleRootHash":"0x28304721fa321fb6919db862a5948afd180cd8e6de80c73d64c2d716a4466961"},{"version":"0x00000020","timestamp":"0xcaefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7672f6c3dfeb5b5c3507bad6685d92f376cae90679089a3c6e151d76e1ab7026","merkleRootHash":"0x5e8f910fb7f5f2cc45aefeb3185414ebcd7ea6f5a360a40e5575b85c2a051442"},{"version":"0x00000020","timestamp":"0xcaefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1919f4496b4cbaf23123b20c30ae711c096086bbfea3dc3f211e9f29decd950d","merkleRootHash":"0x426951f0709a4b273947a1bdd050c4dec0255c8f06a54ba4e5ade68f7f00b30b"},{"version":"0x00000020","timestamp":"0xcaefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfa402e67af67fae92ecfc21fd2acdf4e55610fae91c6279e8580c708fef0511c","merkleRootHash":"0x8cd2e06dff0a4b4eaaf19ff558350d4341122ce9e157c979a5d65df20d9cd168"},{"version":"0x00000020","timestamp":"0xcaefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0a97c486e7e86700ea8f95e531d700ea33a3b7ea96d2007b6db36f0390b0206c","merkleRootHash":"0xd6f1773ffcda7db5cd0e05455819259887c9b7a35039f6613997bd0eb28ae9ed"},{"version":"0x00000020","timestamp":"0xcaefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x84f39c2ea152677629b8f4cb74367011e951f4fe2854b07274d54ae78e85912c","merkleRootHash":"0xb83a80e5d32a882d61c175a3ab4a1182acb6d3f5944d9f532b6771236002b699"},{"version":"0x00000020","timestamp":"0xcbefba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xae42916910b2573f73d74976e30feb3ffdcc654abe7fe41359886fd0007f1106","merkleRootHash":"0xb7635215b4b6ae96deaa4b5595465ef590f8196b5a70cd2799611e60d16ad352"},{"version":"0x00000020","timestamp":"0xcbefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf8b677eb0c1a8174be0c3fc911f33a867489b4ce69efb2a294484c5769d57811","merkleRootHash":"0x88b9f51ba20012f1b49a80999e7fd17267549cbb7cb551034a1e7fec47e9234a"},{"version":"0x00000020","timestamp":"0xcbefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2b6b01ab163e7376031c33e66a363639500cd3bd61d85e17ba9086ef5f61b013","merkleRootHash":"0x2df7a5217dc21d92cc3275c781fa46301e9887d2308d150e201b7a32e464eb96"},{"version":"0x00000020","timestamp":"0xcbefba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x8bb23c4776017d3e1c792be97459c6c69c778905062814b75713531be44fd40f","merkleRootHash":"0xed31216f3996561d74a9ff82f1a98a221fbe53fee5cef48fd030f0b8d4c714b8"},{"version":"0x00000020","timestamp":"0xcbefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2e734654560dc96c102997dc8877aab13133061e83e2189f711f8dac1c62ef0e","merkleRootHash":"0x7ed8d74451e7e10de718594af84a04d7e0b4bde896cf6ab6bbee361acdb2f08c"},{"version":"0x00000020","timestamp":"0xcbefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb1cb60080e58154724aebac8ce56b19ff3d6e979f464e0a1d0b9c2b102568a3f","merkleRootHash":"0x3fb7ba7e8ade84619d04d368fb384aec01a28645efebc7363a6737770431b392"},{"version":"0x00000020","timestamp":"0xccefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x82c5e6b03d3937591fdc0e986bad50a38e5161f213af0e221bc93a8ddc4f7e79","merkleRootHash":"0x4226612949dba3d72feecdca52b3893ae79d5d9b509d0014e7052a543861d5bb"},{"version":"0x00000020","timestamp":"0xccefba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x5bb0ab601e13dbdc675ffd5ee1bdd3ac1b6927b26f4edb768c0720b662585323","merkleRootHash":"0xd15f15352912ffc3ed7db4f29631c349b6eb07629cfcdc23d3cea5313fd24d6a"},{"version":"0x00000020","timestamp":"0xccefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x88df621c8386c852427bbeab024839c0605e0b4f182b225f815f626585065268","merkleRootHash":"0x47619b44ec539a8d5e263b7be1439e91e9966c379e0535a65bd0eaf1ea6f8099"},{"version":"0x00000020","timestamp":"0xccefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd7ff0819725cc534ec866ef5634d78740a1f1c7819315d8cb25ae9ddec13721f","merkleRootHash":"0xc7cd309a9584b1b7c8ba4ea0991b35608aec91644c02c72a1d2a85421d9a4e7a"},{"version":"0x00000020","timestamp":"0xccefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa5467545232e4ef4e5cc964c3f4181594dee410bb3b3c787ec4b0a0887a7a226","merkleRootHash":"0x704c91251bcb71adc8ee96dac1d828d0a73233b9f54b3f39ee5f5a0dc85de049"},{"version":"0x00000020","timestamp":"0xccefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x13333a0311df738e1e011b75d0866e5a2d540621b480a25ec6b18e50753b517b","merkleRootHash":"0x446fe648df64548d9aff3e89388e86fa5c3250ca2184fde13c582d9407216ff0"},{"version":"0x00000020","timestamp":"0xcdefba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x32731db33e6608d4e48f226108ea88cae808bd168d3359deeb692aeb97396805","merkleRootHash":"0x1fc2f3d1bdfa0a72d654fae18c486a3b88c1b7a6d69e4914fa52828b15ee78f2"},{"version":"0x00000020","timestamp":"0xcdefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd20972759ce3128b216f495bf9bc1a31c5e75f0d6ece11fe683d880ed7358a79","merkleRootHash":"0x019f8a3bee09d292f5a5b36f919956538c98d20cb7b09801d3d55de59aa86913"},{"version":"0x00000020","timestamp":"0xcdefba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x439afef2ff23cbb0096f3e91e53e749c09cbe8fe862cc18db65d274c34e97a4e","merkleRootHash":"0xf6783a8d4815d3c01c2de6745883a779c3cf3189e3c9027c261d49b38574bd15"},{"version":"0x00000020","timestamp":"0xcdefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7cba011f0ec683a71a23c7251d8c8e363293a6be0041c87aff25a0b4c818bd78","merkleRootHash":"0x7cd48bb3c44437c6285fca3a7b122f9b2f1fffb359686307da039a85a522b1da"},{"version":"0x00000020","timestamp":"0xcdefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8022a819ae89f54b458b10eac6463075f9a21611ff1f1a50030d604de78b9642","merkleRootHash":"0xab749826d71a4f3fd3b6685d03d452b340408d1b6e87a03071e12bf7882c28a3"},{"version":"0x00000020","timestamp":"0xcdefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3790ef889eba2371c2bd679f2c3a843a3d9cb8ebd62fcc09afa6d6f5bc90bd26","merkleRootHash":"0xe7a8b75c578c7f98f1a27af7c46a332a66862d4b5ad0fc362b198668e6dcf91f"},{"version":"0x00000020","timestamp":"0xceefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf86bf59d4925e6ab8141842753b7ae1cdaea7468146887c8478d62af65c99368","merkleRootHash":"0x5cab0f52d51614614d287d5205c5e6291df36a103de268cd8d72db3660614438"},{"version":"0x00000020","timestamp":"0xceefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb28e42d804cfe2a1c3d8af6504b66eab06ca5badad6c2a7eccc63a7987762207","merkleRootHash":"0x42b040683998f45fef86fb72a6a42c13ea616b4e3e98d42f804920c54009d459"},{"version":"0x00000020","timestamp":"0xceefba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xcda7777e3b3fe68ccdca03d90d2915623c39225934b99b88ee62caee4df31860","merkleRootHash":"0xd4bd75c7bd8920cc61b136c75f8608b245691dbb46a733e17e313c6d59627041"},{"version":"0x00000020","timestamp":"0xceefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x075eb240d3e99c1d6bba0abfbb3ade75f70d4bb9bf6094c48baad32ed604d44d","merkleRootHash":"0x707c69353bdb47c48b296f838fd030caea9038fa655a98cddc69d382bf15ffdd"},{"version":"0x00000020","timestamp":"0xceefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2e3679659267c3616a5732059aa4a4ebf9605a8dcee7981b15c37aaa572acd35","merkleRootHash":"0x664bb684c2db76e35486b337db78394a65917bc8887b76485ac9bb17d136a60e"},{"version":"0x00000020","timestamp":"0xceefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2e4ac3cc570d55a6e420737f24ee8ea6c3da3553819871e9d6ea85ccdddf4236","merkleRootHash":"0x7d381cef601c2ebbb8b012215b6fbc8687c9bc410f5575379406b54cd2b641f8"},{"version":"0x00000020","timestamp":"0xcfefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x590373aa727beeaa21059597ef37b6f72080df37aa8643886ce7c80e9acacd07","merkleRootHash":"0x6d0263720203a1e4899fd232d29f273b1b77dbf8bbb60869a22e1c1e01a73bb5"},{"version":"0x00000020","timestamp":"0xfcefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4f49c59f94dea5f3b2797c622fd508264c58966e05459882429d42ca60ec3841","merkleRootHash":"0x8f6060f074a6c0836a8f698284e9bd9f046d763e9b971b72b0c640767de4251e"},{"version":"0x00000020","timestamp":"0xfcefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xeb564c7272406d86935b08a8768511f94c4af2433f9f465c58ce852ef8719c32","merkleRootHash":"0x9e5e089329f2f678788fc009561e0d4d5d20e36aa8fa334dca16c64720314b8e"},{"version":"0x00000020","timestamp":"0xfcefba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xfd36ed78b4ea930b7945795faf27e3fde310b0feecf1deed872850aed7232908","merkleRootHash":"0x0857eb9204dbe28206439b8f78ef8923264a08bc63c6694376d23667a725d88a"},{"version":"0x00000020","timestamp":"0xfcefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7910ac75c1386b85a2d59b0db92d93f0b29b226e90f5af402b98342103a17872","merkleRootHash":"0x7912782309c1a9d285c33fb829c22f7319b674c4474ce768ea27da9abdfa7a0d"},{"version":"0x00000020","timestamp":"0xfcefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x237b001a0beda0e8c0947207a03e8b1916d41a48232ff272d30a4bfa061da61b","merkleRootHash":"0x61224122ebd1b195586a6743e3aa884e8a13fd38932c8534ad84588f0dcdf6e6"},{"version":"0x00000020","timestamp":"0xfcefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x7a42fd5c3f834e272a78856354f0b18d7520617113ede35a4130d5dbc4c38253","merkleRootHash":"0x7f2521e67bf35c34a89e8f09ce35f69c02b8f560d219c1dffbd960ac2cb6700f"},{"version":"0x00000020","timestamp":"0xfdefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8af07f68ffd1199e899e28d35c97cc85e11d87414160de603b67eb3208c3007d","merkleRootHash":"0xb0994120cf506f44f7c43904147758a575e0a8acef85dda24fda8044d1cf4dbe"},{"version":"0x00000020","timestamp":"0xfdefba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xaa37e8aa94f00e1dea801ae81bd408436f50effb32189211d666a5d7401cb360","merkleRootHash":"0x4f68305122cda7f434ef29040ded29e027b67c1f517caefd4beb15c5e3acfa35"},{"version":"0x00000020","timestamp":"0xfdefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc8d84d1214c02f304cefb30818b3b7fc7d2ea1c6cbd683b6da48bb821fe10b72","merkleRootHash":"0xfd0754b1c32c21f3eaaf344315c2f24d081ea71009c77a2df0ea4e104c0640fb"},{"version":"0x00000020","timestamp":"0xfdefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6e91833d538bf30d084b482a841c305a139b8c3074e64bf23385dd13b4302f16","merkleRootHash":"0x1d8ef2684465a24d28e73cef4d9f4b2ce37ac702dfc5a73a19de30e42257d9c3"},{"version":"0x00000020","timestamp":"0xfdefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x775eae3b71976646758d854e742cdf3e4294928a26bbae62d743c33a40131f29","merkleRootHash":"0xce2097b16c3a6b804eec4a9b212225c63da326d3daae1bcdca63478cf29ba9fd"},{"version":"0x00000020","timestamp":"0xfdefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x979d44136e3170ceccd6c0c02cd1c502f7e3b5b1d63daf6e62424752558b4e77","merkleRootHash":"0x5cd260d55da197e4eb0c24fca6b03733b5737d80d4c335804a51900a21dcb8df"},{"version":"0x00000020","timestamp":"0xfeefba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x0663d1c90396aa7ba471d366cccd7dbc760e3fb38d7cea2706e4d2ef3c2ef001","merkleRootHash":"0x5c1d05c7a957eef046179a1b7f2b12f4ed2e26e6019b14c45d6681fcf4a8a81d"},{"version":"0x00000020","timestamp":"0xfeefba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x29a2c339169339503ea2f030d9d94f0b7e3fd13902d78213ad52842bb6d20436","merkleRootHash":"0x34efd038def1f8753a2c961585faf47e40a6d0d09cd840f810cbd1744c9fe9d3"},{"version":"0x00000020","timestamp":"0xfeefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf90b72da9e3ef3537662744e1c9161edd4e6cf89c8393f2037bba073a5b62b0a","merkleRootHash":"0x2816ea9c3864a9caa11c8c1f23b22816adc0af681e624b0d35334a9f8bb0e3c5"},{"version":"0x00000020","timestamp":"0xfeefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1a8319fa4bf90266b2c6faf42f876b75b19a9d566e31902f2288cbfc5650f65c","merkleRootHash":"0x43ac64c1badb7a64cced1ade9eb2b0ad6cb35b98f2cfca403b9c8d9c0709ef77"},{"version":"0x00000020","timestamp":"0xfeefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8f52ca997d0c87ac53be1a2bcc32ca74ceab8188f434d374b5760864c6915116","merkleRootHash":"0xcc6e28b4b550f23ab12c20afd96144227bbfcda6fd98b4fd3919bf322b3e1b7b"},{"version":"0x00000020","timestamp":"0xfeefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9c016de2d5a697da26a3ff9dd057924f03e4f8adf510ce1201242dd23ba58f6d","merkleRootHash":"0xf0aed795b52273d7adb58adb1afe8dd89ab578fd0a576b4decfaa5d8a872d02d"},{"version":"0x00000020","timestamp":"0xffefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7f4a4626d89d4f4401e6f8e65135bea7b67443687fbcd3b3de170c41e8384830","merkleRootHash":"0xe4abbf6798ec5b84a97e295e2059631c2f9fbd18a1534fb727849c92b152d5cc"},{"version":"0x00000020","timestamp":"0xffefba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0c47dabd7e9679daa62813a063d06fa2d32d018dc7e8151e9d64d3c9574ce711","merkleRootHash":"0xe3c54125580b808dc15168dc113fdace4764f6070fd2d20cba52503fe65b1a19"},{"version":"0x00000020","timestamp":"0xffefba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x325c6a719d64f9a084a8269cf00ec9e07e6c66236c2dab744e7d0515b08f792c","merkleRootHash":"0xb431aa1556a89bad4fb1c3fd8a7af7ffc08b28e34826c77bf810c0fd370c6712"},{"version":"0x00000020","timestamp":"0xffefba66","nBits":"0xffff7f20","nonce":"0x07000000","previousBlockHash":"0x83861cfbce14668d839d649005759e273f427a648d8c287d747221f562113857","merkleRootHash":"0x09bd2e3e9ea629d79b7b8587071d1574942165c552bc79a0af86f8bf935fbe25"},{"version":"0x00000020","timestamp":"0xffefba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x8a2bae95769e0e0a57c5d320f1782974800d2fa5799dfb91b2795fbf701c8d4c","merkleRootHash":"0x5b5c9152f6246c752c2716359ab477ccf368151cfe427fca93f1560f339b2ed6"},{"version":"0x00000020","timestamp":"0xffefba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0xa82e73cf65ea944570ddb5fa96bf9c261f5562567fc380bfbafbc82ee9d83651","merkleRootHash":"0xaf468bf88b3294a8d4896e6cbc8133fc79c230ab1c00344b9639879c1e25c3fe"},{"version":"0x00000020","timestamp":"0x00f0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xe63e630b929e2435519f2d5455960b45ca3a0443966c7050b76917ba234d8b75","merkleRootHash":"0x2b0c1a7bfe8173383c5cb17f87d94390051c557f537dc0a859e7b0f6d06e5a2b"},{"version":"0x00000020","timestamp":"0x00f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0731bf3f1fada8c3c35cd600e898747b3e905f471fcd0010ecad1961d7f58475","merkleRootHash":"0x576d247e42452cca01137fb105d2bd167c74639822b03effa927c5b43de52ad7"},{"version":"0x00000020","timestamp":"0x00f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7b9b5a110daab650ece13a34feba69e1a43996e907205933d9562e7cae28dc42","merkleRootHash":"0xe021a680fc9fbe06cb3d2f861d1d43dde5a269057c91d4a81187a3479fd73c2f"},{"version":"0x00000020","timestamp":"0x00f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x22bb51f565f40dc0692c570e4c328e3dbc595fafeea976f1a06aa62afd1c7507","merkleRootHash":"0xfbe939c7a2fdbf72dac1f3862fb9ff7fcc2b36c5e9a1d80dd1fab54521735163"},{"version":"0x00000020","timestamp":"0x00f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xec06e8cfc0cf1dcba4db677c8639428a788b626c8ce1a70e91326589d7ba970d","merkleRootHash":"0x7755da0db22d42453050f227a4b71ff57ce2ca283d730b5f3d371d20a1ca801d"},{"version":"0x00000020","timestamp":"0x00f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1d6a7f7e1797740a2fabd2f610d20986869e798f91ba1baae391920a49b3e219","merkleRootHash":"0x2fb29280e85938033619e8190292b46b393d618cb19dda5fcf88d1d8eb0b701a"},{"version":"0x00000020","timestamp":"0x01f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x355436afcecc44de705a9a458c1793dd30d265b02328fda4f15786c7cddbf530","merkleRootHash":"0x169972b8c7756bb96be069015c2a73a5920a1fd1c52392fa724587e935fbb15c"},{"version":"0x00000020","timestamp":"0x01f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x554599f87f3d2c83bb9e6a9ead3abd50240fd0d37d47212f3aa5c7fa5bf13426","merkleRootHash":"0x045997f2a9bd26d62299e53dde873e9f2ed79d3438f6bcd6e435be2c1484e9b5"},{"version":"0x00000020","timestamp":"0x01f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x331eb963668d38d2f2fe8994e8873aa876ff236493e49fe193dab3a04bc63b3c","merkleRootHash":"0x031f24a5154147aaccf88949aa1f67a86b4fb9165f790831f6fefa20378ac571"},{"version":"0x00000020","timestamp":"0x01f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xccb6305f1d3567d4007a48a7d987ac13408b41e81be7736e01947b28bf42211e","merkleRootHash":"0x324b9aa48fb6be0bbcb0e4573072255f70298d57333eb9324dc3f162ada341f1"},{"version":"0x00000020","timestamp":"0x01f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xcb3a4528f008667081773f492aef9ff91e60640f815a91f8488e46ee8deecd34","merkleRootHash":"0xad9ff6c165674af7a859804fd7b48be8bc8efbcb8e638dec3f46f69187bb4d0b"},{"version":"0x00000020","timestamp":"0x01f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x42f2f25d68dec948bffb405e50ae6e2600d3dddd4439734fb8527b2c9d82d600","merkleRootHash":"0x36cdf1d1cc5ca2d8b584bffef122cc421aa9675495d249a90c5584a527dc4ad2"},{"version":"0x00000020","timestamp":"0x02f0ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x96e927d840f725b1266b6f3121627cda92184e1de40c4ca175cb124228d92c0c","merkleRootHash":"0x941feafb7d3fbcfbbe8eae804eb184c8941f87b50b9ca0507516d5b228994b89"},{"version":"0x00000020","timestamp":"0x02f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x05126a81e5f9823c24548dce3540ecd9d701e9446d8423afdd88c3b67577e608","merkleRootHash":"0xf6510e5b69bba2ca629d332dd54dadacc7b057ec92dd75a7819bb62588f9bd6c"},{"version":"0x00000020","timestamp":"0x02f0ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xcc97a7d8446f193328362208fda380190c6237c8ed0ec127595139fd54f59417","merkleRootHash":"0x4dabcb7f5f93e0fd3b91c4a571a159580ca88fb1bc274d9690ff128e0ae9623f"},{"version":"0x00000020","timestamp":"0x02f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5b561edc5cc9eb61b94d10abba1cbec6b966842abe201b7c17192909418e915a","merkleRootHash":"0xe7920e35eece691b35d3122113e53da8fa8c48b097d8f4399e8f43ca20f9de16"},{"version":"0x00000020","timestamp":"0x02f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xea2a55b7168f21b3152dce27ed64929867cf884f6895a4e692b298c182ca347a","merkleRootHash":"0xbe525f9c1839a433c15555f559baa6c403b684de5a7d089a097b42b193d7700c"},{"version":"0x00000020","timestamp":"0x02f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe8cf460756238ee0ab3216965320e5e0f1f9434f61abf546bdcf42660101da76","merkleRootHash":"0x34fff906296118b767709893f0e3759101254d0c03939f600d9c0185f6f381a3"},{"version":"0x00000020","timestamp":"0x03f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6b03a0fa3cecc6d106e6f592eae02ed38571c8190af2e78b222ea0879ab92034","merkleRootHash":"0x84870b0c4cc8b364155ae9027231a040a26d963004832e8cdbdb69e1dc9a7156"},{"version":"0x00000020","timestamp":"0x03f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc1c810e1aabc0d3ca32a730789bf02f45d929057df67d4e0f222a21537e33255","merkleRootHash":"0x70a8f29b593a6acc3f012ce5fd1b4129530a1871d60fa58804801c97a532b797"},{"version":"0x00000020","timestamp":"0x03f0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xa7d6c2f169f719d1b41d471b1fc3e74f39bef3f8a5b95414eba82786dbf06241","merkleRootHash":"0x414dad0f53f5b14a23e7c91a136b666f4aeb770bc5c90808f9ef3a7a6b881814"},{"version":"0x00000020","timestamp":"0x03f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdffb87e6cd46dacd388f0d5ced0395880b6c11626b3c41a2245ed2f127efa445","merkleRootHash":"0x005c04adf60ed034bd06c20a3969ca3413fdf0eb978c83b47938c02ad659d30e"},{"version":"0x00000020","timestamp":"0x03f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x17b89a60be2167a9bb84518c7cccefd976de15282a15f111934a6c1e54e8634a","merkleRootHash":"0x4c8e225e53b703b3842b0c2e20914eb02a9b84861efe9adb666fce8aa2c95051"},{"version":"0x00000020","timestamp":"0x03f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6fc97a412466c78591efec8b7e0c326f590cc825d1e4ac096c4e57efcd355f2d","merkleRootHash":"0xdf1f1dd1e268468b90b5a331aecbd80689694d0e67ae8bb59c6859ac99135325"},{"version":"0x00000020","timestamp":"0x04f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x32399ac986a23bb859de12c283d462bcb6729f48eff017e0184f73e3c12fa62c","merkleRootHash":"0xb297443f14269ecd217e445355d07570b3c3f630ba187ae546ee5678d3936949"},{"version":"0x00000020","timestamp":"0x04f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x20ed0f0abd6d8fbb1cbd19a7348237d4940dd85bb090ace742e4d2c3d9f88744","merkleRootHash":"0xa2d8b2c1ddedf3e1361d5f6832768df7830d8d307c0d4a21b11533a5b0e60594"},{"version":"0x00000020","timestamp":"0x04f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x074f0e0e97df01db135563d3c7efd4bd1416680b98da06408698afa80767ff2e","merkleRootHash":"0xc6353945e37a37e98afd3b264bc9d7eb457160759ca6e496fe37f5e257cc0f19"},{"version":"0x00000020","timestamp":"0x04f0ba66","nBits":"0xffff7f20","nonce":"0x06000000","previousBlockHash":"0x39df6a3ccd49321ba3a2498c98eff01089437671136a9db9e441c053831f853e","merkleRootHash":"0x9501b5af6cfa7e2d9c8ee3e4e326de21f57c744612fb8b6e96dd3b17164883cf"},{"version":"0x00000020","timestamp":"0x04f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x02e1f383e71f6dc5c88b6f73ae595451f1dd17aac64f558c6f62c321f301db65","merkleRootHash":"0xe4940025a9d4580c94cfc730abdaa13851477d7d691ff11344a3eec593cde926"},{"version":"0x00000020","timestamp":"0x04f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4290f7099265e11cf628c478939de2faa05dd2936e7b93017411a1dd13b0d27d","merkleRootHash":"0x1b4174dc58beeede60c17c7f7154403dad1f2e427145227080b35fd4769581d4"},{"version":"0x00000020","timestamp":"0x05f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd540fac8f6957cb3fc5bd901d40240e7a127a05f87dd0a4953ac80670285a318","merkleRootHash":"0x2b44f55a970f3b306a9ff10a05d7a5b668e311f6f8af33f09bf5711029bed9dc"},{"version":"0x00000020","timestamp":"0x05f0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x5099f735ddde2898a6e08a146d7b83ebf76828128fcb48888b902171ce7f4019","merkleRootHash":"0x3f31199c95149e94dfd0af57630b60e1f83f5ed1ab0e7cac330546f6624f0d30"},{"version":"0x00000020","timestamp":"0x05f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe99241cd2c911433218081690e01fd241f4631bb62b4680cfe7c28a0326bf449","merkleRootHash":"0x1b9ba830dcd9709fae6df0ebabf4d20e1027c1b9c623ea8a8e9ea5e0442d144d"},{"version":"0x00000020","timestamp":"0x05f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xda18de1b6664989ba94b954349f80638d6be79d620cc850f1100c302adf65b3b","merkleRootHash":"0x93c66f5d7a069f46270e34d40c55ef386b4b2ac42c9ad33df61bf9fc6562bdfd"},{"version":"0x00000020","timestamp":"0x05f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x02f862887de32e3c29d5212fa62cf8e763c36e577e57dc9fe0cee7ddee168a64","merkleRootHash":"0x4a8586e105af6de30f8f13456324768e23fa3775330ad65ed29994d37037b98e"},{"version":"0x00000020","timestamp":"0x05f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x60ff9994f60c75227a7148ec153ccf3f308f65dd988e93ad571190213bdcfa6e","merkleRootHash":"0x6328d64b3568bbc828ea80fd0f0efcf055f887bcbb27394219f9bf8ef81f4fb9"},{"version":"0x00000020","timestamp":"0x06f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd556ca8a4ded1f1063f686c8c16e74f10a8f8c321877de49361525e2c536264e","merkleRootHash":"0x4f4bb03da2fe93937809d6cfa720d0aa2e2c8d911baca2e8c1723cbe5784dd6d"},{"version":"0x00000020","timestamp":"0x06f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x184cd961e9a3061de1cd912db5f07dd5bb5cf702c403991b00b2991968ac3678","merkleRootHash":"0x2dfb00e3a56f6111c9e7c6919ee69e5d2224039b33c6da62f7ad7298d4762184"},{"version":"0x00000020","timestamp":"0x06f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe91972b124cd060830481a058127c95da7cc187aa1d88f2ca3e4194c795a7253","merkleRootHash":"0x95219d81299bc50ef1b09328a65e54d5e8f9074af77a0df3b6a7360db671aa4b"},{"version":"0x00000020","timestamp":"0x06f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x89a93f197b52c13ed91619b5f3ec8377b937d42f658417de558f47564bd9cc5d","merkleRootHash":"0xa29345bf2e4b16f0561b701cabc414ebec2d8c37ad7ebc266a9fc04f5beded4d"},{"version":"0x00000020","timestamp":"0x06f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdab0807fe1f668ece2d5d3b35055792726946b8408209fe0536f38bfc78c2543","merkleRootHash":"0x1ec3a2f8a986c1073895d0f19397bbaf05dff3d37916e4b0da5912c25dab133a"},{"version":"0x00000020","timestamp":"0x06f0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xcbcf33a51d67c0efae47d6c9e923026fcfec6a37c92acb5c435f328f1ed88b6d","merkleRootHash":"0x28669656390b5e29cd9b96434ec1874dc429fceb9e199bfa2827fa9564057c15"},{"version":"0x00000020","timestamp":"0x07f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd85181b5ffcc1bffed8325f6bae45183695031946366dc0b40e0649643cdcc08","merkleRootHash":"0x23f29dc5a8d604966954e5011c14dae540aa848d50462ad3207ea89c8e419433"},{"version":"0x00000020","timestamp":"0x07f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2f53d21980c608d0123262cdede5a60c9216cd759131e8454317cbdffcc03a2d","merkleRootHash":"0x2445e32c172c0e9a1c54cbcbe6b6991ea5dfaf59f5689468ee30a4442ffb89a6"},{"version":"0x00000020","timestamp":"0x07f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2bdc65bbe27897815196bc1fdba028390a3a600433b2e03463b3797a974cfb22","merkleRootHash":"0xc746d9bfeaea25d8599b89d3e81f5652316ddcc475854b50a011a964e57f0127"},{"version":"0x00000020","timestamp":"0x07f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x1e182e327f8dfeae51799912ee2f556684cb244ee618f4038284beddbe9b5277","merkleRootHash":"0xfa7fee63f2c98db527b2eb735bec5ba8017878d5f9e3b0983953dacceda65327"},{"version":"0x00000020","timestamp":"0x07f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb07a149784aacf7203797471242b568be2dcd18ae07d85f9a895c1d380d90a43","merkleRootHash":"0xce8aa988f5200caccec4d40d37029aa1f99ed548aae5255832ac74efc82ee853"},{"version":"0x00000020","timestamp":"0x07f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xc3f122d9015e0acee446b84aeabef9c7b4e8345aca41b27dcd5ff58ac56c1469","merkleRootHash":"0x87a1ba545c763188f87f661c541b8d871d446e72ebb35cfddc2d08fc2ea95120"},{"version":"0x00000020","timestamp":"0x08f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1cfd0af7c1aa91da5827427256a6c6b28094c9250a99a7da2ac087c1c7301e5a","merkleRootHash":"0x01005f502b10465ee279ff580f1a39aac69129cbee172fd94efaec0d0afcd44c"},{"version":"0x00000020","timestamp":"0x08f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xae4b7e304ceb81b3a019b118bfb08f1cfcb9ea773b0bb47250b6a51b3666265c","merkleRootHash":"0x5a879c715afe43a75a8ba79030fba9c490ee99099052e8d1141de6a0e5ef5564"},{"version":"0x00000020","timestamp":"0x08f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc9dcbf1378401361ce77692dd4b3f4b489e40a4630279bbc43d20e10f2ef135d","merkleRootHash":"0xdd89159399374874f7216eec7dcedbcad562606edb444977910bf37a66d52dc3"},{"version":"0x00000020","timestamp":"0x08f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbcc407889d6fd7fbb85ebf9cd4bee26fdafaf7e0e9a537b8eb33dd8ee6b3cf0e","merkleRootHash":"0x5203ee712875ccaa207ed7821f28ead2616cfc2886dc5d1b8134d511824bfc48"},{"version":"0x00000020","timestamp":"0x08f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x8c416cab8bd69017ae704b6c1080c07397aea6c05e2a7e7b1b5b4e19b5faaa42","merkleRootHash":"0x7a54ec30fb3506922c635a4ca24cdc87ed52facc36f64c75c6086ffbd43d3e34"},{"version":"0x00000020","timestamp":"0x08f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5122af6be9a920b4ae0e76d28a7f2f6b63cd941105725ad396dc8968a64b7b55","merkleRootHash":"0xbe3b74a016d93e31d4110ba0061fcaf83f21897d5f09c94b186dd8379f8e4294"},{"version":"0x00000020","timestamp":"0x09f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf78b07c0ac480e05453ae27602970ac0342733128fc4a21c737abcc3d2b59827","merkleRootHash":"0xa3e5f5e3417a5eb2103ba6b8a7e0089b88a573dee3782f72f0113f47007b0023"},{"version":"0x00000020","timestamp":"0x09f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x210b66081a979179410dbbbb820347234da8e7cea0fce6bc30c2b7439755f248","merkleRootHash":"0x9e515f3bcd1b7ba424d2cf93fb81eb2377018cb3991d7281528facea965a93e4"},{"version":"0x00000020","timestamp":"0x5af0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1394a8c783eb01bad22149596a17b8b8b1f0acf208fa3f4262241d883d46d751","merkleRootHash":"0xd1f165d6ec71b89aa9223bf92adf257c5ad53efb24b702ab6c278b619cdedd10"},{"version":"0x00000020","timestamp":"0x5af0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x76bf5be938c483f514073f443635587d50119292939f2abd2c74059e30b09b41","merkleRootHash":"0xe0419802c199b7c9b169c7306bcc2f2824f7938952d8922c97fe7a2f75c9f7d5"},{"version":"0x00000020","timestamp":"0x5af0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0f8aeac8c3ea95257fae5f7b785ee6eedb476fcbcd9cc56e59f8a90702bccd51","merkleRootHash":"0xf0755d73618e20128bafc8fa31c909d117e6a0a07b0b86927b83bff423170927"},{"version":"0x00000020","timestamp":"0x5af0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xacde85e164b670a1c88020e42f269ab17d39fefc8f01d0bc311960b80a68c115","merkleRootHash":"0x42f15dd093428c1d7f5ef228b82f3913bbbee5c9d74163e844116214524406ba"},{"version":"0x00000020","timestamp":"0x5af0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x2c236e9fbf50b88c1984ec56d8e03cabd5890fe386508a39492cd85e779ef149","merkleRootHash":"0xf3659ad21de8f8aec6df5a9e0a2aa4983f02894e27ba1629da50d673bde20859"},{"version":"0x00000020","timestamp":"0x5af0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x668c6bd4dd86440fa8ddcb5d83eb4c3d351ea675489354d17a764648ddb49f72","merkleRootHash":"0xe50ae8bd7b30634e219de230bb980cee1bc1ce81173d13891b61fbc2679c895f"},{"version":"0x00000020","timestamp":"0x5bf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x402326143978cd7c114ec41f12aa4c383558b98dd4392471474d1650b3134f0a","merkleRootHash":"0x5044ba0ddcfe9a1f1c5cfd4605fd114e9dcae50006432fa81c3fa1a786bc3d77"},{"version":"0x00000020","timestamp":"0x5bf0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0aded13d0393f9bd76288f0f96e660a2cf96222ea9136d13eb8caffa2af08312","merkleRootHash":"0xd55a6a85a04736506e7876a3a207038ec177afe51fe5d6833d8420598208b530"},{"version":"0x00000020","timestamp":"0x5bf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9c8ed317f85e97f8309a119a8752ff448a9cf11aef2586a67280dfc088cc320b","merkleRootHash":"0xc1a15b20595d6da20f697aad7d0db79ec902dbbcc4cfcf1cd133b0e11b6948f9"},{"version":"0x00000020","timestamp":"0x5bf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x01052820d3eabf2c6193c4859e4e50a5091a71f45d5f96ada0f6eb254782a265","merkleRootHash":"0x9261dd92f190301b3ca6ab965a6d144a22b756412452828ace2f457ef5511f9c"},{"version":"0x00000020","timestamp":"0x5bf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd65d6648d098e94f10b549f966ab5df156cf30236216c6fdf0020148cc19b743","merkleRootHash":"0xf1dd38d2343180883eb2d6ad9c37ec92adc1cdbc44b8d6ad3e1772f375e88346"},{"version":"0x00000020","timestamp":"0x5bf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x957073c4adcab45c404f46e511c6521375ad2435c094a9f4c3663b2ff72aa86e","merkleRootHash":"0x3dbf9758f22c68e919a955ab985d343b3356de199e97ae1740f2ed4816999712"},{"version":"0x00000020","timestamp":"0x5cf0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x80a6366052059228136aa40a9c6ca4f778eb37e610f172f10de210b31e18b71a","merkleRootHash":"0xcc092efc18f62e616aead09948f87c6a0fc99b0ccf71e95e6f87e0eb082642f3"},{"version":"0x00000020","timestamp":"0x5cf0ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x5aced0280cef8cd919e1cdd539f340377b07579561c318c825bbf1eee1c2e865","merkleRootHash":"0x5309b5e3ea6063091b0a260854e9ec0a00f30ff070ef9cf1666e99a4d2ee5624"},{"version":"0x00000020","timestamp":"0x5cf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5b9694690ff6c0dda13c79831791ceeeb8852049e322d0498fc45b9fe8add139","merkleRootHash":"0x27a07c47291aaa430c65a755d91d7fdcda13295914f109643bb6f25f9419251b"},{"version":"0x00000020","timestamp":"0x5cf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8b4661fac336b6e949004caeff38a5f5d6b108bc399c7cc9fdd0b64105dc743d","merkleRootHash":"0xb217425304e6072d1d4ca0c85d6c1ed470db81980a460cf94861ebdfc2460ec9"},{"version":"0x00000020","timestamp":"0x5cf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x770ffae518d5206ca78ff02aecd861119ef08b0842aab4d9704425ef54f1cf75","merkleRootHash":"0xbf446dd9bc7519704ae1ac2bb6f4096ca5ae98337c26c8d05ac97d251f230c14"},{"version":"0x00000020","timestamp":"0x5cf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x88ad0f88dd8734d0601ca87d875e19e6a57e57aaee39585a26ca10698dec5a7f","merkleRootHash":"0x3c9d14098a93207caba230efc9ec5e1cdf3e48323cb2bc4739bb354232b680a4"},{"version":"0x00000020","timestamp":"0x5df0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xb58b24fe1e4f5189cb30a06d353e95f62fda3da4702af55d9a6c18cc8dc5b148","merkleRootHash":"0x078a24b3843921eea14c61a1319ab7d5d8ab88b1c587f8aba328571bae9fe993"},{"version":"0x00000020","timestamp":"0x5df0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x64a530b9a3e854860d4907bc3fa7cbca0fe16d64fb695ad3951e6504434f6a11","merkleRootHash":"0x418e67abacdbb240d7167cf367b421f0d445591f490a2395ee73745ac57c162b"},{"version":"0x00000020","timestamp":"0x5df0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7ebb1333d774431a6a590d28ff1ec5ea2fcef4cf3436dd3a902a52f9e977117b","merkleRootHash":"0x1edb857c218d65d3bb406e5189e945d961490c8ebbb52c482667d56fd00b433a"},{"version":"0x00000020","timestamp":"0x5df0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcb1a4175f679415538bb34901a4ffab67e2ae4d529e4cb70ab3331b0608f9b06","merkleRootHash":"0x4061f1626ea4954d6684caba516faea45f1991b10bf3615f10e01049632f579c"},{"version":"0x00000020","timestamp":"0x5df0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa03fb93c1ca74bfa1d2c2917b1dfc7e240c3e420b8d19c600c76cf7f920e6a2a","merkleRootHash":"0x6eb84a82b5cd723d7691f4184088f273355daf175e9c43484fee24c6a59c9c72"},{"version":"0x00000020","timestamp":"0x5df0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd7b90dc2400a06aeff46703b402a7c4feaae22525e34583df8934e8397586c67","merkleRootHash":"0x506a3203f9229c7c5083afbd4083a1f8277f3bdaf13cd0542620b93e363a223e"},{"version":"0x00000020","timestamp":"0x5ef0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x39c68381c48702e84bc8f5f9df8fe0f820e8f7b0714d0b378abe0f2ce28a9427","merkleRootHash":"0x2d75d75984a476112cb28c3d0fd662d4cb83880f071a11ef855eb0fbc13c7a5c"},{"version":"0x00000020","timestamp":"0x5ef0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x05d62aea870ea253f9763a33f998bddc28ad3c579e69e0aa9cab940d60195600","merkleRootHash":"0xeb5da6b975a18e7aa53b4eb2a089b7175446ef332c8b618991adce46c29a2fbe"},{"version":"0x00000020","timestamp":"0x5ef0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb1dc6a34100b028bb30b054869ac05196bafae950af98e2f8f3950cfe54c1b07","merkleRootHash":"0xe4e6e9dbec0010bd92e3c6107693a5cc04024df492e880d60cfc754823a710a4"},{"version":"0x00000020","timestamp":"0x5ef0ba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x394e5ddd40a084175699057c1f6814763656373bd40034355c8dda03fcb23141","merkleRootHash":"0x3b6a6b9cc58f9ee7d28ff396caa72b2ead3295cd04f7833222b378ba1ed2c018"},{"version":"0x00000020","timestamp":"0x5ef0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe55009403a0c723abff10dad289f6be201e242d3f15812a6d354b211a6124b0a","merkleRootHash":"0x7551ede58f7cd4703f00527a743d2ad1c6b81bb16a7e154eb429d5e5d0fe4d04"},{"version":"0x00000020","timestamp":"0x5ef0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa9cac0ff819b85448da0677cb47c5cedc41ef33a8835840f2abca3bd27ed126c","merkleRootHash":"0x1f275b8af0d11993ce401e6559529694b771984de2554f888b03dec4ce4bb4ef"},{"version":"0x00000020","timestamp":"0x5ff0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xde5fe3264467cdaac3ebbb1ce3963bd16a9331068aae50fb0229060b657b7509","merkleRootHash":"0x5773bd39542105fa2e2bc761d44261d9597b309793bc20318ac0a8a704c86229"},{"version":"0x00000020","timestamp":"0x5ff0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe26bb895fdc53e972d6de138669e566057aa22fa2513414b3ce60547748ad518","merkleRootHash":"0xeef941c91cc8348d6f27120ae94f2b2d2411a4b972e01644eab86c84b910b57b"},{"version":"0x00000020","timestamp":"0x5ff0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x36ebd821e4bdf77c124d260a46ba318372a9a81960d5e227fd629db9bfd7ab6d","merkleRootHash":"0x5fac7396a3ea0fa3f9228bc4bc7f2c22d6f70e0265feb49cd6ce8d225f036989"},{"version":"0x00000020","timestamp":"0x5ff0ba66","nBits":"0xffff7f20","nonce":"0x06000000","previousBlockHash":"0xc504941761f99b5a108b48c83bb8ff9f9af7f374727920261e50e06344d62e38","merkleRootHash":"0x7ca343a36905efaddaffbb6037b72b2c4442754faed42904db63ee7b0a60c918"},{"version":"0x00000020","timestamp":"0x5ff0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1fa442aa57cfd56094f233e1c272e7202e4b814922410c899ac7726250b80e77","merkleRootHash":"0x49d3086eeedf61185fc78446eca6463f8cd7671243b5c3660157b03a65862930"},{"version":"0x00000020","timestamp":"0x5ff0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc51af35b75b46c8321b491317b8593ccad53627a60a74b14f0a25cbc56c27c2b","merkleRootHash":"0x3a47802f5a94099575f5a286a0eca5554a893ca1e5d657c83435eb551b16f2b9"},{"version":"0x00000020","timestamp":"0x60f0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xdd5938b704a21d44a50962475cb188278ae801cbf1b2871087aa0b7f6abccc52","merkleRootHash":"0xc8daf6d6dfdeea4bd58e0926e6884bdad5384430cea19c3ddb6167fc9ae96cd6"},{"version":"0x00000020","timestamp":"0x60f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8943ae0f728220f637d8cbe18acba76ec6992c1ee0bb516f98af24a3270ae314","merkleRootHash":"0x4c65213c71010f6c8bed62c839c283d8af5523c20f5c0bfb5f7472da090fe9b7"},{"version":"0x00000020","timestamp":"0x60f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x9d87d9421b2e80ebbda6ddf39b1c033445dd917d5d194b9863d248533f67191f","merkleRootHash":"0xa40f0445b46c194bd7a8e9142ff01a457cef2a419b85680c5cce31a9d19673a4"},{"version":"0x00000020","timestamp":"0x60f0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x00365d0404658b28aef6a3d2edb55c44b005d4f7b5c2b2b71d1e4d8eda74cf71","merkleRootHash":"0x095e9d4b182a672515ae3346e5d1ff266166ad05f65b60b1af8defc39d7a3720"},{"version":"0x00000020","timestamp":"0x60f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd526f175b7f42388b633593f44e6960e44affe0568a8e573f62d4667a9f52945","merkleRootHash":"0x4f3ca8b94388b48c48e133380b296078a1dcff5fe49ff28bb5b2175e8d01b840"},{"version":"0x00000020","timestamp":"0x60f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7631d2d5d1e89eb77a0702803b4fd1306e59683ad6b1b1bf67d3cfc94b8eb133","merkleRootHash":"0xe6a082c3010a40fc1ab3bd28f4f19ed4b03d4f34d196426694f643b153c8cb39"},{"version":"0x00000020","timestamp":"0x61f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xfcdde47d2e053bfe455accc65f8e491a53131e8a550edf15e94bb0985e842f0a","merkleRootHash":"0xa516c8a5874b7e5e440c5be9d7fac648efd8f78049aea3c9f9333b874a5eee55"},{"version":"0x00000020","timestamp":"0x61f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5823abdd99d5064e9da7d19d29ed13b7d223edc7a8e6e5e92db9392feefab369","merkleRootHash":"0xb9264e5a2b7ef214c877ed2930a8963fcfd4931e8094fb52528c74c27a29f934"},{"version":"0x00000020","timestamp":"0x61f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8d3f841635e2ae68b14d86d273b4051a2f74a3b8daa062675ba69c7585245844","merkleRootHash":"0x8e76000a826e156759c7a0a76430c2b55b4c2f12e9a3585947c51fe5d3e4ebfc"},{"version":"0x00000020","timestamp":"0x61f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe0c3cabae722b3543ee11b7c00be644d31f18b63030e65170146520b9d923444","merkleRootHash":"0x2f59d3f7f2e6ab614d83a6b696067fe6a18271bc8694a410718f823c321b621a"},{"version":"0x00000020","timestamp":"0x61f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xef9d88d341038164603d27f1e761684b959cf4f007fb6434e5e0808409e9c647","merkleRootHash":"0x6574c9cb7420a731000c5d55fb2478ab949da882d344afd2608a551703ce0ebc"},{"version":"0x00000020","timestamp":"0x61f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb9298c581b631a9e465cbeecf8f8d561b04f477da544aa9d234a4c5ffa183d48","merkleRootHash":"0x07d56e31adbe3cabfe8447b9dae4b502aa2bd004aadc8145c7a4770d38938328"},{"version":"0x00000020","timestamp":"0x62f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x511af1a658ac3927d2079fb18a5b69720c738c59a843b0dbc8852e0c9a6fa171","merkleRootHash":"0x40f8df5c00c2e3821784efcce71e310dc58c685efa9989150a71fa6b06aeec06"},{"version":"0x00000020","timestamp":"0x62f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x902720a299d1751a9f1376ca282594eb4f98bf3dc6954667d24c20ae7f2db664","merkleRootHash":"0xa6e05ae1da81570131e67913ed351ff731d9ad1cac05bed08eeddbb7f4889040"},{"version":"0x00000020","timestamp":"0x62f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8017c1ac1f4e6c9ba4ead8674362445561982ba52d8ffb62a17c62a29ae25633","merkleRootHash":"0xb4ccbd41092868442b4ecc04c5058c5c6620b37085dd27bed99a619bb09ccfa8"},{"version":"0x00000020","timestamp":"0x62f0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xba77be0b7576824c15b91fbe2f37eccdb3bebaba42d5e0baf0e459606a45f750","merkleRootHash":"0xaf23a498a13c20a396214e26610cd2da0c3dab6daa3e709e624abf0d1c14f775"},{"version":"0x00000020","timestamp":"0x62f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x20852e5e5eb7e07970a0c4064deea007dfd829d6d979489df0b0e5796904cd15","merkleRootHash":"0x20b7ba00f8bedcecf92c3b09d000129b6cde6034bece9fa85324e2b8abc22997"},{"version":"0x00000020","timestamp":"0x62f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x94f43b8f8e5d1dc9b9606ac54d3f116665f62477f3faaf0642685d5542222505","merkleRootHash":"0x1eb22f68455a2eb17a90a98e0dd4c26ee46d91aac6c93411362b11dc8ff58b90"},{"version":"0x00000020","timestamp":"0x63f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa8d74c4745e0d5becda1ad36cb16564728f8865861753729c7c47ad26d069012","merkleRootHash":"0xbe9145df78018aa538856c3172559678f0e0b5e9ee5d6d5889689dc3fa0bac79"},{"version":"0x00000020","timestamp":"0x63f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x19dfbede6c5a0432a88132c5fbdb6f4e36f84dce23046d9175addd94604dbb6c","merkleRootHash":"0x80d2e2bb400c7769f75484e06aa40e4c870b711055fe1a0f64b39a08e8accaf2"},{"version":"0x00000020","timestamp":"0x63f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe7b8c6edac63a9df19517d75ccd476c753c50339847bf7153707226e2a7b9a44","merkleRootHash":"0x8b4fb885038fb9a20f7de94af2209765d6449baafd724bc2e5c8561bbe45a45e"},{"version":"0x00000020","timestamp":"0x63f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xecd3e0431d903fcbd339339850fbf89e83107efa606c67510ac0b6d290962163","merkleRootHash":"0x506c2797ef8d07a02a7602fab53bd3ec4953aef4360ab3f327f633415db9f155"},{"version":"0x00000020","timestamp":"0x63f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x327a63ec515581206aa1c6db31fcd0cca582b5bc7983fc7413e6681cf340a03c","merkleRootHash":"0xe28e589182c5053157c2b17bf8bf8974891ac42fe0d109498d38df28c233d197"},{"version":"0x00000020","timestamp":"0x63f0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xe06705c089d2b3299634253879c90eb2a0f9dde92fb9e6c8b509a2064638bb17","merkleRootHash":"0x8ce29a6b5459045b5937e5e498e566c0503330c033d10f7ba288a4074f0c8b70"},{"version":"0x00000020","timestamp":"0x64f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0f1cd003426cb98053e81aaf2e3723649024bb19d733ec8ba04345dc80cce52d","merkleRootHash":"0xd39b9623acca5165dff1c55b7c147f7104dbe40be275775f1ba7f8b1b9c51108"},{"version":"0x00000020","timestamp":"0x64f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x016da16180568c17bf40ef89e88b7dbc4d7c2177caad4773443d82f0012c9311","merkleRootHash":"0x2afadbfce827ade3d50bc363ea9f3765d1bb975ff5092b3b99e56e6a6a90db10"},{"version":"0x00000020","timestamp":"0x64f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf94ab64a460a1fb2757b441a421b89573ae0aeebf5b43fe4679d5b85ed2de22f","merkleRootHash":"0xbf82136a0230c7970d8d78be444a8a7216f42ee7b90b366f0b1e6cd9c0ee0250"},{"version":"0x00000020","timestamp":"0x64f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd199d427705147d26697bd74e1399434e0609fd1e0ae16637dd0a131c286d822","merkleRootHash":"0x52075cd40fb6c6d7693abbce0caa6795820d20b77969d116dc421d22b2ffba4e"},{"version":"0x00000020","timestamp":"0x64f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x66fe5c29780507a125ca3b169b441c9d31b4d296408c33ee13da247559e46c58","merkleRootHash":"0x7d84e1e71e1e5f3d3683d7151969cb37a65e99d95e513ec81f01465b903a4d71"},{"version":"0x00000020","timestamp":"0x64f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2c29a8e21fadd1e8bfd64ff0f65c5e10c1168110da7c28ba9e598f9fa716f95d","merkleRootHash":"0x011a7ada9bfc6a64c7dc35f8520f35dd53a40cbb7780132a8b8868cacfc30d60"},{"version":"0x00000020","timestamp":"0x65f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0e05603f5fcaf3427c4ffec48af50df657c9ae73bc7dbf96333dfcad7131c021","merkleRootHash":"0xf21c36043717d38972d6e13ed7de2847e0b50af6a0a0e17b55023a19315500c0"},{"version":"0x00000020","timestamp":"0x65f0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x9dbbfec3ef9e5b88bc99c9b4d924391dc4ebbf675aa0afbd63636064303dfb09","merkleRootHash":"0xc66f9038f2671dae5ff2ee2461da187f3297c84e6662a95f3b6aa624c68811a1"},{"version":"0x00000020","timestamp":"0x65f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8d81800bd52d48d7b5005ddd8feff2c1c310a6e232c406e757e4ecfc08d7f539","merkleRootHash":"0x97bf050be3d287b8fc54de5defd6665684f913923575f3ca83de71119eb20761"},{"version":"0x00000020","timestamp":"0x65f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xc846a207694fa774b0e4c590e4f3859486a08b66da561aa99b3b0656f5662631","merkleRootHash":"0xcf15e8d2dffde95c26cbe089ad772f5bbdab7458536a70aa69f880ddb797f969"},{"version":"0x00000020","timestamp":"0x65f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2bbc0289ed8a4f303f226387f84492aec151158d7e5ac1df1ea07b518cb04478","merkleRootHash":"0x59ab29d3069b75af7f85769b0db7fc4bafa219b42f41904f292661cbab949da7"},{"version":"0x00000020","timestamp":"0x65f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x4531c84ab5288fc4718a6b0cc6aa3196f0fd131d784304c83d36811537204178","merkleRootHash":"0x419af03034112d8c42bb7209c1f8e8dca904cf73379a31d71659b2e14f08355d"},{"version":"0x00000020","timestamp":"0x66f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4376c1fb42f1285dcdc2c51359d00ef1a5367e3f65570adb998c9b8b8390c344","merkleRootHash":"0x7960907e23e20229964da749a8716322f26ea4d89134ac23218bc21b527c093d"},{"version":"0x00000020","timestamp":"0x66f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x80edc3f24d538595d1c16dc783a906a857b732767b4ba11b677a067248ca474d","merkleRootHash":"0xbfb74f5616142128e2d0709376a377e48116aa5681e7f79264d62d0ee6daf560"},{"version":"0x00000020","timestamp":"0x66f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8112db394eee619fe2abf75a7bc453de4dad12a784a2f95cb37488194e237c1b","merkleRootHash":"0x3ee6ad3b75bfd48c835b7b3675cd9e176c7713e483a6f6a55b1c884cccb583c6"},{"version":"0x00000020","timestamp":"0x66f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x735aadbfb413b122ad561bee7d89cd5d688b72ed4b46182f72ed2a6a578b2d69","merkleRootHash":"0xb8cf1536cfc34f6d6e22494754e9699cff274282df2e46852eeb2845a4e135ea"},{"version":"0x00000020","timestamp":"0x66f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0d4af8b5be42aec9e52e13bef48d7e9cfeee25b479b7d7dc4523ea6b0eead912","merkleRootHash":"0xcaaa657f1de4875fa7532602646d43c005eae0db271d87856f02770746c4986a"},{"version":"0x00000020","timestamp":"0x66f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xeba808f23f1fcac88eed94a82ca50b60e33307290089afe722e146c080ff2a4c","merkleRootHash":"0xf2040eb48d94dff2777a9ad4a7c437a1eaaf8262d62bd276219e1baf3a147359"},{"version":"0x00000020","timestamp":"0x67f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x000b627d8eb26dcbd2688c84703f7065505de5fe5a4559b2bf94d0511b99b451","merkleRootHash":"0x57beeee2be503982d14aa6a957f9fea2b990a694ead8b92b5f1585d5625ba183"},{"version":"0x00000020","timestamp":"0x67f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x301620a19b6f458578adcdca0e62404e7ea60c17cf3eca5902d542be77a8ba6f","merkleRootHash":"0x02145257b0390fcba87f8deb3badb9fb93c68bcdf4e6b1d23876c098a44ec84b"},{"version":"0x00000020","timestamp":"0xbbf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x92ce07849418bf75bc74bc49e3c3e5f0d7273b88fe1bcac53167623a8c03bf12","merkleRootHash":"0x7651c7a577174c257663fe65e5c4f019d7b9e96ee97cd2003fd7d2eb735f08ba"},{"version":"0x00000020","timestamp":"0xbbf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xad28a8423e3b7392e5caad0d4e969aa7e0cee43a1f59e4a7f4c7d92965245161","merkleRootHash":"0x23bbeb2e1ace0540bab3e8d3947ea7404c6a230fa54af7d2bbc7a76d9f3806b6"},{"version":"0x00000020","timestamp":"0xbbf0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x69649dabffe2a979d7e5afb20e0674686f3fb78289890d0fb03bdec8d8a3fd1d","merkleRootHash":"0xdf05dbacb115fe6878f82a2ead95f0a73f4d8bf997cedef82108b6ed82d71a9f"},{"version":"0x00000020","timestamp":"0xbbf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe099bbc3624667daca9f6a6697b339d5626b18dc73d6b4341bd05fa77e7f562f","merkleRootHash":"0x88d8238475ca1948336096a2b19f4a30381577dee35a24627ca89f0f9baf2b81"},{"version":"0x00000020","timestamp":"0xbcf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xab71dfc377a910473dafefbdf636c69458a5b9d4fb5141df3c11597c83f98142","merkleRootHash":"0x85bcde7c24c5791f98e9af7a2a4e27fb1021a2497e382aa94d17c71df079d715"},{"version":"0x00000020","timestamp":"0xbcf0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xdf26596db06d12499d9ec88fd189f7ee79822267b72da8c905cf44443d7e6f0d","merkleRootHash":"0x6ad4fca66293576a811050846c98e27e378e3ab35544283c0005d0331c79a09a"},{"version":"0x00000020","timestamp":"0xbcf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xad7ec27cf7354e4142b176c3e25796de1050fd5e67a8d4f02deb79961883612d","merkleRootHash":"0x08f837179097056b134fec1c81159cd461ac71461749f999c6e681cccdd3d90f"},{"version":"0x00000020","timestamp":"0xbcf0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x4e514f75efcaf0eb15068f08839903b9d32456022c088893e9df8093020bf81a","merkleRootHash":"0x4922117a6dbcdfb016be1b88ea31834e871fe6df63ab926ba3647cca22e2beb5"},{"version":"0x00000020","timestamp":"0xbcf0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x94d06f5c0e2f9f2a87e8808f69261a9906b600aef6df49576ef0d4790a08fb34","merkleRootHash":"0x9ef1b33d52b22c7e49b5409de401fd3e4d55a0afbbcb112647a279d493d091a3"},{"version":"0x00000020","timestamp":"0xbcf0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf562459272a5a03b8e2feb70330a470db64eb363e3d0f96802fe4f33c6c56505","merkleRootHash":"0x54b84a61c6c7cb83cff8e1f9aa70fb5727eecafaac8cc2d330c1072b5fc07f46"},{"version":"0x00000020","timestamp":"0xbdf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4c5a96b0726d613d15d2954c9b35340790968b3f1ce5358d5751c8cf84259740","merkleRootHash":"0xaf1f37add9fad9ba492a4f6f9f62f36745f223dccfc9a9673b28b62c7774dddb"},{"version":"0x00000020","timestamp":"0xbdf0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa6dc8df73fd559b6ff3a5681b12c6e5f5a98520db6baa6fcf3e2eb8a73437d63","merkleRootHash":"0xd84a51761e3068e451b1351b8d68b3c853b3d4f75d16b504822cdca50441d660"},{"version":"0x00000020","timestamp":"0xbdf0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x808da69be025b7a2a712ff419f965289f7af94ed48591d4a32475aace7789d06","merkleRootHash":"0x5b64bf57a0a5b35e38cfae71283d74b1740a066a009ff49378d2ee534a7f7633"},{"version":"0x00000020","timestamp":"0xbdf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0b8223d92fcad0a60670a3c0b65b602f752f50541d0ad649d5b49e457db25f4f","merkleRootHash":"0xee59d7e11bc5cbc8cbbecc41c0f92604fbf1b48a168e598305125cb7d77c9c73"},{"version":"0x00000020","timestamp":"0xbdf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xad9c24938d11fa8efb68a63b58de607b4e2482a5fe9aa00c0cf53e86647b9d1a","merkleRootHash":"0xe2024f640d90f25d18959b6bd4efbe69f1000c84b2634182822c510b644a9038"},{"version":"0x00000020","timestamp":"0xbdf0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xb83b26601bc17d3470d69f95b3890efc593d29303ce2155efbafce1f46b12105","merkleRootHash":"0x40e5bc5191b801cd7ca9429c73538db89af078956da338b0913375af9e00ab2b"},{"version":"0x00000020","timestamp":"0xbef0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x720ecffffaaff99bdaa7d9f42d908cd5bb7d4bded4ff295d4be4c6b2dd053d66","merkleRootHash":"0xf439b61b2de03fa326b5920086f495f2c5a986f1744d958bb4a611bf4375d451"},{"version":"0x00000020","timestamp":"0xbef0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc2a6208847ce0a20f1bc447c104314c795847abaf71bb1ed5c7d43948f8e5115","merkleRootHash":"0x4be98f64f9107a68d8b6ca5aa228a2b3dd123bc00a254469aab39dcddba186a3"},{"version":"0x00000020","timestamp":"0xbef0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xda10213e960d0ddfa606c7e6e9bb0318c27932553045a15d34d8ba3e3d12f75d","merkleRootHash":"0x6a5dbfd9a86b0f214c1f665b33b0c9644aa27c468aaedfd0e6b18c1655e92aa5"},{"version":"0x00000020","timestamp":"0xbef0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x28a4c644e3d9ea57e6685f56d4f4786b3b21aa2429c9d18b3c1736084f4a8523","merkleRootHash":"0x2ac79312b9d0f4d0491a5639591306d75198804018a4fae8e1f28c5d7ebca47e"},{"version":"0x00000020","timestamp":"0xbef0ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x5ce2e3b56089500fd6d3ff14463b2adde1e9d6752043c3e84fd8ac79ded0db4d","merkleRootHash":"0x6911bd031a6efecec0b7297829ded84686a576a4436c01192cac925ee108a0ea"},{"version":"0x00000020","timestamp":"0xbef0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf4c23cf61df29d334937334b1bdd700442223d5559946a92d76fb93011385f5a","merkleRootHash":"0xa0fd312aa9268bcb8e5ae21ae149e50385bca751c0525623c34defd91585081d"},{"version":"0x00000020","timestamp":"0xbff0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xcf2ce8682406433d70ee066f5fe72f40b41dc2a2eccfac14482eba9ccf15a232","merkleRootHash":"0xe0c03f2367e44c419811b82bb9e71ef9e088ed61f4889a23f29e321edb75a160"},{"version":"0x00000020","timestamp":"0xbff0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb1dc277097326ac32cc7693cfb8244cdb09462519a3fde947633b4825351b733","merkleRootHash":"0x71eb6ad67fc4787563d9054a9770db204419372fe4415b1cbe65e9c92a46f823"},{"version":"0x00000020","timestamp":"0xbff0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6d82b6703e71cba18608573d6d14339ac9a834f33d695f6dd8312933c84dd73d","merkleRootHash":"0xc53878c3e14cac7dd2539500c4ba1b308337b9ee9e08cea930862a0c51bd2ca2"},{"version":"0x00000020","timestamp":"0xbff0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x4bf2ef2b008d7ac68919573802cf9049aae075b6839e64e5aa809e8c16996e0f","merkleRootHash":"0xcaca1fdb08d6304d7c9d6b71a8a7fedc3a02e0f27b2709d457008d1f47e8b1b2"},{"version":"0x00000020","timestamp":"0xbff0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb03a4840a80c5d0f47b4e9f28b1a3163056376bf54d87259707a87b492d9f051","merkleRootHash":"0x18ec422179a5f63ca17a921252f59cbaec59802e955c4daa745481a08fbb980e"},{"version":"0x00000020","timestamp":"0xbff0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc6d05b4faa59b0f70e58d339fc115105dc9f904dcbda5862509397ddda4af644","merkleRootHash":"0x802cff5d2fab91bb02a6bf57e2c862e88ec841426bc379aa6177d579905ba836"},{"version":"0x00000020","timestamp":"0xc0f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0965bf54ded1b89bdaa1d193b46659562ce86ad92dfeed9f2f12fe0850203646","merkleRootHash":"0x08ea95e2a121f6286552ebc2c710fe57183a30969f041af7179d527727df1354"},{"version":"0x00000020","timestamp":"0xc0f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7f4c9867a8b966360d3ceb063ad801375624f40ef9e0f2996f48ce41a7aad80a","merkleRootHash":"0xc1eb3cf1669eb7ba3971e58dec7100ca0db6e3ebf1d05263546fcf62080e9c87"},{"version":"0x00000020","timestamp":"0xc0f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3d213dbcb9dbc21515b0ed3179c9ac3d8d5fe37b9875735813846ffc7e452261","merkleRootHash":"0xff02d5f2f2698bbce4efd4bb2ce011343d8f5f6688e63a74f16337951be8e277"},{"version":"0x00000020","timestamp":"0xc0f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf31456572506b7dcb44435092fc0958c96e91c04a0ef79cad24e4c456c922250","merkleRootHash":"0x3cab14924e6f41b02a9c5945f280b6b58a66ba158b1156740d3048e86fbe1871"},{"version":"0x00000020","timestamp":"0xc0f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2f26e321bbd9a2eb1a39c388715bd9d6e0ddaf67514880e51ef96f5757f13f1d","merkleRootHash":"0x8f830bb084327480ceb4c9717d57eec9c572d0c68ea1b446a86f52c2bb6d2c12"},{"version":"0x00000020","timestamp":"0xc0f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb975bd8c660e40d5a96c372130c4c3e0a2086456c87dee9ad1eb46bc4529dd28","merkleRootHash":"0xbfc45f37b943c115cf16fa0eeaf3aac31095f675a9587d59df1b6348ca649216"},{"version":"0x00000020","timestamp":"0xc1f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0b26698794b283d2704d1d75b9ecd44cecd3a1d4efda3e1f4b83b5d80ce11756","merkleRootHash":"0x27482a572594e6501e41fe8ca6de529767701bf351325321de812a903b658498"},{"version":"0x00000020","timestamp":"0xc1f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe8b1d23b27a8035f805cd968052df51a5396411e384aac590d42c06b95037c10","merkleRootHash":"0x245cf12e5c94dba96bb5cc8d575f5fc196226c9aa2e4d628415ab457a4069f15"},{"version":"0x00000020","timestamp":"0xc1f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x81d251e7990be672345b595dd8e2724a9639bcb5719993372d0018619369495f","merkleRootHash":"0x5e544d5e14a7b6a1dc057d3764c238f6d8bf60b6b2a9e817939599e9e8827af7"},{"version":"0x00000020","timestamp":"0xc1f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd0808dc932b361c8832079e500268e0d4bd0264c100d56746022dad0aea6b563","merkleRootHash":"0xf35aa6e78081a093d9e44bb03cb1238fa46c6923ea7285317cff9a9a31be467e"},{"version":"0x00000020","timestamp":"0xc1f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x66db1dd36c8895876ff4010f9222f7cc584be900b262aaf3ca345466a8b1e972","merkleRootHash":"0xa86104869de8f8128f765d2fc6f45c1e6629d4629a4a9ee74b2d59def8221af7"},{"version":"0x00000020","timestamp":"0xc1f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x87e7116b67a38ea841965bc7469fd2d6db2bcf2fef124005950482ca25dec643","merkleRootHash":"0xedc5c40fd191de83801c87da5c54d66038947911fa032e535bb022d8052a569a"},{"version":"0x00000020","timestamp":"0xc2f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x498cc411c2b2a577db64e064269bcd1c8cf93cbf3816189545de88adeb1c5810","merkleRootHash":"0xe4a75f7e1be797516694231e260811aad914f38b71089c0d6a3f19d3944576fd"},{"version":"0x00000020","timestamp":"0xc2f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x66cdfe162cec226791a02c3730a10a1f94e6710acc34d1c1a2b3ba544adb7a58","merkleRootHash":"0x604ad492e3d302f436c94e68381f2fe1594bb47d9b1e5f78faf948b62150add3"},{"version":"0x00000020","timestamp":"0xc2f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe28ddaf8925fc3a62dddffa95ca62991799a55761dbbe0b82c483b7cc6500565","merkleRootHash":"0x0f4925c2e66148706601f8ea34ab35fd5e48adbd9859a3a084a2a9a6a42688af"},{"version":"0x00000020","timestamp":"0xc2f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x45fbf9a6c3cb15bd5592394255c017fd3c6b75a97ba55a9260c6217ec1374605","merkleRootHash":"0xceeed71a72685f09f95eb0cc36a427688c87838973cd21788c2f05e26a4aee0c"},{"version":"0x00000020","timestamp":"0xc2f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8c4e02923883b7cb471514c3d4fe6a30c56d14c9eff4f484730468b97fa3d32d","merkleRootHash":"0x839a03ae2754dab94fd09f3e7c5e5426c4f0126a61512691d265403d66cea196"},{"version":"0x00000020","timestamp":"0xc2f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdc68dee714c66327d950af4408908611d6b26622a961a779330f7e36ce6bb37c","merkleRootHash":"0x26285ed4612588906d40eae444ee4d4bb9ac4a268c10448d0e10f9e289be2ee1"},{"version":"0x00000020","timestamp":"0xc3f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xcce59f1c56e6a7863aaecb7ae113100b1acf753867824f3e342b887b35587310","merkleRootHash":"0x47cdaf2c66862b97b79aaaedbb42a511dbf0bf90ed5a6254b89a5167af0eb9ba"},{"version":"0x00000020","timestamp":"0xc3f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5aa91347a3927da9969e879bb583a663f5521b999088c6f4b4db60d912918372","merkleRootHash":"0x7da15f51804883ac652cdc1e20ca46048ceca0cf0737b732ea6cec2a52745689"},{"version":"0x00000020","timestamp":"0xc3f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xdff8db83fb294bc00c3bbdb580e50dbd635666897bf0ed6b0a78214dab90fc1a","merkleRootHash":"0x58d26ced285de61912254ee6d67bf115aa7010bc28b657a6e77d6fd115acbd41"},{"version":"0x00000020","timestamp":"0xc3f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x49e50d73dbe6270a0b92e4265b9b3643a7bdec2bec138ac39f19db13a3fde90b","merkleRootHash":"0xdc3e13f35ad14b526d10d0ad639b0613f859854adbd61a74a8d530a44e81e6af"},{"version":"0x00000020","timestamp":"0xc3f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb95fd8fea558da9c89f5b6ee3cbff5c7f1a0250748c0d1257ef18915f412922f","merkleRootHash":"0x9e72be1fffbdab8d013bdad38cddaf9291d5f0889f699a06b615c8d6e023db3c"},{"version":"0x00000020","timestamp":"0xc3f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xb3cddcf038399bf321a4f9aadc76d9c8de0d5faebccc9d289be54497ca8eb102","merkleRootHash":"0x51b00a23dc77fcdf9cda14966211fe87367d3dc00ed02df886a164b92baa73d6"},{"version":"0x00000020","timestamp":"0xc4f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x17be06a9cb32180e4b985e789681911382a73bee819ebd58c2362618c8d0c857","merkleRootHash":"0x7b870505a9dab38ec70cbdc6de7a6942d5ac84fd919d4d6cceecfec4139cab03"},{"version":"0x00000020","timestamp":"0xc4f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x57765e390f266b6bf05288369c08fb5182b20785313e518477c13477fd13a27e","merkleRootHash":"0x63eaeb62baf9bc94c0ebdda785d1e21faede05134c55448c08ed93dceac820e5"},{"version":"0x00000020","timestamp":"0xc4f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x156a2837df22872106ec98422c3c6c552a3e1e242af04fd1c59d43310035df1f","merkleRootHash":"0xbc56fe8552b0f63768ed572c024aa326ae4df81ca9b2c2722e2b4cc836cafba9"},{"version":"0x00000020","timestamp":"0xc4f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xed92e7fe9c13fe57e65098daef360c762dd31c05a698b6f7bcf0325c69146a33","merkleRootHash":"0xef23ab8a756378b660aee7992ad4afccef948b93ed0a1df00fdbd0f8e0833aac"},{"version":"0x00000020","timestamp":"0xc4f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4c53384cbcce6b617e9ebe30e95fb6561c672194a99bc3d7091b08246f9fe045","merkleRootHash":"0x706770b5487dd33c9bcb34c55dc684ac4b78507e285f3660ca7e527fd4b695af"},{"version":"0x00000020","timestamp":"0xc4f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf284ccfdbec245edca8970dc8c0cb939192d4f87f62680cbd66ea8bb3bde9d1d","merkleRootHash":"0xee80a97a7e9454efbe4f7695dc3bcbd875006e8d2133545003ad0504e9763cb3"},{"version":"0x00000020","timestamp":"0xc5f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2222b52868c0e5fee82e19d624070f1eb59d896d160cb4ff46f1669a0df4c410","merkleRootHash":"0x1c798e42d13e4ac43bc9bd5dc2922defe585c19859e74151fc89ee271175f293"},{"version":"0x00000020","timestamp":"0xc5f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf9db06509883237d51b7e0f0c2f13838c2dafc4b18ac86c07dbf6dbf9b1a453e","merkleRootHash":"0x6b7beb1b5382991de2efb7dade0edd54637285140be2700ebf003bb41ce0fccf"},{"version":"0x00000020","timestamp":"0xc5f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x96d9330bd63e85de1f4a0290d3ffd6fd271f6fe23e2f9d15a28bc017b5678f68","merkleRootHash":"0xca01164cf22d0abde75bd807180901dd91d3fb08ade634e490e99d6b2f820d42"},{"version":"0x00000020","timestamp":"0xc5f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x6a61b2f59a6526087eb125ddebb4df457bc33fd342f46d2144d9d2c38d450f1e","merkleRootHash":"0x022b27e0febff03c4df6455154b0c502491dfd7f4a94a19078ba4485095eb3c5"},{"version":"0x00000020","timestamp":"0xc5f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x6aa5107dd9d80b0a2adbd89da77c7716135deab2983fd85846d9f49296c42048","merkleRootHash":"0x4f97f39f3467d03c6c6cc18f5900bd9ba1031f6ad4273d11975f28a4829f4818"},{"version":"0x00000020","timestamp":"0xc5f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x32244e2316b64554c9469909564c61365d50f2fc641137e928f85face6580121","merkleRootHash":"0xf742c31c86caa4bacdfe0078cb400ecdafad967120fabd3e5e75203c2f49de28"},{"version":"0x00000020","timestamp":"0xc6f0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x46a11b3b8dc189d064ae7291de25e46801cba33cd3f1664b4d5d214f5c7ab245","merkleRootHash":"0x572eb3ca8877cca130990b8248980f5c9574dfbf02fa14720d737bd79317a167"},{"version":"0x00000020","timestamp":"0xc6f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0ec16162c8ea8e76fbc40339cb5011ef3cee0adf162b620370bc8dd4d3924e6d","merkleRootHash":"0x74e98e17db09f9a61d2f6416f5d66c585773f679308b1f5f17c2414dba8c062f"},{"version":"0x00000020","timestamp":"0xc6f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6a0c98609304da903f7e94ff4d0738f13215be57c4e297ce6236f0ee7bbd0f1e","merkleRootHash":"0xb45aa2f5c79f3147383ebdc2a1513087828dc17c30c909ee8d9c6ea19e56fb83"},{"version":"0x00000020","timestamp":"0xc6f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdaa53c26ae514431842c0c1cc82c9324835e1297a9afa87c9243693fab68fa5c","merkleRootHash":"0x1cf83245b7854d149235ab2d566ace7f8b9c4bc74f95205ab9787578d7d81328"},{"version":"0x00000020","timestamp":"0xc6f0ba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0xa4bdf3f278164d3b770784eeffa03a444b82c81aa029d51313f0e9ee6588b80e","merkleRootHash":"0x8bb60a6bca338239856e3587e0385ea87815f86aa850e892cb8ce2b0420c37bc"},{"version":"0x00000020","timestamp":"0xc6f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x116eb2bee795cc157babc09700f4afa11ac7d7404f52eb0a336d833d06ce1a2d","merkleRootHash":"0x4526aab05b2dc7e4ef2bec76f25698d1e4a8891623d08e9936d153a01783803e"},{"version":"0x00000020","timestamp":"0xc7f0ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x77e730ad0e908694c3670d5a92441c317a462390b374f80496c2d885d67ad932","merkleRootHash":"0xd75b2f5a481cf2003b28caeef77d291302404ff7750d094a1b71faca58c5c531"},{"version":"0x00000020","timestamp":"0xc7f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x55536ad162c59b551a24b3c30abdec8f6d337620da5edb443b007b0c29548752","merkleRootHash":"0xad102e37b41442c1de65c5d291b504d5d4ba45c9273b3e30c515bbf49046de7e"},{"version":"0x00000020","timestamp":"0xc7f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xec52ea4135622a3f2e7409ba29371f2ba36431a5d6973a42cf8e1d2a25e38558","merkleRootHash":"0x8bbb75a051668f69fa2c412b4ebaa4c6d8aa2203acd9473c22a5d4b3988e02ed"},{"version":"0x00000020","timestamp":"0xc7f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6f4f57e6f36845780d9f9d274922322ebbec6b49e65852b97cc94395554e251a","merkleRootHash":"0x845416af29558f2ab44815281257cdfa08e374d1b5fd6931cfd84ad9e874a853"},{"version":"0x00000020","timestamp":"0xc7f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x79d731f1d2233a90fe9668c3eec3618c79666c5fdd3686d8c812faf019443f39","merkleRootHash":"0xbddb80cc4c045a4e1f6d12a38c4a6f17541a2496b9d7b9258add0e8774b867f1"},{"version":"0x00000020","timestamp":"0xc7f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x652d9e830f11f35790ab90f7ad313f75603a38e76caf5bd26523a342a7657d5a","merkleRootHash":"0x7f1899615d6899c760a420c40bc4b7f17f488d94acc1003a48466be90592c7e3"},{"version":"0x00000020","timestamp":"0xc8f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc9f0c878451a91b3452a8ad5e478b81abeee394ba721947644949a3702672747","merkleRootHash":"0x48562fcf5691b65ae0754429e8b69b2895f994f39d87326b0b9156db8d24c7d0"},{"version":"0x00000020","timestamp":"0xc8f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x01f158a14f29f35e33734c952e76e34371d5543f8a817a1e931180330ac8700d","merkleRootHash":"0x329130cfc5ef93b450020668c9a9fb2dcbe777d05707aaa91bbc6a650ebb77ac"},{"version":"0x00000020","timestamp":"0xc8f0ba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x6a2eefabf3d3337589f18b0644ba778b0d474cda3b15ba9736af4b1dd0383009","merkleRootHash":"0xdede388946856bc1c4bd882cbf32681ed9525c0bb4eecc66d5086a6f8f8d279c"},{"version":"0x00000020","timestamp":"0xc8f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc4a16c3f353d936295c1c0bffc8cd1ab276cb562633624e02a40d5d7580ccd38","merkleRootHash":"0xde8ed1b69195dd7e21a0fc8cab09e68b63189a99bd7e21f6d5ab001f6ae95a4f"},{"version":"0x00000020","timestamp":"0xf9f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x36f8ac969f25ffd75a12b0550016c62f48d5a9641d0636b01f2e405b1e43883e","merkleRootHash":"0x551fb0dd3fcd766ea8fafedd6e9d65f87ee04ab427627d937c994d235f0ee607"},{"version":"0x00000020","timestamp":"0xf9f0ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x1966fd87723657f201afde70684e70f06ad92bb8bdd669d502cfc855f49f0004","merkleRootHash":"0x9f693f2aa907bb92b686e1e8a731a120dead1922c8cc0d1be1cbedf690d94430"},{"version":"0x00000020","timestamp":"0xf9f0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf7adaa2a7fb052b1eeb5aff88ec1533c558d72e4f1d9af70635cd3caeee47c59","merkleRootHash":"0x22b2620519dc285fa382bda6a5f6384838da2d310e45b5b8ce58e58b94a20ecc"},{"version":"0x00000020","timestamp":"0xf9f0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x9bff75938bc96f87873dbbd014120712fd61c9e0ceb5157dfc613d8568a18b21","merkleRootHash":"0x2c60a2b819dba0341e9c493cf8521ea2a2f92efd32d8dfdbe7508889098578ae"},{"version":"0x00000020","timestamp":"0xf9f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8dae6af6d1cee65fed3837ec7e1a1be3e6ded84df6bbfa2a414444a1a6ea7e6e","merkleRootHash":"0xf91e93578a750ac5c5e7dfff8084dc22d2e5e427ee89617461296ba4ce48780e"},{"version":"0x00000020","timestamp":"0xf9f0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0b5f7dd9cdc5e309ce150af3f0d201bb0b93e13539b9564cf0df4f4bc9f85a6a","merkleRootHash":"0x176d5fb7ccf2ee8f8d67b2ca9c898341ddf81303c3bdb48d90626379eac2b4d4"},{"version":"0x00000020","timestamp":"0xfaf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x627dbc743c3e7fae38973f03a4ac0ccd5df37b895cdd570dd4badbbf27363c1e","merkleRootHash":"0x0e4c9ef036e51ae480ef4a7d09f98c9ac2b0d07db683eb23002d2bb85ff86425"},{"version":"0x00000020","timestamp":"0xfaf0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x987603aa78aa8382dff747f353e242bc2e7c5f499040b3e462f76f21842a6568","merkleRootHash":"0xee94487f91a43e05eac39f9d69d15905f9d3f544204f14ca61715457d9ed08b3"},{"version":"0x00000020","timestamp":"0xfaf0ba66","nBits":"0xffff7f20","nonce":"0x07000000","previousBlockHash":"0x01594bc239445fc6c4b5f885c86b5e88a66f3dd094fb70cfdb9bd521b1919d66","merkleRootHash":"0x07b968cfb2964b8c9572147693dc350d0de311772e00eca7b78832c526286fd3"},{"version":"0x00000020","timestamp":"0xfaf0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xce3e21e79bfb1cf5174dcca3992379a3ed4f9faa8ed3a7331ebed1aaa081b646","merkleRootHash":"0x986fa2302a518d2f866d3b2d0578f93cd9d989943a91623625d28fa883ecaef4"},{"version":"0x00000020","timestamp":"0xfaf0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe28793537679da3181c78a43385ff3ce5b9806c45a7bb65e3e6104da34763f2d","merkleRootHash":"0x3e6544d5fda09d266771a77dcc0a52dc779e724c0fc20d9b05ea925fe2082ca8"},{"version":"0x00000020","timestamp":"0xfaf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x89969f976ab632d8e3a906179d9c53747e85577bf6fd0f450c5ad9a87feb542d","merkleRootHash":"0x50b33172ae7ca8d88177c8f16a4d8ea86ad4448139c381520fa8972b71d4d36f"},{"version":"0x00000020","timestamp":"0xfbf0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x5c3b61ac295f70b8a18cbf3fc2217168634929ccd8e64795931b9270a2f91356","merkleRootHash":"0x0d6390c3baefee2c01d9f90f45ba8d749d7c6704a97041d2d1e26e1d39ca9d92"},{"version":"0x00000020","timestamp":"0xfbf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdf849fc49a110cc157c20edd9fe833dad97825b83086dab9e176c308336e544f","merkleRootHash":"0xd34cf3fb8eff31b8f57d2ff206f6ad730a77dacd2c80fd24662090f83c790c99"},{"version":"0x00000020","timestamp":"0xfbf0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2805b5d58eaa8761f4324bddbedaa2e14b278ece8da21f3c780c08756537673b","merkleRootHash":"0xe74a21cf5351167b9f8ea8d1354b0f3029bc475d13e4cc4aa681167ad5b5a431"},{"version":"0x00000020","timestamp":"0xfbf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdd7f0135b12265afbbf2c445097c1bb11e9214cf998b4a2ac7c9a4d447fa6434","merkleRootHash":"0x7b419602a371d0fd4d72ce3f456e8605ff181126633118dcb78d7e6eb7917cd0"},{"version":"0x00000020","timestamp":"0xfbf0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0611813432aee892db1fb600bcefa2937bbd04b26a63fb2486dbdf3e22e03c4d","merkleRootHash":"0xbd330ac48cf785a3c56f3c44529dd96ffe2b593c67d72fc901fac7645442e0b7"},{"version":"0x00000020","timestamp":"0xfbf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x95f133aecd86fce95fe49c1be560935848cec5ff9a33336a4a1f906acfa56242","merkleRootHash":"0xade3b13cbb35fe52533a1e8fbf80f5f0d4e23df3dc531ca1d9dee465aa1aa3c8"},{"version":"0x00000020","timestamp":"0xfcf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd17b8f00ffdd99163d271379a393702a25964a95a22b1232052604c54957907e","merkleRootHash":"0xc0226b495459f9c33a5b2a37e714a8621256ae3244f0785af35521b3c769a537"},{"version":"0x00000020","timestamp":"0xfcf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2e0ce2e5d8dd9ade670473d21bd22ef9265e69458f852f1a6cbc18ff586b9d24","merkleRootHash":"0x93ad34d589ddc3b00e03fef4a44c80b8041105cca0368c90fdc86e17c9391e86"},{"version":"0x00000020","timestamp":"0xfcf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0ea590bc757f2921e7364f43fe56d0f102b2308a995159eda88d934fe387e316","merkleRootHash":"0x8b08f755e3ad6d485affe7b1a24ccde1d05b82deb789e9fc00ff08e8211428cc"},{"version":"0x00000020","timestamp":"0xfcf0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xeae67a8eb5454a4bffb742f7a2045ba824b34c2a9fc71c73fdedfd9425c12e06","merkleRootHash":"0x8158f04ec6969412077dbb41eb2f66f580abd20f50f9bf9eec849021668faa43"},{"version":"0x00000020","timestamp":"0xfcf0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb10b9ef3a183e1ef667fc8ce6ee007143e81874b8ce55f6dad6b2f00f984201e","merkleRootHash":"0x9652550013c2df31754054932766cc104ed5731e251fba601782850963b8a226"},{"version":"0x00000020","timestamp":"0xfcf0ba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0xcff91f81cb75fa01d9d383646bb8fd79697bfe39003d7f1c0e685cf0d1f28331","merkleRootHash":"0x32e30d6057a9563d0300feb00cedff3146b714c158bb9fe847cde61885627e01"},{"version":"0x00000020","timestamp":"0xfdf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x670a34b64f76c3a24fbc8d2f85fa71445830e668393e3fc1f80f3125a5bcdf6f","merkleRootHash":"0xd47ef38b96ae069207cc4dcc43e9bc5e5f1c3c78158024ae764effe01b5bd510"},{"version":"0x00000020","timestamp":"0xfdf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9a8677ff602f1ab83b230383f77f142893036c5afdbc32ff7c4b50c03ea3b435","merkleRootHash":"0x164319b04a99f5c476482b151de221746628717c69c0fe47104e2701037dc296"},{"version":"0x00000020","timestamp":"0xfdf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x472f0a54df553b1581f28eb9ca715d1205fe9cbc7cadd759907a7d90d8c5de57","merkleRootHash":"0x7c8fafb50096a42c769447bdff70baa5c725bc26f1e2382d20a27cc74dd8d6db"},{"version":"0x00000020","timestamp":"0xfdf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe88758e917ba6403239c8aec9381f1431210f5449c62d0c10946979e1a7b4605","merkleRootHash":"0x841f7b4290b5ac0eca7db14a79ed8d0c271e39098d8eb6cb9c9da98cfcc3a72f"},{"version":"0x00000020","timestamp":"0xfdf0ba66","nBits":"0xffff7f20","nonce":"0x0a000000","previousBlockHash":"0x47671f0319c04cbb1e68b3b292391a859149f630f3b11e8e1fb1c40e5104253c","merkleRootHash":"0xdf1a9345a1e02eb1df01d94d18d06e3284e102ce149c6587022cc0a40ae57fe4"},{"version":"0x00000020","timestamp":"0xfdf0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7c0eb50b104392367bda59710ae0784830a85adc3154878de4c5862c4d940b5c","merkleRootHash":"0x746a3744c672f342d9263d20e332a611a92e509a713302af8a870bef7c111680"},{"version":"0x00000020","timestamp":"0xfef0ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x87086563dcd2abb97947698ff392c52177d4aebfb8123d583267b0ac92ecf025","merkleRootHash":"0xf6d8fc934ed7dd519e18acc0f909e6bc9f09c07f14a3ebd5d5460d615fa89df7"},{"version":"0x00000020","timestamp":"0xfef0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7e6ddbe2743ea4abcde3a76bcd19b4617f2dc3785fc1743735779c44b4e3bf4b","merkleRootHash":"0x696988046b9e7c244a83eea0550d2ed5dcbeeb378843f807a1e7de671b329ffd"},{"version":"0x00000020","timestamp":"0xfef0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3ab67d8f785e5c5ac7f5dfe5f449f0164830127c6952e6e4a9b4d77cfb2cb116","merkleRootHash":"0x4f50f38acce35bdfc6244bd47a7767cee8a630f3c28dce602b1cd8680a88862d"},{"version":"0x00000020","timestamp":"0xfef0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x87c7ca00dfec39d9b9cc83c5aa58a4472b7a8d9f4504e670316432d46e806d22","merkleRootHash":"0xa094675248216b6e5134da7f852f2086e0af366f3e572fb440a098fd45784d06"},{"version":"0x00000020","timestamp":"0xfef0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x192b4786dfcf74b4bec33122c6e121e9ee600472fd1d82bcc1b36faa07dfcc58","merkleRootHash":"0x0160a0bbc1c654da90dc96a8fca8842d288aa56b5d6dc62d74488df6e82748e3"},{"version":"0x00000020","timestamp":"0xfef0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4f435fc68f77fbec39a39f17a6f2692fdc7cd0d2eed7bcbcc1129e2b7f5ace23","merkleRootHash":"0x6cbe681f47daaab0c3a003e62a2596e2bd7de9de0afa8268fc297f32fc163c48"},{"version":"0x00000020","timestamp":"0xfff0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb15d5c5bba863a14d35411e5a87f7eeded16030866fc45c340df0b1056607f29","merkleRootHash":"0xae63e9580e3988f20a9b12825abc8ea84b20793c45422380853197b84e66c1eb"},{"version":"0x00000020","timestamp":"0xfff0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfa261a7ec7659082b7f686d34c74cb188169733d273b2a845e38cc7c16c2e111","merkleRootHash":"0x406a4d68dea432bdf9c224dcdb4d9790c03c9472a72fdc431eb93574aa69159e"},{"version":"0x00000020","timestamp":"0xfff0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x91ab8c5d5f7eb774f0997679fff7ec803a4aa81fa685d4320c86e1ae0613e81d","merkleRootHash":"0x5e1f17eb6aefdad5e8789fab059f12d9440f96f9611d1c8213e94d59030950a0"},{"version":"0x00000020","timestamp":"0xfff0ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf8bac0bd993616f4973b1eba3c9d77623f1060621b74175873a8388183fa0415","merkleRootHash":"0x89e8f8032ec850500042a2828354ffae8bdbf2d0bc9f2a9447d0694bc4f2037f"},{"version":"0x00000020","timestamp":"0xfff0ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa30f99ba3483ef640df5b547ef81d639d194a7d27c2fe7e6c9a3521244279c1b","merkleRootHash":"0xc1c3d2f373d019bb49d9192ee34ca033a8862b29f140f871a6336d26b8a658da"},{"version":"0x00000020","timestamp":"0xfff0ba66","nBits":"0xffff7f20","nonce":"0x06000000","previousBlockHash":"0x6fc592a2cc11577bf064f291481865839c80b882766088f02804b5e7b3b4841f","merkleRootHash":"0xa6b2ad880270f6a3a1a2b317ef53bba2be755448ee21870b41b31284ebf5c921"},{"version":"0x00000020","timestamp":"0x00f1ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0605f9fec883a7a3dadc0c28048e5d70b9a425ada104ff8a31927114baf85215","merkleRootHash":"0xcb870bdf66655008e2a3dfe7d1964d5c47da6e0e35c5cd67a6eec0bff66573a3"},{"version":"0x00000020","timestamp":"0x00f1ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x7e2fec156df6bd0dcbd44e921311718d75cda9a954017c57b016db930cac2d14","merkleRootHash":"0xdc1742315ba77fce720b4a594d385f03f435d95772a6f1492b0c8d1bb4629baf"},{"version":"0x00000020","timestamp":"0x00f1ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x47ae26d70ec551433e6b11182bf24ad496e2008858ed1d889b5444ac3a479e73","merkleRootHash":"0x5b25a6fd46e5e3618b4ffcf41457cd6bd7024a392d24d2296c343fbcb47878eb"},{"version":"0x00000020","timestamp":"0x00f1ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xcb62a762229185878b0c005987d5287fc6ed2c0e27afc412a0a07ac75c37c528","merkleRootHash":"0xddab8a78779fa399d3d907374c7bc7a1363c0c14b6610e6864edb52352e49371"},{"version":"0x00000020","timestamp":"0x00f1ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x60e1c43d1c4390bef685227b0ec2532361a8d42f3015fbbfa808bf9630d06c6b","merkleRootHash":"0xa4f54b2846826d4ada78163a92854ee822e2fa7105ad1659e613cd8674aa6af0"},{"version":"0x00000020","timestamp":"0x00f1ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x54542ba66c52904e776235c20ddcc4cdfb603cdebddfe867ce99d28919c2b40c","merkleRootHash":"0x0df6b73241cc6973cfa83947af78c5bdf6190fcaff6919a2a1345dc88dc52481"},{"version":"0x00000020","timestamp":"0x01f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x98bd2d06ccb9d486e7e087b97241ee5b20f3827d65d81a8b1fd49bb8df63bd06","merkleRootHash":"0xaf8135e5e21b5eb917512818ba20567f1178067e7c559415ed3125dfb886c2e0"},{"version":"0x00000020","timestamp":"0x01f1ba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0xbb2f3a1ce1e4d778312309bcb9d1a95e075fa30ae067285ca836cdf441a8df77","merkleRootHash":"0x8d84bdbbc14b31cf5779c5efd5a0da828ba13632e1c4482eb920aa03dcb170ad"},{"version":"0x00000020","timestamp":"0x01f1ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x4fb372e78ec36fe8cc17386e96fa2972255e805588a2bf887e6950a6e2044b29","merkleRootHash":"0x5bcd7d3155c23139af76dc1c7043050ee1fe0205cc98623ae091ac41212adc07"},{"version":"0x00000020","timestamp":"0x01f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x53ed1595909fbe08a75b025648799d602b3c071683da89e70ba467c58f77701b","merkleRootHash":"0x03758dcaed2d4a4b93ca91fd4c859e51bc524358cdbb7e7ed1dba7ddd068ab4c"},{"version":"0x00000020","timestamp":"0x01f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcfa1ef83c40f9973c6d7040ddcf6c79fd2c6b43e53857e55a746613488359d22","merkleRootHash":"0x76e0bb468c68451972e917730f41c962562f2213546dd92c73d05681aa8d6135"},{"version":"0x00000020","timestamp":"0x01f1ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xc6b3da8bd3ed675068f154eb130f4da7befd200f32ccbd9d9a5d88377f3ca02e","merkleRootHash":"0x52b8d3fe29af41405f8ee02529e034c5a5b58bf3754fd255a0eeae32a6f0d3a6"},{"version":"0x00000020","timestamp":"0x02f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x402f80b33adfd9ddef32b43e6ca5415281c8a89b4f0d8b10349aac3f3d70eb03","merkleRootHash":"0x03a538123f1c6d6e31561c7e3af56de56654702b7ea5d4aeeabaefe7a1218855"},{"version":"0x00000020","timestamp":"0x02f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x52c680ec5da00f51e9c8aede4ef6a746a2632a32f15cf7d24ef5e3cef8b9f201","merkleRootHash":"0x616848fb7f5c088aef15995f8473ef7dbdb50c41decbc9f4a5333b25a7334e3f"},{"version":"0x00000020","timestamp":"0x02f1ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf0809d864cebdba951075f783aa33466d23ddeb3eda222cfe598f88e7963a00f","merkleRootHash":"0xe6d47f226a0840a3a18cbab4f38003f1d33ec99c5ad7ec6c66ae4b38eda00a02"},{"version":"0x00000020","timestamp":"0x02f1ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xe4b69a13a9b4c7d29c9354f8523c1a133e0c6e479abd17385a12c04ee16e521a","merkleRootHash":"0x71e73fdcb08f6b82a7b17ea4083b7e7cfd6e0b381b81dd53e3ec67870d47bec8"},{"version":"0x00000020","timestamp":"0x02f1ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2e8f19e750e806d80fad626f16a91fe82887389cb86ae8f62ada8b5179141759","merkleRootHash":"0xdc7a2025688ac90c38830fa22cf3313339843bdf476c7bbd0c8394abcdb89d94"},{"version":"0x00000020","timestamp":"0x02f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdab76e2ac59e2e6b4979640d841f0cadc2a7b288819cd0d618b9cc1271a3a52c","merkleRootHash":"0xb7094b5f0ce17717ed96447665f992229ff6b9f7847ea6e076db44676db1ad01"},{"version":"0x00000020","timestamp":"0x03f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6d78ec6d31fa4e348449246a0f4a4d21f7129e3f1d295597e2b960c0a2ccc833","merkleRootHash":"0xab443fa9bf10a4081d989a2466813aa6c47d7a78be09b755e5b635dcd0e10fb1"},{"version":"0x00000020","timestamp":"0x03f1ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x82cae4940b2270710c7352438f157a21705bd4ecfae8ef78b3ef44f5d0677d1a","merkleRootHash":"0x448261f95a4e568cf565ce1977e77190cdda586b91269b162810ed709568b0ad"},{"version":"0x00000020","timestamp":"0x03f1ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x944ad0006aacba9772882d095376d5fe171a21138267c59e41ab978d15ba6e6c","merkleRootHash":"0xe5f20c13bef202e70748189537120ee2c28910e083f2575de16169b02f88c8c7"},{"version":"0x00000020","timestamp":"0x03f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2e58610752222adafe4212f11705a157cd373eb5fc588b26d734267017ca046b","merkleRootHash":"0xc0707334c9ef860c9e555ae505157cb230d9e7ea0597f188ab577eb1ef0e17c0"},{"version":"0x00000020","timestamp":"0x03f1ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xa405495c056ea9e5bd8d510f0d0209fed52ab88eadeb7dfb391d4e4bd60c3e33","merkleRootHash":"0x9804f11053ad043f554f7d01ab83ab83b27bb6ec511fec36004432ef59a96d73"},{"version":"0x00000020","timestamp":"0x03f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x76d4ca6082cfc67136c4c982b889d80be0d2250108a4d095f9e3ea56c07dfd49","merkleRootHash":"0xdb1d03dfddbc893711a398b58f70f3d3b680d62fd6f7d605fbb6a40ea949487a"},{"version":"0x00000020","timestamp":"0x04f1ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x25e45021e843318a9e03777d4207b783734b58ef733af5aeb8db4b695bada07b","merkleRootHash":"0x03bd5623eecdf43b38db57c966578ac201508d2f27ca5bbfee5900e46109ae02"},{"version":"0x00000020","timestamp":"0x04f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4b80537ad2382a3b6b5a4795585c2a2e81bab11fb3d083ca4b4464f4d08e7c01","merkleRootHash":"0x5d55b6ffad5beefcf6398bd7ef4150884bc47a1ab9a48a06665200a3eeda4ed2"},{"version":"0x00000020","timestamp":"0x04f1ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xaee966be067a25bdc3e1357af269b19e96243aa73f7fab516bdd63d8a24f7762","merkleRootHash":"0x9f43edcb50d89e962986490f84b7de32938796304da068fa75b5fd284961d367"},{"version":"0x00000020","timestamp":"0x04f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe004ffb68f6642a8134c6e301bea423544d51f1ad900e37cf770ee193c43334a","merkleRootHash":"0x5e90112581b141c1e3720849b0072e4a76825eadb4c964f20f9bb4f9464dcfa5"},{"version":"0x00000020","timestamp":"0x04f1ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x7abe9172bedcffc9cc2f5a8995c47558efb8f6690e8d4915fa83dfa74e6b1a52","merkleRootHash":"0xe7a59b62730e0ec76d0384f08d439381f484ca72a9548ecd6ec14a0c9ab8738b"},{"version":"0x00000020","timestamp":"0x04f1ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x893fa2adfe669a32928de32e77c4c4b16b3454a28daec72d0001bdfb5db27658","merkleRootHash":"0x99b4f3b27c163e6fda1c435d606ce43178c1b82370101a7c23bb98b5a8aa1a58"},{"version":"0x00000020","timestamp":"0x05f1ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8bace8b794344224659b4e41ba918ab61382f19516a8d51c87e532b90437b636","merkleRootHash":"0xfe06596c8e48ad8c343b622c234cbe2d4841b63100c55002a1da9b4de5d0a444"},{"version":"0x00000020","timestamp":"0x05f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2b3f1f4c875cf6419f6eb0a7055d4120d421e2bbe305274bc260f1fba6757c2e","merkleRootHash":"0x5a8d8242647911eaa0f5b52b893614354c3e798d3aec71bb21a741a12029f401"},{"version":"0x00000020","timestamp":"0x05f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xce331fd3bd38749d5f09c67e94cec79c218a2e0d4c9363dc4e48c11985f9c51a","merkleRootHash":"0x5aae9ab78c69ca7a4b93fdbddda731c2a10c4580318e2c257b809fbacf738692"},{"version":"0x00000020","timestamp":"0x05f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5e278bf20c3fd45e81c3967a4d11c390c2ebe871c2af814513cadc882041c723","merkleRootHash":"0x8ffeb87ceb20b2c66173903b6b14e0f482df1a47652b637343472bc22b5ba193"},{"version":"0x00000020","timestamp":"0x05f1ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0327383a8188d986064a1d9a916a26c1c17b4c79b5160d607458377b8bd8ec10","merkleRootHash":"0x99360b5c787c51e6720c4fbea59b52787d4eb31c15e8811ba6c8f0f04126726c"},{"version":"0x00000020","timestamp":"0x05f1ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x602fbf4014e34aa573ee5f6032a7dab69e08d247341ff2dadbb9c5a775deb877","merkleRootHash":"0xa4f08a0890dabaff7f0f8e1d53a258bbd59ad38ae53e8e727c0c394f51f07cca"},{"version":"0x00000020","timestamp":"0x06f1ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xd5c7eb235959ddc2e27bc6aea8da484d82dcd0d7230e13245c0a9f890104c03f","merkleRootHash":"0x55198166278fbcd3f87c8232d34a279574ac2665c263639d16aae556967d832b"},{"version":"0x00000020","timestamp":"0x33f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xa349eebbab02db06162305673ee4349e0b17e982fcfa5eb9c322da9e369aed11","merkleRootHash":"0xac57e1294a4c8eeaf00f81013099f1e8cb0f16e2db44f3cb40ddc7bd27b00e4d"},{"version":"0x00000020","timestamp":"0xb2f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8f12d24045c45e7a5cbb44bbc3d8238dadc0eb9d6e6722ebc0a220afc2ff061e","merkleRootHash":"0x04f1f80b352fd7a27b81bbe7b4135efd2166fa571cad337fe36d2b91f084fdf2"},{"version":"0x00000020","timestamp":"0xb2f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x96d9de4a7741f86e94589cc14724d143fb361a8fdd557a396365dd1082377c40","merkleRootHash":"0x7ee22bf44981845406d3499dae2f533df715cca5967807b0bae2e0491e5cff9f"},{"version":"0x00000020","timestamp":"0xb2f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x142ad6647b79e8afd662a1dba58a6c5f28112ef7b62a275fdb21d4f05ce38b44","merkleRootHash":"0xefc8922104fe93478bc30321464ff2d8214f8079364e912f156ad4dde1d4db5a"},{"version":"0x00000020","timestamp":"0xb3f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x94351c7f44113945d324d76b8b6701097f116e34d5fadbfc015d85f4dc463745","merkleRootHash":"0x97fe9ed745fafe3c40f9481b6770d7ad277714c6d7e4dc992e35820c8d8616b7"},{"version":"0x00000020","timestamp":"0xb3f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3acd85b4f97d44993405afad501570d4c3a15ef4c33c941e2145609c5b770a7f","merkleRootHash":"0xc80f7256996289f7647490c516c3c339ee7f68c839db3b9b9ec9ccd7d1db22f0"},{"version":"0x00000020","timestamp":"0xb3f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x88b6383afe82b296a9a379a1c0ad5904b9443797774af33a541260ed3a1ec10e","merkleRootHash":"0x9398c0993cbb662e2c4a014d109656f819238e7a4dba73a9407dda11fded7144"},{"version":"0x00000020","timestamp":"0xb3f2ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x57bdced86f9aa0a2a9ea46b529e5c49699e5a344ef2dbc18c5eab0a80695a35d","merkleRootHash":"0x2ee0a1b188711cae48d9dbc692da5917e9590afc2557bb84acb968043a304615"},{"version":"0x00000020","timestamp":"0xb3f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x51bfde43eab0e3b598b3de54557f369383a2ac0441da1ac225d6279ee2a6c975","merkleRootHash":"0xa89e865dce28d9d0bd828e352e3cb848d5ba7c8900e3ae139bdc5c36a6483ec6"},{"version":"0x00000020","timestamp":"0xb3f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x5bf86983d5f6eb40d902c0eccfe7810575dfa2821ed0507b62d2a05246411c33","merkleRootHash":"0x7a1b49f6b8a80688352f86f3ae6200d019d8d4d7bc1a745e765070c6e2a296fb"},{"version":"0x00000020","timestamp":"0xb4f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xf3c6cbee8161454ac277815bc7c1540d56eb45893f62fa395c6979eab8678a42","merkleRootHash":"0x35396a47114c520c5e485de978458e72ec2f0b014fb042a9c87f33b33d8e7bed"},{"version":"0x00000020","timestamp":"0xb4f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x79d9a53ea68b751ac8021bcffd84e797ffe1d9867031cff5ce6d92c208e8cb1d","merkleRootHash":"0x69b10c5fd006fde01b5c2daf0be75005326704fd23644eea342ff9e041cd47aa"},{"version":"0x00000020","timestamp":"0xb4f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf6ac606a7b25de2f4576211dbf8f1b3852af5b6b942deb6151e89c26d7e9e709","merkleRootHash":"0xcac462583e039afbc720140e369421a3cee771206fade2590bf1159aeff24b05"},{"version":"0x00000020","timestamp":"0xb4f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc5608b3fc658673a1cb91852c81a29d893e1cd7c3e35df613854250ed00d7215","merkleRootHash":"0x039b7ca1669cf89eeb5b508c1b463d8a35db5f31069988e6b51d2db9952feb73"},{"version":"0x00000020","timestamp":"0xb4f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x7b6928029b4b2879b9a2e38b8bc1fa6ce9205a9b0e1a6d012cb7bf16da351231","merkleRootHash":"0x0ad4e8beb02ed94d6aa6de64763513fe744ee1ca992664bcb1c68f57a65c921e"},{"version":"0x00000020","timestamp":"0xb4f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7d11d526053da1023a38c2dcc3ff6cc3624dd53d4db16b372b84fd9c958d5d0d","merkleRootHash":"0x823e8bac3b6cb7cf564e66678845547463076993b399899ab7497209e1417da4"},{"version":"0x00000020","timestamp":"0xb5f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xeb66859c2836f12f9d0f1a529f892b9a1f4ddc727eaf56295a24636098a24744","merkleRootHash":"0x518cb658c39fea4b2b53a3f168200b46ee334baf73678eb82819270e6b6bb5bb"},{"version":"0x00000020","timestamp":"0xb5f2ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x87adcbfefc480b9971ef543f8d0171dd25368c0254e04dc2eead219eaeab290f","merkleRootHash":"0x3744d5483b0894ecb56c705c81feb35d6484dbcb020d12ef2392c67695eedac5"},{"version":"0x00000020","timestamp":"0xb5f2ba66","nBits":"0xffff7f20","nonce":"0x06000000","previousBlockHash":"0x7134278b02c1ca87c5ca9d1fad99297c6dc446ee8e3f10374e8a2826afeaa403","merkleRootHash":"0xae32846e5379e30e3780c9dc2326b4ae8d20397f7f95a6141dd6b45a1978b43e"},{"version":"0x00000020","timestamp":"0xb5f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb3f8a1656a7379028b20934c471c13e62895af85f281ce46f25fd0539b968f0b","merkleRootHash":"0xdbb9a517a35ecdf3bb244e9f6aae6e8e465d5dec497856a4dde98748e1c7385a"},{"version":"0x00000020","timestamp":"0xb5f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x213d039fa58d8b5d7b1274e3965213c9ab4393cbe1bee191fb46d98fc51f9a19","merkleRootHash":"0xc06bc58809feb8882f5caaaf014b3d3f761b7f01058a63164b9bb70406b20175"},{"version":"0x00000020","timestamp":"0xb5f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xca9a4949818d747c47762faa2f0023f1a1103f3582f342fe3236190ae582c41f","merkleRootHash":"0xfe2be6ebcb5a839ef89ad6143f89d17a7ba15f6244ce4da58659c5aa8a9475a7"},{"version":"0x00000020","timestamp":"0xb6f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x272dd23caa2958ac22b96ee71158d02f86282f6024968432569f1756c11de15c","merkleRootHash":"0x0b400869e78ebdceaecf9465bdc34ae2c26f1ca9945cad7acd96023069bc38de"},{"version":"0x00000020","timestamp":"0xb6f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4aaa39aaae7649a395af534b896bc77b6f0e70fe2162eab510d78996251b5a3c","merkleRootHash":"0xb534535eb42f7d46bb8fc0f4cfc345c44ea85856b2def416355d85cf934a085d"},{"version":"0x00000020","timestamp":"0xb6f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xff84d1b457fc1a38574ee983da99948262554a22b2429e5e7359c4de3d81ea78","merkleRootHash":"0x2565d4e89e022ce1541e96532567e54f8dd50e7d850a7feb01ec492002f5876e"},{"version":"0x00000020","timestamp":"0xb6f2ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x952693e1a6e90c122a8ebf564b3485d48598167afdbff83b2a55bfc326a3c966","merkleRootHash":"0x374ec9f60d5a0cf4dbd0269159cc74d69f24b922f9f52b42169b266472a3c96b"},{"version":"0x00000020","timestamp":"0xb6f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc7971e55f698b101e9f1b7e4940cd1fb8b45b9b5c14a5e1f1bbd9e5c0b32997c","merkleRootHash":"0xe043c43562077c2863d1132e23d87b822749d84cf66cc16af5aaf287bd8f6ea7"},{"version":"0x00000020","timestamp":"0xb6f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe65da39d767c4968d727dc6d1a096d783b98c11a1c7346e20249d1f7014b3815","merkleRootHash":"0x096f0f137025a92ece099a96558f35a4df33c4045d435c147a8c279489588213"},{"version":"0x00000020","timestamp":"0xb7f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd6507a9cb2147de034b9d0f40ebc6958fb13358836f22eb2a0fa08c414f6c309","merkleRootHash":"0xa49f9f67d2f344bc4e8db9a392ee5b1c982dc9e8a5bd5f13e3ebd5b8251eea52"},{"version":"0x00000020","timestamp":"0xb7f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa6b2d37b038ab093a02dc9fe229d4e293f316054940b1e6e2916e8b96708c000","merkleRootHash":"0x22e03346b8d5696681c8cfcc15dd99e53ca170ad5771ea5f35bcec56ca1ac964"},{"version":"0x00000020","timestamp":"0xb7f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbd563973c8fd6d7f2efdfb4415fd0da296dbce94f9d628c6d3491d75d7d0f263","merkleRootHash":"0x4ab36cf5b22f3c955dc9026234d01ac600aed3e90ea70ef8c60b93e449ceb067"},{"version":"0x00000020","timestamp":"0xb7f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xaad470c7dd8a8cb139d81bfe046bd1cab75cbb6e36fe0ff99c874eac72cd522a","merkleRootHash":"0x9f389c801dd28dcaf25e010424981c503aba1b3dc54cc601e72ec3fd54690dd2"},{"version":"0x00000020","timestamp":"0xb7f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6db1eec483987f551f59359cff18886b882d6b540058ce765f1e0f00815dcc09","merkleRootHash":"0x8bb5f2a7208867b73f146374e6e9efd1b627d719b95f3675a834c832118e68f2"},{"version":"0x00000020","timestamp":"0xb7f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb8f03d4f734b02a583086bb113593969460b89d777596c47aaf6afee1d4b6e63","merkleRootHash":"0x33d692b63e043037ae6e58611ea48fdcab56bcb2abb6d3f4b19871fbe489afb0"},{"version":"0x00000020","timestamp":"0xb8f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd701c8ee4634bbef124ddc965738dd67f700acdbfb6d3a7b2a71101283fa5131","merkleRootHash":"0x7f0609a8eef04061d9fd6a703ee4c743184edf7cff0c09ca50d7e0a9de44c117"},{"version":"0x00000020","timestamp":"0xb8f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb776de15a6ffaa06392ed2351e614d60f060052dd2d1981762e62a95c9f51646","merkleRootHash":"0x3b859890a237c6b9258655c18de62720acdeecc7b96b3ec416d06a8e14f6dd88"},{"version":"0x00000020","timestamp":"0xb8f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0059f16f422322877787ba03f0fc5c28f1ef619411461e164fde06dd0ef3ba76","merkleRootHash":"0xde1d9de838e3d439b7816e8d68698eedc4ec47685283b5c6486aa666eaf6770c"},{"version":"0x00000020","timestamp":"0xb8f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbcfc2b38b3790ba8cbcb428bd767f8bcc97351301a9a2f8c1e0f66d99086aa53","merkleRootHash":"0x3607b1998851f9931e5a48c2cd8d86864dec64c451f867978c53c70274dcab36"},{"version":"0x00000020","timestamp":"0xb8f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4e48d121880819e43f17cb2869908336a5d4ca0d160410e0b97e54b5a411c860","merkleRootHash":"0xc769c764830cb9815b58cc3197459fc22a887550c668281c3d855d905c4a45eb"},{"version":"0x00000020","timestamp":"0xb8f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x593fab985f8488ac9e1a0cd3a2daaebb75ec23175bba04c55c9abebfec763719","merkleRootHash":"0xbdfe20efc288d584c84ca9e10650c1c8feda817890a00a74d88f4dc8549e15c4"},{"version":"0x00000020","timestamp":"0xb9f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x1211995f82b0c137a9e2645f0fa7d08414be262dca13484edba67fc7cbb3d77d","merkleRootHash":"0x9ac4e2d48650521341de4a9ff3eca58db27570f5be9d0485252eaa389e3d7b48"},{"version":"0x00000020","timestamp":"0xb9f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x438b57cfeed5f3dd5169f0621ab2e220a671c902c9b12136964f457c1f63276d","merkleRootHash":"0xf9911adab3084632913102c88aa504e66287ac8badbee6d6cb19aef08c195ad1"},{"version":"0x00000020","timestamp":"0xb9f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x27b8ecb492e6f9b31dbf3817b54d80c73ac476b6dda01a6f94e9cd884ea6f202","merkleRootHash":"0x7a2db9955cc2987445e7d8f7bf6500140d852efe7b8b5e9e82cd8e9f3d76394d"},{"version":"0x00000020","timestamp":"0xb9f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x283ca99cae29793fb1c4abe9528998844d2c59313666dd32750203d32299547a","merkleRootHash":"0xd54389eb9f19e7bad1fdeac0ca6ffceb2cff8745be2ff29e22be25dab98a18d9"},{"version":"0x00000020","timestamp":"0xb9f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x42fee7dc2e2e2edc0a94355282c8a91080bca839b710acd6ad347f0844ec5e4c","merkleRootHash":"0x38e3ee5baa821d9d54e3cc425c958aa0a5410406349dd518b684091ab70b7c36"},{"version":"0x00000020","timestamp":"0xb9f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x82e475767f2ac034d39755a28f429203b43aed4abd87afd2dd42d3624c1ad46b","merkleRootHash":"0x096750991754a8dad5f32757da65778a35e6989b316fc521e11458100e280cd4"},{"version":"0x00000020","timestamp":"0xbaf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa94e44ea449ae96f748a1dfd5dcffbe2b992c59e42dde86439058cc1cab2610a","merkleRootHash":"0x098355bd3579f8e71bc0e165db0aa64a65b673429bfcdf96c981dfde18dd5f55"},{"version":"0x00000020","timestamp":"0xbaf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x247017fc062047e5d8757140ef034bcf1bb48c4e074894fca910a42507b5a951","merkleRootHash":"0xde3bf8518e1f815951ad700b08ffbec35c8a3f43192d88afee108b8a907082fb"},{"version":"0x00000020","timestamp":"0xbaf2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x5e7addfe23dc77055bed588c49bcd05a5e4d012860d9c6f9d8bac618933fde55","merkleRootHash":"0x941e3027fa03ad054e2e5ef10139231567db077590cbcb9c77019e66278919ac"},{"version":"0x00000020","timestamp":"0xbaf2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xdc097277b11a658db1b9c9900748f04fc515bfd4d35e5b58567fc9423e7db139","merkleRootHash":"0x146b2c61c143ff2a414956ef615ddf56ea5474dcecf52a04819ca6958d699306"},{"version":"0x00000020","timestamp":"0xbaf2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x2cfb157fcd9b95ab3ace5fca6fd1e4721bd349d4823fd0d78c37c907a5c1295f","merkleRootHash":"0x718483b1cd527e0604e136f67c06e3dae5463d60f212ff02adffa7b183767c96"},{"version":"0x00000020","timestamp":"0xbaf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6e73159b1061e04079771029c0298bbf6f6d42ddca436c119f76046f5a5eb738","merkleRootHash":"0x4d5d0cd8773ad7c0f0de51f1a1d3e2448ce21f0387dc4fbb9b19192fc08de636"},{"version":"0x00000020","timestamp":"0xbbf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd7214f2cd086e1be974ade8b85cc5555a1c13152e6a009b21afae20c29fad260","merkleRootHash":"0xbb01ce3a03851bcbde759924a9964c84a7a309a9fb2c27ca08c522beba16e4be"},{"version":"0x00000020","timestamp":"0xbbf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6eed4bb5af75f0e22b247a7593ba273490f7e55f6c6aa045ca5b924f80cda940","merkleRootHash":"0xb7edab212c4572e5afa9bc1810348822875b36adc0f841b82702829113053bd0"},{"version":"0x00000020","timestamp":"0xbbf2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xe5a69cc1a52b35a6484f216dac1a8d700f23bdc88b2261c86cc56947dd7f8b55","merkleRootHash":"0xb75ee50a653407426cfad43fe60889a1bedef545b76f7b639a44bbcde3677aba"},{"version":"0x00000020","timestamp":"0xbbf2ba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0xcf0056d982761cc99856d269125e75c1b12337f7c04b302357688c6270ece506","merkleRootHash":"0x2ca58339af5b7a3cbab2132171af6eaecb41e49bb8e7a3a4a859d8542170ca2f"},{"version":"0x00000020","timestamp":"0xbbf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfe7288f7e3f3c1b5a63fd1b2c4fad0bb1b2458fc0073c92a7a3dafd20aa2b02a","merkleRootHash":"0x18dbf25a3e1184d8fb77fba4449ac59133e4aed9b6fc70396e82205cb4c5e905"},{"version":"0x00000020","timestamp":"0xbbf2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa9a1fca7216c34a8f15e9ded0ee282864f05e0ceee813c184321083ab1cf6023","merkleRootHash":"0xa46939f5bfaad56acecdefee5bce6d7434b3b2b9e453a310a612efaf381604f0"},{"version":"0x00000020","timestamp":"0xbcf2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xab488e8c3fdfc6c26f469c355283d1edfb170c33f02c7c423909f9ea344e0603","merkleRootHash":"0xee7d2033657db675dad1ca69ce9ac9c33c8e4b58d9b85bf2dfcd3efb2e0ebd94"},{"version":"0x00000020","timestamp":"0xbcf2ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xe9eed89d55c538e7f0711ab35ea26cae1c192b4327edf6fdbf31ce947c5cdf04","merkleRootHash":"0xe061449c19ef4e56981161f71284738c2fc667c92a189643353c90325635ef24"},{"version":"0x00000020","timestamp":"0xbcf2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x8d8dc466806b68557801ac7aee97d75d5fcddc4918fc0576f5377427f1da2a73","merkleRootHash":"0x7e5a069818030dccbc7b0d8eedd5cc4cee1c4af591b6d0914c1c82e9e8e68118"},{"version":"0x00000020","timestamp":"0xbcf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x30f76f1829bd742f401a28e2966cdb6542a288dd3f696914f94db451219e2d01","merkleRootHash":"0x9af8be1418377dd6d08d4c622a82afc8173470cfe1ae96bbb2a13541f69721fc"},{"version":"0x00000020","timestamp":"0xbcf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3bdaccac79431d25b28ba125b5a80b2866160e585bdf5fa8d3b60af171093e1f","merkleRootHash":"0xffeda86eb1d0c65351cc9d1322a32683d82a2b32fda2b809e56855f202d1b8e4"},{"version":"0x00000020","timestamp":"0xbcf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa552c0c327a056aa12ae782555a5d98879daddb63e094a5c22798e0d28c64a71","merkleRootHash":"0xcddf5506084f8442e177dac1bc888d102d180751ec68aa3560680087457ad8a0"},{"version":"0x00000020","timestamp":"0xbdf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x647049725cea02dfbe6eef87f311dea9aad4e83c948e72ed9fc6889cd9b1772e","merkleRootHash":"0x686e33fea82c5edca05367ffa21ab55f9b2f28fdd066b0b96ea618723e323852"},{"version":"0x00000020","timestamp":"0xbdf2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x85602c2811f992becf8a813e3e2d0a51adc313a6025c80d493d9e3d280994967","merkleRootHash":"0x13a910fb11cc93a401a664559555ffb60f98fe4e90bfbdc390e985f13295a848"},{"version":"0x00000020","timestamp":"0xbdf2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xcef97966091a2c72948af4457e2f057aa15bf40e9c8da988c27abcefe651530e","merkleRootHash":"0xb52637e1f00ed4ec3f2aecaeb87ade6c75a74032695c88699fcde9375bae810e"},{"version":"0x00000020","timestamp":"0xbdf2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2bf4b7812a0a7a2b0a1e40b6d21015f2f2c613a79e819ca90b3bf1392d8b185d","merkleRootHash":"0xc9132264d561505b44d994351aa2debe8c04c40b509b269678b1fdb7c2fbe100"},{"version":"0x00000020","timestamp":"0xbdf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb5b9a1df4fc688489edb77ee5fdabba68663b6c6af96c3b3bdbb4e96b7eb0b19","merkleRootHash":"0x88ad206a0d2441ad7fbff9352bd0240aa7af01b8664f9759dcc5aa6050418725"},{"version":"0x00000020","timestamp":"0xbdf2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xcbdda59601891b0933d70b005468a1abdd88d697ee534f7054b834d3e58e3b30","merkleRootHash":"0x8f8c3d3cbbc481234019e8cdf46e11efd74efba8883b742f81456acd557b77da"},{"version":"0x00000020","timestamp":"0xbef2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1b1b1f63db38290c5c9d55ea0d19e5fe34b02925d67b6624cb88fca7d94aa64e","merkleRootHash":"0xd18f03f6320bbc61418ed8374643e09d695af1676cc3d1b31dab16d2133997f0"},{"version":"0x00000020","timestamp":"0xbef2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf141545a1df8be4d31ddbd878ecb2e180e5c1897cf49dad49e6df8c49f055329","merkleRootHash":"0x8107068cb4fc9c4277d1754176b020fa9b74434302710cf9d3d07afcd39a1047"},{"version":"0x00000020","timestamp":"0xbef2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3a38d16cec0301beb6c8de7ab0e018c6b72ffaf1deeff927a3056d18cb20f170","merkleRootHash":"0xa7a4d5de2504e676dccb46fa3fa7f43634e4c30e7fbe25e38111902fc3e474d8"},{"version":"0x00000020","timestamp":"0xbef2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc9414176522873a03597996af993f1e2ee1c7309263009ea952c5f6eb3768753","merkleRootHash":"0x9d47ebc1d66dcdd65bd11f7461a40b52692d7d07a376aea9cba5655d50332365"},{"version":"0x00000020","timestamp":"0xbef2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2cab2007e16d89df309e548c5eb0551b693107b5fb8b010adc79dea045d01253","merkleRootHash":"0x72500f57b2db80de103639e2c23e4e1ccb03d9246fba738e3c7800eced3b0486"},{"version":"0x00000020","timestamp":"0xbef2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb886a2fc270117789c35fb3be96d5973534f005289334dafe8d35f7fee3cb716","merkleRootHash":"0xf60c1834de6dab98d911f2b257a8367b09a047f418439c52e12cc01f9d05133c"},{"version":"0x00000020","timestamp":"0xbff2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x05a24f39bf82fef34487269545b32580a01422d42afaed2caded658a5ef12b78","merkleRootHash":"0xe0ac10ba84d200e1efaa00fb28067023ae4757af23d80cb21647216209cb7756"},{"version":"0x00000020","timestamp":"0xbff2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x95017de4927fd55c3be1254347debc26bf983a96020721b4c6671a4938139006","merkleRootHash":"0x01fe8b7484a8560d4aed9732ed68026ebb58f9e1f0eea8474d6d96dc483f43f2"},{"version":"0x00000020","timestamp":"0xbff2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe73049fb0f888303a963becdb0855769d1df838871f00cfd5c4302e3506ccb70","merkleRootHash":"0x48fe7b11bf70eb537839534b5daf236a308a8825795f89047d8aec90aeb1d08b"},{"version":"0x00000020","timestamp":"0xbff2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x01029ff5bdb078a779da849c9bd139f7308abc23f7ca64446427c6e49d8e5f0a","merkleRootHash":"0xce17053ff44724dca64def64913e35d4b1351cb881edeb2add044929e06ee19a"},{"version":"0x00000020","timestamp":"0xd2f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9d0c1d8595aad50f460dfda4c0d7a95f5697a74bf50b7dfa0f476cf66f48de5d","merkleRootHash":"0x8fb8df05378fa4e8ac1cabd3ff466ccf9d2f7982a283f7f4aaf94732611b8a22"},{"version":"0x00000020","timestamp":"0xd2f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xdb7715e5634d19c166b149b3d4e7cfe4677b19feb7536cd9195ec71b70a0e82b","merkleRootHash":"0x4b60fdad56330d9b993a72eaaaec1eec13feacf2a89ed22d8dab33534de21fc4"},{"version":"0x00000020","timestamp":"0xd2f2ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xa66d8a1e6ca87e3403b7f70800d7a659162c615991f5dd536ef18eb08679ca01","merkleRootHash":"0x31a42b9e0e509fa2b79bbe7f88bb36b24e250ff96d8f9f3f87087eb93a75aadf"},{"version":"0x00000020","timestamp":"0xd2f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3b34cf506cb5262df3fa53aeadf07981ab7f6fdc9a05df15da4b4053c7232b2f","merkleRootHash":"0xc36d3f562c5ab23f98725ccf4d30d4ff22273e5a085b36c3a48dcfe47f4f9f83"},{"version":"0x00000020","timestamp":"0xd2f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xedeb945c466332e85e8ac874060d30d1dcbd84f2c3d119ee2f765e77a962e138","merkleRootHash":"0xafe563fbed21de126793608679d930b55c5037e290d9787c72c8c073d296ba61"},{"version":"0x00000020","timestamp":"0xd2f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb6ec49a8afc64aa30f20f17cbda067e29334fc314ba0b5ed5d68ef6c850fb166","merkleRootHash":"0x4705946cb45a0c2d4e6251832bd697706479f958c93b9214d1f300a56700f74a"},{"version":"0x00000020","timestamp":"0xd3f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x18b83a2473e966787f5db2567ed2f57e2d65403642e97ade9da59db34279100a","merkleRootHash":"0x5b0faa26c133b0574b18aa7ab15e606c15e5d920b1560fbb13ab141691978066"},{"version":"0x00000020","timestamp":"0xd3f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xefa4aa64b5133eef836045a823e04eec1a53602aa023d40ef54768ce4d42b004","merkleRootHash":"0x7a7bcd9f259b8e51efb06c7c0581c849a314011f824a1a22ba0276bedd81002e"},{"version":"0x00000020","timestamp":"0xd3f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xea806cd9910b7710059f5dd97533fcb779a43dba370a33a2092292c0c1268050","merkleRootHash":"0x88e8a7ce625d0e16e93f2d17729ad51f80df71923c084a38c4dbf810b26465d1"},{"version":"0x00000020","timestamp":"0xd3f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc9e4ead011121f3247a3b5d96ac59607b3a494494a7ee77754873d7ddb2e8307","merkleRootHash":"0xeb5be16a687e892c50509290d5a326040bd0c3a443883a6d810afdf77ce75238"},{"version":"0x00000020","timestamp":"0xd3f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xeb36f88ebc18ce7890cd19c60efb9ca5fea1848cc7a57b4f3b989bbf56270f6c","merkleRootHash":"0xdf61b8805913f03a94734ecd8083e18beab5f1b5d74dfd2b14f225c8ba26cfd5"},{"version":"0x00000020","timestamp":"0xd3f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x45cd27ca88fcbbdbd1e5659a72ff41e1f4c1391ce6d6c02e2498c7e95155d32a","merkleRootHash":"0x91163763a35a9c728615c14b96d0be88a625b0b621e2c6257d2737afe75fafdc"},{"version":"0x00000020","timestamp":"0xd4f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2677fdb2c6c5c64598a36ba8a42082371740702ff607ac228c46afda11057665","merkleRootHash":"0x1d8c28973f8eb014b93d9f2df244a9887ad55828643ec6699bee5070dd28fe8d"},{"version":"0x00000020","timestamp":"0xd4f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8c9c0f6043e354430ef846d21a93c5853bb30c20cf9bde2274eebfd90a9bfb1a","merkleRootHash":"0xb5a1b7443ea78b2fb2dc21f753aa5763edeca9b94975442738dd17f04867f3d8"},{"version":"0x00000020","timestamp":"0xd4f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x061e841cbf9fc34767df76d371e71999d941c1aebbcc84fde40806c7577f922f","merkleRootHash":"0xbab135f3947de62a42cdc993b7b32197fb9d3bfd3a72f5dfa2145e037fefce99"},{"version":"0x00000020","timestamp":"0xd4f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8a2ccc90c39f2b708d3c6c276627cd887b7cdb2d801d9acb53df215270393c6d","merkleRootHash":"0x00803132df68203d778ec90e57a583571db652503283b4e0c15a6dc792c52b14"},{"version":"0x00000020","timestamp":"0xd4f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4af10cc8bcf494c5d48c30494c4c934902d71a58af474b12556f04210aaae53c","merkleRootHash":"0x1e159d34bcfb50006234379434ce161b230337e1d97053bb85fb648ae32f4892"},{"version":"0x00000020","timestamp":"0xd4f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb96201933ab10a21bd46ffbd95a46887ac84f4b91d14b37823fd023ea81ce701","merkleRootHash":"0x9c6b10c87582cf681d74bcedc49117dab914f6368e563f456035117ca3dc6c43"},{"version":"0x00000020","timestamp":"0xd5f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x246944f41459f69d445bee4c2347297fc2f1fe14725a58b9299cd2890d107a33","merkleRootHash":"0xe12aef3e442c91dd3b27333c2413b7c13c4e88cfa48ad56d75cabfe46071fd91"},{"version":"0x00000020","timestamp":"0xd5f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xefd17c72620b4519963e45cdae46485b1c1151d3c062b5907db82ee383219076","merkleRootHash":"0xf5e1ebbaf20a74c9f00fef2af8d63b4077f8708c68e4804f4029b33b41eaefc5"},{"version":"0x00000020","timestamp":"0xd5f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xd2abf91207a6196c55bb84645ef59b03b04d4bbe656676ccd535b293568ede5d","merkleRootHash":"0x365872b2406d66bbaf50fbbfc9cc5102fe2d33ebd448db977859c0389196c217"},{"version":"0x00000020","timestamp":"0xd5f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbe225e2ddb665b1b95abbe43b079b904426dde760e6e27765c9cc2788c839365","merkleRootHash":"0x56e43c8df0ba65b9e7d39c07a9f95cfeb5248a146896cbf66769084504b13ec9"},{"version":"0x00000020","timestamp":"0xd5f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6fa81f2eb68636880b2ff3bc695c0aad90574f538d1010c33cc17557a3713c77","merkleRootHash":"0xb7678e8b579f60186055c73bdf4dc79433108479887107bb9ad049f67f5eeae2"},{"version":"0x00000020","timestamp":"0xd5f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xc58cde06e75fdde0ed565fbf149b5b43557a333144ddb6dda6918320d5b4d531","merkleRootHash":"0x9782e4616b5cce228b91c4eef9b4dc63890cfe68df244f259347a7be0d540e1a"},{"version":"0x00000020","timestamp":"0xd6f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd91bb18908d14c38316f31fdee1e02e07360a63c500af861e12e54bfddd32a42","merkleRootHash":"0x06fa00c458232de0a04de36a4477addba3673f468967ff134ce1df13b1e021de"},{"version":"0x00000020","timestamp":"0xd6f2ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x7eafd0c50ded4e66f04518cc5a0d60115743f3574a0d9d5d3633200d51b82f14","merkleRootHash":"0xd622409e8a379f60db384140738301f0db0163db437203926e84d217e11656dc"},{"version":"0x00000020","timestamp":"0xd6f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe2b1d2c9f00fca4ac3be2391c21dadc3a603ebd31f41800bb30601d447a26227","merkleRootHash":"0xcc3fe5685537828214eb8fd94908e29cb4ea0f0ce389ff94e1ec8ccfbfbf5266"},{"version":"0x00000020","timestamp":"0xd6f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x935f42253a1cf6012edf739976fc18863c5616f1710791ff81df912b419abe18","merkleRootHash":"0xd3c24e1f1f495a4c81ccd21b901ce0fea6028a4c9f2da1ce4d7806a359bbdc6c"},{"version":"0x00000020","timestamp":"0xd6f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xf8fe0f828d286cb731ce19ae30f967466416a6ea14139b0abcfa9d70b9f00456","merkleRootHash":"0x7377c1e9c962b2bf0afff4f5ccd48181b25d415f59322181ff43a4266da2179a"},{"version":"0x00000020","timestamp":"0xd6f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xcbc6a34a72c68ab4e315e541594cee263976b0f0da8ef9c6fb20749e2902533c","merkleRootHash":"0xa12dc033d39203cf02662d309dc219b0e3edc7dd93c58ddb1348b6e9283979bf"},{"version":"0x00000020","timestamp":"0xd7f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdd7957e4bb70ac4733627f2a7d1d099c8a88d8a5d17cbfe180bb2ec262bf6c03","merkleRootHash":"0x59f118ed95b9e34c813fc9b45095371228bd3967354e44438ff5d66cbe4cd601"},{"version":"0x00000020","timestamp":"0xd7f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0424a42ca392818b381aa4f2339d4d737192b8c90e52dc3bdf114633656f2751","merkleRootHash":"0xebe664bda886ec60b0d090693020278bda95ebd9815a40d8f8db5b2361785828"},{"version":"0x00000020","timestamp":"0xd7f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x269081d34516f79d37d6a2ebc6f536fc0c594566aa510c1128bbb0d139353025","merkleRootHash":"0xb60136d157bd9dd39c284b262932f44dc704043ab62d9728007b7fef0bed8be6"},{"version":"0x00000020","timestamp":"0xd7f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa688e900675791cdb4e40beda0dce87bb038920926ba53c5a07b7b1183c70955","merkleRootHash":"0xabfd08b5189b6a18ca2ab5dc4697cdc00ffa392ea66cb323aea6751c24e7484b"},{"version":"0x00000020","timestamp":"0xd7f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9603104d2f110f12eb898b5f7a81b9ca9baee3f310799f01c292a7bcd7315547","merkleRootHash":"0x80482d7e39745eb99d06069a483e12d79bebb95454f3073263f64227d61afdd8"},{"version":"0x00000020","timestamp":"0xd7f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe06aef99569cecb32eb0b9eeb3ccb7ddd800a03f138c71f209842c8cca0c720c","merkleRootHash":"0x7633266236d1631bc408b88c11e617ecf434522b8d0a4f4b63bd351f5e944b39"},{"version":"0x00000020","timestamp":"0xd8f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x748d4c7952cf4242f89849b9cc01979a0c0152a869ef618435d8f9cd7817191b","merkleRootHash":"0xd502ba01f6a977d4968c9461c199222f62c201a6a003fad3a03e9cbe4001ed2b"},{"version":"0x00000020","timestamp":"0xd8f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe0520050019f356e9e95dc094ec16226557504488035fb552c011cae2fe47c16","merkleRootHash":"0x5a17a3a40766cb7b8c29a4c3fea1f025e1da04251465773f0ce27288d8fadb7d"},{"version":"0x00000020","timestamp":"0xd8f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x82e4a1d37ad1e40f3abe65958d01aca9d4801a6146fb53d45a97778f32545e3c","merkleRootHash":"0x023607d6eca8d69c3859d01480f9287ae2aaf906b19e50b2bcd252f6784990c1"},{"version":"0x00000020","timestamp":"0xd8f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x20da86495679a16b27ce6ba8eeb6b2fd515aac6b66d36f974a7364183435680f","merkleRootHash":"0xb07886d612b185f72c2d6e3ed2b93e8e72e52058468fe5f344ca1f46abfedf21"},{"version":"0x00000020","timestamp":"0xd8f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x982450a6a8b15a3a9d6339b261eded6ab7e40eefd9c7604be43ca2cd2117077f","merkleRootHash":"0x2e822c8d608158bcc24cfc696da2de638effcdc4d78444598461972d42cf305e"},{"version":"0x00000020","timestamp":"0xd8f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x67f7416d67a7cadb867b9cddcd64ed6ddfa9a18e1d937c882c0adb23767cb01c","merkleRootHash":"0xd2919d0df5f9bc4772b7b8f0d9860bef00e0e2f85640c20a999a13b047c0ccb1"},{"version":"0x00000020","timestamp":"0xd9f2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xa40c648ab99ee5c2a29acfd1f3b2d286f61f2f0d7d0208cd798ddc7eb3250d13","merkleRootHash":"0xd93d58cfaa3657bd913e68a86a578c0a6ff0bb331d397d850d933844d5414809"},{"version":"0x00000020","timestamp":"0xd9f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4c51de41025b16cc2d889ef3a778ce4ecd9f9563de56998724869db83e72a605","merkleRootHash":"0x34c2bcea8a68c21cdfdf55187d52548b574245a43c6d26cbf16a6754fe8ee455"},{"version":"0x00000020","timestamp":"0xd9f2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x62426f1de56d9171ecffd12807239d987077ecf1b43e9d6b4ed6c5a2da7c0e77","merkleRootHash":"0x6f9cf4090f7955a6283392f5019070acee4cf0d06b926dc3700ae79234f67ca3"},{"version":"0x00000020","timestamp":"0xd9f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x60b3f0a12a0a2e6066775595769547016c34f0883f74e1549402b98c80d88b6e","merkleRootHash":"0x7f59bbd6fb8e16acca66b73877b2ad40d1c1cc12d4d20a68d410812d0ee8988a"},{"version":"0x00000020","timestamp":"0xd9f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x516c268de308a8b748a71e84d500c40c1b45471e19c8d201e30157ac2c69d755","merkleRootHash":"0xe9be195a9648e98fc9cb10a1455b9bdc182190492603179006fc966b228f6491"},{"version":"0x00000020","timestamp":"0xd9f2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x79fa2376e2409f6208e621ad426509ee804a9f45565630db891eb447521db259","merkleRootHash":"0xa6fc805bb3e8c6104c3652024e9e688355cf82f9b6f2534a404a3a6c37e90ecb"},{"version":"0x00000020","timestamp":"0xdaf2ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xe8df507cb7849be9f0d014fbd4d3deb0e7048b619ebe36488fb274818b0f784a","merkleRootHash":"0x0e9eaeec23b398b7a29d1d4ed4b908539378fe310a65f37ae24b5edd3e7fa308"},{"version":"0x00000020","timestamp":"0xdaf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd566afd2359aa04c0386538a2f5e8aba61b140fe352ebff366b9e67c6cf20c0c","merkleRootHash":"0x13aa78973edc83c3e403fb41a76037d2f04b78511a472e24f321176e897fa49d"},{"version":"0x00000020","timestamp":"0xdaf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2d4996203ea3d7c54994a7b0c5bbc6be70382007eae46d6968b2ae231bee9063","merkleRootHash":"0xb51e0dccdcf50958fdf316528a6b03251adaad4ad7887c034fa56331e916a45e"},{"version":"0x00000020","timestamp":"0xdaf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5f6fcfa473a536cdfe357e74aa99f175e22ebec41f9f5f623dccd268990e3a5e","merkleRootHash":"0x91cb542a265b7ea3ec045e10b900bf96c5135a65a6d6cf2714eecea59d156d8e"},{"version":"0x00000020","timestamp":"0xdaf2ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xdd41f90ab6ced9b33d91629ba8b2b79a4fe6b494c31b95d0d3bf1807b085a410","merkleRootHash":"0xac46eb10710bc29ef804a37125e41f7e8018cd7d4864438d7bcbd5ef3768944d"},{"version":"0x00000020","timestamp":"0xdaf2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x1ca8e404297306e78ad830ea06369cf79be28b5456519edce4ff98a1b9a06275","merkleRootHash":"0x365c399a69fbcf7544d31b023aefed96950a724025f66924181f1a4e18cfc44c"},{"version":"0x00000020","timestamp":"0xdbf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xda7e2ce3cb83a1e87479273af62b92060db392be89afdb75323979f5e611216b","merkleRootHash":"0xf13b162e64c06a77b47ce12535bd69ee3762cb2fa8f48807993ed6bffdea6d07"},{"version":"0x00000020","timestamp":"0xdbf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf2c8b1828cac878b9a26f1d0e37976c389515df7e8af2398cbc7c675383b0a3c","merkleRootHash":"0xd53ddde2335ce29e84a093adac045ffd3dc455d03b95c9f42d1a91f8e215b6a0"},{"version":"0x00000020","timestamp":"0xdbf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0eb2171885532815927dd7e18f7b5ee6673e129f0a84924489766914f2cb914d","merkleRootHash":"0x39fcf6469aa03bcaaec0fe363137539f0b83dfda02751cd8e750071cd4fb3b42"},{"version":"0x00000020","timestamp":"0xdbf2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xbd20f855ea0c7dfdd2577553ebb313665de1d6fff892cdb6c71d8beb87cef529","merkleRootHash":"0x6dc70e7c35f9e09f14aca403826ff5d585ec42e8b47d594a4fb23457e5878190"},{"version":"0x00000020","timestamp":"0xdbf2ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x6a766d3c707e365a5266df399b0ff5d4e851cd6620b40c945f407ae1ddeb3f56","merkleRootHash":"0xedbb649474d904693aeef8bf43fc8c6db7df793aaa8ebfb1b6080e33c771b421"},{"version":"0x00000020","timestamp":"0xdbf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf0bc01f9e1e6949175f6f1ca78ba28f9df2a5e83957ae2fa2cd46e67fded3174","merkleRootHash":"0xcf0fcd45e66d127153bf31aa4ccffe2a8455d9bdb45fe7df203ee8fa0063a7f1"},{"version":"0x00000020","timestamp":"0xdcf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd977f0827d3f7ba9a9685de72aa98424427ef9eb85d4d32ef6ae394614cad91b","merkleRootHash":"0x5309443fd5240bcb5c0938fd45364523b43baf140275a730a20a98c00e76fed5"},{"version":"0x00000020","timestamp":"0xdcf2ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x575e2b8cae0f8740008b996d6474ae28ec155e85f60be64904b49205b570de41","merkleRootHash":"0xfd7f4606d34bd1ba08dfbc70ab911ca770008572b344aca5e338ab0172a997c7"},{"version":"0x00000020","timestamp":"0xdcf2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb0a1f5e7bdc513558f1359e8df2941d7b6ad69d827f7eab541b49742bf9bf340","merkleRootHash":"0x0e2540e3ec43a433b9c3d2b278745d338300769e86e3226260235812aabff46a"},{"version":"0x00000020","timestamp":"0xdcf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3f302e9d1f6dcffa2dd358c800cfb721791d63bcb4b8ffbe95125f5ad41d3e0d","merkleRootHash":"0x7c9a7225c1410fcd29b8f788a25fb6d8e26e19bdd4ed981047575d8c704f663f"},{"version":"0x00000020","timestamp":"0xdcf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x049d4c549c56d3dd17392764fe1625e6d9ec007c3d4ae35b85371260ede04f71","merkleRootHash":"0xa91f813aefda0ef3d30d0602e2bdebd8830c41d449cbd29f1eeefb0f5d5dd822"},{"version":"0x00000020","timestamp":"0xdcf2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x741b97fcd3b44413e81a16f72685aa61c13f7fdb43e9c4d937553a1e0f2f8327","merkleRootHash":"0xecfb2e7342803ef4889f27f93c43c7246d0cabaf78d5efb333fe1435f270fc9b"},{"version":"0x00000020","timestamp":"0xddf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x24d8b9d654f1425a403fbd741bd6f5f3442bd13c99435d58a7e423f663d51c79","merkleRootHash":"0xe518f1ed9996a42a089a0174144e74ee3be5123eb58d6f15c6ba691d9616b082"},{"version":"0x00000020","timestamp":"0xddf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3e3e53e946a233ce4794418d0a4c717eaab950e8a43cd0d6d506a973b58ec302","merkleRootHash":"0xbeeac741a38c2041ae2d6a20ab11a1f0f6455aef35f9a6baebc450614d93e669"},{"version":"0x00000020","timestamp":"0xddf2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x730c5c2dc743c06571726348238742af6ea32ab573dda808bacb1cac11ce7142","merkleRootHash":"0x6c2dd940b249a034c87fae77e8543aec6b6d4694f2e01ad7003f31969c507873"},{"version":"0x00000020","timestamp":"0xddf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb04da9a1a20daf9ed0e0232f0b60b4fa5c36adc0518a2b932096f0d57f0c800e","merkleRootHash":"0xa41935f82efef7d72017392912ea57240fb2b8ca83771f9585b4df91923bfe25"},{"version":"0x00000020","timestamp":"0xddf2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x40645972b169e5d9d653a6f4e8c7322ac1be03c506fe6ac76b889dc81eb6ca43","merkleRootHash":"0xc1321a2ef259590c523b6e60c602241477f7a407cf94dd0c1da37d529fac63d5"},{"version":"0x00000020","timestamp":"0xddf2ba66","nBits":"0xffff7f20","nonce":"0x06000000","previousBlockHash":"0x2570145e80b9036a8cc42a7dd2653e42e349bdc7ed60c9e2612e5cdc1bd63e31","merkleRootHash":"0x889e4e6295ced03a44710a744c142d4941811d014db02a50788c7fc91764c114"},{"version":"0x00000020","timestamp":"0xdef2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x95a3210b5b7454bab205ebfc9c399d608eb122c71f8ff8e389d511d28b611b74","merkleRootHash":"0x2883cb93d5f40c0fccbefe817fa1e03877dcc0875feafbb5fdf2b89305c7d7e0"},{"version":"0x00000020","timestamp":"0xdef2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3c396f3764593c13d5777182dded3245bb87b2776dc2c159c2206afc0e20d966","merkleRootHash":"0x437427396537e7a94ef7610bcf02962374747556b627a631d2f05af064b7f154"},{"version":"0x00000020","timestamp":"0xdef2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe3c960c5c05e94e76a361e0f8a91ed3a3ede833ec04127d1f81b2f8dd7f83956","merkleRootHash":"0x032da8dad79bf77d3f191c63a0939f86d2c0b55503bdea9ea07d5bda6f206964"},{"version":"0x00000020","timestamp":"0xdef2ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x682631a5bbf83e009f7076a6ec8b1866dd6119d976f20a830ea0508e63bef561","merkleRootHash":"0x9f032fc7a8183fbbf966c78a727be15faf2a976ac432e76818f80aa827be3264"},{"version":"0x00000020","timestamp":"0xdef2ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x639ae0e773375eaf7d85ca4c5b2952e9f2e7bdc6675c52287cfb7b3b51c74152","merkleRootHash":"0x71a474c36f2dd2056f8e70851ea01e993fec6b138cb6e464e523c58526cf1325"},{"version":"0x00000020","timestamp":"0xdef2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7425056374aa00d4088a552cc2afe2d9dc3f085a6be87c898c768782f6b76b31","merkleRootHash":"0xffdff5c16daf934ed52a8d899915bf8d099c372356ac06c026b9f21f88ff7702"},{"version":"0x00000020","timestamp":"0xdff2ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5ec00bc14874530003663537a115330f347308c1ad4f3fdd5c9b294a205a6271","merkleRootHash":"0xd9cb6fef517b72a69e26b728b78ff8371346fe236f4d6ccf025eb8c67cf6b60b"},{"version":"0x00000020","timestamp":"0x51f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x3e0601683ab101d6cd2a36bf7fd25b968b53411dfb2655bcc0e2900df7444751","merkleRootHash":"0xe988bf642311a8d8da02798bdaac91f80a6d9914fa9a164e4e456db00cd40793"},{"version":"0x00000020","timestamp":"0x51f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9435ebd0c6e3b1e8b65f2d069589d3ab10a2f0af8781e1247384fb4b9c64195c","merkleRootHash":"0xb22799767876e6c95cc7aa810ded4fd509c148e91e0a2d57e8e75ec793ea5d9d"},{"version":"0x00000020","timestamp":"0x51f3ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xa8494b7c43bf2fbc8815c4356e290a357a6f45b03e7d6be341b76453fd14e578","merkleRootHash":"0xf28947018809f47d86bf5b8335256eb3b8b6a3fe7417c54ad885b4e1fd2e9ff0"},{"version":"0x00000020","timestamp":"0x51f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7440b689561cbe6af63ff3b2c824682179033f6145fa8138e0addcd6ab37f114","merkleRootHash":"0x4913012c82b01ec992cbdb6ec68a3eceb51ecdd8ec82bb3f044f2f1675e64b78"},{"version":"0x00000020","timestamp":"0x51f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd33196309e892140c4740433b7a2ac8cf94e260b3ac0176a8def7fb9c86eaf5e","merkleRootHash":"0x7848933dac76167adf68709a7392ea7a51fec2bb725f140e92d9deb7b41c0385"},{"version":"0x00000020","timestamp":"0x51f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8b49cd83d95f2fbc4ca572a291089b1ba117c577b73d8819e6eca4187165ed43","merkleRootHash":"0x8fe1c938becdd694f92176c84665bdf05fdbd3b7a76bd63242a478c091d5171f"},{"version":"0x00000020","timestamp":"0x52f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfae304101f143c0b417b0145dea26fb8c04b6504cf23226fe2e31bd9f9cf1173","merkleRootHash":"0x5108ec4a3e8262da18b405b54bf57b45c3fe078e79a065900e53d61f011e542b"},{"version":"0x00000020","timestamp":"0x52f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x942ad0c5916a9cc798cb8e1097115510ff67b6b2d6fed610754116e43ad4fd1d","merkleRootHash":"0xe7e27c2765fd4bbb48f22506b43e7f1887939d3cdd970ad461296d3ddb59258e"},{"version":"0x00000020","timestamp":"0x52f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0683edbeb5dba4aa0ff0d18463a3746d5f0637ebc4a807ce0bfec23317c08306","merkleRootHash":"0x21041cbc91e4cef24dc9589eea5964ec22bac2695386bc6f294b6727d57886ac"},{"version":"0x00000020","timestamp":"0x52f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2e22c84026c5b62dd8fa80a0b32b897216137ac140d3964afac691dc9836f67a","merkleRootHash":"0x853fd6c368b7786243b49c2b0ff417cf6dc79db22cbd638e445ff6ccdacaf900"},{"version":"0x00000020","timestamp":"0x52f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x72755bdc50ab3a5db8f7c808748e3cf0a20d2b63e17b3a20875ae241667ebd35","merkleRootHash":"0x36eb0cc043f8c520f7dba2cecdd095eed5bc09fcd995d16216c561a90b1efe0f"},{"version":"0x00000020","timestamp":"0x52f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe9c157223dbfb9bbcd9d8766f598bc0a88ee1f41e079dc478999fdf41ce89337","merkleRootHash":"0xdf320211fd0388c8abaa89c7593d3f2b98760907be425836438b707587d40e19"},{"version":"0x00000020","timestamp":"0x53f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x29b07e00f3429ead2e028a719d8f4f24250216f861ef1bd7912efd4a0bc71323","merkleRootHash":"0xcaebacf2084d3d97f53297f5d14848ef994dfe0d80c5ae491653ed302e0e1ac0"},{"version":"0x00000020","timestamp":"0x53f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x13a4e540794ffac04e102eae9973dc596fdac546236b4bcd0152b2e4c6432208","merkleRootHash":"0x692c215146a9f9a470f42b0666c9558450fe6f3bf678ade06f51dc544609a67c"},{"version":"0x00000020","timestamp":"0x53f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa8e83dce281e5819a702edf95835cffbb8ec29a9df2b5bdfc812b8773eb0c00a","merkleRootHash":"0x6a8b25bb45e1ed067e3f0e413f47e8ab10c8b62e0f0b6bae065ee8892584601f"},{"version":"0x00000020","timestamp":"0x53f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc4b520c5c10eeee7a7b222cc772731476178925c68a0528872195dfc161c1c67","merkleRootHash":"0x3c8dbf9853fceedfcb4d2f527177f53a14380ff998fcbd4697c09f262fb77247"},{"version":"0x00000020","timestamp":"0x53f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xc5b64daed3d7c7b1ad74ea78b4c016d0fa551906202e07d8f6f4760e27243346","merkleRootHash":"0x243bcd3c673e73ab2dcd5307c80c3b893c46e2471eeb135a29a399945c53ff7e"},{"version":"0x00000020","timestamp":"0x53f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x546b46e6d893243c999a05f0334ea848d322eb39974949b0b5dec3a48f35974b","merkleRootHash":"0x850268086fc2a18bad16376425f7a73cd4452166c736418d1206b7e3c6c82169"},{"version":"0x00000020","timestamp":"0x54f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x941ea50d507d816fbf8f111a3b1ecfca14c9c82bda337d42728fa9adf5ba4132","merkleRootHash":"0x88dce676b879ad3a162697f281ed1c48c98724ba690a0e2f512f9cf85b75fa77"},{"version":"0x00000020","timestamp":"0x54f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe837ce6c4b41990ee5801e04d05cee8d26a1ededeb9de749a43bb22814dc8a69","merkleRootHash":"0x3af4fe838032c18f8d5ad1979d6a0bb0c22dc543ab204afd74b709b57cf09afd"},{"version":"0x00000020","timestamp":"0x54f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbfef1d38ce03cebdf1a5efd48184dfcd0879349f0eda52bc12600191a5e15159","merkleRootHash":"0xa177a39d1789a3cce6bf67755e5416cfac22363af18b25fa14826325ea69ab3d"},{"version":"0x00000020","timestamp":"0x54f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0dda899dd0b16b8cfb2c5440567d8637c76e49c7666bb110c6d449c94f989930","merkleRootHash":"0x0d1feffd2469cdbfd540e95e9fd05c58721bfec1bdd9e52fbdb1d0c8559291a2"},{"version":"0x00000020","timestamp":"0x54f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x99f6c32f1327e7059755bcf83728fe515de863235c65523f67a8c16ea55b6b61","merkleRootHash":"0xd2117fbbad7717667e887bffcb419147f5cddbc223c2af170d6d4a33112d9e23"},{"version":"0x00000020","timestamp":"0x54f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x6f20e3c254a15ec01217b637d8e8b3b10d03adcf53161d9af934b8b7bd71612a","merkleRootHash":"0xb52eb552e9e1c70bab9ee5583b5a24266e34d7f81c9966982faf0e279772c03a"},{"version":"0x00000020","timestamp":"0x55f3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x23262ba8a485e0a2fe188a10a77073e8d27ec2abed422f222192be7043620757","merkleRootHash":"0xdebe29cd5ecaa3e31d94ae506899a67525db6eef6aae0903e79b68b6bc8eb8bb"},{"version":"0x00000020","timestamp":"0x55f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0dea73030c742d4424b450ae697c78b7b16434cdb601b59e87a8ff62896b2e25","merkleRootHash":"0x5d5f128919e1f4554ebaa10117e9f0727fc5cfa3206f89db1a68a5b7ca1a678d"},{"version":"0x00000020","timestamp":"0x55f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8fe84016c2e25c62180e8f8bea86f201634bbe106d8d369fce3ba9c68420c306","merkleRootHash":"0xbe239f1a9a5e751b9db2ce25ccc99e8cbf837eb8359e35a36b31b4ca021b01e3"},{"version":"0x00000020","timestamp":"0x55f3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xcc42ce370e658a3f9f929454796c39bc613ecbcaa1f53cdb130d69b0bdade26e","merkleRootHash":"0x1ca3fa39a9605bee3ee8f7990dd0aa052beefe9027f48308255ef14734a65cae"},{"version":"0x00000020","timestamp":"0x55f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x77aeaf5d637a7ea6c29a9952a062b57d6b472861218a8500519f57c198e86d14","merkleRootHash":"0x7688946f34afcce13c7bc00c4bbe4c17cfdf351c59542a766b738e99fc91c197"},{"version":"0x00000020","timestamp":"0x55f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x69329d0410894108c6095fc9fd61ee4c42ed7c2dffe63851950f1c51f3a9c40e","merkleRootHash":"0x1a10ce965f9b4b04ed5f11462c8ca4ce0fccabbdc9423b13fdab3e0dab1aaea9"},{"version":"0x00000020","timestamp":"0x56f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x883cf51e5d499a2dbe209d7393bf5bc7ed2fb7cc8ca5e1b90e3ac1e0696e5e1d","merkleRootHash":"0x16b92d4a90cb7e78379a8b4e10ce349e9ca19f5e8027f31204e92bfd7711b999"},{"version":"0x00000020","timestamp":"0x56f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x7830548cfc2620c84133e0ac5010db03542e0e8d7302f0e74826c0f4d386e76c","merkleRootHash":"0x3964604e456b0336d9a05c1a3e28e598757f80443af193e7022262a7ce9c59c6"},{"version":"0x00000020","timestamp":"0x56f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7f1fd144e2582dbe5495e4839ebcc2b9cf70ac7546a0ba3b5442a20c8994285d","merkleRootHash":"0x13bcc5f7ec8e51425f5c659ffca71e232198976f3e35778ee7684a68a3baab0c"},{"version":"0x00000020","timestamp":"0x56f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf8e8a6e3fbbd4a029bd2f04c33429b1fc94c2699a1e58aaeacda229f4159ff5b","merkleRootHash":"0xa7adf12b898b2a9706ac2010691e40fde617b8a8fe9146fe18855ea86bfb48e6"},{"version":"0x00000020","timestamp":"0x56f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa6d00fb6fd0fe9914de6c0445e1d4ed2d2286b38749e8df58d35a8fbb254984d","merkleRootHash":"0xdfc8cadabc66e455d24a3824a9918b8ee2f46d1e9a443413bce19046ac5e5020"},{"version":"0x00000020","timestamp":"0x56f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x5102ac77b2111859a42b3ec0f12e77be856e69afc0dfa5b5fd8199842e328140","merkleRootHash":"0x9b230f2e28dc0d42dab67ed16001ace0648e4b6f0a4c4baee08d3f2249933882"},{"version":"0x00000020","timestamp":"0x57f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xcead0b247ca4ff373b0a1c998f2f4571f1242951a7c6543cecc131695d81d81d","merkleRootHash":"0xd32660feb8b3670c74f2f89583658f235b137cad998113ae30fba98702f2da8f"},{"version":"0x00000020","timestamp":"0x57f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x24bfff6ef40254d85f3d3f2bfe5357d699433e7ba24081ac90180470fc5a5757","merkleRootHash":"0xc164d09a82b64d42119245ab61b5038019005fb2375dec02f381f470d91245a5"},{"version":"0x00000020","timestamp":"0x57f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x21e78c73cc327ab8c70ba11a5fbce7c6e28d98f0df2cab244da38c5152a13a5d","merkleRootHash":"0x1a2bcbca219661da7503bac00ccd5810de92fe2a06c2bee0c8306291ca49e16c"},{"version":"0x00000020","timestamp":"0x57f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xd0a9a562ad2eb5a90218e978a0ceee2d38f9b9a4e4cc49f4a89b0eca6f34172b","merkleRootHash":"0x9eb1c25a9a84d4b08e6cacec33f24382013f8e12e13f827e4259a00758def53b"},{"version":"0x00000020","timestamp":"0x57f3ba66","nBits":"0xffff7f20","nonce":"0x06000000","previousBlockHash":"0xdefeaf5142563d9d176003a3f0809fe2a1f45d4a64d55777881811540fb13b71","merkleRootHash":"0xb8a89a4fd6a6ecdae0003eb4a207cb7b21b9a93b4861e3f5db3fe07bbdf0fb40"},{"version":"0x00000020","timestamp":"0x57f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x5188540a0dcb4a14fe15b6d744817f16fd1457cb9d74e0fdf120c8f750cde70c","merkleRootHash":"0x28e79af1a140cc5da21d5a50366d825bbc3ea9b3c34699a48d34e542fe76bff6"},{"version":"0x00000020","timestamp":"0x58f3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x5143b67ed4a72c38aef102403e207e3ef8ba74b2ce6612500ca3bfbe0185d82b","merkleRootHash":"0x6e5e38029a8fe36807497eca43d3933f5a914b1d027e6817b6d53e0ce643098a"},{"version":"0x00000020","timestamp":"0x58f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb4fbd6311512e25f81c85733b4f4e1a06a777ce36c46bf6c55289463da5ea666","merkleRootHash":"0x2ec007c42c5688fbcb9936edcc4b5964fe8e3438c6a0ae3fba9df1521073ab72"},{"version":"0x00000020","timestamp":"0x58f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x68cd5be2a372924b2db1d671854ec247e8f171e5784dc8d8994eaa2a1a3cf32b","merkleRootHash":"0x1c9dfbe2727a3a3d2bb3075d9a51c56fdad835e2421cab8e9b07d6dac54fa715"},{"version":"0x00000020","timestamp":"0x58f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xeda51d690441c4aca8ee40d90c867cbd5097fcae8d048a6bc24e2a87ccfc7470","merkleRootHash":"0xf2c619c4da1c245fa898bf987bce882d1a6872c74caebf87b9f827206c37e12f"},{"version":"0x00000020","timestamp":"0x58f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0f16e8613a72e9ad669b4915600614a2b7c1cac46bfcc29ae92d349b9fd76d5e","merkleRootHash":"0x69150b12b06035b8d44227a8b037e7f8ab381d7fe297cd8b98ef27e883a76d75"},{"version":"0x00000020","timestamp":"0x58f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x01e4bcabd5fcc705874418f68dd269f74e6090b3f39f0bb15eba73dcd94f2e7c","merkleRootHash":"0x29eaa94c490a18ac9cb3e4046c49217f19f1beef0093bb7de6ce0488b7e757da"},{"version":"0x00000020","timestamp":"0x59f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xb865976408d2bb171ab00e59272d0a9f536183ad35ca442dc43fc64e38260527","merkleRootHash":"0xfdcd4e41fbddb600b02240fc6ac6744048243c0b7eeeb43f18c67a67a90b1323"},{"version":"0x00000020","timestamp":"0x59f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0de72c7a02c2fcdbac94fd7de29c7855fd357818d721a15c04fcb6a840b33d0f","merkleRootHash":"0xb083c7fe5fe64822e9b3e2f6a1dd627f802d4719250f308bb21151a02beab8ae"},{"version":"0x00000020","timestamp":"0x59f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x58c069e3ff151cf05d0a472c6b01635bd9c01883d5f6a912f0ce195a82af664b","merkleRootHash":"0x9bc91868ec9efd6a61668de54458dd31e583ad137bb1e2c11923a7c52abd2dd5"},{"version":"0x00000020","timestamp":"0x59f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb7734a0e13bdfb5f322888534fa68e97ea7110517a8f2747a8a21ee81f676c41","merkleRootHash":"0xa37766830740c0d94073b330211561346c24cfbc5134e6d6b5f6d5b6fc6b8c23"},{"version":"0x00000020","timestamp":"0x59f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5617bc851831871b57429583144749c58b9aedf277caa00999187478c31dd829","merkleRootHash":"0x7e6a03904ce9f2ad59b85c5abdf0351cdcf714c94d2fa5579f3dc746664ce6e5"},{"version":"0x00000020","timestamp":"0x59f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x5af83932b2da731d5c82d4eb13e892ca779eb8c6240ff1a525b9bb3f0b3c2c0c","merkleRootHash":"0xe3fc94f324c095cb2a876bc84255dd1cc72f99cee809a4eb2deac0527d515122"},{"version":"0x00000020","timestamp":"0x5af3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x9ab79db6b3fd68889ccd63fd06fe55cef8ae34d45abf7c8877d52cfcd4ffaa4f","merkleRootHash":"0x5b7e77a2d4c829875e68fdd4ce6c91da720339514dae1618cdc61bb6ccd5c7b4"},{"version":"0x00000020","timestamp":"0x5af3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x63d65888a6ecd09a412bfb6bc1a772c222524513b8f34c1781698d80f78a5547","merkleRootHash":"0xedc690d1e3ee115340985dc1b4924020724a29f97a971cf8cae050c92a76e5a7"},{"version":"0x00000020","timestamp":"0x5af3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xd17b4f49a68e0a64e0709da0ef7370e98582753323f2a2692a2d12e53bcb5d14","merkleRootHash":"0x3ddbb00aa62461823a2d286eabb7de18879ef19e6b2b17dd30497ef88a819539"},{"version":"0x00000020","timestamp":"0x5af3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x7c26c0281c9c5fc4b6fd0efd2f49d019a664d8fe3407669726ed4fec4c72bd32","merkleRootHash":"0x1c5573e8846ed3a2772d7979f6af55f4f67c4acfd7b2ff00fe751b735e947f9c"},{"version":"0x00000020","timestamp":"0x5af3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xdecf1072c78af6fa8531d50233d5e4767e3dce56b0d2a71904793810ae71c256","merkleRootHash":"0xc0b356e0e8086374e2603ff918915b37486eb3f0941a8ef0166b2e5b858892ec"},{"version":"0x00000020","timestamp":"0x5af3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xaccd9609d8425e46e281bd6745b9a4fcffcf2ce2c295554d70184f4ce6fde00f","merkleRootHash":"0x41514e7fc496246cccc4bfe4aaac6fbe6dfb99034faa3f7b0ff09c96bcab797e"},{"version":"0x00000020","timestamp":"0x5bf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf954a49a024fbafa6f26ef0c1e7ac8db1d9f6349248d80586c8cf805c2012253","merkleRootHash":"0xa81b5e4470c3554d3ab942b5b200bee8bdf7bd3e3c3e05df29230a692991f2f3"},{"version":"0x00000020","timestamp":"0x5bf3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x5ae7ec94ff96b2d1d052506b9ba89e965791b029f7eb582b23a632a294c2f631","merkleRootHash":"0xa8b0eb536d745d4ce31f67cbfb289cd2774285fd2938e7359ec3f39b4d56bb03"},{"version":"0x00000020","timestamp":"0x5bf3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x66c9eab28b06d51d027eee8ab50d32283f04f8a071c06819c2470bffeecc7f3b","merkleRootHash":"0x9875cda9a5a17470e928770b445528260c6d8b254f19c29e4c824715b19526f6"},{"version":"0x00000020","timestamp":"0x5bf3ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xa97fe39d893800a715dc448c870e5617e03575b3d13af60f730f67c80d46ff7d","merkleRootHash":"0x6c004d186484152003b4d62c9197172e5e1f4c04886a5398c1721453ec0808a2"},{"version":"0x00000020","timestamp":"0x5bf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x18619d946c8edacf88b7fee296f5ebfffb1d2fdd6f0fbc718726b85d67f7184e","merkleRootHash":"0xc0051a7b954be31a804935f137d3cdf50b7ec5df02a0f559551dc67505cdf66d"},{"version":"0x00000020","timestamp":"0x5bf3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa444d848af3d39e211403708e55502e517388929c791b362685e2d66e4d00371","merkleRootHash":"0x0e6ef36c85cc4d0982cea6cf7033a48b2dc42196bb7d0ed173246d426c7d7d3e"},{"version":"0x00000020","timestamp":"0x5cf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x18c96704c4f326accbc4d32a4d9743dabb5ecd2b9e30eb383ca733eaff1ce65b","merkleRootHash":"0x0ea10465877331195ad90742301068d1c1c0378901e5c990c44a9a01b18bf983"},{"version":"0x00000020","timestamp":"0x5cf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4d68f112721a4db779c24af2e6095594681b0d816ec0cd4a1a27dadd79520a51","merkleRootHash":"0xb8d48e97a24e074d01e5565efb38846dfa28e5f7a0c1b921680d03d095e6fdbb"},{"version":"0x00000020","timestamp":"0x5cf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdde5918e2bc2abc886375d0069cd65ed8f18894c1a76ea061cb935ae348b7e19","merkleRootHash":"0x4ba48db2ad5da954d4131821f9dfe4698cc3630e6388a6e951f641acd18462d5"},{"version":"0x00000020","timestamp":"0x5cf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbd8548e210678419499fb130f45f538c313fb10ada84651a4da8bfc1d7c32a1c","merkleRootHash":"0x43119136221a00dbfeee9cb6c391830813322f520d3ebedd181d7bfcb7b40537"},{"version":"0x00000020","timestamp":"0x5cf3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x24986de0f35b2352d5849534df019e21a77a8192501b211877837dcafddc1900","merkleRootHash":"0xae50b295d5eef4433fca01c8287d36ac503c8b01ec39f4ec22fd435641eaf441"},{"version":"0x00000020","timestamp":"0x5cf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x289dff1d69f72e218727c6d431d202dc61d90aab27e12fce8b19ad6d79b3c50a","merkleRootHash":"0x34ee600d7896650c3ef58c77f49d5d1d7290ee586b1c717bd66df2c348c66b84"},{"version":"0x00000020","timestamp":"0x5df3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x883583450825ae15544f470639f8c542936569ce7039dc873f1f884d9fa09012","merkleRootHash":"0x052a4ac8b3b3fad4330729abe51ddfe7e9152d9e9f47bde49c65cfd37c616317"},{"version":"0x00000020","timestamp":"0x5df3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe3492ce0ce3eff4a66f4575dca5de192d87f14c8a6447aadbd7e7e8d5fb0dd4b","merkleRootHash":"0xfca500890d2c92e3958ea98813b661bc17e05b0c17e318507ec49f91d412af32"},{"version":"0x00000020","timestamp":"0x5df3ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x111c69df8cecac1c70dad650fca14c2d4996d1c5bbd63adcde5a4b33c0a29202","merkleRootHash":"0xc7eba27991750189e71b75894f1c825ca583477f19d1620a9652bc749f23c9b3"},{"version":"0x00000020","timestamp":"0x5df3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xbe58c1383923b888dd5a4e43fde4f5ccf51dc42374e9f03d2a5b77bba2b12b6e","merkleRootHash":"0xc13a3c7a5faa96624fc93bc453f572934f4a9eafdd95a8967a83d17e2daaae12"},{"version":"0x00000020","timestamp":"0x5df3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x555eaa349bc3648af8292f5354adbcc323210f05ccbb3ed44127411cefb2275f","merkleRootHash":"0x5d8c183fd5b25edff340cac362ffc2a3ef17a911e5742b67c3e2b0648511b7d3"},{"version":"0x00000020","timestamp":"0x5df3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x6b302fe77a1c24061e93ee0e1e87c47fa586abed61725603dc70326e0e53107c","merkleRootHash":"0x12f708d5dc85f4507fe11794661d19686a5a83ee02170ca48f36b91047a55038"},{"version":"0x00000020","timestamp":"0x5ef3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x49acd5c3bda468a216a81d4dc527c9589ea05aac7684a9249c818112300fbe34","merkleRootHash":"0xb6ce707322135fa4d1f55560b7dfb59f5f6dd6bc8d6e5d18f4c9ef7138b65c95"},{"version":"0x00000020","timestamp":"0x5ef3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x2b2f37f8cf363dc6f106b39f2cc1460f652df74d7e53f7efbe0bd8067e21cd64","merkleRootHash":"0x92ace694c2cdf6d76594a40597660a5b14095e527d216a7eaff3da85702656c8"},{"version":"0x00000020","timestamp":"0x92f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x72e4af57883f089dc0dcd301c97be4a84996a96f6f5563481cf1e9099a48bf3e","merkleRootHash":"0x0cca1b0b939577350f1129d84169f291e0296dab54420eb2dd03a29495ee2952"},{"version":"0x00000020","timestamp":"0x92f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6d5c27d50ce841b42dfd647060682672d64d804fd34fbaabdb9e588a657bec77","merkleRootHash":"0xe3b21d8ee1168cedb698b801d6d792fe11d467ec00b5c98fa2ed22890fecbe0d"},{"version":"0x00000020","timestamp":"0x92f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1756a635563350beb32a976a6ec1c07fefd572762e327b605a8e6a25e30d276d","merkleRootHash":"0xc8d21f4b44f7df861a15a78c4e216ad6e5bbdffe9d133d0bcb6ba3f981f53282"},{"version":"0x00000020","timestamp":"0x92f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8a45e37efcd3c97174e56f389a4d36b95bdc6ec95073a267076bf5370e1d0a16","merkleRootHash":"0x7e1daf9d561dd0a539f45d698fca31250f87d1e480a2386d0a88d9c0f240878c"},{"version":"0x00000020","timestamp":"0x92f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6997282dfddf3dd02628309160de3676a83f1b964bbeebfc6fadc115a0e91500","merkleRootHash":"0xed437e83a89d7b748a4a598b12ab42e4d8ddd0ea9131826f5ed256c1090e9064"},{"version":"0x00000020","timestamp":"0x92f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x30a5f8ce273800545408c33a66139d3c0c0ea5ab54a04322b37889dccc2b2f28","merkleRootHash":"0x0d07c58b944f900e4118e8e3681cc2102211617f2240142eeb45fc45dc3cce53"},{"version":"0x00000020","timestamp":"0x93f3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x82a9d5fa37fc940ca8a35fdcc884e602c9966faf0f93b2731b88888a9fa7ac11","merkleRootHash":"0xdea63257a60e514037d9f060a0f65040ffb6d59ba2ef10c2ed40dfe133a8d629"},{"version":"0x00000020","timestamp":"0x93f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x991a1afee4e62349069f15ebeb5192ed8a777bdb68ee952a0c6fc4af81738474","merkleRootHash":"0xaa2e49a55cb8baddb070dc6ff9f7fab84e1cd4ea545f483ae898fdb0b219cb92"},{"version":"0x00000020","timestamp":"0x93f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf958a4b3dbc64debc3178f069cbfbb1b872208a5f3fd178abe6d39a00f680448","merkleRootHash":"0x62273f3ac21cb82482fe315762b551d49c601572aaff3aa2fb70ce80d99bd66f"},{"version":"0x00000020","timestamp":"0x93f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf5526a1bc875f28cd3fad2ab79bde43e217692a2a9b20045bbd4c8cf209f512e","merkleRootHash":"0x7c15f0768b768054b2426a7592f861086ecc55ebbefbf3257ac23c96c681774f"},{"version":"0x00000020","timestamp":"0x93f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x628ecdeb224c65f464b43c0a9bb0a67951f143396a450301247ec02e6fd78e58","merkleRootHash":"0x0321a49a94d0385380f6e86ea92a2fb5ee6ca17df4e5895f947cb8249ceb1954"},{"version":"0x00000020","timestamp":"0x93f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x399be0bff410b68f62276e22beceb44ab724e2ec1cea79c56c2d1e59de82e474","merkleRootHash":"0xbf9d3589d56c3097d6302f03673c68f9e4bff912f1e54915cba52766005a9e18"},{"version":"0x00000020","timestamp":"0x94f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9b1d941a0451891ac0e326d1e31aff2444f3bb0deadd2849fd679239e8fac52a","merkleRootHash":"0x893c5620948d0fb733de18c86aae43c4b02140e855289e30e5682afa9f156171"},{"version":"0x00000020","timestamp":"0x94f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x64b761d942636c77a0181825eda671b4e791895bea41b4292b774afd81c4467a","merkleRootHash":"0xecb2455cee7b9e433a3ff50ff4b9942583e27c755a8609a9d0c771d5b9c21679"},{"version":"0x00000020","timestamp":"0x94f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf81a2ff18948e22c7637e54d441ed460f7eca622d3b016d2ed44e2e8265f536c","merkleRootHash":"0x015b46fbc19ff7d1c3bb44f53ab8f3dcaa2c0094561b14b7f5dde68893ee9124"},{"version":"0x00000020","timestamp":"0x94f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x16cbd56b3193ae771c2694c92b325a204bb82766073faedbca2b1a23bb3b975e","merkleRootHash":"0xcd5da1aba041401dced23253f87858464390e01a7facdab4e96d64a4f2c9deca"},{"version":"0x00000020","timestamp":"0x94f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0bdec5d769f8b1724503690415d887d2402d0c8dc34ba080ef28032ca868d36c","merkleRootHash":"0x16efb108e3c9e2a349350a81b162ae40168fb000b943500cf7fda476e3ca8e12"},{"version":"0x00000020","timestamp":"0x94f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5b30b86fef74946ae4876b65bd1fd8277607c2db47f668c07e2c07828704d501","merkleRootHash":"0xdebdbd5f14bef43982586b269b231c96b319c41a13bc2b316b471bc0d539d183"},{"version":"0x00000020","timestamp":"0x95f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x4f6a63ede49d2d0ae868b6a48d652f75518349db4a09605cdf2b9a2b2d28e77d","merkleRootHash":"0x0dc42f29ef1a917c0e1cf1db80f8bf4dc31ec57d7008ae7900892ff883ba1b6c"},{"version":"0x00000020","timestamp":"0x95f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3bb6d93bc857dfd7e0a324e9d000dfec9b433b1828b12cf4f8d1041f508e026f","merkleRootHash":"0x57150d78d5a72e4a1faf764c8b0167ce47c39756a019654b4e26dc1418cd6726"},{"version":"0x00000020","timestamp":"0x95f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe0f6f39aea6b780eb2efff0d5b567c9cc3622a132ca1bac2c210884b3a6eb736","merkleRootHash":"0x42385c886dd792cd90153d9f07ad7cb7bd3b056a3a304b077d76a54791f4e684"},{"version":"0x00000020","timestamp":"0x95f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x4af5e16c164bf3dfaae3eb619791194f6a34f0663af97452d246705d16cc4148","merkleRootHash":"0x1e6d8fd3956d694bc1d1e4cc0e65e2e9935f5f3c51dd9019b1d664a4a25157c8"},{"version":"0x00000020","timestamp":"0x95f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf7f25329d78e832de53879c49cc827097fee3c804ad1e3de02b420e501d1e313","merkleRootHash":"0x3b52d420d23c10832e47164113e519014a57dc5fd0ce66237adc5eb40b8800d3"},{"version":"0x00000020","timestamp":"0x95f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbd81afbac2803800a99be3acefa97cd841763b5b845ad0b8fe55c324b27ba92c","merkleRootHash":"0xb0a3955c4c744fcc23baccf86da0bcea568d9d1df616f2f6269bb810fe7f24e9"},{"version":"0x00000020","timestamp":"0x96f3ba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x90d9f4a5313453ceedb6dcdeaee0d8afefb053fd5f8bb7679154dc16c49dcc59","merkleRootHash":"0xc6733d3afe46118b9ae8a5544e55ad48593f87180733410552ec288daefe3228"},{"version":"0x00000020","timestamp":"0x96f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xee73433c2d96741f589dda559db912bcc9e06d4f7f8c58fd7ab2c18296f12555","merkleRootHash":"0xf47214d86b95aa3db8aadc53466627e9594ad2916f0d9fc2cba1d55b748d0892"},{"version":"0x00000020","timestamp":"0x96f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x310adc0545ffbfc07987f3404f7a973a30a06be5417d5f82792242f46a067530","merkleRootHash":"0x20fef1c2e223f35490b373b6e5c2aac803d486f56aea1564fcf7768c76d9b460"},{"version":"0x00000020","timestamp":"0x96f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x9fda738528169d770a0a6be2bcd858500143241e84a80d9a2aa5b86f8e0eff15","merkleRootHash":"0x6701938a80a447a19e32a235a81fdb2e76fa5206c61bcc7b966c394ee4b53eae"},{"version":"0x00000020","timestamp":"0x96f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xefd3d25dfda02320316b524bf83aa2c033b1e7b17d2a67c462a3f4e91b26b507","merkleRootHash":"0xa2b65a9374224d136e014a209a90eb8acf37e25919169e1620f6d70b4f594385"},{"version":"0x00000020","timestamp":"0x96f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x24b3186c1f41610d4f41a0e6a4d9f805e3b3bf48700a612383d8a8a5c042c019","merkleRootHash":"0xf5a745815af99e1da59ff8c83a3dc75edfc5f7b45cb9bba0d1bf21acaed12684"},{"version":"0x00000020","timestamp":"0x97f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf55ef218b05dac9ac79a974dabfe8cae78a09ad136603cc8d6aa241925e80c5c","merkleRootHash":"0xa370294b8dfe46b074d8785a1f5c9c71593b365da86b99b6aab87af5b3c41317"},{"version":"0x00000020","timestamp":"0x97f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5ca1656962b6d524089ac0ca9cba741caf119eefaaf5bad3d5251851caa04412","merkleRootHash":"0x9c0872b43ed0efd13e93b5ec6008c1eb00cc104a61a921fdb34bc3fbddb3c303"},{"version":"0x00000020","timestamp":"0x97f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x467d3fdf8b32e1bae10467c5a82f79bfe78d778051919fdf4c9ad9fd8d3fcd27","merkleRootHash":"0x52299eccb7266799fa33655a502af84a07d64f2c090f68fc8db4973b1788b848"},{"version":"0x00000020","timestamp":"0x97f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xda3494d7e39771270044dd23efbf67d1cf687bb540f2dc3f273a70a710d84631","merkleRootHash":"0x92844b0aa9800983e1fa906ccb93ef9680db919a0ab551be79a0a35752f04a48"},{"version":"0x00000020","timestamp":"0x97f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x121728e7cd4a54cf9df147c62a31e4eaed760c584cc8bba81d35f9cd33c1e244","merkleRootHash":"0x0db7d3131f988aafefdbe65040ec0d111f202c3960cd3322628d906ebd4f514d"},{"version":"0x00000020","timestamp":"0x97f3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x5e43e5ba0340285dd30e66f9162296c415bfdd59fdd90bbb55b19e082c672165","merkleRootHash":"0x5d014c2507f5680249ffd44d9598cd9e45267764f2466b4016cc99f7cc4ca490"},{"version":"0x00000020","timestamp":"0x98f3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xbc59489420878997382e9a9da089450c590d03e78e305e98d8845074270b7152","merkleRootHash":"0xa5baa50d42242f93546674ff6ebc53c863f3eaf98304090144c47037801bb1e5"},{"version":"0x00000020","timestamp":"0x98f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9c69cdca6fa7850cc3f65345bbb3ed4af0555d488f934d09b13c4e3dcaa33e28","merkleRootHash":"0xb1abd5869a828ef1b2b64cabbd4a48aae7ffb7d494319bc0f8a76c2db8affaed"},{"version":"0x00000020","timestamp":"0x98f3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xbf803cb8c0fc639e8b9e15401334f10f08d77f7b924ea000e0a8c761bf18a541","merkleRootHash":"0x912b2081d9911e2894e06d8e2c47faebb1ae1e5e1fce209583d97b453ca857b7"},{"version":"0x00000020","timestamp":"0x98f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x435dbb1d07ee3b8ab7f489ed5c235253583101d0cf4ea4c564698d1f54d9d44c","merkleRootHash":"0xd8f09d4402049858141e9e60f8de3ef23cbb48343f41f9794376041a54807672"},{"version":"0x00000020","timestamp":"0x98f3ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x74bb5554419a9f5e6852960b64aa54f2ce0d961ace91fcb07661f3cde407d31d","merkleRootHash":"0x6a1fb9522fbd129f8f0d1c39bc20eb8cc598456ff29721eb9309a525c7898146"},{"version":"0x00000020","timestamp":"0x98f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x023f866b4a6bcf9179f074c6ce86c7883dd97c316ed381ff3ab4889fcb8b3377","merkleRootHash":"0xf8f211476e99cddefe79311ef661274ba39af40e74e8fe72205e7fc2a8d36e3c"},{"version":"0x00000020","timestamp":"0x99f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe3806bb4220adca1e0855dd7dd63468b332a60e98a7eba2ab8c17b4193f48230","merkleRootHash":"0x21f8124b787d06c48eac73c8e52459076a2104675d9fa0ed8dac41d79f0a4f73"},{"version":"0x00000020","timestamp":"0x99f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x034c8060e24241a2bedb7f6a7e0290a014d1efb41d0828d2ca6925f372c14174","merkleRootHash":"0x3c259bf21d71163d08ecd61ae73741fdf984f45d784f566d8025ebc04f4f7b78"},{"version":"0x00000020","timestamp":"0x99f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb5272d24da9b09a3a61462317d3bf6612cce15bb52c540e266470c5f84ec522e","merkleRootHash":"0x493364287077288f635bf66ed6f92d885f679b084b838db711ab5d3f8ea9d5ca"},{"version":"0x00000020","timestamp":"0x99f3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xb7088cdfedb0306c0d28ce603ab5ae3991b01a73d300746108f182b3293b4035","merkleRootHash":"0x78dcb68315f2e22dc1a786ff31633f23159497ad86b467a4a2741237ff4aa31e"},{"version":"0x00000020","timestamp":"0x99f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3ab5a6e15f141026af4388e0e5ec7ae291a487972fc2a97ac1be0b3a8856451c","merkleRootHash":"0xfdb4d1366d4236c16800c779a1649be05dfeea40a92b07ec14b9c3419f4435b6"},{"version":"0x00000020","timestamp":"0x99f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x42f5b7ef82f8082e331b5d93c307843fa74c782c3b174da7e39ddb145b4d7b0f","merkleRootHash":"0xf598a1028d6855265e13eae17ed5fec24929a2026271fac66e3326eb394d106f"},{"version":"0x00000020","timestamp":"0x9af3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xcd763cf0190b00e0d06751a930e83b900ce5da16bcaff454f5a182003cc22e13","merkleRootHash":"0x5d145ea3db576901bbc7c4da2f40ca0f9468b184d85e8d4b32022274d31938ee"},{"version":"0x00000020","timestamp":"0x9af3ba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0xacca938edf3067845f03116fce83c203e41fe746f972a5ec00e4f4036c4a823b","merkleRootHash":"0x7b223a23d78cb94fd55ca19d3bc7063ddbaee7295edb386c570c56dca06bc563"},{"version":"0x00000020","timestamp":"0x9af3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xddb86bbe5acb50994d5aae1f90d35c6b70a174349f99a35fa385e2b9c859ba71","merkleRootHash":"0x0e673a4053001575fe7c06fcc8b507a15cdff8106b6ddb104a46303534e7a710"},{"version":"0x00000020","timestamp":"0x9af3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf72f9a72d165a3d6fe1973922b5f9a4ac17c0a577c4477fcb2f6bdf49f099c45","merkleRootHash":"0x889e560ca319ffb6ae2431edc933a73c9fd409dff2c714435bf1e22573654788"},{"version":"0x00000020","timestamp":"0x9af3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1a8a2535550dd965d65a12a30d9df0995a8b35566399cbb0a936add85a25be20","merkleRootHash":"0x1d644dcce746aef43f6835b58726badc33e61b3572cbfd069e2a4664862a5210"},{"version":"0x00000020","timestamp":"0x9af3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf0504e23204411d93204986c9ed1b9ef12b56dfd6b416b1d97b941a632c97667","merkleRootHash":"0xc5fdf2aebd1b1b8e8a2ccfea865945ee77af927d39eee6acfc05eb2ff345edfb"},{"version":"0x00000020","timestamp":"0x9bf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3599e658dd7f491edb72f063f8efc621e9ef70a13760697885b27f08648bb273","merkleRootHash":"0xc2f2ca11f55e00cdf5b745eeea3f60768ec9674ef0dfc13ed3ecfee04dc49122"},{"version":"0x00000020","timestamp":"0x9bf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc74adc91c5a47f02ac7325e160db63df051b9f951841f574a631222655a2793d","merkleRootHash":"0x8f478fb9f6b2964ef05acd0123c2dafa7179b64e1e43481f93f852edfc1b9dac"},{"version":"0x00000020","timestamp":"0x9bf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfc719fde72b97130baf6224f843ff1bd38f3342def89cf6b871fa2633b51937f","merkleRootHash":"0x9c410b3325fca1fdf107a8e717d589bebd0870aab77a27223e725162047dc260"},{"version":"0x00000020","timestamp":"0x9bf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x207495d290bf541aa935e02fdb33d48b11d8313757a61ef3a4cdbbca8557af4c","merkleRootHash":"0xba52a8f3b8b9b9f55f7c3ebd7a762c83384d17d0e7d8fee2ccbc5aac1385c80a"},{"version":"0x00000020","timestamp":"0x9bf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4e81df4974b39ffb6a2eb5b1109e03bd32184087b0c181309ed0d8a282b5bc01","merkleRootHash":"0x0d31a509ae7f1ce24dad08490e4d918ff561023acca8c69d3eee86d11177f0c4"},{"version":"0x00000020","timestamp":"0x9bf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x59e47b741daf90076e5e580a81535261aee093f2eb4935fbd33af807af0e3963","merkleRootHash":"0x44b71f97257b860bf7228c766aaf0073b6665f7786c1531431a2c16b641a688e"},{"version":"0x00000020","timestamp":"0x9cf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2770d58480d084415c0fa9923de0621d2b6cca6a73ab429366b2ba2981440805","merkleRootHash":"0x1279bb465c21498afeb40aa2338cf8f509cac66079c00d56618b09e1aadd2d09"},{"version":"0x00000020","timestamp":"0x9cf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x453d366eae55dfe9ebb48c21aa9ed933a75b41bc94b2b41726bd984bb50cf501","merkleRootHash":"0x90dff143485d3b3bc3e0b90dcfcbfbba14bb386d801645b3f8ca5d32948f73ad"},{"version":"0x00000020","timestamp":"0x9cf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x70f190f912d601a0d0be173682c4f9c6b07d16b919283c7a518bbba171672227","merkleRootHash":"0x62f7e6d90826d388f36c13a5e5f5ab2516994778d3fdf7741f7e5a3d7efa7207"},{"version":"0x00000020","timestamp":"0x9cf3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x45cc537bfde3aacc8a85fa28464b66394dbbbf31d7144cb478cab88484ed807e","merkleRootHash":"0xc0399e90fdbbb97f429715cd8035909a8db9b74fc029ae81bd41fdae6ea46ef1"},{"version":"0x00000020","timestamp":"0x9cf3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x39d6dab7cd95011743692356023e6f8cd24507f4a95601919e68ef9822bb6a61","merkleRootHash":"0x0f12a8323cf1c5a1c0f07f264430e80307cf671b2708d84728b7c518914e135e"},{"version":"0x00000020","timestamp":"0x9cf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xded80569826a85f65734111b71bc433c22c611291daa1643dbbab827a36b276c","merkleRootHash":"0x671e52f550abb38a898f921df4dd4207f9c98793cb6b5ce7b66ef35394cb7c53"},{"version":"0x00000020","timestamp":"0x9df3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xacedaf5a20ec6dd33520e66a7c276e2fa164ce259429e762507ca01bc2536143","merkleRootHash":"0xad9d05f9ccf924d39e22f87a96f9aaec38e211b73345758fc491e26bfa4573f1"},{"version":"0x00000020","timestamp":"0x9df3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xacdd8fda866e54c38e95385be094b38422536d8214ae9294b687b301e374cf6d","merkleRootHash":"0x2b40b2c2faa90c540cb146424a5a7aff02da13a2f8879c170c025a9194cd98bd"},{"version":"0x00000020","timestamp":"0x9df3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x2871ad8f5369be0522697353994c092b014d85bb2381871a666583c819661607","merkleRootHash":"0x9b5a9b9f9eb1bb91f36cc9e71d74a3f4d439bbcf20efaa8de4ecb413980b0d42"},{"version":"0x00000020","timestamp":"0x9df3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa2d1e6e08ec62c8735df1c87d620394bdf3aebae1eb84212360449f32d53b108","merkleRootHash":"0x0f3d1c036ded7026f838d283c140af33812516ac7698b0c2151878697a9f27af"},{"version":"0x00000020","timestamp":"0x9df3ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xe035f4a31c8db9c1d8c64e3349a14789fd5a715601c0cb7ada437ebc8b871966","merkleRootHash":"0xa00b974a8e902ea7a74365c73d451240ea3263a2c39a12e20e27c37f6e5ebab9"},{"version":"0x00000020","timestamp":"0x9df3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8e21b1c1a22630363c46ecce1037e9f27e43476ee30288897f69b6377d82b472","merkleRootHash":"0xca0be3095dcf5b3349714c744f821d84ee3067948a76d7546b6db1ad0566f145"},{"version":"0x00000020","timestamp":"0x9ef3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x5d644f96a49fd424378ace6ed8fe4557b92dd92b181604c0c8cfde9608ec211d","merkleRootHash":"0x94267aa985c2a512b484232bc95a5f4aa1447884fb2719c3f7c8abf85ff93abb"},{"version":"0x00000020","timestamp":"0x9ef3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x473f148ce8a9d3b2ecad12f10ce09ef0fb10fc45db9f4d4339d24c2c825d0172","merkleRootHash":"0x042454ba587ec1aadcf577a5b43cd063b6aac98968e516744869b12e06ed6680"},{"version":"0x00000020","timestamp":"0x9ef3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf16022582e271c95ac23129746c4047cfa37591fab1d842259c16d3ec653fb2b","merkleRootHash":"0x26d791b6323d3c7cc32d9c5194ce351ae30a220b4664ee5d0ebdbd2b1ef37c5a"},{"version":"0x00000020","timestamp":"0x9ef3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x1330e9826abcc581290e6155405d1881b5a1d27a0ef94010bdc765c530cb691c","merkleRootHash":"0x4ab54b4cef4836b68a2a8d5eb3cd9e19a760c87cb8c649e10b1ff16686633e17"},{"version":"0x00000020","timestamp":"0x9ef3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe1a64bafccba26acc6a8822205ac062c4707262dee63840eb1eb7d3eb1ea456b","merkleRootHash":"0x203ac2850df53f5cdf01ebcb950febe900cb9cbe954ed25e93c3a4ef5c0e33f2"},{"version":"0x00000020","timestamp":"0x9ef3ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xe97bdc32aeb9620284972633c2186281dce911c06d28d90164792e2177a55b70","merkleRootHash":"0x185ed75304fbbe614c8492655df558dc027e653701873d401113db6a634f9fa4"},{"version":"0x00000020","timestamp":"0x9ff3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9fba414d675e766d4a90b33f575bf063c07ce0ca87bf5a4b2f603f1a21ac4725","merkleRootHash":"0xc28f9801aad9138dbd4b04b3a87e1975445dfc5b19e7fc76d9107966e21ee4bb"},{"version":"0x00000020","timestamp":"0xd5f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x55990437f5085c5476ba0059ef9140ad3ea6cfd1fe3185cad0d658e5103e6575","merkleRootHash":"0x45bb866561fb3d21478c697d3650e0e2d64717cce7542581653357aa29b953f8"},{"version":"0x00000020","timestamp":"0xd6f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x15ef331d45a0201e3815ecc534260b84cef729ab9537f3a78743b3346c4f7926","merkleRootHash":"0xc5b0e5bfa2ee231d38ec39d39adf1ec407647b73d081df79f51760b85b89bb78"},{"version":"0x00000020","timestamp":"0xd6f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2890cb4db932ff98dad18b0c02b7b5e7d7afbf29262f9567fb7e92b153c20631","merkleRootHash":"0x1fd50735bd3cdaf299619f6765c6013fb7488e97d494e80ab2704da86d2a1ad8"},{"version":"0x00000020","timestamp":"0xd6f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x19f88e9debc6db1f409c9a12ec6934a5e096eafede74cdc4dce1f38482198f49","merkleRootHash":"0x6453d5b51fe22a2a0bac01686b80c4f862ba72756b69f7a7f89bc3d362344a0c"},{"version":"0x00000020","timestamp":"0xd6f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4d1577ea36f3e07cb2ab56904020bc0e477d6d972f247a72fbe0190ffb582a72","merkleRootHash":"0x4379b9aaacff1315106dad5b8103f46779eba434f3966ee0748c300a09a39a06"},{"version":"0x00000020","timestamp":"0xd6f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe13e69acbef2a8dd5e598d09d269442da19e5c6ec184ba31f974c76498e2fd73","merkleRootHash":"0x747d57bd2be663935a73c37f32165ab1dedfd20a0a9cd78e1d553d8e66ad240e"},{"version":"0x00000020","timestamp":"0xd6f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x67a69afce6ec76f0d083b68f75815f5a800068345d9bd72f864ae63c214c7b39","merkleRootHash":"0xc77c382c48aac7e98dbd97a2e27ce546ca99dd1dfafb6e8d5af7eebb36a78159"},{"version":"0x00000020","timestamp":"0xd7f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc0e557822e40d4485249f985955177039c8cc4c794eda8331ceb3c46e397e139","merkleRootHash":"0xc51573557652c06c39e1a2f5041a763322f2e329bd0dc10c098731d2ea67aea3"},{"version":"0x00000020","timestamp":"0xd7f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0cc5a1c07e47d419380c949442aed59b2915f1cee514745dbd9fa34209a96412","merkleRootHash":"0x835dbd71aa61a87f39356ab42283880e9e3c84c2fa78b1d8c17d95fb1df4289e"},{"version":"0x00000020","timestamp":"0xd7f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xccf207fdd1add9bdef1fe9e8deffc96a80cb249358a1507878de12616bef0662","merkleRootHash":"0x85a63f767d7d9bee37dba71645114cfa19e1dad07b51d40b21ca06dde4d41304"},{"version":"0x00000020","timestamp":"0xd7f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x943c8e0ea8e331d2586fddaf1fcde521abb14b41b2beed853dd43b40b96ee575","merkleRootHash":"0x3d312ad21fe1487cb1533c6ab0e1b98d677c04403fb82da34d2e7ee286da8be8"},{"version":"0x00000020","timestamp":"0xd7f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6d99188a35472cdf7ec342bdda1dbd373652bc611fb640651c4557b5a008574d","merkleRootHash":"0x8e4fc2dff067de89b8cb2222bcafbc5eabc181062fe0ca1959e1e3e01b60d29a"},{"version":"0x00000020","timestamp":"0xd7f3ba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x12fb2ff04dd34e1231134a3e875d0256ee94374844aaa59ba98c4c212dc1ee7c","merkleRootHash":"0x4e24ac0fc31400bf13fe11abc0499c9d3d6bff4d436ef9a1ecce8f3b43a25033"},{"version":"0x00000020","timestamp":"0xd8f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x91be3a66b15d82f5668b4dc172ae25d868e09b67c62ad746894ee3a84807ab53","merkleRootHash":"0xd2e85ff1918f1e35c1bd8f94af4da4565230c99b7e484662acb6aeb4620b1066"},{"version":"0x00000020","timestamp":"0xd8f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x34971b11dcfa6a14c697627965ce1d54d2c74cb83bac071af6cc2842965e5104","merkleRootHash":"0x1b8cbc2f5f51c7a6904fa7288f0e1f0ed8d2cccf9da1becc69f5e71e549bf728"},{"version":"0x00000020","timestamp":"0xd8f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0c23183572745a25d855260d631c459bdbffb47dedb26a45e15842e1a2d31a2c","merkleRootHash":"0xd1780c61bd97d17a378ea85800ffa2d49895d40b0fcf15a3bfc8e5024e14ac3e"},{"version":"0x00000020","timestamp":"0xd8f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x24bd211697f43e1dbb597ba1ab826d3e2e710071c97e7d2e882f28f50f24e924","merkleRootHash":"0x1b1a3e19ba9f242c6d51fbb43db10422671d6ec9121e0517d5af005f73ce80ba"},{"version":"0x00000020","timestamp":"0xd8f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa5101202d6bf169fe053748ce11e731bf8e7447b714d37ab9cde2bab6ba85753","merkleRootHash":"0xaafebefda14968dcb2425a5211f589cf6c72061ab23769f204a870077124ec8d"},{"version":"0x00000020","timestamp":"0xd8f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7f97c9edea636960a754960e9506dc8923a7c162ded94fd617de02c0f016c06a","merkleRootHash":"0xbfc6be08d3040b7357d1d7f9e795ffca205211953213c4746506cd4d8793a376"},{"version":"0x00000020","timestamp":"0xd9f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa97b1868f63d6b350b173847a663a92643fc7ae6774526f6a3b2217a837e3075","merkleRootHash":"0x726adc774dd9a2ccae8dc0977ec236901ed18701761a07d108eaaa8a5f73d041"},{"version":"0x00000020","timestamp":"0xd9f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf24e508f7d0e0315188862de617e96ad821f0bc4475f1f8db0b7602f70b3ee46","merkleRootHash":"0x743cb9221edf7e8c1dd9d9fa892c7465c2c179a42621705659a609f60cea87c5"},{"version":"0x00000020","timestamp":"0xd9f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x087040446dd352743eba6b687539f282a35c6bac9a299ccb5c95755cc33e3d32","merkleRootHash":"0xe2c25e74e0f64f86b80301b1ab3a819fbe52d3134c44c76fe514e2ca789312c4"},{"version":"0x00000020","timestamp":"0xd9f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc4fdc368e66cb4bf0df93c934688f55ae5b2979a401f06c865f186e9601f9f19","merkleRootHash":"0x4e0eaa132f522abacddd1870b9a9c04ad7427754a781c972a228d7ad8252977e"},{"version":"0x00000020","timestamp":"0xd9f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbcf73587177a37e7e7ba4e5bc66194073c69f72b609cfa82d6b82a649debaf3d","merkleRootHash":"0x4a656561068197dfca49d2ee8c269c6d9bad542dc2a1d250a0a086b9b78dc02b"},{"version":"0x00000020","timestamp":"0xd9f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfe2b0bb28719c1692e02699bdc7ab0b47a74414324b82907e76ac5286b305025","merkleRootHash":"0x0f6bf477484115e653c70485b3964a046fdb16cf6ba5e439efbd630bdf76b202"},{"version":"0x00000020","timestamp":"0xdaf3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x3fd9fed8fb00c0593741965c8188cd6a0ec36897263b9ff8caa3ed5bce13e965","merkleRootHash":"0x54119285603709df05db50b0230eca3da1c9a3f1f957e8bbb8e973e9fde50e6a"},{"version":"0x00000020","timestamp":"0xdaf3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9b8c8c3810de6ff27382bec099b909f0d5ae98ff46288ce3a85f1e32335b683a","merkleRootHash":"0x9c81f078b1642121dfcc9e07e45f760993f1fe59170a8cc55a506ab70b8e08ed"},{"version":"0x00000020","timestamp":"0xdaf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xeeee3d5bc4a57e6c9e28f25dbc476c78f065a2f6d5049a13244b40b1cdb20907","merkleRootHash":"0x93193282317815b25ed7ce4ca5d22cb3a5f76c494641b5ad2d949d60adcc106d"},{"version":"0x00000020","timestamp":"0xdaf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe6602dac9421a6f18bfa83d10115f002fe7bbb0b8933928e2ba8b1a23f49211d","merkleRootHash":"0x66b2854c0da4e4e94d7c8198a2001bc6cd809def608da1f99b9daab58d76e4d7"},{"version":"0x00000020","timestamp":"0xdaf3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x88fda5e2990949a32701b06eef82e74a4d205202d0221c415cdfef284183356d","merkleRootHash":"0xe443b4d65b4750b55853081bf917ded7b873c62373168a9c74067afc7bd618f6"},{"version":"0x00000020","timestamp":"0xdaf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4f2db576d44c2f01741478e9814212810786cd26a40d4faf1d82a777b7e3286d","merkleRootHash":"0x0c747554bfa6bc0231f5d5a8662028e31b44aa47609a580c0ea9851d7a3ca30c"},{"version":"0x00000020","timestamp":"0xdbf3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xb2159fc20768dce9e07755d967e418be541a832f434a95f9df57350d91ab0371","merkleRootHash":"0xc7b6ed22ec470eb03c413731a1108a7e993c8a81fa8bfec683873adf4c03859c"},{"version":"0x00000020","timestamp":"0xdbf3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xe4dd9f3de72f7c76bf7811da1ae716c78f6510df42df594f6f104efde5a6eb1f","merkleRootHash":"0x997940e47bc8ee4cdf810f12d8a928839afaaf949977ec7eb1e61c87195adbdc"},{"version":"0x00000020","timestamp":"0xdbf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6a25d39d5afaa18cc469e0b8579144fab9b35f892c98651f2dc2828a9b51ee61","merkleRootHash":"0x426aaf65b374c1a1082f6c60930baec9e1f88f7a2e8e7289af53fb56cc454dab"},{"version":"0x00000020","timestamp":"0xdbf3ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x6d216194abb6dd3da09809c97e0504be8e7a48ae3d0ef14bbebd8760bdd6876b","merkleRootHash":"0xe5a64ef6140b840757aad1340d97ef128d42eb4df518a37e36e33f7b10c575cb"},{"version":"0x00000020","timestamp":"0xdbf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbeacefc077885c1e22bd244db2809b1fdc065dba624146103d33b151e89f0a5e","merkleRootHash":"0x6e4651b05b7eeee7851f0216572c20ae07c9ec5b7c985f86ee151c1b06dc1107"},{"version":"0x00000020","timestamp":"0xdbf3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x73ae1a9fc0c9a0b0f4e8e5daba74fe0967a82ea639b790533dff3e63db334450","merkleRootHash":"0x72b4b8d91fda2b3f457fd9b12a896dcdb00d821a37c9bf6ce32f1b035e9d6086"},{"version":"0x00000020","timestamp":"0xdcf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4534630e826383c6f0c11ea434d63366a404b902b85f91a29cc08decb4c7662f","merkleRootHash":"0xc76d70da4a47f7b615eff7f9a4b7651a87a58676ea7ddee259d4319d52ec047a"},{"version":"0x00000020","timestamp":"0xdcf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1f8bf193cc88f93fc9a5e28ce5ee8610ac0f03b9335c5583595e70aec598373a","merkleRootHash":"0xc022cb9b61719116d5e8169385105ba4065938a918c0f06494b7030ddeee8484"},{"version":"0x00000020","timestamp":"0xdcf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc18c2b2b4a5f9d47d4beb7f030dcafebbdb637f87e1ac249a47c16000ca2d30a","merkleRootHash":"0xa751e3b361b6b2551109c74aad2d3b15e1a9dd34ae6c06387f9ac6143adffec3"},{"version":"0x00000020","timestamp":"0xdcf3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x187339c31d60799d7b88380a946a32a912c199bbf512a22c0f2d5d36767dde5c","merkleRootHash":"0x0e5d54a596544b1898a574452a85533c689fd348bb8b8ea191df2aa71b9a66a9"},{"version":"0x00000020","timestamp":"0xdcf3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa40463baf1578fed0957ab1410bb6a58e8c7303d7518bc94925027e3ed2dcf19","merkleRootHash":"0xbe634980033b87482e297679252f6ff3b14dcba8b367940cdd88a65a7f59da14"},{"version":"0x00000020","timestamp":"0xdcf3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x857b970afdc51242c8a133ad2e782c781dede39f26d86abf6a1682530bf06b33","merkleRootHash":"0x60df418ae1fa725c210d56ecb3d3e489e7ba6ee64c94ee25c3222635a3d3b387"},{"version":"0x00000020","timestamp":"0xddf3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x1c73b85e5bd43bb4f629a39d255bbf6f52106efd8aa381087b051514eefd9c6c","merkleRootHash":"0x34443924a94841d7a52b0424aa8b5a95a912a979a42caecf1181fcd6d6d1b20c"},{"version":"0x00000020","timestamp":"0xddf3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd2d25d2720cdde288306acfd58fc974bb46e66727dbbce4f5057e1a84bf15e3f","merkleRootHash":"0x9ae84ea83bf2a5eb45adea38e6376169feded65c658161196f890ef75f1c1251"},{"version":"0x00000020","timestamp":"0xddf3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x3a60bad70a37e10c9fd60360cf08e86e26c9687cc9044ef243f2f4fb30772c76","merkleRootHash":"0x3f546648c778f6e5722add9531317fc896b14e6c09f4695ff6cb0e255467138e"},{"version":"0x00000020","timestamp":"0xddf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf609dc0601dea61caaeac88ee0a65badd29e8e8a936c67c8275108924b546d06","merkleRootHash":"0xaa78fa1174cd42bfaa01335dff9227762ac0de2aa0bb2bebbbce29544b061b74"},{"version":"0x00000020","timestamp":"0xddf3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x413b49096306562b59341e6cb76b738db9989e177dcf071f4622903c2f279d50","merkleRootHash":"0x9e7d2bbdd02c24dd240764448703c9ef2571344a399e6f6e2c16910b19cbd2f6"},{"version":"0x00000020","timestamp":"0xddf3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xcbcd97b09f67b4be3cb36e3a65f33c0bf5bc41581462fa9c052aac0f0a45456a","merkleRootHash":"0x4240ec1a894053809c627fc4f7140549b1e03a101aedb65a182604fc93332d3b"},{"version":"0x00000020","timestamp":"0xdef3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x73d11bb1cc54624f38099ceb1ccc5ce0bf5eb1582d2a7bb4c2b78173e3266e16","merkleRootHash":"0x9b0224c96b450b36e9bd881b38065dce976a315f50ea800a94af6439e980f566"},{"version":"0x00000020","timestamp":"0xdef3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x791bb4a336e8e34e95088b14322023eb5eb22c99bc22bd73549d71453d959f22","merkleRootHash":"0xd6ce769bbea302673a02480f8cc60a24c2a416d87fe7b0006b52398d9c1d5c6f"},{"version":"0x00000020","timestamp":"0xdef3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x90b5aa7f58299ca588002573da6363057ecc51ff62972d7e12d978f14744c646","merkleRootHash":"0x50df63839f651ed59103292345c80c9b83f0170da465a2ac0ff06b9695272616"},{"version":"0x00000020","timestamp":"0xdef3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2134ea509c9aa998f176c3451abca41682a0ef0d76d25f4304997fb83d8f4909","merkleRootHash":"0xb0852840180917491d697f10a16c0f69ab57c31fe8ce084e5d2cc6ce1a5ca0e6"},{"version":"0x00000020","timestamp":"0xdef3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb331c6168ef2f2bfa1dd186145613e1832afab83457844b30456dcb4e0c33c48","merkleRootHash":"0x1dd83761e7d651965f5788a60430665d1c6b0185cccb30ff7d6da1af7e8c79e5"},{"version":"0x00000020","timestamp":"0xdef3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x7e454c1be91a591d7227e140d1f0cc3349c4bf936e2c793e410b1ebda8d04f1d","merkleRootHash":"0x4bd616017e5dae79371efff0ee87bf5e6e0c3ebe045e1ae2e04f7bff48fee6e6"},{"version":"0x00000020","timestamp":"0xdff3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xd9f0f604cf06c611c062701a4d19eddef842a5df5ef30e40bc521b4d8f6e9339","merkleRootHash":"0x37a7b905c4cdec4e7d95d2af53e19a40e692dd880efff17608b9a3c734ebaee8"},{"version":"0x00000020","timestamp":"0xdff3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x37e8f911854c34867969ba879f16034033fb29a482778cfd668d574943bb9a60","merkleRootHash":"0xb80e9fb00c17787ea5fb44fe8191f6f58376d2e33e5e311191793ccf1d17ef08"},{"version":"0x00000020","timestamp":"0xdff3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd7bbdeb236c67b2f639acdf4bf1ee83a7499ab07eec5870ee0a72dcab970f30c","merkleRootHash":"0xe4ffeeb207ebb3f634a3fc922ccb4c8f916971eb9afd8977f08a41b3b1f381ad"},{"version":"0x00000020","timestamp":"0xdff3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x67078b8c0a5db120868869690614cdc49afc85298e73b2af0b322dbfc23ed316","merkleRootHash":"0xbab113760cbb5591ae1a122dbfa716d91307d193fedf12e0e389fb75e545b067"},{"version":"0x00000020","timestamp":"0xdff3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xb825873bacc8f5633b5c3304624676e13c246409901363890725436cf25a420b","merkleRootHash":"0x79cb78dd6245b3fd0d14a5d442aceab9e4b538f71309c99d57fa51e9e6c2d059"},{"version":"0x00000020","timestamp":"0xdff3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x76867b9121b34fe363f530c73e57cf36f928979911bffcb6d1d81ac7ec232606","merkleRootHash":"0x0a549e4c503aa6c1eb59c70f820ff01b72f77f8798ad5a1a73193aed6c9dbcd8"},{"version":"0x00000020","timestamp":"0xe0f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb2085a1f45062b326a1565844ef9f2862e5309856907b60775e646a2d2401962","merkleRootHash":"0xd638ae4cc21c41dd6cd285d2a525488df06097328f2dafeb7704b2c725f99e98"},{"version":"0x00000020","timestamp":"0xe0f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x911408c94a5cbad75de4fc7fc15c0da0caeb0d1444a61bed4c0c4cdfd034552d","merkleRootHash":"0xd3b18628079ea4bf4bb84c239e916a9b1d1f8f90d5a4ecc75a17c80a4a65a1c8"},{"version":"0x00000020","timestamp":"0xe0f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0c69196d08006558823e6b563e50b9f841f08aeedb13cc5a5d0ed2972a1c711a","merkleRootHash":"0x2cceea9f6e55a60e52c33c34f4b55488ae7beff7a390dc9f680fa14b36e852fe"},{"version":"0x00000020","timestamp":"0xe0f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x20238b2eddc50ba9721e408c764c63f0b1c094802b9f7d239c7a709b5ed07c27","merkleRootHash":"0x4ed3a0d0d7822a4e27e2a763b7d5061643161cb65284cf2ac16e8515920fb952"},{"version":"0x00000020","timestamp":"0xe0f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x5bfe5fd537ba7c4e2f5d37ec440d1fac0bea416861cee62f94f15de2fb34b005","merkleRootHash":"0x63f90d25041c635de461362cf782e3ea886a4a7bc1099e28a3605af8414428b0"},{"version":"0x00000020","timestamp":"0xe0f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf050912f605bdc9af7c9690d085be3422fe8ee56601f0c346a2a1e4c7e893712","merkleRootHash":"0x7c08df7c8f67f83385de8aca05ed7d19fad70a2abfeb1f29c7db6f28055b8782"},{"version":"0x00000020","timestamp":"0xe1f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3082c594a3465042cb10fc0925b365af59db390f50d1258beef47738c8996567","merkleRootHash":"0x72aa858b1c26845b369ff325103348a0daad61661165c269ad7eba57aa90aafc"},{"version":"0x00000020","timestamp":"0xe1f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x75bcf6b0085ea1181d52e9fd4b7c752a75fb8ba3b7439dace7e26a20c92f4124","merkleRootHash":"0xd973edbed8bea4eaa409fd841a9a2e9c83b6d8bfc998704d0b5ea8b5f0022664"},{"version":"0x00000020","timestamp":"0xe1f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x94ec5bd3967ad308bdf4200a4b7159e3c8b2dc1397eab95c65711f27f7059d2d","merkleRootHash":"0xb58f006ac99b10320fa8f03739494f577346a152f5b89edb50fc0844ae0f84bd"},{"version":"0x00000020","timestamp":"0xe1f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x83ae59928de0a82d5dde70881988925da8d51ef27ffd2665bd676313a98e9c58","merkleRootHash":"0x07042e9e30e3e3fcba2cb4bef83458997211dbd32d15dc0842e60747d6cf3440"},{"version":"0x00000020","timestamp":"0xe1f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x98d8c6da833a39ffb56916a8b779c706cd129fbf49938e542949f22bfe1fec51","merkleRootHash":"0x0dbfa6a06483b6c005450945700f0b76e63cf30f2d9758b70baa68a6fdc0ff2b"},{"version":"0x00000020","timestamp":"0xe1f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x23edd8b4426ea6a15b607a05fbe6ea1aa4628bd835dcee4b1603faa4bf2d9c6b","merkleRootHash":"0xa569ca60b5b2fb889ec15cc00641db4bbf4432290ca58dac1973ad1a8c3a2c80"},{"version":"0x00000020","timestamp":"0xe2f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x84ede2fc0a97470845b49e623b4b5da13d5c536147297ddcbc3b0548beda387c","merkleRootHash":"0xb90ba6eaf7a802fd2407e7f7708ccc5630f424f99cb2cf9bab0326623c3a17c3"},{"version":"0x00000020","timestamp":"0xe2f3ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc829c76767c07c96796f11bb5da5ffd3eacecfa6640c4354d4b5b35f4a1a8030","merkleRootHash":"0x8cec25b5b0f71e072001ee50cb25dc7e98708ec2710a9932fe625ae9dd882f3c"},{"version":"0x00000020","timestamp":"0xe2f3ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xe8f2075a9cdb07a2e890400fd5c4b7a13f8f441792bee44e4ca8c256d1233270","merkleRootHash":"0x6598ba6bf76bd4ff856b24cc62af6a0699c2e201371aa0603353886fc8a3c03f"},{"version":"0x00000020","timestamp":"0xe2f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd05a694a159cbeabdd3c4fa15c4c214fa40e08328eafafac7e332488416ba039","merkleRootHash":"0xea2c17581384fef1d4ed593ac5d1ce12533dfaf1961931f218868d43ae9cea23"},{"version":"0x00000020","timestamp":"0xe2f3ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x25f6bdf9ae3013d6f1f7dd3c349936877e4c6332bc0a34901fd2fd4f7ca40e42","merkleRootHash":"0xcf92784fccea0c30d4645605963876d77b7f23774409f56aba524c901636548a"},{"version":"0x00000020","timestamp":"0xe2f3ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe8a53420578d139b1aa5ab33f132c327578ad19077482c48b6c60201bad82552","merkleRootHash":"0x4a180201b0c5d72bd7b8ed2021de74012c673d214f3b5cb1228b6b337010a008"},{"version":"0x00000020","timestamp":"0x58f4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x9a17da8cf877ee886e8708c5dc8a7baefe940cb680b17616fd967baca5cfd441","merkleRootHash":"0xf1bb00cbace3766026afe2597ba3eb4333bd03f0f40f4fb9949474dfeb654aa6"},{"version":"0x00000020","timestamp":"0x58f4ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xe2a9497e2714f9d7fdf289a567b672ada8c58591cd12d4214780b8c3ee55b654","merkleRootHash":"0xda7659fee66bcc96ec187091872f339c1726263b1130ad8fc3ed4287253b794d"},{"version":"0x00000020","timestamp":"0x58f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x901d260e00c3d8792d70e26b7f9e58b46dc7e1117c160af6bf100d3f98a50362","merkleRootHash":"0x1ca7723ddedf12f0ace32acb4f3c115684bebfd135babe8d36fd60b6869df8fb"},{"version":"0x00000020","timestamp":"0x58f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe1f0f84d46a62d0f7125d0f451b329f471e1760bb335e6efc3daf98fdd20a718","merkleRootHash":"0x974c160a29289805c8c53a1a6884c7f7868a83447c16d123a9f9c8e4e10a375c"},{"version":"0x00000020","timestamp":"0x58f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5c3b8a7af3bab62e57b81aa71cef895c8710cdc8951d7f752e4e622098e26b4c","merkleRootHash":"0x7a491d296e6bf0fa8902e31312f1e946fcbf0c50e118cc6d0f64a0584c09cec6"},{"version":"0x00000020","timestamp":"0x58f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2d973cd0bc9a76a690da4ff9b2e0a69bc43715ab9924621cff2724020a5dfb59","merkleRootHash":"0xd338684b926f6c2dad8fb818b1accaef1e53aae2e08cc67f661ece793a2438c9"},{"version":"0x00000020","timestamp":"0x59f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xaf85aa9c554901e39447467cfbfb074dbfdd8b960f7fd14c7510c5ac7101d23d","merkleRootHash":"0x6d5cf361823d96703326fef5e1db729ceb4f045407cc5eb3d621e6502d89333b"},{"version":"0x00000020","timestamp":"0x59f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x841aa3830fc4420ee1cc456ac9e46f27a5fce3fe1b3814350edfe48945f27a40","merkleRootHash":"0xcd554cdb889a04b3be986da342c1d8e6a2ba3355dbe2797386ef8deaea500613"},{"version":"0x00000020","timestamp":"0x59f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9bca7a5981bfb282b7347677aa0906834443790162a23152a0c99ebbc8d4e979","merkleRootHash":"0x2781ea76cf255ee78630e4a854534c10e794b77a72990a4fe4e50fa6cb368b6e"},{"version":"0x00000020","timestamp":"0x59f4ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x6b3fd4a4d504bdf650922bd52addf530652ed4e27273414fa61b6b0ac159ee1d","merkleRootHash":"0xe30f8b3f33a652e1618a146b80e4b75c07846210708d81fb21dfdade29f57ea1"},{"version":"0x00000020","timestamp":"0x59f4ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xaf79dfdc08b0935001faa896cff1e5aefb6f1b07a56b7011dc2d8395b327fc27","merkleRootHash":"0xff683001850f02e9e41a7b7a08a62dbeab99ad0adac65139ccef747c97efce52"},{"version":"0x00000020","timestamp":"0x59f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x78166f6dfa8a1f7ec06bf6f3d7f5c91ce21f7647183c82bd654fbae72f8bd938","merkleRootHash":"0xdccd4f7bff2de74b95867d357fef42f3afdf1224dfa1e17580ee18ff915dfd89"},{"version":"0x00000020","timestamp":"0x5af4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xa875060e61bc63606e0a734679dbad767a249493fd5dde120253d7e156840c27","merkleRootHash":"0x0a0f0ab972395b5437b90391396f0523f0c38d064f1cef7b55bb0d64b67ae229"},{"version":"0x00000020","timestamp":"0x5af4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0b31a5c2577dfcaa4a442e7b394c00fcc0cc00e9d2d5b9900a36fac43e5bdb7c","merkleRootHash":"0xb88f9d9507ce351dc82830822260e93f79b6e68130a9f9f57e6bdeb83ca08cfd"},{"version":"0x00000020","timestamp":"0x5af4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x27c672ce7992b13e4b13c6a3c0b35e58a550884bd5b7df89b0babd2dd388723e","merkleRootHash":"0x06b602277720c926f9174fcb6c7a28ee33f7f2401d7e829281017f81556da5bb"},{"version":"0x00000020","timestamp":"0x5af4ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x92c114b017e8bda91e5f543002cee045b2fe7b01599b9e4178a6f8c606354d72","merkleRootHash":"0x9d94f5a0c53d295dea31a7ab006e42e7540462be88c0c5549c4184b1632f04dd"},{"version":"0x00000020","timestamp":"0x5af4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfa4b1106f77abee98dbf08400d33418bda6148fb7b1221a93aecffe4b88bd754","merkleRootHash":"0x0177304c98c7a7bf0dc318391ae2fe50354fb37dfd186f2794797fa14f74a65d"},{"version":"0x00000020","timestamp":"0x5af4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2dc72694bbabb0b93485b6bcf4a2f400a4bb26749ddef685c3e377d7f4f60173","merkleRootHash":"0x591d0174c7c04af08998a19742cf3b34e24cc6a67406360fa8d0e4faa2be7a46"},{"version":"0x00000020","timestamp":"0x5bf4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6b86e6e1a27f93c7f1ff9096548fd307b9a433317c687aa539f4be5e02e52657","merkleRootHash":"0x46178069222771c8a64052247819e7523bbf9c17763d299bfd429c586c0e8fdf"},{"version":"0x00000020","timestamp":"0x5bf4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x10f3b7dd3993c3be3d71669f67938a5b2a0264cb3196def0cdfc14787ff88e6b","merkleRootHash":"0xd995163c73c12af9f53665d350061f87f53b9dcec586b1d3f066aa404d48a1df"},{"version":"0x00000020","timestamp":"0x5bf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x61e3b89ec01c56a7a348b1c3912b0b0e132848c885fe0d8eabd0ba49e2e5de35","merkleRootHash":"0x27ce136fac7eaf8f972ae322047b66cd2ff27efbcf954de8bc7e347542c6445a"},{"version":"0x00000020","timestamp":"0x5bf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x547b3c5e422420448953eb5bb33fce3da75a66867278c95dff7a695c810a070a","merkleRootHash":"0x2d34fae8cfe92a0bb322d0226011d58e8b13bb98679c0145d7501e96d1ba4512"},{"version":"0x00000020","timestamp":"0x5bf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2cbfa1c2554aac566b079f2deb4c6a5e3fc657c651c54f6d29b5c5e044ff224f","merkleRootHash":"0xb11e75350469dea681b0c6bb10237eb2b3fdc2843646af099793c7800dce5edf"},{"version":"0x00000020","timestamp":"0x5bf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x568ac77d3ce42ca66d5727ff2c944a6840188b896f26f5d3195ba51714ea001f","merkleRootHash":"0x89835e2d88eb9c1da5d3f1bb3a7dd50ae9b34a749dfd270c4f0cca0f4763c0f8"},{"version":"0x00000020","timestamp":"0x5cf4ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x203f9bdcb5e37a2a331f5eaa9bd3847da44e56b81ce241b395f9414461dc0f02","merkleRootHash":"0x8393ef7107525512815515c3d3ff56a296ceff2f05f7ee016e666aa064441ecd"},{"version":"0x00000020","timestamp":"0x5cf4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1090e8540c1c9bf1bcd1278ac596bd6b68f1aab4c58661148b7d47fbe2337e6d","merkleRootHash":"0x52a756c7bc122bf890fc67e377f2aa9d5a5455c219db30f320092dee12339258"},{"version":"0x00000020","timestamp":"0x5cf4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x77a9c13d16696ebd5f71ba6aef39e54c63e2833a9cbc13351dcbb8d63a48ef0c","merkleRootHash":"0x790d87e1be237126510d5c080b23886f58a2c92ce4b4d17fdbe568f1936258b4"},{"version":"0x00000020","timestamp":"0x5cf4ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x2312a85246d14370a4cae7aa9787e7549bc8eda61f8991027e38160f0c10ce3b","merkleRootHash":"0x0ec1c3a8517ffcbd4e1071b5c1e60acd839777c3c77ea01c1cf4669fbe8dbc76"},{"version":"0x00000020","timestamp":"0x5cf4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xad698cfea0f8ab364d1be1759d5b447be3f24e252dce7d9392eb35d77649b733","merkleRootHash":"0x3cbd841b075a724115547d5a0ac595407c90310f94c0d696ddda1b891f1adf4e"},{"version":"0x00000020","timestamp":"0x5cf4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x27a44386852b2adc868ee0fe79719496b763b8cbd97a138bab1556374930730e","merkleRootHash":"0xdec52e05d4cbf4faf21f0e09102bc54135aab296604e6940777033654d9ea76c"},{"version":"0x00000020","timestamp":"0x5df4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0254caa18b364fe315f5cd53e04b1c670e1565f392afd14cbf2ea3ff52332b33","merkleRootHash":"0x27c9b68c1fc15546e75bf476d4876327f252017b45d74cc7fbdb54cef03e9ec3"},{"version":"0x00000020","timestamp":"0x5df4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd65d5e806c3f07e430db817092d0130ad0aa6bd621732278399a9c22b9bc6c4d","merkleRootHash":"0xdb6ca3375986c3ab3ec70771703cfb287f741a8b08b5b700fa4c5541be65da6c"},{"version":"0x00000020","timestamp":"0x5df4ba66","nBits":"0xffff7f20","nonce":"0x06000000","previousBlockHash":"0xee06de53470e309a0555971f73b46b8c1150aca2f70ce4f07afe4dcb704ad179","merkleRootHash":"0x185124673993aaab6c77e4e34565525cccb057abd15dcfcf6bc488e7d79a92ab"},{"version":"0x00000020","timestamp":"0x5df4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa9b4934d0f128300a5942112581f92e62392d68773e3278b9f441f29668ae259","merkleRootHash":"0x85441542458cee25edd3b3acd80908b480ca547103e8cf2f48b0d5274ae8bcc2"},{"version":"0x00000020","timestamp":"0x5df4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc06491f4d057334d77b68ad0938c744ebf8e4c5eb48ab4939d720982a9471428","merkleRootHash":"0x9e1ff299fb0135309ec10f54fec228106a5afd420a4db3592740c5f255e73eb1"},{"version":"0x00000020","timestamp":"0x5df4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x11e9d1654d01b9f85919071e75f0d5b6c794b236026e6c6622ee7254db9f1607","merkleRootHash":"0xaf406fa78cf98d24a716f61bb0183e87df350274f2327b3ea265f28d505c8559"},{"version":"0x00000020","timestamp":"0x5ef4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb9913d0c391890c91b06d81426b130b200ce9438fc487f095b6e056e63092c36","merkleRootHash":"0x6ebb3f855c0efb2eb38978285f2918eca85084539949f4582d10d325d96e1860"},{"version":"0x00000020","timestamp":"0x5ef4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x75c3fd556012cda486fa255b7e4c7be39c591fe456986e88c3a86379cfb3211d","merkleRootHash":"0x28d5cc6dd01ea436a6dea4ad7c08c1d3b19c2f062bab7bef6b774482f541afc4"},{"version":"0x00000020","timestamp":"0x5ef4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x62c2e44ada4d3bb26732a4baca9a6ba4ec6696b140f5014b196cd02d8b86e748","merkleRootHash":"0xc3985beac3d0656ae1953599066cb653dd3b6ea587ca23dffa8a1c0e49272829"},{"version":"0x00000020","timestamp":"0x5ef4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1e5c2e774002b527f06a736fc31d4bf88be4d71da11d4fa7e141873d483c4514","merkleRootHash":"0xb34336932440d8e0963deeb4c9f16eaa9aeb54152a71996cd45532317973e51d"},{"version":"0x00000020","timestamp":"0x5ef4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xceeafb4b5ce871c8870266debd38a68239d78359eb57ff9a19b8d706bb369976","merkleRootHash":"0x2d0453ecfeb20afb5f7e56a9b502e0dce49e13dc96db018dfd1803d898db41cd"},{"version":"0x00000020","timestamp":"0x5ef4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbd33b54ac9431122fe4bd8ea4b62748594354740580f7724c449f5de5032351c","merkleRootHash":"0x8e11b2cbb88a019800441a5563bc5f5f93e283b779b8a18cce1eadc14a588e6b"},{"version":"0x00000020","timestamp":"0x5ff4ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x1959c014cdeccdad3a25c718c4cd98768e38c291d4eb2169272c74614f79714a","merkleRootHash":"0x9472ac0e6adde7732e93d2480eef4a6acf9f569a06bced18d77a6103283dbc7e"},{"version":"0x00000020","timestamp":"0x5ff4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2272801a1072f557d0461210094717b0c65a2a747b05721132379b653c385c33","merkleRootHash":"0x81a22645003e3da2d1ef0d503296c2ae0523cc2297752fa270370ceef9c30349"},{"version":"0x00000020","timestamp":"0x5ff4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4583063588ffb5a09d6e9bb6ab86ab6c16e28f98baac60259bd00fec944f5779","merkleRootHash":"0xff1d74cd2a3e24543b6262a17dff23e79234cb0cd90886fc73f57afd390c5f2c"},{"version":"0x00000020","timestamp":"0x5ff4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x877bc22440370fcd5ce2e6f5d52e83412ec0a823cece800e20c3bd4e34e9ad7f","merkleRootHash":"0xeaf86e702e245e0f56a411ba1a030ff51d240f6246f251d4c3e5b1dadd8a2e2e"},{"version":"0x00000020","timestamp":"0x5ff4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0e0185139cbe7ae0530cc75d5e60eb75cad4001e1c0dd437b01a1a1039e17307","merkleRootHash":"0xe8742c1bc903a383864c4e93fd6065132b7674408b38ad751f46b60dbb70bfb9"},{"version":"0x00000020","timestamp":"0x5ff4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe8381860cd7e4c89ac83fbaea60c08f410c47d2b753126df868a0b70c20fda51","merkleRootHash":"0xdd3b298afffe9bdacdbf7874e2fe7d633ac5b2bd605980149746e857a50b7fe0"},{"version":"0x00000020","timestamp":"0x60f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1818ecc382edf9166de1f6d4bafb0ff0fd9ea9226b2e18edc8e26e41f50ba778","merkleRootHash":"0x06e22d4a0a3555cb0a51f52254859cd37bc681b3b7556f08624cef744cfbc96f"},{"version":"0x00000020","timestamp":"0x60f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8489dbea95129b0e1ba3631f485d8766e9fe915981195ed5f4aecd1489494a3f","merkleRootHash":"0xd07c56305396a78288c1b81ff80584cba4f964c7a64e61b2878f8d13de73f972"},{"version":"0x00000020","timestamp":"0x60f4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x04c5e11d346e3da6b5a6ec0a614d2eb6d5ab55d776b999c79d00716b7908ed54","merkleRootHash":"0xb80ea79185efd35145780145dbc423753e0aa587e8784360b5e7ba3eafa5bb69"},{"version":"0x00000020","timestamp":"0x60f4ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xdc7f4e448e405f6366a74b25ee1d9a2d0078640c5bd7f8e077de0ebfccf7e039","merkleRootHash":"0x531b684e1baec7dc77636095151175a8d2a8881cd8b98c32944ba0bdb8325111"},{"version":"0x00000020","timestamp":"0x60f4ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x1c5b0fac14e568fbffd0dde999b26326dd691a06caf0ecfd4dab793784a4c84d","merkleRootHash":"0x082b09a21c6735fa345482e7177c266d12bffcae20b748f51991ae4216ceccdd"},{"version":"0x00000020","timestamp":"0x60f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf46b7be69340b7c65c8b37a6442d3a9cbae3d3a16f9bf807b84334e7a8d4be52","merkleRootHash":"0xc1e61100bcc44343594978b42d8bcb726b21b8935e33277fa94e19a6f22e86db"},{"version":"0x00000020","timestamp":"0x61f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x083e0705ceed492840423be3c0dbb7dd9bb319883308b66cd7fc245bfb991e51","merkleRootHash":"0x0a30c9bebf29776becd7518b0f529011dd74f460b2ccff2eb3c31e55be5469a8"},{"version":"0x00000020","timestamp":"0x61f4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x49681f3eb7c9afe696538c46728de2250391ed7376945932faaba74c88f2e103","merkleRootHash":"0x2856a0fd13b71e407a02bde232284ff364a17161758488fe3724917bac95ae69"},{"version":"0x00000020","timestamp":"0x61f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x52895553cf21505f1cb26a2494ceed9fc0b4da16f03ab930ceee6e26dd219065","merkleRootHash":"0xcdda354bccdc7c120d259e0fc84a5f8a2763e8ab945e33e317df2db45a28b10a"},{"version":"0x00000020","timestamp":"0x61f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf4193685b1df618ab71519c88c314f741b8b9f94ee64a5a193c63d3447ea5a06","merkleRootHash":"0x10b0284f40f048a2fe5e4c07c90ee8e8b0ee8223b69b8d8cc9ebd674a6b494ac"},{"version":"0x00000020","timestamp":"0x61f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa620d305c23888d52cff728bd0507e5ecbc183e2a02cde7aeb145e2b6469eb66","merkleRootHash":"0x92a01cf97320ff6809eefff6322d4cc94101d6be4aec8daaaff2592132d65f14"},{"version":"0x00000020","timestamp":"0x61f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x45093bc04c70225f982d2406a828cf52ed8ef518628861a0d5d523872100510d","merkleRootHash":"0x5c455a47ebdac445f453d8b17fc6053d12a1966e334a7391e7297342111edfc2"},{"version":"0x00000020","timestamp":"0x62f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x07e0e7b93b27d957a0d90da941a8fe9d35721e67fc0f90107570c335f6cd6742","merkleRootHash":"0xee415281d07746a06050101ac2263818daa29669ec42fd89b2b0e4173549b221"},{"version":"0x00000020","timestamp":"0x62f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8a82ab8ec63478dc2e3e0c3b1d9264fa515ddaf8c47b2adb7a113b2dfbf7a97e","merkleRootHash":"0x34ef66d5cfc851f7244303a11328f70e801ddc772df72de35ad037349e8f30ee"},{"version":"0x00000020","timestamp":"0x62f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x47c98ead527ea841b4e1f9f224163f02f072bcb32b8f94381fb08eb5113aa56f","merkleRootHash":"0x7866f5663ff2ac03490879c86e027b4eb331d03ab9251ae4aff72cbf4a1e265c"},{"version":"0x00000020","timestamp":"0x62f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8a3d824a9dfebcb29c6196edeeb8c911a1b34c336fb3749798e8ce0f747dd248","merkleRootHash":"0x46656404074de1bf852d93b8352248b0852be2c294d243e3375de598f10a30cd"},{"version":"0x00000020","timestamp":"0x62f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcf68c4e07b1dc1c73308c9cb5e03a1e0ae5bc83df0dae4d20215004528303314","merkleRootHash":"0xebccaf6b419b83e59aa546cf695151817dbc6cdfd09ca98ffa4ab03ef868f8ab"},{"version":"0x00000020","timestamp":"0x62f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1bfdf09bb248b2ebab8f0167d187991aabee56cef2c8be7940e12f57e629062a","merkleRootHash":"0x5e7ac1a9217a31205b72ba48dc7add7c5a651125d278581d3d0c1d2b2ce1d341"},{"version":"0x00000020","timestamp":"0x63f4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x3e11dba934c932ad045dd8c03d87ff271b9dc88e2ef73afce33f214bade3b51b","merkleRootHash":"0xbf576af1ef0599294c66f34328a2387e9ed89bf179e7bfa77fca7e1d4b79880d"},{"version":"0x00000020","timestamp":"0x63f4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xb17a2255c849e50e13acc031340944627b7dc8feb23027fd93157250904ca346","merkleRootHash":"0xc09d8b073028bcdb1abddf132d5f786cd4e5d9b8d3d5b439792482a388bd0029"},{"version":"0x00000020","timestamp":"0x63f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0dc2dd32220c9736487b2879eb16a19217c55882e97d9cb0fdcb737f9838b770","merkleRootHash":"0x707d4659a46773d7a8f68a82d42a10fa82d8fdeed8965bcc8fc84922740fd8e2"},{"version":"0x00000020","timestamp":"0x63f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x194f28cefba68ce254730d915c0449340a402e3eb8248d278cd1e9290b11c71d","merkleRootHash":"0xd4d9aec472195c61d585a9e4b9f5fa00c652103c39138363d75c1284073d776a"},{"version":"0x00000020","timestamp":"0x63f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3de09199ee68ddb8cbaab2a536580fe0a0cf693d2719c3a5e645b3a92ea2183c","merkleRootHash":"0x82a4466ed4125e2a51a9620080d929e784730835b4d38ccd83747cf50ad10395"},{"version":"0x00000020","timestamp":"0x63f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xeb820d52fd7e7950cfbce5847f1d662648c47de1c87ffa2fe34982fa9def5356","merkleRootHash":"0xe934e02bc84a9e6d4bcb373331000c887ecf298bede0f35bc200613c8d049beb"},{"version":"0x00000020","timestamp":"0x64f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xdd17a5941e83e7a85941dd19984ffd780e94e943f16486736095fc46c091be6c","merkleRootHash":"0xbe0b5315eb98884d2d65f3548bd7281829e0121002f47c19df9c21fa0d68a8cc"},{"version":"0x00000020","timestamp":"0x64f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4bf4f6b557a26eaf8614c4e596cf7e340b5940d43e5a73e7fea234ae7a7ebc14","merkleRootHash":"0x8503243e6fc55df08ca6691881adca347182abcc2fd25fc3897f46e20b279bef"},{"version":"0x00000020","timestamp":"0x64f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x95d214a651b4974e2db1442889b5ab6bd09c712e34a945fcb58abe00f818267b","merkleRootHash":"0x8a66cc1e40a8738f40f1c88afe7ac3af8f5a4cd69be530ffd9fb9a44106f7d06"},{"version":"0x00000020","timestamp":"0x64f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8b347b087b415c212a07d122ada9ef76f02be1fada4cf66c8a17efee584c465c","merkleRootHash":"0x702d9fc2fcdc0e0212258154fb7de3c33b53a2d65996a9492002d481db8ca1bb"},{"version":"0x00000020","timestamp":"0x64f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xbe7233999ee951a73d0737eadcfb91823ebc9c8bb5051d5324d9142c4c95ab04","merkleRootHash":"0x345b615e4ed54f8059adc3d7c34dc69c341fc6095379e08aa6b2c1011a6a0747"},{"version":"0x00000020","timestamp":"0x64f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa493d2038879d623475149c7f33214a4f40f2bfcd807dab3854c9d93102bb771","merkleRootHash":"0x8bec75c4def780172c858bf0d8f2fc3790098e426d54b4a5f8913e1acc9c20b4"},{"version":"0x00000020","timestamp":"0x65f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5ddfd9b77949e82f0527b0a0b113b360985826d8ec91a9826b2465920f00ff5a","merkleRootHash":"0x8f17595b509b2ba8a292c4ee0342734e466774e4871189516d95db61af65cfa0"},{"version":"0x00000020","timestamp":"0x65f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xea887f95c620d339f81e2c9c73533640708414fe6540f511d9749a5283d0db15","merkleRootHash":"0xf583d271bce44a12e572341d5ac979bd52e512aa0aecdffd8d72e565c9e4fa07"},{"version":"0x00000020","timestamp":"0x65f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x64163f4639c8026cb35e89e1d06d8c5001a93cf199c46e0ab64fdd4f8d0fdb1e","merkleRootHash":"0x5664867342eacfede152148cc3db4a97454262f7fe426df96cab7f57d785f4aa"},{"version":"0x00000020","timestamp":"0x65f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb4e9b29d948d31710e4265f3c95b5bdf4df5b4abe6eb564ea07594f89e085044","merkleRootHash":"0x24b05a5272f69d53bb96a58c7e65bc25c0749747f1ffb1501a19af19e05eb02b"},{"version":"0x00000020","timestamp":"0x65f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1e34ab42649530db06b9eb27336d8c953ef9a8841c3a33866544753ceda1401b","merkleRootHash":"0x429b43ae142d7541441b600ee924cef5ea7eab847e5fdba7694630bbf8253544"},{"version":"0x00000020","timestamp":"0x65f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xac3f2beed7a5ef35e4ef8a37f7d79f2a8408fd7a3e607f796d62deba42b1c436","merkleRootHash":"0xf7314b7a8b80ab1c43beac6b20b4c1b03910b44e0752be6b0649bcda55982967"},{"version":"0x00000020","timestamp":"0x66f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd06c42b66f72583e5f2725e19b62c2a5d1b46a188b19ad7716f67985effd227c","merkleRootHash":"0x517c18de8c6be5252c206faba730c1b581c95bc54aa6d3942831924124f4b2e1"},{"version":"0x00000020","timestamp":"0x66f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf8e7025ea291d14f7b546ab41e7e24304d595ec61bee2eb2b783be0367788e00","merkleRootHash":"0x2693be415f15d91f8e3182e82e616e35cbd0164e336ad25c57d87b7acf011c79"},{"version":"0x00000020","timestamp":"0x66f4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x9c1cc6521da848ccb0b70cc240b50ee98fda552607df6330fff929b3f390e55d","merkleRootHash":"0x3ce431653512559d93918c81ecb61d9410a8e30226a5fdc135656d24a9c7a6d8"},{"version":"0x00000020","timestamp":"0x66f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7eb17a6977e2823ea01981548b46a6a2e312e4e115948d825d40640e1e1b4770","merkleRootHash":"0xf17a287bf2f6ce3fd3c15e987319d7dc9b2acbb6a6790242bbb06ae3835dcaba"},{"version":"0x00000020","timestamp":"0x66f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5cde7453d48d3ccdab02af6e56ff8d476c6b409f7ce2adaf026e747e8eaaae51","merkleRootHash":"0xa823f51247f9d1302605b05136e93c3b68d1e7a6d24e7df6929e8030740f66ce"},{"version":"0x00000020","timestamp":"0x66f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0c2880a8850fcd0adc642d1c0bd533e8749db5f540953932b6f020599ffa0016","merkleRootHash":"0x4e28b39bc6e2a3aef81483377ea60e1e9bcc837fb5d1515b7f8ef50bbd7c0cca"},{"version":"0x00000020","timestamp":"0x67f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1aef527a6d90870d4153f83468ffd9b4f1906df9e05020168a866650dc30eb51","merkleRootHash":"0x0651b20a00d6cdd3b2998c120af2a8fd44302b2595b93cd2efece8f389c230f4"},{"version":"0x00000020","timestamp":"0x67f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9fd1697d73bf20fd4fd8f2fbb63251d2b8a1666999ccbd7fb0e28ad7b4ed114d","merkleRootHash":"0x4714c091e62ebe67d1832c99773de69cb8aa3a1e8426a9b24945b22fe4706ddf"},{"version":"0x00000020","timestamp":"0x67f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xee95016da24fab0ee52559e4f8787a51fa794738c267219312f670684d963b42","merkleRootHash":"0x33a99ef48490a42c8f26c2d59ebf778360c5a987877ae57c59e83126e4d1c845"},{"version":"0x00000020","timestamp":"0x67f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7c3f6c203e7a2c5a1e4b14c5c2b72c1af527e2e148e1fa7a82b4a1a9f5c7bd75","merkleRootHash":"0xbe7b2d8efe02b0bd3941a09d6add834ad206d1f0961f17ddc1b6bb2c04bcd2fa"},{"version":"0x00000020","timestamp":"0x67f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb6fae438ab31c3022eb6706d424de0110bacce9f5cb5e96b4d6b7ea6baf0d238","merkleRootHash":"0xd964e09bb2c5f9dcba6a3376f731276b945a586917c42ac5b74af7ab9432edb5"},{"version":"0x00000020","timestamp":"0x67f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xaf7b0b5e457da11dfb75c7d6b5ef39914671d702a2912e45ebbb80a00dcf0537","merkleRootHash":"0x16d9703bc301fdcd8dd72abf49860a90861d4ede4f7d9bec882c54faa8e0bfd1"},{"version":"0x00000020","timestamp":"0x68f4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xd08e08f3d6087c937deb0c4b375aad017d74a0457b36942467dc1a1613f6e307","merkleRootHash":"0x478829a238ec264c8b880281b6c4259d161f020bda64bfbab2ca97d0372812dd"},{"version":"0x00000020","timestamp":"0x68f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x14c3a9247c00f94bdbb46e38524875e6ad67d40361c4f48e4fd066f8fe08eb07","merkleRootHash":"0xc47d4705e7d47641d7a3c5e1542b0441d2a2b24c12fb6dc8db0f7e6a86c969b3"},{"version":"0x00000020","timestamp":"0x68f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1a051654b35bb62ab3dbd7bc3e9afd27c84060a91f28741a16fb00809f28047b","merkleRootHash":"0x9e9fdaf46cc5e635eb75ef09e1eaef5d2b730a772cead2cfea569e2f18b81d07"},{"version":"0x00000020","timestamp":"0x68f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe32bd6944ce39cecc11885f82842db8d86fc7333ec4f0436f662997b5e20b118","merkleRootHash":"0xd55c83b91c152c36153e6de648d21e9f674d81f5d2e0ff25426acb86b811f304"},{"version":"0x00000020","timestamp":"0x68f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd2939d477feb3772943ba2c0a3cf2a0643e32907fc977b119439e7e068b1d47c","merkleRootHash":"0xb18d28e29a5ccaf4239d79f4e372977bfde2ca9592319d636846df429e85083d"},{"version":"0x00000020","timestamp":"0x68f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa88e06dbffef32086c2a8c5a2567d8a71367d5e33004f1513f73cf6d8531a710","merkleRootHash":"0x737b5c796022faf1a7cf5c7d2ff024dd742344117bdba6bb8b0b68c158d1eeb8"},{"version":"0x00000020","timestamp":"0x69f4ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xa63d298cc291b726ceb0d7c64189478cdcb15535a789a121720f14bda4936c2b","merkleRootHash":"0x8bb7df2ee7639a98dfe4d4f821bb8f423254f8a1c5a6d58c603965a553bcd638"},{"version":"0x00000020","timestamp":"0x69f4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x19c95a837c895d424810f6f260e956c95c05abc2fa612d8dc69a4406fcf3971c","merkleRootHash":"0x0455627a2d6cf2432708765bc299385b9d6adc0ef68f3dbb2a39dee267a65c56"},{"version":"0x00000020","timestamp":"0x69f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x432ccc13097b1019a1ff9802192e6bb40edb2a7a56e20b8444f472eca25d1807","merkleRootHash":"0xc10ece96a5707650487a4cfe8e73eb6a08e5ee682ec6e1e289bad54a572fffc5"},{"version":"0x00000020","timestamp":"0x69f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1c06bf663cd02778826fe6be172349149de3823cba6a07cbc401c75be3f4f841","merkleRootHash":"0xd03e5f9a7b48213b6740e24432c52bf7fc7bcc0f039d0727243cd07c8454acc9"},{"version":"0x00000020","timestamp":"0x69f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xba7ebb35e82a2aea3d36d40817db97a57317aa3e54a0651fe438564abc33ef1e","merkleRootHash":"0x3b03d469d6a844b44d9e9d98e23187a347711c3cde5257892be04a561f5ff944"},{"version":"0x00000020","timestamp":"0x69f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x765da73527244b12c53c0e11800b6e06e93a9fc3a8fff9800ada7e706da37d15","merkleRootHash":"0x2dba8dfe40fd0f69df18eaf6f3ad5f359888749c9b9de9f5846fc13139c4ad74"},{"version":"0x00000020","timestamp":"0x6af4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xcca3b1c3fe4447833e899821aefd8bc22fa741f161d1a0f689fa8e3c79e69c2c","merkleRootHash":"0xb6f8529b6ac06378bbdda2d9f48f0fa1723c022bf9f237ec0483b493269d7728"},{"version":"0x00000020","timestamp":"0x6af4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd17ce681c0c50652784168158d67427b689a08105e19ae63c46bda094813b23d","merkleRootHash":"0x4832d49f5eaba41ce7d2bb82bec0caf77d56995b3632c079ed84de251fae9390"},{"version":"0x00000020","timestamp":"0x6af4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8a8eea78ff5ceb8d27e9304c781ee8af03f4912ccf44ce52993668c577ed236b","merkleRootHash":"0xc0cf963f4817c42744015f27daf671fd1627af24d8a5e79b5310aa4f10842079"},{"version":"0x00000020","timestamp":"0x6af4ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x90507edf63e182e0a51dbc4ef5ade4f89d2744c28b284f8c965d3c7023a6c62a","merkleRootHash":"0x2dbf04e090c91a0e9c6da179b086c270e82d491eb95dcba222b176eee1838694"},{"version":"0x00000020","timestamp":"0x6af4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x95824f8cddf19b71eb38654346c14282b791c3880bd9b0440f6553828b958835","merkleRootHash":"0x33ceb2b2c6f7972afe48a90edb2ba4058e1c79b687cac968527953274638d915"},{"version":"0x00000020","timestamp":"0x6af4ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xb03d03eb56f27fb44036099f3b526e66b212f61340031aa4681a6702c990f044","merkleRootHash":"0xbad9500da2e9bf41b77cc402db290de8c4681b9a55b5518abec6169598335492"},{"version":"0x00000020","timestamp":"0x6bf4ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xba986b1f3ff211e9c0d7871b089f92bacc1f67c68bbccdcfb8a5ec6d5309257c","merkleRootHash":"0x40c3abd6b6fa97da95333a7011a02f2df3a6959293dc2d75a9fa312028496a0c"},{"version":"0x00000020","timestamp":"0x6bf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x499a797aa43cc47b4abed411beafaee89c3bde245400b82e7c9f55e353361a1f","merkleRootHash":"0x06c59c7dc5d3de20e0fb5c710fe83bc68c5788e45d512ad580de7a9b11f02c5a"},{"version":"0x00000020","timestamp":"0x6bf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6b35561140e20759749948fb76fdb6ad7d75bc89b052686df2f521d1bac8504e","merkleRootHash":"0xbe7f4e3677369c76fcae80086e2efdc6d23fc4a24d8bb66ffae4395f133bab98"},{"version":"0x00000020","timestamp":"0x6bf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6c7ce602e8ca46831def8cbff90e68d31d5fdce2f778083c1685375ccb305a27","merkleRootHash":"0x6f0cbae181409249c797ccfc45e84c28541f9948ce3ffe039781190ef9b5a923"},{"version":"0x00000020","timestamp":"0x6bf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc23598661b9c11d809b3dc990faa65c12ca89d23a704cf599940789644e6b342","merkleRootHash":"0xe60517b4b4588801414cb82b8da981cdd1765c3299a081cc01ba73e03d2fc494"},{"version":"0x00000020","timestamp":"0x6bf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3867e8772395cf18d2809c3d4827d8700ca5678d6d561d0c2fd403b7fb007a71","merkleRootHash":"0xf58ea69cf8025a29725db82deba5d5cb910e4bd0586a5356bbb875a01e82c480"},{"version":"0x00000020","timestamp":"0x6cf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x099efa3e4932382be137f94782822b9717f4127c257094805c146ec7e7ce2002","merkleRootHash":"0xb7f20f1033f5dd7752ce07670447c8fbde4511576bff206ed0a34bc58133b85a"},{"version":"0x00000020","timestamp":"0x6cf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x27047e21afc0061a21b4200bb7d19eb38613447072a61f40e15da8819b264f18","merkleRootHash":"0xcb4ee3122582dffc70d33d7f4680ded0b9c736e0da6532405f4eb07b9df327f5"},{"version":"0x00000020","timestamp":"0x6cf4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe73c0c085d502dbd27f72d742cf84e9eceffa6dcfcdfb1f6b73e51d6e9af7f7c","merkleRootHash":"0xd3063bdd08927604ebb4248186fc23ae49e6ff1e5e367508aff8f271823663a1"},{"version":"0x00000020","timestamp":"0x6cf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd364a3d22d965a1f24489c9ddcf5c7f874ba785a4ffafd69c71f0d8292d5d408","merkleRootHash":"0x601552b34ad5af1bb1ac8c67f9224b5f56a63e3532811da181c2fbeaa4498b57"},{"version":"0x00000020","timestamp":"0x6cf4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb349b1c41ef48b050ec92e91a3f6c426f577c8e1873a0d683c40c4cd81308347","merkleRootHash":"0x03b8e5306458faa57f841d0b69635e417d8880a0fe8a5a2ffd1f278b80032f03"},{"version":"0x00000020","timestamp":"0x6cf4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe444bbc1d07417a8e521a748dbcf7229d70dd62f520148b12e5a0d39929d1e79","merkleRootHash":"0x508f931522a37bd5503522add8fded34449ecabc6004945bb8a7486ade86a3f3"},{"version":"0x00000020","timestamp":"0x6df4ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x43a387d1d683ebb4e7263f8ea29d072ada10354ecfc92070272ab004ce92312f","merkleRootHash":"0x674f7748007608dbdad0b035181ae5684e99f5a1f9ead221a65609d13e2d2f63"},{"version":"0x00000020","timestamp":"0x6df4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xb34c06d93127e0874d7031245e502c3a8b76e95561b7e908a9a89f43b0af1f3a","merkleRootHash":"0xd6989b1bced46a42406b04ce4bee3bbd1346778a0d30bfd61553319547699f3a"},{"version":"0x00000020","timestamp":"0x6df4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdd7c390bcd5fa3094d3bc28a57329ba5d52378ab64db2deda6c1470b8d7e3d15","merkleRootHash":"0x9c1b592118ce944c4911b8aeb7dc0c6b72a22a90ad38d7eed55cd6e259025a94"},{"version":"0x00000020","timestamp":"0x6df4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1a81c17fa2873ca5227490c0fc4f598808ff9422ce69d9f61d9830b9a7b93e77","merkleRootHash":"0xcf564e450ed5d74615f91952f17896f3cf11d42a8babe55d87d3fc4f746dbfbd"},{"version":"0x00000020","timestamp":"0x6df4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9c82733faebe414475551a1ec2d6c19c494471ecb583696d957b688ff094fc71","merkleRootHash":"0x519a62861f97d7ce5a8eb967f23102df53a2b5e898674fc56a01124acab3ad34"},{"version":"0x00000020","timestamp":"0x6df4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8d365c597f1160b055d163af84a59a34483fc3d8c601dce7a6c1244ff4e4423a","merkleRootHash":"0x68cf59bcd9adfbdaf056700d3d3d0dfd0464ad51cdca706fedec55fac6d60125"},{"version":"0x00000020","timestamp":"0x6ef4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa0dfebf0f8910f59fa35045d40a2c7c5b00c9cb3f52cdb6b59ecedf0b1814904","merkleRootHash":"0xb24bd296012b552e56a013c46e2ae2fc5a361f5b12747de59f471e2b43b2b7e8"},{"version":"0x00000020","timestamp":"0x6ef4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x934d3b6545ef952713ffd942e56253e73fa1c4694767fcede8e1a1e02f5cc374","merkleRootHash":"0xe52139548f437aae3bce0bac60653fd1085c5d3ac9f82153056a0689fc5e1fbd"},{"version":"0x00000020","timestamp":"0x6ef4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xacdfac3323f39febfc2861e4607c0ec8fdd27d38e668b9a9556c9e81a2f06e1a","merkleRootHash":"0x67582e1aedef98fbc25cb02037579c3d0a7557e4c6de8fc05b292fbdb601cb62"},{"version":"0x00000020","timestamp":"0x6ef4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x399ce0fc748fb2a2aad756c05e9c6603a5e65825b59b696190630971d2c54760","merkleRootHash":"0x9c3026a04205e262cd1be114cdce818821da837137bc6abdb73bf5d0d4630791"},{"version":"0x00000020","timestamp":"0x6ef4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x36921f46a4f9e246796db0866dbfa4644c12c66325d97aae595740142370305f","merkleRootHash":"0x2708b525ef50aace00869e8a9b2738c8b3515959f84f69760c973dbacd1907f5"},{"version":"0x00000020","timestamp":"0x6ef4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcaaece2d01c28f89ea12166ca32a3dba0689e686d47013951cf1135a81e4c851","merkleRootHash":"0x3d9c5008084c321bd7a957b852b23e37ce43cfb008bcefd592b423dacefd7263"},{"version":"0x00000020","timestamp":"0x6ff4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1f6840c8db73478d25a9215337ff8319d4ab0ca5dbf6691dfe856eed2afc645a","merkleRootHash":"0x99ca1223a63e9b11f52c630372b5ec964a1f8e733bf187d33ba91ea9a73cef63"},{"version":"0x00000020","timestamp":"0x6ff4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x08d33069cc9eeaf8796d03ae76fc4d639811c42d44e88f5579097c599aa4617a","merkleRootHash":"0x3b9c512c34bcce21f04500690ca3740339d7be2394c1421f5d239fea3580d91d"},{"version":"0x00000020","timestamp":"0x6ff4ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xebf566904dac98805acca26f0d7f1815d8812ef82b226872b2fac91c38d94c67","merkleRootHash":"0x708d9f1854d098dbb3d641636c04be18da58aef31368fc43a852ccbcbafbca17"},{"version":"0x00000020","timestamp":"0x6ff4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x111668055dfe2f0ce62c28450356f7387af35b27a638f6777233eb67ce3d8f5b","merkleRootHash":"0xfef698675dd76e3860f2410e98e49532280705b64d74a73c3b0c9d298b139914"},{"version":"0x00000020","timestamp":"0x6ff4ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x619844c25612a168e5257e77ec06fa60cc0fdb248caec641971413d3318ec42d","merkleRootHash":"0xf5ca5c61cf7f79717cd12981b55534286faa6943ddf8ffcf872fee69231c665e"},{"version":"0x00000020","timestamp":"0x6ff4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8d4ff39240301766d9d48ca5c26e385767958534a55f762772094fe17b9c2623","merkleRootHash":"0xa23b27e2ba668dc76e03217befd03f7a3d084c5d2ab16ff855275b59effbf7d9"},{"version":"0x00000020","timestamp":"0x70f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xaed5963ed397258e8afc5afe403b0d28e7a021c7b6fbcd3608c02047069cc66b","merkleRootHash":"0x9d317d65859a34f0742b4797b1816204e0ca0e053c3a3cac9f6f4758a5df636a"},{"version":"0x00000020","timestamp":"0x70f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd42953924dc7ea13369a1d1b7e6e2bfa9c91abcb42e02cc0dd499f20467aab1d","merkleRootHash":"0xa4dfd6125d59d4c6be08af82a4ae31681b9e7b5c9542fbbaddecb901dad84b7d"},{"version":"0x00000020","timestamp":"0x70f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3af7b9bdd3433d98da08f75ea670fb465ad50a7b7fa421c1cb3947d5af9c523b","merkleRootHash":"0x4896c9f531ed6dc3226e4dd0fc8660e72b8e10fa0860552a5acd71a438713b76"},{"version":"0x00000020","timestamp":"0x70f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4f2a028c60621aa325389a0e9a87fc288a4cced295e0c2ac8235d0306c323f56","merkleRootHash":"0x612b9fb0366382d74148fac01e107040cb421a8ff947f9ece7e533478e492ab8"},{"version":"0x00000020","timestamp":"0x70f4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x4bc172edc826a3bd99e7600d90aa67d632a4d246721b9d25fa409b2880cb6273","merkleRootHash":"0x768e6fc81ca9185d04721d4ff42af176c4bc09daf3e93bca2254c4ff34546657"},{"version":"0x00000020","timestamp":"0x70f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8be42057b74522d4fcffb1062203c6aec4f07449ed3f6a9d39742bcd365b893a","merkleRootHash":"0xab3c1fb04cd03a0f295f5529ea67553b8a354e7745821b122edab531953445cc"},{"version":"0x00000020","timestamp":"0x71f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8f78d7a9f0ac6ef368e1391c1410e843bf0fc687313f8639a8bac49b21b3c44c","merkleRootHash":"0xdc8a64124cc276cbf492bf4d1f915598fb75f5b529f1d0abf58ec4b243a07529"},{"version":"0x00000020","timestamp":"0x71f4ba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x712e1609160c30c38692ef4a1b30507103390a4361a8d3d45ff566ea31336d05","merkleRootHash":"0xa72bc0836b5beaf1db8c83b1eb62894822c0b7b07f8fa7f8057cf1461601599e"},{"version":"0x00000020","timestamp":"0x71f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x07d344dcad5045bc846cedd43974637243e395a96eec877bad37eef227cc0561","merkleRootHash":"0xb63d37d01b94f06c6cf33a17fa1657e751f8e0fbe656326279be0361496de2fe"},{"version":"0x00000020","timestamp":"0x71f4ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb9d021abe638b93a0ca633bb4a63d2046dfb21ca7c0612c60fdd429df8d6ce45","merkleRootHash":"0x162fdb6b408b2d225bc7c4399e7bb69970151f0d08422b8a8b8dfa602f5e7983"},{"version":"0x00000020","timestamp":"0x71f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf441e9ad6146f168372c9a2618c6b2ed4c77647ea0c340a746e823ecaf49f837","merkleRootHash":"0x24598599fd66deba071362050445a61e4ca00826ef956311cf254c84a41deabe"},{"version":"0x00000020","timestamp":"0x71f4ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x32c0ae984dd10a63edab9377b073d37d84f904f2feb922d39a56fc3c3d5c3254","merkleRootHash":"0xee380d1be8864647ed8bc03a3cbba3ffb02d540925f08c92071989c9e0c937ce"},{"version":"0x00000020","timestamp":"0x72f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5e7758e77a720ed8b5df804650d90081e1f323077f118d48d453f825858efd1d","merkleRootHash":"0xf1b672712357f2c916994efa97cc1f8bb6f89c3aec4b576adf04cfa99152ed6a"},{"version":"0x00000020","timestamp":"0x72f4ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xad7f324b7de41d0342f6166c379ce43c06258914d99f004c84ca1080700a191b","merkleRootHash":"0x81d230ea2d1f30d0484ad889c90965505f7ebaf9826294ce01e6dde692568d1d"},{"version":"0x00000020","timestamp":"0xe8f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x5f7820c8832c17b310c4e1464f6272af4d2b44d1105790c2e79ee7ecaf714209","merkleRootHash":"0xf293bcc6aac15634021045e6a0e856a05d8aa43b705fee725fb7d499147a6c83"},{"version":"0x00000020","timestamp":"0xe8f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5c88cad6ca1aaa0bcb581cac230d1001bf2cbd13aa7e4dbfe926150e6adbd948","merkleRootHash":"0xb352b2d2bb9a2a7f1feb0883ab46b6b94e6b6abd49f0ca20800016ef131d389b"},{"version":"0x00000020","timestamp":"0xe8f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9073307ad64bb773938196320af31986284e1c46adc748539a55b1550339db45","merkleRootHash":"0x40e6cbc2274d5538d1b54a16ca726e9413157986863de0da63c1bc96b2c6d1d6"},{"version":"0x00000020","timestamp":"0xe8f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x48e24942f98b0fd42ec549a0a54f6992daa3209f069c14d8e90830228b870d69","merkleRootHash":"0x949793796789187dd790f4348f640b07193165ff80f7c48b8968ac08741a9b30"},{"version":"0x00000020","timestamp":"0xe8f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe90e7e7eef4c8ecb716ea02b71005ce0f27edb9845876e28d0af1743e05d6a40","merkleRootHash":"0xfcc018aee679002bf2f591380b7bd71a321c50b546aadcfb8829069605a1950d"},{"version":"0x00000020","timestamp":"0xe8f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x9a25ecfd250fae67c2201db0b22beb62b107f67d6617a2c69163dd8d4e24a656","merkleRootHash":"0xc06f8f54ee19a43d511c81d4aa55b92760898fa31b6f90c9ccb468dab514a1ea"},{"version":"0x00000020","timestamp":"0xe9f5ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x84adccdc1074773ebff05bd1ab80bb568486a60c4efbef4715dcbd1d0c442250","merkleRootHash":"0xf5321c248e5cc6fb30bb93596a5ed2065dff51ecceb8ce12f7aca6fe10538210"},{"version":"0x00000020","timestamp":"0xe9f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6428cf5e7db9b51971a37b852245fb0749cc944f4b7ed12e4a8dee252eb4af29","merkleRootHash":"0xd4b5c1b0b435bb4a53890a2f12b48b5e6a0505151c12c1d3022651dbdecfc935"},{"version":"0x00000020","timestamp":"0xe9f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2e969ad4320438fff7f937bf8789c97295dcc7a7396b3f63965d9a2a1e1f2c45","merkleRootHash":"0xf7e45cc1c648f384c46e65c49c597ba0b6990311eb67090903284ab75fa71d0d"},{"version":"0x00000020","timestamp":"0xe9f5ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x3d9d94830529005d283ff15b06f459d4e22f02920e277067dc256ab3c873ad7d","merkleRootHash":"0x2d9e926a11257988a90e062a9a04cd986e14ea6d633bf24d486372743f3fcb13"},{"version":"0x00000020","timestamp":"0xe9f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1491d6e3e278565ab87c65488922379f4a09f68679326f657c72c041a0680a64","merkleRootHash":"0x15388a80a36f9312f2745a653854293ac76c07f6bdf11c54a256f59ed79ba2bb"},{"version":"0x00000020","timestamp":"0xe9f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe4bc0cd5a6399e38b95c5e2b7ae1407c654530676d723e0745d0fe56c5960b27","merkleRootHash":"0x463b958acfbb4dab2d81f4f7ee04dd408648e69c7a07482812536d324ffd5fd2"},{"version":"0x00000020","timestamp":"0xeaf5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf9e01c4aa7c9520bfc53ac90dce2cc8f46e16ea7aa003a937d7f7bc7dbc2af33","merkleRootHash":"0x487616b1193d1cf49c675f9a02e74e932f01d0dff61efd4d26b6ce09b33f3968"},{"version":"0x00000020","timestamp":"0xeaf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3f6f57333079f8162001dffe8ec7ee0101cefd353c25d61d6483ea6cdd4d8c37","merkleRootHash":"0x5e5334048f225cbd00779d706cac5b1115cedf2e44710c931dad5535c0cd2456"},{"version":"0x00000020","timestamp":"0xeaf5ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xc827a9b21e210e25cbcc346128225d79672472a428f64fc962e7025d7a981b67","merkleRootHash":"0xa666cf8d9439a1b6ece049b694de8fbe3568b13e8e31f32528133c2ecdccafd6"},{"version":"0x00000020","timestamp":"0xeaf5ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x43e8b792fc0d7190209de5c869e322b4a9e37909bca88887a8c110fcd1927847","merkleRootHash":"0x5289e80cdc0117be99ef50c04e98116b9ae4976d975b9802356ba5c4d90cc640"},{"version":"0x00000020","timestamp":"0xeaf5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x59c1b2ae5bd3b7025356e599fa8fe16d1b36fc6044d18663dc871a1987e97312","merkleRootHash":"0x7fd2ac18ea4eb70314040fc15b5163c1ca19ed8764a63f5675911c97ebf6899a"},{"version":"0x00000020","timestamp":"0xeaf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf9eaa9140374570df156dd02ad24e3d084d6aa14a1a29bbdeb9f44d7e067ba18","merkleRootHash":"0x9a7fd3679a62a5ad3c0ba991b7c98161f16ab175d6712faaff02d02aef06525b"},{"version":"0x00000020","timestamp":"0xebf5ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x821ffd6f2998e1732f9cf6b5b57e9a66a8e2026b3b41bebe8a0ff4ef07d65e15","merkleRootHash":"0x7a963e01aab40829e3dc1749a20fef73830d146b596bfcf3b1e8524746442eca"},{"version":"0x00000020","timestamp":"0xebf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x08e20d32462d352f799c70cd122d465750987a112e573ec00eb05b7c27af5b01","merkleRootHash":"0x33ddc0372182de9ef2c914050ce60b743b76b53089fa1e139aea630675a3ad7d"},{"version":"0x00000020","timestamp":"0xebf5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd17d68a6242dd2ac41d3298c69973987e6804c59098ec079f39f52d0e7ecbe19","merkleRootHash":"0x53f69f78a46d5a9bab3f38980cbf90b9324cd485e7742ddd97b2cf24aeba6aaf"},{"version":"0x00000020","timestamp":"0xebf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5a2e2ed4a84682bd31ebb1d49e17152971f867ca6cc1f2530fa1a329b43f072e","merkleRootHash":"0xc13775c9ed0986e8be1e47807dcd050c8aeb506d8d979619c53dbc00d18a5b47"},{"version":"0x00000020","timestamp":"0xebf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe0c59e573e83e042c612431675b9168d3912431e2cb37e7a40f1515b607f2163","merkleRootHash":"0xe1d89caa35c19b6280c186ed788da936f2916008b8b1fba21225d989276cc19c"},{"version":"0x00000020","timestamp":"0xebf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1cc5273721bf55ef9f00621c23eb153777676c89ed8672f5e751fbc52b5f445c","merkleRootHash":"0x9470548895f42454564e98646ea48d9c64838b6037943a6b5e21535af23df15b"},{"version":"0x00000020","timestamp":"0xecf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x1b7666361e15d198fb75555f5c67794503288f2905d4595f82860bbd77671d20","merkleRootHash":"0x24c41a65a1e35261277234c1fd04e3d6ca16f429523bc2e03a6c45a7a2c35ed5"},{"version":"0x00000020","timestamp":"0xecf5ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x89e0b8fe97d317dacc188874ca6e49b7f202d02b7619e9a748da31f548c4534c","merkleRootHash":"0x7aefdeab10dd5ab9dbc69c7ec11a0bc34c614e2a1f1fab528084ff55f96e47c7"},{"version":"0x00000020","timestamp":"0xecf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4d3837e06831f209f586adf80f5f574dc4edffa241ef66d411988b02b5fb9e50","merkleRootHash":"0xc6d20682514deed7cc95eb868e0441db54e1a28089a54d5738868299015f2d93"},{"version":"0x00000020","timestamp":"0xecf5ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x61713cb6d6f268b340fa710bec090c8f07638ac250cefd263a1a671580ba3f47","merkleRootHash":"0x24a7674b30de766c06ab71559c49357eef1c104d323147a748e15bd5aec7c148"},{"version":"0x00000020","timestamp":"0xecf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc0a9bd091d817a31e7fb29164fad53a60f5b007d04f54a2d51dee7e9415ca867","merkleRootHash":"0x155fe4319566fd4af53abee239d8d65401c53e25c08752bcaf40f1060ab29f86"},{"version":"0x00000020","timestamp":"0xecf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x14a5436ab83c1a774e7cabe23696bcc5a8cf0bc68fa0a5c433b1d9072822e22a","merkleRootHash":"0xeccb81bca8bcefeff72b4338a318250cd8a9529e67290ff6ff65d07632e4d98a"},{"version":"0x00000020","timestamp":"0xedf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8dad45c1bbd69ad5441859d263c51c24e6366424a770ed5de87de3ccf44a9d1e","merkleRootHash":"0xceef5a9321ddd567a3a36d2c3b02e77020332e76e3e2cf7fe7b49f209cf65115"},{"version":"0x00000020","timestamp":"0xedf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdc8dc2e644a239bd6e6834174b103fd46d58fd08acdd94c846b3dbf07da3d058","merkleRootHash":"0x4a39756c3c2d068782038df4f03d8611fe9392c90eaa860c7a450fa31ec7879a"},{"version":"0x00000020","timestamp":"0xedf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xabf7c257f0ed060ae83d4129e5d588c713eab9296970481798f7badd67599048","merkleRootHash":"0xec24904a8bc08aca12d3b91289d3fb822b61e8e306c58fd4ea763c2ed76b09f5"},{"version":"0x00000020","timestamp":"0xedf5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xa394b3a70f143ebcbce9fa240df8bb0da1f3b3ec9d1dc99afb548dedb0e9fd4a","merkleRootHash":"0xdbee466465586eaf3fa8e7ef9e00db5b7b02ffc7d09beda00188015b1bc6ddb9"},{"version":"0x00000020","timestamp":"0xedf5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7ccf08b6f84d79051ad1bea99bfc0b1cdadad568d6eef58534c7adbbc2d9496d","merkleRootHash":"0x3e096592430392e206499053bbc3670722b2a16128a6476cb2788c6047670852"},{"version":"0x00000020","timestamp":"0xedf5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1fb1debe237c8e2fe090e3f6c19119a92a4a90d51fb7c36fe47cff22ce7ad032","merkleRootHash":"0xc750545004bdaf7e9ea4a74bc7eb06287bb55c579ba5c9fd47169b7eace8c434"},{"version":"0x00000020","timestamp":"0xeef5ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xe1234fb6bb9d33c640127d71e54d1508a823a91362bea7993e1ae8ddccdf8f5d","merkleRootHash":"0x92c4e3761cba836b4257d477ce208e374161415b9aae7ccdd020b6ef2d014dc8"},{"version":"0x00000020","timestamp":"0xeef5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbfeedecc40d36d0190960e22b4166edaf983ff8ebab986470bbb0dea78cb0c62","merkleRootHash":"0x8d5d8a93caa7623dfc6f875035ae223c35c90ba550fa46c1d05e7c4f75692f4a"},{"version":"0x00000020","timestamp":"0xeef5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5fde8bbc1a1e94b1108732eb17edacf5440a41cc9b4ab31bc3613b7f8738ef78","merkleRootHash":"0xa2df072b5d62ecad5bd0ddc77efef411e6c571ebf0d065d067f238772a658549"},{"version":"0x00000020","timestamp":"0xeef5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x0bdea0cbbe2ab622154c8c3b0385c50e8ad7cde11a3c73c8b3cb99190f1c1d11","merkleRootHash":"0x2d3d609298215e7623333a9f174243c529abab050e27be305f34bea635e0daf1"},{"version":"0x00000020","timestamp":"0xeef5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6c46755441801783d7123e6293fde3ea023bb06e69dfb74a5d23dd25c64ddf09","merkleRootHash":"0xffc06a762d6d23352c3ad43cc96d2c213a5f396b4baba4e241a445fca837e471"},{"version":"0x00000020","timestamp":"0xeef5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5edfda929aecb713f3b7121126ba2ebf871ececc75456dd1112f28ec64547655","merkleRootHash":"0x5983fb3ff5794b22c9f73bbef0929df5473df6a49659100e0632f5f531d7e8f2"},{"version":"0x00000020","timestamp":"0xeff5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa1c58b8b7c5693c922f2efba1defb9f77e52e7852559e963015b9c850b57483e","merkleRootHash":"0xa45406b3bf7b835bd735d20a7dda374198c9dc11b1c6c77fff19934bd3169dc8"},{"version":"0x00000020","timestamp":"0xeff5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb00cb94a415d71fad898d490a978c953d1e765a9e6f076b83d7cbb32f6bb8616","merkleRootHash":"0xa43e1440c847f1a8a9d4c327b8f564d5fdaa137c1f8ebdd1d128d39650665fbb"},{"version":"0x00000020","timestamp":"0xeff5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4969fd4250b7bd710179468a44fb68483a24228260ba189b9f293bb86873e67b","merkleRootHash":"0x97f45ef260ef8e7547c224a2c6053ff2768f1a66024cef42b084ecae021458b3"},{"version":"0x00000020","timestamp":"0xeff5ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x47ada8aa8ccbfafcf5e32251be3fa7e02aff6fb1cc434be39970d7bf7135ae45","merkleRootHash":"0x0a0ecba2dbaeb7969c0929f7e4545993e58f00b74b2953ad1cf327c5dcd66897"},{"version":"0x00000020","timestamp":"0xeff5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xce2197bf8b0723ef04cc03d765c91deffed8ce7d1364af2c554c1eb8c8bb7f18","merkleRootHash":"0xe0a3cb1676faff021d3ef4f58113e90f82a88f18dac6e3e4f1f96cd319f4dc23"},{"version":"0x00000020","timestamp":"0xeff5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6d19c3ce2c17eeb024720ad3d5ba88b68b3b92052cf263aec52c5dac3fd55a78","merkleRootHash":"0x60cd1f90570403395a6293030c54f5fdd4a1cf5bbb519a8d80e3a0180fdab3dc"},{"version":"0x00000020","timestamp":"0xf0f5ba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x6ee81d8fc6a3e95377afcd23f913c4b47d03878d937acefe499357e12eb51068","merkleRootHash":"0xbf83b0c5be5a905496cd62fd6f7d52aba4389903c37739ffe8086e28d7394271"},{"version":"0x00000020","timestamp":"0xf0f5ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xbf35aeacf3b02b1aef88e82db1539d04c29675e3d1c4bfc82be0d5e3a281457f","merkleRootHash":"0x252f6fcced443550ae31f0715b5c72212347a3c413d36bbc9e948e7e19874c66"},{"version":"0x00000020","timestamp":"0xf0f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x58b968d8e068a01a618eb29bca1866f29333219c0bf6937aed7af1699d0c9e67","merkleRootHash":"0x68d9a45343ea74b24c6a1978006fa404e02724b61e9cd4ebfaede532742b42bc"},{"version":"0x00000020","timestamp":"0xf0f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd7dd528c8e9f85895c96f813916c12204ed40d52fa3bf9493bdca8a2af2d415d","merkleRootHash":"0x181109f8908434a337feba134deade9eaba6da61a302075be20238bb72e23a81"},{"version":"0x00000020","timestamp":"0xf0f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd24555991c7a795315ddc48567c7fc3881d23984832a2054ec769129bb5b265a","merkleRootHash":"0x7dd1ea9662cbd800868fa55441d8d069f78b8fa771b1dd0062d97d52334a148f"},{"version":"0x00000020","timestamp":"0xf0f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9e6890872199f3632caa98b7da6dfbc4a66afd45c303f9fd31f9123a3fafd274","merkleRootHash":"0x94609b9699a23afb1857f42e1662dc71d1f469d7c662c186e2e81f1cf38c0ffa"},{"version":"0x00000020","timestamp":"0xf1f5ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xb3850afc77860d7c46ff27ba74353959896dbcf65eec5f43997a38da3cdf8e12","merkleRootHash":"0x73364733cb95dd147682ffc214676325fb6ed341540a1a8ff06da0e5fadd16de"},{"version":"0x00000020","timestamp":"0xf1f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcbcd61451112658ab1e8e8372f6d4a45b924df8b0b76993d5fb3ea87e53b775f","merkleRootHash":"0x85260cd9c01d8f54b1d4bbf764ea21d0326013ef4fc789aa29cc501fdcdc6515"},{"version":"0x00000020","timestamp":"0xf1f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb3a41c4b78445cddee12ec8fc8a3a4f89db36a510d1d46d2e27c7b19079b502e","merkleRootHash":"0x46a2ca2b402b21dffb66c2540978af3a3bd34554020fb81c687ed16dd5476b05"},{"version":"0x00000020","timestamp":"0xf1f5ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x838f28d1574a59da25dea4aabc7c38fbebe31d2739720d8c4253d4755a305e48","merkleRootHash":"0x486abaa4a0592b21cd6063785c0e73c8f62d8eb73acf80c7ac91c9914ba05842"},{"version":"0x00000020","timestamp":"0xf1f5ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xdd7af7e9a892a9c24a14380dc8c03cd7539f9eb90deffeaacc08708c823ca576","merkleRootHash":"0x709813f8619a1a9e283f71c92314c7e4eb0a3fcaa0ced7ebefc54de6448f2c9a"},{"version":"0x00000020","timestamp":"0xf1f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xef1397f5df9a2c57f65c8aca8f9a97bc5906339e17278249e82854c03d2d5e15","merkleRootHash":"0xcaeee8f1880601ecfeb4cb4eaae1247271cc88d735436df0a900927eecaf3419"},{"version":"0x00000020","timestamp":"0xf2f5ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x98538bb7abc4ba4ec2a924e7178477807ad62e27604db27559a5aff258ff8b2f","merkleRootHash":"0xf94fd8904c61dff6436c22a61ce2d5859691357be8c5aa4138a914da2fc3f786"},{"version":"0x00000020","timestamp":"0xf2f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x757d861d29e0b9e4ff4b1ddac70425928d89f80d3c0ac82605c09ae8d67eb902","merkleRootHash":"0x1db6e360cc9ebcf841b0903f7bf86cf6ae82ad9ce5c76fdbede5e7759cd58cf2"},{"version":"0x00000020","timestamp":"0xf2f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1be31b37c89e3d9d7a1ef8f9c97125fe66d26946b7384d5c4e9e996ae9de0717","merkleRootHash":"0x26b3188f22754d283169a8458b0adbc70f1060e2c3357513f2fefa684b941381"},{"version":"0x00000020","timestamp":"0xf2f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x60eadf30acd81a10a4f2a4ced28602823a76e3c2fc5e7c0cd8e13d4593638322","merkleRootHash":"0x88ab1fad6c4a6012711fc1f6199153d801d1bf9f1d15597daf2297d7c5584997"},{"version":"0x00000020","timestamp":"0xf2f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x54ace8a08bc5d4b6d7d3e257540883e333b7baae0b7c747ac39693f35e4af776","merkleRootHash":"0xa9c3fca2ae6dde70da48c3a79e7ef16ddf2d5f8a2ef94c4faf573bb9c2117444"},{"version":"0x00000020","timestamp":"0xf2f5ba66","nBits":"0xffff7f20","nonce":"0x07000000","previousBlockHash":"0x2e733cca4dca22387acee3053e6cf2ced82df6941e7bc87964e47de8cd8c1915","merkleRootHash":"0x31a78a5cfbd38d0047ce2aaf5dc64f52f84566c8a5769c8bf5b9e329b6948af8"},{"version":"0x00000020","timestamp":"0xf3f5ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xed7cc38dec2ae1ec90363b7a59a9b923f5b960f2da6c7372ccee975e99be1147","merkleRootHash":"0xd87bc564d07bb2cfe5444707eb9a641b3a2190645fc3f00ccb2122fad97ffa07"},{"version":"0x00000020","timestamp":"0xf3f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x67412717cf9cda458ede6e8d309cb0035a14382bb3d04a1f5f7dd6249d303d08","merkleRootHash":"0xaaaffc8263daf50c05dc065f994dfd2f4e19111e1c7f8d950a19009f03dba3c4"},{"version":"0x00000020","timestamp":"0xf3f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc32dea7b60d0db5b48fc9def033263cb170253868a77ba64e8414ca416e16417","merkleRootHash":"0x183981adf795914ef87084d2ca446820921296d2cb5ebf41267f8150f4013dda"},{"version":"0x00000020","timestamp":"0xf3f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb7b0ed388bb79a2269449e4e2c4b71e74481185d8407a7fc041eec40378efa48","merkleRootHash":"0x7933483e9c5e20d3339ff09ea5d1e39ca6f3c332ef3c4c8361bfa22e969b9426"},{"version":"0x00000020","timestamp":"0xf3f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xeea3dab1aa021d19e335e14888fbcbe76f790cd110035bc17a73c56bb12f1656","merkleRootHash":"0x94384ed960444c40005a46f4dd0efbcffbb53e3b695836da41ca42bef78a1db7"},{"version":"0x00000020","timestamp":"0xf3f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x6e73858699476ae43cb44f7243f4b671671257d7485430d056f00d00d85a274f","merkleRootHash":"0xbaeecce7af6f612b624334cd25a892fcf4235dcd363fcf3a955a7147d273d428"},{"version":"0x00000020","timestamp":"0xf4f5ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x2c5b0cabf87453e6bf3a57788855c85768e9258278480af6ba03580d0e8b8e57","merkleRootHash":"0x71904b1cdeb70104816f1cbe9f4845363f54c25945b6db265f8b6455ded6baa1"},{"version":"0x00000020","timestamp":"0xf4f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3a34c1339c9f42f0d1494ebfbc678996f8c01568617915fc2ac8d2821410676d","merkleRootHash":"0x70f263b2a025d489fda4024e7111c03fc3b0db71e638bac5b5274a95fbc30e88"},{"version":"0x00000020","timestamp":"0xf4f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb1fcd77cc91d1ae00ed09fb4b0e318be4f2d9725c39cf6b28342b74b2ec2f955","merkleRootHash":"0xd8109f1d7b8862f798d43ab4daacdedf0295600a3baa0db007f07297f03d3f56"},{"version":"0x00000020","timestamp":"0xf4f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x10756fd049bad1f96541f6caf7a162559c242b3e2eeecb9b3c8f418e0fca6322","merkleRootHash":"0xfbe6930ef111eceb03dd23055cedc40fb0a425e2d48026b2f34e06e984685357"},{"version":"0x00000020","timestamp":"0xf4f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1f5c42570ccd64980cce8e69053fcae2db07827b2ec3857aeb3086a457051d7f","merkleRootHash":"0x6fe007fd80292091df7bda872468265455a73d5e11009237123dfb60fa9f6bf4"},{"version":"0x00000020","timestamp":"0xf4f5ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x05cfa8d9356ad341a4dd4cd01b0bb53c8c6fe857b9c385dfa7a9f37f5a2df41d","merkleRootHash":"0x1b1d757142d3dbfa2dfe9acf56ffc4226495450d82fc788e83779087dcb60e32"},{"version":"0x00000020","timestamp":"0xf5f5ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4b947889f2da4f8c53d2f5faf37d9716046923769851b1d15545440c20b88b0c","merkleRootHash":"0x20fb2b5cb9cb102de7765afde0e67c6cdb712fe514c4fdee1582c48f179c6f7c"},{"version":"0x00000020","timestamp":"0xf5f5ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x58b73e7a69a8d60a9d0e0f561e6902df1ad1409a24afd20e2b5b760bf6094b75","merkleRootHash":"0xb5395f4314784d398e6ca56da33c59f518573bb8e9cb4282eca1b335d2968fa5"},{"version":"0x00000020","timestamp":"0x20f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xef86a6162fadb73d512f19e9858915edf46f7def1d0f420d384784ee1426fa53","merkleRootHash":"0xe029bc8205a10193326e6d287302dc948155972eb1d3fa57712b772d2845fd1a"},{"version":"0x00000020","timestamp":"0x20f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8c1de31588b36cdfd610cbcc1c8173c92505943956ba309af3feafe89de42f68","merkleRootHash":"0xab70276791e40d084fd7526c64f337f274834290ce38d92201c404adc3c763ef"},{"version":"0x00000020","timestamp":"0x20f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xbc96e9b04dd17fdb1367f0a06fedc06bae889cac6ac871cb5e2ac235949f6e36","merkleRootHash":"0x851b34a4a06dc6daf6701df5a493c6fcad819ab45b3e92a95c4007427c591905"},{"version":"0x00000020","timestamp":"0x20f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x250af85b1b84453939e07da71296c9a583561636159eeed51730447c8247d626","merkleRootHash":"0x56e869cff66ad9414aa3eb7e9fdc396210eddf8d0edc29c1060c3346d913fd6c"},{"version":"0x00000020","timestamp":"0x21f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe8110e5c465bf3648e34d219bcc031a73ba2ad2fa7d67775ff7936961385b957","merkleRootHash":"0xec60be20d8984b634996cb46e1b74e42cd19a42262a5d2ed28505b49c0662282"},{"version":"0x00000020","timestamp":"0x21f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe8e3a812b9f7d9a329cc4db5604ea521bd1440b322d7532233315560579ed445","merkleRootHash":"0x41eba796515010df07ad0ddb56c86f7a19aa9ec37e1c82e0d120cfda32ed0adb"},{"version":"0x00000020","timestamp":"0x21f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3973b30159f7fa72c58b53885ff83bb2d6e4b7390645092c04b13c195a826154","merkleRootHash":"0xb44adc374d590785464d9d1e13286052a3b4539bb5ea6106ed9f2b0c05fb45d6"},{"version":"0x00000020","timestamp":"0x21f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa35d7a1880e87bced60958bfebf5fc6dc5f810c71fda133d2fbe55264963cb4b","merkleRootHash":"0x11014fc165774a7d7ea9c641ac8f8383a7ff1eb6d745817ec962ec1c59d93800"},{"version":"0x00000020","timestamp":"0x21f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8c10581bfdc7743d4bec8cb741c8e3007b83cab1b412cd5d491f57fd6fa8a638","merkleRootHash":"0xf0d16f327d36b3400540226f609c2cc1350d4173030ad405051eddc8ee85aa9c"},{"version":"0x00000020","timestamp":"0x21f6ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x997d2f47a1399988304779ea83481e143046fc6a78fb08eb18b0bc1088b19958","merkleRootHash":"0x0a9a135be19f44fa6077ece14657ee37bffce7a3119779e217b67952c5636e55"},{"version":"0x00000020","timestamp":"0x22f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x86ea1cb208635891887418b4b2b348777126f280130c86c037cd232766cfaf1b","merkleRootHash":"0x732b691a6961e5117770328c8a964f6ae2874037a1b361e4c5018bbaba7f2e47"},{"version":"0x00000020","timestamp":"0x22f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe8636ab56d9a7da511215e73fa5ac153485c97f9b9167d25a52bdcb8e90dcc38","merkleRootHash":"0x2a14ef1bdb7d1a66228f571cdc25da52130494a51cf9bec21f26686f1a71b457"},{"version":"0x00000020","timestamp":"0x22f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8aea7a1358d5c826521e9cf620f4cb102f8bcdec0aea016f360452364dc1c062","merkleRootHash":"0xde4e444c34def13ff1b5563960351f485d86e3089085f0782dafdff509bf45e3"},{"version":"0x00000020","timestamp":"0x22f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x55d7895b7087bacbd607ef318c31eaee49554086236b286f49dbceaccd5a5b40","merkleRootHash":"0x2338a44c0ad489605244cf0b23c7c00b16124fe66f6f0bc567dd3903fa4bf69a"},{"version":"0x00000020","timestamp":"0x22f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc9f4e4bd047e67d4e58497a9350be25ab84ce84475623e584d509125f586400e","merkleRootHash":"0x8183ab0d3134ee6f6f9be32d8d6651e8ec4540983567c6efff39c664de44415d"},{"version":"0x00000020","timestamp":"0x22f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9ee54aaa9f105722630054c8765b13bc2abdb85e0def2e3984fde4220220fe2e","merkleRootHash":"0x9eaf9d08c7e84635b06fac4f3ffb77664a0fe978773ae114f8b0e457d83b8087"},{"version":"0x00000020","timestamp":"0x23f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc8f4519b547f2ba4c23fff61ccd24005bc402bf89496cf98a9d2b6016e315177","merkleRootHash":"0xbb548bb406493dac320f10e16d6fafb76d3c75d4036423877b135c0daf63fda0"},{"version":"0x00000020","timestamp":"0x23f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x41f54527ed0461c3bc03db40d8cd24e4a8da1e634e3ff240d5d917a334589c03","merkleRootHash":"0x693d083865d7edf9d24f81fc1d275ef43884a2d4c1ab5ef71f1685c5aae165b9"},{"version":"0x00000020","timestamp":"0x23f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8103706733468f09722da082dae761992a37f5b6dfe159549e6c9944d1dd0923","merkleRootHash":"0x0a6345f7dc2e6495248259efb831b2a9735c012eb61cffb1004f0d4d913d0785"},{"version":"0x00000020","timestamp":"0x23f6ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x1ed554854f773b17e41f6b5b7202d1c41c35468b81860563f3330c046d285b3c","merkleRootHash":"0xd2ec6aa06754836ba4fb688e2dcb20363535850608994e50d3ce9de36df05b33"},{"version":"0x00000020","timestamp":"0x23f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6486b613fb22da480ae9711c157e1beb05bd4607ca1a3de6ea1ec831583ab45c","merkleRootHash":"0x0214486da1d9c5cad215232db57640c1ab1f68467db90f0bacc17a5484b8d8e7"},{"version":"0x00000020","timestamp":"0x23f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x88f9bee7938cc957af24af848cc2a4adfe4282f404f900db1572462e229b9918","merkleRootHash":"0xff4f74458bddaf2321fed8dcbfb76eee6195d7d17d86fca75b88961d8b0bfe77"},{"version":"0x00000020","timestamp":"0x24f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xec3268052f2c9cfb889ba11a6b84375075fd069a3470ee26d333ff66da9d7866","merkleRootHash":"0xd3f954342651a9dd16fc85c4305a8a8ea45e4fded40b697aa7de6224b5381dcd"},{"version":"0x00000020","timestamp":"0x24f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x4126440c537b87166e3afccc8df6ceb6c89848e9d9cb19b6801091020bf9da04","merkleRootHash":"0x9fbafa92ec2d598ee76356342af48878a5a968843178b248e5631cad78231cd3"},{"version":"0x00000020","timestamp":"0x24f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1cab5615cd38886ea28d68ae56b98fbce87373e08b8702e5c403cc339407177e","merkleRootHash":"0xd196b36d2a1dbf9d5551aa6217b06fbe4529558398c2e525ec598b2680f895f9"},{"version":"0x00000020","timestamp":"0x24f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xfab3058dcb105903315a9b48fbb5839a887ea858a2adcbb23b935361ab8fd919","merkleRootHash":"0x0894041c4e7403950d8922959786d36349ab7d8892151eb05a93bb49f60288c8"},{"version":"0x00000020","timestamp":"0x24f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xcdd1909d7804b7f1c5549bb659eb49568dd0b776e7779befee6655df99d1eb01","merkleRootHash":"0xfdade55bb45d22e9e36ff0cb2c4ad97ab3309695b891ddc5a25f12a92a5f891e"},{"version":"0x00000020","timestamp":"0x24f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbeac46926bb277a52f548c0bc17d61a3dedd19901ac9ba713b9a24d148935236","merkleRootHash":"0xfcfc9c60e030ca408bb182cbf82eebc449e15fdd055b5960eeded3fe6c795988"},{"version":"0x00000020","timestamp":"0x25f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6ce7c0c05bdb2a87ff2335ba478fecbd9d633eefa50d9056312ca246ced72f0c","merkleRootHash":"0xbc040dac1a195d1412d522c2d82f0c9999530b56f1a453e9c941140421fca89f"},{"version":"0x00000020","timestamp":"0x25f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xa22ad9155b4261f7d8d18c716084405c1ad820b8db31f575d0bfd36cf017d419","merkleRootHash":"0x98afba2e986d1752200a390a137999796757ef6210010e2aa8c53e0fadaf5c73"},{"version":"0x00000020","timestamp":"0x25f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x749afcebc567aa102c6376ffd18ab29b49e93d275f31e5b276c5880c17554856","merkleRootHash":"0x981be7e05a3939d58989698466d5cb8d3baf1aca6aa79ed3f979cb732bbd1bca"},{"version":"0x00000020","timestamp":"0x25f6ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x4636a9cdecfc93d357fda93bad2490e139d83885efe5e7ce8ff5515adfec426e","merkleRootHash":"0x99dc13c7bcf29a66270efd1ed9136fb8b226a240d4ed7fb8fe9e2460630d0264"},{"version":"0x00000020","timestamp":"0x25f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc55482c117029f227b6af6fd4b2de054daee0d9adb57d536514cad7bf4a57439","merkleRootHash":"0x7774431a5e645bc5cfd1f672f6cca2b663cbad680f317516706360bbdd32ef5d"},{"version":"0x00000020","timestamp":"0x25f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x740609fd0c7b039d359d006b555bde31b519bc7099fc7e7076927dfa07216838","merkleRootHash":"0x93096605b8611e48e722c7e3b04a89909ed5d99ede707b22798d12bbde9212ff"},{"version":"0x00000020","timestamp":"0x26f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xf75ebd9e6f58acd05e48e1a09c013643c6c0a5333e4ed1fec4ebea36d4ae8d58","merkleRootHash":"0x74857d903346d33f867d18ae24d2d3fdfd160e7c48dae81d42f35c25e33b0a3a"},{"version":"0x00000020","timestamp":"0x26f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x1fcb6f88b15d120fff32c5880926af3e02c75a0ee8b12b335a84c139e2d71d57","merkleRootHash":"0xee566c39ec185ae281996090dc29f5d6f41da5905135dbb07549883dbd41b1b1"},{"version":"0x00000020","timestamp":"0x26f6ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x6890cb9f958a9975b938a4e7f56cefb679c73438949bef1170cef11111808103","merkleRootHash":"0x2a99a12f410316a2d4713d4099c76322f6125885a59d8eb08d4588a6e118a8a4"},{"version":"0x00000020","timestamp":"0x26f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb59650c07713bb11e9a4b42dec2ed94f1d7c8c7e36eaffb06db32c37b2138377","merkleRootHash":"0x4eb4ec80a3af1cbc7b05c891da53ea0ed2057d8d5794200d6fe6353564e24a72"},{"version":"0x00000020","timestamp":"0x26f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1ee07edcdbda130a533e2806c58254e4f55b2bb86be198c5815415911a9a4c1a","merkleRootHash":"0x3c5c031deb2bc7271ec0713e3b67209d15228f7d73523a4fada5ce8f3e39ce45"},{"version":"0x00000020","timestamp":"0x26f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xea8c896be55a5e16d00157a524fd8ed2f858bcf74e93e31d86dfebe2cc5a8f32","merkleRootHash":"0x3bc861f487c9685eb43dad4e911ccdf3487c05c9a26487a034061402e651e05b"},{"version":"0x00000020","timestamp":"0x27f6ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x8c2681d44bd29ac7aa7b140c43ca6961dabaca1a62ba904542acb9aba09b1236","merkleRootHash":"0x872f0986089713c73a71dd7b6c5a7150fabcaef87fbb1d06dc4fc0bb4dbc730a"},{"version":"0x00000020","timestamp":"0x27f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xda5b9702f6547a666e9d0741d9e874f0d55260501dc1b21bf3138333ec585756","merkleRootHash":"0x5b9c2c2c1a15e164fde7e8e37453eb080274ac6cd45b3322785048f154fd9601"},{"version":"0x00000020","timestamp":"0x27f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xcd8058499015133f475b8b1f5309218e5730eca2d3ed6362b1a6553347dbe827","merkleRootHash":"0xe83d1eac88cb787b32b5b5e5461b27fb72ebcbf64b7cee642ec3d5d5de4837bc"},{"version":"0x00000020","timestamp":"0x27f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x037b51531fd5f9da7e88353050dd71583c8115407db03c6dda1d1ce9fd387273","merkleRootHash":"0xbc9b9411ff43d4c3c2e6ee62c192ae134db145c6a392e97dbc119e6049a74f6d"},{"version":"0x00000020","timestamp":"0x27f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb7fe80e87f0920aba63e7582c4eb9dfb29c7c6edd5662ada507de3f096692701","merkleRootHash":"0x2541b59eac48ed69ff78e6123e0a97d634d58bfb8d2c7c24d70cee51397796fb"},{"version":"0x00000020","timestamp":"0x27f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x72e65ee22f74c9fab9652a954a7fded3242a66717b77c1145b6cdf7a65ca060e","merkleRootHash":"0xb0d269bd23d999dcec3a2f151e22ad9b4d04f96649efd77d250e354e2a354acf"},{"version":"0x00000020","timestamp":"0x28f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xe107f47a78a2308cf8997e9b037966c210cce418c501ce02d999d5c82185fb15","merkleRootHash":"0x13263c8da4670ade513409d59c597187b715972f8b159b1621f7fcb306d66a9f"},{"version":"0x00000020","timestamp":"0x28f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x8037d9192344d4232aaa269dc4d46e4b9f242bd1fd000bed28f0dbe555662524","merkleRootHash":"0x415232b28e097b65f2316966326aba368af39cf98b4f9a9e5c89940b754bdd46"},{"version":"0x00000020","timestamp":"0x28f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5adede26d769f8e7aadddbabc76ca422c805a516f77c0ed8abfd893f6cfaa638","merkleRootHash":"0xb77fa3f479eebe6eb724b7bd279389a8d1fdb299fd325391c4f20342201ae18a"},{"version":"0x00000020","timestamp":"0x28f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x96e2c88ccff90bbffff34d290fb80d37228c5407d05252044ff22dd9e3b3f439","merkleRootHash":"0xabfa654ed9b76cb8c2b1d04fe3dae6d6ffb68e90b689d3a6cafc45b1c152f68b"},{"version":"0x00000020","timestamp":"0x28f6ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xcd8c8428a8e42c63b3e18569f69f95745d768d74221cadb2a2f8db50179d8e59","merkleRootHash":"0x5cae542d5b619389203cb00537d224bf8c42288cb7c7ba2c289da112ed3efe26"},{"version":"0x00000020","timestamp":"0x28f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3be71e2b10654613e745df1bb4cdeeae4a8c675c1f9782300e39853d59058d52","merkleRootHash":"0x52d60d059090102deb9d112af5b8fdbeadc54c27b9d2586287b6c8039f3e129e"},{"version":"0x00000020","timestamp":"0x29f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xbe15779911a4d791976faee16bbc11a99f55f6438b76adacb2a878a3b118fe76","merkleRootHash":"0x8fa289f5634d96769610b4457f50d54777002e57cded97c7ef569bf29b90cb66"},{"version":"0x00000020","timestamp":"0x29f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x91cafac651db2910d1b51ae25ee8748414e3b71bbce8ed01fd416e2f02871c63","merkleRootHash":"0x9f31cb0e590e39294ec3ab5ccf2f7a48549abd4a3794797410980139d607c3b8"},{"version":"0x00000020","timestamp":"0x29f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x430c8342569adb4ecb6f631c4ae26e63d6e39997bc35b509da78a138dc1eeb6c","merkleRootHash":"0x4ff76b56d8d813540e6e65d6f320451d5887452ac859e9d4d6e06595904e54fd"},{"version":"0x00000020","timestamp":"0x29f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd503b745906742d6e075ba277f07ed7e82f9d79dcbd33ae568dd9628e1064745","merkleRootHash":"0xcc08dfd63ad4918ce2617c85b59f75d95183d5379ee43999dab1b02540f165dd"},{"version":"0x00000020","timestamp":"0x29f6ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xb447882183e27779266906c65995b0d1a9854814df2e3ea163e71b3da6acf97c","merkleRootHash":"0xf972986fce5c759c8b72b7def5ca88bcccfcf455233727be4c02449e9290148f"},{"version":"0x00000020","timestamp":"0x29f6ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x83ef535c4382a7fe7ff59965ab97ac91300922263f6d5cfabc80e1912ae3b041","merkleRootHash":"0xffc0282be8d4775847b8b0e450e1915653f037d2ef672264b6a91b77aa884a47"},{"version":"0x00000020","timestamp":"0x2af6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x911cce173ac4f2ee9a20eeb37641085992e8df82db1c13c043f145941c9a8971","merkleRootHash":"0xef05eeb6069ba11c9f0d77ea2f4a8b11f1d23710f15ef5c79c0bc10e3240a739"},{"version":"0x00000020","timestamp":"0x2af6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4e8c628f6765452e1bc0a9cc01f815f9ed12ac8b9238ba92351fca8ccfd4b865","merkleRootHash":"0xaa1552e5f7cbece42d4fc47edfdb9aca60acd0fc9c2d552592c61e1c5d3379db"},{"version":"0x00000020","timestamp":"0x2af6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xbf8246039d0557998860b5f3d8404539c1e7ace12eec54c34548fd238d87056d","merkleRootHash":"0x8fce55361f64ad81c0c46e5d247d174e67e06b2b7ed4fbe89fe265ddd8265952"},{"version":"0x00000020","timestamp":"0x2af6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7fb4f81ffeac585485ffe141a9742637541a6da4a07fe6c82499eee0c8e62e12","merkleRootHash":"0x66190a480af8f9181051e7864b8c7c3ee12e50d9207b700ac26edbaa8be065e9"},{"version":"0x00000020","timestamp":"0x2af6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x2e8d4687004c5804d087938ed1605a726a52b2eb11491b20e2b5d63c9214551a","merkleRootHash":"0x831f1eab906b415aee9eb60513aee1c6fb33fd3d818d73085c4f5cc9c14d6adc"},{"version":"0x00000020","timestamp":"0x2af6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x560f50f85e8e6e30fb164dde7e8d159037e66bd2c3c26d093f388714b3d91830","merkleRootHash":"0xa012ac5d9167f21d13d7996202f3ef8926894656e2058173d961ecf0bb066e3d"},{"version":"0x00000020","timestamp":"0x2bf6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x372dc5c5bc5872853c90b058e751654cb96b5562eaa9f5e2a1db3f543a535e4f","merkleRootHash":"0x351053198f378ebb7d909e19a09c713a70df299ed6a9935fe6c467a5e39b3951"},{"version":"0x00000020","timestamp":"0x2bf6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x96b7b1e827a0e53699131ab959e6f9bc5afd9990abeb2eb45b0c22652ba3916a","merkleRootHash":"0x4a7e0a1beeca9715f4f9b9bf3a0fc3ab88bb1ab14602ee163a3ed66988886a18"},{"version":"0x00000020","timestamp":"0x2bf6ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0xc762ed29c90e6d39de9c917871a483e06e2c61d71dd58104434e1d9527307127","merkleRootHash":"0xf60f740ebd19ac56556fc1eaa123bc18246c7c4273af725f657c8f64bed36c7c"},{"version":"0x00000020","timestamp":"0x2bf6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x4d9fd40f7f616587f28150d019cebf1943dda337a60ffa7faaf9322e559b1932","merkleRootHash":"0xa94b3e0c8f11e6783f7da2bf094416f1a1fa88c04a4d0adfd75228d572c8d64d"},{"version":"0x00000020","timestamp":"0x2bf6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf34b06d1d71f7f6eaaf8c68b66702755577c67388c0b00dc15692b356d589141","merkleRootHash":"0xee283f1eaaada6c7e1df16597b78ae774e9c4f0fe3723c23a7a518995fce763c"},{"version":"0x00000020","timestamp":"0x2bf6ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x8d99a3cb5650827f4e6bc184913943014ce3687ce4fdeacd9362c84fe6f82910","merkleRootHash":"0x7876582bcfee7d6a35deaaf70cc27bd06ca23988e4b9019d7d076a5150019ec5"},{"version":"0x00000020","timestamp":"0x2cf6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x778dea5c99979630a45d8cd2b7b831f99290c483bfedf735363f055bb88c2129","merkleRootHash":"0x363a1f57258d7cff70c2a5bbc0cd8af2a4f98bd2dbfe8436216022d92e232a0c"},{"version":"0x00000020","timestamp":"0x2cf6ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xc8044b8a16186f74c08967045e1cc809f3c65320092559db0325bb6bae93874b","merkleRootHash":"0xdb67ba7a31e6169f52b0a2fd7f4ad8004d140f47d67a031663a49f006a8f6c26"},{"version":"0x00000020","timestamp":"0x2cf6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8412840f7fc950800fe4889b145abcba71ea1d68274e9baf130518da9ba4cf0b","merkleRootHash":"0x5fe8e6e774fe964eed56850be36927c04b964b9aa98f69e29744efb16c93bc5d"},{"version":"0x00000020","timestamp":"0x2cf6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x20ec780bbd617d9bcfd5a563c304e6b4360a16703a81259ac21ac0e2fb041c25","merkleRootHash":"0x4ac4752e0d6abe3d16a6d33a45bb3a683177a68a5c4fbbecdfc4403554527191"},{"version":"0x00000020","timestamp":"0x2cf6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x9a80c8135de59e85bc1e5838286fa8ef6c49b1d358f2dbab91aa4dc3651c314d","merkleRootHash":"0x418bffb0a13962484dc0cd33db852a6a90e53d3b6d8fb79c8867c0170d9deed2"},{"version":"0x00000020","timestamp":"0x2cf6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xf5b0afaa0e38b58b49c02a470db6741c68c7aa6c9f9677ee515530580fdfd57b","merkleRootHash":"0xd73f47293ec67ffbb65c1139cb2ca18a178f9db88f0a3f04d5027a72ad34e72c"},{"version":"0x00000020","timestamp":"0x2df6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2202c99fe9e64e69129cd0e55dc009d4e9d2081cb34ce7d1a3222f9eb81dfa7e","merkleRootHash":"0x11fb24de850b818be7532b8cc9da439e64c9dc4e9090bdbb55b53178b136528b"},{"version":"0x00000020","timestamp":"0x2df6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2e00f55767d0177e71e0aa57dabfd1a63b8df4d9ee054b25bfd943845d8eb569","merkleRootHash":"0xc57b58af9e9855c6eaf209d886cb5990e6b88adb05d85c4f44eab9b010f008ce"},{"version":"0x00000020","timestamp":"0x2df6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xda7cde40bc9ace44f1cb60179f1075b117ccebdc9560f0555e21da01ec385305","merkleRootHash":"0x8731e613621855b883b111297974bea0085be7dba52253eadc814f72aecb160f"},{"version":"0x00000020","timestamp":"0x8ef6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd63df9d83981b0fe4fca5d1a02a55a4e1b7b0ec05c8b5410ba5cf7704631705b","merkleRootHash":"0x9b7302b9242749003630d394ee3c2b360c6aaddac6491587ea9ca736f405b059"},{"version":"0x00000020","timestamp":"0x8ff6ba66","nBits":"0xffff7f20","nonce":"0x05000000","previousBlockHash":"0x61d4f13f3683b95065d61297f43d8756cbc284900beced491e3a50b727763261","merkleRootHash":"0x6ceee5120c18064855328d970bacd5e12a7440299e80275fb66432a9a2a135c9"},{"version":"0x00000020","timestamp":"0x8ff6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd18e62a1f7d9d7d1a5b592adec3f4c40081fd6a8d78c0b30f3fa6569f9f8d554","merkleRootHash":"0x13c400bf0c6311bff8244ddaa563719334f2c33d123a2b2685ec668ca79d20a2"},{"version":"0x00000020","timestamp":"0x8ff6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3b63438fdc3a17ce8b42c97bc1b7dadc7ec393ca98b0aae33a68e79dac0b536d","merkleRootHash":"0x7cdabab20a9ddae1a544b26880d26b267638194d3fb5789bc10ba9c512588143"},{"version":"0x00000020","timestamp":"0x8ff6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc6ab0aec143fabbdf57f9d3d9ca709f8a0c65c7cdaa4f0f4a8f6cdb28e34966e","merkleRootHash":"0x984313708741cfa20b5db5064d030817829045a94a2925285e0fbb99581dbdaf"},{"version":"0x00000020","timestamp":"0x8ff6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xfb0c084c258fcaf5b037d0ee78c76e6dba16063b8308db577ce7404bdc91692d","merkleRootHash":"0x44a457211686e01654d9077847cb52fc46a89160ec7297d925679ef14e65cf7e"},{"version":"0x00000020","timestamp":"0x8ff6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe378846782786309b81ffa09647c5ca4f8290c2cf1c4b1b763b9e071b67b7116","merkleRootHash":"0x5f24926e32bd0083ff86937c866ccf8e7fe0ab5e41f3c3d4130b472a9142c014"},{"version":"0x00000020","timestamp":"0x90f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x73e99735d4d70767214781cd564580c8a98e52a96bc54112324081b70d98b245","merkleRootHash":"0x70921371dd8222e1a15931ae29a8817bac26506e4804650ded1a6a803fd66d8f"},{"version":"0x00000020","timestamp":"0x90f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3489830b666ad592d86a53cf67cd9be232e02e570587c3cf98f0a570bce8e800","merkleRootHash":"0x90b06072bacee0da440d101348c05b1ed6d216dcf8a119628596bb44f7917a73"},{"version":"0x00000020","timestamp":"0x90f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x0c930fda845a468d4b0a6861aecf11027eced17c1712965e07e7abdadfd0c109","merkleRootHash":"0x958456962f03368bf668aedd3391b2fe5b3b1e323a7a73a9a08137bba112d814"},{"version":"0x00000020","timestamp":"0x90f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc243f2ec3742cd3a3254dfa1d6a0514f24f5685a6d3a42b1b46df3c2308d2f61","merkleRootHash":"0x9123e26df078d2a674e76a180bfddcbd9ffb9d4cb1a60047d3a31b13d39f37dc"},{"version":"0x00000020","timestamp":"0x90f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x92b47153a40677f62eab52d0c138502873af77dc365fec58c3c01075327b9342","merkleRootHash":"0xc74017af065af7c9edce2c90b84784e2452a0d76f1656b9bbb740940e3cfadc4"},{"version":"0x00000020","timestamp":"0x90f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x80c7b7a0eb57c58e751ee6b64af253c4acb094a4e96248511e5cfda164ce6e77","merkleRootHash":"0x59ceec0b7f9c46edd2d40db4e21f6ca890307fe3f543e7354ab11e044ff45e09"},{"version":"0x00000020","timestamp":"0x91f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x7b394b96655d27e402f430742416490b27e20f2c8b7717471a1f24b3cee42114","merkleRootHash":"0x86459217bb78a9b0178b07e0b682f0ebe7acac2fe7547c045ad31c44eb2b05dc"},{"version":"0x00000020","timestamp":"0x91f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xf8505c67e22e5372f6c17c05cdba3ee45a83517580238be17a8623327cfaa073","merkleRootHash":"0x7d3ec23fb34f25de616072ab29c823164d75e2ee547e4ba4a6977afe3a9d4f02"},{"version":"0x00000020","timestamp":"0x91f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xd42262e8c7b19e47ac3d54fd6d6003315f2cc4087fecb90fafd1f13038ae324c","merkleRootHash":"0x06e97cfaf7b17ad0e3833e84a76111afd5ae65d58bbc7ced8a0168e0583ec0ce"},{"version":"0x00000020","timestamp":"0x91f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xc0f13e4c01a3a31fa5da5a54bad4f75fdc964343d1849fd8be60313af7bbe312","merkleRootHash":"0x5ff49b3491fa47da1a583e4893ebaec40bb314d67588568be1b247f376c6ddf0"},{"version":"0x00000020","timestamp":"0x91f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x3c7069a8c73558dcbdb4e2d73f5c154de9c35ed857da5d138142160d175eeb02","merkleRootHash":"0x884d3329bf907729662335c54c8c2d6f93bde8bcfbdc6797295e1a7e66c131ae"},{"version":"0x00000020","timestamp":"0x91f6ba66","nBits":"0xffff7f20","nonce":"0x04000000","previousBlockHash":"0x9919727d8f16207443116e5f62f354c5485c9faa4ccb6f6cb788737fa4d6e932","merkleRootHash":"0xc559da2611d62b30f930aa054cbf57ae76a5188691ca946282788271931dd2b6"},{"version":"0x00000020","timestamp":"0x92f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x560a099399d48be2e500a0eac21bc29df93552c85d0afaeb686146e72a8ba519","merkleRootHash":"0x89959d4a1892f4cfccf417c779d9045f14006a8f089de300b7c26714ed89a24d"},{"version":"0x00000020","timestamp":"0x92f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x6186c6b352591f82105059f9cc44b36929f776d87b74ffd1722158bdb5574375","merkleRootHash":"0xe556d39651e65b447b9a803f8eef8f6207bf641f5d8df1a909880620c70d9ecd"},{"version":"0x00000020","timestamp":"0x92f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x468755d969861b5207c1455eb89e71bfb07552288f26e6fde86d60b12292a17a","merkleRootHash":"0x099ea5c418275a932b2c204c43c024dec3a6aa44b1c8e0e63c00215be6bb6682"},{"version":"0x00000020","timestamp":"0x92f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7a7078df3e0d05087ae3965dc87db44a3bee6ae8ddff0b318b8c86943319c06f","merkleRootHash":"0x2c4d08ebf9dcd1365dfa9841771cfcad19f6def5ed9bc6c1377f55649b54f265"},{"version":"0x00000020","timestamp":"0x92f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x58b579ba04f9761599a0d6e249552968637b13cd9d6d6ec27406cd7b814eaa33","merkleRootHash":"0x445636af207f4d2a7ceec0df884cd53c210c6544d190be61a7a14438e4054d05"},{"version":"0x00000020","timestamp":"0x92f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x7ade6a9bd4cecf42b9a5903e5b2d7655fd79ee754059f2d53b2c3374593f8f4a","merkleRootHash":"0x8a2f6702c66586a93a0d4320a4e552a42256a410eb2fd2057b12d456857753b8"},{"version":"0x00000020","timestamp":"0x93f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x8140f872141c410c7f974f80e45f55571ff876f60df48456fa348b0fe697b574","merkleRootHash":"0x0f99f3856a92d1ee6034c333abd0aec4259ad26d4a378599c1f3858ab2c1f53c"},{"version":"0x00000020","timestamp":"0x93f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xc0fbdf55efb2bc839b5e305693e56d8230d3726b611f2d2cdc43f835d5c83e55","merkleRootHash":"0x6c1a753f444cbe46f0487daa325ca12eb40ca0d3ac0bda75e089da5f26d6f8d4"},{"version":"0x00000020","timestamp":"0x93f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xdc3cd9e46a076f0202008b318a50314a8780fd7ce83b818ffe1b26121d6b152e","merkleRootHash":"0x044c7aa65a73b11d25c21cb50d4fbde4a8879fddd096afa592fa56484bfb9950"},{"version":"0x00000020","timestamp":"0x93f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8bc825e59e959a7ffa2f5da48af5b10c870e9f23f4a1d01d9b87f04daac3204e","merkleRootHash":"0x7d7c6747c1a94816fd0e9c363e799489fb5701e43e5f8c1ff53c7385b67eff61"},{"version":"0x00000020","timestamp":"0x93f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x8c0ff96f062f3c934c97051e28acb88b0676163c4ae6b99b45a0db0bb10afa02","merkleRootHash":"0x56e3a02df972c00fb9a2b876c6cd819a42e228a096360e971f343097bb75bcb4"},{"version":"0x00000020","timestamp":"0x93f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x79ae68ae44ca97a451c1e193cfed373ae40450d386e71dcf1eedc124b94eed79","merkleRootHash":"0xd5ea285dfc441a765e967569d18d49a6fed7c5f753e5dcd087d8b911d14e6863"},{"version":"0x00000020","timestamp":"0x94f6ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xb902a8fc616a3ccda608197c6388ee5a1bb02658a5e0377df7938725684aa233","merkleRootHash":"0x4b50f0babb8e57fec29a501d1c3c13dafce362605436af7a4dfa6f31b19c72ea"},{"version":"0x00000020","timestamp":"0x94f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x1d60aafd5e5f50a589f4d143c0cf074243d4445625eca31cb61139a29ced0748","merkleRootHash":"0x0df5e10d9a189a4a2e5163e1ed19e63858ce107c6ad9accd2847c59c70d198c0"},{"version":"0x00000020","timestamp":"0x94f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xa51e9acdb5a666d3053933e592ed1558c7181f933f203011b9b7f4039a0ab478","merkleRootHash":"0xb32918223a3c6edc48f7a6e961513dbc8b95392942051e4ddc7f4530a92f639a"},{"version":"0x00000020","timestamp":"0x94f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb49b6a9290b3d51b95d512507d6acf47633ffad87b735b9611011ca7f313b146","merkleRootHash":"0x5074280abdd911884e0567190e9b274234ea6505e76be5943c4e6e74bf1322cb"},{"version":"0x00000020","timestamp":"0x94f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xcaff0a473fe1cffe619d7f7f5edc7e0804b020582914cc99d2afbc2735b43f52","merkleRootHash":"0xf276a3757a0488d83f912f0c8b6977874b1b7d5eef10e078d0b066e333fd5ca0"},{"version":"0x00000020","timestamp":"0x94f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x7503edfbe1da3d7b15cda9ea13273333b9615a064078e22eaa96cc812e654765","merkleRootHash":"0x963dad0ba826a3af13b2603d44f0d3e88f7ae07d772b6db3b5c0d33562f63a2f"},{"version":"0x00000020","timestamp":"0x95f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x77c1c1c3d957c3a343319cf01f077bf2d225dcd9c3f38f9a30364e1b8b480746","merkleRootHash":"0x0de0f893dda26f3859dc33e55402869193c019933afd9638827decf2b3388695"},{"version":"0x00000020","timestamp":"0x95f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x8fb24de7958da596d3a885c722eadbdf3371f05cba1bfc8cd6246c9a1e7f9d65","merkleRootHash":"0xb442346a90bde0e77a74dd45c1039f07bec078595fdfa9607aaa950379e7d33e"},{"version":"0x00000020","timestamp":"0x95f6ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0xd62110e00c172a1fb4ee463a398bd079fd8b81f45acda8fbe3ff257e36d7267d","merkleRootHash":"0xa14f8d58d3948a0b926419a344222457e808ca4a4584b3b8addc6fb3cd986fbb"},{"version":"0x00000020","timestamp":"0x95f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x34f4e833c57b8468abed0f7ca891a72cd0aab95079a1c602a3beb0176ac2d834","merkleRootHash":"0x694818a133d8974460dbbf8f9d28e93a2215e95af87882a10038e4cbd9090c0d"},{"version":"0x00000020","timestamp":"0x95f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x056e284d738d40df774ccccf60295eebaa46b1df5c7652aba8cd2653e2bd701c","merkleRootHash":"0xb3deb5047a4505b4e72c9c022f24a0741640028b5c60c5ab6f6f539cd6e3f788"},{"version":"0x00000020","timestamp":"0x95f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x94d9595e773abfd35e0771989773ca199e85a766c8ac9bb28d8c6194c611e236","merkleRootHash":"0xe6d582ff3aaae1f37e41aa7c4b7acad18b73ec4cf323584801b7536d143e2d65"},{"version":"0x00000020","timestamp":"0x96f6ba66","nBits":"0xffff7f20","nonce":"0x03000000","previousBlockHash":"0x93929b2b84ad7c1c96db9122fa4d601a20b9bc79d0d2c56af4e49b406f119b58","merkleRootHash":"0x60ee4adda022d26d07ba9304a6c5ed98931162e10ba9d9aee9e868c13ee23740"},{"version":"0x00000020","timestamp":"0x96f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xd424b636733dbbce25685b63236df5924eebe3ffd441aa7e6a44346c0babe649","merkleRootHash":"0xc2467aa199ba0695e67dd7a7a6fcc7547bb4d9d3acf96b52cba7b86febaac5a1"},{"version":"0x00000020","timestamp":"0x96f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xdf680e332c08ff685775f3b902a55934e32c6176d3ee9eb6f1fb0ce8f9e5fc24","merkleRootHash":"0x6626af1de4eeb6f296c88a1f87f4514347cc90b73d86d8ce392ac10e7bdd6e14"},{"version":"0x00000020","timestamp":"0x96f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2870f3741e34d7cea63e0fd0c4c9d9c5ad7799e2e592ab6f9ae46a2cf07c6517","merkleRootHash":"0x5562f3c1f1aceae5ffa0a88555bc52bd85fb141debcc0669a435ab82c380a57d"},{"version":"0x00000020","timestamp":"0x96f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xe698195a39018398653d745bf32e0ad43aeaf3352978d3f3cdb7f10ac4cdc00d","merkleRootHash":"0xad41728df1880f72cb9d560a1d1c52034df5587fea174ff78eebadb2948d4fca"},{"version":"0x00000020","timestamp":"0x96f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x759a1bc4131deac6066d0f25c9e039b89ff90b4ce4eadb2bcdf9f546a7d28661","merkleRootHash":"0x2fe14b79ff780a4d9bdcf7fbc3c0cbdcff75a33b43d74aef58981f75306b540f"},{"version":"0x00000020","timestamp":"0x97f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x64351f1fee15b0ab112d1082960532a62cfffdc2b6d67549245618a2659d8035","merkleRootHash":"0x228a09000b71c43e46f1359a629f85e3b37ff50ca6dec8c12e1c0498ba764f33"},{"version":"0x00000020","timestamp":"0x97f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x848a33a53efef1346b7c4c54a75bb8f385d5031d2ee9067de452442df3670428","merkleRootHash":"0x7906901b83ee57fdfaf1af67a02c0f6488206b059d435b16c7a0befd1c54ee5a"},{"version":"0x00000020","timestamp":"0x97f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x80186dc33ccd8e35d4491ffc3a40255cf3d342adb34163ce65aae714e31aef36","merkleRootHash":"0x7150eaf6b6176f497830030024a59c1d7f36628a3c56ef9bc4463512268c6249"},{"version":"0x00000020","timestamp":"0x97f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x03c221e1545d7df8d6477666854b8b9743e3d0750475741cd8d0215d520b877e","merkleRootHash":"0xc471cc6d302df58ae69c196918f43bac5ade85f22fbf8e5195070cc81e554d9b"},{"version":"0x00000020","timestamp":"0x97f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xb67964d05744f51697af596c08babc972ca66b1654f405bd784d80745380a909","merkleRootHash":"0x302143fa4ab16a5fdd771f968bd17730ee402509a803b267a92ebfcbec6e8b12"},{"version":"0x00000020","timestamp":"0x97f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x3bc901b0d659941ffb48d645b071863fa209c8b795e8f76fbf5712bd0e942818","merkleRootHash":"0x391161d82c24974ff1496f3eb162670d238430b3a994a70a84f60273f756d981"},{"version":"0x00000020","timestamp":"0x98f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x71962ac5eb6e61d917d965ffc8f17980c7b93efe892c8df6989ad47418fb3159","merkleRootHash":"0x5e37a47335afd1c09981396aba4d2099586c22c9841b61c4b8f925cefa5e0d34"},{"version":"0x00000020","timestamp":"0x98f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0xdf3d86339a91669536b5f2aa90ab9c6a8e5401faacde4cfe48f57710ea3a5924","merkleRootHash":"0x93a3ccb6e73a7c6ef754257aa756b8bc1393e494d488da0d185f4c38821fd2d1"},{"version":"0x00000020","timestamp":"0x98f6ba66","nBits":"0xffff7f20","nonce":"0x01000000","previousBlockHash":"0x99eb59ef51d79c0278dc8e6d1fad04691cb8873c9caee4d16aab07de4ae1587d","merkleRootHash":"0x634a26a7042c816b83831aa8ba8f18bdd8c24aa0537cdd321451fe572316087d"},{"version":"0x00000020","timestamp":"0x98f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2b41955923ad994a256fc0d5b9a78652b9f72a696bdcd93fd760d41f90d55d02","merkleRootHash":"0xbc6735a539bcd63feb04477a6fab49a704e632bc18c23d63df6ece9c629b70a6"},{"version":"0x00000020","timestamp":"0x98f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0xc40689cd7ba3db32b7bf49b9f0cadc3ed4f4727e7cea3d344f959996cc2b2f22","merkleRootHash":"0xd5223423c9e4d2aedc23cff4f9c7de0c30a33d202c6f95db1f08bef810f1c793"},{"version":"0x00000020","timestamp":"0x98f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x2ac78299cdf46b2babe5c2b9e2e2bb019b79b219aefb5d920799a3b9cf7c380f","merkleRootHash":"0xb51928c09c61384e3473fddaccaa4c403592594da64751bf2089dc1cbd19851b"},{"version":"0x00000020","timestamp":"0x99f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x516d0fb12d4f36f3f1715387c6e4b9b36c5d9fec39302eeb69c90e2519715919","merkleRootHash":"0x2d009c81fa773a359606b6c8a89b3d3925928e1d38949e0624a411230d929f29"},{"version":"0x00000020","timestamp":"0x99f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x86d392ad86b52ec0bf61d8cfcff56c0c7522cd0364a57e19ffdf68660e92881b","merkleRootHash":"0xaad6cdf76d8fb4f6d15d9642c97eb61f3572d20b6d4223a2a9560952d0aa61bb"},{"version":"0x00000020","timestamp":"0x99f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0xb1d32a7b091ea8f2952555c9025091026afd0f864f8777dba555343b01567734","merkleRootHash":"0x05afa28b7e358df730595a6b15f2c4d9c33e533eb7311b3c8aa90070850238e0"},{"version":"0x00000020","timestamp":"0x99f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x5f5366663e744ba34cfd3fb306cba6ff176ec7277e47231d2be96c8e77e8b163","merkleRootHash":"0x079cc222e9c94748b568fa607ec55e6afd133c03d685c55360a48de474b5fe7e"},{"version":"0x00000020","timestamp":"0x99f6ba66","nBits":"0xffff7f20","nonce":"0x02000000","previousBlockHash":"0x34ea132824c10ea22c52131395ff5bede1518babc4250e21045a335d06168167","merkleRootHash":"0x1fd5cb43336d251a74b6fcd6a510226828e91871f88055cfdd84b710cc9c226c"},{"version":"0x00000020","timestamp":"0x99f6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x4939a708e183a9b60d4792f3349d6329ad8a42758cef2803caeaa7f3ff5eb64f","merkleRootHash":"0x7cc374226c725fa88f55f78eaf4f95091bdc3e298d5cb0830ce3437edb5aa14c"},{"version":"0x00000020","timestamp":"0x9af6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x9bd30fd00b1be9e3420eae5c9dfaf19aea987b41a4787a69332f8c2e5d31c43c","merkleRootHash":"0x5d5c029ef9978d1bf0d80bc8cc55f0f07e114365df8a587ffbcc02b078f5758c"},{"version":"0x00000020","timestamp":"0x9af6ba66","nBits":"0xffff7f20","nonce":"0x00000000","previousBlockHash":"0x00e82dd884b24e0340bac61c2f41f080a9ba8172863189e2e8721f486877b30c","merkleRootHash":"0x50b770fe94ff230b1fbbbaebb5e5182dd63000211e84e4a13581bdbbbf91604a"}] \ No newline at end of file diff --git a/test/fixtures/difficultyEpoch_testnet.json b/test/fixtures/difficultyEpoch_testnet.json new file mode 100644 index 0000000..8ca953b --- /dev/null +++ b/test/fixtures/difficultyEpoch_testnet.json @@ -0,0 +1 @@ +[{"version":"0x00a07231","timestamp":"0xfd27a266","nBits":"0xe12c5719","nonce":"0x2a4300d6","previousBlockHash":"0xaa41b457d9fec6f7778b63e940ac45d9f3f4cbf46384fa550000000000000000","merkleRootHash":"0x56a02032d8ca9b81f63152b0a1c767ad522d0bde5563f5dc9ddc8c4b5ee88d3c"},{"version":"0x0000002e","timestamp":"0x3229a266","nBits":"0xe12c5719","nonce":"0x01a93513","previousBlockHash":"0xb711f9007ac70e72421eb4dc3d2a8b3bc556895f7ef5a11d3a00000000000000","merkleRootHash":"0xfd55398c434643797554011e5d84cd0f46c4694e1e61f05a917d40c48882e0b4"},{"version":"0x00808d26","timestamp":"0xc829a266","nBits":"0xe12c5719","nonce":"0x14c6e4f0","previousBlockHash":"0x54eb1982b7f4d6ade748f404c308c78731d784dde36ae7ef4000000000000000","merkleRootHash":"0xa3483172343d9f32fedf4027afe66800933624f2da8c280fe3c84a2af648ebaf"},{"version":"0x00000020","timestamp":"0x792ea266","nBits":"0xffff001d","nonce":"0x358c7190","previousBlockHash":"0x14df266a1c4c242f8ffc09ea09be7acba184dcfa1049af294d00000000000000","merkleRootHash":"0x6f4caf488293e8d8bfbce9342426ccd43d77d171b5e7fcfa0ff309da10c873ca"},{"version":"0x0000492c","timestamp":"0xfa2fa266","nBits":"0xe12c5719","nonce":"0x1134543e","previousBlockHash":"0xab0472a8bab3e41ab52eabfddcf8833d6e2b4fe9614333c373db849d00000000","merkleRootHash":"0xe3fa9397e5bdded018a8c8b589b9a06e0190517318902b2fe209ea522a07ea6e"},{"version":"0x00205627","timestamp":"0xe430a266","nBits":"0xe12c5719","nonce":"0x226e1dc9","previousBlockHash":"0x3675d860a13e99ebbe883f4ae32d3361d56f9adf5e5401f80300000000000000","merkleRootHash":"0xb065694c97faa46da48ded52237f8af5acdc2f91d91f5e3337ff7594ad22863c"},{"version":"0x00801a2c","timestamp":"0xf731a266","nBits":"0xe12c5719","nonce":"0x1b3945e5","previousBlockHash":"0x5071d5e4eaccc35dfcc0e0cc508b13a85b027d44cb4f98520b00000000000000","merkleRootHash":"0xc0e8da7bf53b6b43745d7fee0f90600bd6ac5ab44e3337abf2296e02192cffdd"},{"version":"0x00c0492d","timestamp":"0xfc31a266","nBits":"0x07936019","nonce":"0x79b5f08c","previousBlockHash":"0x89185975606b4ef0354ac973b34363cf01b22f73235a5b731f00000000000000","merkleRootHash":"0x333b61bd6047b2cd23e459366b5591e5462661167a9a257039bce13cc6c0956e"},{"version":"0x0000ff3f","timestamp":"0x5435a266","nBits":"0x07936019","nonce":"0xc5add125","previousBlockHash":"0x6f5eaba1fdd1d124f2c4326a9992b00642432528df79bd624700000000000000","merkleRootHash":"0x40496df68fb224004994734b4103ec396da28c1a254290f7262beb809fbf6d43"},{"version":"0x00c0a533","timestamp":"0xcf36a266","nBits":"0x07936019","nonce":"0xda9449bd","previousBlockHash":"0x63aa8503876b7dd27473712dc174424d8919def8996f4b7c3100000000000000","merkleRootHash":"0x9a3562eb5a8c4b40139697362eede159537b0118ad6d19d8aad6c2f3c62d7fe5"},{"version":"0x00c00e21","timestamp":"0x3e38a266","nBits":"0x07936019","nonce":"0x6200e49e","previousBlockHash":"0xad088ca9a8b6427db62359ef62c8b188b0f9ae41ee4baa793600000000000000","merkleRootHash":"0x4ae037f35187972e78509fa2c6d7175c7db862cf503c5d7ec09fb70663d69cfb"},{"version":"0x00e0c62b","timestamp":"0xa53aa266","nBits":"0x07936019","nonce":"0x46de62cd","previousBlockHash":"0xc96320704c7025e83635ede59ca82b2d613d5151b68e8ac02100000000000000","merkleRootHash":"0x5ec1d3b3e32441b42ccdf3741f0dc030bfe5ee6d26c261802277d5cf6fda3e18"},{"version":"0x00802920","timestamp":"0x0e3ba266","nBits":"0x07936019","nonce":"0x466d37bc","previousBlockHash":"0xf8eead85a0bd3e5d2da8d340dc7198ef5d9e42eb13c035ef0900000000000000","merkleRootHash":"0xb4c10c5c724e944a8c98bc9d230c6b70d3fd9b4e97a3259039eabe111b7786f5"},{"version":"0x00200020","timestamp":"0xc13fa266","nBits":"0xffff001d","nonce":"0xa342db71","previousBlockHash":"0x52b04703e93d6aec62a65576bbdc10289bbdb401a7cfb4815900000000000000","merkleRootHash":"0xd64cfec3eff177c88e859180d488a278913b581ce80f2595c47cfc0d504c022a"},{"version":"0x00c05129","timestamp":"0xcd3fa266","nBits":"0x07936019","nonce":"0x48b4cbec","previousBlockHash":"0x95717cfbfe790480168564302630c369c3c5e8c902518d832d6a460000000000","merkleRootHash":"0x9366bbb5dab18e260efd9407c5a3ce21e7ecfe401d8029163e1699c906993cda"},{"version":"0x0000e133","timestamp":"0x8341a266","nBits":"0x07936019","nonce":"0x1746410a","previousBlockHash":"0xcb6fa59c9ad3f4b92797fb8ee1b9048e7b86e792aa5084b02200000000000000","merkleRootHash":"0xa83ea3960652dd77fd1afbf27098ec452e519a1f2b20ed17e7f25e589be0dcfa"},{"version":"0x0000ba23","timestamp":"0x5342a266","nBits":"0x07936019","nonce":"0x674688fe","previousBlockHash":"0x440a957b6deff1951812172c34b1090eff34aa584423f0903900000000000000","merkleRootHash":"0xf253cd457aba3342436a6650aeeb8ca4e6d534f9c63879a518f23491e2eaa3d1"},{"version":"0x0060a92e","timestamp":"0x9c44a266","nBits":"0x07936019","nonce":"0x44a4c71a","previousBlockHash":"0x302511d89091c40552fc180feba33a8b8b55276489bc16330c00000000000000","merkleRootHash":"0xcb0e3a1c06302aa46a54469d4083e5eb601098d2e101f760bb22e512f6098e48"},{"version":"0x00000020","timestamp":"0x5049a266","nBits":"0xffff001d","nonce":"0x26ca12f5","previousBlockHash":"0xeffe2d674ee197f4c6c705eef8a7dbcea2010c293016d8163f00000000000000","merkleRootHash":"0xf485749a59e4c1685f283158b3aa76fc1e47d2f94ca0b769196f7145c4662a83"},{"version":"0x00e05d2b","timestamp":"0x5149a266","nBits":"0x07936019","nonce":"0xdd800a14","previousBlockHash":"0x6df5441e11c4fb6af90d94e57db6ef5f68644be682a1ac14e538ca6b00000000","merkleRootHash":"0xc7bfda332d3c70b3b5ca00df62826587cd6f76fb54e5d996bbb8cce37a248fbb"},{"version":"0x00000020","timestamp":"0x124ea266","nBits":"0xffff001d","nonce":"0x4cec3bee","previousBlockHash":"0x3f5840ca50e92fb23ccc896b6ead9e96a6923d3d624ef1d24000000000000000","merkleRootHash":"0x5f3a1cec2bd1a51cba28dac8287a88246e7b7c37bf3837fa7bb3cb4971860112"},{"version":"0x00c04d34","timestamp":"0x124ea266","nBits":"0x07936019","nonce":"0xae246457","previousBlockHash":"0x88cfc9c8b51ceb52a38441621e454baf5831ecfbdcff8f2a03a56f8000000000","merkleRootHash":"0x0d14f1fd0da8006bc0dd9a0e1373622a8ac352bb3c2d4907a9e5b5642bb66ddb"},{"version":"0x0060202e","timestamp":"0x3152a266","nBits":"0x07936019","nonce":"0x4ec4dd71","previousBlockHash":"0x6852e9dc41e32279dc0e8e5f9229bc24610bae76d1b1872c1100000000000000","merkleRootHash":"0x38c3f35276ee0d958e22842e7813443bf2e33becc415065fcbc9d4d59bfc18a0"},{"version":"0x00000020","timestamp":"0xe556a266","nBits":"0xffff001d","nonce":"0x40b1eac2","previousBlockHash":"0xb873d37d2105e295d853cb7d205a8e382ab24609d0d8ae4d3500000000000000","merkleRootHash":"0x0631aabfa856190cd1181582c966c90a50cc65bc2a588c9dfbc17a42ff333e30"},{"version":"0x00e0dd20","timestamp":"0xea58a266","nBits":"0x07936019","nonce":"0x47055b5c","previousBlockHash":"0x29a3d0f87a6434b9300151a6df22213da5cfb63453ef42aaa432aa0200000000","merkleRootHash":"0xabf07cb2f80fb675521fa4d3f82ab8188fa21f2e60768a0f4f353a9c7d9ec83f"},{"version":"0x00e04834","timestamp":"0xb259a266","nBits":"0x07936019","nonce":"0x88148645","previousBlockHash":"0x9bab8316f413b40e9a64eb58d1e6b3148be2509cb68a5bf84900000000000000","merkleRootHash":"0xb369197fb17ee7966cf155ae7f48e675a2adee1eb31ec20b92331a4214ae8216"},{"version":"0x00a0c426","timestamp":"0x835ba266","nBits":"0x07936019","nonce":"0x417a3d2d","previousBlockHash":"0x96162820043e920cb9efaef8bf3eaa543d7b749a51d09ebf4100000000000000","merkleRootHash":"0x2589d5487d686aefd876412b7901025d1da7a0cd8187c52fa929a380bf53b4b1"},{"version":"0x00000020","timestamp":"0x3660a266","nBits":"0xffff001d","nonce":"0x60a3ffba","previousBlockHash":"0xd59ec7aae7eb11c206dc5feb50ae99f1629ed849c08766681800000000000000","merkleRootHash":"0x66f4930cd93d9c899df2d13bdace6a14d8fb144ef1143467d91ae92c58ffdeaf"},{"version":"0x00206422","timestamp":"0xe864a266","nBits":"0xffff001d","nonce":"0x40ecf9ac","previousBlockHash":"0xda82882a3769947471b3dde7ef0df11f8fcad8fae8f434774f38455800000000","merkleRootHash":"0xdd98598d7f3a496b7c1eec7e48518698401c1f394e7633e37fde0252af0d36a3"},{"version":"0x00000020","timestamp":"0x9b69a266","nBits":"0xffff001d","nonce":"0x001e830b","previousBlockHash":"0x96e2823fc8cb54bbc1806f545da02dd5e5ba3662d8524c5a1762000000000000","merkleRootHash":"0x9572ed26d710f68b0cb67081592b748c449ecbbf775db21f6c17b2f5e686cfaf"},{"version":"0x00c0942b","timestamp":"0xc96aa266","nBits":"0x07936019","nonce":"0x1ca143ab","previousBlockHash":"0x532f4ec8dd70bd75f2df772554e8cb60c49e2673b98340e5dc47de2b00000000","merkleRootHash":"0xfe4d6dc2cdbfe8e5307b9c10a4dd09ed26eb650c8c7f08fb63de879a3708f8fc"},{"version":"0x00805527","timestamp":"0x2f6ea266","nBits":"0x07936019","nonce":"0x6a823c06","previousBlockHash":"0xd77a291fb4c54efde402e5c9b91f2c1859fa52a4e05ec7f15f00000000000000","merkleRootHash":"0x42202e8c2fa1ea6a50f4dba6517b458e061ce8e5cad948c4924b78c3482a5379"},{"version":"0x0000ea32","timestamp":"0xf971a266","nBits":"0x07936019","nonce":"0xb06ab219","previousBlockHash":"0xa93d580c007851e8fa12e3d2488615ddfd45740a8bf8a0bd5200000000000000","merkleRootHash":"0x5d30b1cb04e66d2f3ce9396e85aca45e18f05e3dc667a852d71564c5d56d5d83"},{"version":"0x00203b21","timestamp":"0x9d73a266","nBits":"0x07936019","nonce":"0x441b2e28","previousBlockHash":"0x99dd7176616c48b5645c9d6d3e7d0d909eb1e61cabcade722300000000000000","merkleRootHash":"0x1cd218239a04edc0335d8052a851cc359d0196221d952586d443b25e874124ba"},{"version":"0x00600120","timestamp":"0x5878a266","nBits":"0xffff001d","nonce":"0x961ad683","previousBlockHash":"0x3937a7ef1d1a85584e7c3068c3722dbef9ba45031389d9ed0a00000000000000","merkleRootHash":"0xe94362f11e2d9c6ccd91ddcbc4a11cda3208c0a7c9a54d6a4a6fe5c8fc600724"},{"version":"0x0020e933","timestamp":"0xc178a266","nBits":"0x07936019","nonce":"0x5b10d2f4","previousBlockHash":"0x58b0aeee55669da983e0016b2da139b4674ab3bedd6f30ad101c050000000000","merkleRootHash":"0x041ff213d046256db9f09382d8c8e930c2801cd15aaf95aebdc0b08ad99370b9"},{"version":"0x0040892a","timestamp":"0x567aa266","nBits":"0x07936019","nonce":"0x75227112","previousBlockHash":"0x7b06cbe749e58733ce0e0860ffdd8895fba271126706410e1800000000000000","merkleRootHash":"0xfcb7cefac8625a152b83daeccbe6d5dc31fb34aadd915a681f4de1b041a56327"},{"version":"0x00e0c02b","timestamp":"0xf57aa266","nBits":"0x07936019","nonce":"0x3639003d","previousBlockHash":"0x0aa27db4989e3654aa886e92a21c3ef93c22a1d6c777ff8e4a00000000000000","merkleRootHash":"0x7f5cb73d6286cbc92292c4e0dc49bd953d6c77daac8f5362300cac99e9d62440"},{"version":"0x0080ad2e","timestamp":"0x187ba266","nBits":"0x07936019","nonce":"0x0da028a1","previousBlockHash":"0x70538ece097b7a17e9fe9bddfb99ee5681f403e1ac3deb7d2e00000000000000","merkleRootHash":"0x37e6aae76f2133087a348081c64f95613cb04cdea31a430c545f8d95b43bec0e"},{"version":"0x00001332","timestamp":"0xe97da266","nBits":"0x07936019","nonce":"0x5d047546","previousBlockHash":"0x041bf2c7e1607bc6f839f1d10c3e35bc69b676bd128bb9795500000000000000","merkleRootHash":"0x307dba70395947515bb4fec7a0cc36052a1e69dbfbc3f0939e7d4b4e0e505886"},{"version":"0x00c07f2f","timestamp":"0x6c82a266","nBits":"0x07936019","nonce":"0x54a4bb3a","previousBlockHash":"0xeb025795bc235c4db8229ad76ad5a93edba5327ef755ed7b4c00000000000000","merkleRootHash":"0xc4d59b90c7fa90eb693cfc09118281474a71b4d5277ff5e58ea3ed63383bc164"},{"version":"0x00a04134","timestamp":"0xb782a266","nBits":"0x07936019","nonce":"0x70bb3e67","previousBlockHash":"0x1ce5a03cbfd1cb1cb0a056dc8f105c6c670221d4ec4b56c50f00000000000000","merkleRootHash":"0xdbdf8cbfd01bcc58f525dfd921e68fac2286a5462a9561a9ca294c0e2f97875f"},{"version":"0x00e0ff3f","timestamp":"0xfb82a266","nBits":"0x07936019","nonce":"0xe8703d16","previousBlockHash":"0xa3a62a8f68cc4a6328190b3524122026deae89ad8d258ae15b00000000000000","merkleRootHash":"0x19d8d9cde9ac0129191ff02f18d422b390b5a19894c3f1abc379f8c7dedba269"},{"version":"0x00e0c82c","timestamp":"0x1e86a266","nBits":"0x07936019","nonce":"0x371cbae1","previousBlockHash":"0xa440bd904d6ba4d00505b52eb02cf6cbd007f80eb34856ae5500000000000000","merkleRootHash":"0x9bfc7364174de1e6ee4da590a36297af237266166aee15b7118c3750f6ea1c0f"},{"version":"0x00000020","timestamp":"0xd28aa266","nBits":"0xffff001d","nonce":"0x01425162","previousBlockHash":"0x068fb5ec6803b81de78113834121bb69036ed68587a889c03e00000000000000","merkleRootHash":"0x3eb22f50b9b5504c70c09e5ae754adcad587434588091f8ffb588306dc85d91a"},{"version":"0x00c0a624","timestamp":"0x828ba266","nBits":"0x07936019","nonce":"0x56884fb7","previousBlockHash":"0x8ac9448ef02c6b877a4ea4cebf194f483ee92da76c375c5d0845c41c00000000","merkleRootHash":"0x88a2a4648c6ea49748014ddebc3be9896abc2b1d57ad5f7d594ca8fa1ad2b911"},{"version":"0x00005522","timestamp":"0x508da266","nBits":"0x07936019","nonce":"0x857c818b","previousBlockHash":"0xb8d259e57fb2af9d4c022bc31d79b8abaf6d7bd0af6d70ee2d00000000000000","merkleRootHash":"0x848995142e40840eec8765b4bd1727f2cc039f6eb9117b18cd2978c83a505b54"},{"version":"0x0020df21","timestamp":"0xdb8ea266","nBits":"0x07936019","nonce":"0xc462e04e","previousBlockHash":"0x299a5917d3da9247b58f65d232c0746b6ae4274860c86e0c0700000000000000","merkleRootHash":"0x135ecfb68f8dea76f9c4dcdfd15b01bc0566efa1e23f4870da2795bddaa36aaa"},{"version":"0x00c06f23","timestamp":"0x068fa266","nBits":"0x07936019","nonce":"0x4c10c3da","previousBlockHash":"0x7428ac80e100ed19593f0592bf5ee8809de8e43c129b71e33800000000000000","merkleRootHash":"0x133a9f2a8a5708648597ea1c06e19456a0e707660f683a426eef9701e49b9b13"},{"version":"0x00800020","timestamp":"0xb793a266","nBits":"0xffff001d","nonce":"0x1c2c0b2f","previousBlockHash":"0x7d0788d3ce7e046b8a6d9a9fa8c69152085bf9c01d4819d70100000000000000","merkleRootHash":"0x98b8d693f267de728184ab5952b928eed5ae22ecfd06d5b8a483ca2fc11323c9"},{"version":"0x00e0ff3f","timestamp":"0x6d98a266","nBits":"0xffff001d","nonce":"0xa0bcbfaf","previousBlockHash":"0xa92beedc6a9a20c617711e2f5a17011681e79f0c563a604a79630b0000000000","merkleRootHash":"0x449dae38d52f6bbdb7f4da09c3895c5c97164eff835be6e85072ac92e8ab8f40"},{"version":"0x00206833","timestamp":"0x3599a266","nBits":"0x07936019","nonce":"0x48ddf5e4","previousBlockHash":"0x00ce5687f30b8c8a53fd2ddca585e7554fbd15763b5d8525032d000000000000","merkleRootHash":"0x0c1cb3ea788cb8e82d1bc46983274765e5c469fa54b86540e17c93f78f1817db"},{"version":"0x0080f425","timestamp":"0xc099a266","nBits":"0x07936019","nonce":"0xbe00126e","previousBlockHash":"0xd0ddc1df6942d148c7e3a10b4f83ec4de07c4d6e7ef3a4a24d00000000000000","merkleRootHash":"0x5e2f0c741bdb33c1f2b310fd74d41a7d15092dfcb093a87fb85c8c3a1ddae99e"},{"version":"0x00200020","timestamp":"0x719ea266","nBits":"0xffff001d","nonce":"0xb3c4a76e","previousBlockHash":"0xadd6650a80bff2770a631a2c8a5f26267fb1bac7e2349b320d00000000000000","merkleRootHash":"0x31aa3b6419025f775cbb601f4b22af61ad4cf51472bc006e572de5121c42cd46"},{"version":"0x00a07423","timestamp":"0x8e9ea266","nBits":"0x07936019","nonce":"0x1eec5752","previousBlockHash":"0xc227292f1eb7c019fac18182ab0b6c960c7082f8af50a52394e90b0000000000","merkleRootHash":"0x49704a7ce2c01e9b01fb176912ce73698c1b0af8fb696cb00d2a09efb5c0e470"},{"version":"0x00002429","timestamp":"0x759fa266","nBits":"0x07936019","nonce":"0xbb0c3df9","previousBlockHash":"0xa6c63c32e8de8875c3a578c653585d815893f9e83f9ea9cb1d00000000000000","merkleRootHash":"0x435c30295be75a563bc956f15e482a43df0a02b5f1adf32c99f7371c60a52d7b"},{"version":"0x0040f820","timestamp":"0x29a0a266","nBits":"0x07936019","nonce":"0xb8bd5335","previousBlockHash":"0x6e4fe7badfcc487ad053c23dd2bfd0172430f534393195e83300000000000000","merkleRootHash":"0x7bc60c997ce8a4710e5a0458947023f1e94d6de587407f7420e8f94ccb4b147f"},{"version":"0x00806c25","timestamp":"0xeba1a266","nBits":"0x07936019","nonce":"0x356410d5","previousBlockHash":"0xd9767a065b0bd80fc5df741d497d87d9ac158b050051a5d30000000000000000","merkleRootHash":"0x44d575ee91f35335c435fa08df451da518454e6327907bdde8c0a1078cc7eb29"},{"version":"0x00000020","timestamp":"0x9ca6a266","nBits":"0xffff001d","nonce":"0x9637b5ad","previousBlockHash":"0x47cb5342cc8649f11a1177a0a8db6151bf847f78d6876cf90c00000000000000","merkleRootHash":"0x3d92c58551037c14035f7830620404f39ad4abab6d4e83e1c9ea710cf58d7b7c"},{"version":"0x00a04c27","timestamp":"0xeda9a266","nBits":"0x07936019","nonce":"0x4c34d3d6","previousBlockHash":"0x7efc37b099d1b9c116d79d35c4b4772883ec7f569f9281e4269ef8f300000000","merkleRootHash":"0x7fc19a4af1614f14ff39606e81b5182fb4607a92389219e653d018871bf76e9f"},{"version":"0x00c04c20","timestamp":"0xecaaa266","nBits":"0x07936019","nonce":"0x4a18a796","previousBlockHash":"0x8409d4731abd2326ee5109275597073e5deaf6540c58a7e34400000000000000","merkleRootHash":"0x52e26ae9629f1135cc4e09752f62c429e96399805af83293887de0b11dec4b0e"},{"version":"0x0080ea29","timestamp":"0xebaba266","nBits":"0x07936019","nonce":"0x1096a190","previousBlockHash":"0x4893ccd66b800aba1369b5f723740447edf714e3fb711d7e4400000000000000","merkleRootHash":"0x333ffa20a1e86f21277989691f1da0b0095a5b93b16a242543e1631df9f5dde2"},{"version":"0x00807123","timestamp":"0x44ada266","nBits":"0x07936019","nonce":"0x8025abd1","previousBlockHash":"0xb469240bc994877d464571c9133a096aae6d80b48a7be42b2d00000000000000","merkleRootHash":"0xfafa2a1188bfc9b89b1406d5f29fab9b09f33cc091fca622e9ddf2f65db2874a"},{"version":"0x00c0b02e","timestamp":"0x7faea266","nBits":"0x07936019","nonce":"0x0af271cf","previousBlockHash":"0x82dd53b120cd2d817ba83361c70c4c20ec34035b22f611e34a00000000000000","merkleRootHash":"0xd8285f1cad43e6b6f3d7c9f68858e035c8e4852258764540dc740790e3dbf3d6"},{"version":"0x00000020","timestamp":"0x34b3a266","nBits":"0xffff001d","nonce":"0x8854e495","previousBlockHash":"0xe160c5d843c310407157e73d3754ee8c44248cdcc7bcf06f4400000000000000","merkleRootHash":"0x9b4db83235af10873379030166a63bd812f73d8fbb12a5d6bef599aad269420b"},{"version":"0x00a0b525","timestamp":"0xf1b4a266","nBits":"0x07936019","nonce":"0x7d0c730a","previousBlockHash":"0x09cedd964763c9c34d5a8943f72c2a6ffe7efca262a654852c06000000000000","merkleRootHash":"0xf53447994253ca17c1ff0ab76cf29d9d7e6e4ec71bbc088aac79934bd747ff5f"},{"version":"0x0000252c","timestamp":"0xf5b5a266","nBits":"0x07936019","nonce":"0xc6422513","previousBlockHash":"0xb1054ef023a2006d3c04d76c10168acbb09c56b2ce4d638f0600000000000000","merkleRootHash":"0xb398a36837c73a05fc09aa4c05b18a7064b16bfa8f7376f7e087a74818df10e9"},{"version":"0x00c08b30","timestamp":"0x1bb8a266","nBits":"0x07936019","nonce":"0xc5170417","previousBlockHash":"0x4ddd65b7849e9a72e2def3b0f828267f48b86ce3cc73e4ab0b00000000000000","merkleRootHash":"0x21caf3dca8bef8ad283d1fc66f6f0d8812e58b6397c03ed35471d7c46dfcf289"},{"version":"0x00002b23","timestamp":"0xe4b8a266","nBits":"0x07936019","nonce":"0x488a40bc","previousBlockHash":"0x40e058e673625b5f5d2708b421ff4eaf14f0e5d7298b800a1a00000000000000","merkleRootHash":"0x69c79a90cebf118119d0aca563cdb2e38edff06f49a3d3356a8472b11787b9e5"},{"version":"0x00e00c25","timestamp":"0xe3b9a266","nBits":"0x07936019","nonce":"0x28bf2359","previousBlockHash":"0x40e644cc2a04a8f7fb941469b8b2564d818ecc2caf96f59d2c00000000000000","merkleRootHash":"0x4cc24d1d6229bf52b260d81f6ce4a83f4c7d862dfb3f367378492083e889b63f"},{"version":"0x0060e531","timestamp":"0x87baa266","nBits":"0x07936019","nonce":"0xc675fc8a","previousBlockHash":"0xeabd2ee5293743bd238701451d7b190f5af1fe09096604d54200000000000000","merkleRootHash":"0x1b1e28cb157297088567fb3e072afa40194c8c03f9b5039a247f722240e5b310"},{"version":"0x00e02426","timestamp":"0x59bca266","nBits":"0x07936019","nonce":"0x7890ec6c","previousBlockHash":"0x9ad9366e20f64f09ec75cf0b42b62d8de002d96f59a8a2a83200000000000000","merkleRootHash":"0x2514ad22e5d1355c36c01c867e1d736d0bb16ac7512e52f6a99584f3ffbe56bb"},{"version":"0x00000020","timestamp":"0x0bc1a266","nBits":"0xffff001d","nonce":"0x2a7d5d8f","previousBlockHash":"0x72905298bc56a9dce31f6f069411609683a963d266dca9fa2700000000000000","merkleRootHash":"0xe91b00b7cdfa4aa9b67d0e54f396776c06acb9162435f0b78de41a7697cbd2e7"},{"version":"0x0000ff3f","timestamp":"0xc9c5a266","nBits":"0xffff001d","nonce":"0x4f283c18","previousBlockHash":"0x375e933cbea61e2a1b2942ee9df50b0ccadc648edafceff81b1cda9300000000","merkleRootHash":"0x173fbba5ec934cf5e20172802e1b8aa36188cf03e871c1138150d779eb85cd65"},{"version":"0x00604623","timestamp":"0x5ec6a266","nBits":"0x07936019","nonce":"0x3e054d5f","previousBlockHash":"0xe1fa412d2bfefb042a4b44e382646684a4d96851b73b5747d6c2030000000000","merkleRootHash":"0xaefebef6cd35248259884cb4fb7fc2ee77ad5286edfc9a9cc6609a26f64e0929"},{"version":"0x00000020","timestamp":"0x16cba266","nBits":"0xffff001d","nonce":"0x4ae8ae0b","previousBlockHash":"0x044ad45ae70fd356d06c7945d5994284421963a50f364b4d3800000000000000","merkleRootHash":"0x4d0575c04a53f2e8eba7d4b63f24bd7396dab819909a6bc3c26fdcbf0240baf6"},{"version":"0x00406234","timestamp":"0x29cfa266","nBits":"0x07936019","nonce":"0x3e949267","previousBlockHash":"0xfebb808beef6770639af00979aecb8265d78487614190a921e4a23de00000000","merkleRootHash":"0xb1b1e487ffa9a6ed270097c3391326ded51add6e3dd488b532d29d4489c6ea47"},{"version":"0x0040c32a","timestamp":"0x0dd1a266","nBits":"0x07936019","nonce":"0x3224691e","previousBlockHash":"0x556b2059734b174382711d1b3f4ff8de9e1359e7835ef6cb0500000000000000","merkleRootHash":"0xbd062fd7180354575701bfb88eb1b2de6b80c4621532f2626dba3d212817b045"},{"version":"0x00609322","timestamp":"0x87d4a266","nBits":"0x07936019","nonce":"0x8c90f44f","previousBlockHash":"0xc17438615850667b1afad1d6c7a6ebdfc6710060e19d94370200000000000000","merkleRootHash":"0x387aa605acea06fb748a7e0a0b25a3c02645fcdac13becd8c326a037b200e019"},{"version":"0x00605a31","timestamp":"0x3ad9a266","nBits":"0xffff001d","nonce":"0xb36a02f5","previousBlockHash":"0xd707803e792e2e2e138e5bef62aefad7bd7e5f995d2e51dd4300000000000000","merkleRootHash":"0xd232ab0c0c8045d0d82db31030c9eaf359892e3f12c525bdb7ea018b33915056"},{"version":"0x00607825","timestamp":"0xf2dda266","nBits":"0xffff001d","nonce":"0x44ed8ede","previousBlockHash":"0x500f222a2f6fc4ff596aa3e3629e7e5acac83710e3251deb0d21000000000000","merkleRootHash":"0x8ca17a9a0550dd4758a88b4e5d6feb45d9763fb83628fb0b81b16a36d56da8cf"},{"version":"0x00409729","timestamp":"0x00e1a266","nBits":"0x07936019","nonce":"0x887516bf","previousBlockHash":"0x9dc0fb634733019527767b6d498f17cbf78fc117e3deb955b405000000000000","merkleRootHash":"0x7452de2809b30c0afefd41927d4862de6d3f3cc96d04361dff6d1211b17c581e"},{"version":"0x00c03f24","timestamp":"0x2de1a266","nBits":"0x07936019","nonce":"0x96d9613e","previousBlockHash":"0xec6c2d9e7c0e5042ba80898931f724e920f7c294bdce0baa3600000000000000","merkleRootHash":"0xa954c3c791a5762678bad4b977661e7a48831997a9b38f6bbac2d5e15dd4fabf"},{"version":"0x00e0ff3f","timestamp":"0x9ae4a266","nBits":"0x07936019","nonce":"0x28257e72","previousBlockHash":"0x08bc300683eb487438d68a538fa6712115b921d11ecf04295c00000000000000","merkleRootHash":"0xdd9dbada1d13eb39866853a5380ca15d18738da56ac98e78be59b1c9aa9c2896"},{"version":"0x00000020","timestamp":"0x4ce9a266","nBits":"0xffff001d","nonce":"0xf4be5861","previousBlockHash":"0x933a06e47a840ba30e84c1db54307dc8041b0539270abee80900000000000000","merkleRootHash":"0x3cad2bcc449175da6bc7cd59e0878a9581e6d1b39c5150e644dcf7e785bad43b"},{"version":"0x0000ff3f","timestamp":"0x06eea266","nBits":"0xffff001d","nonce":"0x39491b98","previousBlockHash":"0xe81c1e2224a5e8bc347ef349c048852172d495c14edc26e2f97db21700000000","merkleRootHash":"0xff1506d16aeced83f12a9504d51280c903c521086cd423249ab2178a6c489f42"},{"version":"0x00405429","timestamp":"0x4eeea266","nBits":"0x07936019","nonce":"0x722408bd","previousBlockHash":"0x7c67b5bd67cccbe7e640c8f3e5500627de3677cc5a03cd62e829010000000000","merkleRootHash":"0x8e5fb8dc1497db1de142926fc2d49ed3c5b337eb79a8dad0121c7d6c3dd50fdb"},{"version":"0x00209326","timestamp":"0xe1eea266","nBits":"0x07936019","nonce":"0x12a50657","previousBlockHash":"0xc6f82147a7de0ddf4999027fb8cf823242a0cf25af6c105b3700000000000000","merkleRootHash":"0xf99a06d76018151ff1c958cb44bb72399943da07dd27ddbc9d0327e48f63250f"},{"version":"0x00e0d32b","timestamp":"0x22f2a266","nBits":"0x07936019","nonce":"0xad0edbe3","previousBlockHash":"0xe17906a68c5e353298db2ae8a0dd2da2c5b74fbe0ffebf034000000000000000","merkleRootHash":"0xeff4962960aeb1110bddb9812c3a7a887aae95b42f224893e21db4323984d0a6"},{"version":"0x00004e20","timestamp":"0x45f2a266","nBits":"0x07936019","nonce":"0xd0f5cbab","previousBlockHash":"0x5f11dbbeda2ecaea514d016bc078e5aadf75a67b671fd57a3f00000000000000","merkleRootHash":"0xbd360385523dde4753b7e03318a39a1157177d7cb590fec09e35fbb935e4ebbb"},{"version":"0x00007c22","timestamp":"0x0cf4a266","nBits":"0x07936019","nonce":"0x591c424d","previousBlockHash":"0x38be7fa2e9348f76ff8f3d86f90447244866f31893ce37794900000000000000","merkleRootHash":"0x120efc814257ea5e2cf351c465623d528ffd9a20445c7a49e069fa42263bcaa8"},{"version":"0x00001423","timestamp":"0x23f4a266","nBits":"0x07936019","nonce":"0x5e54b503","previousBlockHash":"0x8263b8fee5ce98ba85bdfe30c89ef5f7a78d2bb962e9f0062400000000000000","merkleRootHash":"0x0f8332167960d674ca7862d43c0363b59968dfb684259954e3e041f0dec68f3e"},{"version":"0x00205322","timestamp":"0xedf4a266","nBits":"0x07936019","nonce":"0x52806c28","previousBlockHash":"0x13c18cef37f0c709fd346c87ba086bf33494b50e164544aa3200000000000000","merkleRootHash":"0x1d9474812fcda20d8a124805c4b961c55448528dbe1d4996f32ab30f30a6aeac"},{"version":"0x0000ff3f","timestamp":"0x9ff9a266","nBits":"0xffff001d","nonce":"0xbc12c973","previousBlockHash":"0xd59f78c6cb3f7b9dd244a98fec4d9db37093d98ef14ce4a33800000000000000","merkleRootHash":"0xfaae38ff4fb20dc0ff7df1081cae433e3492c5cc82c1f8ee42abf6e7f52a6ba5"},{"version":"0x0040e527","timestamp":"0x76fda266","nBits":"0x07936019","nonce":"0x8994a144","previousBlockHash":"0xd43d7848973524d4b9c70f554cd6a6df169fb7bece0d7da47fa6030000000000","merkleRootHash":"0xef0855c56bac0871cc78c80c2e0635e5bfd47998d14136964bf65b63961b4725"},{"version":"0x0060b322","timestamp":"0x72ffa266","nBits":"0x07936019","nonce":"0x0628db0e","previousBlockHash":"0xd42807f0f786587efca440b6f029d568ae206e73d16c54b74b00000000000000","merkleRootHash":"0x32b927b231b8c1fd7e3f0e61f8ff14ec83a77a212f9e4d0158eeb8a4d68795c1"},{"version":"0x0060ac24","timestamp":"0x2303a366","nBits":"0x07936019","nonce":"0x493023bf","previousBlockHash":"0x2c74538c3ce9cac3a2eed9e8a28912156bf713df515922fc0300000000000000","merkleRootHash":"0xb486992fe445e3fd1b8151d8f0bd9fd376783e2d432696355b3797d96428ffe6"},{"version":"0x00404624","timestamp":"0x4e05a366","nBits":"0x07936019","nonce":"0x20f8b82c","previousBlockHash":"0xf3b363581348566e0e300ffa37a4977362911ad2efd4ac725000000000000000","merkleRootHash":"0x43aaa16166929cab1bd5ee3e7bc751ba951713c71ab670557043f1bd2e700663"},{"version":"0x00606134","timestamp":"0xaa05a366","nBits":"0x07936019","nonce":"0x98dcb169","previousBlockHash":"0xda8d646836ea1c156322f4efd7b285343bb049840c9e1d0a0700000000000000","merkleRootHash":"0x7ccffa9e2250c53fd68c35cc3a3ae133102795cc842da54b81de03f87ebe655c"},{"version":"0x00000c23","timestamp":"0x1108a366","nBits":"0x07936019","nonce":"0x3320ee2d","previousBlockHash":"0xc71e790add09532ed1c82493797bc91d317fa93d5df57f0f4b00000000000000","merkleRootHash":"0x20ef5d78fe31d2cde409b7c4251c40e0c62bda9c4ec8f4db38948959f8a488d5"},{"version":"0x00a08f25","timestamp":"0x900ba366","nBits":"0x07936019","nonce":"0xc99ccd27","previousBlockHash":"0x04cd337b1d810f3098620c24c0b2a0e46cecd6f9e7d254b11f00000000000000","merkleRootHash":"0xcaab18ab41b746cdbdef26d14a5f8db9ca827e9039f619e7480bf5cacd04454a"},{"version":"0x00000020","timestamp":"0x4210a366","nBits":"0xffff001d","nonce":"0xdba4e998","previousBlockHash":"0x1bd8d2dfb5142002c9c8ef311cae1a8bddfc4cbfa815bb803200000000000000","merkleRootHash":"0x3c03c5f790375e35ca38e8d79acb48c511c012d8aa4cf39705db4567b873f1cf"},{"version":"0x00e0b42c","timestamp":"0x0812a366","nBits":"0x07936019","nonce":"0x8a407740","previousBlockHash":"0x20b2cb278523b02fb96cb5682d37997ab3ff833d5917ae6a30367d8000000000","merkleRootHash":"0xa6b9a848e991c5ecbb8758e9fd8b55d29be4e1a8d181497c9ee24b53a5033c09"},{"version":"0x00a09a2a","timestamp":"0xb615a366","nBits":"0x07936019","nonce":"0x26784411","previousBlockHash":"0x16fb3aeaf52fcd620226125f6862b9a4a4eb19b2684490190f00000000000000","merkleRootHash":"0x0cef798767272e4e6b5629944a2724b52ba31cc85cee8cee2436dca304da2788"},{"version":"0x00a08021","timestamp":"0x6a1aa366","nBits":"0xffff001d","nonce":"0x4a82b33c","previousBlockHash":"0x4b7b60dd7ff08dd3099b03a03e03c0dc3b7a4afc575ce3c03000000000000000","merkleRootHash":"0xad67ea084ad4b7a0c0fab84a8adf9d23bb2a21b97c649c6f43257690002df23d"},{"version":"0x0000bf28","timestamp":"0x051ba366","nBits":"0x07936019","nonce":"0x25222404","previousBlockHash":"0xfb1e798d6113456927ca3c4576bf441bb1b7422ffadf9fe51839000000000000","merkleRootHash":"0x54145bba3c6014fb7275d17684dd9dc86fdb89f75e1ff928c46f5a8b5ee6b4e4"},{"version":"0x00c05f21","timestamp":"0xff1ca366","nBits":"0x07936019","nonce":"0x2db5e8f7","previousBlockHash":"0x8fbc0c39e5c4a5c78c32343849ddd6dd158aa36fbd2459fc1300000000000000","merkleRootHash":"0x3a9987fbcbc33c527c7588f707fffcf3c08040debe6cc7034d3ad801ce3569d5"},{"version":"0x00e0232f","timestamp":"0xaf1da366","nBits":"0x07936019","nonce":"0x4acc8aac","previousBlockHash":"0xf0ba7fe224a99f343eca1f63501c2301fac87f94a35402e24000000000000000","merkleRootHash":"0xa4a56802d63ed9ee3a6470c9c4a637d19e7c61d545216d65770af9a7b30b7755"},{"version":"0x00000020","timestamp":"0x6622a366","nBits":"0xffff001d","nonce":"0xaccddfff","previousBlockHash":"0x25d26bc1b8141c6155ef0d20d2bdb0046a3fe147f204f4f70400000000000000","merkleRootHash":"0x12b87c278faf849bcc307eec13680bb62345a36b32e7777d924d708201b7d306"},{"version":"0x00000020","timestamp":"0x1a27a366","nBits":"0xffff001d","nonce":"0x14491e7e","previousBlockHash":"0xe778042505070e12cc02912db3b23bbec444c2b0d7d0e3270b0e310000000000","merkleRootHash":"0xe1c88b847245fc6b87ccf790f2a3fcc44767a2ed92810d2b6179c22b5191a99d"},{"version":"0x00802f2a","timestamp":"0xd529a366","nBits":"0x07936019","nonce":"0x4c8ccd4d","previousBlockHash":"0x28ba1f47efa6c64647dd8542cfc252536865b11859e289069800ec0000000000","merkleRootHash":"0xd0bb7bf03235fd7e0a928da602a7efe163571f977d6eadd1d95e635491a045ed"},{"version":"0x00a0d723","timestamp":"0xef29a366","nBits":"0x07936019","nonce":"0x0e82cae0","previousBlockHash":"0xe0b7c8fc33d40316faec964d0c408ee24c315606e9766dba3f00000000000000","merkleRootHash":"0x0bb08fa131ade58e826e9378e1a990ce08d52aa052c9ebc374cf1baee0be680f"},{"version":"0x00e0bd21","timestamp":"0x682da366","nBits":"0x07936019","nonce":"0x79022481","previousBlockHash":"0x77983ab3347416857d04dc315e2c7c9b0896673a05d7f7e73800000000000000","merkleRootHash":"0x8c2170b077ea6b158e508933cbb178a595aab43d647031cef57fa32335298ae5"},{"version":"0x0060e525","timestamp":"0x2930a366","nBits":"0x07936019","nonce":"0x64b17f1f","previousBlockHash":"0x3f3d0d83dcb26a1a40fd81863d485d9cdeda0917ea1fd2562300000000000000","merkleRootHash":"0x220bfb7b7a47680d776fb2926da4c0cc2c6d6fb22ffe2204f28d8630410c03d5"},{"version":"0x00205532","timestamp":"0xb030a366","nBits":"0x07936019","nonce":"0x0874e5ff","previousBlockHash":"0xf694cfb6e925ce898452bbdfb391e48abefa255521ac16b73400000000000000","merkleRootHash":"0x7adf7e91beda0cb11edcaa5e26845db773c94b6eee6ebb8d1a35fb21ce013470"},{"version":"0x00c0df21","timestamp":"0x2631a366","nBits":"0x07936019","nonce":"0xdc340ff0","previousBlockHash":"0xc85466f6f91a5bd78a4d3d883f245ec0e2c4dc8ba77fc2e41b00000000000000","merkleRootHash":"0x8d36ca0437185217e002bdcd24b7a894c8f0757db37d1be9a046d059aa97e849"},{"version":"0x00a09423","timestamp":"0xdc31a366","nBits":"0x07936019","nonce":"0x14154268","previousBlockHash":"0x4ed368dd291792dce79a87545175d95ffa61be66f423fda20200000000000000","merkleRootHash":"0xe3542c907bbfa6c9ccefdc243b8a76edbeff8fb0817657dc9a527479b1c8503e"},{"version":"0x00a06b2a","timestamp":"0x9e34a366","nBits":"0x07936019","nonce":"0xd4033ca7","previousBlockHash":"0x088b80c8140181a87d39cdb899529876b59b9618f5b6ef182000000000000000","merkleRootHash":"0xa7b0aaea73eee0fd1513b94328d029ccd60d7bb54266acac068225e7261e5018"},{"version":"0x00805426","timestamp":"0x2037a366","nBits":"0x07936019","nonce":"0x12c2dd7b","previousBlockHash":"0x2a212a261dd4b6ab58816d3020d6de9600eac7d3d1dc94d65c00000000000000","merkleRootHash":"0xaa192e0a730bd1f240169855afd5527f3fb8a8794f89e12819701dc8269bb0cf"},{"version":"0x00603622","timestamp":"0x0938a366","nBits":"0x07936019","nonce":"0x55566caf","previousBlockHash":"0xf253d8f89e250ffe1fa230f0d8e03d7d5d774452e7e363235100000000000000","merkleRootHash":"0xeb0850780dbed5371ee0e8a91f2dd8588ec57052f4c5da4eb4dd08260a737706"},{"version":"0x0040ee22","timestamp":"0x6939a366","nBits":"0x07936019","nonce":"0xcf9a09f8","previousBlockHash":"0xb4865a8176929557906005355aa0fde35966d6a296646b902300000000000000","merkleRootHash":"0x9cfc627fbf6b33537c8dd0b120c2c7b3e9101262b9d5f96d8aeee956f71c4c8a"},{"version":"0x00009629","timestamp":"0x5e3aa366","nBits":"0x07936019","nonce":"0xb6470eec","previousBlockHash":"0xeccfd9c4f1d6ed5f55a4bf5ad7d4e662b7000b2f64fad1361400000000000000","merkleRootHash":"0xe8550353f84e0c531bd227bf4a599df82c42d29818dab719e0b71072ce199054"},{"version":"0x00602233","timestamp":"0x923da366","nBits":"0x07936019","nonce":"0x3f0e5ad4","previousBlockHash":"0x4b3e6ba7beffe56c65d8394820d77bf60aed66adf83471332400000000000000","merkleRootHash":"0xe251ca4fbe7841be75492ce8bcbf478e979cdf750c5122b0237c69daa7db373e"},{"version":"0x00c0cf2b","timestamp":"0xc43da366","nBits":"0x07936019","nonce":"0xb345bd4c","previousBlockHash":"0x387dc857a5e1d981bfd7a489b27bd996ab9f4343c81c52fb3300000000000000","merkleRootHash":"0x091290c2b782e591f6c08ba4d31217a2001a977fc5b692b90ca7b4fcd37856c5"},{"version":"0x00809d2b","timestamp":"0x7f3fa366","nBits":"0x07936019","nonce":"0x6e9c8bdd","previousBlockHash":"0xa04d768d95da8ef50e817eacf524f2baa25082ad0f5cb91a1500000000000000","merkleRootHash":"0x64eaa661fb0a12f66f46b4b240ce804c961d9f2c1bf1f27417c5352ae9fa8f88"},{"version":"0x0060102d","timestamp":"0xad43a366","nBits":"0x07936019","nonce":"0x1d501d1b","previousBlockHash":"0xa974bd6fa0ec546f02b926c312d08818b04b107716db89c84a00000000000000","merkleRootHash":"0xda93e746a2ef5df92375b4b3814a21d140b9182ba3cae6773b0c4c61adb0b8e4"},{"version":"0x00600c24","timestamp":"0x8e44a366","nBits":"0x07936019","nonce":"0x1a44df64","previousBlockHash":"0xf7de3b557c6f9fb448922f4c4e2dcd4159355938dd8f6a1d0200000000000000","merkleRootHash":"0xf233c0cb3bd2629ecb490cc35c7cac2e13faf95190ee9c9d9e6d8fa40495e869"},{"version":"0x00e09a22","timestamp":"0x9948a366","nBits":"0x07936019","nonce":"0x7ee18070","previousBlockHash":"0x2a6ca8b9288799d49606949f658bcd283ec2a34dc9d236f65800000000000000","merkleRootHash":"0x99e6a943be856b13db6a697b4eadf54ce3527a0a5318a139ee76440de4218423"},{"version":"0x0020af31","timestamp":"0xfe49a366","nBits":"0x07936019","nonce":"0x315c15b7","previousBlockHash":"0x727ca0c8ad45d29fd99fa0df29eb924f029fab8806edbc5f0300000000000000","merkleRootHash":"0x890a791cc7bdb97a6ac75cba9352d9a70409b8e1a41fefabc1b8230118c398a1"},{"version":"0x0020922d","timestamp":"0x5a4ca366","nBits":"0x07936019","nonce":"0x715cd383","previousBlockHash":"0x1d48b6e8cad43374f0021b669bd3588ffc6aa8d5a809f9e95800000000000000","merkleRootHash":"0x571010295b80404cc83c7b436fafa4f3a4406363361a07baebb1b04685e4b9db"},{"version":"0x00804422","timestamp":"0x2c4ea366","nBits":"0x07936019","nonce":"0xc24279ef","previousBlockHash":"0x1a4d5a42358347af8a3a7c2651d41caa4a1d96ea88d880134a00000000000000","merkleRootHash":"0xbc23f03099a99158cdd1e07e28fc8dd7d8ed762e791848db9911ee9fb570a17e"},{"version":"0x00c0a423","timestamp":"0x0b51a366","nBits":"0x07936019","nonce":"0x916f3f2b","previousBlockHash":"0x7b03e03df7537b0435c56645f1588310d7a4910e72c85fad4000000000000000","merkleRootHash":"0xdc69b6e8357c7ea176cb702836759a720a78ff186e2eec79e287cf1c78d371db"},{"version":"0x00000020","timestamp":"0xbf55a366","nBits":"0xffff001d","nonce":"0xd4267eab","previousBlockHash":"0x5fa80f6941a3a9b3d720b13b7eb7d67e3e1374d4678b66b53a00000000000000","merkleRootHash":"0x889d7f938e947002795a952c559a03873e37ca9dcf3d0968e5cc9d44a33ecef4"},{"version":"0x0020f727","timestamp":"0x5557a366","nBits":"0x07936019","nonce":"0x68013b38","previousBlockHash":"0x946725e023fe8201079de8416ef4f974f9997917932a464431db6c4a00000000","merkleRootHash":"0xd350739d9bc647311f106213af4ff3c1c0ecd7c29ccb4527380aa79a682a24d0"},{"version":"0x0060e62f","timestamp":"0x245aa366","nBits":"0x07936019","nonce":"0x2ac1893c","previousBlockHash":"0xf0384f62cf8f7f4bf763a7717f1c7e27a677bd67c48c71bb1400000000000000","merkleRootHash":"0x13c75c14edf3d0e0767f99d31423b804372c7fd610689c964f02153f493d091c"},{"version":"0x00000020","timestamp":"0xd55ea366","nBits":"0xffff001d","nonce":"0x4b0a902f","previousBlockHash":"0x4cb8d632e4f05ec400d07dc2b09a4a4c33420425586f72c74d00000000000000","merkleRootHash":"0x0e54c66cb9be9575e96f19820116192f3eff71b6daa5cb5328549fff631a37ff"},{"version":"0x0080512f","timestamp":"0xcf5fa366","nBits":"0x07936019","nonce":"0x330efaab","previousBlockHash":"0xcbf1bd6fc4e167949a098313bca7bd6d62ffd3c1fdba66e06b63ec8300000000","merkleRootHash":"0xae9072940447ea329821f71d3574a1c912b998ebca8edf7e290a44b8d8118b36"},{"version":"0x00000020","timestamp":"0x8564a366","nBits":"0xffff001d","nonce":"0xcb605d1f","previousBlockHash":"0x7ad1ac66859481008a9a24f1f62f2d841ee16627e0f997d02f00000000000000","merkleRootHash":"0xf7d5ef22be80777dcfdb38bc649e6438fa823ffd68499be1dc39e9e8eec0f4dc"},{"version":"0x00001230","timestamp":"0x9d64a366","nBits":"0x07936019","nonce":"0x3502b97a","previousBlockHash":"0x3d8187959ad7e193b45cf308a904bb2c6e8781d0f90df1e72d976bba00000000","merkleRootHash":"0x608fd948922ba156c37021a51fdafe85e6658f9899ed1ec694b79f115a013a0c"},{"version":"0x0000ea2a","timestamp":"0x5466a366","nBits":"0x07936019","nonce":"0x5966993d","previousBlockHash":"0xbc435d6db78b32af2969004ed40a18c84a84cf76ab4a879d5a00000000000000","merkleRootHash":"0xc835f83417dee745c8a3752743972df5e1303d42ce0dcddb03f1fcba733dd7c3"},{"version":"0x00000020","timestamp":"0x0a6ba366","nBits":"0xffff001d","nonce":"0x80540a49","previousBlockHash":"0xddfd6104efb4714a1b90f072db126efecbe0d7980afa03ff5d00000000000000","merkleRootHash":"0x16aa75ed80d7fd12354b68e378fd9142d1836ef868f78d6abfd307445d8e86a0"},{"version":"0x00800020","timestamp":"0xbb6fa366","nBits":"0xffff001d","nonce":"0x0e0313fb","previousBlockHash":"0x1d39c3a83990ad9fb88b8e3182431f178397a337c725c4857dcdd76e00000000","merkleRootHash":"0xeae1ec2ae36d5e2d249f7dba23631d0ebd09f53fc9d49842d7f0148476058954"},{"version":"0x00403d2a","timestamp":"0x8c71a366","nBits":"0x07936019","nonce":"0x56533433","previousBlockHash":"0x9c224d05d60d3a9534d0e42df00bb4aaf021147d57bd80cc53b74b0000000000","merkleRootHash":"0xe41061e9b6dfe27d83ec309d41bebdc8ba54d6aa73e88d6d681c047f41becfed"},{"version":"0x0000812c","timestamp":"0xd771a366","nBits":"0x07936019","nonce":"0x7a2d2ee2","previousBlockHash":"0x75c7ced988a789bfe84bc9350b6d2a98a84f3c4c9cca03ac5400000000000000","merkleRootHash":"0x7f298bacddae932d497f5d1e7b41e5f8290f879ec04233ded89cf91a801dc516"},{"version":"0x00e03221","timestamp":"0xe273a366","nBits":"0x07936019","nonce":"0x4e026d3e","previousBlockHash":"0x7c5c48443f3c612844a34dee13616bda5664d18a92f162f70700000000000000","merkleRootHash":"0x27f57858248b98d0bb4f09ba007942ab28c355d254bcd6ecf833797ae8e82579"},{"version":"0x00000020","timestamp":"0x9378a366","nBits":"0xffff001d","nonce":"0x0267d6f0","previousBlockHash":"0x29a26d1b7379ca5437b0e786c139c24d5f25bf4d2549431f0000000000000000","merkleRootHash":"0xae1c6a9d10b3ac69ab1758b7fa4a04c94a55ac337fcb0736b709b5ccae199a07"},{"version":"0x00409f24","timestamp":"0xf878a366","nBits":"0x07936019","nonce":"0x0e381c5a","previousBlockHash":"0x4700b6b65e72f49240daa875450289eaef10510b6788904e4a191ca300000000","merkleRootHash":"0x5ac6c414de90230e26e36bfa9b31c366db0e6f91d917fe74954dbc880f2d99f3"},{"version":"0x00c0ed29","timestamp":"0x5f7ba366","nBits":"0x07936019","nonce":"0x40d24821","previousBlockHash":"0x5e4f063b7bbb307127f2af4b3389b837074f08a0ccc5f9ec4400000000000000","merkleRootHash":"0x838671d454fef5b50575dee007250d228c8af6093a3aeb6173e6277b4b442544"},{"version":"0x00000020","timestamp":"0x1380a366","nBits":"0xffff001d","nonce":"0x00bec650","previousBlockHash":"0x4753d3d2eff191fb57848f713ba4bb19bf6b9ed0c675c4181100000000000000","merkleRootHash":"0x18ea28ddaec26f08ffddf36f6590523cc42a81bf280eb786854e312e96f21f3d"},{"version":"0x00405e2c","timestamp":"0x8c83a366","nBits":"0x07936019","nonce":"0x1ea9c602","previousBlockHash":"0x3a3a464f7a76cf48295dbeedddf52b3d19a5fa5b739513a9d01a1d8900000000","merkleRootHash":"0xb77abeaf5d8aba980321fd2b69cd55124653ab6c08c7dd8ebbe9afe7702e313e"},{"version":"0x00c09e2c","timestamp":"0x4584a366","nBits":"0x07936019","nonce":"0x916e7a1f","previousBlockHash":"0xb4c11f827b8b8d7cadae2339e76a7bc32108fec8026f9dfc5c00000000000000","merkleRootHash":"0x7db719c7d702506531bdfa82f6d036242bd18fe0172e17733fb3f4d3f633302e"},{"version":"0x00c00f20","timestamp":"0x9e85a366","nBits":"0x07936019","nonce":"0x19957c63","previousBlockHash":"0x3e62d669d96e3868425ca6204ff559f06f8a694d8d0166cb0500000000000000","merkleRootHash":"0x4d7b783f295e441e1b6d07422584d1f7fc99195f8ee72dd4edff67f055e2a10f"},{"version":"0x0080ce23","timestamp":"0xa289a366","nBits":"0x07936019","nonce":"0x009d379d","previousBlockHash":"0x4874221cd44892f0f1cd64c0d903aec6721f49cfaa9db4783f00000000000000","merkleRootHash":"0x6d36eb374456f547487e13a3d748e2477d7df2431a5654dc4aeb578980d271eb"},{"version":"0x00409625","timestamp":"0x128aa366","nBits":"0x07936019","nonce":"0x1e6d987a","previousBlockHash":"0xccec643fb0f097a9fe93e19d6bf73b979dac56c382d064f40900000000000000","merkleRootHash":"0x919930666141cac6778e11c4fe01dea101af9c99ad741b829f8d5cfcc42c79e4"},{"version":"0x00400628","timestamp":"0x928aa366","nBits":"0x07936019","nonce":"0x429218b2","previousBlockHash":"0x22aaf35094a803a5de10994f3acd7da164b12962c6d7dd795000000000000000","merkleRootHash":"0xa591b5616e89c9dd70e4b7e9f4c6fe5dcfb8d50a9f3771083f606a475e74df78"},{"version":"0x0040e324","timestamp":"0xbf8aa366","nBits":"0x07936019","nonce":"0x263017d9","previousBlockHash":"0x97d2321bf722321209f704bf3d4b9a1ebc99cca5921a00d91000000000000000","merkleRootHash":"0x268c6f4bbc021004830300bf3de3a06014f4ccced39d91ebe854bd6bd5a7eab5"},{"version":"0x00a0e631","timestamp":"0xe98ea366","nBits":"0x07936019","nonce":"0x1458dc9c","previousBlockHash":"0xbf6740060bceff161344efc0ba9b45e47d2751f668066ba51900000000000000","merkleRootHash":"0xaecd6cbc4195fe2ec4de49100ae6834ae43b368401e9da65f8141c2eb9311918"},{"version":"0x0020b82b","timestamp":"0x178fa366","nBits":"0x07936019","nonce":"0x5b109ef9","previousBlockHash":"0x0626435e6d89fed1636a1c89e239bfa3ee6fdfc1c77237f21900000000000000","merkleRootHash":"0xf0f2980aca6be228def70ebbe4f788eb4813cca430af09493406c9e4750e267c"},{"version":"0x00000020","timestamp":"0xc993a366","nBits":"0xffff001d","nonce":"0x37c64532","previousBlockHash":"0x4cd4476ed9af88faa7f52413e8d0ff2a7cbbb31773e72fb40700000000000000","merkleRootHash":"0x7b78e52b7eb8ab860b1c9c1936afdc5921d1fc34f581c0b148fbcbc1a006e26e"},{"version":"0x00006a2c","timestamp":"0xf496a366","nBits":"0x07936019","nonce":"0x368d16ac","previousBlockHash":"0x1092fb9fa62361f7970ec2928a4c093a8f77f9362dbe92d8a79c903700000000","merkleRootHash":"0xac162bc80bd3371b793cceffcfab649d4d1bfe968c4eca4c38582741dbc9ef17"},{"version":"0x00a01532","timestamp":"0x6297a366","nBits":"0x07936019","nonce":"0x5690d365","previousBlockHash":"0x57ec2c862054959eb7413831fae1c670908e819fecbb6adb1200000000000000","merkleRootHash":"0x08b9b3cee626cac6e6133603d5dc732c652a341574b9cc7e9d46c37a9f3e7a72"},{"version":"0x00a00727","timestamp":"0xde98a366","nBits":"0x07936019","nonce":"0xcf3533f6","previousBlockHash":"0xf0d73427dc58fcfc3f09bee266393436dd4df9c9ed103d0b1600000000000000","merkleRootHash":"0x130b25c566352186e60e569d013affd0bf7e9c62cf0c83931ca719e373af9cde"},{"version":"0x00c09833","timestamp":"0x7b99a366","nBits":"0x07936019","nonce":"0x5511d301","previousBlockHash":"0x293d71a2a474db622f956d979b93ae7ad3c22428e20a6ded4800000000000000","merkleRootHash":"0xae0e10d4cb391772f5f6c37e57e01dbada9fb40b8e724290350db74fb691f4f9"},{"version":"0x00000020","timestamp":"0x2d9ea366","nBits":"0xffff001d","nonce":"0x60312509","previousBlockHash":"0x8d458e2bd060856d36bf692470cea03d6e2cb0b44e2be3f82100000000000000","merkleRootHash":"0xba1277e035452253e8a85209990c8d03e09fd316ce1ed16c1fe463113b6a6f88"},{"version":"0x0000df2e","timestamp":"0x979ea366","nBits":"0x07936019","nonce":"0x5605e233","previousBlockHash":"0xa5cdcf9d7ccb7709a189cb584369bf8bdc29c613cc236ac5dfd1922500000000","merkleRootHash":"0xca060e398c60a7b5df3777a0702342f0582edb5cb01bbaeb5c20d796b0e82fb5"},{"version":"0x00603429","timestamp":"0xe0a0a366","nBits":"0x07936019","nonce":"0x70073f33","previousBlockHash":"0x5279963c11fa390d699fcc0366e8dcfb5d5979bfb55e78a75c00000000000000","merkleRootHash":"0xf034395dfc07a841eed52dff9656c7bab290a5375cb7b15e88c9fad3257c8b2d"},{"version":"0x0020372b","timestamp":"0x27a2a366","nBits":"0x07936019","nonce":"0x5cec6f52","previousBlockHash":"0x792437dc4aac7f20564d8c8334d696c90418f4fe937e241a1d00000000000000","merkleRootHash":"0x4899807bea58f89a3c5f2d38234bf6a184f6b9eabfeddc96e5be802179561065"},{"version":"0x00004e2a","timestamp":"0xe5a5a366","nBits":"0x07936019","nonce":"0x5bb02261","previousBlockHash":"0x6f3ec04d01bd4f5da088f13503cb5848326a8b31b50bfbd05f00000000000000","merkleRootHash":"0x59ce8d319f7c0d57ba630177f8d7e26795cd48bc65eaa7bdcff8432688827ebd"},{"version":"0x00406121","timestamp":"0x41a6a366","nBits":"0x07936019","nonce":"0x6d06edba","previousBlockHash":"0x089563e61241e5f5d3538021ff1e36adadb28d535136ba253200000000000000","merkleRootHash":"0x4efb1939a6972718383effaac15d946e26468c48e9ddeaa1f732560924823f14"},{"version":"0x00a0022e","timestamp":"0xe6a6a366","nBits":"0x07936019","nonce":"0x1c5ee0a3","previousBlockHash":"0x8d9c38f7d69fa5d518fc394501952f6b538a693a07e044295100000000000000","merkleRootHash":"0xbd5081b76758bbc83cf1b2e393b7a475f7e16f6af67e5a648a66fb22fc748f11"},{"version":"0x00c0e72a","timestamp":"0x6aaba366","nBits":"0x07936019","nonce":"0x7b2ec1da","previousBlockHash":"0xabc64447ba9a2265a7fd822c6934ed59fd6693fce24140ed3700000000000000","merkleRootHash":"0xa35bac2149d64db19cf49be990b3de407fdb6b33acac98fcb08f9219e8eed3c3"},{"version":"0x00e09220","timestamp":"0xf0ada366","nBits":"0x07936019","nonce":"0x60328691","previousBlockHash":"0x28deea48be8858ba91b82fbe6c34ceef1c92e505006e71332700000000000000","merkleRootHash":"0x1c9947c7a078f92c21ff4d6e89bc6cd2e34ae60fa24814a6c2d28891f058450c"},{"version":"0x00601430","timestamp":"0x84b2a366","nBits":"0x07936019","nonce":"0xcb130b6d","previousBlockHash":"0xc812a4d74d91d0b83084a270b514fa227089d37f169d69cb5c00000000000000","merkleRootHash":"0xf9d1f3b9ddbfd6c582a8221198fe2edf036a35f5df6058972e5e347b05c9815c"},{"version":"0x00008020","timestamp":"0x72b5a366","nBits":"0x07936019","nonce":"0x2c8b7d6e","previousBlockHash":"0x931f5ad5be15d495282910a0b384a465429eb6687d31cd032200000000000000","merkleRootHash":"0x500e413f30997ed47919d7a9bb622285954092ee4c97c060b4b2835d5f8c4c73"},{"version":"0x00000020","timestamp":"0x24baa366","nBits":"0xffff001d","nonce":"0x55631d6d","previousBlockHash":"0xb049bb9c696343c1af2c2c1e1f85040f9149ce53785eaf831800000000000000","merkleRootHash":"0xc0242c92760b58374546dc34a7b3b51baaad8a0495b105addc495aad197ce9ff"},{"version":"0x00400020","timestamp":"0xd6bea366","nBits":"0xffff001d","nonce":"0x404db863","previousBlockHash":"0x74ceffd3616a1ef6c2a34fcb02cf5f9e0c54886e4ecea784a662d8f500000000","merkleRootHash":"0x43b3a8be16762b1dcc7b6f0a7dd3f1b0676688a62197f7cef3b047514e3074e0"},{"version":"0x0000c020","timestamp":"0xbabfa366","nBits":"0x07936019","nonce":"0xb45d1a93","previousBlockHash":"0x50c6318f3f2a28aa447e9377f77ab5e6caa9982fd32d05dfb02ba80000000000","merkleRootHash":"0x4da33b9b21ec6abcd17e05ef133de43a987322d859243cdd7942bd941953c3ca"},{"version":"0x0060bd30","timestamp":"0x3ec3a366","nBits":"0x07936019","nonce":"0xc14715c9","previousBlockHash":"0xa3c2943f547ee3a46087cdbeea925abf9f181749cb68184f3400000000000000","merkleRootHash":"0xe5798aa34d742951d175bae83d817db853d0c198f6c0b4068a6e66f104d111cd"},{"version":"0x00a07225","timestamp":"0x8dc4a366","nBits":"0x07936019","nonce":"0x2e8e1a1f","previousBlockHash":"0x6cc57d23a7dc8e11e0079e702041d1e3921378a1ae669a2e2100000000000000","merkleRootHash":"0x620f70bbfb5531979556bcc81d5f9dea893faef26e3839d299852347309ed161"},{"version":"0x00e0ff3f","timestamp":"0x40c9a366","nBits":"0xffff001d","nonce":"0x68cf17a4","previousBlockHash":"0xbacfb28904ea94c2775b2c65a58a800148728473310a19ea5b00000000000000","merkleRootHash":"0x518dfa63b3b789077ff7498fa4701bf2eb98b202b5d9616b9e8d725779666130"},{"version":"0x00e06525","timestamp":"0x8ccaa366","nBits":"0x07936019","nonce":"0x2204a51c","previousBlockHash":"0x25d60bf6db53f9955022b163b3378593ccf10539fd92e73af246020000000000","merkleRootHash":"0x8124df2e9b6c90a8965e865303e9fff105004e7e53f974f5a4d9d5ad5dd5c920"},{"version":"0x0040fd2d","timestamp":"0x8bcba366","nBits":"0x07936019","nonce":"0x7e2ce76d","previousBlockHash":"0xd809b28b41920d56acc125361b97dc71868947f69e36b4a63500000000000000","merkleRootHash":"0x9b193c01b5f3bfc3fc84d87cb845a2c67cb2f971727a862900b989a8803b80e9"},{"version":"0x0080bf22","timestamp":"0x3acca366","nBits":"0x07936019","nonce":"0x09d05623","previousBlockHash":"0xd133eacacd618d46eabcbfc08c7fc3a39fa8cc70b9635e325000000000000000","merkleRootHash":"0xb944b01d4182a39f793eb2fa05d052a6c04805177fb3d0e3495b731356212fa2"},{"version":"0x0060b420","timestamp":"0x4fd0a366","nBits":"0x07936019","nonce":"0x80a879eb","previousBlockHash":"0x089e30bf1e03203bd5cc8a03589050bd7c893c00f374df0b3c00000000000000","merkleRootHash":"0xef8025b1e44245bc79616945119f3e0abbb6d2ed376805315223e05560e91ad6"},{"version":"0x0060082f","timestamp":"0x4ed1a366","nBits":"0x07936019","nonce":"0xcb29e287","previousBlockHash":"0x83ec54814820f79408c55732761c2f8fd163786932a1b9e04100000000000000","merkleRootHash":"0x68554ea5c7a6e87914e5100a9950669559a2c09bbd9aa6fe46d40101b258a9cf"},{"version":"0x00004020","timestamp":"0x03d6a366","nBits":"0xffff001d","nonce":"0x868f0e27","previousBlockHash":"0xcd3b8640e93c46e5e2c02bb7bacdf6b0eee98b4f5ba69cd80300000000000000","merkleRootHash":"0xedfccde7d52dd9c3fccb065e5fd6fb74fac7af4e8829cb1aa6f243be14128423"},{"version":"0x00a0e123","timestamp":"0x93d7a366","nBits":"0x07936019","nonce":"0xc448e3d5","previousBlockHash":"0x2ed1d0a537f479dc12da2b00ddb9fac0d9dbb16fa17cc4d5de7b010000000000","merkleRootHash":"0x75ba211c94a5ce4f5995187e3197366b0ebeafb33b45256d017f6173218e2762"},{"version":"0x00004020","timestamp":"0x55d9a366","nBits":"0x07936019","nonce":"0x2e82ac99","previousBlockHash":"0xd11dba2cf0c01c1edcf04cb9360663490880dbc262c231a21100000000000000","merkleRootHash":"0x6f8e6a5eaebaf3063bec9f88851d826781fb9497f44f3f793ca1856d0af6b53e"},{"version":"0x00008020","timestamp":"0x09daa366","nBits":"0x07936019","nonce":"0xbd0d4ecb","previousBlockHash":"0xdea83aa74b26be7cfc278dc1ae5e8f400b23312c7b0e027e4700000000000000","merkleRootHash":"0x0e3dfe13948e45ea602f3322e22b8ed5110672239d046ccd9a67a4dec0130576"},{"version":"0x0020902a","timestamp":"0x0cdca366","nBits":"0x07936019","nonce":"0x5040b158","previousBlockHash":"0x36bffe154c1ea13aba4454db07e31f0f6d91de997525ea692700000000000000","merkleRootHash":"0xe6575c079a384b669261095d93595f5acc711f9f0d76322be85435f5ad18234d"},{"version":"0x00607f2a","timestamp":"0x00dea366","nBits":"0x07936019","nonce":"0x0a16602f","previousBlockHash":"0x9f27bb0acbf2b1b4a928d475b9c54ff0f0a2dcbb075843f94300000000000000","merkleRootHash":"0x2e726cbca0c1215806034a76e5d1726e4dbe333056cb0d88bdf8cc96cbf8cc52"},{"version":"0x00607b31","timestamp":"0x56e2a366","nBits":"0x07936019","nonce":"0xbf2a57d0","previousBlockHash":"0xccdd5965edb7d8e7a6e89c46424a5241cc602db9d5aa698a4b00000000000000","merkleRootHash":"0x3dd61b531917ab984188b323759b6771787a81dbcb484f41b1b58de0ee6ca94d"},{"version":"0x0080902e","timestamp":"0xece2a366","nBits":"0x07936019","nonce":"0x4e74abcb","previousBlockHash":"0x3153ee640d8df7f6c1db02a28baa7b9a1c6382979b9958392a00000000000000","merkleRootHash":"0x4f28542eafd32e786267d9652392e77de9a786c296894f7a41c3fc1d779c0a25"},{"version":"0x00000e32","timestamp":"0x87e3a366","nBits":"0x07936019","nonce":"0x031e02d4","previousBlockHash":"0x058a6cfd8098b70eb4fd4e60f839da0512589663763682d05f00000000000000","merkleRootHash":"0xff05829faf088a16842e4751ae37fe13229f9030d2bebe116722c937d964df90"},{"version":"0x00202922","timestamp":"0xa1e6a366","nBits":"0x07936019","nonce":"0xba00552c","previousBlockHash":"0x8919058c326402c20168ef46e0a201d8a06a010fe78e7d683f00000000000000","merkleRootHash":"0x84ff47f9d747ad261de007da3188eb153dc6a19cdb115975026bc0547fa04098"},{"version":"0x00c00120","timestamp":"0x5beba366","nBits":"0xffff001d","nonce":"0x1a0ae00b","previousBlockHash":"0xcaa1827a6d10f899c0c6a5ca174b409ac83dddb900fc039b5e00000000000000","merkleRootHash":"0xd04d7f40fb5a06848c7ed6228b3f88797c328bcf4f8157a1b967613487717569"},{"version":"0x0020f028","timestamp":"0xfbeea366","nBits":"0x07936019","nonce":"0x147919e9","previousBlockHash":"0x8d825f83068f1fc8ed408a31beb30a8072a1ba0aab43bf372fc64e0000000000","merkleRootHash":"0x5893d01245ad4f580ffcf245526ce4bc7019e82e8b05ab03a80d6a493292d8eb"},{"version":"0x00c04926","timestamp":"0x62f1a366","nBits":"0x07936019","nonce":"0x9b652f57","previousBlockHash":"0xf319d0300cf0863bd144824300d8664fe10b72fe20af3a425e00000000000000","merkleRootHash":"0xcc843be6725a79720cf364bf4cc1bfa7e78aa8473811fbf8f4adf95e5cf40fee"},{"version":"0x00807121","timestamp":"0xd5f1a366","nBits":"0x07936019","nonce":"0xce3022fa","previousBlockHash":"0x504c1b44915902f64abb3667f429692da9922f350e6c05595a00000000000000","merkleRootHash":"0x8f81e0ee0cea416e30d261a8d5c36be899fd944e6121847026afa0658af999a0"},{"version":"0x00000020","timestamp":"0x86f6a366","nBits":"0xffff001d","nonce":"0x16ce0e08","previousBlockHash":"0xc28b20cf4be2bd17f6865d7bde8dada72647bbf9671598422d00000000000000","merkleRootHash":"0x067e8a3e691e5ac95778e574748e39560799b885d4118d1b4830c0411d0228a4"},{"version":"0x0020c724","timestamp":"0xcff7a366","nBits":"0x07936019","nonce":"0x84e9167c","previousBlockHash":"0x0a41c5ee56c7b09245a7c4b8de1d9b1f6886ab88e868d792450d880000000000","merkleRootHash":"0xff8520e56aaa38d74894edebe091fe35fc9a7fac3546f8953553f37db75bed89"},{"version":"0x00800120","timestamp":"0x82fca366","nBits":"0xffff001d","nonce":"0x4a1fc9e6","previousBlockHash":"0xa9eee84cd9c6a9add3d2768191d2f2eb0e377d633a7b57525600000000000000","merkleRootHash":"0xcc43a91fff7241ba509749d95b3679a91598eebe3a345a40efd45ffe935cea33"},{"version":"0x0020542d","timestamp":"0x4dfda366","nBits":"0x07936019","nonce":"0xb0ef269a","previousBlockHash":"0x983bbde228bcb7362463fbafdfec1e0d411f81f5fe13d73d55e0150000000000","merkleRootHash":"0xc0d5795bd9c0bbd06185a33e38affbd7d4537b5fdbc41f5ed4082c53636379a2"},{"version":"0x00008020","timestamp":"0x59ffa366","nBits":"0x07936019","nonce":"0x08eeaddf","previousBlockHash":"0x6f51376a27a700646ba502738580a21fde04702c258cadbc3d00000000000000","merkleRootHash":"0x3dd0b973b5e46866c7246655f630e4ab38cdf1c5408829ce1b4f74b053658eef"},{"version":"0x00a08423","timestamp":"0xfd02a466","nBits":"0x07936019","nonce":"0xb5290872","previousBlockHash":"0x58f99c788eb948d072b90f760d2e15d6947a1c67757697682400000000000000","merkleRootHash":"0xd6f013d01f407a2b383ca44b465dc100c5dc38361f9d9cecf2ccfb63e50bbda4"},{"version":"0x0080b324","timestamp":"0x8804a466","nBits":"0x07936019","nonce":"0x504925ab","previousBlockHash":"0xabe3940bb368302f28d0a791428a8c45526c2c239cc2133b3c00000000000000","merkleRootHash":"0xc123f95f10c489a23b1c8fb4a1f01e74c6283dd9b8950f56660c7a4fe9503ca7"},{"version":"0x0000c725","timestamp":"0xa604a466","nBits":"0x07936019","nonce":"0x3aa590a9","previousBlockHash":"0xce59013641990b86f5ec9429d08ec1182b3361a22392fd624a00000000000000","merkleRootHash":"0x236aebc8f67b540e6d2867e6dc5c07b1cc97b9a3fc4ca6396416958f73452a34"},{"version":"0x0020312c","timestamp":"0x7805a466","nBits":"0x07936019","nonce":"0x2270908d","previousBlockHash":"0xfedb8ddb746d15879cd67b58928cf6bdb8f043d7f48239c73700000000000000","merkleRootHash":"0xa01e0355f6a2db11fc6e8347ce187134ae07ae782c173fd4d1642be79dffbeec"},{"version":"0x00806526","timestamp":"0x6f09a466","nBits":"0x07936019","nonce":"0xa3506455","previousBlockHash":"0xd388e1c484b0763fd2e760dfbd601a990a8e6950e986ae014f00000000000000","merkleRootHash":"0x3be84900eea60ce5f83a0a3dd0b4238c8859081fc3c8ebfccc56b8e58b73ee18"},{"version":"0x00600f28","timestamp":"0xf109a466","nBits":"0x07936019","nonce":"0x84aca7be","previousBlockHash":"0x16a5a06ea594d6d16d542fb1a4faa7db1c72a8f0682e30ea3800000000000000","merkleRootHash":"0x3c0849eb1ba5f59d874dbc3680e0c017693355c4bf58667f73ffaf83b5cfc8f1"},{"version":"0x00800421","timestamp":"0x930da466","nBits":"0x07936019","nonce":"0x07884a2d","previousBlockHash":"0x199c927144e0eb561c8fe7ca8361ab982dbcb3c4d8bc7fd04800000000000000","merkleRootHash":"0x94048b06d3289f09853a65e91d01f27cedc668577f4f847b5a067cd62d86ae12"},{"version":"0x00e0fc2d","timestamp":"0x1e0fa466","nBits":"0x07936019","nonce":"0x60ec0fd5","previousBlockHash":"0xf3493e992b93b349d3d74334ca5d4120976fc2aade4027343000000000000000","merkleRootHash":"0xbd6f3a4ff90076703b39571b9d68010afc54f283d2c0911de2cae33ba4149d3e"},{"version":"0x00407b2b","timestamp":"0xe411a466","nBits":"0x07936019","nonce":"0xa8690e7a","previousBlockHash":"0xf92ac681d32cfff704c116b7edf9b8a29505df5e6cc609313f00000000000000","merkleRootHash":"0x86fcb2ab7300bf1f5cd145e4eff366765ef7844483f1b990c4ef5d7777c1a868"},{"version":"0x00604432","timestamp":"0x1112a466","nBits":"0x07936019","nonce":"0x98298967","previousBlockHash":"0x53b8095c0a079b719b0d9892dd9e7978fd948f87eceb808d2a00000000000000","merkleRootHash":"0x6ed8d2555de41b8c4ce697c4b9a63aa1673e9aae0543c1d09bc3ae1241f9797e"},{"version":"0x0000c020","timestamp":"0xc512a466","nBits":"0x07936019","nonce":"0x0f125f92","previousBlockHash":"0xa3801330065d5fc2b2a8d2de00beb83c9ae3211cdf62d7ad3100000000000000","merkleRootHash":"0x17845d7bd00efeac4601a03642d26139ff809928f94adff2d4202985c47018fe"},{"version":"0x00000020","timestamp":"0x3014a466","nBits":"0x07936019","nonce":"0x844c449b","previousBlockHash":"0x2debd06f7c4bfadb492fadb1161758bb3a42dba27c7301422e00000000000000","merkleRootHash":"0x7ed7d9f014cd4e5596abf92a48b385e064315c2ae751631ec07441518c523504"},{"version":"0x00607623","timestamp":"0x1516a466","nBits":"0x07936019","nonce":"0x062c767a","previousBlockHash":"0x0efb57e6eb6dda4cb108bc7b865ce8e91f0b9d8f303297ef3500000000000000","merkleRootHash":"0xe5ff72848c12619d72f1fc7904e42790a9bd19178a240a9ac1143536dcb0f0fa"},{"version":"0x00403129","timestamp":"0x7416a466","nBits":"0x07936019","nonce":"0x0e253b4c","previousBlockHash":"0x9988a06d9bd54a3e836de4b2ea433876ccddcddde642991f2b00000000000000","merkleRootHash":"0x973bcaf08868d37bf3b9c2bee8afa62c7df02b1061340406d3e342df00b9cd15"},{"version":"0x0020d22e","timestamp":"0x0c1aa466","nBits":"0x07936019","nonce":"0x14a0f8e0","previousBlockHash":"0x2cc01ad6780ae55936198e0c3367391afc1dc19659d457671300000000000000","merkleRootHash":"0x0712880198c61806aea05198ca5913eee051ab56e98666d333922c0a18a48498"},{"version":"0x0040ce27","timestamp":"0xd11da466","nBits":"0x07936019","nonce":"0x151c8e40","previousBlockHash":"0xade74f9ed6ca9dd583ad62837b360dfd2a514b7a79067e205300000000000000","merkleRootHash":"0xf3ab3af8e26e01e5123ea1d441625887a28e9785d3de3f2c349341474df252eb"},{"version":"0x0080a522","timestamp":"0xde20a466","nBits":"0x07936019","nonce":"0x801cb887","previousBlockHash":"0x67166c7bd2aedeb08c636b29fdcecd6564c2e4910fcfe2652f00000000000000","merkleRootHash":"0x3264d48eb6764b389b1ba4948231e09c704a69d79fb7476facb3f2943b0e6c1b"},{"version":"0x00e0a32d","timestamp":"0x5d22a466","nBits":"0x07936019","nonce":"0x5584d8b4","previousBlockHash":"0xa6203a0d53c9322e77324c9cd7c15a8bee8023344d08ea3f3b00000000000000","merkleRootHash":"0xb9a739a5f0f671ce831c7ef3afcf97b3f7bfc166ff1ea16caf5a70c94f661f76"},{"version":"0x0040d327","timestamp":"0x5f23a466","nBits":"0x07936019","nonce":"0x3f1038d2","previousBlockHash":"0x07af01cf3cb186032183c08b942d4271bd2fbbec023dc0d42400000000000000","merkleRootHash":"0x36d6a15b6a05ff131acafc55ce9dd033e78085461a5ba0061e0f16d2aba74c2b"},{"version":"0x00402730","timestamp":"0x2d25a466","nBits":"0x07936019","nonce":"0xa8b4ac50","previousBlockHash":"0x0ac43c14f83d0db9b8886105bbefee1a9a8a2f1f63e267741f00000000000000","merkleRootHash":"0xf09bf326a786f394c2ab67dc36e9c04ca935b1b0df2e1a13f46a593000c6edd4"},{"version":"0x0080c12e","timestamp":"0x9029a466","nBits":"0x07936019","nonce":"0x54bce3f6","previousBlockHash":"0xb2e51ff5dcb9bc639959900e74f97c1d5da781b84d018b1e5c00000000000000","merkleRootHash":"0x891b1fcebe81a24c4b89c087911be1e874f443d05ff325812a736b4eaf949c8a"},{"version":"0x00e0ed2c","timestamp":"0x702aa466","nBits":"0x07936019","nonce":"0x0c513302","previousBlockHash":"0xfa15b2a9f2ab5c132fddf85eeaa18f5b100d82c5e9026db12600000000000000","merkleRootHash":"0xe321eddbe6bac322f605408ad165cbf66da986da6a959ed436f7e6bb172b6f64"},{"version":"0x00000020","timestamp":"0xf92ca466","nBits":"0x07936019","nonce":"0x3f5f65b5","previousBlockHash":"0x6a33187b898f0055b85eafbb64f3d19a015e0a8e3b29590e5f00000000000000","merkleRootHash":"0x9f8cbd6d969699563f541d3ee00e32cc160c5714a72426bbe00f68b0611f255c"},{"version":"0x0080242a","timestamp":"0x222fa466","nBits":"0x07936019","nonce":"0x286874a8","previousBlockHash":"0x43445fe8cd89bde1c745dc74a87e4918b17f3037183c24772f00000000000000","merkleRootHash":"0xa797b37ac01581671ab9ae273a89c9b968d6aeefa4e16ad492287508feaf97e5"},{"version":"0x0020ae2d","timestamp":"0xb72fa466","nBits":"0x07936019","nonce":"0x1b94abc5","previousBlockHash":"0x75475d1b0bcda597aa6ff0c08e761c16fc40dd681c7f99411500000000000000","merkleRootHash":"0xd68b70c6715378393acb4d09194ad9fb0b531da0abf06436fd9b1b3c059c5033"},{"version":"0x00004020","timestamp":"0x1630a466","nBits":"0x07936019","nonce":"0x40433378","previousBlockHash":"0xa1f012f295ec467551863ceaa9cd872ef24ecb14100395871400000000000000","merkleRootHash":"0xee1d6b1aca0f3977ef58699e4cf1a9fe379a086a9732db30ab53a0e72faad102"},{"version":"0x00e0e125","timestamp":"0xd331a466","nBits":"0x07936019","nonce":"0x4d157f2a","previousBlockHash":"0x4f5b33faddbec7ddefc99fb240c3c4112df6b29ba46c6ca30c00000000000000","merkleRootHash":"0x24919a150ad43658992d5253fd93a63cd87404d41a7abb028c1cb7cc60b39621"},{"version":"0x0060dc24","timestamp":"0xd332a466","nBits":"0x07936019","nonce":"0xcf4cb619","previousBlockHash":"0x61585c2965b82c855d53fcb4fec549313324dcc93d8fdf8d4100000000000000","merkleRootHash":"0xbeb61f3f8a4a35b05b89b9a940bb9793fc317ea707a4fcccafeb1ff68c8551ba"},{"version":"0x00800221","timestamp":"0xfb32a466","nBits":"0x07936019","nonce":"0x2d5a7a2c","previousBlockHash":"0x250cba8fa1d981695802148e4615c3261b63f72f9ceb1e271800000000000000","merkleRootHash":"0xac90bb47a4f38712b0f41b4f63cd2ea877e34560cd61eb2b9fa493191f2b5a60"},{"version":"0x00e0be20","timestamp":"0xa033a466","nBits":"0x07936019","nonce":"0x9f8c84d6","previousBlockHash":"0xa27e193c7391eca72bb17d7f23234a20df3593471c761baf0f00000000000000","merkleRootHash":"0x568ce59c1e19bea17a56e581a55adeebe7490ae8667b1b73877fcfbf35392fe6"},{"version":"0x00004020","timestamp":"0x6735a466","nBits":"0x07936019","nonce":"0xa3d78782","previousBlockHash":"0x4942c726fedcadbca8accf828cfc7125ac9be84237a0ae913d00000000000000","merkleRootHash":"0xd4077a3bc67fc17e5aa65f58c6570d0ad76da314a3366d97402c50d8c1e6b245"},{"version":"0x0080be21","timestamp":"0x7235a466","nBits":"0x07936019","nonce":"0x806611ec","previousBlockHash":"0x017192ed4267be0dd6a4dd5fded86527edf314640a6948a93b00000000000000","merkleRootHash":"0x090c8b778a2503ad2a43ded8cd32ed7ad9c47e5c1363244f8198049e99f22374"},{"version":"0x00008020","timestamp":"0xad35a466","nBits":"0x07936019","nonce":"0xd27024de","previousBlockHash":"0x68da8a2c6fcead07db24d1a59292a85daf2e16496fec2c032800000000000000","merkleRootHash":"0xc9c0b6c4c5d983750616738335aee2309e0b9113bb7df95cf00ea4e2c163cc90"},{"version":"0x00e0fe2a","timestamp":"0x7b38a466","nBits":"0x07936019","nonce":"0x64d42766","previousBlockHash":"0xf0bff10d7f20c2814e0b51d54856113654212c58750e0b711f00000000000000","merkleRootHash":"0xf63f0d66e288d8e9f0dbd511f9283da61c4e305f22e2620a6243c967ec59b9db"},{"version":"0x0020d528","timestamp":"0x123aa466","nBits":"0x07936019","nonce":"0x6cca7d58","previousBlockHash":"0x90368bfa7d0b18d58291df092c2f821f730bfb5b5e1aa0b50600000000000000","merkleRootHash":"0x0fb887766b9dadbf8391c7476c937fa45d4ad388d1117829746f0fe321c6b70f"},{"version":"0x00400424","timestamp":"0xee3aa466","nBits":"0x07936019","nonce":"0x0624b921","previousBlockHash":"0xf10c22a47f01c8623e7f9256f59cd10cdbc556651efe65855a00000000000000","merkleRootHash":"0xe92e5033bd0cf46493c29d91c76227e0b72fb6b4e6907581de91cfd1ac07bb94"},{"version":"0x00000020","timestamp":"0xa03fa466","nBits":"0xffff001d","nonce":"0x809a8287","previousBlockHash":"0xd1982df80ca52772c9a5a05ee358350d1f86d962b7e1a4383700000000000000","merkleRootHash":"0x3044b597abfedccda641996a7e3ae77a447686baa117a807d7587640d9b2090d"},{"version":"0x0060b531","timestamp":"0xe541a466","nBits":"0x07936019","nonce":"0xd4d9fa87","previousBlockHash":"0xae86d1e341a34f5c0bed6af9d8adbb1e7d53da1ca527ab6c67dd6d7c00000000","merkleRootHash":"0x13b1b657311a6ccb5d200f06cc1fc8eeb6f252e60ddccce05d3fa0d15c5a4e0b"},{"version":"0x00000020","timestamp":"0xc742a466","nBits":"0x07936019","nonce":"0x8b804af9","previousBlockHash":"0xbc8c4515a8006bc3597874d601b635090ea917f2617929314000000000000000","merkleRootHash":"0xdfb741129f69dafb795ae8583e1581ea4a689b230dd1ef3f060fb527b477f092"},{"version":"0x00808f2e","timestamp":"0x7e45a466","nBits":"0x07936019","nonce":"0x6898a0d6","previousBlockHash":"0x43c3335b74a5d41e115272bb1387ec99b0e841cba66d544b1900000000000000","merkleRootHash":"0xa7a7aac82094bb3e17d7e62b8c88404214c1956d11f9391d4178d370df299a49"},{"version":"0x00c09533","timestamp":"0x0647a466","nBits":"0x07936019","nonce":"0x5b560761","previousBlockHash":"0x82b701f2b3675aa70d78a1e9365f04533be1920ab94915c53f00000000000000","merkleRootHash":"0x9c9d39755732bc5e7d1f285b5c058b970b8ead13cd4aa5ea3a50b7bc461bf403"},{"version":"0x0080bf24","timestamp":"0x0149a466","nBits":"0x07936019","nonce":"0xa8560f82","previousBlockHash":"0xe7790e06429a8f2066070b28e13e76a68875d6dc20599f1a1100000000000000","merkleRootHash":"0x314c8cef5fdc8a2ef030da971296be19bbb8d33bbcba69fcab714b99e736b8a4"},{"version":"0x0000c223","timestamp":"0x944ba466","nBits":"0x07936019","nonce":"0x1421e620","previousBlockHash":"0x04599818143ef2d74101e3c1b7220bb6abb3c401a15eb0c63c00000000000000","merkleRootHash":"0xcd7e2abd878b8a2076116f09bf268ebf09d9d164864a069dd981a1dc275c85d4"},{"version":"0x0000372a","timestamp":"0xf74ca466","nBits":"0x07936019","nonce":"0x7f9a4c0f","previousBlockHash":"0x43c4c3c769d3ea848005738fccad3a3b1c98d9e3e25f00502c00000000000000","merkleRootHash":"0x9beae1d7e44fd024584e12bd28e0bea6d43632389fe2f87e0fb1597344cd5553"},{"version":"0x00000020","timestamp":"0xab51a466","nBits":"0xffff001d","nonce":"0x400877d6","previousBlockHash":"0x0a9300580ce2264867d66bfc5aa142ce23c51fb0257522a34100000000000000","merkleRootHash":"0x934089cc92b8ccb6d0c25353f62c15ba68d040eb73a55f479c417c3b6c5d7220"},{"version":"0x00e06a29","timestamp":"0xab51a466","nBits":"0x07936019","nonce":"0x335ef361","previousBlockHash":"0x6cb84dc158fe97eb7d90efbe2c23fc3234eb74a19c031a1c31313b1700000000","merkleRootHash":"0x64ed202ce650f743b28ed608675e4b1b2f8f2b2e426c2ef69315a922f3884750"},{"version":"0x0000c020","timestamp":"0x4a53a466","nBits":"0x07936019","nonce":"0x3904b05e","previousBlockHash":"0xaf74cd7c4ad18fec19a849d6993ad438c45dd2071d5e44b23700000000000000","merkleRootHash":"0xb808ed068ad5d3885673c3e1472238f4e4f5b92404f4e5c20eb0e78eb155b3f8"},{"version":"0x00000020","timestamp":"0x0058a466","nBits":"0xffff001d","nonce":"0xeab14d6e","previousBlockHash":"0x146deefd2902cd283904153f7cd58ff7f611d7268a4b3e475300000000000000","merkleRootHash":"0xbd9f08fa58aec2babb9baf6c0930810d3855c0bf90e2b3e2afec74d0ea025a65"},{"version":"0x00200020","timestamp":"0xa659a466","nBits":"0x07936019","nonce":"0x4f4c84cd","previousBlockHash":"0x9eca4eb9009735eb85a90148b9852a632455044f13535cc8b347657900000000","merkleRootHash":"0xea82f39edd8c6622456ac6b58081f325f02ae8d4fb48556831b905a82a859992"},{"version":"0x00008020","timestamp":"0x4d5ca466","nBits":"0x07936019","nonce":"0xb64b1e38","previousBlockHash":"0xb748cbcd259cd81d971f549bad677ca58076eaa7342e38c31600000000000000","merkleRootHash":"0xca93058d993e8e30ef9454854644b627bd062d69c5c8167846c89da57413517d"},{"version":"0x0040a72d","timestamp":"0x735ea466","nBits":"0x07936019","nonce":"0x270116f7","previousBlockHash":"0x3d3dc20e13ff2a3025b5290fddf447dd49c7471c85cefd781300000000000000","merkleRootHash":"0xada119c23850e112f3553909c13a7b5a6f0f3130d2c747006081e89f20795de8"},{"version":"0x00000020","timestamp":"0x2763a466","nBits":"0xffff001d","nonce":"0xe809d9ac","previousBlockHash":"0xee23464d85ef3eb0c82fbf378f2324367daa627b92a1b5aa4700000000000000","merkleRootHash":"0x19cf068da59a0293cc1dffd4b1caa5a7a3519771cfd0657a18258b466c16165c"},{"version":"0x00000020","timestamp":"0xd867a466","nBits":"0xffff001d","nonce":"0xa6d34dec","previousBlockHash":"0x6e76157d40baed210cb29522a2fb05977a31c8abc06c3d5fd33d68bb00000000","merkleRootHash":"0xae842a50bb19ee910bcf019b9d7d39286410bc4f7b8d9b11e3f6bc538426ad9d"},{"version":"0x0020a022","timestamp":"0x656aa466","nBits":"0x07936019","nonce":"0xaae4e40c","previousBlockHash":"0x720eadccafff3036387898dc0645388a7b05b75422908dd51b50e23e00000000","merkleRootHash":"0xb3b4b385be2ee1dd1d7976a7f4d10bad1d4c17149adb55b4b6de81bdb7d39467"},{"version":"0x00c0d720","timestamp":"0x556ba466","nBits":"0x07936019","nonce":"0xd1640d0d","previousBlockHash":"0x7ba642d9fe4ac84375a1a0d59e0a7801018e437ac755da423a00000000000000","merkleRootHash":"0x7b29fd0d456474452ab15570dd59e217e1a3d39e91fcb133b7fc90b3644aa32d"},{"version":"0x0000d92b","timestamp":"0x586ba466","nBits":"0x07936019","nonce":"0x0715dafc","previousBlockHash":"0xd0eb88d55280ac4b1db3be647be52a92ebde0ca3333cd07d2500000000000000","merkleRootHash":"0xa09ef56bdfe1656c803d3c589bc2fe454841264bdae92d93e180be82bf75503b"},{"version":"0x0080982a","timestamp":"0xf06ba466","nBits":"0x07936019","nonce":"0x33597819","previousBlockHash":"0x2d0a2c0885abcb4bbee1f5b2f2ac21ebce9d8b98e0c4b6383e00000000000000","merkleRootHash":"0x45cff1ab422ed0f7f95cb74841be7999291f15920cd3e50402ee9b6d3bfeca25"},{"version":"0x0000d22a","timestamp":"0x746da466","nBits":"0x07936019","nonce":"0xca62cf51","previousBlockHash":"0xaf800f61c2bc499d401dcdacc26e816adb2d0155dcb3f0ee2600000000000000","merkleRootHash":"0x08777ebd05d6271c37a14da4b2f92db4822b264f4f83ab52a41e8faf22d3f021"},{"version":"0x0080a420","timestamp":"0x2972a466","nBits":"0xffff001d","nonce":"0x0af9b2aa","previousBlockHash":"0x444e6e9661ba4a58c836c76c072e42208d04b495d99ee6395a00000000000000","merkleRootHash":"0xebd2fd18738de1a7bcfcaa01b589997aab1b60faa24c1b742bf96c324d5f7058"},{"version":"0x00007020","timestamp":"0x3075a466","nBits":"0x07936019","nonce":"0x41a4a67f","previousBlockHash":"0x52b526abe3bdf30009cf450bf4fae8aafdc1c11a3e20688f7508000000000000","merkleRootHash":"0x7254586f35c9105eb494c5919827b1aa1dab6968ae2aab24f234fd2e94489a63"},{"version":"0x00207323","timestamp":"0xf375a466","nBits":"0x07936019","nonce":"0x02b2223d","previousBlockHash":"0x98ec04f31983705e9ef646922a30002d4b02a2984525ee392000000000000000","merkleRootHash":"0x5c3e7164ef0750ed46e0b1466e58bdfdf8068c98134b62a2aa4977ee91eef551"},{"version":"0x00c08d2e","timestamp":"0x1676a466","nBits":"0x07936019","nonce":"0xab8943c1","previousBlockHash":"0x4e12ea15b2901d2ea90a1a56640bc47c67ca00084f139c2b0d00000000000000","merkleRootHash":"0xb23d91d499670b5028a3172d80006ac2d99f8d9fb891818d5245ab3373e6478e"},{"version":"0x00c0a024","timestamp":"0x2c79a466","nBits":"0x07936019","nonce":"0x94be4cef","previousBlockHash":"0xb1333c70167d55a93e543c12d537d2d9d0bd2b7fea032afc2b00000000000000","merkleRootHash":"0x94b1276a8047ef88d0e31adfc5a1fd19e41f06b639f328c580de1db6270e403d"},{"version":"0x00000020","timestamp":"0xe07da466","nBits":"0xffff001d","nonce":"0x962ca3bb","previousBlockHash":"0x7f4ec34aea8d1f08ecb7455f1ae72c95a81d4696c9f70f224e00000000000000","merkleRootHash":"0xc21faffa9325a9fe8e99d99ccbe1a994ca1dcdce4ea11bb6765953ccaec1a66e"},{"version":"0x00001331","timestamp":"0x7e7ea466","nBits":"0x07936019","nonce":"0x39631ee4","previousBlockHash":"0xaf9459c8e085756ee0cf1219bee7a1068f46be2d18475df8aa349b4d00000000","merkleRootHash":"0x2fa13f2ea5c68f28bc07ad679aa4d19e02936739ceb1259f17d546a2173d4dc3"},{"version":"0x00000020","timestamp":"0x827ea466","nBits":"0x07936019","nonce":"0xb249c4d6","previousBlockHash":"0x7c52599d14a575cb649a6dbeea335ad70a24d31526fabcfa3b00000000000000","merkleRootHash":"0xc458a49df6248619231ea9a9e32e43bb8b3012afcd38392bf981d9909395d376"},{"version":"0x00000020","timestamp":"0xb47fa466","nBits":"0x07936019","nonce":"0xa1671942","previousBlockHash":"0x3aa5e26b72c2800a7ad2f795964587e8dc4696deac40867d4e00000000000000","merkleRootHash":"0xe3ccb88da630576883630a0a1ad28b73cdf7ce23be5c0ef999302bfadd1e18cf"},{"version":"0x00e04532","timestamp":"0x5b83a466","nBits":"0x07936019","nonce":"0x420e8f43","previousBlockHash":"0x0e3ad744065d174dde7d70249eab5ab6c2f78418d4c6a6655600000000000000","merkleRootHash":"0x733a3377b9a65653ec016a09daaebc7a610ec968edd7b1f65259fc5c68a35bb9"},{"version":"0x0040f932","timestamp":"0xab83a466","nBits":"0x07936019","nonce":"0xd58c4c5a","previousBlockHash":"0x02c2d254797782b1bd5e103609ab5d90211915575de5c5fe1e00000000000000","merkleRootHash":"0x41b61d4862425d6063a12b4ce9b32e6ac0a425e7d1255ec169c70d1276a94ecd"},{"version":"0x00004020","timestamp":"0x2c85a466","nBits":"0x07936019","nonce":"0x9ae690a7","previousBlockHash":"0x0d5b2c27fcdd7c6e449d9a1f15a2a9eb62869a01a7fd01333300000000000000","merkleRootHash":"0xb056e147036c4a3d88286e26e5edaf81af2ef6160f6ded3f8723ef0dc9ab5abe"},{"version":"0x0040252b","timestamp":"0xf886a466","nBits":"0x07936019","nonce":"0x8c523945","previousBlockHash":"0x7505412706366d5e3e4e5456cccd2d9d4a711ca4b43102870f00000000000000","merkleRootHash":"0x139910e5c5310ef17842801eab540aba25e38f73f7a43d6be0032ea327f7e06b"},{"version":"0x00a0212e","timestamp":"0x5087a466","nBits":"0x07936019","nonce":"0x229533e2","previousBlockHash":"0x63206105b0c9f6b5b7736d12766ec95909744579327ed0284c00000000000000","merkleRootHash":"0x4d4b431f0ced35e026a64f085a8dc095affbf2455362833a9f403dc50c956572"},{"version":"0x00e09120","timestamp":"0xde87a466","nBits":"0x07936019","nonce":"0xa922cc5f","previousBlockHash":"0x3b2cb95c4a75cb0ccd1b4b3c930674eba71b6461b7f996b70b00000000000000","merkleRootHash":"0x5b15341f97cd3c2d8bd1fc48339d12c0fb675a6d48df429e9f5eb988b3ef7511"},{"version":"0x00207928","timestamp":"0xef8ba466","nBits":"0x07936019","nonce":"0x61467bfc","previousBlockHash":"0xef7105483b02497a8f4f7b64d42f64445e836db76df3dfef4700000000000000","merkleRootHash":"0xe897b9d810603563fcda6d15a5e065932c754ee24d858aa0ee33476e5f850d61"},{"version":"0x00808b2f","timestamp":"0xcc8da466","nBits":"0x07936019","nonce":"0x06ca86f0","previousBlockHash":"0x4c0f639c401b89da2bb216f6058ece8dac873d726c79a72a3c00000000000000","merkleRootHash":"0xe43d57594a3b274d045246bf47e5432ecf423d316e776a2db39f44a81044f9d4"},{"version":"0x00000425","timestamp":"0x538fa466","nBits":"0x07936019","nonce":"0x6be83238","previousBlockHash":"0x0531dbf7c8219e35fef88cdb0caf9053cf4c7048b07d32774e00000000000000","merkleRootHash":"0xe872ce759c77241ebdb85195f40c40f24547e6e4230ffd46bd5c810ca2f3c757"},{"version":"0x00004020","timestamp":"0xc293a466","nBits":"0x07936019","nonce":"0xb549a607","previousBlockHash":"0xb982f465a8ea38a74a3b445d9fb4b49c4a01f61ba6e170c44400000000000000","merkleRootHash":"0x43e077bd51b97945b7d1432d433b41ea3a8d324d131ae457627bb3aa36947b6b"},{"version":"0x00000020","timestamp":"0x7398a466","nBits":"0xffff001d","nonce":"0x4d2cd2a1","previousBlockHash":"0xe39da81e8de0bb0ddd33134efd9fc394f97e23f9da3c5b0a4c00000000000000","merkleRootHash":"0x059c03e681663e78030dbe1292587cc9fbf31ab54d59582944a8bee25d1787cb"},{"version":"0x00004020","timestamp":"0x8999a466","nBits":"0x07936019","nonce":"0xa1a50cef","previousBlockHash":"0xe026aa88a21cf4f21d50a7d4c9c5af9d942b063355ed3ef7f8a34b3600000000","merkleRootHash":"0x6c0f896265a81541b031e9b8688664386ef415e7f38d7b71323d575c11591016"},{"version":"0x00000020","timestamp":"0xb59da466","nBits":"0x07936019","nonce":"0xbfa5e483","previousBlockHash":"0x5622c2706cae4cf70480b0fdb6a7a76669d6cf21c1d9860f3400000000000000","merkleRootHash":"0x6a39cd2fefbaada82067feb0b4b9beb9855dd33ef82288cfcb1f9fa1c2387995"},{"version":"0x0000ff3f","timestamp":"0xb29ea466","nBits":"0x07936019","nonce":"0x5b95698a","previousBlockHash":"0x0cf5dfa07d05134453fc1b9813c16f93b749fc673cb68c572c00000000000000","merkleRootHash":"0x871388f6620ee81ad2389d742cff6c938ef3b96f934ede3119aab10f4fd46ec4"},{"version":"0x0060dd28","timestamp":"0xb79fa466","nBits":"0x07936019","nonce":"0xd22ab357","previousBlockHash":"0x666b0e85a23722d606007e02a1f04b3a122aacffc9d41ff35200000000000000","merkleRootHash":"0x6f177e23466f350e48e64bf1e3af33974738682aeec7ac8ab80e912ed2f7f87f"},{"version":"0x00c09025","timestamp":"0x8ca3a466","nBits":"0x07936019","nonce":"0x46ba2ee1","previousBlockHash":"0xfa480b24d73434c9bdcc392974154d7c049ca10b997835572900000000000000","merkleRootHash":"0x24248883caf008c1fcd77a259c0a43c1dd5311c7dbf3c0e3a035019d0dc0a0b7"},{"version":"0x00000020","timestamp":"0x3da8a466","nBits":"0xffff001d","nonce":"0x008d32c3","previousBlockHash":"0x972aa63652d2e2c1f6d692df7d2e7e629739dab6828bd0094a00000000000000","merkleRootHash":"0x816e2d2690855132a5c296966a4b75de8fd047898680d85be8916269984201b0"},{"version":"0x00000020","timestamp":"0xf1aca466","nBits":"0xffff001d","nonce":"0x2b33a9c8","previousBlockHash":"0x10e642b274ae9ddb69114351d44e2f5a3b668cc480271415c6afcf9a00000000","merkleRootHash":"0xe6e582546ea9159e0a17fd26fa564aad4c2e2236174b3d9e92946801e4540e90"},{"version":"0x00600020","timestamp":"0xa5b1a466","nBits":"0xffff001d","nonce":"0xb0c18106","previousBlockHash":"0x4e7b48a2cda5b5e1965152f290adf9e9ed8528892c5ec10c9698f53f00000000","merkleRootHash":"0x6052d913e214ef3bf96687419ae7304afde825645ebb55de3704ec959b206af7"},{"version":"0x00e03b31","timestamp":"0x0ab3a466","nBits":"0x07936019","nonce":"0x18728f7c","previousBlockHash":"0xb4a2cb01361eeeea2f2e646e1207960bbf8c991c7da976b633bb880000000000","merkleRootHash":"0x9fb89e14620a49f98ec0c815a2288e8f78b7db2bbb190540018d8a7e095f5e0a"},{"version":"0x00401320","timestamp":"0x4fb5a466","nBits":"0x07936019","nonce":"0x785944b0","previousBlockHash":"0x48d1b3cc99a1133a89bb762af51b8cfb8e662d06f1fd56923c00000000000000","merkleRootHash":"0x48c3042bf5f6dee827d1aef40d41a07774773b8173e8ea17116a3ca85584ed6b"},{"version":"0x00400020","timestamp":"0xb2b6a466","nBits":"0x07936019","nonce":"0x9dc70e04","previousBlockHash":"0xc5f3f196f97015bfde7f1d7cf3ab9c9e1c23849a5cb34a3e3300000000000000","merkleRootHash":"0x71dd22ba2c7ea83e5c1bc5406a9af587ac792d5d8b1ab515ad592148193e06c9"},{"version":"0x0040042c","timestamp":"0x87b8a466","nBits":"0x07936019","nonce":"0x11bcd5ed","previousBlockHash":"0x72c607a98b360e88db60371f824ca6b8ad33d1b99253a9253e00000000000000","merkleRootHash":"0x947631b73ebcf2b8d286537230e230c6c2b02a539dc3f066d272c8c9a8caccae"},{"version":"0x00c08529","timestamp":"0xa6b8a466","nBits":"0x07936019","nonce":"0x91668bfc","previousBlockHash":"0xd22aa180e83374a48d5462b8b507b86591c7b05144cf86ec2800000000000000","merkleRootHash":"0x7253774675d5bb343f3f9cf198d216a9c9c5653c72e1322ed746438c588c999e"},{"version":"0x00e0d721","timestamp":"0x5ebaa466","nBits":"0x07936019","nonce":"0x141e12bf","previousBlockHash":"0x215e389ac577c6fbe39c60eb3b3b7b79abb4cfc65904a6744b00000000000000","merkleRootHash":"0x4f0eaa5438b3bf1128d291d175ace199d274f65bf1285aecce34cede661e608d"},{"version":"0x00000020","timestamp":"0x0fbfa466","nBits":"0xffff001d","nonce":"0x2558a51b","previousBlockHash":"0xf57ef9d1b6499a296fb739765b7d7664d221bb115d78ea6c1700000000000000","merkleRootHash":"0xc3e61a78e368ba6cf247432e419607de179e60e4a549187d23395c7471a434bc"},{"version":"0x00c02e23","timestamp":"0xd0bba466","nBits":"0x07936019","nonce":"0x592ad50c","previousBlockHash":"0xca68f1244d05116b7cddf41f595797f5e7b64e741b9b7642123aee1b00000000","merkleRootHash":"0xff54996cfc9de49dcb6fd6f25708b3af87bad64c5ce5dd4cef14aacd63db9108"},{"version":"0x00000020","timestamp":"0x81c0a466","nBits":"0xffff001d","nonce":"0x6851fb28","previousBlockHash":"0xdb6eda6b200d4e512d5bc93171c69dd63138dadae6013f9e3600000000000000","merkleRootHash":"0xd46e19066d2818e63b5d384144708af05da2bd3708619c55e84ad4f641529b53"},{"version":"0x00000020","timestamp":"0x32c5a466","nBits":"0xffff001d","nonce":"0x7d752615","previousBlockHash":"0x239c8649bace99c6b17963ea8828176ffb649265d4cf99d753f9123400000000","merkleRootHash":"0x91cc9d42bd7e4c22884ca8e6fa56c83190aacf61a35be214810fc5de920383be"},{"version":"0x00807027","timestamp":"0xc4bfa466","nBits":"0x07936019","nonce":"0x46d80818","previousBlockHash":"0xe4b7eff83e37c4fa2b0d0e0470dd5d92dea24ebd3b17615078990c6800000000","merkleRootHash":"0xe9cd16954a3a798c2100a58f8f9f1eb6d428040ddaf0e653e89d09e9af8c66a4"},{"version":"0x00000020","timestamp":"0x77c4a466","nBits":"0xffff001d","nonce":"0xd9a57362","previousBlockHash":"0x5ddc2c939f68158c20b0b5ce22164b94a10c1ffd4a97602b5300000000000000","merkleRootHash":"0x27d2a14ff5d3851faa727501c7f82b1e28646889c5e8137078dba2e62558ed55"},{"version":"0x00e0682b","timestamp":"0x48c5a466","nBits":"0x07936019","nonce":"0x377c7163","previousBlockHash":"0xc4fd36c6cec5b30ba75e97af9db141dac9d6aa786e392b43bf69610300000000","merkleRootHash":"0x8d0937f1f5e0268d9835ad2bf73a28b5f92350af7d432a2a10468f559874c25c"},{"version":"0x00000020","timestamp":"0xf9c9a466","nBits":"0xffff001d","nonce":"0xef651a42","previousBlockHash":"0xa7d9c7ef09e890c765f67b523dedb3e8821ff0d5badcb1760d00000000000000","merkleRootHash":"0x9adb9d0bb10475e701cc93327ad3ebdf50f5270b20f97ba4046d5a3ed98c6448"},{"version":"0x00409d31","timestamp":"0x9ec8a466","nBits":"0x07936019","nonce":"0x05b59c4d","previousBlockHash":"0x8f0a5c5189e2885b68b8253721e446b94c0af6093c8900d61a05edc800000000","merkleRootHash":"0x19fcd1357c4e908e118f606727dc638cd8ec5ee354921dfce53ec606feceff55"},{"version":"0x00403124","timestamp":"0xb6c9a466","nBits":"0x07936019","nonce":"0xdafb20ac","previousBlockHash":"0x439d4c63632be7504a6ad45eae8177e28563c2b800f1bc915900000000000000","merkleRootHash":"0x91b99657c8bcdf729e4cdd839db008c25b96025b7908d5edddb50bda6bee0047"},{"version":"0x00003730","timestamp":"0xdac9a466","nBits":"0x07936019","nonce":"0xd4006335","previousBlockHash":"0xa3966cefead4619d8bcecfd7a424d9651289a66ad436d4d11f00000000000000","merkleRootHash":"0x777c7f4359139f42dbceda888b34c18b6dd3cb2352abefbd330384fc7ef0b89e"},{"version":"0x0000832d","timestamp":"0x5acaa466","nBits":"0x07936019","nonce":"0x493133b4","previousBlockHash":"0x5ce4d3a68f22293144cb37cb4ac381c7b0458456935846064a00000000000000","merkleRootHash":"0xf80f1c11b179a81f310f79cbdccfc5795f9634ab3596fe8745a739bc66793633"},{"version":"0x00000020","timestamp":"0x0bcfa466","nBits":"0xffff001d","nonce":"0x37e44626","previousBlockHash":"0x434d4c0a41af3824688ed9f1d54751d6961248afd5e205b15500000000000000","merkleRootHash":"0x136d7cac9cb986cfa9b5c940f84efd03521072106004e4cbc9503291e83bce70"},{"version":"0x00000020","timestamp":"0xbcd3a466","nBits":"0xffff001d","nonce":"0x3bd41500","previousBlockHash":"0x0e9f285eaa084251402303b487a4a1b966e72f2c333518f1e9f13a2f00000000","merkleRootHash":"0x516541cfa01e60e2ce18aab54e7e0bc3b108cf54c04de4a970e99f62ad748654"},{"version":"0x00004020","timestamp":"0x19cda466","nBits":"0x07936019","nonce":"0x452f7f73","previousBlockHash":"0x66bb4dca8c3ac18ac5549dccab8dcdbd33f29bb5f1a2feb97304c17a00000000","merkleRootHash":"0xdb7389d3b30184fb51bff60240e4e7586f64b7c7fd1aeb75c119d72e049d6153"},{"version":"0x00004020","timestamp":"0x60cea466","nBits":"0x07936019","nonce":"0xccef525d","previousBlockHash":"0x8df3d2395e9e62b2736b168beebe2bd3b05bc19b91ba86422400000000000000","merkleRootHash":"0x1c53e9441a5bc46046e4b0e600fc686956fd2c1caaab8051a0127c91e8dce8a9"},{"version":"0x00000020","timestamp":"0x11d3a466","nBits":"0xffff001d","nonce":"0x4ef4d002","previousBlockHash":"0xc2c732e6c5b9314d968b6877b841982d93861668fc488b401400000000000000","merkleRootHash":"0x105d524c3a55bae4c29c36be8a4d1c48ae6d49d7597e5e93e433d0dfd76fd782"},{"version":"0x00a0f92a","timestamp":"0x52d2a466","nBits":"0x07936019","nonce":"0x2bd9079a","previousBlockHash":"0x944dbf531261252b6dad46afcbbfd97b5eb54730102bfe6a30008d9200000000","merkleRootHash":"0xeac69ba3c30425f748bac0ee3e6343eef484003f3558bb9f1fa8f2d39c2ef708"},{"version":"0x00e0c921","timestamp":"0x58d3a466","nBits":"0x07936019","nonce":"0x71e47f26","previousBlockHash":"0x0107d837d77e92fc04bc45ea8305f7734ce61a056fc63abb4800000000000000","merkleRootHash":"0x813cb8676093372548ef876ba403976805f6e3dd695d28a3b17a5705ab60e337"},{"version":"0x00a02922","timestamp":"0xbfd3a466","nBits":"0x07936019","nonce":"0xbc4afb11","previousBlockHash":"0x2f0bc078ff30a4368bd9ff5da0c57dd16bb4c1edcbf8f3740000000000000000","merkleRootHash":"0x9f3d7f864364498eca672035e34236b0a99a5ffd6a110bd8b1506e0c0cead3b7"},{"version":"0x00000020","timestamp":"0x70d8a466","nBits":"0xffff001d","nonce":"0xac658d27","previousBlockHash":"0x498a0ef222d4a831942f2f3040444eef426455526e677da45200000000000000","merkleRootHash":"0x82815b75a0c6050311c85705ce417477f43e86919f4ff2b9e86feaf7e4ea5761"},{"version":"0x0080ba26","timestamp":"0x33d6a466","nBits":"0x07936019","nonce":"0x2386ff83","previousBlockHash":"0xf03b976465efe9cdda7f2b847a1fa399e28d197de1ddbf0f95b264c500000000","merkleRootHash":"0xf0c919912546da6d590f6e9f9ec8f514db1cae9e6a34542fdeae53f66eeaa9de"},{"version":"0x00a09d27","timestamp":"0x2cd7a466","nBits":"0x07936019","nonce":"0xc819ca51","previousBlockHash":"0x920d71f1ede6f073f929842a2e87498b30e469a3ec21f8c81800000000000000","merkleRootHash":"0xaa5507f9892455a25af519a4e51f9512acb1c98cd7fe86c6be2b2c5fcd4b10d3"},{"version":"0x00a02230","timestamp":"0xedd8a466","nBits":"0x07936019","nonce":"0x6c629aca","previousBlockHash":"0x27790687564e0026f562babd3f5d172cef12ba6e328a16710200000000000000","merkleRootHash":"0xfb01a0b96d2f92cb0182f142534cb4f17f0a942f7309499db2679a236d595f84"},{"version":"0x00000020","timestamp":"0x9edda466","nBits":"0xffff001d","nonce":"0x9dbb2a1f","previousBlockHash":"0x4c255e4a01dd2f6adf556da38f60b1eeeec60d769621b22b0d00000000000000","merkleRootHash":"0x7824b04acd90a5645d5c929e3fba6694c64b78209ffe57fdbedbc9f056ca124e"},{"version":"0x00003224","timestamp":"0x57dba466","nBits":"0x07936019","nonce":"0x8e02f5bb","previousBlockHash":"0x2abfd3d54e1fe85f225873e3a3850aa716d613fa5c959105868f894d00000000","merkleRootHash":"0x0eaab0af257461b092fd6f65e7b9685be9fbb5b4d4bddea760e72368d58481ad"},{"version":"0x00000020","timestamp":"0x08e0a466","nBits":"0xffff001d","nonce":"0xc7aa4e10","previousBlockHash":"0x567ed84695fdb21ba4626d62e4497ea2e9bd69a6a4f9f8804700000000000000","merkleRootHash":"0xec773c2b50abcaec4088f7c88931fb81dc1b6c6b6b3d55c7cee95d0d957afbe0"},{"version":"0x00000020","timestamp":"0xb9e4a466","nBits":"0xffff001d","nonce":"0x3a45c724","previousBlockHash":"0xf52f70a42c45f5be801cff3dda045bc2234ed51833acbc26abb4f02900000000","merkleRootHash":"0x3eb7bfa0774be01d1ba11fb6410129b3a3a2f14f7ee1751fa89f633e9cb98125"},{"version":"0x0080cc20","timestamp":"0xccdea466","nBits":"0x07936019","nonce":"0x5e2a8abe","previousBlockHash":"0xc70f969ea623238351591501770520bc21784b2aeb0cd937ea8cdaca00000000","merkleRootHash":"0xe7b7454e4907993e2c35456a21f7d5c2094a73bdfd43e04e4663820680adf0cc"},{"version":"0x00a01330","timestamp":"0xe0dea466","nBits":"0x07936019","nonce":"0x70deaf67","previousBlockHash":"0xb9a6d62a4b71f05bb44e42339407e620de89a52217e0dd1a0500000000000000","merkleRootHash":"0x17b628dd68e45bb257e9564b43324ff509338d5a08d59426ef5cba23130f7e04"},{"version":"0x00000020","timestamp":"0x95e3a466","nBits":"0xffff001d","nonce":"0x9b595df4","previousBlockHash":"0xb05ecc0d1e1b86b002a24bedf939282a87fccad33c6fc3cf0e00000000000000","merkleRootHash":"0xf98df3cfe7842e0598a6490a9e87a369e6c41194693f4245fc90b3dbde738007"},{"version":"0x00c09223","timestamp":"0x4ae8a466","nBits":"0xffff001d","nonce":"0x18015cb0","previousBlockHash":"0x1153dcf7987f091da6fd9ef00dec1be134aa5357161bc172fd28a47000000000","merkleRootHash":"0xfc596a05072d4834efe72e98c49557151f9477492eae00db5f6d99118e287a7c"},{"version":"0x00c01332","timestamp":"0x12e9a466","nBits":"0x07936019","nonce":"0x494a7b02","previousBlockHash":"0x14884f22af8ceabea28a1f37886240b4cccf6fdb6cac20e5b929000000000000","merkleRootHash":"0xb9f0b9eb8c0e8a53e06024fb130075503530b5e2254f5a5ebae49ca8359a9b81"},{"version":"0x00003c33","timestamp":"0xa9eaa466","nBits":"0x07936019","nonce":"0x6279e4b4","previousBlockHash":"0xd2e00d92e6abcad9dc20dc815dff43556a690dba10ba09031a00000000000000","merkleRootHash":"0x18f33bd9bc157138fd29b2bbbb8797f6e7291de48ae5cd1892c106f470167c47"},{"version":"0x00c07f26","timestamp":"0xbbeca466","nBits":"0x07936019","nonce":"0x7f52c4b4","previousBlockHash":"0xeb51fc7141b9d1f51494ce036b09bc2686a843121040a1733800000000000000","merkleRootHash":"0x4f751beac2c8441fff24560ea012ed66b4cb82718392dc0d93a6eb14cac169de"},{"version":"0x00000020","timestamp":"0x6cf1a466","nBits":"0xffff001d","nonce":"0x8a5b4a02","previousBlockHash":"0x584b2212090f432d1d52704fae27cd15826167869e3971c40b00000000000000","merkleRootHash":"0x01b36f67f176db821ed423a2e4559add6de214a25063c951552c41feba0bb31d"},{"version":"0x00e07c2f","timestamp":"0x42eea466","nBits":"0x07936019","nonce":"0x40cac8ad","previousBlockHash":"0x02a437f3166eda7601459d69c7e8ba0d80fbc32d24ca8e5e735bead700000000","merkleRootHash":"0x58c826110e03106fa25e07ba774725556a031fcc92ddb76528dce4ecb26c704e"},{"version":"0x0060ea2f","timestamp":"0xc2eea466","nBits":"0x07936019","nonce":"0x61007fa1","previousBlockHash":"0x395da5e19d69aeb6981a2aa4a30a39d7cf20bc3c0bb7d9905b00000000000000","merkleRootHash":"0xdef8f40c2b56d2f792a1248a03d08ffd4182e61d6bf548c881ac72c719d8f952"},{"version":"0x00000020","timestamp":"0x73f3a466","nBits":"0xffff001d","nonce":"0xcb4fb012","previousBlockHash":"0x3ddd562b3dcbfcaaa6b28ba649938dbe6dd55cdf754b68921800000000000000","merkleRootHash":"0xf54660c01a4c60b9401af8b6ffc03e01d4b997bc09689521fe177ad7ce2b302a"},{"version":"0x00202623","timestamp":"0x54f2a466","nBits":"0x07936019","nonce":"0x7b65a58f","previousBlockHash":"0x63d7c37c8f93513ddf16f090f66d5556c0beb8c408a334f641429f5200000000","merkleRootHash":"0xc023fbb006970ea66d6cb65f47e8360dbde42cfe199c37ff015749a9ddfa6320"},{"version":"0x0000ba23","timestamp":"0xfaf4a466","nBits":"0x07936019","nonce":"0x5adc2f21","previousBlockHash":"0xabfae206e0e5c5792332b9557d6642b6866467de374265282000000000000000","merkleRootHash":"0xe5fd04227c987e9510b3b67c0b0fe3dbb2eecf90fed765babd4e0fe584e0bd6a"},{"version":"0x0000f027","timestamp":"0x30f5a466","nBits":"0x07936019","nonce":"0xbc6d2dce","previousBlockHash":"0xa32186d5b1f93fd2add0e62b24369975748b5dd55c0ed3f34f00000000000000","merkleRootHash":"0x8757e33858554aab40bb2a4e0fd316d1a6363b1f4d51211757437121253b710c"},{"version":"0x0080d220","timestamp":"0xbcf5a466","nBits":"0x07936019","nonce":"0x201e04e0","previousBlockHash":"0x9a6d272dcb6cfd56d4cfd5991bb19c5f9b458259f8621e432700000000000000","merkleRootHash":"0xb1d2df5ff68fbae072bab050693f7aa7608dd8d2cdee83fb8e85c87283927a4f"},{"version":"0x00000020","timestamp":"0x6dfaa466","nBits":"0xffff001d","nonce":"0x00ce36e5","previousBlockHash":"0xc0ad218b96d04e2713ca76296e21952ad8d17accc8c8e99b5d00000000000000","merkleRootHash":"0xb25daf9e7492b84acfba002b0c1b3d189b8b183e3c9cedbe342945c96e5496a6"},{"version":"0x00603525","timestamp":"0x04fea466","nBits":"0x07936019","nonce":"0x49692080","previousBlockHash":"0x3e485b089ea788c432b146cedac422e3bb792a4b1900b75cd401860000000000","merkleRootHash":"0xb7583afdf10702819c443b3a15113066ba6f2478739581395d7a78acb9decc9d"},{"version":"0x00a0e023","timestamp":"0xe400a566","nBits":"0x07936019","nonce":"0x0571b6ea","previousBlockHash":"0xc09abc7dc752abc2a0f2972546e81bd5e4a982114c6df1df0100000000000000","merkleRootHash":"0xa05ec12ed0a05cfd7a1741d248cab39e877bf0c1b375a2fc4cbcc9914b8e59df"},{"version":"0x00605f23","timestamp":"0x0b05a566","nBits":"0x07936019","nonce":"0xb182ae91","previousBlockHash":"0x9faf96fe92007589b47ebd399c870a67148cb9d7fe003eb80700000000000000","merkleRootHash":"0x1960c066da0d1c4adb1b985c9999a39c04c74253c4c0d526ddf5e8858ba74cf6"},{"version":"0x00000020","timestamp":"0xbc09a566","nBits":"0xffff001d","nonce":"0x8001a312","previousBlockHash":"0x7378af362b4ac0e18099dcbe01852a348f21415cc8c7c1f92a00000000000000","merkleRootHash":"0x22602b0d39fb959e86dc040f805918719d82ba02c97d1e302064c559777c315e"},{"version":"0x00000020","timestamp":"0x6d0ea566","nBits":"0xffff001d","nonce":"0x151fb556","previousBlockHash":"0x7d4470be0ce3cced4d854d7a862afda80f30053570ac0697f91a088300000000","merkleRootHash":"0xb5ce9cf957b3970cf98a939f23531aa53db0c4e0ba8237817e5b07e10bd07813"},{"version":"0x00e0eb2c","timestamp":"0x1208a566","nBits":"0x07936019","nonce":"0x8ae0d10e","previousBlockHash":"0x8585d6d06a24adcd445d923404626569b7621f7125e475a43dc5b0b500000000","merkleRootHash":"0xd34f4fbe88f4fb286334cbf18ecbc8f14e2a0b18e00360318a127152b89baf93"},{"version":"0x00000020","timestamp":"0xc30ca566","nBits":"0xffff001d","nonce":"0x83fce10d","previousBlockHash":"0x92ca79f0b10145dee39f505ce2d23e227d75edea3c2cf4dc3600000000000000","merkleRootHash":"0xb455bcb5a69d3f6ea7e5d70894282f2cdf9c50b74a3fe6b993f61940ef34ea99"},{"version":"0x0000ba20","timestamp":"0x120ba566","nBits":"0x07936019","nonce":"0x6a4c11b9","previousBlockHash":"0xc04106367253e1b8a56286995e8b33f3c05898d6bc973669c5e63f7b00000000","merkleRootHash":"0x727bfb8f37464ac05bfff05b8155e9b1a4962bfb8da5faaf449d028d234fd42c"},{"version":"0x00001c25","timestamp":"0xd70ba566","nBits":"0x07936019","nonce":"0x5b40fe28","previousBlockHash":"0x2f31d4af238efac0364443efcc2147479e1ad55ba16de6202200000000000000","merkleRootHash":"0x63ab3ff44670a0e2c8272a802c02c6392a781c4ca7d1f9070711aeb55f588b01"},{"version":"0x00c03f2d","timestamp":"0x8a0ca566","nBits":"0x07936019","nonce":"0x61449562","previousBlockHash":"0x9fe2a1735b037fcce9270fef411e5556e064b0b9488e02bc5700000000000000","merkleRootHash":"0x6613257eaafece073d812ede04d8f5042d7ef5b68a1ccb12b7e6b75ade268c78"},{"version":"0x00c09425","timestamp":"0x3a10a566","nBits":"0x07936019","nonce":"0x6e780a83","previousBlockHash":"0xa3c0ea56b72fc963bad45f2e3a061f8282685e9802aed3771300000000000000","merkleRootHash":"0x1ac8e62ec7dc18fea634f314b08cc0463130d4543756fd0e5badac4ee69a2b8e"},{"version":"0x00000020","timestamp":"0xeb14a566","nBits":"0xffff001d","nonce":"0xbef60a27","previousBlockHash":"0x741da4bbdd07a4ba0de80239f665fd5de70d57d026b8b6a15f00000000000000","merkleRootHash":"0xaa4399bbac1c07ddbacb58a57b60b70d38e3119642eb799e589418ac7adb3b73"},{"version":"0x00604231","timestamp":"0xc812a566","nBits":"0x07936019","nonce":"0xb389f4cc","previousBlockHash":"0x4a1a850fd66341c75da7b8061e5d230e61db6aab4cae3500fd73d8e800000000","merkleRootHash":"0x897e653f1b2cb28dd1a32ebdff4823adc2667a58089be037f3a6b45e39334057"},{"version":"0x00e04726","timestamp":"0xba15a566","nBits":"0x07936019","nonce":"0x1e7c5f9e","previousBlockHash":"0x38e2c63fe4639b2d662695b175ada3477849fba5a1e16f093a00000000000000","merkleRootHash":"0xf4f26d86730f3548181171771a55be13eef2d6bacf5fb8b9bf0d4c602f7fe8b7"},{"version":"0x00000020","timestamp":"0x6b1aa566","nBits":"0xffff001d","nonce":"0x39f89004","previousBlockHash":"0x86a4342cc04f3399f10ea549848d768a3ef374165b86b9d54300000000000000","merkleRootHash":"0x9aba87a91cdcc1a01fbb93e134bf856576bb5e92dc8e27050357138905ea5178"},{"version":"0x00000020","timestamp":"0x1c1fa566","nBits":"0xffff001d","nonce":"0x4fe3cf08","previousBlockHash":"0xb1efbc5bd5c91673a07d61b48917855ccbdac6d89ab497ae5a122b2a00000000","merkleRootHash":"0x2fa42670f688efb8d604dc2568f34ce08f816c986d28ad17ec75c6f97e7ef3ec"},{"version":"0x00e0602c","timestamp":"0xff22a566","nBits":"0x07936019","nonce":"0x21615f62","previousBlockHash":"0xddce389cdd9a611479bc4c46a49e1b137d56e83e242a37148eb4dff600000000","merkleRootHash":"0x9c803527917a566c884fc4c68c62ebfc835b178e2c38d379aff7929fa2caaef8"},{"version":"0x00000020","timestamp":"0xb027a566","nBits":"0xffff001d","nonce":"0x8e181734","previousBlockHash":"0xa905a300dce76efb75d56e92d7479e74171f054e2f0187512a00000000000000","merkleRootHash":"0x38399a0ac9b667a587703935aa1b78b795fc7cd0e3f67bc5c8bca163fd6e448b"},{"version":"0x00000020","timestamp":"0x612ca566","nBits":"0xffff001d","nonce":"0x4b71a711","previousBlockHash":"0x2993b9aa8d6a20075c9efaeb40376bc16ae073c18e9bddf767aa6ebd00000000","merkleRootHash":"0x3f1f8fd40187849449549b75822c59b8267c80d79c93821473882344dd9277fe"},{"version":"0x00000020","timestamp":"0x1231a566","nBits":"0xffff001d","nonce":"0x32604439","previousBlockHash":"0x2dee27907d0e90427b2887a1c4c4c2f77d231266ef1b473cd9ca5fd400000000","merkleRootHash":"0x723cc00d8f4c31fa9a772dc0a1cd3da0685f720ae121a3e0b5fbf558e0121d1d"},{"version":"0x00000020","timestamp":"0xc335a566","nBits":"0xffff001d","nonce":"0xa2f31e0b","previousBlockHash":"0xed973c2e543573948897d7f3ab2a9a62da3a7e8830a557fe4682306b00000000","merkleRootHash":"0x4ddbc6a6a468aca28c03f15b117e003a7caaa83bf9e33788d390d6bdb1d5559b"},{"version":"0x00608b2a","timestamp":"0x312ba566","nBits":"0x07936019","nonce":"0x1a98e91c","previousBlockHash":"0x76bce69a09a30ab938b716faaa7aa1a58da4a200b7dc2cb6f2ccc9e200000000","merkleRootHash":"0x356435b5917b672ad5b26834b6950146b5fd9632980b47227be0776adab3140d"},{"version":"0x00600020","timestamp":"0xec2fa566","nBits":"0xffff001d","nonce":"0x2e434ce5","previousBlockHash":"0x5be4dae08c15da95230bcbaac637dda46b398f7d80c740643900000000000000","merkleRootHash":"0x7555c85d529f7da823218705300edf2080a45cfdaa4f52bb056389599d81936f"},{"version":"0x00001c29","timestamp":"0xa633a566","nBits":"0x07936019","nonce":"0x6f7c0768","previousBlockHash":"0xc4748ee87439cab9abf716820030f576fbdd4245d0695712a3db110000000000","merkleRootHash":"0x64b86539d68b81f397fa212d60a56af3c125bfb2ce5856657a8b08af5dca5b00"},{"version":"0x00a06222","timestamp":"0x6d35a566","nBits":"0x07936019","nonce":"0x5960e3fa","previousBlockHash":"0x5087ff168a5b9fb80a3bc8eb4837392f322dea159d632b6e2000000000000000","merkleRootHash":"0x0bd7f13218fab732de728f418ec0d72ba125588dbfcd87e819d13a2b7cc85c59"},{"version":"0x00a07c2d","timestamp":"0x6b37a566","nBits":"0x07936019","nonce":"0x6d0145d6","previousBlockHash":"0x754be0abe29663c8624f4c2d1ca30384fbc44bd88d496c7c2e00000000000000","merkleRootHash":"0x84578db6626b2c6ac3e48cda4eaefd98a39aa42b6fac3be8375e08e684397550"},{"version":"0x00000020","timestamp":"0x1c3ca566","nBits":"0xffff001d","nonce":"0x95762b06","previousBlockHash":"0x9af41dbd3d489034e7a80c3a06326878c91991b46b1e4ee40300000000000000","merkleRootHash":"0x97aa350e772e2946688f8e8c5aa2a7bb0a16689f6cd1082fa7bda6fcdb93de00"},{"version":"0x00a0c42d","timestamp":"0xef3aa566","nBits":"0x07936019","nonce":"0x1366adb8","previousBlockHash":"0x2c4abdf9cadb09d854648d84c28be031fb8a6fcbbb3a3ef1fbffcc4500000000","merkleRootHash":"0x07c22fa6dddfbb408c1869a81688009fd929f4fc136eb587dd7759d3b012f0b4"},{"version":"0x0080422e","timestamp":"0x6a3da566","nBits":"0x07936019","nonce":"0x222565d4","previousBlockHash":"0xc6cff25bb245ba4ba7cbb1e18def17af20e07c8f8aa0bf764800000000000000","merkleRootHash":"0x2a5ad0ceaad15061e8494bfcb70d8006755ecb1a2bf8d54465b91ec8d66e8613"},{"version":"0x0040a02d","timestamp":"0xa741a566","nBits":"0x07936019","nonce":"0x9e111799","previousBlockHash":"0x5c79ebc24b232e4962f1edb8a3b48d0aa429ba0a4299f3393c00000000000000","merkleRootHash":"0x5f867edf9f9b12c0da4541a929ce34b43a92d330029135cb5a8889a7d3a05d60"},{"version":"0x00205027","timestamp":"0x5846a566","nBits":"0xffff001d","nonce":"0xda547d51","previousBlockHash":"0x2124c06b1bd63056bc1ddd39f4abbe8ce73566d561a13e8c3600000000000000","merkleRootHash":"0xcd36a071e588ab567f0cba9d5ee46a040537f2af78ab5ab4e322d8fd246b0634"},{"version":"0x0080f829","timestamp":"0xab47a566","nBits":"0x07936019","nonce":"0x7806daab","previousBlockHash":"0x6b617193295092d1ae52a80e5b87e58c5968e1575831904fe91c000000000000","merkleRootHash":"0xc31f0d6b67cd654a99bc5f4c8cef7cf5d59d442f6170c9365f0a46eec2403456"},{"version":"0x00800031","timestamp":"0x8148a566","nBits":"0x07936019","nonce":"0x5526ca2b","previousBlockHash":"0x1a6e5352f2f28e54f5f348143dee7453f0c6353061bc42bd5100000000000000","merkleRootHash":"0x3d122a24186c474faa14f742a3a039607dd775b8e16e44fb39dd4aa51f98ab11"},{"version":"0x00800120","timestamp":"0x8d4aa566","nBits":"0x07936019","nonce":"0x7974ee0e","previousBlockHash":"0xfacf93e73046c0ec241905a99cb9db868bb2d24f4b5954714400000000000000","merkleRootHash":"0xafd29d336d3810af09481d61018cb8d63b6ac645d33b284120dbebdcd0ecdcba"},{"version":"0x00000020","timestamp":"0x3e4fa566","nBits":"0xffff001d","nonce":"0x70f2ae27","previousBlockHash":"0xf97313029cb8026cff9cf008b8f17cbb23c86529d7009bf53e00000000000000","merkleRootHash":"0xd4951fb0455f5eeea6fcb56db9146b9d9b47bac31dd0719c0d732de630f0f092"},{"version":"0x00205222","timestamp":"0xe653a566","nBits":"0x07936019","nonce":"0x70d48b4c","previousBlockHash":"0x775fad721931746a50de1319a61ccd16f2ebf3cb76216b4031964c3f00000000","merkleRootHash":"0xc6e347e16c7b75283ea22e6f50816cdb0abdeb64776a0bf4efcd5e1ac7291c03"},{"version":"0x00000020","timestamp":"0x9758a566","nBits":"0xffff001d","nonce":"0x8fdce23c","previousBlockHash":"0x6c5820afe1ef41d59c08c10c24f4fa9ea971b24a9f4691b23d00000000000000","merkleRootHash":"0xece834ebe20a51eefe0f325013bfe8a0e4e6f8aa25da26f2225e77dec48918a5"},{"version":"0x00e0a122","timestamp":"0xf355a566","nBits":"0x07936019","nonce":"0x8ac4b235","previousBlockHash":"0x771c30ab28f8f4b57dc191f8636a78171ab1790e35dfc89be9c4509c00000000","merkleRootHash":"0x1af3597c2820a8cc68f4b663fddfbba86f80e31d10fff550d2b946611cd290bd"},{"version":"0x00000020","timestamp":"0xa75aa566","nBits":"0xffff001d","nonce":"0x4012bdad","previousBlockHash":"0xccf61aff5aff4212775b057db8b0621364a65dd9f93733b14d00000000000000","merkleRootHash":"0x3ad00fb0f3037516d33ac66c75e6b1a0283e9974ea15dfc7764946caeaaef64c"},{"version":"0x00000020","timestamp":"0x585fa566","nBits":"0xffff001d","nonce":"0x299a1f0d","previousBlockHash":"0x052517583918171b83d560ec0ee76d15660471aab72be447c0085c2600000000","merkleRootHash":"0x52f858e0de473fae39baea824b5de1e87e10d9ccccbf65c37b45285e1d05960f"},{"version":"0x0080ba30","timestamp":"0x075ba566","nBits":"0x07936019","nonce":"0xa24e09e7","previousBlockHash":"0xaad8bb43b4104fddeb61db73ac44fce7908edf56c09e1184844d505700000000","merkleRootHash":"0x59fe1a6eb771f7eac5d6d7704b75a95045cf6054aa3800c670f6b3bf893006ed"},{"version":"0x00608130","timestamp":"0xb45da566","nBits":"0x07936019","nonce":"0x0329613a","previousBlockHash":"0x2ed5e1afac06f47b67980661226d4ef7ddedf103857db96d4c00000000000000","merkleRootHash":"0x2a1fc97e1893200471c29e683fe32bdc696503796c87484d03ec06dab18ddfa2"},{"version":"0x00007021","timestamp":"0xca5da566","nBits":"0x07936019","nonce":"0x11614d3c","previousBlockHash":"0x36b3544c21ea687a94059893fb5351f2afa3664786fb4c864600000000000000","merkleRootHash":"0xaa2b0ce2d105245cab891a5d1ccf96e2c04588718f3cbf69e6e77a1737612f28"},{"version":"0x0080f529","timestamp":"0xba61a566","nBits":"0x07936019","nonce":"0xaecdd364","previousBlockHash":"0x2ada2972315d9f428f268a78b0e28b7963a7cb6d3a6fd7874c00000000000000","merkleRootHash":"0xbb06fc2d2db61edb3a086e47ff01a16c1b7ec6d8b6a8677a89c4406fead6c3b1"},{"version":"0x0040282c","timestamp":"0xe063a566","nBits":"0x07936019","nonce":"0x37597d83","previousBlockHash":"0x87d21eda9488b74faca446a24039529c2d3f4332f660af0a6000000000000000","merkleRootHash":"0x1c6a121a2624f1bd7ebe7b646420ddb46fdf7305871cc85e04f5fc3d0118d07c"},{"version":"0x00000020","timestamp":"0x9168a566","nBits":"0xffff001d","nonce":"0x42b96e02","previousBlockHash":"0x48788d1056c8b323ca5ce9094104d8cfa2c6acf1ae4986d11000000000000000","merkleRootHash":"0x9cff1242a1b885c1f38d6ec7e72ce5ebf58de52f15cf4120c0a18265ce36a341"},{"version":"0x00401126","timestamp":"0xcc68a566","nBits":"0x07936019","nonce":"0x813e4b30","previousBlockHash":"0x46a567d294f39866f6784093c1e30b0e99027d3b631e7457081622df00000000","merkleRootHash":"0xfaa39ab7cab19a14f9c3d7abd91fb5c55aefacef901b8515256b9729512a1a3f"},{"version":"0x00000020","timestamp":"0x7f6da566","nBits":"0xffff001d","nonce":"0xf5928e82","previousBlockHash":"0x6013cbf74fdc59c68861335ec7b1f67e315ac65d1dbe0eea1600000000000000","merkleRootHash":"0x1d60313ec05591aad380d6c3cdd9b56fdf85e1358e0eea05088f5a6ea2e99b4f"},{"version":"0x00e06a21","timestamp":"0x8271a566","nBits":"0x07936019","nonce":"0x2624bf08","previousBlockHash":"0x66bf5aa5054ac5b647a50f63b3a1e9ac55071c169fb364c0460ccd1f00000000","merkleRootHash":"0x4661bd9522a23be1433976cbdcd368a41393e2e592a7d77db3bbb8ac5989bcc7"},{"version":"0x00802132","timestamp":"0xdb72a566","nBits":"0x07936019","nonce":"0x5191c874","previousBlockHash":"0x2a1a41cbf93b011ca5054d0b9861006165400fadf2270aac0f00000000000000","merkleRootHash":"0xfde68992c32f0b3d0b84214e1c5cd4b9554bfe1b64cf65fbe6381f8490f71e0a"},{"version":"0x00603a24","timestamp":"0xe874a566","nBits":"0x07936019","nonce":"0xcec7e4b5","previousBlockHash":"0x17b5017fc2acd89c79800884fe74c941d02e061e88034e630c00000000000000","merkleRootHash":"0xb41cd8f6e19b4ec07ba8c1ff39c03cc19a74df5f6997c466b8327487d531494e"},{"version":"0x0080d62b","timestamp":"0x5576a566","nBits":"0x07936019","nonce":"0x1d30e343","previousBlockHash":"0xc8025fb7579e1c7d4058011b8cbed64afa48eaa518a1922b0000000000000000","merkleRootHash":"0xd5bce533312348652d268832584e235a50e4cdabcbba3846ce16fbaa6b06fccc"},{"version":"0x00200622","timestamp":"0x077ba566","nBits":"0xffff001d","nonce":"0x69b40e9f","previousBlockHash":"0xac674bb8628fbee4b85ddb3e2b1d4f460e49b7bc6d17a38a3a00000000000000","merkleRootHash":"0x13a56bdea9531b7ab68da6f0bbb37072154af7f50135554ffeef8e1965cdc2a5"},{"version":"0x00e0ff3f","timestamp":"0xb87fa566","nBits":"0xffff001d","nonce":"0x6032bb7f","previousBlockHash":"0xb9e577e7b883b411c94d3d6109f42c447a3601c34c2adbd63b20000000000000","merkleRootHash":"0x041b373a393a9f28acec0fdc34290770add77a1a709fcd33cb4cc899ee1451fa"},{"version":"0x00600020","timestamp":"0x6d84a566","nBits":"0xffff001d","nonce":"0x39c43752","previousBlockHash":"0xcaf8b286e6b5b1ec2209b95807508605d73840e151f6efaafefe030000000000","merkleRootHash":"0x5f2c3904a308822c5f3dc8161d1414b7a38eb5c0436c98ec75a9e26a5c01770a"},{"version":"0x00e09121","timestamp":"0xdf87a566","nBits":"0x07936019","nonce":"0x20248352","previousBlockHash":"0x0ed42567e5d262fda6253e400afd686f5d443798034b7a409cac290000000000","merkleRootHash":"0xde25d35ec87cd24f29c87f22c50ac290eebfacd03ad61b815995e83643252215"},{"version":"0x00000020","timestamp":"0x918ca566","nBits":"0xffff001d","nonce":"0x40ad2ccb","previousBlockHash":"0x8bc51f632557494f7954ec8a860d9129794953776f34b0492e00000000000000","merkleRootHash":"0x0bfbe2467b0f092a23cb16ccb96144f5437ebe3ac39416fd6864a58d48d6c654"},{"version":"0x00000020","timestamp":"0x4291a566","nBits":"0xffff001d","nonce":"0x357267d4","previousBlockHash":"0x04fce532e1f354cac1a710146eaad1c0c92f70810e00cface4b4f7aa00000000","merkleRootHash":"0xe616de8a3ed369a24c7d9d395863503e1c561c68c32b30dbfe420177aacfb213"},{"version":"0x00e0d52c","timestamp":"0x6091a566","nBits":"0x07936019","nonce":"0x0ee9731d","previousBlockHash":"0x71015be9e954baeb26f8313298b732c0ceba68259116c29bf205117900000000","merkleRootHash":"0x97c9f4eb4446e22df240200929f10cd6381e626d46d2096bb737e9aff28d1d1d"},{"version":"0x0080cd24","timestamp":"0xc194a566","nBits":"0x07936019","nonce":"0x23646fe9","previousBlockHash":"0x8039de4a14a3e9f885c43bc7329e52db43440d84393910952400000000000000","merkleRootHash":"0x6edd71115e52b351f3a011476f8cdede934dac7436d19594dda6357b56d5bb35"},{"version":"0x0000472f","timestamp":"0xe597a566","nBits":"0x07936019","nonce":"0x4d122f9a","previousBlockHash":"0x29ea1828dee7561d17d79de5c5ee6764fda0b5bae140791d4f00000000000000","merkleRootHash":"0x01988b77668987f23e2845746d8bfd0bf127967fcea251ed66fb044d84884402"},{"version":"0x00000020","timestamp":"0x969ca566","nBits":"0xffff001d","nonce":"0xcdb055e7","previousBlockHash":"0xddb9e6c32d614950203463bc424775bc1c30b639d4cc642c5700000000000000","merkleRootHash":"0x25129c37f8ea3c8c9d4fdc6a0803b5349bb88476229a2e77da6e45a8392fce22"},{"version":"0x00000925","timestamp":"0x4aa1a566","nBits":"0xffff001d","nonce":"0x496ed01a","previousBlockHash":"0xbf39ffe25ac1a63137526853bd5c1f9c562401b949b0389c5fbdb2fc00000000","merkleRootHash":"0x6b7412090006231c018e5e0fb1ff126c116cecf6b5df7d3e0e62fa83a8a070fb"},{"version":"0x0080412d","timestamp":"0xd2a1a566","nBits":"0x07936019","nonce":"0xc24274e4","previousBlockHash":"0xc939b0a41b209d1666fcd8853061909b87136bc5cb5411ac355c000000000000","merkleRootHash":"0x0339f937ebef9160feb610ba7e7a406066c73a905676a82502eb67861b0a6127"},{"version":"0x00a0b62c","timestamp":"0x18a2a566","nBits":"0x07936019","nonce":"0x8c944b6d","previousBlockHash":"0x6822ac6cf4ea24c1ae54fa0a59f56c584a5cf1a583fcdb4e3a00000000000000","merkleRootHash":"0x665c952d26ff233f6444e1f20b29d3a2ac01f1ef6f3fe783d9c9b57e8b6ff72d"},{"version":"0x00e0a824","timestamp":"0xcda6a566","nBits":"0xffff001d","nonce":"0xca588625","previousBlockHash":"0x9d890ac6a2ead6a7646d71a3545ad1afe43f178b10072cf14c00000000000000","merkleRootHash":"0x57cacd74e1dd67f135a9793ae587826471e57616815070db2f4a3d7d622f4c42"},{"version":"0x00e00020","timestamp":"0x84aba566","nBits":"0xffff001d","nonce":"0x65e7481b","previousBlockHash":"0x264d2ac6a3c7fb7dacbd074d6f4ff9ae360732b0eeb90705d42f000000000000","merkleRootHash":"0x0462de7737f916d52eb49a2ad46b18811b4878bdef19e8d1756eb552913d5125"},{"version":"0x00003434","timestamp":"0xf0aea566","nBits":"0x07936019","nonce":"0x37529ac7","previousBlockHash":"0x39cefd614d94d2edd25fb82ff8c4adc9990390a54e7000ef5916000000000000","merkleRootHash":"0x8a90d5c0a2f12fbac896217c4d8f451cb4e5c16e51a4ea702b3e907ab0602853"},{"version":"0x00000020","timestamp":"0xa1b3a566","nBits":"0xffff001d","nonce":"0x688ae705","previousBlockHash":"0x2a876fc08e6fd7f361dad3cd49e7e9fd2d525636bb7e534a1700000000000000","merkleRootHash":"0xd22092156684dbfa9000fef57b35f15078fc59917d39c0d1c94229d80ca7679e"},{"version":"0x0040eb28","timestamp":"0xbdafa566","nBits":"0x07936019","nonce":"0x94a81109","previousBlockHash":"0x5f055794e51d2cb728237a59a401323743ebbbabe316abe1679107ce00000000","merkleRootHash":"0x13bf8188a12cd233dac8aca47548f5804502982bf3e696e4b2bc870ed85cc9a0"},{"version":"0x00000020","timestamp":"0x6fb4a566","nBits":"0xffff001d","nonce":"0xea8564ac","previousBlockHash":"0x4170d5d28800503c3e5ad5f431c670dafc5ebbf1b818db353400000000000000","merkleRootHash":"0xf9e0802b03a59331eb3056183f419888ee4fc2ae51c079b50f03411d1ee2918f"},{"version":"0x00400620","timestamp":"0x10b6a566","nBits":"0x07936019","nonce":"0xd0715cf8","previousBlockHash":"0x4f1cb966cf1fad6478b8e7c2ae0b7d22779e2413284323e330e029f100000000","merkleRootHash":"0xccf3715cc6c424907fa64a50664979121ef0569d56c70b04156488b47f019445"},{"version":"0x00e0ff3f","timestamp":"0x74b7a566","nBits":"0x07936019","nonce":"0x74bcef04","previousBlockHash":"0xe05d5ed605ad85e3ed622f23b2d1e1b8860bbe0ed5cd0d5c1a00000000000000","merkleRootHash":"0xc6bc7974409a916e5cf94688f799eeece2a4ec4f1ccca0a4336419177e7c2326"},{"version":"0x00c0a22c","timestamp":"0x4fb8a566","nBits":"0x07936019","nonce":"0x4d5139a3","previousBlockHash":"0x18ddca2e06ce7c1432c4949f4366b6fa18fefea0b058ac1b2600000000000000","merkleRootHash":"0x9e226371a56e460d1828a5b8771b1f2ef92befa6697aa56cef45d070601c17a3"},{"version":"0x0040f722","timestamp":"0x50bca566","nBits":"0x07936019","nonce":"0x96da7f7f","previousBlockHash":"0x8d7ed83c580cf2e49737d70101862298a0222a4596e4fcb81100000000000000","merkleRootHash":"0x21794d886765b0c5014734dab4f434329c1dfc87a78baabd8e39e3920e378028"},{"version":"0x00a00324","timestamp":"0xbbbfa566","nBits":"0x07936019","nonce":"0x06c61e83","previousBlockHash":"0xe99c24e332c9f8e90f4ec32d4dcc186e7aca3380118e23595000000000000000","merkleRootHash":"0xbd6cc44cc0a6ee3779e1f4d79fd22fdaa40b4c3ebfddfe3658f081537aa2bea2"},{"version":"0x00000020","timestamp":"0x75c4a566","nBits":"0xffff001d","nonce":"0x802d6918","previousBlockHash":"0xd606fd4235a058419fa64e2c559f6ad0d325491ee318d3ee5200000000000000","merkleRootHash":"0xb70645d352c1bf89637ab6404c3219f17c809968b2651d62969a430196e5478d"},{"version":"0x0000e222","timestamp":"0x14c7a566","nBits":"0x07936019","nonce":"0xb926d099","previousBlockHash":"0x726a46d11453f575aaa824a540a895085dc49b741a245df6169ccdcf00000000","merkleRootHash":"0xbf953542f075c89c8bc2b4cadb197f9ad86c3fa7cd733d1fbe32fe6e732ca8de"},{"version":"0x00e0c32e","timestamp":"0x4bcba566","nBits":"0x07936019","nonce":"0x3b1aaa9c","previousBlockHash":"0x76f683281fc27b3148aa259d9a663d7cbadf97f90026c75c2500000000000000","merkleRootHash":"0x0b1385cba34220896f0d1fd28484a515f6e9fd882d105697d9e1e3b2fc1be489"},{"version":"0x00000020","timestamp":"0xfecfa566","nBits":"0xffff001d","nonce":"0x8b5b2a08","previousBlockHash":"0x0b88fcd4c22193ee43dc01f1b83fa06c46f0806f99bb9c0f4c00000000000000","merkleRootHash":"0xcfac57736c296fc7fa980124b8e9a9e8378f1617818b3a8f5ff2dac52987f491"},{"version":"0x00407121","timestamp":"0x4ed4a566","nBits":"0x07936019","nonce":"0x6b6d38ca","previousBlockHash":"0xb39df7b2e38f6af10326dab6ad8e0267350188d6834ef308558523bd00000000","merkleRootHash":"0x8ff031323b57c2fe523170158a5b768c75c6718af63c264505be63584b597037"},{"version":"0x00a01721","timestamp":"0x98d4a566","nBits":"0x07936019","nonce":"0x6a02e7b7","previousBlockHash":"0xb1b82d8abbc0fe9b8700e9f463a1fe6f0072872da6c54a475500000000000000","merkleRootHash":"0x9ff56facc478c59e506c5f73693ad673926a0877f3a43e2e3cc0386f175b2a4f"},{"version":"0x00000020","timestamp":"0x4ad9a566","nBits":"0xffff001d","nonce":"0xc1b8a9cf","previousBlockHash":"0x315d28d37b05f3c7a8057892d7030ad00fb122f7f6f8a1b54300000000000000","merkleRootHash":"0x9072eb33d39b0d30d865532e26a4ecafd9d5831be907c3e9b6568b63ecf3f2c1"},{"version":"0x00000020","timestamp":"0xffdda566","nBits":"0xffff001d","nonce":"0xcd149aa5","previousBlockHash":"0x743fd4b58105b66d5d9bb1fbca98317092b9d7f2fb41e60dd0ed6c1b00000000","merkleRootHash":"0xd38d03202725c7feadcef3f1c4a74cbce456d2448b537e46285de4ae248679c3"},{"version":"0x00c0c02e","timestamp":"0x63dfa566","nBits":"0x07936019","nonce":"0xd34814f4","previousBlockHash":"0xf38e4c72d6e2660ce7c80d2051617c5051b49061724b1a08d269d97d00000000","merkleRootHash":"0x1d91d7858d9d1c7835e3fc094ea76410c150b27e08e0cbf1f9377d8d46b1c51e"},{"version":"0x00000020","timestamp":"0x18e4a566","nBits":"0xffff001d","nonce":"0x000a3654","previousBlockHash":"0x68c4a3bde4d7fc5cda8e7ea2d86abecde678ae0588ae65c70e00000000000000","merkleRootHash":"0x8ee3284d0e70a2810768a763022548f01f2e0d9eea6b83794ce23da3de28590c"},{"version":"0x00000020","timestamp":"0xcae8a566","nBits":"0xffff001d","nonce":"0x8e405af9","previousBlockHash":"0x83eddfe8ecde67238fa63c6c883cd947dec0b566dcab9c8c3f807dc800000000","merkleRootHash":"0x60a18891c562694469481e0fa602f17c8ac241a2f681f81b76baa748e004b21b"},{"version":"0x00601920","timestamp":"0xc7e9a566","nBits":"0x07936019","nonce":"0x09641258","previousBlockHash":"0x20c62cf3b38d402c7058d4c40f97d5b7493c4d3e1cdbfddbd0a97d9100000000","merkleRootHash":"0x1e5899ae5513fb566786f225118239cb902991956e03cc4de653411472de6590"},{"version":"0x00a0ec27","timestamp":"0x5feea566","nBits":"0x07936019","nonce":"0xb7324028","previousBlockHash":"0x3b5ba19654f3bed17d94507762e62e42292aec9247a3409e0600000000000000","merkleRootHash":"0x2e57a9c43b459a7a08208833b5a7a82ea7477666d8a5b1322ceb984b12e9f36e"},{"version":"0x00e06723","timestamp":"0x89f1a566","nBits":"0x07936019","nonce":"0x92582ff0","previousBlockHash":"0xd665fa507fd2a182580e8509e1fe6519370f22bee459d7de5a00000000000000","merkleRootHash":"0x2a12b715fafbe4281a93cdc12293575a3bd85647bfe7db6007a0b0fced4116e5"},{"version":"0x00a09a28","timestamp":"0x16f6a566","nBits":"0x07936019","nonce":"0x295c1fa0","previousBlockHash":"0xd9a20ae41a8ff447031e509aa2aa676054fec22fa04ca8f80100000000000000","merkleRootHash":"0xc81316a222aae524009465d1897b3c5b618cffeafe8ae90d4a807e4133987630"},{"version":"0x0020d52d","timestamp":"0x18f6a566","nBits":"0x07936019","nonce":"0xaa20e400","previousBlockHash":"0xac49069c625530be386af498dccaa0e458e91b5eca27e5b20f00000000000000","merkleRootHash":"0x9a9b5efb01d259a8ec23be93468e8a0fb3ee74e0c342212aee513a803488dd1a"},{"version":"0x0040d621","timestamp":"0xcbfaa566","nBits":"0xffff001d","nonce":"0x1668ddfc","previousBlockHash":"0x9b6a6bf598d2fc04e94c3dcaa64969869f8a651bb078c2df0f00000000000000","merkleRootHash":"0x8926aa417b11e046d4fa4e057fd4c5da76e91b6ad102e23c55233c2611ca4f4a"},{"version":"0x0080ac28","timestamp":"0x7fffa566","nBits":"0xffff001d","nonce":"0xdfb27aeb","previousBlockHash":"0x752cb3bf57ad88b2eb4c573f0fecb263b9ec3da0ca38be1ff171000000000000","merkleRootHash":"0x1aaf10027852130ea13b51a6113c5c62c725edb07998efdf14bc9620891cd314"},{"version":"0x0020832f","timestamp":"0x9fffa566","nBits":"0x07936019","nonce":"0x194d5f25","previousBlockHash":"0x24d300e98cca12095f2cc6ed73cc3a5141368d1376d05480cd1c000000000000","merkleRootHash":"0x91b2c4972c2ba7e999a29116fdf840cb51238c500e34817f35d64b61244492d4"},{"version":"0x00806127","timestamp":"0xfb02a666","nBits":"0x07936019","nonce":"0x7c60f8d1","previousBlockHash":"0x8dd495cebd9a433979ee9d17b5bf749733c5d424b4943c643f00000000000000","merkleRootHash":"0xa7c59520c03f3b03fd4a8c4f44c49a7f2a1fa883b32bbdc4645d98d520273466"},{"version":"0x0000ae23","timestamp":"0xf605a666","nBits":"0x07936019","nonce":"0xb7770235","previousBlockHash":"0x008afa38799fd609080c6f88c5847f978dae87173c51427f3400000000000000","merkleRootHash":"0x686caee39c12e7dd140fbd82bf20221e88f782f5851c35066104ae05167ea08c"},{"version":"0x0060b12b","timestamp":"0x0808a666","nBits":"0x07936019","nonce":"0x027e33f7","previousBlockHash":"0x8898f235e9785d6c5e897899e3768331e2845718a5592b854500000000000000","merkleRootHash":"0x8b9bbaa272e550c19534d901fe08b72e24e08f66d53f88e98217fab8c3b3ad01"},{"version":"0x00000020","timestamp":"0xb90ca666","nBits":"0xffff001d","nonce":"0x7ee17015","previousBlockHash":"0x0d3079450159f8c811831398a0e89346083b4fb500e5b32c3400000000000000","merkleRootHash":"0xa7d55896c885b9f4986bf3251286162f3b034d6e27210b8a4df5ac6a856f92bc"},{"version":"0x0080862a","timestamp":"0x400fa666","nBits":"0x07936019","nonce":"0x4b3036ed","previousBlockHash":"0x137fdb95aa888611f9c126dfab55bf50528016ca73c127f5124daf0000000000","merkleRootHash":"0xfc0ca067c23d79ee23c6514e981b3bc3be3df5e218bde88bfff0b25b0760ecbe"},{"version":"0x00000020","timestamp":"0xf113a666","nBits":"0xffff001d","nonce":"0xc0cd974a","previousBlockHash":"0xc3dc2215a49775ba905b82ab32fa038d6f0179b44a057de90c00000000000000","merkleRootHash":"0xb74e84a3283354a61dd2027a25920d959e4fd27f7bef91f3cab5a4b9b697903d"},{"version":"0x00406326","timestamp":"0x0313a666","nBits":"0x07936019","nonce":"0xab4ca1d8","previousBlockHash":"0xdf37b2be36919912eb11a964a3a48f9ec8c7039c3613f6d5e56e67bb00000000","merkleRootHash":"0xd48385c0ebd01191a387f412fd277accf52dde88bf02d6428a3eda40c9c2824e"},{"version":"0x00000020","timestamp":"0xb417a666","nBits":"0xffff001d","nonce":"0xea83f20c","previousBlockHash":"0x74a12472be38f92cda54f2df9dc9d3f1b2264f893bd82d214c00000000000000","merkleRootHash":"0xf5cae1e591723cba50f8b48b4387f584e6aaf05252522fe483f42b6042b8ce1c"},{"version":"0x00000020","timestamp":"0x6c1ca666","nBits":"0xffff001d","nonce":"0xc8429cf4","previousBlockHash":"0xa3488108bee2299d1b5d21880309c4bbd1d461ea8ccbbb2ae733e61b00000000","merkleRootHash":"0x05c5879150825d9b21d4f259b600676b1a6bf2152e1d9792b590290350b732f0"},{"version":"0x00000020","timestamp":"0x1d21a666","nBits":"0xffff001d","nonce":"0x3d5a4c35","previousBlockHash":"0xd2cbb97c594760b977be9a95215f0dd18ade2a3aabeb13a90caa3ddb00000000","merkleRootHash":"0xe58d47e3ee6e1d7660aa983de731e5992eaca34ea73a7529e547e5c73fc046cb"},{"version":"0x00000020","timestamp":"0xd325a666","nBits":"0xffff001d","nonce":"0xd5f341b8","previousBlockHash":"0xa26794261d0b25dcf477e16cbb5b983c0d7a2848fbb7760f8de8502100000000","merkleRootHash":"0x5ffe6e086ebce74692ca1a775e3f26278ca40f51ae888f3fb10a86bd0a574a3f"},{"version":"0x00206423","timestamp":"0x3328a666","nBits":"0x07936019","nonce":"0x2e68e931","previousBlockHash":"0x6f588e600f53d2961d8783c3a44dad61834e6da1c20c193f0eeec3fe00000000","merkleRootHash":"0x5ec6acdeb390a433828562e808d14ac8368135c0676267f51b1bff61217e4ca8"},{"version":"0x0040262f","timestamp":"0x2329a666","nBits":"0x07936019","nonce":"0x94305f20","previousBlockHash":"0xdd1e86d58e20504d9acf0753c3567a715a43a1a7899f2c2a5800000000000000","merkleRootHash":"0x4faad06d42ee2b7ae8c3360c1f27775172a3ae4ad951f3f4c961523b725d5d38"},{"version":"0x00a01d21","timestamp":"0x1b2ca666","nBits":"0x07936019","nonce":"0x9d615a94","previousBlockHash":"0x860ff6b1df2a8cc7f2dadb811957f31e72d9d6c7af0632202600000000000000","merkleRootHash":"0xc8e4fec98ad1545ebf164c50fd2f23895ec052d82e923c8c5b9e085555226f73"},{"version":"0x0060bf26","timestamp":"0xd330a666","nBits":"0xffff001d","nonce":"0xa53abdc8","previousBlockHash":"0x5ffe2e81674359221e423339281c21612381546b30c881493e00000000000000","merkleRootHash":"0x50f82d36f58c651595f51be055fbadaf613bf888de9ef87afabc66d9c118b977"},{"version":"0x00000020","timestamp":"0x8435a666","nBits":"0xffff001d","nonce":"0x2a37d61d","previousBlockHash":"0xd60fbb391065978f2b0f05cafefbcafbe537ab1dd7cc1af40a06000000000000","merkleRootHash":"0xff438492a950584da5a16518fb36b1d53b78ed73325a6510fdef9aecabb41d56"},{"version":"0x00a0842a","timestamp":"0x0c36a666","nBits":"0x07936019","nonce":"0x95264b7e","previousBlockHash":"0x3f8f54efee515b3ccef4e701282af53ef425f88a390ae25201d2c2fc00000000","merkleRootHash":"0x07b4d2194b52457ffa7e803e1c4cf5c6c559d6b992556f35fff12f101b36648d"},{"version":"0x00000020","timestamp":"0xbd3aa666","nBits":"0xffff001d","nonce":"0xa8a8e10f","previousBlockHash":"0xd2cefd3ccb7a87c21c20be79c2bce338720183f99570d77a4d00000000000000","merkleRootHash":"0x34b03ce28719bd9f095eb09a621ccc788883aedbf5a18f5bee8973271239959e"},{"version":"0x00000020","timestamp":"0x6e3fa666","nBits":"0xffff001d","nonce":"0x6382b21d","previousBlockHash":"0x45c42a410c15f5f1bece80d2b32b91e5ccfddd7b95ce41cd55a15d7800000000","merkleRootHash":"0xd2dec6fb75ee6da32d25bdae5b4eca67a8f6a05f437adf25071815b914f23811"},{"version":"0x00a04e26","timestamp":"0xf33ba666","nBits":"0x07936019","nonce":"0x72015005","previousBlockHash":"0x0182191a9cf4fb3dddd811fa3486732cea8b335332112b6c40d1491d00000000","merkleRootHash":"0x17f29ab153add336dfea4201ce0cf9b816485d0d1249da6070333f8da7863a17"},{"version":"0x00206131","timestamp":"0x373ca666","nBits":"0x07936019","nonce":"0x513a4a01","previousBlockHash":"0x8fc9539ff8e8406c8df9a6ca3eae2907972b6c3f1c16db5c4f00000000000000","merkleRootHash":"0x21c7530c8a89ca4539eec1ea1ae3b8196bd488f8498ec400cc65656fa65fc859"},{"version":"0x00000020","timestamp":"0xe840a666","nBits":"0xffff001d","nonce":"0x3eb17b06","previousBlockHash":"0xfa3350b8630152684ca491313fa59cfde518ecf41b6daa085b00000000000000","merkleRootHash":"0x6a4a4495d192e54c81e1b851e04f71cb7de95884a7a9654a68e8027e20a50a5c"},{"version":"0x00000020","timestamp":"0xcd3da666","nBits":"0x07936019","nonce":"0x538ee72a","previousBlockHash":"0x13f8998e4f89facc929d48c6c70c6cdc87f9e2256391dc35cf31c63200000000","merkleRootHash":"0xeb716b33498e300c8d4818a7b5d30eab16cf51c6a81b71d669b3dc8d312a1113"},{"version":"0x0020632a","timestamp":"0xf240a666","nBits":"0x07936019","nonce":"0xd89e06ff","previousBlockHash":"0xa03c9e2078f15fb6bfcb91c4d8f4d22641add164b358a99f5100000000000000","merkleRootHash":"0xe11cc4ebcdb41121b43249df42031840a3ec08927571fcc63c36d3a324f6c63d"},{"version":"0x00a0f233","timestamp":"0x3342a666","nBits":"0x07936019","nonce":"0x0215d055","previousBlockHash":"0xefa1300cf4ee0bc5c230e8e00d0b977e6df851f89b8d4c8d3100000000000000","merkleRootHash":"0x135c3be3d6ebc27dd293e3a04d00dd53215dd775f463f83ef73616e97f9ca302"},{"version":"0x00000020","timestamp":"0xea46a666","nBits":"0xffff001d","nonce":"0x804549f5","previousBlockHash":"0x44b71ef31389e6ed845a7b285488aa2f611dd8c71a5fcfa51b00000000000000","merkleRootHash":"0x1cf4429423082cec1c96e151f11125d4e41d83eff092bbd315a0412f0ff22ad0"},{"version":"0x00001d26","timestamp":"0x5147a666","nBits":"0x07936019","nonce":"0x7ea29a4a","previousBlockHash":"0x362c2b1cb4dfbcad809278aee965144931cb42b22cb56018327f9b4000000000","merkleRootHash":"0x74d113bc1c8e3cc355571b5637be1644084a3518fc038469dbf7491a371da93f"},{"version":"0x00a0bf29","timestamp":"0x7947a666","nBits":"0x07936019","nonce":"0xd5029c1d","previousBlockHash":"0x4e017b764658db67fec4faeed9a0cad287a37748e0ee62fe0600000000000000","merkleRootHash":"0x454e94fe410d9553daadf3970d8de6d482d7afb008e4f4a7e0c90ccbbe87dd14"},{"version":"0x0080212e","timestamp":"0x7f4ba666","nBits":"0x07936019","nonce":"0xa564fc50","previousBlockHash":"0x4ba9b918916e76962d8a501f6bd57a05c22e3470125e75172000000000000000","merkleRootHash":"0x6a5eef3c0b7a3a1a4767adf4c3cd8b56e76ea338a8fcc74b8c31a232143280dc"},{"version":"0x00000020","timestamp":"0x3050a666","nBits":"0xffff001d","nonce":"0x7cf25211","previousBlockHash":"0x20f307cd217cd8eeb96e31bff94777c4e200c0a5a2f0f7b91a00000000000000","merkleRootHash":"0x9ac30c25d4d24d841dd56429d69eeb48e645989d5790ccf3f803028f27de0469"},{"version":"0x00400020","timestamp":"0xe654a666","nBits":"0xffff001d","nonce":"0x8984759e","previousBlockHash":"0x98d6c7fdac2e048f4804697556129b5371290757a4ed798642b99f6a00000000","merkleRootHash":"0x145cae4ec9d2035fad7f8ef6954ee6979ed9d298a0131f86e887d22acd80cf8c"},{"version":"0x00e0a222","timestamp":"0x8457a666","nBits":"0x07936019","nonce":"0x0cced9df","previousBlockHash":"0xafb7475af5e6316bbcb74c123cf1188541302a5eca1d35cc36ab700000000000","merkleRootHash":"0xb30cc66c76cf592a1d3689aec0af714af54bb1f5b11fb46e560db3114edc6a75"},{"version":"0x00000020","timestamp":"0x355ca666","nBits":"0xffff001d","nonce":"0xab6e3570","previousBlockHash":"0xe4ce703e8235be64c51dbe7f1cf3beccbc28f18e72da06981b00000000000000","merkleRootHash":"0xc8b2427c76c646d23c69cc0b740335f5b5931971611c8fdeacc6f61cc572e1d8"},{"version":"0x0040432d","timestamp":"0x7359a666","nBits":"0x07936019","nonce":"0x66b0b964","previousBlockHash":"0x53a3937896716c49b287b8f2f096634d7755d8101e916292261e981c00000000","merkleRootHash":"0xdefc13ab16b3923fd50fed67c92a94925b6d380494a68b9d092855390741a438"},{"version":"0x00000020","timestamp":"0x245ea666","nBits":"0xffff001d","nonce":"0x7901d502","previousBlockHash":"0x7995a57e8bfc280d63e95a33453ea77508a2de4dc696df8a1f00000000000000","merkleRootHash":"0x07502c3feb8f7c4f84ca6d3ca799bec3249938e9cd8fc4579a0f3eee7bbb4f54"},{"version":"0x0040942a","timestamp":"0xae5da666","nBits":"0x07936019","nonce":"0x10029d58","previousBlockHash":"0x84968537a778aa49c66fef7d556788814f7e5ecbaf2b718dcb0dce5900000000","merkleRootHash":"0x07a0d6fc89d65845541e5e93da342b11e36f7dc454f20ff52253cad4439137b2"},{"version":"0x00000020","timestamp":"0x5f62a666","nBits":"0xffff001d","nonce":"0x9f22a808","previousBlockHash":"0x89314b0da9b5defb90554f2abc2238b367accaabfd2c9d681e00000000000000","merkleRootHash":"0xc8cead6650ce44bc400d0c89ed813327a3bd955d344f632b8ef9d754a87226a3"},{"version":"0x0040e52d","timestamp":"0x1d64a666","nBits":"0x07936019","nonce":"0x6bb42a1f","previousBlockHash":"0x84c4bfaa65291d292627997a8926b761dfc19ec7eaccb8f778b701ad00000000","merkleRootHash":"0x3ad9335743b5005c32eecce8896c329d2506499ea3b37ad4c2b8c7e08be27497"},{"version":"0x00000020","timestamp":"0xce68a666","nBits":"0xffff001d","nonce":"0x170b071e","previousBlockHash":"0x2e97dfb51a15c1b508020152c119cd358b1a92c71fd416444000000000000000","merkleRootHash":"0xf44e31fee71d2d5430dec8aefa20f5af691c79ae381b0f8294af10abc1627141"},{"version":"0x00000020","timestamp":"0x846da666","nBits":"0xffff001d","nonce":"0x1586bb45","previousBlockHash":"0x737978e2827bd0ac40417a8b133bfa7f62a19d688e7f84b59809c7f600000000","merkleRootHash":"0xeb827d5a3fe6447c33ea79d2f65a92bafac9f3217dbe66aaddd4fb9c17f49699"},{"version":"0x00000020","timestamp":"0x3572a666","nBits":"0xffff001d","nonce":"0x0d59c50a","previousBlockHash":"0x6c3032a4221dfc412798fbba5e85a571309f033cfedfa1668e58019e00000000","merkleRootHash":"0x2ce499d5136cf4a606272b7c98ffc83fcb151e5422a05f3b12dfbb105399e258"},{"version":"0x00000020","timestamp":"0xe676a666","nBits":"0xffff001d","nonce":"0xbec79501","previousBlockHash":"0xbee198f03db473ac7c93ad8021ccc5a9dc570ed1c2c295160d2fa98400000000","merkleRootHash":"0xc7299f2295bd1776a4f1d14698246f0872d3099d27c77239a340c943e1594ee2"},{"version":"0x00e03727","timestamp":"0xbf6fa666","nBits":"0x07936019","nonce":"0x11716d39","previousBlockHash":"0x86c0b52c9b3ed1da8de53ca6240b5b28b0becd5c9b87396c794bca6600000000","merkleRootHash":"0x0ab14ba77a5667a87fd710c0523c4276dfb74b64f538807ee1d51436bd3a6711"},{"version":"0x00e08a2d","timestamp":"0x1973a666","nBits":"0x07936019","nonce":"0x1aa4d7e7","previousBlockHash":"0xa6186798005a23371ff987aa64a9cc8e9dfbe207cf6f1a006000000000000000","merkleRootHash":"0xd51f70dcb7dddb28e45a99078248fe2ea854dbe4195c5a8324aaffed1dbc6ded"},{"version":"0x00000020","timestamp":"0xcb77a666","nBits":"0xffff001d","nonce":"0xedba5cb2","previousBlockHash":"0xa901a843ea1aa5897938f8da07f39dd4eacb1103d11872b05600000000000000","merkleRootHash":"0x949a841c98f24643d9c80642b60ea9ab81e3fc816b877ab8f542588cf40dffd1"},{"version":"0x00e00020","timestamp":"0x807ca666","nBits":"0xffff001d","nonce":"0xbaa64904","previousBlockHash":"0x00b07e87046c57df9fce481a91c6bd89c02af928e915e65554a4ede400000000","merkleRootHash":"0x3c2fd379c469c4deb7ff8d14b1b83c6a9fa02f36278732897e2abbd58db90fa7"},{"version":"0x0060fe29","timestamp":"0xca7ca666","nBits":"0x07936019","nonce":"0x68ea509b","previousBlockHash":"0xa1a3f8132aa3cae39440615cd177750d50e3f9945c5cf1b0a97d000000000000","merkleRootHash":"0xe5e0c2d795bd62aeb652314c81666ff7e95cb94ffe99f0330ca27ddb113fb834"},{"version":"0x00c04b2c","timestamp":"0x9c7da666","nBits":"0x07936019","nonce":"0xb0a62d6d","previousBlockHash":"0x088de598c06cf1ddca1a06a67c6dde68fe85e4d7b3db9c2d1200000000000000","merkleRootHash":"0x80ede4c08b3785852492cd305a66c7982dbf424e2d38c99345ab8c802786f89e"},{"version":"0x00006123","timestamp":"0xd87da666","nBits":"0x07936019","nonce":"0xa328919f","previousBlockHash":"0x2d684fdf6aba0b6707bd3a1647dc4ff50a22056b5aeb3a6b5300000000000000","merkleRootHash":"0x3090f59c7cda1f3550e3a6a968ebc8abdf1952a827d48b96604da34a8e78d97d"},{"version":"0x00609827","timestamp":"0xc280a666","nBits":"0x07936019","nonce":"0x7aa02388","previousBlockHash":"0x7b4fa292543dc25b8c05f25058834dd91b35a5b1bf33f5392300000000000000","merkleRootHash":"0x247617fc6b2b86a8e959293e4d113cae4eab25790a7e1841cb6155f547abdb4e"},{"version":"0x00a0bf22","timestamp":"0x4582a666","nBits":"0x07936019","nonce":"0xcb7949d9","previousBlockHash":"0x2df184ced9d25641fbf73b898561e9359eb1a35029485cf72d00000000000000","merkleRootHash":"0x24c4d6660e16a455ad081c49a761b10437789e7a641c8f33bbe8894b8ad9782d"},{"version":"0x00a0132a","timestamp":"0xd583a666","nBits":"0x07936019","nonce":"0xd325d2a5","previousBlockHash":"0xd1e65933f03675c0d231c236ab6a2fe5d3030cfcfc04670d4300000000000000","merkleRootHash":"0x74c45792beefd4acc52fca207960807b7ed13178296bcdd7ad3f22d66ff22299"},{"version":"0x00000020","timestamp":"0x8688a666","nBits":"0xffff001d","nonce":"0x258e1409","previousBlockHash":"0x2a9976f590c5ffcdefced5291065fe6da2091ca943b5869a5100000000000000","merkleRootHash":"0xd0401a2af3bb49b757f0ad189f08b63f5b5ef4e60f984ca4e95279dc9aa0ceaf"},{"version":"0x0040692d","timestamp":"0xc485a666","nBits":"0x07936019","nonce":"0x2c04a574","previousBlockHash":"0x12a19b8520d293f5746e065039626fe2ee7c4252d7ffd01fbbf6937300000000","merkleRootHash":"0x89d5f88cd03e62dff1919dda68ea16a26cc101f8f65332d866de683340316841"},{"version":"0x00000020","timestamp":"0x758aa666","nBits":"0xffff001d","nonce":"0x86b5c802","previousBlockHash":"0x343720d090db0b4fa60dce9519457c62206f2febfa1ebc772e00000000000000","merkleRootHash":"0xa463fc8e980e4726ba2708eb372f0e3ccecd09e098a254e1a73f1e296a779a0a"},{"version":"0x00a0012a","timestamp":"0x738ca666","nBits":"0x07936019","nonce":"0x33064578","previousBlockHash":"0x87f01684ade84d9f773e90bf7eda7bd1f1ec15beae42201ea8efd66a00000000","merkleRootHash":"0x7e8b653070cf69d770da2729a903c83c2a63dd9132054ea94fd5116bd1dbcff9"},{"version":"0x00008f23","timestamp":"0xf28fa666","nBits":"0x07936019","nonce":"0x1d5237d1","previousBlockHash":"0xccbd9576d9946e44a4ac6ac2475b211e7219412aada441525400000000000000","merkleRootHash":"0xe714740d28b6c1266dd1200116d588dee7380922e7c0fe36250bfc97146a0491"},{"version":"0x00000020","timestamp":"0xa394a666","nBits":"0xffff001d","nonce":"0xf8f5cd1e","previousBlockHash":"0x7dd6270f4a82401c2425d4f32403f41dde8c1e83fbe844db4200000000000000","merkleRootHash":"0xe133d9e8755d0d2cb72edc321c7155d2058c208a9451ab817778a688671c564c"},{"version":"0x00000020","timestamp":"0x5499a666","nBits":"0xffff001d","nonce":"0xa8ce572d","previousBlockHash":"0xe32674018b61ce8478af86c664ea8b09a0d38b394e275b8655a3714500000000","merkleRootHash":"0x0ecd294fb2365c89e2f943b491aa05c39d48df6bf617c04b05be23772d0da3a0"},{"version":"0x00000020","timestamp":"0x059ea666","nBits":"0xffff001d","nonce":"0xdbc56e02","previousBlockHash":"0x454bf012dc311b25871ca9c53b9c99537f7f2132db7a570d897064dc00000000","merkleRootHash":"0xe074977eb8a76941b66fafcf9ead7c8e30b526e47c13c528e9ed9d3e8353331b"},{"version":"0x0000712a","timestamp":"0xd597a666","nBits":"0x07936019","nonce":"0x1ccc46c1","previousBlockHash":"0x9ad6319600072af4446f683e2dbd885e57404e692cfcd1d1f8cc5c4a00000000","merkleRootHash":"0x4ec22c1d76f079695fcef88b74094f5f93f8b6cda6602cf11b1207637f766bcf"},{"version":"0x00a01426","timestamp":"0xc397a666","nBits":"0x07936019","nonce":"0x0b46f48f","previousBlockHash":"0x06cae7103b177d7c9336256adee8aa935fbef4b2bf7eaec31800000000000000","merkleRootHash":"0x448f911dcfc5c34eff1e0e835126188169601cebe0bc86e80d745e8d2a56074f"},{"version":"0x00601d29","timestamp":"0xa498a666","nBits":"0x07936019","nonce":"0x3cf0ef90","previousBlockHash":"0xabf8f57fe635abe754964d4d586c299fcad14ca1997a48dc0e00000000000000","merkleRootHash":"0x4577e94d658fe5de08a86680bc0766e875c43f094d71ed7986426ce91b52ac27"},{"version":"0x00a04128","timestamp":"0x0a99a666","nBits":"0x07936019","nonce":"0x1e386a21","previousBlockHash":"0x8b62fa7936902d5a87892975ef29b24c58e706afee2d9f9e0e00000000000000","merkleRootHash":"0x68e76482c98f0d15a6c4540756445887855be5b37e7235168a5d042b250ede26"},{"version":"0x00009f2e","timestamp":"0xc59ba666","nBits":"0x07936019","nonce":"0x0f4cb49b","previousBlockHash":"0x6629dbb58bf649e5b800e0fa1d51e429af031e0b5382025a4f00000000000000","merkleRootHash":"0xeba416859a12f378766eb38ff8f66e8df7c8020807567f92dae34d3fb8e7f074"},{"version":"0x00e0bd26","timestamp":"0x159da666","nBits":"0x07936019","nonce":"0x9ecc4944","previousBlockHash":"0x50f4bb1931eb6f4b331fa0541fe4ac0e309483241468d5952c00000000000000","merkleRootHash":"0x4b4357fc80efdc774671e8c1b51446ddee15735192dddc02f064423c6116cf8f"},{"version":"0x00c0b124","timestamp":"0x009ea666","nBits":"0x07936019","nonce":"0x938e0554","previousBlockHash":"0xf1e37aca09829fef226e69a261258980be3cf713e97e71f71c00000000000000","merkleRootHash":"0xf08937896a1ad11597cfedd65da8a0e208cbe8b813fba4da41c49b594045d243"},{"version":"0x00200e2f","timestamp":"0x3c9fa666","nBits":"0x07936019","nonce":"0x547d1b21","previousBlockHash":"0x6a7a7ceed8fe1ae11c2912fbd30f73924dd2b765a8a709b23800000000000000","merkleRootHash":"0x710702fccec950c8696a7531934539eb5ec5fe152c289a72d53dcaf9daef24e0"},{"version":"0x00000a2e","timestamp":"0x8ca0a666","nBits":"0x07936019","nonce":"0x74b514b4","previousBlockHash":"0x8079f9bddeaef8982311be83220bc3054f34ad5e6162042e4900000000000000","merkleRootHash":"0x04554b450b3002f333a01b6b528fa61a313a6845070e8da85d197c61eb881830"},{"version":"0x0000212b","timestamp":"0xf6a0a666","nBits":"0x07936019","nonce":"0x08550b1d","previousBlockHash":"0x2d6ad5c4e2d4ef1d37a6671bb8b4f66492fe0be6ff52c6e93700000000000000","merkleRootHash":"0xcbc46891b97a5d12da48bc8aa49e14428f8f525aadf2d458f86b0e3dc5dd4191"},{"version":"0x00007423","timestamp":"0x23a3a666","nBits":"0x07936019","nonce":"0x7b24d36f","previousBlockHash":"0x5356ba5fa77caef32c0e247847fae80a3ea1b3ea7d298ac83500000000000000","merkleRootHash":"0xb5199a0c50b4f89ee7a0786dc1a638f8054c0ba3cc00f6173fc9da072a271f9f"},{"version":"0x00a0232b","timestamp":"0x0fa4a666","nBits":"0x07936019","nonce":"0x4846a378","previousBlockHash":"0xeca41b00b27fca3e59ea309e5f7a272a7c8b92eb790fc66a0300000000000000","merkleRootHash":"0x8ea4efcdcdccae0e1d1d9b06ab9d0be418d9ef4b63b9fa9bc2fb849bb5d0cd48"},{"version":"0x00c0072d","timestamp":"0x4ba7a666","nBits":"0x07936019","nonce":"0x6f25080e","previousBlockHash":"0x9ec1b6baa638eb843e52db02a2837c5104ffb31c8be7e4351100000000000000","merkleRootHash":"0x4a4135e959c8e0a0db71927937f1eaed6608204795c7a74957c79ffbb38219fa"},{"version":"0x00406124","timestamp":"0x83a9a666","nBits":"0x07936019","nonce":"0x2d0d61c0","previousBlockHash":"0x7eedb4fff62bf748113e3a803bcd3129797d2900105a6a524400000000000000","merkleRootHash":"0xaa6d7765a7da0ad3841b3198ffffc6c716edce2f8609810b9ad3202f64d1d2be"},{"version":"0x00000020","timestamp":"0x34aea666","nBits":"0xffff001d","nonce":"0xe7a4a516","previousBlockHash":"0xb3f169c6e23978e334dbac817cfce59d933acfab544945a55e00000000000000","merkleRootHash":"0xf3523dd9c6711a4af13e2602500fd13ef494e53ff75842316d77a1d8ed31acc4"},{"version":"0x00c01d2a","timestamp":"0xbdaba666","nBits":"0x07936019","nonce":"0x0f5e0fc8","previousBlockHash":"0xabaea8965d6043e0c835e7d3c4bfb2d4570bfb499fc19ebf47af13af00000000","merkleRootHash":"0xd61ccfef3d85c65b52df597cc732ebf5ab58ef9b03c37e56ed3239726089258e"},{"version":"0x00804222","timestamp":"0xa1aca666","nBits":"0x07936019","nonce":"0x5479a6cf","previousBlockHash":"0xdcf4da7a7dd8945ecfe96c61f7b6feaf3331c63125e484b53700000000000000","merkleRootHash":"0x43287cb83697ddcb17cea1084869170eb2637ced0bb2b2c80775b83d5d0d9e91"},{"version":"0x0060f129","timestamp":"0x68aea666","nBits":"0x07936019","nonce":"0xace8f1b0","previousBlockHash":"0x1a3191e52ecec098fcaeac22affdd4560806597ca4db615a0a00000000000000","merkleRootHash":"0xda99a75031711b50212a985f0d7fe2fbaf657d06e9412f720dbedc257805b9a2"},{"version":"0x00000020","timestamp":"0x19b3a666","nBits":"0xffff001d","nonce":"0xd8217214","previousBlockHash":"0x02251c381e29de6dc719a4dc2d8543fa94b7ee8a9b5eb9a82400000000000000","merkleRootHash":"0x5d6d8784dd87977a3529734d787d076d78aee1449675afd7bf944fae2fe6ebc6"},{"version":"0x00409828","timestamp":"0xf5b0a666","nBits":"0x07936019","nonce":"0x6364f54a","previousBlockHash":"0xbeb7155a8dc182178815816535be40f90a9a551cc39c890a2c9784f200000000","merkleRootHash":"0x446dcb1c6790271b1ad3db146a6f24f3d921e23c481fd0042eea95686163a8eb"},{"version":"0x0000a92b","timestamp":"0xf3b0a666","nBits":"0x07936019","nonce":"0xc6021242","previousBlockHash":"0x7d65bfdb4ffa08856b59566cee07122829720083414926144000000000000000","merkleRootHash":"0xec392238c0bf57b4763b139bc7d625f8cb5eecb08e8788a195521679d9ed7f64"},{"version":"0x00e0272f","timestamp":"0x52b2a666","nBits":"0x07936019","nonce":"0x52187f34","previousBlockHash":"0x6f5598ef595d8255667af2a3faa7c0e35518016ea2178b874800000000000000","merkleRootHash":"0x0b3124e7f38a2a08f2c97f5266e4cba9f43276742236e1efc9df7c95d89b9bbe"},{"version":"0x00a06033","timestamp":"0x7fb2a666","nBits":"0x07936019","nonce":"0x56767426","previousBlockHash":"0x9959801f664d8cccf5e117496cc6f594620bc1ce270b4d322900000000000000","merkleRootHash":"0x102a38482c780fdf81e3b0fa9ab59a228e64170e7913e40b01097ff516059aa2"},{"version":"0x00000020","timestamp":"0x30b7a666","nBits":"0xffff001d","nonce":"0xd4567e0e","previousBlockHash":"0xcc7702d2c37bfdf506db9ad9c6748c2f08646dff7dd9a1673900000000000000","merkleRootHash":"0x4baad1102e7810c7fbab2fdf0dd03d5c0ee9a6a537ddf3800733ca47e36018cc"},{"version":"0x00c04b26","timestamp":"0x13b5a666","nBits":"0x07936019","nonce":"0x3e830a09","previousBlockHash":"0x6a4a903c4a68b6f2ac4fde9d6c03f259b2b618822f0cde9a190ddbc200000000","merkleRootHash":"0xae8d308810d555cfa2f59990be6a7552981c5c53d80f4c8578d0bd42a0727de2"},{"version":"0x00400225","timestamp":"0x5eb5a666","nBits":"0x07936019","nonce":"0x2d0e728c","previousBlockHash":"0xd88b30c56e2ae70da48d3941c2a832937d65c7b24d33ca543600000000000000","merkleRootHash":"0xe54d8eceeb5c6b322df9aeebba6bff3d9e38c1f92d6df2d1659e09337c487444"},{"version":"0x00a0c720","timestamp":"0x98b9a666","nBits":"0x07936019","nonce":"0xd5aaf303","previousBlockHash":"0xfa0b363664e53c261223252c2188c1efe122931d161fe4250600000000000000","merkleRootHash":"0x62c9e9c9b6603f4acc031a52adfec6d08bffa8b0b52b5958866e244d3445ffb6"},{"version":"0x0080302a","timestamp":"0xd3baa666","nBits":"0x07936019","nonce":"0xda6299ff","previousBlockHash":"0xe91b312bdb6d29a8c37faafb2eee0feeb50c58876f3bd6e22000000000000000","merkleRootHash":"0x7e3069df8f56afbf22d101c1c09c661e13eda58442df2819d941a342edfad8ce"},{"version":"0x00a02426","timestamp":"0xa9bba666","nBits":"0x07936019","nonce":"0x5431ddf5","previousBlockHash":"0x5a17db174cfa82eaa5b018c615f1690f4576fca84c86b6d51300000000000000","merkleRootHash":"0xa44507114bfc1908c25afa67eaa8ae53af06ea52225987aabaa158fc0aee22e9"},{"version":"0x00003526","timestamp":"0x0abca666","nBits":"0x07936019","nonce":"0x7022b1f7","previousBlockHash":"0x2e4a041b685f30785f3cfb47e9c888cd30390f251b0cfc863100000000000000","merkleRootHash":"0x4bea5561295a712cebd1b80f79f2298c3d8451d694133d9e6ce0a2fd812c260a"},{"version":"0x00404834","timestamp":"0x0fbfa666","nBits":"0x07936019","nonce":"0x1e60ce9d","previousBlockHash":"0x20c2e3c7b1437b6ffa9e76a537423c0206f0ad55c52741fa0300000000000000","merkleRootHash":"0xf93897626018fc86cc2d4e617f608edb3bf6f6c735e9256c433531748e6c440c"},{"version":"0x00202922","timestamp":"0x1bbfa666","nBits":"0x07936019","nonce":"0x754c5bfa","previousBlockHash":"0xdbcfd0afb26462162aa681205d30fc8f2098e2c2294f8f8c5d00000000000000","merkleRootHash":"0xde729c790ecb9e5e87a9ee5496e2a60edfe18ef9d7ebba70605696d4076f67b1"},{"version":"0x00e07a28","timestamp":"0x7dbfa666","nBits":"0x07936019","nonce":"0xbba70718","previousBlockHash":"0xfd7ad2ad839c5ecee9a621ac35e08140802c3bf8bc357cb74f00000000000000","merkleRootHash":"0xcee1ad5e63f3f57f11e382a57d67d8e67b17d743ff075a8a632192c0f665b6f9"},{"version":"0x00801322","timestamp":"0xb4bfa666","nBits":"0x07936019","nonce":"0xc71873e2","previousBlockHash":"0xd5663dcb49172ae202bef567fde36e89a8b77148aec3146f5300000000000000","merkleRootHash":"0xaf17e7e637a4c7b23c518153f78e26635c005cd886d7d01d0cb9b92b43c7de9e"},{"version":"0x00400020","timestamp":"0x66c4a666","nBits":"0xffff001d","nonce":"0x3709e64f","previousBlockHash":"0x1f7c8bc0c219b0eef00af8b6cc102d44b462146849e4a8a14500000000000000","merkleRootHash":"0x02410f3ce98218d94e78e066c4e2313e0ec899e2c224af75cf27306777666216"},{"version":"0x00a05a30","timestamp":"0x6cc4a666","nBits":"0x07936019","nonce":"0x61405bd1","previousBlockHash":"0x5a08c497f2c8e88f76a3a2f9adb206ab249efa77f089b7f5f85a4c0000000000","merkleRootHash":"0x5d1c8082b9c33c5d9ba4f9ee55c693fa8b3796c772828e4f2fade5b6ad4030c5"},{"version":"0x00a0662f","timestamp":"0x0cc5a666","nBits":"0x07936019","nonce":"0x4cb4c01f","previousBlockHash":"0xd9fdda1701489c379afa2c63fee71ed43f457a969e92ca8b4600000000000000","merkleRootHash":"0x2963c725e872f1b3130d0559c87c772e498e1a0acdd81977f03b293c69f4ee68"},{"version":"0x00409424","timestamp":"0x01c6a666","nBits":"0x07936019","nonce":"0x42713ff9","previousBlockHash":"0xf44761b0567c45089b6263b7cd5caf0758b330c6ed30cf992400000000000000","merkleRootHash":"0x7f7bc03f927e75dc2bb6b9ff193b6be3d4b2e23a0ab02efde601f51791a502ca"},{"version":"0x00609f34","timestamp":"0x3cc9a666","nBits":"0x07936019","nonce":"0x792477a6","previousBlockHash":"0xb49759d2b7f7c0f7a00b2ff34b378bc046910acaa10097be1e00000000000000","merkleRootHash":"0x2588f9c4faa4154bbed7ce154ed40f7ecc9f83b877ceaa74493f496d40104a50"},{"version":"0x00a0e120","timestamp":"0xc9cba666","nBits":"0x07936019","nonce":"0xc7218299","previousBlockHash":"0xb3853694e5115d806a9dfcbc03922a736638d2b496f49a821600000000000000","merkleRootHash":"0x4e3aff242be11639dafe7f16dee43afc8b9693f75282aa4ec80ebf8b4c0d6d50"},{"version":"0x00400027","timestamp":"0xc8cea666","nBits":"0x07936019","nonce":"0x1e80a095","previousBlockHash":"0xb03ec105a234e5368e992e3735376065b2dbae8eba8be4c03400000000000000","merkleRootHash":"0xec12358c0a815b73e58ff51a89ebddde291234b1ee6c5b41d76b604df6720017"},{"version":"0x00400e27","timestamp":"0x11cfa666","nBits":"0x07936019","nonce":"0x8d51c0eb","previousBlockHash":"0x55d6a1e17100360cc5b95a854107ac20483b5def7e2bd0fc3b00000000000000","merkleRootHash":"0x7deff1a5a205c06da012847770d8c30f66991d44751673bb8b2efa1c44466dc5"},{"version":"0x00603f25","timestamp":"0xcbd3a666","nBits":"0xffff001d","nonce":"0xc60808d5","previousBlockHash":"0xe39a19b6871d46f0fa0709cf758b796a27768a244baf7fcc1f00000000000000","merkleRootHash":"0x82b81822da452a954fd79634d23151a86f3b947dd3683db09846fa5c8a1af2d2"},{"version":"0x0020012b","timestamp":"0xd1d3a666","nBits":"0x07936019","nonce":"0x4b3209cd","previousBlockHash":"0xc7f5adf6766c0ba106d911097d810fc88bf5bdb4ce6f3ea6ce1e000000000000","merkleRootHash":"0x696497c5201a9ce50b21733dd4f68142a6c0067e824fd7007c86b146a50eb25e"},{"version":"0x00a02f23","timestamp":"0xdbd3a666","nBits":"0x07936019","nonce":"0x4b92713e","previousBlockHash":"0x79f1e4766d0f1ffd81b86edc89eb4e77689a6145e565111f1400000000000000","merkleRootHash":"0x4c9510086afda4efb92cdf874410d75f97eb3ed22e6fc5e17daf332b3995b28e"},{"version":"0x00e0eb23","timestamp":"0x84d7a666","nBits":"0x07936019","nonce":"0x3c02e774","previousBlockHash":"0x10a5274b24422d18f7b6a8519c850d91cb907071a8605a920700000000000000","merkleRootHash":"0xe5b3bc861f3c6b3ee055972b8993e87f05ac23f33ef3cf4ea4f1e50f2ad4ec99"},{"version":"0x00a05027","timestamp":"0x91d9a666","nBits":"0x07936019","nonce":"0x26841dba","previousBlockHash":"0xa2946752f9f48c3b8d41bd4eea62766fa49ca81075f54fea1e00000000000000","merkleRootHash":"0xd1f3581e1791b9fbf23df4423f0dd1411e77284b445ceb78b253f0cb4768203d"},{"version":"0x00c01a22","timestamp":"0xdadba666","nBits":"0x07936019","nonce":"0x1cd83e58","previousBlockHash":"0x299410bd9b86cb2b44d5573e15c93e9fe350e344443d3dcb2f00000000000000","merkleRootHash":"0xfae4e3cf67a02dbffc92405e4cf91b94f927dd2638767ac765ddca6cdb402aa5"},{"version":"0x0080f622","timestamp":"0xe7dda666","nBits":"0x07936019","nonce":"0x651e8581","previousBlockHash":"0x4eedbf326643eda7c0ec091133aa4863fc43a5797c2ce7e01900000000000000","merkleRootHash":"0xa4849cc3c8451c98d7358ce26ebc13a60e60692411d1558fbba9c87bfe266f95"},{"version":"0x00000020","timestamp":"0x65e0a666","nBits":"0x07936019","nonce":"0xd00aa64e","previousBlockHash":"0x4030eb067e6442540c791b8167ec109fea5f5badc126cfee3d00000000000000","merkleRootHash":"0xd9ebd83df7de1646bc1e3704acf170999d238d43241b32350a69389cf6fe4b47"},{"version":"0x00000020","timestamp":"0x1ee5a666","nBits":"0xffff001d","nonce":"0x4d179b14","previousBlockHash":"0xfa636194cbbcfa7ac738519e68319bfb5f608d69e26bfcd52000000000000000","merkleRootHash":"0xfbd81902eba9a0644b49f5ba318a60dc4cc3e994bb3ec05f60b27c6c425c24a7"},{"version":"0x00c0cf29","timestamp":"0x66e6a666","nBits":"0x07936019","nonce":"0x04bb3809","previousBlockHash":"0x4edbb0a8b1ca6a517aaff6e4d472be5127c3d5976d7da2ac0f273cde00000000","merkleRootHash":"0x926d8aebc5976de88a23bbcd08caa8d430e2e26f1891a52bfa3830e34728870d"},{"version":"0x00e06c20","timestamp":"0xa1e7a666","nBits":"0x07936019","nonce":"0x4c2d8321","previousBlockHash":"0x7e58d0270e0df3d685c4da126a9fb045b71b4bd3bede06663f00000000000000","merkleRootHash":"0xcdbb0dca35d362fbe4c722f6a410bf54bf6957bd7b0569646d8e72de2224cdcc"},{"version":"0x00000020","timestamp":"0xd5eba666","nBits":"0x07936019","nonce":"0xb3e35e39","previousBlockHash":"0xe38928b8bf637315a49cd28f1ad3774b15161591b5ad90a75e00000000000000","merkleRootHash":"0x2e1bb776108570b63b3085e58aa10b27faa282d0b46e2f27ebb962da72569758"},{"version":"0x00c0de2c","timestamp":"0x7deda666","nBits":"0x07936019","nonce":"0x58e86ab3","previousBlockHash":"0x66641f228929ff914056b29f6a874252e8f1b2d6f2aa0fde3600000000000000","merkleRootHash":"0xda7e2cfb4e4cc4765f46f2bdaf407de1eb2245c9e999e9dd328e7c66a2374076"},{"version":"0x00000020","timestamp":"0x32f2a666","nBits":"0xffff001d","nonce":"0x00151a67","previousBlockHash":"0x88160c6b0e8d0e7629c7c9d63912ac92a90dcd84f6bd1b252600000000000000","merkleRootHash":"0x1be08d3f25a4b92567ef68d4f1de7b3a906a1174ec860c81357170864161a801"},{"version":"0x00808528","timestamp":"0x49f4a666","nBits":"0x07936019","nonce":"0x30c9caa6","previousBlockHash":"0xfc6e414e593c3b9f3ba3bd828f89c35f2b3c912f87ec6aceef7b433700000000","merkleRootHash":"0x727f42b59c3b0ad9350b99f83143aecee320218e03efd66288a85a7bf123bc9c"},{"version":"0x0000c020","timestamp":"0x88f4a666","nBits":"0x07936019","nonce":"0x1b8fc117","previousBlockHash":"0x18e1f87ea9a1061541520595c8d77a70dbddebdcb0af216c0f00000000000000","merkleRootHash":"0x28e324e7fb7de50facaf2c408e36ca33981ebf28a980cef2a49a73e6263812d5"},{"version":"0x00c0a223","timestamp":"0xc1f4a666","nBits":"0x07936019","nonce":"0x17367c52","previousBlockHash":"0xc0f536dd76dbe34884858baf970e165dae30e7fd6afece930e00000000000000","merkleRootHash":"0x187b110190d61aaf78ca1d11fc10f817425687f142e8b29523ae9ef0c54e4da8"},{"version":"0x00401b25","timestamp":"0x79f9a666","nBits":"0xffff001d","nonce":"0x9f033dcc","previousBlockHash":"0x188642d2a4b752c875e8c5966545bb1018e323b8b56ba7a31f00000000000000","merkleRootHash":"0xfdd625f8d26431f7b959adda360bc999a962186b4915426f9c44d679d01012d0"},{"version":"0x0000ab30","timestamp":"0x0cfaa666","nBits":"0x07936019","nonce":"0x3316d92e","previousBlockHash":"0x47ed9be40d1344eda4881fb4a44f83816fbf6f174e2425606759000000000000","merkleRootHash":"0x00b0080cbb82b32af57aecb7880789bc9e841838ff087cc9f7fabf42d8182daf"},{"version":"0x00209b24","timestamp":"0x29fba666","nBits":"0x07936019","nonce":"0x7a230418","previousBlockHash":"0xb299b3dd5afac9b65bb9352e9c653cc5ddd95199f70f688a5500000000000000","merkleRootHash":"0x1abc010f8d61cfcb3ab3a6f4feda1ee5f4d9d68b1273a911a97f839975fbcf1c"},{"version":"0x00008020","timestamp":"0x4ffba666","nBits":"0x07936019","nonce":"0x2e1b23b1","previousBlockHash":"0x62c70171c10e932942fad036e92f3418592a313963005aa04500000000000000","merkleRootHash":"0xc572deaaa536ee00ecb30650a02648bcd3286c72cd859463a95be58fac693c8a"},{"version":"0x0020762d","timestamp":"0xe1fda666","nBits":"0x07936019","nonce":"0x3d50d8de","previousBlockHash":"0xd19d2b967d0d793c10abf9623fb7855467732af37787b7732e00000000000000","merkleRootHash":"0x679b4e03eba75415779429e1bd4a1c0f2abdadb196d387d6c584a04072cc813b"},{"version":"0x00603327","timestamp":"0x68fea666","nBits":"0x07936019","nonce":"0x4e9ed608","previousBlockHash":"0x401a8f9ffe4beec92ab9afde66212b4af2205d95bf31184d2d00000000000000","merkleRootHash":"0x37c9ae0b32f171a101ce86f8aa5022307c5570aadb126ff12bfa6eb68377df78"},{"version":"0x00209626","timestamp":"0x8bfea666","nBits":"0x07936019","nonce":"0x6e09e7de","previousBlockHash":"0x25d23185403bcef1381c38e1637c775807229b3af2748e344c00000000000000","merkleRootHash":"0x3ca051c02ca789c0400cc07a3d5f715b7367f08383e202f148205209740b6b8f"},{"version":"0x00c0082e","timestamp":"0x2803a766","nBits":"0x07936019","nonce":"0x2a90a7c1","previousBlockHash":"0x47ed204f2db1bbac320762952615c9cb76033f20088d9c8d5e00000000000000","merkleRootHash":"0xc3b62d855f7507289975565eee5fd80db9dbbefc13a2f83458ad76bc3180695d"},{"version":"0x00e09f2b","timestamp":"0xa306a766","nBits":"0x07936019","nonce":"0xc5a71796","previousBlockHash":"0xad9910c00b416ece2f94f1c64968cd0dfee5c67e32b662905100000000000000","merkleRootHash":"0x52a784c966fedfb3bb64e63ecd7020e4af50dce4d50094342f1fdd60ff01fd83"},{"version":"0x00a0252b","timestamp":"0x5e08a766","nBits":"0x07936019","nonce":"0x22ea4cac","previousBlockHash":"0xb4fa3af3f3ac700426e75f8ba3cecbd00f0556e89f1cb77f2d00000000000000","merkleRootHash":"0x65fd1182b2434cad6d90388e5d4a8cd0c27a39225b292d4ba883e2e98beae0fe"},{"version":"0x00e01325","timestamp":"0x2509a766","nBits":"0x07936019","nonce":"0x4ff053d0","previousBlockHash":"0x15749efaba3d9c5092b53a2ac55c29526d93ae4676d2711f1b00000000000000","merkleRootHash":"0x3251c68a26314e1d7a18ef5a417b9b6aac719cc8c79181e8dd4a92f37562fd3b"},{"version":"0x00404c2d","timestamp":"0x020aa766","nBits":"0x07936019","nonce":"0x40eae367","previousBlockHash":"0xb5ec53eacc9faca4258c7b0bacec1e3cb9f18745562c76b55300000000000000","merkleRootHash":"0xc7e5b3acc9886ab50bc997413e11646c5f0861acdea35dfae631d05846ea16a6"},{"version":"0x00000020","timestamp":"0x620ba766","nBits":"0x07936019","nonce":"0x5160b511","previousBlockHash":"0x0d483535d838c214f06cfc498bd5448034ec3b741d69ce8b3f00000000000000","merkleRootHash":"0xe5ee5d5d40c4df6e598a654725f3aeff46cd74d967ad5827e6e3d1a59fd9aab4"},{"version":"0x0060052b","timestamp":"0x4a0ea766","nBits":"0x07936019","nonce":"0x7d7c7ad4","previousBlockHash":"0xce1d3f8df70e9a2e556365ff9f23b9ff5db39259f753ee704a00000000000000","merkleRootHash":"0xae7322cb43069024c2c5dfb5433b04b19923d00f081e7ef24f8dd7b5385a5271"},{"version":"0x0020d12e","timestamp":"0x580ea766","nBits":"0x07936019","nonce":"0x54d2bad9","previousBlockHash":"0x44bf7f4dfce2fca4866ca34014b52937c5d78a5a8de89c442d00000000000000","merkleRootHash":"0x16dad9e9121f4654d78de6c4efdce8483f442febf4f68a9f5cf068b075bd31c2"},{"version":"0x00c0a933","timestamp":"0x9710a766","nBits":"0x07936019","nonce":"0x608c2273","previousBlockHash":"0x2e3c5dda0658fe59a3b18b13e35939e789731ebf0193a6c72500000000000000","merkleRootHash":"0x48f7ad13d29e66c5f4ab9cec8fe84b7ae00175705d761f57b9a9065217ceda8f"},{"version":"0x00000020","timestamp":"0x3713a766","nBits":"0x07936019","nonce":"0x488814fb","previousBlockHash":"0x44c859ed3f525ba9eb5fd96c551c528e764026f6ed9685995300000000000000","merkleRootHash":"0x8dcefc70b476269385efe75967abd8d62d0ad1c0a7d73e77c2c60b24b6c7ec7c"},{"version":"0x00c08428","timestamp":"0x2915a766","nBits":"0x07936019","nonce":"0x57389b6a","previousBlockHash":"0xab3357374ea883bad0e3d570681e6d4dc44217a58f5026b80300000000000000","merkleRootHash":"0xc8e78805aa5a5537e49eb94949aa0ccd7218c4bd6f3529401d065e408c61362f"},{"version":"0x00a07725","timestamp":"0x7415a766","nBits":"0x07936019","nonce":"0x53256dbb","previousBlockHash":"0x06d6911dc8cbf760faf7e4fc66409bbf614d59bf7713425a3300000000000000","merkleRootHash":"0x971e8ac992ecc49a512f010bafe17d40160ea672889d28f6821d08d5ee6abe0d"},{"version":"0x00003933","timestamp":"0x3c16a766","nBits":"0x07936019","nonce":"0x78e42951","previousBlockHash":"0xef5754e2b95a1f3acedff8d9806a178fb139a562c20dcf372b00000000000000","merkleRootHash":"0xbed0493aa39972a3609702905a56af16a1c89ea7c5df5e0277bef72ed9cfd3bc"},{"version":"0x00004020","timestamp":"0x3c18a766","nBits":"0x07936019","nonce":"0x9001ad3b","previousBlockHash":"0x2e76a9657b9514119cf72cefa35467e11fd351ea3690a9661f00000000000000","merkleRootHash":"0xd9cd9e4e286409d98f373845af9d65a35a8377168d22ec9640f70c54b7fe6a7b"},{"version":"0x0020df24","timestamp":"0xc119a766","nBits":"0x07936019","nonce":"0x6cfcb5e2","previousBlockHash":"0xda57c98f3d5b70ef953306acfb7778768a672028e58fb8b63700000000000000","merkleRootHash":"0x9aa1ef66b2e0ea049e95caa81521c952a6776fae41d1f35dc7a92faa24e13489"},{"version":"0x00a0ef30","timestamp":"0xc01aa766","nBits":"0x07936019","nonce":"0x4ef62caf","previousBlockHash":"0x85016bec9d03884409ea8399d67f8e47e8832e9e0d0381343700000000000000","merkleRootHash":"0xbd956c661a0cd69d12f54f194ba05985851b051de231c1f1a3d00a616d24349e"},{"version":"0x00c05224","timestamp":"0x731fa766","nBits":"0xffff001d","nonce":"0x3d2a0ea4","previousBlockHash":"0x51bf266821f0415a210ca6b6a21790d31deedc160f362dba2b00000000000000","merkleRootHash":"0xc01f0e555fad16ab9d808c44813d2a22cd79cddf731584347c0441c703a25d18"},{"version":"0x00600928","timestamp":"0xe31fa766","nBits":"0x07936019","nonce":"0x6cccee1a","previousBlockHash":"0x790cc13976cc6b64344a392560bf46876d277403e8b80f64f0c9000000000000","merkleRootHash":"0x3658c0179b42fcaa24f2669459758434efeaab724ced98687ff6c240fd81504c"},{"version":"0x00000020","timestamp":"0x6824a766","nBits":"0x07936019","nonce":"0xa404e5f3","previousBlockHash":"0x03c896a58d6b9092c119a3005fd14e51cef69440789c29373d00000000000000","merkleRootHash":"0x3208a53c502f2769934ebcb3567a0212e2f7f3dec4620efee03649d73c5517f7"},{"version":"0x0040e62b","timestamp":"0x7526a766","nBits":"0x07936019","nonce":"0x32c0d1fe","previousBlockHash":"0xf8d0beaea366045a532cf9ab72ab0f281b64fc8904157b161f00000000000000","merkleRootHash":"0x1312eba933770459af4c86dcdae886a81797324cf768a6a0d7eae01e7bee170c"},{"version":"0x0080e530","timestamp":"0xb129a766","nBits":"0x07936019","nonce":"0x2629fbf0","previousBlockHash":"0x00498dfba8b196fde31f228a3313db6c626b439a739898d14500000000000000","merkleRootHash":"0xb1055e83aacbff46d1e85eaed964ad019627affbee243925abdab179775393f1"},{"version":"0x0040fc2d","timestamp":"0xec2aa766","nBits":"0x07936019","nonce":"0x5a4abcec","previousBlockHash":"0x75d7b3169c635cdcfbaa4f9fe2c21deb341bd150d51f34fe3900000000000000","merkleRootHash":"0x1b425c381074b8d9e3aaa97f7430737ab62170362fef40eea37c066d4d1c404b"},{"version":"0x0080be25","timestamp":"0x632ba766","nBits":"0x07936019","nonce":"0x590aac71","previousBlockHash":"0xc2be80989a29efb091013955a26090a2ca6145d08f3f407d4200000000000000","merkleRootHash":"0xe4484a8770d8126b670fdee133e237101d8d5d17639b7a4a4e61e1ad31832bce"},{"version":"0x00e0c122","timestamp":"0x662da766","nBits":"0x07936019","nonce":"0x6ff0eb6e","previousBlockHash":"0xbe2614b41a4debec250b7c1ed843a32199dd28c05ee9f1922700000000000000","merkleRootHash":"0x5f553c286fda6f4b9b73939c7b80aa08333eee82b3d9903a25406d42fd5417a0"},{"version":"0x0040432b","timestamp":"0x7b2ea766","nBits":"0x07936019","nonce":"0xad4c5cce","previousBlockHash":"0x61d3801c6c099e9205c00c9f1222606f3082629862440ef03a00000000000000","merkleRootHash":"0x482adbe65472eb03d9d46aec9cb76a7bef8ea79b5c53e4c8e2e96f4e7d547781"},{"version":"0x0020f928","timestamp":"0xe12ea766","nBits":"0x07936019","nonce":"0x563d47fd","previousBlockHash":"0x2dd087b50dbcf4cb9d9e83a640f23ab1b0cb1b0cd82791503e00000000000000","merkleRootHash":"0x3fac9c34df8ebb802482d1271027056d29bb15ff0b9b2599728a714ec0207880"},{"version":"0x00004020","timestamp":"0x7332a766","nBits":"0x07936019","nonce":"0x2b6061e3","previousBlockHash":"0x059b494dd1f98cb0e3450b260eeac16db9b2f0597d0b995d6000000000000000","merkleRootHash":"0xf8a05120b32212463754493916f7dd6d7519042b70ad1927dbff52b9e6d2a3a5"},{"version":"0x0000432d","timestamp":"0x6135a766","nBits":"0x07936019","nonce":"0x1cccf903","previousBlockHash":"0x29bf65283ae340f4fb2dd15706bd58521f12d21e39c569cb2300000000000000","merkleRootHash":"0x9c2c971a76ea852b7d63020a90c79b9e98cfe3b56b04fe35c7f5bd007abed51f"},{"version":"0x00c07028","timestamp":"0x9f35a766","nBits":"0x07936019","nonce":"0x3848c687","previousBlockHash":"0x41c0dfac71ce326f65b3e6726bed34618207f10d4270b4a83c00000000000000","merkleRootHash":"0x8ff4d1b6e355902ae087dfeb6f9512c90f8219f4a8a21ab6b9e16e290298985b"},{"version":"0x0000f926","timestamp":"0xdd35a766","nBits":"0x07936019","nonce":"0x52b297dc","previousBlockHash":"0xed963d7f883527d4893605746976a0df888eddb3749aacae2500000000000000","merkleRootHash":"0x0eaf2c6af57f77969d902567238ca99ab503331dbd2af791cf6cafe0e6ca1a5e"},{"version":"0x00a0032b","timestamp":"0xae37a766","nBits":"0x07936019","nonce":"0x48d8052c","previousBlockHash":"0x987306e6e5fcf13fa2a340a01a8d5556d7ece6f6ed32678a4d00000000000000","merkleRootHash":"0x3f3ae148d78d657d10be2da1582b7848b8ffd9cb04bca6ac120fd0c9d8428582"},{"version":"0x00c08c20","timestamp":"0xc137a766","nBits":"0x07936019","nonce":"0x83a546b4","previousBlockHash":"0x28163e6f73a773372089f46817b581d63dd66f516d92278d1a00000000000000","merkleRootHash":"0xbe08ac6cbf20a57942d4136130f8f35cfb6b3a14f94e9b58c18d9ee5f157d4cf"},{"version":"0x0080392d","timestamp":"0x6238a766","nBits":"0x07936019","nonce":"0x2ec01887","previousBlockHash":"0x48ffde04a639081805fab1ef5a383cc814a6a22d51c7ffec3600000000000000","merkleRootHash":"0x84f87f629b00db7cf242062a397b383981189674f16143d0751d4ea66642de08"},{"version":"0x00004020","timestamp":"0x073ba766","nBits":"0x07936019","nonce":"0xb5c73c63","previousBlockHash":"0x8fddf53af101d9c890d1870fecb868d6a0dcff8bb9cb4ec04200000000000000","merkleRootHash":"0x138c6f1a5e0310688dbb7e37f2424c0e7c4c2443c76410804c31a041c9dd2a30"},{"version":"0x00e03829","timestamp":"0x833ca766","nBits":"0x07936019","nonce":"0x98d2a8b3","previousBlockHash":"0x44ba1f1c1e6774f5a0176d1f255e14df5a0867188bdd27511000000000000000","merkleRootHash":"0x5e6a7fd74b8234a8ee5aba0cab669dabd6ee7736b29381f7ec270fd829598ba4"},{"version":"0x00a0ea2c","timestamp":"0x3f3da766","nBits":"0x07936019","nonce":"0x7289bd40","previousBlockHash":"0x061533e27e3272cf7c01c54c61de4f438eb5bd50e337de802d00000000000000","merkleRootHash":"0x562327c831aa8f138dc6dbcee012bd4b8738459f4bd6c48ba887d87cfeea97cf"},{"version":"0x00e09c2b","timestamp":"0x0e41a766","nBits":"0x07936019","nonce":"0x01b92c6d","previousBlockHash":"0x1ba193d5ee78d24de85e24376e5b378ef719e030ef8b25ee5400000000000000","merkleRootHash":"0x4f3bd48dc1865a8974c389dea620af52649a7a9b7a5c3628a066c05da193a430"},{"version":"0x00600020","timestamp":"0xfa40a766","nBits":"0x07936019","nonce":"0x1e0ebfcc","previousBlockHash":"0x68afc34b67a8376f10b68fbf30c082b5ef33e9135199d2600f00000000000000","merkleRootHash":"0x95007812d1e66c81ffc0e1118aba7a7fae8233669c766c0826a545cd7118259c"},{"version":"0x00e00229","timestamp":"0x8041a766","nBits":"0x07936019","nonce":"0x25bc0248","previousBlockHash":"0xb19ad073a55e80044065918c8e6ddfca7d669f7bbb1df5342200000000000000","merkleRootHash":"0xe26ebe3f5c0ffc1ff0e3e5f2fd00c04942e9fa892786f93c2cccd037fb9bc342"},{"version":"0x00000020","timestamp":"0x3146a766","nBits":"0xffff001d","nonce":"0xdd546a2f","previousBlockHash":"0xf6f1e571aea92e9f90badbc57a896b767d22806156a2f6686000000000000000","merkleRootHash":"0x14455e0ab7a06a972a00a849af643ec9d7fe337c2ae8ab0f392f59bb53ef82f9"},{"version":"0x00000020","timestamp":"0xe24aa766","nBits":"0xffff001d","nonce":"0xba918c0c","previousBlockHash":"0x442050c85eb836a6f8053778855bed7e92915cd208d9b37e6036c02800000000","merkleRootHash":"0x3b305be8d6252d9692042de91a18505a37d2a140a2112cc5f6b1a605d0941cd7"},{"version":"0x00e0af29","timestamp":"0xa94aa766","nBits":"0x07936019","nonce":"0x7d0ad5f3","previousBlockHash":"0x0973cc6e68814f3afdc537c73cb4f7d69e12818057d267d37f74d94800000000","merkleRootHash":"0xd55176aec81d2be26e22726666598efc4738a03a2222a99029eb8cc170cd16bf"},{"version":"0x00003222","timestamp":"0xe24aa766","nBits":"0x07936019","nonce":"0x4c08b53f","previousBlockHash":"0xa09ad818ce66272366d2c2cec34ca84598c281e9b9d108df0c00000000000000","merkleRootHash":"0xdbe316858d2ad18a5c7679630e1830633445ab33b15cf57cf827de710ef7828c"},{"version":"0x00000020","timestamp":"0x934fa766","nBits":"0xffff001d","nonce":"0xc5ce0407","previousBlockHash":"0x1621aaf1c7b2216d698987a34162f5c40a1842d1032f6a855600000000000000","merkleRootHash":"0x7b58728323945c0bea7f7b62ff49a1fa100e681484f49b370944c4fe0b324329"},{"version":"0x00000020","timestamp":"0x4454a766","nBits":"0xffff001d","nonce":"0x27887714","previousBlockHash":"0xa91d6a3b4cdf62d61212e34032fbe1c89bb3cd7c2d7711213a0f4f2000000000","merkleRootHash":"0xb90fc1ca7f60f2a4ab7f1ecca70d1e906595c4c2cb06531c771974ac7926ba4c"},{"version":"0x0040242c","timestamp":"0xbc4ba766","nBits":"0x07936019","nonce":"0x6e389e28","previousBlockHash":"0xc19e3a2510853dc3821af269b4e95c11cd8b96d80c21fe49da2a9ab600000000","merkleRootHash":"0x99f5c506036e193bbf9d42930cbb44bf821f9231e18e372a792f211840da4fa4"},{"version":"0x00000020","timestamp":"0x6d50a766","nBits":"0xffff001d","nonce":"0x3a1e4b86","previousBlockHash":"0x46291e528f3114e50f2ebef3f54ef35239fdb6e7988b48920f00000000000000","merkleRootHash":"0x260fbaa69070cfa3f17b5bcc8ad61f0d037bb5ab7ec3d3e8fb064c7e815630b4"},{"version":"0x00000020","timestamp":"0x1e55a766","nBits":"0xffff001d","nonce":"0x21fc650f","previousBlockHash":"0x5ae839e75ffa07cfbaa28b6dd3d4f91a4239485fea5d8909f685c54e00000000","merkleRootHash":"0x7f1ee24abdfff270705de52e0ac06784c9455058f7b1fabc0290668460e7741f"},{"version":"0x00000020","timestamp":"0xcf59a766","nBits":"0xffff001d","nonce":"0x6fbdf42b","previousBlockHash":"0xab8bdc6ccb430e93eb0e7e2e48214aa1fe31797f6abcd46498a7d1d600000000","merkleRootHash":"0xedcb58bbfe7939bba2544f4ded893d56f2b92490e1ddb612fdaf25ba983faca5"},{"version":"0x00000020","timestamp":"0x805ea766","nBits":"0xffff001d","nonce":"0x8631ca22","previousBlockHash":"0x955213b5c13b5ab015ba48e19031f79d61831634fb9872647ea5507b00000000","merkleRootHash":"0xcaa9b1b07975025ac45194e7dd18053f4bb773f9de078311f8713817cca80e8f"},{"version":"0x0020b423","timestamp":"0x0c51a766","nBits":"0x07936019","nonce":"0x73b66610","previousBlockHash":"0xd81471b89a42fcab7379a777695b2464a945699db9337f9843738b9d00000000","merkleRootHash":"0x85e1e126c78500516a6ebce6039896fed255e650d2a6ef2342c409a4656bd18f"},{"version":"0x00000020","timestamp":"0xbd55a766","nBits":"0xffff001d","nonce":"0x6d89d022","previousBlockHash":"0x022d354edfe7fa7e1577dd1c55626098349b6e83b9ca5c974200000000000000","merkleRootHash":"0x06d0f7ac2feaef2df03f74bd59c13fd65e7178905bf1b7e8e25a2a8e7a6e9162"},{"version":"0x00000020","timestamp":"0x6e5aa766","nBits":"0xffff001d","nonce":"0xa25a8208","previousBlockHash":"0x70ecab5ee6fb08a3641f5253bc075d3df8acc4a882821034e84c575400000000","merkleRootHash":"0x1354979eb8e4079ed32cb6f3e56e5ae3b26d2b4db79667b62a325b429a40a738"},{"version":"0x00000020","timestamp":"0x1f5fa766","nBits":"0xffff001d","nonce":"0xa3447511","previousBlockHash":"0x110bd07b53695e901fb88df861b643398bf6c8ad9baa6f48b8c806fa00000000","merkleRootHash":"0x7f1bb0d816e550b2fe40811b7ff8cfcb5b5f783777b7d18d1522e8799fd535ce"},{"version":"0x00c0cb27","timestamp":"0x1a56a766","nBits":"0x07936019","nonce":"0x1e68bad8","previousBlockHash":"0xb496f47ef003fbf7792b3a4611fdccec77383cd59ef8edf3f4eb352200000000","merkleRootHash":"0x66eb24e4fe41b8c95140d8fb5c7bd9866fcde1d2b4668db3e0c39583e8f4d912"},{"version":"0x0080712b","timestamp":"0xf757a766","nBits":"0x07936019","nonce":"0x7ae40a8e","previousBlockHash":"0xd980cb2948cc8adba4c7187df41639d4480efd24810ba9b11900000000000000","merkleRootHash":"0x9c7a3dd6098c152592cc55e94bd5800e925cb8f44bc31854c3cc097ce2e7f4f3"},{"version":"0x00a0432a","timestamp":"0x2958a766","nBits":"0x07936019","nonce":"0x179958dd","previousBlockHash":"0x4a38e39e561bd7405ce8373f9d3c45b51dc38c48eae8f20a2600000000000000","merkleRootHash":"0x0f8fb18ad85fd8131a76e739c54fe87fb90d610faec6b1e74dfc32fbb16e16b1"},{"version":"0x00a0592e","timestamp":"0x7458a766","nBits":"0x07936019","nonce":"0xa00857bb","previousBlockHash":"0x2d8b664dc30cb2e5927347eacf8a7c52bcaa79c4a514b6173d00000000000000","merkleRootHash":"0xa01b38da4413d27496e06cff6034a32180a7df4c3c58e4a10ea6fe803df6b73f"},{"version":"0x00806425","timestamp":"0x265da766","nBits":"0xffff001d","nonce":"0xbefca046","previousBlockHash":"0x8ac107994e6186a95153e30b44e14d2a4574864336af02f32f00000000000000","merkleRootHash":"0x68b5c3c0dcad2ae7fbe81dc7b9e434c54c987da2f4b736a0a9fb8c13d3159be2"},{"version":"0x00c0742c","timestamp":"0x2e60a766","nBits":"0x07936019","nonce":"0xaf0dd89e","previousBlockHash":"0xa19ea05bcdcb4ff902e5c2688645ec093777a6ef049a16f01460000000000000","merkleRootHash":"0x9c8289569c8203833c660f2be339ba5c83382b5841b91921f826828f70655cf1"},{"version":"0x00008020","timestamp":"0xd360a766","nBits":"0x07936019","nonce":"0x4c16eeec","previousBlockHash":"0xd856e0f3b841c0adee18551af0ecb30eb14495c550ffea1d5200000000000000","merkleRootHash":"0x63d4815cd9905c903d8b407c8795eb659f4ce9d4259f01b2412ed684588b0cc3"},{"version":"0x0000c020","timestamp":"0xf160a766","nBits":"0x07936019","nonce":"0xc04de453","previousBlockHash":"0x6ff47a215c37a5a097ac7ad6b15f04118ea88894b7ae99750700000000000000","merkleRootHash":"0xc839273a17b10d22f0027f83268879a2523f331bf455a142a0380043134418b4"},{"version":"0x00000020","timestamp":"0xa265a766","nBits":"0xffff001d","nonce":"0xccf02b0a","previousBlockHash":"0x2e69b50735a943fdaad5d357ddec2c154b57bd525c9edc0e3300000000000000","merkleRootHash":"0x6d607fb81e60ef89dd94af9234e12f86d776cdaf3e6f7e73fd215d5da4520ef0"},{"version":"0x00000020","timestamp":"0x536aa766","nBits":"0xffff001d","nonce":"0xa206c204","previousBlockHash":"0x51e1dd234f22257d519596f945ebeabe48a4a86689ff3afe31520b1800000000","merkleRootHash":"0xbbc2d581eeb7a0e885080803692fcda961bf99b011fd865e9cb564f87d71e2f5"},{"version":"0x00200924","timestamp":"0x0863a766","nBits":"0x07936019","nonce":"0x051d4040","previousBlockHash":"0x76490c0d95856534ed43f3b39ce88e97f5e7a3d8357b6a0e16ffd61200000000","merkleRootHash":"0x1a5e141281cbb606dd0da4d3aaaec288361a2725e4f10b890b8a52420c7ec119"},{"version":"0x00000020","timestamp":"0xb967a766","nBits":"0xffff001d","nonce":"0x138f3700","previousBlockHash":"0xa27c47609ff1cfe96899f2bb4314ec4bde2bdd5b44e5e8b13600000000000000","merkleRootHash":"0xcc1e1881a73b4e9d21944ebb5b57f27331741f3bb591f2fc9e6a02950cd2fe33"},{"version":"0x00000020","timestamp":"0x6a6ca766","nBits":"0xffff001d","nonce":"0xe7525308","previousBlockHash":"0xefd8f08ba9aa6731e5509381babd1408db767968bc87ecae36358b5200000000","merkleRootHash":"0x5b3c4da8e2f4d55ec61adfe4f61e32c9a66d2c928dc26abd1b3a146b70170139"},{"version":"0x00000020","timestamp":"0x1b71a766","nBits":"0xffff001d","nonce":"0xbffcbb04","previousBlockHash":"0xa3b5eae48df7e805e91fa51db1a00bcd51756b4f795f2e016b9593ea00000000","merkleRootHash":"0x73f2f4b1c8f19530072bd979b6088a0f6860a9b52c74260ee8e67aa83c65760a"},{"version":"0x00000020","timestamp":"0xcc75a766","nBits":"0xffff001d","nonce":"0x9012fd01","previousBlockHash":"0x69f84308e32bbb9010c7f2dbf5cd1b46ea94496498e8c212c638272f00000000","merkleRootHash":"0x0bd4b410686f97495bb91dd7c68e0ae0a5a0f8872cda2d712853015b2582ee80"},{"version":"0x00000020","timestamp":"0x7d7aa766","nBits":"0xffff001d","nonce":"0xe87ada2d","previousBlockHash":"0x17603f1d9d12f53e888d557335383a993040f1e208a71181f1e8c78f00000000","merkleRootHash":"0x91fdfc51ab86645e44f647fd10b792699a390da44974a572b3eca09bb6fc52eb"},{"version":"0x00000020","timestamp":"0x2e7fa766","nBits":"0xffff001d","nonce":"0xa309bb05","previousBlockHash":"0xaaa0eb3849708be94e4866d52e79cc5b78195eb27944babbea84ff1c00000000","merkleRootHash":"0xa0edac71b16d0b2edc4fe05fa0f5783d4d4171077ffcff139331698f13e29c5b"},{"version":"0x00000020","timestamp":"0xdf83a766","nBits":"0xffff001d","nonce":"0xd0468d35","previousBlockHash":"0xbf5871cde539ab062085f2eb7ff46af43c2aea1728efcacc3b7c171a00000000","merkleRootHash":"0x3d160cd74ed3af888ab90608ef7334ee6f4b6121d646c58a8fba8af1d4565ef7"},{"version":"0x00805931","timestamp":"0x7d6da766","nBits":"0x07936019","nonce":"0x59228a67","previousBlockHash":"0xf788f35c51217bc07c3d82e7d1154ae275ceaec803b1013a1139f57000000000","merkleRootHash":"0x8b1abee3c611fa192afb0cbbf3cdbdff44aff8fe1f168303e8d2f7b23a653622"},{"version":"0x00000020","timestamp":"0x2e72a766","nBits":"0xffff001d","nonce":"0x342d040b","previousBlockHash":"0xf63dccd6b34716fbbb2aeb19b070534167eab551671ab0453300000000000000","merkleRootHash":"0xc2d2c2ac26cb8701d3e5ef8560c2c3d4e645473e85911873a3dc145f41c2ccd4"},{"version":"0x00000020","timestamp":"0xdf76a766","nBits":"0xffff001d","nonce":"0xa7186d09","previousBlockHash":"0xde4f79d57dbe0d4d303120fe78791472ce184dc9b3f90b04f691696900000000","merkleRootHash":"0xc75fd29eb37f74e2335c41bedbf21cae5e675fecc6472e40ec22c8b81ff392e0"},{"version":"0x0040982b","timestamp":"0x2f72a766","nBits":"0x07936019","nonce":"0xd4aea8ba","previousBlockHash":"0x7a32a25ac2f58b47e7b2d79d0b5da1589aa576bc7780baf8838fcd7a00000000","merkleRootHash":"0xe40ed703888a0df3454736c778fd84a5604993cea24d4ad20d753dda4f277b5c"},{"version":"0x0000c020","timestamp":"0x3072a766","nBits":"0x07936019","nonce":"0x0b412963","previousBlockHash":"0xdbc22b1fb742c6e1331ad9f7d22ee2078fb507cf46b4018c5b00000000000000","merkleRootHash":"0xd870297e7b4e2eb6b00c834c193b2cae6aeafaf0a14bce49e623607e6ae9b692"},{"version":"0x00000020","timestamp":"0xe176a766","nBits":"0xffff001d","nonce":"0x89a87913","previousBlockHash":"0x5ccd3ec268a04d42659bf283570fac8c37ef0b193bda248f5200000000000000","merkleRootHash":"0x73d8871ab353de1ec6fe1e9f26606f9eba3f97e74bff24d1f4a5a60368b9141b"},{"version":"0x00000020","timestamp":"0x927ba766","nBits":"0xffff001d","nonce":"0xd3281648","previousBlockHash":"0xa94d8c8078e0bb27a19920b3ae9b38e524bf57fc628ae7bdfeaa840800000000","merkleRootHash":"0x55f7e27a1315e78e9fc71e725e7491ee550662b0afe25ced786f16a549bf067a"},{"version":"0x00000020","timestamp":"0x4380a766","nBits":"0xffff001d","nonce":"0x46cf6037","previousBlockHash":"0xe6367a8e59fcca3f589ed40d32c233d5d36c1ec382c079031240320900000000","merkleRootHash":"0xd4752287e1a95975c701eeb2ca87d2a82f19674ab4db8a6d2a038c81414c6350"},{"version":"0x00008020","timestamp":"0xe276a766","nBits":"0x07936019","nonce":"0x29eb0c61","previousBlockHash":"0x3ed1e69adb9ff7df49ad9962f5aa3d96a3f89cd2b113d247b1f85fd300000000","merkleRootHash":"0xb45ccdfab80c76e7418ed777c803c511d4b1ab85d1ff1c9439790f2456d35b79"},{"version":"0x0020c521","timestamp":"0xe276a766","nBits":"0x07936019","nonce":"0x8778ffe8","previousBlockHash":"0xe85cac89d61c73601a0b2e08718b1646aa886ba9fa8e76ed2200000000000000","merkleRootHash":"0xabd4743d7ad9f5063b61961593742bbeacae9b405e00f87312e45f9a71af05f1"},{"version":"0x00000020","timestamp":"0x937ba766","nBits":"0xffff001d","nonce":"0x7b489623","previousBlockHash":"0xea39b036e1f30c96de9a36f23a7cb2bd0c4c05be05cba5a33e00000000000000","merkleRootHash":"0xee45488a60ced7623cfd43dfeb74e158d2bae7bf280d36d67547edb1d52627d5"},{"version":"0x00e0ec30","timestamp":"0x5c77a766","nBits":"0x07936019","nonce":"0x36294d79","previousBlockHash":"0xc57a82a8d06a920f34563a31c5a7d99ddc33e58d252d7643df1f9bed00000000","merkleRootHash":"0xb0ce911a33ca9216b7aee5fe8b733345476a2a9ca6aa53d15f14eca561a30dc5"},{"version":"0x00000020","timestamp":"0x0d7ca766","nBits":"0xffff001d","nonce":"0xd17c5d27","previousBlockHash":"0xf8f2e3480452274b95a7f865d54ce044a3ade7824fa265002600000000000000","merkleRootHash":"0x0c814536aaf6e2b958e60a0a834270c2b38a52fc5fd9bd23430995b0691466f2"},{"version":"0x0060b126","timestamp":"0x9679a766","nBits":"0x07936019","nonce":"0x5cea14b6","previousBlockHash":"0x4629b1366ed9afa08b1eeb834e3ee83feb1d2b2fe82912170c0d88ff00000000","merkleRootHash":"0x33b1740f1f0e53a39d412dcc9bc9cfccda1829040dcd2c0796817d1d62884482"},{"version":"0x0040ab29","timestamp":"0x317aa766","nBits":"0x07936019","nonce":"0x378eb04d","previousBlockHash":"0xfa004b06a460bea48b1022da8f85fa7cd91f295cf20e3d772b00000000000000","merkleRootHash":"0xd62416682bac8994985ef24d55f018fdcee818b151c32334266e55dc2e961402"},{"version":"0x00e0ff3f","timestamp":"0x5c7aa766","nBits":"0x07936019","nonce":"0x1749bf5f","previousBlockHash":"0x7d44dd610740b7b8e289cf97441e1c999cf3f5e589b718853400000000000000","merkleRootHash":"0x097891731e9f5e5ccfc54462c8be69ad8b9b8bae2c25c00d50d0080f1002f726"},{"version":"0x00a07227","timestamp":"0xd17aa766","nBits":"0x07936019","nonce":"0xd42d4d89","previousBlockHash":"0xe1afeb2e1641cb27987b9f08dca3f6b6cf92abaa2e8305143d00000000000000","merkleRootHash":"0x9b56f8bba690017c8f3703f0b33ef7b41683b1285900a513c13efe458a2b9ce4"},{"version":"0x00000020","timestamp":"0x827fa766","nBits":"0xffff001d","nonce":"0x6181e70f","previousBlockHash":"0xbd61ff0f2b91cbe012d543a9a915c47ef6bacd68111d7db42a00000000000000","merkleRootHash":"0xc652910aeaa82c027c377c145bfe14be8ce249f45b69246b115f5047270612a4"},{"version":"0x00000020","timestamp":"0x3384a766","nBits":"0xffff001d","nonce":"0xbec1b630","previousBlockHash":"0x7d74795dcb3070acee5446cfe2e3d7e2bb3d830d222e649e6fb911ef00000000","merkleRootHash":"0x4347916b6fb8c104bdc49addb449f7d01fce4889742c5288d1f825ed89d43783"},{"version":"0x00e09b2b","timestamp":"0xb57da766","nBits":"0x07936019","nonce":"0x5b0ed39a","previousBlockHash":"0x7dcd6dd9adff325d0670e9b324d7aab2084177f1dfbe8fd5be74d4ab00000000","merkleRootHash":"0x96104de16e0e067cf822975472dedef75d597d15a30d2cfdc5bd211ac2084eb7"},{"version":"0x00000020","timestamp":"0x6c82a766","nBits":"0xffff001d","nonce":"0x33e81346","previousBlockHash":"0x34cc3ca204e322d388b7c2c688d717307117a7c8d0c344102300000000000000","merkleRootHash":"0xa6c7cdaa5e7f05d18c89f83862fdd94bb4b9341ee211651e5287afbd7abe4445"},{"version":"0x00000020","timestamp":"0x1d87a766","nBits":"0xffff001d","nonce":"0x45068101","previousBlockHash":"0x46c0887fc7c4de94929549a1887e3ebec52e8554f1adfbbc758c6df000000000","merkleRootHash":"0xbae7fd1bbed8b8f3e7f04dddebd6d5371fe2192d9e416887b51d15978c572f8d"},{"version":"0x00200c33","timestamp":"0x8c83a766","nBits":"0x07936019","nonce":"0xbaa8fb8b","previousBlockHash":"0x3e7c524acab8e55421dab8f22efc9b311238553454922d985b9659db00000000","merkleRootHash":"0x954887ae3ce4d9125d83628dbf202c200aa4d2a1cb6259e9edf38d62133c0ba1"},{"version":"0x0000cf27","timestamp":"0xff83a766","nBits":"0x07936019","nonce":"0x50a428d9","previousBlockHash":"0xf25d75eb5aaf431023acbd5856d5dbf68ec9a9c669a115683800000000000000","merkleRootHash":"0x94698b90cb7f2babcb964dedce600b7a4f38e352138514391968f743a8117e1a"},{"version":"0x00003d31","timestamp":"0x2888a766","nBits":"0x07936019","nonce":"0x82b5ff46","previousBlockHash":"0x386fbf333f59ba04a0669e1b624cdaf5ec49c1435dde53225400000000000000","merkleRootHash":"0x263b4b35f913af51f27f909430e570cbd15b41c661c5e8aaab8c331177cf97bf"},{"version":"0x00400020","timestamp":"0xdb8ca766","nBits":"0xffff001d","nonce":"0x284272de","previousBlockHash":"0xdc1d5f5ff8c7cbbc51cd354dec3a339f6659f76da4f683915e00000000000000","merkleRootHash":"0xca62e7aa2524392bb2715339563e69327f7dcc9dae4fd308cde6c5271da9083b"},{"version":"0x00000020","timestamp":"0x8c91a766","nBits":"0xffff001d","nonce":"0x26cfc60f","previousBlockHash":"0x62ba87ff284ffc9ee3a349d8c3119f41745c28e88786371755756b0000000000","merkleRootHash":"0x7832c98858f5bf08a0cefae01d6ba55eeff112c4ffb5241ceca41983299abd7f"},{"version":"0x00000020","timestamp":"0x3d96a766","nBits":"0xffff001d","nonce":"0xc0be9d00","previousBlockHash":"0xfdf8e11f61f95856f3811d57096d07ee7069e837ea70da6d8baf558500000000","merkleRootHash":"0xb8d1dd5cda154544bc894cbacb606dd6f250fe5becfa9438e6fe27ffa9bf0cbf"},{"version":"0x00601221","timestamp":"0x5691a766","nBits":"0x07936019","nonce":"0x90d851e8","previousBlockHash":"0x2da49960b0dfbf01aab7f2737a26a6ebe8d95df50d71f0a90bbd0e1c00000000","merkleRootHash":"0x0c7d736d2504cf4e0378ef8ee43fe5a775b6ce3b73793c5791155923c9cac047"},{"version":"0x00000020","timestamp":"0x0796a766","nBits":"0xffff001d","nonce":"0x554af612","previousBlockHash":"0xc770f04f05577a2547062aa6599b08e0f92c6b4e112281680500000000000000","merkleRootHash":"0xce008e9d767eec30a5f586561a0a53c0718567810e661e961d2fc9dd8c0cd357"},{"version":"0x00000020","timestamp":"0xb89aa766","nBits":"0xffff001d","nonce":"0xec412e32","previousBlockHash":"0x5629a6575727fe7f642e3f93eb737028f77d9aa4c8bb2719e95c845100000000","merkleRootHash":"0x312e779ec1903621fac3df0ecc51a7cab179327e613ac9a53c3513e226254025"},{"version":"0x00000020","timestamp":"0x699fa766","nBits":"0xffff001d","nonce":"0x09b96011","previousBlockHash":"0x3d9f7bf483ea186493226508faa34322fca8c0feb1857c9b25fe05e700000000","merkleRootHash":"0x7921be7232410574797bd40cf2bf3e446fdd2583d67d33a80f4ba6ab792ab0cc"},{"version":"0x00000020","timestamp":"0x1aa4a766","nBits":"0xffff001d","nonce":"0x6f2bcc57","previousBlockHash":"0xfefcc15c2ca85bcb0c14802cf69333030e56035f475bf1da1773c44a00000000","merkleRootHash":"0x12863993612330c40f4e958405f70015a63621a6ff3537a2d09fec0ee49cbcc2"},{"version":"0x00000020","timestamp":"0xcba8a766","nBits":"0xffff001d","nonce":"0xbcc25529","previousBlockHash":"0xd77b9a4fd085dd7efddc638f4fbd4c283b27bbb4ed2a448308a7121300000000","merkleRootHash":"0xb70fbd0621c9900e331d63b4a3f0b7d6ba55d39e7083fde5305ceb8fe179a9f0"},{"version":"0x00000020","timestamp":"0x7cada766","nBits":"0xffff001d","nonce":"0xa1c5454c","previousBlockHash":"0x26a9a8bea30c1c24b94e5e86165a21f1bdcc7cb22cfa20816c3e37ab00000000","merkleRootHash":"0x5d18aa28e6783e91c300bc6d6f0297c2314981e2ae3fdb5d96a023bcaa5ebc2e"},{"version":"0x00000020","timestamp":"0x2db2a766","nBits":"0xffff001d","nonce":"0x80621e75","previousBlockHash":"0x977413fd8ff7e662f13d764ccce0f89989c3e836f6ad3df5d70268e000000000","merkleRootHash":"0xb0e1c96ce8fc04ae980fdc5a5b357b546ddc0bc080e51fc1764958732440281c"},{"version":"0x00000020","timestamp":"0xdeb6a766","nBits":"0xffff001d","nonce":"0x90288123","previousBlockHash":"0x024dcd4fea9de8d136490dbcb7d4c2683888bea94393a0d1de7d888000000000","merkleRootHash":"0x9061a39a580eebc4fef7c973841cb150374c017b648368834af92286dd21e69f"},{"version":"0x00000020","timestamp":"0x8fbba766","nBits":"0xffff001d","nonce":"0xd1b4d600","previousBlockHash":"0x1e1d85831a68f75c0aa8af95997e17dbe70ae414dd51cdbba1c2851d00000000","merkleRootHash":"0x5758ba22d7db89123f8255f9a635ea0c5f55d48a3df54871804eb6920db5b3c2"},{"version":"0x00008020","timestamp":"0xc7a5a766","nBits":"0x07936019","nonce":"0xa6cdf83a","previousBlockHash":"0xac9cc4aab55b5597847111f3030adf33dbd868462732fd27a77444d700000000","merkleRootHash":"0x8558e7be757ca0e34850935a118c667735bb09e63fa32c1fa57597ef28b1c841"},{"version":"0x00000020","timestamp":"0x78aaa766","nBits":"0xffff001d","nonce":"0xa202821c","previousBlockHash":"0x94ee3c1ff512cd09c6d8aeddb7363db6fcc9387dff9c89052500000000000000","merkleRootHash":"0x977b1fdc5c3f71c312e113c0a63f510519704a4acb0479169044192e86167a79"},{"version":"0x00000020","timestamp":"0x29afa766","nBits":"0xffff001d","nonce":"0x33230643","previousBlockHash":"0xd3a8c16c52ae4e2c3c0b3fe6a0539c87498a60c9ccc83bfe9c35826000000000","merkleRootHash":"0xdafc9404fece53c1fbf66f62ba8dd01b0d22e751e6e9f899af2c9612262cd1fd"},{"version":"0x00000020","timestamp":"0xdeb3a766","nBits":"0xffff001d","nonce":"0x681c4569","previousBlockHash":"0xe0b0255b4820812b0098ea43bd7caec838480d09ac2b9f5eeaf2405300000000","merkleRootHash":"0x9274625957dfd64bd76a47749181a1ae0f602e127b5ca241227dd56d42916069"},{"version":"0x00000020","timestamp":"0x92b8a766","nBits":"0xffff001d","nonce":"0x00b658af","previousBlockHash":"0x2352fb7c6bc54b46a27bbdd5285d6caf7ae13fd801a4cced235986da00000000","merkleRootHash":"0xb39bc22c4a82d91715a909858a0a0acd320b831f5576bcbc092199915f445f40"},{"version":"0x00000020","timestamp":"0x43bda766","nBits":"0xffff001d","nonce":"0x1b037ff5","previousBlockHash":"0x81628eb7674af11cc550c427a493e7d89b1adce936031a3ad566d3ac00000000","merkleRootHash":"0x82f210d90334fbad5a60f56dcffbfed374c57dbfca6790e31b605283b96cfffd"},{"version":"0x00000020","timestamp":"0xf4c1a766","nBits":"0xffff001d","nonce":"0x825afc76","previousBlockHash":"0x144d268044b41683889150aaa771fd05ebba6b40285ae50f17cd326200000000","merkleRootHash":"0xaf32abe3fb47757a91ea698a4701becad61b229313a9f568c251fb4f82f84910"},{"version":"0x00000020","timestamp":"0xa5c6a766","nBits":"0xffff001d","nonce":"0x559b241b","previousBlockHash":"0x7e52d7e26708f2a12b189e4325f37ec19eeee5200aaf855faacdba7900000000","merkleRootHash":"0x989e23ff5af59cce33e409b520b44ef269677321d9d14ee3072c1c3519ce315c"},{"version":"0x00000020","timestamp":"0x57cba766","nBits":"0xffff001d","nonce":"0x95585764","previousBlockHash":"0x45feff5048e59d584a6067f96bc0f6b5b846b5a343b065176893b6bb00000000","merkleRootHash":"0x5f369c8b4e29fd3b57b3a307c3d85f0594ffdbda0474ce3d5a96d362cbf23c66"},{"version":"0x00800120","timestamp":"0xa0cba766","nBits":"0x07936019","nonce":"0xa02af626","previousBlockHash":"0xc480f1d8bfcf9b3fca79f180098ecb6bf490bfcb0db43c4ba63bdc8b00000000","merkleRootHash":"0xa6b8d86653ebb7caa6cb0350084354118cf370864d1ec1c8d5ae136297207b2a"},{"version":"0x00000020","timestamp":"0x51d0a766","nBits":"0xffff001d","nonce":"0x32dfa100","previousBlockHash":"0x61dc64bcb904e59aa33226a783e4a11278e6c2816bc196bd5000000000000000","merkleRootHash":"0xa4d6f80324183bcaaa3ea1f6151d7c8a5e842527faf271391694a2ab935c02ba"},{"version":"0x00000020","timestamp":"0x02d5a766","nBits":"0xffff001d","nonce":"0x5dcc6f01","previousBlockHash":"0x987f4582cfd1f633eb260d2b1ed04bcfb0d8349fec4debda8715fb3b00000000","merkleRootHash":"0x290220c497ced02384383e992c3ce8c1a1975096daaef96bb3f0bb377a6d4212"},{"version":"0x00000020","timestamp":"0xb3d9a766","nBits":"0xffff001d","nonce":"0x7434f11f","previousBlockHash":"0x37115b9a3455b67527fb7417b38b2c28c53e3e3f7454fcc5060edfaf00000000","merkleRootHash":"0x335219cfc0f28b1c48f6c35c82f104aeb4f1280289429ee792af5c5a53a55752"},{"version":"0x00000020","timestamp":"0x64dea766","nBits":"0xffff001d","nonce":"0x03b85021","previousBlockHash":"0x49a4e00d0030f179fdbdf62516c892aca8898742ccae814f43ca9a2200000000","merkleRootHash":"0x6c53b484e44d52fcd290d11bec956aededff88863913a03bf0953a21a58efb6e"},{"version":"0x00a00120","timestamp":"0xcfdea766","nBits":"0x07936019","nonce":"0xea4a7f88","previousBlockHash":"0x9f6b2b0645fa41d898abbc286c69b33e5f7b77ed3abfa3054f38c51b00000000","merkleRootHash":"0x400d206eb0bc71cd6dc1ac079380f9607bcc0293377f5959abae38c25f7b43f5"},{"version":"0x00200120","timestamp":"0x18e1a766","nBits":"0x07936019","nonce":"0xd5a07948","previousBlockHash":"0xc97e264760afc1d2031c2ef2d65aec80cd434c038c3f84915400000000000000","merkleRootHash":"0x27ff881736c5cd89a95b192cedc061f7c72ab88242aa31c10ac55939b53acf42"},{"version":"0x00800020","timestamp":"0x9de3a766","nBits":"0x07936019","nonce":"0x0b2fd315","previousBlockHash":"0xd6b98447635392240dcf4a0351ed201328c00cb7e296ff233500000000000000","merkleRootHash":"0xbd463bd9f09b9357979970d664683375751a3dfe441ded601104b9903cee3415"},{"version":"0x00000020","timestamp":"0x4ee8a766","nBits":"0xffff001d","nonce":"0x6f0d4b17","previousBlockHash":"0xdc5bcdd3049e63739b8a6632faf8a56df2851249c68a44be2300000000000000","merkleRootHash":"0x833b92383ae11071d2a9fd56e872e50fe3fa48fd0567627df80c929dbd0eeed9"},{"version":"0x00a00020","timestamp":"0xa8e8a766","nBits":"0x07936019","nonce":"0xd09d6dc4","previousBlockHash":"0x568b6374ad685964fa035e44e3bd219925c3c14576a2b8376ce853ac00000000","merkleRootHash":"0x086893a8bddc863b259cae2e2612beda029feaac41ad4b3cb92b4e04f87cd413"},{"version":"0x00a00020","timestamp":"0x1feaa766","nBits":"0x07936019","nonce":"0x4e78e52f","previousBlockHash":"0xb923ff61c6d33642ff924decff19482853fe82c8a0fbe2d35100000000000000","merkleRootHash":"0x5653178aef44d6d511e6eb4b5f8023e23c0d91751bdd03360e97f48b09652b06"},{"version":"0x00000020","timestamp":"0xd0eea766","nBits":"0xffff001d","nonce":"0x67d2ee43","previousBlockHash":"0xac8efa63ee457aa9c9878c1d8ca263c38161d28d16a095663a00000000000000","merkleRootHash":"0xd62cf697e1d1b7fe01f257997d5aa49e65daec49b78f4f881c0108081c9f319b"},{"version":"0x00000020","timestamp":"0x81f3a766","nBits":"0xffff001d","nonce":"0xcad6011a","previousBlockHash":"0xa4fca025e24e94578a1c217763612f77a97d1262724f68280ce10e0400000000","merkleRootHash":"0xb35e94131d6d51547520b883f8a94cfc7e387d38fcdc348e86182d5996ef21f4"},{"version":"0x00800020","timestamp":"0x83efa766","nBits":"0x07936019","nonce":"0xbc7085c0","previousBlockHash":"0x658dc37c7a9370a496b023b821bbe400cc18323f06133ecc2c0ec51600000000","merkleRootHash":"0x5d3800e6029e7f6b0a5f6d07b3bce0cccbbe2d061a935dcabc7142739e67a66c"},{"version":"0x00400020","timestamp":"0x38f4a766","nBits":"0xffff001d","nonce":"0xc4478e22","previousBlockHash":"0xdb3c00aa6b7de25fb17046f6b21d627b5de7cdd2a7c9868a5900000000000000","merkleRootHash":"0x5dfbb5d25463a3a2067c14c607f09e945dfbae76fc463f5cecb0febc3edd59fb"},{"version":"0x00600120","timestamp":"0x9af7a766","nBits":"0x07936019","nonce":"0x9752413c","previousBlockHash":"0xcb1c255dc11bdd99f1409596e7dd654d9a414bc23ad3bd136a6fb90000000000","merkleRootHash":"0x65c702616f8a24ee647119970e87dc55421caca629d304d33ddb3da2771688d1"},{"version":"0x00000020","timestamp":"0x4bfca766","nBits":"0xffff001d","nonce":"0x414bc411","previousBlockHash":"0xf45be6d991174279bbab088f490f196b0569a2b80f883e161400000000000000","merkleRootHash":"0x650616b871bbc6706857ea5d240d362709d870418bbe434513459fff20dea459"},{"version":"0x00000020","timestamp":"0xfc00a866","nBits":"0xffff001d","nonce":"0x592be423","previousBlockHash":"0x304c7f532a2823fd1cc8cb4ab4c814a2431f1c8d0c986f3eed76384000000000","merkleRootHash":"0x454ece4de51132ead214ce529a370539214d738b61f5e9f5d29fd3502a67083b"},{"version":"0x00e00120","timestamp":"0xbdfca766","nBits":"0x07936019","nonce":"0xeb0f7a28","previousBlockHash":"0xc7fb6449546eb7a5ec3b299b5dd95a6190f625e52c7ea8b181bbe6ce00000000","merkleRootHash":"0xde5fc754dd48b75bade006cc03347c8d558191bd230f9608daa7eb83cc647035"},{"version":"0x00000020","timestamp":"0x6e01a866","nBits":"0xffff001d","nonce":"0x779ef21c","previousBlockHash":"0x54f11b1aa1b959df85d986449fc7a1032b764bd9668b7fae0800000000000000","merkleRootHash":"0x13cf9ce598ce0c5be1e3efd7416d08aa4ed574bd8321f700a9629f7e1c5072cb"},{"version":"0x00000020","timestamp":"0x1f06a866","nBits":"0xffff001d","nonce":"0x4e65bcaa","previousBlockHash":"0x40c84885b3a9d0a5b463fe1dfe8a840b25b14118f44970578ae66c6200000000","merkleRootHash":"0x36f668f61db01a0e4587ad8a43ccf28526a39dfb4dd14edc8249c803b2f1f0c7"},{"version":"0x00000020","timestamp":"0xd00aa866","nBits":"0xffff001d","nonce":"0xf5f3cfa2","previousBlockHash":"0x37a425c9dbd9f4bb3225eee4ee8acd459dc4fbb0af11beeb8101d62d00000000","merkleRootHash":"0xcf319831ed5f3016772d8f6525995ec2aa2ab1f75206f8f8ebcffa51d728929d"},{"version":"0x00000020","timestamp":"0x830fa866","nBits":"0xffff001d","nonce":"0x4104a793","previousBlockHash":"0xaa870012bce2e0f22727fb22fee4d9345f991758b689694a8e38673300000000","merkleRootHash":"0xbfad0050c124f86f3906e89304d55ed5bcf7459d150cc841c52a2899cbad5633"},{"version":"0x00000020","timestamp":"0x3914a866","nBits":"0xffff001d","nonce":"0x407739ff","previousBlockHash":"0xfbd76f9f1e62e63deec792b0fe56d50e84aff67988bdabb6781f56da00000000","merkleRootHash":"0x53cef4eddea9fb5d9cb3ab7cf46ba82385bddebcda1ced76f81a6c7be947e386"},{"version":"0x00000020","timestamp":"0xeb18a866","nBits":"0xffff001d","nonce":"0xe08edbb5","previousBlockHash":"0x97a95e98efd00ff1cc06759da657f395b78bb417e1eaac7975385f3d00000000","merkleRootHash":"0x068fbf0e2cd40028308fb1d5277cac36c37663d14a721f66698f93c2dcf2b92e"},{"version":"0x0080022d","timestamp":"0x2719a866","nBits":"0x07936019","nonce":"0x10c4c358","previousBlockHash":"0xa82888f6e2122d17a0c776677d2f059036d2024fbc6b44ca0a4b70b800000000","merkleRootHash":"0x8fa75121f512692537c3f4beb49b78fb08d0a362d77c35e0a2135332459cce34"},{"version":"0x00a00020","timestamp":"0x2f1da866","nBits":"0x07936019","nonce":"0xeb377a05","previousBlockHash":"0xd734bf8c959b77fbba373fa47adfb2f793fcef352c1fcb584d00000000000000","merkleRootHash":"0x0a5739bd1490a9aca5b2785e4da8b9cceb263fb460e4aae12b603485e48b1897"},{"version":"0x00000020","timestamp":"0x331da866","nBits":"0x07936019","nonce":"0x2b0e5b04","previousBlockHash":"0xa79e48b8dcf2582d68b78fd405b568ab859a04d9d44a312d1c00000000000000","merkleRootHash":"0xeb7ebf37e39d3f34d57ad714225add8624cd4e753d13426bc2ac8213f7405d0a"},{"version":"0x00e00120","timestamp":"0x1f1ea866","nBits":"0x07936019","nonce":"0xa98481b8","previousBlockHash":"0x2181848a9193610036cd1ad70d8805b9d33e05f076c6560a0400000000000000","merkleRootHash":"0x1496e40cac2cbdb41d48c3cdd6040a401697f88e78e1aabe1672b249be1d24bb"},{"version":"0x00000020","timestamp":"0x2e21a866","nBits":"0x07936019","nonce":"0xb05405c6","previousBlockHash":"0x04c8faddf5b94c788795a1df98162d58ca7a84f6954009240800000000000000","merkleRootHash":"0xc2d8104b8545b693020305d025a1985c17487c540c237174e56f21fddd08138c"},{"version":"0x0020f72f","timestamp":"0xf521a866","nBits":"0x07936019","nonce":"0x2c2866cb","previousBlockHash":"0x7f3ec51cb92576bd0ed4a1ec13c1293af6b2c4eaac30e4e12f00000000000000","merkleRootHash":"0xceb0051ea97868029008ff832248180a0df207e31d9f25f1d0758bcaa04c1ac0"},{"version":"0x0080652a","timestamp":"0x3324a866","nBits":"0x07936019","nonce":"0x32441fa5","previousBlockHash":"0x4ad2b42e5f58fc57134310ec173a3ad4592a4e462c9c8b2c0e00000000000000","merkleRootHash":"0x4b523f20f53c6752e6179d09fb38e99cc815805b7ca20627d64538ec20b6ff38"},{"version":"0x00203b24","timestamp":"0xa128a866","nBits":"0x07936019","nonce":"0x671c7478","previousBlockHash":"0x9706e58cad83319010fe326f9f04addc66179485d113da4d4b00000000000000","merkleRootHash":"0xe9afc1853b1d0e3d7a467ccbad7c8ec33cc0d0ed8ec0399419f254fb93619ead"},{"version":"0x00a00020","timestamp":"0x9d2ca866","nBits":"0x07936019","nonce":"0xd98c7d95","previousBlockHash":"0x47cd15ec60a0ac88c04162e76b726a30950cb3641a44f77d0900000000000000","merkleRootHash":"0xfe0ff64b27043d0230c10979c2ad74fb2dc5682fe1d1f7b4a102c46a5d6b601d"},{"version":"0x00e00120","timestamp":"0x612da866","nBits":"0x07936019","nonce":"0x082eeca4","previousBlockHash":"0x7aa335c5fa2e10af76c203b2ba077fcd3ffb3719b358f4131f00000000000000","merkleRootHash":"0x8119d3f4489d97497738380232bd1a71753363635141d47dedb631774171ffd2"},{"version":"0x00e08928","timestamp":"0xc72da866","nBits":"0x07936019","nonce":"0x50fcfbbe","previousBlockHash":"0x2db73588539b463fc827a55f79dc73dae5119a1dd2b2a2e42100000000000000","merkleRootHash":"0x543ea56d8ef592712ef4ca523f3b1b9db11fd5358ebfa4cedb4a07f71fcd3ac7"},{"version":"0x0020432a","timestamp":"0x4d2fa866","nBits":"0x07936019","nonce":"0x14ac323b","previousBlockHash":"0xa862c40295f73731be3f6e60aa2334cae83f9a0556fd48040700000000000000","merkleRootHash":"0x0f5df6512e0bcf9f4a5025e174a333d5b6d4789bfa04a4ec2db4d3a3aaf29e46"},{"version":"0x00600020","timestamp":"0x8a31a866","nBits":"0x07936019","nonce":"0x1a9002cf","previousBlockHash":"0x6baa490f35160ce70d9b78c83f60156d1424f28dfd2e3d435300000000000000","merkleRootHash":"0x85643c52202d53e943a7471c86e0ed91df90d9b514e6a03a0fe56aa023476043"},{"version":"0x00409b2a","timestamp":"0xbf33a866","nBits":"0x07936019","nonce":"0x5dd41025","previousBlockHash":"0x8644fdcdb880d3992957b5f4bffb8b6a7ccbccfea01d21861800000000000000","merkleRootHash":"0x45bebaae625fc5e38866be6c16cc6f51640fa318aa08dbb9685e4ac9082e85a3"},{"version":"0x00c0a125","timestamp":"0x7438a866","nBits":"0xffff001d","nonce":"0x760000c4","previousBlockHash":"0x9af81ffd5c1fb0af290fc80f0a9a70c908dbd079b8abdc973700000000000000","merkleRootHash":"0x55106af330c17f40a4dc1f6423c0ad846a0a09d3594f5297e5c4607b22223c24"},{"version":"0x00400020","timestamp":"0xa138a866","nBits":"0x07936019","nonce":"0xf9a0e1cf","previousBlockHash":"0x0c0845e63d66d444decef1441ae60fc1b1cc169642604160dae74b0000000000","merkleRootHash":"0x42707587ed2dfb4123b47e31a3756c2a7809b4b6fd9745261c31aa193e5b8ba8"},{"version":"0x00e0292c","timestamp":"0x153ca866","nBits":"0x07936019","nonce":"0x07053cfe","previousBlockHash":"0x0e398287f5e72b561b6f423052eca060e762c837ef4e63132a00000000000000","merkleRootHash":"0x500bbe115622a99f12209a2dc04c6d0eacbebdc9cb3ad4d76aad8e2c80cf43f9"},{"version":"0x00000020","timestamp":"0xd240a866","nBits":"0xffff001d","nonce":"0x35c9502d","previousBlockHash":"0xf6cffc660663b461d707c79ff453182321fbd595c21c434e5900000000000000","merkleRootHash":"0x4c90efafadc9530d7b8a1f50302ad8c894924e4bbcfbc5050ec5f1014f05cbe5"},{"version":"0x00004020","timestamp":"0x6842a866","nBits":"0x07936019","nonce":"0xbe497158","previousBlockHash":"0x950171efa9bf23c58e0aac43d223473ec54591fb4c074d3e02ea37aa00000000","merkleRootHash":"0x4d54bd77f6a55e98cab7cd730f3562c2d32f6f082563cdbf6a36347cfe6f5bf4"},{"version":"0x00400321","timestamp":"0x6743a866","nBits":"0x07936019","nonce":"0x145132b2","previousBlockHash":"0xac6d92263eae451b903ff11f67e57cc871a5bf034162b8e44800000000000000","merkleRootHash":"0xa9f7c91c82e9f8ac02f8dc064ca56431912b4577a7e284b797784e29332f1fa0"},{"version":"0x00000020","timestamp":"0x1b48a866","nBits":"0xffff001d","nonce":"0xb62272e2","previousBlockHash":"0x4a23186a95785dec652e61d940910940f536dc954e6fe6075400000000000000","merkleRootHash":"0x5d1c5a5939539f4e26b8f6c8b79f7ffce205b5a097a8b8e192728476486c4dc3"},{"version":"0x00000020","timestamp":"0x714aa866","nBits":"0x07936019","nonce":"0x4d5b2b8e","previousBlockHash":"0xd2187a3692d8a727491c05b66e64bbd9812c6c10bac71400879830d700000000","merkleRootHash":"0x4f9f7a5fd521e438844f8670c4e2be5295f108b62a000038c3577f11b13b9360"},{"version":"0x0000c020","timestamp":"0x7b4aa866","nBits":"0x07936019","nonce":"0x1f03ce8d","previousBlockHash":"0xef0ced6b54359495acb3f1aea965d21a479e6ff222f00ee40500000000000000","merkleRootHash":"0x7716906ca2805ff237de8be7f1a5abbadab79bcecbd0f3481a36d5d4f4bdc4cd"},{"version":"0x00800020","timestamp":"0x044ea866","nBits":"0x07936019","nonce":"0x7e9065af","previousBlockHash":"0x47589142ea6ab86c4a8d482a86e52b099576220b37449c120000000000000000","merkleRootHash":"0x484d6462c0f2f263a1163d15a415f5db4c950c3b5ca901002319ca0f4b68a845"},{"version":"0x00004020","timestamp":"0xde50a866","nBits":"0x07936019","nonce":"0xa0ed1a55","previousBlockHash":"0x9b0d7f1ae2db9d5e976ba2e469be38bb238a0624e84fe9fd4000000000000000","merkleRootHash":"0x4264e12ac9b7989301804c8fb9df5965c299adffb4540db5bac90c37f823a3b0"},{"version":"0x00000020","timestamp":"0x8f55a866","nBits":"0xffff001d","nonce":"0x5bfa03e6","previousBlockHash":"0x58df4ba6aafb93e5ccd7f793d180964591b171b1fe19e1be0a00000000000000","merkleRootHash":"0x9667f6851add941a3e145ccfb60fb33ab383224ef76d9d1599dbbdb42df48112"},{"version":"0x00e00020","timestamp":"0x4a5aa866","nBits":"0xffff001d","nonce":"0x077f7545","previousBlockHash":"0x189e3825bcfa049ce3d738123ac41a7b4ff89362eb71cd216082837f00000000","merkleRootHash":"0x19a39f9c027e7d61fdf8d8a6c76c383a6f406f41d48fe7ffc3d6fcdf06aed850"},{"version":"0x00000020","timestamp":"0x005fa866","nBits":"0xffff001d","nonce":"0x2aec5480","previousBlockHash":"0x074cbcd0db4f9bbaeec3880b6a4285ce69cb505dd9bb691ca668030000000000","merkleRootHash":"0x4e9c895a7239067532582dddf68a70b537e3b89b14bbf6847583ee7a371a936e"},{"version":"0x00400020","timestamp":"0xcb5fa866","nBits":"0x07936019","nonce":"0x36fe9abd","previousBlockHash":"0xe3bd0f826f05aa0527229a3854bddba7c14a11e8958344653d82541600000000","merkleRootHash":"0xa2b9f338018b528a92f4bfd4f05e61981400969cf855694c8bb61e790dffec0f"},{"version":"0x0000292c","timestamp":"0x3760a866","nBits":"0x07936019","nonce":"0x7cb45fdc","previousBlockHash":"0x3fa849e9e011efe3c2566b30c051355dcff09aeff3ae8c0b5e00000000000000","merkleRootHash":"0x08662ff7e624be2e3edc8cec2dcdeec396e676540c7e3bdf166b9162baf16b87"},{"version":"0x00e0ff3f","timestamp":"0x8360a866","nBits":"0x07936019","nonce":"0x37038876","previousBlockHash":"0xb5eb1759f4da848e87a3712110a94737efa01df2c71d04ce1700000000000000","merkleRootHash":"0xd569c6ec04487c5d177f84b37ef5530ec88abbb68f8626c9868cd417779231bc"},{"version":"0x00600020","timestamp":"0xaa62a866","nBits":"0x07936019","nonce":"0xe50d5f3f","previousBlockHash":"0x874fce661775fdb7a06bc3e09a4d71a095788254b6f71d262700000000000000","merkleRootHash":"0x88a9e4617f1191277ecf68df2a9c4a8ba8125d6fa63e9c94d5f5f991bcea944a"},{"version":"0x00c00120","timestamp":"0x5b66a866","nBits":"0x07936019","nonce":"0x3d5b45c6","previousBlockHash":"0x3391a6f26e2be50b077b496196297570df19f20727eb3e694000000000000000","merkleRootHash":"0x9239525e3c68c5b23d96cca3bc66c61dd2aedf798adc717c371ee7423349b9e2"},{"version":"0x00000020","timestamp":"0x0c6ba866","nBits":"0xffff001d","nonce":"0x0f338a19","previousBlockHash":"0xa66d81caf5a7bee2c165f668e4fd2c31528e2b2cd6750a601800000000000000","merkleRootHash":"0x94b34773d145e973d0b09489ee7358515f1a1b99fdd5b490dd570bf46dc9554d"},{"version":"0x0000c12f","timestamp":"0x366ca866","nBits":"0x07936019","nonce":"0x339c6c02","previousBlockHash":"0x742c76b6b35520dc1756eb1efc418372f8d17abb850f2a215d26b39b00000000","merkleRootHash":"0x8c011176a78e5b66b6b455aa1edd8eaf667269cc63b46ed15af2b0f121a16ec4"},{"version":"0x00600f25","timestamp":"0xf06fa866","nBits":"0x07936019","nonce":"0x87aca09e","previousBlockHash":"0x6aa9cc7075bfc001a430d02019388fb352d2869f68533a021000000000000000","merkleRootHash":"0xc09dee454188ee55dda507a88d4c9218e0c34c28367084af96d081ddefe200cd"},{"version":"0x00c0c72b","timestamp":"0x1471a866","nBits":"0x07936019","nonce":"0x7a11169f","previousBlockHash":"0xd05ea6ee51055cb1c8c162195e5687aab48bb4e1d9efcd283500000000000000","merkleRootHash":"0xc53712de5167b0d258f4b84f231bc37c639d71b1e07ddf00b2dd0843780cd5c5"},{"version":"0x00200020","timestamp":"0x1071a866","nBits":"0x07936019","nonce":"0x4582d134","previousBlockHash":"0x0a9fc2b9aed10be3f3e0e8c56d206d297356dbe9a04d702c0100000000000000","merkleRootHash":"0xf8d84abcacaba18a8747ddcbc78cc3940829b66e6a0f6e3cd2c3ac50ad886f2c"},{"version":"0x00003326","timestamp":"0xc275a866","nBits":"0xffff001d","nonce":"0x379aa987","previousBlockHash":"0x109010a7cfdb2e61f0a33137a67b5fcf898b873e63f74b8c5d00000000000000","merkleRootHash":"0xac77155c1cf20c51f838e072029b9496fdb88f7a34585896720886746a0b6fa3"},{"version":"0x00405720","timestamp":"0x6b78a866","nBits":"0x07936019","nonce":"0x3584b356","previousBlockHash":"0xf5487d210bc80c9ff15d7f31aa5120cc07d780b17c2888c47c55000000000000","merkleRootHash":"0x806548bcd4e6154ed17a85d9278b13c67f5dd37d5fe83e10770f9a5e524ff24d"},{"version":"0x00400120","timestamp":"0xbc79a866","nBits":"0x07936019","nonce":"0xc876351e","previousBlockHash":"0xdd151c806b59500b346cd0f3d43846085086254b577ae3734100000000000000","merkleRootHash":"0xe0ed5b8c7997ceee4f290c889c4811a2aac7ada6663267a974fdf9ee786c33c0"},{"version":"0x00802327","timestamp":"0x167aa866","nBits":"0x07936019","nonce":"0x6066b348","previousBlockHash":"0x06ac4dad7e3c8be1d11d831b63ce373df182c6f507248adb1400000000000000","merkleRootHash":"0xc58db9b6f6b6b3511b06d4d10f99c21d1ddb99030b3716f0d07832002f4911b5"},{"version":"0x00c00120","timestamp":"0xd87ba866","nBits":"0x07936019","nonce":"0xe8fe70a9","previousBlockHash":"0x9d55f73d3bed44a5e88e40c52824a5ce95d6e05fb79991961c00000000000000","merkleRootHash":"0x026477a015db5d083e0ba418c391c1e326e11a324eead17f3a4036a4b1e11e67"},{"version":"0x00000120","timestamp":"0x237ca866","nBits":"0x07936019","nonce":"0x9b8b2435","previousBlockHash":"0xd0f8792294bbb1119391dfa05be5412a8792dad44556f2731c00000000000000","merkleRootHash":"0xefd2a7e6dd116caa2999fc6878ddfb3b206d78160112534afb71976c88659354"},{"version":"0x00c00020","timestamp":"0x307ea866","nBits":"0x07936019","nonce":"0xe20355a4","previousBlockHash":"0x18c6a6c13e5b2cedf6013fd4cdaad77dcdf44f9fe44510752a00000000000000","merkleRootHash":"0x3f2d232ba2c9e786b3e2a06cf7e2a936c5576401a63bbca3a0732933f2e2c13a"},{"version":"0x00c06628","timestamp":"0x327fa866","nBits":"0x07936019","nonce":"0x29cc6636","previousBlockHash":"0xb424c0c0b33bc42f5c525092022dd61753eeb8a649ab22224300000000000000","merkleRootHash":"0xc12f0b47d8983d9f13eb2978d28fefd138e0343cbc6365c5b5179307fd735dd4"},{"version":"0x00a04222","timestamp":"0x3482a866","nBits":"0x07936019","nonce":"0x9574b9ba","previousBlockHash":"0x91101cd3c05a8d88aed5629b3fb16fae77ac4b8e61847e6f1f00000000000000","merkleRootHash":"0x3499e37492e73b671236f9ab4500152ea61a41db048faa45b37d072ed7eaf279"},{"version":"0x00606227","timestamp":"0xed82a866","nBits":"0x07936019","nonce":"0x7b78d890","previousBlockHash":"0x7195887237e701cae64d7c6ed7368ae37855e3b9fe0d549f2600000000000000","merkleRootHash":"0xbed17d8dced02c5968583be1cc0cc6be1048055fdc3e7db2a96fefaeca446b98"},{"version":"0x0040c222","timestamp":"0x2584a866","nBits":"0x07936019","nonce":"0x803000d7","previousBlockHash":"0xe66995b4e3eb028537cd2114db21a4e9c4d3aa50eb4db5e12600000000000000","merkleRootHash":"0xbee26bcbf69736ed3be035d796c6fc8551465034602bcc76bd28cf748f9ce3f3"},{"version":"0x0040e129","timestamp":"0xd884a866","nBits":"0x07936019","nonce":"0x52e07374","previousBlockHash":"0xf12d4a7acffe2e0a0a4f8849c262f2517b23f50ebae96ccf3600000000000000","merkleRootHash":"0xf168c77cf67ad428a9bfefe72d5939fa93bc07c4fa3476737710ab71fecf3f87"},{"version":"0x00000020","timestamp":"0x8989a866","nBits":"0xffff001d","nonce":"0x3c609311","previousBlockHash":"0x4af3c1f23403b05e4653fd78db876013540e12f9de14e5b85f00000000000000","merkleRootHash":"0xde8df5ad463c853db1ec5f4251bd197d4c61fe5ede7ebf6f209b1840e12bf303"},{"version":"0x00201628","timestamp":"0xd985a866","nBits":"0x07936019","nonce":"0x5be12e9b","previousBlockHash":"0x0f9e760c8d8ae6b29b27e0214876899c0371b67b5dcc2832eba4d52300000000","merkleRootHash":"0x3056828037bcfd82009924ebe1b884466482ce2b360dea03ad795c18e953f536"},{"version":"0x00a00120","timestamp":"0x5a87a866","nBits":"0x07936019","nonce":"0x34124f35","previousBlockHash":"0xb1e2fb52cd0942fabc2109feafb93d5d90494fbcdfa5d59c2b00000000000000","merkleRootHash":"0xe4aa8968a655915ba7f88bccac0e75dd3f57bf7525893980fec87d042cb63bc1"},{"version":"0x00e0bd26","timestamp":"0x0188a866","nBits":"0x07936019","nonce":"0x4498e1cc","previousBlockHash":"0x53e619e91c1ee5d0c878a02726c148b098d6523a2e37afb43400000000000000","merkleRootHash":"0x8374b8cfa86ab9cdc8118964503c134171362d8ed4f10ef0700214818ddcb8f2"},{"version":"0x00e0b021","timestamp":"0x7588a866","nBits":"0x07936019","nonce":"0x09fcfd3c","previousBlockHash":"0x3c9e22f34622c03ca184745e6d504b551fa614ff5ed4c0fd3c00000000000000","merkleRootHash":"0x4c64bb835a5bbf3cb18a6c0d3cfa0f62bcd9ce28768a674c1adcb4f2b1f41371"},{"version":"0x00c00224","timestamp":"0x8d89a866","nBits":"0x07936019","nonce":"0x7ba47dfe","previousBlockHash":"0x08460b90f7eb3af964a69ba1f45c081d4d934ea643eb679c4400000000000000","merkleRootHash":"0x0becfacfa92ce1a1e90f2d1c8333e2c14554925d1ec0f17cb1cd47d12d5f7af6"},{"version":"0x00200120","timestamp":"0xd089a866","nBits":"0x07936019","nonce":"0x883ad295","previousBlockHash":"0xaed83062932e98e2fb61d374f59cc63ff0ae8bc4b5349e505c00000000000000","merkleRootHash":"0x4f03ed20c3128e0bda0429f7c16297d7e1eee45ddd1019ccd90714ac6d556180"},{"version":"0x00e00020","timestamp":"0x178ea866","nBits":"0x07936019","nonce":"0x1a6a4987","previousBlockHash":"0x489eacf694d70251cbf096a3dc268fb3ce9662d0ac79213e5700000000000000","merkleRootHash":"0xff0eeab806dc137a09a3726179f8e7e7548a201b4ce8e84f935ef8828facd7d1"},{"version":"0x00000020","timestamp":"0xc892a866","nBits":"0xffff001d","nonce":"0x7aca2910","previousBlockHash":"0xb6957d361e35f7deba40c7f1237048cf9fa61241a8012fab2b00000000000000","merkleRootHash":"0x5f5e5934b8fc77996a825cf4111dfdf49e15c597b28ce143d32b3ce6f8d8ecc1"},{"version":"0x0000af2b","timestamp":"0xb38fa866","nBits":"0x07936019","nonce":"0x764cb1ce","previousBlockHash":"0xa9671851c617c03e07ff54775dcd0bf540f3c1c25c95720e4e27779f00000000","merkleRootHash":"0xc5011ba3f03000e185cdae4710cfe75da4820d6df9b62b2afe3a9971b16d8ea6"},{"version":"0x00000020","timestamp":"0x6494a866","nBits":"0xffff001d","nonce":"0xa9cc401d","previousBlockHash":"0x0643dc98b25f697c88d095ab7538aed76b96e0e6a04d2d8a2b00000000000000","merkleRootHash":"0x374ed4ed3449928cbd4e57598610a906e7e2be95f57ef7331d0ac36432f528fa"},{"version":"0x00000020","timestamp":"0x1599a866","nBits":"0xffff001d","nonce":"0x68fcd438","previousBlockHash":"0x0e283db1fc13eade1dfeeae5e5737ca606ac677cc214ac9b8baa92b100000000","merkleRootHash":"0x8e209b9a96cb07a14c13dd5c18c235ff456ddf7aa25e2d35df20af8eb09d4fb5"},{"version":"0x00606426","timestamp":"0x5a91a866","nBits":"0x07936019","nonce":"0x09840996","previousBlockHash":"0x99913ad54acf52c67b46236f91619c6e66601a2b09a6c0f3230e675a00000000","merkleRootHash":"0x00ac54b3a3e0090a2a6bc4f6f34dad4514e77164d0ca33a477ae6aecdaa06194"},{"version":"0x00405e20","timestamp":"0x0b95a866","nBits":"0x07936019","nonce":"0x304672e1","previousBlockHash":"0x9b1872fdea03348dbf2d345094544a418ca4254b05654ffc4400000000000000","merkleRootHash":"0xb8ce77701eaf135ee4273aff28fad593abb0cd632eeeecbef970bef4dad6a22b"},{"version":"0x0080ac2b","timestamp":"0xf597a866","nBits":"0x07936019","nonce":"0x1d2221bc","previousBlockHash":"0x079f0503631792e11454fdf58d4b098849de3f68993958f43800000000000000","merkleRootHash":"0xf6933d94ae6a0c6bbd19862b509eb7acc97bf904b27fac50fd8028ff52191b2e"},{"version":"0x00e0742a","timestamp":"0x6098a866","nBits":"0x07936019","nonce":"0x737497e9","previousBlockHash":"0x8f16a3c7499ea59bee1db8a379a838cff13cbe8cb3aa4f411100000000000000","merkleRootHash":"0x802e755206dd891df515b6b4bee254e7a0daf65c1cf4361c37245d3f3980736e"},{"version":"0x00602d2e","timestamp":"0x9898a866","nBits":"0x07936019","nonce":"0x18dc75e2","previousBlockHash":"0x0373c473f2ca6532201778300b12fed4e70a353d14c036da2a00000000000000","merkleRootHash":"0x0770c1efbd6e6887f5df869687b94800a2a2aad57e247ff9015599eb2169a229"},{"version":"0x00a02424","timestamp":"0x8999a866","nBits":"0x07936019","nonce":"0x7dde3269","previousBlockHash":"0x08ac9d9b1dfd05d8801c9f8d08814837e2a644cfa4e5660f2700000000000000","merkleRootHash":"0x89f0e6873ddfabe65c6a000a524c93e01a4ccba71719e99bef87b05223ca14ca"},{"version":"0x00c06e28","timestamp":"0x719aa866","nBits":"0x07936019","nonce":"0x125582e8","previousBlockHash":"0x28b2a8a8e35e6d66400a9e1207a7b013e8dec85d842e9b554b00000000000000","merkleRootHash":"0x9e5b5bc1c1c780b00464f0f7e6d1021eac22019ba5f73ce923e1946ba6add98c"},{"version":"0x00400120","timestamp":"0x899aa866","nBits":"0x07936019","nonce":"0x5113329b","previousBlockHash":"0xcb4da5b1391ee8d8f3ccc232d92ce2f38ca66acb536134512b00000000000000","merkleRootHash":"0xa3689aa1409c980d60c4f2aa81fccc5827a9892ec0994c101403c461ebc9acc7"},{"version":"0x0020eb26","timestamp":"0xab9aa866","nBits":"0x07936019","nonce":"0x8f800c16","previousBlockHash":"0x8a284640f083f4d7d706a1e8a7bb42f07011f3de3267781a4b00000000000000","merkleRootHash":"0xd03789fe7c222a00bae5fe9f9f3affc1a945e35396b92153f215d31f1e088d06"},{"version":"0x0060cb32","timestamp":"0xb49aa866","nBits":"0x07936019","nonce":"0x22ccf25f","previousBlockHash":"0xa92e79a96abc86657bec912cddb1211f795a075cda82317f1300000000000000","merkleRootHash":"0x62784706414d9e3cff137af3d7e41537ba4a9e6c00608aeff24c0112e0ebb43c"},{"version":"0x00e00320","timestamp":"0xbb9aa866","nBits":"0x07936019","nonce":"0x6d952e5b","previousBlockHash":"0x515dc5c54693d42b21429cbc9b8fc41a1e545c07c777785b0300000000000000","merkleRootHash":"0x427f5bb6f748df0af5b1e1a05b120ec9a20eacab977ab87c44c1d6b8a4778c67"},{"version":"0x00600521","timestamp":"0xa49ba866","nBits":"0x07936019","nonce":"0x614aa229","previousBlockHash":"0xed27275eb0b818a938f556fedb17cb5434d3afbaec2aa42e4200000000000000","merkleRootHash":"0x6303dc417a13f9602115fc1b9712c4515ed0646e013b286d56afb6057dd59c66"},{"version":"0x00a0b02a","timestamp":"0x6c9ca866","nBits":"0x07936019","nonce":"0x6ef4fdc9","previousBlockHash":"0xc045dd214986bc85cb43b31c6da486e97f10b119324889802800000000000000","merkleRootHash":"0x6063837b4fdb84757d5d2f4adba15130200499e09693a865495e913072c5c055"},{"version":"0x00402920","timestamp":"0x8b9ca866","nBits":"0x07936019","nonce":"0x1955842a","previousBlockHash":"0x0b4d9e1dc8346e241c55bffa36f086533995fdc2d415aa540200000000000000","merkleRootHash":"0x76101dccc8ce9e3a901472024888712d2fa1cb928c6cedbcc4af4d850620abe8"},{"version":"0x00600020","timestamp":"0xc39ca866","nBits":"0x07936019","nonce":"0x423d5102","previousBlockHash":"0x0826b3b59a297b16bcf448daa12ce74a6ccb89f18257cc063f00000000000000","merkleRootHash":"0x19f704df933709ff4b766ca0c6911485097966f2e4d8bfda22cf3759e9dd05c4"},{"version":"0x0000b023","timestamp":"0x039ea866","nBits":"0x07936019","nonce":"0x08d4f500","previousBlockHash":"0x57813385fcb4795430d6e871f55c1b3b7faea50ce5ad70863700000000000000","merkleRootHash":"0x8751db4738cb03106cb962ed564bf1862695323655910b5a1b81e18f5294a4f3"},{"version":"0x00000020","timestamp":"0xb4a2a866","nBits":"0xffff001d","nonce":"0x05f4231d","previousBlockHash":"0x4076d224bafde504f37aee10ad7ea0ba3bdff5cfccd7ac540a00000000000000","merkleRootHash":"0x25f09c9a991eed68e8f28690ac2a8b4bcfc44a32349b1ec772d26b379059e39f"},{"version":"0x0040b32a","timestamp":"0xaa9ea866","nBits":"0x07936019","nonce":"0x7cacfa5a","previousBlockHash":"0x52b38120ec9730dcd790c43c64f676dc2ec736b04c73fe3c2368770d00000000","merkleRootHash":"0xcfa6314056d30c3ad729dc982af0cd97464fe511750480f05dfc5348900561f7"},{"version":"0x0080c920","timestamp":"0x289fa866","nBits":"0x07936019","nonce":"0x4b6eb6e2","previousBlockHash":"0x048525321dc4878fc58cd6ae5187b277fa8612b68242f1210000000000000000","merkleRootHash":"0xae5fc9e59150fe0875b03defaf1cb2ec78f7e0e930be4e0ad9d1da631830641a"},{"version":"0x0060d627","timestamp":"0x26a2a866","nBits":"0x07936019","nonce":"0x79c34791","previousBlockHash":"0xc0e7534804c3511fc55d3049be4520cac2fa3b1503d7aec55900000000000000","merkleRootHash":"0x994da0b8dfd9341d9f6218327e90a7f16b862f85703c7f39f80e36e92249d84c"},{"version":"0x00c0e823","timestamp":"0x74a2a866","nBits":"0x07936019","nonce":"0x16d70aca","previousBlockHash":"0x79bb6a353aff5eae303cec57933b759d265b4be40ace2f494700000000000000","merkleRootHash":"0xca6ad7ddb44356b77986ceb56b671533b08abbb77ca416d4a3581e7fe355d121"},{"version":"0x00000020","timestamp":"0x25a7a866","nBits":"0xffff001d","nonce":"0xedfab00c","previousBlockHash":"0x25409af274243a3b48fb7c4f0dce3796df09088873db66af5400000000000000","merkleRootHash":"0x929833442da192d85667e3c50d2eebbd1f6a9a41d2c81f70c70d610d55f56389"},{"version":"0x00800020","timestamp":"0x1fa5a866","nBits":"0x07936019","nonce":"0x09ce004b","previousBlockHash":"0x9247a5d596f56f1b58ab79dd8fdb6fb69b335f51f4bafd32e8d7d4a700000000","merkleRootHash":"0x6accd3b41c8eae016108d2db1f709aa51455e332ca09bb243787a990303a1876"},{"version":"0x00202e23","timestamp":"0x6da6a866","nBits":"0x07936019","nonce":"0x3b6c6bd4","previousBlockHash":"0x3bafbdf92434184d068effe953ea61b4687872139a7dd2df1a00000000000000","merkleRootHash":"0x6bc7964218ba0ede77109304ea19c0959e0666fa51cfae4750491fe26e0bc613"},{"version":"0x00000020","timestamp":"0x1eaba866","nBits":"0xffff001d","nonce":"0xa09f6f1c","previousBlockHash":"0x6d0f2a512f33e06a985383caa4c07d525e818c701cdab1203600000000000000","merkleRootHash":"0x127383b7a2ec9adb5c9b3b7df23304848c10e21b7438e4775b26b59edc312c9e"},{"version":"0x00000020","timestamp":"0xcfafa866","nBits":"0xffff001d","nonce":"0xe74b590e","previousBlockHash":"0x68035beefd5a604fa261bd9e46e39f96451f42d1810574d6dd282b6f00000000","merkleRootHash":"0xdb391ed01ab1ef5a733d7c440c7ff7ff0b9f553a7d40db53b2310525870a61ed"},{"version":"0x00000020","timestamp":"0x80b4a866","nBits":"0xffff001d","nonce":"0xed720423","previousBlockHash":"0x2160748f86cf0e9286be21394c5bed680d84adf6ddfcc7739ca1d1ef00000000","merkleRootHash":"0x985e2759a1222d643f87f431bb06fc6b1999efe146af5c285d5f1107b5ae47b5"},{"version":"0x00200120","timestamp":"0x65aba866","nBits":"0x07936019","nonce":"0x6e51e79e","previousBlockHash":"0xbbc07bd4f44332c3cb6c1bc0d9c70c861f11ab86e7654d5f4bd0928f00000000","merkleRootHash":"0x0c10b9bea3d3549b7ef1c17509d1d6fd94ffe60fdd54402a22b8041b6c4f02d0"},{"version":"0x00000020","timestamp":"0x16b0a866","nBits":"0xffff001d","nonce":"0xc59b3406","previousBlockHash":"0x666aa7691028a7fc715c1fa912af6855144f25b95c6c842f5500000000000000","merkleRootHash":"0x7143089c936c61db742ecfae1f1e3cacd5b4c18d143ab2d4f10f240f2655945b"},{"version":"0x00000020","timestamp":"0xc7b4a866","nBits":"0xffff001d","nonce":"0xe5f51d14","previousBlockHash":"0x7d63d9f137af3516ea14104067f28fb3312867e9fa8facb157acd37e00000000","merkleRootHash":"0x10c9874c9c41695416ae76613075de935a122ae441575ab24f6978a6f5d6c625"},{"version":"0x00000020","timestamp":"0x78b9a866","nBits":"0xffff001d","nonce":"0x2a0e8c00","previousBlockHash":"0x2d87d638a8985716db18d954c06dfdd0101c3c6a1888b543a2725e8900000000","merkleRootHash":"0x465f82a08118f7cd77a883f0cad227de7fbd194c4e99bce0cd29ce9229abb59d"},{"version":"0x00000020","timestamp":"0x29bea866","nBits":"0xffff001d","nonce":"0x9ca28b28","previousBlockHash":"0x607dfa20256aba0e0379bc96b35bb69f75e146e1b83b8d560bfae5f000000000","merkleRootHash":"0xdd7394bac703120cee11b1f3d7bc2b698c133d512fd78a653c448b47a3f3b6cc"},{"version":"0x00000020","timestamp":"0xdac2a866","nBits":"0xffff001d","nonce":"0x60eb420c","previousBlockHash":"0xcdbe8d17ffc6a28adf01b1626812a2ccb662f011a127e8c21bf27faa00000000","merkleRootHash":"0xdf41dfd79d4336375769d92d4f60ecc43be6992f1188218ec87be1a2a8df1c35"},{"version":"0x00000020","timestamp":"0x8bc7a866","nBits":"0xffff001d","nonce":"0x3a28251a","previousBlockHash":"0x5714b611f405a1f9988addb6b6a8c08a76f238623685c070299c658000000000","merkleRootHash":"0x1511351f6d99fa6338e46e0d30a961224c86d8387967100605d3313fd72f472c"},{"version":"0x00a00120","timestamp":"0x0abca866","nBits":"0x07936019","nonce":"0x730beca4","previousBlockHash":"0x3567714ab0fefc5427328bb1b47c418d1d1c67a86b2b192d1f73b1f900000000","merkleRootHash":"0x4d7732601a6317bc2169905dafd0b7e593d98c1ac1a0e90da269de6602bba819"},{"version":"0x00000020","timestamp":"0xbbc0a866","nBits":"0xffff001d","nonce":"0x6ff42f10","previousBlockHash":"0xc1fb551ea83d271364bb4e53b74b903e8cb0fafa8d67fa343800000000000000","merkleRootHash":"0x688057d300fd1e8d72f11e72b06a96787a19790be58bd1cb2ef151a099e96f45"},{"version":"0x00000020","timestamp":"0xbcbea866","nBits":"0x07936019","nonce":"0x9e096488","previousBlockHash":"0xdf0323c32d2d6f0a7964029e872aa7e288dd34772fb03097d46f611800000000","merkleRootHash":"0x1147594d2cca35d259441ac1f0e43608948892b951ca25ebde794d5f24b947af"},{"version":"0x00000020","timestamp":"0x6dc3a866","nBits":"0xffff001d","nonce":"0x99b7fd2d","previousBlockHash":"0x15895138e100b34d7afd24ad4073c3262e1eefc8529ee56f4f00000000000000","merkleRootHash":"0xc74515f5dab8bcb4d51d64db0cab021e9ea134b320e460f9722f981fdee6d78b"},{"version":"0x00000020","timestamp":"0x6bc5a866","nBits":"0x07936019","nonce":"0x0869cfa9","previousBlockHash":"0x003c3d29011948b7cfd6614e76811071083cf93bb6ee469ee5c89cd200000000","merkleRootHash":"0xfaa1785e7b23543050bd8cbfd397dbfbfb380c896273b3dd9ab2edeaee0d8959"},{"version":"0x00a00020","timestamp":"0xd2c7a866","nBits":"0x07936019","nonce":"0xd4bfa4b1","previousBlockHash":"0xee21537a4c0a70e5536413dd75cfa6368e8c1efd2c09420c3900000000000000","merkleRootHash":"0xd9daf3e27fce5efcf3392eab07a5797c063c475b8201701ae18ba54ef42dc605"},{"version":"0x00000020","timestamp":"0x83cca866","nBits":"0xffff001d","nonce":"0x4ee4fd61","previousBlockHash":"0x1cd8e63f63cafb08570fb64590f62cf567442846cb7da4ae5d00000000000000","merkleRootHash":"0xa034a1e1d6a34925b4ed7457d145227e2e36ca57cba32fa5c1e940e7dc16f2d5"},{"version":"0x00000020","timestamp":"0x34d1a866","nBits":"0xffff001d","nonce":"0xc620b638","previousBlockHash":"0x8c59e8149167cb75c00fbc4f8d21349e5d85df6fbbaa8f1b0f9fb12f00000000","merkleRootHash":"0x33627cf03ba28baac692b0a94cee4c9774f7e3e303078801372b83ebf1e81d9c"},{"version":"0x00800120","timestamp":"0x65cba866","nBits":"0x07936019","nonce":"0x949bdda8","previousBlockHash":"0x824607f7bac3b1543009abf94f3f67ec939c3cda43a1ebb591b068f300000000","merkleRootHash":"0xf23677c31539d6bd99f8dcc3aaf8c4a7a472743a0e2ef3b4a76e1f07269f812b"},{"version":"0x00a0562b","timestamp":"0x4dcea866","nBits":"0x07936019","nonce":"0x510964e7","previousBlockHash":"0xdf12d286a8bb1113507b547eb51558f6f05c4437a99bface5400000000000000","merkleRootHash":"0xed6f346c4512c24f02da202be531106459d16892b309a5aeb907341ea35d67b0"},{"version":"0x00000020","timestamp":"0xfed2a866","nBits":"0xffff001d","nonce":"0xe98c7840","previousBlockHash":"0x6beec10aaecb58793c848cf344ad85758036923f2cf0b3950600000000000000","merkleRootHash":"0x33dc7d710ab356493eac918e7ab0d161450ee7f56c5b55c03285f1aefe591e9e"},{"version":"0x00000020","timestamp":"0xafd7a866","nBits":"0xffff001d","nonce":"0xede04b32","previousBlockHash":"0x52a483b6f80cfed6a3bae25c0a1889595f4abc2dbae2bc9a9a6cf3a300000000","merkleRootHash":"0xb7e1ceae8cf2dc69138a80a7de8ab9c44d3bd79f9c1c6439e9f3773e3b1433e7"},{"version":"0x00000020","timestamp":"0x60dca866","nBits":"0xffff001d","nonce":"0x6f858a1e","previousBlockHash":"0xf6c3ac1851ccc254d05bd0841215102efda7f111fdc1c41a15792b1200000000","merkleRootHash":"0x9de8432c359ebbdc3091c3e712c3c873dbe00780c2c82e6d655fbb1bef926533"},{"version":"0x0000bc27","timestamp":"0x86d2a866","nBits":"0x07936019","nonce":"0x23dd23bf","previousBlockHash":"0xfa883e8dab645d8e19423c56ae10670500209593438d1f84dbab363800000000","merkleRootHash":"0x88ce7c5a10cbf4fc428159e4629f919b9ed05dcade10e3aaf6c803aa7c171b46"},{"version":"0x00000020","timestamp":"0x37d7a866","nBits":"0xffff001d","nonce":"0x1010ed1e","previousBlockHash":"0x6bba20462b16b4a2a77c8f2c96d2dc2b8dd23cb524bbaa843800000000000000","merkleRootHash":"0x6a390f1bffb1b012bda5926a3e4fca55069f095c8b084c233db72d7d1b83eeed"},{"version":"0x00000020","timestamp":"0xe8dba866","nBits":"0xffff001d","nonce":"0x83e8563d","previousBlockHash":"0xada6ddab1b6b50d4b7f11794b35ed4aa23cdb2d8606d19a99b64289f00000000","merkleRootHash":"0x5db6094544608426069f17c7959312096ad81931284954dee081aa7eaa82d27c"},{"version":"0x00c0c721","timestamp":"0xccd9a866","nBits":"0x07936019","nonce":"0x5784d0d4","previousBlockHash":"0x8f5b91629420cb4cb3e7b3931d891d5f9371703c3cca1e70dd1e7cb200000000","merkleRootHash":"0xbcb78ac257c16d9417b436b7f17972ae823f18c243bba5893fa815b673b2766a"},{"version":"0x00c02325","timestamp":"0xb8daa866","nBits":"0x07936019","nonce":"0x1e8c4b6d","previousBlockHash":"0xd27a9da27002d3a1bd609435202c286620516b4b774deb990e00000000000000","merkleRootHash":"0x4b33f2d9b8c485231853d5da1275719b14b5068923a25c605a3393b6c820ca3a"},{"version":"0x00c00120","timestamp":"0x04dda866","nBits":"0x07936019","nonce":"0xd653cd24","previousBlockHash":"0xa54a5ef0c787d0f09e6c092ccf084f153d74c80d9e0f864a0d00000000000000","merkleRootHash":"0xdd2f835bdba21caf55b51206ddd09c9236e29241e963f24396c6867951b25a12"},{"version":"0x00e0e22c","timestamp":"0x44dea866","nBits":"0x07936019","nonce":"0x4078ea14","previousBlockHash":"0x4bf726fb4536d24b5b7130e4407350822923effe8b0937fa3600000000000000","merkleRootHash":"0x9f3c635cc526d1961d1dcf005db2f9965938d73c9a1e3ea98cc6bd596ef8b9e9"},{"version":"0x00000e20","timestamp":"0xa6dea866","nBits":"0x07936019","nonce":"0x127d027e","previousBlockHash":"0x0bf158bd608a2a203c0204238e7c9ca8286ae234b13f0fe45c00000000000000","merkleRootHash":"0xadbc9bff135010f9117aaebda5426b3085c2e16945f9bf6acc48e7b9dd558e88"},{"version":"0x00408427","timestamp":"0xcadfa866","nBits":"0x07936019","nonce":"0x23cc30b3","previousBlockHash":"0xe62b805431cd69bcced321d7ad5f29b1ed0e60713e0dc5e52d00000000000000","merkleRootHash":"0x533183b8f850d8d9bac78c764484454f2b7be1c5f51d326bd344859be28fd160"},{"version":"0x00400120","timestamp":"0x10e0a866","nBits":"0x07936019","nonce":"0xa520500a","previousBlockHash":"0x3a5331232578c88ac3cff02792803fe1769911065d4554b22b00000000000000","merkleRootHash":"0x04d9992c1e5f797c495a3218ff2010fa43aac1b28e0d86346c0d2dd087cb97e2"},{"version":"0x00000020","timestamp":"0xc1e4a866","nBits":"0xffff001d","nonce":"0x64e78e11","previousBlockHash":"0x19b48c5a21f85a7399ae79c123931542527b5240cd914f924900000000000000","merkleRootHash":"0x849ea2c8a9210ee2d5b7cb2fa1eba9867aad402b3b6d676cecc6472301fad1ae"},{"version":"0x00000020","timestamp":"0x72e9a866","nBits":"0xffff001d","nonce":"0xea409b13","previousBlockHash":"0xabc53cbc7a980bad1b48d06f00509fcd81c4f400dc94571cae95c78a00000000","merkleRootHash":"0x06df0b5ab989d035fdc7dd75cf17cd6fe4d6652e6dffc67501403ce6f13e218a"},{"version":"0x00000020","timestamp":"0x23eea866","nBits":"0xffff001d","nonce":"0x3df10905","previousBlockHash":"0x8e2820ac9899c61256406dbd932654538f2f7df1fae61b8a5443106f00000000","merkleRootHash":"0xae251a35e4a13663d4cbbb36dd642e1f46cc10dafc9d266280a783735874eabb"},{"version":"0x00800020","timestamp":"0xeee3a866","nBits":"0x07936019","nonce":"0x780d59a1","previousBlockHash":"0xfda297fb54f97c94b0c3bf0066b51910c80a41dffb4cdef9b73fecca00000000","merkleRootHash":"0xea2fcb5eda0d6f0839cd552aa4ba3bfd3e71a4657620731cdac380b01e0604ab"},{"version":"0x00000020","timestamp":"0x9fe8a866","nBits":"0xffff001d","nonce":"0x23391f00","previousBlockHash":"0x4b69cc5e194cf224ab896dcf8d5b5f2232ea1b8bf423de5f2100000000000000","merkleRootHash":"0xe6b010f0560f995d9aba25363ce7cbd2c7247c7e272c5640a0e0d8613f428838"},{"version":"0x0020c821","timestamp":"0xcde6a866","nBits":"0x07936019","nonce":"0x70bcfe54","previousBlockHash":"0xdd9f61628d0c08e392a79e720c63cc2381aad5834e04bd976c6086de00000000","merkleRootHash":"0x82765bbd284df1e30584f2661d5b518b4a2571328f2a10f48fe0056ed988df90"},{"version":"0x00e0e123","timestamp":"0x82eaa866","nBits":"0x07936019","nonce":"0x7404c060","previousBlockHash":"0x9fd2f415dd5c6a0eb16dcaface57916f9e5c99428a35b1954d00000000000000","merkleRootHash":"0x03b07f92eba57e24d833592fdfe7670cdadade620760ba6ef576db6fa6649a91"},{"version":"0x00000020","timestamp":"0x33efa866","nBits":"0xffff001d","nonce":"0xeafb2a27","previousBlockHash":"0x7637c390410aac76999d97c798dce8c8cbdc6d955a3669334600000000000000","merkleRootHash":"0x5206703100dbfc5fcb2caeacf0b929437bb7c7b1015e631332e397ce6bb211fc"},{"version":"0x00000020","timestamp":"0xe4f3a866","nBits":"0xffff001d","nonce":"0x5efd901d","previousBlockHash":"0xab83e4bc3551e1e5dfa33c6815f66e66e09c6b77ab8c90df1f9aa75600000000","merkleRootHash":"0x0c5e05725f86ba1436dc6f57ba02c240359009cf4bbedcdfe9cb933e65fa9bb7"},{"version":"0x00600020","timestamp":"0x14eca866","nBits":"0x07936019","nonce":"0xe7280a9b","previousBlockHash":"0x8b8be47994712a731111b884470fb9fb2d76f4fbb0607a8d393f29d800000000","merkleRootHash":"0xe1548e57ac021379f0962837001d9239fa95692906d748ee6b98ade62159ef78"},{"version":"0x00000020","timestamp":"0x4aeca866","nBits":"0x07936019","nonce":"0x458c7757","previousBlockHash":"0xc6c75967ed68e81a000440a7ad596a4d15ed45956dd896900100000000000000","merkleRootHash":"0xeb981d338ba6e596c2b7921e0797001bce6e3f9aa639bf857bbeeea4632a2bc0"},{"version":"0x00000020","timestamp":"0xfbf0a866","nBits":"0xffff001d","nonce":"0x5041d004","previousBlockHash":"0x44bb4e9df1249731021fe20ab3647af29c83604d1d3bea386000000000000000","merkleRootHash":"0xc3ffd2128d769f05550676f97da5d16a106706d22b78bcdacc52c0beadaf2233"},{"version":"0x00000020","timestamp":"0xacf5a866","nBits":"0xffff001d","nonce":"0x4263bd1e","previousBlockHash":"0x5c3555356be975856380bfbef0c507f05e485570818c52adf89f86a200000000","merkleRootHash":"0xf114f5d8f6160074d0546aa97d09d71ef661a5486be261bf2ac6e454ffa404ea"},{"version":"0x00809f2f","timestamp":"0xc2f3a866","nBits":"0x07936019","nonce":"0x16ac3d4d","previousBlockHash":"0x50449f406a133ef05942da8afbdc6454680f2d9006aa0680397e564c00000000","merkleRootHash":"0x4753a5c7adc942ec6f76740c5bc8c5d3e94c7e1d68731f1055dcf405231d67a8"},{"version":"0x00004020","timestamp":"0x75f8a866","nBits":"0xffff001d","nonce":"0x93d8ea6b","previousBlockHash":"0x3ac8f3ee519b278dc02566bd01b49026049308d4a67961f33e00000000000000","merkleRootHash":"0x10d656a7222e8b0bd77f193f1ffad0cb39168b0a7d4d3d6c9bc40261c0dfe165"},{"version":"0x00e00129","timestamp":"0xddf9a866","nBits":"0x07936019","nonce":"0x7800c7ff","previousBlockHash":"0x23e80896268dc6666381406e1f591aaff4f79d35476f344d80ae000000000000","merkleRootHash":"0xd8fed91daf76ab9bab312924d93bd0b8c5cea65da8187a50057f85d5fc322b09"},{"version":"0x00600020","timestamp":"0x8ffea866","nBits":"0xffff001d","nonce":"0x1c06a3cc","previousBlockHash":"0x74c7666c8fe7697ede69bb82bbd56f436513cac40f229d715100000000000000","merkleRootHash":"0x7333986734b512e10804f769d21c1be4ed5bec05fefb3c8bf7776861549be997"},{"version":"0x0000f027","timestamp":"0xc702a966","nBits":"0x07936019","nonce":"0x6ebcd63b","previousBlockHash":"0x2b9ed77e1f23a03bf62c840656208e92d1d3bd35f1c2e72295f9000000000000","merkleRootHash":"0xd3ef9afbd090f0209bfd359d8628ce68e224d384acd3b3d6cbf6298ccb97cbfa"},{"version":"0x00c00120","timestamp":"0x3d05a966","nBits":"0x07936019","nonce":"0xd265e521","previousBlockHash":"0xcfe9ebec5ff201bca69d670469665b3d0dc8bc9647b1fc3c2200000000000000","merkleRootHash":"0xecd898ed58ef989735ceb6cc416c91ca624ea0467f430b21aa3e6b13ff8ab875"},{"version":"0x0060852d","timestamp":"0x6d06a966","nBits":"0x07936019","nonce":"0x0a8ce146","previousBlockHash":"0x0b620dac38d74b50bf79d874a07abb943acd2dcda130ddcd1100000000000000","merkleRootHash":"0x7545d8bc93624f9c1b69bd4286c03b86b0dff91a6f4aeefae85daa8418e8a494"},{"version":"0x00004020","timestamp":"0xc805a966","nBits":"0x07936019","nonce":"0xd0e0056d","previousBlockHash":"0xcb686bfb496aeee2e43394c247e526ff62f608557b1a7cbe5a00000000000000","merkleRootHash":"0xf3e4d64d31a72fd3746352aa348448973fdf238b395e8475aa511bbd4bc32516"},{"version":"0x00000020","timestamp":"0x7a0aa966","nBits":"0xffff001d","nonce":"0x959f65e6","previousBlockHash":"0x17ae4b67debe0a946d65a295202cbeb3e12be1feaa0a48a93b00000000000000","merkleRootHash":"0x7e88843239f358db1c8c7274f13029d44acc0e2cd91c8cc4186777c75fa06d79"},{"version":"0x00008020","timestamp":"0xb00ea966","nBits":"0x07936019","nonce":"0x36238c44","previousBlockHash":"0xe3082d13e07fb82564b8192458802daaf592a18b0479a69b25b269f700000000","merkleRootHash":"0x8df2815fc5cbe9448c032b908840f95d2267506ee7162b489aa72861e318aee8"},{"version":"0x00c00020","timestamp":"0x8e0fa966","nBits":"0x07936019","nonce":"0xf6d2df18","previousBlockHash":"0x9958b340ef2d2dff39acfcb03b7bc2da1f1c3a95afcf5a501800000000000000","merkleRootHash":"0xc4b3da5b76f88e9a6b89a74784c612f9f6f669a7f365c8f64ea10a6be21a76ef"},{"version":"0x0040ad2a","timestamp":"0xa613a966","nBits":"0x07936019","nonce":"0x3e8562e9","previousBlockHash":"0xc4eac285d3ca6d75ea1f7260635f27f2e7ca4838128087c00600000000000000","merkleRootHash":"0xc92a018bd39a787b1bad2dc1df1fae17d6386c08a78bc8f9b4b4abbba97361c9"},{"version":"0x00008020","timestamp":"0x2e13a966","nBits":"0x07936019","nonce":"0x0c4c4e94","previousBlockHash":"0x7b8b88167104535e362df72309574db06b2641e7bc93b85a4700000000000000","merkleRootHash":"0x30959eaf5c6eab8a39ff8ddb42a230640c2e8b9abf7aab7fb630b0659c5ce130"},{"version":"0x00200020","timestamp":"0xf313a966","nBits":"0x07936019","nonce":"0xbe38f8ad","previousBlockHash":"0x52a5333ec95d43582c22cd2bd4e40f69738386b11dd27b0a5600000000000000","merkleRootHash":"0xf248af43da429ff29d9c36aab8098eb920850abd94a4e6a0eb04100d626e23d8"},{"version":"0x00e0b428","timestamp":"0x6d15a966","nBits":"0x07936019","nonce":"0x47d449a6","previousBlockHash":"0xfb9854ad91da723e873f159aec452fa668fd303572152f633100000000000000","merkleRootHash":"0xd51e40aecca921d21b05dc1bd447fa2e467866e576a7d016fb0a20ffc1d3ed0e"},{"version":"0x00008020","timestamp":"0x4617a966","nBits":"0x07936019","nonce":"0x2be523f5","previousBlockHash":"0xd792f5c34bc74c117bbcf312a36de46cc80cad1c07ba94450500000000000000","merkleRootHash":"0x9e4ab8e802f9b230c7ed9920855a2ff013011d4ed9c1610461cc52b428b42313"},{"version":"0x00006c20","timestamp":"0x7f18a966","nBits":"0x07936019","nonce":"0x12d988c1","previousBlockHash":"0x9f7cb54c622e78edfc8729e0d4ec4f116756506f932958b74500000000000000","merkleRootHash":"0x2333f4029bcd4da76a193f3faff8328e5ecfe5626c56063eba139f679f323a16"},{"version":"0x00800120","timestamp":"0xa21aa966","nBits":"0x07936019","nonce":"0xc32a4032","previousBlockHash":"0xfae95171bd508e447ce312bc34eea24ce37d87a1034116780900000000000000","merkleRootHash":"0xea6df37ba97db67f9029ea457a8cf789ddbe6702f5ef3b77444a4bbe9cf39868"},{"version":"0x00e00020","timestamp":"0x611fa966","nBits":"0xffff001d","nonce":"0xe5a3d9c0","previousBlockHash":"0x2383944b2f40cda489980ea6053f34f1f76ac20aa78947b22900000000000000","merkleRootHash":"0xd6197b1c039490f36d63397108e1eee8ce88ffec94bd996966c32e76eeee38f8"},{"version":"0x00000020","timestamp":"0x1924a966","nBits":"0xffff001d","nonce":"0xe66ce1ed","previousBlockHash":"0x7dd9440c58fa2ed871bd19ea0c06f67342c64fe8440cc36114fb000000000000","merkleRootHash":"0xd1b3bb221a4a741021a44da2e93456c1ff021581a0b931d0fe17babab09255f4"},{"version":"0x00a0da28","timestamp":"0x6324a966","nBits":"0x07936019","nonce":"0x73acaaae","previousBlockHash":"0x3d23ea87d0b86f4d61e153a3aecc8991e06fbbb13b3c8af2afce5e6c00000000","merkleRootHash":"0x546718e12f8cc4d04483ec3310bc0d8f8525c38f600a2ddce4a81f352bcb05cb"},{"version":"0x00004020","timestamp":"0x5c25a966","nBits":"0x07936019","nonce":"0xc4e81360","previousBlockHash":"0x5734213ba1617f5f709e9357d6d0aad4505b5a84cbf8dbd33900000000000000","merkleRootHash":"0x5539b9892e87dce25120bc6da9f832ccd41787a6bd8769ceba95e0dfb4bb8924"},{"version":"0x00a00020","timestamp":"0x112aa966","nBits":"0xffff001d","nonce":"0xacd36e86","previousBlockHash":"0x0d2b730205e6de25f4b989b0624ca3d5a19d6a2c2bccfd450100000000000000","merkleRootHash":"0xeb86e18015de8f859ecbbe9468bfc019dfa11205e1a4ce8faba21d61d28a3207"},{"version":"0x00000020","timestamp":"0x932aa966","nBits":"0x07936019","nonce":"0x3dd20ddb","previousBlockHash":"0xd5a2b1a7ee8162741d764bf99ef6ec6b9a97ab40e6f1fa49ae04000000000000","merkleRootHash":"0xb5bb487a982c9bbce1e3a231cfb737e2cf9bc5ac47b434b4026c7e132ba08dfb"},{"version":"0x0040922b","timestamp":"0x1d2ba966","nBits":"0x07936019","nonce":"0x3670d802","previousBlockHash":"0x2d647d9d58bee2267c07c125677a9dad0d49eb88070ab22b3600000000000000","merkleRootHash":"0xe590c0a2b9fd9d51e612b9f2a9a4bd7e603072d7a1f912d73aba2148e129da6b"},{"version":"0x00200b2e","timestamp":"0x982ca966","nBits":"0x07936019","nonce":"0x38587cbd","previousBlockHash":"0x5c307b15d3527f24dc73629531a44a192dc95189a7cef7790d00000000000000","merkleRootHash":"0x289629ed3b8bb1b4e376f95d1ac2b15b73f8c244bd21aa27cd455be3f108c714"},{"version":"0x00008020","timestamp":"0x3e2fa966","nBits":"0x07936019","nonce":"0xc24fd1d5","previousBlockHash":"0x8a24ffbaef432b46e77ecaa332d3def0518ec3b46abad4f80700000000000000","merkleRootHash":"0xd50bbbed3a8a52aadd6aa93f3bc2268bd803d3a98f903e9eb75d5ec81598ef96"},{"version":"0x0000c020","timestamp":"0x6f30a966","nBits":"0x07936019","nonce":"0xba99a169","previousBlockHash":"0x6e8fa5bfb7ea18c67688e0d5d1de7d788e86f4df711d9f003100000000000000","merkleRootHash":"0xf7073388634ad1013298345d36b69ec90a4d033e1b3d3a992bca86e3c679e20e"},{"version":"0x00600020","timestamp":"0x1931a966","nBits":"0x07936019","nonce":"0xd5484512","previousBlockHash":"0x2ade953662aa4aeaacc5524b8b9c86c09610271fcd8fbff75200000000000000","merkleRootHash":"0x73be4023c47aa0d34773df037bcb33336cd688585a2c082254d9f699847e46ea"},{"version":"0x00a0152d","timestamp":"0x2f34a966","nBits":"0x07936019","nonce":"0x333fead5","previousBlockHash":"0xc432c413024977e391e3d778fd83ff78e1b8fa4e70d6e6002b00000000000000","merkleRootHash":"0x690c23174fd4a737bcc32a8760c8a7927bba0cb5df5e54552ab2e839bc2585bc"},{"version":"0x00e0bf22","timestamp":"0x0135a966","nBits":"0x07936019","nonce":"0x12881ab4","previousBlockHash":"0x27686da0669f8a4f7c02644adefa2e747003fbfd40e6091c2800000000000000","merkleRootHash":"0xc468e0d944765a31b81839501fbf5242a762a94ce82a5c89b163c1ab595ae54d"},{"version":"0x00004020","timestamp":"0x3d35a966","nBits":"0x07936019","nonce":"0x09ae4c22","previousBlockHash":"0x5c688aaafa3a4cecab1403f7951aa5474cf540b7534df21d3600000000000000","merkleRootHash":"0x6989d803bf74980715af5af5a1c81cc3bf82b69578e9225ff7475205bc36c6dd"},{"version":"0x00008020","timestamp":"0x9f37a966","nBits":"0x07936019","nonce":"0xce917fd5","previousBlockHash":"0x60532c803adfc1276f18189d50887450dc17ad5f4ea4e41f4900000000000000","merkleRootHash":"0xcc765793d15ea0d62ed4bc49d3104b3684280ab199342cc3aa81e71682b3bbcd"},{"version":"0x00004020","timestamp":"0xbd37a966","nBits":"0x07936019","nonce":"0x2513ad89","previousBlockHash":"0x8fa468d862fff09f65f1a61435c1cdec174490de766d2c792000000000000000","merkleRootHash":"0x832971326f04c8fdea82f217418a4d8c49487a9a7ba9df23c1fa35073c4da6da"},{"version":"0x00e07b29","timestamp":"0xde3aa966","nBits":"0x07936019","nonce":"0x65447494","previousBlockHash":"0xbda5b1e49e5457b3985bc68f96e1f1ba88d0dbcebf9a1e2b5400000000000000","merkleRootHash":"0x1b7a7a1e80088bf984e03386e08118638fb0222da4ea0cb24bd0dcaf555f4da9"},{"version":"0x00609821","timestamp":"0x503ba966","nBits":"0x07936019","nonce":"0x64211dcb","previousBlockHash":"0x62436904cefa0feaf423c78f569294711b51fa68aa0950091100000000000000","merkleRootHash":"0x3d765024077944d810ae9c9cd6f6f585c7d64e3cd856d5fc1129d17ce415964a"},{"version":"0x00600120","timestamp":"0x0140a966","nBits":"0xffff001d","nonce":"0x607596a7","previousBlockHash":"0x8fe69ea63b2f2d7038e19b2daa446d1668c8ed0e5e8e64600c00000000000000","merkleRootHash":"0x3ff6ef957ae3e424eb9904b83ccd1fe4d69d69286036dbe829a2340b0e687ff6"},{"version":"0x0000c020","timestamp":"0xb344a966","nBits":"0xffff001d","nonce":"0x1106a783","previousBlockHash":"0x052038e740e8e905fbfcabfe80950f52cb9593e5552154929bb7000000000000","merkleRootHash":"0x64b4099d2c8004c434cea7033ea960702bf01c183875ef6a67bf233980b2e620"},{"version":"0x00000020","timestamp":"0x6449a966","nBits":"0xffff001d","nonce":"0x4164c40d","previousBlockHash":"0x73e6b62757053f086c29dd7ffb363d745763d9fb5a25e8fdf9f4000000000000","merkleRootHash":"0x5f43efb0846d1d6583cc823e68ef1a88aa1a35584e89ffcfb5df7f9029153768"},{"version":"0x00000020","timestamp":"0x154ea966","nBits":"0xffff001d","nonce":"0xda91592a","previousBlockHash":"0xbc31cddf3cf7bc64d674b8d9dac57558059278b1a172a77fe5b6cb6a00000000","merkleRootHash":"0xdd1734c852dd0f1827deb7a4ab6299584fba66177a2a42ae678a548fbfb87d6b"},{"version":"0x00400120","timestamp":"0xbf4fa966","nBits":"0x07936019","nonce":"0x62fb273f","previousBlockHash":"0x079aedebefe6888867e6ba941bd7c8dd6f71fd068d354f5b9d5764d200000000","merkleRootHash":"0x92aa66330170bf5153e094582a89ee07e03523d4a92dacbc37bcf37bd5e24b40"},{"version":"0x00004020","timestamp":"0xbc51a966","nBits":"0x07936019","nonce":"0x2a24fbb2","previousBlockHash":"0xf708999cf6d651c760c687a74a4ee115622dfff30f4270b92e00000000000000","merkleRootHash":"0x3cebfb4221e3f28b9057147e8f98ea0bcff12315ab37b10465389bfd8d5f9335"},{"version":"0x00000020","timestamp":"0x2854a966","nBits":"0x07936019","nonce":"0xb094ddec","previousBlockHash":"0x8bf74c6f7fc9eb567262b4359420a83d01379e5f7464dd8b3200000000000000","merkleRootHash":"0xf5005176da8b9ea62979cb1412a2057184d6e1ab6a19f81cbec813b4c18e6b06"},{"version":"0x00000020","timestamp":"0xd958a966","nBits":"0xffff001d","nonce":"0xc88fd402","previousBlockHash":"0x75ef3b2d2f6ec06523bbb4f859089beabdb5dd1151694ebf4f00000000000000","merkleRootHash":"0x576373514cd0a3aa940a06f2b27d84cbaf6ee004860f6b1ce2e17fb7fabbdae2"},{"version":"0x00000020","timestamp":"0xb55aa966","nBits":"0x07936019","nonce":"0x46754824","previousBlockHash":"0x79c276c4df72faaa128627ed7678be61a7d3c76e3447188c28f5323600000000","merkleRootHash":"0xd5c4deb47ff8683f35104e94f63933856c5a49a143bf2dd7f16004b718071594"},{"version":"0x00000020","timestamp":"0x675fa966","nBits":"0xffff001d","nonce":"0x800e2486","previousBlockHash":"0x34c865feee040eec6ebf6f4bc1d1b1f05cbd41f8103ca2354900000000000000","merkleRootHash":"0xa097616eba3c4dc13046b1ba406e52fbfdef7ef2342409dc4e5866d5609208c0"},{"version":"0x0000c020","timestamp":"0x1864a966","nBits":"0xffff001d","nonce":"0x9449ebaa","previousBlockHash":"0x5a0a3672935749e9d1e8943a03efd3a7f4e39e3d8b958313c142cf3400000000","merkleRootHash":"0x0391ae2b17db4dc58a7acb43371a77d54f3f24095296c75f593d580901480851"},{"version":"0x00200120","timestamp":"0x6a64a966","nBits":"0x07936019","nonce":"0xec2e83c1","previousBlockHash":"0x2fa39a0d0b26433a11ff308274ed66134f5d4044b5f35afd7eb3000000000000","merkleRootHash":"0x8a262459fabbbcee89e31cafd4ee51e3ee99729883e36f1c6e1d93ef94b314f7"},{"version":"0x00000020","timestamp":"0x0d65a966","nBits":"0x07936019","nonce":"0x47c9cf2f","previousBlockHash":"0xbdeaf2d560bdfbdb0cd23ecc381d6c850a96665d7fc611500900000000000000","merkleRootHash":"0x1a6b0b25e3ea432bb8c3f2e9dbfc55ba77571ad59cafdddfb28c14635167e284"},{"version":"0x0000c020","timestamp":"0xbf68a966","nBits":"0x07936019","nonce":"0x8dde8704","previousBlockHash":"0x5620116d7400941da4f716de6732e50366989f8dddb0259a2b00000000000000","merkleRootHash":"0x088ed1f46b12a479db0471a595af7c4f33b59d0624273438fd5992307bf3de1d"},{"version":"0x00a0b229","timestamp":"0x0a6aa966","nBits":"0x07936019","nonce":"0x70e93250","previousBlockHash":"0x4f1fffee17ecb46ac8e5273191a2d1fa80b65cd2f2792b364100000000000000","merkleRootHash":"0xa16ce93ff8656d4a45b3c4d3d2f6a7d9336ce5e493d6182363e36ef68b292559"},{"version":"0x00008020","timestamp":"0x176ba966","nBits":"0x07936019","nonce":"0xc90840b4","previousBlockHash":"0x765879df82c14648b52e7b5c4d0104dc002fc156a0f2e7a15100000000000000","merkleRootHash":"0xa11c14d7a3dda1a8abf0cdd5a197d1be24be3ac4512957118283e76c8000591e"},{"version":"0x0060ab2f","timestamp":"0xd86ca966","nBits":"0x07936019","nonce":"0x7829880b","previousBlockHash":"0xdb17e87285a5938b31cdb7c742b5e02bc59f1165c968fb945100000000000000","merkleRootHash":"0x59e72f53f80d3742f8c66b0de6873777a52ceae949beb81969e572d22b0c0183"},{"version":"0x00400020","timestamp":"0xbb6ea966","nBits":"0x07936019","nonce":"0x0d0fc288","previousBlockHash":"0x84fa0721eea69d26e31233ed9d419fa2a86dd25156f15a284800000000000000","merkleRootHash":"0xdc1fc0bbf65c9e91b1949bb015b3da5d339538a224afe2cab059ed67c3cdf046"},{"version":"0x0020c021","timestamp":"0xde72a966","nBits":"0x07936019","nonce":"0x5b1cfd0d","previousBlockHash":"0xca45ea98bb5b3886252539269640281b96aa0bbc299ccdc45f00000000000000","merkleRootHash":"0x5023c6fc23449b73e77d3cd9bf3acbe9dabf7eec984df4fbc81462a203de934d"},{"version":"0x00004020","timestamp":"0x0675a966","nBits":"0x07936019","nonce":"0x21c05ddc","previousBlockHash":"0x4715668f5924cd729079cc662b1f6d4ab472fc3cc27a2b692a00000000000000","merkleRootHash":"0x2a93466e61618f90e6d49ea733b402110b13ab1f0ef7a1840973468eac48326e"},{"version":"0x00800020","timestamp":"0x5877a966","nBits":"0x07936019","nonce":"0x722d5abe","previousBlockHash":"0x1236459e526858cc288195decb6fadc87bb68f078bdd0b605600000000000000","merkleRootHash":"0x85f51a166c77af4262b7b342c7240e25199e021a177cc0539d743e19304cc265"},{"version":"0x00000020","timestamp":"0x097ca966","nBits":"0xffff001d","nonce":"0x83aea905","previousBlockHash":"0x915830176fa3af53513580de5b052a764d5fe0ee744213652e00000000000000","merkleRootHash":"0x1e2a6a98e258eaf487e40302d191aaa4daad17a16045b50841179cc3b3609f60"},{"version":"0x00a00020","timestamp":"0x437da966","nBits":"0x07936019","nonce":"0xe08444c8","previousBlockHash":"0xa9f30f805bb5489baea6e6b1bcf33147918c9df52a0bd21a6ff25d3700000000","merkleRootHash":"0xfdafc50eeb8bee07ccf488f146d0f4a3ec967de3b04ec67d5b4c7ba5f3b97e7e"},{"version":"0x00000020","timestamp":"0x0282a966","nBits":"0xffff001d","nonce":"0x2a329e34","previousBlockHash":"0xa4e6980830945461610950ffbff144af679198519c9f18704600000000000000","merkleRootHash":"0x15addd0f137c33ca5ca1bfb60081242f4b5614fc90d5cf4b8f84f8cf045f36fc"},{"version":"0x00a0fa20","timestamp":"0xc383a966","nBits":"0x07936019","nonce":"0x3204606b","previousBlockHash":"0x1efb55b90b36e36e735764d05f4e2798d9bbc94557ad4ef3140a010000000000","merkleRootHash":"0xed3474f09f4eff9b3d9073331025e76863a38a22b952be35f107d2e6775b3b13"},{"version":"0x00600120","timestamp":"0x4d87a966","nBits":"0x07936019","nonce":"0xc244d043","previousBlockHash":"0xdaa2c6b50e7c31cebf7225c797a6649d60cbccaf6356ee5c6000000000000000","merkleRootHash":"0x26ceea6739c3c9e7506be3bb815ff754cf72d2d8ebf0e759a77e1f27f895e27d"},{"version":"0x00000020","timestamp":"0x018ca966","nBits":"0xffff001d","nonce":"0xeb8f4ad1","previousBlockHash":"0x5ca030381212e63f34a683cf84104fad08d4b6ca603c05255900000000000000","merkleRootHash":"0x123c089c32660b1c5e4d785770d4cc44127dc4de72163fde3c3f4f239d7e3856"},{"version":"0x00a00120","timestamp":"0x278fa966","nBits":"0x07936019","nonce":"0xdf432f38","previousBlockHash":"0x34f107d7083888289f313958fd18e4b8ad175af079da020c19739d3200000000","merkleRootHash":"0x519f87ef7bc9baec2ae69e83cf500bc00f2e5da35ec08be36899ba9642f790e3"},{"version":"0x00206d2d","timestamp":"0xd493a966","nBits":"0x07936019","nonce":"0x24248a02","previousBlockHash":"0x5ad8c454b6d671c579ba3ba10ae0b486d6da302c19e6e25b0c00000000000000","merkleRootHash":"0x2483808a3dbf5fcead2703bdecf923125fac2fddbe238d2a2f6f7182eb3304f7"},{"version":"0x00209225","timestamp":"0xba97a966","nBits":"0x07936019","nonce":"0x5b1cc208","previousBlockHash":"0x6b458c5d79cf9f7cee5b0d0ceda04ad567267db772d0b9bd1c00000000000000","merkleRootHash":"0x5edcc8387bb268362fe2eb10c255f8a8578de58b737ed464a57f740faf4084d2"},{"version":"0x00a00120","timestamp":"0x5297a966","nBits":"0x07936019","nonce":"0x18db6437","previousBlockHash":"0x77b5d305a17c60df985a3e8d7989a1d07ef1dd1ff60a82581900000000000000","merkleRootHash":"0xfde10227684afa81322ea2dbb6abb7d998c70668680c20e8256dfe425ad14369"},{"version":"0x00000020","timestamp":"0x059ca966","nBits":"0xffff001d","nonce":"0x26bdc4f7","previousBlockHash":"0x1f9b44ec46bdcda981e9e2e53c46485aafaf9fb70e7884285600000000000000","merkleRootHash":"0xce92036b41d3875bb0a18f5d59bcf08f073c91b5e150bc71e9a314553286f0e6"},{"version":"0x00c0da2c","timestamp":"0xfa9ea966","nBits":"0x07936019","nonce":"0x3dd49694","previousBlockHash":"0x66588353f18b84ee3de1e6d41c469f49ecd7334e76342cc35030439a00000000","merkleRootHash":"0x78ea7f54965e4c7fbe4df9d47515a149350d4f6ed42a8014e12974c32bb37d7d"},{"version":"0x00200020","timestamp":"0xb4a3a966","nBits":"0xffff001d","nonce":"0xc350c3a4","previousBlockHash":"0xef5162dcfb587615b6c4306e00ce74e5bcc0a52c3ee2f3bc3e00000000000000","merkleRootHash":"0x51f3f1248e3cee9ae065811d2ca12d4f29ab576b86e869439ab9b5bedd365478"},{"version":"0x00c0fe21","timestamp":"0xd4a4a966","nBits":"0x07936019","nonce":"0x41a0235c","previousBlockHash":"0x7c77dad0632beab44f329c7cddd42e23f4c9f0dc50ec6c8724e6000000000000","merkleRootHash":"0xc2671615bf1bbadd96523143e70f379fb5e80a80c70fed8721f974abb4740546"},{"version":"0x00a00020","timestamp":"0x48a6a966","nBits":"0x07936019","nonce":"0xa93cd1b9","previousBlockHash":"0x810d16117cde3df6e5ffa5cb83c0b6d5c2c9352ad72d02aa0500000000000000","merkleRootHash":"0x53f3c56261b9c00740586e5bd73321cc7ebc804e93e7d2a5160e2011a48dde7c"},{"version":"0x00200b28","timestamp":"0xd6a8a966","nBits":"0x07936019","nonce":"0x3760b1ea","previousBlockHash":"0x39d92138a31a8c3d243c231d2758310377423166bdb3ab834200000000000000","merkleRootHash":"0x58defa52b69b374352a39dedd1f346d589e909ea6468279a2b41a671ee4f6938"},{"version":"0x00600120","timestamp":"0x46a8a966","nBits":"0x07936019","nonce":"0x4e1cbc0c","previousBlockHash":"0x454d7e565147651a825f48246bfefd4cb33cd741505ac5c25c00000000000000","merkleRootHash":"0x97015a548d6512914d16ac3431218c5a0f5966e6be3c604540f61a9cbf7acbce"},{"version":"0x00600120","timestamp":"0xe9aaa966","nBits":"0x07936019","nonce":"0x236cc2ce","previousBlockHash":"0xd90517a13e1d2e3d4b2335ab8b0f47b734571857c13b53c14e00000000000000","merkleRootHash":"0x93aafc8d1244c8cd866fe6d26b6b9aacfe8a04473da96883fe21924dbe8cea10"},{"version":"0x00a0af29","timestamp":"0x4faba966","nBits":"0x07936019","nonce":"0x23a800dd","previousBlockHash":"0xa08a30f56f0c6e37186fc4681b6d3469f426938806f9ea863400000000000000","merkleRootHash":"0x23f156e73cc6e0387d5b356e875ec71e2bd2098b4f7146a09a1d5fc9173b9cb9"},{"version":"0x00000725","timestamp":"0x20ada966","nBits":"0x07936019","nonce":"0x66110b45","previousBlockHash":"0xbe0c9007c828adca339e597408479b75065610d06c227cbc1c00000000000000","merkleRootHash":"0x18f61c9086f6ca092dc0dc98465afdd9bb8602ceb4d5117f40778bc2020ad88d"},{"version":"0x00600020","timestamp":"0xd6aea966","nBits":"0x07936019","nonce":"0x3f5b86b3","previousBlockHash":"0x75ec64cf3550d2a13c939a976e01a15fbefe55ff49b984833b00000000000000","merkleRootHash":"0x61afd9444b15c0e2086a518b6d7c7cdf6cd0afa154c85ee28b4e836959f23aeb"},{"version":"0x0080a02e","timestamp":"0x7dafa966","nBits":"0x07936019","nonce":"0x0df53471","previousBlockHash":"0xdb0e0fe463e7783047c42ddec1d9426e3ec4a2a2ccc083900c00000000000000","merkleRootHash":"0x8c6fb657a6fc07366edae65977eed3959f1396965d2adaa253bfcaec4349b6ee"},{"version":"0x00000020","timestamp":"0x2fb4a966","nBits":"0xffff001d","nonce":"0x00071496","previousBlockHash":"0x4e084f015d4d96eaf770c47c2c4ede4e7ae589cd5181172e5c00000000000000","merkleRootHash":"0x2df7af69ea9d7ef0aee284fc88b51824710242a74ddabc2f3fd11206493a6f35"},{"version":"0x00000020","timestamp":"0xe0b8a966","nBits":"0xffff001d","nonce":"0xad02cfb8","previousBlockHash":"0x77960450cbac4ad55551053a5bfa45231d7f20975ddb59ce5ed2e32600000000","merkleRootHash":"0x60064a13c2e8321f933363bfb05c4d81ef3e788f552343501e4f5c8ce9ef34bd"},{"version":"0x0040612a","timestamp":"0x61b9a966","nBits":"0x07936019","nonce":"0x5d4949e6","previousBlockHash":"0x62934cad67646a366336a0a807d08ce4bddfd64fab7fa16fea2c000000000000","merkleRootHash":"0xe02d8c503896640561676b3586e22f8fe32d77fef0fd3324c51cce384c5fd4b0"},{"version":"0x00200120","timestamp":"0x04bea966","nBits":"0x07936019","nonce":"0xcb2b9d3e","previousBlockHash":"0x77ccccaa0115618e5c3bfc82c5f5db1e513410799b76e1813c00000000000000","merkleRootHash":"0x44f5c2459601f47674ce6b0701f91df2d1f0c3d9681467b829732a747a4a163c"},{"version":"0x0080fe24","timestamp":"0xe0bea966","nBits":"0x07936019","nonce":"0x2764ced3","previousBlockHash":"0xb26fcef70515c6ae7e18b784ecaffe8446bfcc97400131560f00000000000000","merkleRootHash":"0x206caa209afedc6113ffe563d39e19d74ef3c7035ad475e51ccdc72bbec27642"},{"version":"0x00e00120","timestamp":"0x4cc1a966","nBits":"0x07936019","nonce":"0x52a780cf","previousBlockHash":"0x80e3ff9f6693caf73f6a3946508877de046038802104d4082b00000000000000","merkleRootHash":"0x6d12913859a7357385e270037f2e393597169e7215a98d57e77ba0863f0e0329"},{"version":"0x00e09b20","timestamp":"0xffc5a966","nBits":"0xffff001d","nonce":"0x0600b95e","previousBlockHash":"0xea52992c7ab546f71f92196c11735fda0eab5062920d4de42800000000000000","merkleRootHash":"0x704b8287937a1f5c0cbcbd5b5a66fc25e77a9dd2bd31c3b91dddf144b429f1e1"},{"version":"0x00000020","timestamp":"0xb0caa966","nBits":"0xffff001d","nonce":"0x46043e30","previousBlockHash":"0xa8ece02e3178e7d1ed95376a99c7aaa257a583790b69a91dd82d340000000000","merkleRootHash":"0x8bbf2927f532a8f6581e980559129d9cc33f8768e2d789b180cdd7829b841b69"},{"version":"0x00c0de2f","timestamp":"0x94cba966","nBits":"0x07936019","nonce":"0x60840756","previousBlockHash":"0x43beb96a2926d1c6e74161308f7f86fc168ed13714b351684d8b400000000000","merkleRootHash":"0x3e002695b58593640922ce167ddbca588e40464b90bd5f2860d88afef06a3388"},{"version":"0x00c0b128","timestamp":"0x68cda966","nBits":"0x07936019","nonce":"0x77b46c70","previousBlockHash":"0xf1ede3aee1facc3040cac02ad4ef9f8a962b868422632f650a00000000000000","merkleRootHash":"0xdb3924c96cb20723efb129beb82e198268fab6b3d154e12b2ec94dc521827703"},{"version":"0x00000020","timestamp":"0x19d2a966","nBits":"0xffff001d","nonce":"0x6c5e7e12","previousBlockHash":"0x41fce9747a6c265d050d7b099a8139a19a473da28e1456904100000000000000","merkleRootHash":"0xb2d6277687a69e6cd9ee6583356f00b8e6bdb95027f12441407b4d4063cf5d17"},{"version":"0x00000020","timestamp":"0xcad6a966","nBits":"0xffff001d","nonce":"0xd437cd1e","previousBlockHash":"0x4a97c02c1fd111f58e0eca3a3afb2294039fdaa74d1abad04f5ef2a600000000","merkleRootHash":"0x7193bdcd04d7029aaa3623897dbeee5a84e215ddcdcf279392019e209d8e3699"},{"version":"0x00000020","timestamp":"0x7bdba966","nBits":"0xffff001d","nonce":"0x32a96d35","previousBlockHash":"0x97956c7f7a018ad669d04c7ace7abb32c1335dc4cda1c800e2bf12f000000000","merkleRootHash":"0x3b9d2743da68a6296a0f339fd3c58c3b2aa2ffe055b1538c4d6949b5ff456c59"},{"version":"0x0040cd2a","timestamp":"0xc3d0a966","nBits":"0x07936019","nonce":"0x5f19841a","previousBlockHash":"0xf3d6311977fcad4224e1437685a502b544f78ce16c3649a2d666c62100000000","merkleRootHash":"0xf77d56a3bef5c3e0383051197040f134b3c164d53ed345174575ff65d2517d6d"},{"version":"0x00000020","timestamp":"0x74d5a966","nBits":"0xffff001d","nonce":"0x9ebf401b","previousBlockHash":"0x2aa87b606df5c9e33a5e7b06f0bbe908b916bc1f2cac9d031600000000000000","merkleRootHash":"0xe5c30330f6bfdf7b5a6207ac06bd72b58869c17044104cc66b4c319126476c09"},{"version":"0x00000020","timestamp":"0x25daa966","nBits":"0xffff001d","nonce":"0xfde21930","previousBlockHash":"0x502a11086d385da9d46c978161b7ab82d85882587f9f5576e602900e00000000","merkleRootHash":"0xa1a99897e1e59d4b49aae0fdfe0d6943df40a747cf16928fcd37d62b1bc1623e"},{"version":"0x00000020","timestamp":"0xd6dea966","nBits":"0xffff001d","nonce":"0x66df0022","previousBlockHash":"0x66df4721b77db880bd4ec1facfab9cd91602cb030c758ae0a660bf2a00000000","merkleRootHash":"0xafffb0c0691198b76642203d9560fd3b06d9d5a7fc743fba20cc3974c7346028"},{"version":"0x00000020","timestamp":"0x87e3a966","nBits":"0xffff001d","nonce":"0x3ac0aa33","previousBlockHash":"0x5fc2edbdcd7354f7cf95ee77034c8f8a54e3b92de0ddf049699fe38400000000","merkleRootHash":"0xe8bb12e90272b013cf6fbdaecc6cc9bbbca6cbfbe1d860ec48020e1fcd7c701c"},{"version":"0x00000020","timestamp":"0x38e8a966","nBits":"0xffff001d","nonce":"0xeb209024","previousBlockHash":"0x8df97cc081155e95f27bfab6e0ade4047116daaaf0a6acf1d098c16100000000","merkleRootHash":"0x8f46ea92db311b3d9a410eae94b42b534c41f6d9fa71feeb764195bc70da1773"},{"version":"0x00800120","timestamp":"0xcbd6a966","nBits":"0x07936019","nonce":"0x720d194d","previousBlockHash":"0x6805c918e122725889ebde3618f115b882ee4b3ab954a5cedf897fd400000000","merkleRootHash":"0xff7cc41d8d9ccce753f0224ce74430006e9e3839b373b44a7db4ed27d3066c86"},{"version":"0x00000020","timestamp":"0x7cdba966","nBits":"0xffff001d","nonce":"0x5c7d2c1a","previousBlockHash":"0xfd87165030e97557820dc95bcbaaaa1466cab2db14cb8b950f00000000000000","merkleRootHash":"0x2ff22670b38d94b06136732b96c19aed46c590e79332c747ffb236c8166f1c0a"},{"version":"0x0000c020","timestamp":"0x00dba966","nBits":"0x07936019","nonce":"0x0dae3c60","previousBlockHash":"0x1238189b9aaec2b6f323eb1eb08a5a996279d8c4b3126fb95b08fa0f00000000","merkleRootHash":"0xca9caa22605281a8ba38158282c74adb0fa9e40efd487fa973f229e8fdc42919"},{"version":"0x00c00727","timestamp":"0x9cdba966","nBits":"0x07936019","nonce":"0x534c7c6b","previousBlockHash":"0x6cbcc0a93e1145c12e9d272c0a3d658fc04b82bf0d13cb0f1100000000000000","merkleRootHash":"0x13726b8b06efc268917e7250779e1fc5bdafce8c64ea85c62a7264ce866ee0ee"},{"version":"0x00000020","timestamp":"0x4de0a966","nBits":"0xffff001d","nonce":"0x86e67601","previousBlockHash":"0xafff954513dd68b5f3e0bbcd32177ad3e5658aea3cb228db3900000000000000","merkleRootHash":"0x37bf64ef86ee6c469551fa72f0cdf0a17c2e2e220a362ef84392d48df8a9d5c1"},{"version":"0x00000020","timestamp":"0xfee4a966","nBits":"0xffff001d","nonce":"0x14d7b876","previousBlockHash":"0x6aa5623368bb1b14c7b61a50a465cede1ce94b84fc633dce235c065200000000","merkleRootHash":"0x6483cfd4fd636dab9d1c1d7f67772bcc6f0546f674fe73f883663c67c3acaa93"},{"version":"0x00000020","timestamp":"0xafe9a966","nBits":"0xffff001d","nonce":"0xda6ca002","previousBlockHash":"0xc2a2de2eac470ddaf42c3ae9894308d384759d46eedec9b1a917152600000000","merkleRootHash":"0x88e8f02c6c78e9593cc7e883d5ae2a365ac189c91b870cabd27907996956eec3"},{"version":"0x00600120","timestamp":"0xdee0a966","nBits":"0x07936019","nonce":"0x771be3c5","previousBlockHash":"0xf7cb0f9c411ace189863a1be664a3a1baaca3428625346349d4f3b0b00000000","merkleRootHash":"0x4569b672d9ddf9ce406221aeac8ef5cca1b63cdea0cba143bbeefac8483c9845"},{"version":"0x00000020","timestamp":"0x8fe5a966","nBits":"0xffff001d","nonce":"0xcd369019","previousBlockHash":"0x9ff16e7805e1a06c2d53d5c0ebe5002733cb419d4f1872e02900000000000000","merkleRootHash":"0x26079e9b96a8a7a2e5f5517126ca6dbe89714485f8b23435883c23c8895a718c"},{"version":"0x00e00120","timestamp":"0x30e9a966","nBits":"0x07936019","nonce":"0xe05281c7","previousBlockHash":"0x119c48325c01edc1384155689e4fb586d32fd4b72a8ec3ed0de998d900000000","merkleRootHash":"0xa1bedbf61b7919cb96c2fd28c077f40bc6639b13c5509b659180df16d5fb5f03"},{"version":"0x00e0812a","timestamp":"0xeeeca966","nBits":"0x07936019","nonce":"0x2a5001b1","previousBlockHash":"0x56103651a6297902e48f6f1261f69208f93fd8a7764ecd9a4800000000000000","merkleRootHash":"0xc62bc7d1c713c71078354cb5b6fa90f4d30f6e20cb35868574ce170ca362a590"},{"version":"0x00000020","timestamp":"0xb7eca966","nBits":"0x07936019","nonce":"0x435fb7c7","previousBlockHash":"0x6a3a061b3b29dd8a2def053d7fb57e7f01b64610365708fb5b00000000000000","merkleRootHash":"0x48a1058f0c801450750d87ad3ab935eae9d7ff93cc9c63d61be2a03f58f528bb"},{"version":"0x00402a27","timestamp":"0xc1eda966","nBits":"0x07936019","nonce":"0x40185a99","previousBlockHash":"0xa7026467334b05d429e9210718da4e2b7565f131805ad5342900000000000000","merkleRootHash":"0xb9bc64f3c777c0d136c0018cf71200890a343f3a179f4566cf9709e52245fec7"},{"version":"0x00c00120","timestamp":"0x7beea966","nBits":"0x07936019","nonce":"0xcd789912","previousBlockHash":"0xc66e439e49cf19564ed3c5467fa41f2f8fd048b8976d2de75c00000000000000","merkleRootHash":"0x670ee53ad0fb1167e5fcbc4c35fba29543a555b4c40c31bdab62adb7b84e2180"},{"version":"0x00004020","timestamp":"0x62efa966","nBits":"0x07936019","nonce":"0x52901611","previousBlockHash":"0xa024ef00f6218877fa5e24b1206ba0538d9275f50c05af512300000000000000","merkleRootHash":"0xd456f06aa4abed81166f2df08606b1662759cbeedab0d5d20dc23cf34e7397da"},{"version":"0x00000020","timestamp":"0x21f4a966","nBits":"0xffff001d","nonce":"0xd556f363","previousBlockHash":"0xf29ab8f6e11182e9b5020d14b34b4a9ce6581aa7d60fb3412500000000000000","merkleRootHash":"0x0a340d0377b9c0ba3814ed1ed8dcda478e193e4adf6a4406be7da1e362ba21f8"},{"version":"0x0020b02f","timestamp":"0x48f7a966","nBits":"0x07936019","nonce":"0x1718af00","previousBlockHash":"0x7256af7560c0c008d85a487f1e372ffb4b7fecdb7c6354a6f67416fa00000000","merkleRootHash":"0xd928033e8de83c14685428f5041879181be42fae8b3679f69341a50abc6cc5fd"},{"version":"0x00200020","timestamp":"0x00fca966","nBits":"0xffff001d","nonce":"0x3bd5ea14","previousBlockHash":"0x3ce34c746803bd5025aede1a21185ef5c59009bc6d1e6c1c1400000000000000","merkleRootHash":"0xf5e2bf46edb603b559e09ce4228007cc263914ce4a24d71bc7c336495a583961"},{"version":"0x00008b28","timestamp":"0xd0fda966","nBits":"0x07936019","nonce":"0x6cb4ce7b","previousBlockHash":"0x45fff1a08f0f60f8c2fd25f11c7e1bbc9a6107e462af2a68cc1d010000000000","merkleRootHash":"0x41b486750737655763a5e75e90cd676f8e3d614dd2ccf8e43a28d55ed31fff89"},{"version":"0x00a0402b","timestamp":"0x6efea966","nBits":"0x07936019","nonce":"0x1654a87a","previousBlockHash":"0x2f5cacb3c16a57420be7fd7bf5156304becfe98dd120cba64f00000000000000","merkleRootHash":"0xe9c376e0a332e4de90b2f30cfeda664c6e12bc833a2d3524b857cc4c8f8baf24"},{"version":"0x00000020","timestamp":"0x2903aa66","nBits":"0xffff001d","nonce":"0x8720a815","previousBlockHash":"0xd782dd061648cf7978e4c5689da2e31d714f35133fdd75372400000000000000","merkleRootHash":"0x07c9b34fac79639b4a9c02003af2874d1a83d7e5ff4dc5dc7700b71aebbd60b5"},{"version":"0x0080f82f","timestamp":"0xea06aa66","nBits":"0x07936019","nonce":"0x64c0a055","previousBlockHash":"0x2263ae472b80591e07f7bcc22483cb7f09abe5c4f64e7735fe8cce6200000000","merkleRootHash":"0xcb45904c4d60889b11a35d123bc120e308a664bee64ee0a0caf786fc792a3815"},{"version":"0x00e09123","timestamp":"0xe309aa66","nBits":"0x07936019","nonce":"0x54b54ac9","previousBlockHash":"0x3dd4277dfa6ded8b6e0b237d3b5d3c287cfaa6d819c707130f00000000000000","merkleRootHash":"0x04ce7d7842d6b8dd6cbe7424234c78d82a58ee1e0abf7e99e1c561a3a28d87d2"},{"version":"0x00004020","timestamp":"0xac0baa66","nBits":"0x07936019","nonce":"0x9b8282fd","previousBlockHash":"0xcd829f095b13b08d0910f68ceff62cd2208421746ecce8675600000000000000","merkleRootHash":"0xa10efc740c3b229d9b1250f85c6ef37fc57ceba1230f5af691928b9d6901b27a"},{"version":"0x00e0e623","timestamp":"0x730daa66","nBits":"0x07936019","nonce":"0x26fc9246","previousBlockHash":"0x1ca766c9eadd397bb84fbe8ea9743f1d79dfc3c0682ff33d3000000000000000","merkleRootHash":"0xbc27c16301c02aaef48e263e272e01a4747cac058d0a00cdb2cdc4831895a270"},{"version":"0x00000020","timestamp":"0x2412aa66","nBits":"0xffff001d","nonce":"0x804f396c","previousBlockHash":"0xb96f0dd001328f5ca4ccdc4e20b4e53cade4036b3cf04b141c00000000000000","merkleRootHash":"0x61d1a424e70c63517bac44df5335e2699da160e19de8a74c57c790fa25e5bdc7"},{"version":"0x0040d326","timestamp":"0x5e13aa66","nBits":"0x07936019","nonce":"0x64889e10","previousBlockHash":"0xea72c5b806affcfa3eb7282e3985d9d0597df43505e9efd07612475b00000000","merkleRootHash":"0x56024edaf054ffa5f14eca45b32f2e68b76ddc000e5f075188aab7621c2f6c01"},{"version":"0x00000020","timestamp":"0x1d18aa66","nBits":"0xffff001d","nonce":"0x1244630b","previousBlockHash":"0x2b0ba2c3e242c40ff8d927f4c183eb600cac17f1b658534a2c00000000000000","merkleRootHash":"0x11b53e5a4478a7cfc62d4bb4467340ec9e616d3baade95a22c29e96f2c021c32"},{"version":"0x0080ad25","timestamp":"0x7f1aaa66","nBits":"0x07936019","nonce":"0x19d54a0a","previousBlockHash":"0x2f3509cc3830c6b6316a901b680eaf34ce83f8ea2b51cce8b917010000000000","merkleRootHash":"0xa4f7404c27c0933ce690f46022020822f8d7a2597655181147457d34d6165036"},{"version":"0x00808f29","timestamp":"0xc31daa66","nBits":"0x07936019","nonce":"0x50bcdfcb","previousBlockHash":"0x9c022d0ba3e136998f558e240536ea5e8907dc6a33a6060b0200000000000000","merkleRootHash":"0x29bad4ce4b2057be2f4ad04ba656440d0fac62e45b68825f13ddaeadd57b3199"},{"version":"0x0000c525","timestamp":"0xc91daa66","nBits":"0x07936019","nonce":"0x1b687d03","previousBlockHash":"0x6993e8cf9c72d3b263ee911dd3d362e8c765197c1636b8854a00000000000000","merkleRootHash":"0x04568d51fb2e4ccac3b8fecf9cf30965859cf21f393c2fd9dae5a5a9e298e70d"},{"version":"0x00000020","timestamp":"0x0724aa66","nBits":"0xffff001d","nonce":"0xf39c4d06","previousBlockHash":"0x9b8e8e839f8928a51c7c153dc400f140590e91aa0a9e0b4f4a00000000000000","merkleRootHash":"0xa5c4726cc13c76ab4b7ab68e9107eb05ff8a82a4805ab54fbe7f6511b97ca4c4"},{"version":"0x00000020","timestamp":"0xb828aa66","nBits":"0xffff001d","nonce":"0x358bc304","previousBlockHash":"0x750838e8e69e4ec4a38d7f62f9b9373d2996ba55048d03d34935947600000000","merkleRootHash":"0x6b82991c7ab77ec0812fb7d69fb01dd9d0cc16df2bb0f2ad61fdc6342ade18f7"},{"version":"0x0000c020","timestamp":"0x6228aa66","nBits":"0x07936019","nonce":"0xa8d17913","previousBlockHash":"0x69689fa7c0145fc44fc0c96ab4fd619b479531aa1809afb503d7de0500000000","merkleRootHash":"0x954d1d7aa6a36bd532b46a0b553e057c13475e5b3bb810a45fc001c91977e0e2"},{"version":"0x00000020","timestamp":"0x172daa66","nBits":"0xffff001d","nonce":"0xec3d62f0","previousBlockHash":"0x9167049761c5e47cef2abfb3edbbe7eb2d863575157560071200000000000000","merkleRootHash":"0xd4fbeddeed26f766b19e979bf3b813ea841731aa803551d8e39afc179dc092da"},{"version":"0x00000020","timestamp":"0xcf31aa66","nBits":"0xffff001d","nonce":"0x0242acb0","previousBlockHash":"0xfd5238e41fd0b42e54009957f02b8d9b66aeef726b843cd9a1d937ac00000000","merkleRootHash":"0x69e4fd6424bfb283c75b74a5e1404dc4447a70ed102e15a6588954d33282311d"},{"version":"0x00008020","timestamp":"0xdd34aa66","nBits":"0x07936019","nonce":"0xa018523e","previousBlockHash":"0x29101aabd8d5b4a05d73088f33960aab7c506ffc819a4518d282238500000000","merkleRootHash":"0x7b52a6ef5fd6ac2a52106ba9f697fdb823322490c1307394fcc4ce75f27938e8"},{"version":"0x00000020","timestamp":"0x9239aa66","nBits":"0xffff001d","nonce":"0x006c236e","previousBlockHash":"0xdb747006ac002b3314fa28e89e5e130353b403b4ce09e03d3800000000000000","merkleRootHash":"0x824d812ec6c572f2673e91b02b195a62e1d839385e87b9b3bb46bdf6765853f6"},{"version":"0x00000020","timestamp":"0x453eaa66","nBits":"0xffff001d","nonce":"0xab8dd220","previousBlockHash":"0xed61d8e1affdfae8827adfb94b6a73d8d5a4e32af21bdc72eb9c556b00000000","merkleRootHash":"0xed001bd667d19a5c09968e3100d9a11510eb6ca2cc85ca16140f852e114c233e"},{"version":"0x00000020","timestamp":"0xf642aa66","nBits":"0xffff001d","nonce":"0x87163316","previousBlockHash":"0xeade1b51d5eefff4b900f31a627e5272a1b3de19a261820030b32c6f00000000","merkleRootHash":"0xc926d4503d1bc211c568327acf5d9bc5836e483ec34103f1ad678189b973edd7"},{"version":"0x00004020","timestamp":"0xe045aa66","nBits":"0x07936019","nonce":"0x0f5ab8bf","previousBlockHash":"0x6e1d01d6bea4bb4202d51c03d5ed27061b588ae9bb10cef04486412500000000","merkleRootHash":"0x5c1987bf40301e06dd2af14ff18f3bd11c1fe659e1fba1c4d04341119ab61eb8"},{"version":"0x0040c022","timestamp":"0xf549aa66","nBits":"0x07936019","nonce":"0x4bf4d8b9","previousBlockHash":"0x89704f9c92c687faa90944b30b456a761e27fbc9091d11960c00000000000000","merkleRootHash":"0x5cae7bef05b7bb86eae25dc9bc95cddab8ed1bde28c6c23047b231738a302b4e"},{"version":"0x00806d29","timestamp":"0x984aaa66","nBits":"0x07936019","nonce":"0x80b89be5","previousBlockHash":"0xf1994389fb1493244688b1c03d47f077e6d5e43ab8cd95632600000000000000","merkleRootHash":"0x8b926462eb4beee9c31ef6d0033b5b2b192d56f6277dd67e52c3f19cfc20f783"},{"version":"0x00000020","timestamp":"0xca4caa66","nBits":"0x07936019","nonce":"0x34cfc080","previousBlockHash":"0x15fa046cecb94e68d91a1c9410d3a220c34a738121b56f172700000000000000","merkleRootHash":"0x36a1af20a2d5bd8c81ddd4b1444f14b28c9c3d049fb2ae6280b0b1ebf19aca64"},{"version":"0x00000120","timestamp":"0x0c4eaa66","nBits":"0x07936019","nonce":"0x81f407ce","previousBlockHash":"0xb5536d26f7c984fb56f3df889b6bec66bd7a16b0497175b14400000000000000","merkleRootHash":"0x4f6e38d8b663fb5a0dcca8f45931a1a99ee30ae38c5a001db1982a622a94c138"},{"version":"0x0020db2b","timestamp":"0xe74eaa66","nBits":"0x07936019","nonce":"0x5078e265","previousBlockHash":"0x153698d7554aa60897210d60ce19e70a036cc6412197205d4800000000000000","merkleRootHash":"0x4c7d4e47408bbf7e889aee13c37ae3e66aaa5af0846f5ab5e094c39d71af2ea7"},{"version":"0x00000020","timestamp":"0x9853aa66","nBits":"0xffff001d","nonce":"0x31b0d570","previousBlockHash":"0xd2ca2fd8bbb3c2f2751deb1815ba3f9da1ed810050c7ed913a00000000000000","merkleRootHash":"0x154151898ef7b2582380c75e96fe84ebd328ce62bea9c9f7e192a73de09018b4"},{"version":"0x00000020","timestamp":"0x4958aa66","nBits":"0xffff001d","nonce":"0x221dd83b","previousBlockHash":"0x3a929b9a0dd63f2343aab868ee48840a055e598e92bac0325ec3811b00000000","merkleRootHash":"0x86b2a4113375761fbee3a5437677e943b8d33ac3da6833f489fc59e73a57444f"},{"version":"0x00c0802f","timestamp":"0x8b54aa66","nBits":"0x07936019","nonce":"0x18a86e7f","previousBlockHash":"0xf217492dd5777e20afacefd2e03c7fb9b406061ecca7cf5ffd31810000000000","merkleRootHash":"0x6fd6347d2f865ee72b93bde4d74010aef3c92214b7d5edf8a70b7f0bb1161aa1"},{"version":"0x00000020","timestamp":"0x3c59aa66","nBits":"0xffff001d","nonce":"0xc6f23b1d","previousBlockHash":"0x3dc94b6585721eb1781ebbbcf980524c6b5909c9680fc56b1500000000000000","merkleRootHash":"0xd4fea2fd3a53f3cad8a01101e6a07910028ba8e679c1811f34be5720d7da8675"},{"version":"0x0000c020","timestamp":"0xba57aa66","nBits":"0x07936019","nonce":"0x48646efe","previousBlockHash":"0x4c9c64f820a3eb7158029d749d4a5856a5c499babc09fdb166cfa56500000000","merkleRootHash":"0x34b9cf3575c18d3ecb5a66816eb3a7f358d678777b9d6e50c3fb849385048ee2"},{"version":"0x00400a26","timestamp":"0x1e58aa66","nBits":"0x07936019","nonce":"0x7368bc6b","previousBlockHash":"0x494b451363ebbb659e5837617c465cab0e761370693e5e3a4300000000000000","merkleRootHash":"0x010565700b4e6b64b4ac44ff3b2d0538eb80dbdd6f8a6a48cd36f4f67560c7c7"},{"version":"0x00000020","timestamp":"0xcf5caa66","nBits":"0xffff001d","nonce":"0x4cc48f1c","previousBlockHash":"0x714e1cb44bdb0433d7ab886165ceab63c6d5fce33f4804820100000000000000","merkleRootHash":"0x63b336d77c33f0799b5d92713886fabc7f19da38942993ed34b39a28ea5bd40d"},{"version":"0x00008020","timestamp":"0x1859aa66","nBits":"0x07936019","nonce":"0x39e3983a","previousBlockHash":"0xbf092459b4fb4b13762eb9e446663afa962d0bfa70207ae93c99d69c00000000","merkleRootHash":"0x83f6c5fdfd4080bce9ae35683a1ceab9e507ab24dc9500998f8eb4dbffc3d7e9"},{"version":"0x0060ea29","timestamp":"0x6859aa66","nBits":"0x07936019","nonce":"0x32995fba","previousBlockHash":"0x75314d945f99aecdeedfe41a15cea7b7db70c9088582a8cc1f00000000000000","merkleRootHash":"0xb769145b7fe831544f5b2fc8158e12ae7c552df976ad7d323afbb697d2a0d15f"},{"version":"0x00805e24","timestamp":"0x275caa66","nBits":"0x07936019","nonce":"0x3f6d5676","previousBlockHash":"0x480228c8eeaa9acca878adbb4860ae6c6f1ac2a89bbdfbfe3800000000000000","merkleRootHash":"0x0a17bbd016447594a9d54c84c7d39dc52678a689e4d34dd5907437b14f33efb8"},{"version":"0x00000020","timestamp":"0xd860aa66","nBits":"0xffff001d","nonce":"0x0fe06805","previousBlockHash":"0xd27cbd33dca646ef0ee12fe430c10472fcfb4c94dd7238530900000000000000","merkleRootHash":"0xb66997d0be48cf9525549ed9ad1e98746e8c57ee6a361a2011726e2557e7ed03"},{"version":"0x00e02a27","timestamp":"0x975eaa66","nBits":"0x07936019","nonce":"0x1a030a2a","previousBlockHash":"0xefe079ffa47611505eafc74b5ac99016b7e84786eef0b663b604b4a600000000","merkleRootHash":"0xcc1f7be5da2ffd8fefdfec75f8d07fc76aeaa1ea941db0ef6a3ffe28edb9860c"},{"version":"0x00000020","timestamp":"0x4863aa66","nBits":"0xffff001d","nonce":"0xc0db7b02","previousBlockHash":"0x800173e1f499271c012b7615821bf43f12885d509735018a0b00000000000000","merkleRootHash":"0x346bd738d3bca9bad8136c144d4e2978457a912a48bd9cd8998a0e7031593de5"},{"version":"0x00208f2a","timestamp":"0x0760aa66","nBits":"0x07936019","nonce":"0x2ca82862","previousBlockHash":"0xe886da68d62d8a59e4a1880ad3a4ab87a4e2d07d1e92c26019d7fb0900000000","merkleRootHash":"0x36bbfeb29cfe7de7bd4fe191012ded6f0f8a612d3ed2f52d6ed277cea16d1626"},{"version":"0x0080392d","timestamp":"0x7562aa66","nBits":"0x07936019","nonce":"0x48bd2a7c","previousBlockHash":"0xa00c96f89239bd653528f1fe03a3d4ee973952c3fe6173db0700000000000000","merkleRootHash":"0x27c2d3e200b6f1b62c5e07f81f74906c4785f28b2da609962a4f7ae17426118d"},{"version":"0x00a04721","timestamp":"0xab62aa66","nBits":"0x07936019","nonce":"0x59dc6851","previousBlockHash":"0x09a1ef0d7383492308a38a1720ba8aefdf333321e2f18c445000000000000000","merkleRootHash":"0x6d3292fb3ee3200c2e41a57b13af90cc4bd9074f42e4d6ac069ad90596a88343"},{"version":"0x00202328","timestamp":"0xdd64aa66","nBits":"0x07936019","nonce":"0x49bcd829","previousBlockHash":"0xa6c864cb6e49fc6cc8bd91ea08f677c542816f7da198d8ee2900000000000000","merkleRootHash":"0x5363e58d9c1ce585a3048b49950b4f9620885e89a18606eafb71b94b257caeb9"},{"version":"0x0000c020","timestamp":"0x0d65aa66","nBits":"0x07936019","nonce":"0x0d042fdf","previousBlockHash":"0xe67636aaf536391036a2feda2dd58421033ae3121dd05a580a00000000000000","merkleRootHash":"0xe3878b54493c0804e68393174dd5c2d1712a3c8f03a42cee124474170a77ddb2"},{"version":"0x0080a421","timestamp":"0x6069aa66","nBits":"0x07936019","nonce":"0x5f11422f","previousBlockHash":"0x60e68793815e43c234d37b5148090ed08415b6e5dceb9a2a4500000000000000","merkleRootHash":"0xab389e705b14c6a611217249827545bd6d3b282d1118e3dcc42b11d97ce9e114"},{"version":"0x00000020","timestamp":"0x1b6eaa66","nBits":"0xffff001d","nonce":"0x3a318dea","previousBlockHash":"0xbe005b797b8284f4ffb1c1ae8acea1fbcca93d8886a128635200000000000000","merkleRootHash":"0x66c0fd077436c8169c81fe0ef3a89b3dfe133bdb4c6f050b648ef202a9a587f8"},{"version":"0x00000020","timestamp":"0xcc72aa66","nBits":"0xffff001d","nonce":"0x91680210","previousBlockHash":"0x44b326482f73bf3a09e4b8771ab344ddfbcf858b18e3efb107ea18bd00000000","merkleRootHash":"0xf0b021d9266623254b45f07ace96ab4c0c772524c9ad69dcd3cb1a50dcbf8f00"},{"version":"0x00e0532d","timestamp":"0x7074aa66","nBits":"0x07936019","nonce":"0x65045870","previousBlockHash":"0x804ed655685f5607d201cbd9b674a3a7d9491311869e020b7e722f0900000000","merkleRootHash":"0x1db7c7356231157e03c024aad07ab72a0e01d3040715c337dad9d3394afffedd"},{"version":"0x00000020","timestamp":"0x2179aa66","nBits":"0xffff001d","nonce":"0xe9633100","previousBlockHash":"0x15576dc049c7edbbd078d25b545d90d7ff229a29c14689fa4c00000000000000","merkleRootHash":"0x77460b6e72d4661ac03c19f1fdc574f1eef109c3d7252faa6a67f786ab1cff30"},{"version":"0x00002225","timestamp":"0xc674aa66","nBits":"0x07936019","nonce":"0x1ea89589","previousBlockHash":"0x97d53ce85481788831fa0b8033ccaef445008f94da98d782971e742b00000000","merkleRootHash":"0x6446a9efc052530c273998cdf5c869be0edc6b3e54a4490a57ece703dd599569"},{"version":"0x0060a526","timestamp":"0x3e75aa66","nBits":"0x07936019","nonce":"0x3f2138bf","previousBlockHash":"0x37e7e9274dbe39bb553836a43ca198b24066a32a25a887103200000000000000","merkleRootHash":"0x8549a9cc3782d88489a4b69b10244909d33a2fd96c23258509ca24cce27fba6e"},{"version":"0x00000020","timestamp":"0xef79aa66","nBits":"0xffff001d","nonce":"0x35a19750","previousBlockHash":"0x687c623b9f14774d6d84f53829b1fcfed3ec03dee3448e640900000000000000","merkleRootHash":"0x51c84e43621d2ba2431642e492ad4b820b4484730557b1068427fd246197cdf5"},{"version":"0x00000020","timestamp":"0xa27eaa66","nBits":"0xffff001d","nonce":"0xccff143c","previousBlockHash":"0xfaaf75e494f3062da69f166210cf89abc01638972f546eae2626e5b500000000","merkleRootHash":"0x6bdd003024dfe8a49bf93587b5d5b660b6b1b4385f59e5b097b1fc2ee0b320ea"},{"version":"0x00000020","timestamp":"0x7881aa66","nBits":"0x07936019","nonce":"0x0e065937","previousBlockHash":"0x10ff6fa165848492d0dda736766a5532112c0b65a900297100b2e7ca00000000","merkleRootHash":"0x392ce84fb2e9f342f07949ad6ad00f460f716acff87424ec2935c8c359af23fd"},{"version":"0x00000020","timestamp":"0x2986aa66","nBits":"0xffff001d","nonce":"0x80cc0900","previousBlockHash":"0x3a25243ca02f3ea4aa03bf5234e935ac4085e5e3996817054800000000000000","merkleRootHash":"0x83ee6d6487fd4ae4c70a78661d979a691e3b98f247beb0b40828bbd941dc8d02"},{"version":"0x00607129","timestamp":"0x4886aa66","nBits":"0x07936019","nonce":"0x55dc966f","previousBlockHash":"0x145208c2362a6ded33db85957a1ef455d3ddb1a0a38ccbfdf749b19800000000","merkleRootHash":"0x4613169031bc9f7b3888fcb9315e8044a7286276df55eb791c3d7ae07885d8f2"},{"version":"0x00000020","timestamp":"0xff8aaa66","nBits":"0xffff001d","nonce":"0xb5622d18","previousBlockHash":"0xdc5c8a78bed21e1e84da42f317aa8d050ca0455380a875900400000000000000","merkleRootHash":"0x6767d59a465d579d536aa049bef45200e516bdfb3901658d302e297059f97aa3"},{"version":"0x00000020","timestamp":"0xb88faa66","nBits":"0xffff001d","nonce":"0xeb5065d8","previousBlockHash":"0x4717fc422acc5b65581b42ccd7f809537635e6c0b97ea3d1f1c2b79000000000","merkleRootHash":"0xa162e0370beedb5a3ddd68358462a5c27c172706b0b4ccae2626567b204c5e26"},{"version":"0x00000020","timestamp":"0x6c94aa66","nBits":"0xffff001d","nonce":"0x2b608422","previousBlockHash":"0x281c21b7f19f4752a7b59da7cc0ad55e211627c1cd43325feeb5f12700000000","merkleRootHash":"0x7f0ab1104f9a491bd43715892b7299bd78fdc2514d781c1d3abc9c0566860dfd"},{"version":"0x00000020","timestamp":"0x2799aa66","nBits":"0xffff001d","nonce":"0x6d9fd5cd","previousBlockHash":"0x4cc42914d6aa95ae453af83b2ec32fb00310ab19c8e58175ed999a1900000000","merkleRootHash":"0x42c4578b507f40157448ac8d35dafa6da51525b3169f6570402b65084e473db1"},{"version":"0x00c0852c","timestamp":"0xba99aa66","nBits":"0x07936019","nonce":"0x1ea4f550","previousBlockHash":"0x65b5b16d165d564aae2d050d76ec2e081f68942082082c1e47946eca00000000","merkleRootHash":"0xf3f221e5bb029f31a4653d357c3e862cbee525ad17dd53a3e93e7c68e38b45a4"},{"version":"0x00000020","timestamp":"0x759eaa66","nBits":"0xffff001d","nonce":"0xc01344f8","previousBlockHash":"0xf6299810524c8a99c5d33546f42373085787158efedf5f346000000000000000","merkleRootHash":"0xcea2fbc637aacd6415d33f56bc6be088fe3406f293766fbf9b85529274aa3ec9"},{"version":"0x0000a92a","timestamp":"0xaf9faa66","nBits":"0x07936019","nonce":"0x686d88d0","previousBlockHash":"0x51b99c75bd6f73626e473a4ead2c82e07b2376852a4cd7ef304e36fd00000000","merkleRootHash":"0xe9abd57dc5c6aeeaec5126e28e86ad4a53aa3f4e744925f0fc505bd3200f4573"},{"version":"0x0000282d","timestamp":"0x2ba4aa66","nBits":"0x07936019","nonce":"0x7a102d5b","previousBlockHash":"0xcd6a02ff109f57ac5d0482f5d7fc52fdb0d8d7951d7765bb1d00000000000000","merkleRootHash":"0x5fa6681c198a9505c0d03f5f671f39d4fa6fae5e8ea6f2f9d3cc66b9627715d0"},{"version":"0x00000020","timestamp":"0xe6a8aa66","nBits":"0xffff001d","nonce":"0x4abc8c8c","previousBlockHash":"0xe6321b6563df166cfb074e7670f2d308e12b9a0cb66f38770700000000000000","merkleRootHash":"0x95e23fbfc54b71d198198f1de5bf477336f2986097f0b0751a03f383d7c0d10d"},{"version":"0x00000020","timestamp":"0x9eadaa66","nBits":"0xffff001d","nonce":"0x968d32f2","previousBlockHash":"0x7da07ecc796af7fc50b66929a768591dd89255bebe844fd81db76f9c00000000","merkleRootHash":"0x03cbfb1fbdad82a947afa9d06927e134d4bb59d9155dfc7307ff710220d4a9c4"},{"version":"0x00e0cf23","timestamp":"0xfcb0aa66","nBits":"0x07936019","nonce":"0x71149875","previousBlockHash":"0x5307f044ed0a2f08139212b9f2dd58b22b2325117e24a8b37a1c1e0000000000","merkleRootHash":"0x0a9aa7621979fce300d0a6569240bd0191f79617402fa531d00b5c713b3224d1"},{"version":"0x00000020","timestamp":"0xb2b5aa66","nBits":"0xffff001d","nonce":"0x818a94ba","previousBlockHash":"0x9820229ad8c594a52876682430784bc6363e8c15bbeea6841500000000000000","merkleRootHash":"0xcfceac298adf5db7eb9a92ae0ff29aca297b7db5e7a7bfd3738e9d242fac11df"},{"version":"0x00e00120","timestamp":"0x9db8aa66","nBits":"0x07936019","nonce":"0x969502c6","previousBlockHash":"0xf676583f82486375f5eb5c5dfb0d87c4f614296066fea04ab888458700000000","merkleRootHash":"0x5743375e268541eedc6e828e84853e6687cf8af11ce1b41d6e4d87b625cdfe67"},{"version":"0x00a00120","timestamp":"0x40bbaa66","nBits":"0x07936019","nonce":"0x0750d99a","previousBlockHash":"0x46b18de84a18696a981c3173ad5d1f42f7c397133d8fccf44200000000000000","merkleRootHash":"0x0002a0fc8c631af0787e95a4013d4a68208ec0aa0eaeb030433b9a23c127f138"},{"version":"0x00c00020","timestamp":"0xf1beaa66","nBits":"0x07936019","nonce":"0x0924629d","previousBlockHash":"0x8c7b6dadfacea35be262dc37b7ef564b3ea236136f108e812300000000000000","merkleRootHash":"0x04186d24c5c2763678d388fc4dbf499c335452b0596e44b94ac98ed2d989f6cd"},{"version":"0x00400020","timestamp":"0xa6c3aa66","nBits":"0xffff001d","nonce":"0x4c8b83a9","previousBlockHash":"0x4bdc2128410a4a791777f9883589dbed31d488b940f3b0e34d00000000000000","merkleRootHash":"0xfeb104149977081de42d05d0e3a7b3c39c3bb4bf0b2f021fe03a21e67f306352"},{"version":"0x00200120","timestamp":"0x44c7aa66","nBits":"0x07936019","nonce":"0x67b4439e","previousBlockHash":"0x00229a7caa80d62a21736f534112e239b06dcda6bfb2d16815b7220000000000","merkleRootHash":"0xa2dcff1e640d6a24cfb64cb12ae1158ddb624542bc17bd2f8c051d59eab72ce9"},{"version":"0x00e00020","timestamp":"0x8dc9aa66","nBits":"0x07936019","nonce":"0x46167c11","previousBlockHash":"0x9ba9c49141f1259d69d1c0c77439eda7a993152554f4649d2100000000000000","merkleRootHash":"0xac1bdab3ba46854c92558849d3224356ef6b5d68df1c1b23039e2b7d18e2cd8c"},{"version":"0x00800d2a","timestamp":"0xa1cbaa66","nBits":"0x07936019","nonce":"0x464ce1bf","previousBlockHash":"0x2f188486fc94a506a813048ce026c041c4da0e54b9aed2f53100000000000000","merkleRootHash":"0x3bc8da602e63272a840e2579f3cd5081e547a628a053a8060aea311403123938"},{"version":"0x00000020","timestamp":"0x54d0aa66","nBits":"0xffff001d","nonce":"0xe8b1e6ad","previousBlockHash":"0xaf10a98b12d2ba6aa5c643d66b97713a9aabd6b0f2ecc7c64800000000000000","merkleRootHash":"0xba8156a6adb42db6a96704fd7474d7a8436063a0ba636d579ce1e0a7b76ef4f7"},{"version":"0x00a00020","timestamp":"0x09d5aa66","nBits":"0xffff001d","nonce":"0x9ffca6c3","previousBlockHash":"0xa7bcebc5c7ef71e245e226e5d678b618f6b49aa8354aabf4abe9834700000000","merkleRootHash":"0xe931f9f14104e740ae908ebda14abfc1c5c6d20e9bff1cafd09552ccde346977"},{"version":"0x00000020","timestamp":"0xbfd9aa66","nBits":"0xffff001d","nonce":"0x0e914c5d","previousBlockHash":"0xa0293826eefbd8301722a163d0596b3133ff93af519791afcd47000000000000","merkleRootHash":"0xd9d14edba8fba357de687f062a41a87b6e1d0caa65751dd1c246660821b7f723"},{"version":"0x00807c2b","timestamp":"0x84daaa66","nBits":"0x07936019","nonce":"0x79147e52","previousBlockHash":"0x470846037a5503ec48fef0101bcd989ffdee38c6436ae2f9a9d1327300000000","merkleRootHash":"0x14787c15cf3a66491fe0e5316d0e2ec9cc8e5e0f5ece61c8cb59c8bfacb97e6f"},{"version":"0x00e00120","timestamp":"0x35dbaa66","nBits":"0x07936019","nonce":"0xb4db7a2b","previousBlockHash":"0xa766ed2b0036feab65f6ccec6b9c4c4f0221bd0a615c13275800000000000000","merkleRootHash":"0x1a0b1cb16cf01df30a783b789a497fc04755d942a914c767749217df989a2da0"},{"version":"0x00802024","timestamp":"0xd8ddaa66","nBits":"0x07936019","nonce":"0x01842291","previousBlockHash":"0xcba026cd9c6426fb6d8f700cf54785ae694b6804bed3476c2b00000000000000","merkleRootHash":"0x755985df3490d0652924caf02bb022c2563af0d4a9114e8b888fc21daf7442c3"},{"version":"0x0040012d","timestamp":"0xa4deaa66","nBits":"0x07936019","nonce":"0x0e892467","previousBlockHash":"0xcd38827bf4720727d90fcb09c4e72e024d1f5d544f9db3482d00000000000000","merkleRootHash":"0xcf7c6e4368c2e308fbdf6a268adff8aa33cc5468f5f97689abca45308c5bfe3b"},{"version":"0x00200120","timestamp":"0x10e2aa66","nBits":"0x07936019","nonce":"0x8029f93e","previousBlockHash":"0x85844e1039e0e33dd647c6080f63e2bfcddf1e859c7b774a2c00000000000000","merkleRootHash":"0xf99767e4234f2b9fee311935d497c2c785f1f7a019d8deb9042135d151027e56"},{"version":"0x00a02025","timestamp":"0xbae2aa66","nBits":"0x07936019","nonce":"0x6af02ae1","previousBlockHash":"0xc767cf8c8ef5051e761d775c18fa9819aeaa56b660092de91e00000000000000","merkleRootHash":"0x2442364ba88d89aefe9132accab534b11087be9d5bcbd336077e6ff9f558080c"},{"version":"0x00c0ae21","timestamp":"0x0fe6aa66","nBits":"0x07936019","nonce":"0x36686231","previousBlockHash":"0x7fed3ffd9e57efa9f26c16f0e2e3d8296f4c340a47f245161200000000000000","merkleRootHash":"0xd50a53df42cd103202dd10c1b737b625f1e8b8f8ad68675eff6c9409f741da28"},{"version":"0x0080ee29","timestamp":"0x39e8aa66","nBits":"0x07936019","nonce":"0x2f043442","previousBlockHash":"0x6d97d3a2f2f74f94f8f2bbbfab6376de520728a5ae75de510b00000000000000","merkleRootHash":"0xff15609e3e3f920c253514bbc560e84221d1ca93ebf5405dc99d2e5d5474cb1f"},{"version":"0x00c01328","timestamp":"0x90eaaa66","nBits":"0x07936019","nonce":"0x45509537","previousBlockHash":"0x438e9533a869d29f4832f7c324f1b5a843075924cbaf09640200000000000000","merkleRootHash":"0xab5c2bd45ffc23df4867c675b38ed9345b558fcd76c920e405d923a28e75580e"},{"version":"0x0000632a","timestamp":"0xfeeaaa66","nBits":"0x07936019","nonce":"0x5c4cccf6","previousBlockHash":"0xb5aa5d244ae1f12beda8081d01d954fcb0f0724fe679e5280a00000000000000","merkleRootHash":"0x33d05d1124f49b6d2ef270d5116a779036e26eb52a1101c1f532edd63fa5cd23"},{"version":"0x00600120","timestamp":"0x5bedaa66","nBits":"0x07936019","nonce":"0x3bb5008d","previousBlockHash":"0xd386123c7157e16bedad6a1851dbdc4a18f553d9f5fdfe532300000000000000","merkleRootHash":"0xec429d936c2f0f82a81dc8814170c155258d8cdbd7376837e278bfb35cc52ea1"},{"version":"0x00000020","timestamp":"0x3ceeaa66","nBits":"0x07936019","nonce":"0xe48695b0","previousBlockHash":"0x4b381f2cf2a127434d85d9f683b7dd1c8d7c44f0160d94562000000000000000","merkleRootHash":"0xbd8bf70e643f4a64cbffd983ff5ea24b865406fe2618487f7cc9ed9de02941a5"},{"version":"0x00800020","timestamp":"0x3befaa66","nBits":"0x07936019","nonce":"0x6f4d1988","previousBlockHash":"0x3254dc1e4c11f7f74de1c11d3f1da2501b2ee0d8b2d32b273400000000000000","merkleRootHash":"0x4cd52ef5d80402379beb5e26baa132c0b02951bc94a02421e4eeffc9940384ab"},{"version":"0x00807d2c","timestamp":"0xefefaa66","nBits":"0x07936019","nonce":"0x677cb39f","previousBlockHash":"0x1a25c66e2ab8050a06f492c508f090401ad0b84a44b504fb3000000000000000","merkleRootHash":"0x58a53e05dc45209a103682e66ce9f07847a406a35a02d1a0cb785bc9299d5706"},{"version":"0x00e00120","timestamp":"0x2bf0aa66","nBits":"0x07936019","nonce":"0x3167cfc3","previousBlockHash":"0x68591ae98e48f19ff889392360a44db22a342b09806866a45b00000000000000","merkleRootHash":"0x6560a13033b6b59e4c9b251603dbfe5c4d0f226cc6692b44ce963584a4d09a28"},{"version":"0x00000020","timestamp":"0xddf4aa66","nBits":"0xffff001d","nonce":"0x4ecd3bdc","previousBlockHash":"0xaaf04d336549e57aabcbcdb17d9cd3d0875ee043d95500f82600000000000000","merkleRootHash":"0x3e29458e267f4f541aefcfc7757a3c15432e52f2e5ba258076525081d9e5d7bb"},{"version":"0x00000020","timestamp":"0x76f5aa66","nBits":"0x07936019","nonce":"0x6ec0f6b1","previousBlockHash":"0x9cdee1bb7875ee5d06c7f636cf9629d625e17f10e84c7bd8c3751c7b00000000","merkleRootHash":"0xcba8471241ce03b27cde4f81374cae919a5f91ec73f95fb9112ee3198e734eab"},{"version":"0x00000020","timestamp":"0x28faaa66","nBits":"0xffff001d","nonce":"0x0adae2f1","previousBlockHash":"0x3bc3d1a6e4e5b2889e2f53d29f203331bbc4e01c1caa17da5400000000000000","merkleRootHash":"0x7ad63e19fc4d2076dcf5238c5981af1818990d64a797ca97e397be4594493fb0"},{"version":"0x00c0b525","timestamp":"0xd2fbaa66","nBits":"0x07936019","nonce":"0x36491a79","previousBlockHash":"0xee13183f043a591c8a2169863ffcd221232638916bde6e060150fb7d00000000","merkleRootHash":"0x4002576e4023590deedee5e9197ea273e2bdc57764e698a40576a374425a73df"},{"version":"0x00000020","timestamp":"0x8600ab66","nBits":"0xffff001d","nonce":"0x6adf1297","previousBlockHash":"0x593d7deb2641bc8a05f417d447dd83c2ee37ce74248f60745100000000000000","merkleRootHash":"0xea155321f648d5d56e16c984185809b013c79c152c940bce75c225299a47ac7e"},{"version":"0x0000f121","timestamp":"0x0d02ab66","nBits":"0x07936019","nonce":"0x776822f0","previousBlockHash":"0xc1a211d0fe0c6e04d7a15bc6889b7412496c1c3ae809e97cd5597b7100000000","merkleRootHash":"0x2b2d436892751c6253217fb9c4f973a629f1f0a0413ad5ac82f5f53c2d2288a1"},{"version":"0x00201722","timestamp":"0x7f03ab66","nBits":"0x07936019","nonce":"0x15b55fa1","previousBlockHash":"0xa545daecd4759cdef93d8ada253e7cbbae95a861403c6d0e3c00000000000000","merkleRootHash":"0xe85267a0164d8a722060cba9189b73d3077d7f3b1dd97108b5c53470a6e15d5d"},{"version":"0x00600120","timestamp":"0xfd04ab66","nBits":"0x07936019","nonce":"0x4007becb","previousBlockHash":"0x8d3f8ffa2daaf19f83c80320006124136700035fa52ad06b1800000000000000","merkleRootHash":"0x6b6aef847bf9b05c3d8afc030ea4d8c49c6af29a09bef68e5eb8ce195afb4a74"},{"version":"0x00c0d625","timestamp":"0x3107ab66","nBits":"0x07936019","nonce":"0x2e405652","previousBlockHash":"0x791daaa700322317ff1f94c15675cf1d3219770e466895f21a00000000000000","merkleRootHash":"0x36a10e5fc3667585de33a557b13dabebf8f513f129b99e598ecf90a526dde435"},{"version":"0x00200120","timestamp":"0x330bab66","nBits":"0x07936019","nonce":"0x94f1ae29","previousBlockHash":"0x0464a8501a20967550869b55d347d25d395721da90743b521300000000000000","merkleRootHash":"0x676c69531c27abd0db5fc62a3958632dddece472f63b5108997a87998e70ff30"},{"version":"0x00c00020","timestamp":"0x140cab66","nBits":"0x07936019","nonce":"0x4fbba714","previousBlockHash":"0x4fa7ba942d376250deb557800778f265328a649f031b398e5300000000000000","merkleRootHash":"0xa62a7a582c6e8e9d6bb943bf570bdb4491d63194741dc35b0f351de8d135e365"},{"version":"0x00a00120","timestamp":"0x9b0cab66","nBits":"0x07936019","nonce":"0xaae7b5ca","previousBlockHash":"0xee34af0855070aeda4b743a8ad61e37d4cf51748a75374a33000000000000000","merkleRootHash":"0xe4b4c5a2102f728e681e77d168df4feb7e35afb7ca26b4e96078f90d383ddad3"},{"version":"0x00204129","timestamp":"0xb50fab66","nBits":"0x07936019","nonce":"0x37750e0f","previousBlockHash":"0x303e64cfc9fea7d505ff75a83cf8ae335be0289b06e1d11c2500000000000000","merkleRootHash":"0xa457744f3c4b70830e3ef665b5999eef41339a8c28b589dc645e06cfe1175057"},{"version":"0x00e0a52f","timestamp":"0x6411ab66","nBits":"0x07936019","nonce":"0x209934bd","previousBlockHash":"0xae015a922db9b0afc9efcb31b8bd3e999796c9d5c0484c0a3600000000000000","merkleRootHash":"0x60134053f18717c0c49c364868b9a8f059cbde616f4e921e7f4ddd01b6c39aa0"},{"version":"0x00800e23","timestamp":"0x5612ab66","nBits":"0x07936019","nonce":"0x5824ac8f","previousBlockHash":"0xa0ad12a93e4b0737b8911c64225d29b710ad9b080fd4323d6000000000000000","merkleRootHash":"0x0382601b4406a61ea8e459f9d7cfaadb32940b6b1ee2bc2d703bc444ac2b0a4a"},{"version":"0x00a0a32c","timestamp":"0x7014ab66","nBits":"0x07936019","nonce":"0x59e4509c","previousBlockHash":"0x437209349153ba70644d7f1ce83ff852b0b8e117bef305af3600000000000000","merkleRootHash":"0xac2fa3a416e0a141b747c7633e999b5dcb4fa4f4572df05ad2c72427453c2b86"},{"version":"0x00200020","timestamp":"0xed15ab66","nBits":"0x07936019","nonce":"0x6aad35a7","previousBlockHash":"0x4ae7bca21489f50f18e5785ef86a8f54da080b734ce5dfa32800000000000000","merkleRootHash":"0x249896c388ef5daf409d5b43407094dc7a4df0f2792b68ce58ff14f786eb295f"},{"version":"0x00c0642d","timestamp":"0xa916ab66","nBits":"0x07936019","nonce":"0x6bf528b7","previousBlockHash":"0x26c93714e1dc853d569759dc859c2a8d1f8e823690e6686e4500000000000000","merkleRootHash":"0xb0cca16c5888951fb3475b7cefd4ed470e27d6af6ff9db9fb5819507ec2d5351"},{"version":"0x00608b24","timestamp":"0xd416ab66","nBits":"0x07936019","nonce":"0x032c84fa","previousBlockHash":"0x90379e6336c42367520d0d11490506627613474d7ade6bb23600000000000000","merkleRootHash":"0x09b9b0380aef98c5a52c28e8e0ae504011e1236e6864061b60c9627e5d76f0ff"},{"version":"0x00000020","timestamp":"0x851bab66","nBits":"0xffff001d","nonce":"0xf0a4291d","previousBlockHash":"0xec3c14e05c5b4dd4ff8c08051b52357969b65c7ca844bc885f00000000000000","merkleRootHash":"0xc7dc37a0abc9cb3383e844c08e1726c8f907c44a31af83aa2894c7622ff04743"},{"version":"0x00000020","timestamp":"0x3620ab66","nBits":"0xffff001d","nonce":"0xe21367b0","previousBlockHash":"0xee07233e8b557daf0335032973e38f808c1e221fefa6a03c580c85bf00000000","merkleRootHash":"0x66e010c49335f0291c8084070068becc36755b7e1a91b08eae2be9c1b0ae0a02"},{"version":"0x00404827","timestamp":"0xc91eab66","nBits":"0x07936019","nonce":"0x50580648","previousBlockHash":"0xde19dcfc54c681254a0d1398440c7f9089bbd59fc266f82c09f93cd000000000","merkleRootHash":"0xf2ee32b7ac96c9131be31870d62c971ba1b7c1eec4a333779355fe2b7962d9ab"},{"version":"0x00000020","timestamp":"0x7a23ab66","nBits":"0xffff001d","nonce":"0xf3863109","previousBlockHash":"0x19f787bb8a387d8a83ce849f946ad9cfd194680b8de341c25100000000000000","merkleRootHash":"0xfb17c202959c17675c2b551cf204670b7089d0302b8a1c0735ddaf867a320500"},{"version":"0x0080812f","timestamp":"0x7e1eab66","nBits":"0x07936019","nonce":"0x676462e9","previousBlockHash":"0x36df6d122a41df627755697ca18c736d4d63804c26a0f68ca04b36a700000000","merkleRootHash":"0x7273a7181a055afef124b779bd5eca4a5ee3ec4f49d4d1d2c09edf0253ae93cd"},{"version":"0x00000020","timestamp":"0x2f23ab66","nBits":"0xffff001d","nonce":"0xcdc5f619","previousBlockHash":"0x80a9bc4b0a7ad5038d3267f93dc0cb18e2749b07fffa86f10d00000000000000","merkleRootHash":"0xd59bcfafcca824bd6b6ddf121b06e997f5d8fa3ec94b127d9bf26ebf559674eb"},{"version":"0x00400120","timestamp":"0x3820ab66","nBits":"0x07936019","nonce":"0x1deed5cb","previousBlockHash":"0x71bf091fd3f22bc166216f53fea75fd8a260e9ccc445471fcd8797cb00000000","merkleRootHash":"0x937cf9ef3b97a0265f25e158cc3de552933470475f53350a45c52297f22f3455"},{"version":"0x0020732e","timestamp":"0xc621ab66","nBits":"0x07936019","nonce":"0x28b12738","previousBlockHash":"0x70a5d578825aa4c684e2b9f2e68cb109f4b6691d38706aa11f00000000000000","merkleRootHash":"0xcf63b832560305b4e082fe0c985947d416176561a378bf57b8ffde80c56cfa94"},{"version":"0x00000020","timestamp":"0x7726ab66","nBits":"0xffff001d","nonce":"0xef952c00","previousBlockHash":"0x3bb092fdb383826473095f1494bfa31f6f9e8594108bfb2e2b00000000000000","merkleRootHash":"0x64fb1933acee598c0b7be3ac07f0b3d4536800184ca949dbd6a935bc6ada062e"},{"version":"0x00000020","timestamp":"0x282bab66","nBits":"0xffff001d","nonce":"0x343eb76e","previousBlockHash":"0x249b5a51c974f0eee84d625bb68e6e96ae6c82de1433966b20d7160500000000","merkleRootHash":"0x89d5d8f6acc26513ebaac8cb1d0bd5da32eea3a3ba62356b79134d62c7fafd30"},{"version":"0x00c00020","timestamp":"0xd627ab66","nBits":"0x07936019","nonce":"0x5814441e","previousBlockHash":"0x2bdb571bd3e585ea05f2ea2b051df56acf81def7f180f1c7e3d9a60d00000000","merkleRootHash":"0xa9d148a5dcc2309933eb3413733811e38f1c2a3f3fb36794936b88baade13576"},{"version":"0x00009c2f","timestamp":"0x2829ab66","nBits":"0x07936019","nonce":"0x68a029ba","previousBlockHash":"0xb4d2638616cddada91763acb07baa8956dc60e6d322edd8a4600000000000000","merkleRootHash":"0xf831f7ef7f7100cc1d88ceb45f994af9e28a5199405cb29ba4b8318057e4c4ef"},{"version":"0x00e04127","timestamp":"0xf42bab66","nBits":"0x07936019","nonce":"0x31e01f52","previousBlockHash":"0xf4c3dcaa1377136e3b3171c3034ca0ff4dda8f2bf9596e955600000000000000","merkleRootHash":"0x9b1d2a379fd879681781ca2591c150ae1d86b93fd235b7f0d5172e545cb38526"},{"version":"0x00a00f2c","timestamp":"0xf32dab66","nBits":"0x07936019","nonce":"0x2ec498f1","previousBlockHash":"0x108e8f0c3aceb6f247fa688135631941e7e1cbb2a010793e0500000000000000","merkleRootHash":"0x242d1de700261c476648977b6bc5f8b4b1da98a6d35a4729957e14d719bd0030"},{"version":"0x00000020","timestamp":"0xa432ab66","nBits":"0xffff001d","nonce":"0xd517941d","previousBlockHash":"0x32d98879e540d62baac017d3d6cbe3f457ac97c74ba570250400000000000000","merkleRootHash":"0xad5e990b4757a9a86d17708e3b2cfffd52239cb52d4c3cebf289282fe30054db"},{"version":"0x00000020","timestamp":"0x5537ab66","nBits":"0xffff001d","nonce":"0x3ab4ca2f","previousBlockHash":"0xe7b9d1789eac3417a849c9f8c83f62bb7850537a5d00a02560fca3a800000000","merkleRootHash":"0xaa4c1ef372a0200d3b81999d465ce2e7f779e4cdc46a58db805477daae7a7bd8"},{"version":"0x00000020","timestamp":"0x063cab66","nBits":"0xffff001d","nonce":"0x88806976","previousBlockHash":"0xaaff00072ab961c3433b0fe28fe760b82e2a6abe3929fac92fd2906700000000","merkleRootHash":"0x8640e561fc56dbe97cd00390d3848cbc311bb58c6a2a404e31d7d6e290f12e3e"},{"version":"0x00000020","timestamp":"0xb740ab66","nBits":"0xffff001d","nonce":"0x71bad805","previousBlockHash":"0x047ea94573eacd3bf0a7aa822cc86f550fd361145b29fd063e87319600000000","merkleRootHash":"0x5c0daa3a2cf44391dd00b32b6fc61d4e9e93569903d0d04d502634eb97461117"},{"version":"0x00a00527","timestamp":"0x5330ab66","nBits":"0x07936019","nonce":"0x72fc1dec","previousBlockHash":"0x30139e155640eaa3069369ab83530cfdfc91af2e463735bb8df7d17200000000","merkleRootHash":"0x7de072e5d15ded913948b6afb0a022be339011b8f3cb8280627fbf1c03aab243"},{"version":"0x00c00f2c","timestamp":"0x6c33ab66","nBits":"0x07936019","nonce":"0x05b12b7d","previousBlockHash":"0x2b13ddf84a3e819e1fa1f7667c0c04731f3ef4fe87da0c844900000000000000","merkleRootHash":"0x0ee15d2791379e200bfb67a727a5e5ac2a54e38324a7749bf3c3d908c3161f56"},{"version":"0x00000020","timestamp":"0x1d38ab66","nBits":"0xffff001d","nonce":"0x8cda5500","previousBlockHash":"0xb31ff32e1152e78c3b97984e29c3e8460c98ab8f19fc1f224f00000000000000","merkleRootHash":"0xb1119e01023d5fdc4809485481a49cb2d73c1f371086a7894276a5ee2d2fc345"},{"version":"0x00000020","timestamp":"0xce3cab66","nBits":"0xffff001d","nonce":"0x1b9c8802","previousBlockHash":"0xc7842930e23b10fcfecda27ff2ff7d3a7ab29230af9d43a555d131ac00000000","merkleRootHash":"0x29301f03b361a4914bac0b5b4d8f3f201c9ae6568e5d6c80c5467a865889b82a"},{"version":"0x00400020","timestamp":"0x1a35ab66","nBits":"0x07936019","nonce":"0xc72d528f","previousBlockHash":"0x24ae2d5302fe86a89d11e57b3f94c1281ad566cf9ba2f44df747794e00000000","merkleRootHash":"0xdcf8194c08f1fb636d5ee53b53640fedab340bb7b65dd94b1919e639c129f3d3"},{"version":"0x00000020","timestamp":"0xcb39ab66","nBits":"0xffff001d","nonce":"0x00d1fe3f","previousBlockHash":"0xbee62b7df831addc3b5041c7b74095eb2d5e2843b187a9845d00000000000000","merkleRootHash":"0x1e7bd802d46c6e96785bf05c5bf32a7160c742d756958cc1c20867edc2bc0788"},{"version":"0x00a09d22","timestamp":"0xb83aab66","nBits":"0x07936019","nonce":"0x31b8660d","previousBlockHash":"0x8b5eef7effd3146310b0629da9d3c372fc7de63daf940e7928703da900000000","merkleRootHash":"0xc8f57d3b780a5c624d4b895924addc8c3dd0a4f9a133c4be1fb409081f96a2d1"},{"version":"0x0020ac21","timestamp":"0x083aab66","nBits":"0x07936019","nonce":"0x7728a771","previousBlockHash":"0x78d29ebf5ed853955a5c74dadecda7d508c4014820b57f0f5800000000000000","merkleRootHash":"0x9643d2ffa5c21559ceddb82ff1865f3eadc945d6ce79b8e5c4146df52b343de5"},{"version":"0x0020422c","timestamp":"0x293aab66","nBits":"0x07936019","nonce":"0x309558fc","previousBlockHash":"0x012f1e10e0d270e11510759e341779617b884ad5cf8a7b735500000000000000","merkleRootHash":"0x0a5519fd00c4a6325b813439c0f33a8854899b6c36228b47c4bc4dd86fca5513"},{"version":"0x00000020","timestamp":"0xda3eab66","nBits":"0xffff001d","nonce":"0x79368a08","previousBlockHash":"0x23dadc82e9482d2fcd16e95950192caf0e5cfe332588e2e72a00000000000000","merkleRootHash":"0x93c568f1022eae35fec8eea96fa41d9024f0ad989f003cca5cabe2f8714064a7"},{"version":"0x0040dd29","timestamp":"0x7e3fab66","nBits":"0x07936019","nonce":"0x57bc13e2","previousBlockHash":"0x15816cfe6f2bc8a8b5e82e7b395b8635af6e6c741f5aa61bba96d83800000000","merkleRootHash":"0x13e13e99ccdd5d84d668fc44681232e52c30bb0ba99754d5148db35d56fa28cb"},{"version":"0x00000020","timestamp":"0x2f44ab66","nBits":"0xffff001d","nonce":"0x0264ac00","previousBlockHash":"0x3c5220ffc769987394856961e45c4997011b3cf6542794682c00000000000000","merkleRootHash":"0x886172a00c81b999963a4c6edf16dae5ad6b189bbfc06b731b7c7c69210f8f54"},{"version":"0x00409a22","timestamp":"0x1e40ab66","nBits":"0x07936019","nonce":"0x2b3c7167","previousBlockHash":"0xcea7294f4fb09c9134ddc0bf129f0bdbbc07f5d4c4ec2e04161c86e200000000","merkleRootHash":"0x032f433eaabb76fa978f350836265eeb8bc14bc8e37a97081b2d604fbd169cc8"},{"version":"0x00400020","timestamp":"0xd444ab66","nBits":"0xffff001d","nonce":"0xba41d743","previousBlockHash":"0x29e6d983fe0d8610556c256d07ec7bc4753e57bdc418917c2900000000000000","merkleRootHash":"0x11009ee072459f12ef2f8a20f333b3cbb3c0516ab3e811300c27e508201b5b1d"},{"version":"0x00400120","timestamp":"0xd246ab66","nBits":"0x07936019","nonce":"0xa9753b0e","previousBlockHash":"0xb3253ce630a36663bfdd60ea1b600cdf32e005b0cfb3c29609a31c0100000000","merkleRootHash":"0x90610c7377575940607016d26e7cc398ad04dd07da246d3eeb359d3a9963c7f2"},{"version":"0x00000020","timestamp":"0x834bab66","nBits":"0xffff001d","nonce":"0x2b338f52","previousBlockHash":"0xc303024c31dab73f8eeac896eaece8ebbf05a7e8c125d98d1d00000000000000","merkleRootHash":"0x51b177e1df54167a32710d8cb7ab6815e9599aa1d314482f3f9d433ccedef9c6"},{"version":"0x00000020","timestamp":"0x3450ab66","nBits":"0xffff001d","nonce":"0xbfd0b62a","previousBlockHash":"0x933cf3dde16322f844d5089a2b873cd23c6988cb73b3a9ff3432ba4600000000","merkleRootHash":"0xdf04a2985b428b9f4f88f514b4015e896450f61113c5a22482b98e542546bd6e"},{"version":"0x00004c2c","timestamp":"0xd84aab66","nBits":"0x07936019","nonce":"0x72c838f6","previousBlockHash":"0x3cf731ffdfad2e49d3b860fe66d1e50802d96e421ad91705a1b54eb700000000","merkleRootHash":"0x2f113e5f783b695916f1b77d0e0ecd98dafe4d030492b1c20f318bec31b34ee7"},{"version":"0x00800020","timestamp":"0xae4cab66","nBits":"0x07936019","nonce":"0xee6e14ca","previousBlockHash":"0xb615e939ad898117c085fb681fe9a6813d4c1d59046fd1f32400000000000000","merkleRootHash":"0x39dde33732132dfab67aeba077d7fa847a42a08d28c628f4d6b11370c8cde488"},{"version":"0x00a06929","timestamp":"0x134fab66","nBits":"0x07936019","nonce":"0x7c413997","previousBlockHash":"0x6e7cc89e421fe48ce2b7d9f2b0a92107b20155c073bd3c651500000000000000","merkleRootHash":"0x33ce21cd0c276ff5c0b7ff7d97df104cc61d0e489a88f9b229d683c0c45cd59b"},{"version":"0x00000020","timestamp":"0xc453ab66","nBits":"0xffff001d","nonce":"0x71975106","previousBlockHash":"0x15314e46125bb4fdb0c373c200f5a1db0228737e01241c9d3a00000000000000","merkleRootHash":"0x19e78f47bde4b8ddb5a65c10c98efc30f725c688c757f032530de1f81bbda878"},{"version":"0x00000020","timestamp":"0x7558ab66","nBits":"0xffff001d","nonce":"0xbdcb830b","previousBlockHash":"0x6413894efb41c53207b3abb19893ea4705fa9ea8224b63fc1474383500000000","merkleRootHash":"0x46f75ea2131ed9f433f5cf2b487a6ef4be51d125709d2882799ae425c271a6a9"},{"version":"0x00000020","timestamp":"0x265dab66","nBits":"0xffff001d","nonce":"0x81552797","previousBlockHash":"0x6d696e0eb4ba88733166a0670019861d9a543fb71273a76a4fd15e0500000000","merkleRootHash":"0x6f4f2728f6e8745f06eb821a7e2d7178ac42d47444168f51cf228866352849d2"},{"version":"0x00000020","timestamp":"0xd761ab66","nBits":"0xffff001d","nonce":"0xc3facc2c","previousBlockHash":"0x5486ea4b64c016597727c20b7678a0f6c51b06db8fa67fad0a6002df00000000","merkleRootHash":"0x534f8faa563711079551427fa4849560af6f1c50b117631b87ffc5ff97102eec"},{"version":"0x00000020","timestamp":"0x8866ab66","nBits":"0xffff001d","nonce":"0x7ad5cd36","previousBlockHash":"0x7d91986462e38d35ac311a80596bb6e21efeda7863b476bdd4477adb00000000","merkleRootHash":"0x31d145d165440d1e890163787b788f7c3ba5eccafb269e252d64a60d0c489287"},{"version":"0x00e00020","timestamp":"0xf358ab66","nBits":"0x07936019","nonce":"0x077a0521","previousBlockHash":"0x72b49cf610b7d6a895d49d5fe29a40fbb188cde94b4fa3c058564a5400000000","merkleRootHash":"0x0ce5fba608171effe4c4a58af863d21795fb1a9e6e927dcd6f202e3f3d225cc9"},{"version":"0x00000020","timestamp":"0xa45dab66","nBits":"0xffff001d","nonce":"0x40532744","previousBlockHash":"0xb41b4a71b84a580813c7d5058226cf00c22237d44c55640f1500000000000000","merkleRootHash":"0x2b3f6f942ca84289ce3a2ee2696ee308b258b626f76e1508d54b5b9546a353e9"},{"version":"0x00000020","timestamp":"0x5562ab66","nBits":"0xffff001d","nonce":"0xcce60058","previousBlockHash":"0x04dfc9ef9bd67584b2611013d881505e115dcbec4663f5ee2c9522a600000000","merkleRootHash":"0xed673df376e9ccbb8e9f3fea8fb1d64a5a6491bc313013f29d71b2abfd67aad4"},{"version":"0x00e0b327","timestamp":"0x5d5dab66","nBits":"0x07936019","nonce":"0x56301d0b","previousBlockHash":"0x98292fa864e009154b96f56614b021a3ba561b8005fdc1de00d23f6500000000","merkleRootHash":"0x6f4e35da3620aa80c4602bbdd60c7ce93f7aa699e1cff5db34bd4189530cc9c4"},{"version":"0x00000020","timestamp":"0x0e62ab66","nBits":"0xffff001d","nonce":"0xea27be64","previousBlockHash":"0xbaaab2a892d59f31305e78063c2633e1b8147712bba8e6c54a00000000000000","merkleRootHash":"0x9c2046de8802421c6710804ea20fb951550289a3fb6333c40da042bdc8475d32"},{"version":"0x00a0aa20","timestamp":"0xf961ab66","nBits":"0x07936019","nonce":"0x78040876","previousBlockHash":"0xaafa2fefa53387762e96f0363a2d0d2607778a20ccbc40b26f86cea500000000","merkleRootHash":"0x9a06cb9efbeefae920d81f29d48458e8234f11ed09ebdedb936012772343bf90"},{"version":"0x00000020","timestamp":"0xaa66ab66","nBits":"0xffff001d","nonce":"0x63bbe1ba","previousBlockHash":"0xa3d29a731d5a1c5c4acc74a4187a29721b049548b15f9ae34500000000000000","merkleRootHash":"0xcd74bd96e2031a6adfb0862c2fcfc94b0fcca09da6118914f17344fcaeb82d48"},{"version":"0x00c00622","timestamp":"0x3464ab66","nBits":"0x07936019","nonce":"0x389d743c","previousBlockHash":"0x3b8333f161e69a90e50fbd11b625afcd1fdc80541d86570d19700df700000000","merkleRootHash":"0xa3de210e51a865c9d7a1dd8954ad03865b0195fc773e7c0ef93e1e7719e98d17"},{"version":"0x00c0ee26","timestamp":"0x6164ab66","nBits":"0x07936019","nonce":"0x25585dbd","previousBlockHash":"0x5ab2ec08b66b2fb16ff215f6b429b5dcd43fd963135a86e43800000000000000","merkleRootHash":"0xbca3dbd92d7ecfebcb4afe2b557df9dc655255f30e128d5e75e004580ed0ebc4"},{"version":"0x00200020","timestamp":"0x1969ab66","nBits":"0xffff001d","nonce":"0x1449210b","previousBlockHash":"0xe115021a786cf5abfa2ff464e4eb0a89d996720513bcebca3300000000000000","merkleRootHash":"0x40bfa68ac97678f1e2f74c0a4199d84ce1454994e054f6a420a39f71da681f68"},{"version":"0x00000020","timestamp":"0xca6dab66","nBits":"0xffff001d","nonce":"0xcfa5cb04","previousBlockHash":"0x42f90fb4c44f6c73cea004f6d71a552bcd5ddb125c40ce43f689090000000000","merkleRootHash":"0x342e7920951595eb06cae760feab8d52b8afb926abbd0da82543cf7d4349b3de"},{"version":"0x00000020","timestamp":"0x7b72ab66","nBits":"0xffff001d","nonce":"0x60723a37","previousBlockHash":"0x50317bb8e63d939b677aed3a0ab26259acdff8369ceee3f0f39173f100000000","merkleRootHash":"0xa79329a11ef3fb3ede2921947c5d958c36a935a23bbf8315c1653ff50df03184"},{"version":"0x00000020","timestamp":"0x2c77ab66","nBits":"0xffff001d","nonce":"0x693af611","previousBlockHash":"0x3784684fb61d1f487e89e10bc6306c6bc69116316643b2de046eac8500000000","merkleRootHash":"0xc1bc2a2e12d76b680b67f8489ff74b1b7db3a3592458fa607b4c34494cf7eb84"},{"version":"0x0060c42c","timestamp":"0xea74ab66","nBits":"0x07936019","nonce":"0x2e315fe1","previousBlockHash":"0x180d961f055317034861033d24754a90fb511d698c0fe2616cf0c98600000000","merkleRootHash":"0x387fcd04da3dec4fcddfe8d315e420923f8172b633ffabf5ac8473978063bf88"},{"version":"0x00000020","timestamp":"0x9b79ab66","nBits":"0xffff001d","nonce":"0x0aadc42e","previousBlockHash":"0x33b9a416e60c041af840789954d361453dc1fd97255299634700000000000000","merkleRootHash":"0xe436548c40326ec6da630db4d03774153ef06cd9b0821bc734bef5b0de998189"},{"version":"0x00000020","timestamp":"0x4c7eab66","nBits":"0xffff001d","nonce":"0xb42da93d","previousBlockHash":"0xc99d03a4711c83f26c5f0990a68e0cc61ffe19d0080125c017cc487100000000","merkleRootHash":"0x1c2b209dff8ff97f8c2d7607054acad0f2b4a42e85d08a77203755c3a3df2ccd"},{"version":"0x00000020","timestamp":"0xfd82ab66","nBits":"0xffff001d","nonce":"0xa6800dc8","previousBlockHash":"0x50e85301957c8c278fbc67f5cdda58641c03bffd2eaeffaa989219f100000000","merkleRootHash":"0xd04db740c6bd2b1305d6387b4adb739b2379b69f199ba31902b2b70ee18b44c8"},{"version":"0x00805624","timestamp":"0xbb81ab66","nBits":"0x07936019","nonce":"0x64c82645","previousBlockHash":"0xdf058e0fa74400815142f0c266b7a17c456f22361f58ca82e8afbdc900000000","merkleRootHash":"0x6a1699d2c3ffc8cb94b314a5f17cae6e36a4e8e33f7daf100860de5534760b2c"},{"version":"0x00000020","timestamp":"0x6c86ab66","nBits":"0xffff001d","nonce":"0xc97cee20","previousBlockHash":"0x5a80169ce95879f6fad083c124b8e447e276ea5f4b87fe6c0e00000000000000","merkleRootHash":"0x76740897eb03e6937b8ddcbc62083250119e9108601ece19b1134fb3200476dc"},{"version":"0x00000020","timestamp":"0x1d8bab66","nBits":"0xffff001d","nonce":"0x6a3af811","previousBlockHash":"0xc46c271a14bb4a732906d4089428267d59ce69e98f29550485f8440400000000","merkleRootHash":"0x21de4239552fb02e31e435f6e69f23850df20b4ad7901551826e2d856bd25f45"},{"version":"0x00000020","timestamp":"0xce8fab66","nBits":"0xffff001d","nonce":"0xfbf91016","previousBlockHash":"0x55abd392f932d30166b0dbfe7c638ce2d03306c1e93d7ed4d8f6bc5e00000000","merkleRootHash":"0x763bd67f12abe3096f7c45bdcd3bf82f35153645ab7bbd023cdd7265e16e5c39"},{"version":"0x0040662f","timestamp":"0x4690ab66","nBits":"0x07936019","nonce":"0x6fd426d9","previousBlockHash":"0xde7a56da3492cafeec1e2c5d263bf5914e37bf90058cf0df6b21d94400000000","merkleRootHash":"0xd96840976b2783dd8709dfeed13f27dd792fddf87e61c720fa35bb08625eb073"},{"version":"0x00200020","timestamp":"0x4a93ab66","nBits":"0x07936019","nonce":"0xd70141ab","previousBlockHash":"0xfd3e7219bd5883bf15846bf9242544caa5033a2eb817e67b1300000000000000","merkleRootHash":"0x7249f2e039e8486f10c1e2a679502d3afaf45fd5c33be12038e620f2cfa428a7"},{"version":"0x00000020","timestamp":"0x0a97ab66","nBits":"0x07936019","nonce":"0xf0bae736","previousBlockHash":"0x5dff671df802c205643fba439477c606b7fb6067c56e7ac00e00000000000000","merkleRootHash":"0x553eb21c6435130776d84dfb92627426cdb2249cb50ff1091790e13c34466c7a"},{"version":"0x00000020","timestamp":"0xbb9bab66","nBits":"0xffff001d","nonce":"0xf7f07260","previousBlockHash":"0x8dbed2a29d853f593bb40d2af15047e001f734d1d593de931d00000000000000","merkleRootHash":"0x71c32b2b91f0970f139b661d932c6ff819d059c29ae46b8d76a00f86f6fb438b"},{"version":"0x00000020","timestamp":"0x6ca0ab66","nBits":"0xffff001d","nonce":"0x7de4b80e","previousBlockHash":"0xe78a0668a1f52de12fb7eb16d2552af6b76d53484076397759e57b4c00000000","merkleRootHash":"0xbfc78eb56a4c07a32e927a2e93566236d4d0ab03e5b38116dfb2493303e9e1d3"},{"version":"0x00400020","timestamp":"0x11a2ab66","nBits":"0x07936019","nonce":"0x5c3e6463","previousBlockHash":"0x58855c9a32eb5e8560695082ee01c84fbb70c97113f960b62b5790a000000000","merkleRootHash":"0x353b8e6c23cea483bc240f3ae88668062b40f75b7038b45859f275e9e19731ae"},{"version":"0x00000020","timestamp":"0xc2a6ab66","nBits":"0xffff001d","nonce":"0x3474141f","previousBlockHash":"0x51861cf84aa3df19458d913b2283cb42872251ffa2b261b14a00000000000000","merkleRootHash":"0x2d10ca65eaf10a0c42c85b2898c24abc6bb4a534403b1729bf6092da1f6ccf17"},{"version":"0x00000020","timestamp":"0x79abab66","nBits":"0xffff001d","nonce":"0x4010190a","previousBlockHash":"0xa421b533f8e33d083ee6e6927a17b1f3373a6a790aeef4ffdbf1eb5500000000","merkleRootHash":"0xdca78f66514d7c0c58bcd642e0cc1e54806931fec46eb9b208faf43548c251bc"},{"version":"0x00000020","timestamp":"0x2db0ab66","nBits":"0xffff001d","nonce":"0xa0cc90a2","previousBlockHash":"0x916f9b1cbd4cf69ac8f252b546cd09e87f4bb1ca45d285dae1b839f500000000","merkleRootHash":"0xe319a7c292388ce8e783f832c8f1c5fdd4809337057fe5fabcfc53e310da21b6"},{"version":"0x00000020","timestamp":"0xdeb4ab66","nBits":"0xffff001d","nonce":"0x23f0761e","previousBlockHash":"0x6a4565f1814f2b2d44b46ff3a667da4f00f0da6f78645a60ca02dbc100000000","merkleRootHash":"0xdafe13994bdbdc5e7c9cc718cd7e89c08cf9db897eba268e27136eb2df31f00f"},{"version":"0x00008424","timestamp":"0x3eb3ab66","nBits":"0x07936019","nonce":"0x6a6ca698","previousBlockHash":"0x4e1ae352719218f92650452bb2c2b3962d24fc98b460f68d55ad055e00000000","merkleRootHash":"0xbc318f818c1162e568039a257747270acab365245ed2ef8bee2c4988416f14fd"},{"version":"0x00c01d2f","timestamp":"0xcfb7ab66","nBits":"0x07936019","nonce":"0x6c28b0eb","previousBlockHash":"0x6c4894505854476f2371414053285b1cc918cf75ff900af84800000000000000","merkleRootHash":"0xf0752b87dd8a89ca545f1364baa9a9a33af1f972baed7da24b70fb95522d89cf"},{"version":"0x00000020","timestamp":"0x80bcab66","nBits":"0xffff001d","nonce":"0xf273743d","previousBlockHash":"0x4096886503d8b662e756b05bb1eecdb7e4021c84d5e94cfc0300000000000000","merkleRootHash":"0xd00b7b392a9cdc0bc2a6b2a52b79edacd4d5296b1c3dbe37923228521ceb0d3c"},{"version":"0x00a0eb2d","timestamp":"0xb1baab66","nBits":"0x07936019","nonce":"0x17c4b3a4","previousBlockHash":"0x28b3f16e5643ec217691e6885b9b4a4eca5c30360d3cc386ca6b175b00000000","merkleRootHash":"0x16ff33abf70801ce9d2eece3146c9acf32cae204476d46af73b20d3cc1be58fd"},{"version":"0x00000020","timestamp":"0x62bfab66","nBits":"0xffff001d","nonce":"0xc01ba804","previousBlockHash":"0x619a45615d96726220a9b98a0398eb0ee5b1fb1ee12034535400000000000000","merkleRootHash":"0x92007845442e23324581cd7b37c367ee4d84eaf2f4b90cc24169be47bfcca1d8"},{"version":"0x00000020","timestamp":"0x13c4ab66","nBits":"0xffff001d","nonce":"0xa1a54e05","previousBlockHash":"0xae03525eb4870f71c262635a23e39c6bb3d69dc123239364d443e77900000000","merkleRootHash":"0xf8ad60251cf433fa8b5e5a047fc686ab65f49746f94cb2459975b54dce1112da"},{"version":"0x00000020","timestamp":"0xc4c8ab66","nBits":"0xffff001d","nonce":"0x6d4d031b","previousBlockHash":"0xf99ecece9dc845ab60ba02273d8c43e58faaad62ce90aa1f3d1fcfef00000000","merkleRootHash":"0x5f46839bdccd089b831e8d8a4d9017847c8bdf3f8f1b6185b62d6e9326a38617"},{"version":"0x00400020","timestamp":"0xdbc3ab66","nBits":"0x07936019","nonce":"0xe13dd9d4","previousBlockHash":"0x820d734c2cfb050ebeed344efc0c2ff8918e986e5fbbc8b73bc95a3e00000000","merkleRootHash":"0xe61fc7423aea509001c5d54c9f7b3ca4339f2e77f5bac39b82c0f3f83405e3a6"},{"version":"0x00000020","timestamp":"0x95c8ab66","nBits":"0xffff001d","nonce":"0x33d1a79d","previousBlockHash":"0xe920e15423aac653063dac9edc9142bd5832a319e816bd082900000000000000","merkleRootHash":"0xa69519ec9001395abb0feaee0a7aab848dfbe8bd6f17ad9963574198a7601c56"},{"version":"0x00600020","timestamp":"0x96c8ab66","nBits":"0x07936019","nonce":"0x3226b624","previousBlockHash":"0xd5ba642ed6220989b2dc57df27b1e7553501faa3a78fb30d31af94b300000000","merkleRootHash":"0x57c1c39ab90dda783acf310230e8175ad47701dadc9a2ac4d83a73e94f65aa9b"},{"version":"0x00e0fd2a","timestamp":"0x7fcaab66","nBits":"0x07936019","nonce":"0x2190c6ac","previousBlockHash":"0x8703280d0342c8b7efa1788f7955f1944ea5f8128717cf802000000000000000","merkleRootHash":"0xdf0a9230607ccf407798c2dd9b6bed5e08b2080b771eb2a782f6d8090c6bfd64"},{"version":"0x00600020","timestamp":"0x30cfab66","nBits":"0xffff001d","nonce":"0x2a06b108","previousBlockHash":"0x941089a682236e27c3fb2f10878526c55c1e315fcad603253500000000000000","merkleRootHash":"0x533c8ac8be9fa25611a67b85c237d2a1eb79cf64cef5731ba5f485ac5f5440a7"},{"version":"0x00000020","timestamp":"0x36cfab66","nBits":"0x07936019","nonce":"0x13901ac9","previousBlockHash":"0x0be18f1aecfd915c4b8838e91497146131ad4c2aa52e054c4847780000000000","merkleRootHash":"0x1053779b6728d5ce03ad6708f52e8b09e59bfb362b088fab2269881d9ea45cf4"},{"version":"0x00c0a422","timestamp":"0xb6d2ab66","nBits":"0x07936019","nonce":"0x758d73ba","previousBlockHash":"0x07aa831173f147476e85652697575d39d0b3a90e851a3a0e1100000000000000","merkleRootHash":"0xee603b0a75bdad5c39764d20d410562e082c37f472599bbc840a2b17647eb332"},{"version":"0x00000020","timestamp":"0x67d7ab66","nBits":"0xffff001d","nonce":"0xc8981c0d","previousBlockHash":"0xd64028b6cc77e120f9b5bac2ef565754c27e0f4d3e55afc65f00000000000000","merkleRootHash":"0x8c912b19a0a763f2b564a21e6fab3c9a04f31d526d498e7b8bf15d5ebd03be7c"},{"version":"0x00600020","timestamp":"0x38d2ab66","nBits":"0x07936019","nonce":"0xd0118ec3","previousBlockHash":"0x6a52f023c8135736f290d60a408b26cdce484ef018d0678d779bfb3600000000","merkleRootHash":"0xc9d1d2f40c24a13949ea237eded00cafb717bbc2d157700306c5126653454e99"},{"version":"0x00000020","timestamp":"0xe9d6ab66","nBits":"0xffff001d","nonce":"0x6a490117","previousBlockHash":"0x7882ca4f8f325c567e4df3c1b7f1f5e7397cf74fbe4e2dd25800000000000000","merkleRootHash":"0x7e373a014b83cb23a131631bdfe80857794e4a79cba02a2c0d176ba3f15928c5"},{"version":"0x00000020","timestamp":"0x4ed4ab66","nBits":"0x07936019","nonce":"0xaed2b2ac","previousBlockHash":"0x6102be04e1bb32384432c621294c93e543ee5361ae08e029deb3b52200000000","merkleRootHash":"0xf77913f897354733a6194b7005a1afd004b4816c6c67b9309a9ed6ab1959a182"},{"version":"0x00000020","timestamp":"0xffd8ab66","nBits":"0xffff001d","nonce":"0xfb774414","previousBlockHash":"0x3ddafa89bb146ca788d96f9c708eaa897f8d7961023466ce0300000000000000","merkleRootHash":"0xc00bd4fc36cb49b7187e548d7929b4c9d4cbe7e8a6fcf0a75afb5e0d07ae9fc9"},{"version":"0x00000020","timestamp":"0xb0ddab66","nBits":"0xffff001d","nonce":"0x58ee76d5","previousBlockHash":"0xebf1a580061083fc98d170e3c6673925d80006e2f5fadb33162ef00300000000","merkleRootHash":"0xbe3fa3bb427034d0b8252edd8c8f8b4bad3dadf59fa765be269a18355ebfe9ed"},{"version":"0x0060242a","timestamp":"0x4edcab66","nBits":"0x07936019","nonce":"0x12e49520","previousBlockHash":"0xe5c11c2a98a657e5d1effd497627f20e46891cd492618c6e0c08e75d00000000","merkleRootHash":"0xcdccab0411a4224d92b847c8ee66ef8f9d1a1408f489883edfd2fddadc227405"},{"version":"0x0040e72e","timestamp":"0x84e0ab66","nBits":"0x07936019","nonce":"0x78fc9bfa","previousBlockHash":"0x3312b2e659f94fa4138cc8010dd1ffabef7a120b2a9617074800000000000000","merkleRootHash":"0xebebd2d24455f65f773efcb307bae131126384a1073c45881497e8eccdbe1557"},{"version":"0x00000020","timestamp":"0xfcdfab66","nBits":"0x07936019","nonce":"0x5fc0fbd3","previousBlockHash":"0x08e3c3a7a71d40adc9db1551f6d1e65d32c51a8a0c932ecc3400000000000000","merkleRootHash":"0xdd842ffcea167e66cf665c4c14c5adfa2c855ef8d38f1ac3499b779b0cbcaa51"},{"version":"0x00e0ff2f","timestamp":"0xd3e1ab66","nBits":"0x07936019","nonce":"0x01657ee0","previousBlockHash":"0x457e14d0e70012f7f650ebb15c045757fba0e0e26aece0a52900000000000000","merkleRootHash":"0x7e0db854c6361ce65d437d4f1947545cbb6014610ee3066bbb3fd753653fd965"},{"version":"0x00000020","timestamp":"0x84e6ab66","nBits":"0xffff001d","nonce":"0x4072de05","previousBlockHash":"0x7f6ec219dae2ad1bbabe655adf03233001ee255c211523701c00000000000000","merkleRootHash":"0xfe736083209536a92fb14c317b958cc0cf15ba333548f2b128e8147c50851d5d"},{"version":"0x0040ea29","timestamp":"0x75e4ab66","nBits":"0x07936019","nonce":"0x788935b7","previousBlockHash":"0x78de13e7198375edf3890176eeb0a38450cc0ef038d67a7e11c935dc00000000","merkleRootHash":"0xea3469f784615bf11f1d2658a39972af110d4a3f1be3a019284ef1949ff21786"},{"version":"0x00e0ff27","timestamp":"0xe9e3ab66","nBits":"0x07936019","nonce":"0xaa0f2cd6","previousBlockHash":"0xc935d072799001afe1e553f5e04e20074c5b1a78a962421d3a00000000000000","merkleRootHash":"0x99bc0d2786b35257c24d5781a4cc619cef4c8e097408a2a384265e78489bd9cf"},{"version":"0x00000020","timestamp":"0xa3e4ab66","nBits":"0x07936019","nonce":"0x7a071a29","previousBlockHash":"0x213ca3c2caf43acab5ffad5bf470ceac798372bfcb2f16f52700000000000000","merkleRootHash":"0xc84c8e583c190c36315cd44c55dbf8e90566cde9387b5844ed82e4105b09fa15"},{"version":"0x00600020","timestamp":"0xa8e4ab66","nBits":"0x07936019","nonce":"0x6a256d86","previousBlockHash":"0x64b49f41fdba3d15bab7528fc9b7de469a78c4b94a26c6293500000000000000","merkleRootHash":"0xc6b48d492d7b7f74654654307d8c7cfc13ff67c48a9aedd212d51482a3b77574"},{"version":"0x00000020","timestamp":"0x59e9ab66","nBits":"0xffff001d","nonce":"0x5bd6a31c","previousBlockHash":"0xfcf411f80e82021c2dcba5e6e4c3645ffc6c3cdc59ba62584900000000000000","merkleRootHash":"0xe95a98c8cacaf5c89b7bcca6992a1e56f632b756d2f6be838aeaeb407706b810"},{"version":"0x00e0e626","timestamp":"0xd4e8ab66","nBits":"0x07936019","nonce":"0x5c19be97","previousBlockHash":"0xa870b167845795be75167dffacf0e9420b5323ff19f84150a0968e2400000000","merkleRootHash":"0x489b14e7ac61947491d71b768e2ddc440c3750f635a8f1e768cba93cbe4a0338"},{"version":"0x00000f20","timestamp":"0x1fe9ab66","nBits":"0x07936019","nonce":"0x0f1e0565","previousBlockHash":"0x59a7dcd81ef78215e1468f854b28af726493fd9bd00ca8a61100000000000000","merkleRootHash":"0x3e1c895a58f7720afa79d19a41ce149a8694580488821ca19dda1d0b32a4932b"},{"version":"0x00000020","timestamp":"0xd0edab66","nBits":"0xffff001d","nonce":"0xd00d0e00","previousBlockHash":"0xf177ea378988518698b6df1c2b8a9d370f0b05e17c6a93c32900000000000000","merkleRootHash":"0x53ebde4dc82dda347308af38972a7b5c12c5fb3b0795058d3fc6b3d54532c200"},{"version":"0x00e0ff37","timestamp":"0xa6ebab66","nBits":"0x07936019","nonce":"0x213a741f","previousBlockHash":"0xb0cb08d6130365c09afa91ca14d238a9e5ed264c6165b1d2f8a7c17b00000000","merkleRootHash":"0xf7bba02f3400f3673105515c9c48b16172785aeb9da7bf0987bbe165f24ada5a"},{"version":"0x00000020","timestamp":"0x57f0ab66","nBits":"0xffff001d","nonce":"0x39f7611b","previousBlockHash":"0x05aeefbc5d06f716dbc18760123e2f143c1ef37199ca213c1f00000000000000","merkleRootHash":"0x4b724c939b4ac46c6c3b1ad1ba1cf6ebda98073185ed2f45a2a13b1f10e1c17f"},{"version":"0x00000020","timestamp":"0x64ecab66","nBits":"0x07936019","nonce":"0x8528cfe6","previousBlockHash":"0x0dbe13d579682edf5f215de2370d24fcfa65c2bb18b46fdfdf4ff9d700000000","merkleRootHash":"0x45894031c0fbec0e76e4ef4437a30772df705fedb8941ecd71378f4589b0fe9a"},{"version":"0x00000020","timestamp":"0x1bf1ab66","nBits":"0xffff001d","nonce":"0x0034f010","previousBlockHash":"0xc0d997e2dc5adbf6e19eb75fd94045e657752f42f94ae9d44500000000000000","merkleRootHash":"0x5332757d30c92bc94887856487bca5d371aa7e468e0e91a7dea2f62a68a7dab4"},{"version":"0x00c0df24","timestamp":"0x33f3ab66","nBits":"0x07936019","nonce":"0x20b49a1a","previousBlockHash":"0x8690502598d9192b5e0a40db44026553116997a87fa8dbcbf26a903a00000000","merkleRootHash":"0xbc712f3afa6fb14068f092c7ca08c145f83caf582b96a84417e5129d0ec6094d"},{"version":"0x00000020","timestamp":"0xe4f7ab66","nBits":"0xffff001d","nonce":"0x9287f62e","previousBlockHash":"0x26cb5df194b4eb7dac0c1488a3b85844b39f295a658e9d261600000000000000","merkleRootHash":"0x9e518d771cab589bb1a78ae7f03cdcfecd1349f4ff3d8fdfe6e10a44aaba4a7d"},{"version":"0x00000020","timestamp":"0x95fcab66","nBits":"0xffff001d","nonce":"0x7a015514","previousBlockHash":"0x3fc86f283b878f745932758ed6acc006557849649b195ff44322087b00000000","merkleRootHash":"0x182119023fa56e9cabac6b696a2ed3e155c4677492c7497e9cdcec7dac8f5be1"},{"version":"0x00000020","timestamp":"0x4601ac66","nBits":"0xffff001d","nonce":"0x0814fb46","previousBlockHash":"0x57115e2023ebb7e347132d17fdba2e4542ad25b0284915abc1785ec700000000","merkleRootHash":"0x39b9f9fa0073b98850b78e43c0fd8ab5106543c60e8ae29a4551d153ffc5f3e7"},{"version":"0x00a0e220","timestamp":"0x5bf8ab66","nBits":"0x07936019","nonce":"0x5e960b8b","previousBlockHash":"0x0b0657214eff1d356d197fbbccad8add1d56e5959f0ae4cc0dff44f800000000","merkleRootHash":"0xf95a7d581ebf53e8eb394fbef0760d86f0a8fccff592238a515f293180fbc1c1"},{"version":"0x00000020","timestamp":"0x0cfdab66","nBits":"0xffff001d","nonce":"0x03901017","previousBlockHash":"0x57a911e61d61e1164e846ab1521f69c7ccef2679daa30be22d00000000000000","merkleRootHash":"0xe4e42bf873fdf839155caf6d880e4c8507cbc470bd83dc9315561980e0d4d156"},{"version":"0x00000020","timestamp":"0xbd01ac66","nBits":"0xffff001d","nonce":"0xc9bb1d3c","previousBlockHash":"0x3929bf2ea7c0ce3e53cd3491b84c4d7f93c7188e84b641075c54746100000000","merkleRootHash":"0x300b05a7220994794da9821359c32d312e0327ae39884bcab0d5eb598a9360b2"},{"version":"0x00600020","timestamp":"0x65fdab66","nBits":"0x07936019","nonce":"0x80af80c2","previousBlockHash":"0xbfcac9be237c6cb471c3423d39e0ba7244a6ab374fb92d6153861eb700000000","merkleRootHash":"0xc976f38ce8f29345f955f3a85dcb2bafaecf7a7eb2e5fd123d3dd43352773dc7"},{"version":"0x00401e25","timestamp":"0x46ffab66","nBits":"0x07936019","nonce":"0x0d2c11ff","previousBlockHash":"0x5ad064b220e95f200a4883187928672b681e97de98f74bd93e00000000000000","merkleRootHash":"0xd82c54d7c9d776884fdb6193a517017ac0555c0afb12656d7b5f4c5e4409a449"},{"version":"0x00e0ff27","timestamp":"0xd3ffab66","nBits":"0x07936019","nonce":"0xc0d1112d","previousBlockHash":"0xbf0f08cd1391bca612bd05eb1c94eaaf50866d74ec20663c5c00000000000000","merkleRootHash":"0x791cf199caf6375770a727cd6494c65a64ca350486870d4522a400e815f410a1"},{"version":"0x0060d124","timestamp":"0x3704ac66","nBits":"0x07936019","nonce":"0x42b152df","previousBlockHash":"0xf845f43087e0710699467bd83522cd575a227a78a05213d34a00000000000000","merkleRootHash":"0xaf7062d80336d564500e8734e075ab4909894faa3941d7dd08d4be4e4f960585"},{"version":"0x00000020","timestamp":"0xe808ac66","nBits":"0xffff001d","nonce":"0xb6d0f2ef","previousBlockHash":"0x4d499123a23208001535e173aa031673bf0923b086ac7d145200000000000000","merkleRootHash":"0x4cdf26d20c3aabf8132db79c263250d588ea5148f09b2e5d34b64b7db043a3d0"},{"version":"0x00001d23","timestamp":"0x5b0dac66","nBits":"0x07936019","nonce":"0x3319c68b","previousBlockHash":"0xe73f105be6ced3ad422d0d619449cbe5e44f79ac223083eafc2607d200000000","merkleRootHash":"0xca61fc6845d0df88767f285285a7726161ddb0b5bc1b9a396718735dd7e0c50b"},{"version":"0x00e0ff27","timestamp":"0x970eac66","nBits":"0x07936019","nonce":"0x426282e0","previousBlockHash":"0x5ff7627ce1e03266a6bd05818e356c90f448169e8bc445744100000000000000","merkleRootHash":"0xdf5f300ad8f2a3b5ebaadf4afc4298fa487c5396093e61783a0942b043c88d51"},{"version":"0x00000020","timestamp":"0xff0fac66","nBits":"0x07936019","nonce":"0x9642f16b","previousBlockHash":"0xfa8f18343a82aa5b3aacc92eb29415d9eb902a479ae295eb3600000000000000","merkleRootHash":"0x5de4cfae21160b97c8c8e3b0199e0561f201518736515ebeca58ad7b5324f4f2"},{"version":"0x00400020","timestamp":"0x0512ac66","nBits":"0x07936019","nonce":"0x70343ceb","previousBlockHash":"0xa9c7baa07d27ff10329aa2c942b02f48a6f0e0659d3777c73600000000000000","merkleRootHash":"0x9f369d170688386d2886840c29ffc239fab109718adfaaae56c6286914b15eba"},{"version":"0x0060fa20","timestamp":"0x8312ac66","nBits":"0x07936019","nonce":"0x1e7b8980","previousBlockHash":"0x73ddbcc17789a8d9ae42edcff1b571cc6d7b18cb107ced440900000000000000","merkleRootHash":"0x25186c99ee7fa57936e706c745886785c765018545a59d9c47f560b51d7d9763"},{"version":"0x00000020","timestamp":"0x8f12ac66","nBits":"0x07936019","nonce":"0x5b13e5ea","previousBlockHash":"0x2c715f32f165f4a63817abde74ffe57776bde24bfc84c4eb1c00000000000000","merkleRootHash":"0x7b133becfc12d1016d8162e572d373900d31099e1e80104ae27ad0eda155159a"},{"version":"0x00007f21","timestamp":"0x2714ac66","nBits":"0x07936019","nonce":"0x25247331","previousBlockHash":"0x6f2ad3160b5b1dfa951235a125fc31a9883f949163c2514d5800000000000000","merkleRootHash":"0xd675e88daa8af1ec80cfe24d11e9b3e22f90c1a0b490a473dc9de002e1a024a9"},{"version":"0x00000020","timestamp":"0x7314ac66","nBits":"0x07936019","nonce":"0xf784fe23","previousBlockHash":"0xdfe22454b9e078dbcceafb928fe4b611c51c2fa4df555b461000000000000000","merkleRootHash":"0x7293b7b2284a527128a4f789f283792090056d3d96d17cf68a008afba16e2a0d"},{"version":"0x00000020","timestamp":"0x2419ac66","nBits":"0xffff001d","nonce":"0xc03b0b57","previousBlockHash":"0x52a3c751cd48da9c2a4a28722f44bf221d6cb9c00bde0b1f1400000000000000","merkleRootHash":"0xa76c186c6eba553944189e5324bf8b943124cbb2fe0fceebca6d38a83068ee9f"},{"version":"0x00a03225","timestamp":"0x991bac66","nBits":"0x07936019","nonce":"0x72ce5665","previousBlockHash":"0x899466ee5127659f02ff2fba8bf9c06d64ee2318722b35c2ff989aae00000000","merkleRootHash":"0xd2bdbd563c30ced7f6ac0067801bb257e1054250053a421ef45e644b73218703"},{"version":"0x00603022","timestamp":"0x981cac66","nBits":"0x07936019","nonce":"0x48c84a78","previousBlockHash":"0xa73ac9104f9c22dc72adad86dd7a98454f4f3bf4f75b7d705800000000000000","merkleRootHash":"0xf4671a3a91c338c2e3e4a635db4433e40a2e91a094cd73e4944e021e175d0d05"},{"version":"0x00e0ff2f","timestamp":"0xb31fac66","nBits":"0x07936019","nonce":"0x9dbe6906","previousBlockHash":"0x8737eedcc58c7cda73d97b1f89433cd136b631179ba8f2511900000000000000","merkleRootHash":"0x274a4e42a43700be248b400504f96cd7ff864d45656991921566373fa67f06be"},{"version":"0x00000020","timestamp":"0x6e24ac66","nBits":"0xffff001d","nonce":"0xa6c21683","previousBlockHash":"0x7c77613c725ef853207e04e342ad38a232cf6cbe73dfaae91c00000000000000","merkleRootHash":"0xb5df527e5de0ea9f323f93bcc80664b7506b8f48e93113293ffaf0f75f30d6c7"},{"version":"0x00400020","timestamp":"0x7124ac66","nBits":"0x07936019","nonce":"0xc639b335","previousBlockHash":"0xee6c8f29b2204c132c7e5e4939573010ea051f9764e67ccde0ac100000000000","merkleRootHash":"0xd510906f4932a972934adf52ee6e7d6710458f01528c8cd9576a1ded777631ab"},{"version":"0x00000020","timestamp":"0x2229ac66","nBits":"0xffff001d","nonce":"0x297e3b04","previousBlockHash":"0x260af3e346113a39cc71d02ba0590a9f9bfdf86ca41482170500000000000000","merkleRootHash":"0xcb301a33a39d52b7560a80512fb15b506683061c95c0d0387c473510cf80d4c8"},{"version":"0x00e0da25","timestamp":"0x0c26ac66","nBits":"0x07936019","nonce":"0x3b6d0b8b","previousBlockHash":"0x16446dde62966cea41d82087aa6200da336836e88e29b6b34fe67a5200000000","merkleRootHash":"0xc242fe266070b3924adcf67331714060d27094b45b8d909fcc0e6d58e9355cd7"},{"version":"0x00006722","timestamp":"0x4727ac66","nBits":"0x07936019","nonce":"0x2b314e63","previousBlockHash":"0x967f1d6dc76e903b2f8b4200e46579c2a3f59d27097377731b00000000000000","merkleRootHash":"0x5950dc3821cdee87bb9ecfe528a8d1cb10a3eb7e3f468c1aa2b01163e7d7935e"},{"version":"0x00000020","timestamp":"0x5627ac66","nBits":"0x07936019","nonce":"0x6bc33e42","previousBlockHash":"0xc48a3a4ce7178b4990c2e2706b8a6bc99ae94ef8fde866d62000000000000000","merkleRootHash":"0x8a5437174324090f7dd311c787dd991a5b4324bd4a1e08e860b587b1a57cadc3"},{"version":"0x00000020","timestamp":"0x6b2bac66","nBits":"0x07936019","nonce":"0x6702fd09","previousBlockHash":"0x7b2752aa98de88d59c11548902d6fc82ffb244987433ab7c1300000000000000","merkleRootHash":"0xc439399a53372e87c0cfd4ac37d38cb901df219a18ff8b6aa124ab1f4a2d6d69"},{"version":"0x00400020","timestamp":"0x2330ac66","nBits":"0xffff001d","nonce":"0x30cb6e4c","previousBlockHash":"0xeeead57213d1fd71a9a905e446dcd797ed3b741099ccada55200000000000000","merkleRootHash":"0xf6029778e05cc18419a9c59c0df45ea996f0de8a0c7e40c921cecd59be83e319"},{"version":"0x00000020","timestamp":"0xfb31ac66","nBits":"0x07936019","nonce":"0x806c3c8a","previousBlockHash":"0xf67a5ac622b1ac3b30845e5cbc4df58569dfbfcceecf090db049940000000000","merkleRootHash":"0xf108389a308ad6b9b9ad765b7ef924024b359a783176fc7c034a4bdb1699d596"},{"version":"0x00000020","timestamp":"0xb336ac66","nBits":"0xffff001d","nonce":"0xc4cc6bce","previousBlockHash":"0xaf4f555484719e6972d1cea7d11ca8f463c6221c54fe70f21600000000000000","merkleRootHash":"0x5d517f0193ef88051af502203812703bd668bf9e94782def57d6ae6d8fe94895"},{"version":"0x0040e829","timestamp":"0x1a3bac66","nBits":"0x07936019","nonce":"0x2c76d510","previousBlockHash":"0x7fdf7e0ff20878cb41e52d431fd6e7e21d87cfc0594b2f4252ed430100000000","merkleRootHash":"0x674f42cb4143030dece6890f1365519e63c415ab70fbea2479efcf81e75e20d2"},{"version":"0x00e0ec26","timestamp":"0xfb3bac66","nBits":"0x07936019","nonce":"0x661f7eba","previousBlockHash":"0x8060b16d0ee9576aa26a649b2cb8be3cd120c036620d55e23700000000000000","merkleRootHash":"0xb54b2c6cafab615d02f20bab865189d42b9c525b9ed7c773d137043d75eea79b"},{"version":"0x00407027","timestamp":"0x623eac66","nBits":"0x07936019","nonce":"0x0e3aa578","previousBlockHash":"0xb3b514f82e4b365ed92e06b241d928da8bd03de3c40dd8035700000000000000","merkleRootHash":"0x8e5fe730cea70777dade3e99777974bcee72165f1c8e5a902e674b2d9edd705c"},{"version":"0x00000020","timestamp":"0xdf3eac66","nBits":"0x07936019","nonce":"0xbf89cc30","previousBlockHash":"0x044014cbd3a40d3208f7755d71e42e53a091321f0a5555560200000000000000","merkleRootHash":"0xd860c77ec2ba300ac62e57e0f8d8744b84eec719b1d9beb254cb1edd6315c7d1"},{"version":"0x00404023","timestamp":"0x073fac66","nBits":"0x07936019","nonce":"0x23ccdc8d","previousBlockHash":"0xafa05574c5b9533df68b0a4fd885148810e22b8816e96feb2a00000000000000","merkleRootHash":"0x5084c7a7765f89bbd59c44aae65782fb1869daa4a0b6638c346e0f58322ec001"},{"version":"0x00e0ff27","timestamp":"0xaf41ac66","nBits":"0x07936019","nonce":"0x8113072f","previousBlockHash":"0xa28e1075fa8d68f186a150519876ee9b75578aefeb7ce7866000000000000000","merkleRootHash":"0x7765e97046c515acdd7aa8adbf8e7cca3de2d1b3604679c12cb25088311fb550"},{"version":"0x00e0082e","timestamp":"0xaf42ac66","nBits":"0x07936019","nonce":"0xeb954be4","previousBlockHash":"0x4993a37e6ff276e115a8ad2e565aff481a59a030cbb4350a2e00000000000000","merkleRootHash":"0x3aaef6ddc8969e4a2a1d6bf758d59a4a3634a1cf2d2446af7567313fc84e7e90"},{"version":"0x00400020","timestamp":"0x1f43ac66","nBits":"0x07936019","nonce":"0xbbd79475","previousBlockHash":"0x5186029adf1472359811e691795991d75798d91387e05aa14e00000000000000","merkleRootHash":"0xde39cd4c231038378f323ae03cefa22b5c9579c9ef9579c919254f25fe5c3c03"},{"version":"0x0020ee2d","timestamp":"0xd247ac66","nBits":"0xffff001d","nonce":"0xb2014723","previousBlockHash":"0x3e9e7926404d6db2923894df4c21c250ae5d28d8335ac21c2a00000000000000","merkleRootHash":"0x9af7cee01f235a32c08add3dfea6e3fbfbbeec27532c83ab2961f0ef495155dd"},{"version":"0x00806e25","timestamp":"0x554cac66","nBits":"0x07936019","nonce":"0x9a01eef8","previousBlockHash":"0xb64667b91933d3d9faeb21106ec09d9ad969bb5181055bfc71884c0000000000","merkleRootHash":"0x654ee471814fc389f0023122111a732eb0d7788be55bbfaa971562ce55ef0d45"},{"version":"0x00000020","timestamp":"0x0851ac66","nBits":"0xffff001d","nonce":"0x801720a8","previousBlockHash":"0x05146bfe52a8593ff3657ed6d0dfa2c987f3598a499bd2d51400000000000000","merkleRootHash":"0xabb346c45ce2b663e35618e42fabd8461336fdba670cf95d2cdcb8c333aae3ea"},{"version":"0x0060c821","timestamp":"0x9b51ac66","nBits":"0x07936019","nonce":"0x5f5ae6c6","previousBlockHash":"0xc5a4a4fbfd43b51fa2705d17abeaaa0797991d6f8353d0f82fa80c8d00000000","merkleRootHash":"0x45be9f7f147eb86eaa122aa833295b36d97ab1518240f08dd507ed6d35d2c10f"},{"version":"0x0000c020","timestamp":"0xd654ac66","nBits":"0x07936019","nonce":"0x44dff516","previousBlockHash":"0xc2db1ef07125e0d6aeb9694fd291b4bcedf8b3d332d4cb5f0000000000000000","merkleRootHash":"0xbf7a05bb097fcdf6fe479b6e4fbda120dd4ae2800f3d06100d67a0a3d9993adc"},{"version":"0x00e09228","timestamp":"0xb857ac66","nBits":"0x07936019","nonce":"0x4621e22c","previousBlockHash":"0x125e23bfbabdf5350af2585ce54c0526c2ac29bbe0cc2b632800000000000000","merkleRootHash":"0xe078868324589a2f85be2b9fcd18b4d30d17bf1f24b8ffb9243df9defba9b5aa"},{"version":"0x00000020","timestamp":"0x0f5aac66","nBits":"0x07936019","nonce":"0x0a1178cc","previousBlockHash":"0xa881737b644f800c80e067791dda3ea637764ce300b76fa65700000000000000","merkleRootHash":"0x2bb0ba04b8f0c715832f02fe1d4ef483495b4edd830c4524b19d69255e6c05a0"},{"version":"0x00c06427","timestamp":"0x785bac66","nBits":"0x07936019","nonce":"0x29abea4e","previousBlockHash":"0x66395b2fb7d8774344a2d6711430d02fa3cf2bf8795ca5fd4f00000000000000","merkleRootHash":"0xb733c8cf900916f3e13f98d39ed1311ff35564f4e7bdae2fcd403c1062b2afda"},{"version":"0x00805124","timestamp":"0x535dac66","nBits":"0x07936019","nonce":"0x99008590","previousBlockHash":"0xb6c8efe16ecb2b901ac4e6564abe22114bcafa6ef218fe0e0600000000000000","merkleRootHash":"0x5167603f7dff1363eff4332cf08659ce33331f61c0dc64db2b489c6ee5dd2960"},{"version":"0x0000c020","timestamp":"0x2960ac66","nBits":"0x07936019","nonce":"0x91de1192","previousBlockHash":"0xbe51cdda43cb8abf7ffd8f97be44d35bd55fb32ff42c64c35000000000000000","merkleRootHash":"0xd96a38c2c6b3218573ce49cd048219956f4433539a4e3f8c80787f7c20767b52"},{"version":"0x00000020","timestamp":"0xe264ac66","nBits":"0xffff001d","nonce":"0x01033b56","previousBlockHash":"0x35d25c66a4b6f7cfeb8added269f4c6d839b77c68c9750031e00000000000000","merkleRootHash":"0x642b8799f371c1b48861dc26c82a42fa0889253e29bd8788a03fb8fc41fe7e72"},{"version":"0x00209424","timestamp":"0x0e66ac66","nBits":"0x07936019","nonce":"0x7e6dd218","previousBlockHash":"0x67380cfef05fb0d02f8b5897a657b40d728ee556097ae1328cb7fa8b00000000","merkleRootHash":"0x8996dcd9e924a5afa695777b6159bbb52ea73676411cc15c46deda2f1b47876c"},{"version":"0x00000020","timestamp":"0xc06aac66","nBits":"0xffff001d","nonce":"0x4bb1c040","previousBlockHash":"0xfa725cbe45d08a0a598e5b5ff953eea58fa6c81ff8a8dcc40200000000000000","merkleRootHash":"0x096a8f287704f2e697c325e6df37e8914144092528db645853e64173d92741f8"},{"version":"0x00e0ff37","timestamp":"0xe06bac66","nBits":"0x07936019","nonce":"0xa947ed02","previousBlockHash":"0xbb08c677c6a4c872ae51f1620a863fa0d4ecbb858c4984aa7f83277300000000","merkleRootHash":"0x706058525520d6ebbfd5b1802128714930587cd4023bfd7b55baed4b5a8ef20a"},{"version":"0x00e0a529","timestamp":"0xb36cac66","nBits":"0x07936019","nonce":"0x7db981d3","previousBlockHash":"0x68a0eae10ce0b935a05707e5f65c6b6eea601461488265a34100000000000000","merkleRootHash":"0x8aa57ef4ad7ffd9e3a312d3d542a87e344026109b0ed55bca01a875088baa24a"},{"version":"0x00004020","timestamp":"0xc56eac66","nBits":"0x07936019","nonce":"0x80cf125d","previousBlockHash":"0x0add275fbffad59315a1ce84f792b8d30e6e4663cd41e1960800000000000000","merkleRootHash":"0x946fb8d0f1a6de7ed1bd6ddeda22ebcd5f2a3f88cf7eb1a2ce275965432ac70a"},{"version":"0x00000020","timestamp":"0x7673ac66","nBits":"0xffff001d","nonce":"0xb3642c1f","previousBlockHash":"0x4331ebf23d83bb2d1290c736ec4d29307241a010673336215600000000000000","merkleRootHash":"0xd3afcca4ca25a71e8e73079e356fa156c146fad4219d4b5cac852c32b0784ef9"},{"version":"0x00000020","timestamp":"0x2978ac66","nBits":"0xffff001d","nonce":"0xeac0a26a","previousBlockHash":"0x4199e21cba3100f21fd7bf8b8754d9b332ef02ee1a8aa77d98fa6abd00000000","merkleRootHash":"0x5d20bbea3e7d545b07a24c6f78c0371bece8347bc631559502d592c8e664f63d"},{"version":"0x00208f24","timestamp":"0xe878ac66","nBits":"0x07936019","nonce":"0x29cde9ba","previousBlockHash":"0x1300cff7f8b4a0c0cfc8ced6c2b45cf92f1c5491be615fc1f271200600000000","merkleRootHash":"0xf536312826842aea4d3da0892104275ca47b7c4c3dee5b5cfc4fb7257f0b01f7"},{"version":"0x00000020","timestamp":"0x9d7dac66","nBits":"0xffff001d","nonce":"0x00349a94","previousBlockHash":"0xd02471d98633cc9b7f79717115570e84fce7dbac06a3abad2c00000000000000","merkleRootHash":"0x19bfda20fcf3b1bb8f4693db109dcebdd52f9e4e027bfc54c7359f45390e51dd"},{"version":"0x00c01a22","timestamp":"0x0e80ac66","nBits":"0x07936019","nonce":"0x284e611c","previousBlockHash":"0x978bd4d4910b3459ea07903702d3a8be0243d6e634d4841c845bdaa100000000","merkleRootHash":"0xbf0a682184514ba3d64225caea719d599e31011dd250070582d9350ecd13dd8c"},{"version":"0x0060dc28","timestamp":"0xa683ac66","nBits":"0x07936019","nonce":"0x17268eba","previousBlockHash":"0x261e0be617d357ac72c42fdf4bdaf9a92e74cd4399730f132a00000000000000","merkleRootHash":"0x2de91c000e63269beebce6b3ede409a16533b8399f876b62eeaf81f3547294b4"},{"version":"0x0000a326","timestamp":"0x5a85ac66","nBits":"0x07936019","nonce":"0x945cd884","previousBlockHash":"0x71275c84e9c7c6bfbd164d6aff87a3dcbf20226ebab4b3905300000000000000","merkleRootHash":"0xf32319f6b760f3ef17d2e7f7eccc8b30ebd7f57748efca947addafbaa9197970"},{"version":"0x0080ec20","timestamp":"0xe185ac66","nBits":"0x07936019","nonce":"0x5bf32077","previousBlockHash":"0xb0f8fc97868e1978048342913acd433f86bf303d417af9c73c00000000000000","merkleRootHash":"0xc1168dfcf7d05839aaa2cc3708f4bc4f9c0484786fa873a0fa6d1915645fa6f5"},{"version":"0x00c0c623","timestamp":"0x0e86ac66","nBits":"0x07936019","nonce":"0x289cb858","previousBlockHash":"0x65b74bddf620f610938ad6f072e0f7a205fd0848ec12322a2100000000000000","merkleRootHash":"0x31b01e19ac780e6d77c65c69aa93d6ed65ce0c2c87cd4c2f19d39db057abcfc4"},{"version":"0x00000020","timestamp":"0xc18aac66","nBits":"0xffff001d","nonce":"0x40615903","previousBlockHash":"0xc48c230e3871f2111bc7120cad8250547f4e1f3b435c914b5400000000000000","merkleRootHash":"0x5bc80cf606a8ae867ea58f81965c38af8bb76658ff6110c93eda9de788365aa0"},{"version":"0x00e07924","timestamp":"0xea8bac66","nBits":"0x07936019","nonce":"0x490c93b8","previousBlockHash":"0x6ce9b81fbce2301813673cb8e5661d570da05d87ad138490900489a200000000","merkleRootHash":"0xf371c50edbd04f490069e23dc97a3c49eb1ad0a3f403f6df9010e899a6e62016"},{"version":"0x00e0ff27","timestamp":"0x288dac66","nBits":"0x07936019","nonce":"0x769ec743","previousBlockHash":"0x002ca4bdfbd3b01c2b07466a893cedfbad0d03f2e1807b533500000000000000","merkleRootHash":"0xc1df2b22d635064209fe01709551470db180cb68c893ca0c6281fc80c31e2ec5"},{"version":"0x00403521","timestamp":"0x4e91ac66","nBits":"0x07936019","nonce":"0x97d639d5","previousBlockHash":"0xd633687024818c3b69dfceda5cb544be6c499bf72418a7cd4200000000000000","merkleRootHash":"0x519961b4105ae9d8bb429f9c3ead56acc6086e0207f06db70493bf8739d763e6"},{"version":"0x00000020","timestamp":"0xff95ac66","nBits":"0xffff001d","nonce":"0x7ddff316","previousBlockHash":"0xe7c6ff09e38f9f6505fc7b2c6654c75aa07c090c6ccd05265e00000000000000","merkleRootHash":"0x6888593dd1c017f17629fbf12c7e4752305164798cace05b5a5ac2d7d05caac7"},{"version":"0x0020ed24","timestamp":"0x2f93ac66","nBits":"0x07936019","nonce":"0x73b1ed4d","previousBlockHash":"0xa73630b92463b732fcfac796a5f00abfdd5061287797424f32c50bd400000000","merkleRootHash":"0xd18b3f0a704826beb6a9c9feb13e6b87744b95a18dea12a37f82871c3cf5d83d"},{"version":"0x00000020","timestamp":"0xe097ac66","nBits":"0xffff001d","nonce":"0x11d8df2e","previousBlockHash":"0xef4613ca8fbbb64cf34396f10a1d0adbdd44533632550da95200000000000000","merkleRootHash":"0x8383bd494c354d27ced1f2b4e9dda1f49fb5f174b3b788245dcc5814e9fa4459"},{"version":"0x00000020","timestamp":"0x919cac66","nBits":"0xffff001d","nonce":"0x74978b05","previousBlockHash":"0xf170defc64a65089a1afb4370db6fd3466b4b1dd026362292610eaba00000000","merkleRootHash":"0xd480780c3d27b811f297e4fee4a49379b4cf72c8e46c84fdc30affef93b3488c"},{"version":"0x00000020","timestamp":"0x42a1ac66","nBits":"0xffff001d","nonce":"0xe1b25f04","previousBlockHash":"0xd743af246f72fcdd30690ffb36388304359773c350b74ed52214f2e500000000","merkleRootHash":"0x308fe518625fda0a3dbed57095e69a77dac447e0675a7ab11bae83202a3339fd"},{"version":"0x0080ae28","timestamp":"0x2c96ac66","nBits":"0x07936019","nonce":"0x90917b8c","previousBlockHash":"0xec92f1a7f39e76e7a45d4941d7e31651a96cb3ef44cd81f1978034ca00000000","merkleRootHash":"0xd53016900d007c8b6d8c57a1dfb84000176720a09967fb2f3bd9a7ccf2a9d70b"},{"version":"0x00203525","timestamp":"0x4997ac66","nBits":"0x07936019","nonce":"0x774e7f80","previousBlockHash":"0x8e5b41265be909969f2183b0155c48f4e663f5b7b07ff3a74d00000000000000","merkleRootHash":"0xe4e81fc069699227c6a9c6971265c2b71523637878857fa98d0361483a36ac72"},{"version":"0x00c09024","timestamp":"0x3899ac66","nBits":"0x07936019","nonce":"0x133c15f5","previousBlockHash":"0x9359bb7288b0006871e5bc7e1bc817225d7670b731f2ebfa5b00000000000000","merkleRootHash":"0x421e7ff0a50c0b492219a26759fd182688d42db22b8edcb54ce3ff360b75a4c6"},{"version":"0x00609820","timestamp":"0xc29bac66","nBits":"0x07936019","nonce":"0x21281a8d","previousBlockHash":"0xb81e852298a7c029281496887a5981b75150b2c097b62d6d5700000000000000","merkleRootHash":"0x1f66a57357246d7a780f34ca2e25b41242b4a51fa1848e4cc1af91db92920a63"},{"version":"0x00000020","timestamp":"0x73a0ac66","nBits":"0xffff001d","nonce":"0xf3c75615","previousBlockHash":"0x27d23aaeef58c4b73c28896506442bf4ccb0d46e3ebbd22a1500000000000000","merkleRootHash":"0x55018ab6dc2dbf247792b92c592024b30061caf2b21236eb0418297e44d1d675"},{"version":"0x00000020","timestamp":"0x24a5ac66","nBits":"0xffff001d","nonce":"0x97c30654","previousBlockHash":"0x2a0802d8dbd7e1922f53a68856b90bfd96c1cd57c3c270811ed995ba00000000","merkleRootHash":"0x89afc545c0a0122693f8b9f29564d783d124ea4b6f938872e05245e951c08525"},{"version":"0x00000020","timestamp":"0xd5a9ac66","nBits":"0xffff001d","nonce":"0x82507a30","previousBlockHash":"0x922b65667c9ecbd47acf446b3bb1140e30e8317a8706c68787d4217900000000","merkleRootHash":"0xee1fbbe89a5a83f3c12f1ff9d248efb03922fd7200b292d08f3c635408b908ae"},{"version":"0x00000020","timestamp":"0x86aeac66","nBits":"0xffff001d","nonce":"0x960a0a19","previousBlockHash":"0xd63169ac0adc8f155926f3c94a54137cebeb92f385246f0ed8a4ab7500000000","merkleRootHash":"0x1de1b9968f36834b589eeaab56a3b10f252fb7d7179fdb3db162ab5891455f20"},{"version":"0x00a0a726","timestamp":"0xf7a8ac66","nBits":"0x07936019","nonce":"0x573787f8","previousBlockHash":"0xaf08cfb5dc3005a0286201604694bac345028c95e9feeaf945a6c29f00000000","merkleRootHash":"0x06a8593e13fd2b707f8e8178c95158abe862723589f388f2cf58c90598c05634"},{"version":"0x0060ce22","timestamp":"0xe6aaac66","nBits":"0x07936019","nonce":"0x969fae74","previousBlockHash":"0x8f48729de1e660278ce9ac6e81b870466dfe188875c3a1b43500000000000000","merkleRootHash":"0xdbe84155fba3d348f30fbd60cb2598e321b9c26b52913ad6dc3cc9494d973dd5"},{"version":"0x00000020","timestamp":"0x97afac66","nBits":"0xffff001d","nonce":"0x66c6ea00","previousBlockHash":"0x6061d111460fd56a99277158eac4bd36af3ccdc6802b00114f00000000000000","merkleRootHash":"0x4ea99f18d014900c51f7d7b8efac2a88f398416c534ad2e5d0f05adfe79630d5"},{"version":"0x00000020","timestamp":"0x48b4ac66","nBits":"0xffff001d","nonce":"0x56256c24","previousBlockHash":"0x78b24395a7dec44e6ca42421e8ff7f123edf132e2b7ebb03f34539e200000000","merkleRootHash":"0xa6dce9e39681cddbccb89a1ad02a2bb2742e5dc9ea3f271cfb8d6324fb951103"},{"version":"0x00000020","timestamp":"0xf9b8ac66","nBits":"0xffff001d","nonce":"0xeba85f00","previousBlockHash":"0x38c8b89c4694018ceb3789fae56ba32cb5ba71baffd73323aa0641fa00000000","merkleRootHash":"0x53800bd08a783c696aafa81a5cc62ec49e7fc8d2d246899aeb41997aa3309886"},{"version":"0x00e0ff2f","timestamp":"0x54acac66","nBits":"0x07936019","nonce":"0x76f35b17","previousBlockHash":"0x1eb8454a5fd7add9fd7b227adaab3008f20d82666a2a3f72b4ccb66900000000","merkleRootHash":"0x723dbd118f1cee343d9237b9f57be90e31373460a305f3f75fbb7f6cd3c12386"},{"version":"0x00000020","timestamp":"0x05b1ac66","nBits":"0xffff001d","nonce":"0x5ffe4776","previousBlockHash":"0xf50da6d48c67f6de02bb3cd5e996c0e10baefb09ba12b89b1a00000000000000","merkleRootHash":"0xe55b29b822484cb82ddec886d3b05fb2b1ca50cbfb945ac28c788dd82322c01c"},{"version":"0x00000020","timestamp":"0xb6b5ac66","nBits":"0xffff001d","nonce":"0x90920711","previousBlockHash":"0xed98a47468214b1e8102e9062a46cc950d3602c8f6889c4eab27a84400000000","merkleRootHash":"0x670819d993e07e76c536e7cfb39056c6629f9f9ae19ed9b000e03e29c88184f0"},{"version":"0x00003b25","timestamp":"0x77b0ac66","nBits":"0x07936019","nonce":"0x10530036","previousBlockHash":"0x2e55797fea5580d69be23d841f50c9a1b68ae84a718acdfe6bea986700000000","merkleRootHash":"0x8661e1a3bc55d540190347f3f476c27d65c0027021f63959143e6c28adb72b56"},{"version":"0x0080f724","timestamp":"0xecb3ac66","nBits":"0x07936019","nonce":"0x214e7270","previousBlockHash":"0x65016a7c2dd7c731a2cfaf8257b7bc86d6b0b7265eee25215000000000000000","merkleRootHash":"0x61ccb0930e5916834bc36cb45926270582a00a6493b2ec1772195fb9e7786288"},{"version":"0x0020c932","timestamp":"0x73b4ac66","nBits":"0x07936019","nonce":"0x50022f1e","previousBlockHash":"0xa4131749820da79fb25ca3492fc4edb9958feeb8bd81bff80d00000000000000","merkleRootHash":"0x43fd84474774ee8d31c832da77e43bc5ccb830a085521e21be4439f4603dfefe"},{"version":"0x00000020","timestamp":"0x24b9ac66","nBits":"0xffff001d","nonce":"0xe50a4205","previousBlockHash":"0x323168554b66b732089a2ba6114047c0d559361ed843cefb0100000000000000","merkleRootHash":"0xb40ab80ba9321a5b8ce702b6cf530b2b1d8948b6ac900ea3c9fa6e3f97a87c04"},{"version":"0x00000020","timestamp":"0xd5bdac66","nBits":"0xffff001d","nonce":"0x7e41271d","previousBlockHash":"0xe80691ec4f59d67a64fce9b724a0f35b50b47ab69bafacfdb8733cce00000000","merkleRootHash":"0x2c0f1bfe44f6cc91c2fa5e1348bf3010e9766e6ce85f5272060ad713b4573c5c"},{"version":"0x00000020","timestamp":"0x86c2ac66","nBits":"0xffff001d","nonce":"0xebad2c1e","previousBlockHash":"0x419d306ea28d31ece21ea6d3bc12d47c1e4421c4a7c0e6389ac1d76000000000","merkleRootHash":"0x806cfe0fcea16756180cff17ccb8b00a5cfc55f17ee3f031f2d1d42ff96b5b9a"},{"version":"0x00000020","timestamp":"0x37c7ac66","nBits":"0xffff001d","nonce":"0x1498f81f","previousBlockHash":"0x0b49da93b2b65a5852a61b649ba86a8f3db4d0fc23c448a204b3b3c500000000","merkleRootHash":"0xfc5c3729216432af23d237ef059492b9516c90bf9c848d42b3d7f9811469eddc"},{"version":"0x00807f24","timestamp":"0x69bfac66","nBits":"0x07936019","nonce":"0x71852df0","previousBlockHash":"0x25c7f7f0d36689ba975177a7457587cd4103446608a35e77576422b800000000","merkleRootHash":"0xc081f6acd4930e6fff836fd7feb2671a7580388abab84422ca82302462e33749"},{"version":"0x00000020","timestamp":"0x93c1ac66","nBits":"0x07936019","nonce":"0x57834868","previousBlockHash":"0x843e3273f66b86d8f705ab5e5b45f95ccc6c5e29c56ad3561200000000000000","merkleRootHash":"0x7622d144562bd55bdb2801a5b4d5ffe83f7ecc386af9ce15b6a3705255a6ca64"},{"version":"0x00000020","timestamp":"0x44c6ac66","nBits":"0xffff001d","nonce":"0x19304309","previousBlockHash":"0xeda7d50bd009729fbaa9969e21cecd351d666ae0405fb5c22600000000000000","merkleRootHash":"0x387c6938ed1cc663101895837784a72f66917bf8057a0a09be85366e9bafd5ae"},{"version":"0x00000020","timestamp":"0xf5caac66","nBits":"0xffff001d","nonce":"0x41f0c80f","previousBlockHash":"0xb2acf28385df56317d0f4a99c8e9838185c723c514df9028c3684a4e00000000","merkleRootHash":"0x8eacca253b0a095cf03a374c765d0a3fa5da5e3b43f648157794883b11196e93"},{"version":"0x00000020","timestamp":"0xa6cfac66","nBits":"0xffff001d","nonce":"0xca4bb60a","previousBlockHash":"0xb0ed76fe106e18e1e9473aa00a1162e5aca089a0315ad4dd0356001600000000","merkleRootHash":"0x5c59db3c0c7af1982f4195456f859e97968db5457682a1b8dcfd1f5aa448b49b"},{"version":"0x00e01f20","timestamp":"0x1bc7ac66","nBits":"0x07936019","nonce":"0x0471f41f","previousBlockHash":"0x8d125c6787a88ac029fc2ef35345c1f869fe17093042546f880de88100000000","merkleRootHash":"0xa2e5bbadfdaf2890158be0bbe940b3e20603a6f61d337161d986d101e0cd814a"},{"version":"0x00000020","timestamp":"0xcccbac66","nBits":"0xffff001d","nonce":"0x6e3f111c","previousBlockHash":"0xee39ac441496d5650699c9c3fecca46b29ae2318083eab624200000000000000","merkleRootHash":"0x4eca15b140a71d1565dff099d576a3e21d69473856c3b4c7e478a854e6b8dfe0"},{"version":"0x00000020","timestamp":"0x7dd0ac66","nBits":"0xffff001d","nonce":"0xec91183f","previousBlockHash":"0xd90518bf65eac990a5117834c9dce28deb47abfe9c56d7938f835e2900000000","merkleRootHash":"0xa748ecdb484e8ea7abb12df2c78bef5653983ab65dd903a6dae16861b5936c50"},{"version":"0x00000020","timestamp":"0x2ed5ac66","nBits":"0xffff001d","nonce":"0x1dd6d624","previousBlockHash":"0x125bfc659edf36845f09e9c8cd40daa681b706d04125014b0be49b8700000000","merkleRootHash":"0x34ae85a297c75ec22699df3920205ee194970ee8fa46e0442f11a8efdae24baa"},{"version":"0x00000020","timestamp":"0xdfd9ac66","nBits":"0xffff001d","nonce":"0x097b397c","previousBlockHash":"0x750fce88cf0e20ec104d968bf575ddaf23f6f1a8d6235e0ad2a02e8300000000","merkleRootHash":"0x2a111ec87ca4cda194bb24bf7716bd4a59931f3b57092694164a95731a5eb374"},{"version":"0x00a0ff23","timestamp":"0xccd0ac66","nBits":"0x07936019","nonce":"0x873a9621","previousBlockHash":"0xe76389c04e2836479ae7fbf85d4e414a741917a3857922c9c1a706cb00000000","merkleRootHash":"0x9fd60a74f43c528eba7b1755df9a6db1608da888928c258974d9ee23a413d16e"},{"version":"0x00604b22","timestamp":"0xcbd1ac66","nBits":"0x07936019","nonce":"0x58d29d36","previousBlockHash":"0x9b1f942536d3b3d47e1827240f00cc4f13e398f6bbe3462d1200000000000000","merkleRootHash":"0x07db2199fffb2c7c382569e733ab69086df4396b3856879279dcf503171ced9b"},{"version":"0x00000020","timestamp":"0x7cd6ac66","nBits":"0xffff001d","nonce":"0x67d8c914","previousBlockHash":"0x8941e89a515178f76247002b8caed03e8a13c39e89378ebd5e00000000000000","merkleRootHash":"0x9eb9c5e883499fa4f53b8989c2eb85d21fcb1ac04dfd2249b474ca3fb0af0277"},{"version":"0x00000a20","timestamp":"0xf5d4ac66","nBits":"0x07936019","nonce":"0x4f23f698","previousBlockHash":"0x3cd099a3e7ea766133bdcd6675b113b522616e6e3a7b2f8ce6597b6400000000","merkleRootHash":"0x66047dfc2fc8222ebfda61815a65c50a21f872d11c0f393fd98b432952c51715"},{"version":"0x00000020","timestamp":"0xa6d9ac66","nBits":"0xffff001d","nonce":"0x98ec4549","previousBlockHash":"0xeb0f2d7dbb27ac5a9d1169f41b0481fff90a951a1eede4ab3d00000000000000","merkleRootHash":"0xc6b7843ca47ed2a07be15c909e947659b695a78814fcd072da609af7e894c022"},{"version":"0x00000020","timestamp":"0x57deac66","nBits":"0xffff001d","nonce":"0xe9584920","previousBlockHash":"0x1031b58ca0c6b6846a1a5c9ddf333d3831a296cf96bfbd1cd67a9ad000000000","merkleRootHash":"0x1c198bd007e070ea4c551c718908b2c63d5f7974937fdc2d97fd9d43c519e405"},{"version":"0x00609921","timestamp":"0xefdbac66","nBits":"0x07936019","nonce":"0x5a9d54a3","previousBlockHash":"0x4b94d9a3b68afeeaeacd5fe089ab13d51469a126dcf3f0d6f6b705af00000000","merkleRootHash":"0x82cc1767412a62546029845219c4544507d59fd79de4e4870a7e2efe6323ac78"},{"version":"0x00000020","timestamp":"0xa0e0ac66","nBits":"0xffff001d","nonce":"0x11fa6406","previousBlockHash":"0x176c145473b70ae2a79f5a11580eb25688c32f15b85994d61700000000000000","merkleRootHash":"0x44a5d435da823717ed033889dca1e92159e6624e38733e70862e4df6adf6027e"},{"version":"0x00000020","timestamp":"0x51e5ac66","nBits":"0xffff001d","nonce":"0x803e4203","previousBlockHash":"0x4225e978ba15dfc95da324061da2211315fbef76521ec9149aa2914000000000","merkleRootHash":"0x24ee9eae07e0cc227bdc5ced6c3451f4e6ad23894a44aa39cd56d4e80e592fb4"},{"version":"0x00405a24","timestamp":"0x08e1ac66","nBits":"0x07936019","nonce":"0x07d69963","previousBlockHash":"0xf89863dec523ec3ebd9ce9cefa6fda08d2f23bf45131bfaf48c095e000000000","merkleRootHash":"0xe4359b422e6e9dc3fd3e24154554f934890e7ddbe53fe0b776da2f6f8a4cc170"},{"version":"0x00602127","timestamp":"0xade1ac66","nBits":"0x07936019","nonce":"0x72260fe2","previousBlockHash":"0x713bb2a69157565bcde5ed83e92577aec04361ae46d55c121100000000000000","merkleRootHash":"0xc8e915a966cb40120f088470da767335bc8815a43de5c116f614d1f0ba29532a"},{"version":"0x00a0bf21","timestamp":"0xdae1ac66","nBits":"0x07936019","nonce":"0x76f41ce4","previousBlockHash":"0xb861566b8cddff6c8030f27f6f572d9f8f1682523bfa49fd1c00000000000000","merkleRootHash":"0xba4a6de11ad0dee4b7c73274fdedb5d5b301ed0b4bf717dafe4e91d0a148c93d"},{"version":"0x00c0b622","timestamp":"0xf7e2ac66","nBits":"0x07936019","nonce":"0x0d3db0e0","previousBlockHash":"0x3e3e5708df0e5a92b73df7458235965fe33a10d1f35b92f40300000000000000","merkleRootHash":"0xd72447612cc02f6984dfea46a5dab38d68ed103392ee2e972ed952e76dbd6174"},{"version":"0x00000020","timestamp":"0xa8e7ac66","nBits":"0xffff001d","nonce":"0x81cd0c01","previousBlockHash":"0xd52549c9906f043209b7f176af74b87dafef163c4f1e60e65300000000000000","merkleRootHash":"0x0e171343e65bc49ee7616787024a3bd7a6ee431ba2dae51aaa577aa34ae22cf6"},{"version":"0x00000020","timestamp":"0x59ecac66","nBits":"0xffff001d","nonce":"0xfac09303","previousBlockHash":"0x2d238ac3e8051e83be325bfa0a0e736c64d4835e1e7fee16ae2f5a0f00000000","merkleRootHash":"0x9d8905c21566de49e10374c22ff131bfbd072176d464f979257083f9507911a2"},{"version":"0x00a02724","timestamp":"0xa8e6ac66","nBits":"0x07936019","nonce":"0x08c7c5d6","previousBlockHash":"0x9bba6adf6a27874e43c802bb380a80b357b2505488ffcb047f086f7700000000","merkleRootHash":"0xd2d92be26567469af1437833c0356df035914869b33470888b1d64a42228d92c"},{"version":"0x00e0ff37","timestamp":"0xabe6ac66","nBits":"0x07936019","nonce":"0xdb073a60","previousBlockHash":"0xc629f1ce30b90239ccd5cec18bd1a5db46e9cf91ab9a2b075000000000000000","merkleRootHash":"0x93b3e6d8991117ff9d9c802aeefd3f5bb363f569a28a020537ccc12422c2f301"},{"version":"0x00e0ff27","timestamp":"0x8ce9ac66","nBits":"0x07936019","nonce":"0x5b5c26bf","previousBlockHash":"0x6e849fd35a4031d0fff67494f930d30979a597a4198cde205300000000000000","merkleRootHash":"0x5db458b7f57d8f108ad95a3f2f3e01b3c13c7898539d70c5a5f6886c6d2712b4"},{"version":"0x00007f27","timestamp":"0xefeaac66","nBits":"0x07936019","nonce":"0x7ce5270c","previousBlockHash":"0x19268eb71893e9667f0f65b60d7becd43ee2b5a2c7c203fe1a00000000000000","merkleRootHash":"0xec0cf4d5a8e114e59fb95d74bd94f2ac2e54e69de4bf8ae2946b8502c5adb7ce"},{"version":"0x00c06c28","timestamp":"0x38edac66","nBits":"0x07936019","nonce":"0x029d11fd","previousBlockHash":"0x280fe1b8261da570f86edb348e744628cef5c362d084c3ef0b00000000000000","merkleRootHash":"0x75b34b95cccca6a94d062a1b827d3fd27d5e19cabf98a94abeb9d37110083086"},{"version":"0x00000020","timestamp":"0xe9f1ac66","nBits":"0xffff001d","nonce":"0x91ed450a","previousBlockHash":"0xfe132f8f5aeed3ed76958ff277b83275d74e54da241f858f3800000000000000","merkleRootHash":"0x4c1d561760a6337caff838f81a4de6a0fda46150dd3ec2163f5a53af8bf65e16"},{"version":"0x00808020","timestamp":"0xa4f0ac66","nBits":"0x07936019","nonce":"0x8251c587","previousBlockHash":"0xf54f52fdccb3c82bb185502dd7b8302418d0cee2baa417e03ebc9cd900000000","merkleRootHash":"0xc2358b21620e8b1b52a01768f9675025eb5d7290db25b6119d99983d7d24c08e"},{"version":"0x00400020","timestamp":"0xc0f0ac66","nBits":"0x07936019","nonce":"0xe1996713","previousBlockHash":"0x824361c5689df24c270258ecec36cabd61dda390148effdb4100000000000000","merkleRootHash":"0x6e7f444058419eba2db1cf6bc2489801f4dab70b44a83225943bbcf17c4b4fcc"},{"version":"0x00000020","timestamp":"0x0cf1ac66","nBits":"0x07936019","nonce":"0x2cb3be14","previousBlockHash":"0xac642b32764431f16c96511786825e98cb80a863a3cc00f12200000000000000","merkleRootHash":"0x0874d045878a73760d8e873ee839b054071e4e3255115e1ca2449a9099eb7f8e"},{"version":"0x00000020","timestamp":"0xcef5ac66","nBits":"0xffff001d","nonce":"0x024a5103","previousBlockHash":"0xb19e0668ac3854ea1fe2ef57cbc3198acf60066b756b4d771600000000000000","merkleRootHash":"0x9072500748bd0268fff5db8af303276009f32d211d55035127868c51145041d9"},{"version":"0x00000020","timestamp":"0x9cf7ac66","nBits":"0x07936019","nonce":"0x5b17a8f2","previousBlockHash":"0x67a9cd1956dd75536e8bfd85ffdfdf2c525915feb112ba1c35114eca00000000","merkleRootHash":"0x5401215eea3dc046e45f05bd8efbb98440964a7aae54146a7dbf1fc4ca3071a8"},{"version":"0x00200020","timestamp":"0x7cf8ac66","nBits":"0x07936019","nonce":"0x430836ed","previousBlockHash":"0xf13379a12b2965ef7edc417d03a8874886b090042c5a72b00a00000000000000","merkleRootHash":"0x4f50bcc9159e7c5e4873cd608292c5b2e84a3e0ba4a5f636f6b4110f5ca58a45"},{"version":"0x00200020","timestamp":"0xf4f8ac66","nBits":"0x07936019","nonce":"0x7d7fa96a","previousBlockHash":"0x7af4237cd3e14f00151c88ec4dd9880aefb4d92d62f593394d00000000000000","merkleRootHash":"0x44b9dc164cf0d775699f04b91890030618f65d87e1ce2f6ff5a6a20c751bc0e2"},{"version":"0x00400020","timestamp":"0x98faac66","nBits":"0x07936019","nonce":"0xecf85a71","previousBlockHash":"0x44a858e9834686d5aa31ab6efcfd7f3993b3feb97fad09e35300000000000000","merkleRootHash":"0x1ce600b81e4dd14682f591407022c800bcdbc976e9c08d1b48a7be107be97cb7"},{"version":"0x00000020","timestamp":"0x4cffac66","nBits":"0xffff001d","nonce":"0xb4be3e1b","previousBlockHash":"0x654a3ef2b34e377d7ccbb47d44aa40c8b51aa82fc21680ed4d00000000000000","merkleRootHash":"0x270b59f42d204f0af0100a5bb06b39409065c524397645c77312c019c8c838c5"},{"version":"0x00000020","timestamp":"0xfd03ad66","nBits":"0xffff001d","nonce":"0xa3b5d036","previousBlockHash":"0x5f3e67129c8ff0e70dfd2d9a9fa9f5d156ef47688e28b1e29cfacbc500000000","merkleRootHash":"0x9f5c99b8f776de1d0c8e2a8333dbf7a4279b2ab60fda60a52e7520a20e878d4a"},{"version":"0x00600020","timestamp":"0x0803ad66","nBits":"0x07936019","nonce":"0x99317206","previousBlockHash":"0xbff129bf9c15833fdb58142c68f3f6fca075f8d9872e00f94f749fd000000000","merkleRootHash":"0x411fa528a66da9d361a653da61fb33a67e1081492014944d54048c66c2f9492c"},{"version":"0x00000020","timestamp":"0xb907ad66","nBits":"0xffff001d","nonce":"0x3527361c","previousBlockHash":"0xff7635755fd1db50bf9ca5d0d90511db6848d7849ff08f455e00000000000000","merkleRootHash":"0x2b98f36cec2f1dfd32006681e800e35e74f488a0ada78ae0dbb1e63d4f0cbdac"},{"version":"0x00000020","timestamp":"0x6c0cad66","nBits":"0xffff001d","nonce":"0xa762cec7","previousBlockHash":"0xf7c1fd55476b734b0f28770296a7d567ffa925f795cf0d29937567e600000000","merkleRootHash":"0xb08823153385f4919b546dc05585d1a8034dbf2eed060af85668a35ddfad4527"},{"version":"0x00000020","timestamp":"0x1d11ad66","nBits":"0xffff001d","nonce":"0x61958d1f","previousBlockHash":"0xcfd1a4c6ce3f5e86a7593577b23b0d1513518e4ac8815de481e3998400000000","merkleRootHash":"0xb4272018377bcfdf31caa64b93c5c08ad4011f3469cb4eba0ce0d5a49c7a4561"},{"version":"0x00000020","timestamp":"0xd615ad66","nBits":"0xffff001d","nonce":"0xeb8896cb","previousBlockHash":"0x22fd0400251df38e350f1e00e85ee329c06e3c5ca50bd39bda9a029500000000","merkleRootHash":"0xc82e1b780ffa97a2c7d0e08cd0bffccb169caf838b57b4483a2633f8ba64caf9"},{"version":"0x00600020","timestamp":"0xb816ad66","nBits":"0x07936019","nonce":"0x814d2952","previousBlockHash":"0xbdffe71dd80aa5fe1cce824dba5d010bfac3c81e0d381b375fd1c4a000000000","merkleRootHash":"0xb1e8a55515f2e945f2c0c411f46485114d1fd0db3e10145d4e599870fb49bd2c"},{"version":"0x00c0bd26","timestamp":"0x6219ad66","nBits":"0x07936019","nonce":"0xd0e26862","previousBlockHash":"0xd18637e22ae02c458aa6fe7ab0bb1c6fdac1163d23542bec2300000000000000","merkleRootHash":"0x8207bb64289749907459e8055121ac0c2c1cac9f9a725cbf7318ba864baf78b2"},{"version":"0x00000020","timestamp":"0x131ead66","nBits":"0xffff001d","nonce":"0x693a0d03","previousBlockHash":"0xb6c99fe3a1ea1e85aa0a287aad2dfaec8b1aa93fc3b5d7b83500000000000000","merkleRootHash":"0x3933baa8d68d19d65a0ccdf9b0c4bb19aa64b8bfec6b0556b658ac502221b58b"},{"version":"0x00400020","timestamp":"0xb41aad66","nBits":"0x07936019","nonce":"0xbca750c6","previousBlockHash":"0x14f2d5e405d17413504486054fca591b848c77e4f7fb0b53e6e1019a00000000","merkleRootHash":"0x9c3347db2322c29872c6f8ecb2d6ee566039e02eeaab71aa052470afbab225fd"},{"version":"0x00c07123","timestamp":"0x601bad66","nBits":"0x07936019","nonce":"0x547b71e2","previousBlockHash":"0xb680005aa431682f87484d7eac3e8f8e1aea025129ab49850600000000000000","merkleRootHash":"0x173121a82b867e528ede1f58c3658fca8f8b0a1c20bfd690c01b43d6a394c47d"},{"version":"0x00e0ff27","timestamp":"0xd01dad66","nBits":"0x07936019","nonce":"0xa930b94c","previousBlockHash":"0x502323070274609d2b61cf779c5e9b9f3c05a4869c4b9ff21200000000000000","merkleRootHash":"0x08a39225ac8ca9406dc6bd294e142370c4da478624d02f1ce3c5174eac57b25c"},{"version":"0x00e0ff37","timestamp":"0xdc20ad66","nBits":"0x07936019","nonce":"0x80f2dcf9","previousBlockHash":"0xe7101bfec63a1c9d9d7ebc9c82203b86c1193cb83cda13f63e00000000000000","merkleRootHash":"0xdc51e00e6d01aeb051af4ae2cd817c4c9c3f2c334e7bba3550ba92eed84a7f15"},{"version":"0x00000020","timestamp":"0x4422ad66","nBits":"0x07936019","nonce":"0xe5b39c81","previousBlockHash":"0x0d4c22c3e86cbd883ea0e15edb4542f9cb3b0315e13125c22500000000000000","merkleRootHash":"0xefb73a62e0916a7dc4cb02bee45cbf2829c694c6d159b690cadf533ca5b1cbc0"},{"version":"0x00e0ff37","timestamp":"0xbc22ad66","nBits":"0x07936019","nonce":"0x6d879489","previousBlockHash":"0xa55fb7a4d1839f0507297c19b68a89ce153193189e0d6e292900000000000000","merkleRootHash":"0xa8554b1703365cc33fa30b69fce57c9f3b5ef0401458f682842c5af960e31fef"},{"version":"0x00600020","timestamp":"0x7127ad66","nBits":"0xffff001d","nonce":"0x3744cd91","previousBlockHash":"0xcb7e3167772ece85b516352f0b27ea47867fb74e2e9b2e4a0200000000000000","merkleRootHash":"0x3957cd78992c2118c22d99df1c26d672b8d6cb9443afc98d234ac5529c8084b1"},{"version":"0x00000020","timestamp":"0x222cad66","nBits":"0xffff001d","nonce":"0x91c47b02","previousBlockHash":"0x3ffd031fb71792b0e3b44a9b6473dc62d66596ea3b0906728c35460100000000","merkleRootHash":"0xaa5ae1a29c6b6fe582db685370e3cced4c4a8e63c193adaccb875ea7463558a9"},{"version":"0x00000020","timestamp":"0xd330ad66","nBits":"0xffff001d","nonce":"0xbd7bb953","previousBlockHash":"0xc0baf66f45f2d8605f498b530f04f9479313ac0e4f1a17e6d60cf16100000000","merkleRootHash":"0xafe22fa8fe3b57d7cd14cbdbb7b8da496c124350864b8635b99053eebd3b6deb"},{"version":"0x00804d26","timestamp":"0x952aad66","nBits":"0x07936019","nonce":"0x7e01658d","previousBlockHash":"0x8e5bcc45eb90d8ad8dd10e2c9431b2d852794f6813d4091d837e71ae00000000","merkleRootHash":"0x3d256c0ff795be90316e3a3f786f5e6484915278c4350dbf5551f5e5bc1c8902"},{"version":"0x00200020","timestamp":"0xc02cad66","nBits":"0x07936019","nonce":"0x0aa1452d","previousBlockHash":"0x8783184d1dcc13b955355c0b9ba518f72f6b1eadf07901d34000000000000000","merkleRootHash":"0xd41819f3bd98ce9a9d6c1ba284b051d7ad84635b3c5f8761440230a2a519027c"},{"version":"0x00000020","timestamp":"0x7a31ad66","nBits":"0xffff001d","nonce":"0x3564721b","previousBlockHash":"0x5eea23a3288720d505adff51df7d7985d1d3d86a3734e53b3400000000000000","merkleRootHash":"0xb7060ff5662dfa5c2682a02ebf6247fada7e72ec40171cc170ae38384562cdfd"},{"version":"0x00600020","timestamp":"0xac31ad66","nBits":"0x07936019","nonce":"0xbf87f411","previousBlockHash":"0x5dbc90a0a544eb9eb854a8f7df15bee546cd181e589795162ab3a89c00000000","merkleRootHash":"0xe0a40e2a5741d82390d6309395b157805951f4aad3225efe332599c46dcf04d6"},{"version":"0x00000020","timestamp":"0x5d36ad66","nBits":"0xffff001d","nonce":"0xcf58da2c","previousBlockHash":"0xd1d971ec7135c7b7a0d51545afaffc580ab8ddb162deb8994200000000000000","merkleRootHash":"0xfbb9f40c87bd7ed171fa9ad68343c577a929bf0161a87d2db74ea13a6ba40377"},{"version":"0x00000020","timestamp":"0x0e3bad66","nBits":"0xffff001d","nonce":"0xfd3ccc0d","previousBlockHash":"0xe20971eb37c3b394319dc77aa129f2553c2e5ffd0c4aa19d9ef89d6100000000","merkleRootHash":"0xcd392f71f57993b411653d830a80499ee8f68165d6a35b14377617446253106b"},{"version":"0x00000020","timestamp":"0xc93fad66","nBits":"0xffff001d","nonce":"0xe054a139","previousBlockHash":"0xa8508445f19549cba051e6fe6a75cebbb6c71287048b60a14eef6ef900000000","merkleRootHash":"0x48b452160c269032fd73fb21f0f89fce9d21287d5a3758b3c5df16f35e506e22"},{"version":"0x00e0ff2f","timestamp":"0x4540ad66","nBits":"0x07936019","nonce":"0x05340d54","previousBlockHash":"0x254d97eab9e90e5db4bb256050daa95c1d11b42000b67d8b540bd15400000000","merkleRootHash":"0xe1c2fd2013cfa074c01c941c7543cc47776b7be2394a2d4b5e1218c6b874a812"},{"version":"0x00000020","timestamp":"0xf744ad66","nBits":"0xffff001d","nonce":"0x8ac1ce2b","previousBlockHash":"0xbe3eff217410b45281869a16242be45ac04cc47e0ff5c22d5100000000000000","merkleRootHash":"0x8ed7bef2dcbc9f9fc1748b52bd3bb2646c8c398ab38fbb65480985dd80a1fb46"},{"version":"0x00600020","timestamp":"0xac49ad66","nBits":"0xffff001d","nonce":"0x1b891688","previousBlockHash":"0x5a704a24cb918de7ae378f13aed9c31e33f533aa52852cd8e03229b200000000","merkleRootHash":"0x84396fab3f614d2afb4ab26b5c095cb5f71096d383628735c8f83d322bd06ff9"},{"version":"0x00000020","timestamp":"0x5d4ead66","nBits":"0xffff001d","nonce":"0x3548e6bd","previousBlockHash":"0x51790400f636c84d4fb42eb2006befd12280cbfb88934f2c2a7a1f0000000000","merkleRootHash":"0x442d6bc21e760a44aa1f50d8f467c30fa40460ebf21a5f092c7f059840a2531a"},{"version":"0x00000020","timestamp":"0x1153ad66","nBits":"0xffff001d","nonce":"0x5b26e5df","previousBlockHash":"0xbe1f69c5055c7579afcd848ed33543a57c457aaff90e35c27d54f60000000000","merkleRootHash":"0x740519033aa48b20b9ab39bd93d53cbbed77307ec8dbe2f636d6704bdbd685f7"},{"version":"0x00000020","timestamp":"0x1453ad66","nBits":"0x07936019","nonce":"0x3acfb942","previousBlockHash":"0xac1039752b5d887e15316def43d604cca8e7a10c1447719f264e325000000000","merkleRootHash":"0x3e6cbea308d694aeeeada3c2f15d90ffb480584a212e84ca40edbc4a84f4c4a7"},{"version":"0x00400020","timestamp":"0xcc57ad66","nBits":"0xffff001d","nonce":"0x4bc1e20d","previousBlockHash":"0x9f00f37af027644f47c10c76c5b59ed92bd368426023e5f13b00000000000000","merkleRootHash":"0xd35cefe56cd27268f60f475491f9ba48964a27acaa628f8f82f83383d5eebd68"},{"version":"0x00200020","timestamp":"0x8b5cad66","nBits":"0xffff001d","nonce":"0x3a042486","previousBlockHash":"0x9ba076d13c64ef2d34bbf54e56677a0be0dcca9f05fe731d5bc7370100000000","merkleRootHash":"0xa078dc8338fba1eb78be7a7ed2a07dc7605fc73c753674bbbe2b928957240473"},{"version":"0x00000020","timestamp":"0x3c61ad66","nBits":"0xffff001d","nonce":"0xda159349","previousBlockHash":"0xf2ccc80c8ec7f2552b757c11313460390c87d1e27c416c9849d8aa0000000000","merkleRootHash":"0x681a4c017684e63f88228673221ef3b688bbe1cab336b878efd712478917ea55"},{"version":"0x00000020","timestamp":"0xf065ad66","nBits":"0xffff001d","nonce":"0xf570f47a","previousBlockHash":"0x66aec1b4950eca43ce64c14f8d7f8f2e52d6f6d0c8619a178505bb7a00000000","merkleRootHash":"0x81344af0418ab449037ff2cec4e5f50735a43a4ad54c1eaf26e1e855355375a0"},{"version":"0x00000020","timestamp":"0xa46aad66","nBits":"0xffff001d","nonce":"0x8045451f","previousBlockHash":"0x2be673054847acac7bfd8c7ed6ba918372b945235803ca45d1de8a6e00000000","merkleRootHash":"0xd4c584a16b2d0c0771ba2106a2b684536400dc6cc831f748039664012cb2d28b"},{"version":"0x00000020","timestamp":"0x356ead66","nBits":"0x07936019","nonce":"0x5effcb41","previousBlockHash":"0xc6927db2236794a2c7d49c73f970d7d4d9a83ea397a9c26664b43b8e00000000","merkleRootHash":"0xc632c0b85e07c460f86cf2c1dd733a81d8dc195272e5e3d28329b4f134c0c420"},{"version":"0x00000020","timestamp":"0xea72ad66","nBits":"0xffff001d","nonce":"0x07102c85","previousBlockHash":"0x9489b1aea59396453ef5d488f1e554a4f3cce725094bf4e42100000000000000","merkleRootHash":"0xc75ac1723278d8612d2403f1f37ee04ff4c166ca84294f93a0f0015d1676af16"},{"version":"0x00400020","timestamp":"0x3c74ad66","nBits":"0x07936019","nonce":"0xe23617c3","previousBlockHash":"0xe17283a887f6a35e7b4a39a249a335c05178a4eb8932b66c435c150300000000","merkleRootHash":"0x7cbae6e0496adb5b789f6257d29f4ed0ec7b0a870bf72aa99dfca22e5eb2f899"},{"version":"0x00000020","timestamp":"0x6976ad66","nBits":"0x07936019","nonce":"0xcdf2de72","previousBlockHash":"0xcb681c44c1f94597b8c275faad831c78e8841650a3ffcc073900000000000000","merkleRootHash":"0x95baed6faf6616bbb39f129ee4bd16e306178816923b7a7762161a8370ca6610"},{"version":"0x00200020","timestamp":"0x8477ad66","nBits":"0x07936019","nonce":"0xe8eaf701","previousBlockHash":"0xfc94ddbff1524de6962afa102ada718d3a6c21aed16e3b474c00000000000000","merkleRootHash":"0x04f8a2873e1e0fb857b0002d414123911eecd2a4bdd230cd32aa36a03bbf5e50"},{"version":"0x00000020","timestamp":"0x447bad66","nBits":"0x07936019","nonce":"0x42eceea5","previousBlockHash":"0xde602d3aad2df459aa0bd3aa4ba18b2f819e63f4c2b7d1062500000000000000","merkleRootHash":"0xa8ff2f7442ef3ed0bcc03c055ab89dee4b234c4b6b0492645cd3dd86083f2adb"},{"version":"0x00400120","timestamp":"0xf77fad66","nBits":"0xffff001d","nonce":"0x606c16bb","previousBlockHash":"0x987db81bad442535e981eba0f5deea7de295478838248a5a5c00000000000000","merkleRootHash":"0x2cb66246357ce2737822d8990806dcddb12abbfe6f5aea91f6149de673b9469b"},{"version":"0x00e0ff2f","timestamp":"0xe581ad66","nBits":"0x07936019","nonce":"0x24439ca1","previousBlockHash":"0xb31918dc0b0ff1c4d393b33b3f60b70396c89fe630cdbb1e9ee3000000000000","merkleRootHash":"0x762f1b642f63ab7106ed60efb1ca98fc20ecb8d79f06448c35dcbe31442d9e6e"},{"version":"0x00200020","timestamp":"0xe582ad66","nBits":"0x07936019","nonce":"0xcba6af03","previousBlockHash":"0x61475e9f1d9326a996302f9efb00c222b65ece8d2b3c70d91e00000000000000","merkleRootHash":"0x628975c48b13ce85c1cdca5d847050c7da08e73adb3bffa8d58de1ab71f723e7"},{"version":"0x00000020","timestamp":"0x9a87ad66","nBits":"0xffff001d","nonce":"0x60b91611","previousBlockHash":"0x53ef62e2241f004ccba1b3857091f1074cc533529be260643a00000000000000","merkleRootHash":"0x2b666858d0b7966414884f227d4bc8ad8285ecf6895aeaf4e730fd9ee0cb5ef3"},{"version":"0x00000020","timestamp":"0xf98bad66","nBits":"0x07936019","nonce":"0x8dd37cfc","previousBlockHash":"0x9f64fbab6ceb094acc6cc5327af35128bd3b59e41b52487101b9c47b00000000","merkleRootHash":"0xc8e22ba5a6abce944618a5db9173bd6c31a3a60f6395b715251c5ee84c936352"},{"version":"0x00c00020","timestamp":"0x7e8fad66","nBits":"0x07936019","nonce":"0xb17306b8","previousBlockHash":"0x1224215c5f1c1ef4c76cc92cc1f45e6d4d05b046bcf82d065100000000000000","merkleRootHash":"0xb0bbc542c478fb39c5edbc5ab0d962efcb7f4a58dca4f16c34bd00ba4a0753e0"},{"version":"0x00000020","timestamp":"0x4d93ad66","nBits":"0x07936019","nonce":"0x307b3495","previousBlockHash":"0x3e85381f89a7cd630343b6c6b540931fe74a092b35772f132900000000000000","merkleRootHash":"0xce1c5fb9fab3ab271fb426a264b689c05d0d493cfb257ff42d3bcec6ace4aa47"},{"version":"0x00000020","timestamp":"0x4996ad66","nBits":"0x07936019","nonce":"0x82210c5e","previousBlockHash":"0xef82b5c522046b4d9bddbba079faa683f5dc897be1f19e065300000000000000","merkleRootHash":"0xe20b419f96b4a4263e63256db5591097417b3a081baf580d359bc506bfdfe397"},{"version":"0x00200020","timestamp":"0xa097ad66","nBits":"0x07936019","nonce":"0xa99382cb","previousBlockHash":"0x77b7a66233f61efbf099e4d0c796fe18403fb90df341f66f1b00000000000000","merkleRootHash":"0xce50e89754c45bc3eb1eeaa7f40516fae6e4491e432d88830fa649d68b7073f5"},{"version":"0x00000020","timestamp":"0x539cad66","nBits":"0xffff001d","nonce":"0x1558dae3","previousBlockHash":"0xac4d7bad632938f93c04f3628ad625c452360cbba147c5d63100000000000000","merkleRootHash":"0x763e6504d928b57a2923ca40ef059563c1867250bffbc321bddd812b18b7ce37"},{"version":"0x00000020","timestamp":"0x409dad66","nBits":"0x07936019","nonce":"0x84adba6d","previousBlockHash":"0x7e57ab4697aca59d3fe3b6bc193a6fe97ebf426a5d98736fb7a38f9d00000000","merkleRootHash":"0x55ec87b7f1032482607a04aced3ac266cbc213b5b339730b86e9dd59b3ceff63"},{"version":"0x00600020","timestamp":"0xc4a0ad66","nBits":"0x07936019","nonce":"0x3d1c18f4","previousBlockHash":"0x0a83d58af49548ac562a54b9741a890c5809ded521c0757b3a00000000000000","merkleRootHash":"0xf08b38804f36d6bbc904ed624a7e9068da9c18b3c3a9b3c03aeb8fa0ce661502"},{"version":"0x00400020","timestamp":"0xc0a4ad66","nBits":"0x07936019","nonce":"0xfa49cb8a","previousBlockHash":"0x57ea19011cd92588ec67f1aa3a0140880e572a9a77cc1f594900000000000000","merkleRootHash":"0xedf803a209cf5e31e17fd70c21e08b2239eac9702f4349146f1b23f1d6ac1b88"},{"version":"0x00000020","timestamp":"0x77a9ad66","nBits":"0xffff001d","nonce":"0x8e1e0e46","previousBlockHash":"0x57e384472a16bd04673d17a8a44f5378058139985ff6373d1b00000000000000","merkleRootHash":"0x2cdcb7dcc6da60d115ccc4a4311d19a89b814a2e7eae7617636d8c010554c76a"},{"version":"0x00000020","timestamp":"0x29aead66","nBits":"0xffff001d","nonce":"0x34331774","previousBlockHash":"0xaffc4852c24d51519d2a71cc6482ae93fce908ebde39e882577f06e800000000","merkleRootHash":"0x730227eab32d3ff3bc183b665febee5743dd382a8f6a5c82b53612936736d7d3"},{"version":"0x00600020","timestamp":"0xb4b0ad66","nBits":"0x07936019","nonce":"0x4a2d50c1","previousBlockHash":"0xd984f829a3f4f5d7a86093421783f66b91a44e10319534f798391d1c00000000","merkleRootHash":"0x087cc9b298a36e24c3dabaa9af075229ae554a3fa9ffef64aee1afd081e9785f"},{"version":"0x00400020","timestamp":"0x58b2ad66","nBits":"0x07936019","nonce":"0x1634ae0e","previousBlockHash":"0x1eb285c5ad5b5ff30f575a63dd2a18d93b722f8c7d46499c4800000000000000","merkleRootHash":"0x3b241c0acd03dd2c9352991f583375917f89bec95e0913404b52eb8ff88e3e4d"},{"version":"0x00000020","timestamp":"0xa0b5ad66","nBits":"0x07936019","nonce":"0xbafdaccd","previousBlockHash":"0x367bbf83b52d41f25293b06635623d42fb6c296884d730701800000000000000","merkleRootHash":"0x3c21dbd33507e80c891bb34c4a82ac2521482b57a68a34d7cdb7d1a22f72a0a5"},{"version":"0x00e0ff27","timestamp":"0xddb6ad66","nBits":"0x07936019","nonce":"0xda567639","previousBlockHash":"0x95e563c9ba8d4537604f24c4898dba7b6c4675edd4368a230e00000000000000","merkleRootHash":"0x27f89b91d5cc753aa82dc7c87997e90481d5a930bb80937c926fdd2dba14180f"},{"version":"0x00e0ff2f","timestamp":"0x55b7ad66","nBits":"0x07936019","nonce":"0xe31b0cf8","previousBlockHash":"0xf06807b7cb205bb7209b36d925e15b8f4f27227c62f17de21300000000000000","merkleRootHash":"0x5044639fec37cac4e3b89d6d5dcfd16a7b4549ff0c2669319e644bfb13f31599"},{"version":"0x00000020","timestamp":"0x09bcad66","nBits":"0xffff001d","nonce":"0xc685d94b","previousBlockHash":"0xbb8b009ea3ec5ef6f45a5903e5b630699bf9c01a734c0b302f00000000000000","merkleRootHash":"0xbbd9219ba9da79b349c501cedb9a3f6a4730f3e5ee999babd019305285b4ee6b"},{"version":"0x00000020","timestamp":"0xa9bdad66","nBits":"0x07936019","nonce":"0xfd359955","previousBlockHash":"0xb61030826bedc405c79f9154b4cd6630eab241bd8ef8a03f4989aef200000000","merkleRootHash":"0xa464ff7cb4a1956703924c0e48dcd862329e2af001b872ec990c853773927214"},{"version":"0x00e0c823","timestamp":"0x13bead66","nBits":"0x07936019","nonce":"0x1c281e83","previousBlockHash":"0x0dd100493f23c72942ed25b0a70ce89648548eed0db7913b0e00000000000000","merkleRootHash":"0x8674ae7231efa22e6c8fcecd813708429b7d502446672310cd4f7906e7809452"},{"version":"0x00e0ff27","timestamp":"0xb5c0ad66","nBits":"0x07936019","nonce":"0xbf80d4c3","previousBlockHash":"0xb6d929b38fa9feddeefcca2b4663f8eedbe8537cf336bb823900000000000000","merkleRootHash":"0xdfd147aae28c8b4dd8803d9b1d12492f50d554826cd7d6f97d5a6f02423b5e95"},{"version":"0x00006128","timestamp":"0x1dc1ad66","nBits":"0x07936019","nonce":"0x6bb12946","previousBlockHash":"0xb893630009b325525e859a0027ee43acb25e168af3d3d1b63600000000000000","merkleRootHash":"0xa3d811fd5e9d64ca68e7968b1ca6dff39cdec6beaff7a9915649b41a73fd50ea"},{"version":"0x00400020","timestamp":"0xdcc4ad66","nBits":"0x07936019","nonce":"0xca7c92b6","previousBlockHash":"0x92d1c33ea2b743418032131af91d6f7bdcf8de16b6452d464000000000000000","merkleRootHash":"0xb9038d7adb6a623446eb52f8df10077095a6f17e2c32dd15de34d36d78e73cce"},{"version":"0x00e0ff2f","timestamp":"0xddc5ad66","nBits":"0x07936019","nonce":"0x76662b52","previousBlockHash":"0xc11c3b1cb2cc5bff8b56853195ce5420b78b893268895adc4100000000000000","merkleRootHash":"0xc8ee9ba4bf3a2c6242268db6153574575df64d89699e9e0bbd7f2a82e0954ca9"},{"version":"0x00000020","timestamp":"0x93caad66","nBits":"0xffff001d","nonce":"0x277f8e4a","previousBlockHash":"0x93f23d60c883ecbe36d6927bc0a05cc39da5e588e838fd9b2200000000000000","merkleRootHash":"0x2b67d4a7e27575253b2eb8ab36e65f0769fb3a0c210234626119e5f1cffaa931"},{"version":"0x00600120","timestamp":"0x9ecbad66","nBits":"0x07936019","nonce":"0x04f3acb0","previousBlockHash":"0x1c01022c0c2ee237f77a8d069537e1eb58b3fffa89589034c99a891000000000","merkleRootHash":"0x15b8b5bf26a19f8ddebf1c03b2af1f2d1e63c32403b4b58c3416de7a80a73e6f"},{"version":"0x00000020","timestamp":"0x52d0ad66","nBits":"0xffff001d","nonce":"0x69e123ac","previousBlockHash":"0x0105108219adea317def180f15907aa29dc492248d68efc55a00000000000000","merkleRootHash":"0x5f6d2b59a361b341b4d4fcff6c299db817b78b10e92048290b7e27b3dc955d47"},{"version":"0x00600020","timestamp":"0xb0d2ad66","nBits":"0x07936019","nonce":"0xa0cb712c","previousBlockHash":"0xefd09ad1131368473e387059d4657b94ff72053b0ba6826de45ac52000000000","merkleRootHash":"0xb9087651e2707d20e4c10a081c6c4d54262705bed73495356508d13a74c2bff1"},{"version":"0x00e0ff2f","timestamp":"0xedd3ad66","nBits":"0x07936019","nonce":"0x986ae951","previousBlockHash":"0x564116ac234a685f809244274ecef06cbc2e2b874c877f173800000000000000","merkleRootHash":"0x61a180faab65219893e6078a4335ab992ec11cfa94d53beaffbc469d979653d5"},{"version":"0x00000020","timestamp":"0xa0d8ad66","nBits":"0xffff001d","nonce":"0x7576d72c","previousBlockHash":"0x8d2a1fa9b7bd6ba26a50d8c7755234f706bcb17126c2c24d4f00000000000000","merkleRootHash":"0x79ba68fa897b1218d95fe0c13a40e074ae883d50f998d1bb45de9e949f08ef11"},{"version":"0x00000020","timestamp":"0x30daad66","nBits":"0x07936019","nonce":"0x80cf8a8f","previousBlockHash":"0x141ae4555475647fdaf188fce2a08534b2ed9a9f66b72b1fd91812d500000000","merkleRootHash":"0x2dae7042758a9f30b2815c1edf7a5ce0baad39daac55bc0b4e08ff9aecd289ce"},{"version":"0x00000020","timestamp":"0xe1dead66","nBits":"0xffff001d","nonce":"0x5b893109","previousBlockHash":"0x9d482761d015eefd7265b84d70987dfa6b2e72e50a439a0f1c00000000000000","merkleRootHash":"0x37701481f75107079b346316fc840b2bec05692894a48ca4ed527aab44fe7cb6"},{"version":"0x00000020","timestamp":"0xf9dfad66","nBits":"0x07936019","nonce":"0x49d341b9","previousBlockHash":"0xb51f76c822bf50cebf881c98f7b3540c8185a8cf7eb5a77c145b517800000000","merkleRootHash":"0x24d3879d6ea535440f46eb319a0f418d9ab4377eef5e2479cf4b6d74d5ff7996"},{"version":"0x00000020","timestamp":"0x54e3ad66","nBits":"0x07936019","nonce":"0x3c946555","previousBlockHash":"0xbc9c2ddefecabd2442e38d6b907b9b5370be604b763369981400000000000000","merkleRootHash":"0x7c5dd590e401bb699ed261c0dcd572569bc0d764a9733b796f02119ba13ea6c3"},{"version":"0x00000020","timestamp":"0x05e8ad66","nBits":"0xffff001d","nonce":"0xc26ccf09","previousBlockHash":"0xdd621b6d979c0df022ebd2c9e626ec9972462e0ebc6cd1b42d00000000000000","merkleRootHash":"0x00c0f8a7cfd4ca88eb13906ba905ec272894b4973f95bf5e777b0f455eec9dc6"},{"version":"0x00600a24","timestamp":"0xb4e8ad66","nBits":"0x07936019","nonce":"0x478086b2","previousBlockHash":"0x218ef2c3137d56c595b1c73cb9a4d73b88372144d58e4d8f407ee0e300000000","merkleRootHash":"0xd70cfc2a6c264ae3b8ad62e56ffc732d52c2e76750525aeb6dfbcd5e6cd10fd1"},{"version":"0x00e0c92c","timestamp":"0x9ae9ad66","nBits":"0x07936019","nonce":"0x50d8644a","previousBlockHash":"0x6519c2eb014f98c0fff84b31541920309ecda0c197f5f9965400000000000000","merkleRootHash":"0x058398be5d9ac2ff582a821e5e1173778ae3b1ef2a09a863b98498f9eaa9e3e3"},{"version":"0x00009425","timestamp":"0x1eecad66","nBits":"0x07936019","nonce":"0x6a4d0825","previousBlockHash":"0x01c159c2c77540b9f62d17eb4a9dc91b7c86a892ededec0d1400000000000000","merkleRootHash":"0xb1ee7cdaf88a1f37efb2cb363bfcc67cf22edeaf3281ec37d550f06b5a001176"},{"version":"0x00600020","timestamp":"0x4beead66","nBits":"0x07936019","nonce":"0xd35d4d1c","previousBlockHash":"0xa6fe06ce0c8b780576b84d62711354f12ac398b96fe977340800000000000000","merkleRootHash":"0xaa16381b30ce1e9661e78e190781e2bf40f8ac0c7e90ab952b1dc90f428ab503"},{"version":"0x00400020","timestamp":"0x2cefad66","nBits":"0x07936019","nonce":"0xf0797725","previousBlockHash":"0x5ac480d67ca20df4598e30a5e9208125f5883c062db841602700000000000000","merkleRootHash":"0x2638a0a36bdb030a69791e3f8ce4de0274904e09e67de74ade054b44d0005b61"},{"version":"0x00e08f29","timestamp":"0xabf0ad66","nBits":"0x07936019","nonce":"0x1980b377","previousBlockHash":"0xdfa7a6ae68cea555f92863b95d6c711d79576a622792f28e3400000000000000","merkleRootHash":"0x51f370d98c7b4e1f321ce38de7a8f3ee5d29d90394cded2027973794e240cfa0"},{"version":"0x0040d224","timestamp":"0x89f2ad66","nBits":"0x07936019","nonce":"0x4328fa7b","previousBlockHash":"0xe060e8d4cac98dc66a64729431e037c7bcbdd47286170cdd1e00000000000000","merkleRootHash":"0x86edacf928a93d47e6481ce7547c5f12b6186d68c4c917b4764a31a0de1bfea5"},{"version":"0x00000020","timestamp":"0x3af7ad66","nBits":"0xffff001d","nonce":"0x95bc8404","previousBlockHash":"0xba828bc68b00c9d7276cd14dfee989595d5d83d0e37911e12c00000000000000","merkleRootHash":"0xec20b189e7bf04308bc95cba9fe99a6408a8646e5d5263d829743506b5668da0"},{"version":"0x00a0c02f","timestamp":"0x2df3ad66","nBits":"0x07936019","nonce":"0x4d7cd794","previousBlockHash":"0x89779551a5eee78342d50071f7d013a90cbafc7864662a90988bae9d00000000","merkleRootHash":"0x24ef1a712515519d7ef98e0b3a4d932edbf86c0f0657fa672130ec236f5b27d8"},{"version":"0x00000020","timestamp":"0xdef7ad66","nBits":"0xffff001d","nonce":"0xfa632f19","previousBlockHash":"0x634c627b5adb1d9168a8769304dd56901ac0f225a7fca47b5100000000000000","merkleRootHash":"0xe56b769877cb3aec877182fa2b11cac90976ac12f2aa04f6e4ad1ddbb8c6393f"},{"version":"0x00000020","timestamp":"0xbaf3ad66","nBits":"0x07936019","nonce":"0x04770c36","previousBlockHash":"0xbd8f8b51a6c6ef3c059b463ff2010c4f0078cb00d1c4586dd1964f4d00000000","merkleRootHash":"0xb3ce25cc98d927ba6a9f9a8a0dc40eacf2bcb62a0464083a488edfe62c0c4c65"},{"version":"0x00406e26","timestamp":"0xd5f7ad66","nBits":"0x07936019","nonce":"0x1cd87e75","previousBlockHash":"0x37142868b7fd4461618fd593aa23fec3eb802780c35fdf0a4a00000000000000","merkleRootHash":"0x3783b1b1e07c986282e41dc98d7cc5e6c149c42591cac7e686638e5dda32f9a3"},{"version":"0x00e0ff27","timestamp":"0xb0f7ad66","nBits":"0x07936019","nonce":"0x1945dec0","previousBlockHash":"0x67f705938a96b028cfeb10a5e4d798354cb5b3d289b70c7c5e00000000000000","merkleRootHash":"0xce7c83adea21c74fe22f6338c1407e062c23d47c2b6136ce9a2d9271468eadfb"},{"version":"0x00000020","timestamp":"0x61fcad66","nBits":"0xffff001d","nonce":"0x47da9e0b","previousBlockHash":"0x36cbbc0a6d416c997e54ceb9eb6a56d9305d72533184229a5500000000000000","merkleRootHash":"0xb642bd0c45f768e6cd49e0fe9f1c142bda39e5a57f150b65aff6ef61a2991ddb"},{"version":"0x00000020","timestamp":"0xcffaad66","nBits":"0x07936019","nonce":"0x2ea866e0","previousBlockHash":"0x22f0b65bda517a306034f4f27dc0f273872a3798ba228e77265edec800000000","merkleRootHash":"0x00583478d5d60b02e2e76abd7d9cd3bb05973df95138258f7f25ab5e14199ff5"},{"version":"0x00a09a21","timestamp":"0xd6fbad66","nBits":"0x07936019","nonce":"0x23e86ab2","previousBlockHash":"0x15747c667048a0673d2be085742fb981f2958317fdf8fbd75f00000000000000","merkleRootHash":"0xae10854245acd5cdf7cf127dad6a0792caf839989f6e0b2404879d1d6039f55a"},{"version":"0x00000020","timestamp":"0x8700ae66","nBits":"0xffff001d","nonce":"0xa0176a11","previousBlockHash":"0xbfaee1a7e95dc87a47b8f13cca61cba714d807320f44d9142c00000000000000","merkleRootHash":"0x3e273aef1ad2fd4dadceda66505f5aa58f591feba2115bf869f8aed1cb9cea15"},{"version":"0x00e0ff37","timestamp":"0x8afbad66","nBits":"0x07936019","nonce":"0x8d9a2cd5","previousBlockHash":"0x8592bdc9a6dd89672a4cf2ee26bf0ce11ec735c8f083666b059147ef00000000","merkleRootHash":"0x0f637bd192a2cdd0869e05d49945e4fbf778a193d1490db6955811ed778519b3"},{"version":"0x00000020","timestamp":"0xf0fbad66","nBits":"0x07936019","nonce":"0x94db8846","previousBlockHash":"0x5249c8df82c5e3f662f6abbee6d0328c1e49bd0179675ae53800000000000000","merkleRootHash":"0xdc6dd6d4c54bbd2f488d0152be2bb16b7479522102eec1131c337d89707a86d6"},{"version":"0x00600020","timestamp":"0x84fead66","nBits":"0x07936019","nonce":"0x0e4dd1e3","previousBlockHash":"0x2a0a56b2b56ffd8a32907bfecd8435520340cdb40507af861300000000000000","merkleRootHash":"0xe128ae4e27b514043d945a78af35b88e2b38a5d495470fbffe193c4447d87f54"},{"version":"0x00000020","timestamp":"0x3503ae66","nBits":"0xffff001d","nonce":"0xe6a0b9d1","previousBlockHash":"0xd5089db752c6af9f977f6622c58cdf338430ee17d188120e0b00000000000000","merkleRootHash":"0x5b848a1dda5b491c0c0ef07813e3c84cd4f4b2e5fc20de3a730655c6a0a882c7"},{"version":"0x00000020","timestamp":"0xe607ae66","nBits":"0xffff001d","nonce":"0x184b1a08","previousBlockHash":"0xe4e52766717fefee2bf66cde558a22bb77a8de23643a57fdaa2b94fa00000000","merkleRootHash":"0x0b4f93d1d0373e553428cce39460481f1981e529a92c134e5cbe776b13c28902"},{"version":"0x00000020","timestamp":"0xaf08ae66","nBits":"0x07936019","nonce":"0x9446ad19","previousBlockHash":"0x98b79a9d84298b66cf75934bfe0f9dfaf440579ebf9e3cc2216dd5fb00000000","merkleRootHash":"0x3db4c639c81c8b4a5746bcb683ff92b5c4cab191c63049156995efa2bca2b267"},{"version":"0x00000020","timestamp":"0x600dae66","nBits":"0xffff001d","nonce":"0xbd8f4c02","previousBlockHash":"0x4fe0292725bbe5d2c7805b3711e06db51affeb961a31e7670600000000000000","merkleRootHash":"0x3dc91df870704ba4918043bd7fca6a8c4254dad57b89c2ce779844a73aae3bd4"},{"version":"0x00a00020","timestamp":"0xbd09ae66","nBits":"0x07936019","nonce":"0x0f2fec89","previousBlockHash":"0xe9c29e7dae6ff8b3ac988159335036f48fff7e4b0708267acaa2911100000000","merkleRootHash":"0x4cb1a2908f022317be605e21507e5d487e7bf4f930c19792efe365f1e764b78b"},{"version":"0x00000020","timestamp":"0x6e0eae66","nBits":"0xffff001d","nonce":"0x27435f03","previousBlockHash":"0x3dc172fe17403d42874e96eeee895cad4b3506b5ced63c982d00000000000000","merkleRootHash":"0x0e51b5966c6222c212b7ab37d703b310ccfcbc1a5ff75dd72ce11b4b81ff8cde"},{"version":"0x00e0ff2f","timestamp":"0xe10cae66","nBits":"0x07936019","nonce":"0xbaec48ca","previousBlockHash":"0x720c00761a1892a075c26cfc9895726d1958bd7cf5f83d994d0cc8b300000000","merkleRootHash":"0xf4502b6a84d4862ab810810886a53dba5a44e1a41d23e73e76c92d977e7ab38d"},{"version":"0x00801028","timestamp":"0x750eae66","nBits":"0x07936019","nonce":"0x5f4118ff","previousBlockHash":"0x8b0c574c441c5e32675e4dea44106aed3221d5d221299ed82d00000000000000","merkleRootHash":"0x245d16f971e477a4918d070fef9cf53f50c2fffab0a0ab811be6b26e1aceb301"},{"version":"0x00200020","timestamp":"0x740eae66","nBits":"0x07936019","nonce":"0xaf2aaff2","previousBlockHash":"0x8eade7d7d5e820c8c76f08417e08ffc7ac585c239112839d1b00000000000000","merkleRootHash":"0x0406babaea8c7094bb34a31f78b8be954e4593252c58e178388b4f94bd530624"},{"version":"0x00000020","timestamp":"0x2513ae66","nBits":"0xffff001d","nonce":"0x2d34a505","previousBlockHash":"0x610654cff50a88ebe3b8323e7d8c543c9453e268a69f376a1400000000000000","merkleRootHash":"0x43def73158e261d4713c684e2a221e4d77eb8c33e68d12f34e553992a8715ac5"},{"version":"0x00a00020","timestamp":"0x8910ae66","nBits":"0x07936019","nonce":"0x832d0946","previousBlockHash":"0xecad87736579a35ee22621d2b385245e45928e73e96583dd2078ff7d00000000","merkleRootHash":"0x52804f2d7ee0381d0a92f41ed6b632cccf735640ae45a29d05ab174e8fd38bea"},{"version":"0x00800120","timestamp":"0x4915ae66","nBits":"0xffff001d","nonce":"0x15281803","previousBlockHash":"0xfe93ea66b5b3387ca3a5e63acf3d74bb5f3cbe9fda01cff40600000000000000","merkleRootHash":"0xdcc454e44a740ae65c66569cfcd34eac99fff1616ef2242c36ffb4556403856e"},{"version":"0x00000020","timestamp":"0xfa19ae66","nBits":"0xffff001d","nonce":"0xf7d87216","previousBlockHash":"0x65f71a16cabc3d6f249a9c75b5a773cc079d5ea4ba03841051ed000000000000","merkleRootHash":"0x1c1d162d7b10b9d3f5dd8157dc35da15875ce51f4efa1399a24e9fcf0d45e3c5"},{"version":"0x00001d22","timestamp":"0xb416ae66","nBits":"0x07936019","nonce":"0x49d46d9f","previousBlockHash":"0x98c74f5fcf2f6502507f16894cca6520563eace39aa222ec70ac028900000000","merkleRootHash":"0x491596f87f7d3e8087dde20f795e5a5ef3e02b9996e9ce8f836bda7ddf992761"},{"version":"0x00200120","timestamp":"0x9519ae66","nBits":"0x07936019","nonce":"0xd6c241cd","previousBlockHash":"0x02a433727f1b74ebe2ad8dd9980eff91f63f2bbeabb816104900000000000000","merkleRootHash":"0x44d7a6c21b5375e87086b990d75ce9b2ca4b5da9a75104763ab0406e31a579c6"},{"version":"0x00e05328","timestamp":"0x751dae66","nBits":"0x07936019","nonce":"0x69f0857a","previousBlockHash":"0xca90f838bc27dba10cbe5df600bf83ecfef79863ea00c7232e00000000000000","merkleRootHash":"0x712859b4b6ff5684a0ff506a5e78db0e9ed997d964c3ccb962d0d39d80532fb1"},{"version":"0x00000020","timestamp":"0x2622ae66","nBits":"0xffff001d","nonce":"0xd338ea17","previousBlockHash":"0xb47a2a0f99e6857651181bfcede48369227afd6b5c9a562f4900000000000000","merkleRootHash":"0x4369c5e1c9e4160b56cb402c15758f5bb6a834eef81aec528a6db554e50cbc69"},{"version":"0x0040032f","timestamp":"0x4f1eae66","nBits":"0x07936019","nonce":"0x0ae55a30","previousBlockHash":"0x5f6875319895b93a6a84ed5f08069ef269f5d418ecdf8cf1df36247e00000000","merkleRootHash":"0xa0e8ef95ee401b88a6eb830e81a3c5b4973948fd8bc5d0e4b2bbe2ffd3a4a768"},{"version":"0x00000020","timestamp":"0x0423ae66","nBits":"0xffff001d","nonce":"0x75574ca9","previousBlockHash":"0x0d62ca1a136d7a4b84d923fd280c2186413912ab6a363f885800000000000000","merkleRootHash":"0xa5162ba1bc2792bc85095722ffe62084e0625ae036e604990c24e727fa00dbd1"},{"version":"0x00400020","timestamp":"0x3025ae66","nBits":"0x07936019","nonce":"0x45973c27","previousBlockHash":"0x4009ec430c363abb7fb677b6b37cf7bfb1f701e60e818bb32c128e0f00000000","merkleRootHash":"0x8681d11b69bec6bbd417d5980260f74c76003b34f2c73ddb9978950267749a58"},{"version":"0x00000020","timestamp":"0xe526ae66","nBits":"0x07936019","nonce":"0x10e3e36b","previousBlockHash":"0x94b8947cd1ed0429aaf8c131de892abf24fb184a55f8ef5e4b00000000000000","merkleRootHash":"0xcce47743c3f4112096dda535f02a9441f7d20bdb57c47d61e8cc16b5e0856e2f"},{"version":"0x00000020","timestamp":"0x962bae66","nBits":"0xffff001d","nonce":"0xa0bf7d0a","previousBlockHash":"0x4a1a7f7c1614d39278035ce2bafb38dcd4ec63558b2bea8a0000000000000000","merkleRootHash":"0xad1a1e72b37bb0f70e05c1eb979db2f1d1c19a562ac0077e8882230dafef7f96"},{"version":"0x00000020","timestamp":"0x4730ae66","nBits":"0xffff001d","nonce":"0x96619603","previousBlockHash":"0x78c46a56de8168dfccca49a2edccd47cdbdaed8cec0246ea79bbb53400000000","merkleRootHash":"0x19fa564813fad55f9892410b4c1247290b5d7a8a83540e2fd0a4a2ac809716ed"},{"version":"0x00000020","timestamp":"0xf834ae66","nBits":"0xffff001d","nonce":"0x9499af34","previousBlockHash":"0x0d32c162d7144988122f02691cb45de5b568665ce7989282bbef539600000000","merkleRootHash":"0xe9d469fabd10ab420c9362809865b633b0baeb1754426637a28043c7c2185971"},{"version":"0x00000020","timestamp":"0xa939ae66","nBits":"0xffff001d","nonce":"0xe6ce5b03","previousBlockHash":"0x0cc6bcd2ef80a1a3c3bea148373f54d379c4565a3a932eb1c3c9592400000000","merkleRootHash":"0x4067f0371cf6cd850ce0f44dd6d5a5238b188f8529125e17701df417d384b2ab"},{"version":"0x00000020","timestamp":"0x5a3eae66","nBits":"0xffff001d","nonce":"0xa8067104","previousBlockHash":"0xade0248dcf459ff815c2c1a343a132c06b9d0f20a79d354473fe5cb000000000","merkleRootHash":"0x0973b3d32f27db408a52d97a4ec26242419e372f8ad072d54640faceda8d255f"},{"version":"0x00400020","timestamp":"0x3430ae66","nBits":"0x07936019","nonce":"0x30b046e6","previousBlockHash":"0xd617fddd9833854a70c45a042ea439358fb8229e54d29b2da40e1dd500000000","merkleRootHash":"0x013863cb4f7c787bf8a4b3e550ae71306b281b04e4eec1268d38249bee216410"},{"version":"0x00000020","timestamp":"0xe534ae66","nBits":"0xffff001d","nonce":"0x41083215","previousBlockHash":"0x21b6fdf77f1d841b7e4e01cfd65ac85ce90f904dfb7c0ed42200000000000000","merkleRootHash":"0x1a1badb9289a6dd2d0aa608cb50f17e3f14cafdd212842316ec2afc72cec5a00"},{"version":"0x00e0ff37","timestamp":"0x6132ae66","nBits":"0x07936019","nonce":"0x88c05c8c","previousBlockHash":"0x1b80eaebc3f45bdc6ddfc29a126ff3f5524af5927a00ec29a2719a0f00000000","merkleRootHash":"0x9a1debb87142f2d94613a324211614bec477d1d325b822a9ab3979f5eb4fb967"},{"version":"0x00000020","timestamp":"0x1237ae66","nBits":"0xffff001d","nonce":"0xd57bee17","previousBlockHash":"0xe1474a373ff80d8c179aae6a71b1c2f5d06a9aae94f187e90200000000000000","merkleRootHash":"0x78ce0240fdd569f025cc4be0d15f1ef2e9899abe5c8f48aac13c1550eab6e0ad"},{"version":"0x00600020","timestamp":"0xb833ae66","nBits":"0x07936019","nonce":"0xd5884c24","previousBlockHash":"0xe6ad9a08ad293aeb4968630c5905a7051dececb77a69472bbeea5e0800000000","merkleRootHash":"0x15fd18ae2cf9b40c48e666e95e2f65a5a0a69c57a31cd43bbff0185d3fd5ac5e"},{"version":"0x00e0ff2f","timestamp":"0x4134ae66","nBits":"0x07936019","nonce":"0xd5908e58","previousBlockHash":"0xd3740f8640599971b331b27073b0df3b50622c5a07fda1b92800000000000000","merkleRootHash":"0xa874bdb87c23d86e7076ba78d007729993471b7113ce41079d16e744b9ca6317"},{"version":"0x00e0ff2f","timestamp":"0x5734ae66","nBits":"0x07936019","nonce":"0x5f1690dd","previousBlockHash":"0xc274ff621dabb227cbfa213a15ee6d3cb5416271cfffefb92100000000000000","merkleRootHash":"0xc8c822ebf8241b45ecfe2983283f9f17d55fe7015f3b679048d07e975c8aa30e"},{"version":"0x00400020","timestamp":"0x6f34ae66","nBits":"0x07936019","nonce":"0x66207ff4","previousBlockHash":"0x8b1a56faa728a33424eaa27509b5adbc09b23ec37d75c22f0d00000000000000","merkleRootHash":"0x08c3efe26aee06cbf436af541ff6b0cb86ccc1eacff9f923640d170696e3c3aa"},{"version":"0x00000020","timestamp":"0x2239ae66","nBits":"0xffff001d","nonce":"0x60227c92","previousBlockHash":"0x047c832656210a75581e7ce9060ef14e20cc4f3282be1c763d00000000000000","merkleRootHash":"0x2baeb182d0b120f505ec5aa9279eed73c5a7ac35e6a56a68f07e3b75a1ebd1d9"},{"version":"0x00000020","timestamp":"0xd13aae66","nBits":"0x07936019","nonce":"0x76278655","previousBlockHash":"0x732c3e43485c2c56a89fadf669ecbaf5702eca9f08947a6022fd9f6b00000000","merkleRootHash":"0x041f8294d3f20024332091876c65e53a697c7c89d3db02c304b3924d2ecf0574"},{"version":"0x00000020","timestamp":"0x823fae66","nBits":"0xffff001d","nonce":"0x0ff1aed2","previousBlockHash":"0x357b9943d2724adca6931882566f8048bf86ebaa543cab415100000000000000","merkleRootHash":"0x28bc614e950e8ce0e12a60062b1c89d92be74b8bb1855323072fc12dd5a4caa0"},{"version":"0x00e07c25","timestamp":"0x2a40ae66","nBits":"0x07936019","nonce":"0x07a0a50e","previousBlockHash":"0x772c30bed2690113718e851fc13d76f87b50def7d464a847d0cebe2800000000","merkleRootHash":"0x47d548eeaf41798d9bdf1d1ac6f69f1087a846ef43a1ee87adcbce67fd77fdd1"},{"version":"0x00e0ff37","timestamp":"0x7140ae66","nBits":"0x07936019","nonce":"0xb0449232","previousBlockHash":"0xe30636855f3799df0773d7558fd92e4d23ebb27d120975a85100000000000000","merkleRootHash":"0xa6f16c5b641b2b61c2a0b6f7980f2b2f8031d1269a0f1947d56a2e2e087acc10"},{"version":"0x00000020","timestamp":"0x2345ae66","nBits":"0xffff001d","nonce":"0x021c12d0","previousBlockHash":"0xb2a1c91ffb04eec88d00e1081f549353eb8583df2a3bcf252d00000000000000","merkleRootHash":"0xaa307b98e1aee24c7d9f6f6b1d0102e3fbc586acd44300d5c330b4c7909da55f"},{"version":"0x00004020","timestamp":"0xdb45ae66","nBits":"0x07936019","nonce":"0x2c700f8f","previousBlockHash":"0xb549db8229ed32fb40c75d4a7789f4a6d565572a962522342380410200000000","merkleRootHash":"0xebbaf0ed7c5703a651ea171d29fe1111105f1816c8e6014b51bae1e8cd15d330"},{"version":"0x00000020","timestamp":"0xb446ae66","nBits":"0x07936019","nonce":"0x6ec19ff2","previousBlockHash":"0xe11bf3e458cd23253540f3a9d74cb833a84cfa5e7c4a85904400000000000000","merkleRootHash":"0xc5f00b1719932766f0cd35c7d38f168ad33b69de963dbf25ebfa83aead6fd3ed"},{"version":"0x00200020","timestamp":"0x744aae66","nBits":"0x07936019","nonce":"0x88636f83","previousBlockHash":"0x3b46de82cf6c3815b61670579c149f105fd15202182719073700000000000000","merkleRootHash":"0xf1aefb04251a3aebfe693fab4504e98039f6ebf29b2fb022eeb04c6f5b764332"},{"version":"0x0000c020","timestamp":"0x7f4cae66","nBits":"0x07936019","nonce":"0x2b2820d1","previousBlockHash":"0x5f5a0ae324e1dfc6dd4816d05dff3534cf3b85154d42ec211b00000000000000","merkleRootHash":"0xafc51f7fa7b7bc0542cdf59986eaacbb4f5655a328718509585159b1400ad8f0"},{"version":"0x0080c62c","timestamp":"0x654fae66","nBits":"0x07936019","nonce":"0x7ce01a11","previousBlockHash":"0x6c0794a6393e6c81d30d993ab30d157b23981863e4966ada4a00000000000000","merkleRootHash":"0x671ffae883faac675b98764250257ddea6ba1437be1223626aeaf59c8465b3cb"},{"version":"0x00000020","timestamp":"0x9c4fae66","nBits":"0x07936019","nonce":"0x04c045d0","previousBlockHash":"0x3dd937defe5c4a8a63c6c127d502b742385d17b63b14ab6b5900000000000000","merkleRootHash":"0x12ad4d332806f832763cdd3f81ddeca14383914973754386f74d27cf350ac4bb"},{"version":"0x00809c2c","timestamp":"0x1152ae66","nBits":"0x07936019","nonce":"0x5f887744","previousBlockHash":"0x2c351c730cc8b57506a7f6cba5e65a316f2aa3e7503150905d00000000000000","merkleRootHash":"0xa49d71eb5ed6694f713160f971f019f35a43d99d7949109b8e878a2a1cda14a0"},{"version":"0x0080312d","timestamp":"0x1252ae66","nBits":"0x07936019","nonce":"0x40886572","previousBlockHash":"0xe9ffb17ea010defa7257ea62347fb477d72c2ad418120f660000000000000000","merkleRootHash":"0xb5b7b54fab9ec9c798f7f4cea64af6d8a794c2a89f721df909e044a9b39718b0"},{"version":"0x00000020","timestamp":"0xb553ae66","nBits":"0x07936019","nonce":"0xc44a61d0","previousBlockHash":"0x1b012f1029dd02ff4014a4796b1cb12a122c21d2e48f1f6e4200000000000000","merkleRootHash":"0x4744c0e9e5246d9c7a34f15965f4f655545808f2c36b19e03f4ad759cd7f1915"},{"version":"0x00004020","timestamp":"0xd056ae66","nBits":"0x07936019","nonce":"0xb39025ec","previousBlockHash":"0x7e0bd9cbc54565c07a9b61b380ee9361710bf8677aba4e062700000000000000","merkleRootHash":"0x370bbe6213167f44b4c41bf11f923faab824159946ea0ab1a90ffca06fa41462"},{"version":"0x00600020","timestamp":"0x645aae66","nBits":"0x07936019","nonce":"0x387cdc6a","previousBlockHash":"0xd0ece6cee4cc2819cb4cd9dfc642525c7837e0e4db77407f4100000000000000","merkleRootHash":"0xd3fab696104ac4da80c4244a9f007f515f50cbf051d7a8328ab381613f7c8537"},{"version":"0x00000020","timestamp":"0xe95eae66","nBits":"0x07936019","nonce":"0x91b32032","previousBlockHash":"0x9857ac209673acee7c7a42d7d04ed8db51c6eb64028d67671f00000000000000","merkleRootHash":"0x024d4725a36411fd17b72f77077bb1888b3b04e9bdc7a586dff8536c62f25842"},{"version":"0x00000020","timestamp":"0x3061ae66","nBits":"0x07936019","nonce":"0xb182a3ab","previousBlockHash":"0xf06a1adce94a722b3a978405dff9a89cdf8d8a530c731be11e00000000000000","merkleRootHash":"0xb2557f8804f776214c55836eed847002f32121a2b796499e46a43605b5f6db4d"},{"version":"0x00000020","timestamp":"0xed65ae66","nBits":"0xffff001d","nonce":"0x60ff26d5","previousBlockHash":"0xc7be665cd65b23d16181295db502b71991ae91427d3e97d23a00000000000000","merkleRootHash":"0xde2639a9d79dee2919b7c0ea04669c6703b109718862ca6c5b9331dc0ae9e0dd"},{"version":"0x00000020","timestamp":"0x9e6aae66","nBits":"0xffff001d","nonce":"0xf432410a","previousBlockHash":"0x31adb41cfbf74a90329664f66fdde2f0b3d5ec0ed336f5050cea0f1700000000","merkleRootHash":"0x23f1f7ef68adf93d53bff92e02d82bc250e65b15f8d0aa0a068a0f2f5f0e2ac1"},{"version":"0x00600020","timestamp":"0x9c6dae66","nBits":"0x07936019","nonce":"0xc6bcb274","previousBlockHash":"0xcc61dcf7554a2cd878b563240ec4a17d740356c50cf5ada68d74180d00000000","merkleRootHash":"0xae8e3c41bc9a4b350c8bbe38a4ea93b71127a9d5b52ce9a1ce3e6db70457b047"},{"version":"0x00000020","timestamp":"0xf46fae66","nBits":"0x07936019","nonce":"0x69fb73d6","previousBlockHash":"0xe661d0b6a81bacdcefac8cdcafa35eef34767a8c5c262c0d3100000000000000","merkleRootHash":"0x71d31f4345428813fd5c1811f23b0be0f4e63ffda371ad9323d58782c661a921"},{"version":"0x00e0ff2f","timestamp":"0xb970ae66","nBits":"0x07936019","nonce":"0x72296089","previousBlockHash":"0x933c87e70346bb6cba65163d746329f3be4e04f2a18e890d3400000000000000","merkleRootHash":"0x95eaf5a9730b8cc2e9c8c95ae0c4f690c307a454470c05db085a4547fc664737"},{"version":"0x0080802b","timestamp":"0xd970ae66","nBits":"0x07936019","nonce":"0x36dd774a","previousBlockHash":"0xf347ec7905b07b5e220064a4b1ee665f05cea45ed97ecee60400000000000000","merkleRootHash":"0x84bfa0d516efef7de21efd723af221848f62f6d43feb3eb627a5f116b2b1ec57"},{"version":"0x0080452d","timestamp":"0x3272ae66","nBits":"0x07936019","nonce":"0x17049ef9","previousBlockHash":"0xb807ba6fd43d43bb88b1f93fda21292744f79a9e22e1073a5200000000000000","merkleRootHash":"0x30dfae2f28087960d1731100f1cfc52700a6f303ea51dba16ebf7fa1a3ae68d5"},{"version":"0x00200020","timestamp":"0x7873ae66","nBits":"0x07936019","nonce":"0xed7730ae","previousBlockHash":"0x52fa7ea17ef7ba927517f31f57a62091a889be535622652c1d00000000000000","merkleRootHash":"0x50cf91756d1436a39965143f84f890cf413570aca859aeb7f39861f9308da87a"},{"version":"0x0060972d","timestamp":"0xcc75ae66","nBits":"0x07936019","nonce":"0x668c33ab","previousBlockHash":"0x243cfdb0b9fa33b901a8c8a897c9c0f94d7f13997ed97acd5a00000000000000","merkleRootHash":"0xaf32f52243e3792fa1270c4101b540c52396cc401ae2c6d0ffcf8caf1cf4b495"},{"version":"0x00000020","timestamp":"0x7d7aae66","nBits":"0xffff001d","nonce":"0xab728304","previousBlockHash":"0xd80a6709df084242daaf9d0b142c2fd9fdec88980bbca9401900000000000000","merkleRootHash":"0x5a233cb354922a922b93485c34853d9d1f23ac1d48e0701256680c9445f5b649"},{"version":"0x00000020","timestamp":"0x2e7fae66","nBits":"0xffff001d","nonce":"0xd849bc14","previousBlockHash":"0x81df3ccfcde41b6c9f88bcadcf1b3d014e6011dcb30cf17979d9b77e00000000","merkleRootHash":"0xe73194b5326d2d56a1659c690542a3b02cf9b8b5d4f0dd1c7fe4596bba6ae91d"},{"version":"0x00e0ff2f","timestamp":"0x6579ae66","nBits":"0x07936019","nonce":"0xac64ab4d","previousBlockHash":"0x86042cb77600b3847840970de941f5dbe3cecc4da2a779386fd2b75e00000000","merkleRootHash":"0x87064ec39233327c505879d3ba1491e06750dbdeddb0d92a17f35a4284d74cd8"},{"version":"0x00200020","timestamp":"0x247cae66","nBits":"0x07936019","nonce":"0x2836c001","previousBlockHash":"0x82368a9c6cb801bd8e31378109ba450a1565bb34cb7a46825400000000000000","merkleRootHash":"0x35ee46c9648ced12f62883f95732a1a75f789f8b4a24fbe4a8dc4258369d5f75"},{"version":"0x00000020","timestamp":"0xd580ae66","nBits":"0xffff001d","nonce":"0xa9a37702","previousBlockHash":"0x64ea5c964b6eb60a68c32c588d54569a2fdcde5755dff8ec5600000000000000","merkleRootHash":"0x69d2fb99179636d93e0edf5f92fe02a8274fb1514594a1dbb220cb4a01f671ce"},{"version":"0x00000020","timestamp":"0x8685ae66","nBits":"0xffff001d","nonce":"0x61a73400","previousBlockHash":"0x8e9949fb5af99c51337afe65cd6afc8e6fbf4d65e20c2bd2299e7cc700000000","merkleRootHash":"0x63836b9ad4bd44c692a640746260797291d2699bb3586c62cd93bf6ad9cb6a9e"},{"version":"0x00000020","timestamp":"0x378aae66","nBits":"0xffff001d","nonce":"0xcd658e04","previousBlockHash":"0x05523e075136d0b754ae944e6d13097127a845c4e828027239650cef00000000","merkleRootHash":"0xd8826c9dfb9e4eb67c74e6a2569da6e7e45aeaab1ee7431378cfb2d69782beb0"},{"version":"0x0040a623","timestamp":"0x5b7eae66","nBits":"0x07936019","nonce":"0x2e60b72a","previousBlockHash":"0xa9ad55bfa3d1b5df84cc649a59a751453c9c62200a90fbaac6abd4fa00000000","merkleRootHash":"0xd43b38af59eee667c6993955b95332d453ef08cfe5f2506cb20b8a1b44211e52"},{"version":"0x00000020","timestamp":"0x0c83ae66","nBits":"0xffff001d","nonce":"0xcbb66f01","previousBlockHash":"0x3352f4f11debbca34b5f3f9c0ac9acf471dc4ed1921144ef2a00000000000000","merkleRootHash":"0xa784ca300ed27f657b75ee4ebeb607987556d940c77baed4e8949d798d485541"},{"version":"0x00e0ff2f","timestamp":"0x057fae66","nBits":"0x07936019","nonce":"0x384b7ad5","previousBlockHash":"0x549b7f313066c2a9915df397d8289ba5b77db9de9c179247c0bda4ed00000000","merkleRootHash":"0xb8c0266f180f8887b3f15e3ec5d4b0a1d6f3d2d40fef16a227ddf353730d4752"},{"version":"0x00000020","timestamp":"0xb683ae66","nBits":"0xffff001d","nonce":"0xd7686c01","previousBlockHash":"0xa316618c37784392984309d9b877f73538f06e7eda92f5451f00000000000000","merkleRootHash":"0xa1ba2172fe90cbac78c26bcd795781515531104aa158793112020c41e2d6f097"},{"version":"0x00e00a23","timestamp":"0x9b7fae66","nBits":"0x07936019","nonce":"0x71b8f3e9","previousBlockHash":"0x08c6256e02e5663f655dc953e0e7ac8355041dda12b43741e36f167800000000","merkleRootHash":"0x3bcb93e724c44e8b278d8cda0d0413d8bfc0d4d70faa7663f4f8344b38366340"},{"version":"0x00600020","timestamp":"0xa87fae66","nBits":"0x07936019","nonce":"0xb923338e","previousBlockHash":"0x066a41891884842dcde78629daeaa3f8e78e719bb83907b12100000000000000","merkleRootHash":"0x2afcc3c26af28b9741e5ad728d2632b7fb6be59e7e5cf68cf98a0a77f413a428"},{"version":"0x00000020","timestamp":"0x5984ae66","nBits":"0xffff001d","nonce":"0x29592503","previousBlockHash":"0x65926cef2b98452e95ee6e5df9b4efe48b6addd3ed0a05e81200000000000000","merkleRootHash":"0xcc275073b9dab04ce115b55c440283d1fa125d95ee994495abfc65e9ca0cbc60"},{"version":"0x00200020","timestamp":"0xe083ae66","nBits":"0x07936019","nonce":"0x3fb0a9d6","previousBlockHash":"0xbd4c52e1431fdbf5c3e19327040cb1668314466fd941137f723f3c0b00000000","merkleRootHash":"0x6ec420b16c9c8208b0acaf469d27ad06cb5f77749cb1767736737411786810c4"},{"version":"0x00600a2f","timestamp":"0x2e85ae66","nBits":"0x07936019","nonce":"0x4874521c","previousBlockHash":"0x0bf584b091a27e24a37da4f5e0011e00fdc816f5aad5f2ca1100000000000000","merkleRootHash":"0xabed8dc005b559e16a5fc5abc9b92c3a8b9db7ac526c555cd826b8314d5aea0c"},{"version":"0x00000020","timestamp":"0xdf89ae66","nBits":"0xffff001d","nonce":"0x5b79d70f","previousBlockHash":"0xe738567219c75af24385a9946ab12b31cd575498f3b0e5c50000000000000000","merkleRootHash":"0x7775c4864ccf8f5053e7d0a663869b7caf9527dec72938f0a73a5c77370f40d8"},{"version":"0x0020af24","timestamp":"0x2085ae66","nBits":"0x07936019","nonce":"0x372c566f","previousBlockHash":"0x07c862f4bd4499e81e8f33c9b944b8f2a7e3c207fbc7163a6033f99f00000000","merkleRootHash":"0x9232d86db0d21beffd1d59029cdaec2f690b13e5fd89c9c5512a8be89716fd52"},{"version":"0x00000020","timestamp":"0xd189ae66","nBits":"0xffff001d","nonce":"0x91c7fb03","previousBlockHash":"0x18c14d82ccf269b63eaa41de3c3c4310099c31b07ada5f1b2500000000000000","merkleRootHash":"0xea1bdc81d26411b30f8979d727095be17ee38df841719b4dd02bc9683d7e90fc"},{"version":"0x00000020","timestamp":"0xd684ae66","nBits":"0x07936019","nonce":"0x0abae129","previousBlockHash":"0xb976f2d4528289318677925c2ea9ddcac882ea5606bb48bfb2b7eaba00000000","merkleRootHash":"0x1006ee5845c51646512e6ea682a92fa12a81fc85bc8ec03e61cfdfaa6136a901"},{"version":"0x00808d21","timestamp":"0x2589ae66","nBits":"0x07936019","nonce":"0x4a3c43c1","previousBlockHash":"0xee9d7c36b0b7a23135ca5d216c07813a6af616b18fdb96f63100000000000000","merkleRootHash":"0xfa38582fb7b486dd96fd24e9520e141013084cf9f3eaf109c67794a2e6052dd0"},{"version":"0x0000c020","timestamp":"0x1a8bae66","nBits":"0x07936019","nonce":"0x9c103d29","previousBlockHash":"0xc7dbc0e9b98ebbe6ef66bdc07701871a8006465f14eeb8a92f00000000000000","merkleRootHash":"0xb69f2bd7092c7737676a18467ac7a8d84f681920c83818b79a7f58ab049d0193"},{"version":"0x00007d2e","timestamp":"0xad8bae66","nBits":"0x07936019","nonce":"0x30e88509","previousBlockHash":"0xd7287cb4ee37f6aaece044029873b88518d21ccb388b466d1500000000000000","merkleRootHash":"0x87fc0e3985f76b47b0eb0cc6a6b2f179f5476f6370ae2d2bec6d9dc33fa51b27"},{"version":"0x00c0d521","timestamp":"0x2c8cae66","nBits":"0x07936019","nonce":"0x184cf9b7","previousBlockHash":"0x127d0c20bc5b96130ae535a3a7eecd718c52ebb6d8a951131500000000000000","merkleRootHash":"0x0e9d08c918c52c4ef64d81fb63c3f87ea194847bd00c10ba4acb137a77ad1104"},{"version":"0x00000020","timestamp":"0xdd90ae66","nBits":"0xffff001d","nonce":"0x6261c602","previousBlockHash":"0x8b492873ace05e428be823a226d8de1637e1efd03578ba745400000000000000","merkleRootHash":"0x13ac57f7b57cce0f3ee0e7d626c1eab94ebeed7205efbbd3059983efc9e40654"},{"version":"0x00004020","timestamp":"0x738cae66","nBits":"0x07936019","nonce":"0x2286e82e","previousBlockHash":"0xf28f3482391b61bfb7473640b7d13a55dd2a4e36d38f44a34e60562000000000","merkleRootHash":"0x48ff54d2e4b98eed2b2c41b4547ae42163def76ecfdb6b3f4b4bce0813491a1a"},{"version":"0x00000623","timestamp":"0xbb8cae66","nBits":"0x07936019","nonce":"0x07c4a803","previousBlockHash":"0x673f06e095c058553620c51c8d39b0376b11b127d24e5c182800000000000000","merkleRootHash":"0x6f27915750415c5445e72f57ff31d13da55364d84aa18c2df461d88c7d677d55"},{"version":"0x0000d629","timestamp":"0xb38eae66","nBits":"0x07936019","nonce":"0x79c823d2","previousBlockHash":"0x1ae1318e1ead5a1780cd04e31997dd028631adc3a2bfec022000000000000000","merkleRootHash":"0xfc06e667b92dc53c31468f69fba53885c4215b3ad5a2647a6d3a9ccc8284c1ba"},{"version":"0x00e0522a","timestamp":"0x5792ae66","nBits":"0x07936019","nonce":"0x03d8b30e","previousBlockHash":"0x403d9455698b1f50b5bc0ee284364c7e099f5f9e9f26138f5800000000000000","merkleRootHash":"0xaa28bfaac1bda5d621a9910396a8e02fc82c28a642c6a1e67863e709761db581"},{"version":"0x00e0ff2f","timestamp":"0x6a93ae66","nBits":"0x07936019","nonce":"0xe3e5bd12","previousBlockHash":"0xc8e52ccd713f7742005101e3fbd390f941768617972cb0f21800000000000000","merkleRootHash":"0xd0b53521fce4186af8dc397048f23dc12ea8b6925a00af9ca6e2a0b9d5723b92"},{"version":"0x0000c020","timestamp":"0xb694ae66","nBits":"0x07936019","nonce":"0x878a4d77","previousBlockHash":"0xf0ae288f8a8c576e180e38f87d4fcec14c897c1516d7fd310800000000000000","merkleRootHash":"0x537358cc3c62d7448ae4457b7ce88fc736c8e9ca69b4e3a7f4cc9d0d5b69e512"},{"version":"0x0000db25","timestamp":"0x4495ae66","nBits":"0x07936019","nonce":"0x242cc3be","previousBlockHash":"0x2d74ff333942a69126becfbc455a629d669b6437a955e1aa0300000000000000","merkleRootHash":"0x2d81c6779a7d05ece0f85c6a6d7dcb014f9631a3c49ded0110ba85a7cdcdfbd7"},{"version":"0x00000020","timestamp":"0x4696ae66","nBits":"0x07936019","nonce":"0x518cc7d9","previousBlockHash":"0x2ee8497e243c0c6812eee717e2e8bfb4b89f77be9518ba5a2c00000000000000","merkleRootHash":"0x1be481f96f2dda61b5dfee1b091bdc83fe87ef1dad3256bce0ec659b2d82f9fe"},{"version":"0x00000020","timestamp":"0xf79aae66","nBits":"0xffff001d","nonce":"0xc1621973","previousBlockHash":"0x07e0b19f036fa58e57c31811c63e2a3152619a3055b30e3b5800000000000000","merkleRootHash":"0x121e553774c5094eb58fb1a02f87a4e5bf197c5838091962999c63f11a3bdafc"},{"version":"0x00e0db2c","timestamp":"0xa39fae66","nBits":"0x07936019","nonce":"0x63b0457a","previousBlockHash":"0x9547bf91f5ad7280e24740d9da4a6c5385bb57801b9d8e06715eb82900000000","merkleRootHash":"0xb2b8df154cbe971405f958c2f4fbc351564e9ecf1b71e71cb3e302af633b24c2"},{"version":"0x00008020","timestamp":"0x5fa0ae66","nBits":"0x07936019","nonce":"0xc626003b","previousBlockHash":"0xe82ba760eb42bef1b79f4c4a602418097e875ab85ffe7c4e2900000000000000","merkleRootHash":"0x1be508bcb8f505532fd874a59fa1467f882fa4c0dbbb164b52ffa4d79ea02016"},{"version":"0x00000020","timestamp":"0x7da0ae66","nBits":"0x07936019","nonce":"0x0ad85666","previousBlockHash":"0xf7c91a734ff259279e063df04b0121c997249f31f07c328c4b00000000000000","merkleRootHash":"0x28aca287d049f2808ef76d937ef9468d3b23795454c967b13f694a5954b05b7e"},{"version":"0x0000c020","timestamp":"0x0da2ae66","nBits":"0x07936019","nonce":"0x8f03ea70","previousBlockHash":"0xf488db8f6d253f6a00ead86ab1420df35a6a7941915571fc0800000000000000","merkleRootHash":"0xbb1e8f208a024e25af75f0ef35eee1904bb1803d185678e8aaf76f1bfd6c372a"},{"version":"0x00008020","timestamp":"0xa7a3ae66","nBits":"0x07936019","nonce":"0x040feefc","previousBlockHash":"0xfbd7b570b3869c4bbb54031d9661e98e2689f0c73ecf267d0b00000000000000","merkleRootHash":"0x8f220e691bb5bd8fe00735efcfebc6d851bb221620f8b843ea65c79d7a15d7cf"},{"version":"0x00e0ff37","timestamp":"0x0ea4ae66","nBits":"0x07936019","nonce":"0x2f23925b","previousBlockHash":"0x9717147db410b3500a679bb0f6d78b1e356ada71556825dc1a00000000000000","merkleRootHash":"0x0bbf1b65410bc796ddbd844f9704b96e72179458d21256724076b8252f5bdf5b"},{"version":"0x00e09126","timestamp":"0x81a8ae66","nBits":"0x07936019","nonce":"0x7ecc642c","previousBlockHash":"0xcb76b29ab255019deedb412a3a0bb6f42e210702f10401501a00000000000000","merkleRootHash":"0xdbb5c7bce78332e15b0d9f5762f467cdf50e6ecdf9d656331cdf3251e5e19bf5"},{"version":"0x00e0ff27","timestamp":"0x62aaae66","nBits":"0x07936019","nonce":"0xdba88c84","previousBlockHash":"0xa19271471a0c9b744dc078b2437135ef9f384ffd524ed80f2900000000000000","merkleRootHash":"0xe844729e3c31a81555ffcbc372dbe42fd92246a4c4e964235c4f80d9e79e78f8"},{"version":"0x00000020","timestamp":"0x0eabae66","nBits":"0x07936019","nonce":"0x89e09ce0","previousBlockHash":"0x44c9c71788280e9af9440a0843a995dc09bef1861152104b3e00000000000000","merkleRootHash":"0x184a3095a157374a5020d4d9c8fed3570dd07498446b0f1eac6ee13330b5990b"},{"version":"0x00e00421","timestamp":"0x4babae66","nBits":"0x07936019","nonce":"0x3db970a2","previousBlockHash":"0x751ad67d01adc3b4e53ad67e45a0da9750255259d0bb21a84e00000000000000","merkleRootHash":"0xb2203b296d567aa6611d83d29c6c5a2215b39b2f3d0a6775eb882f16e258067d"},{"version":"0x00000020","timestamp":"0x6eadae66","nBits":"0x07936019","nonce":"0x4b628e6e","previousBlockHash":"0x2e11190cd11468d42b64500e856d842b4e12d64fec3eeafb5f00000000000000","merkleRootHash":"0xc767423f6f5d39e137f772107e28f9819b3a4c3d981f0ae575c0a2713ae51918"},{"version":"0x00000020","timestamp":"0x21b2ae66","nBits":"0xffff001d","nonce":"0x00728ca5","previousBlockHash":"0xf909e4c2226ffb27b9bb2649b6328700cf236a75b0861aaf5200000000000000","merkleRootHash":"0xa1091c09deea709254dd68fcacbe5922d16478667e616256bfc336a240f750cc"},{"version":"0x00e0ff37","timestamp":"0x24b2ae66","nBits":"0x07936019","nonce":"0x2f995c70","previousBlockHash":"0xd2e1452e305b1f6efbbafcfb0fe11c3bb95e84b3970a507fdaccdaf500000000","merkleRootHash":"0x39b848cd8b4ceb509f62bf242ec8cfb368fa9d14f37a3f2ff236c3240be9fce2"},{"version":"0x0000c020","timestamp":"0xc6b2ae66","nBits":"0x07936019","nonce":"0xc042055e","previousBlockHash":"0x974a7c57849712bcbe8071c49ce6369e2ad7e731bb3d8c960400000000000000","merkleRootHash":"0x284acdf614dd00d5308f322572592ea37d3e1c3891557dcfa7d2357278a58578"},{"version":"0x00404629","timestamp":"0x43b4ae66","nBits":"0x07936019","nonce":"0x58f17615","previousBlockHash":"0x23fbe1e1b617db0741d8bd45402ceb987034337703d297fa2200000000000000","merkleRootHash":"0x10e24e6f384921c02a843d846a520fc5d115924935e18665dd064a2cf481f221"},{"version":"0x00000020","timestamp":"0x44b6ae66","nBits":"0x07936019","nonce":"0x042a23e8","previousBlockHash":"0x13d7d0e4a85e47de45f01b6b002efa9549aad148b2ee7d9c2800000000000000","merkleRootHash":"0x183846cc12de6ec9419b32368e55452634587fead5ef2b16b64ae55a0557ee96"},{"version":"0x0000c020","timestamp":"0xf5baae66","nBits":"0xffff001d","nonce":"0x38c938dd","previousBlockHash":"0x67fbc347d1ed16f7668d9e4a366d9b1c5f31ef81bf21b6040200000000000000","merkleRootHash":"0xa7c6d48e1afbfaa80067ad33a0f0fd1a9dd22740aef82efc22985a9d0ae475a8"},{"version":"0x00004020","timestamp":"0x46bfae66","nBits":"0x07936019","nonce":"0x358d2d47","previousBlockHash":"0x515024808730582f50e2686e49e1089d4ac2dc3c6ae5306b4365000000000000","merkleRootHash":"0x1e2c0442dceadc41d833a124eba41a93dd47842a74300920caf74c49bebda082"},{"version":"0x00803e2f","timestamp":"0xf9bfae66","nBits":"0x07936019","nonce":"0x4a514698","previousBlockHash":"0x39f1f7dbfcfa257069c0551d1e89ce20abaca8f02e5755a43200000000000000","merkleRootHash":"0xe242cfab3fa54251e145917bc9d7eaef1777175d3d3e952c3c0cb8d4d50f22df"},{"version":"0x00008020","timestamp":"0x48c2ae66","nBits":"0x07936019","nonce":"0xa0a2e4e8","previousBlockHash":"0x6852e06e4eb7b7ebdee045c96d52af9fb3dd71716e456bc94700000000000000","merkleRootHash":"0xc54e684eab507c7c2e544fdb9463bd8350dac919a88caf6e931f8d12e294e75d"},{"version":"0x00600020","timestamp":"0x64c3ae66","nBits":"0x07936019","nonce":"0x0e2061c4","previousBlockHash":"0x490ea2e209336012801d1c76ee56bdf5ecee534a5a1a35f71b00000000000000","merkleRootHash":"0x53f0e4b0f33083092bb91263fb927e8bcd16163c5f1a16fca4f485a209a7a074"},{"version":"0x00008020","timestamp":"0x68c5ae66","nBits":"0x07936019","nonce":"0x9a1e945c","previousBlockHash":"0x97f63e3d01611b06cb8464d9ae8307646118dc7b30a189dc3100000000000000","merkleRootHash":"0xbf9160862dac0f6cc3dbf81dadfc196b4a4387b745bed8a9feb84a44ca8bb91f"},{"version":"0x00000020","timestamp":"0x1ccaae66","nBits":"0xffff001d","nonce":"0x002f4115","previousBlockHash":"0x52a712f2b65575f03509c81db36901158253e3cf141fa9191500000000000000","merkleRootHash":"0x4198ce88e88f8c97a38ca4218c6b75e95dcca127b1f226795608df80b48b05e3"},{"version":"0x00c09d25","timestamp":"0x25cbae66","nBits":"0x07936019","nonce":"0x34c82249","previousBlockHash":"0x65e4ae772000c93b8bcc19c0b6195ee824b96df71098648c4c73329300000000","merkleRootHash":"0x733128ac63b6da1fe9f9c5b5de6c4e99ab101d2c061a07c5287a6005a34e31fe"},{"version":"0x0000c020","timestamp":"0xd6cfae66","nBits":"0xffff001d","nonce":"0x321c5d6c","previousBlockHash":"0x49ed983aca508606235ef0e1b6b119ab787d32e4b510a7cc2a00000000000000","merkleRootHash":"0x117097c726be30012b59b3db3bfd65c66cf2249f79f01c597b4dfce2717dbd3d"},{"version":"0x00004020","timestamp":"0x4cd2ae66","nBits":"0x07936019","nonce":"0x3145ecea","previousBlockHash":"0x872ada8b5347c3b6a2b29ac596be9e4fb2aff9a342607c377879010000000000","merkleRootHash":"0xf8f3cb7929c545d126844c4d6cac1ac7f8369e136a5b03180f87bbfda2319885"},{"version":"0x00402e2d","timestamp":"0x42d5ae66","nBits":"0x07936019","nonce":"0x7dac877e","previousBlockHash":"0x3b1c08095f7c764783e47df9fcc3ca0f1d90848b61341c685100000000000000","merkleRootHash":"0xde636a8e70e55a1df0e62b0f2acc2a2d6dabebdedcb95c46ef8a04b7583a9fe0"},{"version":"0x00e0cc23","timestamp":"0x53d6ae66","nBits":"0x07936019","nonce":"0x6e7c979f","previousBlockHash":"0x32780c312225b5ae934fb048fab35ad1dfed804c521e46b63100000000000000","merkleRootHash":"0x0717f974aca00cf45a2247be2f4f45d2401f080a0c04e57706542cbbf3795ed1"},{"version":"0x00c0ed2f","timestamp":"0x7bd9ae66","nBits":"0x07936019","nonce":"0x6794413b","previousBlockHash":"0xe2d5a3dc7004d1fd0aaeb06f1beef2e3812203a7e972d9923100000000000000","merkleRootHash":"0x344c4312098e3691a4bdab8e3f5351c3e0bd13255abb9ff2d039abd7793b1814"},{"version":"0x00600020","timestamp":"0x00dcae66","nBits":"0x07936019","nonce":"0x42dc0d6e","previousBlockHash":"0x02ce92f60fcbada2c33ea7c5b52b1d1d91de828c9a4e1fed5000000000000000","merkleRootHash":"0x91eeead781b9eb7d138a97a70b24450bf7596b7b2b4d3075d952c63ae2138d19"},{"version":"0x00000020","timestamp":"0xb6e0ae66","nBits":"0xffff001d","nonce":"0x0cd27c9f","previousBlockHash":"0x4ead5a92dd52ea55be1af65d4befac650b989078a649298f0400000000000000","merkleRootHash":"0x74e1c3f0bd71815246c743505c8272e4614bed4e7c93a6c1bb3d380bf0db2a65"},{"version":"0x00400020","timestamp":"0xb7e0ae66","nBits":"0x07936019","nonce":"0x4aa7c98e","previousBlockHash":"0x0996996bed8ea5890d79e2bf4833ce43c763f838a9ebb3fa506e95b500000000","merkleRootHash":"0xa47f23759479c7e4f02434ce61888a0d3b594858cf8a2739a29aa03a967feadc"},{"version":"0x00200020","timestamp":"0x80e3ae66","nBits":"0x07936019","nonce":"0x9d4b1b03","previousBlockHash":"0x6d0075c0045c0137d59eff9654738e786b188763d50fb9324b00000000000000","merkleRootHash":"0x5cbacf7b4c3b02320a86109602aae274649318cc5783fb4ec0bf92043bfae6e6"},{"version":"0x00405326","timestamp":"0xc4e6ae66","nBits":"0x07936019","nonce":"0x5c5d127a","previousBlockHash":"0x448f43853ea954e2791cfa9820d62a09dbfc2f988bf130ed1400000000000000","merkleRootHash":"0xd70c862de9afe01b5391ca7936ba53d70f477b84520f8e8b3a7d313227a1310a"},{"version":"0x00c0fd26","timestamp":"0x96e6ae66","nBits":"0x07936019","nonce":"0x3215446a","previousBlockHash":"0xa6c804ee77c997981240ca66a358cf81ecd9199b957a98284e00000000000000","merkleRootHash":"0x2cbf28c63166381900e46906c7feb0fc2e4f48f933a6d49ec3ae0fbb16dee165"},{"version":"0x00004020","timestamp":"0x52e6ae66","nBits":"0x07936019","nonce":"0xa3c8a4a0","previousBlockHash":"0x717b25b709797ce057677947242b9dd820f46eb2fe8b96f42000000000000000","merkleRootHash":"0xaec30f566f25a93eb856d7e4341846d1cc3e5afd522da53c524a3395db4021a3"},{"version":"0x00008020","timestamp":"0x3de7ae66","nBits":"0x07936019","nonce":"0xa440aa48","previousBlockHash":"0x785dfe25e47f030501d9aeac082fdacd03f4955835d5c85f2a00000000000000","merkleRootHash":"0xab9afe044f676c4bb0515457347ce957e87fed1b023e440a33cfa151dcee26c3"},{"version":"0x00000020","timestamp":"0xeeebae66","nBits":"0xffff001d","nonce":"0x29986200","previousBlockHash":"0xc8abf1ac0cefb7de5c0eee90b37fcd1a036abf9d3cfc2da82600000000000000","merkleRootHash":"0x3f2e57a57e2bf49f17f2c929c5d6ba836d736b38a8c97a5b764ff6e79e5026ce"},{"version":"0x00e0ff27","timestamp":"0x5eeaae66","nBits":"0x07936019","nonce":"0x20ffe4f7","previousBlockHash":"0x848aef0650f76eaabd95a12c54d7ce7cd186ebd044de651b526df1f300000000","merkleRootHash":"0xac73fff118b850650987b6697104979cfeda8d53e5698581d1372ace19805084"},{"version":"0x0080c923","timestamp":"0xf8eeae66","nBits":"0x07936019","nonce":"0x46d0f418","previousBlockHash":"0x2ec33d2de0cf6b96d0ad5a733ce7ba0658da4a03814656a90e00000000000000","merkleRootHash":"0x81b9c5043260f93152100ff51b8b5114e939163648eb9e082f72e25ec9558e3b"},{"version":"0x0040aa21","timestamp":"0x00f2ae66","nBits":"0x07936019","nonce":"0x579170e5","previousBlockHash":"0x57c92f608d67fb9edc4b7a06407b77545ba1308097e8ddd05100000000000000","merkleRootHash":"0xf94b17e8bc5007298f0174c44c65be04e0069f40eab4426e5dd34f0760853daf"},{"version":"0x00e0ff2f","timestamp":"0xdef1ae66","nBits":"0x07936019","nonce":"0xc45bf82a","previousBlockHash":"0x43e475d5446538d1d677c2607666168da62ba6b2665fe0dd5700000000000000","merkleRootHash":"0xd3a2eb9f05f560d34968c7201a4b07299f269c114417e0752034dcffc2cff54c"},{"version":"0x0020ef2f","timestamp":"0x96f3ae66","nBits":"0x07936019","nonce":"0x1b1d6733","previousBlockHash":"0xf8c6408fc732dc96d05e4c44dbf6546d2312a9c651daf9de2800000000000000","merkleRootHash":"0x60b2f39dd93ae9c5bd438e0e67838f50d187740d3c93fad9d274cf16419faf7a"},{"version":"0x00806328","timestamp":"0x1af6ae66","nBits":"0x07936019","nonce":"0x68354749","previousBlockHash":"0x378554ad47b45de466392fa423e27427aff2ce67990e03665800000000000000","merkleRootHash":"0xdcfe5394955b595642f72c4db797ff100a1dec1c82f0be633c552a7044c2be28"},{"version":"0x00600020","timestamp":"0xcdfaae66","nBits":"0xffff001d","nonce":"0x3b0e50d4","previousBlockHash":"0xa1605aaab1e863a37ada4c2d976a54c32e23dae027b521902600000000000000","merkleRootHash":"0x318d3726edf7228e13c97c622463b66b73e847e7e08dca7855930b79abe3c700"},{"version":"0x00000020","timestamp":"0xf0faae66","nBits":"0x07936019","nonce":"0x216a70e6","previousBlockHash":"0xc5c33af78a7659de7e8e5fd2c641b5c414f87e3ab757aa4bc15f6b0000000000","merkleRootHash":"0x4a43032db05dadfdff6ee56e6675e81f15bfa0f88a875d36f3618f5d5fc82b89"},{"version":"0x00600020","timestamp":"0x84fdae66","nBits":"0x07936019","nonce":"0x9da4472b","previousBlockHash":"0x85bde2837658d09f9442585a80173684e1bbcc47ef7dc7690500000000000000","merkleRootHash":"0x66eeac03996a5ea0d6e4538d75d9a9329fac8e815a15d61e18fc98c58236676c"},{"version":"0x00000020","timestamp":"0x3602af66","nBits":"0xffff001d","nonce":"0x9dac9e25","previousBlockHash":"0x8e2a8cd028e0816e853bd7c4fca88603f391e85118d1e4aa0000000000000000","merkleRootHash":"0xee0b9c9f48dde5cebd46bcf4448295a6f73817249b9477978fee3b5de0635fc1"},{"version":"0x0000942c","timestamp":"0xd803af66","nBits":"0x07936019","nonce":"0x5b54fc86","previousBlockHash":"0xdff4e03a2b0c2e5173c82b03a44b5f9b2975174fa3efa37041fcd06b00000000","merkleRootHash":"0x636f21e97682e7839167528e3d20846ed8fe17ee5cfb631cb1cc7b62a7d85ee3"},{"version":"0x0080592b","timestamp":"0xb103af66","nBits":"0x07936019","nonce":"0x0b88055b","previousBlockHash":"0x39ec2ad028592fd31b213d708de76055b4237877fa7b8be31500000000000000","merkleRootHash":"0xca134b33b2f5f3d59c9da4cbcc195602bea1638d10f39f146d0b751e42556ece"},{"version":"0x00000020","timestamp":"0x6908af66","nBits":"0xffff001d","nonce":"0xee0ba0a5","previousBlockHash":"0x321dc9ea88a52616fe0b89ef4fb176a743b15dbcc9f71dcf4b00000000000000","merkleRootHash":"0xf75009fb00f2f8c453062e156566cfd7e74276d70530a0631e628d098b6dc0d1"},{"version":"0x00600020","timestamp":"0x8808af66","nBits":"0x07936019","nonce":"0x5f667272","previousBlockHash":"0xf947e806c97c0a163a9710c5d03356f7e6b9164c024660865fcb307d00000000","merkleRootHash":"0xa749867b895bd336fb02070b1e826097056c68d4662ff07739d1623cc2422481"},{"version":"0x00004020","timestamp":"0x450daf66","nBits":"0xffff001d","nonce":"0xd2094791","previousBlockHash":"0xcecfd896687e3a10bf50e72e31f79688009f47e72a91d0262700000000000000","merkleRootHash":"0xde72b22dc74833f97ba0957572a18483b3a09bd8dcd9bc0c62c1de7f6e9d3812"},{"version":"0x00000020","timestamp":"0x760eaf66","nBits":"0x07936019","nonce":"0x7ddf1080","previousBlockHash":"0xffd0aefc5f02b99c7f2f329f52254114070a1be32c087367bf3f010000000000","merkleRootHash":"0x108ff61f843488cbc8068dbb3e0c2bdcc66ac5ff585bd215b8bf5955037d26a1"},{"version":"0x00407921","timestamp":"0xc910af66","nBits":"0x07936019","nonce":"0x4ba576cd","previousBlockHash":"0xbb237af688e06354439183a01880dea03ff665cc6c2f099f2200000000000000","merkleRootHash":"0xe173097cc4dac9a351657b976bc22a70fe2690d0e7b4f2daf6e191a460c36cfa"},{"version":"0x00e0ff37","timestamp":"0x3612af66","nBits":"0x07936019","nonce":"0x98bb0edd","previousBlockHash":"0x108130d8855796497946fefa9aa8deced6e1fa086499587c5400000000000000","merkleRootHash":"0xde01c68eb4c371cba0428cf2d66e30df8ddf879582caf2952f8cbdb765b473d8"},{"version":"0x00000020","timestamp":"0xe716af66","nBits":"0xffff001d","nonce":"0x00c1033d","previousBlockHash":"0x1274036f01a5c12e1c4c260504aac1498edb8beb633fa8e81800000000000000","merkleRootHash":"0xa854b11142eef7a84f23f3f513452bc492a02e4c51b7b2d8a53366345ccdb828"},{"version":"0x0000c020","timestamp":"0xd31aaf66","nBits":"0x07936019","nonce":"0xaccebcd5","previousBlockHash":"0x13f231efdb0ab33edba931297d810d8982b9b7fbd0f142d1328765e900000000","merkleRootHash":"0xe2f65264ca09bfac0b487c0c0d9422c19c437e6f9af406a8e8bc6efb7d502e3b"},{"version":"0x00600020","timestamp":"0xec1aaf66","nBits":"0x07936019","nonce":"0x20b393c3","previousBlockHash":"0x8969d73bc3e23ee2141c2559060dd9c465cc46026bd4a26f2c00000000000000","merkleRootHash":"0x24e33f4727025cd0bb8e89edd24c0bc4fffd77231f58189ec423074eaadd38a4"},{"version":"0x00e0de28","timestamp":"0x3c1daf66","nBits":"0x07936019","nonce":"0x5488cc89","previousBlockHash":"0x894463f16447171cac3137a56e03bc87c377fb1484bb13c15c00000000000000","merkleRootHash":"0xae39cb932a0f8bcd8d4ce41c295709cc849122d50cc615fa1baabbba42cf6537"},{"version":"0x00600020","timestamp":"0xfe1caf66","nBits":"0x07936019","nonce":"0xab6311ee","previousBlockHash":"0x4e5c1d29962e177f565e78c79879051737457045b9913b541500000000000000","merkleRootHash":"0x220a46c07bf69065ce9ab24de5d8305b757e868b48e980b2a79a0b4141766984"},{"version":"0x00803227","timestamp":"0x3620af66","nBits":"0x07936019","nonce":"0x776c7f97","previousBlockHash":"0xfda09e4d5932ae60533c5f924e21e3f74ab43b36806f61263800000000000000","merkleRootHash":"0x401f151475b1fa39ce81ec4f4ed8867dbbf8c112ad62013a4af0c321548d24d6"},{"version":"0x00000020","timestamp":"0xe724af66","nBits":"0xffff001d","nonce":"0x89310c04","previousBlockHash":"0x9f62af83fbc05455605f417eea1e7db683539375e938da100400000000000000","merkleRootHash":"0x4a46a0c7f3453399f1db58a90e64984be1f8bd6eeba193799859d3fd97b02df8"},{"version":"0x0000c020","timestamp":"0x0723af66","nBits":"0x07936019","nonce":"0x406597a1","previousBlockHash":"0x180020b3e9a8ff7aeba5f42c1d59b64584553164c817dbbd678880c200000000","merkleRootHash":"0x641bc027fc8543f7816a2d0ee1a3c4d0cb74ea60de50f7f3331d454ec50553a2"},{"version":"0x00603c25","timestamp":"0x5b23af66","nBits":"0x07936019","nonce":"0x2a48496e","previousBlockHash":"0x0ff7c0648e21e2ee489ba1592f38796070ead377b4f594f14a00000000000000","merkleRootHash":"0xaacb4479eb0810fb5dd0c1c773562c96d72e892e412fa49960cfe9a5dd9d3fd3"},{"version":"0x00000020","timestamp":"0x0c28af66","nBits":"0xffff001d","nonce":"0x3749e20b","previousBlockHash":"0xd8a6e5e3b87bb518db185ba148f6b1618c4aa8c9f85f6ae75e00000000000000","merkleRootHash":"0x14dbc1c874afb73b926fe8133af8c98582fc286ceeebf38be66f1f31db1eabf9"},{"version":"0x00008020","timestamp":"0x1925af66","nBits":"0x07936019","nonce":"0x3b899b77","previousBlockHash":"0x22892e309e48361ce2dcc72dab2e852f81a375f9d963e7759e6213cc00000000","merkleRootHash":"0xaec1ef05e52db624adc7ff8b8cb6482f5403c1cdded393ecfc1fc8c0226cb306"},{"version":"0x00000020","timestamp":"0xca29af66","nBits":"0xffff001d","nonce":"0xbacc5915","previousBlockHash":"0xe79b6505aae38fcc8e8fd2726333cb6ad72f5194cec231ff1000000000000000","merkleRootHash":"0x20d47baf8dd12116f2fde07d72b6e4876f240669d49450a8c0d80090fe9d6cd7"},{"version":"0x00000020","timestamp":"0x1c29af66","nBits":"0x07936019","nonce":"0x1d405902","previousBlockHash":"0x1191b6bb405df2ad23b2ea6a8bf6b5f17507a6f8a0e1a8b1d1e8846e00000000","merkleRootHash":"0x3cfc363311721473f61d88be94bef167a04eaf20e2439b01b441c5c2c5ee819f"},{"version":"0x00000020","timestamp":"0x322aaf66","nBits":"0x07936019","nonce":"0xb4c29493","previousBlockHash":"0xb5aac14f1efb2af46e174734c467dbcbcb8722c90eafa8290a00000000000000","merkleRootHash":"0xad741b35f8389b40bcf08aafae45de98f33b8dd8cf219393fa1e6e3930683449"},{"version":"0x00606423","timestamp":"0x362baf66","nBits":"0x07936019","nonce":"0x54dc0e7e","previousBlockHash":"0xb5c5eda938fc528cd9495c4f3b76ad209b1b5a0e53cf0eb02a00000000000000","merkleRootHash":"0x3920f8bb9d5b146c33a63f59000d12453f8d8b523304cd200a49cc526a3ac5aa"},{"version":"0x00000020","timestamp":"0xe72faf66","nBits":"0xffff001d","nonce":"0xe34f2806","previousBlockHash":"0x91df006abdc5ef5c69c346012e4d92bbbf6317c37390a7350400000000000000","merkleRootHash":"0x886bddf55216fb51419cf721ac855a8d55fd575c4c0056a0d862e4e53a4d0736"},{"version":"0x00000020","timestamp":"0x9834af66","nBits":"0xffff001d","nonce":"0x57117007","previousBlockHash":"0xb224f22bae0574f6190a702c49d8e4d226c308370b1caef6676e05a200000000","merkleRootHash":"0x0c94e9b7545bd1db0aebef385899623937ac096c73f9e5a1a9277caf39cc098e"},{"version":"0x00a0552e","timestamp":"0xbc2daf66","nBits":"0x07936019","nonce":"0x5c34aa78","previousBlockHash":"0xd4a2a821f97de0410518ea04eec994202f984cedf7057a40aca8915e00000000","merkleRootHash":"0x7112cfe2eb11e25968907631cf147561346923d6d0f987f4735b4b86ef6d8bc6"},{"version":"0x0040b124","timestamp":"0xf92eaf66","nBits":"0x07936019","nonce":"0x76581e4d","previousBlockHash":"0x186e9215a8c28ab9ca18f7458db0b83304ba09f44a359db82e00000000000000","merkleRootHash":"0xf51452289d949dcac55e9907255db69c917f12dca247c641e4144bb1d5c66ade"},{"version":"0x00200020","timestamp":"0x802eaf66","nBits":"0x07936019","nonce":"0xae1fe410","previousBlockHash":"0x435453bb9c3d44abf89bb434a00f47650de0f2f47cb608d91800000000000000","merkleRootHash":"0xf04f9a8db07a283bdefaf5ec9138bf87645482200a87e08796f26c629162e1ca"},{"version":"0x00000020","timestamp":"0xb132af66","nBits":"0x07936019","nonce":"0xc0024c09","previousBlockHash":"0x6db831bcb58d829049aa8d6f4277ca378c1da9ace1dcf7423000000000000000","merkleRootHash":"0xd8720283803456fab693a9eef322c2ac9b2264d5f7751388c48477c04d9064c0"},{"version":"0x00000020","timestamp":"0x6237af66","nBits":"0xffff001d","nonce":"0x83fd5b03","previousBlockHash":"0x51d3eff5bcb9e9b5c6b886d6a08b80eb80880a5c9d5323bd5b00000000000000","merkleRootHash":"0x505c7f0b522871909cf7c771e8562cd60e01e5bb4bedd0dea2d8d8a3c81401a4"},{"version":"0x00000020","timestamp":"0x9636af66","nBits":"0x07936019","nonce":"0x322699b2","previousBlockHash":"0x5ce0e2cea2fe1e4bf1a537198fcb904ac18a0c47140a2d378c6a5e5800000000","merkleRootHash":"0x723b46c829a707aa1048115e4f3a9ecbedabed9061c4fb7919225fad7b0a2dca"},{"version":"0x00000020","timestamp":"0x473baf66","nBits":"0xffff001d","nonce":"0xbbe2c712","previousBlockHash":"0x7bc1c14958878af092117a3b30965fbd379a6218e31a2a1d1800000000000000","merkleRootHash":"0x09a723205191284464207d6386b66de10517e96a130d2fc76d9f4057b3b87c06"},{"version":"0x00e0ff37","timestamp":"0xe238af66","nBits":"0x07936019","nonce":"0x22fe7075","previousBlockHash":"0xc6fe8cb1cb83d15165b1b58cd96764df566134d8cf578a8ffa67b22c00000000","merkleRootHash":"0x678b066d2e3667c898d8cfd52e81bdbf88c1ddc8533717f73883cec4bca48858"},{"version":"0x00600020","timestamp":"0xc039af66","nBits":"0x07936019","nonce":"0x43dc5765","previousBlockHash":"0x61bd66823998283114864fca2d4dbab645b78528f4504baa2300000000000000","merkleRootHash":"0xf9b334b9ca0cbbe0b10e0d6a4466fde22055aa1c0f9bd9992bcbfb17eabe5446"},{"version":"0x00400020","timestamp":"0xcc3caf66","nBits":"0x07936019","nonce":"0x80cb4e72","previousBlockHash":"0xee385d744f6ab7c88791a3baf167b7f43e97be8da7d8ed1d4700000000000000","merkleRootHash":"0x1f187ea9228b3d71fdd145146f1a030efe2e2c7f5c6a6f971e1ff1009049de1c"},{"version":"0x00e0ff2f","timestamp":"0xf23caf66","nBits":"0x07936019","nonce":"0xbc7fa013","previousBlockHash":"0x005048fd102fab07ac9cea7b771cdba5d98fc19968209fc40000000000000000","merkleRootHash":"0xfb5be24bf9eb7d68afd7accdfe91d2c05e1abb535abd6244f2a650d52119a601"},{"version":"0x00600020","timestamp":"0xc840af66","nBits":"0x07936019","nonce":"0x770cf166","previousBlockHash":"0x59464909325cc502b7392dc4c49a7d4b94d8acf1891cdc610d00000000000000","merkleRootHash":"0x258bf9c6242c3fb5d6f198ec74cae18ce64a04eb5d52b6c8163ddbc34db49803"},{"version":"0x00000020","timestamp":"0x7945af66","nBits":"0xffff001d","nonce":"0x212dfa03","previousBlockHash":"0x1522c36dc1ce0ab0ba9cc06df5164af13b05aa12356e57db5d00000000000000","merkleRootHash":"0x190f6678f406d0dccc3af559b122059a50549d6ff63a88a2eed2734199f97410"},{"version":"0x00e09f2b","timestamp":"0xb043af66","nBits":"0x07936019","nonce":"0x0a0439a8","previousBlockHash":"0x2bc0bdc821ee03af3cb3440dff0121ca2fda37e1c0d52f17bbd836ee00000000","merkleRootHash":"0xfd63cf22e3beb9596304d2c76c2a3912414190a9d8895ee4ed369b1b12eaf30c"},{"version":"0x00004020","timestamp":"0x9c43af66","nBits":"0x07936019","nonce":"0x885c5883","previousBlockHash":"0xbae76369b539dd6b12120ae3642f927868c7f0c23d90b0aa3300000000000000","merkleRootHash":"0xec6a6aab9be415d7abcccda2eb5abf53084622f9e7d126fc36ece3776df7e72f"},{"version":"0x00000020","timestamp":"0x5048af66","nBits":"0xffff001d","nonce":"0x27b571fd","previousBlockHash":"0x7a67027a5fa51c1cbe9cde9a3c8a5d014b0ba08fe7c3e1830100000000000000","merkleRootHash":"0xf883dfd39d94ac442a5135673e65057319e867f2a1d812e3891d7137eb726207"},{"version":"0x00000020","timestamp":"0x014daf66","nBits":"0xffff001d","nonce":"0x48107e13","previousBlockHash":"0x59afcfc4dc1bb2a0a90741f75b1c45806524a376d25904929734a76100000000","merkleRootHash":"0x1931ccf4524df884d20815d49e532513c5940fdcedd1b0e6ad58621feea7cc9c"},{"version":"0x00400020","timestamp":"0x544baf66","nBits":"0x07936019","nonce":"0x2dfd4a22","previousBlockHash":"0xfbf6ac2d191dd087f2657adbdb4c7fde711735ddda1774199ea0b3f600000000","merkleRootHash":"0x0c2f8ef754556cdc93a8ddb77a761f15b351dc2e663add1dd6e1931a7fac23a2"},{"version":"0x00200020","timestamp":"0x444caf66","nBits":"0x07936019","nonce":"0x1facc528","previousBlockHash":"0xdae390f456686b8f981247832da8a0cded62061a3dc451a83e00000000000000","merkleRootHash":"0xa9e438798809ed40aac2224c82ae8119c85d49fea900453500f8cc96f2976fec"},{"version":"0x00200020","timestamp":"0xac4daf66","nBits":"0x07936019","nonce":"0x6f90d9f6","previousBlockHash":"0x74266970f8bb9bdff6ff2651a56c18050b2cc7c0281c8c134d00000000000000","merkleRootHash":"0xcd2f09e5fb01e343e8608749872e996aca7dee42351ecd237f1ba9762716857f"},{"version":"0x0060152d","timestamp":"0x2150af66","nBits":"0x07936019","nonce":"0x58249ec0","previousBlockHash":"0xbfc823603b83cb0b5c395d40560259848cf63e4cb344a8b40f00000000000000","merkleRootHash":"0x852a7f2f037f3300b9772f0881a8586ac529b0d20ea8778ff5879d9251cabfd1"},{"version":"0x00808e24","timestamp":"0x6354af66","nBits":"0x07936019","nonce":"0x6b9c6b45","previousBlockHash":"0x4e883da4f6bdd5510fae62c9b62749a2e5ff3a11b92eb8025900000000000000","merkleRootHash":"0x859d5f57b8170d1c3b818c25f8287a3712366fac8dbb2edd6343d6eef1af5607"},{"version":"0x00e0372e","timestamp":"0x7456af66","nBits":"0x07936019","nonce":"0x1e08db58","previousBlockHash":"0x7edf5fe966955ebb70944fc20596a296b085a644ce43e8160e00000000000000","merkleRootHash":"0x2f24718d9ccd621c753920a0c74638bd440892c12084d75ba9ab10d97b32bf2d"},{"version":"0x00400020","timestamp":"0x3858af66","nBits":"0x07936019","nonce":"0x01859f6b","previousBlockHash":"0x326d6d6dec51640f2347f92541a52a4eb5ea4dbe7a35b6b00b00000000000000","merkleRootHash":"0x469b5ce3216ba8e15385ae2f24409cf6dc34083e910a8e7c90cd0d7d8afe5cc9"},{"version":"0x00600020","timestamp":"0x7458af66","nBits":"0x07936019","nonce":"0xb50a8dcc","previousBlockHash":"0xc78c8321b2f2ab5ad4bb0d2fb223f4b90580bb2544ae00455f00000000000000","merkleRootHash":"0xe3c94faf0fe6127a752d7df62749d6c49562ec5b3c4a07c5c3521dafb0f34a0d"},{"version":"0x00e0ff37","timestamp":"0xa158af66","nBits":"0x07936019","nonce":"0x55e59382","previousBlockHash":"0x08058abb7c78865d7bd5740ded688312e9e7783972ecfe632800000000000000","merkleRootHash":"0xe8db6818c82b8312d4c0a8a94419f4fd2506a3978841d91b79be84899fea879a"},{"version":"0x00a0de20","timestamp":"0x2b5aaf66","nBits":"0x07936019","nonce":"0x35c431ce","previousBlockHash":"0xbd38fa3cc74d81f2ce58c314443ad5ee8e8edb44f1cd48da2a00000000000000","merkleRootHash":"0x76b66f8c486727ba3d8a5c241ebf8cd02cc2849933ef8801492b174d887b2152"},{"version":"0x00a05b28","timestamp":"0x855eaf66","nBits":"0x07936019","nonce":"0x64014b9e","previousBlockHash":"0xe6b06a9c5cf0c5741702a8aed4233644d37c6067ce0df8974300000000000000","merkleRootHash":"0x734735d1dc7c345c3973af3af76f99a03cc5fae5bf7740a27b71fc0a6828e564"},{"version":"0x00000020","timestamp":"0x3a63af66","nBits":"0xffff001d","nonce":"0x80f62f35","previousBlockHash":"0x30b012b0e25a214c1c04674d29ee96c891d61745fb9592932700000000000000","merkleRootHash":"0xab785804dfa77b6bbe8e7f966e08eacc98c4e7dec952106cec23948f8a434cc1"},{"version":"0x00e0ff37","timestamp":"0xc663af66","nBits":"0x07936019","nonce":"0xb1581a38","previousBlockHash":"0x4db7ccc41131df411d8c1293f1c5c68e6333ee5b54d10c1d3357897f00000000","merkleRootHash":"0x83406d23615135c18fb74ceddd9199b95ad23a30f0e89f60e77702d02bca12c3"},{"version":"0x00000020","timestamp":"0x2e65af66","nBits":"0x07936019","nonce":"0x3291b175","previousBlockHash":"0xe9546321c2c9ff00d4e61136dd9d127ba91a59fd6ffd15a10d00000000000000","merkleRootHash":"0x977b97494ed91e2164ac668392a2b6aff897dfe0b053b877ffb0f26910d5514a"},{"version":"0x00e0f722","timestamp":"0x9d68af66","nBits":"0x07936019","nonce":"0x113d17e6","previousBlockHash":"0x88f558a1e46a23b07ae9f38fdcf04c2a63c1d2a5f430723d5800000000000000","merkleRootHash":"0xaa3cb4c511b66ee2f26aa233f8e91fc1d4947d660483a94bd375d8cd61cbfd0f"},{"version":"0x00008020","timestamp":"0xf267af66","nBits":"0x07936019","nonce":"0x0888ece8","previousBlockHash":"0xec1bac0549f50660e72d230849b4e45b76322df5821380c43d00000000000000","merkleRootHash":"0x2e71ae298146a5665bc0c75c040cfbf6e06592b44f1da725683ad4b330f8f293"},{"version":"0x00e0ff27","timestamp":"0x466baf66","nBits":"0x07936019","nonce":"0x89afa804","previousBlockHash":"0x5b26e73974e47b5295a5d553687f39722d59c451b0eaf9591600000000000000","merkleRootHash":"0x86385dbbf0fcdb02a188cd0a355ee18d2b24852019bd5333cd3a4b597635c6b5"},{"version":"0x00e0ff27","timestamp":"0x366caf66","nBits":"0x07936019","nonce":"0xf1fb152e","previousBlockHash":"0x696fa6bf110a8f0bc0bbcc76cc3b4eca5ccca816202671553700000000000000","merkleRootHash":"0x1340eb22acbca87fdaf219b169b2fe8c91a77329f68720adb0bbad0df0bc7673"},{"version":"0x00200020","timestamp":"0x3f6caf66","nBits":"0x07936019","nonce":"0x1ff19f43","previousBlockHash":"0x272c6c3db309a25dc0d73706bbbcdb0117c73251ec432ace5100000000000000","merkleRootHash":"0xe2dcf719cccaf146529a4e3f4e11a72502722114ccefec42d29515d5d3d72110"},{"version":"0x00000020","timestamp":"0xf070af66","nBits":"0xffff001d","nonce":"0xd46e982e","previousBlockHash":"0x59949bbbf746546481c5a65034852c1a67268b32a35dc7fc3e00000000000000","merkleRootHash":"0xfc96e81fca173ce5891114b6a67c1ede90661de3287033d8793d80ff679b3b26"},{"version":"0x0000c020","timestamp":"0x4d72af66","nBits":"0x07936019","nonce":"0x96490249","previousBlockHash":"0x336f83d85576eabd5375f4c4c93bcac1dec67534b44750e50ddffc8200000000","merkleRootHash":"0x7db8eb34fd435dd3dc04b8228aacc85183eb52deba6b4c77eef687c86a9f5991"},{"version":"0x00e0ff37","timestamp":"0x0273af66","nBits":"0x07936019","nonce":"0xd7d07414","previousBlockHash":"0x87aa7b7ec2d4069c3706d2aa3b6625cc5ea3e9911b4590964500000000000000","merkleRootHash":"0xc98ac637aca30a995264d8fecca2a8639023af461d4e4abf020ffc780d1fa08e"},{"version":"0x0060372d","timestamp":"0x0b75af66","nBits":"0x07936019","nonce":"0x73489fc0","previousBlockHash":"0x46eede260dc1855bab321117100f4683aa009948ceb24e523f00000000000000","merkleRootHash":"0x79d55b2423d76f41151216ec895c2dd5d3b051949850b1173e8612cc844736d3"},{"version":"0x00000020","timestamp":"0xbc79af66","nBits":"0xffff001d","nonce":"0x8c041d0a","previousBlockHash":"0xc147daed3c7dc837abc662a4b3cdb80e4480d1c44a2062195100000000000000","merkleRootHash":"0x1d628d8e0384a25857c0612a58d4b04e56dfb1e1c5345de0efcba2641b5dccfd"},{"version":"0x00400020","timestamp":"0xd074af66","nBits":"0x07936019","nonce":"0x07138792","previousBlockHash":"0x5cb7d10ec007e1a9d4e7592a8efc392143ce86dce40ef8185ef72ba400000000","merkleRootHash":"0x8b5fb498784b11d73d6ec05e9577d0e86d85ba05213e429dfda65459c60099f0"},{"version":"0x00000020","timestamp":"0x8179af66","nBits":"0xffff001d","nonce":"0x70882322","previousBlockHash":"0x0c9f507f1aa7e9ee6433b50e630b5c82524665d6174cf9434d00000000000000","merkleRootHash":"0xe3698e5334df9356ac34bbbf35a99d6f498ec22dc4202da7f24347aee607561f"},{"version":"0x00000020","timestamp":"0x327eaf66","nBits":"0xffff001d","nonce":"0xcae5e710","previousBlockHash":"0x1d167df70e566d5975a7986e32f1952036f3c5b15a1af6bbc9889ca800000000","merkleRootHash":"0x4454dd3a6097ad9d6c1c8c0cf54cf777abeffac43498da6a553c4baf99e9d100"},{"version":"0x00e0ff37","timestamp":"0xae7baf66","nBits":"0x07936019","nonce":"0xb2e94cc9","previousBlockHash":"0x39a1874afd46bc6a84ac0f30be73e0f24a9d27a6ae34a8350802a9ab00000000","merkleRootHash":"0xe894b6ffdd90bbfa19ece11499c0e2e2a01590733425c8bc8d696fdc9962cf7b"},{"version":"0x00a07727","timestamp":"0xf87caf66","nBits":"0x07936019","nonce":"0x3ef07de0","previousBlockHash":"0xff475f9f40ff809870b187f60b4d0539c27ada53ad6005693200000000000000","merkleRootHash":"0x9a188b365e395a1ad800de2f991f9dfa9c90e20f8ebcf31e8748740d37fff6ef"},{"version":"0x00000020","timestamp":"0xa981af66","nBits":"0xffff001d","nonce":"0xf9241327","previousBlockHash":"0xaa59ac19c608a16cdea8254e16b284dfdc5b6afcd8997cd10d00000000000000","merkleRootHash":"0x55a3f830cff15b43d35d5e908937ffc1f7c3431ff1e0bf359a468ae0b41293c7"},{"version":"0x0080d826","timestamp":"0xdb7eaf66","nBits":"0x07936019","nonce":"0x6a10d626","previousBlockHash":"0x1b740b79706e18a3acba556c6c9935cb7ea75a419591c54cdd9d6ddc00000000","merkleRootHash":"0xc2c628702efe92b4aaa998e8a1bf5fc361647e54b41ba1f98f0c0a669970ec5b"},{"version":"0x00000020","timestamp":"0x8c83af66","nBits":"0xffff001d","nonce":"0x2bf90303","previousBlockHash":"0xfe8f9411b3a810eeab9ed137c363883b66e2a6b88f3342374400000000000000","merkleRootHash":"0x71c330f4b24d8e4cd9662581a07d562e2eeeb517f80e575fdaa3411447e3a235"},{"version":"0x00e0ff37","timestamp":"0xeb7faf66","nBits":"0x07936019","nonce":"0x8488dc65","previousBlockHash":"0xd0011a9fc0175e43468e5f9435a6c2367ee5c94bf16e798079c8d56c00000000","merkleRootHash":"0x51088a1b25337c1266215ef10b360c5a509084d43d8164d46feee04b2cf7b953"},{"version":"0x00000020","timestamp":"0x9e84af66","nBits":"0xffff001d","nonce":"0xe9f29960","previousBlockHash":"0x66f6c9290ed043aa8d82102e854c0fbeca5e95e1d3de76de3a00000000000000","merkleRootHash":"0x5c0d8548531e0e4a8980f8eeda15eb69766bc0c61463632820f5872b478d4caa"},{"version":"0x00000020","timestamp":"0x6486af66","nBits":"0x07936019","nonce":"0xf3a3cb11","previousBlockHash":"0x9aa5ea3916ebfe19ccbd988ea7f847807ea269422a362412581918ff00000000","merkleRootHash":"0xe90ca36cb9226894e8a2b217418b4d198450a269a5c00e74ba0dd00a1ff322e0"},{"version":"0x00000020","timestamp":"0x158baf66","nBits":"0xffff001d","nonce":"0x6d07d10a","previousBlockHash":"0xb76fb0783b88e5a21a267b721ec7977b7333261e3851f5334000000000000000","merkleRootHash":"0xc7cb5f3354a40273688b4bb638a43dd95e390c90fb82576ad8fa08be8f165330"},{"version":"0x00008020","timestamp":"0xdb89af66","nBits":"0x07936019","nonce":"0x8d6b0a16","previousBlockHash":"0x6cd54b81068c22a57363f3241375742b8ea95ce35f9b6d0364e0cfee00000000","merkleRootHash":"0xfab1f693a9100a91b00631646af3da49ddefba881db3a48f10ee694a0fad816b"},{"version":"0x00400020","timestamp":"0xf48caf66","nBits":"0x07936019","nonce":"0x3168ef04","previousBlockHash":"0xd4e6c713f4a17bfc3f7ff2992c0f03ca5b30f43ffdd69a445f00000000000000","merkleRootHash":"0x0a544ee4016f53d7b472810470ddb4aa4d6351ea5571a7241864da606731d4df"},{"version":"0x00400020","timestamp":"0x5c8eaf66","nBits":"0x07936019","nonce":"0x1977676a","previousBlockHash":"0x3388b1dda7b847c1dced192a71d99da57585ae5f468ee6d92000000000000000","merkleRootHash":"0x7dbdd5192742367439e5a27ccc8edeaa079f64497acb89b499e216ffa72a3ef3"},{"version":"0x00000020","timestamp":"0x668faf66","nBits":"0x07936019","nonce":"0x26178789","previousBlockHash":"0x5db08826e6ad611feb18054b362f469149efde54fdc765a00300000000000000","merkleRootHash":"0x5d2720914bf999fb04bb7acf73466d1adabb06f7cb974b64c9a96d5d07bb1e04"},{"version":"0x00600020","timestamp":"0x6891af66","nBits":"0x07936019","nonce":"0x85051c55","previousBlockHash":"0x423715052b47098b82330a874241d9d3021cee22880af2360b00000000000000","merkleRootHash":"0xa1b6cdff54e390d5e34c46076e221da23c659f02244bb8703c28ad35f9dc7e9f"},{"version":"0x00000020","timestamp":"0x1996af66","nBits":"0xffff001d","nonce":"0x2aa21b11","previousBlockHash":"0xf1e7a0c705b9e0263a4b01d4e01cda803254df3df6afe9cb3a00000000000000","merkleRootHash":"0x98cf7ac9b30eaf6fa83d42f1558f2f57737f5df914a29401cd94a8b6b478f199"},{"version":"0x00e0ff27","timestamp":"0xd293af66","nBits":"0x07936019","nonce":"0xd016052f","previousBlockHash":"0xf74b9b5681e5dbf9b981873f8263439ce2b570fc00272cf358f9e6a900000000","merkleRootHash":"0xc5921b16d60ea42daa97dd727c307dc1a99dcb183563fe1249f3a5b0ce7317af"},{"version":"0x00000020","timestamp":"0x8398af66","nBits":"0xffff001d","nonce":"0xec129116","previousBlockHash":"0xe046326edd844a3a176a59deb064415c3edc2cf48ea435802a00000000000000","merkleRootHash":"0xa19c0ae3309f83153421fd1277e06a42f0e428ac9ed86061704db02cc049eb12"},{"version":"0x00000020","timestamp":"0x2a97af66","nBits":"0x07936019","nonce":"0xc316caaf","previousBlockHash":"0x92fdcaffae21edfc0399c8bcaaec46a2fe81f5a798dca4d6c966757800000000","merkleRootHash":"0x764093bbcb38374462c7c2d3af9f42863293a8faa71e050aa273435ff6933cc8"},{"version":"0x00000020","timestamp":"0xdb9baf66","nBits":"0xffff001d","nonce":"0x2303aa11","previousBlockHash":"0xbc52d5924c63b1550b2daf7663719fb82ea25726cd4dd3171100000000000000","merkleRootHash":"0x6450ab8b7b0be5ba9daba58a9c47d9157100c1c77c40e3ed9f9059ddb7cf8ba0"},{"version":"0x0000c020","timestamp":"0xef9daf66","nBits":"0x07936019","nonce":"0x4ce4f90b","previousBlockHash":"0xe3d1355ab0f37b8016bc4ca85a3717bdbb8d3870f894744b1e3014ef00000000","merkleRootHash":"0x3409e7d7522e88a14d8657fc01ea7b7287dc28c36b3a310624223ce29a2870cd"},{"version":"0x00004020","timestamp":"0xb79eaf66","nBits":"0x07936019","nonce":"0x430ae6b3","previousBlockHash":"0x60062edd10de22358919d4b4d0d05ca9acd0d969f0148c382900000000000000","merkleRootHash":"0x25bf893c721cb6e1f771e0cea89ece9e3fe00ff5d1f8101f138838f09e05405c"},{"version":"0x00000020","timestamp":"0x68a3af66","nBits":"0xffff001d","nonce":"0x11e8920a","previousBlockHash":"0x0d25d637383bea4d37934db9ea4da6022e669ef993bc08ad3400000000000000","merkleRootHash":"0xea2fa97f6ef60e89813ac50b77006c86e1baadf68b27d1873ebd2d0c09f35ad8"},{"version":"0x00400020","timestamp":"0x3c9faf66","nBits":"0x07936019","nonce":"0x18e47149","previousBlockHash":"0x2db694367d3e00f1c1766cfaf54461591e233aac71fbbb68b6db5f8f00000000","merkleRootHash":"0x2ddd436d74d4107756e2fa36f03968854454679c6f650dd347d18d99d8a2bc38"},{"version":"0x0000c020","timestamp":"0xf3a3af66","nBits":"0xffff001d","nonce":"0xa74f7ed7","previousBlockHash":"0x6a0eaab533eb24c392ea0a7adeee3ef5d6b8fae2383fd5b01d00000000000000","merkleRootHash":"0xd81e660a5a8cded9f3bfb6a187ace43cc7d60da80eddf32595af4689feb67413"},{"version":"0x00e0ff2f","timestamp":"0xb2a4af66","nBits":"0x07936019","nonce":"0x0d47f568","previousBlockHash":"0xf058bbf2d9c3c5ce9a049adb97b3c351a6e5e901d980ecb8b95c000000000000","merkleRootHash":"0x4d30fbcdece322696fa69119a6e528ebe6ec4ad18afe769f28baaa08342db2b8"},{"version":"0x00008020","timestamp":"0x9da5af66","nBits":"0x07936019","nonce":"0x44692111","previousBlockHash":"0x6ce3770bcc76578570e63ce1d0eb5d2fdbfde323c49fce333f00000000000000","merkleRootHash":"0xdb81b53d344a0d8e756e017ebebdee1ac0c1e0074c5a97156c22bca11053e2f9"},{"version":"0x00008020","timestamp":"0x23a7af66","nBits":"0x07936019","nonce":"0x355d0eae","previousBlockHash":"0x357e98ca0d069fd5b940de8966996e9ef96cf12e474bd67c4f00000000000000","merkleRootHash":"0x18c971ee55ba245ae1c205694a5b232265f5a12ddd1a1c5b9174e7a29f844f7d"},{"version":"0x00008020","timestamp":"0x12a9af66","nBits":"0x07936019","nonce":"0x1ddece5b","previousBlockHash":"0x1f07866e315d6b9653dd8d52ef54bade1a4b628bcf3550901100000000000000","merkleRootHash":"0x645756ffed3954a1dadd60465f6c248fa92ab0cc6752b5f335a9e2ac1a0d8fed"},{"version":"0x0040a12b","timestamp":"0x37acaf66","nBits":"0x07936019","nonce":"0x4b18bd33","previousBlockHash":"0x2082232da57708b5a9962494a7bf43a3cc21656968bb39351900000000000000","merkleRootHash":"0x6eaa56883e05a44810a41e3128a8a0c7510320ecece9b4d5a4ece51d1339005d"},{"version":"0x00400020","timestamp":"0x4cadaf66","nBits":"0x07936019","nonce":"0xecb63c54","previousBlockHash":"0xfde70efcd0a432f5d56bf194a7cdb0a1d0bd4190883ee1bf2600000000000000","merkleRootHash":"0x87fe45a64cb51a51abe9aee79d709f091095ef21622a7d99f69c9652675a3db1"},{"version":"0x00000020","timestamp":"0xfeb1af66","nBits":"0xffff001d","nonce":"0x4056662a","previousBlockHash":"0x3662c4a96b98315b4d72e4c966ba0b32bee1f1af3c4247782b00000000000000","merkleRootHash":"0x214b27b9cc221abd95a157698210e455fb6711e24d69ec115b291a3386eec180"},{"version":"0x0060bc25","timestamp":"0x1db5af66","nBits":"0x07936019","nonce":"0x5b4c4739","previousBlockHash":"0x25dba02f82eb4691fd04ea5e2f21195ed0157f153b034e24874bc74100000000","merkleRootHash":"0x75ea5684a42e2b0f0e0478cbf167a15c3ba2531afaa469dc94cd9cac19f155ef"},{"version":"0x00400020","timestamp":"0x08b5af66","nBits":"0x07936019","nonce":"0x9bfb5b6f","previousBlockHash":"0x70e6b32e7639dc1e27c83fad9b7acfb2a50008b9fd9174423000000000000000","merkleRootHash":"0x68d2b0aa0ee73f003eedbae9ba1edc0f68964b7f3c8294d08b07166febad2171"},{"version":"0x00000020","timestamp":"0x82b6af66","nBits":"0x07936019","nonce":"0x333c7ad9","previousBlockHash":"0xf98294cee88d2c80ef61164010210bdb4a9405dfee69eac63c00000000000000","merkleRootHash":"0xd19715c5e6f87b4a7829dbd1a3ecf11119ffc3df4a87749441f7bcdaaa49b4ce"},{"version":"0x00200020","timestamp":"0xe8b6af66","nBits":"0x07936019","nonce":"0xf76a8bf2","previousBlockHash":"0xdfd80d49c73bc48f98a5a59b88839dad3e7777c3668a67821000000000000000","merkleRootHash":"0x71a00b7069f28541b1ce74ced6e218e81fe66aa3f14b44ed9f2de8f5ca2f56b7"},{"version":"0x00000020","timestamp":"0x99bbaf66","nBits":"0xffff001d","nonce":"0x318afd06","previousBlockHash":"0x3f80498549ff8c4bfab8825e63474df0d6ebea1be038f8740d00000000000000","merkleRootHash":"0x1d0b82106a992f490281f4626b2739c2c8bbec01db02679a01792029db77ee1d"},{"version":"0x00e0ff2f","timestamp":"0xaabbaf66","nBits":"0x07936019","nonce":"0x993614aa","previousBlockHash":"0x8d63dfe32b82fe12768b2ede00813137882988c1efbb8bbde93a834e00000000","merkleRootHash":"0x4f55ee0f1a7544d090feb2c88b20a8df7e7be9cdb4c19a2ee244e0f21f228c18"},{"version":"0x00000020","timestamp":"0x5bc0af66","nBits":"0xffff001d","nonce":"0x64386251","previousBlockHash":"0x8461124867f1d9a05cc48834bba322b967e3ba2f43f60b964200000000000000","merkleRootHash":"0x10271100fa82afcba5b8943066432d39898c4c4a3f517679ae3be419d2b6f433"},{"version":"0x00000020","timestamp":"0x0cc5af66","nBits":"0xffff001d","nonce":"0x6b39260b","previousBlockHash":"0xe7fb501b13c0f62e573fc0fd84e6005d97dad42d0407b0071a1af6ba00000000","merkleRootHash":"0x54c75336a56d90e3a2fe915459e0a51cf893df0fb777a9985ba3d8b0c5b02d54"},{"version":"0x00000020","timestamp":"0xbdc9af66","nBits":"0xffff001d","nonce":"0xe0f51505","previousBlockHash":"0x666d23e4605b5841831afdde709299ea75b277bc850f42de299da3c400000000","merkleRootHash":"0x997c1ea40455da94cd35d3fb6df4e07116d1d987bdfc073f53b22c16ecbf50c3"},{"version":"0x00000020","timestamp":"0x6eceaf66","nBits":"0xffff001d","nonce":"0x7ee76100","previousBlockHash":"0x3d8b3381899b201ca98d5477d5b08657c9dc85e987721633d5d6dd9900000000","merkleRootHash":"0xe9824279f167d2f7a9675a96c31c375c14aee50e3cf35213b29eb965105e8f2d"},{"version":"0x00000020","timestamp":"0x1fd3af66","nBits":"0xffff001d","nonce":"0x5846131f","previousBlockHash":"0xc86f2ace1c7894dab1df784a81bbf66b65ea219b73362df7445ef46900000000","merkleRootHash":"0x7d6b64c741ee89b0c3eb752af678f2531c2a5b63e67e98828343e626cc023115"},{"version":"0x00000020","timestamp":"0x54c3af66","nBits":"0x07936019","nonce":"0x6bf67747","previousBlockHash":"0x56567ccae5fdcc0532fa9ed69c4889b12b7f6f0f2eacb5e1aa68c7c900000000","merkleRootHash":"0x446ecaea696e6b9b321098ddd31797d0bc8f79cc2b516b8a64a3ccf5c9ddd3ef"},{"version":"0x00000020","timestamp":"0x05c8af66","nBits":"0xffff001d","nonce":"0xbbc13208","previousBlockHash":"0x5426cb631f57aa3c4dfa5c3b4c0c31bb5896816f4b06ded33b00000000000000","merkleRootHash":"0xc251853baa8c3e81512fde7fc502694a7ebd1fdc9598323de14371cdaa51d8f2"},{"version":"0x00000020","timestamp":"0xb6ccaf66","nBits":"0xffff001d","nonce":"0x1757d307","previousBlockHash":"0x1feaed4ebd413558128cd3a7fec3d5a59c7f7fc6bc13753e3ec84db400000000","merkleRootHash":"0x53f98901de762b98e13eed5436aa5958816dd09daa850e9bd08bb21dea87d46a"},{"version":"0x00000020","timestamp":"0xb4ccaf66","nBits":"0x07936019","nonce":"0x9a44fb8f","previousBlockHash":"0x6ab831201ffb0b49766188f05c07836805b440eb7b475d362732547b00000000","merkleRootHash":"0xbb7e963d4b7264a051647130735dda427359f2a5ab9309adeaaa9fd5304e7683"},{"version":"0x00000020","timestamp":"0x6ed1af66","nBits":"0xffff001d","nonce":"0x8ff5d28e","previousBlockHash":"0x1a2e92a63204a6ef4a37ef001297589803f0787a7d4161ad2100000000000000","merkleRootHash":"0xa4621bdf7cbb531e10adb19df330f4f3885317c7d2a90f58f719f03bdbe6341e"},{"version":"0x00200020","timestamp":"0xa0d1af66","nBits":"0x07936019","nonce":"0x4a0ddac2","previousBlockHash":"0xe6a269970943863e93efb549078de67d74320b79ab3946b7fbaac83e00000000","merkleRootHash":"0x8f6b393c6312ed239a55e26f8ba04be5095267207751340a2cc6051a79406acd"},{"version":"0x00200020","timestamp":"0x90d2af66","nBits":"0x07936019","nonce":"0x69b93361","previousBlockHash":"0xeb647f912e8d12ece892440671749e2f605c04fbd1fd2c190900000000000000","merkleRootHash":"0x931ca1a22eb8f4189d17aab1806cbf1c51576554678cdbc106786fef914aacbf"},{"version":"0x00000020","timestamp":"0x43d7af66","nBits":"0xffff001d","nonce":"0xa7ee65c4","previousBlockHash":"0x5cfa8daf704781960980b2a28712e0b4a5811c5e8a86280a5200000000000000","merkleRootHash":"0x168e2439983cfe5a5cbb00562ab57fccc51aa576b448d5428af25f6281910525"},{"version":"0x00000020","timestamp":"0xffdbaf66","nBits":"0xffff001d","nonce":"0x016aebe7","previousBlockHash":"0xddbc5559bde3160dec27387f7ddd4753ad7b1adafd623fb342f7b70700000000","merkleRootHash":"0x0f236bf524011c2d2c4b0d07b71409195bcca71c32da236b6b9a1f3c21aa285c"},{"version":"0x00000020","timestamp":"0x2cdcaf66","nBits":"0x07936019","nonce":"0x81d40150","previousBlockHash":"0x9e0ee49e4296ab3ab5594a57f57cfa7c2c3f02e1f135b5a6846e572400000000","merkleRootHash":"0xc0875ed7d5ca59c1ffda1a19ac64e8cf65c41007cde609dda3f5c3cf97e7c5fb"},{"version":"0x00000020","timestamp":"0xdde0af66","nBits":"0xffff001d","nonce":"0x464d0717","previousBlockHash":"0xbfe16b5db8d66cc093d0b8aa8baf2d215945d5f63f3ed6175800000000000000","merkleRootHash":"0x279930a361a1d91718c37ac66b6587538b1da577d691ccbd3487c3c0d7d259f0"},{"version":"0x00000020","timestamp":"0x8ee5af66","nBits":"0xffff001d","nonce":"0x851d2a2c","previousBlockHash":"0xba901f8023d28c8b7cbb0c500da42be80453cadc8ae44412337870cd00000000","merkleRootHash":"0xa7e3199b75c7cd68fb402a152b5e714ee31af89eedc1e1c4a09fabcded214e43"},{"version":"0x00000020","timestamp":"0x3feaaf66","nBits":"0xffff001d","nonce":"0xa0feeb0d","previousBlockHash":"0xd6036552144c557c9fc3a4191d349f295ff736d6229fdbb19141c73e00000000","merkleRootHash":"0xb159d370307dc4756057ea1983133fdc3c40ba18c685bf5229194d9e502bad2e"},{"version":"0x00e0ff27","timestamp":"0x43e7af66","nBits":"0x07936019","nonce":"0x370dae83","previousBlockHash":"0x4a4bb77923dce7aa7f2d93374573e67c040643b28882b53eacf5503200000000","merkleRootHash":"0xdfbb635a5cfce476756f79483f6984637c1ff9d46c1a1a8640c938a2feb68002"},{"version":"0x00000020","timestamp":"0xf4ebaf66","nBits":"0xffff001d","nonce":"0x0b56493b","previousBlockHash":"0x2aeee1a3fefa500aeb099a75e14d216fadbd2d7d6e95390c3a00000000000000","merkleRootHash":"0xba490faa2cefd323368ca837a083cf9f8ea98079aaab1ba476ecd46bc5386252"},{"version":"0x00200020","timestamp":"0x84edaf66","nBits":"0x07936019","nonce":"0xce2a7b8c","previousBlockHash":"0x41f0b883faa335de66f9b3027dedcc026061c0c65c8412ae4a544a8b00000000","merkleRootHash":"0x3176ebae2884cea26dafe51ac1cc3a19829ea6eeec6e4d98a8615cde98099961"},{"version":"0x00000020","timestamp":"0x36f2af66","nBits":"0xffff001d","nonce":"0xd5e98334","previousBlockHash":"0xaf2c5ae2ce77d1f045e17df86729604fdd3344a906b1cd733800000000000000","merkleRootHash":"0x52fec07d211de763322bc741e1932b700fca77d0bc851bf186e19176287a8e78"},{"version":"0x00000020","timestamp":"0xebf6af66","nBits":"0xffff001d","nonce":"0x761f50ce","previousBlockHash":"0x1e77112aa9070dbee40b6debb152a4409c45ed99c34bd02f3438d86600000000","merkleRootHash":"0x6288253b5343e5808333f23241100fa8878f56f37bba87239475522c234b482b"},{"version":"0x00600020","timestamp":"0x88f8af66","nBits":"0x07936019","nonce":"0x1dbd73b5","previousBlockHash":"0xb8229720eafedcd4c5d197d965bfb2b25424c0f5779a114deeac251700000000","merkleRootHash":"0x2e56d64debb259243d0f0f159db9e90e4118abc63782406416e30b2ac2ddca03"},{"version":"0x00000020","timestamp":"0x39fdaf66","nBits":"0xffff001d","nonce":"0x25ebbd2d","previousBlockHash":"0x33213051bd9d56a6d10ae0269b15ba97be8890e08b80e4045900000000000000","merkleRootHash":"0x2dbbdec64bc1439793e131364801d353be6bce54784adc4b4ff2f4de68e72811"},{"version":"0x00000020","timestamp":"0xea01b066","nBits":"0xffff001d","nonce":"0xb4c22235","previousBlockHash":"0x0cc24cdf50f73d7567ba8d47eb407662dc98f1b47cd962b9f2585e3200000000","merkleRootHash":"0x567aa40b4ebacfae0a83b3915c7b0c7c0578133650e81f48bb90d2126446b95a"},{"version":"0x00e0ff2f","timestamp":"0xa3ffaf66","nBits":"0x07936019","nonce":"0x5b1d2081","previousBlockHash":"0xd830e0f7343db2a21f7dd3a536339cef41c9a7b75f7d1a93964c282300000000","merkleRootHash":"0x155f2a09595c159209e576a317b2cc30194e441b07760d1b2b3f166431badcb0"},{"version":"0x00400020","timestamp":"0x8000b066","nBits":"0x07936019","nonce":"0xf2cd16ae","previousBlockHash":"0x2520caa99795841058a00af0231ba4bf2b2366ee262e59893800000000000000","merkleRootHash":"0xab6046d6f23c47bf5d5294804c5b90dc2f6b28ba1a42167c25afc0d752438bd2"},{"version":"0x00e0ff27","timestamp":"0x0b01b066","nBits":"0x07936019","nonce":"0x7cb230a6","previousBlockHash":"0x170cc518b648ce29bf0b47b8be292802f000586b73cffa771800000000000000","merkleRootHash":"0x3720233a80f5a8bde4375b648372be19707446e685b589069f9b99dcc0eaa5e6"},{"version":"0x00000020","timestamp":"0xc105b066","nBits":"0xffff001d","nonce":"0x2881514b","previousBlockHash":"0xbce9d95aeebebb575dc28319711c75c5842b2d8254a78a092100000000000000","merkleRootHash":"0x7ff5f5923e8d83119a3c969321c549ea48da04f7d9a2f6e5166baf9e2fb35bc7"},{"version":"0x0000c020","timestamp":"0x7e0ab066","nBits":"0xffff001d","nonce":"0xbe5e8fa2","previousBlockHash":"0x1de1cc7c3d99617cd3a2d481b8d62bd69e4b5b2c8f62a258cc2d2a0000000000","merkleRootHash":"0x4c53f00ccd2327b297667f058c23d2689ec694f9535b3f364150250eb879372f"},{"version":"0x00000020","timestamp":"0x320fb066","nBits":"0xffff001d","nonce":"0xa0814d65","previousBlockHash":"0x07c5e65972083424416d0248004850604070e95480c84e248e21000000000000","merkleRootHash":"0xe5dc6345407ad20cf6d06d187214d7f167f3dcac47caf9d60e5f362f7e9e180f"},{"version":"0x0000c020","timestamp":"0x5e11b066","nBits":"0x07936019","nonce":"0xab84dec0","previousBlockHash":"0xf3f1d0da48fb3911bc3222481e94076c3112dc83981e1c4692f45c0200000000","merkleRootHash":"0x43c7737db4a87e3f2f12925ff238c58a00538a0b57b66f9ab653a2081a263445"},{"version":"0x00004020","timestamp":"0xef11b066","nBits":"0x07936019","nonce":"0x12304b27","previousBlockHash":"0x2028ee6f841a5e9738ebe4f1027e7cb0bd018bf3b7ed865b0a00000000000000","merkleRootHash":"0x9203eaa791daf50794416dd0f26a58739fccd3a3a49284f36c0944165882f874"},{"version":"0x00000020","timestamp":"0xa016b066","nBits":"0xffff001d","nonce":"0x05cc4d02","previousBlockHash":"0x00b6194728f08d419cfbd1e92a18b93c6c1c005ac9ca84282500000000000000","merkleRootHash":"0x3e70e8e7b0a7742f5cc972ac87daf2fa1397f78801f693ba6a13a877a662dc6a"},{"version":"0x0000c020","timestamp":"0x3913b066","nBits":"0x07936019","nonce":"0x9d5c1bd8","previousBlockHash":"0xc3815192d5cfc35cd963e6171aa618c0596e0cee7792b66e56165a7300000000","merkleRootHash":"0xdca3014d932cb44d43170540396e44e0faca0bacb8067cf3b73aaf7b3cc42992"},{"version":"0x00e0ff2f","timestamp":"0xbb14b066","nBits":"0x07936019","nonce":"0x220e6aad","previousBlockHash":"0xfa1d6c7876fc23eeaf2af9fb1c32c868d6f4bcda05f95ce85900000000000000","merkleRootHash":"0xc94e43ee2283a6ffe6994c7ab93565bd908c03e141ca464b4015789599702308"},{"version":"0x00004020","timestamp":"0xc316b066","nBits":"0x07936019","nonce":"0x29e230bf","previousBlockHash":"0x42ffc6474ae69a772ac359e832d1685e721b129e98bba53c2800000000000000","merkleRootHash":"0x209ebad32ea949bec42ec5879d2db308a77c0bddea0cbdaadd84fa60c4b36b20"},{"version":"0x00000020","timestamp":"0x8617b066","nBits":"0x07936019","nonce":"0x8c628d8c","previousBlockHash":"0x6ce46c1dcff62b29b5666ec5664b15fe615ee3a52906b2464400000000000000","merkleRootHash":"0xa6daf5d2b8feba5115d170013a4ede3c0e9cfa1fa9f87c8b0b8703c86ef12887"},{"version":"0x00400020","timestamp":"0xa418b066","nBits":"0x07936019","nonce":"0xbc5efe86","previousBlockHash":"0x53fd126c5211a1fbe01a955b2d1b12ffe3c50f552eb147e14100000000000000","merkleRootHash":"0x879494e8e94152945f7b60ea30d4e35e896c5699bb4cd66fc509cfd89a8afb8d"},{"version":"0x00000020","timestamp":"0x571db066","nBits":"0xffff001d","nonce":"0x9b053473","previousBlockHash":"0x14b5089da257770882ca08f07ad87d2552fca64afa043d615700000000000000","merkleRootHash":"0xc981146fb4c7881dbf8db2cfbed8c7fdd93bf4415413c27af7cc5a7df3bba2de"},{"version":"0x0000c020","timestamp":"0x641db066","nBits":"0x07936019","nonce":"0x3c0badfa","previousBlockHash":"0x597cd4d329c549c508bf463f7cefa59255547229200fecd40ce26c2200000000","merkleRootHash":"0x994effcc95f311ca484a36d87f78e7cf564a904b3640ff75e3d221e293f769c3"},{"version":"0x0020252d","timestamp":"0x7d1eb066","nBits":"0x07936019","nonce":"0x2d5081c6","previousBlockHash":"0x9468644bea64cf8d7801342cf98dbf203c27059ac1758c7e4e00000000000000","merkleRootHash":"0x10e251d5e874c7b1b2e42c0605795e76274fa159c263a99b8e859c3458a23cce"},{"version":"0x00000020","timestamp":"0x411eb066","nBits":"0x07936019","nonce":"0x243b39b1","previousBlockHash":"0x7c5ef3b40615143ef356e71b91a03ec01c99bbb768d9a73f3600000000000000","merkleRootHash":"0x831c2b3d04f6e68c4aa3f163376927397aee9e74f6e1c94d896298cc53585a16"},{"version":"0x0000c020","timestamp":"0x6b1fb066","nBits":"0x07936019","nonce":"0x5d2b310b","previousBlockHash":"0xdfe7bdfae7e0a3e8e02adfae8c4cf3af6d4b6e1ad7221c702700000000000000","merkleRootHash":"0xbf8ef2694f42f301c573e6a31970173ff47e73746e09c1a380b1b605f8cc280f"},{"version":"0x00a02d2d","timestamp":"0xa121b066","nBits":"0x07936019","nonce":"0x176401f9","previousBlockHash":"0x60bccf5921083d7d8afe92eae77998a7ac556534dc54c3fa2500000000000000","merkleRootHash":"0x8bc1fa289d6db88bbe541ff46add449cbf8b36bfd47fcc0bc6f7f8486edb3b36"},{"version":"0x0060642a","timestamp":"0x7922b066","nBits":"0x07936019","nonce":"0x05e0a0ff","previousBlockHash":"0x5ecd45f31d955ce599095bb813334d44568d6cdf16b1ab933b00000000000000","merkleRootHash":"0x9355e1033e6e0f8c9cefe0e5c7f1a9d9b37ec9bb60af0afa70a64a826dff3da3"},{"version":"0x00008020","timestamp":"0xc622b066","nBits":"0x07936019","nonce":"0xa7eb592d","previousBlockHash":"0x47d550407c6d778bf4935c7fb1959d19391e624448ed47880b00000000000000","merkleRootHash":"0xdd95fb028e5c911a9b216ba8ce42572abea24d003d4598bcaf774ad129d8e422"},{"version":"0x00e0ff37","timestamp":"0x7f23b066","nBits":"0x07936019","nonce":"0x9ca1fb69","previousBlockHash":"0x6e047b79424b1cf22bb41f5c1aba37df91fd1007538ddf985600000000000000","merkleRootHash":"0xe9c91a677b1cd64ce0c692ab2ceee86146c72e45a1bb2796f4dce80c269cf475"},{"version":"0x0000c020","timestamp":"0xa223b066","nBits":"0x07936019","nonce":"0x527734f8","previousBlockHash":"0x5d26f555e270f9c2e0539ee11ad400e2f31c13c95f6d09da4900000000000000","merkleRootHash":"0x2934b3fd7e27a4c203dcc6493be84f8d0225d7cf54e08d5ca857399a7291e83d"},{"version":"0x00806128","timestamp":"0x8325b066","nBits":"0x07936019","nonce":"0x5b60d4c5","previousBlockHash":"0x974b317ad9ef1fff8234e46ed43d1327c224fe7c718666261000000000000000","merkleRootHash":"0x0ac05886d83f66362d5590868b5a0ca151afa3d172fa1fd8bbba260b0a65a82f"},{"version":"0x00400020","timestamp":"0xb426b066","nBits":"0x07936019","nonce":"0x0aa51c64","previousBlockHash":"0x88e731dabbe4e4d05e615b62f771772e9576eed86818754b0f00000000000000","merkleRootHash":"0x409da1b15c4220fc7ae6522ae52b5feaf09597a67bc3785984898dd2ea53d83a"},{"version":"0x00004020","timestamp":"0xcb28b066","nBits":"0x07936019","nonce":"0x10914045","previousBlockHash":"0xd0bdb29bbcea2b1f02b150a1b8250ad72152d408527874b10b00000000000000","merkleRootHash":"0xa82742f929ed777f59e533cf9d4ad3b9354f44e8e1931bc5c866066addaef9e3"},{"version":"0x00e0ff37","timestamp":"0xd329b066","nBits":"0x07936019","nonce":"0x6f7df747","previousBlockHash":"0xf72c6e0416bf64f854ec9ba0b51371dbe90bd0a6f43f3afa3200000000000000","merkleRootHash":"0xdfbe0993ef8fdde5a2e1e6abe99bcdbc0567eec0ada3dd8cb02b8c61fa2ddf8b"},{"version":"0x0000e020","timestamp":"0x202bb066","nBits":"0x07936019","nonce":"0x16709992","previousBlockHash":"0xa06f9ae01379b87e16902e8aea88a1134ba71d23981d6e391000000000000000","merkleRootHash":"0x50f8364c66bd07d6a3b00265f721a5fdb33f1f211b4786440c53fcd1b9d6a502"},{"version":"0x00e0ff37","timestamp":"0x1b2db066","nBits":"0x07936019","nonce":"0x50157aba","previousBlockHash":"0x17764c89f41948f62234e859693ee41ddfe35491c9338a494c00000000000000","merkleRootHash":"0x700825d652aeab029fec5d164bc9aa6b99f283929f9a6553d009cd5a7168e86d"},{"version":"0x00000020","timestamp":"0xce31b066","nBits":"0xffff001d","nonce":"0xe7d4309c","previousBlockHash":"0xc1507db05aa6385e89020ebb60d50e0b2b04d69da007212a0700000000000000","merkleRootHash":"0x86b65746588973be6b7b3d8245f511b0a0286d24fe6f5f3ab6d34ddbd22e31cd"},{"version":"0x00400020","timestamp":"0x6c32b066","nBits":"0x07936019","nonce":"0xbfccc085","previousBlockHash":"0x18b4e084fcf2e1832aa7a626d87deea104c5a3e3b2598ecdef1fb81f00000000","merkleRootHash":"0xc90fefd0c90dae3bedc0bbd53fe30dfee1a04ba1fe62d861161e02083ba36062"},{"version":"0x00400020","timestamp":"0x2033b066","nBits":"0x07936019","nonce":"0x67fd4cab","previousBlockHash":"0x565599d446431bfcd8d194cfd3bb999661590f51bc569bf23a00000000000000","merkleRootHash":"0x7b985e225de67b1d0fde80c2d03e4cb884e508ae253e382bd50b1b24322a40ff"},{"version":"0x00400020","timestamp":"0xc434b066","nBits":"0x07936019","nonce":"0x8b9516f4","previousBlockHash":"0xdd1f48ba0e72c1ec08eec85aade5d6d7cc5873ae6de21f964c00000000000000","merkleRootHash":"0x09e3cc1db148b82fde58749e31388437120e2ef34579a3e54bb36fb105fa2590"},{"version":"0x00200020","timestamp":"0x0035b066","nBits":"0x07936019","nonce":"0xf4ab1149","previousBlockHash":"0x95ead17768b65e5dc5a603477fc85833684c2a862f8a06dc5f00000000000000","merkleRootHash":"0x9f674ea4f219cddb72ecefa2b53e641f92fe5a4aecdd8532a6d16e0fbd5fcb8b"},{"version":"0x00000020","timestamp":"0xd338b066","nBits":"0x07936019","nonce":"0xd45ffedd","previousBlockHash":"0x96594d22dd9454acdedfa7ff1b2aa61d6731582452b4b2b53800000000000000","merkleRootHash":"0xdaee17a889eaefca283bfc7a1d6acd41d86e972aac02ebd6c15ecf96d5d1b893"},{"version":"0x00000020","timestamp":"0x773ab066","nBits":"0x07936019","nonce":"0xc3853372","previousBlockHash":"0x47dcd9f628124f77144df8f401f5fe16091afae78fe341e84000000000000000","merkleRootHash":"0xfa008f7d50ff0392cd044216fb105a2af688906ebd6b1e1aa07344a03b589906"},{"version":"0x00008020","timestamp":"0x423bb066","nBits":"0x07936019","nonce":"0xccef0932","previousBlockHash":"0x26a6573a26b8aea4251b74b33bdbcdd9d130f332d8f4d6871200000000000000","merkleRootHash":"0x7ae02a762ac4f8e4583e7c862d7ebc9591c23db2bc797e0ff692fedb5e30e654"},{"version":"0x00000020","timestamp":"0x803cb066","nBits":"0x07936019","nonce":"0x824d1062","previousBlockHash":"0x30c173addd5f8043531bb4e61d26476a7509336d8db834f85400000000000000","merkleRootHash":"0x146b6169b718ac1f84e97941b18351802a6812f368d99ce4db81230a3d5f1ef1"},{"version":"0x00e0ff37","timestamp":"0x8f40b066","nBits":"0x07936019","nonce":"0x2fa93411","previousBlockHash":"0xe0abdc3f0f68e19dd04f5d355a3c64d09d35c99d65891d562200000000000000","merkleRootHash":"0x11bdb87f4b63e2ebc25514e942cdb62c001e9b9385a8de09ac6c5682b6c7aeab"},{"version":"0x00400020","timestamp":"0xf440b066","nBits":"0x07936019","nonce":"0xe8983b24","previousBlockHash":"0x79babf1dcfa14f3a4dbc4e1347bfe8131c69f7208bbacf6b2600000000000000","merkleRootHash":"0xe53338c5214a2d6b768b89021c97d2da66258d9c69a047c9b2764c16e830fe88"},{"version":"0x00002020","timestamp":"0x1941b066","nBits":"0x07936019","nonce":"0x073718f6","previousBlockHash":"0xbd76b0ed57a1af51080d9cd596c68f73fe737c501e809fb33100000000000000","merkleRootHash":"0x8bd8ac0343b015187adb6ec1e2e89385fc9e238dae2d91128c42b71553a14d42"},{"version":"0x00400020","timestamp":"0x2542b066","nBits":"0x07936019","nonce":"0x0785e6aa","previousBlockHash":"0x7aca4a5c038cbf4025d7d89b12799a84536c0d7def6447bf5800000000000000","merkleRootHash":"0x16f949ba4e77dc24f54a932a48abbabfcdde90e57c180e3bfef43e68640f8409"},{"version":"0x00004020","timestamp":"0xcf45b066","nBits":"0x07936019","nonce":"0xc61ce897","previousBlockHash":"0xfcb29637277787d85c4e13cedc9963739880eb1e814b686e1d00000000000000","merkleRootHash":"0x53b73db9980f508ce0e1d035998669b1ba3a87d38a0702731ab24e158ae7bc4a"},{"version":"0x0000a020","timestamp":"0xdf45b066","nBits":"0x07936019","nonce":"0x0641b978","previousBlockHash":"0xcf435122ba1318d1b9dc0dc275fdc00d5f503da7231fd5704400000000000000","merkleRootHash":"0xb60bc9225065bde3d76189b61a6a8bf3e02f2e7684d6760a114bbe43761e659e"},{"version":"0x00000020","timestamp":"0x9a4ab066","nBits":"0xffff001d","nonce":"0xe0152ac4","previousBlockHash":"0x63f2701e16908f5b4212fae17d2f7c8e52aa1af0273d0f022f00000000000000","merkleRootHash":"0x3481c639b09edd85702f2b43893edd26049ae6de4a94e6ba4edc8d90ed7f627a"},{"version":"0x00e0ff2f","timestamp":"0x1b4bb066","nBits":"0x07936019","nonce":"0xf9d14085","previousBlockHash":"0x1a644f1ba72624b547cdf29e55ea88bd46877a48d48ec64593be75a400000000","merkleRootHash":"0xc6c162df7614c0437bdab00160c4a674e1fe7104691357c901f61429d9dfb5a2"},{"version":"0x00a0de24","timestamp":"0x7d4cb066","nBits":"0x07936019","nonce":"0x62c44c12","previousBlockHash":"0x2d0516827132fa7d84cbae149b089d892a5f01c05a3250ea2200000000000000","merkleRootHash":"0x75679ace500e54ca1b325c0fe70b7f1cce87d6cf01da9548b0ad57b747428b1b"},{"version":"0x00000020","timestamp":"0xf94cb066","nBits":"0x07936019","nonce":"0x8802418a","previousBlockHash":"0x80045d2b78ea10287b0f71a2a20afcd9649ed14519e2e68d3700000000000000","merkleRootHash":"0xfa47bc94007d998678e82a35a095c4aebe36f2d8f259e0489495e5deca99434b"},{"version":"0x00a0072f","timestamp":"0x994eb066","nBits":"0x07936019","nonce":"0x28c86557","previousBlockHash":"0x3973211e5bdd635721f2371b85856c071f2078e3dd843e002200000000000000","merkleRootHash":"0xae01715ddaa4d8d21c8c36256c558545093bcfe416a67c9926e00aea256f57a6"},{"version":"0x00004020","timestamp":"0xb04fb066","nBits":"0x07936019","nonce":"0x500bc3af","previousBlockHash":"0xc5df5b7a7e4748276bbcaea181a42ff2fae86c608e86f69b1a00000000000000","merkleRootHash":"0xdef59e3ed803f3911bbe51f85d12ef01f96cf3ddd0879e51cfbbc1f670764394"},{"version":"0x00008020","timestamp":"0x6950b066","nBits":"0x07936019","nonce":"0xa21684a9","previousBlockHash":"0xc09bca495a43014822f35bbb015faa8b057e4e39c43bde934d00000000000000","merkleRootHash":"0xc2926cb67e52770d45a58f3764f115121494fb939cd45be305131d2768447c53"},{"version":"0x00000020","timestamp":"0x9851b066","nBits":"0x07936019","nonce":"0xc8f4e1c5","previousBlockHash":"0xeddb325eef2e97ab3ccb54afbf5db5a5bc8519d7b76d96423d00000000000000","merkleRootHash":"0xb0817276b8d5408a64c8ef1c9f757587a7b2d634f2c001d5850fb92c14f47efb"},{"version":"0x00e0ff2f","timestamp":"0x8b53b066","nBits":"0x07936019","nonce":"0x1824c377","previousBlockHash":"0x4a075b4e36291b3cbd2586fc33243b73c9fd282e6701ab365b00000000000000","merkleRootHash":"0xefcdeb173313b14a8af088b9791c88f0822ee282471eca8abe2f65568799cc97"},{"version":"0x0060db2a","timestamp":"0x5d55b066","nBits":"0x07936019","nonce":"0x3a2d0201","previousBlockHash":"0xa46c393e91b78993e58fe6982249352f593c934b1448401a1f00000000000000","merkleRootHash":"0x541a89d89c0bf393ec71d2c3ad8e25d3eb0173ad09c1ffabd96ddfeb48cbaff6"},{"version":"0x00008020","timestamp":"0x6955b066","nBits":"0x07936019","nonce":"0xc311e7dc","previousBlockHash":"0x3cb7bc88429a6da3dcfeb89219c886785603f29b792472703c00000000000000","merkleRootHash":"0x957982173d898337e60c03f9480776a4bbd9d1adad2ba43c615fe583eea8654e"},{"version":"0x00600020","timestamp":"0x1859b066","nBits":"0x07936019","nonce":"0x1cdde1c7","previousBlockHash":"0x9984f82655f31bbf2b01f64f50196e147b1d8bdd88c4e5a54300000000000000","merkleRootHash":"0xccd39b1765136b0d8ae6f503e4f529ec0650e657b014633f3ce02744d689e6e1"},{"version":"0x0000a020","timestamp":"0x025ab066","nBits":"0x07936019","nonce":"0x2b57cad1","previousBlockHash":"0xf6fba7b62b1cffe62d135fe61334b23b0bdf0fd9369b6a292600000000000000","merkleRootHash":"0xe04d38918cd87c6da9161cb98dc751771e764c36f48f8b59dcaccca74661ab44"},{"version":"0x00008020","timestamp":"0x215cb066","nBits":"0x07936019","nonce":"0x8a421bee","previousBlockHash":"0x2de700b8287191ed77c4689f0ab4056c7ddca1c5f0bdc5325700000000000000","merkleRootHash":"0x36640c992a1943c5e1e0991e097184acb980673f9c4a968dcbd6094a4b5cba1c"},{"version":"0x00000020","timestamp":"0xd260b066","nBits":"0xffff001d","nonce":"0x0827f73e","previousBlockHash":"0x5d63dbd2dce3d2a02fa14f3bde84044e473300c2348653d01f00000000000000","merkleRootHash":"0xc96d4249a05bcf3d4f8c616d1006970e1413f1573262c413e7e40d03f46e6d3d"},{"version":"0x00000020","timestamp":"0x8365b066","nBits":"0xffff001d","nonce":"0xf1968e1e","previousBlockHash":"0xb81a12b70d84b8c231247561c4909f1c533fd9615e04a96db262e9dd00000000","merkleRootHash":"0xc53ac6e581ac388ce73859e2371db4b720527a37e3dc35af64651bf2d94559c7"},{"version":"0x00000020","timestamp":"0xeb63b066","nBits":"0x07936019","nonce":"0xae09250f","previousBlockHash":"0x9254681026329ac5ba8f290a8b04e7c923a6e9e43082c69743d0743a00000000","merkleRootHash":"0x3d00cb8ad74712ccdc2445edd13cadb225d6564f14b75f19cd2994b3b86d9d07"},{"version":"0x00000020","timestamp":"0x9c68b066","nBits":"0xffff001d","nonce":"0x71e64e89","previousBlockHash":"0x6ed911f114354eb177e52a1af20e14af1e3fa3a1a4a32f363c00000000000000","merkleRootHash":"0x7a9bcae6c2e5cd7307dc381f3fb795ef7770a4ae9b2ef9548138d82199e1e00a"},{"version":"0x00000020","timestamp":"0x4d6db066","nBits":"0xffff001d","nonce":"0x634c0711","previousBlockHash":"0x19bf116e3883c96e66fb59302df7b65ae45385222e67156c10689ebb00000000","merkleRootHash":"0x2b074f8f0b4c2b422e527c0fdea45124440d7c28a3d73190cb7f1cfd8d8e74e8"},{"version":"0x00000020","timestamp":"0xfe71b066","nBits":"0xffff001d","nonce":"0x44ee47a9","previousBlockHash":"0xb63f2ff34d1f878040fd551ee66dd4a459cc4302a55c383a46af1c4400000000","merkleRootHash":"0x8a0dc4c86094cd27d2d96d76f854412c1cdeba7d003f85e164f3a2818bbc79da"},{"version":"0x00000020","timestamp":"0x9a6ab066","nBits":"0x07936019","nonce":"0xa20b23a4","previousBlockHash":"0xd28e3557e9198e7c8433975735eae9267e8ed76d5b8ec88a793bc07000000000","merkleRootHash":"0x6a4c0074fe41fe74a5c8f1a5de2559fee6828d8b22e2e4c843a8c1778f2ed758"},{"version":"0x00000020","timestamp":"0x4b6fb066","nBits":"0xffff001d","nonce":"0xf5b15500","previousBlockHash":"0xf8120d84dec13837b8b3619168dbdb9e457cf6a534994ade1d00000000000000","merkleRootHash":"0xe744aaf39fc31484e810ab6f5ff5588e01ab7bad9a9563b93f32496792bcefcc"},{"version":"0x0000c020","timestamp":"0x666cb066","nBits":"0x07936019","nonce":"0x41013206","previousBlockHash":"0x0add8dcf27f87bac5fe02ccc5823bafcf763efcc6cf730c8ee540ecd00000000","merkleRootHash":"0xe283a62e4227e8904005a1191074b8ef8315a32e1c49c030ff808371b459e3e8"},{"version":"0x00000020","timestamp":"0x1771b066","nBits":"0xffff001d","nonce":"0x59e86e25","previousBlockHash":"0xd99816ae57a21fa0dca4b65befa1ecfbcd298eba8bed7aab2b00000000000000","merkleRootHash":"0x9869e24a242a3d79a9ebb3420c6f20a31dd9f56b9aa8c78f88cc3edc01aeea60"},{"version":"0x00000020","timestamp":"0xc875b066","nBits":"0xffff001d","nonce":"0x63439e53","previousBlockHash":"0x455dc41ea8e262f6fefdd319e25523ae581b95d06eb155632a541a8f00000000","merkleRootHash":"0xa7ceb462b520f4fe45b292c4b304de9ff94a3d8ec288ddae89cd2d4094b0d908"},{"version":"0x00000020","timestamp":"0x797ab066","nBits":"0xffff001d","nonce":"0xb0f88713","previousBlockHash":"0x66dbe7ebda9109fe5fce23444a246b9da7373c252cc3a556b7db1d8800000000","merkleRootHash":"0xbdf70b09044e096606caa338910a76b95dd8f00deab5800823746140db2588d3"},{"version":"0x00000020","timestamp":"0x2a7fb066","nBits":"0xffff001d","nonce":"0xe29c5309","previousBlockHash":"0xf3d12444b45c4ea6f209f6e52fded6ec3c20996400fe33b2e68a860a00000000","merkleRootHash":"0xfd0170a9e561b4f4955ad9d0d0573ae35c51d8034a4c13430df7319d37bee3d8"},{"version":"0x00000020","timestamp":"0xdb83b066","nBits":"0xffff001d","nonce":"0x0b6ee152","previousBlockHash":"0x1efe18184bec6deff7f8977ee9e0f678ac00a44efad43b3c9c807fea00000000","merkleRootHash":"0x103cdd7045a5f78db729583d7a2cb890010d70fbc496667dff8925b50e6fe4c3"},{"version":"0x00000020","timestamp":"0x8c88b066","nBits":"0xffff001d","nonce":"0x65745a30","previousBlockHash":"0x18789a3376138bb42fc5219f153313e36e62ccf956be8e8b0ccedcdd00000000","merkleRootHash":"0xcef9ce11fcf5a0ba6e17c8e4ca0cee9a9e63bb31d0014140ad29097c58881e36"},{"version":"0x00000020","timestamp":"0x3d8db066","nBits":"0xffff001d","nonce":"0x655de415","previousBlockHash":"0xf0f7556640192285151866a1bec258e090328d4173ce84fad5ad523f00000000","merkleRootHash":"0x7726cff29a49ee0b11d7418dbcc25433863eee58f0e69c0a14878318347d9596"},{"version":"0x00000020","timestamp":"0xee91b066","nBits":"0xffff001d","nonce":"0x3a51e835","previousBlockHash":"0xf8ed195e721ace700ddfaee6f8eed48d1f769cb57f912edb81c9d8e700000000","merkleRootHash":"0x5481ca432c95718f5ddad2d7ef24953857b2fe0b3b2998596fc9a44f730eaa4c"},{"version":"0x00000020","timestamp":"0x9f96b066","nBits":"0xffff001d","nonce":"0x431e2f06","previousBlockHash":"0xcf080348bd00e8bc4050be3e1b448c1fafa552baf49ced861bcb849400000000","merkleRootHash":"0x7bc32ca981c67ecf479d3c6816163fcc3f4745415ea7ffa20c49d42c0f8e03c1"},{"version":"0x00400020","timestamp":"0xc47fb066","nBits":"0x07936019","nonce":"0x4c541db4","previousBlockHash":"0xc7ee45b1d3953cf5bb687e4ae54e1c5fdf7b995a00ae1081b8f1d43c00000000","merkleRootHash":"0x5de10da2baf0a87bd5bbf6097202bd1c9a99b51909a95e22cafa888316836f6c"},{"version":"0x00000020","timestamp":"0x7684b066","nBits":"0xffff001d","nonce":"0x6039637c","previousBlockHash":"0xf9a274ca04f528a8d8ae291ac0faf17a42b184e07822b88e0800000000000000","merkleRootHash":"0x716bfbc3e2dd715d4eb39d23851d428fb353812c7b1d6db7ed9ae4dde35a72b6"},{"version":"0x00000020","timestamp":"0x3689b066","nBits":"0xffff001d","nonce":"0xf369c3df","previousBlockHash":"0x66b88d67833902d94928d61a710035b232290a5b84541b2b9a0515ce00000000","merkleRootHash":"0x6b7b48e9aa2f662efa68a2391b524fe359ded8e48563ae05ac87883db173ae3f"},{"version":"0x00000020","timestamp":"0xeb8db066","nBits":"0xffff001d","nonce":"0x75bf4a02","previousBlockHash":"0xabb64979854ec31ee568a24301ad7e17e9c8db8102e228398bdea3f900000000","merkleRootHash":"0x7e8257b4eedf812987ca647aa32612d3a41406342d7f9d8f9f62d46b58e71a68"},{"version":"0x00000020","timestamp":"0x9e92b066","nBits":"0xffff001d","nonce":"0xa00a39de","previousBlockHash":"0xb1b3faab8dfc1e80061f37c222fe25b91595c55f1621eaf027a2d5ff00000000","merkleRootHash":"0x3868a61dd607f3ef410fd487e35c0ce695ff8c808900180337452c9c24e183fc"},{"version":"0x00000020","timestamp":"0xa094b066","nBits":"0x07936019","nonce":"0x5f1429d4","previousBlockHash":"0x3e1579c20203cc3bea94abff7eac59c62ca6d8ac8c6c91d46dbb1af700000000","merkleRootHash":"0x0afabd03b9703286481b34b157b03aff9dbc821fc77de631b989950954a9406b"},{"version":"0x00000020","timestamp":"0x3798b066","nBits":"0x07936019","nonce":"0xba595127","previousBlockHash":"0x257978e0ac024d13717e0571ae4f467ddba2d1fd7e417e634300000000000000","merkleRootHash":"0x0c62fad82efc31c18b35dfc299683b46d18b8b1c7ceb1d530eaf814489edda20"},{"version":"0x0040d42c","timestamp":"0x7a99b066","nBits":"0x07936019","nonce":"0x24033f82","previousBlockHash":"0x65db0d3ea06a79fc64dbd079ffddea23a6dbc08b617594682100000000000000","merkleRootHash":"0x6a2a9f4d54824b9a0027f25ca8d77244abe98b2c90d08556b565ce3716e793a3"},{"version":"0x00004020","timestamp":"0x7d9bb066","nBits":"0x07936019","nonce":"0x43809d38","previousBlockHash":"0x2cd924ce5d2da611c14c68529fdf27783611f6c9a9c583ac4500000000000000","merkleRootHash":"0xaf4333736486e62cdbdae42dca59914774e98ec02ec49ab2f14d9310e3506933"},{"version":"0x00004020","timestamp":"0xc69db066","nBits":"0x07936019","nonce":"0x20c867af","previousBlockHash":"0x4083249bd7b5b6d39db26386e6f7678c8e1bcfcc6f3305542600000000000000","merkleRootHash":"0x20dcdc537fa8d2eaeca045667db1bd1e1dbcf7f7ac191469b6889495c0d1c9dd"},{"version":"0x00600020","timestamp":"0xc0a1b066","nBits":"0x07936019","nonce":"0x73b5cccc","previousBlockHash":"0x0ce673f92fcc5ca6996b2e12d3e284fb2555b8a5b169b3434700000000000000","merkleRootHash":"0x16c5f7aaee6b3c8e39bb0fcc223d0514be613dad2bca3b9f44f3581118ee86b2"},{"version":"0x00000020","timestamp":"0x78a6b066","nBits":"0xffff001d","nonce":"0xd6378c18","previousBlockHash":"0x9960e3369f108e08408d4bf2e2be9954641371078d29925a3e00000000000000","merkleRootHash":"0x91e7740b81b6de4bd0d4bc7a8ec823966cde9bd7715a7c46e79f28a403b7ae1e"},{"version":"0x00e0ff27","timestamp":"0xeba7b066","nBits":"0x07936019","nonce":"0x13d2c6dd","previousBlockHash":"0xd9f58323beb1a2f3fb175638991f0d5101fd34ce082091b486ccee1400000000","merkleRootHash":"0xe7c9f7d71c46c2bc9f1fbda33fc3baed1bd9adb9044afc595650bfdbe6f03f09"},{"version":"0x00000020","timestamp":"0x63a8b066","nBits":"0x07936019","nonce":"0xd69c3825","previousBlockHash":"0xa66d6f4c403a2528864c6073545bb376d71e95de107970411c00000000000000","merkleRootHash":"0x48678648190ed6b506d70d6f6937ad2f23494bca6fcd0182439b358b027ea7dd"},{"version":"0x00000020","timestamp":"0x17adb066","nBits":"0xffff001d","nonce":"0x9b64839a","previousBlockHash":"0x34eee98b82d441361b9f39d6b7ce8e468753655ecc8588e63400000000000000","merkleRootHash":"0x9ff141ddb05e9e2b36fa452ade6b1acf87e49ec94ab9a9800934a072f18341df"},{"version":"0x00e0ff27","timestamp":"0x1fb0b066","nBits":"0x07936019","nonce":"0x0ad108a6","previousBlockHash":"0x3dbc6a8cc42063cf9272b2dae879e4bad6a30cefb401e9ac64c3d94d00000000","merkleRootHash":"0x001d2faff19302262988df6d385696316fa54dc95be443381e78830e03cc47e5"},{"version":"0x00200020","timestamp":"0x84b0b066","nBits":"0x07936019","nonce":"0x3203ff08","previousBlockHash":"0x4cfd0d10f670893a0f2d82cb096e077bd11bcba8f79740ed1200000000000000","merkleRootHash":"0x0289a9388ef4f58cd97c71bf5f6d11cce5482921ac196cb34c33a1e4d9acf95c"},{"version":"0x00000020","timestamp":"0x3cb5b066","nBits":"0xffff001d","nonce":"0x421ec0de","previousBlockHash":"0x25549c747bb4122bb8adc8572a89e01723f127cf2ee2b5484100000000000000","merkleRootHash":"0x921f5868ca55814b4d1f6aa8ff170856507b8b9e90abd30907fbf257333d9c17"},{"version":"0x00000020","timestamp":"0xf2b9b066","nBits":"0xffff001d","nonce":"0x33d02705","previousBlockHash":"0xdfd281a2c51afbc6d7b1bce04aadb02ff0464cb58a3b46bddb78b36400000000","merkleRootHash":"0xa5646972905da4a218faf428bb9716b6b3fe6c0b0e9da00cfcde94601e11c2fc"},{"version":"0x00000020","timestamp":"0x5cbab066","nBits":"0x07936019","nonce":"0x8502296b","previousBlockHash":"0x778d7e4830c01e859b717ab2bde651e9fc8b1ea7c1aac687057c9ab000000000","merkleRootHash":"0x46ea8ce0d2530a86243595afcfe1933fae75707bf97a2275686d8543260f5a75"},{"version":"0x00e0ff37","timestamp":"0x23bbb066","nBits":"0x07936019","nonce":"0xa1ad0567","previousBlockHash":"0xfd5249fb7f4d72bd5b1abd78bc5ced6a90741714475c9b105000000000000000","merkleRootHash":"0xa0714f9e0a1169dc1614731d9bb31f4fe36feef6bd971dd75bd60d94a649da3e"},{"version":"0x00000020","timestamp":"0xd8bfb066","nBits":"0xffff001d","nonce":"0x4ada2112","previousBlockHash":"0xe6783236a5c86d062c9c6d41154d9e8f045a95949dbc55d02400000000000000","merkleRootHash":"0xc2318a698ae8ae5e8f48d37bac43d491dd28d7e4289f6de48133aed237656ac1"},{"version":"0x00000020","timestamp":"0x89c4b066","nBits":"0xffff001d","nonce":"0xcb1674b5","previousBlockHash":"0xcea595ba1de324dc8c2ae57b2ddef1383ded3231383e5ecd9af23c9800000000","merkleRootHash":"0x24dede9fcee4c13e92bbc38693cc0347e30ca3fa81656f04644c4d7c3b4cf43f"},{"version":"0x00000020","timestamp":"0x3ac9b066","nBits":"0xffff001d","nonce":"0x68e12dc4","previousBlockHash":"0xa919c786c60db477adce3e5903748169863e945f7e0f985e873d0d1500000000","merkleRootHash":"0x1ea5b69cc1819ec9c0f7f30db536367cb6b80f6f674d231139149fc9fb30129e"},{"version":"0x00400020","timestamp":"0x88cab066","nBits":"0x07936019","nonce":"0xfa67e1f1","previousBlockHash":"0x605c03c0419105dc0b9b06f229bc640a468ff9a32a671f7f053d4ef700000000","merkleRootHash":"0xb3c2b6adfe627f49b3a5990af7f8716cc527f3cc832a271114a37a5b95fffc56"},{"version":"0x00400020","timestamp":"0xa4ccb066","nBits":"0x07936019","nonce":"0x9fd84ff5","previousBlockHash":"0x9fd73c7849e97b765d1b524d7a98c5d0f100ac3ad8e83d1a5c00000000000000","merkleRootHash":"0x64e61b7296f267579aa5904712a68da038a038de09c62f02b19fa66667fe8877"},{"version":"0x00600020","timestamp":"0x58cdb066","nBits":"0x07936019","nonce":"0xfb50e424","previousBlockHash":"0xfb1d252ffe9e591c298145534d166b4729e7d83fca50b1e83700000000000000","merkleRootHash":"0xea0a96e603ad0b96f9b2ba0971a106ce9a09394ff332609f30dab8097c5c529b"},{"version":"0x00000020","timestamp":"0xc3cfb066","nBits":"0x07936019","nonce":"0xc03cb485","previousBlockHash":"0x44e49682592f5db67ce9aafca23ab8d9c0a9ad90fb8e6e1a2800000000000000","merkleRootHash":"0x6b187074a2c7e9dd955c62387bac307fb03ab6c3b86c64b2ed2c8f8a46651be5"},{"version":"0x00600020","timestamp":"0x7ad4b066","nBits":"0xffff001d","nonce":"0xa3828079","previousBlockHash":"0x9e56ae64ce33e451890269844265861489010ec9ae6e5eb64800000000000000","merkleRootHash":"0xc9aa1fccbf4fda835f576ed039d15d0f8d3113d63a9a2057b7d249c92ae9f56d"},{"version":"0x00600020","timestamp":"0x2ed9b066","nBits":"0xffff001d","nonce":"0x52459241","previousBlockHash":"0x8919c13856e3eab2fc8c6416a7cbacf8c4b27b3f1e186bbba0b4210000000000","merkleRootHash":"0x9efb731ea0b79b2298bf247c359f5a87ff7f6edcda84dc5fb62f1e3acd4a7984"},{"version":"0x00000020","timestamp":"0x31d9b066","nBits":"0x07936019","nonce":"0xaf66a417","previousBlockHash":"0x7a452b0f931df56ec94025cca4e70f98617439120d259d00eb380e0100000000","merkleRootHash":"0x962c4b14a0e31b18e3ad5832487f6c0c09f28fa0672f4870b8a0647cef6c3cf3"},{"version":"0x00000020","timestamp":"0x88d9b066","nBits":"0x07936019","nonce":"0x927331d2","previousBlockHash":"0x9f4821202307709680d01ac7f15a74d1dd5f159487a55ca61a00000000000000","merkleRootHash":"0x79ef213231b6967c0fb7eeb91a459d68e7b4979d22890d831693f0af119b2dfd"},{"version":"0x00000020","timestamp":"0x68dbb066","nBits":"0x07936019","nonce":"0xdbb3ec73","previousBlockHash":"0xcaa0fbcce5b87895c3305483a9d4327e7bee59b7482c01c34a00000000000000","merkleRootHash":"0x85464493789185752db215a1618f6ac98f72e2f0eb1f473c1749f09ead484b07"},{"version":"0x00e0fa26","timestamp":"0xf7dfb066","nBits":"0x07936019","nonce":"0x314d8f00","previousBlockHash":"0xc8bc715e5acd336853d4405c1142e2b0d4c39ea41a4a0cec0200000000000000","merkleRootHash":"0x3bc8168d7ad30332aed281c8f2f7afd52602c4a4bc4be432edea4e3f1687e24d"},{"version":"0x0060d720","timestamp":"0x14e1b066","nBits":"0x07936019","nonce":"0x2c35c7ab","previousBlockHash":"0xf762dcee2ad5f4c6ebc10e1a5a899de9b542fa7f4aeb64771d00000000000000","merkleRootHash":"0x298da88716f4a5b54cf6792fee3c14851009b2680bd9c6aadaa93e296aee1574"},{"version":"0x00e0ff2f","timestamp":"0x93e1b066","nBits":"0x07936019","nonce":"0x3c2bfb24","previousBlockHash":"0x1ec1d4ab0dcbe0162fd646cb8eac5edc74ea61ca18c9af333d00000000000000","merkleRootHash":"0xf39a90ca704f4e9e9e24c0f54e5b2be62f9946f6ae5e727d3b774e7b4aee9de8"},{"version":"0x00400020","timestamp":"0x4ae6b066","nBits":"0xffff001d","nonce":"0xaf0af72e","previousBlockHash":"0x030c1957e71e79a90b64d02605b30c2c419a0fab37ce45b94400000000000000","merkleRootHash":"0x1a74709a6d10c477a80ea32c91400d23fa85e2a1dce105ee3532c6bfb4f22a8e"},{"version":"0x00e0ff2f","timestamp":"0xb7eab066","nBits":"0x07936019","nonce":"0x00f35413","previousBlockHash":"0xb42014406a3a4354fe09fd4563dd89066ef2190ae190e27c1432100000000000","merkleRootHash":"0x63ccffde729d487ea03b4feb2eb88d94417735b57643c5af610e170d4d7759d1"},{"version":"0x00600020","timestamp":"0x58ebb066","nBits":"0x07936019","nonce":"0xc5e041ee","previousBlockHash":"0xde9c3858e695c5c0b5ac3c90d57b164ca3ee7143a93753793c00000000000000","merkleRootHash":"0x2133b092bde1f4909b6495ec6f971032418ad2c6e3220de8260df5a748cde2c4"},{"version":"0x00000020","timestamp":"0x09f0b066","nBits":"0xffff001d","nonce":"0x8c97a80c","previousBlockHash":"0xd462778a6d747324e6866d322bdc706715911be803e07cff0400000000000000","merkleRootHash":"0xbe9bfffb0dcf090fe0d9879cceb429ece483c6e99d514350a969fe6eeefa45ac"},{"version":"0x00000020","timestamp":"0xbaf4b066","nBits":"0xffff001d","nonce":"0xe3805023","previousBlockHash":"0xe820092f984e41abd39185d064820fa92cc9a4a1f569c510a181e70400000000","merkleRootHash":"0x70f332ebd830d09b82a8888bcd665220cbff053f421fdf091db475fcf9870ffc"},{"version":"0x00200020","timestamp":"0x54efb066","nBits":"0x07936019","nonce":"0x3143256a","previousBlockHash":"0x24194db7b36cee7f13a614a3253b0a561764279a7253f5f664610e9b00000000","merkleRootHash":"0xb452579f9d6c2c5b2a492d1f5a3f0baa32737b780b433ce8711d80628774736b"},{"version":"0x0040e024","timestamp":"0x9af1b066","nBits":"0x07936019","nonce":"0x23ca092d","previousBlockHash":"0xcb66c3d40944657c6b47b07208ff5d79e88fba700c77ffd83800000000000000","merkleRootHash":"0xcb043d2de40494e3fdf5e924821a470fd27866d66d22cccf7db8f5e46b01f4a9"},{"version":"0x0040152f","timestamp":"0x03f2b066","nBits":"0x07936019","nonce":"0x380d40d8","previousBlockHash":"0x1f2c9653514a728b7249fdc5a668df01f37fd7daed3e8f653d00000000000000","merkleRootHash":"0x99ef2340489bd11b43d0db6fa8c5b9ebb5c7756faf3b3a3d7ded056222fe4ffc"},{"version":"0x00e0ff27","timestamp":"0x27f3b066","nBits":"0x07936019","nonce":"0x1f7b980e","previousBlockHash":"0x0b866bee6254b89fb096f57f4139cdeb070b5a4da3288cca4600000000000000","merkleRootHash":"0xb6eba351f4cab058ed1e88d8a57b7246ac317a7f7da96661eda7b266a8d04d70"},{"version":"0x00000020","timestamp":"0xd8f7b066","nBits":"0xffff001d","nonce":"0xb034cd03","previousBlockHash":"0x7ac2a6ea219541299117bd6b9218120c87b87b0a6991ac345c00000000000000","merkleRootHash":"0x2ecf0ce7d6b01894133874ad6bfb94aefca5e748f978797b9a93bab3c5f57ee4"},{"version":"0x0080892b","timestamp":"0xd0f7b066","nBits":"0x07936019","nonce":"0x483cbb9e","previousBlockHash":"0xc9784d7de445a1ead6a24e9a41bd7988be0f858c0ac22ab485f81a3000000000","merkleRootHash":"0xd070cb4f9be16cb1f95edd7ad9fc55c5264bc1d69b9f45f1df7218924a517fda"},{"version":"0x00400020","timestamp":"0xb4f8b066","nBits":"0x07936019","nonce":"0x8ca87401","previousBlockHash":"0xf35c45d4286c33ac8fc1b02eb87be8b49fa9c1dd4b08b80f1400000000000000","merkleRootHash":"0x2d141d149360dd7ad6551effa32af60eded8bacd538125968977998d5f73d4bd"},{"version":"0x00000020","timestamp":"0x65fdb066","nBits":"0xffff001d","nonce":"0x0b535d17","previousBlockHash":"0x2fe1ccafd6551bed68d61bb9522ad6a7df7eb75d2f50f2100e00000000000000","merkleRootHash":"0x6f6e7be0df254b35080740a581488fbab66a9c7c2a38d5640d06c947d27ee55e"},{"version":"0x00000020","timestamp":"0x1602b166","nBits":"0xffff001d","nonce":"0x815a3f1b","previousBlockHash":"0x2479aa3be1ca22bc91a27183c7aa4912d6a41c16a9c887f7ab7e77cd00000000","merkleRootHash":"0x5fa810441fd59d786ed54573ca5e5046a021b13c340f1311f033d88351155f79"},{"version":"0x00000020","timestamp":"0xf3f9b066","nBits":"0x07936019","nonce":"0x7f5fca7f","previousBlockHash":"0xd745f13ec49cb83bc9e5c3645ea02e8101e8b835c943d23f295540ef00000000","merkleRootHash":"0xf288765019d94689b4dce72746ac48068be039956b5a6d5fae68ab9a2c2592cc"},{"version":"0x00000020","timestamp":"0x58fab066","nBits":"0x07936019","nonce":"0x9f5d26a8","previousBlockHash":"0xc25cd0bc5db33eb21bed66663b1d22c0677ab8bbd2e23c601d00000000000000","merkleRootHash":"0x72ed562a82d59820bfe260c2e7fea78918097292306108d620d907dcfa0d53e0"},{"version":"0x00000020","timestamp":"0x09ffb066","nBits":"0xffff001d","nonce":"0x69ec4414","previousBlockHash":"0x301a5efef31cd77b56b3c836acdea5d9a72d5b1babc71df61100000000000000","merkleRootHash":"0x54cda81e86f779f7e6f6e24be9ac28845d5510b23fd45b5d288c44cfa0d3170c"},{"version":"0x00000020","timestamp":"0xba03b166","nBits":"0xffff001d","nonce":"0x002c0244","previousBlockHash":"0x60db2b26798ba3c8a56b4de3bab96e3db37a1f601089f6554459845400000000","merkleRootHash":"0x425dbeaee0d919331160b92e5b1c0a36d6d24db7409c9ca68e495f8364d03fe1"},{"version":"0x00000020","timestamp":"0x6b08b166","nBits":"0xffff001d","nonce":"0x507fd15b","previousBlockHash":"0x24ecb3da70db8a00f7132ca13c2ef7a706065da4ac7a00268be35ab000000000","merkleRootHash":"0x928291bb2ea9bcec1caa8aa67d4eb0bec57522631f0d0cadeaaad0725ee4b4f1"},{"version":"0x00805e2f","timestamp":"0x8dfeb066","nBits":"0x07936019","nonce":"0x4824f86b","previousBlockHash":"0xab3ab5e00a222216ccbc8b814bcb4e2064e45104d8ef9a2505674f8200000000","merkleRootHash":"0x3c5d4e1f1f408486107aae8940a028f42d2f208c821524fb74e1028ee1795c67"},{"version":"0x00000020","timestamp":"0x3e03b166","nBits":"0xffff001d","nonce":"0x83c0771f","previousBlockHash":"0xe4b9eb680aefa531130af17cdb0f404c5229a15c376396fa5c00000000000000","merkleRootHash":"0x6ffdad114fa406f9e883c6960be7dabd165bde51a514c80990c8026eb77b205f"},{"version":"0x00400020","timestamp":"0x8c02b166","nBits":"0x07936019","nonce":"0x624feec2","previousBlockHash":"0xeff86cd653bcf206be7de2709be70d603a7d98b58deed46c4ec9466e00000000","merkleRootHash":"0xe88a3506a7f60071aaf91abb89156ffeeea7d687d6b491b700021fbf49ba543f"},{"version":"0x00000020","timestamp":"0x3d07b166","nBits":"0xffff001d","nonce":"0xa775309a","previousBlockHash":"0xb75d90630edf8ebb609e6bffe604c437d3ee7b778c3a31cb5200000000000000","merkleRootHash":"0xc1020e886978542062651a13721cab5d17aba1e6dfc32e368d0079f3c9146b86"},{"version":"0x00400020","timestamp":"0xfc0ab166","nBits":"0x07936019","nonce":"0x21acf906","previousBlockHash":"0x794a03b54d5783d64de1ddd8ab25e738ccd8259259fc7caee323e72600000000","merkleRootHash":"0x6e32049ea836ff04fafef63ebafb0928e1360928974f92b6e57ddbe9b51b79ba"},{"version":"0x00000020","timestamp":"0xad0fb166","nBits":"0xffff001d","nonce":"0xb8d0730c","previousBlockHash":"0x1a762eb2fc5a5eab68115005f3976979a5ac51ac7fe5adfa4d00000000000000","merkleRootHash":"0x396232f9c788edf71c791de2c89439ef367f20beca2eab895bb48393da38539a"},{"version":"0x00000020","timestamp":"0x5e14b166","nBits":"0xffff001d","nonce":"0x4b266b04","previousBlockHash":"0x83864d42955049c26a8453d9684be9f318e6d66ff8971bfe18bc092a00000000","merkleRootHash":"0x2bf1117089421a71338163e2d2a4d87c38a9bdbcde2899d84034ecfa88fae2cf"},{"version":"0x00200020","timestamp":"0x9c10b166","nBits":"0x07936019","nonce":"0xa168f983","previousBlockHash":"0xf87c2457ef67c6f83d945421e3fa1379794387787e7f213ef7c08ea000000000","merkleRootHash":"0x88f7bdc00baf841cad3e3dbff7773f61f4d81671ff5744f83ed1fb649f68fb4a"},{"version":"0x00000020","timestamp":"0x4d15b166","nBits":"0xffff001d","nonce":"0x73db83bb","previousBlockHash":"0xe92b7537cfcd425377678d9d71a6054e93a2d237e084d7a50d00000000000000","merkleRootHash":"0xbbce2ed716840d80c03d00405f6176b74069ba2decd82500a0195ab227ec1774"},{"version":"0x00608027","timestamp":"0xc316b166","nBits":"0x07936019","nonce":"0x15249604","previousBlockHash":"0x67d14a69c68dee6db2ffa9df8cb8005f290b3d424951fed5666dd9f400000000","merkleRootHash":"0xff5229c93a2004b2c8cfc2cb4091a8050c993abcf97623e1022f43ea76ccbcd7"},{"version":"0x00000020","timestamp":"0x741bb166","nBits":"0xffff001d","nonce":"0x32d7b308","previousBlockHash":"0x0dd959562c95e7ed5b4020555a9ff9dd070b731b1ce07b115e00000000000000","merkleRootHash":"0x3149578f34e387b0fb19c27d561ef5158552eb56a40e0b145ce29507d387e1f2"},{"version":"0x00e0ff37","timestamp":"0x2f18b166","nBits":"0x07936019","nonce":"0x6347165f","previousBlockHash":"0x34ef66b65c38f6c0f71aac6f7c2406fbb03a0d4f63308aece450f78900000000","merkleRootHash":"0x71848b8c941ed4a0877e83b2813f8eded6c4a211f9bc8977d5b270aa7fd54a42"},{"version":"0x00000020","timestamp":"0xe31cb166","nBits":"0xffff001d","nonce":"0x69b4fe59","previousBlockHash":"0xa87b72088aa2e45c8fd8315c3769e3cf7c774c17ef6e0a0a3300000000000000","merkleRootHash":"0x4ee18506c4ca46207bcf2539caab8d9c865643fdb48b4d6abb07de79022549ba"},{"version":"0x00e0ff27","timestamp":"0xd01db166","nBits":"0x07936019","nonce":"0x7a8868ca","previousBlockHash":"0x8490bef02b8a5feb005d817eac5d893b65271e2e8ec4cbe8b5fc04c700000000","merkleRootHash":"0x3e9980cbb0997690b7b0179d60be6e32ddb075db238d387a9b4ec445407dae93"},{"version":"0x0040f623","timestamp":"0xd91eb166","nBits":"0x07936019","nonce":"0x42314c55","previousBlockHash":"0x84a895804df325512c1ecf0a82ad0404ddc4b2682516d80e2d00000000000000","merkleRootHash":"0xeed70006b241af624c14ecce17e7290494267c6721f13555b694f3b9a8af61ca"},{"version":"0x00809332","timestamp":"0xf71eb166","nBits":"0x07936019","nonce":"0x1f4814e4","previousBlockHash":"0x0a86c5cd0e4f8b9abe958ca724f1ad3c97962839add820a05100000000000000","merkleRootHash":"0x6cdc520d411897610df39fa2617df8b9c490cae14fb01d7dc681afd958f57874"},{"version":"0x00e0ff3f","timestamp":"0x3420b166","nBits":"0x07936019","nonce":"0x1d3a0741","previousBlockHash":"0x184835486007bc59c8fe90ae3caa4773b42d1ae284ca59361e00000000000000","merkleRootHash":"0xd5b899bffcdd47133d7bb31c69ce4743f2222f5c4919c74059ba046cb1cc3cf8"},{"version":"0x00603524","timestamp":"0xe720b166","nBits":"0x07936019","nonce":"0x48526b3c","previousBlockHash":"0x8f83489922048b69f3a98e537e35c2334605943d80f83ade1200000000000000","merkleRootHash":"0x1d246737014826c44fb020b64e4b4abbdb95425fffe0596b798cd306de7142e6"},{"version":"0x00809229","timestamp":"0xbc21b166","nBits":"0x07936019","nonce":"0x2435a63c","previousBlockHash":"0x0cccce85a99f0355b8f5d61fe26147cbf57bd9d495a3e3762000000000000000","merkleRootHash":"0xb49739d049e4f3d276ecb7f68840f37d1b793f95b1f4280e2d4f7e36d4f21358"},{"version":"0x00600020","timestamp":"0xc521b166","nBits":"0x07936019","nonce":"0xa141beeb","previousBlockHash":"0x9ec7a7adc467d7dd99a8457a3bf37ecb3acf834c2470f8600f00000000000000","merkleRootHash":"0x5547480f8131e7c849ce5d38d4094bd802087ba6b532d447f8816fc1910c5ff9"},{"version":"0x00400020","timestamp":"0x3022b166","nBits":"0x07936019","nonce":"0x74460003","previousBlockHash":"0x753ff940c801c4c69c7f7243ac8f17607ce3d96051da58633c00000000000000","merkleRootHash":"0x19236ddc85d697b8a1660b4ef5d75e07c0671808f6d17ebc27fa9a781bcb949b"},{"version":"0x00000020","timestamp":"0x6c22b166","nBits":"0x07936019","nonce":"0x8c5b8913","previousBlockHash":"0xc90e9ac6f1ff267b9dd98d04141aa1d97df9616ccd7ea4d14d00000000000000","merkleRootHash":"0x3f2a6fdc19dee5c9794186d7fc6b92dc200a0d78e59fcfb90babb61e05e0a149"},{"version":"0x00801e23","timestamp":"0x1723b166","nBits":"0x07936019","nonce":"0x88d24f23","previousBlockHash":"0x73899e5e898b641308b8c9d87b01469846218a3ebaae383e3500000000000000","merkleRootHash":"0x48d769a960e38218ecf82f55a73a7a1e99474e1e0c490a56dab237a4861615ae"},{"version":"0x00c0102a","timestamp":"0xc023b166","nBits":"0x07936019","nonce":"0x648b75b5","previousBlockHash":"0xf4638cad74cbd8f594980ea902743f8fbbe50f1e8350b0b83600000000000000","merkleRootHash":"0xa9585341ae358447d48b2159cfa492b16f8e857e97a0d69839e47d099b34e7f7"},{"version":"0x00000020","timestamp":"0x7128b166","nBits":"0xffff001d","nonce":"0xcb004822","previousBlockHash":"0x947e1562722d602d847b978c761d09333882867d095bebec2400000000000000","merkleRootHash":"0xa969292858281020add818c012da84dbcbd37ff103115ca56699538f79d99589"},{"version":"0x00400020","timestamp":"0xdc2ab166","nBits":"0x07936019","nonce":"0xae5d388f","previousBlockHash":"0x43957936b61273ef94caf4d951a2506ca2ae9d2596eaac429123830300000000","merkleRootHash":"0xb2dbdc721c32fe85824efa1f44e5803a27b91ee6db2cc7b856c42e4098df3563"},{"version":"0x00e0ff2f","timestamp":"0x842db166","nBits":"0x07936019","nonce":"0xb1098623","previousBlockHash":"0xb3fe65e331831fd5d85d550322c15b1e2982169e8b1a73291b00000000000000","merkleRootHash":"0xae5984080a78b82be22a49425fa82bf3ef3cddda701ea0e72497aeb13834df29"},{"version":"0x00004020","timestamp":"0xba31b166","nBits":"0x07936019","nonce":"0xcc68d7ee","previousBlockHash":"0xfef92a65aef839f7db009fb4eebfceeec89fd2b644ad04852400000000000000","merkleRootHash":"0x67c7fa9ebad48623c23cc675d4ee7436873a2c1afe070a13a9fd7d93187034a8"},{"version":"0x00e0622d","timestamp":"0x4d32b166","nBits":"0x07936019","nonce":"0x52b4ffbf","previousBlockHash":"0x3648db6158f989086a4b678f9109c343138b43d363db1a805d00000000000000","merkleRootHash":"0x44558c1beaf124f8dde9962b9b4f54f07cfb2eccaf59400d502694969034e30b"},{"version":"0x00e0ff2f","timestamp":"0x1434b166","nBits":"0x07936019","nonce":"0xb7467e62","previousBlockHash":"0x8cf1818f18322e53083c6f8567377ebe0b887d9720e82f415f00000000000000","merkleRootHash":"0xbb9a0bc5048ef87b159e64c0f1cc561d1873280a9c1d2c57c93f70084ceceb3f"},{"version":"0x00004020","timestamp":"0x4134b166","nBits":"0x07936019","nonce":"0x9d4315f0","previousBlockHash":"0xce217373afe1bc9aa8c46da5f621aa31f80caf3106c6a03a0800000000000000","merkleRootHash":"0x10d61b406c47be5c1640728fb1971d27ac4f20a0826c8ee3a5ed1068679f5ea4"},{"version":"0x00004020","timestamp":"0x9f34b166","nBits":"0x07936019","nonce":"0x105b14d6","previousBlockHash":"0x1dcbe342c025a5d3e76a1d81b66148744cf39c3f97a40edb3800000000000000","merkleRootHash":"0xf0b3d5325944349c607d55c278c6723c518de92e8917776ec0af582d7bdeaa9d"},{"version":"0x00004020","timestamp":"0x7536b166","nBits":"0x07936019","nonce":"0x90cf6c75","previousBlockHash":"0xcbfd89fc24c002f4bd9e3caa379a054a7466e91dd0d5bc4f6000000000000000","merkleRootHash":"0xe280391f39b314ae5b4f07fc5038588f949c0bf3b025f3fe95a85955947e7b03"},{"version":"0x0000c020","timestamp":"0xeb37b166","nBits":"0x07936019","nonce":"0x37087556","previousBlockHash":"0x959ada6cb11d9b602cabece4aa8ffe15ba8086ef836acc7e5f00000000000000","merkleRootHash":"0xbbc72a72b91bc940d3b73755f86cd374b40b028bbe05d689c21ce6bd7be068e3"},{"version":"0x00200020","timestamp":"0x6439b166","nBits":"0x07936019","nonce":"0xd7bbfbcd","previousBlockHash":"0x94421a5c7cbd03fa45107068c32c4f03c7503980241210125e00000000000000","merkleRootHash":"0xcc4ed0384add5a65d1f85f0bbcdab69edde5bf279f96afa7558e75e61597e2aa"},{"version":"0x00000020","timestamp":"0x2a3ab166","nBits":"0x07936019","nonce":"0x95e2ddf1","previousBlockHash":"0x89fc2222112183d53f54794276ce97b51507520ed67acd692200000000000000","merkleRootHash":"0xe678b51667132c928f5725371d740c8c9330f684bf6d80fcb007e017eb0da796"},{"version":"0x00004020","timestamp":"0xce3bb166","nBits":"0x07936019","nonce":"0x35c8e897","previousBlockHash":"0x234f6ccdd46bef82f7d989939aec3955662296f4cb0ab67c3d00000000000000","merkleRootHash":"0x19d331d7026e8737dac95ca8b8ba8f1a572239a14aab9f7ec66976e220aadbf1"},{"version":"0x00008020","timestamp":"0x9b3cb166","nBits":"0x07936019","nonce":"0x166c140d","previousBlockHash":"0x93c56aa2ba2bb73fd8e0fbb3a8004e6ccf4aba76bf9ef6874e00000000000000","merkleRootHash":"0x33c16f35b3872931b5a6fef515c15544f04e26907dad006c55e26c39a58f435f"},{"version":"0x00000020","timestamp":"0x4c41b166","nBits":"0xffff001d","nonce":"0xe630c303","previousBlockHash":"0x01f6f78923fdfe39673724d3d4209bc4ff21347bec2ecea70700000000000000","merkleRootHash":"0xe61e50665a166b96e554b196f8884f4e14b22fafa992b21b03349b4884ceaabd"},{"version":"0x00000020","timestamp":"0xfd45b166","nBits":"0xffff001d","nonce":"0x812f100c","previousBlockHash":"0x20f16540a2c0bd96a17a92f17f2039b0a8e8bb9730782130656f87d500000000","merkleRootHash":"0x82b28a6086b29310ff3d84ee5a87560ae7246bc29d213279e52cf74bb773bff3"},{"version":"0x00004020","timestamp":"0x4240b166","nBits":"0x07936019","nonce":"0x4f1888b2","previousBlockHash":"0xb090cc3e7e871546a5172d361411aeda3a773195b22cfaa42304194b00000000","merkleRootHash":"0x944ccb5ed34e40352e615f14a30dc219868ff943a2c7d3d7b5d3bcb188500311"},{"version":"0x00000020","timestamp":"0xd840b166","nBits":"0x07936019","nonce":"0xb4cf31f9","previousBlockHash":"0x69eb80169eabe62f41c3c2e4e4fdbbab2fb9a184b09257b70800000000000000","merkleRootHash":"0xe35c58bd88fd43a6dc72a294ab2e3720af3c5eecc44bfa456759ce969c94f870"},{"version":"0x00e0ff3f","timestamp":"0x8c45b166","nBits":"0xffff001d","nonce":"0x4c6e8daf","previousBlockHash":"0xf172187fa71ff03328e03c7cc07dd3129083f6b2b9fa86b24900000000000000","merkleRootHash":"0x0a7b6bd6e5a9613771e8c3e40ce56616bf0e5cdc187901637b5bc31d5a2a0ac8"},{"version":"0x00200020","timestamp":"0x8c45b166","nBits":"0x07936019","nonce":"0x75e86ec1","previousBlockHash":"0xb03ea06bcf095e1a3324debfb7c9c261eb8ebc16e8d673058e7e120000000000","merkleRootHash":"0xfe61d8897da3d2c61670f2aa6bbe87ccb16b16f321e17106bde9e8afcc399cc0"},{"version":"0x00000020","timestamp":"0x7848b166","nBits":"0x07936019","nonce":"0x845720bc","previousBlockHash":"0x4fadcf10e969221e0e09e7c26b32b940a103ff1d86e96fa45000000000000000","merkleRootHash":"0x0e20a8197a9458a164296ee846f12d8c5f2bbbc31bf9377d5bfa46516608e2ac"},{"version":"0x00609630","timestamp":"0xff4bb166","nBits":"0x07936019","nonce":"0x71c11c6c","previousBlockHash":"0x508d6c875c949d7246c03d4e1c9591b202260189f50dc21c2200000000000000","merkleRootHash":"0x337f7cc4303e1396472ef636c0177b4be30f7737d0d955f06d71d0d6403577b8"},{"version":"0x00000026","timestamp":"0x464cb166","nBits":"0x07936019","nonce":"0xacb43fb1","previousBlockHash":"0xfd1ffbe35ecc9238fededd846566172ab247e4eeae00e7a24a00000000000000","merkleRootHash":"0x37978279f6c4db961e3caae6662a8debf15e7e29daca872a82a145c39c0c819d"},{"version":"0x00000020","timestamp":"0xa04db166","nBits":"0x07936019","nonce":"0x15b2feba","previousBlockHash":"0xf5f6fc78594bce0117bddf2f85fa4b7e1a214174130af8000500000000000000","merkleRootHash":"0xa7814369578982dda429459ca81a7f8931b8f3ef7c94209ba5f45495ccf963f9"},{"version":"0x00e0ff37","timestamp":"0xf84fb166","nBits":"0x07936019","nonce":"0x7a65dcfe","previousBlockHash":"0x327012e8f2d2bb437190dfdb0b0b9ebdb7c41d148254622e5800000000000000","merkleRootHash":"0xf35f79655eb032a7bd27fcab4b997bb3a71788b33c1929ee391bfa797fa6dbf3"},{"version":"0x00e0ff2f","timestamp":"0xe850b166","nBits":"0x07936019","nonce":"0xc534e0a1","previousBlockHash":"0x87b0dc559e7444f618a80715048eb4c3870e392019b488254800000000000000","merkleRootHash":"0x45f3107da84e40cda93054cd91ced711ec3f8e5cfa691f649e6ab38b60bd9439"},{"version":"0x00000020","timestamp":"0x9d55b166","nBits":"0xffff001d","nonce":"0x26aa643d","previousBlockHash":"0xee51c8f32adc4a1923d00d9420683afe076287b300f429cb1700000000000000","merkleRootHash":"0xe98f7431501f01d10caee7429bca8c5b43a32c5cce1f994b14e5c5035562508a"},{"version":"0x00c0e123","timestamp":"0x505ab166","nBits":"0xffff001d","nonce":"0x2922bcfe","previousBlockHash":"0xf06a5e238d8c20d7a54db27dbb67c9e8a0df0f65d1a025e130d23b4200000000","merkleRootHash":"0xb726731d4498491eb5fef151dfd522c5f35d8caf1ec70b1fce14b765ae69b27c"},{"version":"0x00804828","timestamp":"0x315bb166","nBits":"0x07936019","nonce":"0x5f8d88d3","previousBlockHash":"0xc75098b8c5abf4c8c018edd5fc228f677da352bd6ec63f178963000000000000","merkleRootHash":"0x8e905a3d9c1f4910603186dfb77a7a15553895e8f3487826eb9f7549e8350654"},{"version":"0x00200020","timestamp":"0x045db166","nBits":"0x07936019","nonce":"0xfe450550","previousBlockHash":"0x990471cae4e16645f8c08e6d2bbbb23313fb5b2548ef950c1b00000000000000","merkleRootHash":"0xb65ca71cb9de80551c29f51aaf53f76928d3813d7d43ae90198b4a681546ddea"},{"version":"0x00000020","timestamp":"0xb85db166","nBits":"0x07936019","nonce":"0x5e2bd7a6","previousBlockHash":"0x5c497ecf522dffdf5f1c4aec0e016d8c5fbe73602a0485634900000000000000","merkleRootHash":"0x267217f3537929536f0f44ddada4e9c3333ea47b5c2c73483e1dd776ae2747ff"},{"version":"0x00200020","timestamp":"0x205fb166","nBits":"0x07936019","nonce":"0x9d9d60c5","previousBlockHash":"0xdcf473628c753fbd249788451c20e0af7ddab04f2e5935481000000000000000","merkleRootHash":"0x35054b6f862fed545a935ca452c19b06c13793f5ddf5a4d6f017d27435e22b4b"},{"version":"0x00809f20","timestamp":"0xa55fb166","nBits":"0x07936019","nonce":"0x2e9d3758","previousBlockHash":"0x8b773dd663c77f30ee73e1e99d31e9172c4f4b8ee0b241291700000000000000","merkleRootHash":"0x9755bcc56da184ee653fcfa8ba39b7634dbc6760b347bc48d13b770341a43d7e"},{"version":"0x00400020","timestamp":"0x0061b166","nBits":"0x07936019","nonce":"0xb28f3c2a","previousBlockHash":"0xc550fc2ab7d86fef995645dfb220ba8a2192b5765d3b5e514500000000000000","merkleRootHash":"0x5729a7bde2825d9bc3adff9e0ec5cb56cebda2d14ebf40c43a3abae89c7407b2"},{"version":"0x00a01823","timestamp":"0xc161b166","nBits":"0x07936019","nonce":"0x3de89d90","previousBlockHash":"0x6369f96d3e9cf0cb860ff919212094f605c15610c944f0a35900000000000000","merkleRootHash":"0x580bc21ea79e3011f264ee6400647c247f4c8ae0fc1ae3e9bd81c23a3e82e2c7"},{"version":"0x00404f34","timestamp":"0xdf61b166","nBits":"0x07936019","nonce":"0x1a71ec8e","previousBlockHash":"0x57f911bd8aa504b39deabb70b98b8d3619193dfa0d536fb11d00000000000000","merkleRootHash":"0x57865c0b6365d8846d4d623788b1a4b612142ef088bc8ee8504245db3c3cdf3d"},{"version":"0x00000020","timestamp":"0x9266b166","nBits":"0xffff001d","nonce":"0x0a39b613","previousBlockHash":"0xb167ed9e2b19991625a6965f78fc9f0365daddf643f514a91300000000000000","merkleRootHash":"0x28570afb1cac6c756fe2a924bc19b07b5cbbc71d3118624b38189644efa4c09d"},{"version":"0x00008020","timestamp":"0x456bb166","nBits":"0xffff001d","nonce":"0x0ec32614","previousBlockHash":"0x676a880d63f4e341c2e113087fe58a6a970bf371c3e56fee13dd360000000000","merkleRootHash":"0x82f4cb45c86419a45aaa1db4de37232ed2e13c0004b3eecb30b955f0ae86ec37"},{"version":"0x00e0ff2f","timestamp":"0xbc6db166","nBits":"0x07936019","nonce":"0x9bfbde7a","previousBlockHash":"0x59ae7686205475b43a5e7dea0569856aa5f484166d48a79a0725010000000000","merkleRootHash":"0x036ef525952afc4e74ae6aa494716c6edbba7d1001bce93f15da24bbfd2c3434"},{"version":"0x00409932","timestamp":"0xd96eb166","nBits":"0x07936019","nonce":"0x2b09781a","previousBlockHash":"0x4cff19537e40ff6f823d0aece6dcb0968e025fd9d270fbd32a00000000000000","merkleRootHash":"0x2a3747b341b69cca7f1b95bf20670d3f4ab083c62294bf7f4dd2a5d7f7a01ccf"},{"version":"0x0000dd20","timestamp":"0x5e71b166","nBits":"0x07936019","nonce":"0x78c0584e","previousBlockHash":"0x5aeab59077cea211635cac526ae6c440d1bf83487c708cc95f00000000000000","merkleRootHash":"0x4793b58742835efba87e3dd59b22219d6ea487c7c735a3f33e1d8eccb97f11cf"},{"version":"0x00000020","timestamp":"0x0f76b166","nBits":"0xffff001d","nonce":"0xe8a68c00","previousBlockHash":"0x2377c22e2d613493534041e1a37e7c4f5a5bb795518965ff0800000000000000","merkleRootHash":"0x0daacece6164b79600ea575160f44f8c67e6a49e1e4e018ca674267019e452de"},{"version":"0x00c0b426","timestamp":"0xad72b166","nBits":"0x07936019","nonce":"0x4201315d","previousBlockHash":"0xe08789993051d8fb4b0615cb56ad7ea7688aa6a24f51c300248f29f700000000","merkleRootHash":"0x0b79fd97b769d6b8fb42b809d5f73b5d7e30ca9222d01fbb25a770b32d9349b2"},{"version":"0x00000020","timestamp":"0x5b73b166","nBits":"0x07936019","nonce":"0xcaab2618","previousBlockHash":"0x828cf1698111e31afea9517a9d08944ce3656a64c2a11dad5a00000000000000","merkleRootHash":"0xf9da6588592f402752bcad74f4e5506a7d253f3989fdc4c016b9564e13326d13"},{"version":"0x00000020","timestamp":"0x3c74b166","nBits":"0x07936019","nonce":"0xcc1048bf","previousBlockHash":"0xca8be87844e8a141a8c8b9eb852bc59ae724e8fdbe06f7fd2700000000000000","merkleRootHash":"0x41fb05c6917ac54ec09c87a506a390e29e202ab3f12de5313c5be1b369b95dd3"},{"version":"0x00a0ac28","timestamp":"0x6777b166","nBits":"0x07936019","nonce":"0x118e3425","previousBlockHash":"0x1f3950322287760e7821ba45e58b7c164d8b51dcacf00aab1e00000000000000","merkleRootHash":"0x33f25034faca2140221ee4d1aacce4a545b539d1a57ed2a0dd0b30f1dbf5e678"},{"version":"0x0000c020","timestamp":"0xe377b166","nBits":"0x07936019","nonce":"0x025985fd","previousBlockHash":"0xdb149e6e82d121a754ceb3ae234151f8f6334686002dbb875f00000000000000","merkleRootHash":"0xdb2726c354a277e359c607ec6dc5e76b584401a01793f1e1642d58c029bc4978"},{"version":"0x00000020","timestamp":"0xe878b166","nBits":"0x07936019","nonce":"0x53878d22","previousBlockHash":"0x0510e8a8ad71cb7291f56e4a68d1ea294654fb17359bf44c1b00000000000000","merkleRootHash":"0x92f44d7dea0d4012d7197d510965680ba60cdbae6ac407931328c40164aae7d1"},{"version":"0x0080f224","timestamp":"0x827ab166","nBits":"0x07936019","nonce":"0x0b614b0e","previousBlockHash":"0xfdd95443a94d933d3ad68fcde4ec351b760d2eebbb307f6f5600000000000000","merkleRootHash":"0x30a60bfaa3aabc8a5213548c1e69d21ec59b120a40d6de0ca2b148c721bb2e66"},{"version":"0x0080c929","timestamp":"0xa07ab166","nBits":"0x07936019","nonce":"0x035d8256","previousBlockHash":"0xf4a8e2c6297bfdf90fa23e293d8c03e4a1609fac6a193f770c00000000000000","merkleRootHash":"0x8bd4a346995bec159a82041728ddfe89cb1e2766684e3b4df20e3790ee7def83"},{"version":"0x0080fc23","timestamp":"0x447cb166","nBits":"0x07936019","nonce":"0x19818f68","previousBlockHash":"0x77d2d6d1c2a8fc9e21609050d98ba306b6794cbefc8db5c85400000000000000","merkleRootHash":"0xceff670e9e7eea51fa1c2158b2982efb01c2c925ecff9a662cc85c64c004790a"},{"version":"0x00000020","timestamp":"0xf880b166","nBits":"0xffff001d","nonce":"0x001dd214","previousBlockHash":"0x2100797dd804c50ff4173e3a9bf2e314616dc217a308e4381200000000000000","merkleRootHash":"0xe300fe47e475cd73b572189120b1531d7c5b6226fc71b3572bb333ba9c37daad"},{"version":"0x00600020","timestamp":"0xaa85b166","nBits":"0xffff001d","nonce":"0x91048d34","previousBlockHash":"0x3d6f05c245b7d2d55fef179bde09eedc58bee0b1475ee9ba0648b9ad00000000","merkleRootHash":"0x82896b3782a8d303befc0cde68e809a914997b1b5cc53a942ba0d437d5ca38ac"},{"version":"0x0020512b","timestamp":"0x9189b166","nBits":"0x07936019","nonce":"0x471c22ad","previousBlockHash":"0xb332b9c7d8d75cfa836c130851275402105dbfcf0529fe82f431480000000000","merkleRootHash":"0x0e192f3031ff4711be2acb1005453120b365f82c37c9585f9df7bbb9c2c8ff4e"},{"version":"0x00008020","timestamp":"0x278bb166","nBits":"0x07936019","nonce":"0x955713ff","previousBlockHash":"0x2a80da92ddfdbffd76d7fd8ac0707cca19889752a59b4cc40200000000000000","merkleRootHash":"0x2234100dbe7e49dfc4f48d516c8d4e7e5b177a7a8f52b5fade1fdd11bebbf704"},{"version":"0x0080422d","timestamp":"0x078cb166","nBits":"0x07936019","nonce":"0x7072abd1","previousBlockHash":"0xe12bc8a94d18d7dca647ee271db7266c2224c75b16557e9e2900000000000000","merkleRootHash":"0x8a1f5da063c295666379713c7cd84a7ed309f5b7488981c0a2f3e46b8489d72a"},{"version":"0x00c0eb22","timestamp":"0xaa8eb166","nBits":"0x07936019","nonce":"0x4e95a6a7","previousBlockHash":"0xfa7b9f5bf7a2eef4fe18c13f96a30a7983f9b78d34990de31d00000000000000","merkleRootHash":"0xfe8ae4779005da4af324fe8c21ad349804947de015c21636147081c3ab68b1ab"},{"version":"0x00403022","timestamp":"0xf58eb166","nBits":"0x07936019","nonce":"0x6180dac9","previousBlockHash":"0xf712d1f1893cc6931fe91d723aa1bd795a796b12ce42041d0400000000000000","merkleRootHash":"0x968c24f3f5510799d9e84c3faaa202c396134157b386b4ac25db290f3a3f9926"},{"version":"0x0040df33","timestamp":"0x5e8fb166","nBits":"0x07936019","nonce":"0x6294c2ad","previousBlockHash":"0x37b510ec102bdba4e9d5cb1a08a6c84e1fb4369bf45ef2c74700000000000000","merkleRootHash":"0x238f3b4c0616c76198b4611a6ef234fd8d8f33ee3ea049207300d8cd4ec566c3"},{"version":"0x00600020","timestamp":"0x7e8fb166","nBits":"0x07936019","nonce":"0x9bf1724e","previousBlockHash":"0x9bdd476ebfb55353dd8c4e7771faf857bd6f19a591f19afc2400000000000000","merkleRootHash":"0xe336622d8f3c1b28e7c12a8808312e201650242869895b9bc0ad8d01a8d4b48b"},{"version":"0x00008020","timestamp":"0x6293b166","nBits":"0x07936019","nonce":"0x049a7c89","previousBlockHash":"0x4500414b94f31c77c8d70147db8c11de5b5c786158879d6b4500000000000000","merkleRootHash":"0x1dcfec115f3b106b185ab5b3ae956aa16fa33800e7aea7b24fad0c83eb4c5a90"},{"version":"0x00000020","timestamp":"0xdc93b166","nBits":"0x07936019","nonce":"0xda687874","previousBlockHash":"0x4335859d400a855b58ae05530b95cc5f4ed7e2df37fa938e2800000000000000","merkleRootHash":"0x7ce3daf03f178db4175b6a3f51e1a0d31f90be80fe92fa899f0291b2292db692"},{"version":"0x00000020","timestamp":"0x1894b166","nBits":"0x07936019","nonce":"0x40200f62","previousBlockHash":"0xf7c87975de93aa73ee0d92718469d5c46bc09159cb78907f0c00000000000000","merkleRootHash":"0xeeda1dc045db1b2b3875a8a113bc7c84797bd22292224ac5e2548806bf18a689"},{"version":"0x00000020","timestamp":"0xbc95b166","nBits":"0x07936019","nonce":"0x2479dfd6","previousBlockHash":"0x84adc414fe39c0da90cb830dded47c8600c6bd1c44e646e73300000000000000","merkleRootHash":"0x214c04a81fca72180fbb51e8a05e0a66a752deb3d1185403ff7123727c6ca77c"},{"version":"0x00203c34","timestamp":"0x5796b166","nBits":"0x07936019","nonce":"0x5891a7e7","previousBlockHash":"0x426762f46b0bb2ac44c2aebfed873bcde81fa217ca75aabc3100000000000000","merkleRootHash":"0xa2c1e92f80751a9aaf3f08a49c25f3f7f0e3f345386416d4291993bce17c4571"},{"version":"0x0000ff3f","timestamp":"0x4e97b166","nBits":"0x07936019","nonce":"0x0484e936","previousBlockHash":"0x842a193ea1162e819c02b657da9787cc8cf45e5922066f420b00000000000000","merkleRootHash":"0x86afbc1c59fd7c0241f271cb1e6a7ec7533550ff4858a2cbd326fa096c0af046"},{"version":"0x00a0cb2c","timestamp":"0x259bb166","nBits":"0x07936019","nonce":"0x4f0de3b5","previousBlockHash":"0x69a6d29c83f465f722c2df1969199a5625bd73fc0fa162b80700000000000000","merkleRootHash":"0x23c381d344d063162a00a93152dd08503ee66ed6929d4b5850ec231cc437c623"},{"version":"0x00e0ff27","timestamp":"0x149db166","nBits":"0x07936019","nonce":"0x2099c30c","previousBlockHash":"0xd298d485c73ffebb2127d3f40fdc3ed42b93fd48c994a5524200000000000000","merkleRootHash":"0xd781cda584528750434d022f833b1ddf13ca2b2b37e7a6a153a5055206fd1c10"},{"version":"0x00600020","timestamp":"0x689eb166","nBits":"0x07936019","nonce":"0xd79617ea","previousBlockHash":"0x53099c32c22115ecb942cf6bf7b966422fc2d981f69d62a75e00000000000000","merkleRootHash":"0x219cece7fe5bb0654bc85be10315f0dde1f405d208b3b4290a8ab37f3c5f066c"},{"version":"0x00c0fa2a","timestamp":"0x20a0b166","nBits":"0x07936019","nonce":"0x2e01f976","previousBlockHash":"0x9a18dd9d3ff9d10e6c63289470d444ff344bba377b78510d4700000000000000","merkleRootHash":"0x6be615007786a0922b1b1810fce1a2df4ddd06a43fa74f6ba22a3562fc52707e"},{"version":"0x00200020","timestamp":"0x84a0b166","nBits":"0x07936019","nonce":"0x436c9108","previousBlockHash":"0x1a4d2cab754bd7574a78ffb802186e472d82583db43685853a00000000000000","merkleRootHash":"0xd2e517c70ecbc8108f4cc4dd2759eb3aa9103ad9f7c5e4fe2b64b89633f31c9a"},{"version":"0x00801634","timestamp":"0x98a2b166","nBits":"0x07936019","nonce":"0x25a0760d","previousBlockHash":"0xd498feb53a57baaf237b7f9ca0c47ee66002235e1e69dd685200000000000000","merkleRootHash":"0x0420690bea880258a0540cf61d02a1784f40f16f13734aab34ddfc61bd0dfa71"},{"version":"0x00402c2d","timestamp":"0x57a7b166","nBits":"0xffff001d","nonce":"0x01713e84","previousBlockHash":"0x7c8df83b55f2c8c2d6cb22bceb532b9822a65e9f80f5ffe43900000000000000","merkleRootHash":"0x4f7715dfd24ddb8b3506142af5eec21d33643f9b172f6a072af386f2d49bf961"},{"version":"0x0080732c","timestamp":"0x84a7b166","nBits":"0x07936019","nonce":"0x6b26efd9","previousBlockHash":"0xce9883e58160499e64dbb42a853095596705bb4d6571c181348a000000000000","merkleRootHash":"0xf6bf25ede3063af309c6707cdc089e9aedf99b3d44be46c623e66f8d20e48dcf"},{"version":"0x00e0ff2f","timestamp":"0x44a9b166","nBits":"0x07936019","nonce":"0x61399e02","previousBlockHash":"0x351ce873671594c2f58ef0abf15325f3fe927676cdc8d6686000000000000000","merkleRootHash":"0x3122ec7c7c3ff362c4616cae5ebb939ff9756c4bef75e73a571ff1d7915e504a"},{"version":"0x00a09e2a","timestamp":"0xf6adb166","nBits":"0xffff001d","nonce":"0x4e4d79c6","previousBlockHash":"0xefb132c91644d64035f5094466a45e7d95f6c315a0a5195b1f00000000000000","merkleRootHash":"0x0dd34ddabf2a9ae46671cf25d11acc7f937117fa7cccaf57fbc7ffe1d7905b50"},{"version":"0x0040772f","timestamp":"0xc7afb166","nBits":"0x07936019","nonce":"0x311dafb8","previousBlockHash":"0xe93a4f3a4b1600b01475be85d7f0caba8a6330d6f2662bfd6c80000000000000","merkleRootHash":"0x8b37948cc3524c790279e4de47b0fba85394ffeee6073317b5ab2e913b048b11"},{"version":"0x00000020","timestamp":"0x78b4b166","nBits":"0xffff001d","nonce":"0xeac522d4","previousBlockHash":"0x894a491ba9c948e33fbbfa14e17afc12141bbe06e957c6aa0f00000000000000","merkleRootHash":"0x6bee62bd4a40c58784d0bb97390f243732dd37b9d2ebdb0edf4824b5158131ba"},{"version":"0x00e0ff37","timestamp":"0x08b8b166","nBits":"0x07936019","nonce":"0x624c5ec9","previousBlockHash":"0xc2476d2d407ef2df85795241db7bb29ae8793659091253366b6f355e00000000","merkleRootHash":"0x757e21ba07561209db1c6759f0b5b76ab264db7291aa4b039a447b34c60fcde8"},{"version":"0x00a0382b","timestamp":"0xbabcb166","nBits":"0xffff001d","nonce":"0x02cd38f1","previousBlockHash":"0xcb0559af9bd469304a1cfce0682b8aefe4de3f0616775d740500000000000000","merkleRootHash":"0x81eb2d6fd99f8b4a54136896916e7d38e92f5267b8debfd769546b06ad779b5d"},{"version":"0x00e0f427","timestamp":"0x23bdb166","nBits":"0x07936019","nonce":"0x00faa3bb","previousBlockHash":"0x7a927f2837629b4527dc251adb98a7cadc110f38cd7eeb7e4ba3000000000000","merkleRootHash":"0xc7b0cd15c5d5c7d05d7fbbb579ae6963ee73bcc98ee2e884f6f3a1893c78cbdd"},{"version":"0x00000020","timestamp":"0xd4c1b166","nBits":"0xffff001d","nonce":"0x0a12127b","previousBlockHash":"0xe93c999b1eaeafd37d0982844dea32ae32c502a2b9a077673a00000000000000","merkleRootHash":"0x9552f04b5259d1d15d10504d6f6ae71f67312cabb71834798a6e97b578cd1f78"},{"version":"0x00e0ff27","timestamp":"0xb4c0b166","nBits":"0x07936019","nonce":"0x0882832d","previousBlockHash":"0x876c8c357639170455468c81de0691ef777bd44d2249b59af626b20900000000","merkleRootHash":"0x53fb4798b9a9c8ba0a4c407367f0c59012aa4864f30a9ce7c0debfe49c79d644"},{"version":"0x00000020","timestamp":"0x65c5b166","nBits":"0xffff001d","nonce":"0x07a77109","previousBlockHash":"0xbce858f8dd0b1a6c922aa9e34d332ba47771ea50fa1873324900000000000000","merkleRootHash":"0xb013db4b1caa0a8269836c73fc7203e08d4c9eb4465612b7f10a1d94382c44fb"},{"version":"0x00c0ac31","timestamp":"0x04c1b166","nBits":"0x07936019","nonce":"0x44b0ef02","previousBlockHash":"0x5e065e0d6def197482fe3c656454a9b12acf81d273edb56364c3d5b600000000","merkleRootHash":"0x9d53d5e977a8ce9cbab5f706ae929ba8e6fe9d37949044f813174add24adf115"},{"version":"0x00000020","timestamp":"0xb5c5b166","nBits":"0xffff001d","nonce":"0xcbd96821","previousBlockHash":"0x114ce3227561d4431f01e6ba3c1d3c97d811de590d508c023700000000000000","merkleRootHash":"0xbcffa598daed68dd64ea51df7ade06266743a555c7873209cfafca72d24106be"},{"version":"0x00c0fe30","timestamp":"0x30c2b166","nBits":"0x07936019","nonce":"0x50c2694c","previousBlockHash":"0x827b44a5d0e0c51e72015a65d4cac00169cf9bf16643827f2308fba000000000","merkleRootHash":"0x9b367ab6bd7d392a71daecbfdf19ce9feec681708588c85e1dce9b324e98284f"},{"version":"0x00000020","timestamp":"0xe1c6b166","nBits":"0xffff001d","nonce":"0xa5661d1b","previousBlockHash":"0x25edcd0d099dd6fb9a8fe18081f0a37e6ad2e00e9edfeddb3b00000000000000","merkleRootHash":"0x772055daaee6c3f21e52176e6c706ffe32babcc85f548deb30b8892cd1beb2b8"},{"version":"0x00000020","timestamp":"0x92cbb166","nBits":"0xffff001d","nonce":"0x05faba32","previousBlockHash":"0x972ea554ab716861b18b7653d58ae3da9980cc970f15cba60fa1551100000000","merkleRootHash":"0xaf5daf58f473a55fc185c3c6850286ad9dc9ac9a92c1aa2e6cc6bae77eab6e06"},{"version":"0x00008020","timestamp":"0x4dc5b166","nBits":"0x07936019","nonce":"0x3f54079c","previousBlockHash":"0xa9dcd885ca8134759be03f9a421908c218c00f870007c3363fd3788b00000000","merkleRootHash":"0x07c5e6effb7504c1f8d910d4d8565008fe2be528819259e4975dc13992822a86"},{"version":"0x00400020","timestamp":"0xa8c7b166","nBits":"0x07936019","nonce":"0x38cf2b8e","previousBlockHash":"0xea408162ac1c74f3f5b9f0aaa9305a98e610c771fb1bf33d1800000000000000","merkleRootHash":"0x4473b30e682223c3db44bee32f4b34108235919ea46e6e5610908d703a6309fc"},{"version":"0x00000020","timestamp":"0x59ccb166","nBits":"0xffff001d","nonce":"0x49559908","previousBlockHash":"0xa78ee9642168b523659e88473d6eb55ee1f19b61f3f703531400000000000000","merkleRootHash":"0x6a3d05a353a4402924caae0bd4d74b5279ce3e19ea9fccff2d9d5a9d1034dba6"},{"version":"0x00000020","timestamp":"0x0ad1b166","nBits":"0xffff001d","nonce":"0x64972020","previousBlockHash":"0x36d3c162c63e12764d9019c2f4b40e929ccc27f794eb78686809e58400000000","merkleRootHash":"0x979d4d115d012e355c912639f255a9668db1e5cd10061a4601d4bfac503b3435"},{"version":"0x00000020","timestamp":"0xbbd5b166","nBits":"0xffff001d","nonce":"0xaec4da1a","previousBlockHash":"0x9810ff45551566dcce7926d062c1cb8ff7ec65350cc2f2a1fef2200800000000","merkleRootHash":"0x4a00537ab21c3eadb77ce7e3fbf7689aaed8731acb1f2a6427b598f5b0aaae17"},{"version":"0x00000020","timestamp":"0x6cdab166","nBits":"0xffff001d","nonce":"0x9a00e01c","previousBlockHash":"0xf1db79ecbe59d03776f7e938dd8b6edee104d43b90dded44edc0196c00000000","merkleRootHash":"0xe84032937b589b6bcf339d3285f6422009480b68f77d5d2ad5606b99206bdd8d"},{"version":"0x00000020","timestamp":"0x78cab166","nBits":"0x07936019","nonce":"0x72e83c75","previousBlockHash":"0x67a616013f773cf26f3a9b23a0d12d86b6e4b24bda1d6c8e969198e700000000","merkleRootHash":"0x50b58be7a4aea5aaafa27e3fcaa621f7ac547eba50e08b98b136a502fa184d67"},{"version":"0x00200020","timestamp":"0xd0ccb166","nBits":"0x07936019","nonce":"0x3b833c14","previousBlockHash":"0x3b285b7d8116b5a4cfc718cf42887f5960c884bc48d856714300000000000000","merkleRootHash":"0x6fabe85ff58d4446ceb76b6bcb2e2e0d05bf15fbf9205cf46e7299fad521edc2"},{"version":"0x00e0ff2f","timestamp":"0x3ccfb166","nBits":"0x07936019","nonce":"0x74b8ae7f","previousBlockHash":"0x5802e5dae5e38cb7c0a2bfec92ee22a8cc8d433c054193233500000000000000","merkleRootHash":"0x30b8d9e1a9cf635dca3ae04d6cd94be2a567d34125b537a1e97f5cba09f92235"},{"version":"0x00000020","timestamp":"0xedd3b166","nBits":"0xffff001d","nonce":"0xa3f15e40","previousBlockHash":"0x2b73ed074d65f204dd7a148cd3c0c8b7272c5181ae367d084e00000000000000","merkleRootHash":"0xf11572a11c99a33baea923665443c14dc40ee4c3eb7f72b37b5e5b5e32311636"},{"version":"0x00200020","timestamp":"0x25d0b166","nBits":"0x07936019","nonce":"0x156dc2cb","previousBlockHash":"0x6ad763659b765ef4ed6746d09da4faf764c460ff187e58bc4c45a0ba00000000","merkleRootHash":"0x58e932eaaae5650a741c05a9f0a5777ffdc1f597bbd703b12f0105e603caf2ce"},{"version":"0x00200020","timestamp":"0x80d1b166","nBits":"0x07936019","nonce":"0x3f77b263","previousBlockHash":"0x085123cedd2e8ecead76bd0a5628c4f8e14a55a394f5e28f4600000000000000","merkleRootHash":"0xdd0804420fa4b57d440ce93023ebad0d527725e370129cdad7d34ffaaf8975f3"},{"version":"0x00000020","timestamp":"0x17d2b166","nBits":"0x07936019","nonce":"0xb447dd0c","previousBlockHash":"0x365bfbe42f6efd17fff833c16200df98931c4aa7c720a2550500000000000000","merkleRootHash":"0x1a687010c876a92a1a0d6af1db6277411bca0c96f46f4c637d64e0d8c80b1ab3"},{"version":"0x0000c020","timestamp":"0x53d2b166","nBits":"0x07936019","nonce":"0xa8a4fb68","previousBlockHash":"0x82df482b55c7711b58b98551f1b551e72f61b9eca028faaf4800000000000000","merkleRootHash":"0x01170f723e6268674b449ced88304ad7e9cdd98c1205a134f966ff7877015dd6"},{"version":"0x00004020","timestamp":"0x66d3b166","nBits":"0x07936019","nonce":"0x05d7e4c9","previousBlockHash":"0xdb785aea1786c132f66f5f4f615bb215d22b8a9944c587ae5100000000000000","merkleRootHash":"0xe1a9f1f6a48122ec0bb25e2bebd021c71ee9e393157d5f37166aebbaf9e61e4d"},{"version":"0x00000020","timestamp":"0x77d3b166","nBits":"0x07936019","nonce":"0x37d71bdb","previousBlockHash":"0x9dd4e94dc8d30a6f1dfe03362d92b6210e3beec940ae941d3700000000000000","merkleRootHash":"0x1d4d310664e38839c6409fdfe7c8f5245394ea5194c8944f8aa60f10682d8350"},{"version":"0x0000c020","timestamp":"0x13d6b166","nBits":"0x07936019","nonce":"0x5390ec23","previousBlockHash":"0xe57f509b2fd797e38d5b830e7b219a565ebfdeb22c326dca1500000000000000","merkleRootHash":"0x6490a33d137f7b090f8acd17888700fdc6f7d0250f9d30938319a9289ca96df1"},{"version":"0x00004020","timestamp":"0x3fd7b166","nBits":"0x07936019","nonce":"0x89e20d0f","previousBlockHash":"0xba68f80f8bb6f4a69852a1741526014321718176bb0b78a95e00000000000000","merkleRootHash":"0xbea2d88e234edd5a24156dc16ff48ae5a59f3f9c2c0e41148de251ec7b01ede4"},{"version":"0x00000020","timestamp":"0x61d8b166","nBits":"0x07936019","nonce":"0xa0d93316","previousBlockHash":"0xb4629fc3fe4bc0fd3ea639a36c68dbb0009d8934666cc2444600000000000000","merkleRootHash":"0x5252ebec76a016be0e60f16a1408aa9b3400d7fe9d1adf447731c0148cb58077"},{"version":"0x00000020","timestamp":"0x12ddb166","nBits":"0xffff001d","nonce":"0x64281a16","previousBlockHash":"0x036bce9dd96571f0b24f2d77928a1c61722c3f5ae18db56a0600000000000000","merkleRootHash":"0x47e9b61cfa7a22a11834f23b3d2d4a0b81f21a33108eeb518448bce67f4a447e"},{"version":"0x00000020","timestamp":"0xc3e1b166","nBits":"0xffff001d","nonce":"0x154ed90c","previousBlockHash":"0x5e1ee9a567628ffd2f0ed728fdac2ddf1cae32f1e8e18dc18e59a47200000000","merkleRootHash":"0xea6edcd40413a7df5a28f7675895bb532347aba5410c523865473c69fd4cbf50"},{"version":"0x00e0ff2f","timestamp":"0x28e3b166","nBits":"0x07936019","nonce":"0x7c95bc66","previousBlockHash":"0x8ab5d140536563c5d2f8023fa8bbce188c54be1f87bf04f0875ee48d00000000","merkleRootHash":"0x3bd0454a4c714753e646931c25f59134737fe61660babcd6916caaf530a0b1c3"},{"version":"0x00000020","timestamp":"0xd9e7b166","nBits":"0xffff001d","nonce":"0x6e833a27","previousBlockHash":"0x707bc35083077c7a3cf027d2c0fd6d1496592a9cb3a889182300000000000000","merkleRootHash":"0xb79cd23c8ec3f932c25474ee86583f7f58c3f87e4713bb26a88c3bf43620b086"},{"version":"0x00000020","timestamp":"0x8aecb166","nBits":"0xffff001d","nonce":"0xe8556202","previousBlockHash":"0x2252940e180aeedbcbaf9212cc094733aac873dbc5c7011189a6204a00000000","merkleRootHash":"0xea966480c416bbea6b9e5b6c0d36fee21249960e260636226730dc18a716a1cf"},{"version":"0x00000020","timestamp":"0x3bf1b166","nBits":"0xffff001d","nonce":"0x4d444e36","previousBlockHash":"0x5810deca7d130952701e2290665feeac4b4340c84f6382b6f224000600000000","merkleRootHash":"0x92b1128dd10cc579ff018acf326bf19aa50098000a19cf407e5ff5bbbeac74a3"},{"version":"0x00000020","timestamp":"0xecf5b166","nBits":"0xffff001d","nonce":"0xf9f34c00","previousBlockHash":"0x33143ecf13d137a93217cda741d354068659e9237c6fb1f8e1c5d82300000000","merkleRootHash":"0xac7f8350947bb722bac9aacf2c5df2448cf9507b7dde824359a4c3183441ac18"},{"version":"0x00000020","timestamp":"0x9dfab166","nBits":"0xffff001d","nonce":"0x7b3efb4c","previousBlockHash":"0x9cc305692d8a73f5a65a4087b98267c6369bd6efa54f7624866bd6d200000000","merkleRootHash":"0x7a86aad639a6e7fdd1c1b0dc0a19f1d5600ea934f5ad87a529235291232db294"},{"version":"0x00e0ff27","timestamp":"0xc8e8b166","nBits":"0x07936019","nonce":"0x9f65ec8b","previousBlockHash":"0x0b710706d8578a782136db763f27fc6944a5b43b7d59ad2ae68b5a1000000000","merkleRootHash":"0xabd15427cea5deeb0867b049329151494ab227c56c5fc12c2074da649a4ab31a"},{"version":"0x00000020","timestamp":"0x79edb166","nBits":"0xffff001d","nonce":"0x2a6d4a14","previousBlockHash":"0xac00fb643ab2dc9110f5ab4a77fd29c5bf667fcc5866f8942600000000000000","merkleRootHash":"0x3fbc14af5cd262bb6c17aee33de02b739642f20894bb1ca16a3ac4816931d602"},{"version":"0x00200020","timestamp":"0x0cebb166","nBits":"0x07936019","nonce":"0x89288f86","previousBlockHash":"0x2615857d18d9c19a3189247bc106e7887947cf55fee05bc64493a6d300000000","merkleRootHash":"0x6cac938d069708966569496f8a7a4685e16a1d1faa3f7d8fd3eeb0a92d6d07ed"},{"version":"0x00000020","timestamp":"0xbdefb166","nBits":"0xffff001d","nonce":"0xdd0c1325","previousBlockHash":"0x078525dac9f68c56007e6ff405c0e5e903b852473a1decd05500000000000000","merkleRootHash":"0x89fe7035b194832dec5e3a74724c178178fce242428d4fb93cc4b14aaa31dd95"},{"version":"0x00000020","timestamp":"0x6ef4b166","nBits":"0xffff001d","nonce":"0x1f00404f","previousBlockHash":"0xbf3c6c9810a064fd0e37b39d410a3adc945c8287cd06637bcb90248c00000000","merkleRootHash":"0xc025bf8dc5a46bc90f4251443d6f7884013cb3d056e7bb1b04037a82364faf05"},{"version":"0x00000020","timestamp":"0x1ff9b166","nBits":"0xffff001d","nonce":"0xb527e002","previousBlockHash":"0xd88045c7fb9595bc8479b7443197813d3ccf55a108d51f5a34282fa000000000","merkleRootHash":"0xe79a284511d0fe8741d23ef5d75f639d4140a4e832baffece5df891721e16c3e"},{"version":"0x00000020","timestamp":"0xd0fdb166","nBits":"0xffff001d","nonce":"0x7050571e","previousBlockHash":"0xc9fa92d421b5e908fab174e7ecc53ee98b6f8bb49dd1362b0017632900000000","merkleRootHash":"0xf870f119ff58023d9016000ba8c4f21a6088dc7f3256337484b2a047ed274083"},{"version":"0x00000020","timestamp":"0x8102b266","nBits":"0xffff001d","nonce":"0xb7695048","previousBlockHash":"0xe76b9190250c52fb9bb71d553d29121d52030eaf49027bda64e2a74000000000","merkleRootHash":"0xfb7bfd7b7268a05208b9ee26a0cc6ffd20b578b072a5d88645332d82143b21a1"},{"version":"0x00600020","timestamp":"0x98f5b166","nBits":"0x07936019","nonce":"0x9925ae6f","previousBlockHash":"0xda28839e83025be204ac36069166f7f6c92c6806888d33ee4bd7f4b100000000","merkleRootHash":"0x044468a2ebac1590c0b574a7dbb9b4dcc52b215cb04bee66d4186c20845add81"},{"version":"0x00e0ff2f","timestamp":"0xcef5b166","nBits":"0x07936019","nonce":"0x6747c766","previousBlockHash":"0xf56dd97b9fd068dfef33053471682187e124bec8798dbe511600000000000000","merkleRootHash":"0x4b6052f63a846286d0f74c6b3f32110fecea719da2edc332cd6d34a9b0399b19"},{"version":"0x00000020","timestamp":"0x7ffab166","nBits":"0xffff001d","nonce":"0xe1974d0f","previousBlockHash":"0x90fb8e660f9ff94732016f25515c02384fa4a7b80f20a20d0200000000000000","merkleRootHash":"0xd07fb3dac81e271b2024914ea25e058c11cd386d57d8315a55a2e43ee0b91fcc"},{"version":"0x00e0ff37","timestamp":"0xc4fbb166","nBits":"0x07936019","nonce":"0x593f6b55","previousBlockHash":"0x7cacf1b71bc25b9c5820c79fc5999cb17dd9c8550e5393889bdda76d00000000","merkleRootHash":"0xad46248a1d1a3f27fbd96b2d57e9024eef701648f4568dcad368d55cd4306152"},{"version":"0x00600020","timestamp":"0xecfbb166","nBits":"0x07936019","nonce":"0x579d2bf4","previousBlockHash":"0x6d8e70458aa6c7c870d0633f01977d5c48bd1722031dcc554e00000000000000","merkleRootHash":"0x2512933fe16179da9c653178ea14786dbfac88115433d567321556419f7d686f"},{"version":"0x00000020","timestamp":"0x1dfcb166","nBits":"0x07936019","nonce":"0x45daa4e0","previousBlockHash":"0x78ab3676bd6db62401f6c38950c5a7ee9294fadc89414f634100000000000000","merkleRootHash":"0x5677553b6c7d134baca46fdd0ba043aeb524a77f860a21f29796819af8896669"},{"version":"0x00000020","timestamp":"0xce00b266","nBits":"0xffff001d","nonce":"0x05022f4a","previousBlockHash":"0xf8a73f29ccdfa0ebdf14280b13cab98c8395a73ce1d3bf012500000000000000","merkleRootHash":"0x0995b282173a39cfb9c3152f6c721d26d9d93eb15426f28cbf568b0b305edf8f"},{"version":"0x00000020","timestamp":"0xe8ffb166","nBits":"0x07936019","nonce":"0xdc184833","previousBlockHash":"0xbd515d35eb0d89bf04a1236746f9a71fd461efdd53cfebe18283a87000000000","merkleRootHash":"0xe001f48028e2ffe54ede28a838d007e49acde23702ba9193255dfc3c72ab05c4"},{"version":"0x00000020","timestamp":"0x9a04b266","nBits":"0xffff001d","nonce":"0x20382add","previousBlockHash":"0xff492f334857dc3fe33f9a52e2a24993b819f6c18ab36d1b3200000000000000","merkleRootHash":"0x2c1460422c7712563a27fb024a0d10e70ce854fe345480cb72bcf72a569cf710"},{"version":"0x00200020","timestamp":"0x5808b266","nBits":"0x07936019","nonce":"0xfcebf632","previousBlockHash":"0x5310a3a1fb349882c0553b335682b70d3141d25941fdd60a18a5663500000000","merkleRootHash":"0x1399c80e9082864d427801bf06db24bea9ceb7d270e7cf07f61edf76ac765d6e"},{"version":"0x00000020","timestamp":"0x0f0db266","nBits":"0xffff001d","nonce":"0xdbc080c5","previousBlockHash":"0x26029c35cfb6bad6d129c6cea447b62efc8ed6925d1152161300000000000000","merkleRootHash":"0xb2fafe16ce5417bf4b855515bf6af22a281d66d18ba71987523cd7198d0e447c"},{"version":"0x00600020","timestamp":"0xc711b266","nBits":"0xffff001d","nonce":"0x038bfe87","previousBlockHash":"0x60d373a8db38cb6c4e704fbb36d746f5a497d0d5fb29598ca8fe973000000000","merkleRootHash":"0x22a11cebd97ead76435402ac8e2e6fca391780452e54447b1144e82e9acddb0e"},{"version":"0x00000020","timestamp":"0x7816b266","nBits":"0xffff001d","nonce":"0x1ffca400","previousBlockHash":"0x6c771e0f569b909b57236e55443899224dd9740512e0072306713f0100000000","merkleRootHash":"0x5b1063baa979355d850f27c7f925ba9a2b78b0ce228f82d86b64289b814f424a"},{"version":"0x00600020","timestamp":"0x5c13b266","nBits":"0x07936019","nonce":"0x80283251","previousBlockHash":"0x4eeeaa1ab94a97876c56165952103cc04ba6cf0b35a5aee290d3982e00000000","merkleRootHash":"0x0b7083c85b8e3fbb8cf7d58869627fdbb085249b121b855364bc40c4bed9020a"},{"version":"0x00000020","timestamp":"0x0d18b266","nBits":"0xffff001d","nonce":"0x269e8a55","previousBlockHash":"0x28938b69d6cbc5e6198ce10bb3c913b7ee005aadedba24de4800000000000000","merkleRootHash":"0xb391df7d46152ea96f4282f4e140007561e82ac55dd4d7e499f626df16394be0"},{"version":"0x00000020","timestamp":"0xbf1cb266","nBits":"0xffff001d","nonce":"0x80ad3734","previousBlockHash":"0x7e2458b7e4204853e943a26abfeaa8c98784c913c278fdcd91f63a6000000000","merkleRootHash":"0x50920b1d110917df2c3a28e95801142be8c6bbea980f77abeb9bdd75697482b7"},{"version":"0x00200020","timestamp":"0xc31cb266","nBits":"0x07936019","nonce":"0xd363d349","previousBlockHash":"0x8d9aab214cdef3b068135e9d366244f6c70dcadb8c2f6fea3978319600000000","merkleRootHash":"0x141b8d95e219ab9e09c368738577ddbc3d3641452aad1b53ee080cc8dddfc8ee"},{"version":"0x00004020","timestamp":"0xcc1cb266","nBits":"0x07936019","nonce":"0x14ebd8de","previousBlockHash":"0x7ba2af95b20feeb540810398ae0eb719992cfa87b37781101e00000000000000","merkleRootHash":"0x13bc496ccc2e0f1ffa8ec9090f51209881cf3939bc58632d0ad1b34f2c38c192"},{"version":"0x00004020","timestamp":"0x101fb266","nBits":"0x07936019","nonce":"0x2ec1386f","previousBlockHash":"0x32e968b0527bc92423c4d1aa4ba059b6d407056d81df8d402a00000000000000","merkleRootHash":"0xcb4e3638fdab29aea3ef0876c97be485dbbc89d27d2b60ee1e49e71b13bbdc43"},{"version":"0x00000020","timestamp":"0xc123b266","nBits":"0xffff001d","nonce":"0x5debfd66","previousBlockHash":"0xa7e3417444bccd197e0dd7542d1450688fe9fdb8e5d149f85500000000000000","merkleRootHash":"0x4a740e753975b9ec26ca8e4ec9fc6721f8d5e7794c3d1b2893594b56d48a5cd2"},{"version":"0x0000c020","timestamp":"0x6222b266","nBits":"0x07936019","nonce":"0x426e59ce","previousBlockHash":"0x99957c5004626228a0119e4b4ed3b36ba35e3c7477676b7f95d9236f00000000","merkleRootHash":"0x7115f70bbb6e7434f69a34cc28b52165eea93129519836eba799a098054460c2"},{"version":"0x00008020","timestamp":"0xf322b266","nBits":"0x07936019","nonce":"0x97e79186","previousBlockHash":"0x8efa1e33f6ab4cb703c7cbd6f30be57bbbbc32cd30881c043000000000000000","merkleRootHash":"0x660d77f4b31bc84844b643a177d97c918a84f1faae6bf93655d33648e19cdc3b"},{"version":"0x00008020","timestamp":"0x8624b266","nBits":"0x07936019","nonce":"0x839dbd8f","previousBlockHash":"0xf208a7dad5d12e82ab77f9f8afc5924ea8268b4f81aeecc55800000000000000","merkleRootHash":"0xf1631d0da3ee2d762c40a8581d3843b4282a9f3ef83afc6a7ab1dcefb0b6d502"},{"version":"0x00e0ff27","timestamp":"0xe426b266","nBits":"0x07936019","nonce":"0x74cfc264","previousBlockHash":"0xbd88f9fa08225cc6f01d6393463c341ef071becbda853c141600000000000000","merkleRootHash":"0x027b8c3c7a9c047ba622486e028c15010e7346a76fa84534be5c4624ec7111ff"},{"version":"0x00000020","timestamp":"0x962bb266","nBits":"0xffff001d","nonce":"0x1583d159","previousBlockHash":"0x666c28d32f2a636540a67678e5026b7a814c599a437cc1ce3400000000000000","merkleRootHash":"0x058def401c56a4c2cd82419979672affe828e1e210275952b7e1c4557af7d601"},{"version":"0x00000020","timestamp":"0x4930b266","nBits":"0xffff001d","nonce":"0xc04be393","previousBlockHash":"0x253a3dc153237141d030ed6f126de88f79e3102874fc914aee902df700000000","merkleRootHash":"0xce4ebcd55de2d52b740d57eeca34a9c9e20407570d5e2748a42f56845a56da95"},{"version":"0x0080dd2b","timestamp":"0xfa34b266","nBits":"0xffff001d","nonce":"0x10d72e31","previousBlockHash":"0x6428011b0e72033d2739a230362f591928c192fb294562f7cbaad9f300000000","merkleRootHash":"0xaa827faab54f847e6d6fc892df613ad34e4edbd54b54213f0b1e05f7416d921e"},{"version":"0x00a0fc2a","timestamp":"0xfd34b266","nBits":"0x07936019","nonce":"0xbf9c1460","previousBlockHash":"0x8295ce45bacbf9ff195a88800966bf7362a3f85a88de6b14b112000000000000","merkleRootHash":"0xe8d9ec1acbb54bfa5300a503b40ddabd2e20a54f9ba42b843802ddd10af0b931"},{"version":"0x00603226","timestamp":"0x1237b266","nBits":"0x07936019","nonce":"0x83473e50","previousBlockHash":"0x3ac740effe63a7252932d9d279bd44d101e58aa7cb9b303f3600000000000000","merkleRootHash":"0x2167dc0c4eaf3a178aff19bdba49229d6744319c93a1edca39712d02e813d4c3"},{"version":"0x0060182e","timestamp":"0x3537b266","nBits":"0x07936019","nonce":"0xd83a9112","previousBlockHash":"0x95e8af6c11be895810ca7db2efdcaf116c7a15b0715dcf052100000000000000","merkleRootHash":"0x96231d5a7e9db5bd48a91da7e209e603d89b1f20dccde098e84316ede2c4e0c6"},{"version":"0x00000020","timestamp":"0xc437b266","nBits":"0x07936019","nonce":"0xcc242f82","previousBlockHash":"0x37e6ef0c733ed95984b633b6bbf674616e4affa16e0fa5971a00000000000000","merkleRootHash":"0x9979c91be12e744a34ded7b9aa61a4b45664e706e74c9fb6943ae33e990f986c"},{"version":"0x00e0ff27","timestamp":"0xf038b266","nBits":"0x07936019","nonce":"0x28939cd0","previousBlockHash":"0x0eb868c38a08c311806c8c76a7f1d6eb4b5e7133f3f3c1eb1900000000000000","merkleRootHash":"0x9f0c2e3be44fe8138906953216c9a9526ecb2714af080f9fa39adafd16b7e0f2"},{"version":"0x00000020","timestamp":"0xf83ab266","nBits":"0x07936019","nonce":"0xfcdeda82","previousBlockHash":"0x59f4846a91a52ada81e940e26f1d1de8eabfe8a689de7aea2500000000000000","merkleRootHash":"0x91c0f98f4fdf1d650fb90ffc9bfbbef4ce286d2246f173c23685960d63d918fb"},{"version":"0x00000020","timestamp":"0xb13fb266","nBits":"0xffff001d","nonce":"0xcd524cb5","previousBlockHash":"0x9f3979fed0897d9ed31528d74a9272c9b42fbed53517afcc0d00000000000000","merkleRootHash":"0x5ce805db179ee3f0b51ea3c79b7616ad77e39fa5b703dad288de7ad7a8ce6308"},{"version":"0x00000020","timestamp":"0xb23fb266","nBits":"0x07936019","nonce":"0xa4d48c0e","previousBlockHash":"0xa43657a78bfe9f9a0e811d9e1e95218f09770c995427012d7bc16b2200000000","merkleRootHash":"0x91c07130e8c835d5a6eacee935476a8f7f6b260723077d50f8d68a01a296240e"},{"version":"0x00000020","timestamp":"0x6644b266","nBits":"0xffff001d","nonce":"0xd568424a","previousBlockHash":"0x7a2d9a22a297dab057df795a0aa89c136f40dca89d9225592a00000000000000","merkleRootHash":"0x3030da54f54e83c9479479b3616466a361b4ad9923a1b5a3c25d712cb6816081"},{"version":"0x00000020","timestamp":"0x1849b266","nBits":"0xffff001d","nonce":"0x4d47e212","previousBlockHash":"0xb828ca229006db7c6087661f233307ac12e3b7c388f9e91b07ba3e9200000000","merkleRootHash":"0xcac5762310d98bafd417db3c0f1bd8b9682397afc44f1149a425b7d45767fc69"},{"version":"0x00000020","timestamp":"0xcf4db266","nBits":"0xffff001d","nonce":"0x6b49fc2b","previousBlockHash":"0x111cdc53e3a9da0cb7b702c962b609c92b7474c7b9bc433c212e628f00000000","merkleRootHash":"0x3f10b3c2a8e3bfc023fa24cd290eec4c3b945bdf559674209b5a1ff96bac3bac"},{"version":"0x0000ff3f","timestamp":"0x9652b266","nBits":"0xffff001d","nonce":"0x3da4a30a","previousBlockHash":"0x24dbba0d74a9250de576a20986c18fc65484b7944e979e104404880700000000","merkleRootHash":"0x64c4e34846b9e85ddf57c31affade38e0032969f67dc3c9df5bedd46ca9bc087"},{"version":"0x00e0ff27","timestamp":"0x3c56b266","nBits":"0x07936019","nonce":"0x520fbd6a","previousBlockHash":"0xb7310e072e93d689f9223b37f7d47a25335b70dab15e2e93ce7d1d0000000000","merkleRootHash":"0x3c5c09bdee9851f2cb6a93a2092646f1d528fcd95b4f2f515554ceeaeedd24c6"},{"version":"0x00200020","timestamp":"0x245ab266","nBits":"0x07936019","nonce":"0xe973f186","previousBlockHash":"0x4d59533d882e492eaf9f5540968420fdfe58df1fb2fd49f22a00000000000000","merkleRootHash":"0x5ac063aa31ea430d93905ec56182f9a8b8a6c907cad5e3363d0bfe538d028324"},{"version":"0x00000020","timestamp":"0xd55eb266","nBits":"0xffff001d","nonce":"0xc77d5826","previousBlockHash":"0xb76f0b50fdf79727ac02ed02f92374c2a2b654d6f12347530300000000000000","merkleRootHash":"0x2d89127cad82cdef8abb8bccbb0893fa4285fe1e7291966447d10fe69d04b61c"},{"version":"0x00000020","timestamp":"0x8663b266","nBits":"0xffff001d","nonce":"0xb0f01c03","previousBlockHash":"0xb152ed50de710cd3d7398066e0c68b63613f26c0ae153237ad9c8f6f00000000","merkleRootHash":"0x4fd1a2677cef6b5137ab902e304ae05b4eb3fa02ffa4850f702f4d23f65854fa"},{"version":"0x00000020","timestamp":"0x3768b266","nBits":"0xffff001d","nonce":"0x8a417529","previousBlockHash":"0xecad4730553db19c977dd0490270ab41e698142a3ad08c2fa1d79b5600000000","merkleRootHash":"0x85bd5db6ab5c38c70a13508a5f505fedb03a2bfcdc79487db3395fe3adfdd5c4"},{"version":"0x00e0ff2f","timestamp":"0xb565b266","nBits":"0x07936019","nonce":"0xd0194345","previousBlockHash":"0x7c018e6a7266b1ddd11662ea318737f57a2d52b104aada373233eff300000000","merkleRootHash":"0x9c2403dcb7d5f9c5b60e716a8bf777d12c7d2a46929a9650d97e720da38c2e5a"},{"version":"0x00e0ff37","timestamp":"0xc765b266","nBits":"0x07936019","nonce":"0x64f1e06c","previousBlockHash":"0xa31bf380c8f7d168113c9b0f23b9b21e7adcac9c1265b24b0d00000000000000","merkleRootHash":"0x411d0b07fd864872a3e02740730e11f27cab2a36066774d269ff2d7a804857b3"},{"version":"0x00000020","timestamp":"0x786ab266","nBits":"0xffff001d","nonce":"0xf9e96e44","previousBlockHash":"0x79799a15b4d514e03526c5567caea33e30f5356b0db310ab2200000000000000","merkleRootHash":"0x6e854e6f0458dbff2e7fdfc7143b6cf8881ed899b2146669bcad09e3abde6a2b"},{"version":"0x00000020","timestamp":"0x296fb266","nBits":"0xffff001d","nonce":"0x7df9302f","previousBlockHash":"0x3c5a9f18e24abe78333ee3492355692272c5914103f64ff475be8ef800000000","merkleRootHash":"0xe9710175a1654fded7ab0b50272f2fa218398c8f43b0903c3be03de982e02f15"},{"version":"0x00000020","timestamp":"0xdd6ab266","nBits":"0x07936019","nonce":"0x8d58aa07","previousBlockHash":"0xf472d6fdac5ce5d6e78222f14f7c8c43e4e96360dc255f4b5778189400000000","merkleRootHash":"0x06d1b8c88c4e80000e969f3c291d33005e5946f710cdaf9d425b163be644337b"},{"version":"0x00000020","timestamp":"0x8e6fb266","nBits":"0xffff001d","nonce":"0x0b2b9b11","previousBlockHash":"0x77aae47bdca9c54c553c6f3f66b3e4baeee60ff7966ad6221300000000000000","merkleRootHash":"0xca8cb6cf02ad48a46312c53f2ec8bf0084ac8ba5ca1d6f05bf614e55cda380e4"},{"version":"0x00600020","timestamp":"0x786fb266","nBits":"0x04fa5419","nonce":"0xaa34e108","previousBlockHash":"0xa4d64c4535d2a737f425706bfb4a0c9f52d7a76ec5ec79b41e7a241c00000000","merkleRootHash":"0xb99b6fafb6db698ef72c8ae17342aebff5f0ddc0f286fe2423501d4cfa3f96db"},{"version":"0x00400020","timestamp":"0x2c70b266","nBits":"0x04fa5419","nonce":"0xec31c091","previousBlockHash":"0xa4eccf399d9568a93a3b5585c1959f0f8447c3152c8ad4fa2700000000000000","merkleRootHash":"0x2a27c78a5ef009e07e47912d21432bb09f07d5fc1cd568ecb3f86e7e2fdf3198"},{"version":"0x00000020","timestamp":"0xdd74b266","nBits":"0xffff001d","nonce":"0x0bb71025","previousBlockHash":"0xe2bf2f10a7a15f6bb9ad725e1904d1d1d14aedb9407d35120d00000000000000","merkleRootHash":"0x0cad71b108840d7cf8e01715351d45f6dd348bb83ab5f4d8bd63a2eb9618d0eb"},{"version":"0x00000020","timestamp":"0x9479b266","nBits":"0xffff001d","nonce":"0xc0b19bab","previousBlockHash":"0xbb7e800d59c370701242e0a6520ed71e7060a555eeda13b4a971249100000000","merkleRootHash":"0xc3002fbc4a0dcc995cf3bab84b3b5f52d234e36dbfc694f8845ed136eaa3f4cf"},{"version":"0x00400020","timestamp":"0x9879b266","nBits":"0x04fa5419","nonce":"0xbfc50f4a","previousBlockHash":"0x2ec6bb01e5e1cbf9fdbfa3dac3eea04741ba0703fefed47e4992ef7b00000000","merkleRootHash":"0x2b0395d8c60cf3c0e6ea8fe37beba4be7654b4d890e9a75001d24e13e82e6b1e"},{"version":"0x00000020","timestamp":"0x4a7eb266","nBits":"0xffff001d","nonce":"0x6041c332","previousBlockHash":"0x579680e9a112138c5d97b4afa22cccd90153694ae44661864700000000000000","merkleRootHash":"0xfa7b14ea5c91f652e0fc986d0e459839c5a001aa9c3065b39b0fff58a14a0135"},{"version":"0x00000020","timestamp":"0xfe82b266","nBits":"0xffff001d","nonce":"0x8e527619","previousBlockHash":"0x93fefd215cd1d89f24c155af1866b93d593cdc336a8a5e8aef7da75d00000000","merkleRootHash":"0xebd7539db84f1cc806412d635f39997e3a94dab5558eafbc30ff13aa4dc50496"}] \ No newline at end of file diff --git a/test/scripts/scrapeBlocks.js b/test/scripts/scrapeBlocks.js index 0ebcc94..439ca8a 100644 --- a/test/scripts/scrapeBlocks.js +++ b/test/scripts/scrapeBlocks.js @@ -1,11 +1,11 @@ const { writeFileSync } = require("fs"); const { formatBlock } = require("./formatBlock"); const { join } = require("path"); -const API_URL = "https://mempool.space/api/v1/blocks/"; +const API_URL = "http://localhost:30000/blocks/"; (async () => { - let start = 840672; - let end = 842700; + let start = 72; + let end = 2020; const blocks = []; while (end >= start) { const blockResponse = await fetch(API_URL + end).then((res) => @@ -20,7 +20,9 @@ const API_URL = "https://mempool.space/api/v1/blocks/"; } writeFileSync( - join(__dirname, "..", "fixtures", "difficultyEpoch.json"), + join(__dirname, "..", "fixtures", "difficultyEpoch_regtest.json"), JSON.stringify(blocks.reverse()) ); + + console.log(blocks.length); })();