010Editor Keygen for Delphi Console

冥界3大法王

[Pascal] 纯文本查看 复制代码

program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var
  k: array[0..7] of Byte = ($11, $22, $33, $9C, $55, $66, $77, $88);

  Encode: array[0..255] of LongWord = (
    $39CB44B8, $23754F67, $5F017211, $3EBB24DA, $351707C6, $63F9774B, $17827288, $0FE74821,
    $5B5F670F, $48315AE8, $785B7769, $2B7A1547, $38D11292, $42A11B32, $35332244, $77437B60,
    $1EAB3B10, $53810000, $1D0212AE, $6F0377A8, $43C03092, $2D3C0A8E, $62950CBF, $30F06FFA,
    $34F710E0, $28F417FB, $350D2F95, $5A361D5A, $15CC060B, $0AFD13CC, $28603BCF, $3371066B,
    $30CD14E4, $175D3A67, $6DD66A13, $2D3409F9, $581E7B82, $76526B99, $5C8D5188, $2C857971,
    $15F51FC0, $68CC0D11, $49F55E5C, $275E4364, $2D1E0DBC, $4CEE7CE3, $32555840, $112E2E08,
    $6978065A, $72921406, $314578E7, $175621B7, $40771DBF, $3FC238D6, $4A31128A, $2DAD036E,
    $41A069D6, $25400192, $00DD4667, $6AFC1F4F, $571040CE, $62FE66DF, $41DB4B3E, $3582231F,
    $55F6079A, $1CA70644, $1B1643D2, $3F7228C9, $5F141070, $3E1474AB, $444B256E, $537050D9,
    $0F42094B, $2FD820E6, $778B2E5E, $71176D02, $7FEA7A69, $5BB54628, $19BA6C71, $39763A99,
    $178D54CD, $01246E88, $3313537E, $2B8E2D17, $2A3D10BE, $59D10582, $37A163DB, $30D6489A,
    $6A215C46, $0E1C7A76, $1FC760E7, $79B80C65, $27F459B4, $799A7326, $50BA1782, $2A116D5C,
    $63866E1B, $3F920E3C, $55023490, $55B56089, $2C391FD1, $2F8035C2, $64FD2B7A, $4CE8759A,
    $518504F0, $799501A8, $3F5B2CAD, $38E60160, $637641D8, $33352A42, $51A22C19, $085C5851,
    $032917AB, $2B770AC7, $30AC77B3, $2BEC1907, $035202D0, $0FA933D3, $61255DF3, $22AD06BF,
    $58B86971, $5FCA0DE5, $700D6456, $56A973DB, $5AB759FD, $330E0BE2, $5B3C0DDD, $495D3C60,
    $53BD59A6, $4C5E6D91, $49D9318D, $103D5079, $61CE42E3, $7ED5121D, $14E160ED, $212D4EF2,
    $270133F0, $62435A96, $1FA75E8B, $6F092FBE, $4A000D49, $57AE1C70, $004E2477, $561E7E72,
    $468C0033, $5DCC2402, $78507AC6, $58AF24C7, $0DF62D34, $358A4708, $3CFB1E11, $2B71451C,
    $77A75295, $56890721, $0FEF75F3, $120F24F1, $01990AE7, $339C4452, $27A15B8E, $0BA7276D,
    $60DC1B7B, $4F4B7F82, $67DB7007, $4F4A57D9, $621252E8, $20532CFC, $6A390306, $18800423,
    $19F3778A, $462316F0, $56AE0937, $43C2675C, $65CA45FD, $0D604FF2, $0BFD22CB, $3AFE643B,
    $3BF67FA6, $44623579, $184031F8, $32174F97, $4C6A092A, $5FB50261, $01650174, $33634AF1,
    $712D18F4, $6E997169, $5DAB7AFE, $7C2B2EE8, $6EDB75B4, $5F836FB6, $3C2A6DD6, $292D05C2,
    $052244DB, $149A5F4F, $5D486540, $331D15EA, $4F456920, $483A699F, $3B450F05, $3B207C6C,
    $749D70FE, $417461F6, $62B031F1, $2750577B, $29131533, $588C3808, $1AEF3456, $0F3C00EC,
    $7DA74742, $4B797A6C, $5EBB3287, $786558B8, $00ED4FF2, $6269691E, $24A2255F, $62C11F7E,
    $2F8A7DCD, $643B17FE, $778318B8, $253B60FE, $34BB63A3, $5B03214F, $5F1571F4, $1A316E9F,
    $7ACF2704, $28896838, $18614677, $1BF569EB, $0BA85EC9, $6ACA6B46, $1E43422A, $514D5F0E,
    $413E018C, $307626E9, $01ED1DFA, $49F46F5A, $461B642B, $7D7007F2, $13652657, $6B160BC5,
    $65E04849, $1F526E1C, $5A0251B6, $2BD73F69, $2DBF7ACD, $51E63E80, $5CF2670F, $21CD0A03,
    $5CFF0261, $33AE061E, $3BB6345F, $5D814A75, $257B5DF4, $0A5C2C5B, $16A45527, $16F23945
  );

var
  x: Integer;
  k0xork6, k1xork7, k2xork5: Byte;
  eeddxx: Integer;
  eeaaxx1: Byte;
  eeaaxx2: Integer;
  eessii1: Integer;

function Encde(const a1: PAnsiChar; a2: Integer; a3: AnsiChar; a4: Integer): LongWord;
var
  v4: PAnsiChar;
  v5, v6: Integer;
  v7, v13, v14, v15: Byte;
  v8: Byte;
  v9, v10, v12: LongWord;
  v16: LongWord;
begin
  v4 := a1;
  v16 := 0;
  v5 := StrLen(a1);
  v6 := 0;

  if v5 <= 0 then
  begin
    Result := 0;
    Exit;
  end;

  v13 := 0;
  v14 := 0;
  v7 := 15 * a4;
  v15 := 17 * Byte(a3);

  repeat
    v8 := Byte(UpCase(AnsiChar(v4[v6])));
    v9 := v16 + Encode[v8];

    if a2 <> 0 then
    begin
      v10 := Encode[v7] + Encode[v15] +
             Encode[Byte(v8 + 47)] * (Encode[Byte(v8 + 13)] xor v9);
      Result := Encode[v14] + v10;
      v16 := Encode[v14] + v10;
    end
    else
    begin
      v12 := Encode[v7] + Encode[v15] +
             Encode[Byte(v8 + 23)] * (Encode[Byte(v8 + 63)] xor v9);
      Result := Encode[v13] + v12;
      v16 := Encode[v13] + v12;
    end;

    v14 := v14 + 19;
    Inc(v6);
    v15 := v15 + 9;
    v7 := v7 + 13;
    v13 := v13 + 7;
    v4 := a1;
  until v6 >= v5;
end;

procedure w9c1;
var
  k0: Byte;
  al: Byte;
  eax: LongWord;
begin
  while True do
  begin
    k0 := Random($FF);

    al := k0;
    al := al xor k[6];
    k0xork6 := al;

    eax := al;
    eax := eax xor $18;
    eax := eax + $3D;
    eax := eax xor $A7;
    eeaaxx1 := eax and $FF;

    if (eeaaxx1 <> 0) and (eeaaxx1 >= 10) then
    begin
      k[0] := k0;
      Break;
    end;
  end;
end;

procedure w9c2;
var
  k1, k2: Byte;
  al: Byte;
  eax, ecx: LongWord;
  cx: Word;
begin
  while True do
  begin
    k1 := Random($FF);
    k2 := Random($FF);

    al := k1 xor k[7];
    ecx := al;
    eax := $100;
    cx := ecx and $FFFF;
    cx := cx * Word(eax);

    al := k2 xor k[5];
    k2xork5 := al;
    eax := al;
    ecx := cx + eax;

    eessii1 := ecx and $FFFF;
    eax := ecx and $FFFF;
    ecx := $B;
    eax := eax xor $7892;
    eax := eax + $4D30;
    eax := eax xor $3421;
    eax := eax and $FFFF;

    eeddxx := eax mod ecx;
    eeaaxx2 := eax div ecx;

    if (eeddxx = 0) and (eeaaxx2 <> 0) and (eeaaxx2 = $3E7) then
    begin
      k[1] := k1;
      k[2] := k2;
      Break;
    end;
  end;
end;

procedure Reg9C(const a1: PAnsiChar);
var
  En: LongWord;
  edx: LongWord;
  EnDl, r8, r10, r18: Byte;
begin
  En := Encde(a1, 1, #0, $3E7);

  edx := En;
  EnDl := edx and $FF;
  r8 := (edx shr 8) and $FF;
  r10 := (edx shr 16) and $FF;
  r18 := (edx shr 24) and $FF;

  k[4] := EnDl;
  k[5] := r8;
  k[6] := r10;
  k[7] := r18;

  w9c1;
  w9c2;

  Writeln(Format('%2.2X%2.2X-%2.2X9C-%2.2X%2.2X-%2.2X%2.2X',
    [k[0], k[1], k[2], k[4], k[5], k[6], k[7]]));
end;

procedure RegFC(const a1: PAnsiChar);
var
  En: LongWord;
  edx: LongWord;
  EnDl, r8, r10, r18: Byte;
  eeccxx, eeaaxx: LongWord;
  k0, k1, k2: Byte;
  ecx, eax: LongWord;
  edx2: LongWord;
begin
  En := Encde(a1, 0, #$FF, 1);

  edx := En;
  EnDl := edx and $FF;
  r8 := (edx shr 8) and $FF;
  r10 := (edx shr 16) and $FF;
  r18 := (edx shr 24) and $FF;

  k[4] := EnDl;
  k[5] := r8;
  k[6] := r10;
  k[7] := r18;

  while True do
  begin
    k2 := Random($FF);
    k1 := Random($FF);
    k0 := Random($FF);

    ecx := k2 shl 8;
    eax := k1;
    ecx := ecx + eax;
    ecx := ecx shl 8;
    eax := k0;
    ecx := ecx + eax;
    ecx := ecx xor En;
    ecx := ecx xor $22C078;
    ecx := ecx - $2C175;
    ecx := ecx xor $FFE53167;
    ecx := ecx and $FFFFFF;

    eax := $F0F0F0F1;

    // 模拟 64位乘法
    edx2 := (ecx * eax) shr 32;
    edx2 := edx2 shr 4;

    eax := edx2 shl 4;
    eax := eax + edx2;

    eeaaxx := eax;
    eeccxx := ecx;

    if eeccxx = eeaaxx then
    begin
      k[0] := k0;
      k[1] := k1;
      k[2] := k2;
      Break;
    end;
  end;

  Writeln(Format('%2.2X%2.2X-%2.2XFC-%2.2X%2.2X-%2.2X%2.2X',
    [k[0], k[1], k[2], k[4], k[5], k[6], k[7]]));
end;

var
  Username: array[0..99] of AnsiChar;
  id: Integer;
  input: string;
begin
  Randomize;

  while True do
  begin
    Write('请输入您的用户名称：');
    Readln(input);

    // 解析输入
    if Pos(' ', input) > 0 then
    begin
      StrPCopy(Username, Copy(input, 1, Pos(' ', input) - 1));
      id := StrToIntDef(Copy(input, Pos(' ', input) + 1, Length(input)), 0);
    end
    else
    begin
      StrPCopy(Username, input);
      id := 0;
    end;

    case id of
      0: Reg9C(Username);
      1: RegFC(Username);
      2: Exit;
    end;
  end;
end.

论坛上好像还没有Delphi版本的，算是填补空白吧。


Keygen.rar (22.41 KB, 下载次数: 166)

2026-2-11 21:22 上传

点击文件名下载附件

还是D7编译出来的最小，只有45K，打包一下还有23K。

wolaikaoyan

#include <iostream>
#include <string>
#include <array>
#include <cctype>
#include <cstring>
#include <random>
#include <cstdint>
#include <cstdio>

using uint8 = uint8_t;
using uint32 = uint32_t;
using uint64 = uint64_t;

static std::array<uint8, 8> k = { 0x11, 0x22, 0x33, 0x9C, 0x55, 0x66, 0x77, 0x88 };

static const std::array<uint32, 256> Encode = {
        0x39CB44B8,0x23754F67,0x5F017211,0x3EBB24DA,0x351707C6,0x63F9774B,0x17827288,0x0FE74821,
        0x5B5F670F,0x48315AE8,0x785B7769,0x2B7A1547,0x38D11292,0x42A11B32,0x35332244,0x77437B60,
        0x1EAB3B10,0x53810000,0x1D0212AE,0x6F0377A8,0x43C03092,0x2D3C0A8E,0x62950CBF,0x30F06FFA,
        0x34F710E0,0x28F417FB,0x350D2F95,0x5A361D5A,0x15CC060B,0x0AFD13CC,0x28603BCF,0x3371066B,
        0x30CD14E4,0x175D3A67,0x6DD66A13,0x2D3409F9,0x581E7B82,0x76526B99,0x5C8D5188,0x2C857971,
        0x15F51FC0,0x68CC0D11,0x49F55E5C,0x275E4364,0x2D1E0DBC,0x4CEE7CE3,0x32555840,0x112E2E08,
        0x6978065A,0x72921406,0x314578E7,0x175621B7,0x40771DBF,0x3FC238D6,0x4A31128A,0x2DAD036E,
        0x41A069D6,0x25400192,0x00DD4667,0x6AFC1F4F,0x571040CE,0x62FE66DF,0x41DB4B3E,0x3582231F,
        0x55F6079A,0x1CA70644,0x1B1643D2,0x3F7228C9,0x5F141070,0x3E1474AB,0x444B256E,0x537050D9,
        0x0F42094B,0x2FD820E6,0x778B2E5E,0x71176D02,0x7FEA7A69,0x5BB54628,0x19BA6C71,0x39763A99,
        0x178D54CD,0x01246E88,0x3313537E,0x2B8E2D17,0x2A3D10BE,0x59D10582,0x37A163DB,0x30D6489A,
        0x6A215C46,0x0E1C7A76,0x1FC760E7,0x79B80C65,0x27F459B4,0x799A7326,0x50BA1782,0x2A116D5C,
        0x63866E1B,0x3F920E3C,0x55023490,0x55B56089,0x2C391FD1,0x2F8035C2,0x64FD2B7A,0x4CE8759A,
        0x518504F0,0x799501A8,0x3F5B2CAD,0x38E60160,0x637641D8,0x33352A42,0x51A22C19,0x085C5851,
        0x032917AB,0x2B770AC7,0x30AC77B3,0x2BEC1907,0x035202D0,0x0FA933D3,0x61255DF3,0x22AD06BF,
        0x58B86971,0x5FCA0DE5,0x700D6456,0x56A973DB,0x5AB759FD,0x330E0BE2,0x5B3C0DDD,0x495D3C60,
        0x53BD59A6,0x4C5E6D91,0x49D9318D,0x103D5079,0x61CE42E3,0x7ED5121D,0x14E160ED,0x212D4EF2,
        0x270133F0,0x62435A96,0x1FA75E8B,0x6F092FBE,0x4A000D49,0x57AE1C70,0x004E2477,0x561E7E72,
        0x468C0033,0x5DCC2402,0x78507AC6,0x58AF24C7,0x0DF62D34,0x358A4708,0x3CFB1E11,0x2B71451C,
        0x77A75295,0x56890721,0x0FEF75F3,0x120F24F1,0x01990AE7,0x339C4452,0x27A15B8E,0x0BA7276D,
        0x60DC1B7B,0x4F4B7F82,0x67DB7007,0x4F4A57D9,0x621252E8,0x20532CFC,0x6A390306,0x18800423,
        0x19F3778A,0x462316F0,0x56AE0937,0x43C2675C,0x65CA45FD,0x0D604FF2,0x0BFD22CB,0x3AFE643B,
        0x3BF67FA6,0x44623579,0x184031F8,0x32174F97,0x4C6A092A,0x5FB50261,0x01650174,0x33634AF1,
        0x712D18F4,0x6E997169,0x5DAB7AFE,0x7C2B2EE8,0x6EDB75B4,0x5F836FB6,0x3C2A6DD6,0x292D05C2,
        0x052244DB,0x149A5F4F,0x5D486540,0x331D15EA,0x4F456920,0x483A699F,0x3B450F05,0x3B207C6C,
        0x749D70FE,0x417461F6,0x62B031F1,0x2750577B,0x29131533,0x588C3808,0x1AEF3456,0x0F3C00EC,
        0x7DA74742,0x4B797A6C,0x5EBB3287,0x786558B8,0x00ED4FF2,0x6269691E,0x24A2255F,0x62C11F7E,
        0x2F8A7DCD,0x643B17FE,0x778318B8,0x253B60FE,0x34BB63A3,0x5B03214F,0x5F1571F4,0x1A316E9F,
        0x7ACF2704,0x28896838,0x18614677,0x1BF569EB,0x0BA85EC9,0x6ACA6B46,0x1E43422A,0x514D5F0E,
        0x413E018C,0x307626E9,0x01ED1DFA,0x49F46F5A,0x461B642B,0x7D7007F2,0x13652657,0x6B160BC5,
        0x65E04849,0x1F526E1C,0x5A0251B6,0x2BD73F69,0x2DBF7ACD,0x51E63E80,0x5CF2670F,0x21CD0A03,
        0x5CFF0261,0x33AE061E,0x3BB6345F,0x5D814A75,0x257B5DF4,0x0A5C2C5B,0x16A45527,0x16F23945
};

static std::mt19937 rng((std::random_device())());
static std::uniform_int_distribution<int> dist8(0, 255);

// Encde(const a1: PAnsiChar; a2: Integer; a3: AnsiChar; a4: Integer): LongWord;
uint32 Encde(const char* a1, int a2, unsigned char a3, int a4) {
        const char* v4 = a1;
        uint32 v16 = 0;
        int v5 = (int)std::strlen(a1);
        int v6 = 0;
        if (v5 <= 0) return 0;

        uint8 v13 = 0;
        uint8 v14 = 0;
        uint8 v7 = static_cast<uint8>((15 * a4) & 0xFF);
        uint8 v15 = static_cast<uint8>((17 * a3) & 0xFF);

        while (v6 < v5) {
                uint8 v8 = static_cast<uint8>(std::toupper(static_cast<unsigned char>(v4[v6])));
                uint32 v9 = v16 + Encode[v8];

                uint32 resultVal;
                if (a2 != 0) {
                        uint32 v10 = Encode[v7] + Encode[v15] +
                                Encode[static_cast<uint8>(v8 + 47)] * (Encode[static_cast<uint8>(v8 + 13)] ^ v9);
                        resultVal = Encode[v14] + v10;
                        v16 = Encode[v14] + v10;
                }
                else {
                        uint32 v12 = Encode[v7] + Encode[v15] +
                                Encode[static_cast<uint8>(v8 + 23)] * (Encode[static_cast<uint8>(v8 + 63)] ^ v9);
                        resultVal = Encode[v13] + v12;
                        v16 = Encode[v13] + v12;
                }

                v14 = static_cast<uint8>((v14 + 19) & 0xFF);
                v6++;
                v15 = static_cast<uint8>((v15 + 9) & 0xFF);
                v7 = static_cast<uint8>((v7 + 13) & 0xFF);
                v13 = static_cast<uint8>((v13 + 7) & 0xFF);
        }
        return v16;
}

uint8 k0xork6 = 0, k1xork7 = 0, k2xork5 = 0;
int eeddxx = 0;
uint8 eeaaxx1 = 0;
int eeaaxx2 = 0;
int eessii1 = 0;

// w9c1
void w9c1() {
        while (true) {
                uint8 k0 = static_cast<uint8>(dist8(rng));
                uint8 al = static_cast<uint8>(k0 ^ k[6]);
                k0xork6 = al;
                uint32 eax = al;
                eax = eax ^ 0x18;
                eax = eax + 0x3D;
                eax = eax ^ 0xA7;
                eeaaxx1 = static_cast<uint8>(eax & 0xFF);

                if ((eeaaxx1 != 0) && (eeaaxx1 >= 10)) {
                        k[0] = k0;
                        break;
                }
        }
}

// w9c2
void w9c2() {
        while (true) {
                uint8 k1 = static_cast<uint8>(dist8(rng));
                uint8 k2 = static_cast<uint8>(dist8(rng));

                uint8 al = static_cast<uint8>(k1 ^ k[7]);
                uint32 ecx = al;
                // cx := ecx and $FFFF; cx := cx * Word(eax) with eax = $100
                uint32 cx = static_cast<uint32>((ecx & 0xFFFF) * uint16_t(0x100)); // effectively al * 256

                al = static_cast<uint8>(k2 ^ k[5]);
                k2xork5 = al;
                uint32 eax = al;
                ecx = cx + eax;

                eessii1 = static_cast<int>(ecx & 0xFFFF);
                eax = ecx & 0xFFFF;
                ecx = 0xB;
                eax = eax ^ 0x7892;
                eax = eax + 0x4D30;
                eax = eax ^ 0x3421;
                eax = eax & 0xFFFF;

                eeddxx = static_cast<int>(eax % ecx);
                eeaaxx2 = static_cast<int>(eax / ecx);

                if ((eeddxx == 0) && (eeaaxx2 != 0) && (eeaaxx2 == 0x3E7)) {
                        k[1] = k1;
                        k[2] = k2;
                        break;
                }
        }
}

void Reg9C(const char* a1) {
        uint32 En = Encde(a1, 1, 0x00, 0x3E7);
        uint32 edx = En;
        uint8 EnDl = static_cast<uint8>(edx & 0xFF);
        uint8 r8 = static_cast<uint8>((edx >> 8) & 0xFF);
        uint8 r10 = static_cast<uint8>((edx >> 16) & 0xFF);
        uint8 r18 = static_cast<uint8>((edx >> 24) & 0xFF);

        k[4] = EnDl; k[5] = r8; k[6] = r10; k[7] = r18;

        w9c1();
        w9c2();

        char buf[64];
        std::snprintf(buf, sizeof(buf), "%02X%02X-%02X9C-%02X%02X-%02X%02X",
                k[0], k[1], k[2], k[4], k[5], k[6], k[7]);
        std::puts(buf);
}

void RegFC(const char* a1) {
        uint32 En = Encde(a1, 0, 0xFF, 1);
        uint32 edx = En;
        uint8 EnDl = static_cast<uint8>(edx & 0xFF);
        uint8 r8 = static_cast<uint8>((edx >> 8) & 0xFF);
        uint8 r10 = static_cast<uint8>((edx >> 16) & 0xFF);
        uint8 r18 = static_cast<uint8>((edx >> 24) & 0xFF);

        k[4] = EnDl; k[5] = r8; k[6] = r10; k[7] = r18;

        while (true) {
                uint8 k2 = static_cast<uint8>(dist8(rng));
                uint8 k1 = static_cast<uint8>(dist8(rng));
                uint8 k0 = static_cast<uint8>(dist8(rng));

                uint32 ecx = (static_cast<uint32>(k2) << 16) | (static_cast<uint32>(k1) << 8) | static_cast<uint32>(k0);
                ecx = ecx ^ En;
                ecx = ecx ^ 0x22C078;
                ecx = (ecx - 0x2C175);
                ecx = ecx ^ 0xFFE53167;
                ecx = ecx & 0xFFFFFF; // keep 24-bit

                uint32 eaxConst = 0xF0F0F0F1u;

                // 模拟 64位乘法高32位
                uint64 mul = uint64(ecx) * uint64(eaxConst);
                uint64 edx2 = (mul >> 32);
                edx2 = (edx2 >> 4);

                uint32 eax = static_cast<uint32>((edx2 << 4) + edx2); // edx2*17

                uint32 eeaaxx = eax;
                uint32 eeccxx = ecx;

                if (eeccxx == eeaaxx) {
                        k[0] = k0; k[1] = k1; k[2] = k2;
                        break;
                }
        }

        char buf[64];
        std::snprintf(buf, sizeof(buf), "%02X%02X-%02XFC-%02X%02X-%02X%02X",
                k[0], k[1], k[2], k[4], k[5], k[6], k[7]);
        std::puts(buf);
}

int main() {
        std::string input;
        // 已使用 std::mt19937 随机种子初始化

        while (true) {
                std::cout << "请输入您的用户名称：";
                if (!std::getline(std::cin, input)) break;

                std::string username;
                int id = 0;
                auto pos = input.find(' ');
                if (pos != std::string::npos) {
                        username = input.substr(0, pos);
                        try {
                                id = std::stoi(input.substr(pos + 1));
                        }
                        catch (...) {
                                id = 0;
                        }
                }
                else {
                        username = input;
                        id = 0;
                }

                if (id == 0) {
                        Reg9C(username.c_str());
                }
                else if (id == 1) {
                        RegFC(username.c_str());
                }
                else if (id == 2) {
                        break;
                }
                else {
                        // 其他 id 默认再请求一次
                        std::cout << "未知的 id，输入 0 生成 9C，1 生成 FC，2 退出。\n";
                }
        }

        return 0;
}

goldharp

沙发，支持，很棒！

l261178929

大神出马!!

雾都孤尔

还是大佬厉害，感谢分享。

dork

010 Editor拥有网络验证，所以仅有注册码是不够的

塞北的雪

大佬威武~~

shashaliuzi

这个软件我记得是有网络效验的。光有注册码肯定不行的。

snakegao

感谢楼主分享，辛苦

chishingchan

感觉 id 的值总是等于 0 ！

wolaikaoyan

牛逼，谢谢大佬