LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/ttasm.c
// Function: get_local_variable
static int get_local_variable( struct function *func, struct element *elem, char *suffix, char *message ) {
	int idx = 0;
	char *name = elem->str.string;
	size_t len = strlen( name ) - strlen( suffix );
	struct local_variable *local = func->variable_decls;
	if( len > 0 ) {
		while( local && ( strncmp( local->name, name, len ) || strlen( local->name ) != len ) ) {
			idx++;
			local = local->next;
		}
	}
	if( len <= 0 || local == NULL || idx > 127 ) {
		if( message ) {
			sprintf( message, "Invalid local variable '%.64s' on line %d.", name, elem->line );
		}
		idx = -1;
	}
	return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x30c0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30c0
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
jbe 0x1aa30
jmp 0x1a9c4
xorl %eax, %eax
cmpq $0x0, -0x40(%rbp)
movb %al, -0x49(%rbp)
je 0x1aa0e
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x3060
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x4a(%rbp)
jne 0x1aa08
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x30c0
cmpq -0x38(%rbp), %rax
setne %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x1aa17
jmp 0x1aa2e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x1a9c4
jmp 0x1aa30
cmpq $0x0, -0x38(%rbp)
jbe 0x1aa44
cmpq $0x0, -0x40(%rbp)
je 0x1aa44
cmpl $0x7f, -0x24(%rbp)
jle 0x1aa6f
cmpq $0x0, -0x20(%rbp)
je 0x1aa68
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x1f4c(%rip), %rsi      # 0x1c9ad
movb $0x0, %al
callq 0x31f0
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl -0x24(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/ttasm.c
// Function: get_asm_operator
static struct asm_operator* get_asm_operator( struct asm_operator *operators, char *name ) {
	while( operators->name && strcmp( name, operators->name ) ) {
		operators++;
	}
	if( operators->name == NULL ) {
		operators = NULL;
	}
	return operators;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0x1aab8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x3130
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1aac1
jmp 0x1aacf
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x1aa90
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1aae1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_01/unbuffered.c
// Function: main
int main(void)
{
	int n;
	char buf[DATA_SIZE];

        memset(buf, 0, DATA_SIZE);
	for (n = 0; n < DATA_SIZE; n++)
		if (write(STDOUT_FILENO, &buf[n], 1) != 1) {
			err("write error\n");
			break;
		}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20010, %rsp          # imm = 0x20010
movl $0x0, -0x4(%rbp)
leaq -0x20010(%rbp), %rdi
xorl %esi, %esi
movl $0x20000, %edx          # imm = 0x20000
callq 0x1040
movl $0x0, -0x8(%rbp)
cmpl $0x20000, -0x8(%rbp)    # imm = 0x20000
jge 0x11c8
movslq -0x8(%rbp), %rax
leaq -0x20010(%rbp), %rsi
addq %rax, %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0x1030
cmpq $0x1, %rax
je 0x11bb
leaq 0xe55(%rip), %rdi       # 0x2004
movl $0xd, %esi
callq 0x11e0
jmp 0x11c8
jmp 0x11bd
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x117c
xorl %eax, %eax
addq $0x20010, %rsp          # imm = 0x20010
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_int_atomic_fetch_inc.c
// Function: shmem_int_atomic_fetch_inc
int shmem_int_atomic_fetch_inc( int* ptr, int pe)
{
	int* remote_ptr = (int*)shmem_ptr((void*)ptr, pe ); 
	long* x = (long*)shmem_ptr((void*)&__shmem.lock_atomic_int, pe);
	__set_spin_lock(x);
	int r = *remote_ptr;
	*remote_ptr = r + 1;
	__clear_spin_lock(x);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1fb0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %esi
leaq 0x3037(%rip), %rdi      # 0x71e0
addq $0x10, %rdi
callq 0x1fb0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4520
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x44e0
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erik[P]gamut/convolute.c
// Function: main
int main(int argc, char** argv)
{
    if (argc != 2) {
        fprintf(stderr, "usage: %s KERNEL\n", argv[0]);
        return 1;
    }

    const void *kernel = NULL;

    if (!strcmp("blur", argv[1]))
        kernel = &BLUR_KERNEL;
    else if (!strcmp("sharpen", argv[1]))
        kernel = &SHARPEN_KERNEL;
    else {
        fprintf(stderr, "unknown image kernel: %s\n", argv[1]);
        return 1;
    }

    return convolve(kernel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x1737
movq 0x28e5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x959(%rip), %rsi       # 0x207d
movb $0x0, %al
callq 0x10a0
movl $0x1, -0x4(%rbp)
jmp 0x17c2
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x941(%rip), %rdi       # 0x208f
callq 0x1090
cmpl $0x0, %eax
jne 0x1765
leaq 0x8e1(%rip), %rax       # 0x2040
movq %rax, -0x18(%rbp)
jmp 0x17b6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x920(%rip), %rdi       # 0x2094
callq 0x1090
cmpl $0x0, %eax
jne 0x178b
leaq 0x88b(%rip), %rax       # 0x2010
movq %rax, -0x18(%rbp)
jmp 0x17b4
movq 0x2866(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x8f8(%rip), %rsi       # 0x209c
movb $0x0, %al
callq 0x10a0
movl $0x1, -0x4(%rbp)
jmp 0x17c2
jmp 0x17b6
movq -0x18(%rbp), %rdi
callq 0x11f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nickglobal[P]usbloger/core.c
// Function: main
int main()
{
	// comment pushed via ssh
	int i,jj;
	printf("usb log core \n");
	printf("start count \n");
	jj = 0;
	for ( i=0; i<10; i++)
	{
		printf(" count rqqqqwerewrwe %d \n", i);
		if ( (jj++) == 5) {
		   printf("JJ\n");
		   jj = 123;
		} 	
	}
	if ( jj == 123 ) 
	{
		printf("remote branch added fix 1  \n");	
		printf("remote branch added fix 2  \n");
	
		printf("remote branch added fix 3  \n");	
		printf("remote branch added fix 4  \n");
		printf("commit once again \n");
		printf("count end\n");
	}
#ifdef USB_FEATURE
	printf("USB logger [ON]\n");
#endif
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xeae(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
leaq 0xeaf(%rip), %rdi       # 0x2013
movb $0x0, %al
callq 0x1030
movl $0x0, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0xa, -0x8(%rbp)
jge 0x11c2
movl -0x8(%rbp), %esi
leaq 0xe98(%rip), %rdi       # 0x2021
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x5, %eax
jne 0x11b5
leaq 0xe94(%rip), %rdi       # 0x203b
movb $0x0, %al
callq 0x1030
movl $0x7b, -0xc(%rbp)
jmp 0x11b7
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1179
cmpl $0x7b, -0xc(%rbp)
jne 0x121c
leaq 0xe70(%rip), %rdi       # 0x203f
movb $0x0, %al
callq 0x1030
leaq 0xe7f(%rip), %rdi       # 0x205c
movb $0x0, %al
callq 0x1030
leaq 0xe8e(%rip), %rdi       # 0x2079
movb $0x0, %al
callq 0x1030
leaq 0xe9d(%rip), %rdi       # 0x2096
movb $0x0, %al
callq 0x1030
leaq 0xeac(%rip), %rdi       # 0x20b3
movb $0x0, %al
callq 0x1030
leaq 0xeb2(%rip), %rdi       # 0x20c7
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/chess.c
// Function: sendKillSig()
void sendKillSig()
{
	int i;
	int sig = -1;
	for (i = 1; i < numProcs; i++) 
		COMM_WORLD.Send(&sig, 1, MPI_INT, i, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x17f75(%rip), %eax     # 0x215f4
jge 0x96e2
movq 0x17948(%rip), %rsi     # 0x20fd0
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x9e80
movq -0x30(%rbp), %rcx
movl -0x4(%rbp), %r8d
movq 0x1791c(%rip), %rdi     # 0x20fc0
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
xorl %r9d, %r9d
callq 0x9f20
jmp 0x96b7
leaq -0x18(%rbp), %rdi
callq 0xa620
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9676
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xa620
jmp 0x96e8
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8a50
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/chess.c
// Function: enqueueMove(Move*)
void enqueueMove(Move* move)
{
	if (queueFull == TRUE)
		free(moveQueue[queueIndex]);
	
	moveQueue[queueIndex++] = move;
	if (queueIndex >= MQ_SIZE)
	{
		queueFull = TRUE;
		queueIndex = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x1, 0x17bb1(%rip)     # 0x21604
jne 0x9a6c
movq 0x17b9c(%rip), %rax     # 0x215f8
movslq 0x17b9d(%rip), %rcx     # 0x21600
movq (%rax,%rcx,8), %rdi
callq 0x8680
movq -0x8(%rbp), %rdx
movq 0x17b81(%rip), %rax     # 0x215f8
movl 0x17b83(%rip), %ecx     # 0x21600
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x17b78(%rip)     # 0x21600
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
cmpl $0x14, 0x17b6a(%rip)    # 0x21600
jl 0x9aac
movl $0x1, 0x17b62(%rip)     # 0x21604
movl $0x0, 0x17b54(%rip)     # 0x21600
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/chess.c
// Function: logMove(char const*, Move*)
void logMove(const char* filename, Move* move)
{
	//Open file
	FILE* fp = fopen(filename, "a");
	
	//Log move
	char* moveStr = moveToString(move);
	fprintf(fp, "%s", moveStr);
	free(moveStr);
	
	//Close file
	fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x114e2(%rip), %rsi     # 0x1b1bd
callq 0x8670
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x186f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x114bf(%rip), %rsi     # 0x1b1bf
movb $0x0, %al
callq 0x8870
movq -0x20(%rbp), %rdi
callq 0x8680
movq -0x18(%rbp), %rdi
callq 0x8560
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/chess.c
// Function: movesEqual(Move*, Move*)
int movesEqual(Move* move1, Move* move2)
{
	if (move1->startRow == move2->startRow && move1->startCol == move2->startCol &&
		move1->endRow == move2->endRow && move1->endCol == move2->endCol)
		return TRUE;
	else
		return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
movq -0x18(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jne 0x9d85
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
movq -0x18(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x9d85
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %eax
movq -0x18(%rbp), %rcx
movsbl 0x3(%rcx), %ecx
cmpl %ecx, %eax
jne 0x9d85
movq -0x10(%rbp), %rax
movsbl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movsbl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jne 0x9d85
movl $0x1, -0x4(%rbp)
jmp 0x9d8c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/chess.c
// Function: printScore(int)
void printScore(int score)
{
	if (score > 0)
		printf("Board Score = %d (WHITE).\n", score);
	else if (score < 0)
		printf("Board Score = %d (BLACK).\n", -score);
	else
		printf("Board Score = EVEN.\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x9dc4
movl -0x4(%rbp), %esi
leaq 0x113b5(%rip), %rdi     # 0x1b170
movb $0x0, %al
callq 0x8040
jmp 0x9def
cmpl $0x0, -0x4(%rbp)
jge 0x9ddf
xorl %esi, %esi
subl -0x4(%rbp), %esi
leaq 0x113b5(%rip), %rdi     # 0x1b18b
movb $0x0, %al
callq 0x8040
jmp 0x9ded
leaq 0x113c0(%rip), %rdi     # 0x1b1a6
movb $0x0, %al
callq 0x8040
jmp 0x9def
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/boardutil.c
// Function: buildNewBoard()
char* buildNewBoard()
{
	int i, idx;
	char* board = (char*) malloc(64);

	//populate white
	board[0] = ROOK;
	board[1] = KNIGHT;
	board[2] = BISHOP;
	board[3] = QUEEN;
	board[4] = KING;
	board[5] = BISHOP;
	board[6] = KNIGHT;
	board[7] = ROOK;

	for (i = 0, idx = 8; i < 8; i++, idx++)
		board[idx] = PAWN;

	//populate other squares with EMPTY
	for (idx = 16; idx < 48; idx++)
		board[idx] = EMPTY;

	//populate black
	for (i = 0, idx = 48; i < 8; i++, idx++)
		board[idx] = PAWN + BLACK;

	board[56] = ROOK + BLACK;
	board[57] = KNIGHT + BLACK;
	board[58] = BISHOP + BLACK;
	board[59] = QUEEN + BLACK;
	board[60] = KING + BLACK;
	board[61] = BISHOP + BLACK;
	board[62] = KNIGHT + BLACK;
	board[63] = ROOK + BLACK;

	return board;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x40, %edi
callq 0x8780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x2, (%rax)
movq -0x10(%rbp), %rax
movb $0x3, 0x1(%rax)
movq -0x10(%rbp), %rax
movb $0x4, 0x2(%rax)
movq -0x10(%rbp), %rax
movb $0x5, 0x3(%rax)
movq -0x10(%rbp), %rax
movb $0x6, 0x4(%rax)
movq -0x10(%rbp), %rax
movb $0x4, 0x5(%rax)
movq -0x10(%rbp), %rax
movb $0x3, 0x6(%rax)
movq -0x10(%rbp), %rax
movb $0x2, 0x7(%rax)
movl $0x0, -0x4(%rbp)
movl $0x8, -0x8(%rbp)
cmpl $0x8, -0x4(%rbp)
jge 0xe859
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movb $0x1, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xe833
movl $0x10, -0x8(%rbp)
cmpl $0x30, -0x8(%rbp)
jge 0xe87d
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xe860
movl $0x0, -0x4(%rbp)
movl $0x30, -0x8(%rbp)
cmpl $0x8, -0x4(%rbp)
jge 0xe8b1
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movb $0x33, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xe88b
movq -0x10(%rbp), %rax
movb $0x34, 0x38(%rax)
movq -0x10(%rbp), %rax
movb $0x35, 0x39(%rax)
movq -0x10(%rbp), %rax
movb $0x36, 0x3a(%rax)
movq -0x10(%rbp), %rax
movb $0x37, 0x3b(%rax)
movq -0x10(%rbp), %rax
movb $0x38, 0x3c(%rax)
movq -0x10(%rbp), %rax
movb $0x36, 0x3d(%rax)
movq -0x10(%rbp), %rax
movb $0x35, 0x3e(%rax)
movq -0x10(%rbp), %rax
movb $0x34, 0x3f(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/boardutil.c
// Function: toString(char)
char* toString(char pieceId)
{
	char* str;
	if (pieceId == EMPTY)
	{
		//empty square
		str = (char*) "EMPTY";
	} else if (pieceId > BLACK) {
		//black
		pieceId = (char) (pieceId - BLACK);
		switch (pieceId)
		{
			case PAWN:
				str = (char*) "BLACK PAWN";
				break;
			case ROOK:
				str = (char*) "BLACK ROOK";
				break;
			case KNIGHT:
				str = (char*) "BLACK KNIGHT";
				break;
			case BISHOP:
				str = (char*) "BLACK BISHOP";
				break;
			case QUEEN:
				str = (char*) "BLACK QUEEN";
				break;
			case KING:
				str = (char*) "BLACK KING";
				break;
		}
	} else {
		//white
		switch (pieceId)
		{
			case PAWN:
				str = (char*) "WHITE PAWN";
				break;
			case ROOK:
				str = (char*) "WHITE ROOK";
				break;
			case KNIGHT:
				str = (char*) "WHITE KNIGHT";
				break;
			case BISHOP:
				str = (char*) "WHITE BISHOP";
				break;
			case QUEEN:
				str = (char*) "WHITE QUEEN";
				break;
			case KING:
				str = (char*) "WHITE KING";
				break;
		}
	}
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x0, %eax
jne 0xe923
leaq 0xc9f6(%rip), %rax      # 0x1b310
movq %rax, -0x10(%rbp)
jmp 0xea1c
movsbl -0x1(%rbp), %eax
cmpl $0x32, %eax
jle 0xe9a7
movb -0x1(%rbp), %al
addb $-0x32, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0xe9a5
movq -0x18(%rbp), %rax
leaq 0xc978(%rip), %rcx      # 0x1b2c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc9b6(%rip), %rax      # 0x1b316
movq %rax, -0x10(%rbp)
jmp 0xe9a5
leaq 0xc9b4(%rip), %rax      # 0x1b321
movq %rax, -0x10(%rbp)
jmp 0xe9a5
leaq 0xc9b2(%rip), %rax      # 0x1b32c
movq %rax, -0x10(%rbp)
jmp 0xe9a5
leaq 0xc9b2(%rip), %rax      # 0x1b339
movq %rax, -0x10(%rbp)
jmp 0xe9a5
leaq 0xc9b2(%rip), %rax      # 0x1b346
movq %rax, -0x10(%rbp)
jmp 0xe9a5
leaq 0xc9b1(%rip), %rax      # 0x1b352
movq %rax, -0x10(%rbp)
jmp 0xea1a
movsbl -0x1(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0xea18
movq -0x20(%rbp), %rax
leaq 0xc8ed(%rip), %rcx      # 0x1b2b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc98a(%rip), %rax      # 0x1b35d
movq %rax, -0x10(%rbp)
jmp 0xea18
leaq 0xc988(%rip), %rax      # 0x1b368
movq %rax, -0x10(%rbp)
jmp 0xea18
leaq 0xc986(%rip), %rax      # 0x1b373
movq %rax, -0x10(%rbp)
jmp 0xea18
leaq 0xc986(%rip), %rax      # 0x1b380
movq %rax, -0x10(%rbp)
jmp 0xea18
leaq 0xc986(%rip), %rax      # 0x1b38d
movq %rax, -0x10(%rbp)
jmp 0xea18
leaq 0xc985(%rip), %rax      # 0x1b399
movq %rax, -0x10(%rbp)
jmp 0xea1a
jmp 0xea1c
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/boardutil.c
// Function: positionString(int, int)
const char* positionString(int row, int col)
{
	const char* str;
	if (row > 7 || row < 0 || col > 7 || col < 0)
	{
		str = (char*) "INVALID LOCATION";
	} else {
		const char* squares[] = {"A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8",
						   "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8",
						   "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8",
						   "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8",
						   "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8",
						   "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8",
						   "G1", "G2", "G3", "G4", "G5", "G6", "G7", "G8",
						   "H1", "H2", "H3", "H4", "H5", "H6", "H7", "H8"};
		str = squares[col * 8 + row];
	}
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x7, -0x4(%rbp)
jg 0xea59
cmpl $0x0, -0x4(%rbp)
jl 0xea59
cmpl $0x7, -0x8(%rbp)
jg 0xea59
cmpl $0x0, -0x8(%rbp)
jge 0xea66
leaq 0xc944(%rip), %rax      # 0x1b3a4
movq %rax, -0x10(%rbp)
jmp 0xea95
leaq -0x210(%rbp), %rdi
leaq 0x120ec(%rip), %rsi     # 0x20b60
movl $0x200, %edx            # imm = 0x200
callq 0x8460
movl -0x8(%rbp), %eax
shll $0x3, %eax
addl -0x4(%rbp), %eax
cltq
movq -0x210(%rbp,%rax,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/boardutil.c
// Function: totalPieces(char*)
int totalPieces(char* board)
{
	int i, count;
	for (i = 0, count = 0; i < 64; i++)
		if (board[i] != EMPTY)
			count++;
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0xec13
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xec06
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xec08
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xebe6
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: kingInCheck(char*, char)
char kingInCheck(char* board, char color)
{
	int i, j, row, col;
	if (color == WHITE)
	{
		//Find white king
		for (i = 0; i < 8; i++)
		{
			for (j = 0; j < 8; j++)
			{
				if (getPieceAt(board, i, j) == KING)
				{
					row = i;
					col = j;
				}
			}
		}

		return !pieceSafe(board, row, col);
	} else {
		//Find black king
		for (i = 0; i < 8; i++)
		{
			for (j = 0; j < 8; j++)
			{
				if (getPieceAt(board, i, j) == KING + BLACK)
				{
					row = i;
					col = j;
				}
			}
		}

		return !pieceSafe(board, row, col);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0xeeef
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0xeed2
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0xeec5
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0xeab0
movsbl %al, %eax
cmpl $0x6, %eax
jne 0xeeb8
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xeeba
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xee8f
jmp 0xeec7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xee82
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0xef70
cmpb $0x0, %al
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xef61
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0xef46
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0xef39
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0xeab0
movsbl %al, %eax
cmpl $0x38, %eax
jne 0xef2c
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xef2e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xef03
jmp 0xef3b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xeef6
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0xef70
cmpb $0x0, %al
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: spaceSafe(char*, char, int, int)
char spaceSafe(char* board, char color, int row, int col)
{
	if (row < 0 || row > 7 || col < 0 || col > 7)
	{
		return FALSE;
	} else {
		if (getPieceAt(board, row, col) != EMPTY)
		{
			return FALSE;
		} else {
			char p;
			if (color == WHITE)
				p = PAWN;
			else
				p = BLACK + PAWN;
			setPieceAt(board, row, col, p);
			if (pieceSafe(board, row, col))
			{
				setPieceAt(board, row, col, EMPTY);
				return TRUE;
			} else {
				setPieceAt(board, row, col, EMPTY);
				return FALSE;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0xfe80
cmpl $0x7, -0x18(%rbp)
jg 0xfe80
cmpl $0x0, -0x1c(%rbp)
jl 0xfe80
cmpl $0x7, -0x1c(%rbp)
jle 0xfe89
movb $0x0, -0x1(%rbp)
jmp 0xff0b
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0xeab0
movsbl %al, %eax
cmpl $0x0, %eax
je 0xfea6
movb $0x0, -0x1(%rbp)
jmp 0xff0b
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0xfeb5
movb $0x1, -0x1d(%rbp)
jmp 0xfeb9
movb $0x33, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movsbl -0x1d(%rbp), %ecx
callq 0xeb00
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0xef70
cmpb $0x0, %al
je 0xfef6
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
xorl %ecx, %ecx
callq 0xeb00
movb $0x1, -0x1(%rbp)
jmp 0xff0b
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
xorl %ecx, %ecx
callq 0xeb00
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: newMoveSet()
MoveSet* newMoveSet()
{
	MoveSet* set = (MoveSet*) malloc(sizeof(MoveSet));
	set->cap = 100;
	set->size = 0;
	set->moves = (Move**) malloc(sizeof(Move*) * set->cap);
	return set;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x8780
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x64, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x8780
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: addMove(MoveSet*, char, int, int, int, int, int)
void addMove(MoveSet* set, char pieceId, int startRow, int startCol, int endRow, int endCol, int boardScore)
{
	//Check for expansion
	if (set->size >= set->cap)
	{
		set->cap *= 2;
		int i;
		Move** oMoves = set->moves;
		set->moves = (Move**) malloc(sizeof(Move*) * set->cap);
		for (i = 0; i < set->size; i++)
			set->moves[i] = oMoves[i];
		free(oMoves);
	}

	//Add move
	Move* move = (Move*) malloc(sizeof(Move));
	move->pieceId = pieceId;
	move->startRow = (char) startRow;
	move->startCol = (char) startCol;
	move->endRow = (char) endRow;
	move->endCol = (char) endCol;
	move->boardScore = boardScore;
	set->moves[set->size++] = move;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movl 0x10(%rbp), %esi
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x17c06
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shll %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x8780
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x17bfd
movq -0x28(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x17bca
movq -0x28(%rbp), %rdi
callq 0x8680
movl $0xc, %edi
callq 0x8780
movq %rax, -0x30(%rbp)
movb -0x9(%rbp), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movl -0x10(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x18(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0x4(%rax)
movl 0x10(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x4(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x4(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: printMove(Move*)
void printMove(Move* move)
{
	if (move->startRow == CASTLE && move->endRow == KINGSIDE)
		if (isBlack(move->pieceId))
			printf("BLACK CASTLE KINGSIDE.\n");
		else
			printf("WHITE CASTLE KINGSIDE.\n");
	else if (move->startRow == CASTLE && move->endRow == QUEENSIDE)
		if (isBlack(move->pieceId))
			printf("BLACK CASTLE QUEENSIDE.\n");
		else
			printf("WHITE CASTLE QUEENSIDE.\n");
	else
		printf("%s at %s to %s.\n", toString(move->pieceId), positionString(move->startRow, move->startCol), positionString(move->endRow, move->endCol));
	fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $-0x2, %eax
jne 0x18629
movq -0x8(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $-0x3, %eax
jne 0x18629
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0xeb30
cmpb $0x0, %al
je 0x18616
leaq 0x2f37(%rip), %rdi      # 0x1b544
movb $0x0, %al
callq 0x8040
jmp 0x18624
leaq 0x2f3f(%rip), %rdi      # 0x1b55c
movb $0x0, %al
callq 0x8040
jmp 0x186cc
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $-0x2, %eax
jne 0x18673
movq -0x8(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $-0x4, %eax
jne 0x18673
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0xeb30
cmpb $0x0, %al
je 0x18663
leaq 0x2f1a(%rip), %rdi      # 0x1b574
movb $0x0, %al
callq 0x8040
jmp 0x18671
leaq 0x2f23(%rip), %rdi      # 0x1b58d
movb $0x0, %al
callq 0x8040
jmp 0x186ca
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0xe900
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %edi
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %esi
callq 0xea30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x3(%rax), %edi
movq -0x8(%rbp), %rax
movsbl 0x4(%rax), %esi
callq 0xea30
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq %rax, %rcx
leaq 0x2ee3(%rip), %rdi      # 0x1b5a6
movb $0x0, %al
callq 0x8040
jmp 0x186cc
movq 0x88c5(%rip), %rax      # 0x20f98
movq (%rax), %rdi
callq 0x8660
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: moveToString(Move*)
char* moveToString(Move* move)
{
	char* str = (char*) malloc(6);
	if (move->startRow == CASTLE && move->endRow == KINGSIDE)
			sprintf(str, "CK\n");
	else if (move->startRow == CASTLE && move->endRow == QUEENSIDE)
			sprintf(str, "CQ\n");
	else
		sprintf(str, "%c%d%c%d\n", getColumnChar(move->startCol), move->startRow + 1, getColumnChar(move->endCol), move->endRow + 1);
	
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x6, %edi
callq 0x8780
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $-0x2, %eax
jne 0x1873b
movq -0x8(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $-0x3, %eax
jne 0x1873b
movq -0x10(%rbp), %rdi
leaq 0x2e88(%rip), %rsi      # 0x1b5b7
movb $0x0, %al
callq 0x80e0
jmp 0x187ca
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $-0x2, %eax
jne 0x18769
movq -0x8(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $-0x4, %eax
jne 0x18769
movq -0x10(%rbp), %rdi
leaq 0x2e5b(%rip), %rsi      # 0x1b5bb
movb $0x0, %al
callq 0x80e0
jmp 0x187c8
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %edi
callq 0x187e0
movsbl %al, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x4(%rax), %edi
callq 0x187e0
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
movsbl %al, %r8d
movq -0x8(%rbp), %rax
movsbl 0x3(%rax), %r9d
addl $0x1, %r9d
leaq 0x2dfe(%rip), %rsi      # 0x1b5bf
movb $0x0, %al
callq 0x80e0
jmp 0x187ca
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: getColumnChar(int)
char getColumnChar(int col)
{
	switch (col)
	{
		case 0:
			return 'A';
		case 1:
			return 'B';
		case 2:
			return 'C';
		case 3:
			return 'D';
		case 4:
			return 'E';
		case 5:
			return 'F';
		case 6:
			return 'G';
		case 7:
			return 'H';
		default:
			return '\0';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x7, %rax
ja 0x18838
movq -0x10(%rbp), %rax
leaq 0x2d25(%rip), %rcx      # 0x1b524
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x41, -0x1(%rbp)
jmp 0x1883c
movb $0x42, -0x1(%rbp)
jmp 0x1883c
movb $0x43, -0x1(%rbp)
jmp 0x1883c
movb $0x44, -0x1(%rbp)
jmp 0x1883c
movb $0x45, -0x1(%rbp)
jmp 0x1883c
movb $0x46, -0x1(%rbp)
jmp 0x1883c
movb $0x47, -0x1(%rbp)
jmp 0x1883c
movb $0x48, -0x1(%rbp)
jmp 0x1883c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: destroyMoveSet(MoveSet*)
void destroyMoveSet(MoveSet* set)
{
	int i;
	for (i = 0; i < set->size; i++)
		free(set->moves[i]);
	free(set->moves);
	free(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x188df
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8680
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x188b3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8680
movq -0x8(%rbp), %rdi
callq 0x8680
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: subMoveSet(MoveSet*, int, int)
MoveSet* subMoveSet(MoveSet* set, int start, int length)
{
	int i, j;
	MoveSet* s = (MoveSet*) malloc(sizeof(MoveSet));
	s->size = length;
	s->cap = length;
	s->moves = (Move**) malloc(sizeof(Move*) * length);
	
	for (j = 0, i = start; j < length; i++, j++)
		s->moves[j] = set->moves[i];
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x10, %edi
callq 0x8780
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movslq -0x10(%rbp), %rdi
shlq $0x3, %rdi
callq 0x8780
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x18fc4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x18f88
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: receiveMoveDef(int)
MoveDef* receiveMoveDef(int sender)
{
	int bestIndex;
	int bestValue;
	COMM_WORLD.Recv(&bestIndex, 1, MPI_INT, sender, 0);
	COMM_WORLD.Recv(&bestValue, 1, MPI_INT, sender, 0);
	MoveDef* best = (MoveDef*) malloc(sizeof(MoveDef));
	best->index = bestIndex;
	best->value = bestValue;
	return best;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq 0x798e(%rip), %rsi      # 0x20fd0
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x9e80
movq -0x50(%rbp), %rcx
movl -0x4(%rbp), %r8d
movq 0x7962(%rip), %rdi      # 0x20fc0
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
xorl %r9d, %r9d
callq 0xa5b0
jmp 0x19671
leaq -0x20(%rbp), %rdi
callq 0xa620
movq 0x794f(%rip), %rsi      # 0x20fd0
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x9e80
movq -0x58(%rbp), %rcx
movl -0x4(%rbp), %r8d
movq 0x7923(%rip), %rdi      # 0x20fc0
leaq -0xc(%rbp), %rsi
movl $0x1, %edx
xorl %r9d, %r9d
callq 0xa5b0
jmp 0x196b0
leaq -0x40(%rbp), %rdi
callq 0xa620
movl $0x8, %edi
callq 0x8780
movq %rax, -0x48(%rbp)
movl -0x8(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa620
jmp 0x19710
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa620
movq -0x28(%rbp), %rdi
callq 0x8a50
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: newMove()
Move* newMove()
{
	Move* m = (Move*) malloc(sizeof(Move));
	m->pieceId = EMPTY;
	m->startRow = -1;
	m->endRow = -1;
	m->startCol = -1;
	m->endCol = -1;
	m->boardScore = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xc, %edi
callq 0x8780
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x1(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x3(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x2(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
ud2
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: constructMove(char, char, char, char, char, int)
Move* constructMove(char pieceId, char startRow, char startCol, char endRow, char endCol, int boardScore)
{
	Move* m = (Move*) malloc(sizeof(Move));
	m->pieceId = pieceId;
	m->startRow = startRow;
	m->endRow = endRow;
	m->startCol = startCol;
	m->endCol = endCol;
	m->boardScore = boardScore;
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movb %dil, -0x1(%rbp)
movb %sil, -0x2(%rbp)
movb %dl, -0x3(%rbp)
movb %cl, -0x4(%rbp)
movb %al, -0x5(%rbp)
movl %r9d, -0xc(%rbp)
movl $0xc, %edi
callq 0x8780
movq %rax, -0x18(%rbp)
movb -0x1(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movb -0x2(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movb -0x4(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movb -0x3(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movb -0x5(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x4(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: cloneMove(Move*)
Move* cloneMove(Move* m)
{
	Move* n = (Move*) malloc(sizeof(Move));
	n->pieceId = m->pieceId;
	n->startRow = m->startRow;
	n->startCol = m->startCol;
	n->endRow = m->endRow;
	n->endCol = m->endCol;
	n->boardScore = m->boardScore;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xc, %edi
callq 0x8780
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movb 0x2(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
movb 0x3(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
movb 0x4(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/moves.c
// Function: sendMoveDef(MoveDef*)
void sendMoveDef(MoveDef* best)
{
	int bestIndex = best->index;
	int bestValue = best->value;
	COMM_WORLD.Send(&bestIndex, 1, MPI_INT, HEAD, 0);
	COMM_WORLD.Send(&bestValue, 1, MPI_INT, HEAD, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movq 0x6f8a(%rip), %rsi      # 0x20fd0
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x9e80
movq -0x48(%rbp), %rcx
movq 0x6f62(%rip), %rdi      # 0x20fc0
leaq -0xc(%rbp), %rsi
movl $0x1, %edx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x9f20
jmp 0x1a074
leaq -0x20(%rbp), %rdi
callq 0xa620
movq 0x6f4c(%rip), %rsi      # 0x20fd0
leaq -0x40(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x9e80
movq -0x50(%rbp), %rcx
movq 0x6f24(%rip), %rdi      # 0x20fc0
leaq -0x10(%rbp), %rsi
movl $0x1, %edx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x9f20
jmp 0x1a0b2
leaq -0x40(%rbp), %rdi
callq 0xa620
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa620
jmp 0x1a0ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa620
movq -0x28(%rbp), %rdi
callq 0x8a50
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/upcrob[P]garry/strutil.c
// Function: streq(char*, char*)
int streq(char* s1, char* s2)
{
	int i = 0;
	while (s1[i] == s2[i] && s1[i] != '\0')
		i++;
	
	if (s1[i] == s2[i] && s1[i] == '\0')
		return TRUE;
	else
		return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rdx
movsbl (%rax,%rdx), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x1d(%rbp)
jne 0x1a3f9
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x1a402
jmp 0x1a40d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a3c3
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x1a443
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1a443
movl $0x1, -0x4(%rbp)
jmp 0x1a44a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/Crawler/functions.c
// Function: readFolder
void readFolder(char *path, TrieNode *trie, int *nWords, int *nChars, int *nLines){
    DIR *dp;
    struct dirent *dir;
    char *newName;
    if((dp = opendir(path)) == NULL){                       // Open directory
        perror("readfolder");
        return;
    }
    while((dir = readdir(dp)) != NULL){                     // Read contents till the end
        if(dir->d_ino == 0)                                 // Ignore removed entries
            continue;
        newName = malloc(strlen(path)+strlen(dir->d_name)+2);
        strcpy(newName, path);                              // Compose pathname

        if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, "..") ) { //Filter out
            //do nothing
        }
        else{
            strcat(newName, dir->d_name);
            readFile(newName, trie, nWords, nChars, nLines);
        }

        free(newName);
    }
    closedir(dp);                                           // Close directory
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x15b0
leaq 0x1acd(%rip), %rdi      # 0x3073
callq 0x1140
jmp 0x1685
jmp 0x15b2
movq -0x30(%rbp), %rdi
callq 0x1100
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x167c
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15d5
jmp 0x15b2
movq -0x8(%rbp), %rdi
callq 0x1080
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
addq $0x13, %rdi
callq 0x1080
movq -0x48(%rbp), %rdi
addq %rax, %rdi
addq $0x2, %rdi
callq 0x1110
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1040
movq -0x38(%rbp), %rdi
addq $0x13, %rdi
leaq 0x1a60(%rip), %rsi      # 0x307f
callq 0x10e0
cmpl $0x0, %eax
je 0x1642
movq -0x38(%rbp), %rdi
addq $0x13, %rdi
leaq 0x1a46(%rip), %rsi      # 0x307e
callq 0x10e0
cmpl $0x0, %eax
jne 0x1644
jmp 0x166e
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x13, %rsi
callq 0x1170
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x1690
movq -0x40(%rbp), %rdi
callq 0x1030
jmp 0x15b2
movq -0x30(%rbp), %rdi
callq 0x10b0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/Crawler/trie.c
// Function: createTrieNode
TrieNode * createTrieNode(){
    TrieNode *newNode = (TrieNode*) malloc(sizeof(TrieNode)); // allocate space for new node

    newNode->frequency   = 0;    // default frequency of a node is 0, since it's not a word (leaf)
    newNode->postingList = NULL; // no posting list for a non leaf node
    newNode->charList    = NULL; // no child (letter) nodes yet
    newNode->nDocs       = 0;    // no documents include this substring yet (unknown at the time if this is a leaf node)
    return newNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x1110
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/Crawler/trie.c
// Function: insertWord
TrieNode * insertWord(TrieNode *root, char* word, int lineNumber, char *fileName){
    TrieNode *current = root;
    int newDoc;

    while (*word){                                     // while not all the string has been consumed
        current = findNextTrieNode(current, *word, 0); // go to the trie node that contains the current letter
        word++;                                        // point to next letter
    }

    current->frequency++;                              // increase the frequency of this word (current is pointing to the leaf node (aka where the word is)
    if (current->postingList == NULL){                 // if there is no posting list yet for this word
        current->postingList = createPostingList(lineNumber, fileName); // create it
        newDoc = 1;
    }
    else
        current->postingList = addToPostingList(current->postingList, lineNumber, &newDoc, fileName); // insert the doc id to the beginning of the inverted index of the word

    current->nDocs += newDoc;                           // will be incremented by one, if this was the first appearance of the word in the lineNumber

    return current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1d3c
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
xorl %edx, %edx
movsbl (%rax), %esi
callq 0x1db0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1d0f
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1d72
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x1f40
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, -0x2c(%rbp)
jmp 0x1d95
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x2c(%rbp), %rdx
callq 0x1fc0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/devkot[P]SearchEngine/Crawler/trie.c
// Function: createPostingList
PostingListNode * createPostingList(int lineNumber, char *fileName){

    PostingListNode *newNode = (PostingListNode*) malloc(sizeof(PostingListNode));
    newNode->fileName = (char *) malloc(strlen(fileName) + 1);

    newNode->lineNumber = lineNumber;
    newNode->n          = 1;
    //    newNode->fileName   = fileName;
    strcpy(newNode->fileName, fileName);
    newNode->next       = NULL;

    return newNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x1110
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1080
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1110
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1040
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)