LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
testb %sil, %sil
je 0x2120
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x1eef
cmpb $0x38, %al
cmovel %r12d, %r15d
cmovel %r13d, %r14d
incl %r13d
cmpl $0x8, %r13d
jne 0x20f4
incl %r12d
cmpl $0x8, %r12d
jne 0x20f1
jmp 0x214d
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x1eef
cmpb $0x6, %al
cmovel %r12d, %r15d
cmovel %r13d, %r14d
incl %r13d
cmpl $0x8, %r13d
jne 0x2123
incl %r12d
cmpl $0x8, %r12d
jne 0x2120
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x216f
testb %al, %al
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %eax
orl %edx, %eax
cmpl $0x7, %eax
ja 0x2c97
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
movl %edx, %esi
movl %ecx, %edx
callq 0x1eef
testb %al, %al
je 0x2ca6
xorl %r12d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testb %r12b, %r12b
movl $0x1, %eax
movl $0x33, %ecx
cmovel %eax, %ecx
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x1f12
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x216f
testb %al, %al
setne %r12b
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x1f12
jmp 0x2c9a
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r15d
movl %r8d, -0x34(%rbp)
movl %ecx, -0x30(%rbp)
movl %edx, %r13d
movl %esi, %r14d
movq %rdi, %rbx
movl 0x4(%rdi), %r12d
movslq (%rdi), %rdi
cmpl %edi, %r12d
jl 0x756f
movl %r15d, -0x2c(%rbp)
leal (%rdi,%rdi), %eax
movl %eax, (%rbx)
movq 0x8(%rbx), %r15
shlq $0x4, %rdi
callq 0x1140
movq %rax, 0x8(%rbx)
testl %r12d, %r12d
jle 0x755f
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
movq 0x8(%rbx), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x754b
movq %r15, %rdi
callq 0x1130
movl 0x4(%rbx), %r12d
movl -0x2c(%rbp), %r15d
movl $0xc, %edi
callq 0x1140
movb %r14b, (%rax)
movb %r13b, 0x1(%rax)
movl -0x30(%rbp), %ecx
movb %cl, 0x2(%rax)
movl -0x34(%rbp), %ecx
movb %cl, 0x3(%rax)
movb %r15b, 0x4(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rbx), %rcx
leal 0x1(%r12), %edx
movl %edx, 0x4(%rbx)
movslq %r12d, %rdx
movq %rax, (%rcx,%rdx,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $-0x2, 0x1(%rdi)
jne 0x7ce5
movzbl 0x3(%rbx), %eax
cmpl $0xfc, %eax
je 0x7d26
cmpl $0xfd, %eax
jne 0x7ce5
movsbl (%rbx), %edi
callq 0x1f20
testb %al, %al
je 0x7d3b
leaq 0x1837(%rip), %rdi      # 0x951a
jmp 0x7d4b
movsbl (%rbx), %edi
callq 0x1e6a
movq %rax, %r14
movsbl 0x1(%rbx), %edi
movsbl 0x2(%rbx), %esi
callq 0x1ec6
movq %rax, %r15
movsbl 0x3(%rbx), %edi
movsbl 0x4(%rbx), %esi
callq 0x1ec6
leaq 0x17a4(%rip), %rdi      # 0x94b8
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1030
jmp 0x7d50
movsbl (%rbx), %edi
callq 0x1f20
testb %al, %al
je 0x7d44
leaq 0x17b2(%rip), %rdi      # 0x94eb
jmp 0x7d4b
leaq 0x17c1(%rip), %rdi      # 0x9503
jmp 0x7d4b
leaq 0x1788(%rip), %rdi      # 0x94d3
callq 0x1190
movq 0x4251(%rip), %rax      # 0xbfa8
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x6, %edi
callq 0x1140
movq %rax, %rbx
movsbl 0x1(%r14), %ecx
cmpl $-0x2, %ecx
jne 0x7da5
movzbl 0x3(%r14), %eax
cmpl $0xfc, %eax
je 0x7de8
cmpl $0xfd, %eax
jne 0x7da5
movl $0xa4b43, (%rbx)        # imm = 0xA4B43
jmp 0x7de0
movzbl 0x2(%r14), %eax
leal 0x41(%rax), %edx
xorl %esi, %esi
cmpl $0x8, %eax
cmovael %esi, %edx
incl %ecx
movzbl 0x4(%r14), %eax
leal 0x41(%rax), %r8d
cmpl $0x8, %eax
cmovael %esi, %r8d
movsbl 0x3(%r14), %r9d
incl %r9d
leaq 0x16f3(%rip), %rsi      # 0x94c9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0xa5143, (%rbx)        # imm = 0xA5143
jmp 0x7de0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x4(%rdi)
jle 0x7e61
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1130
incq %r14
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jl 0x7e48
movq 0x8(%rbx), %rdi
callq 0x1130
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1130
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
movl $0x10, %edi
callq 0x1140
movq %rax, %rbx
movl %r15d, 0x4(%rax)
movl %r15d, (%rax)
movslq %r15d, %r13
leaq (,%r13,8), %rdi
callq 0x1140
movq %rax, 0x8(%rbx)
testl %r13d, %r13d
jle 0x81e9
movslq %r12d, %rcx
movl %r15d, %edx
shlq $0x3, %rcx
addq 0x8(%r14), %rcx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movq %rdi, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x81d9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/upcrob[P]garry/moves.c
// Function: sendMoveSet(int, MoveSet*)
void sendMoveSet(int receiver, MoveSet* set)
{
	//Send set size
	int i;
	int size = set->size;
	COMM_WORLD.Send(&size, 1, MPI_INT, receiver, 0);
	
	//Send move data
	for (i = 0; i < size; i++)
	{
		COMM_WORLD.Send(&set->moves[i]->pieceId, 1, MPI_CHAR, receiver, 0);
		COMM_WORLD.Send(&set->moves[i]->startRow, 1, MPI_CHAR, receiver, 0);
		COMM_WORLD.Send(&set->moves[i]->startCol, 1, MPI_CHAR, receiver, 0);
		COMM_WORLD.Send(&set->moves[i]->endRow, 1, MPI_CHAR, receiver, 0);
		COMM_WORLD.Send(&set->moves[i]->endCol, 1, MPI_CHAR, receiver, 0);
		COMM_WORLD.Send(&set->moves[i]->boardScore, 1, MPI_INT, receiver, 0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movl 0x4(%rsi), %eax
leaq -0x2c(%rbp), %r15
movl %eax, (%r15)
movq 0x3db0(%rip), %r13      # 0xbfd0
movq 0x8(%r13), %r9
movq 0x3dad(%rip), %rdx      # 0xbfd8
movq %r15, %rdi
movl $0x1, %esi
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x1060
cmpl $0x0, (%r15)
jle 0x8333
xorl %r12d, %r12d
movq 0x3d5e(%rip), %r15      # 0xbfb0
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
movq 0x8(%r13), %r9
movl $0x1, %esi
movq %r15, %rdx
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x1060
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
incq %rdi
movq 0x8(%r13), %r9
movl $0x1, %esi
movq %r15, %rdx
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x1060
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
addq $0x2, %rdi
movq 0x8(%r13), %r9
movl $0x1, %esi
movq %r15, %rdx
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x1060
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
addq $0x3, %rdi
movq 0x8(%r13), %r9
movl $0x1, %esi
movq %r15, %rdx
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x1060
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
addq $0x4, %rdi
movq 0x8(%r13), %r9
movl $0x1, %esi
movq %r15, %rdx
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x1060
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
addq $0x8, %rdi
movq 0x8(%r13), %r9
movl $0x1, %esi
movq 0x3cc0(%rip), %rdx      # 0xbfd8
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x1060
incq %r12
movslq -0x2c(%rbp), %rax
cmpq %rax, %r12
jl 0x8252
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/upcrob[P]garry/moves.c
// Function: sendMove(int, Move*)
void sendMove(int receiver, Move* move)
{
	COMM_WORLD.Send(&move->pieceId, 1, MPI_CHAR, receiver, 0);
	COMM_WORLD.Send(&move->startRow, 1, MPI_CHAR, receiver, 0);
	COMM_WORLD.Send(&move->startCol, 1, MPI_CHAR, receiver, 0);
	COMM_WORLD.Send(&move->endRow, 1, MPI_CHAR, receiver, 0);
	COMM_WORLD.Send(&move->endCol, 1, MPI_CHAR, receiver, 0);
	COMM_WORLD.Send(&move->boardScore, 1, MPI_INT, receiver, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
movq 0x3c77(%rip), %r12      # 0xbfd0
movq 0x8(%r12), %r9
movq 0x3c4b(%rip), %r15      # 0xbfb0
movq %rsi, %rdi
movl $0x1, %esi
movq %r15, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x1060
leaq 0x1(%r14), %rdi
movq 0x8(%r12), %r9
movl $0x1, %esi
movq %r15, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x1060
leaq 0x2(%r14), %rdi
movq 0x8(%r12), %r9
movl $0x1, %esi
movq %r15, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x1060
leaq 0x3(%r14), %rdi
movq 0x8(%r12), %r9
movl $0x1, %esi
movq %r15, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x1060
leaq 0x4(%r14), %rdi
movq 0x8(%r12), %r9
movl $0x1, %esi
movq %r15, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x1060
addq $0x8, %r14
movq 0x8(%r12), %r9
movq 0x3be2(%rip), %rdx      # 0xbfd8
movq %r14, %rdi
movl $0x1, %esi
movl %ebx, %ecx
xorl %r8d, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
movq 0x3ba6(%rip), %r12      # 0xbfd0
movq 0x8(%r12), %r9
xorl %r13d, %r13d
movq %r13, (%rsp)
movq 0x3b9b(%rip), %r14      # 0xbfd8
leaq -0x30(%rbp), %r15
movq %r15, %rdi
movl $0x1, %esi
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x10a0
movq 0x8(%r12), %r9
movq %r13, (%rsp)
leaq -0x2c(%rbp), %r12
movq %r12, %rdi
movl $0x1, %esi
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x10a0
movl $0x8, %edi
callq 0x1140
movl (%r15), %ecx
movl %ecx, (%rax)
movl (%r12), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/upcrob[P]garry/moves.c
// Function: receiveMoveSet()
MoveSet* receiveMoveSet()
{
	//Get set size
	int i;
	int size;
	COMM_WORLD.Recv(&size, 1, MPI_INT, HEAD, 0);
	
	//Allocate MoveSet structure
	MoveSet* set = (MoveSet*) malloc(sizeof(MoveSet));
	set->size = size;
	set->cap = size;
	set->moves  = (Move**) malloc(sizeof(Move*) * size);
	
	//Receive move data
	for (i = 0; i < size; i++)
	{
		Move* m = (Move*) malloc(sizeof(Move));
		COMM_WORLD.Recv(&m->pieceId, 1, MPI_CHAR, HEAD, 0);
		COMM_WORLD.Recv(&m->startRow, 1, MPI_CHAR, HEAD, 0);
		COMM_WORLD.Recv(&m->startCol, 1, MPI_CHAR, HEAD, 0);
		COMM_WORLD.Recv(&m->endRow, 1, MPI_CHAR, HEAD, 0);
		COMM_WORLD.Recv(&m->endCol, 1, MPI_CHAR, HEAD, 0);
		COMM_WORLD.Recv(&m->boardScore, 1, MPI_INT, HEAD, 0);
		set->moves[i] = m;
	}
	
	//Return MoveSet
	return set;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x3797(%rip), %rax      # 0xbfd0
movq 0x8(%rax), %r9
movq $0x0, (%rsp)
movq 0x378c(%rip), %rdx      # 0xbfd8
leaq -0x2c(%rbp), %r14
movq %r14, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
movl $0x10, %edi
callq 0x1140
movq %rax, %r15
movslq (%r14), %r14
movl %r14d, 0x4(%rax)
movl %r14d, (%rax)
leaq (,%r14,8), %rdi
callq 0x1140
movq %r15, -0x38(%rbp)
movq %rax, 0x8(%r15)
testq %r14, %r14
jle 0x898b
xorl %r12d, %r12d
movq 0x370f(%rip), %r15      # 0xbfb0
xorl %r14d, %r14d
movq %rax, -0x40(%rbp)
movl $0xc, %edi
callq 0x1140
movq %rax, %r13
movq 0x3714(%rip), %rbx      # 0xbfd0
movq 0x8(%rbx), %r9
movq %r12, (%rsp)
movq %rax, %rdi
movl $0x1, %esi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
leaq 0x1(%r13), %rdi
movq 0x8(%rbx), %r9
movq %r12, (%rsp)
movl $0x1, %esi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
leaq 0x2(%r13), %rdi
movq 0x8(%rbx), %r9
movq %r12, (%rsp)
movl $0x1, %esi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
leaq 0x3(%r13), %rdi
movq 0x8(%rbx), %r9
movq %r12, (%rsp)
movl $0x1, %esi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
leaq 0x4(%r13), %rdi
movq 0x8(%rbx), %r9
movq %r12, (%rsp)
movl $0x1, %esi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
leaq 0x8(%r13), %rdi
movq 0x8(%rbx), %r9
movq %r12, (%rsp)
movl $0x1, %esi
movq 0x366f(%rip), %rdx      # 0xbfd8
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
movq -0x40(%rbp), %rax
movq %r13, (%rax,%r14,8)
incq %r14
movslq -0x2c(%rbp), %rcx
cmpq %rcx, %r14
jl 0x88a8
movq -0x38(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/upcrob[P]garry/moves.c
// Function: receiveMove()
Move* receiveMove()
{
	Move* m = (Move*) malloc(sizeof(Move));
	COMM_WORLD.Recv(&m->pieceId, 1, MPI_CHAR, HEAD, 0);
	COMM_WORLD.Recv(&m->startRow, 1, MPI_CHAR, HEAD, 0);
	COMM_WORLD.Recv(&m->startCol, 1, MPI_CHAR, HEAD, 0);
	COMM_WORLD.Recv(&m->endRow, 1, MPI_CHAR, HEAD, 0);
	COMM_WORLD.Recv(&m->endCol, 1, MPI_CHAR, HEAD, 0);
	COMM_WORLD.Recv(&m->boardScore, 1, MPI_INT, HEAD, 0);
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0xc, %edi
callq 0x1140
movq %rax, %rbx
movq 0x35a9(%rip), %r15      # 0xbfd0
movq 0x8(%r15), %r9
xorl %r12d, %r12d
movq %r12, (%rsp)
movq 0x3577(%rip), %r14      # 0xbfb0
movq %rax, %rdi
movl $0x1, %esi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
leaq 0x1(%rbx), %rdi
movq 0x8(%r15), %r9
movq %r12, (%rsp)
movl $0x1, %esi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
leaq 0x2(%rbx), %rdi
movq 0x8(%r15), %r9
movq %r12, (%rsp)
movl $0x1, %esi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
leaq 0x3(%rbx), %rdi
movq 0x8(%r15), %r9
movq %r12, (%rsp)
movl $0x1, %esi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
leaq 0x4(%rbx), %rdi
movq 0x8(%r15), %r9
movq %r12, (%rsp)
movl $0x1, %esi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
leaq 0x8(%rbx), %rdi
movq 0x8(%r15), %r9
movq %r12, (%rsp)
movq 0x34ff(%rip), %rdx      # 0xbfd8
movl $0x1, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %eax, %eax
movb (%rdi,%rax), %cl
movb (%rsi,%rax), %dl
testb %cl, %cl
je 0x8b0f
incq %rax
cmpb %dl, %cl
je 0x8afe
xorl %eax, %eax
orb %cl, %dl
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, -0x48(%rbp)
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdi, %r13
callq 0x1080
testq %rax, %rax
je 0x15ce
movq %rax, %rbx
movq %rax, %rdi
callq 0x1100
testq %rax, %rax
je 0x15b8
movq %rax, %r14
cmpq $0x0, (%r14)
je 0x15a4
movq %r13, %rdi
callq 0x1090
movq %rax, %r15
leaq 0x13(%r14), %r12
movq %r12, %rdi
callq 0x1090
leaq (%r15,%rax), %rdi
addq $0x2, %rdi
callq 0x1110
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
callq 0x1040
cmpb $0x2e, 0x13(%r14)
jne 0x1579
cmpb $0x0, 0x14(%r14)
je 0x159c
cmpb $0x2e, 0x14(%r14)
jne 0x1579
cmpb $0x0, 0x15(%r14)
je 0x159c
movq %r15, %rdi
movq %r12, %rsi
callq 0x1170
movq %r15, %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r8
callq 0x15e8
movq %r15, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1100
movq %rax, %r14
testq %rax, %rax
jne 0x1525
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
leaq 0x1a9d(%rip), %rdi      # 0x3072
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1140
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movl %edx, %r15d
movq %rdi, %rbx
movb (%rsi), %al
testb %al, %al
je 0x1a33
movq %rsi, %r12
incq %r12
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a7d
movq %rax, %rbx
movb (%r12), %al
incq %r12
testb %al, %al
jne 0x1a18
incl (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1a56
leaq -0x24(%rbp), %r12
movl %r15d, %esi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1ba3
movl (%r12), %ecx
jmp 0x1a66
movl %r15d, %edi
movq %r14, %rsi
callq 0x1b45
movl $0x1, %ecx
movq %rax, 0x10(%rbx)
addl %ecx, 0x4(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/devkot[P]SearchEngine/Crawler/trie.c
// Function: addToPostingList
PostingListNode * addToPostingList(PostingListNode *head, int lineNumber, int *newDoc, char *fileName){
    PostingListNode *newNode, *lineNode;

    if(!strcmp(head->fileName, fileName) && (head->lineNumber == lineNumber)) {
        (head->n)++;            // simply increase frequency

        *newDoc = 0;            // do not count this doc as new doc the word has appeared into

        return head;
    }
    else if (!strcmp(head->fileName, fileName) && (head->lineNumber != lineNumber)){  // if this is not the first time the word is found in the document /head->fileName == fileName
        lineNode = (PostingListNode *) malloc(sizeof(PostingListNode));
        lineNode->fileName = (char *) malloc(strlen(fileName) + 2);

        lineNode->lineNumber = lineNumber;
        lineNode->n = head->n + 1;
        strcpy(lineNode->fileName, fileName);
        lineNode->next       = head;

        *newDoc = 0;            // do not count this doc as new doc the word has appeared into

        return lineNode;            // head remains as is
    }
    else{                       // if this is the first time the word is found in the document
        newNode = (PostingListNode *) malloc(sizeof(PostingListNode));
        newNode->fileName = (char *) malloc(strlen(fileName) + 2);

        newNode->lineNumber = lineNumber;   // node points to the document the word is in
        newNode->n          = 1;            // frequency of the word inside the document is 1, since it is its first appearance
//        newNode->fileName   = fileName;     // set the fileName
        strcpy(newNode->fileName, fileName);
        newNode->next       = head;         // next node of the new node is the old head

        *newDoc = 1;            // make sure we count this doc in the unique docs the word has appeared

        return newNode;         // new node becomes the new head of the list
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %r12d
movq %rdi, %r14
movq (%rdi), %rdi
movq %rcx, %rsi
callq 0x10f0
testl %eax, %eax
je 0x1c10
movl $0x18, %edi
callq 0x1110
movq %rax, %r13
movq %r15, %rdi
callq 0x1090
leaq 0x2(%rax), %rdi
callq 0x1110
movq %rax, (%r13)
movl %r12d, 0x8(%r13)
movl $0x1, 0xc(%r13)
movq %rax, %rdi
movq %r15, %rsi
callq 0x1040
movq %r14, 0x10(%r13)
movl $0x1, %eax
jmp 0x1c5f
cmpl %r12d, 0x8(%r14)
jne 0x1c1e
incl 0xc(%r14)
xorl %eax, %eax
jmp 0x1c62
movl $0x18, %edi
callq 0x1110
movq %rax, %r13
movq %r15, %rdi
callq 0x1090
leaq 0x2(%rax), %rdi
callq 0x1110
movq %rax, (%r13)
movl %r12d, 0x8(%r13)
movl 0xc(%r14), %ecx
incl %ecx
movl %ecx, 0xc(%r13)
movq %rax, %rdi
movq %r15, %rsi
callq 0x1040
movq %r14, 0x10(%r13)
xorl %eax, %eax
movq %r13, %r14
movl %eax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/devkot[P]SearchEngine/Crawler/trie.c
// Function: searchTrie
TrieNode * searchTrie(TrieNode *root, char *word){
    TrieNode *curNode = root;

    if (!word)
        return NULL;

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

    return curNode;
}

// Assembly:
testq %rsi, %rsi
je 0x1cbf
movq %rdi, %rax
movb (%rsi), %cl
testb %cl, %cl
sete %dl
testq %rdi, %rdi
sete %dil
orb %dl, %dil
jne 0x1cc1
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x1cc2
cmpb %cl, (%rax)
jg 0x1cc2
je 0x1caa
movq 0x10(%rax), %rax
jmp 0x1c99
movq 0x8(%rax), %rax
movb 0x1(%rsi), %cl
testb %cl, %cl
je 0x1cc4
incq %rsi
testq %rax, %rax
jne 0x1c95
jmp 0x1cc4
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/devkot[P]SearchEngine/Crawler/trie.c
// Function: getPostingList
PostingListNode * getPostingList(TrieNode *root, char *word){
    TrieNode *node = searchTrie(root, word);

    if (node)
        return node->postingList;
    else
        return NULL;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x1c76
testq %rax, %rax
je 0x1cda
movq 0x10(%rax), %rax
jmp 0x1cdc
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/devkot[P]SearchEngine/Crawler/trie.c
// Function: destroyTrie
void destroyTrie(TrieNode *trieNode){
    TrieNodeList *cur, *prev;

    if (!trieNode)
        return;

    cur = prev = trieNode->charList;

    while (cur){
        destroyTrie(cur->node);
        cur = cur->next;
        free(prev);
        prev = cur;
    }

    destroyPostingList(trieNode->postingList);
    free(trieNode);
}

// Assembly:
testq %rdi, %rdi
je 0x1d31
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x1d16
movq 0x8(%r14), %rdi
callq 0x1cde
movq 0x10(%r14), %r15
movq %r14, %rdi
callq 0x1030
movq %r15, %r14
testq %r15, %r15
jne 0x1cf9
movq 0x10(%rbx), %rdi
callq 0x1d32
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O3/devkot[P]SearchEngine/Crawler/trie.c
// Function: destroyPostingList
void destroyPostingList(PostingListNode *postingListNode){
    if (!postingListNode)
        return;

    destroyPostingList(postingListNode->next);
    free(postingListNode->fileName);
    free(postingListNode);
}

// Assembly:
testq %rdi, %rdi
je 0x1d5f
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1d32
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O3/devkot[P]SearchEngine/Crawler/trie.c
// Function: getDocFrequency
int getDocFrequency(PostingListNode *head, char *fileName){
    PostingListNode *curNode = head;

    while (curNode){                     // while there are nodes to search

        if (!strcmp(fileName,curNode->fileName))    // if doc node is found
            return curNode->n;           // return frequency
        else if (strcmp(fileName,curNode->fileName) != 0) // if there are more nodes to search
            curNode = curNode->next;     // go to next
        else                             // else (there are more nodes actually, but since the list is in DESCENDING ORDER, there is no point to look further)
            return 0;                    // return zero (no such word found in specific doc id)
    }

    return 0;                            // default zero return value
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1d95
movq %rsi, %r15
movq %rdi, %r14
movq (%r14), %rsi
movq %r15, %rdi
callq 0x10f0
testl %eax, %eax
je 0x1d91
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x1d77
jmp 0x1d95
movl 0xc(%r14), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/devkot[P]SearchEngine/Crawler/helpers.c
// Function: isDuplicate
int isDuplicate(WordSearchNode *head, char *word){
    WordSearchNode *cur = head;
    int found = 0;

    while (cur && !found) {
        if (!strcmp(cur->word, word))
            found = 1;
        cur = cur->next;
    }

    return found;
}

// Assembly:
testq %rdi, %rdi
je 0x1ddc
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x10f0
movq 0x20(%r14), %r14
testq %r14, %r14
je 0x1dcf
testl %eax, %eax
jne 0x1db6
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
popq %rbx
popq %r14
popq %rbp
jmp 0x1dde
xorl %ecx, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/devkot[P]SearchEngine/Crawler/helpers.c
// Function: destroyWordSearchNodes
void destroyWordSearchNodes(WordSearchNode *head){
    WordSearchNode *curNode = head, *prevNode = head;

    while (curNode){
        curNode = curNode->next;
        free(prevNode->word);
        free(prevNode->fileName);
        free(prevNode->contents);
        free(prevNode);
        prevNode = curNode;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x1fc1
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %r14
callq 0x1030
movq (%rbx), %rdi
callq 0x1030
movq 0x10(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
testq %r14, %r14
jne 0x1f8f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/devkot[P]SearchEngine/Crawler/helpers.c
// Function: readLine
char *readLine(char *fileName, int lineNumber){
    FILE *file;
    char lineBuffer[100000], *line = NULL;
    int curLine = 0;

    file = fopen(fileName, "r");                        // Open file

    if (file == NULL){
        perror("fopen");
        exit(EXIT_FAILURE);
    }

    while(fgets(lineBuffer, 99999, file)) {
        if(curLine == lineNumber) {                     // read the line we need
            line = (char *) malloc(strlen(lineBuffer) + 1);
            strcpy(line, lineBuffer);                   // copy our desired line from buffer
            break;
        }
        curLine++;
    }

    fclose(file);
    return line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x186a0, %rsp          # imm = 0x186A0
movl %esi, %r14d
leaq 0x109d(%rip), %rsi      # 0x307b
callq 0x1130
testq %rax, %rax
je 0x2077
movq %rax, %rbx
leaq -0x186c0(%rbp), %rdi
movl $0x1869f, %esi          # imm = 0x1869F
movq %rax, %rdx
callq 0x10d0
testq %rax, %rax
je 0x2031
incl %r14d
leaq -0x186c0(%rbp), %r12
xorl %r15d, %r15d
decl %r14d
je 0x2036
movq %r12, %rdi
movl $0x1869f, %esi          # imm = 0x1869F
movq %rbx, %rdx
callq 0x10d0
testq %rax, %rax
jne 0x2015
jmp 0x205c
xorl %r15d, %r15d
jmp 0x205c
leaq -0x186c0(%rbp), %r14
movq %r14, %rdi
callq 0x1090
leaq 0x1(%rax), %rdi
callq 0x1110
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1040
movq %rbx, %rdi
callq 0x1070
movq %r15, %rax
addq $0x186a0, %rsp          # imm = 0x186A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x11d8
// File: /workspace/github_c_makefile_star2_O3/LuaJIT[P]LuaJIT/src/host/minilua.c
// Function: luaH_get
static const TValue*luaH_get(Table*t,const TValue*key){
switch(ttype(key)){
case 0:return(&luaO_nilobject_);
case 4:return luaH_getstr(t,rawtsvalue(key));
case 3:{
int k;
lua_Number n=nvalue(key);
lua_number2int(k,n);
if(luai_numeq(cast_num(k),nvalue(key)))
return luaH_getnum(t,k);
}
/*fallthrough*/
default:{
Node*n=mainposition(t,key);
do{
if(luaO_rawequalObj(key2tval(n),key))
return gval(n);
else n=gnext(n);
}while(n);
return(&luaO_nilobject_);
}
}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x8(%rsi), %eax
leaq 0xdc0c(%rip), %rbx      # 0x15498
testl %eax, %eax
je 0x792d
movq %rsi, %r14
cmpl $0x3, %eax
je 0x78dc
cmpl $0x4, %eax
jne 0x78ff
movq (%r14), %rax
movb 0xb(%rdi), %cl
movq $-0x1, %rdx
shlq %cl, %rdx
notl %edx
andl 0xc(%rax), %edx
movslq %edx, %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x3, %rcx
addq 0x20(%rdi), %rcx
cmpl $0x4, 0x18(%rcx)
jne 0x78d1
cmpq %rax, 0x10(%rcx)
je 0x792a
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
jne 0x78c5
jmp 0x792d
movsd (%r14), %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x78ff
jp 0x78ff
cvttsd2si %xmm0, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x798b
movq %r14, %rsi
callq 0x7a06
movq %rax, %r15
leaq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x7ab9
testl %eax, %eax
jne 0x7925
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x790a
jmp 0x792d
movq %r15, %rbx
jmp 0x792d
movq %rcx, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: inputMethodText
void inputMethodText()
{
  char            c;
  methodLineNo = lineNo;

  p = inputBuffer;
  while(1)
  {
    while((c = lstReadOneCharacter()) != '\n')
      *p++ = c;
    *p++ = '\n';
    if((c = lstReadOneCharacter()) == '!')
    {
      if((c = lstReadOneCharacter()) == '\n')
      {
        *p = '\0';
        return;
      }
      *p++ = '!';
      *p++ = c;
    }
    else
      *p++ = c;
  }
}

// Assembly:
pushq %rax
movl 0x2ed27(%rip), %eax     # 0x30268
movl %eax, 0x2ed25(%rip)     # 0x3026c
leaq 0x6c02(%rip), %rax      # 0x8150
movq %rax, 0x7bfb(%rip)      # 0x9150
callq 0x1514
cmpb $0xa, %al
je 0x1574
movq 0x7beb(%rip), %rcx      # 0x9150
leaq 0x1(%rcx), %rdx
movq %rdx, 0x7be0(%rip)      # 0x9150
movb %al, (%rcx)
jmp 0x1555
movq 0x7bd5(%rip), %rax      # 0x9150
leaq 0x1(%rax), %rcx
movq %rcx, 0x7bca(%rip)      # 0x9150
movb $0xa, (%rax)
callq 0x1514
cmpb $0x21, %al
jne 0x155e
callq 0x1514
movq 0x7bb2(%rip), %rcx      # 0x9150
cmpb $0xa, %al
je 0x15b2
leaq 0x1(%rcx), %rdx
movq %rdx, 0x7ba3(%rip)      # 0x9150
movb $0x21, (%rcx)
jmp 0x155e
movb $0x0, (%rcx)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: skipSpaces
void skipSpaces()
{
  while((*p == ' ') || (*p == '\t') || (*p == '\n') || (*p == '\r'))
    p++;
  if(*p == '\"')
  {
    p++;
    while(*p && (*p != '\"'))
      p++;
    if(*p != '\"')
      parseError("unterminated comment");
    p++;
    skipSpaces();
  }
}

// Assembly:
pushq %rax
movq 0x7b91(%rip), %rax      # 0x9150
movabsq $0x100002600, %rcx      # imm = 0x100002600
movzbl (%rax), %edx
cmpq $0x22, %rdx
ja 0x160f
btq %rdx, %rcx
jae 0x15e4
incq %rax
movq %rax, 0x7b6e(%rip)      # 0x9150
jmp 0x15c9
cmpq $0x22, %rdx
jne 0x160f
incq %rax
movq %rax, 0x7b5c(%rip)      # 0x9150
movzbl (%rax), %edx
incq %rax
cmpl $0x22, %edx
je 0x15db
testl %edx, %edx
jne 0x15ed
leaq 0x3a89(%rip), %rdi      # 0x5093
callq 0x13c6
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: readBinary
void readBinary()
{
  tokenBuffer[0] = *p++;
  if(isBinary(*p))
  {
    tokenBuffer[1] = *p++;
    tokenBuffer[2] = '\0';
  }
  else
    tokenBuffer[1] = '\0';
  skipSpaces();
}

// Assembly:
pushq %rbx
movq 0x7af7(%rip), %rbx      # 0x9150
leaq 0x1(%rbx), %rax
movq %rax, 0x7aec(%rip)      # 0x9150
movb (%rbx), %al
movb %al, 0x2ec04(%rip)      # 0x30270
movsbl 0x1(%rbx), %edi
callq 0x1631
testl %eax, %eax
je 0x1690
leaq 0x2(%rbx), %rax
movq %rax, 0x7acc(%rip)      # 0x9150
movb 0x1(%rbx), %al
movb $0x0, 0x2ebe4(%rip)     # 0x30272
jmp 0x1692
xorl %eax, %eax
movb %al, 0x2ebd9(%rip)      # 0x30271
popq %rbx
jmp 0x15b7
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: readIdentifier
int readIdentifier()
{
  int             keyflag;
  char           *q = tokenBuffer;

  while(isIdentifierChar(*p) || isDigit(*p))
    *q++ = *p++;
  *q = '\0';
  if(*p == ':')
  {                             /* It's a keyword identifier */
    keyflag = 1;
    *q++ = ':';
    *q = '\0';
    p++;
  }
  else
    keyflag = 0;
  skipSpaces();
  return keyflag;
}

// Assembly:
pushq %rbx
movq 0x7aaa(%rip), %rax      # 0x9150
movb (%rax), %cl
leal -0x3a(%rcx), %edx
cmpb $-0xb, %dl
ja 0x16c4
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1a, %cl
jae 0x16c4
leaq 0x2ebae(%rip), %rcx     # 0x30270
jmp 0x16f9
incq %rax
leaq 0x2eba2(%rip), %rcx     # 0x30270
movq %rax, 0x7a7b(%rip)      # 0x9150
movb -0x1(%rax), %dl
movb %dl, (%rcx)
incq %rcx
movb (%rax), %dl
leal -0x3a(%rdx), %esi
incq %rax
cmpb $-0xb, %sil
ja 0x16ce
andb $-0x21, %dl
addb $-0x5b, %dl
cmpb $-0x1b, %dl
ja 0x16ce
decq %rax
movb $0x0, (%rcx)
xorl %ebx, %ebx
cmpb $0x3a, (%rax)
jne 0x1717
movw $0x3a, (%rcx)
incq %rax
movq %rax, 0x7a3e(%rip)      # 0x9150
movl $0x1, %ebx
callq 0x15b7
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: readInteger
int readInteger()
{
  int             val,
                  neg = 0;

  if(*p == '-')
  {
    neg = 1;
    ++p;
  }
  val = *p++ - '0';
  while(isDigit(*p))
  {
    val = 10 * val + (*p++ - '0');
  }
  skipSpaces();
  return neg ? -val : val;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x7a25(%rip), %rax      # 0x9150
movb (%rax), %bl
xorl %ecx, %ecx
cmpb $0x2d, %bl
sete %cl
leaq (%rax,%rcx), %rdx
incq %rdx
movq %rdx, 0x7a0d(%rip)      # 0x9150
movsbl -0x1(%rdx), %r14d
addl $-0x30, %r14d
movb (%rdx), %dl
addb $-0x3a, %dl
cmpb $-0xa, %dl
jb 0x1781
addq %rcx, %rax
addq $0x2, %rax
leal (%r14,%r14,4), %ecx
movq %rax, 0x79e8(%rip)      # 0x9150
movsbl -0x1(%rax), %edx
leal (%rdx,%rcx,2), %r14d
addl $-0x30, %r14d
movb (%rax), %cl
addb $-0x3a, %cl
incq %rax
cmpb $-0xb, %cl
ja 0x175d
callq 0x15b7
movl %r14d, %eax
negl %eax
cmpb $0x2d, %bl
cmovnel %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: newSymbol
struct object  *newSymbol(char *text)
{
  LstUInt            i;
  struct byteObject *result;

  /*
     first see if it is already a symbol 
   */
  for(i = 0; i < symbolTop; i++)
  {
    if(symbolBareCmp
       ((char *) text, strlen(text), (char *) bytePtr(oldSymbols[i]),
        SIZE(oldSymbols[i])) == 0)
    {
      return oldSymbols[i];
    }
  }

  /*
     not there, make a new one 
   */
  result = binaryAlloc(strlen(text)); /* FIXME: Shouldn't we allocate one more byte? */
  for(i = 0; i < strlen(text); i++)
  {
    result->bytes[i] = text[i];
  }
  result->bytes[i] = 0;
  result->class = lookupGlobal("Symbol", 0);
  oldSymbols[symbolTop++] = (struct object *) result;
  return (struct object *) result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x2eaa5(%rip), %r15d    # 0x302c0
testq %r15, %r15
je 0x186e
movq %rbx, %rdi
callq 0x1090
xorl %ecx, %ecx
leaq 0x2ea9f(%rip), %rdx     # 0x302d0
movq (%rdx,%rcx,8), %r14
movl (%r14), %esi
shrl $0x2, %esi
cmpl %eax, %esi
movl %eax, %edi
cmovll %esi, %edi
testl %edi, %edi
jle 0x185e
movl %edi, %edi
xorl %r8d, %r8d
movb (%rbx,%r8), %r9b
cmpb 0x10(%r14,%r8), %r9b
jne 0x1866
incq %r8
cmpq %r8, %rdi
jne 0x184b
cmpl %eax, %esi
je 0x18e9
incq %rcx
cmpq %r15, %rcx
jne 0x1831
movq %rbx, %rdi
callq 0x1090
movq %rax, %r15
leal 0x7(%rax), %edi
andl $-0x8, %edi
callq 0x12bb
movq %rax, %r14
leal 0x2(,%r15,4), %eax
movl %eax, (%r14)
movq %rbx, %rdi
callq 0x1090
testq %rax, %rax
je 0x18b5
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, 0x10(%r14,%rcx)
incq %rcx
movl %ecx, %edx
cmpq %rdx, %rax
ja 0x18a1
jmp 0x18b7
xorl %edx, %edx
movb $0x0, 0x10(%r14,%rdx)
leaq 0x37e4(%rip), %rdi      # 0x50a8
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r14)
movl 0x2e9eb(%rip), %eax     # 0x302c0
leal 0x1(%rax), %ecx
movl %ecx, 0x2e9e2(%rip)     # 0x302c0
leaq 0x2e9eb(%rip), %rcx     # 0x302d0
movq %r14, (%rcx,%rax,8)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: newNode
struct object  *newNode(struct object *v, struct object *l, struct object *r)
{
  struct object  *result;

  result = gcalloc(3);
  result->class = lookupGlobal("Node", 0);
  result->data[0] = v;
  result->data[1] = l;
  result->data[2] = r;
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x3, %edi
callq 0x12bb
movq %rax, %r12
leaq 0x376d(%rip), %rdi      # 0x50af
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r12)
movq %r15, 0x10(%r12)
movq %r14, 0x18(%r12)
movq %rbx, 0x20(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: newDictionary
struct object  *newDictionary(void)
{
  struct object  *result;

  result = gcalloc(2);
  result->class = lookupGlobal("Dictionary", 0);
  result->data[0] = newOrderedArray();
  result->data[1] = newArray(0);
  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x2, %edi
callq 0x12bb
movq %rax, %rbx
leaq 0x3710(%rip), %rdi      # 0x50b9
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
xorl %edi, %edi
callq 0x12bb
movq %rax, %r14
leaq 0x37ba(%rip), %rdi      # 0x517f
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r14)
movq %r14, 0x10(%rbx)
xorl %edi, %edi
callq 0x12bb
movq %rax, %r14
leaq 0x37a1(%rip), %rdi      # 0x5186
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r14)
movq %r14, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: newArray
struct object  *newArray(int size)
{
  struct object  *result;
  int             i;

  result = gcalloc(size);
  result->class = lookupGlobal("Array", 0);
  for(i = 0; i < size; ++i)
  {
    result->data[i] = nilObject;
  }
  return (result);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x12bb
movq %rax, %r14
leaq 0x3750(%rip), %rdi      # 0x5186
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%r14)
testl %ebx, %ebx
jle 0x1adf
movq 0x66f0(%rip), %rax      # 0x8140
movl %ebx, %ecx
incl %ebx
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl %ebx
shlq $0x4, %rbx
movdqa 0x35a1(%rip), %xmm1     # 0x5010
xorl %ecx, %ecx
movdqa 0x35a7(%rip), %xmm2     # 0x5020
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x35a7(%rip), %xmm4     # 0x5030
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x1abf
movq %rax, 0x10(%r14,%rcx)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x1ad2
movq %rax, 0x18(%r14,%rcx)
paddq %xmm4, %xmm1
addq $0x10, %rcx
cmpq %rcx, %rbx
jne 0x1a89
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: genVal
void genVal(int v)
{
  if((v < 0) || (v > 0xFFFF))
  {
    sysError("illegal value", "");
  }
  genByte(v & 0xFF);
  genByte(v >> 8);
}

// Assembly:
pushq %rbx
cmpl $0x10000, %edi          # imm = 0x10000
jae 0x1b52
movl %edi, %ebx
movzbl %bl, %edi
callq 0x1aea
shrl $0x8, %ebx
movl %ebx, %edi
popq %rbx
jmp 0x1aea
leaq 0x34e7(%rip), %rdi      # 0x5040
leaq 0x3577(%rip), %rsi      # 0x50d7
leaq 0x3a0b(%rip), %rdx      # 0x5572
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: genValPos
void genValPos(int pos, int v)
{
  if((v < 0) || (v > 0xFFFF))
  {
    sysError("illegal value", "");
  }
  byteBuffer[pos] = v & 0xFF;
  byteBuffer[pos + 1] = v >> 8;
}

// Assembly:
cmpl $0x10000, %esi          # imm = 0x10000
jae 0x1b8f
movslq %edi, %rax
leaq 0x38386(%rip), %rcx     # 0x39f10
movw %si, (%rax,%rcx)
retq
pushq %rax
leaq 0x34a9(%rip), %rdi      # 0x5040
leaq 0x3539(%rip), %rsi      # 0x50d7
leaq 0x39cd(%rip), %rdx      # 0x5572
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: buildByteArray
struct object  *buildByteArray()
{
  struct byteObject *newObj;
  LstUInt            i;

  newObj = binaryAlloc(byteTop);
  for(i = 0; i < byteTop; i++)
    newObj->bytes[i] = byteBuffer[i];
  newObj->class = lookupGlobal("ByteArray", 0);
  return (struct object *) newObj;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x3852f(%rip), %r14d    # 0x3a110
leal 0x7(%r14), %edi
andl $-0x8, %edi
callq 0x12bb
movq %rax, %rbx
leal 0x2(,%r14,4), %eax
movl %eax, (%rbx)
movl 0x38510(%rip), %edx     # 0x3a110
testq %rdx, %rdx
je 0x1c18
movq %rbx, %rdi
addq $0x10, %rdi
leaq 0x382fd(%rip), %rsi     # 0x39f10
callq 0x10f0
leaq 0x34c6(%rip), %rdi      # 0x50e5
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: addLiteral
int addLiteral(struct object *a)
{
  litBuffer[litTop++] = a;
  if(litTop >= LiteralBufferTop)
  {
    sysError("too many literals", "");
  }
  return litTop - 1;
}

// Assembly:
movl 0x384d9(%rip), %eax     # 0x3a114
leal 0x1(%rax), %ecx
movl %ecx, 0x384d0(%rip)     # 0x3a114
leaq 0x384d5(%rip), %rdx     # 0x3a120
movq %rdi, (%rdx,%rax,8)
cmpl $0x64, %ecx
jae 0x1c55
retq
pushq %rax
leaq 0x33e3(%rip), %rdi      # 0x5040
leaq 0x348b(%rip), %rsi      # 0x50ef
leaq 0x3907(%rip), %rdx      # 0x5572
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O3/GregorR[P]lstg/ImageBuilder/imageBuilder.c
// Function: buildLiteralArray
struct object  *buildLiteralArray(void)
{
  LstUInt         i;
  struct object  *result;

  if(litTop == 0)
    return nilObject;
  result = gcalloc(litTop);
  result->class = lookupGlobal("Array", 0);
  for(i = 0; i < litTop; i++)
    result->data[i] = litBuffer[i];
  return result;
}

// Assembly:
pushq %rbx
movl 0x38491(%rip), %edi     # 0x3a114
testl %edi, %edi
je 0x1cc5
callq 0x12bb
movq %rax, %rbx
leaq 0x34f0(%rip), %rdi      # 0x5186
xorl %esi, %esi
callq 0x1496
movq %rax, 0x8(%rbx)
movl 0x3846d(%rip), %edx     # 0x3a114
testq %rdx, %rdx
je 0x1ccc
movq %rbx, %rdi
addq $0x10, %rdi
shlq $0x3, %rdx
leaq 0x38462(%rip), %rsi     # 0x3a120
callq 0x10f0
jmp 0x1ccc
movq 0x6474(%rip), %rbx      # 0x8140
movq %rbx, %rax
popq %rbx
retq