LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::setupAIGame(Player*)
void Game::setupAIGame(Player *player)
{
    shuffleDeck(0);
    Card *c1 = getCard(player->getHand()[0]);
    Card *c2 = getCard(player->getHand()[1]);
    if (player == players[0])
    {
        swap(&c1, &deck[0]);
        swap(&c2, &deck[2]);
    }
    else if (player == players[1])
    {
        swap(&c1, &deck[1]);
        swap(&c2, &deck[3]);
    }
    distributeCards();

    if (flop[0] == NULL || flop[1] == NULL || flop[2] == NULL)
    {
        flipFlop(false);
    }
    else
    {
        swap(&flop[0], &deck[5]);
        swap(&flop[1], &deck[6]);
        swap(&flop[2], &deck[7]);
        deckPointer+=4;
    }
    if (turn == NULL)
    {
        flipTurn(false);
    }
    else
    {
        swap(&turn, &deck[9]);
        deckPointer+=2;
    }
    if (river == NULL)
    {
        flipRiver(false);
    }
    else
    {
        swap(&river, &deck[11]);
        deckPointer+=2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
xorl %esi, %esi
callq 0x43de
movq %r15, %rdi
callq 0x2a18
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x3c58
movq %rax, %r14
movq %r15, %rdi
callq 0x2a18
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x3c58
movq (%rbx), %rcx
cmpq %r15, (%rcx)
je 0x5107
cmpq %r15, 0x8(%rcx)
jne 0x5119
movl $0x58, %ecx
movl $0x48, %edx
jmp 0x5111
movl $0x50, %ecx
movl $0x40, %edx
movq %r14, (%rbx,%rdx)
movq %rax, (%rbx,%rcx)
movq %rbx, %rdi
callq 0x4368
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x515d
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x515d
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
je 0x515d
movq 0x68(%rbx), %rsi
movq %rsi, 0x10(%rbx)
movq %rax, 0x68(%rbx)
movups 0x70(%rbx), %xmm0
movups %xmm0, 0x18(%rbx)
movq %rcx, 0x70(%rbx)
movq %rdx, 0x78(%rbx)
movl 0x38(%rbx), %eax
jmp 0x517c
movslq 0x38(%rbx), %rax
movq 0x48(%rbx,%rax,8), %rcx
movq %rcx, 0x10(%rbx)
movq 0x50(%rbx,%rax,8), %rcx
movq %rcx, 0x18(%rbx)
movq 0x58(%rbx,%rax,8), %rcx
movq %rcx, 0x20(%rbx)
movq 0x28(%rbx), %rdx
testq %rdx, %rdx
je 0x5195
movq 0x88(%rbx), %rcx
movq %rdx, 0x88(%rbx)
jmp 0x519d
movslq %eax, %rcx
movq 0x68(%rbx,%rcx,8), %rcx
movq %rcx, 0x28(%rbx)
movq 0x30(%rbx), %rdx
testq %rdx, %rdx
je 0x51ba
movq 0x98(%rbx), %rcx
movq %rdx, 0x98(%rbx)
jmp 0x51c2
movslq %eax, %rcx
movq 0x78(%rbx,%rcx,8), %rcx
addl $0x8, %eax
movl %eax, 0x38(%rbx)
movq %rcx, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::aiSwap(Player*, bool, bool, bool)
void Game::aiSwap(Player *player, bool fl, bool tu, bool ri)
{
    shuffleDeck(3);
    player->getHand()[0] = deck[4];
    player->getHand()[1] = deck[5];
    if (fl)
    {
        flop[0] = deck[6];
        flop[1] = deck[7];
        flop[2] = deck[8];
        swap(&flop[0], &deck[5]);
        swap(&flop[1], &deck[6]);
        swap(&flop[2], &deck[7]);
    }
    if (tu)
    {
        turn = deck[9];
        swap(&turn, &deck[9]);
    }
    if (ri)
    {
        river = deck[10];
        swap(&river, &deck[11]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, -0x2c(%rbp)
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
movl $0x3, %esi
callq 0x43de
movq 0x60(%rbx), %r14
movq %r13, %rdi
callq 0x2a18
movq %r14, (%rax)
movq 0x68(%rbx), %r14
movq %r13, %rdi
callq 0x2a18
movq %r14, 0x8(%rax)
testl %r12d, %r12d
je 0x524f
movq 0x68(%rbx), %rax
movq 0x70(%rbx), %rcx
movq 0x78(%rbx), %rdx
movq 0x80(%rbx), %rsi
movq %rax, 0x10(%rbx)
movq %rcx, 0x68(%rbx)
movq %rcx, 0x18(%rbx)
movq %rdx, 0x70(%rbx)
movq %rdx, 0x20(%rbx)
movq %rsi, 0x78(%rbx)
testb %r15b, %r15b
je 0x525f
movq 0x88(%rbx), %rax
movq %rax, 0x28(%rbx)
cmpb $0x0, -0x2c(%rbp)
je 0x527e
movq 0x90(%rbx), %rax
movq 0x98(%rbx), %rcx
movq %rcx, 0x30(%rbx)
movq %rax, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/fredericmarchand[P]TexasHoldem/Node.cpp
// Function: Node::Node(NodeState*)
Node::Node(NodeState *state)
{
    parent = NULL;
    visits = 0;
    this->state = state;
    untriedMoves = *(state->getMoves());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x30(%rdi), %r15
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq %rsi, 0x48(%rdi)
movq %rsi, %rdi
callq 0x5d2c
movq %r15, %rdi
movq %rax, %rsi
callq 0x566c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq (%r15), %rdi
testq %rdi, %rdi
je 0x5321
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x2140
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2200
movq %r12, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/fredericmarchand[P]TexasHoldem/Node.cpp
// Function: Node::Node(moves, Node*, NodeState*)
Node::Node(Move move, Node *parent, NodeState *state)
{
    this->parent = parent;
    visits = 0;
    this->move = move;
    this->state = state;
    untriedMoves = *(state->getMoves());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x30(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movq %rdx, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movl %esi, 0x14(%rdi)
movq %rcx, 0x48(%rdi)
movq %rcx, %rdi
callq 0x5d2c
movq %r15, %rdi
movq %rax, %rsi
callq 0x566c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq (%r15), %rdi
testq %rdi, %rdi
je 0x539e
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x2140
movq %r14, %rdi
movq %rbx, %rsi
callq 0x221b
movq %r12, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/fredericmarchand[P]TexasHoldem/Node.cpp
// Function: Node::getUCB()
Node* Node::getUCB()
{
	if (children.size() == 0)
	{
		return NULL;
	}

	Node *child = NULL;
	float UCB = 0.0;
	for (int i = 1; i < children.size(); ++i)
	{
		Node *c = children.at(i);
		float temp = (c->getWins()/c->getVisits() + sqrt(2*log(this->getVisits()/c->getVisits())));
		if (UCB > temp)
		{
			UCB = temp;
			child = c;
		}

	}
    return child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
subq %rax, %rcx
sete %dl
cmpq $0x9, %rcx
setb %cl
orb %dl, %cl
jne 0x54fc
movq %rdi, %rbx
xorps %xmm0, %xmm0
movl $0x1, %r12d
xorl %r14d, %r14d
movss %xmm0, -0x2c(%rbp)
movq (%rax,%r12,8), %r13
movl (%r13), %eax
movl 0x10(%r13), %ecx
cltd
idivl %ecx
movl %eax, %r15d
movl 0x10(%rbx), %eax
cltd
idivl %ecx
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x20d0
addsd %xmm0, %xmm0
ucomisd 0x1cf5(%rip), %xmm0     # 0x71a8
jb 0x54bb
sqrtsd %xmm0, %xmm0
jmp 0x54c0
callq 0x20c0
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss -0x2c(%rbp), %xmm1
ucomiss %xmm0, %xmm1
cmovaq %r13, %r14
minss %xmm1, %xmm0
incq %r12
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x547e
jmp 0x54ff
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %r14
movl $0x50, %edi
callq 0x2130
movq %rax, %rbx
movq %rax, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %r12, %rcx
callq 0x5334
movq %rbx, -0x30(%rbp)
movq %rbx, -0x38(%rbp)
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdx
cmpq %rax, %rdx
je 0x5616
movq $-0x4, %r12
movl $0x4, %r13d
xorl %ebx, %ebx
cmpl %r15d, (%rax,%rbx,4)
jne 0x55fc
leaq (%rax,%r13), %rcx
cmpq %rdx, %rcx
je 0x55f4
leaq (%rax,%rbx,4), %rdi
leaq (%rax,%rbx,4), %rsi
addq $0x4, %rsi
subq %rax, %rdx
addq %r12, %rdx
callq 0x21a0
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdx
addq $-0x4, %rdx
movq %rdx, 0x38(%r14)
incq %rbx
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x2, %rcx
addq $-0x4, %r12
addq $0x4, %r13
cmpq %rbx, %rcx
ja 0x55c6
movq 0x20(%r14), %rsi
cmpq 0x28(%r14), %rsi
je 0x562e
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x20(%r14)
jmp 0x5644
addq $0x18, %r14
leaq -0x38(%rbp), %rbx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5778
movq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x50, %esi
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3fae
movl %eax, %r12d
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x3f4e
movq %r15, %rdi
movl %ebx, %esi
movl %r12d, %edx
movq %rax, %rcx
movl $0x1, %r8d
callq 0x2faa
movq 0x10(%r14), %rax
movq 0x18(%r14), %rdx
cmpq %rax, %rdx
je 0x5dea
movq $-0x4, %r15
movl $0x4, %r12d
xorl %r13d, %r13d
cmpl %ebx, (%rax,%r13,4)
jne 0x5dd0
leaq (%rax,%r12), %rcx
cmpq %rdx, %rcx
je 0x5dc8
leaq (%rax,%r13,4), %rdi
leaq (%rax,%r13,4), %rsi
addq $0x4, %rsi
subq %rax, %rdx
addq %r15, %rdx
callq 0x21a0
movq 0x10(%r14), %rax
movq 0x18(%r14), %rdx
addq $-0x4, %rdx
movq %rdx, 0x18(%r14)
incq %r13
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x2, %rcx
addq $-0x4, %r15
addq $0x4, %r12
cmpq %r13, %rcx
ja 0x5d9a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5e58
movq 0x41b6(%rip), %r14      # 0x9fd0
leaq 0x13a9(%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 0x3c4e
movq (%rax), %r14
movq (%rbx), %rdi
callq 0x508e
movq %rax, %r15
movq (%rbx), %rdi
callq 0x5098
movq %rax, %r12
movq (%rbx), %rdi
callq 0x50a2
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x35d0
movl %eax, %r14d
movq (%rbx), %rdi
callq 0x3c4e
movq 0x8(%rax), %r15
movq (%rbx), %rdi
callq 0x508e
movq %rax, %r12
movq (%rbx), %rdi
callq 0x5098
movq %rax, %r13
movq (%rbx), %rdi
callq 0x50a2
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x35d0
movl %eax, %r15d
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3fae
testl %eax, %eax
je 0x5f05
movl $0x2, %eax
cmpl %r15d, %r14d
jl 0x5ef6
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 0x5ef0
jmp 0x5ef6
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x60ae
xorl %r12d, %r12d
movq 0x3f42(%rip), %r14      # 0x9fd0
leaq 0x113b(%rip), %r15      # 0x71d0
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2150
incq %r12
cmpq %r12, 0x8(%rbx)
ja 0x6095
movq 0x3f1b(%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 0x6146
xorl %r13d, %r13d
movq 0x3eaa(%rip), %r15      # 0x9fd0
leaq 0x10a3(%rip), %r12      # 0x71d0
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2150
incq %r13
cmpq %r13, 0x8(%rbx)
ja 0x612d
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_O3/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, %edi
shrl $0x1f, %edi
addl %edx, %edi
sarl %edi
movslq %edi, %r12
movl %r12d, 0x4(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
subq %r12, %rdx
cmpq %r12, %rdx
jbe 0x15e1
movq %rsi, %r14
leaq 0x4(%rsp), %r15
movq %r12, %rdx
movsd (%rax,%rdx,8), %xmm0
movslq %edi, %rdx
movsd -0x8(%rax,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x15c1
movsd 0x8(%rax,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x15c1
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x15af
movl %edi, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x15c1
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2a28
movq (%r14), %rax
movq 0x8(%r14), %rcx
movslq 0x4(%rsp), %rdx
incq %rdx
movl %edx, 0x4(%rsp)
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
subq %r12, %rsi
movl %edx, %edi
cmpq %rdx, %rsi
ja 0x1579
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 0x1607
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1120
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e0a
movslq 0x41c(%r15), %rax
testq %rax, %rax
jle 0x21cc
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 0x21b6
movq %r10, %r15
addsd (%r14,%r15), %xmm1
addq %r8, %r15
cmpq %r15, %r9
jne 0x21a8
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%r11,8)
incq %r11
addq $0x8, %r14
cmpq %rax, %r11
jne 0x218c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfbe(%rip), %rdi       # 0x31b8
leaq 0xfc2(%rip), %rsi       # 0x31c3
callq 0x1140
movq %rax, %r12
movl 0x41c(%r15), %edx
movl 0x420(%r15), %ecx
movl 0x424(%r15), %r8d
leaq 0xfa0(%rip), %rsi       # 0x31c5
xorl %ebp, %ebp
movq %rax, %rdi
xorl %eax, %eax
callq 0x1170
movl $0x0, 0x8(%rsp)
movl 0x420(%r15), %ecx
testl %ecx, %ecx
jle 0x2332
movl 0x41c(%r15), %eax
movq %rbx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
testl %eax, %eax
jle 0x2324
xorl %ecx, %ecx
imull 0x8(%rsp), %eax
addl %ecx, %eax
cltq
movq (%r15), %rcx
cvttsd2si (%rcx,%rax,8), %r13d
testq %r14, %r14
je 0x22a3
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdx
callq 0x2983
movl %r13d, %ebp
cmpq 0x8(%r14), %rax
je 0x22a6
xorl %r13d, %r13d
movl 0x424(%r15), %ebp
jmp 0x22a6
movl %r13d, %ebp
testq %rbx, %rbx
je 0x22d9
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0xc(%rsp), %rdx
callq 0x2983
cmpq 0x8(%rbx), %rax
je 0x22d9
xorl %ebx, %ebx
testl %r13d, %r13d
movl 0x424(%r15), %r13d
movl $0x0, %ebp
cmovel %r13d, %ebp
jmp 0x22dc
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 0x2266
movl 0x8(%rsp), %ebp
movl 0x420(%r15), %ecx
incl %ebp
movl %ebp, 0x8(%rsp)
cmpl %ecx, %ebp
jl 0x2254
movq %r12, %rdi
callq 0x1100
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2424
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 0x2419
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 0x2411
testq %rdx, %rdx
setns %r8b
cmpq %rbx, %rdx
setl %cl
andb %r8b, %cl
cmpb $0x1, %cl
jne 0x2411
addsd (%r15,%rdx,8), %xmm0
incq %rdx
decl %r13d
jne 0x23f1
incq %r14
addq %rdi, %r15
cmpl %r14d, %eax
jne 0x23d0
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_O3/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 0x622a
movq (%rbx), %rsi
leaq 0x11044(%rip), %rdi     # 0x1615e
xorl %eax, %eax
callq 0x42f0
callq 0x48ac
testl %eax, %eax
je 0x5121
movq 0x19e7f(%rip), %rax     # 0x1efb0
movq (%rax), %rdi
callq 0x4150
andl $-0x21, %eax
cmpl $0x59, %eax
jne 0x51e9
leaq 0x11026(%rip), %rsi     # 0x16172
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x5f35
leaq 0x11021(%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 0x518d
movq %rdx, -0x38(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x28(%rbp)
jmp 0x5194
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 0x51d0
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4300
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51e9
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x4300
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x51fe
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 0x5226
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4300
jmp 0x5226
movq %rax, %rbx
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x524a
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x4300
jmp 0x524a
jmp 0x5247
jmp 0x5247
jmp 0x5247
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x525f
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10f02(%rip), %rsi     # 0x16187
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5f35
movq (%r15), %rdi
callq 0x42b0
testb %bl, %bl
je 0x52ac
leaq 0x10eee(%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 0x52cf
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x52f8
movq %rax, 0x8(%rdx)
movq %rdx, -0x58(%rbp)
leaq -0x78(%rbp), %rdi
movl $0x1, %edx
callq 0x5dce
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x53a5
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 0x12833
movl %eax, %r13d
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x535e
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x4300
testb %r13b, %r13b
je 0x5379
movq (%r14), %rax
addq %r12, %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x152b8
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 0x5320
leaq -0x78(%rbp), %rdi
callq 0x5e3a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
jmp 0x53f1
movq %rdx, %r14
movq %rax, %rbx
jmp 0x53e8
movq %rdx, %r14
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x53e8
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x4300
leaq -0x78(%rbp), %rdi
callq 0x5e3a
cmpl $0x1, %r14d
jne 0x5428
movq %rbx, %rdi
callq 0x4410
movq 0x19bb2(%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 0x53ae
movq %rbx, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x609e
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 0x5b74
movq -0x50(%rbp), %rax
cmpb $0x2d, (%rax)
je 0x6023
movq (%rbx,%r13,8), %rax
movq %rax, (%r14)
movq %r15, %rdi
leaq 0x10196(%rip), %rsi     # 0x161c3
callq 0x40b0
testl %eax, %eax
jne 0x603b
movb $0x1, 0x9(%r14)
movq %r15, %rdi
leaq 0x10181(%rip), %rsi     # 0x161c6
callq 0x40b0
testl %eax, %eax
jne 0x6053
movb $0x1, 0x8(%r14)
movq %r15, %rdi
leaq 0x100c3(%rip), %rsi     # 0x16120
callq 0x40b0
testl %eax, %eax
jne 0x606b
movb $0x1, 0xa(%r14)
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x6084
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x4300
incq %r13
cmpq %r13, %r12
jne 0x6003
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x389f
movq %rdi, %rbx
leaq 0x29be(%rip), %rcx      # 0x6124
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2a12(%rip), %rsi      # 0x6188
jmp 0x3887
leaq 0x2a75(%rip), %rsi      # 0x61f7
jmp 0x3879
leaq 0x2a5a(%rip), %rsi      # 0x61e8
jmp 0x386b
leaq 0x2a3b(%rip), %rsi      # 0x61d5
jmp 0x3887
leaq 0x2a32(%rip), %rsi      # 0x61d8
jmp 0x386b
leaq 0x2a2b(%rip), %rsi      # 0x61dd
jmp 0x3806
leaq 0x2a0a(%rip), %rsi      # 0x61c5
jmp 0x3887
leaq 0x2a6f(%rip), %rsi      # 0x6236
jmp 0x3838
leaq 0x29c8(%rip), %rsi      # 0x6198
jmp 0x385d
leaq 0x2a11(%rip), %rsi      # 0x61ed
jmp 0x385d
leaq 0x29bd(%rip), %rsi      # 0x61a2
jmp 0x386b
leaq 0x29c5(%rip), %rsi      # 0x61b6
jmp 0x386b
leaq 0x2996(%rip), %rsi      # 0x6190
jmp 0x3887
leaq 0x29fa(%rip), %rsi      # 0x6200
movl $0x5, %edx
jmp 0x388c
leaq 0x2a08(%rip), %rsi      # 0x621c
jmp 0x3879
leaq 0x298a(%rip), %rsi      # 0x61a7
jmp 0x3887
leaq 0x29ff(%rip), %rsi      # 0x6225
jmp 0x3879
leaq 0x29b4(%rip), %rsi      # 0x61e3
jmp 0x386b
leaq 0x2977(%rip), %rsi      # 0x61af
movl $0x6, %edx
jmp 0x388c
leaq 0x29c0(%rip), %rsi      # 0x6206
movl $0xc, %edx
jmp 0x388c
leaq 0x2979(%rip), %rsi      # 0x61cd
jmp 0x3887
leaq 0x295e(%rip), %rsi      # 0x61bb
movl $0x9, %edx
jmp 0x388c
leaq 0x2946(%rip), %rsi      # 0x61b1
movl $0x4, %edx
jmp 0x388c
leaq 0x299a(%rip), %rsi      # 0x6213
movl $0x8, %edx
jmp 0x388c
leaq 0x29a7(%rip), %rsi      # 0x622e
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 0x298a(%rip), %rsi      # 0x623d
movq %rax, %rdi
callq 0x2230
movq 0x570e(%rip), %rsi      # 0x8fd0
movq 0x56ef(%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_O3/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 0x8(%rsi), %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %r15, %r15
je 0xa815
movq (%r14), %r12
xorl %r13d, %r13d
movsbl (%r12,%r13), %ebp
movl %ebp, %edi
callq 0x41d0
cmpl $0x5f, %ebp
je 0xa80d
testl %eax, %eax
jne 0xa80d
movb $0x5f, (%r12,%r13)
incq %r13
cmpq %r13, %r15
jne 0xa7f3
leaq 0x10(%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
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_O3/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 0xaa84
callq 0xad30
callq 0x212bc
callq 0x214f8
callq 0x2afc6
callq 0x2b15a
callq 0x2e6c0
callq 0x2e854
callq 0x31d10
callq 0x31edc
callq 0x3eeea
callq 0x3f0b6
callq 0x4404a
callq 0x441de
callq 0x50004
callq 0x502b0
callq 0x6a932
callq 0x6ab36
callq 0x8e43c
callq 0x8e608
callq 0x96b34
callq 0x96d00
callq 0x9d344
callq 0x9d510
callq 0xa321a
callq 0xa33e6
callq 0xa90f0
callq 0xa92bc
callq 0xaefc6
callq 0xaf192
callq 0xaf35e
callq 0xaf52a
popq %rax
jmp 0xb05da
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc9a8
cmpq 0x18(%rdi), %rax
je 0xc9b1
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_O3/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, 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
movq %rdi, %rbx
movl $0x38, %edi
movl %esi, %r14d
callq 0x41c0
movl %r14d, %r13d
leaq (,%r13,8), %rcx
leal 0x1(%r14), %r12d
movq %rax, %r15
movq %rax, 0x30(%rbx)
leaq (%rcx,%r12,4), %rdi
callq 0x41c0
leaq (%rax,%r13,8), %rdi
shlq $0x2, %r12
leaq 0x8(%rax), %rcx
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x8(%r15)
xorl %esi, %esi
movq %rcx, (%r15)
movq %rax, 0x10(%r15)
movq %r12, %rdx
movq %rdi, 0x18(%r15)
vmovups %xmm0, 0x20(%r15)
movl $0x1, 0x30(%r15)
movl %r14d, 0x34(%r15)
callq 0x4100
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)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
vzeroupper
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 0xaa79
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x80, %rsp
movl 0x40(%rdi), %ebp
movzwl 0x42(%rdi), %eax
movq 0x38(%rdi), %rcx
movl %esi, %r14d
movq %rdi, %rbx
cmpw %si, %bp
cmoval %ebp, %r14d
cmpw %si, %ax
cmovbl %eax, %r14d
testq %rcx, %rcx
je 0xcbf0
cmpq $0x0, 0x30(%rbx)
movzwl %r14w, %eax
je 0xcc2a
movq (%rbx), %rdx
addq 0x70(%rbx), %rcx
movq 0x18(%rdx), %rdx
subq 0x8(%rbx), %rdx
sarq $0x3, %rdx
addq %rcx, %rdx
jmp 0xcc2c
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0xcc0b
movq 0x10(%rax), %rdi
callq 0x41a0
movq 0x30(%rbx), %rdi
callq 0x41a0
movzwl %r14w, %esi
movq %rbx, %rdi
callq 0xc9d0
movq 0x30(%rbx), %rax
movq 0x10(%rax), %rcx
movq %rcx, (%rax)
movw $0x0, 0x30(%rax)
jmp 0xcc5b
xorl %edx, %edx
cmpq %rax, %rdx
jae 0xcc5b
movw %r14w, 0x40(%rbx)
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcc7a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcd38
movq %rsp, %rdi
callq 0xc6de
movw %bp, 0x40(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rsp, %rdi
movq %rax, %rbx
callq 0xc6de
movq %rbx, %rdi
callq 0x42d0
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned int>::colony_iterator<std::allocator<Trivial<32>>, false> plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned int>::insert<plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned int>::colony_iterator<std::allocator<Trivial<32>>, false>>(plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned int>::plf_enable_if_c<!std::numeric_limits<plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned int>::colony_iterator<std::allocator<Trivial<32>>, false>>::is_integer, plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned int>::colony_iterator<std::allocator<Trivial<32>>, false>>::type, plf::colony<Trivial<32>, std::allocator<Trivial<32>>, unsigned int>::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 0x8(%rdx), %rdx
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
cmpq 0x8(%rcx), %rdx
je 0x100ef
movq %r14, %rsi
movq %rcx, %r15
callq 0xf99c
movq (%r12), %rbx
movq 0x8(%r12), %r13
movq 0x10(%r12), %rbp
leaq 0x10(%rsp), %r12
movl 0x4(%rbp), %ecx
movq %r13, %rax
leal 0x1(%rcx), %r13d
leaq 0x4(%rbp,%rcx,4), %rbp
shlq $0x5, %r13
addq %rax, %r13
cmpq (%rbx), %r13
jne 0x100d9
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x100d9
movq 0x18(%rax), %rcx
movq %rax, %rbx
movl (%rcx), %r13d
leaq (%rcx,%r13,4), %rbp
shlq $0x5, %r13
addq 0x10(%rax), %r13
cmpq 0x8(%r15), %r13
je 0x10100
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xf99c
jmp 0x1009f
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_O3/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 0xcb62
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)
xorl %eax, %eax
vmovups 0x28(%r14), %xmm0
vmovups %xmm0, 0x28(%rbx)
movq %rax, 0x8(%r14)
movq %rax, 0x28(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xaa79
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a838
leaq 0x48(%rbx), %rdi
callq 0x1a8fc
vxorps %xmm0, %xmm0, %xmm0
xorl %eax, %eax
movq %rax, 0x68(%rbx)
vmovups %xmm0, 0x58(%rbx)
vxorps %xmm0, %xmm0, %xmm0
movq %rax, 0x38(%rbx)
vmovups %ymm0, (%rbx)
vmovups %ymm0, 0x10(%rbx)
popq %rbx
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/include/policies.hpp
// Function: FilledRandom<std::__cxx11::list<NonTrivialStringMovable, std::allocator<NonTrivialStringMovable>>>::make(unsigned long)
inline static Container make(std::size_t size){
        // prepare randomized data that will have all the integers from the range
        if(v.size() != size){
            v.clear();
            v.reserve(size);
            for(std::size_t i = 0; i < size; ++i){
                v.push_back({i});
            }
            std::shuffle(begin(v), end(v), std::mt19937());
        }

        // fill with randomized data
        Container container;
        for(std::size_t i = 0; i < size; ++i){
            container.push_back(v[i]);
        }

        return container;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1398, %rsp           # imm = 0x1398
movq 0xb46f4(%rip), %rax     # 0xef890
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %rsi, %r14
movq %rdi, %rbx
subq 0xb46d5(%rip), %rax     # 0xef888
sarq $0x3, %rax
imulq %rax, %rcx
cmpq %rsi, %rcx
je 0x3b2c5
leaq 0xb46bd(%rip), %r15     # 0xef888
movq %r15, %rdi
callq 0x3a958
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a192
testq %r14, %r14
je 0x3b26e
leaq 0x20(%rsp), %rbp
leaq 0x10(%rsp), %r15
leaq 0xb4690(%rip), %r13     # 0xef888
xorl %r12d, %r12d
leaq 0x8(%rsp), %rsi
movq %rbp, 0x10(%rsp)
movq $0x41, 0x8(%rsp)
movq %r15, %rdi
xorl %edx, %edx
callq 0x42e0
vmovups 0x7cbaf(%rip), %zmm0    # 0xb7dd1
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rsp)
movq %rcx, 0x20(%rsp)
movb $0x4f, 0x40(%rax)
vmovups %zmm0, (%rax)
movq %rcx, 0x18(%rsp)
movb $0x0, (%rax,%rcx)
movq %r12, 0x30(%rsp)
movq %r13, %rdi
movq %r15, %rsi
vzeroupper
callq 0x3acf0
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3b266
callq 0x41a0
incq %r12
cmpq %r12, %r14
jne 0x3b1fb
movq 0xb4613(%rip), %rdi     # 0xef888
movq 0xb4614(%rip), %rsi     # 0xef890
movl $0x1, %eax
movl $0x1571, %ecx           # imm = 0x1571
movq $0x1571, 0x10(%rsp)     # imm = 0x1571
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
movq %rcx, 0x10(%rsp,%rax,8)
incq %rax
cmpq $0x270, %rax            # imm = 0x270
jne 0x3b28f
leaq 0x10(%rsp), %rdx
movq $0x270, 0x1380(%rdx) # imm = 0x270
callq 0x3a99d
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
movq $0x0, 0x10(%rbx)
testq %r14, %r14
je 0x3b306
xorl %r15d, %r15d
movq 0xb45a5(%rip), %rsi     # 0xef888
addq %r15, %rsi
movq %rbx, %rdi
callq 0x19b78
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4050
incq 0x10(%rbx)
addq $0x28, %r15
decq %r14
jne 0x3b2dc
movq %rbx, %rax
addq $0x1398, %rsp           # imm = 0x1398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rdi
movq %rax, %r14
cmpq %rbp, %rdi
je 0x3b33a
callq 0x41a0
jmp 0x3b33a
movq %rbx, %rdi
movq %rax, %r14
callq 0x19bce
movq %r14, %rdi
callq 0x42d0