LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/fredericmarchand[P]TexasHoldem/Node.cpp
// Function: Node::addChild(moves, NodeState*)
Node* Node::addChild(Move move, NodeState *state)
{
	Node *child = new Node(move, this, state);
	for (int i = 0; i < untriedMoves.size(); i++)
	{
    	if (untriedMoves.at(i) == move)
    	{
    		untriedMoves.erase(untriedMoves.begin()+i);
    	}
	}
	children.push_back(child);

	return child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %r14d
movq %rdi, %rbx
movl $0x50, %edi
callq 0x2130
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x5340
movq %r15, -0x30(%rbp)
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rdx
cmpq %rax, %rdx
je 0x561b
movq $-0x4, %r15
movl $0x4, %r12d
xorl %r13d, %r13d
cmpl %r14d, (%rax,%r13,4)
jne 0x55f9
leaq (%rax,%r12), %rcx
cmpq %rdx, %rcx
je 0x55f4
leaq (%rax,%r13,4), %rdi
leaq (%rax,%r13,4), %rsi
addq $0x4, %rsi
subq %rax, %rdx
addq %r15, %rdx
callq 0x21a0
addq $-0x4, 0x38(%rbx)
incq %r13
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rdx
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x2, %rcx
addq $-0x4, %r15
addq $0x4, %r12
cmpq %r13, %rcx
ja 0x55ce
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x5633
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x20(%rbx)
jmp 0x5643
addq $0x18, %rbx
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x576c
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x50, %esi
movq %r15, %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/fredericmarchand[P]TexasHoldem/NodeState.cpp
// Function: NodeState::doMove(moves)
void NodeState::doMove(Move move)
{
	player->doMove(move, game->getPlayerIndex(player), game->getPreviousPlayer(player), true);
	for (int i = 0; i < moves.size(); ++i)
	{
		if (moves.at(i) == move)
		{
			moves.erase(moves.begin()+i);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %r15
movq %r15, %rsi
callq 0x3f1c
movl %eax, %r12d
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x3ebc
movq %r15, %rdi
movl %ebx, %esi
movl %r12d, %edx
movq %rax, %rcx
movl $0x1, %r8d
callq 0x2eba
movq 0x10(%r14), %rax
movq 0x18(%r14), %rdx
cmpq %rax, %rdx
je 0x5ddb
movq $-0x4, %r15
movl $0x4, %r12d
xorl %r13d, %r13d
cmpl %ebx, (%rax,%r13,4)
jne 0x5db9
leaq (%rax,%r12), %rcx
cmpq %rdx, %rcx
je 0x5db4
leaq (%rax,%r13,4), %rdi
leaq (%rax,%r13,4), %rsi
addq $0x4, %rsi
subq %rax, %rdx
addq %r15, %rdx
callq 0x21a0
addq $-0x4, 0x18(%r14)
incq %r13
movq 0x10(%r14), %rax
movq 0x18(%r14), %rdx
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x2, %rcx
addq $-0x4, %r15
addq $0x4, %r12
cmpq %r13, %rcx
ja 0x5d8e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fredericmarchand[P]TexasHoldem/NodeState.cpp
// Function: NodeState::getResult(bool)
int NodeState::getResult(bool playerJustMoved)
{
	if (this->game == NULL)
		cout << "FUCKA" << endl;
	int p1 = game->getPlayers()[0]->bestHand(game->getFlop(), game->getTurn(), game->getRiver(), false);
	int p2 = game->getPlayers()[1]->bestHand(game->getFlop(), game->getTurn(), game->getRiver(), false);
	if (game->getPlayerIndex(player) == 0)
	{
		if (p1 > p2)
			return 2;
		else if (p1 == p2)
			return 1;
		else return 0;
	}
	else
	{
		if (p1 < p2)
			return 2;
		else if (p1 == p2)
			return 1;
		else return 0;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x5e43
movq 0x41c8(%rip), %r14      # 0x9fd0
leaq 0x13bb(%rip), %rsi      # 0x71ca
movl $0x5, %edx
movq %r14, %rdi
callq 0x2150
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
movq (%rbx), %rdi
callq 0x3bae
movq (%rax), %r14
movq (%rbx), %rdi
callq 0x505a
movq %rax, %r15
movq (%rbx), %rdi
callq 0x5064
movq %rax, %r12
movq (%rbx), %rdi
callq 0x506e
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x3510
movl %eax, %r14d
movq (%rbx), %rdi
callq 0x3bae
movq 0x8(%rax), %r15
movq (%rbx), %rdi
callq 0x505a
movq %rax, %r12
movq (%rbx), %rdi
callq 0x5064
movq %rax, %r13
movq (%rbx), %rdi
callq 0x506e
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x3510
movl %eax, %r15d
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3f1c
testl %eax, %eax
je 0x5ef3
movl $0x2, %eax
cmpl %r15d, %r14d
jl 0x5ee4
sete %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %eax
cmpl %r15d, %r14d
jle 0x5ede
jmp 0x5ee4
nop
// File: /workspace/github_cpp_makefile_star2_O1/fredericmarchand[P]TexasHoldem/main.cpp
// Function: printLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void printLabel(string label)
{
    for (int i = 0; i < label.length(); ++i)
    {
        cout << "=";
    }
    cout << endl << label << endl;
    for (int i = 0; i < label.length(); ++i)
    {
        cout << "=";
    }
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x609a
xorl %r12d, %r12d
movq 0x3f56(%rip), %r14      # 0x9fd0
leaq 0x114f(%rip), %r15      # 0x71d0
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2150
incq %r12
cmpq %r12, 0x8(%rbx)
ja 0x6081
movq 0x3f2f(%rip), %r14      # 0x9fd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0x2150
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
cmpq $0x0, 0x8(%rbx)
je 0x6132
xorl %r13d, %r13d
movq 0x3ebe(%rip), %r15      # 0x9fd0
leaq 0x10b7(%rip), %r12      # 0x71d0
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2150
incq %r13
cmpq %r13, 0x8(%rbx)
ja 0x6119
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/01joy[P]test-gperftools/main/main.cpp
// Function: calculateSum(long long)
long long calculateSum(long long n) {
	long long s = 0;
	for (int i = 1; i <= n; ++i) {
		s += i;
		recordSum(s);
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
jle 0x1367
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
addq %r15, %r14
incq %r14
incq %r15
movq %r14, %rdi
callq 0x12cc
cmpq %rbx, %r15
jl 0x134f
jmp 0x136a
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/01joy[P]test-gperftools/main/main.cpp
// Function: main
int main() {
	long long n = 1000000000;
	Complex c;
	double p = c.calculatePI(n);
	long long s = calculateSum(n);
	cout << "pi=" << fixed << setprecision(13) << p << endl;
	cout << "1+2+...+" << n << "=" << s << endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x1130
movq %rbx, %rdi
movl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
callq 0x10f0
movsd %xmm0, -0x18(%rbp)
movl $0x1, %r14d
xorl %ebx, %ebx
addq %r14, %rbx
movq %rbx, %rdi
callq 0x12cc
incq %r14
cmpq $0x3b9aca01, %r14       # imm = 0x3B9ACA01
jne 0x13a9
movq 0x2c11(%rip), %rbx      # 0x3fd8
leaq 0xc36(%rip), %rsi       # 0x2004
movl $0x3, %edx
movq %rbx, %rdi
callq 0x10d0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x18(%rbx,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq $0xd, 0x8(%rbx,%rax)
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x1110
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq 0x2b9b(%rip), %rdi      # 0x3fd8
leaq 0xbc4(%rip), %rsi       # 0x2008
movl $0x8, %edx
callq 0x10d0
movq 0x2b83(%rip), %rdi      # 0x3fd8
movl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
callq 0x1050
movq %rax, %rbx
leaq 0xb9d(%rip), %rsi       # 0x2006
movl $0x1, %edx
movq %rax, %rdi
callq 0x10d0
movabsq $0x6f05b59f17f6500, %rsi # imm = 0x6F05B59F17F6500
movq %rbx, %rdi
callq 0x1050
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq -0x30(%rbp), %rdi
callq 0x10e0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x14ca
jmp 0x14ca
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x10e0
movq %rbx, %rdi
callq 0x1140
// File: /workspace/github_cpp_makefile_star2_O1/leobru[P]ACPUfont/splitter.cc
// Function: smooth(std::vector<double, std::allocator<double>> const&, int)
vector<double> smooth(const vector<double> & vec, int n) {
    vector<double> smoothed(vec.size());
    for (int i = 0; i < vec.size(); ++i) {
        smoothed[i] = smooth(&vec[std::max(0, i-n)], &vec[std::min(i+n, (int)vec.size()-1)]);
    }
    return smoothed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x3, %rsi
leaq 0x7(%rsp), %rdx
callq 0x1e56
movq (%r15), %rax
movq 0x8(%r15), %rdi
subq %rax, %rdi
je 0x1517
sarq $0x3, %rdi
leal -0x1(%rdi), %ecx
cmpq $0x1, %rdi
movq %rdi, %rdx
adcq $0x0, %rdx
movq (%r14), %rsi
movslq %edi, %rdi
decq %rdi
movl %ebx, %r8d
negl %r8d
xorl %r9d, %r9d
movl %ebx, %r10d
xorl %r11d, %r11d
movslq %r10d, %r12
cmpq %r12, %rdi
cmovlq %rdi, %r12
testl %r8d, %r8d
movl $0x0, %r13d
cmovgl %r8d, %r13d
movl %r11d, %r15d
subl %ebx, %r15d
testl %r15d, %r15d
cmovlel %r9d, %r15d
leal (%r11,%rbx), %ebp
cmpl %ebp, %ecx
cmovll %ecx, %ebp
xorpd %xmm0, %xmm0
cmpl %ebp, %r15d
je 0x14e5
shlq $0x3, %r12
shlq $0x3, %r13
addsd (%rax,%r13), %xmm0
addq $0x8, %r13
cmpq %r13, %r12
jne 0x14d6
shlq $0x3, %r15
movslq %ebp, %r12
shlq $0x3, %r12
subq %r15, %r12
sarq $0x3, %r12
xorps %xmm1, %xmm1
cvtsi2sd %r12, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsi,%r11,8)
incq %r11
incl %r10d
incl %r8d
cmpq %rdx, %r11
jne 0x1498
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/leobru[P]ACPUfont/splitter.cc
// Function: centers(std::vector<double, std::allocator<double>> const&, int)
vector<int> centers(const vector<double> & vec, int cellsize) {
    vector<int> centers;
    for (int i = cellsize/2; i < vec.size()-cellsize/2; ++i) {
        if (vec[i] < vec[i-1] && vec[i] < vec[i+1]) centers.push_back(i);
    }
    return centers;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %edx, %eax
shrl $0x1f, %eax
addl %edx, %eax
sarl %eax
movslq %eax, %r12
movl %r12d, 0x4(%rsp)
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
subq %r12, %rdx
cmpq %r12, %rdx
jbe 0x15db
movq %rsi, %r14
leaq 0x4(%rsp), %r15
movq %r12, %rdx
movsd (%rcx,%rdx,8), %xmm0
movslq %eax, %rdx
movsd -0x8(%rcx,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x15b7
movsd 0x8(%rcx,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x15b7
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x15ac
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x15b7
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2a50
movslq 0x4(%rsp), %rdx
incq %rdx
movl %edx, 0x4(%rsp)
movq (%r14), %rcx
movq 0x8(%r14), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
subq %r12, %rsi
movl %edx, %eax
cmpq %rdx, %rsi
ja 0x1576
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1601
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1120
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/leobru[P]ACPUfont/splitter.cc
// Function: Picture::average_lines(int, int)
vector<double> average_lines(int start, int finish) {
        vector<double> avgs(height);
        for (int i = 0; i < height; ++i) {
            avgs[i] = std::accumulate(&p(i, start), &p(i, finish+1), 0.0) / (double) (finish-start+1);
        }
        return avgs;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movslq 0x420(%rsi), %rsi
leaq 0x7(%rsp), %rdx
callq 0x1e56
movslq 0x420(%r12), %rax
testq %rax, %rax
jle 0x214d
movslq 0x41c(%r12), %rcx
movq (%r12), %rdx
leal 0x1(%r15), %esi
movslq %r15d, %r9
subl %ebx, %r15d
incl %r15d
cvtsi2sd %r15d, %xmm0
movq (%r14), %rdi
movslq %ebx, %r8
leaq 0x8(,%r9,8), %r9
shlq $0x3, %r8
shlq $0x3, %rcx
xorl %r10d, %r10d
xorpd %xmm1, %xmm1
cmpl %ebx, %esi
je 0x2138
movq %r8, %r11
addsd (%rdx,%r11), %xmm1
addq $0x8, %r11
cmpq %r11, %r9
jne 0x2129
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%r10,8)
incq %r10
addq %rcx, %rdx
cmpq %rax, %r10
jne 0x211e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/leobru[P]ACPUfont/splitter.cc
// Function: Picture::average_columns(int, int)
vector<double> average_columns(int start, int finish) {
        vector<double> avgs(width);
        for (int i = 0; i < width; ++i) {
            avgs[i] = std::accumulate(column_begin(i)+start, column_begin(i)+finish+1, 0.0) / (double) (finish-start+1);
        }
        return avgs;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movslq 0x41c(%rsi), %rsi
leaq 0xf(%rsp), %rdx
callq 0x1e56
movslq 0x41c(%r15), %rax
testq %rax, %rax
jle 0x220a
movq (%r15), %rcx
movl %eax, %edx
imull %r14d, %edx
movslq %edx, %rdx
movl %eax, %esi
imull %ebp, %esi
movslq %esi, %rsi
subl %r14d, %ebp
incl %ebp
cvtsi2sd %ebp, %xmm0
movq (%rbx), %rdi
leaq (,%rax,8), %r8
leaq (%r8,%rsi,8), %r9
leaq (,%rdx,8), %r10
xorl %r11d, %r11d
movq %rcx, %r14
leaq (%rcx,%r11,8), %r15
leaq (%r15,%rdx,8), %r12
leaq (%r15,%rsi,8), %r15
leaq (%r15,%rax,8), %r15
xorpd %xmm1, %xmm1
cmpq %r15, %r12
je 0x21f4
movq %r10, %r15
addsd (%r14,%r15), %xmm1
addq %r8, %r15
cmpq %r15, %r9
jne 0x21e6
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%r11,8)
incq %r11
addq $0x8, %r14
cmpq %rax, %r11
jne 0x21ca
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/leobru[P]ACPUfont/splitter.cc
// Function: Picture::dump_marked(std::vector<int, std::allocator<int>>*, std::vector<int, std::allocator<int>>*)
void dump_marked(vector<int> * hor, vector<int> * ver) {
        FILE * f = fopen("marked.ppm", "w");
        fprintf(f, "P6\n%d %d\n%d\n", width, height, full);
        for (int i = 0; i < height; ++i) for (int j = 0; j < width; ++j) {
                int r, b, g;
                r = g = b = p(i,j);
                if (hor && std::find(hor->begin(), hor->end(), i) != hor->end()) { g = b = 0; r = full; }
                if (ver && std::find(ver->begin(), ver->end(), j) != ver->end()) { b = 0; r = g ? 0 : full; g = full; }
                putc(r, f); putc(g, f); putc(b, f);
            }
        fclose(f);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xf80(%rip), %rdi       # 0x31b8
leaq 0xf84(%rip), %rsi       # 0x31c3
callq 0x1140
movq %rax, %r12
movl 0x41c(%r15), %edx
movl 0x420(%r15), %ecx
movl 0x424(%r15), %r8d
leaq 0xf62(%rip), %rsi       # 0x31c5
movq %rax, %rdi
xorl %eax, %eax
callq 0x1170
movl $0x0, 0x8(%rsp)
cmpl $0x0, 0x420(%r15)
jle 0x236b
movq %rbx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0x41c(%r15), %eax
testl %eax, %eax
jle 0x2354
xorl %ecx, %ecx
imull 0x8(%rsp), %eax
addl %ecx, %eax
cltq
movq (%r15), %rcx
cvttsd2si (%rcx,%rax,8), %r13d
testq %r14, %r14
je 0x22de
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdx
callq 0x29b7
movl %r13d, %ebp
cmpq 0x8(%r14), %rax
je 0x22e1
xorl %r13d, %r13d
movl 0x424(%r15), %ebp
jmp 0x22e1
movl %r13d, %ebp
testq %rbx, %rbx
je 0x2314
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0xc(%rsp), %rdx
callq 0x29b7
cmpq 0x8(%rbx), %rax
je 0x2314
xorl %ebx, %ebx
testl %r13d, %r13d
movl 0x424(%r15), %r13d
movl $0x0, %ebp
cmovel %r13d, %ebp
jmp 0x2317
movl %r13d, %ebx
movl %ebp, %edi
movq %r12, %rsi
callq 0x11d0
movl %r13d, %edi
movq %r12, %rsi
callq 0x11d0
movl %ebx, %edi
movq %r12, %rsi
callq 0x11d0
movl 0xc(%rsp), %ecx
incl %ecx
movl %ecx, 0xc(%rsp)
movl 0x41c(%r15), %eax
cmpl %eax, %ecx
movq 0x10(%rsp), %rbx
jl 0x22a1
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
cmpl 0x420(%r15), %eax
jl 0x2288
movq %r12, %rdi
callq 0x1100
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/leobru[P]ACPUfont/splitter.cc
// Function: Picture::rectavg(int, int, int, int)
double rectavg(int cline, int ccol, int hspread, int vspread) {
        double sum = 0;
        for (int i = -hspread/2; i <= hspread/2; ++i) {
            for (int j = -vspread/2; j <= vspread/2; ++j) {
                if (cline+i >= 0 && cline+i < height && ccol+j >= 0 && ccol+j < width) {
                    sum += p(cline+i,ccol+j);
                }
            }
        }
        return sum/(hspread|1)/(vspread|1);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, -0x10(%rsp)
movl %ecx, %eax
shrl $0x1f, %eax
movl %ecx, -0xc(%rsp)
addl %ecx, %eax
sarl %eax
movl %eax, %ebp
negl %ebp
xorpd %xmm0, %xmm0
cmpl %eax, %ebp
jg 0x245c
movl -0x10(%rsp), %ecx
movl %ecx, %r9d
shrl $0x1f, %r9d
addl %ecx, %r9d
sarl %r9d
movl %r9d, %r10d
negl %r10d
movslq 0x420(%rdi), %rcx
movq %rcx, -0x8(%rsp)
movslq 0x41c(%rdi), %rbx
movslq %r10d, %r14
movslq %edx, %r11
addq %r14, %r11
movslq %ebp, %r14
movslq %esi, %rsi
leaq (%r14,%rsi), %r15
imulq %rbx, %r15
shlq $0x3, %r15
addq (%rdi), %r15
incl %eax
leaq (,%rbx,8), %rdi
leal 0x1(,%r9,2), %ebp
cmpl %r9d, %r10d
jg 0x2451
movq %r14, %rdx
addq %rsi, %rdx
setns %r13b
cmpq -0x8(%rsp), %rdx
setl %r12b
andb %r13b, %r12b
movl %ebp, %r13d
movq %r11, %rdx
testb %r12b, %r12b
je 0x2449
testq %rdx, %rdx
setns %r8b
cmpq %rbx, %rdx
setl %cl
andb %r8b, %cl
cmpb $0x1, %cl
jne 0x2449
addsd (%r15,%rdx,8), %xmm0
incq %rdx
decl %r13d
jne 0x2429
incq %r14
addq %rdi, %r15
cmpl %r14d, %eax
jne 0x2408
movl -0xc(%rsp), %eax
orl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movl -0x10(%rsp), %eax
orl $0x1, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/npazosmendez[P]branchsearch/branchsearch.cpp
// Function: kbhit()
int kbhit(void){
    int ch = getch();
    if (ch != ERR) {
        ungetch(ch);
        return 1;
    } else {
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1a6f9(%rip), %rax     # 0x1efb0
movq (%rax), %rdi
callq 0x4150
cmpl $-0x1, %eax
je 0x48d2
movl %eax, %edi
callq 0x4440
movl $0x1, %eax
jmp 0x48d4
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/npazosmendez[P]branchsearch/branchsearch.cpp
// Function: run_command(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*, bool)
int run_command(const string& command, vector<string>* out_lines=nullptr, bool show_failure=true){
    vector<string> _out_lines;
    char buff[MAX_LINE_LEN];
    FILE *f = popen(command.c_str(), "r");
    while (!feof(f)) if (fgets(buff, sizeof(buff), f) != NULL)
        _out_lines.push_back(buff);
    int status = WEXITSTATUS(pclose(f));
    if(status and show_failure){
        erase();
        for(auto &l : _out_lines) addstr(l.c_str());
        addstr("\n\nPress any key to continue.");
        while(!kbhit());
        getch();
    }
    if(out_lines) *out_lines = _out_lines;
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movl %edx, -0x2c(%rbp)
movq %rsi, -0x58(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq (%rdi), %rdi
leaq 0x11833(%rip), %rsi     # 0x1613d
callq 0x40c0
movq %rax, %r15
movq %rax, %rdi
callq 0x44f0
testl %eax, %eax
jne 0x4994
leaq -0x68(%rbp), %r14
leaq -0x270(%rbp), %r12
leaq -0x78(%rbp), %r13
leaq -0x50(%rbp), %rbx
movq %r12, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
movq %r15, %rdx
callq 0x4510
testq %rax, %rax
je 0x4988
movq %r14, -0x78(%rbp)
movq %r12, %rdi
callq 0x4190
leaq (%rax,%rbp), %rdx
addq $-0x270, %rdx           # imm = 0xFD90
movq %r13, %rdi
movq %r12, %rsi
callq 0x656a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x62ec
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x4988
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x4300
movq %r15, %rdi
callq 0x44f0
testl %eax, %eax
je 0x4931
movq %r15, %rdi
callq 0x4490
movl %eax, %r15d
shrl $0x8, %r15d
andl $0xff, %r15d
sete %al
movl -0x2c(%rbp), %ecx
xorb $0x1, %cl
orb %al, %cl
movq -0x58(%rbp), %r13
jne 0x4a1a
callq 0x4360
movq -0x50(%rbp), %rbx
movq -0x48(%rbp), %r14
cmpq %r14, %rbx
je 0x49ee
movq 0x1a5dc(%rip), %r12     # 0x1efb0
movq (%r12), %rdi
movq (%rbx), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4110
addq $0x20, %rbx
cmpq %r14, %rbx
jne 0x49d4
movq 0x1a5bb(%rip), %rbx     # 0x1efb0
movq (%rbx), %rdi
leaq 0x116f9(%rip), %rsi     # 0x160f8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4110
callq 0x48ac
testl %eax, %eax
je 0x4a09
movq (%rbx), %rdi
callq 0x4150
testq %r13, %r13
je 0x4a2b
leaq -0x50(%rbp), %rsi
movq %r13, %rdi
callq 0x5bc4
leaq -0x50(%rbp), %rdi
callq 0x5d52
movl %r15d, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4a69
jmp 0x4a69
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x4a6c
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x4300
jmp 0x4a6c
jmp 0x4a69
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x5d52
movq %rbx, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O1/npazosmendez[P]branchsearch/branchsearch.cpp
// Function: delete_branch(std::vector<branch_t*, std::allocator<branch_t*>>&, int)
void delete_branch(vector<branch_t*> &branches, int target_index){
    erase();
    string branch_name = branches[target_index]->name;
    printw("Delete '%s'? [Y/N]\n", branch_name.c_str());
    while (1) {
        if (kbhit()) {
            int c = getch();
            if(c == 'Y' or c == 'y') run_command("git branch -d " + branch_name + " 2>&1");
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x4360
movslq %ebx, %rax
movq (%r14), %rcx
movq (%rcx,%rax,8), %rax
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x6214
movq (%rbx), %rsi
leaq 0x11047(%rip), %rdi     # 0x1615e
xorl %eax, %eax
callq 0x42f0
callq 0x48ac
testl %eax, %eax
je 0x511e
movq 0x19e82(%rip), %rax     # 0x1efb0
movq (%rax), %rdi
callq 0x4150
andl $-0x21, %eax
cmpl $0x59, %eax
jne 0x51e6
leaq 0x11029(%rip), %rsi     # 0x16172
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x5f20
leaq 0x11024(%rip), %rsi     # 0x16181
leaq -0x78(%rbp), %rdi
callq 0x45e0
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x518a
movq %rdx, -0x38(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x28(%rbp)
jmp 0x5191
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x38(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
xorl %esi, %esi
movl $0x1, %edx
callq 0x48d6
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x51cd
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4300
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51e6
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x4300
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x51fb
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x4300
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x5223
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4300
jmp 0x5223
movq %rax, %rbx
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5247
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x4300
jmp 0x5247
jmp 0x5244
jmp 0x5244
jmp 0x5244
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x525c
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O1/npazosmendez[P]branchsearch/branchsearch.cpp
// Function: switch_to_branch(branch_t, bool)
void switch_to_branch(branch_t branch, bool pull_after_checkout){
    endwin();
    string command = "git checkout " + branch.name;
    system(command.c_str());
    if (pull_after_checkout) {
        system("git pull");
    }
    exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x43e0
leaq 0x10f05(%rip), %rsi     # 0x16187
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5f20
movq (%r15), %rdi
callq 0x42b0
testb %bl, %bl
je 0x52a9
leaq 0x10ef1(%rip), %rdi     # 0x16195
callq 0x42b0
xorl %edi, %edi
callq 0x43f0
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52cc
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O1/npazosmendez[P]branchsearch/branchsearch.cpp
// Function: filter_branches(std::vector<branch_t, std::allocator<branch_t>>&, char*, std::vector<branch_t*, std::allocator<branch_t*>>&)
void filter_branches(vector<branch_t> &all_branches, char* regex_value, vector<branch_t*> &filtered_branches){
    filtered_branches.clear();
    try{
        regex regex_(regex_value, regex_constants::icase);
        for (int i = 0; i < all_branches.size(); ++i){
            if (regex_search(all_branches[i].name, regex_)){
                filtered_branches.push_back(&all_branches[i]);
            }
        }
    } catch(exception e){
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x52f5
movq %rax, 0x8(%rdx)
movq %rdx, -0x58(%rbp)
leaq -0x78(%rbp), %rdi
movl $0x1, %edx
callq 0x5dbc
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x53a2
xorl %r12d, %r12d
leaq -0x50(%rbp), %r15
xorl %ebx, %ebx
movq (%rax,%r12), %rdi
movq 0x8(%rax,%r12), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movq %r15, %rdx
leaq -0x78(%rbp), %rcx
xorl %r8d, %r8d
callq 0x127bd
movl %eax, %r13d
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x535b
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x4300
testb %r13b, %r13b
je 0x5376
movq (%r14), %rax
addq %r12, %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x15270
incq %rbx
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
addq $0x28, %r12
cmpq %rbx, %rcx
ja 0x531d
leaq -0x78(%rbp), %rdi
callq 0x5e28
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
jmp 0x53ee
movq %rdx, %r14
movq %rax, %rbx
jmp 0x53e5
movq %rdx, %r14
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x53e5
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x4300
leaq -0x78(%rbp), %rdi
callq 0x5e28
cmpl $0x1, %r14d
jne 0x5425
movq %rbx, %rdi
callq 0x4410
movq 0x19bb5(%rip), %rax     # 0x1efb8
addq $0x10, %rax
leaq -0x50(%rbp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x4170
movq %r14, %rdi
callq 0x45f0
callq 0x4530
jmp 0x53ab
movq %rbx, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O1/npazosmendez[P]branchsearch/branchsearch.cpp
// Function: args_t::args_t(int, char**)
args_t(int argc, char** argv) {
        for (int i = 1; i < argc; i++) {
            string arg = argv[i];
            if (arg[0] != '-') fast_switch = argv[i];
            if (arg == "-u") fetch_before = true;
            if (arg == "-p") pull_after = true;
            if (arg == "-l") locals_only = true;
        }
    }

// Assembly:
movl $0x0, 0x7(%rdi)
movq $0x0, (%rdi)
cmpl $0x2, %esi
jl 0x6088
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r12d
movl $0x1, %r13d
leaq -0x50(%rbp), %r15
movq (%rbx,%r13,8), %rsi
movq %r15, %rdi
leaq -0x29(%rbp), %rdx
callq 0x5b86
movq -0x50(%rbp), %rax
cmpb $0x2d, (%rax)
je 0x600d
movq (%rbx,%r13,8), %rax
movq %rax, (%r14)
movq %r15, %rdi
leaq 0x101ac(%rip), %rsi     # 0x161c3
callq 0x40b0
testl %eax, %eax
jne 0x6025
movb $0x1, 0x9(%r14)
movq %r15, %rdi
leaq 0x10197(%rip), %rsi     # 0x161c6
callq 0x40b0
testl %eax, %eax
jne 0x603d
movb $0x1, 0x8(%r14)
movq %r15, %rdi
leaq 0x100d9(%rip), %rsi     # 0x16120
callq 0x40b0
testl %eax, %eax
jne 0x6055
movb $0x1, 0xa(%r14)
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x606e
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x4300
incq %r13
cmpq %r13, %r12
jne 0x5fed
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JohnCGriffin[P]BrainForked/bf_instruction.cpp
// Function: bf::operator<<(std::ostream&, bf::Action const&)
std::ostream& operator<<(std::ostream& os, const Action& action)
    {
#define ACTIONOUT(A) case A: return os << #A
        switch(action){
            ACTIONOUT(ADVANCE);
            ACTIONOUT(DECR1MX);
            ACTIONOUT(FALSEJUMP);
            ACTIONOUT(GIVE);
            ACTIONOUT(INCR);
            ACTIONOUT(INCR1MX);
            ACTIONOUT(M1ZERO);
            ACTIONOUT(MOVE);
            ACTIONOUT(MOVEWHILE);
            ACTIONOUT(MXDECR1);
            ACTIONOUT(MXINCR1);
            ACTIONOUT(OFFINCR);
            ACTIONOUT(PRINT);
            ACTIONOUT(READ);
            ACTIONOUT(TAKE);
            ACTIONOUT(TERMINATE);
            ACTIONOUT(TRUEJUMP);
            ACTIONOUT(VALUE);
            ACTIONOUT(WHILEDECROI2);
            ACTIONOUT(WHILEIM2);
            ACTIONOUT(WHILEIM3);
            ACTIONOUT(WHILEMGM);
            ACTIONOUT(ZERO);
            ACTIONOUT(ZERO2IF);
            ACTIONOUT(ZEROM1);
        default:
            throw std::logic_error(__FILE__ " unhandled Action case in operator<<");
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rsi), %eax
cmpq $0x18, %rax
ja 0x382f
movq %rdi, %rbx
leaq 0x2a12(%rip), %rcx      # 0x6108
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2a66(%rip), %rsi      # 0x616c
jmp 0x3817
leaq 0x2ac9(%rip), %rsi      # 0x61db
jmp 0x3809
leaq 0x2aae(%rip), %rsi      # 0x61cc
jmp 0x37fb
leaq 0x2a8f(%rip), %rsi      # 0x61b9
jmp 0x3817
leaq 0x2a86(%rip), %rsi      # 0x61bc
jmp 0x37fb
leaq 0x2a7f(%rip), %rsi      # 0x61c1
jmp 0x3796
leaq 0x2a5e(%rip), %rsi      # 0x61a9
jmp 0x3817
leaq 0x2ac3(%rip), %rsi      # 0x621a
jmp 0x37c8
leaq 0x2a1c(%rip), %rsi      # 0x617c
jmp 0x37ed
leaq 0x2a65(%rip), %rsi      # 0x61d1
jmp 0x37ed
leaq 0x2a11(%rip), %rsi      # 0x6186
jmp 0x37fb
leaq 0x2a19(%rip), %rsi      # 0x619a
jmp 0x37fb
leaq 0x29ea(%rip), %rsi      # 0x6174
jmp 0x3817
leaq 0x2a4e(%rip), %rsi      # 0x61e4
movl $0x5, %edx
jmp 0x381c
leaq 0x2a5c(%rip), %rsi      # 0x6200
jmp 0x3809
leaq 0x29de(%rip), %rsi      # 0x618b
jmp 0x3817
leaq 0x2a53(%rip), %rsi      # 0x6209
jmp 0x3809
leaq 0x2a08(%rip), %rsi      # 0x61c7
jmp 0x37fb
leaq 0x29cb(%rip), %rsi      # 0x6193
movl $0x6, %edx
jmp 0x381c
leaq 0x2a14(%rip), %rsi      # 0x61ea
movl $0xc, %edx
jmp 0x381c
leaq 0x29cd(%rip), %rsi      # 0x61b1
jmp 0x3817
leaq 0x29b2(%rip), %rsi      # 0x619f
movl $0x9, %edx
jmp 0x381c
leaq 0x299a(%rip), %rsi      # 0x6195
movl $0x4, %edx
jmp 0x381c
leaq 0x29ee(%rip), %rsi      # 0x61f7
movl $0x8, %edx
jmp 0x381c
leaq 0x29fb(%rip), %rsi      # 0x6212
movl $0x7, %edx
movq %rbx, %rdi
callq 0x21e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x29de(%rip), %rsi      # 0x6221
movq %rax, %rdi
callq 0x2230
movq 0x577e(%rip), %rsi      # 0x8fd0
movq 0x575f(%rip), %rdx      # 0x8fb8
movq %rbx, %rdi
callq 0x22d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/include/bench.hpp
// Function: tag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string tag(std::string name){
    std::replace_if(begin(name), end(name), [](char c){ return !is_tag(c); }, '_');
    std::string res;
    res.swap(name);
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0xa905
movq (%r14), %r12
xorl %r13d, %r13d
movsbl (%r12,%r13), %ebp
movl %ebp, %edi
callq 0x41d0
cmpl $0x5f, %ebp
je 0xa8fd
testl %eax, %eax
jne 0xa8fd
movb $0x5f, (%r12,%r13)
incq %r13
cmpq %r13, %r15
jne 0xa8e3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4140
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/src/vector_list_update_1/bench.cpp
// Function: void bench_all<Trivial<8>, Trivial<32>, Trivial<128>, Trivial<1024>, Trivial<4096>, NonTrivialStringMovable, NonTrivialStringMovableNoExcept, NonTrivialArray<32>>()
void bench_all(){
    bench_types<bench_fill_back,        Types...>();
    bench_types<bench_emplace_back,     Types...>();
    bench_types<bench_fill_front,       Types...>();
    bench_types<bench_emplace_front,    Types...>();
    bench_types<bench_linear_search,    Types...>();
    bench_types<bench_write,            Types...>();
    bench_types<bench_random_insert,    Types...>();
    bench_types<bench_random_remove,    Types...>();
    bench_types<bench_sort,             Types...>();
    bench_types<bench_destruction,      Types...>();
    bench_types<bench_erase_1,          Types...>();
    bench_types<bench_erase_10,         Types...>();
    bench_types<bench_erase_25,         Types...>();
    bench_types<bench_erase_50,         Types...>();

    // The following are really slow so run only for limited set of data
    bench_types<bench_find,             TrivialSmall, TrivialMedium, TrivialLarge>();
    bench_types<bench_number_crunching, TrivialSmall, TrivialMedium>();
}

// Assembly:
pushq %rax
callq 0xab68
callq 0xae14
callq 0x211b6
callq 0x213f2
callq 0x2afde
callq 0x2b172
callq 0x2e74c
callq 0x2e8e0
callq 0x31e1c
callq 0x31fe8
callq 0x3ef50
callq 0x3f11c
callq 0x44158
callq 0x442ec
callq 0x50284
callq 0x50530
callq 0x6b0da
callq 0x6b2de
callq 0x8f382
callq 0x8f54e
callq 0x97742
callq 0x9790e
callq 0x9df38
callq 0x9e104
callq 0xa3e56
callq 0xa4022
callq 0xa9d74
callq 0xa9f40
callq 0xafc92
callq 0xafe5e
callq 0xb002a
callq 0xb01f6
popq %rax
jmp 0xb12ce
nop
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<NonTrivialStringMovable, std::allocator<NonTrivialStringMovable>, unsigned int>::initialize(unsigned int)
void initialize(const skipfield_type first_group_size)
	{
		first_group = PLF_COLONY_ALLOCATE(group_allocator_type, group_allocator_pair, 1, 0);

		try
		{
			#ifdef PLF_COLONY_VARIADICS_SUPPORT
				PLF_COLONY_CONSTRUCT(group_allocator_type, group_allocator_pair, first_group, first_group_size);
			#else
				PLF_COLONY_CONSTRUCT(group_allocator_type, group_allocator_pair, first_group, group(first_group_size));
			#endif
		}
		catch (...)
		{
			PLF_COLONY_DEALLOCATE(group_allocator_type, group_allocator_pair, first_group, 1);
			first_group = NULL;
			throw;
		}

		begin_iterator.group_pointer = first_group;
		begin_iterator.element_pointer = first_group->elements;
		begin_iterator.skipfield_pointer = first_group->skipfield;
		end_iterator = begin_iterator;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl $0x38, %edi
callq 0x41c0
movq %rax, %r15
movl %r14d, %eax
leaq (%rax,%rax,4), %r13
movq %r15, 0x30(%rbx)
leaq (,%r13,8), %rax
leal 0x1(%r14), %r12d
leaq (%rax,%r12,4), %rdi
callq 0x41c0
shlq $0x2, %r12
movq $0x0, 0x8(%r15)
leaq 0x28(%rax), %rcx
movq %rcx, (%r15)
leaq (%rax,%r13,8), %rdi
movq %rax, 0x10(%r15)
movq %rdi, 0x18(%r15)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x20(%r15)
movl $0x1, 0x30(%r15)
movl %r14d, 0x34(%r15)
xorl %esi, %esi
movq %r12, %rdx
callq 0x4100
movq 0x30(%rbx), %rax
movq %rax, 0x18(%rbx)
vmovups 0x10(%rax), %xmm0
vmovups %xmm0, 0x20(%rbx)
movq %rax, (%rbx)
vmovups %xmm0, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x40c0
movq 0x30(%rbx), %rdi
callq 0x41a0
movq $0x0, 0x30(%rbx)
callq 0x4270
movq %rax, %rbx
callq 0x42c0
movq %rbx, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0xab5d
nop
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::reserve(unsigned short)
void reserve(skipfield_type reserve_amount)
	{
		assert(reserve_amount > 2);

		if (reserve_amount > group_allocator_pair.max_elements_per_group)
		{
			reserve_amount = group_allocator_pair.max_elements_per_group;
		}
		else if (reserve_amount < min_elements_per_group)
		{
			reserve_amount = min_elements_per_group;
		}
		else if (reserve_amount > max_size())
		{
			reserve_amount = static_cast<skipfield_type>(max_size());
		}

		if (total_number_of_elements == 0) // Most common scenario
		{
			if (first_group != NULL) // Edge case - empty colony but first group is initialized ie. did have some insertions but all got erased
			{
				PLF_COLONY_DESTROY(group_allocator_type, group_allocator_pair, first_group);
				PLF_COLONY_DEALLOCATE(group_allocator_type, group_allocator_pair, first_group, 1);
			} // else: Empty colony, no inserts as yet, time to allocate

			initialize(reserve_amount);
			first_group->last_endpoint = first_group->elements; // elements + 1 by default
			first_group->number_of_elements = 0; // 1 by default
		}
		else if (reserve_amount <= capacity())
		{
			return;
		}
		else
		{
			const skipfield_type original_min_elements = min_elements_per_group;
			min_elements_per_group = reserve_amount;
			consolidate();
			min_elements_per_group = original_min_elements;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movzwl 0x42(%rdi), %eax
movl 0x40(%rdi), %ecx
cmpw %si, %cx
movl %esi, %ebp
cmoval %ecx, %ebp
cmpw %si, %ax
cmovbl %eax, %ebp
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0xccc6
movzwl %bp, %eax
cmpq $0x0, 0x30(%rbx)
je 0xccff
addq 0x70(%rbx), %rcx
movq (%rbx), %rdx
movq 0x18(%rdx), %rdx
subq 0x8(%rbx), %rdx
sarq $0x3, %rdx
addq %rcx, %rdx
jmp 0xcd01
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0xcce1
movq 0x10(%rax), %rdi
callq 0x41a0
movq 0x30(%rbx), %rdi
callq 0x41a0
movzwl %bp, %esi
movq %rbx, %rdi
callq 0xcab4
movq 0x30(%rbx), %rax
movq 0x10(%rax), %rcx
movq %rcx, (%rax)
movw $0x0, 0x30(%rax)
jmp 0xcd39
xorl %edx, %edx
cmpq %rax, %rdx
jae 0xcd39
movzwl 0x40(%rbx), %r15d
movw %bp, 0x40(%rbx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcd5c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xce1a
leaq 0x8(%rsp), %rdi
callq 0xc7b6
movw %r15w, 0x40(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xc7b6
movq %rbx, %rdi
callq 0x42d0
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::operator=(plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>&&)
colony & operator = (colony &&source)
		{
			assert (&source != this);

			destroy_all_data();

			// Move source values across:
			end_iterator = std::move(source.end_iterator);
			begin_iterator = std::move(source.begin_iterator);
			first_group = std::move(source.first_group);
			total_number_of_elements = source.total_number_of_elements;
			min_elements_per_group = source.min_elements_per_group;
			group_allocator_pair.max_elements_per_group = source.group_allocator_pair.max_elements_per_group;

			erased_locations = std::move(source.erased_locations);

			source.first_group = NULL;
			source.total_number_of_elements = 0; // Nullifying the other data members is unnecessary - technically all can be removed except first_group NULL and total_number_of_elements 0, to allow for clean destructor usage
			return *this;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xcc00
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movq 0x38(%r14), %rax
movq %rax, 0x38(%rbx)
movl 0x40(%r14), %eax
movl %eax, 0x40(%rbx)
leaq 0x48(%r14), %rsi
leaq 0x48(%rbx), %rdi
callq 0xcf42
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x30(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned short>::colony_iterator<std::allocator<Trivial<32>>, false> plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned short>::insert<plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned short>::colony_iterator<std::allocator<Trivial<32>>, false>>(plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned short>::plf_enable_if_c<!std::numeric_limits<plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned short>::colony_iterator<std::allocator<Trivial<32>>, false>>::is_integer, plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned short>::colony_iterator<std::allocator<Trivial<32>>, false>>::type, plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned short>::colony_iterator<std::allocator<Trivial<32>>, false>)
iterator insert (const typename plf_enable_if_c<!std::numeric_limits<iterator_type>::is_integer, iterator_type>::type first, const iterator_type last)
	{
		if (first == last)
		{
			return end_iterator;
		}

		const iterator return_iterator = insert(*first);
		iterator_type current_element = first;

		while (++current_element != last)
		{
			insert(*current_element);
		}

		return return_iterator;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq 0x8(%rdx), %rdx
cmpq 0x8(%rcx), %rdx
movq %rdi, 0x8(%rsp)
je 0xf991
movq %rcx, %r15
movq %r14, %rsi
callq 0xf28a
movq (%r12), %rbx
movq 0x8(%r12), %r13
movq 0x10(%r12), %rbp
leaq 0x10(%rsp), %r12
movzwl 0x2(%rbp), %eax
leaq 0x2(%rbp,%rax,2), %rbp
shll $0x5, %eax
leaq 0x20(%r13,%rax), %r13
cmpq (%rbx), %r13
jne 0xf97b
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xf97b
movq 0x18(%rax), %rcx
movzwl (%rcx), %r13d
leaq (%rcx,%r13,2), %rbp
shll $0x5, %r13d
addq 0x10(%rax), %r13
movq %rax, %rbx
cmpq 0x8(%r15), %r13
je 0xf9a2
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xf28a
jmp 0xf945
vmovups (%r14), %xmm0
vmovups %xmm0, (%rdi)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::reduced_stack::operator=(plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::reduced_stack&&)
reduced_stack & operator = (reduced_stack &&source) PLF_COLONY_NOEXCEPT
			{
				destroy_all_data();

				current_group = std::move(source.current_group);
				first_group = std::move(source.first_group);
				top_element = std::move(source.top_element);
				start_element = std::move(source.start_element);
				end_element = std::move(source.end_element);
				total_number_of_elements = source.total_number_of_elements;
				group_allocator_pair.min_elements_per_group = source.group_allocator_pair.min_elements_per_group;

				// Nullify source object's contents - only first_group and total_number_of_elements required to be altered for destructor to work on it:
				source.first_group = NULL;
				source.total_number_of_elements = 0;

				return *this;
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xcc3a
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
vmovups 0x28(%r14), %xmm0
vmovups %xmm0, 0x28(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x28(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xab5d
nop
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<NonTrivialStringMovable, std::allocator<NonTrivialStringMovable>, unsigned short>::clear()
void clear()
	{
		destroy_all_data();
		erased_locations.clear();
		total_number_of_elements = 0;
		begin_iterator.group_pointer = NULL;
		begin_iterator.element_pointer = NULL;
		begin_iterator.skipfield_pointer = NULL;
		end_iterator = begin_iterator;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1a796
leaq 0x48(%rbx), %rdi
callq 0x1a85a
xorl %eax, %eax
movq %rax, 0x68(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x58(%rbx)
movq %rax, 0x38(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rbx)
vmovups %ymm0, 0x10(%rbx)
popq %rbx
vzeroupper
retq
nop