比特币的原理看我的另一篇博客,承蒙厚爱,阅读量居然16W+!感谢感谢!

下面是我最近写的一个近乎于完整的模拟比特币的代码,实际上还不够完整,不过已经能实现打包交易进入区块,然后挖矿了。这个程序是只有一个节点在挖矿,所以暂时也不涉及分布式系统的东西,还算比较简单容易理解。这个程序就是整个网络中一个节点的视角。分享出来希望对大家有所帮助。

部署过程就是把代码统统贴过去,要注意的就是代码中有两个文件的路径,要手动改一下,代码中有两个文件的路径,要手动改一下,代码中有两个文件的路径,要手动改一下,重要的事情说三遍,然后就可以运行,观察比特币挖矿过程啦!有问题欢迎提问。

Blockchain.h这个没什么说的,创建一个区块链类

  1. 1#pragma once
  2. 2#include"Block.h"
  3. 3#include<vector>//向量库
  4. 4class Blockchain
  5. 5{
  6. 6public:
  7. 7Blockchain();//默认构造函数
  8. 8void AddBlock(Block bNew);//增加区块函数
  9. 9uint32_t _nDifficulty;//难度值
  10. 10vector<Block> _vChain;//保存区块的变量
  11. 11Block _GetLastBlock() const;//获取最新的区块,由const关键字,表示输出的内容不可更改
  12. 12}; 

Blockchain.cpp修改难度值在这里修改Blockchain的构造函数中的nDifficulty就可以了。

  1. 1#include"Blockchain.h"
  2. 2Blockchain::Blockchain()
  3. 3{
  4. 4_vChain.emplace_back(Block(0, "Genesis Block"));
  5. 5_nDifficulty = 4;//难度值设置3基本上秒出结果,4可以看出差距,5大约要等2分钟左右。
  6. 6}
  7. 7void Blockchain::AddBlock(Block bNew)
  8. 8{
  9. 9bNew.sPrevHash = _GetLastBlock().GetHash();
  10. 10bNew.MineBlock(_nDifficulty);
  11. 11_vChain.push_back(bNew);
  12. 12bNew.WriteBlcokToTXT();//调用区块类中的写文件方法
  13. 13}
  14. 14
  15. 15Block Blockchain::_GetLastBlock() const
  16. 16{
  17. 17return _vChain.back();
  18. 18}

Block.h这里是声明区块类

  1. 1#pragma once
  2. 2#include<cstdint>//包含了uint32_t等无符号整型
  3. 3#include<iostream>//标准输入输出库
  4. 4#include <fstream>
  5. 5using namespace std;
  6. 6static time_t first_time = 0;//这个地方是为了记录每个区块产生距离第一个区块的时间而设置的全局变量
  7. 7//创建区块类
  8. 8class Block
  9. 9{
  10. 10public:
  11. 11string sPrevHash;//前一个区块的哈希值
  12. 12Block(uint32_t nIndexIn, const string& sDataIn);//构造函数
  13. 13string GetHash();//返回哈希值
  14. 14void MineBlock(uint32_t nDifficulty);//挖矿,其参数nDifficulty表示指定的难度值
  15. 15void NoMineBlock();//不挖矿直接添加区块
  16. 16uint32_t _nIndex;//区块索引值,第几个区块,从0开始计算
  17. 17int64_t _nNonce;//区块随机数
  18. 18string _sData;//区块描述字符
  19. 19string _sHash;//区块Hash值
  20. 20time_t _tTime;//区块生成时间
  21. 21string _CalculateHash() const;//计算Hash值,const保证输出的函数值不能被改变。
  22. 22void WriteBlcokToTXT();//将区块数据写入到TXT文件中
  23. 23};

Block.cpp

  1. 1#include"Block.h"
  2. 2#include"sha256.h"
  3. 3#include"time.h"
  4. 4#include<sstream>
  5. 5Block::Block(uint32_t nIndexIn, const string& sDataIn) :_nIndex(nIndexIn), _sData(sDataIn)
  6. 6//构造函数Block的两个参数为nIndexIn和sDataIn,分别赋值到Block中的_nIndex和_sData(构造函数初始化用法)
  7. 7{
  8. 8_nNonce = -1;//Nounce设置为-1
  9. 9_tTime = time(nullptr);//设置时间
  10. 10if (nIndexIn == 0)//此处整个时间记录下来是为了记录当前区块生成所需要的时间,而不是当前时间
  11. 11first_time = _tTime;
  12. 12}
  13. 13string Block::GetHash()//返回哈希值函数的实现
  14. 14{
  15. 15return _sHash;
  16. 16}
  17. 17void Block::MineBlock(uint32_t nDifficulty)//挖矿函数,参数为难度值。
  18. 18{
  19. 19//char cstr[nDifficulty + 1];
  20. 20char cstr[10 + 1];//这个数组实际上设置多大都可以,但是要大于nDifficulty的值
  21. 21for (uint32_t i = 0; i < nDifficulty; ++i)//填充数组,使数组的前nDifficulty位都为0,作为难度。
  22. 22{
  23. 23cstr[i] = '0';
  24. 24}
  25. 25cstr[nDifficulty] = '\0';
  26. 26string str(cstr);//创建一个string类的对象,初始化为cstr(将字符串数组转换为string类对象)
  27. 27
  28. 28do
  29. 29{
  30. 30_nNonce++;
  31. 31_sHash = _CalculateHash();
  32. 32
  33. 33} while (_sHash.substr(0, nDifficulty) != str);//substr表示从下标0开始--->nDifficulty的内容
  34. 34//要寻找一个Nounce使得总体哈希值的前n位的0(即0的个数)和难度值的个数相同,则挖矿成功。
  35. 35cout << "Block mined:" << _sHash << endl;
  36. 36}
  37. 37
  38. 38inline string Block::_CalculateHash() const
  39. 39{
  40. 40stringstream ss;//该对象可以通过<<接收多个数据,保存到ss对象中,并通过str方法,将内容赋给一个string对象
  41. 41ss << _nIndex << _tTime << _sData << _nNonce << sPrevHash;
  42. 42//return sha256(ss.str());
  43. 43return sha256(sha256(ss.str()));
  44. 44}
  45. 45
  46. 46void Block::WriteBlcokToTXT()//将生成的区块数据输出到一个txt文档中来保存路径自己改
  47. 47{
  48. 48ofstream outfile("out.txt", ios::app);//此处修改保存区块数据的路径
  49. 49outfile <<"Index:"<<_nIndex<<endl;
  50. 50outfile << "Nonce:" << _nNonce << endl;
  51. 51outfile << "_sData:" << _sData << endl;
  52. 52outfile << "_sHash:" << _sHash << endl;
  53. 53outfile << "sPrevHash:" << sPrevHash << endl;
  54. 54outfile << "_tTime:" << _tTime - first_time << endl;
  55. 55outfile << endl;
  56. 56outfile.close();
  57. 57}

sha256.h 这是一个哈希算法,没什么说的,网上抄的,这个东西我到现在也没看懂,太深奥了。但是只要知道功能就行了。

  1. 1#pragma once
  2. 2
  3. 3#ifndef SHA256_H
  4. 4#define SHA256_H
  5. 5#include <string>
  6. 6
  7. 7class SHA256
  8. 8{
  9. 9protected:
  10. 10typedef unsigned char uint8;
  11. 11typedef unsigned int uint32;
  12. 12typedef unsigned long long uint64;
  13. 13
  14. 14const static uint32 sha256_k[];
  15. 15static const unsigned int SHA224_256_BLOCK_SIZE = (512 / 8);
  16. 16public:
  17. 17void init();
  18. 18void update(const unsigned char* message, unsigned int len);
  19. 19void final(unsigned char* digest);
  20. 20static const unsigned int DIGEST_SIZE = (256 / 8);
  21. 21
  22. 22protected:
  23. 23void transform(const unsigned char* message, unsigned int block_nb);
  24. 24unsigned int m_tot_len;
  25. 25unsigned int m_len;
  26. 26unsigned char m_block[2 * SHA224_256_BLOCK_SIZE];
  27. 27uint32 m_h[8];
  28. 28};
  29. 29
  30. 30std::string sha256(std::string input);
  31. 31
  32. 32#define SHA2_SHFR(x, n) (x >> n)
  33. 33#define SHA2_ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n)))
  34. 34#define SHA2_ROTL(x, n) ((x << n) | (x >> ((sizeof(x) << 3) - n)))
  35. 35#define SHA2_CH(x, y, z) ((x & y) ^ (~x & z))
  36. 36#define SHA2_MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
  37. 37#define SHA256_F1(x) (SHA2_ROTR(x, 2) ^ SHA2_ROTR(x, 13) ^ SHA2_ROTR(x, 22))
  38. 38#define SHA256_F2(x) (SHA2_ROTR(x, 6) ^ SHA2_ROTR(x, 11) ^ SHA2_ROTR(x, 25))
  39. 39#define SHA256_F3(x) (SHA2_ROTR(x, 7) ^ SHA2_ROTR(x, 18) ^ SHA2_SHFR(x, 3))
  40. 40#define SHA256_F4(x) (SHA2_ROTR(x, 17) ^ SHA2_ROTR(x, 19) ^ SHA2_SHFR(x, 10))
  41. 41#define SHA2_UNPACK32(x, str) \
  42. 42{ \
  43. 43*((str) + 3) = (uint8) ((x) ); \
  44. 44*((str) + 2) = (uint8) ((x) >> 8); \
  45. 45*((str) + 1) = (uint8) ((x) >> 16); \
  46. 46*((str) + 0) = (uint8) ((x) >> 24); \
  47. 47}
  48. 48#define SHA2_PACK32(str, x) \
  49. 49{ \
  50. 50*(x) = ((uint32) *((str) + 3) ) \
  51. 51| ((uint32) *((str) + 2) << 8) \
  52. 52| ((uint32) *((str) + 1) << 16) \
  53. 53| ((uint32) *((str) + 0) << 24); \
  54. 54}
  55. 55#endif

sha256.cpp

  1. 1#define _CRT_SECURE_NO_WARNINGS
  2. 2#include <cstring>
  3. 3#include <fstream>
  4. 4#include "sha256.h"
  5. 5
  6. 6const unsigned int SHA256::sha256_k[64] = //UL = uint32
  7. 7{ 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
  8. 80x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
  9. 90xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
  10. 100x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
  11. 110xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
  12. 120x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
  13. 130x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
  14. 140xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
  15. 150x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
  16. 160x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
  17. 170xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
  18. 180xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
  19. 190x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
  20. 200x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
  21. 210x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
  22. 220x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };
  23. 23
  24. 24void SHA256::transform(const unsigned char* message, unsigned int block_nb)
  25. 25{
  26. 26uint32 w[64];
  27. 27uint32 wv[8];
  28. 28uint32 t1, t2;
  29. 29const unsigned char* sub_block;
  30. 30int i;
  31. 31int j;
  32. 32for (i = 0; i < (int)block_nb; i++) {
  33. 33sub_block = message + (i << 6);
  34. 34for (j = 0; j < 16; j++) {
  35. 35SHA2_PACK32(&sub_block[j << 2], &w[j]);
  36. 36}
  37. 37for (j = 16; j < 64; j++) {
  38. 38w[j] = SHA256_F4(w[j - 2]) + w[j - 7] + SHA256_F3(w[j - 15]) + w[j - 16];
  39. 39}
  40. 40for (j = 0; j < 8; j++) {
  41. 41wv[j] = m_h[j];
  42. 42}
  43. 43for (j = 0; j < 64; j++) {
  44. 44t1 = wv[7] + SHA256_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6])
  45. 45+ sha256_k[j] + w[j];
  46. 46t2 = SHA256_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]);
  47. 47wv[7] = wv[6];
  48. 48wv[6] = wv[5];
  49. 49wv[5] = wv[4];
  50. 50wv[4] = wv[3] + t1;
  51. 51wv[3] = wv[2];
  52. 52wv[2] = wv[1];
  53. 53wv[1] = wv[0];
  54. 54wv[0] = t1 + t2;
  55. 55}
  56. 56for (j = 0; j < 8; j++) {
  57. 57m_h[j] += wv[j];
  58. 58}
  59. 59}
  60. 60}
  61. 61
  62. 62void SHA256::init()
  63. 63{
  64. 64m_h[0] = 0x6a09e667;
  65. 65m_h[1] = 0xbb67ae85;
  66. 66m_h[2] = 0x3c6ef372;
  67. 67m_h[3] = 0xa54ff53a;
  68. 68m_h[4] = 0x510e527f;
  69. 69m_h[5] = 0x9b05688c;
  70. 70m_h[6] = 0x1f83d9ab;
  71. 71m_h[7] = 0x5be0cd19;
  72. 72m_len = 0;
  73. 73m_tot_len = 0;
  74. 74}
  75. 75
  76. 76void SHA256::update(const unsigned char* message, unsigned int len)
  77. 77{
  78. 78unsigned int block_nb;
  79. 79unsigned int new_len, rem_len, tmp_len;
  80. 80const unsigned char* shifted_message;
  81. 81tmp_len = SHA224_256_BLOCK_SIZE - m_len;
  82. 82rem_len = len < tmp_len ? len : tmp_len;
  83. 83memcpy(&m_block[m_len], message, rem_len);
  84. 84if (m_len + len < SHA224_256_BLOCK_SIZE) {
  85. 85m_len += len;
  86. 86return;
  87. 87}
  88. 88new_len = len - rem_len;
  89. 89block_nb = new_len / SHA224_256_BLOCK_SIZE;
  90. 90shifted_message = message + rem_len;
  91. 91transform(m_block, 1);
  92. 92transform(shifted_message, block_nb);
  93. 93rem_len = new_len % SHA224_256_BLOCK_SIZE;
  94. 94memcpy(m_block, &shifted_message[block_nb << 6], rem_len);
  95. 95m_len = rem_len;
  96. 96m_tot_len += (block_nb + 1) << 6;
  97. 97}
  98. 98
  99. 99void SHA256::final(unsigned char* digest)
  100. 100{
  101. 101unsigned int block_nb;
  102. 102unsigned int pm_len;
  103. 103unsigned int len_b;
  104. 104int i;
  105. 105block_nb = (1 + ((SHA224_256_BLOCK_SIZE - 9)
  106. 106< (m_len % SHA224_256_BLOCK_SIZE)));
  107. 107len_b = (m_tot_len + m_len) << 3;
  108. 108pm_len = block_nb << 6;
  109. 109memset(m_block + m_len, 0, pm_len - m_len);
  110. 110m_block[m_len] = 0x80;
  111. 111SHA2_UNPACK32(len_b, m_block + pm_len - 4);
  112. 112transform(m_block, block_nb);
  113. 113for (i = 0; i < 8; i++) {
  114. 114SHA2_UNPACK32(m_h[i], &digest[i << 2]);
  115. 115}
  116. 116}
  117. 117
  118. 118std::string sha256(std::string input)
  119. 119{
  120. 120unsigned char digest[SHA256::DIGEST_SIZE];
  121. 121memset(digest, 0, SHA256::DIGEST_SIZE);
  122. 122
  123. 123SHA256 ctx = SHA256();
  124. 124ctx.init();
  125. 125ctx.update((unsigned char*)input.c_str(), input.length());
  126. 126ctx.final(digest);
  127. 127
  128. 128char buf[2 * SHA256::DIGEST_SIZE + 1];
  129. 129buf[2 * SHA256::DIGEST_SIZE] = 0;
  130. 130for (int i = 0; i < SHA256::DIGEST_SIZE; i++)
  131. 131sprintf(buf + i * 2, "%02x", digest[i]);
  132. 132return std::string(buf);
  133. 133}

user.h创建一个用户类

  1. 1#pragma once
  2. 2#include <iostream>//标准输入输出库
  3. 3#include <vector> 
  4. 4#include <string> 
  5. 5#include <fstream>
  6. 6#include<sstream>
  7. 7#include "BlockChain.h"
  8. 8#include "sha256.h"
  9. 9using namespace std;
  10. 10class User
  11. 11{
  12. 12public:
  13. 13Blockchain uBlockchain;//当前节点创建一个自己的区块链,因为每个用户都保存一条自己的区块链
  14. 14string batchTX();//打包交易
  15. 15};

user.cpp这里是实现用户的打包交易,通过默克尔树的方式将若干条交易打包。其中300TXdata.txt后面我会贴上,一定注意文件的路径问题,不然可能运行不了。(大神当我没说)。

  1. 1#include"user.h"
  2. 2string User::batchTX()
  3. 3{
  4. 4ifstream myfile("300TXdata.txt");//读取txt文档中的300条交易数据
  5. 5string temp[300];
  6. 6int i = 0;
  7. 7if (!myfile.is_open())
  8. 8{
  9. 9cout << "未成功打开文件" << endl;
  10. 10}
  11. 11while (getline(myfile, temp[i++]))//将取出来的第一行放在数组中i的位置然后i++
  12. 12{
  13. 13//cout << temp[i++] << endl;
  14. 14getline(myfile, temp[i++]);//将取出来的下一行放在数组i后面的位置然后i++
  15. 15//cout << temp[i] << endl;
  16. 16}
  17. 17
  18. 18for (int i = 0; i < 300; i++)//这是一个伪默克尔树生成过程,为了便于实现,就这样写了。
  19. 19//实际上真的默克尔树生成也不难,暂时先这样吧。
  20. 20{
  21. 21stringstream ss;//该对象可以通过<<接收多个数据,保存到ss对象中,并通过str方法,将内容赋给一个string对象
  22. 22ss << temp[0] << temp[i];
  23. 23temp[0] = sha256(ss.str());
  24. 24//cout << temp[0] << endl;
  25. 25}
  26. 26
  27. 27myfile.close();
  28. 28return temp[0];
  29. 29}
  30. 30
  31. 31

TestforBitcoin.cpp这就是测试程序了,我是假设100个用户中某个用户挖矿成功了,然后来挖矿。实际上不是这样的过程,而是先挖矿才知道是哪个用户挖矿成功,不过对于一个用户来说,都无所谓了,只是为了模拟的逼真一点,加了个随机数。

  1. 1#include<iostream>
  2. 2#include<cstdint>
  3. 3#include"Blockchain.h"
  4. 4#include"user.h"
  5. 5#include<stdio.h>
  6. 6#include <cstdlib>
  7. 7#include <ctime>
  8. 8#include"time.h"
  9. 9#include"sha256.h"
  10. 10using namespace std;
  11. 11int main()
  12. 12{
  13. 13srand((int)time(0));//随机数种子
  14. 14Blockchain bChain = Blockchain();//首先创建一个区块链
  15. 15User user[100];//创建100个用户
  16. 16int miner_id;
  17. 17for (int i = 0; i < 100000; i++)//十万次出块,记录出块速度
  18. 18{
  19. 19miner_id = rand() % 100;
  20. 20for (int j = 0; j < 100; j++)
  21. 21{
  22. 22user[j].uBlockchain = bChain;//把100个节点的区块链初始化。
  23. 23}
  24. 24user[miner_id].uBlockchain = bChain;//对挖矿区块初始化
  25. 25printf("Mining block %d...\n", i);
  26. 26user[miner_id].uBlockchain.AddBlock(Block(i, user[miner_id].batchTX()));
  27. 27bChain = user[miner_id].uBlockchain;
  28. 28printf("Miner ID is %d...\n", miner_id);
  29. 29}
  30. 30system("pause");
  31. 31return 0;
  32. 32}

300dataTX.txt这里包含了300条交易,用户A->用户B的转账,以及金额,这个东西我是用一个程序模拟生成的,如果需要这个这个程序我之后再发出来。 

  1. 101100SUSPE 10111ZKHWI 79
  2. 210010VQJGH 00100UXYMT 34
  3. 300011YMAWT 10010XTPCF 43
  4. 410101TZZMF 01110SHOLR 51
  5. 501011WVQDR 11101VDFBV 59
  6. 611001RRPTU 01011QZWRG 68
  7. 711100TFFJG 10101TMVIS 76
  8. 800010OBWAS 00001OIMYE 85
  9. 910000ROVQD 11010RWCPI 93
  10. 1001111MKMHH 01100LSBFT 1
  11. 1111011PGDXT 01010OOSVF 10
  12. 1201001KUCNF 10011JBRMR 18
  13. 1310110NQTEQ 00101MXICU 26
  14. 1400000IDKUU 10011HTZSG 35
  15. 1510100LZJKG 01000KHYJS 43
  16. 1601110GVABS 11100FDPZE 52
  17. 1711001JJQRD 00010IQGPH 60
  18. 1800101EFPHH 10000DMFGT 68
  19. 1910111GAGYT 00111GIVWF 77
  20. 2000000BOFOE 11011BWMNR 85
  21. 2111110EKWEQ 01001ESLDU 93
  22. 2201110ZYNVU 11110HNCTG 2
  23. 2301001CUMLG 00000BBTKS 10
  24. 2410111XPDCR 10100EXSAD 19
  25. 2500101ADUSD 01111ZLJQH 27
  26. 2611001DZTIH 11001CHIHT 35
  27. 2701110YVJZT 01111XCZXF 44
  28. 2811100BJAPE 00111AQQNQ 20
  29. 2900010WFZFQ 10000VMOEU 28
  30. 3010111ZSQWU 00110YAFUG 37
  31. 3100101UOHMF 11110TWWLS 45
  32. 3211011WKGCR 01001WRVBD 54
  33. 3301101RYXTD 10111RFMRH 62
  34. 3410000UUWJH 00101UBDIT 70
  35. 3500010PHNSS 10000OXCYE 79
  36. 3610100SDEIE 01110RLTOQ 87
  37. 3701011NZCYQ 11100MGKFU 95
  38. 3811011QNTPU 01010PUJVG 4
  39. 3911101LJKFF 10111KQALR 12
  40. 4000010OEJVR 00101NMYCD 21
  41. 4110000JSAMD 11011IAPSH 29
  42. 4201100MORCG 01100LWGIT 37
  43. 4311010HCQSS 11000GRFZE 46
  44. 4401001JYHJE 10010JFWPQ 54
  45. 4510111ETYZQ 00100MBNGU 62
  46. 4600011HHXQT 10011HPMWF 71
  47. 4710000CDNGF 01011JLDMR 79
  48. 4801110FZMWR 11101EGUDD 88
  49. 4911000ANDND 00010HUTTH 96
  50. 5000101DIUDG 10000CQJJS 4
  51. 5110111GWTTS 00100FMAAE 13
  52. 5200001BSKKE 11011AAZQQ 21
  53. 5311111EOBAQ 01001DVQGU 29
  54. 5401110ZCAQT 11111YJPXF 38
  55. 5501000CXRHF 00011BFGNR 46
  56. 5610110WTIXR 10000WBXED 55
  57. 5700101ZHGNC 01110ZPWUG 63
  58. 5811001UDXEG 11000UKNKS 71
  59. 5901111XROUS 01101XYEBE 80
  60. 6011100SMNLE 00111RUCRQ 88
  61. 6100010VIEBP 10001UQTHT 96
  62. 6210110QWDRT 00110PEKYF 5
  63. 6300100TSUIF 11110SZJOR 13
  64. 6411011OGLYR 01000NVAED 22
  65. 6501101RBKOC 10110QJRVG 30
  66. 6611001MXBFG 00101LFQLS 38
  67. 6700010PLRVS 10001OTHCE 47
  68. 6810100KHQLD 01111JOGKQ 55
  69. 6901000MDHCP 11100MKXAT 63
  70. 7011011HQYST 01010PYNRF 72
  71. 7111101KMXJF 10110KUMHR 80
  72. 7200011FAOZQ 00101MQDXC 89
  73. 7310011IWFPC 11011HDUOG 97
  74. 7400100DSEGG 01101KZTES 5
  75. 7511010GFVWS 11001FNKUE 14
  76. 7601000JBUMD 10010IJBLP 22
  77. 7710101EXKDP 00100DFABT 30
  78. 7800011HLBTT 10010GSRRF 39
  79. 7910001CHAJE 01011BOIIR 47
  80. 8001111FVRAQ 11101ECGYC 56
  81. 8111010ZQIQC 00011ZYXPG 64
  82. 8201000CMHHG 10010CUWFS 72
  83. 8310110XAYXR 00100XHNVD 49
  84. 8400001AWPND 11010ADEMP 57
  85. 8511101VKOEP 01000UZDCT 65
  86. 8601111YFFUT 11101XNUSF 74
  87. 8701000TBVKE 00011SJLJQ 82
  88. 8810110WPUBQ 10001VWKZC 91
  89. 8900110RLLRC 01110QSBPG 99
  90. 9010000UHKHF 11010TORGS 7
  91. 9101111PUBYR 01000OCQWD 16
  92. 9211101SQSOD 00110RYHNP 24
  93. 9300001NEREP 10001UUGDT 32
  94. 9410110PAIVS 00101PHXTE 41
  95. 9500100KWZLE 11111SDOKQ 49
  96. 9611010NJYCQ 01000NRNAC 58
  97. 9701111IFOSC 10110PNEQG 66
  98. 9811101LBFIF 00110KJVHR 74
  99. 9900011OPEZR 10001NWUXD 83
  100. 10010101JLVHD 01111ISKNP 91
  101. 10101000MYMXP 11101LOBET 99
  102. 10211010HULOS 01001GCAUE 8
  103. 10311100KQCEE 10110JYRLQ 16
  104. 10400011FEBUQ 00100ELIBC 25
  105. 10510011IASLB 11010HHHRF 33
  106. 10600101CVJBF 01111CDYIR 41
  107. 10711010FJHSR 11101FRXYD 50
  108. 10801000AFYID 10011ANOOP 58
  109. 10910100DTPYO 00100CAFFS 66
  110. 11000010YPOPS 10000XWDVE 75
  111. 11110001BKFFE 01010ASULQ 83
  112. 11201111WYWVQ 11100VGLCC 92
  113. 11311011ZUVMB 00011YCKSF 0
  114. 11401000UIMCF 10011TXBIR 8
  115. 11510110XEDSR 00101WLSZD 17
  116. 11600000SZCJC 11010RHRPP 25
  117. 11711001VNSZO 01000UVIGS 33
  118. 11801111QJRQS 11100XRZWE 42
  119. 11911001SFIGE 00011SMYMQ 50
  120. 12010101NTZWP 10001VAODB 59
  121. 12100110QOYNB 00111QWNTF 67
  122. 12210000LCPDF 11011SSEJR 75
  123. 12301110OYGTR 01000NGVAD 84
  124. 12411111RUFKC 00110QBUQO 92
  125. 12500001MIWAO 10000LPLGS 0
  126. 12610111PDNQS 00001OLCXE 9
  127. 12700101KZLHD 11111JHBNQ 17
  128. 12811000NNCXP 01001MVSEB 26
  129. 12901110IJTNB 11111HQJUF 34
  130. 13011100LXSEF 00110KEHKR 42
  131. 13100011FTJUQ 10000FAYBC 51
  132. 13210111IOILC 01110IWPJO 59
  133. 13301101DCZBO 11111DKOZS 67
  134. 13411010GYQRS 01001FFFQE 76
  135. 13501100BMPID 10111ABEGP 84
  136. 13600000EIGYP 00100DPVWB 93
  137. 13710010ZDWOB 10000YLMNF 1
  138. 13800101CRVFE 01110BZLDR 77
  139. 13911011XNMVQ 11100WUCUC 86
  140. 14001011AJDLC 10011ZQSKO 94
  141. 14110100VXCCO 00111UERAS 2
  142. 14200010YSTSR 10101XAIRD 11
  143. 14310000SGKJD 01010AWZHP 19
  144. 14401101VCJZP 11100VKYXB 28
  145. 14511011QYAPB 01000YFPOF 36
  146. 14601001TMZGE 10011TTGEQ 44
  147. 14710111WHPWQ 00101VPFUC 53
  148. 14800010RDGMC 11011QLWLO 61
  149. 14911000URFDO 01011TZVBS 69
  150. 15001110PNWTR 11100OULRD 78
  151. 15111001SBNJD 00010RQCIP 86
  152. 15210001NWMAP 10000MEBYB 95
  153. 15300111QSDQA 00101PASPE 3
  154. 15410000LGUHE 11011KOJFQ 11
  155. 15501110OCTXQ 01001NJIVC 20
  156. 15611110IYKNC 00110IFZMO 28
  157. 15700000LLAEN 10010LTQCR 36
  158. 15810111GHZUR 00000GPPSD 45
  159. 15900101JVQKD 11110IDGJP 53
  160. 16011001ERPBP 01001DYWZB 62
  161. 16101110HNGRA 11001GUVPE 70
  162. 16211100CAXHE 00111BIMGQ 78
  163. 16300010FWWYQ 10000EELWC 87
  164. 16410110AKNGB 01110ZACNO 95
  165. 16501101DGEWN 11110CNTDR 3
  166. 16611011YCDNR 01001FJSTD 12
  167. 16701101BPTDD 10111AXJKP 20
  168. 16800100VLKUO 00101DTAAA 29
  169. 16910010YHJKA 10001YPZQE 37
  170. 17000100TVAAE 01110BCPHQ 45
  171. 17111001WRRRQ 11100WYGXC 54
  172. 17201011ZEQHB 10010YUFNN 62
  173. 17310101UAHXN 00111TIWER 70
  174. 17400011XWGOR 10101WENUD 79
  175. 17510010SKXEC 01011RRMLP 87
  176. 17601100VGOUO 11101UNDBA 96
  177. 17701001QMXMO 11010QCMLA 4
  178. 17811001TIODA 01001TPDBE 64
  179. 17911110OEFTD 10101OLUSP 73
  180. 18000000RREKP 00011RZTIB 81
  181. 18110110MNVAB 11000LVKYN 90
  182. 18201110PJMQM 01110ORBPR 98
  183. 18311001KXLHQ 11010JEAFC 6
  184. 18401111NTCXC 10000MARVO 15
  185. 18510101IGANO 00111HWIMA 23
  186. 18600000LCREZ 10001KKHCD 31
  187. 18710110GYIUD 01001FGXSP 40
  188. 18801100JMHKP 11110ITWJB 48
  189. 18911011EIYBB 00000DPNZN 57
  190. 19000111GDPRM 10110GLEQQ 65
  191. 19110101BROHQ 00111BZDGC 73
  192. 19200011ENFYC 11001EVUWO 82
  193. 19311100ZBWOO 01111YILNA 58
  194. 19401100CXVFZ 11101BEKDD 66
  195. 19511010XSLVD 00000WABTP 75
  196. 19610101AGCDP 10110ZOSKB 83
  197. 19700011VCBUA 01100CKQAN 92
  198. 19811011YQSKM 11011XFHQQ 0
  199. 19901101TMRAQ 01111ATYHC 8
  200. 20011010WHIRC 00101VPXXO 17
  201. 20100000RVZHN 10010YDONZ 25
  202. 20210100TRYXZ 00100TZNED 33
  203. 20300011WNPOD 11100WUEUP 42
  204. 20411001RBGEP 01010RIVLB 50
  205. 20501111UWEVA 10101TEUBM 59
  206. 20610010PKVLM 00011OALRQ 67
  207. 20700000SGMBQ 10011ROCIC 75
  208. 20810110NCLSB 01100MJAYO 84
  209. 20901010QQCIN 11010PXROZ 92
  210. 21011001LLTYZ 01000KTIFD 0
  211. 21101111OHSPD 10100NPHVP 9
  212. 21200001JVJFO 00011IDYLA 17
  213. 21310000MRIVA 11001LYPCM 26
  214. 21401110HFZMM 01111GMOSQ 34
  215. 21511000JBPCQ 11010JIFJC 42
  216. 21601111EWOTB 10000EEEZN 51
  217. 21710111HKFJN 00110HSVPZ 59
  218. 21800001CGWZZ 10001BNLGD 67
  219. 21910111FUVQC 01001EJKWP 76
  220. 22001100AQMGO 11111HXBMA 84
  221. 22111000DLDWA 00001CTSDM 93
  222. 22200110YZCNM 10000FHRTQ 1
  223. 22310101BVTDP 00110ACIJB 9
  224. 22400011WRKTB 11000DYZAN 18
  225. 22511111ZFIKN 01111YMYQZ 26
  226. 22601100CAZAZ 11111BIPHD 34
  227. 22711010WOYQC 00001WEGXO 43
  228. 22810100ZKPHO 10110ZSEFA 51
  229. 22900100UGGXA 01100UNVWM 60
  230. 23011011XUFOL 11000WBUMQ 68
  231. 23101101SPWEP 01110RXLCB 76
  232. 23211011VLNUB 00101UTCTN 85
  233. 23300010QZMLN 10011PHBJZ 93
  234. 23410100TVDBY 00111SCSZC 1
  235. 23500010OJTRC 11100NYJQO 10
  236. 23611000RESIO 01010QMIGA 18
  237. 23701101MAJYA 10100LIZWM 27
  238. 23811011POAOL 00101OWPNP 35
  239. 23900001JKZFP 10011JRODB 43
  240. 24010110MGQVB 01101MNFUN 52
  241. 24101010HTPMN 11011HBWKZ 60
  242. 24211000KPGCY 01010KXVAC 68
  243. 24301111FDXSC 10100ELMRO 77
  244. 24400001IZWJO 00010HGLHA 85
  245. 24510001DVMZZ 11001KCCXL 94
  246. 24600111GIDPL 01101FQTOP 2
  247. 24711000BECGP 11011IMSEB 10
  248. 24801010ESTWB 10001DIIUN 19
  249. 24910110ZOKMM 00110GVZLY 95
  250. 25000001CKJDY 10010BRYBC 3
  251. 25110111FXATC 01000EFPSO 12
  252. 25201101ZTRKO 11111ZBGIA 20
  253. 25311000CPQAZ 00001CXFYL 29
  254. 25401110XDHQL 10001XKWPP 37
  255. 25510100AZFHP 00110ZGNFB 45
  256. 25600010VMWXA 11000UCMVN 54
  257. 25711111YINNM 01010XQDMY 62
  258. 25801101TEMEY 11110SMBCC 70
  259. 25911011WSDUC 00001VZSSO 79
  260. 26010110ROUCN 10111QVJJZ 87
  261. 26100100UJTTZ 01101TRIZL 96
  262. 26210010PXKJL 11000OFZQP 4
  263. 26301101STBZP 01110RBQGB 12
  264. 26411101MHAQA 00100MOPWM 21
  265. 26500011PDQGM 10011PKGNY 29
  266. 26610101KZHXY 00111KGXDC 37
  267. 26700010NMGNB 11101NUWTO 46
  268. 26811010IIXDN 01011PQMKZ 54
  269. 26901100LWWUZ 10100KLDAL 63
  270. 27011011GSNKL 00100NZCQP 71
  271. 27100001JOEAO 10010IVTHA 79
  272. 27210101EBDRA 01101LJSXM 88
  273. 27301010HXUHM 11101GFJNY 96
  274. 27411000KTLXY 01011JAAEC 4
  275. 27501110FHJOB 10100EOZUN 13
  276. 27600010IDAEN 00010HKQLZ 21
  277. 27710001CQRVZ 11010CGHBL 30
  278. 27800111FMQLK 01100FUFRP 38
  279. 27911001AIHBO 11011AQWIA 46
  280. 28001000DWGSA 10001CDNYM 55
  281. 28110110YSXIM 00101XZMOY 63
  282. 28200000BNOYX 10010AVDFB 71
  283. 28310110WBNPB 01000VJUVN 80
  284. 28401111ZXEFN 11110YFTLZ 88
  285. 28511001ULUVZ 00011TAKCL 97
  286. 28601111XHTMK 10001WOJSO 5
  287. 28710100SCKCO 00111RKAJA 13
  288. 28800000VQBTA 11001UYQZM 22
  289. 28911110PMAJM 01000PUPPY 30
  290. 29001101SIRZX 11110SPGGB 38
  291. 29111011NWIQB 00000NDXWN 47
  292. 29210111QRHGN 10111PZWEZ 55
  293. 29300101LFYWY 00111SNNVK 64
  294. 29410010OBXNK 11001NJELO 72
  295. 29501100JXNDO 01111QEDBA 80
  296. 29611100MLETA 00100LSUSM 89
  297. 29700011HGDKL 10000OOLIX 97
  298. 29810101KUUAX 00110JKJZB 5
  299. 29900111NQLQB 11101MYAPN 14
  300. 30011010IMKHN 01011HTZFZ 22

发表评论

邮箱地址不会被公开。 必填项已用*标注