LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Wheatwizard[P]Waldo/Waldo.cpp
// Function: Waldo::sync(Reactor&)
void Waldo::sync( Reactor& board) {
	bool unsync = false;
	for ( unsigned i = 0; i < board.getNumWaldos(); ++i ) {
		Waldo& waldo = board.getWaldo(i);
		if (waldo.paused) {
			unsync = true;
			waldo.paused = false;
		}
	}
	this->paused = !unsync;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7c30
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jae 0x786e
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x6520
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x3c(%rax)
je 0x7861
movb $0x1, -0x11(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, 0x3c(%rax)
jmp 0x7863
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7823
movq -0x28(%rbp), %rax
movb -0x11(%rbp), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x3c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Wheatwizard[P]Waldo/Waldo.cpp
// Function: Waldo::grabDrop(Reactor&)
void Waldo::grabDrop( Reactor& board) {
	if (holding) {
		drop();
	} else {
		grab(board);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x30(%rax)
je 0x792a
movq -0x18(%rbp), %rdi
callq 0x7890
jmp 0x7937
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x78b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Wheatwizard[P]Waldo/Waldo.cpp
// Function: Waldo::move(Reactor&, Direction)
void Waldo::move( Reactor& board, Direction direction) {
	if (paused) return;
	int dr = 0, dc = 0;
	switch (direction) {
		case DOWN :
			dr = (r+1 != board.getNumRows());
			break;
		case UP :
			dr = -(r != 0);
			break;
		case RIGHT :
			dc = (c+1 != board.getNumCols());
			break;
		case LEFT :
			dc = -(c != 0);
			break;
		case NO_DIRECTION :
			break;
	}
	//Pop current molecule off the board
	board.popAtom(holding, r, c);	
	//Move Waldo
	r += dr;
	c += dc;
	//Put Molecule on the board
	board.dropAtom(holding, r, c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x3c(%rax)
je 0x7a96
jmp 0x7b91
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x4, %rax
ja 0x7b51
movq -0x30(%rbp), %rax
leaq 0x37fc(%rip), %rcx      # 0xb2bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2970
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
jmp 0x7b51
movq -0x28(%rbp), %rax
cmpl $0x0, 0x20(%rax)
setne %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x7b51
movq -0x28(%rbp), %rax
movl 0x24(%rax), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6700
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7b51
movq -0x28(%rbp), %rax
cmpl $0x0, 0x24(%rax)
setne %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7b51
jmp 0x7b51
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x30(%rax), %rsi
movl 0x20(%rax), %edx
movl 0x24(%rax), %ecx
callq 0x5fe0
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movl -0x1c(%rbp), %ecx
addl 0x24(%rax), %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rdi
movq 0x30(%rax), %rsi
movl 0x20(%rax), %edx
movl 0x24(%rax), %ecx
callq 0x6180
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Wheatwizard[P]Waldo/Waldo.cpp
// Function: Waldo::rotate(Reactor&, Rotation)
void Waldo::rotate( Reactor& board, Rotation direction) {
	//Pop the current molecule off the board
	board.popAtom(holding, r, c);
	//Rotate the molecule
	holding->rotate(direction);
	//Put the molecule on the board
	board.dropAtom(holding, r, c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq 0x30(%rax), %rsi
movl 0x20(%rax), %edx
movl 0x24(%rax), %ecx
callq 0x5fe0
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x2da0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x30(%rax), %rsi
movl 0x20(%rax), %edx
movl 0x24(%rax), %ecx
callq 0x6180
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Wheatwizard[P]Waldo/Environment.cpp
// Function: Environment::advance()
void Environment::advance() {
	++cycles;
	for (unsigned i = 0; i < reactors.size(); ++i) {
		reactors[i].advance(cycles);
	}
	for (unsigned i = 0; i < pipes.size(); ++i) {
		pipes[i].advance();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
callq 0x7d90
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x7cb8
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x7db0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x5ed0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7c74
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
callq 0x7dd0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x7d04
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x7df0
movq %rax, %rdi
callq 0x7e10
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7cbf
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Wheatwizard[P]Waldo/Pipe.cpp
// Function: Pipe::advance()
void Pipe::advance() {
	//Move everything from the inQ to the outQ
	while (!inQ.empty()) {
		outQ.push(inQ.front());
		inQ.pop();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x91b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x9175
jmp 0x91a0
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0x50, %rax
movq %rax, -0x18(%rbp)
callq 0x9200
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x91d0
movq -0x10(%rbp), %rdi
callq 0x9220
jmp 0x9164
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Wheatwizard[P]Waldo/Well.cpp
// Function: Well::pop()
Capsule Well::pop() {
	Capsule result = *locationMarker;
	++locationMarker;
	//I should probably make a Well iterator
	if (locationMarker == loopPath.end() || locationMarker == startPath.end()) {
		locationMarker = loopPath.begin();
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movb $0x0, -0x11(%rbp)
addq $0x30, %rdi
callq 0xa290
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rdi
callq 0xa2b0
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
callq 0xa310
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xa2d0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0xa23f
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x60(%rbp)
callq 0xa310
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xa2d0
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xa248
jmp 0xa268
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0xa340
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xa27b
movq -0x50(%rbp), %rdi
callq 0x90f0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: gogakoreli[P]snake/main.cpp
// Function: is_game_end()
bool is_game_end()
{
    bool result = false;
    pair<int, int> snake_head = snake.snake_head;
    if (snake_head.first < 0 || snake_head.first >= MAP_HEIGHT || snake_head.second < 0 || snake_head.second >= MAP_WIDTH)
    {
        result = true;
    }
    if (snake.is_dead)
    {
        result = true;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, -0x1(%rbp)
movq 0x5cd1(%rip), %rax      # 0x7130
movq %rax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x147b
cmpl $0x14, -0xc(%rbp)
jge 0x147b
cmpl $0x0, -0x8(%rbp)
jl 0x147b
cmpl $0x14, -0x8(%rbp)
jl 0x147f
movb $0x1, -0x1(%rbp)
testb $0x1, 0x5cb3(%rip)      # 0x7139
je 0x148c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gogakoreli[P]snake/main.cpp
// Function: start_game()
void start_game()
{
    while (true)
    {
        snake.update_movement();
        if (is_game_end())
        {
            game_over();
            break;
        }
        snake_map.redraw();

        usleep(PAUSE_LENGTH);

        snake.validate_direction();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x14d6
leaq 0x5c3b(%rip), %rdi      # 0x7118
callq 0x1af0
callq 0x1450
testb $0x1, %al
jne 0x14ed
jmp 0x14f4
callq 0x14a0
jmp 0x1518
leaq 0x62bd(%rip), %rdi      # 0x77b8
callq 0x3060
movl $0x30d40, %edi          # imm = 0x30D40
callq 0x1160
leaq 0x5c07(%rip), %rdi      # 0x7118
callq 0x1ac0
jmp 0x14d6
popq %rbp
retq
nopw (%rax,%rax)
// File: gogakoreli[P]snake/snake.cpp
// Function: input_thread_work(void*)
void *input_thread_work(void *arg)
{
    struct Snake *snake = (struct Snake *)arg;
    while (true)
    {
        enum Direction direction = get_input();
        snake->update_next_direction(direction);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x2e10
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x17c0
jmp 0x17a4
nopw (%rax,%rax)
// File: gogakoreli[P]snake/snake.cpp
// Function: Snake::Snake()
Snake::Snake(void)
{
    direction = East;
    next_direction = direction;
    food_eaten = false;
    is_dead = false;
    length = INITIAL_SNAKE_LENGTH;
    clear_snake_world();
    initialize_snake();
    sem_init(&snake_sema, 0, 1);
    pthread_create(&input_thread, NULL, input_thread_work, this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x1d40
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x1d60
jmp 0x180f
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
callq 0x1d60
jmp 0x181e
movq -0x28(%rbp), %rdi
movl $0x2, 0x50(%rdi)
movl 0x50(%rdi), %eax
movl %eax, 0x54(%rdi)
movb $0x0, 0x20(%rdi)
movb $0x0, 0x21(%rdi)
movl $0x3, 0x24(%rdi)
callq 0x18b0
jmp 0x1845
movq -0x28(%rbp), %rdi
callq 0x1920
jmp 0x1850
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x10a0
movq -0x28(%rbp), %rcx
movq %rcx, %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0xea(%rip), %rdx       # 0x1790
callq 0x11d0
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x1570
movq -0x10(%rbp), %rdi
callq 0x11c0
nopw %cs:(%rax,%rax)
// File: gogakoreli[P]snake/snake.cpp
// Function: Snake::initialize_snake()
void Snake::initialize_snake(void)
{
    for (int i = 0; i < INITIAL_SNAKE_LENGTH; i++)
    {
        pair<int, int> snake_part = make_pair(MAP_HEIGHT / 2, MAP_WIDTH / 2 - (INITIAL_SNAKE_LENGTH / 2) + i);
        snake_parts.push_back(snake_part);
        snake_world_array[snake_part.first][snake_part.second] = 1;
    }
    snake_head = snake_parts[snake_parts.size() - 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x1998
movl $0xa, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x9, %eax
movl %eax, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1fc0
movq -0x28(%rbp), %rdi
movq %rax, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x1e40
movq -0x28(%rbp), %rax
addq $0x60, %rax
movslq -0x14(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x193b
movq -0x28(%rbp), %rdi
callq 0x2010
movq -0x28(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x1ff0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x18, %rdi
callq 0x1e10
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gogakoreli[P]snake/snake.cpp
// Function: Snake::update_direction(Direction)
void Snake::update_direction(enum Direction direction)
{
    sem_wait(&this->snake_sema);
    switch (direction)
    {
    case West:
        if (this->direction != East)
        {
            this->direction = direction;
        }
        break;
    case North:
        if (this->direction != South)
        {
            this->direction = direction;
        }
        break;
    case East:
        if (this->direction != West)
        {
            this->direction = direction;
        }
        break;
    case South:
        if (this->direction != North)
        {
            this->direction = direction;
        }
        break;
    }
    sem_post(&this->snake_sema);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x30, %rdi
callq 0x1080
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x1a69
movq -0x18(%rbp), %rax
leaq 0x260c(%rip), %rcx      # 0x4014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
cmpl $0x2, 0x50(%rax)
je 0x1a25
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x50(%rax)
jmp 0x1a69
movq -0x20(%rbp), %rax
cmpl $0x3, 0x50(%rax)
je 0x1a3b
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x50(%rax)
jmp 0x1a69
movq -0x20(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x1a51
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x50(%rax)
jmp 0x1a69
movq -0x20(%rbp), %rax
cmpl $0x1, 0x50(%rax)
je 0x1a67
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x50(%rax)
jmp 0x1a69
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x11a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gogakoreli[P]snake/snake.cpp
// Function: Snake::get_direction()
enum Direction Snake::get_direction(void)
{
    enum Direction result = East;
    sem_wait(&this->snake_sema);
    result = this->direction;
    sem_post(&this->snake_sema);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x2, -0xc(%rbp)
addq $0x30, %rdi
callq 0x1080
movq -0x18(%rbp), %rdi
movl 0x50(%rdi), %eax
movl %eax, -0xc(%rbp)
addq $0x30, %rdi
callq 0x11a0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: gogakoreli[P]snake/input.cpp
// Function: get_input()
enum Direction get_input()
{
    enum Direction result = East;
    char user_input = getchar();
    switch (user_input)
    {
    case 'a':
        result = West;
        break;
    case 'w':
        result = North;
        break;
    case 'd':
        result = East;
        break;
    case 's':
        result = South;
        break;
    default:
        result = Error;
        cout << "Incorrect button clicked(" << user_input << ")" << endl;
        break;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2, -0x4(%rbp)
callq 0x1150
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x16, %eax
ja 0x2e71
movq -0x10(%rbp), %rax
leaq 0x120c(%rip), %rcx      # 0x4050
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x2eb5
movl $0x1, -0x4(%rbp)
jmp 0x2eb5
movl $0x2, -0x4(%rbp)
jmp 0x2eb5
movl $0x3, -0x4(%rbp)
jmp 0x2eb5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movq 0x4159(%rip), %rdi      # 0x6fd8
leaq 0x1226(%rip), %rsi      # 0x40ac
callq 0x10f0
movq %rax, %rdi
movsbl -0x5(%rbp), %esi
callq 0x1130
movq %rax, %rdi
leaq 0x1225(%rip), %rsi      # 0x40c6
callq 0x10f0
movq %rax, %rdi
movq 0x4118(%rip), %rsi      # 0x6fc8
callq 0x1110
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: gogakoreli[P]snake/snake_map.cpp
// Function: SnakeMap::SnakeMap(Snake*)
SnakeMap::SnakeMap(Snake *snake)
{
    this->snake = snake;
    clear_map(this->map_array);
    srand(time(NULL));
    update_snake_food(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1d60
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x198(%rdi)
addq $0x8, %rdi
callq 0x2f30
xorl %eax, %eax
movl %eax, %edi
callq 0x10c0
movl %eax, %edi
callq 0x10e0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2f90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gogakoreli[P]snake/snake_map.cpp
// Function: SnakeMap::update_snake_food(bool)
void SnakeMap::update_snake_food(bool force_update)
{
    if (snake->food_eaten || force_update)
    {
        while (true)
        {
            int random_i = rand() % MAP_WIDTH;
            int random_j = rand() % MAP_HEIGHT;
            if (map_array[random_i][random_j] == MAP_CHAR)
            {
                snake_food = make_pair(random_i, random_j);
                snake->set_snake_food(snake_food);
                snake->food_eaten = false;
                break;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x198(%rax), %rax
testb $0x1, 0x20(%rax)
jne 0x2fc3
testb $0x1, -0x9(%rbp)
je 0x3056
jmp 0x2fc5
callq 0x1030
movl $0x14, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
callq 0x1030
movl $0x14, %ecx
cltd
idivl %ecx
movq -0x30(%rbp), %rax
movl %edx, -0x14(%rbp)
addq $0x8, %rax
movslq -0x10(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x304f
leaq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x3410
movq -0x30(%rbp), %rdi
movq %rax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x1db0
movq -0x30(%rbp), %rax
movq 0x198(%rax), %rdi
movq (%rax), %rax
movq %rax, -0x24(%rbp)
movq -0x24(%rbp), %rsi
callq 0x1d10
movq -0x30(%rbp), %rax
movq 0x198(%rax), %rax
movb $0x0, 0x20(%rax)
jmp 0x3054
jmp 0x2fc5
jmp 0x3056
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: gogakoreli[P]snake/snake_map.cpp
// Function: SnakeMap::redraw()
void SnakeMap::redraw(void)
{
    clear_map(this->map_array);
    for (int i = 0; i < MAP_END; i++)
    {
        cout << endl;
    }
    update_score();
    vector<pair<int, int>> snake_parts = snake->snake_parts;
    for (int i = 0; i < snake_parts.size(); i++)
    {
        pair<int, int> tmp = snake_parts[i];
        map_array[tmp.first][tmp.second] = SNAKE_CHAR;
    }
    update_snake_head(map_array, snake);
    update_snake_food(false);
    map_array[snake_food.first][snake_food.second] = SNAKE_FOOD_CHAR;
    for (int i = 0; i < MAP_HEIGHT; i++)
    {
        for (int j = 0; j < MAP_WIDTH; j++)
        {
            cout << map_array[i][j] << " ";
        }
        cout << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
callq 0x2f30
movl $0x0, -0xc(%rbp)
cmpl $0x1e, -0xc(%rbp)
jge 0x30a8
movq 0x3f47(%rip), %rdi      # 0x6fd8
movq 0x3f30(%rip), %rsi      # 0x6fc8
callq 0x1110
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3084
movq -0x58(%rbp), %rdi
callq 0x3230
movq -0x58(%rbp), %rax
movq 0x198(%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x3320
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2010
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x3126
movslq -0x2c(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1ff0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x34(%rbp)
addq $0x8, %rax
movslq -0x34(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
movb $0x4f, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x30cc
movq -0x58(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x198(%rax), %rsi
callq 0x3290
jmp 0x313f
movq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x2f90
jmp 0x314c
movq -0x58(%rbp), %rcx
movq %rcx, %rax
addq $0x8, %rax
movslq (%rcx), %rdx
imulq $0x14, %rdx, %rdx
addq %rdx, %rax
movslq 0x4(%rcx), %rcx
movb $0x2a, (%rax,%rcx)
movl $0x0, -0x48(%rbp)
cmpl $0x14, -0x48(%rbp)
jge 0x320d
movl $0x0, -0x4c(%rbp)
cmpl $0x14, -0x4c(%rbp)
jge 0x31e8
movq -0x58(%rbp), %rax
movslq -0x48(%rbp), %rcx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,4), %rcx
movslq -0x4c(%rbp), %rax
movsbl 0x8(%rax,%rcx), %esi
movq 0x3e31(%rip), %rdi      # 0x6fd8
callq 0x1130
movq %rax, -0x68(%rbp)
jmp 0x31b2
movq -0x68(%rbp), %rdi
leaq 0xf1b(%rip), %rsi       # 0x40d8
callq 0x10f0
jmp 0x31c4
jmp 0x31c6
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x3181
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1570
jmp 0x321c
movq 0x3de9(%rip), %rdi      # 0x6fd8
movq 0x3dd2(%rip), %rsi      # 0x6fc8
callq 0x1110
jmp 0x31fd
jmp 0x31ff
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x3170
leaq -0x28(%rbp), %rdi
callq 0x1570
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x11c0
nopw %cs:(%rax,%rax)
// File: gogakoreli[P]snake/snake_map.cpp
// Function: update_snake_head(char (*) [20], Snake*)
void update_snake_head(char map_array[MAP_HEIGHT][MAP_WIDTH], Snake *snake)
{
    char snake_head_char = SNAKE_CHAR;
    enum Direction direction = snake->get_direction();
    switch (direction)
    {
    case West:
        snake_head_char = SNAKE_HEAD_WEST;
        break;
    case North:
        snake_head_char = SNAKE_HEAD_NORTH;
        break;
    case East:
        snake_head_char = SNAKE_HEAD_EAST;
        break;
    case South:
        snake_head_char = SNAKE_HEAD_SOUTH;
        break;
    }
    pair<int, int> snake_head = snake->snake_head;
    map_array[snake_head.first][snake_head.second] = snake_head_char;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x4f, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a80
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x3, %rax
ja 0x32e7
movq -0x28(%rbp), %rax
leaq 0xe00(%rip), %rcx       # 0x40c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x3e, -0x11(%rbp)
jmp 0x32e7
movb $0x76, -0x11(%rbp)
jmp 0x32e7
movb $0x3c, -0x11(%rbp)
jmp 0x32e7
movb $0x5e, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: conchoecia[P]fasta_stats/src/fasta_stats.cc
// Function: print_usage()
static void print_usage() {
	fprintf(stderr, "usage: fasta_stats [options] <fasta_file>\n");
	fprintf(stderr, "\t-b ##\tsize of big scaffold cutoff in kb [50]\n");
	fprintf(stderr, "\t-g ##\tminimum size bin to display for gaps [none]\n");
	fprintf(stderr, "\t-l ##\tminimum size bin to display [1000]\n");
	fprintf(stderr, "\t-N ##\texact length of N's to signal scaffold end [-1]\n");
	fprintf(stderr, "\t-n ##\tminimum length of N's to signal contig end [9]\n");
	exit(0);
}

// Assembly:
pushq %rax
movq 0x137a8(%rip), %rax     # 0x15fd0
movq (%rax), %rdi
leaq 0xc929(%rip), %rsi      # 0xf15b
movb $0x0, %al
callq 0x2380
movq 0x13790(%rip), %rax     # 0x15fd0
movq (%rax), %rdi
leaq 0xc93c(%rip), %rsi      # 0xf186
movb $0x0, %al
callq 0x2380
movq 0x13778(%rip), %rax     # 0x15fd0
movq (%rax), %rdi
leaq 0xc953(%rip), %rsi      # 0xf1b5
movb $0x0, %al
callq 0x2380
movq 0x13760(%rip), %rax     # 0x15fd0
movq (%rax), %rdi
leaq 0xc96f(%rip), %rsi      # 0xf1e9
movb $0x0, %al
callq 0x2380
movq 0x13748(%rip), %rax     # 0x15fd0
movq (%rax), %rdi
leaq 0xc982(%rip), %rsi      # 0xf214
movb $0x0, %al
callq 0x2380
movq 0x13730(%rip), %rax     # 0x15fd0
movq (%rax), %rdi
leaq 0xc9a2(%rip), %rsi      # 0xf24c
movb $0x0, %al
callq 0x2380
xorl %edi, %edi
callq 0x22e0
nopl (%rax,%rax)
// File: conchoecia[P]fasta_stats/src/fasta_stats.cc
// Function: scaled_print(long)
static void scaled_print(long i) {
	if (i > 999999) {
		printf("%.1f MB", (double)i / 1000000);
	} else if (i > 999) {
		printf("%.1f KB", (double)i / 1000);
	} else {
		printf("%ld", i);
	}
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0xf423f, (%rsp)        # imm = 0xF423F
jle 0x4751
cvtsi2sdq (%rsp), %xmm0
movsd 0xaa0b(%rip), %xmm1     # 0xf148
divsd %xmm1, %xmm0
leaq 0xac95(%rip), %rdi      # 0xf3dd
movb $0x1, %al
callq 0x2050
jmp 0x4791
cmpq $0x3e7, (%rsp)          # imm = 0x3E7
jle 0x477d
cvtsi2sdq (%rsp), %xmm0
movsd 0xa9d7(%rip), %xmm1     # 0xf140
divsd %xmm1, %xmm0
leaq 0xac71(%rip), %rdi      # 0xf3e5
movb $0x1, %al
callq 0x2050
jmp 0x478f
movq (%rsp), %rsi
leaq 0xac65(%rip), %rdi      # 0xf3ed
movb $0x0, %al
callq 0x2050
jmp 0x4791
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: conchoecia[P]fasta_stats/src/fasta_stats.cc
// Function: print_size(int const*, int, int, int)
static void print_size(const int lengths[], int i, int one_less = 0, int right_justify = 0) {
	int x = lengths[i] - (one_less ? 1 : 0);
	if ((i % 3) == 2) {	// 250... line
		if (x >= 1000000) {
			printf("%3.1f mb", (double)x / 1000000);
		} else if (x >= 10000) {
			printf("%3d kb", x / 1000);
		} else if (x >= 1000) {
			printf("%3.1f kb", (double)x / 1000);
		} else if (right_justify) {
			printf("   %3d", x);
		} else {
			printf("%3d   ", x);
		}
	} else {
		if (x >= 1000000) {
			printf("%3d mb", x / 1000000);
		} else if (x >= 1000) {
			printf("%3d kb", x / 1000);
		} else if (right_justify) {
			printf("   %3d", x);
		} else {
			printf("%3d   ", x);
		}
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl 0x8(%rsp), %esi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
subl %ecx, %eax
movl %eax, (%rsp)
movl 0xc(%rsp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x2, %edx
jne 0x489d
cmpl $0xf4240, (%rsp)        # imm = 0xF4240
jl 0x481a
cvtsi2sdl (%rsp), %xmm0
movsd 0xa945(%rip), %xmm1     # 0xf148
divsd %xmm1, %xmm0
leaq 0xad48(%rip), %rdi      # 0xf556
movb $0x1, %al
callq 0x2050
jmp 0x489b
cmpl $0x2710, (%rsp)         # imm = 0x2710
jl 0x4840
movl (%rsp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %eax, %esi
leaq 0xad28(%rip), %rdi      # 0xf55f
movb $0x0, %al
callq 0x2050
jmp 0x4899
cmpl $0x3e8, (%rsp)          # imm = 0x3E8
jl 0x486a
cvtsi2sdl (%rsp), %xmm0
movsd 0xa8ea(%rip), %xmm1     # 0xf140
divsd %xmm1, %xmm0
leaq 0xad05(%rip), %rdi      # 0xf566
movb $0x1, %al
callq 0x2050
jmp 0x4897
cmpl $0x0, 0x4(%rsp)
je 0x4884
movl (%rsp), %esi
leaq 0xacf4(%rip), %rdi      # 0xf56f
movb $0x0, %al
callq 0x2050
jmp 0x4895
movl (%rsp), %esi
leaq 0xace8(%rip), %rdi      # 0xf576
movb $0x0, %al
callq 0x2050
jmp 0x4897
jmp 0x4899
jmp 0x489b
jmp 0x491a
cmpl $0xf4240, (%rsp)        # imm = 0xF4240
jl 0x48c3
movl (%rsp), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
cltd
idivl %ecx
movl %eax, %esi
leaq 0xacc3(%rip), %rdi      # 0xf57d
movb $0x0, %al
callq 0x2050
jmp 0x4918
cmpl $0x3e8, (%rsp)          # imm = 0x3E8
jl 0x48e9
movl (%rsp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %eax, %esi
leaq 0xac7f(%rip), %rdi      # 0xf55f
movb $0x0, %al
callq 0x2050
jmp 0x4916
cmpl $0x0, 0x4(%rsp)
je 0x4903
movl (%rsp), %esi
leaq 0xac75(%rip), %rdi      # 0xf56f
movb $0x0, %al
callq 0x2050
jmp 0x4914
movl (%rsp), %esi
leaq 0xac69(%rip), %rdi      # 0xf576
movb $0x0, %al
callq 0x2050
jmp 0x4916
jmp 0x4918
jmp 0x491a
addq $0x18, %rsp
retq
nop
// File: conchoecia[P]fasta_stats/src/fasta_stats.cc
// Function: Scaffold::empty()
bool empty(void) {
		if (contigs.back().empty() && contigs.size() > 1) {
			contigs.pop_back();
			gaps.pop_back();
		}
		if (contigs.size() == 1 && contigs.back().total_size == 0) {
			total_size = 0;
			return 1;
		}
		return 0;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x20, %rdi
callq 0x4b50
movq %rax, %rdi
callq 0x4c30
testb $0x1, %al
jne 0x4bb9
jmp 0x4be6
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x6c80
cmpq $0x1, %rax
jbe 0x4be6
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x6cb0
movq (%rsp), %rdi
addq $0x38, %rdi
callq 0x6cf0
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x6c80
cmpq $0x1, %rax
jne 0x4c1e
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x4b50
cmpq $0x0, (%rax)
jne 0x4c1e
movq (%rsp), %rax
movq $0x0, (%rax)
movb $0x1, 0x17(%rsp)
jmp 0x4c23
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: conchoecia[P]fasta_stats/src/fasta_stats.cc
// Function: Contig::empty()
bool empty(void) {
		if (total_size == n) {
			total_size = n = 0;
			return 1;
		}
		return 0;
	}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x18(%rsp)
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
jne 0x4c63
movq -0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movb $0x1, -0x1(%rsp)
jmp 0x4c68
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: conchoecia[P]fasta_stats/src/fasta_stats.cc
// Function: Scaffold::calc_contig_sizes()
void calc_contig_sizes(void) {
		gap_size = total_size;
		std::list<Contig>::const_iterator __b = contigs.begin();
		std::list<Contig>::const_iterator __end_b = contigs.end();
		for (; __b != __end_b; ++__b) {
			contig_size += __b->size();
			gap_size -= __b->total_size;
		}
		std::list<long>::const_iterator __c = gaps.begin();
		std::list<long>::const_iterator __end_c = gaps.end();
		for (; __c != __end_c; ++__c) {
			captured_gap_size += *__c;
		}
	}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq (%rdi), %rax
movq %rax, 0x10(%rdi)
addq $0x20, %rdi
callq 0x7130
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7160
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x5bf0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7160
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5af0
testb $0x1, %al
jne 0x4e6e
jmp 0x4ebc
leaq 0x48(%rsp), %rdi
callq 0x7180
movq %rax, %rdi
callq 0x71a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
leaq 0x48(%rsp), %rdi
callq 0x7180
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rdx
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
leaq 0x48(%rsp), %rdi
callq 0x5b80
jmp 0x4e59
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
callq 0x71c0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x71f0
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
callq 0x6460
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x71f0
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6360
testb $0x1, %al
jne 0x4f15
jmp 0x4f3e
leaq 0x28(%rsp), %rdi
callq 0x63c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
leaq 0x28(%rsp), %rdi
callq 0x63f0
jmp 0x4f00
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: conchoecia[P]fasta_stats/src/fasta_stats.cc
// Function: Stats::add(Scaffold const&)
void add(const Scaffold &__a) {
		++scaffolds;
		contigs += __a.contigs.size();
		s_size += __a.total_size;
		c_size += __a.contig_size;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x6c80
movq %rax, %rcx
movq (%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: conchoecia[P]fasta_stats/src/fasta_stats.cc
// Function: Stats::add(Stats const&)
void add(const Stats &__a) {
		scaffolds += __a.scaffolds;
		contigs += __a.contigs;
		s_size += __a.s_size;
		c_size += __a.c_size;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: conchoecia[P]fasta_stats/src/itoa.cc
// Function: itoa[abi:cxx11](unsigned long, bool)
std::string itoa(unsigned long x, bool negative) {
	int length = negative ? 2 : 1;
	if (x > 9) {
		length += (int)floor(log10(x));
	}
	std::string value;
	value.resize(length);
	std::string::reverse_iterator a = value.rbegin();
	std::string::reverse_iterator end = value.rend();
	if (negative) {
		value[0] = '-';
		--end;
	}
	for (; a != end; ++a, x /= 10) {
		*a = '0' + (x % 10);
	}
	return value;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x28(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x30(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
andb $0x1, %al
movb %al, 0x67(%rsp)
movb 0x67(%rsp), %dl
movl $0x1, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x60(%rsp)
cmpq $0x9, 0x68(%rsp)
jbe 0xa0ce
movq 0x68(%rsp), %rdi
callq 0xa220
callq 0x2400
cvttsd2si %xmm0, %eax
addl 0x60(%rsp), %eax
movl %eax, 0x60(%rsp)
movq 0x28(%rsp), %rdi
movb $0x0, 0x5f(%rsp)
callq 0x2370
movq 0x28(%rsp), %rdi
movslq 0x60(%rsp), %rsi
callq 0x2360
jmp 0xa0ee
movq 0x28(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x2410
movq 0x28(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x22c0
testb $0x1, 0x67(%rsp)
je 0xa15b
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2470
movq %rax, 0x20(%rsp)
jmp 0xa128
movq 0x20(%rsp), %rax
movb $0x2d, (%rax)
leaq 0x38(%rsp), %rdi
callq 0xa260
jmp 0xa13c
jmp 0xa15b
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x21a0
jmp 0xa20a
jmp 0xa15d
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xa290
movb %al, 0x1f(%rsp)
jmp 0xa172
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xa17c
jmp 0xa1ea
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
mulq %rcx
movq (%rsp), %rax
shrl $0x2, %edx
andl $-0x2, %edx
movl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
orb $0x30, %al
movb %al, 0xf(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xa2c0
movq %rax, 0x10(%rsp)
jmp 0xa1ba
movq 0x10(%rsp), %rax
movb 0xf(%rsp), %cl
movb %cl, (%rax)
leaq 0x40(%rsp), %rdi
callq 0xa2f0
jmp 0xa1d1
movq 0x68(%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x68(%rsp)
jmp 0xa15d
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0xa200
movq 0x28(%rsp), %rdi
callq 0x21a0
movq 0x30(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x2420
nopw %cs:(%rax,%rax)
nop
// File: conchoecia[P]fasta_stats/src/open_compressed.cc
// Function: get_suffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void get_suffix(const std::string &filename, std::string &suffix) {
	const char *suffix_list[3] = { ".gz", ".bz2", ".Z" };
	const size_t suffix_size[3] = { 3, 4, 2 };
	suffix.clear();
	for (int i = 0; i != 3; ++i) {
		const size_t &j = suffix_size[i];
		if (filename.size() > j && filename.compare(filename.size() - j, j, suffix_list[i]) == 0) {
			suffix = suffix_list[i];
			break;
		}
	}
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0xb92b(%rip), %rax      # 0x15d70
movq %rax, 0x40(%rsp)
movq 0xb927(%rip), %rax      # 0x15d78
movq %rax, 0x48(%rsp)
movq 0xb923(%rip), %rax      # 0x15d80
movq %rax, 0x50(%rsp)
movq 0x54f7(%rip), %rax      # 0xf960
movq %rax, 0x20(%rsp)
movq 0x54f3(%rip), %rax      # 0xf968
movq %rax, 0x28(%rsp)
movq 0x54ef(%rip), %rax      # 0xf970
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
callq 0x2310
movl $0x0, 0x1c(%rsp)
cmpl $0x3, 0x1c(%rsp)
je 0xa535
movslq 0x1c(%rsp), %rcx
leaq 0x20(%rsp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0x21e0
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0xa523
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x21e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rax
subq (%rax), %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movslq 0x1c(%rsp), %rax
movq 0x40(%rsp,%rax,8), %rcx
callq 0x2320
cmpl $0x0, %eax
jne 0xa523
movslq 0x1c(%rsp), %rax
movq 0x40(%rsp,%rax,8), %rsi
movq 0x58(%rsp), %rdi
callq 0x2330
jmp 0xa535
jmp 0xa525
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xa498
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: conchoecia[P]fasta_stats/src/open_compressed.cc
// Function: pfread2(int, void*, unsigned long)
ssize_t pfread2(const int fd, void *ptr, const size_t size) {
	assert(-1 < fd && fd < local.open_max);
	char *buf = (char *)ptr;
	ssize_t i = size;
	while (i != 0) {
		const ssize_t j = read(fd, buf, i);
		if (j == -1) {
			fprintf(stderr, "Error: read (%d %p): %s\n", fd, ptr, strerror(errno));
			return -1;
		}
		i -= j;
		buf += j;
	}
	return size;
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x4c(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl 0x4c(%rsp), %ecx
movb %al, 0x1f(%rsp)
jge 0xb456
movslq 0x4c(%rsp), %rax
cmpq 0xae81(%rip), %rax      # 0x162d0
setl %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xb460
jmp 0xb462
jmp 0xb481
leaq 0x43c8(%rip), %rdi      # 0xf831
leaq 0x43e0(%rip), %rsi      # 0xf850
movl $0x140, %edx            # imm = 0x140
leaq 0x43eb(%rip), %rcx      # 0xf867
callq 0x21c0
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0xb53c
movl 0x4c(%rsp), %edi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x2390
movq %rax, 0x20(%rsp)
cmpq $-0x1, 0x20(%rsp)
jne 0xb516
movq 0xab08(%rip), %rax      # 0x15fd0
movq (%rax), %rax
movq %rax, (%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x2040
movl (%rax), %edi
callq 0x20d0
movq (%rsp), %rdi
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rcx
movq %rax, %r8
leaq 0x4394(%rip), %rsi      # 0xf898
movb $0x0, %al
callq 0x2380
movq $-0x1, 0x50(%rsp)
jmp 0xb546
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xb495
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
// File: conchoecia[P]fasta_stats/src/open_compressed.cc
// Function: LocalData::~LocalData()
~LocalData(void) {
		delete[] buffers;
		delete[] buffer_start;
		delete[] buffer_length;
		std::map<int, pid_t>::const_iterator __a = open_processes.begin();
		const std::map<int, pid_t>::const_iterator __end_a = open_processes.end();
		for (; __a != __end_a; ++__a) {
			close(__a->first);
		}
		std::list<pid_t>::const_iterator __b = closed_processes.begin();
		const std::list<pid_t>::const_iterator __end_b = closed_processes.end();
		for (; __b != __end_b; ++__b) {
			waitpid(*__b, NULL, 0);
		}
		for (__a = open_processes.begin(); __a != __end_a; ++__a) {
			waitpid(__a->second, NULL, 0);
		}
	}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0xb865
movq 0x38(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x20(%rsp)
movq -0x8(%rcx), %rdx
shlq $0x3, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x28(%rsp)
je 0xb85b
movq 0x28(%rsp), %rdi
addq $-0x8, %rdi
movq %rdi, 0x18(%rsp)
callq 0xbd90
movq 0x38(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x28(%rsp)
jne 0xb834
movq 0x20(%rsp), %rdi
callq 0x2300
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xb883
movq 0x10(%rsp), %rdi
callq 0x2300
movq 0x30(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xb8a1
movq 0x8(%rsp), %rdi
callq 0x2300
movq 0x30(%rsp), %rdi
callq 0xc4f0
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xc520
movq 0x30(%rsp), %rdi
callq 0xc540
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xc520
leaq 0x88(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xc570
testb $0x1, %al
jne 0xb8fe
jmp 0xb925
leaq 0x88(%rsp), %rdi
callq 0xc590
movl (%rax), %edi
callq 0x2460
jmp 0xb914
jmp 0xb916
leaq 0x88(%rsp), %rdi
callq 0xc5c0
jmp 0xb8e6
movq 0x30(%rsp), %rdi
addq $0x30, %rdi
callq 0xc5f0
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xc620
movq 0x30(%rsp), %rdi
addq $0x30, %rdi
callq 0xc640
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xc620
leaq 0x68(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xc670
testb $0x1, %al
jne 0xb97e
jmp 0xb9a3
leaq 0x68(%rsp), %rdi
callq 0xc690
movl (%rax), %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x2210
jmp 0xb995
jmp 0xb997
leaq 0x68(%rsp), %rdi
callq 0xc6c0
jmp 0xb969
movq 0x30(%rsp), %rdi
callq 0xc4f0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xc520
movq 0x48(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xc570
testb $0x1, %al
jne 0xb9e6
jmp 0xba12
leaq 0x88(%rsp), %rdi
callq 0xc590
movl 0x4(%rax), %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x2210
jmp 0xba01
jmp 0xba03
leaq 0x88(%rsp), %rdi
callq 0xc5c0
jmp 0xb9ce
movq 0x30(%rsp), %rdi
addq $0x30, %rdi
callq 0xbe00
movq 0x30(%rsp), %rdi
callq 0xbe10
addq $0x98, %rsp
retq
movq %rax, %rdi
callq 0x5f60
nopw (%rax,%rax)
// File: conchoecia[P]fasta_stats/src/open_compressed.cc
// Function: LocalData::close_process(int)
void close_process(const int __i) {
		assert(-1 < __i && __i < open_max);
		close(__i);
		buffers[__i].resize(0);
		std::map<int, pid_t>::iterator __a = open_processes.find(__i);
		if (__a != open_processes.end()) {
			closed_processes.push_back(__a->second);
			open_processes.erase(__a);
		}
		finish_nohang();
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl 0x3c(%rsp), %ecx
movb %al, 0x17(%rsp)
jge 0xbbdd
movq 0x8(%rsp), %rcx
movslq 0x3c(%rsp), %rax
cmpq 0x48(%rcx), %rax
setl %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0xbbe7
jmp 0xbbe9
jmp 0xbc08
leaq 0x3d21(%rip), %rdi      # 0xf911
leaq 0x3c59(%rip), %rsi      # 0xf850
movl $0x3a, %edx
leaq 0x3d29(%rip), %rcx      # 0xf92c
callq 0x21c0
movl 0x3c(%rsp), %edi
callq 0x2460
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
movslq 0x3c(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbb40
movq 0x8(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0xd7d0
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0xc540
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd800
testb $0x1, %al
jne 0xbc67
jmp 0xbcac
movq 0x8(%rsp), %rax
addq $0x30, %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd860
movq (%rsp), %rdi
movq %rax, %rsi
addq $0x4, %rsi
callq 0xd820
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0xd880
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0xd8c0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: conchoecia[P]fasta_stats/src/open_compressed.cc
// Function: LocalData::finish_nohang()
void finish_nohang(void) {
		std::list<pid_t>::iterator __a = closed_processes.begin();
		const std::list<pid_t>::iterator __end_a = closed_processes.end();
		while (__a != __end_a) {
			if (waitpid(*__a, NULL, WNOHANG) > 0) {
				__a = closed_processes.erase(__a);
			} else {
				++__a;
			}
		}
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x30, %rdi
callq 0xc5f0
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x30, %rdi
callq 0xc640
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xddb0
testb $0x1, %al
jne 0xd909
jmp 0xd96f
leaq 0x28(%rsp), %rdi
callq 0xddd0
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x2210
cmpl $0x0, %eax
jle 0xd963
movq 0x8(%rsp), %rax
addq $0x30, %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc620
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xddf0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0xd96d
leaq 0x28(%rsp), %rdi
callq 0xde40
jmp 0xd8f4
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: conchoecia[P]fasta_stats/src/refcount_array.h
// Function: refcount_array<char>::resize(unsigned long)
void resize(size_type __n) {
		if (_M_size != __n) {
			_M_size = __n;
			if (_M_array != NULL) {
				delete[] _M_array;
			}
			if (_M_size == 0) {
				_M_array = NULL;
			} else {
				_M_array = new value_type[_M_size];
			}
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rax), %rax
cmpq 0x18(%rsp), %rax
je 0xdfbf
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x10(%rax)
je 0xdf88
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xdf86
movq 0x8(%rsp), %rdi
callq 0x2300
jmp 0xdf88
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xdfa3
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
jmp 0xdfbd
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0xdfbf
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop