LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: AddPawnCapMove
static void AddPawnCapMove( const S_BOARD *pos, const int from, const int to, const int cap, S_MOVELIST *list ) {    
    int side=pos->side;
    if(RanksBrd[from] == (side?RANK_2:RANK_7)) {
        AddCaptureMove(pos, MOVE(from,to,cap,(side?bQ:wQ),0), list);
        AddCaptureMove(pos, MOVE(from,to,cap,(side?bR:wR),0), list);
        AddCaptureMove(pos, MOVE(from,to,cap,(side?bB:wB),0), list);
        AddCaptureMove(pos, MOVE(from,to,cap,(side?bN:wN),0), list);
    } else {
        AddCaptureMove(pos, MOVE(from,to,cap,EMPTY,0), list);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq %r8, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl 0x200(%rax), %eax
movl %eax, 0x4(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x22b3b(%rip), %rax     # 0x27e30
movl (%rax,%rcx,4), %eax
movl 0x4(%rsp), %esi
movl $0x6, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
cmpl %ecx, %eax
jne 0x541a
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %eax
shll $0x7, %eax
orl %eax, %esi
movl 0x14(%rsp), %eax
shll $0xe, %eax
orl %eax, %esi
movl 0x4(%rsp), %edx
movl $0x5, %eax
movl $0xb, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
shll $0x14, %eax
orl %eax, %esi
orl $0x0, %esi
movq 0x8(%rsp), %rdx
callq 0x54b0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %eax
shll $0x7, %eax
orl %eax, %esi
movl 0x14(%rsp), %eax
shll $0xe, %eax
orl %eax, %esi
movl 0x4(%rsp), %edx
movl $0x4, %eax
movl $0xa, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
shll $0x14, %eax
orl %eax, %esi
orl $0x0, %esi
movq 0x8(%rsp), %rdx
callq 0x54b0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %eax
shll $0x7, %eax
orl %eax, %esi
movl 0x14(%rsp), %eax
shll $0xe, %eax
orl %eax, %esi
movl 0x4(%rsp), %edx
movl $0x3, %eax
movl $0x9, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
shll $0x14, %eax
orl %eax, %esi
orl $0x0, %esi
movq 0x8(%rsp), %rdx
callq 0x54b0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %eax
shll $0x7, %eax
orl %eax, %esi
movl 0x14(%rsp), %eax
shll $0xe, %eax
orl %eax, %esi
movl 0x4(%rsp), %edx
movl $0x2, %eax
movl $0x8, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
shll $0x14, %eax
orl %eax, %esi
orl $0x0, %esi
movq 0x8(%rsp), %rdx
callq 0x54b0
jmp 0x5445
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %eax
shll $0x7, %eax
orl %eax, %esi
movl 0x14(%rsp), %eax
shll $0xe, %eax
orl %eax, %esi
orl $0x0, %esi
orl $0x0, %esi
movq 0x8(%rsp), %rdx
callq 0x54b0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: AddPiece
static void AddPiece(const int sq, S_BOARD *pos, const int pce) {

    
    int col = PieceCol[pce];

        HASH_PCE(pce,sq);
    
    pos->pieces[sq] = pce;

        if(PieceBig[pce]) {
        pos->bigPce[col]++;
    
    } else {
        SETBIT(pos->pawns[col],SQ64(sq));
        SETBIT(pos->pawns[BOTH],SQ64(sq));
    }
    
    pos->material[col] += PieceVal[pce];
    pos->pList[pce][pos->pceNum[pce]++] = sq;
    
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movslq -0x14(%rsp), %rcx
leaq 0x59d7(%rip), %rax      # 0xb360
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rsp)
movslq -0x14(%rsp), %rcx
leaq 0x226f4(%rip), %rax     # 0x28090
imulq $0x3c0, %rcx, %rcx      # imm = 0x3C0
addq %rcx, %rax
movslq -0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rsp), %rax
xorq 0x220(%rax), %rcx
movq %rcx, 0x220(%rax)
movl -0x14(%rsp), %edx
movq -0x10(%rsp), %rax
movslq -0x4(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movslq -0x14(%rsp), %rcx
leaq 0x5f71(%rip), %rax      # 0xb950
cmpl $0x0, (%rax,%rcx,4)
je 0x5a02
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movl 0x25c(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x25c(%rax,%rcx,4)
jmp 0x5a65
movslq -0x4(%rsp), %rcx
leaq 0x9eb2(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x22117(%rip), %rax     # 0x27b30
movq (%rax,%rcx,8), %rdx
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
orq 0x1e0(%rax,%rcx,8), %rdx
movq %rdx, 0x1e0(%rax,%rcx,8)
movslq -0x4(%rsp), %rcx
leaq 0x9e7d(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x220e2(%rip), %rax     # 0x27b30
movq (%rax,%rcx,8), %rcx
movq -0x10(%rsp), %rax
orq 0x1f0(%rax), %rcx
movq %rcx, 0x1f0(%rax)
movslq -0x14(%rsp), %rcx
leaq 0x592f(%rip), %rax      # 0xb3a0
movl (%rax,%rcx,4), %edx
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
addl 0x264(%rax,%rcx,4), %edx
movl %edx, 0x264(%rax,%rcx,4)
movl -0x4(%rsp), %edx
movq -0x10(%rsp), %rax
addq $0xc270, %rax           # imm = 0xC270
movslq -0x14(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq -0x10(%rsp), %rsi
movslq -0x14(%rsp), %rdi
movl 0x228(%rsi,%rdi,4), %ecx
movl %ecx, %r8d
addl $0x1, %r8d
movl %r8d, 0x228(%rsi,%rdi,4)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: SearchPosition
static
void SearchPosition(S_BOARD *pos, S_SEARCHINFO *info) {

    int lastMove = pos->history[pos->hisPly-1].move;
    printf("lastMove is %s\n", PrMove(lastMove)) ;
    printf("expected move is %s \n", PrMove(ExpectedMove));
    if((trapMove != NOMOVE) && (lastMove == ExpectedMove))
    {
    printf("playing trap \n");
    printf("bestmove %s \n", PrMove(trapMove));
    trapMove=NOMOVE;
    ExpectedMove=NOMOVE;
    return;
    
    }
    int move=Search(FALSE);
    printf("bestmove %s\n",PrMove(move));    

    ClearForSearch(pos, info);
    info->starttime = GetTimeMs();
    info->depth = MAXDEPTH;
    info->timeset=FALSE;

    MakeMove(pos, move);
    int expectedMove=ProbePvTable(pos);
    if(!expectedMove)
	return;
    ExpectedMove=expectedMove;
    printf("expecting move %s from oponent \n",PrMove(expectedMove));    
    
    MakeMove(pos, expectedMove);
    TrapSearch(pos, info);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x270, %rax            # imm = 0x270
movq 0x20(%rsp), %rcx
movl 0x210(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0x6040
movq %rax, %rsi
leaq 0x5e97(%rip), %rdi      # 0xbd51
movb $0x0, %al
callq 0x1060
movl 0x99e9(%rip), %edi      # 0xf8b0
callq 0x6040
movq %rax, %rsi
leaq 0x5e8b(%rip), %rdi      # 0xbd61
movb $0x0, %al
callq 0x1060
cmpl $0x0, 0x99d0(%rip)      # 0xf8b4
je 0x5f35
movl 0x14(%rsp), %eax
cmpl 0x99c0(%rip), %eax      # 0xf8b0
jne 0x5f35
leaq 0x5e7e(%rip), %rdi      # 0xbd77
movb $0x0, %al
callq 0x1060
movl 0x99ae(%rip), %edi      # 0xf8b4
callq 0x6040
movq %rax, %rsi
leaq 0x5e71(%rip), %rdi      # 0xbd86
movb $0x0, %al
callq 0x1060
movl $0x0, 0x998e(%rip)      # 0xf8b4
movl $0x0, 0x9980(%rip)      # 0xf8b0
jmp 0x5ff5
xorl %edi, %edi
callq 0x61c0
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edi
callq 0x6040
movq %rax, %rsi
leaq 0x5e41(%rip), %rdi      # 0xbd94
movb $0x0, %al
callq 0x1060
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x63e0
callq 0x6000
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movl $0x40, 0x8(%rax)
movq 0x18(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x3c20
movq 0x20(%rsp), %rdi
callq 0x6530
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x5fb4
jmp 0x5ff5
movl 0xc(%rsp), %eax
movl %eax, 0x98f2(%rip)      # 0xf8b0
movl 0xc(%rsp), %edi
callq 0x6040
movq %rax, %rsi
leaq 0x5dd0(%rip), %rdi      # 0xbda1
movb $0x0, %al
callq 0x1060
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x3c20
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x65b0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: PrMove
static
char *PrMove(const int move) {

    static char MvStr[6];
    
    int ff = FilesBrd[FROMSQ(move)];
    int rf = RanksBrd[FROMSQ(move)];
    int ft = FilesBrd[TOSQ(move)];
    int rt = RanksBrd[TOSQ(move)];
    
    int promoted = PROMOTED(move);
    
    if(promoted) {
        char pchar = 'q';
        if(IsKn(promoted)) {
            pchar = 'n';
        } else if(IsRQ(promoted) && !IsBQ(promoted))  {
            pchar = 'r';
        } else if(!IsRQ(promoted) && IsBQ(promoted))  {
            pchar = 'b';
        }
        sprintf(MvStr, "%c%c%c%c%c", ('a'+ff), ('1'+rf), ('a'+ft), ('1'+rt), pchar);
    } else {
        sprintf(MvStr, "%c%c%c%c", ('a'+ff), ('1'+rf), ('a'+ft), ('1'+rt));
    }
    return MvStr;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl 0x24(%rsp), %eax
andl $0x7f, %eax
movslq %eax, %rcx
leaq 0x9a47(%rip), %rax      # 0xfaa0
movl (%rax,%rcx,4), %eax
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
andl $0x7f, %eax
movslq %eax, %rcx
leaq 0x21dbf(%rip), %rax     # 0x27e30
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c(%rsp)
movl 0x24(%rsp), %eax
sarl $0x7, %eax
andl $0x7f, %eax
movslq %eax, %rcx
leaq 0x9a14(%rip), %rax      # 0xfaa0
movl (%rax,%rcx,4), %eax
movl %eax, 0x18(%rsp)
movl 0x24(%rsp), %eax
sarl $0x7, %eax
andl $0x7f, %eax
movslq %eax, %rcx
leaq 0x21d89(%rip), %rax     # 0x27e30
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movl 0x24(%rsp), %eax
sarl $0x14, %eax
andl $0xf, %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x617c
movb $0x71, 0xf(%rsp)
movslq 0x10(%rsp), %rcx
leaq 0x59b8(%rip), %rax      # 0xba90
cmpl $0x0, (%rax,%rcx,4)
je 0x60e5
movb $0x6e, 0xf(%rsp)
jmp 0x613d
movslq 0x10(%rsp), %rcx
leaq 0x5a1f(%rip), %rax      # 0xbb10
cmpl $0x0, (%rax,%rcx,4)
je 0x6110
movslq 0x10(%rsp), %rcx
leaq 0x590d(%rip), %rax      # 0xba10
cmpl $0x0, (%rax,%rcx,4)
jne 0x6110
movb $0x72, 0xf(%rsp)
jmp 0x613b
movslq 0x10(%rsp), %rcx
leaq 0x59f4(%rip), %rax      # 0xbb10
cmpl $0x0, (%rax,%rcx,4)
jne 0x6139
movslq 0x10(%rsp), %rcx
leaq 0x58e2(%rip), %rax      # 0xba10
cmpl $0x0, (%rax,%rcx,4)
je 0x6139
movb $0x62, 0xf(%rsp)
jmp 0x613b
jmp 0x613d
movl 0x20(%rsp), %edx
addl $0x61, %edx
movl 0x1c(%rsp), %ecx
addl $0x31, %ecx
movl 0x18(%rsp), %r8d
addl $0x61, %r8d
movl 0x14(%rsp), %r9d
addl $0x31, %r9d
movsbl 0xf(%rsp), %eax
leaq 0x252db(%rip), %rdi     # 0x2b444
leaq 0x5c52(%rip), %rsi      # 0xbdc2
movl %eax, (%rsp)
movb $0x0, %al
callq 0x10f0
jmp 0x61b1
movl 0x20(%rsp), %edx
addl $0x61, %edx
movl 0x1c(%rsp), %ecx
addl $0x31, %ecx
movl 0x18(%rsp), %r8d
addl $0x61, %r8d
movl 0x14(%rsp), %r9d
addl $0x31, %r9d
leaq 0x252a1(%rip), %rdi     # 0x2b444
leaq 0x5c1a(%rip), %rsi      # 0xbdc4
movb $0x0, %al
callq 0x10f0
leaq 0x2528c(%rip), %rax     # 0x2b444
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: ClearForSearch
static void ClearForSearch(S_BOARD *pos, S_SEARCHINFO *info) {
    
    int index = 0;
    int index2 = 0;
    
    for(index = 0; index < 13; ++index) {
        for(index2 = 0; index2 < BRD_SQ_NUM; ++index2) {
            pos->searchHistory[index][index2] = 0;
        }
    }
    
    for(index = 0; index < 2; ++index) {
        for(index2 = 0; index2 < MAXDEPTH; ++index2) {
            pos->searchKillers[index][index2] = 0;
        }
    }    

    pos->HashTable->overWrite=0;
    pos->HashTable->hit=0;
    pos->HashTable->cut=0;    
    pos->ply = 0;
    
    info->stopped = 0;
    info->nodes = 0;
    info->fh = 0;
    info->fhf = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0xd, -0x14(%rsp)
jge 0x645a
movl $0x0, -0x18(%rsp)
cmpl $0x78, -0x18(%rsp)
jge 0x644b
movq -0x8(%rsp), %rax
addq $0xc5b8, %rax           # imm = 0xC5B8
movslq -0x14(%rsp), %rcx
imulq $0x1e0, %rcx, %rcx      # imm = 0x1E0
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x6411
jmp 0x644d
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x6402
movl $0x0, -0x14(%rsp)
cmpl $0x2, -0x14(%rsp)
jge 0x64b7
movl $0x0, -0x18(%rsp)
cmpl $0x40, -0x18(%rsp)
jge 0x64a8
movq -0x8(%rsp), %rax
addq $0xde18, %rax           # imm = 0xDE18
movslq -0x14(%rsp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x6471
jmp 0x64aa
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x6462
movq -0x8(%rsp), %rax
movl $0x0, 0xc488(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0xc48c(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0xc490(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x20c(%rax)
movq -0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rax)
movq -0x10(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x28(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: ProbePvTable
static
int ProbePvTable(const S_BOARD *pos) {

    int index = pos->posKey % pos->HashTable->numEntries;
    
    if( pos->HashTable->pTable[index].posKey == pos->posKey ) {
        return pos->HashTable->pTable[index].move;
    }
    
    return NOMOVE;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x220(%rax), %rax
movq -0x10(%rsp), %rcx
movslq 0xc480(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq 0xc478(%rax), %rax
movslq -0x14(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x220(%rcx), %rax
jne 0x65a2
movq -0x10(%rsp), %rax
movq 0xc478(%rax), %rax
movslq -0x14(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x65aa
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: GetPvLine
static
int GetPvLine(const int depth, S_BOARD *pos) {


    int move = ProbePvTable(pos);
    int count = 0;
    
    while(move != NOMOVE && count < depth) {
    
    
        if( MoveExists(pos, move) ) {
            MakeMove(pos, move);
            pos->PvArray[count++] = move;
        } else {
            break;
        }        
        move = ProbePvTable(pos);    
    }
    
    while(pos->ply > 0) {
        TakeMove(pos);
    }
    
    return count;
    
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x6530
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x14(%rsp)
movb %al, 0xf(%rsp)
je 0x70ef
movl 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
setl %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x70f9
jmp 0x714e
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x7f20
cmpl $0x0, %eax
je 0x713c
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x3c20
movl 0x14(%rsp), %edx
movq 0x18(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10(%rsp)
movslq %ecx, %rcx
movl %edx, 0xc4b8(%rax,%rcx,4)
jmp 0x713e
jmp 0x714e
movq 0x18(%rsp), %rdi
callq 0x6530
movl %eax, 0x14(%rsp)
jmp 0x70d3
jmp 0x7150
movq 0x18(%rsp), %rax
cmpl $0x0, 0x20c(%rax)
jle 0x716a
movq 0x18(%rsp), %rdi
callq 0x5ad0
jmp 0x7150
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: CheckUp
static void CheckUp(S_SEARCHINFO *info) {
    // .. check if time up, or interrupt from GUI
    if(info->timeset == TRUE && GetTimeMs() > info->stoptime) {
        info->stopped = TRUE;
    }
        
    ReadInput(info);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x7468
callq 0x6000
movq (%rsp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x7468
movq (%rsp), %rax
movl $0x1, 0x20(%rax)
movq (%rsp), %rdi
callq 0x7da0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: IsRepetition
static
int IsRepetition(const S_BOARD *pos) {

    int index = 0;

    for(index = pos->hisPly - pos->fiftyMove; index < pos->hisPly-1; ++index) {    
        if(pos->posKey == pos->history[index].posKey) {
            return TRUE;
        }
    }    
    return FALSE;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movq -0x10(%rsp), %rax
movl 0x210(%rax), %eax
movq -0x10(%rsp), %rcx
subl 0x208(%rcx), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x10(%rsp), %rcx
movl 0x210(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x7500
movq -0x10(%rsp), %rax
movq 0x220(%rax), %rax
movq -0x10(%rsp), %rcx
addq $0x270, %rcx            # imm = 0x270
movslq -0x14(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x10(%rcx), %rax
jne 0x74f1
movl $0x1, -0x4(%rsp)
jmp 0x7508
jmp 0x74f3
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x74a7
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: EvalPosition
static int EvalPosition(const S_BOARD *pos) {

    int pce;
    int pceNum;
    int sq;
    int score = pos->material[WHITE] - pos->material[BLACK];
    if(!pos->pceNum[wP] && !pos->pceNum[bP]) {
        if(MaterialDraw(pos))
            return 0;
    }
    if(pos->material[BLACK]>0)
    {
        
        if (!pos->isCastled[WHITE])
        {
            score -= 20;
        }

        score += EvalWhitePawns(pos);
        score += EvalWhiteKnight(pos);
        score += EvalWhiteBishop(pos);
        score += EvalWhiteRook(pos);
        score += EvalWhiteQueen(pos);

    }
    score += EvalWhiteKing(pos);
    if(pos->material[WHITE]>0)
    {
        if (!pos->isCastled[BLACK])
        {
            score += 20;
        }
        

        score += EvalBlackPawns(pos);
        score += EvalBlackKnight(pos);
        score += EvalBlackBishop(pos);
        score += EvalBlackRook(pos);
        score += EvalBlackQueen(pos);

    }
    
    score += EvalBlackKing(pos);

    if(pos->side == WHITE) {
        return score;
    } else {
        return -score;
    }        
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x264(%rax), %eax
movq 0x18(%rsp), %rcx
subl 0x268(%rcx), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x22c(%rax)
jne 0x756d
movq 0x18(%rsp), %rax
cmpl $0x0, 0x244(%rax)
jne 0x756d
movq 0x18(%rsp), %rdi
callq 0x12e0
cmpl $0x0, %eax
je 0x756b
movl $0x0, 0x24(%rsp)
jmp 0x76b5
jmp 0x756d
movq 0x18(%rsp), %rax
cmpl $0x0, 0x268(%rax)
jle 0x75ee
movq 0x18(%rsp), %rax
cmpl $0x0, 0x218(%rax)
jne 0x7594
movl 0x8(%rsp), %eax
subl $0x14, %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9b90
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x93d0
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9650
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x99a0
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x92b0
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9e20
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x264(%rax)
jle 0x7681
movq 0x18(%rsp), %rax
cmpl $0x0, 0x21c(%rax)
jne 0x7627
movl 0x8(%rsp), %eax
addl $0x14, %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9cd0
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9510
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x97f0
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9a90
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9340
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9f30
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x200(%rax)
jne 0x76ab
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x76b5
xorl %eax, %eax
subl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: MakeNullMove
static    
void MakeNullMove(S_BOARD *pos) {

    pos->ply++;
    pos->history[pos->hisPly].posKey = pos->posKey;

    if(pos->enPas != NO_SQ) HASH_EP;

    pos->history[pos->hisPly].move = NOMOVE;
    pos->history[pos->hisPly].fiftyMove = pos->fiftyMove;
    pos->history[pos->hisPly].enPas = pos->enPas;
    pos->history[pos->hisPly].castlePerm = pos->castlePerm;
    pos->enPas = NO_SQ;

    pos->side ^= 1;
    pos->hisPly++;
    HASH_SIDE;
   
    return;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0x20c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20c(%rax)
movq -0x8(%rsp), %rax
movq 0x220(%rax), %rcx
movq -0x8(%rsp), %rax
addq $0x270, %rax            # imm = 0x270
movq -0x8(%rsp), %rdx
movslq 0x210(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
cmpl $0x63, 0x204(%rax)
je 0x791f
movq -0x8(%rsp), %rax
movslq 0x204(%rax), %rcx
leaq 0x20788(%rip), %rax     # 0x28090
movq (%rax,%rcx,8), %rcx
movq -0x8(%rsp), %rax
xorq 0x220(%rax), %rcx
movq %rcx, 0x220(%rax)
movq -0x8(%rsp), %rax
addq $0x270, %rax            # imm = 0x270
movq -0x8(%rsp), %rcx
movslq 0x210(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movq -0x8(%rsp), %rax
movl 0x208(%rax), %ecx
movq -0x8(%rsp), %rax
addq $0x270, %rax            # imm = 0x270
movq -0x8(%rsp), %rdx
movslq 0x210(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rsp), %rax
movl 0x204(%rax), %ecx
movq -0x8(%rsp), %rax
addq $0x270, %rax            # imm = 0x270
movq -0x8(%rsp), %rdx
movslq 0x210(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rsp), %rax
movl 0x214(%rax), %ecx
movq -0x8(%rsp), %rax
addq $0x270, %rax            # imm = 0x270
movq -0x8(%rsp), %rdx
movslq 0x210(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rsp), %rax
movl $0x63, 0x204(%rax)
movq -0x8(%rsp), %rax
movl 0x200(%rax), %ecx
xorl $0x1, %ecx
movl %ecx, 0x200(%rax)
movq -0x8(%rsp), %rax
movl 0x210(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x210(%rax)
movq 0x2374b(%rip), %rcx     # 0x2b150
movq -0x8(%rsp), %rax
xorq 0x220(%rax), %rcx
movq %rcx, 0x220(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: TakeNullMove
static
void TakeNullMove(S_BOARD *pos) {

    pos->hisPly--;
    pos->ply--;

    if(pos->enPas != NO_SQ) HASH_EP;

    pos->castlePerm = pos->history[pos->hisPly].castlePerm;
    pos->fiftyMove = pos->history[pos->hisPly].fiftyMove;
    pos->enPas = pos->history[pos->hisPly].enPas;

    if(pos->enPas != NO_SQ) HASH_EP;
    pos->side ^= 1;
    HASH_SIDE;
 
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0x210(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x210(%rax)
movq -0x8(%rsp), %rax
movl 0x20c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20c(%rax)
movq -0x8(%rsp), %rax
cmpl $0x63, 0x204(%rax)
je 0x7a85
movq -0x8(%rsp), %rax
movslq 0x204(%rax), %rcx
leaq 0x20622(%rip), %rax     # 0x28090
movq (%rax,%rcx,8), %rcx
movq -0x8(%rsp), %rax
xorq 0x220(%rax), %rcx
movq %rcx, 0x220(%rax)
movq -0x8(%rsp), %rax
addq $0x270, %rax            # imm = 0x270
movq -0x8(%rsp), %rcx
movslq 0x210(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x214(%rax)
movq -0x8(%rsp), %rax
addq $0x270, %rax            # imm = 0x270
movq -0x8(%rsp), %rcx
movslq 0x210(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x208(%rax)
movq -0x8(%rsp), %rax
addq $0x270, %rax            # imm = 0x270
movq -0x8(%rsp), %rcx
movslq 0x210(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x204(%rax)
movq -0x8(%rsp), %rax
cmpl $0x63, 0x204(%rax)
je 0x7b41
movq -0x8(%rsp), %rax
movslq 0x204(%rax), %rcx
leaq 0x20566(%rip), %rax     # 0x28090
movq (%rax,%rcx,8), %rcx
movq -0x8(%rsp), %rax
xorq 0x220(%rax), %rcx
movq %rcx, 0x220(%rax)
movq -0x8(%rsp), %rax
movl 0x200(%rax), %ecx
xorl $0x1, %ecx
movl %ecx, 0x200(%rax)
movq 0x235f4(%rip), %rcx     # 0x2b150
movq -0x8(%rsp), %rax
xorq 0x220(%rax), %rcx
movq %rcx, 0x220(%rax)
retq
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: PickNextMove
static
void PickNextMove(int moveNum, S_MOVELIST *list) {

    S_MOVE temp;
    int index = 0;
    int bestScore = 0;
    int bestNum = moveNum;
    
    for (index = moveNum; index < list->count; ++index) {
        if (list->moves[index].score > bestScore) {
            bestScore = list->moves[index].score;
            bestNum = index;
        }
    }
    temp = list->moves[moveNum];
    list->moves[moveNum] = list->moves[bestNum];
    list->moves[bestNum] = temp;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl 0x800(%rcx), %eax
jge 0x7be7
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl 0x4(%rax,%rcx,8), %eax
cmpl -0x20(%rsp), %eax
jle 0x7bd8
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, -0x24(%rsp)
jmp 0x7bda
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x7b99
movq -0x10(%rsp), %rax
movslq -0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movslq -0x4(%rsp), %rcx
movq -0x10(%rsp), %rdx
movslq -0x24(%rsp), %rsi
movq (%rdx,%rsi,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rsp), %rax
movslq -0x24(%rsp), %rcx
movq -0x18(%rsp), %rdx
movq %rdx, (%rax,%rcx,8)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: StoreHashEntry
static void StoreHashEntry(S_BOARD *pos, const int move, int score, const int flags, const int depth) {
    int index = pos->posKey % pos->HashTable->numEntries;
    
    if( pos->HashTable->pTable[index].posKey == 0) {
        pos->HashTable->newWrite++;
    } else {
        pos->HashTable->overWrite++;
    }
    
    if(score > ISMATE) score += pos->ply;
        else if(score < -ISMATE) score -= pos->ply;
    
    pos->HashTable->pTable[index].move = move;
        pos->HashTable->pTable[index].posKey = pos->posKey;
    pos->HashTable->pTable[index].flags = flags;
    pos->HashTable->pTable[index].score = score;
    pos->HashTable->pTable[index].depth = depth;

}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x220(%rax), %rax
movq -0x8(%rsp), %rcx
movslq 0xc480(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movq 0xc478(%rax), %rax
movslq -0x1c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x7c9d
movq -0x8(%rsp), %rax
movl 0xc484(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc484(%rax)
jmp 0x7cb1
movq -0x8(%rsp), %rax
movl 0xc488(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc488(%rax)
cmpl $0x74f0, -0x10(%rsp)    # imm = 0x74F0
jle 0x7cd0
movq -0x8(%rsp), %rax
movl 0x20c(%rax), %eax
addl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
jmp 0x7cf1
cmpl $0xffff8b10, -0x10(%rsp) # imm = 0xFFFF8B10
jge 0x7cef
movq -0x8(%rsp), %rax
movl 0x20c(%rax), %ecx
movl -0x10(%rsp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rsp)
jmp 0x7cf1
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movq 0xc478(%rax), %rax
movslq -0x1c(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x220(%rax), %rcx
movq -0x8(%rsp), %rax
movq 0xc478(%rax), %rax
movslq -0x1c(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0x14(%rsp), %ecx
movq -0x8(%rsp), %rax
movq 0xc478(%rax), %rax
movslq -0x1c(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x14(%rax)
movl -0x10(%rsp), %ecx
movq -0x8(%rsp), %rax
movq 0xc478(%rax), %rax
movslq -0x1c(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movq 0xc478(%rax), %rax
movslq -0x1c(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: ReadInput
static
void ReadInput(S_SEARCHINFO *info) {
    int bytes;
      char input[256] = "", *endc;

      if (InputWaiting()) {    
        info->stopped = TRUE;
        return;
        }
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x1080
callq 0x7df0
cmpl $0x0, %eax
je 0x7dd9
movq 0x120(%rsp), %rax
movl $0x1, 0x20(%rax)
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: InputWaiting
static
int InputWaiting()
{
  fd_set readfds;
  struct timeval tv;
  FD_ZERO (&readfds);
  FD_SET (fileno(stdin), &readfds);
  tv.tv_sec=0; tv.tv_usec=0;
  select(16, &readfds, 0, 0, &tv);

  return (FD_ISSET(fileno(stdin), &readfds));
}

// Assembly:
subq $0xb8, %rsp
leaq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpq $0x10, %rax
jae 0x7e31
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x7e09
jmp 0x7e33
movq 0x71a6(%rip), %rax      # 0xefe0
movq (%rax), %rdi
callq 0x10b0
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x8(%rsp)
movq 0x717e(%rip), %rax      # 0xefe0
movq (%rax), %rdi
callq 0x10b0
movq 0x8(%rsp), %rcx
movl $0x40, %esi
cltd
idivl %esi
cltq
orq 0x38(%rsp,%rax,8), %rcx
movq %rcx, 0x38(%rsp,%rax,8)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x10, %edi
leaq 0x38(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x28(%rsp), %r8
movq %rcx, %rdx
callq 0x10c0
movq 0x7129(%rip), %rax      # 0xefe0
movq (%rax), %rdi
callq 0x10b0
movl $0x40, %ecx
cltd
idivl %ecx
cltq
movq 0x38(%rsp,%rax,8), %rax
movq %rax, 0x10(%rsp)
movq 0x7106(%rip), %rax      # 0xefe0
movq (%rax), %rdi
callq 0x10b0
movl $0x40, %ecx
cltd
idivl %ecx
movq 0x10(%rsp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: MoveExists
static
int MoveExists(S_BOARD *pos, const int move) {
    
    S_MOVELIST list[1];
        GenerateAllMoves(pos,list,0);
      
        int MoveNum = 0;
    for(MoveNum = 0; MoveNum < list->count; ++MoveNum) {    
       
        if ( !MakeMove(pos,list->moves[MoveNum].move))  {
            continue;
        }        
        TakeMove(pos);
        if(list->moves[MoveNum].move == move) {
            return TRUE;
        }
    }
    return FALSE;
}

// Assembly:
subq $0x828, %rsp            # imm = 0x828
movq %rdi, 0x818(%rsp)
movl %esi, 0x814(%rsp)
movq 0x818(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x45e0
movl $0x0, 0xc(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x810(%rsp), %eax
jge 0x7fbf
movq 0x818(%rsp), %rdi
movslq 0xc(%rsp), %rax
movl 0x10(%rsp,%rax,8), %esi
callq 0x3c20
cmpl $0x0, %eax
jne 0x7f84
jmp 0x7fb2
movq 0x818(%rsp), %rdi
callq 0x5ad0
movslq 0xc(%rsp), %rax
movl 0x10(%rsp,%rax,8), %eax
cmpl 0x814(%rsp), %eax
jne 0x7fb0
movl $0x1, 0x824(%rsp)
jmp 0x7fca
jmp 0x7fb2
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x7f5a
movl $0x0, 0x824(%rsp)
movl 0x824(%rsp), %eax
addq $0x828, %rsp            # imm = 0x828
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: PopMove
static void PopMove(S_MOVELIST *list, int move)
{
    int counter;
    int index=-1;
    for(counter=0;counter<list->count; counter++)
    {
        if(move==list->moves[counter].move)
            index=counter;
    }
    if(index==-1)
        return;
    for(counter=index; counter<list->count-1; counter++)
    {
        list->moves[counter]=list->moves[counter+1];

    }
    list->count --;
    

}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0xffffffff, -0x14(%rsp) # imm = 0xFFFFFFFF
movl $0x0, -0x10(%rsp)
movl -0x10(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x800(%rcx), %eax
jge 0x83f4
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
movslq -0x10(%rsp), %rdx
cmpl (%rcx,%rdx,8), %eax
jne 0x83e5
movl -0x10(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x83e7
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x83b9
cmpl $-0x1, -0x14(%rsp)
jne 0x83fd
jmp 0x845d
movl -0x14(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
movq -0x8(%rsp), %rcx
movl 0x800(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x8449
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rdx
movl -0x10(%rsp), %esi
addl $0x1, %esi
movslq %esi, %rsi
movq (%rdx,%rsi,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x8405
movq -0x8(%rsp), %rax
movl 0x800(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x800(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: PrintPositionalEvals
static
void PrintPositionalEvals(S_BOARD *pos)
{    
    
    int score=0;

    score=EvalWhitePawns(pos);
    printf("White pawn score is %d \n", score);

    score=EvalBlackPawns(pos);        
    printf("Black pawn score is %d \n", score);

    score=EvalWhiteKnight(pos);
    printf("White Knight score is %d \n", score);

    score=EvalBlackKnight(pos);        
    printf("Black knight score is %d \n", score);

    score=EvalWhiteBishop(pos);
    printf("white bishop score is %d \n", score);

    score=EvalBlackBishop(pos);
    printf("Black bishop score is %d \n", score);

    score=EvalWhiteRook(pos);
    printf("white rook score is %d \n", score);

    score=EvalBlackRook(pos);
    printf("Black rook score is %d \n", score);

    score=EvalWhiteQueen(pos);
    printf("white queen score is %d \n", score);

    score=EvalBlackQueen(pos);
    printf("Black queen score is %d \n", score);

    score=EvalWhiteKing(pos);
    printf("white king score is %d \n", score);

    score=EvalBlackKing(pos);
    printf("Black king score is %d \n", score);




}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x9b90
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2ef3(%rip), %rdi      # 0xbefd
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x9cd0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2eec(%rip), %rdi      # 0xbf16
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x93d0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2ee5(%rip), %rdi      # 0xbf2f
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x9510
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2ee0(%rip), %rdi      # 0xbf4a
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x9650
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2edb(%rip), %rdi      # 0xbf65
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x97f0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2ed6(%rip), %rdi      # 0xbf80
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x99a0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2ed1(%rip), %rdi      # 0xbf9b
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x9a90
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2eca(%rip), %rdi      # 0xbfb4
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x92b0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2ec3(%rip), %rdi      # 0xbfcd
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x9340
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2ebd(%rip), %rdi      # 0xbfe7
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x9e20
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2eb7(%rip), %rdi      # 0xc001
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x9f30
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2eb0(%rip), %rdi      # 0xc01a
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: ParsePop
static void ParsePop(char *lineIn, S_MOVELIST *list)
{
    
    lineIn += 8;
    char *ptrChar=lineIn;

    int move=atoi(ptrChar);
    printf("popping move %d \n", move);
    PopMove(list, move);

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x10e0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x2e10(%rip), %rdi      # 0xc03f
movb $0x0, %al
callq 0x1060
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x83a0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Engine.c
// Function: EvalCap
static int EvalCap(char *line, const S_BOARD *pos)
{
	line += 8;
	char *ptrChar=line;
	int move=atoi(ptrChar);
	printf("result is %d \n", EvalCapture(pos, move, NOMOVE));

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x10e0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
xorl %edx, %edx
callq 0x8460
movl %eax, %esi
leaq 0x2db4(%rip), %rdi      # 0xc051
movb $0x0, %al
callq 0x1060
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Queen.c
// Function: EvalWhiteQueen
int EvalWhiteQueen(const S_BOARD *pos)
{
	int pceNum, sq, score=0;
	for(pceNum = 0; pceNum < pos->pceNum[wQ]; ++pceNum) {
		sq = pos->pList[wQ][pceNum];
		if(!(pos->pawns[BOTH] & FileBBMask[FilesBrd[sq]])) {
			score += QueenOpenFile;
		} 
	}	
	return score;

}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x23c(%rcx), %eax
jge 0x9332
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movl 0xc338(%rax,%rcx,4), %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x1f0(%rax), %rax
movslq -0x10(%rsp), %rdx
leaq 0x679d(%rip), %rcx      # 0xfaa0
movslq (%rcx,%rdx,4), %rdx
leaq 0x1d9a2(%rip), %rcx     # 0x26cb0
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
jne 0x9323
movl -0x14(%rsp), %eax
addl $0xa, %eax
movl %eax, -0x14(%rsp)
jmp 0x9325
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x92c5
movl -0x14(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Queen.c
// Function: EvalBlackQueen
int EvalBlackQueen(const S_BOARD *pos)
{
	int pceNum, sq, score=0;
	for(pceNum = 0; pceNum < pos->pceNum[bQ]; ++pceNum) {
		sq = pos->pList[bQ][pceNum];
		if(!(pos->pawns[BOTH] & FileBBMask[FilesBrd[sq]])) {
			score += QueenOpenFile;
		} 
	}	
	return -score;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x254(%rcx), %eax
jge 0x93c2
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movl 0xc428(%rax,%rcx,4), %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x1f0(%rax), %rax
movslq -0x10(%rsp), %rdx
leaq 0x670d(%rip), %rcx      # 0xfaa0
movslq (%rcx,%rdx,4), %rdx
leaq 0x1d912(%rip), %rcx     # 0x26cb0
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
jne 0x93b3
movl -0x14(%rsp), %eax
addl $0xa, %eax
movl %eax, -0x14(%rsp)
jmp 0x93b5
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x9355
xorl %eax, %eax
subl -0x14(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Knight.c
// Function: EvalWhiteKnight
int EvalWhiteKnight(const S_BOARD *pos)
{

	int pceNum, index, sq, sq64, score=0;
	//loop through all the knights
	for(pceNum = 0; pceNum < pos->pceNum[wN]; ++pceNum) {
		sq = pos->pList[wN][pceNum];
		sq64=SQ64(sq);
//knight mobility
		//knight center control check
		score += KnightTable[sq64];
		//knight mobility check
		
		int squares=KnightMobility[sq64]-
			CountBits(WhiteKnightMobilityMask[sq64] & pos->pawns[BLACK]);
		score += (knightMobility*squares);
//knight outpost using bitmasks
		 //the knight needs to be in the enemy half of the board
		if(RanksBrd[sq]>RANK_4)
		{
			//no opposing black pawns to push the knight away, and the knight is supported by a white pawn
			if((pos->pawns[BLACK] & WhiteOutpostMask[sq64])==0 && 
			((WhitePawnSupportMask[sq64] & pos->pawns[WHITE]) != 0))
			{
				//add bonus to this knight for having an outpost
				score += outpost;
			}
		}

				
		
	}
	return score;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x230(%rcx), %eax
jge 0x94ff
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl 0xc2c0(%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movslq 0x14(%rsp), %rcx
leaq 0x64a1(%rip), %rax      # 0xf8c0
movl (%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
movslq 0x10(%rsp), %rcx
leaq 0x2c4e(%rip), %rax      # 0xc080
movl (%rax,%rcx,4), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movslq 0x10(%rsp), %rcx
leaq 0x1cb67(%rip), %rax     # 0x25fb0
movl (%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movslq 0x10(%rsp), %rcx
leaq 0x1dcd4(%rip), %rax     # 0x27130
movq (%rax,%rcx,8), %rdi
movq 0x20(%rsp), %rax
andq 0x1e8(%rax), %rdi
callq 0x1240
movl %eax, %ecx
movl 0x4(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x8(%rsp)
imull $0x3, 0x8(%rsp), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movslq 0x14(%rsp), %rcx
leaq 0x1e99a(%rip), %rax     # 0x27e30
cmpl $0x3, (%rax,%rcx,4)
jle 0x94ed
movq 0x20(%rsp), %rax
movq 0x1e8(%rax), %rax
movslq 0x10(%rsp), %rdx
leaq 0x1de7c(%rip), %rcx     # 0x27330
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
jne 0x94eb
movslq 0x10(%rsp), %rcx
leaq 0x1e266(%rip), %rax     # 0x27730
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
andq 0x1e0(%rcx), %rax
cmpq $0x0, %rax
je 0x94eb
movl 0xc(%rsp), %eax
addl $0xf, %eax
movl %eax, 0xc(%rsp)
jmp 0x94ed
jmp 0x94ef
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x93e9
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Knight.c
// Function: EvalBlackKnight
int EvalBlackKnight(const S_BOARD *pos)
{
	int pceNum, index, sq, sq64, score=0;
//loop through all the knights
	for(pceNum = 0; pceNum < pos->pceNum[bN]; ++pceNum) {
		sq = pos->pList[bN][pceNum];
		sq64=SQ64(sq);
//knight mobility
		//knight center control check
		score += KnightTable[sq64];
		//knight mobility check
		
		int squares=KnightMobility[sq64]-
			CountBits(BlackKnightMobilityMask[sq64] & pos->pawns[WHITE]);
		score += (knightMobility*squares);	
//knight outpost using bitmasks
		 //the knight needs to be in the enemy half of the board
		if(RanksBrd[sq]<RANK_5)
		{
			//no opposing black pawns to push the knight away, and the knight is supported by a white pawn
			if((pos->pawns[WHITE] & BlackOutpostMask[sq64])==0 && 
			((BlackPawnSupportMask[sq64] & pos->pawns[BLACK]) != 0))
			{
				//add bonus to this knight for having an outpost
				score += outpost;
			}
		}

				
		
	}
	return -score;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x248(%rcx), %eax
jge 0x963f
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl 0xc3b0(%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movslq 0x14(%rsp), %rcx
leaq 0x6361(%rip), %rax      # 0xf8c0
movl (%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
movslq 0x10(%rsp), %rcx
leaq 0x2b0e(%rip), %rax      # 0xc080
movl (%rax,%rcx,4), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movslq 0x10(%rsp), %rcx
leaq 0x1ca27(%rip), %rax     # 0x25fb0
movl (%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movslq 0x10(%rsp), %rcx
leaq 0x1cd14(%rip), %rax     # 0x262b0
movq (%rax,%rcx,8), %rdi
movq 0x20(%rsp), %rax
andq 0x1e0(%rax), %rdi
callq 0x1240
movl %eax, %ecx
movl 0x4(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x8(%rsp)
imull $0x3, 0x8(%rsp), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movslq 0x14(%rsp), %rcx
leaq 0x1e85a(%rip), %rax     # 0x27e30
cmpl $0x4, (%rax,%rcx,4)
jge 0x962d
movq 0x20(%rsp), %rax
movq 0x1e0(%rax), %rax
movslq 0x10(%rsp), %rdx
leaq 0x1cebc(%rip), %rcx     # 0x264b0
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
jne 0x962b
movslq 0x10(%rsp), %rcx
leaq 0x1d2a6(%rip), %rax     # 0x268b0
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
andq 0x1e8(%rcx), %rax
cmpq $0x0, %rax
je 0x962b
movl 0xc(%rsp), %eax
addl $0xf, %eax
movl %eax, 0xc(%rsp)
jmp 0x962d
jmp 0x962f
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x9529
xorl %eax, %eax
subl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Bishop.c
// Function: EvalWhiteBishop
int EvalWhiteBishop(const S_BOARD *pos)
{
	int pceNum;
	int sq;
	int index;
	int score=0;
//loop through all the white bishops
	for(pceNum = 0; pceNum < pos->pceNum[wB]; ++pceNum) {
		int mobility=7;
		sq = pos->pList[wB][pceNum];
		int sq64=SQ64(sq);
//the bishop should be on diagonals that control the center
		score += BishopTable[sq64];
		
		//check the diagonal influences
		U64 mask=WhiteBishopForwardMask[sq64][0] & pos->pawns[BOTH];	
		if(mask)
		{
			//int square=(63-__builtin_ctzll(mask));
			int square=FindBit(mask);
			mobility -= (WhiteMaxDiagonalDistance[sq64][0]-DiagonalDistance[sq][square]);
				
		}
 
		U64 mask2=WhiteBishopForwardMask[sq64][1] & pos->pawns[BOTH];		
		if(mask2)
		{
			//int square=(63-__builtin_ctzll(mask));
			int square=FindBit(mask2);
			mobility -= (WhiteMaxDiagonalDistance[sq64][1]-DiagonalDistance[sq64][square]);
		}
		score += mobility * bishopMobility;
		
				
	}
	//bishop pair
	if(pos->pceNum[wB]>1)
		score += BishopPair;

	return score;	
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl $0x0, 0x30(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl 0x234(%rcx), %eax
jge 0x97c6
movl $0x7, 0x2c(%rsp)
movq 0x40(%rsp), %rax
movslq 0x3c(%rsp), %rcx
movl 0xc2e8(%rax,%rcx,4), %eax
movl %eax, 0x38(%rsp)
movslq 0x38(%rsp), %rcx
leaq 0x6219(%rip), %rax      # 0xf8c0
movl (%rax,%rcx,4), %eax
movl %eax, 0x28(%rsp)
movslq 0x28(%rsp), %rcx
leaq 0x2ad6(%rip), %rax      # 0xc190
movl (%rax,%rcx,4), %eax
addl 0x30(%rsp), %eax
movl %eax, 0x30(%rsp)
movslq 0x28(%rsp), %rcx
leaq 0x5ddf(%rip), %rax      # 0xf4b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq 0x40(%rsp), %rcx
andq 0x1f0(%rcx), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x9736
movq 0x20(%rsp), %rdi
callq 0x1280
movl %eax, 0x1c(%rsp)
movslq 0x28(%rsp), %rcx
leaq 0x1c9a2(%rip), %rax     # 0x260b0
movl (%rax,%rcx,8), %ecx
movslq 0x38(%rsp), %rdx
leaq 0x14893(%rip), %rax     # 0x1dfb0
shlq $0x8, %rdx
addq %rdx, %rax
movslq 0x1c(%rsp), %rdx
subl (%rax,%rdx,4), %ecx
movl 0x2c(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x2c(%rsp)
movslq 0x28(%rsp), %rcx
leaq 0x5d6e(%rip), %rax      # 0xf4b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x40(%rsp), %rcx
andq 0x1f0(%rcx), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x97a9
movq 0x10(%rsp), %rdi
callq 0x1280
movl %eax, 0xc(%rsp)
movslq 0x28(%rsp), %rcx
leaq 0x1c930(%rip), %rax     # 0x260b0
movl 0x4(%rax,%rcx,8), %ecx
movslq 0x28(%rsp), %rdx
leaq 0x14820(%rip), %rax     # 0x1dfb0
shlq $0x8, %rdx
addq %rdx, %rax
movslq 0xc(%rsp), %rdx
subl (%rax,%rdx,4), %ecx
movl 0x2c(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x2c(%rsp)
imull $0x3, 0x2c(%rsp), %eax
addl 0x30(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x9669
movq 0x40(%rsp), %rax
cmpl $0x1, 0x234(%rax)
jle 0x97df
movl 0x30(%rsp), %eax
addl $0xa, %eax
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)