LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/NodeState.cpp
// Function: NodeState::NodeState(Game*, Player*)
NodeState::NodeState(Game *game1, Player *player1)
{
	game = new Game(game1);
	player = game->getPlayers()[game1->getPlayerIndex(player1)];

	flopNull = false;
	turnNull = false;
	riverNull = false;
	if (game->getFlop()[0] == NULL)
		flopNull = true;
	if (game->getTurn() == NULL)
		turnNull = true;
	if (game->getRiver() == NULL)
		riverNull = true;

	game->setupAIGame(this->player);

	moves.push_back(FOLD);

	if (game->getNextPlayer(player)->getChipCount() >= 100 && player->getChipCount() >= 100)	//BET/RAISE
	{
		moves.push_back(BET);
	}

	if (game->getPreviousPlayer(player)->getState().bet > player->getState().bet)	
	{
		if (player->getChipCount() >= game->getPreviousPlayer(player)->getState().bet)
		{
			moves.push_back(CHECK);	//CALL
		}
	}
	else //CHECK
	{
		moves.push_back(CHECK);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
movl $0x1e0, %edi            # imm = 0x1E0
callq 0x2170
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x3622
movq %r13, (%r14)
movq %r13, %rdi
callq 0x3748
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x3a5e
cltq
movq (%r13,%rax,8), %rax
movq %rax, 0x8(%r14)
andw $0x0, 0x28(%r14)
movb $0x0, 0x2a(%r14)
movq (%r14), %rdi
callq 0x4702
cmpq $0x0, (%rax)
jne 0x50e1
movb $0x1, 0x28(%r14)
movq (%r14), %rdi
callq 0x470c
testq %rax, %rax
jne 0x50f3
movb $0x1, 0x29(%r14)
movq (%r14), %rdi
callq 0x4716
testq %rax, %rax
jne 0x5105
movb $0x1, 0x2a(%r14)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x4720
leaq -0x2c(%rbp), %rsi
andl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x55ae
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x39c6
movq %rax, %rdi
callq 0x2880
cmpl $0x64, %eax
jl 0x5159
movq 0x8(%r14), %rdi
callq 0x2880
cmpl $0x64, %eax
jl 0x5159
leaq -0x2c(%rbp), %rsi
movl $0x2, (%rsi)
movq %rbx, %rdi
callq 0x55ae
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x39fa
movq %rax, %rdi
callq 0x2b2a
movq %rax, %r15
movq 0x8(%r14), %rdi
callq 0x2b2a
shrq $0x20, %r15
shrq $0x20, %rax
cmpl %eax, %r15d
jle 0x51c3
movq 0x8(%r14), %rdi
callq 0x2880
movl %eax, %r15d
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x39fa
movq %rax, %rdi
callq 0x2b2a
shrq $0x20, %rax
cmpl %eax, %r15d
jl 0x51d5
leaq -0x2c(%rbp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x55ae
jmp 0x51d5
leaq -0x2c(%rbp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x55ae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5204
jmp 0x5204
jmp 0x5204
jmp 0x5204
jmp 0x5204
jmp 0x5204
movq %rax, %r14
movl $0x1e0, %esi            # imm = 0x1E0
movq %r13, %rdi
callq 0x2180
jmp 0x5207
jmp 0x5204
movq %rax, %r14
movq %rbx, %rdi
callq 0x4e4e
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/NodeState.cpp
// Function: NodeState::NodeState(NodeState*)
NodeState::NodeState(NodeState *state)
{
	game = new Game(state->getData());
	player = game->getPlayers()[state->getData()->getPlayerIndex(state->getPlayer())];

	flopNull = false;
	turnNull = false;
	riverNull = false;
	if (game->getFlop()[0] == NULL)
		flopNull = true;
	if (game->getTurn() == NULL)
		turnNull = true;
	if (game->getRiver() == NULL)
		riverNull = true;
	
	game->setupAIGame(player);

	moves.push_back(FOLD);

	if (game->getNextPlayer(player)->getChipCount() >= 100 && player->getChipCount() >= 100)	//BET/RAISE
	{
		moves.push_back(BET);
	}

	if (game->getPreviousPlayer(player)->getState().bet > player->getState().bet)	
	{
		if (player->getChipCount() >= game->getPreviousPlayer(player)->getState().bet)
		{
			moves.push_back(CHECK);	//CALL
		}
	}
	else //CHECK
	{
		moves.push_back(CHECK);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
movl $0x1e0, %edi            # imm = 0x1E0
callq 0x2170
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
callq 0x3622
movq %r12, (%r14)
movq %r12, %rdi
callq 0x3748
movq %rax, %r12
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq 0x3a5e
cltq
movq (%r12,%rax,8), %rax
movq %rax, 0x8(%r14)
andw $0x0, 0x28(%r14)
movb $0x0, 0x2a(%r14)
movq (%r14), %rdi
callq 0x4702
cmpq $0x0, (%rax)
jne 0x5297
movb $0x1, 0x28(%r14)
movq (%r14), %rdi
callq 0x470c
testq %rax, %rax
jne 0x52a9
movb $0x1, 0x29(%r14)
movq (%r14), %rdi
callq 0x4716
testq %rax, %rax
jne 0x52bb
movb $0x1, 0x2a(%r14)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x4720
leaq -0x24(%rbp), %rsi
andl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x55ae
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x39c6
movq %rax, %rdi
callq 0x2880
cmpl $0x64, %eax
jl 0x530f
movq 0x8(%r14), %rdi
callq 0x2880
cmpl $0x64, %eax
jl 0x530f
leaq -0x24(%rbp), %rsi
movl $0x2, (%rsi)
movq %rbx, %rdi
callq 0x55ae
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x39fa
movq %rax, %rdi
callq 0x2b2a
movq %rax, %r15
movq 0x8(%r14), %rdi
callq 0x2b2a
shrq $0x20, %r15
shrq $0x20, %rax
cmpl %eax, %r15d
jle 0x5379
movq 0x8(%r14), %rdi
callq 0x2880
movl %eax, %r15d
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x39fa
movq %rax, %rdi
callq 0x2b2a
shrq $0x20, %rax
cmpl %eax, %r15d
jl 0x538b
leaq -0x24(%rbp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x55ae
jmp 0x538b
leaq -0x24(%rbp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x55ae
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53b8
jmp 0x53b8
jmp 0x53b8
jmp 0x53b8
jmp 0x53b8
jmp 0x53b8
movq %rax, %r14
movl $0x1e0, %esi            # imm = 0x1E0
movq %r12, %rdi
callq 0x2180
jmp 0x53bb
jmp 0x53b8
movq %rax, %r14
movq %rbx, %rdi
callq 0x4e4e
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a5e
movl %eax, %r12d
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x39fa
pushq $0x1
popq %r8
movq %r15, %rdi
movl %ebx, %esi
movl %r12d, %edx
movq %rax, %rcx
callq 0x2b7e
leaq 0x10(%r14), %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
sarq $0x2, %rax
cmpq %r12, %rax
jbe 0x547e
movq %r15, %rdi
movq %r12, %rsi
callq 0x48e6
cmpl %ebx, (%rax)
jne 0x5475
movq (%r15), %rsi
addq %r13, %rsi
movq %r15, %rdi
callq 0x4db2
incq %r12
addq $0x4, %r13
jmp 0x5447
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x54c5
movq 0x3b22(%rip), %rdi      # 0x8fd0
leaq 0xd15(%rip), %rsi       # 0x61ca
callq 0x2160
movq %rax, %rdi
callq 0x20b0
movq (%rbx), %rdi
callq 0x3748
movq (%rax), %r14
movq (%rbx), %rdi
callq 0x4702
movq %rax, %r15
movq (%rbx), %rdi
callq 0x470c
movq %rax, %r12
movq (%rbx), %rdi
callq 0x4716
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x30e6
movl %eax, %r14d
movq (%rbx), %rdi
callq 0x3748
movq 0x8(%rax), %r15
movq (%rbx), %rdi
callq 0x4702
movq %rax, %r12
movq (%rbx), %rdi
callq 0x470c
movq %rax, %r13
movq (%rbx), %rdi
callq 0x4716
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x30e6
movl %eax, %r15d
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3a5e
testl %eax, %eax
je 0x555d
cmpl %r15d, %r14d
jge 0x5562
pushq $0x2
popq %rax
jmp 0x5568
cmpl %r15d, %r14d
jg 0x5558
sete %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x38bc(%rip), %r14      # 0x8fd0
leaq 0xab5(%rip), %r15       # 0x61d0
cmpq %r12, 0x8(%rbx)
jbe 0x5731
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
incq %r12
jmp 0x571b
movq 0x3898(%rip), %r14      # 0x8fd0
movq %r14, %rdi
callq 0x20b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x20b0
xorl %r12d, %r12d
leaq 0xa73(%rip), %r15       # 0x61d0
cmpq %r12, 0x8(%rbx)
jbe 0x5773
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
incq %r12
jmp 0x575d
movq 0x3856(%rip), %rdi      # 0x8fd0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %r14
xorl %ebx, %ebx
testq %rdi, %rdi
cmovleq %rbx, %r14
negq %r14
pushq $0x1
popq %r15
leaq (%r14,%r15), %rax
cmpq $0x1, %rax
je 0x132d
addq %r15, %rbx
movq %rbx, %rdi
callq 0x12ac
incq %r15
jmp 0x1313
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x1130
movq %rbx, %rdi
movl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
callq 0x10f0
movsd %xmm0, -0x10(%rbp)
movl $0x3b9aca00, %edi       # imm = 0x3B9ACA00
callq 0x12f6
movq %rax, %rbx
movq 0x2c62(%rip), %rdi      # 0x3fd8
leaq 0xc87(%rip), %rsi       # 0x2004
callq 0x10b0
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl $0xfffffefb, %esi       # imm = 0xFFFFFEFB
andl 0x18(%rax,%rdx), %esi
orl $0x4, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movq $0xd, 0x8(%rax,%rcx)
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x1110
movq %rax, %rdi
callq 0x1070
movq 0x2c16(%rip), %rdi      # 0x3fd8
leaq 0xc3f(%rip), %rsi       # 0x2008
callq 0x10b0
movl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
movq %rax, %rdi
callq 0x1050
leaq 0xc24(%rip), %rsi       # 0x2006
movq %rax, %rdi
callq 0x10b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1050
movq %rax, %rdi
callq 0x1070
leaq -0x28(%rbp), %rdi
callq 0x10e0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1411
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x10e0
movq %rbx, %rdi
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x3, %rsi
leaq 0x7(%rsp), %rdx
callq 0x1b34
movq (%r15), %r12
movq 0x8(%r15), %r15
subq %r12, %r15
sarq $0x3, %r15
leal -0x1(%r15), %ebp
movq %r14, 0x8(%rsp)
movq (%r14), %rax
movq %rax, 0x10(%rsp)
movl %r13d, %r14d
negl %r13d
xorl %ebx, %ebx
cmpq %rbx, %r15
jbe 0x13f0
leal (%rbx,%r13), %eax
testl %eax, %eax
movl $0x0, %ecx
cmovlel %ecx, %eax
leaq (%r12,%rax,8), %rdi
leal (%r14,%rbx), %eax
cmpl %eax, %ebp
cmovll %ebp, %eax
cltq
leaq (%r12,%rax,8), %rsi
callq 0x133c
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
jmp 0x13b6
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %eax
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movupd %xmm0, (%rdi)
pushq $0x2
popq %rcx
cltd
idivl %ecx
movslq %eax, %r12
leaq 0x4(%rsp), %r15
movl %eax, 0x4(%rsp)
movslq %eax, %rcx
movq (%r14), %rdx
movq 0x8(%r14), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
subq %r12, %rsi
cmpq %rcx, %rsi
jbe 0x147c
movsd -0x8(%rdx,%rcx,8), %xmm1
movsd (%rdx,%rcx,8), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x1478
movsd 0x8(%rdx,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1478
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b86
movl 0x4(%rsp), %eax
incl %eax
jmp 0x142f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x279c
movq %r14, %rdi
callq 0x11d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movslq 0x420(%rsi), %rsi
leaq 0x7(%rsp), %rdx
callq 0x1b34
movl 0x420(%r15), %eax
movslq 0x41c(%r15), %rcx
movq (%r15), %rdx
movslq %ebp, %r9
subl %r14d, %ebp
incl %ebp
cvtsi2sd %ebp, %xmm0
movq (%rbx), %rsi
xorl %edi, %edi
testl %eax, %eax
cmovlel %edi, %eax
movslq %r14d, %r8
shlq $0x3, %rcx
shlq $0x3, %r8
leaq 0x8(,%r9,8), %r9
cmpq %rax, %rdi
je 0x1e35
xorpd %xmm1, %xmm1
movq %r8, %r10
cmpq %r10, %r9
je 0x1e24
addsd (%rdx,%r10), %xmm1
addq $0x8, %r10
jmp 0x1e13
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rdi,8)
incq %rdi
addq %rcx, %rdx
jmp 0x1e07
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movslq 0x41c(%rsi), %rsi
leaq 0x7(%rsp), %rdx
callq 0x1b34
movslq 0x41c(%r15), %rax
movq (%r15), %rcx
movl %eax, %edx
imull %r14d, %edx
movslq %edx, %rdx
movl %eax, %esi
imull %ebp, %esi
movslq %esi, %r9
subl %r14d, %ebp
incl %ebp
cvtsi2sd %ebp, %xmm0
movq (%rbx), %rsi
xorl %edi, %edi
testl %eax, %eax
movl $0x0, %r8d
cmovgl %eax, %r8d
shlq $0x3, %rdx
shlq $0x3, %r9
leaq (%r9,%rax,8), %r9
shlq $0x3, %rax
cmpq %r8, %rdi
je 0x1eda
xorpd %xmm1, %xmm1
movq %rdx, %r10
cmpq %r10, %r9
je 0x1ec8
addsd (%rcx,%r10), %xmm1
addq %rax, %r10
jmp 0x1eb8
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rdi,8)
incq %rdi
addq $0x8, %rcx
jmp 0x1eac
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12b2(%rip), %rdi      # 0x31b8
leaq 0x12b6(%rip), %rsi      # 0x31c3
callq 0x1160
movq %rax, %r12
movl 0x41c(%r15), %edx
movl 0x420(%r15), %ecx
movl 0x424(%r15), %r8d
leaq 0x1294(%rip), %rsi      # 0x31c5
xorl %ebp, %ebp
movq %rax, %rdi
xorl %eax, %eax
callq 0x1190
movq %r15, 0x10(%rsp)
movl %ebp, 0x8(%rsp)
cmpl 0x420(%r15), %ebp
jge 0x2020
xorl %eax, %eax
movl %eax, 0xc(%rsp)
movl 0x41c(%r15), %ecx
cmpl %ecx, %eax
jge 0x2015
imull 0x8(%rsp), %ecx
addl %eax, %ecx
movslq %ecx, %rax
movq (%r15), %rcx
cvttsd2si (%rcx,%rax,8), %r13d
testq %r14, %r14
je 0x1fa6
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdx
callq 0x267c
movl %r13d, %ebp
cmpq 0x8(%r14), %rax
je 0x1fa9
xorl %r13d, %r13d
movl 0x424(%r15), %ebp
jmp 0x1fa9
movl %r13d, %ebp
testq %rbx, %rbx
je 0x1fe2
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0xc(%rsp), %rdx
callq 0x267c
cmpq 0x8(%rbx), %rax
je 0x1fe2
xorl %r15d, %r15d
testl %r13d, %r13d
movq 0x10(%rsp), %rax
movl 0x424(%rax), %r13d
movl $0x0, %ebp
cmovel %r13d, %ebp
jmp 0x1fe5
movl %r13d, %r15d
movl %ebp, %edi
movq %r12, %rsi
callq 0x11f0
movl %r13d, %edi
movq %r12, %rsi
callq 0x11f0
movl %r15d, %edi
movq %r12, %rsi
callq 0x11f0
movl 0xc(%rsp), %eax
incl %eax
movq 0x10(%rsp), %r15
jmp 0x1f55
movl 0x8(%rsp), %ebp
incl %ebp
jmp 0x1f42
movq %r12, %rdi
callq 0x1110
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %edx, %r9d
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movl %ecx, %eax
cltd
idivl %ebx
movl %eax, %r10d
movl $0x2, %ebp
movl %ecx, -0x8(%rsp)
movl %ecx, %eax
cltd
idivl %ebp
movl %eax, %r11d
movl %r8d, %eax
cltd
idivl %ebx
movl %eax, %ebx
movl %r8d, -0x4(%rsp)
movl %r8d, %eax
cltd
idivl %ebp
movslq 0x420(%rdi), %rdx
movslq 0x41c(%rdi), %r14
movslq %ebx, %rbx
cltq
movslq %r9d, %r9
movslq %r10d, %r10
movslq %esi, %rsi
leaq (%r10,%rsi), %r15
imulq %r14, %r15
shlq $0x3, %r15
addq (%rdi), %r15
movslq %r11d, %rdi
leaq (,%r14,8), %r11
addq %rbx, %r9
xorpd %xmm0, %xmm0
cmpq %rdi, %r10
jg 0x2107
movq %r10, %r12
addq %rsi, %r12
setns %r13b
cmpq %rdx, %r12
setl %bpl
andb %r13b, %bpl
movq %r9, %r12
movq %rbx, %r13
cmpq %rax, %r13
jg 0x20ff
testb %bpl, %bpl
je 0x20f7
testq %r12, %r12
setns %r8b
cmpq %r14, %r12
setl %cl
andb %r8b, %cl
cmpb $0x1, %cl
jne 0x20f7
addsd (%r15,%r12,8), %xmm0
incq %r13
incq %r12
jmp 0x20d2
incq %r10
addq %r11, %r15
jmp 0x20b3
movl -0x8(%rsp), %eax
orl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movl -0x4(%rsp), %eax
orl $0x1, %eax
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_O2/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 0x1a861(%rip), %rax     # 0x1efa8
movq (%rax), %rdi
callq 0x4140
cmpl $-0x1, %eax
je 0x4760
movl %eax, %edi
callq 0x4460
pushq $0x1
popq %rax
jmp 0x4762
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq (%rdi), %rdi
leaq 0xf9a4(%rip), %rsi      # 0x1413d
callq 0x40d0
movq %rax, %r12
leaq -0x270(%rbp), %r13
leaq -0x70(%rbp), %rbx
leaq -0x29(%rbp), %r15
movq %r12, %rdi
callq 0x4510
testl %eax, %eax
jne 0x47f4
movq %r13, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
movq %r12, %rdx
callq 0x4530
testq %rax, %rax
je 0x47b0
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x5542
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5c12
movq %rbx, %rdi
callq 0x41a0
jmp 0x47b0
movq %r12, %rdi
callq 0x44c0
movl %eax, %r14d
shrl $0x8, %r14d
andl $0xff, %r14d
sete %al
movl -0x30(%rbp), %ecx
xorb $0x1, %cl
orb %al, %cl
jne 0x4867
callq 0x4370
movq -0x50(%rbp), %r12
movq -0x48(%rbp), %r13
movq 0x1a77d(%rip), %r15     # 0x1efa8
pushq $-0x1
popq %rbx
movq (%r15), %rdi
cmpq %r13, %r12
je 0x4847
movq (%r12), %rsi
movl %ebx, %edx
callq 0x4100
addq $0x20, %r12
jmp 0x482e
leaq 0xf8aa(%rip), %rsi      # 0x140f8
pushq $-0x1
popq %rdx
callq 0x4100
callq 0x473c
testl %eax, %eax
je 0x4856
movq (%r15), %rdi
callq 0x4140
cmpq $0x0, -0x38(%rbp)
je 0x487b
leaq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x557e
leaq -0x50(%rbp), %rdi
callq 0x5652
movl %r14d, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48ad
jmp 0x48ad
jmp 0x48ad
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x41a0
jmp 0x48b0
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x5652
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/npazosmendez[P]branchsearch/branchsearch.cpp
// Function: print_window(char*, std::vector<branch_t*, std::allocator<branch_t*>>, int)
void print_window(char* regex_value, vector<branch_t*> filtered_branches, int selected_branch){
    erase();

    // selection may be out of range because of new regex
    int lines = filtered_branches.size();
    if(lines && selected_branch >= lines) selected_branch = lines - 1;

    init_pair(1, -1, -1);
    init_pair(2, COLOR_RED, -1);

    // print regex
    printw("regex: %s | %d\n\n", regex_value, lines);

    // print branches
    int i = 0;
    for (; i < filtered_branches.size() && i < max_branch_shown; ++i){
        addstr("  ");
        if(i == selected_branch) attrset(COLOR_PAIR(2));
        addstr(filtered_branches[i]->name.c_str());
        if(filtered_branches[i]->remote && not filtered_branches[i]->local)
            addstr(" [R]");
        addstr("\n");
        if(i == selected_branch) attrset(COLOR_PAIR(1));
    }
    if(i < filtered_branches.size()) addstr("...");

    // marker on selected branch
    if(lines > 0) mvaddstr(selected_branch + 2, 0, ">");
    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
callq 0x4370
movq 0x8(%r15), %r13
subq (%r15), %r13
shrq $0x3, %r13
leal -0x1(%r13), %ebx
cmpl %r12d, %r13d
cmovgl %r12d, %ebx
cmpl $0x1, %r13d
cmovbl %r12d, %ebx
pushq $0x1
popq %r14
pushq $-0x1
popq %r12
movl %r14d, %edi
movl %r12d, %esi
movl %r12d, %edx
callq 0x4060
pushq $0x2
popq %rdi
movl %r14d, %esi
movl %r12d, %edx
callq 0x4060
leaq 0xf4d3(%rip), %rdi      # 0x1413f
xorl %r14d, %r14d
movq -0x30(%rbp), %rsi
movq %r13, -0x30(%rbp)
movl %r13d, %edx
xorl %eax, %eax
callq 0x4300
movq 0x1a320(%rip), %r13     # 0x1efa8
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x3, %rax
cmpq %r14, %rax
jbe 0x4d3c
movslq 0x1a68d(%rip), %rcx     # 0x1f330
cmpq %rcx, %r14
jge 0x4d3c
movq (%r13), %rdi
leaq 0xf499(%rip), %rsi      # 0x14150
movl %r12d, %edx
callq 0x4100
cmpq %r14, %rbx
jne 0x4cd2
movq (%r13), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x4380
movq (%r13), %rdi
movq (%r15), %rax
movq (%rax,%r14,8), %rax
movq (%rax), %rsi
movl %r12d, %edx
callq 0x4100
movq (%r15), %rax
movq (%rax,%r14,8), %rax
cmpb $0x1, 0x21(%rax)
jne 0x4d0e
cmpb $0x0, 0x20(%rax)
jne 0x4d0e
movq (%r13), %rdi
leaq 0xf44d(%rip), %rsi      # 0x14153
movl %r12d, %edx
callq 0x4100
movq (%r13), %rdi
leaq 0xf435(%rip), %rsi      # 0x1414e
movl %r12d, %edx
callq 0x4100
cmpq %r14, %rbx
jne 0x4d34
movq (%r13), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x4380
incq %r14
jmp 0x4c88
cmpq %r14, %rax
jbe 0x4d54
movq (%r13), %rdi
leaq 0xf40c(%rip), %rsi      # 0x14158
pushq $-0x1
popq %rdx
callq 0x4100
cmpl $0x0, -0x30(%rbp)
jle 0x4d82
movq (%r13), %rdi
addl $0x2, %ebx
movl %ebx, %esi
xorl %edx, %edx
callq 0x4350
cmpl $-0x1, %eax
je 0x4d82
movq (%r13), %rdi
leaq 0xf3e2(%rip), %rsi      # 0x1415c
pushq $-0x1
popq %rdx
callq 0x4100
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4570
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x4370
movslq %ebx, %rax
movq (%r14), %rcx
movq (%rcx,%rax,8), %rsi
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x4490
movq (%rbx), %rsi
leaq 0xf394(%rip), %rdi      # 0x1415e
xorl %eax, %eax
callq 0x4300
callq 0x473c
testl %eax, %eax
je 0x4dd1
movq 0x1a1c7(%rip), %rax     # 0x1efa8
movq (%rax), %rdi
callq 0x4140
andl $-0x21, %eax
cmpl $0x59, %eax
jne 0x4e39
leaq 0xf37a(%rip), %rsi      # 0x14172
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x5810
leaq 0xf375(%rip), %rdx      # 0x14181
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x57e7
leaq -0x50(%rbp), %rdi
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x4764
leaq -0x50(%rbp), %rdi
callq 0x41a0
leaq -0x30(%rbp), %rdi
callq 0x41a0
leaq -0x70(%rbp), %rdi
callq 0x41a0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x41a0
jmp 0x4e5c
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x41a0
jmp 0x4e70
jmp 0x4e6d
jmp 0x4e6d
jmp 0x4e6d
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x41a0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x43f0
leaq 0xf2e8(%rip), %rsi      # 0x14187
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5810
movq (%r15), %rdi
callq 0x42c0
testb %bl, %bl
je 0x4ec6
leaq 0xf2d4(%rip), %rdi      # 0x14195
callq 0x42c0
xorl %edi, %edi
callq 0x4400
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x41a0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rdi, %r14
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x4f02
movq %rax, 0x8(%rdx)
movq %rdx, -0x30(%rbp)
leaq -0x58(%rbp), %rdi
pushq $0x1
popq %rdx
callq 0x56ce
xorl %r13d, %r13d
pushq $0x28
popq %r12
leaq -0x58(%rbp), %r15
xorl %ebx, %ebx
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %rbx, %rax
jbe 0x4f64
addq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x5886
testb %al, %al
je 0x4f5b
movq (%r14), %rax
addq %r13, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13466
incq %rbx
addq $0x28, %r13
jmp 0x4f1f
leaq -0x58(%rbp), %rdi
callq 0x5738
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
jmp 0x4f95
jmp 0x4f86
movq %rdx, %r14
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x5738
cmpl $0x1, %r14d
jne 0x4fcc
movq %rbx, %rdi
callq 0x4420
movq 0x1a006(%rip), %rax     # 0x1efb0
addq $0x10, %rax
leaq -0x58(%rbp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x4160
movq %r14, %rdi
callq 0x4610
callq 0x4550
jmp 0x4f6d
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andl $0x0, 0x7(%rdi)
movq %rdx, %r14
andq $0x0, (%rdi)
movslq %esi, %r12
pushq $0x1
popq %r13
leaq -0x50(%rbp), %r15
cmpq %r12, %r13
jge 0x5943
movq (%r14,%r13,8), %rsi
movq %r15, %rdi
leaq -0x29(%rbp), %rdx
callq 0x5542
movq -0x50(%rbp), %rax
cmpb $0x2d, (%rax)
je 0x58f1
movq (%r14,%r13,8), %rax
movq %rax, (%rbx)
movq %r15, %rdi
leaq 0xe8c8(%rip), %rsi      # 0x141c3
callq 0x5aff
testb %al, %al
je 0x5908
movb $0x1, 0x9(%rbx)
movq %r15, %rdi
leaq 0xe8b4(%rip), %rsi      # 0x141c6
callq 0x5aff
testb %al, %al
je 0x591f
movb $0x1, 0x8(%rbx)
movq %r15, %rdi
leaq 0xe7f7(%rip), %rsi      # 0x14120
callq 0x5aff
testb %al, %al
je 0x5936
movb $0x1, 0xa(%rbx)
movq %r15, %rdi
callq 0x41a0
incq %r13
jmp 0x58cc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x79a9
movsbl (%r15,%r13), %edi
callq 0x795c
testb %al, %al
jne 0x79a4
movb $0x5f, (%r15,%r13)
incq %r13
jmp 0x798c
leaq 0x10(%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
callq 0x4120
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/include/bench.hpp
// Function: void bench<plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned int>, std::chrono::duration<long, std::ratio<1l, 1000000l>>, Empty, ReserveSize, InsertSimple>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::initializer_list<int> const&)
void bench(const std::string& type, const std::initializer_list<int> &sizes){
    // create an element to copy so the temporary creation
    // and initialization will not be accounted in a benchmark
    for(auto size : sizes) {
        std::size_t duration = 0;

        for(std::size_t i=0; i<REPEAT; ++i) {
            auto container = CreatePolicy<Container>::make(size);

            Clock::time_point t0 = Clock::now();

            run<TestPolicy...>(container, size);

            Clock::time_point t1 = Clock::now();
            duration += std::chrono::duration_cast<DurationUnit>(t1 - t0).count();
        }

        graphs::new_result(type, std::to_string(size), duration / REPEAT);
    }

    CreatePolicy<Container>::clean();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
leaq 0x68(%rsp), %rbx
movq %rdi, 0x8(%rsp)
leaq (%rcx,%rax,4), %rax
movq %rax, 0x10(%rsp)
pushq $0x7
popq %rbp
leaq 0x20(%rsp), %r14
cmpq 0x10(%rsp), %rcx
je 0x87f5
movslq (%rcx), %r12
xorl %r15d, %r15d
movq %rcx, 0x18(%rsp)
subq $0x1, %rbp
jb 0x87b9
vxorps %xmm0, %xmm0, %xmm0
movabsq $-0xffffffd1, %rax      # imm = 0xFFFFFFFF0000002F
vmovups %zmm0, 0x20(%rsp)
vxorps %xmm0, %xmm0, %xmm0
movq %rax, 0x60(%rsp)
vmovups %ymm0, 0x10(%rbx)
vmovups %ymm0, (%rbx)
movq $0x8, 0x98(%rsp)
vzeroupper
callq 0x4030
movq %rax, %r13
movq %r14, %rdi
movl %r12d, %esi
callq 0x9e0a
movq %r14, %rdi
movq %r12, %rsi
callq 0x9974
callq 0x4030
subq %r13, %rax
movl $0x3e8, %ecx            # imm = 0x3E8
movq %r14, %rdi
cqto
idivq %rcx
addq %rax, %r15
callq 0x9956
jmp 0x873c
movq %r14, %rdi
movl %r12d, %esi
callq 0x88ca
movq %r15, %rax
xorl %edx, %edx
pushq $0x7
popq %rbp
divq %rbp
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x84c3b
movq %r14, %rdi
callq 0x40b0
movq 0x18(%rsp), %rcx
addq $0x4, %rcx
jmp 0x8726
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %rdi
movq %rax, %rbx
callq 0x40b0
jmp 0x8823
leaq 0x20(%rsp), %rdi
movq %rax, %rbx
callq 0x9956
movq %rbx, %rdi
callq 0x42c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::reduced_stack::pop()
void pop() PLF_COLONY_NOEXCEPT
		{
			#ifdef PLF_COLONY_TYPE_TRAITS_SUPPORT
				if (!(std::is_trivially_destructible<stack_element_type>::value)) // This if-statement should be removed by the compiler on resolution of stack_element_type
			#endif
			{
				PLF_COLONY_DESTROY(element_pointer_allocator_type, (*this), top_element);
			}

			// ie. if total_number_of_elements != 0 after decrement, or we were not already at the start of a non-first group
			if (total_number_of_elements-- == 1 || top_element != start_element) // If total_number_of_elements is now 0 after decrement, this essentially moves top_element back to it's initial position (start_element - 1). But otherwise, this is just a regular pop
			{
				--top_element;
			}
			else
			{ // ie. is start element, but not first group in stack (if it were, totalsize would be 0 after decrement)
				current_group = current_group->previous_group;
				start_element = current_group->elements;
				end_element = top_element = current_group->end;
			}
		}

// Assembly:
movq 0x28(%rdi), %rcx
movq 0x10(%rdi), %rax
leaq -0x1(%rcx), %rdx
movq %rdx, 0x28(%rdi)
cmpq $0x1, %rcx
je 0x941e
cmpq 0x18(%rdi), %rax
je 0x9427
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
retq
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %rax, (%rdi)
movq (%rax), %rcx
movq %rcx, 0x18(%rdi)
movq 0x18(%rax), %rax
movq %rax, 0x10(%rdi)
movq %rax, 0x20(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::initialize(unsigned short)
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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %ebp
pushq $0x38
popq %rdi
callq 0x41a0
movq %rax, 0x30(%rbx)
movq %rax, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x94c8
movq 0x30(%rbx), %rax
vmovdqu 0x10(%rax), %xmm0
vpbroadcastq %rax, %ymm1
vmovdqu %xmm0, 0x20(%rbx)
vpermq $0xd0, %ymm0, %ymm0     # ymm0 = ymm0[0,0,1,3]
vpblendd $0x3c, %ymm0, %ymm1, %ymm0 # ymm0 = ymm1[0,1],ymm0[2,3,4,5],ymm1[6,7]
vmovdqu %ymm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
vzeroupper
retq
movq %rax, %rdi
callq 0x4090
movq 0x30(%rbx), %rdi
callq 0x4180
andq $0x0, 0x30(%rbx)
callq 0x4240
movq %rax, %rbx
callq 0x42b0
movq %rbx, %rdi
callq 0x42c0
movq %rax, %rdi
callq 0x7b4a
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movl 0x40(%rdi), %ecx
movzwl 0x42(%rdi), %eax
movl %esi, %ebp
movq %rdi, %rbx
cmpw %si, %cx
cmoval %ecx, %ebp
cmpw %si, %ax
cmovbl %eax, %ebp
cmpq $0x0, 0x38(%rdi)
je 0x9634
movq %rbx, %rdi
movzwl %bp, %r14d
callq 0x966c
cmpq %r14, %rax
jae 0x9666
movzwl 0x40(%rbx), %r14d
movq %rbx, %rdi
movw %bp, 0x40(%rbx)
callq 0x9692
movw %r14w, 0x40(%rbx)
jmp 0x9666
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x964b
callq 0x95a8
movq 0x30(%rbx), %rdi
callq 0x4180
movzwl %bp, %esi
movq %rbx, %rdi
callq 0x9446
movq 0x30(%rbx), %rax
movq 0x10(%rax), %rcx
movq %rcx, (%rax)
andw $0x0, 0x30(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9566
movq (%r14), %rax
leaq 0x48(%r14), %rsi
leaq 0x48(%rbx), %rdi
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)
callq 0x98f8
vxorps %xmm0, %xmm0, %xmm0
movq %rbx, %rax
vmovups %xmm0, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false> plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::insert<plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false>>(plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::plf_enable_if_c<!std::numeric_limits<plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false>>::is_integer, plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false>>::type, plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r13
movq 0x8(%rdx), %rdx
movq %rsi, %r14
movq %rdi, %rbx
cmpq 0x8(%rcx), %rdx
je 0x987f
movq %rcx, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9180
vmovups (%r13), %xmm0
movq %rsp, %r12
vmovaps %xmm0, (%r12)
movq 0x10(%r13), %rax
leaq 0x18(%rsp), %r13
movq %rax, 0x10(%r12)
movq %r12, %rdi
callq 0x98a2
movq 0x8(%rax), %rax
cmpq 0x8(%r15), %rax
je 0x9890
movq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x9180
jmp 0x985b
vmovups (%r14), %xmm0
vmovups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<NonTrivialStringMovable, std::allocator<NonTrivialStringMovable>, unsigned short>::colony_iterator<std::allocator<NonTrivialStringMovable>, false>::operator++()
inline colony_iterator & operator ++ ()
#endif
		{
			assert(group_pointer != NULL); // covers uninitialised colony_iterator
			assert(!(element_pointer == group_pointer->last_endpoint && group_pointer->next_group != NULL)); // Assert that iterator is not already at end()

			++skipfield_pointer;
			element_pointer += 1 + *skipfield_pointer;
			skipfield_pointer += *skipfield_pointer;

			if (element_pointer == group_pointer->last_endpoint && group_pointer->next_group != NULL) // ie. beyond end of available data
			{
				group_pointer = group_pointer->next_group;
				element_pointer = group_pointer->elements + *(group_pointer->skipfield);
				skipfield_pointer = group_pointer->skipfield + *(group_pointer->skipfield);
			}

			return *this;
		}

// Assembly:
movq 0x10(%rdi), %rdx
movq 0x8(%rdi), %rcx
movq %rdi, %rax
movzwl 0x2(%rdx), %esi
imulq $0x28, %rsi, %rdi
leaq 0x2(%rdx,%rsi,2), %rdx
leaq 0x28(%rcx,%rdi), %rdi
movq (%rax), %rcx
movq %rdi, 0x8(%rax)
movq %rdx, 0x10(%rax)
cmpq (%rcx), %rdi
je 0x151a2
retq
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x151a1
movq %rcx, (%rax)
movq 0x18(%rcx), %rdx
movzwl (%rdx), %esi
imulq $0x28, %rsi, %rdi
addq 0x10(%rcx), %rdi
leaq (%rdx,%rsi,2), %rcx
movq %rdi, 0x8(%rax)
movq %rcx, 0x10(%rax)
retq