Computer Chess Biggest Liar

[thorstenczub]

i am not defending vas rajlich .
i am against stoning and witchhunts.

vas rajlich participated with his program on championships where you are only allowed to participate with YOUR OWN program.

IMO we are human beeings. and because we are , we should not stone people like the religious people all over the world have done it in the 2000 years of history.

So anti-cloning, but also anti-talking-about-it (because that would be a witch hunt)? Sure sure...

jb

there are many ways of TALKING.

you can talk with somebody, interview somebody. or you can
waterboard him to find out the truth.

[Jeremy Bernstein]

no matter if he did the crime or not.

Of course he did "the crime". Just look at the output comparisons posted between Robbo 08g3 and Houdini 1: there is no room for doubt. They are (in many cases) identical.

Your obsession with religion and mass murder as points of comparison makes normal discussion about this stuff really difficult, though.

Jeremy

[Prima]

no matter if he did the crime or not.

Of course he did "the crime". Just look at the output comparisons posted between Robbo 08g3 and Houdini 1: there is no room for doubt. They are (in many cases) identical.

Your obsession with religion and mass murder as points of comparison makes normal discussion about this stuff really difficult, though.

Jeremy

This is my assertion, based on the CCC thread illustrating evaluation similarities between RobboLito and Houdini. Bottome line is, RH lied and makes no attempt to set the record straight relative to Houdini's code make up. But for some reason, thorstenczub equates observation of facts and the calling a spade-a-spade with religion.

[veritas]

Houdart wins title of scummiest 2 faced plagiarizing liar with comparative ease now

anyone remember him posting "i will post source code as soon as i have "cleaned it up " ?

off shore accounts ,fort knox and houdinis encryption are shining examples of the lengths thieves go to to protect there ill gotten gains
btw his Aquarium updated houdini PRO 2b , is a poor ( already available for FREE *** despite his encryption )that struggles to match its predecessor , be interesting to see if the evaluation bug is fixed given how chess OK boasts how strong Aquarium is in this area , it is its big selling point

perhaps alter ego Astroboy will comment


***Thank you Venus & Azzad

[Uly]

Religious discussion has been moved here:

http://www.open-chess.org/viewtopic.php?f=38&t=1653

[Jeremy Bernstein]

Peter:
Robbolito is GPL
Only the first unclear Igorit sources are PD

Frank,

Not for the first time, I'm afraid that you are very badly informed.

For a Robbolito source code without any license, you have to look no further than the Ippolit web site: http://ippolit.wikispaces.com/RobboLito .

You will find Robbolito version 0.085f1 with Italian/Albanian (?) file names, variables etc. I have no idea who created this release, but I doubt that it was Norman. It may be the person that identifies himself as "Roberto Pescatore" (= "Bobby Fischer" - so probably not his real name) on the Ippolit web site.

The so-called "GPL-licensed" version Norman released later is virtually identical to this 0.085f1 version, if you inspect the source codes you will find no changes other than translating files and variables to English and reorganizing spaces.

Cheers,
Robert

Robert:

RobboLito 0.085f1 uses long long integers to represent 64-bit numbers in it's UCI output:
TRASMISSIONE ("info time %lld nodes %lld nps %lld cpuload %d\n", t, NODOS, nps * 1000, (int) ((double) u / (double) x * 1000.0))

In the 15 GPL'd RobboLitos I released, I typedef(ed) an unsigned 64-bit integer type (called I64u) specifically for this purpose:

From RobboLito 0.085g3
"info time %I64u nodes %I64u nps %I64u cpuload %u"

When examining Houdini_w32_1CPU.exe (build 2010-05-16), I find:
"info time %I64u nodes %I64u nps %I64u cpuload %u"

Can you please explain this?

I know I can... I didn't realize that you had defined that type for your builds, Norman. Someone should compile all of this information on a single website. The fact that it's all scattered around causes much of it to be missed.

Jeremy

[kingliveson]

The competition is pretty stiff if you asked me. So Robert said there are no IPPOLIT codes in Houdini...

Again, Houdini is RobboLito modified.

Shall we start from main and compare Houdini 1.0 (build 2010-05-15) to RobboLito? Some of the differences you will see if you looked at the assembly/disassembly are due to slight modification and combined routines, compiler, and optimization flags.

Here is Houdini's main():

Code: Select all

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v3; // ecx@1
  int v4; // eax@1
  DWORD v5; // ecx@1
  struct _SYSTEM_INFO SystemInfo; // [sp+4h] [bp-24h]@1

  sub_12A8B5A("Houdini w32 1_CPU\nbuild %d-%.2d-%.2d \nby Robert Houdart\n", 2010);
  v4 = sub_12A87BF(v3);
  fflush((FILE *)(v4 + 32));
  GetSystemInfo(&SystemInfo);
  v5 = SystemInfo.dwNumberOfProcessors;
  dword_17A6878 = SystemInfo.dwNumberOfProcessors;
  if ( (signed __int32)SystemInfo.dwNumberOfProcessors > 1 )
    v5 = 1;
  dword_12BCED0 = v5;
  dword_13040C8 = 0;
  if ( (signed int)v5 > 0 )
  {
    dword_13040C8 = (int)_aligned_malloc(0x200000u, 0x40u);
    memset((void *)dword_13040C8, 0, 0x200000u);
  }
  sub_128F0D0(128);
  memset32(word_177B368, 134219776, 0x200u);
  sub_1289310();
  sub_12A1F80();
  _cfltcvt_init();
  sub_12A8340();
  sub_128F760();
  sub_12A40A0();
  sub_12A74B0(1);
  while ( 1 )
    sub_12A6470();
}

For comparison, here are 3 different builds of RobboLito

085g3 (Intel):

Code: Select all

int __cdecl main(int argc, const char **argv, const char **envp)
{
  unsigned int v3; // eax@1
  __m128i v4; // xmm0@1

  __intel_new_proc_init(0);
  sub_428FF0();
  dword_4886C4 = (int)malloc(0x200000u);
  sub_435970((void *)dword_4886C4, 0, 0x200000u);
  sub_434DD0(128);
  v3 = 0;
  v4 = _mm_shuffle_epi32(_mm_cvtsi32_si128(0x8000800u), 0);
  do
  {
    _mm_store_si128((__m128i *)&xmmword_79E720[2 * v3 / 0x10], v4);
    _mm_store_si128((__m128i *)&xmmword_79E730[2 * v3 / 0x10], v4);
    _mm_store_si128((__m128i *)&xmmword_79E740[2 * v3 / 0x10], v4);
    _mm_store_si128((__m128i *)&xmmword_79E750[2 * v3 / 0x10], v4);
    v3 += 32;
  }
  while ( v3 < 0x400 );
  sub_40CF30();
  sub_423210();
  sub_41A3E0();
  sub_433A10();
  sub_426CF0();
  sub_428E50(1u);
  while ( 1 )
    sub_428560();
}

085g3 (MS):

Code: Select all

int __cdecl main(int argc, const char **argv, const char **envp)
{
  FILE *v3; // eax@1
  int v4; // edx@1
  int v5; // ecx@1

  printf("RobboLito 0.085g3 w32\nOct 10 2011 23:41:06\nwindows version by kranium and sentinel\n");
  v3 = _iob_func();
  fflush(v3 + 1);
  dword_47B628 = (int)malloc(0x200000u);
  memset((void *)dword_47B628, 0, 0x200000u);
  sub_427560(v5, v4);
  memset32(&word_62B1C0, 134219776, 0x200u);
  sub_403320();
  sub_41A5F0();
  sub_412C60();
  sub_427180();
  sub_41CEA0();
  sub_420230();
  while ( 1 )
    sub_41EC00();
}

009:

Code: Select all

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v3; // ecx@1
  int v4; // eax@1
  signed int v5; // esi@1
  int v6; // [sp+0h] [bp-8h]@0

  sub_4274E8(
    (int)"RobboLito 0.09 w32\nDec 31 2009 16:51:46\nbasic windows version by kranium, improved by sentinel\n",
    v6);
  v4 = sub_42714D(v3);
  fflush((FILE *)(v4 + 32));
  dword_44CBB0 = (int)malloc(0x200000u);
  memset((void *)dword_44CBB0, 0, 0x200000u);
  sub_408530(128);
  memset32(&word_6FA420, 134219776, 0x200u);
  sub_409630();
  sub_41FD30();
  sub_418870();
  v5 = 0;
  do
    sub_426BF0(v5++);
  while ( v5 < 419904 );
  sub_422920();
  sub_425740();
  while ( 1 )
    sub_424130();
}

Here is RobboLIto's main() (main.c):

Code: Select all

int main()
    {
    show_version();
    pawn_zobrist_initialization();
    initialization_zobrist(128);
    history_reset();
    initialization_capture();
    pile_initialization();
    pawn_initialization();
    initialization_value();
    static_initialization();
    game_new(TRUE);

    while( 1 )
        input_console();
    return 0;
    }

As I stated earlier, I wasnt planning on doing this, and if at all, not until maybe December, but in the main time, some additional info:

Houdini calls show_version() (utils.c):

Code: Select all

void show_version()
    {
    char *startup_banner =
        "" NAME "\n"
        "" __DATE__ " " __TIME__ "\n"
        "windows version by kranium and sentinel\n";

    printf(startup_banner);
	fflush(stdout);
    }

The date format has been modified slightly in Houdini and the text, "build," added:

Code: Select all

Houdini w32 1_CPU
build 2010-05-15
by Robert Houdart

RobboLito 0.085g3 w32
Oct 10 2011 22:46:33
windows version by kranium and sentinel

Houdini also calls check_num_CPU() (utils.c):

Code: Select all

int check_num_CPU()
    {
    int num_CPU;
    SYSTEM_INFO sysinfo;
	GetSystemInfo( &sysinfo );
	num_CPU = sysinfo.dwNumberOfProcessors;
	return num_CPU;
    }

The above is just a generic way of getting the number of CPUs in Windows OS. What Houdini does here is set the number of CPU to 1 if the system has more.

Houdini Initializes pawnhash:

Code: Select all

  {
    dword_13040C8 = (int)_aligned_malloc(0x200000u, 0x40u);
    memset((void *)dword_13040C8, 0, 2097152u);
  }

RobboLito's pawn_zobrist_initialization() (main.c):

Code: Select all

static void pawn_zobrist_initialization()
    {
    pawn_zobrist = malloc(list_pawn_number * sizeof(type_pawn_value));
    memset(pawn_zobrist, 0, list_pawn_number * sizeof(type_pawn_value));
    }

Houdini then calls initialization_zobrist(). Hash size in the RobboLito version Norm mentioned is left unchanged in Houdini sub_128F0D0(128):

Code: Select all

int __cdecl sub_128F0D0(int a1)
{
  int v6; // esi@1
  int v7; // edi@1
  size_t v8; // esi@3
  int result; // eax@3

  __asm { bsr     eax, [esp+arg_0] }
  v6 = ((1 << _EAX) & 0xFFF) << 16;
  dword_12BCFA0 = v6;
  dword_12BCFA4 = 0;
  v7 = 16 * (unsigned __int64)(unsigned int)v6 >> 20;
  dword_13040C0 = v6 - 4;
  if ( byte_17B3648 )
    _aligned_free(Memory);
  v8 = 16 * v6;
  byte_17B3648 = 1;
  Memory = _aligned_malloc(v8, 0x40u);
  memset(Memory, 0, v8);
  memset(&unk_1304AC0, 0, 0x100000u);
  result = v7;
  dword_13040CC = 0;
  return result;
}

RobboLito's initialization_zobrist() (zobrist.c):

Code: Select all

int initialization_zobrist( int mb )
    {
    YEARS = 0;
    zobrist_dimension = ((1 << BSR(mb)) << 20) / sizeof(type_zobrist);

    if( zobrist_dimension > 0x100000000 )
        zobrist_dimension = 0x100000000;
    mb = (zobrist_dimension * sizeof(type_zobrist)) >> 20;
    list_hide = zobrist_dimension - 4;

    if( zobrist_initialization_flag )
        free(list_zobrist);
    zobrist_initialization_flag = TRUE;
    list_zobrist = malloc(zobrist_dimension * sizeof(type_zobrist));
    zobrist_free();
    return mb;
    }

Houdini call history_reset:

Code: Select all

 memset32(word_177B368, 134219776, 0x200u);

RobboLito:

Code: Select all

memset32(&word_62B1C0, 134219776, 0x200u);

Houdini initializes capture:

Code: Select all

signed int __cdecl sub_1289310()
{
  signed int result; // eax@1

  dword_17B14CC = -836763648;
  dword_17B150C = -836763648;
  dword_17B14C8 = -970981376;
  dword_17B1508 = -970981376;
  result = 3188719616;
  dword_17B1400 = 0xC0200000u;
  dword_17B1440 = -1089470464;
  dword_17B1404 = 0xC0200000u;
  dword_17B1444 = -1089470464;
  dword_17B140C = -803209216;
  dword_17B144C = -819986432;
  dword_17B154C = -853540864;
  dword_17B158C = -871366656;
  dword_17B148C = -889192448;
  dword_17B1408 = -937426944;
  dword_17B1448 = -954204160;
  dword_17B1548 = -988807168;
  dword_17B1588 = -1006632960;
  dword_17B1488 = -1023410176;
  dword_17B14C0 = 3188719616;
  dword_17B1500 = 3188719616;
  dword_17B1540 = -1124073472;
  dword_17B1580 = -1140850688;
  dword_17B1480 = -1157627904;
  dword_17B14C4 = 3188719616;
  dword_17B1504 = 3188719616;
  dword_17B1544 = -1124073472;
  dword_17B1584 = -1140850688;
  dword_17B1484 = -1157627904;
  dword_17B13F8 = -1205862400;
  dword_17B1438 = -1223688192;
  dword_17B14B8 = -1240465408;
  dword_17B14F8 = -1240465408;
  dword_17B1538 = -1258291200;
  dword_17B1578 = -1275068416;
  dword_17B1478 = -1291845632;
  dword_17B13F4 = -1341128704;
  dword_17B1434 = -1358954496;
  dword_17B14B4 = -1375731712;
  dword_17B14F4 = -1375731712;
  dword_17B1534 = -1392508928;
  dword_17B1574 = -1409286144;
  dword_17B1474 = -1426063360;
  dword_17B1450 = 117440512;
  dword_17B13D0 = 100696064;
  dword_17B1410 = 83918848;
  dword_17B1490 = 67141632;
  dword_17B14D0 = 67141632;
  dword_17B1510 = 50364416;
  dword_17B1550 = 33587200;
  dword_17B15EC = -803209216;
  dword_17B162C = -819986432;
  dword_17B16AC = -836763648;
  dword_17B16EC = -836763648;
  dword_17B172C = -853540864;
  dword_17B176C = -871366656;
  dword_17B166C = -889192448;
  dword_17B15E8 = -937426944;
  dword_17B1628 = -954204160;
  dword_17B16A8 = -970981376;
  dword_17B16E8 = -970981376;
  dword_17B1728 = -988807168;
  dword_17B1768 = -1006632960;
  dword_17B1668 = -1023410176;
  dword_17B15E0 = -1071644672;
  dword_17B1620 = -1089470464;
  dword_17B16A0 = 3188719616;
  dword_17B1660 = -1157627904;
  dword_17B1664 = -1157627904;
  dword_17B1698 = -1240465408;
  dword_17B16D8 = -1240465408;
  dword_17B1720 = -1124073472;
  dword_17B1724 = -1124073472;
  dword_17B1760 = -1140850688;
  dword_17B1764 = -1140850688;
  dword_17B16E0 = 3188719616;
  dword_17B15E4 = -1071644672;
  dword_17B1624 = -1089470464;
  dword_17B16A4 = 3188719616;
  dword_17B16E4 = 3188719616;
  dword_17B15D8 = -1205862400;
  dword_17B1618 = -1223688192;
  dword_17B1718 = -1258291200;
  dword_17B1758 = -1275068416;
  dword_17B1658 = -1291845632;
  dword_17B15D4 = -1341128704;
  dword_17B1614 = -1358954496;
  dword_17B1694 = -1375731712;
  dword_17B16D4 = -1375731712;
  dword_17B1714 = -1392508928;
  dword_17B1754 = -1409286144;
  dword_17B1654 = -1426063360;
  dword_17B1650 = 117440512;
  dword_17B15D0 = 100696064;
  dword_17B1610 = 83918848;
  dword_17B1690 = 67141632;
  dword_17B16D0 = 67141632;
  dword_17B1710 = 50364416;
  dword_17B1750 = 33587200;
  return result;
}

RobboLito's capture initialization:

Code: Select all

signed int __cdecl sub_403320()
{
  signed int result; // eax@1

  dword_43A654 = -836763648;
  dword_43A694 = -836763648;
  dword_43A650 = -970981376;
  dword_43A690 = -970981376;
  result = -1106247680;
  dword_43A588 = -1071644672;
  dword_43A5C8 = -1089470464;
  dword_43A6C8 = -1124073472;
  dword_43A58C = -1071644672;
  dword_43A5CC = -1089470464;
  dword_43A6CC = -1124073472;
  dword_43A594 = -803209216;
  dword_43A5D4 = -819986432;
  dword_43A6D4 = -853540864;
  dword_43A714 = -871366656;
  dword_43A590 = -937426944;
  dword_43A5D0 = -954204160;
  dword_43A6D0 = -988807168;
  dword_43A710 = -1006632960;
  dword_43A648 = -1106247680;
  dword_43A688 = -1106247680;
  dword_43A708 = -1140850688;
  dword_43A64C = -1106247680;
  dword_43A68C = -1106247680;
  dword_43A70C = -1140850688;
  dword_43A580 = -1205862400;
  dword_43A5C0 = -1223688192;
  dword_43A640 = -1240465408;
  dword_43A680 = -1240465408;
  dword_43A6C0 = -1258291200;
  dword_43A700 = -1275068416;
  dword_43A57C = -1341128704;
  dword_43A5BC = -1358954496;
  dword_43A63C = -1375731712;
  dword_43A67C = -1375731712;
  dword_43A6BC = -1392508928;
  dword_43A6FC = -1409286144;
  dword_43A614 = -889192448;
  dword_43A610 = -1023410176;
  dword_43A608 = -1157627904;
  dword_43A60C = -1157627904;
  dword_43A600 = -1291845632;
  dword_43A5FC = -1426063360;
  dword_43A5D8 = 117440512;
  dword_43A558 = 100696064;
  dword_43A598 = 83918848;
  dword_43A618 = 67141632;
  dword_43A658 = 67141632;
  dword_43A698 = 50364416;
  dword_43A6D8 = 33587200;
  dword_43A774 = -803209216;
  dword_43A7B4 = -819986432;
  dword_43A834 = -836763648;
  dword_43A874 = -836763648;
  dword_43A8B4 = -853540864;
  dword_43A8F4 = -871366656;
  dword_43A770 = -937426944;
  dword_43A7B0 = -954204160;
  dword_43A830 = -970981376;
  dword_43A870 = -970981376;
  dword_43A8B0 = -988807168;
  dword_43A8F0 = -1006632960;
  dword_43A768 = -1071644672;
  dword_43A7A8 = -1089470464;
  dword_43A828 = -1106247680;
  dword_43A868 = -1106247680;
  dword_43A8A8 = -1124073472;
  dword_43A8E8 = -1140850688;
  dword_43A820 = -1240465408;
  dword_43A860 = -1240465408;
  dword_43A81C = -1375731712;
  dword_43A85C = -1375731712;
  dword_43A8EC = -1140850688;
  dword_43A76C = -1071644672;
  dword_43A7AC = -1089470464;
  dword_43A82C = -1106247680;
  dword_43A86C = -1106247680;
  dword_43A8AC = -1124073472;
  dword_43A760 = -1205862400;
  dword_43A7A0 = -1223688192;
  dword_43A8A0 = -1258291200;
  dword_43A8E0 = -1275068416;
  dword_43A75C = -1341128704;
  dword_43A79C = -1358954496;
  dword_43A89C = -1392508928;
  dword_43A8DC = -1409286144;
  dword_43A7F4 = -889192448;
  dword_43A7F0 = -1023410176;
  dword_43A7E8 = -1157627904;
  dword_43A7EC = -1157627904;
  dword_43A7E0 = -1291845632;
  dword_43A7DC = -1426063360;
  dword_43A7D8 = 117440512;
  dword_43A758 = 100696064;
  dword_43A798 = 83918848;
  dword_43A818 = 67141632;
  dword_43A858 = 67141632;
  dword_43A898 = 50364416;
  dword_43A8D8 = 33587200;
  return result;
}

RobboLito initialization_capture() (nit.gen.h):

Code: Select all

void initialization_capture()
    {
    capture_value[count_pawn_white][count_queen_black] = (0xd0 << 24) + (0x02 << 20);
    capture_value[count_knight_white][count_queen_black] = (0xcf << 24) + (0x02 << 20);
    capture_value[count_clear_white][count_queen_black] = (0xce << 24) + (0x02 << 20);
    capture_value[count_dark_white][count_queen_black] = (0xce << 24) + (0x02 << 20);
    capture_value[count_rook_white][count_queen_black] = (0xcd << 24) + (0x02 << 20);
    capture_value[count_queen_white][count_queen_black] = (0xcc << 24) + (0x01 << 20);

    capture_value[count_pawn_white][count_rook_black] = (0xc8 << 24) + (0x02 << 20);
    capture_value[count_knight_white][count_rook_black] = (0xc7 << 24) + (0x02 << 20);
    capture_value[count_clear_white][count_rook_black] = (0xc6 << 24) + (0x02 << 20);
    capture_value[count_dark_white][count_rook_black] = (0xc6 << 24) + (0x02 << 20);
    capture_value[count_rook_white][count_rook_black] = (0xc5 << 24) + (0x01 << 20);
    capture_value[count_queen_white][count_rook_black] = (0xc4 << 24) + (0x00 << 20);

    capture_value[count_pawn_white][count_clear_black] = (0xc0 << 24) + (0x02 << 20);
    capture_value[count_knight_white][count_clear_black] = (0xbf << 24) + (0x01 << 20);
    capture_value[count_clear_white][count_clear_black] = (0xbe << 24) + (0x01 << 20);
    capture_value[count_dark_white][count_clear_black] = (0xbe << 24) + (0x01 << 20);
    capture_value[count_rook_white][count_clear_black] = (0xbd << 24) + (0x00 << 20);
    capture_value[count_queen_white][count_clear_black] = (0xbc << 24) + (0x00 << 20);

    capture_value[count_pawn_white][count_dark_black] = (0xc0 << 24) + (0x02 << 20);
    capture_value[count_knight_white][count_dark_black] = (0xbf << 24) + (0x01 << 20);
    capture_value[count_clear_white][count_dark_black] = (0xbe << 24) + (0x01 << 20);
    capture_value[count_dark_white][count_dark_black] = (0xbe << 24) + (0x01 << 20);
    capture_value[count_rook_white][count_dark_black] = (0xbd << 24) + (0x00 << 20);
    capture_value[count_queen_white][count_dark_black] = (0xbc << 24) + (0x00 << 20);

    capture_value[count_pawn_white][count_knight_black] = (0xb8 << 24) + (0x02 << 20);
    capture_value[count_knight_white][count_knight_black] = (0xb7 << 24) + (0x01 << 20);
    capture_value[count_clear_white][count_knight_black] = (0xb6 << 24) + (0x01 << 20);
    capture_value[count_dark_white][count_knight_black] = (0xb6 << 24) + (0x01 << 20);
    capture_value[count_rook_white][count_knight_black] = (0xb5 << 24) + (0x00 << 20);
    capture_value[count_queen_white][count_knight_black] = (0xb4 << 24) + (0x00 << 20);

    capture_value[count_pawn_white][count_pawn_black] = (0xb0 << 24) + (0x01 << 20);
    capture_value[count_knight_white][count_pawn_black] = (0xaf << 24) + (0x00 << 20);
    capture_value[count_clear_white][count_pawn_black] = (0xae << 24) + (0x00 << 20);
    capture_value[count_dark_white][count_pawn_black] = (0xae << 24) + (0x00 << 20);
    capture_value[count_rook_white][count_pawn_black] = (0xad << 24) + (0x00 << 20);
    capture_value[count_queen_white][count_pawn_black] = (0xac << 24) + (0x00 << 20);

    capture_value[count_king_white][count_queen_black] = (0xcb << 24) + (0x00 << 20);
    capture_value[count_king_white][count_rook_black] = (0xc3 << 24) + (0x00 << 20);
    capture_value[count_king_white][count_clear_black] = (0xbb << 24) + (0x00 << 20);
    capture_value[count_king_white][count_dark_black] = (0xbb << 24) + (0x00 << 20);
    capture_value[count_king_white][count_knight_black] = (0xb3 << 24) + (0x00 << 20);
    capture_value[count_king_white][count_pawn_black] = (0xab << 24) + (0x00 << 20);

    capture_value[count_king_white][0] = (0x07 << 24) + (0x00 << 15);
    capture_value[count_pawn_white][0] = (0x06 << 24) + (0x01 << 15);
    capture_value[count_knight_white][0] = (0x05 << 24) + (0x01 << 15);
    capture_value[count_clear_white][0] = (0x04 << 24) + (0x01 << 15);
    capture_value[count_dark_white][0] = (0x04 << 24) + (0x01 << 15);
    capture_value[count_rook_white][0] = (0x03 << 24) + (0x01 << 15);
    capture_value[count_queen_white][0] = (0x02 << 24) + (0x01 << 15);

    capture_value[count_pawn_black][count_queen_white] = (0xd0 << 24) + (0x02 << 20);
    capture_value[count_knight_black][count_queen_white] = (0xcf << 24) + (0x02 << 20);
    capture_value[count_clear_black][count_queen_white] = (0xce << 24) + (0x02 << 20);
    capture_value[count_dark_black][count_queen_white] = (0xce << 24) + (0x02 << 20);
    capture_value[count_rook_black][count_queen_white] = (0xcd << 24) + (0x02 << 20);
    capture_value[count_queen_black][count_queen_white] = (0xcc << 24) + (0x01 << 20);

    capture_value[count_pawn_black][count_rook_white] = (0xc8 << 24) + (0x02 << 20);
    capture_value[count_knight_black][count_rook_white] = (0xc7 << 24) + (0x02 << 20);
    capture_value[count_clear_black][count_rook_white] = (0xc6 << 24) + (0x02 << 20);
    capture_value[count_dark_black][count_rook_white] = (0xc6 << 24) + (0x02 << 20);
    capture_value[count_rook_black][count_rook_white] = (0xc5 << 24) + (0x01 << 20);
    capture_value[count_queen_black][count_rook_white] = (0xc4 << 24) + (0x00 << 20);

    capture_value[count_pawn_black][count_clear_white] = (0xc0 << 24) + (0x02 << 20);
    capture_value[count_knight_black][count_clear_white] = (0xbf << 24) + (0x01 << 20);
    capture_value[count_clear_black][count_clear_white] = (0xbe << 24) + (0x01 << 20);
    capture_value[count_dark_black][count_clear_white] = (0xbe << 24) + (0x01 << 20);
    capture_value[count_rook_black][count_clear_white] = (0xbd << 24) + (0x00 << 20);
    capture_value[count_queen_black][count_clear_white] = (0xbc << 24) + (0x00 << 20);

    capture_value[count_pawn_black][count_dark_white] = (0xc0 << 24) + (0x02 << 20);
    capture_value[count_knight_black][count_dark_white] = (0xbf << 24) + (0x01 << 20);
    capture_value[count_clear_black][count_dark_white] = (0xbe << 24) + (0x01 << 20);
    capture_value[count_dark_black][count_dark_white] = (0xbe << 24) + (0x01 << 20);
    capture_value[count_rook_black][count_dark_white] = (0xbd << 24) + (0x00 << 20);
    capture_value[count_queen_black][count_dark_white] = (0xbc << 24) + (0x00 << 20);

    capture_value[count_pawn_black][count_knight_white] = (0xb8 << 24) + (0x02 << 20);
    capture_value[count_knight_black][count_knight_white] = (0xb7 << 24) + (0x01 << 20);
    capture_value[count_clear_black][count_knight_white] = (0xb6 << 24) + (0x01 << 20);
    capture_value[count_dark_black][count_knight_white] = (0xb6 << 24) + (0x01 << 20);
    capture_value[count_rook_black][count_knight_white] = (0xb5 << 24) + (0x00 << 20);
    capture_value[count_queen_black][count_knight_white] = (0xb4 << 24) + (0x00 << 20);

    capture_value[count_pawn_black][count_pawn_white] = (0xb0 << 24) + (0x01 << 20);
    capture_value[count_knight_black][count_pawn_white] = (0xaf << 24) + (0x00 << 20);
    capture_value[count_clear_black][count_pawn_white] = (0xae << 24) + (0x00 << 20);
    capture_value[count_dark_black][count_pawn_white] = (0xae << 24) + (0x00 << 20);
    capture_value[count_rook_black][count_pawn_white] = (0xad << 24) + (0x00 << 20);
    capture_value[count_queen_black][count_pawn_white] = (0xac << 24) + (0x00 << 20);

    capture_value[count_king_black][count_queen_white] = (0xcb << 24) + (0x00 << 20);
    capture_value[count_king_black][count_rook_white] = (0xc3 << 24) + (0x00 << 20);
    capture_value[count_king_black][count_clear_white] = (0xbb << 24) + (0x00 << 20);
    capture_value[count_king_black][count_dark_white] = (0xbb << 24) + (0x00 << 20);
    capture_value[count_king_black][count_knight_white] = (0xb3 << 24) + (0x00 << 20);
    capture_value[count_king_black][count_pawn_white] = (0xab << 24) + (0x00 << 20);

    capture_value[count_king_black][0] = (0x07 << 24) + (0x00 << 15);
    capture_value[count_pawn_black][0] = (0x06 << 24) + (0x01 << 15);
    capture_value[count_knight_black][0] = (0x05 << 24) + (0x01 << 15);
    capture_value[count_clear_black][0] = (0x04 << 24) + (0x01 << 15);
    capture_value[count_dark_black][0] = (0x04 << 24) + (0x01 << 15);
    capture_value[count_rook_black][0] = (0x03 << 24) + (0x01 << 15);
    capture_value[count_queen_black][0] = (0x02 << 24) + (0x01 << 15);
    }

Houdini like RobboLito then initializes the board arrays/pile_initialization() (stack.c) and pawn_initialization() (p_value.c).

Houdini's value/material initialization:

Code: Select all

int __cdecl sub_12A8340()
{
  signed int v0; // eax@1
  int v1; // ebp@3
  int v2; // eax@3
  int v3; // ebx@3
  int v4; // ecx@3
  int v5; // eax@3
  int v6; // ecx@3
  int v7; // edi@3
  int v8; // ecx@3
  int v9; // ecx@3
  int v10; // ecx@3
  int v11; // eax@3
  int v12; // esi@3
  int v13; // ST28_4@3
  int v14; // esi@3
  __int16 v15; // dx@3
  __int16 v16; // dh@1@3
  int v17; // ecx@3
  int v18; // eax@3
  __int64 v19; // qax@4
  int v20; // eax@4
  __int64 v21; // qax@6
  __int64 v22; // qax@7
  int v23; // eax@12
  int result; // eax@12
  int v25; // [sp-38h] [bp-90h]@10
  int v26; // [sp-34h] [bp-8Ch]@10
  int v27; // [sp-30h] [bp-88h]@10
  int v28; // [sp-2Ch] [bp-84h]@10
  int v29; // [sp-28h] [bp-80h]@10
  int v30; // [sp-24h] [bp-7Ch]@10
  int v31; // [sp-20h] [bp-78h]@10
  int v32; // [sp-1Ch] [bp-74h]@10
  int v33; // [sp-18h] [bp-70h]@10
  int v34; // [sp-14h] [bp-6Ch]@10
  int v35; // [sp-10h] [bp-68h]@10
  int v36; // [sp-Ch] [bp-64h]@10
  int v37; // [sp-8h] [bp-60h]@10
  int v38; // [sp-4h] [bp-5Ch]@10
  int v39; // [sp+10h] [bp-48h]@3
  int v40; // [sp+14h] [bp-44h]@3
  int v41; // [sp+18h] [bp-40h]@3
  int v42; // [sp+1Ch] [bp-3Ch]@3
  int v43; // [sp+20h] [bp-38h]@3
  int v44; // [sp+20h] [bp-38h]@4
  int v45; // [sp+24h] [bp-34h]@3
  int v46; // [sp+28h] [bp-30h]@3
  int v47; // [sp+2Ch] [bp-2Ch]@3
  int v48; // [sp+30h] [bp-28h]@3
  int v49; // [sp+34h] [bp-24h]@3
  int v50; // [sp+38h] [bp-20h]@3
  signed int v51; // [sp+3Ch] [bp-1Ch]@1
  signed int v52; // [sp+40h] [bp-18h]@1
  int v53; // [sp+50h] [bp-8h]@3

  v0 = 0;
  v51 = 0;
  v52 = &word_14414FC;
  while ( 1 )
  {
    v1 = v0 % 2;
    v2 = v0 / 2;
    v3 = v2 % 2;
    v4 = v2 / 2;
    v5 = v2 / 2 / 3;
    v41 = v4 - 3 * v5;
    v6 = v5;
    v5 /= 3;
    v39 = v6 - 3 * v5;
    v7 = v5 % 2;
    v5 /= 2;
    v8 = v5 % 2;
    v5 /= 2;
    v49 = v8;
    v9 = v5 % 2;
    v5 /= 2;
    v46 = v9;
    v45 = v5 % 2;
    v10 = v5 / 2;
    v11 = v5 / 2 / 3;
    v42 = v10 - 3 * v11;
    v40 = v11 % 3;
    v12 = v11 / 3 / 9;
    v47 = v46 + v45;
    v48 = v12 % 9;
    v13 = v12 % 9;
    v14 = v7 + v49;
    v50 = v11 / 3 % 9;
    v53 = sub_12A8150(v50, v42, v7 + v49, v41, v1, v13, v11 % 3, v46 + v45, v39, v3);
    v17 = v42 + v40 + v7 + v49 + v41 + v39 + 2 * (v3 + v1) + v46 + v45 + 2 * (v41 + v39 + 2 * (v3 + v1));
    v43 = (v53 < 0) + SHIWORD(v53);
    v18 = v43 < 0;
    if ( v17 > 8 )
    {
      if ( v17 > 24 )
      {
        v22 = v53 * (v17 - 24) + v43 * (32 - v17);
        v20 = ((BYTE4(v22) & 7) + v22) >> 3;
      }
      else
      {
        v21 = v43 * (v17 - 8) + (v18 + v15) * (24 - v17);
        v20 = ((BYTE4(v21) & 0xF) + v21) >> 4;
      }
      v44 = v20;
    }
    else
    {
      v19 = v17 * (v18 + v15) + (8 - v17) * ((v18 + v15 < 0) + v16);
      v20 = ((BYTE4(v19) & 7) + v19) >> 3;
      v44 = v20;
    }
    if ( v20 <= 0 )
    {
      v38 = v1;
      v37 = v41;
      v36 = v49;
      v35 = v7;
      v34 = v7 + v49;
      v33 = v42;
      v32 = v50;
      v31 = v3;
      v30 = v39;
      v29 = v45;
      v28 = v46;
      v27 = v46 + v45;
      v26 = v40;
      v25 = v48;
    }
    else
    {
      v38 = v3;
      v37 = v39;
      v36 = v45;
      v35 = v46;
      v34 = v46 + v45;
      v33 = v40;
      v32 = v48;
      v31 = v1;
      v30 = v41;
      v29 = v49;
      v28 = v7;
      v27 = v7 + v49;
      v26 = v42;
      v25 = v50;
    }
    v23 = sub_12A7B30(v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38);
    *(v52 - 4) = (((1717986919i64 * v44 * v23) >> 32) >> 2) + (((1717986919i64 * v44 * v23) >> 32) >> 31);
    *(v52 - 2) = sub_12A79E0(v50, v42, v14, v7, v49, v41, v1, v40, v47, v46, v45, v39, v3);
    *v52 = 0;
    result = sub_12A7640(v52, v50, v42, v14, v7, v49, v41, v1, v48, v40, v47, v46, v45, v39, v3);
    ++v51;
    *(v52 - 1) = result;
    v52 += 6;
    if ( v52 >= dword_16A867C )
      break;
    v0 = v51;
  }
  return result;
}

RobboLito's initialization_value()/Material_calculation( int c) (values.c):

Code: Select all

static void Material_calculation( int c )
    {
    int white_queen, black_queen, white_rook, black_rook, white_clear, black_clear, white_dark, black_dark,
        white_knight, black_knight, white_pawn, black_pawn, n, value, white_bishop, black_bishop;
    int ca, white_load, black_load, phase, va1, va2, va3, va4;
    uint64 va;
    n = c;
    white_queen = n % 2;
    n /= 2;
    black_queen = n % 2;
    n /= 2;
    white_rook = n % 3;
    n /= 3;
    black_rook = n % 3;
    n /= 3;
    white_clear = n % 2;
    n /= 2;
    white_dark = n % 2;
    n /= 2;
    black_clear = n % 2;
    n /= 2;
    black_dark = n % 2;
    n /= 2;
    white_knight = n % 3;
    n /= 3;
    black_knight = n % 3;
    n /= 3;
    white_pawn = n % 9;
    n /= 9;
    black_pawn = n % 9;
    white_bishop = white_clear + white_dark;
    black_bishop = black_clear + black_dark;
    va =
        value_value(white_pawn, white_knight, white_bishop, white_clear, white_dark, white_rook, white_queen,
            black_pawn, black_knight, black_bishop, black_clear, black_dark, black_rook, black_queen);
    phase =
        PHASE_MINOR * (white_knight + white_bishop + black_knight + black_bishop)
            + PHASE_ROOK * (white_rook + black_rook) + PHASE_QUEEN * (white_queen + black_queen);
    va1 = va & 0xffff;
    va2 = ((va >> 16) & 0xffff) + (va1 > 0x8000);
    va1 = (sint16)va1;
    va3 = ((va >> 32) & 0xffff) + (va2 > 0x8000);
    va2 = (sint16)va2;
    va4 = ((va >> 48) & 0xffff) + (va3 > 0x8000);
    va3 = (sint16)va3;
    va4 = (sint16)va4;

    if( phase < 8 )
        {
        va4 *= 8 - phase;
        va3 *= phase;
        va = va3 + va4;
        value = ((int)va) / 8;
        }
    else if( phase < 24 )
        {
        va3 *= 24 - phase;
        va2 *= phase - 8;
        va = va2 + va3;
        value = ((int)va) / 16;
        }
    else
        {
        va2 *= 32 - phase;
        va1 *= phase - 24;
        va = va1 + va2;
        value = ((int)va) / 8;
        }
    white_load =
        load_white(white_pawn, white_knight, white_bishop, white_clear, white_dark, white_rook, white_queen, black_pawn,
            black_knight, black_bishop, black_clear, black_dark, black_rook, black_queen);
    black_load =
        load_black(white_pawn, white_knight, white_bishop, white_clear, white_dark, white_rook, white_queen, black_pawn,
            black_knight, black_bishop, black_clear, black_dark, black_rook, black_queen);

    if( value > 0 )
        ca = white_load;
    else
        ca = black_load;
    value *= ca;
    value /= 10;
    MATERIAL[c].value = value;
    MATERIAL[c].sign =
        sengo_initialization(white_pawn, white_knight, white_bishop, white_clear, white_dark, white_rook, white_queen,
            black_pawn, black_knight, black_bishop, black_clear, black_dark, black_rook, black_queen);
    MATERIAL[c].flags =
        flags_initialization(white_pawn, white_knight, white_bishop, white_clear, white_dark, white_rook, white_queen,
            black_pawn, black_knight, black_bishop, black_clear, black_dark, black_rook, black_queen);
    }

There's probably a good answer for these:

Houdini:

Code: Select all

int __cdecl sub_12A74B0(char a1)
{
  int result; // eax@1
  void *v2; // edx@2
  int v3; // edi@3

  memset(byte_1405380, 0, 0x40u);
  memset(&unk_14074F8, 0, 0x3A000u);
  dword_1405388 = 16843009;
  unk_140538C = 16843009;
  dword_14053B0 = 151587081;
  dword_14053B4 = 151587081;
  byte_1405387 = 6;
  byte_1405380[0] = 6;
  byte_14053BF = 14;
  byte_14053B8 = 14;
  dword_14054F0 = &unk_14074F8;
  byte_14054EA = 1;
  word_1407511 = 15;
  byte_14075DB = 0;
  word_1405383 = 775;
  byte_1405386 = 2;
  byte_1405381 = 2;
  byte_1405382 = 5;
  byte_1405385 = 4;
  unk_14053B9 = 185535498;
  word_14053BD = 2573;
  dword_1304AB0 = 1000;
  dword_1304ABC = 0;
  byte_1304AAC = 1;
  dword_14054EC = 0;
  result = sub_12A65A0();
  if ( a1 )
  {
    memset(Memory, 0, 16 * dword_12BCFA0);
    memset(&unk_1304AC0, 0, 0x100000u);
    _mm_storel_pd(&qword_12C40C0, 0);
    memcpy(&unk_12C40C8, &qword_12C40C0, 0x3FFF8u);
    dword_13040CC = 0;
    memset32(word_177B368, 134219776, 0x200u);
    v2 = word_177C270;
    do
    {
      result = 0;
      memset(v2, 0, 0x1FFCu);
      v3 = (v2 + 8188);
      v2 = v2 + 8192;
      *v3 = 0;
    }
    while ( v2 < dword_179C270 );
  }
  return result;
}

RobboLito:

Code: Select all

int __cdecl sub_420230()
{
  int result; // eax@1

  memset(&byte_6913C0, 0, 0x40u);
  memset(&unk_62BBC0, 0, 0x8000u);
  dword_6913C8 = 16843009;
  unk_6913CC = 16843009;
  dword_6913F0 = 151587081;
  dword_6913F4 = 151587081;
  byte_6913C7 = 6;
  byte_6913C0 = 6;
  byte_6913FF = 14;
  byte_6913F8 = 14;
  dword_68EF00 = (int)&unk_62BBC0;
  byte_6914A0 = 1;
  byte_62BBDC = 15;
  word_62BBDD = 0;
  word_6913C3 = 775;
  byte_6913C6 = 2;
  byte_6913C1 = 2;
  byte_6913C2 = 5;
  byte_6913C5 = 4;
  unk_6913F9 = 185535498;
  word_6913FD = 2573;
  dword_47B5E4 = 1000;
  dword_47B5E8 = 0;
  byte_48BAA0 = 1;
  dword_48E100 = 0;
  sub_41EDD0();
  memset(Dst, 0, 16 * dword_42E018);
  memset(&unk_6914C0, 0, 0x100000u);
  dword_43AEA0 = 0;
  dword_43AEA4 = 0;
  memcpy(&unk_43AEA8, &dword_43AEA0, 0x3FFF8u);
  memset32(&word_62B1C0, 134219776, 0x200u);
  result = 0;
  memset(&word_64BE60, 0, 0x1FFE0u);
  dword_6913A0 = 0;
  unk_6913A4 = 0;
  return result;
}

Perhaps there's an explanation for this exact match?

Houdini

Code: Select all

int __thiscall sub_12A6470(void *this)
{
  char *v1; // eax@1
  char v2; // cl@2
  char *v4; // [sp-2h] [bp-1000Ch]@1
  char v5; // [sp+2h] [bp-10008h]@1
  _BYTE v6[3]; // [sp+3h] [bp-10007h]@3
  unsigned int v7; // [sp+10006h] [bp-4h]@1

  v7 = &v5 ^ __security_cookie;
  v4 = sub_12A87BF(this);
  fgets(&v5, 65536, v4);
  v1 = &v5;
  do
    v2 = *v1++;
  while ( v2 );
  LOBYTE((&v4)[v1 - v6 + 3]) = 0;
  v4 = &v5;
  return sub_12A6020(v4);
}

RobboLito:

Code: Select all

int __thiscall sub_424130(void *this)
{
  char *v1; // eax@1
  char v2; // cl@2
  char *v4; // [sp-2h] [bp-1000Ch]@1
  char v5; // [sp+2h] [bp-10008h]@1
  _BYTE v6[3]; // [sp+3h] [bp-10007h]@3
  unsigned int v7; // [sp+10006h] [bp-4h]@1

  v7 = (unsigned int)&v5 ^ __security_cookie;
  v4 = (char *)sub_42714D(this);
  fgets(&v5, 65536, (FILE *)v4);
  v1 = &v5;
  do
    v2 = *v1++;
  while ( v2 );
  LOBYTE((&v4)[v1 - v6 + 3]) = 0;
  v4 = &v5;
  return sub_423B90(v4);
}

input_console() (uci.c):

Code: Select all

void input_console()
    {
    char string[65536];
    fgets(string, 65536, stdin);
    string[strlen(string) - 1] = 0;
    parse(string);
    }

Is there really much point to go through the eval and search? In any case, this was probably a huge waste of time as am sure most reasonable people recognize that Houdini base code is RobboLito.

[Jeremy Bernstein]

*** genius ***

Someone needs to post the link to your post around, although some might consider that a witch hunt. That's pretty definitive evidence.

Not that it matters. ChessOK will continue to sell it, Houdart will continue to deny it, folks will continue to buy it...

jb

[hyatt]

And the Rybka folks will use that as a justification for "rybka is OK" also, of course...

[Jeremy Bernstein]

And the Rybka folks will use that as a justification for "rybka is OK" also, of course...

Fascinating is that, not 6 months ago, the very mention of "Houdini" on the Rybka forum was grounds for immediate removal of a post. Now Houdini is essentially replacing Rybka as the official engine of ChessOK, or at least providing strong competition for consumer's attention. Houdini 2 is powering ChessBomb.com. And so on and so forth.

The entire story stinks. I'm pleased to see another engine displace Rybka at the top, just for the sake of competition. But I can't really say that I'm happy with the way it's happened. According to Victor, ChessOK's line is approximately "if we didn't market it, someone else would".

And although I'm confident that, if the Rybka case goes to court, Vas will lose, I don't see any way for Houdart to be taken to task. He saw an opportunity ("ownerless" software, a stagnant market) and took it, and it seems like he's gotten away with it.

Jeremy