LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kmyk[P]procon26/procon26.cpp
// Function: signature_block(bool const (&) [8][8], point_t const&)
uint64_t signature_block(bool const (& a)[block_size][block_size], point_t const & offset) {
    static_assert (block_size == 8, "");
    uint64_t z = 0; // 8*8 == 64
    repeat_from (y, offset.y, 8) {
        uint64_t w = 0;
        repeat_from (x, offset.x, 8) {
            w = w << 1;
            if (a[y][x]) w = w | 1;
        }
        w = w << offset.x;
        z = (z << 8) | w;
    }
    z = z << (8 * offset.y);
    return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x1722b
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x8, -0x2c(%rbp)
jge 0x171fc
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x2c(%rbp), %rcx
testb $0x1, (%rax,%rcx)
je 0x171ef
movq -0x28(%rbp), %rax
orq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x171f1
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x171b9
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
shlq $0x8, %rax
orq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1719e
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: kmyk[P]procon26/procon26.cpp
// Function: board::board(board_t const&)
board::board(board_t const & a) {
    copy_cell_map(a.a, m_cell, [](bool x) -> int { return x; });
    repeat (y, board_size) {
        repeat (x, board_size) {
            m_packed[y * board_size + x] = m_cell[y][x];
        }
    }
    shrink();
    update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x2030, %rdi           # imm = 0x2030
callq 0x1b010
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x17360
movl $0x0, -0x18(%rbp)
cmpl $0x20, -0x18(%rbp)
jge 0x1733d
movl $0x0, -0x1c(%rbp)
cmpl $0x20, -0x1c(%rbp)
jge 0x1732d
movq -0x38(%rbp), %rsi
movslq -0x18(%rbp), %rcx
shlq $0x7, %rcx
movq %rsi, %rax
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
setne %al
movb %al, -0x39(%rbp)
addq $0x2030, %rsi           # imm = 0x2030
movl -0x18(%rbp), %eax
shll $0x5, %eax
addl -0x1c(%rbp), %eax
movslq %eax, %rdx
leaq -0x30(%rbp), %rdi
callq 0x1b030
movb -0x39(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x30(%rbp), %rdi
callq 0x1b070
leaq -0x30(%rbp), %rdi
callq 0x1b0e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x172c5
jmp 0x1732f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x172b8
movq -0x38(%rbp), %rdi
callq 0x173f0
movq -0x38(%rbp), %rdi
callq 0x17570
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kmyk[P]procon26/procon26.cpp
// Function: board::shrink()
void board::shrink() {
    m_offset = { 0, 0 };
    m_size = { N, N };
    shrink_cell(m_cell, m_offset, m_size, 1);
    repeat (y,board_size) {
        m_skips[y][board_size-1] = 1;
        for (int x = board_size - 2; x >= 0; -- x) {
            m_skips[y][x] = m_cell[y][x+1] == 0 ? 1 : m_skips[y][x+1] + 1;
        }
    }
    m_stone_offset = { 0, 0 };
    m_stone_size = { N, N };
    shrink_cell(m_cell, m_stone_offset, m_stone_size, [](int n) -> bool { return n <= 1; });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x1000(%rdi)
movl $0x20, -0x18(%rbp)
movl $0x20, -0x14(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x1008(%rdi)
movq %rdi, %rsi
addq $0x1000, %rsi           # imm = 0x1000
movq %rdi, %rdx
addq $0x1008, %rdx           # imm = 0x1008
movl $0x1, %ecx
callq 0x1b0f0
movl $0x0, -0x1c(%rbp)
cmpl $0x20, -0x1c(%rbp)
jge 0x17517
movq -0x40(%rbp), %rax
addq $0x102c, %rax           # imm = 0x102C
movslq -0x1c(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movl $0x1, 0x7c(%rax)
movl $0x1e, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x17507
movq -0x40(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x174b6
movl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x174dd
movq -0x40(%rbp), %rax
addq $0x102c, %rax           # imm = 0x102C
movslq -0x1c(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movl -0x44(%rbp), %edx
addq $0x102c, %rax           # imm = 0x102C
movslq -0x1c(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x17488
jmp 0x17509
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1745b
movq -0x40(%rbp), %rdi
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x28(%rbp), %rax
movq %rax, 0x1014(%rdi)
movl $0x20, -0x30(%rbp)
movl $0x20, -0x2c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0x101c(%rdi)
movq %rdi, %rsi
addq $0x1014, %rsi           # imm = 0x1014
movq %rdi, %rdx
addq $0x101c, %rdx           # imm = 0x101C
callq 0x17680
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: kmyk[P]procon26/procon26.cpp
// Function: board::update()
void board::update() {
    m_area = 0;
    m_stone_area = 0;
    m_first_stone = 1000000007;
    repeat (y,board_size) {
        repeat (x,board_size) {
            switch (m_cell[y][x]) {
                case 0:
                    m_area += 1;
                    break;
                case 1:
                    break;
                default:
                    m_stone_area += 1;
                    m_first_stone = std::min(m_first_stone, m_cell[y][x]);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, 0x1010(%rax)
movl $0x0, 0x1024(%rax)
movl $0x3b9aca07, 0x1028(%rax) # imm = 0x3B9ACA07
movl $0x0, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jge 0x1766b
movl $0x0, -0x10(%rbp)
cmpl $0x20, -0x10(%rbp)
jge 0x1765b
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x175ed
jmp 0x175e3
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x17602
jmp 0x17604
movq -0x18(%rbp), %rax
movl 0x1010(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1010(%rax)
jmp 0x1764b
jmp 0x1764b
movq -0x18(%rbp), %rsi
movl 0x1024(%rsi), %eax
addl $0x1, %eax
movl %eax, 0x1024(%rsi)
movq %rsi, %rdi
addq $0x1028, %rdi           # imm = 0x1028
movslq -0xc(%rbp), %rax
shlq $0x7, %rax
addq %rax, %rsi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x8440
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x1028(%rax)
jmp 0x1764d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x175ba
jmp 0x1765d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x175a9
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kmyk[P]procon26/procon26.cpp
// Function: board::is_intersect(block const&, placement_t const&, int*) const
bool board::is_intersect(block const & blk, placement_t const & p, int *skipp) const {
    repeat (i, blk.area()) {
        point_t q = blk.stones(p.f,p.r)[i] + p.p;
        if (q.y < 0 or board_size <= q.y or board_size <= q.x) {
            if (skipp) *skipp = board_size;
            return true;
        }
        if (q.x < 0) {
            if (skipp) *skipp = - q.x;
            return true;
        }
        if (at(q)) {
            if (skipp) *skipp = std::max(skip(q), blk.skips(p.f,p.r)[i]);
            return true;
        }
    }
    if (skipp) *skipp = 1;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17c30
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x17c05
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x7ec0
movq %rax, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x7ef0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
callq 0x7e80
movq %rax, -0x34(%rbp)
cmpl $0x0, -0x30(%rbp)
jl 0x17b44
movl $0x20, %eax
cmpl -0x30(%rbp), %eax
jle 0x17b44
movl $0x20, %eax
cmpl -0x34(%rbp), %eax
jg 0x17b5e
cmpq $0x0, -0x28(%rbp)
je 0x17b55
movq -0x28(%rbp), %rax
movl $0x20, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x17c1a
cmpl $0x0, -0x34(%rbp)
jge 0x17b7f
cmpq $0x0, -0x28(%rbp)
je 0x17b76
xorl %ecx, %ecx
subl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x17c1a
movq -0x50(%rbp), %rdi
movq -0x34(%rbp), %rax
movq %rax, -0x3c(%rbp)
movq -0x3c(%rbp), %rsi
callq 0x17970
cmpl $0x0, %eax
je 0x17bf5
cmpq $0x0, -0x28(%rbp)
je 0x17bef
movq -0x50(%rbp), %rdi
movq -0x34(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
callq 0x17a40
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x17c50
movq %rax, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x1b130
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x5330
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x17c1a
jmp 0x17bf7
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x17ad7
cmpq $0x0, -0x28(%rbp)
je 0x17c16
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kmyk[P]procon26/procon26.cpp
// Function: board::is_puttable(block const&, placement_t const&, int, int*) const
bool board::is_puttable(block const & blk, placement_t const & p, int n, int *skipp) const {
    if (is_intersect(blk, p, skipp)) return false;
    if (is_new()) {
        return true;
    } else {
        repeat (j,blk.area()) {
            repeat (i,4) {
                point_t r = blk.stones(p.f,p.r)[j] + p.p + dp[i];
                if (not is_on_board(r)) continue;
                int a = at(r);
                if (2 <= a and a < n) return true; // is a stone
                if (2 <= a and n < a and a == m_first_stone) return true;
            }
        }
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x17ab0
testb $0x1, %al
jne 0x17cba
jmp 0x17cc3
movb $0x0, -0x1(%rbp)
jmp 0x17def
movq -0x60(%rbp), %rdi
callq 0x17a20
testb $0x1, %al
jne 0x17cd2
jmp 0x17cdb
movb $0x1, -0x1(%rbp)
jmp 0x17def
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17c30
movl %eax, %ecx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jge 0x17deb
movl $0x0, -0x38(%rbp)
cmpl $0x4, -0x38(%rbp)
jge 0x17ddb
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x7ec0
movq %rax, %rdi
movslq -0x34(%rbp), %rsi
callq 0x7ef0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
callq 0x7e80
movq %rax, -0x48(%rbp)
movslq -0x38(%rbp), %rax
leaq 0x94df(%rip), %rsi      # 0x21230
shlq $0x3, %rax
addq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x7e80
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1ecd0
testb $0x1, %al
jne 0x17d74
jmp 0x17dcd
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x54(%rbp)
movq -0x54(%rbp), %rsi
callq 0x17970
movl %eax, -0x4c(%rbp)
movl $0x2, %eax
cmpl -0x4c(%rbp), %eax
jg 0x17da4
movl -0x4c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x17da4
movb $0x1, -0x1(%rbp)
jmp 0x17def
movl $0x2, %eax
cmpl -0x4c(%rbp), %eax
jg 0x17dcb
movl -0x24(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jge 0x17dcb
movq -0x60(%rbp), %rcx
movl -0x4c(%rbp), %eax
cmpl 0x1028(%rcx), %eax
jne 0x17dcb
movb $0x1, -0x1(%rbp)
jmp 0x17def
jmp 0x17dcd
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x17d05
jmp 0x17ddd
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x17ce2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kmyk[P]procon26/procon26.cpp
// Function: next_placement(placement_t&, block const&, point_t const&, point_t const&)
bool next_placement(placement_t & p, block const & blk, point_t const & lp, point_t const & rp) {
    p.p.x += 1;
    if (p.p.x >= rp.x + 1 - blk.offset(p.f, p.r).x) {
        p.p.x = initial_placement(blk, lp, p.f, p.r).p.x;
        p.p.y += 1;
        if (p.p.y >= rp.y + 1 - blk.offset(p.f, p.r).y) {
            do {
                p.r = rot90(p.r);
                if (p.r == R0) {
                    p.f = flip(p.f);
                    if (p.f == H) {
                        return false;
                    }
                }
            } while (blk.is_duplicated(p.f, p.r));
            p.p = initial_placement(blk, lp, p.f, p.r).p;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x64(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x19470
movl -0x68(%rbp), %ecx
movq %rax, %rdx
movl -0x64(%rbp), %eax
movq %rdx, -0x30(%rbp)
subl -0x30(%rbp), %ecx
cmpl %ecx, %eax
jl 0x19b0a
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
leaq -0x44(%rbp), %rdi
callq 0x198b0
movl -0x40(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x6c(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x19470
movl -0x70(%rbp), %ecx
movq %rax, %rdx
movl -0x6c(%rbp), %eax
movq %rdx, -0x4c(%rbp)
subl -0x48(%rbp), %ecx
cmpl %ecx, %eax
jl 0x19b08
jmp 0x19a79
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x1e8f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x19abf
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x1e8d0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x19abd
movb $0x0, -0x1(%rbp)
jmp 0x19b0e
jmp 0x19abf
jmp 0x19ac1
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x19750
testb $0x1, %al
jne 0x19a79
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
leaq -0x60(%rbp), %rdi
callq 0x198b0
movq -0x10(%rbp), %rax
movq -0x5c(%rbp), %rcx
movq %rcx, 0x4(%rax)
jmp 0x19b0a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: kmyk[P]procon26/procon26.cpp
// Function: operator<<(std::ostream&, board const&)
std::ostream & operator << (std::ostream & out, board const & brd) {
    repeat (y, board_size) {
        repeat (x, board_size) {
            int n = brd.at({ x, y });
            if (n == 0) {
                out << "\x1b[40m  ";
            } else if (n == 1) {
                out << "\x1b[47m  ";
            } else {
                const char table[] = "0123456789ABCDEF";
                int a = (n-2)/16;
                int b = (n-2)%16;
                out << "\x1b[4" << ((n - 2) % 6 + 1) << "m" << (a == 0 ? ' ' : table[a]) << table[b];
            }
        }
        out << "\x1b[49m" << std::endl;
    }
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jge 0x19c9a
movl $0x0, -0x18(%rbp)
cmpl $0x20, -0x18(%rbp)
jge 0x19c6d
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x24(%rbp), %rsi
callq 0x17970
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x19b89
movq -0x8(%rbp), %rdi
leaq 0x77c4(%rip), %rsi      # 0x21343
callq 0x2130
jmp 0x19c5d
cmpl $0x1, -0x1c(%rbp)
jne 0x19ba4
movq -0x8(%rbp), %rdi
leaq 0x77b1(%rip), %rsi      # 0x2134b
callq 0x2130
jmp 0x19c5b
movq 0x77b5(%rip), %rax      # 0x21360
movq %rax, -0x40(%rbp)
movq 0x77b2(%rip), %rax      # 0x21368
movq %rax, -0x38(%rbp)
movb 0x77b0(%rip), %al       # 0x21370
movb %al, -0x30(%rbp)
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, -0x44(%rbp)
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %edx, -0x48(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7763(%rip), %rsi      # 0x21353
callq 0x2130
movq %rax, %rdi
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, %esi
addl $0x1, %esi
callq 0x2250
movq %rax, %rdi
leaq 0x7741(%rip), %rsi      # 0x2135b
callq 0x2130
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0x19c30
movb $0x20, %al
movb %al, -0x51(%rbp)
jmp 0x19c3b
movslq -0x44(%rbp), %rax
movb -0x40(%rbp,%rax), %al
movb %al, -0x51(%rbp)
movq -0x50(%rbp), %rdi
movb -0x51(%rbp), %al
movsbl %al, %esi
callq 0x2190
movq %rax, %rdi
movslq -0x48(%rbp), %rax
movsbl -0x40(%rbp,%rax), %esi
callq 0x2190
jmp 0x19c5d
jmp 0x19c5f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x19b48
movq -0x8(%rbp), %rdi
leaq 0x76df(%rip), %rsi      # 0x21357
callq 0x2130
movq %rax, %rdi
movq 0x18329(%rip), %rsi     # 0x31fb0
callq 0x2170
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19b37
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kmyk[P]procon26/procon26.cpp
// Function: void shrink_cell_helper<void shrink_cell<int, 32, board::shrink()::$_0>(int const (&) [32][32], point_t&, point_t&, board::shrink()::$_0)::'lambda'(int), void shrink_cell<int, 32, board::shrink()::$_0>(int const (&) [32][32], point_t&, point_t&, board::shrink()::$_0)::'lambda'()>(int, int, void shrink_cell<int, 32, board::shrink()::$_0>(int const (&) [32][32], point_t&, point_t&, board::shrink()::$_0)::'lambda'())
void shrink_cell_helper(int n, F pred, G update) {
    while (true) {
        repeat (i,n) {
            if (pred(i)) return; // if something found, exit
        }
        update(); // shrink
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x19d1f
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x19e50
testb $0x1, %al
jne 0x19d0c
jmp 0x19d12
addq $0x20, %rsp
popq %rbp
retq
jmp 0x19d14
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x19cf2
leaq -0x10(%rbp), %rdi
callq 0x19ea0
jmp 0x19ceb
nopw (%rax,%rax)
// File: kmyk[P]procon26/procon26.cpp
// Function: int area_cell<bool, 8>(bool const (&) [8][8], bool)
int area_cell(T const (& a)[N][N], T target) {
    int n = 0;
    repeat (y,N) {
        repeat (x,N) {
            if (a[y][x] == target) {
                n += 1;
            }
        }
    }
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x1b42c
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x1b41f
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x9(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x1b412
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1b414
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1b3db
jmp 0x1b421
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b3ce
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: kmyk[P]procon26/procon26.cpp
// Function: void copy_cell_flip<bool, 8>(bool const (&) [8][8], bool (&) [8][8])
void copy_cell_flip(T const (& src)[N][N], T (& dst)[N][N]) {
    repeat (y,N) {
        repeat (x,N) {
            // > 裏返した後は，与えられたときの配置と左右に反転しているものとする。
            dst[y][N-x-1] = src[y][x];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x1b527
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x1b51a
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movl $0x8, %ecx
subl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1b4d0
jmp 0x1b51c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b4c3
popq %rbp
retq
nopl (%rax)
// File: kmyk[P]procon26/procon26.cpp
// Function: void copy_cell_rot90<bool, 8>(bool const (&) [8][8], bool (&) [8][8])
void copy_cell_rot90(T const (& src)[N][N], T (& dst)[N][N]) {
    repeat (y,N) {
        repeat (x,N) {
            // 8×8 のマス全体を時計回りに 90 度，180 度，270 度回転させることができる。
            dst[x][N-1-y] = src[y][x];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x1b5a4
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x1b597
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movl $0x7, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1b550
jmp 0x1b599
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b543
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kmyk[P]procon26/procon26.cpp
// Function: std::vector<point_t, std::allocator<point_t>> collect_cell<bool, 8>(bool const (&) [8][8], point_t const&, point_t const&)
std::vector<point_t> collect_cell(T const (& a)[N][N], point_t const & offset, point_t const & size) {
    std::vector<point_t> result;
    repeat (y,size.y) {
        repeat (x,size.x) {
            point_t p = offset + (point_t) { x, y };
            if (a[p.y][p.x]) result.push_back(p);
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x7f10
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x1b6c0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1b6b0
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x38(%rbp)
leaq -0x3c(%rbp), %rsi
callq 0x7e80
movq %rax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x34(%rbp), %rcx
testb $0x1, (%rax,%rcx)
je 0x1b6a3
movq -0x60(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x7f30
jmp 0x1b68a
jmp 0x1b6a3
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x7180
jmp 0x1b6dd
jmp 0x1b6a5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1b63a
jmp 0x1b6b2
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1b623
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x1b6d3
movq -0x60(%rbp), %rdi
callq 0x7180
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2260
nopw %cs:(%rax,%rax)
// File: kmyk[P]procon26/common.cpp
// Function: operator>>(std::istream&, board_t&)
std::istream & operator >> (std::istream & input, board_t & a)  {
    repeat (y,board_size) {
        repeat (x,board_size) {
            char c; input >> c;
            a.a[y][x] = c != '0';
        }
    }
    return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jge 0x1e772
movl $0x0, -0x18(%rbp)
cmpl $0x20, -0x18(%rbp)
jge 0x1e765
movq -0x8(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x21d0
movsbl -0x19(%rbp), %eax
cmpl $0x30, %eax
setne %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e724
jmp 0x1e767
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1e717
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kmyk[P]procon26/common.cpp
// Function: operator>>(std::istream&, block_t&)
std::istream & operator >> (std::istream & input, block_t & a)  {
    repeat (y,block_size) {
        repeat (x,block_size) {
            char c; input >> c;
            a.a[y][x] = c != '0';
        }
    }
    return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x1e7f2
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x1e7e5
movq -0x8(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x21d0
movsbl -0x19(%rbp), %eax
cmpl $0x30, %eax
setne %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e7a4
jmp 0x1e7e7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1e797
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kmyk[P]procon26/common.cpp
// Function: operator>>(std::istream&, input_t&)
std::istream & operator >> (std::istream & input, input_t & a)  {
    input >> a.board;
    // > 石の個数は 1 個以上，256 個以下です。
    int n; input >> n;
    assert (1 <= n and n <= 256);
    a.blocks.resize(n);
    repeat (i,n) input >> a.blocks[i];
    return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e700
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x20c0
xorl %eax, %eax
movl $0x1, %ecx
cmpl -0x14(%rbp), %ecx
movb %al, -0x19(%rbp)
jg 0x1e846
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1e84f
jmp 0x1e851
jmp 0x1e870
leaq 0x2b19(%rip), %rdi      # 0x21371
leaq 0x2b26(%rip), %rsi      # 0x21385
movl $0x19, %edx
leaq 0x2b25(%rip), %rcx      # 0x21390
callq 0x20d0
movq -0x10(%rbp), %rdi
addq $0x400, %rdi            # imm = 0x400
movslq -0x14(%rbp), %rsi
callq 0x1ee00
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1e8c6
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x400, %rdi            # imm = 0x400
movslq -0x18(%rbp), %rsi
callq 0x1ee90
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1e780
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e88b
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: kmyk[P]procon26/main.cpp
// Function: signal_handler(int)
void signal_handler(int param) {
    cerr << "*** signal " << param << " caught ***" << endl;
    cout << g_provisional_result;
    cerr << "***" << endl;
    export_to_file(g_provisional_result);
    cerr << g_best_score << " " << g_best_stone << endl;
    exit(param);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x1266e(%rip), %rdi     # 0x31ff0
leaq 0x1a67(%rip), %rsi      # 0x213f0
callq 0x2130
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x1a59(%rip), %rsi      # 0x213fc
callq 0x2130
movq %rax, %rdi
movq 0x125fe(%rip), %rsi     # 0x31fb0
callq 0x2170
movq 0x1260a(%rip), %rdi     # 0x31fc8
leaq 0x127ab(%rip), %rsi     # 0x32170
callq 0x1eb30
movq 0x1261f(%rip), %rdi     # 0x31ff0
leaq 0x1a99(%rip), %rsi      # 0x21471
callq 0x2130
movq %rax, %rdi
movq 0x125c9(%rip), %rsi     # 0x31fb0
callq 0x2170
leaq 0x1277d(%rip), %rdi     # 0x32170
callq 0x1f960
movl 0x1275a(%rip), %esi     # 0x32158
movq 0x125eb(%rip), %rdi     # 0x31ff0
callq 0x2250
movq %rax, %rdi
leaq 0x1935(%rip), %rsi      # 0x21349
callq 0x2130
movq %rax, %rdi
movl 0x1273a(%rip), %esi     # 0x3215c
callq 0x2250
movq %rax, %rdi
movq 0x1257f(%rip), %rsi     # 0x31fb0
callq 0x2170
movl -0x4(%rbp), %edi
callq 0x21b0
nop
// File: kuszmaul[P]6886/lock-overhead.cc
// Function: main
int main(int argc, char *argv[] __attribute__((unused))) {
  assert(argc == 1);
  timeit(global_list,    "global list");
  timeit(per_schedcpu,   "per cpu (\\mintinline{c}{sched\\_cpu()} every time)");
  char name[99];
  snprintf(name, sizeof(name), "per cpu (cache getcpu, refresh every %d", cpu_cache_recheck_freq);
  timeit(per_cachedcpu,  name); 
  timeit(per_thread,     "per thread");
  timeit(in_stack,       "local in stack");
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x1231
jmp 0x1250
leaq 0xde8(%rip), %rdi       # 0x2020
leaq 0xdeb(%rip), %rsi       # 0x202a
movl $0x7c, %edx
leaq 0xdf0(%rip), %rcx       # 0x203b
callq 0x1080
leaq 0x189(%rip), %rdi       # 0x13e0
leaq 0xdf4(%rip), %rsi       # 0x2052
callq 0x12e0
leaq 0x1b6(%rip), %rdi       # 0x1420
leaq 0xded(%rip), %rsi       # 0x205e
callq 0x12e0
leaq -0x80(%rbp), %rdi
movl $0x63, %esi
leaq 0xe0a(%rip), %rdx       # 0x2090
movl $0x20, %ecx
movb $0x0, %al
callq 0x10e0
leaq -0x80(%rbp), %rsi
leaq 0x1d3(%rip), %rdi       # 0x1470
callq 0x12e0
leaq 0x227(%rip), %rdi       # 0x14d0
leaq 0xe08(%rip), %rsi       # 0x20b8
callq 0x12e0
leaq 0x254(%rip), %rdi       # 0x1510
leaq 0xe00(%rip), %rsi       # 0x20c3
callq 0x12e0
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kuszmaul[P]6886/lock-overhead.cc
// Function: timeit(void (*)(), char const*)
static void timeit(void(*f)(), const char *name) {
  struct timespec start,end;
  clock_gettime(CLOCK_MONOTONIC, &start);
  std::thread a(f);
  std::thread b(f);
  a.join();
  b.join();
  clock_gettime(CLOCK_MONOTONIC, &end);
  printf("%55s & %8.1fns \\\\\n", name, (tdiff(start, end)/N_iterations) * 1e9);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
leaq -0x20(%rbp), %rsi
callq 0x10a0
leaq -0x38(%rbp), %rdi
leaq -0x8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
callq 0x1630
movq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1630
jmp 0x131e
leaq -0x38(%rbp), %rdi
callq 0x10f0
jmp 0x1329
leaq -0x40(%rbp), %rdi
callq 0x10f0
jmp 0x1334
movl $0x1, %edi
leaq -0x30(%rbp), %rsi
movq %rsi, -0x70(%rbp)
callq 0x10a0
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1560
movsd %xmm0, -0x60(%rbp)
jmp 0x1362
movq -0x68(%rbp), %rsi
movsd -0x60(%rbp), %xmm0
movsd 0xc95(%rip), %xmm1      # 0x2008
divsd %xmm1, %xmm0
movsd 0xc91(%rip), %xmm1      # 0x2010
mulsd %xmm1, %xmm0
leaq 0xd48(%rip), %rdi       # 0x20d2
movb $0x1, %al
callq 0x1030
jmp 0x1393
leaq -0x40(%rbp), %rdi
callq 0x16f0
leaq -0x38(%rbp), %rdi
callq 0x16f0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x13ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x16f0
leaq -0x38(%rbp), %rdi
callq 0x16f0
movq -0x48(%rbp), %rdi
callq 0x1100
// File: kuszmaul[P]6886/lock-overhead.cc
// Function: atomic_do(datastruct*)
static void atomic_do(datastruct *l) {
  while (__sync_lock_test_and_set(&l->lock, 1)) {
    _mm_pause();
  }
  l->value++;
  __sync_lock_release(&l->lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl $0x1, %eax
xchgl %eax, 0x4(%rcx)
cmpl $0x0, %eax
je 0x15cd
pause
jmp 0x15b8
movq -0x8(%rbp), %rax
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Phidelux[P]terminal-table/src/cell.cpp
// Function: bornageek::utils::termtab::Cell::width(unsigned short) const
const std::uint16_t Cell::width(const std::uint16_t col) const {
        std::uint16_t padding = (mColSpan - 1) * mTable->cellSpacing();
        std::uint16_t innerWidth = 0;

        for(std::uint16_t i = 1; i <= mColSpan; i++) {
          innerWidth += this->mTable->columnWidth(col + i - 1);
        }
        
        return innerWidth + padding;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl 0x2c(%rax), %ecx
subl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movq (%rax), %rdi
callq 0x9d50
movw %ax, %cx
movl -0x14(%rbp), %eax
movzwl %cx, %ecx
imull %ecx, %eax
movw %ax, -0xc(%rbp)
movw $0x0, -0xe(%rbp)
movw $0x1, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movzwl -0x10(%rbp), %eax
movzwl 0x2c(%rcx), %ecx
cmpl %ecx, %eax
jg 0x7e00
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movzwl -0xa(%rbp), %eax
movzwl -0x10(%rbp), %ecx
addl %ecx, %eax
subl $0x1, %eax
movzwl %ax, %esi
callq 0xa170
movzwl %ax, %ecx
movzwl -0xe(%rbp), %eax
addl %ecx, %eax
movw %ax, -0xe(%rbp)
movw -0x10(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x10(%rbp)
jmp 0x7db9
movzwl -0xe(%rbp), %eax
movzwl -0xc(%rbp), %ecx
addl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: Phidelux[P]terminal-table/src/cell.cpp
// Function: bornageek::utils::termtab::Cell::maxLineWidth() const
const std::uint16_t Cell::maxLineWidth() const {
        std::uint16_t max = 0;
        std::string line;

        std::istringstream stream(this->mValue);
        while(std::getline(stream, line)) {
          if(line.length() > max) {
            max = line.length();
          }
        }

        return max;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movw $0x0, -0xa(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3320
movq -0x1c8(%rbp), %rsi
addq $0x8, %rsi
leaq -0x1b0(%rbp), %rdi
movl $0x8, %edx
callq 0x3390
jmp 0x7eb7
jmp 0x7eb9
leaq -0x1b0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3050
movq %rax, -0x1d0(%rbp)
jmp 0x7ed2
movq -0x1d0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, -0x1d1(%rbp)
jmp 0x7ef0
movb -0x1d1(%rbp), %al
testb $0x1, %al
jne 0x7efc
jmp 0x7f56
leaq -0x30(%rbp), %rdi
callq 0x3340
movzwl -0xa(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x7f51
leaq -0x30(%rbp), %rdi
callq 0x3340
movw %ax, -0xa(%rbp)
jmp 0x7f51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x7f86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x30e0
jmp 0x7f86
jmp 0x7eb9
movw -0xa(%rbp), %ax
movw %ax, -0x1d4(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0x3140
movw -0x1d4(%rbp), %ax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3140
movq -0x1b8(%rbp), %rdi
callq 0x33c0
nopl (%rax,%rax)
// File: Phidelux[P]terminal-table/src/cell.cpp
// Function: bornageek::utils::termtab::Cell::line[abi:cxx11](unsigned short) const
const std::string Cell::line(const std::uint16_t idx) const {
        if(idx < this->height()) {
          std::istringstream stream(this->mValue);
          std::string line;
        
          for(std::uint16_t i = 0; i <= idx; ++i) {
            std::getline(stream, line);
          }

          this->trimLine(line);

          return line;
        }
        
        return "";
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d0(%rbp)
movw %dx, %ax
movq %rdi, %rcx
movq %rcx, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
movzwl -0x12(%rbp), %eax
movl %eax, -0x1b4(%rbp)
callq 0x7e10
movw %ax, %cx
movl -0x1b4(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jge 0x80d9
movq -0x1c0(%rbp), %rsi
addq $0x8, %rsi
leaq -0x198(%rbp), %rdi
movl $0x8, %edx
callq 0x3390
movq -0x1d0(%rbp), %rdi
movb $0x0, -0x199(%rbp)
callq 0x3320
movw $0x0, -0x19c(%rbp)
movzwl -0x19c(%rbp), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jg 0x809a
movq -0x1d0(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x3050
jmp 0x8055
jmp 0x8057
movw -0x19c(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x19c(%rbp)
jmp 0x8031
movq -0x1d0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
callq 0x3140
leaq -0x198(%rbp), %rdi
callq 0x30e0
jmp 0x8146
movq -0x1d0(%rbp), %rsi
movq -0x1c0(%rbp), %rdi
callq 0x8160
jmp 0x80af
movb $0x1, -0x199(%rbp)
testb $0x1, -0x199(%rbp)
jne 0x80cb
movq -0x1d0(%rbp), %rdi
callq 0x3140
leaq -0x198(%rbp), %rdi
callq 0x30e0
jmp 0x8136
leaq -0x1ad(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x33d0
movq -0x1d0(%rbp), %rdi
movq -0x1d8(%rbp), %rdx
leaq 0x90f2(%rip), %rsi      # 0x111f3
callq 0x5c50
jmp 0x8108
leaq -0x1ad(%rbp), %rdi
callq 0x3280
jmp 0x8136
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1ad(%rbp), %rdi
callq 0x3280
jmp 0x8146
movq -0x1c8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: Phidelux[P]terminal-table/src/cell.cpp
// Function: bornageek::utils::termtab::Cell::trimLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
void Cell::trimLine(std::string &line) const {
        line.erase(line.begin(), std::find_if(
          line.begin(), line.end(), std::not1(
            std::ptr_fun<int, int>(std::isspace)
          )));

        line.erase(std::find_if(line.rbegin(), line.rend(), 
          std::not1(std::ptr_fun<int, int>(std::isspace))).base(), line.end());
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8aa0
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x40(%rbp)
movq 0x10ddf(%rip), %rdi     # 0x18f98
callq 0x8b70
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8b40
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x8ae0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8aa0
movq -0xb8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3060
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x33b0
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x32e0
movq 0x10d63(%rip), %rdi     # 0x18f98
callq 0x8b70
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x8b40
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rcx
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x8ba0
leaq -0x70(%rbp), %rdi
callq 0x8c20
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x8aa0
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x8aa0
movq -0xb0(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0x3060
movq %rax, -0xa8(%rbp)
addq $0xc0, %rsp
popq %rbp
retq
// File: Phidelux[P]terminal-table/src/table.cpp
// Function: bornageek::utils::termtab::Table::rows(std::vector<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>>>>, std::allocator<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>>>>>> const&)
void Table::rows(const std::vector<std::vector<std::string>> &rows) {
        this->mRows = std::vector<Row>();
        for_each(rows.begin(), rows.end(), 
          [this](const std::vector<std::string> &row) { 
            mRows.push_back(Row(this, row)); });
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3110
leaq -0x28(%rbp), %rdi
callq 0xb940
movq -0x50(%rbp), %rdi
addq $0x60, %rdi
leaq -0x28(%rbp), %rsi
callq 0xbf60
leaq -0x28(%rbp), %rdi
callq 0x7660
movq -0x10(%rbp), %rdi
callq 0xbf90
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbfc0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xa870
movq %rax, -0x48(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Phidelux[P]terminal-table/src/table.cpp
// Function: bornageek::utils::termtab::Table::alignColumn(unsigned short, bornageek::utils::termtab::Alignment const&)
void Table::alignColumn(const std::uint16_t n, const Alignment &align) {
        if(n > this->numColumns()) {
          throw std::out_of_range("The table just has " 
                + std::to_string(this->numColumns()) + " columns.");
        }

        std::for_each(this->mRows.begin(), this->mRows.end(), 
          [n, align](Row &row){ 
            if(row.numCells() > n) {
              row.cells()[n].alignment(align);
            }
          });
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movzwl -0xa(%rbp), %eax
movl %eax, -0xac(%rbp)
callq 0x9be0
movw %ax, %cx
movl -0xac(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jle 0x9b64
movb $0x1, -0x85(%rbp)
movl $0x10, %edi
callq 0x30f0
movq -0xb8(%rbp), %rdi
movq %rax, -0xc8(%rbp)
callq 0x9be0
movw %ax, -0xba(%rbp)
jmp 0x9a75
movw -0xba(%rbp), %ax
movzwl %ax, %esi
leaq -0x78(%rbp), %rdi
callq 0xba00
jmp 0x9a8a
leaq 0x774f(%rip), %rsi      # 0x111e0
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0xb9b0
jmp 0x9aa0
leaq 0x774d(%rip), %rdx      # 0x111f4
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb960
jmp 0x9ab6
movq -0xc8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3350
jmp 0x9ac8
movq -0xc8(%rbp), %rdi
movb $0x0, -0x85(%rbp)
movq 0xf4f3(%rip), %rsi      # 0x18fd0
movq 0xf4e4(%rip), %rdx      # 0x18fc8
callq 0x33a0
jmp 0x9bdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x9b4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x9b42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x9b39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq -0x58(%rbp), %rdi
callq 0x3140
leaq -0x78(%rbp), %rdi
callq 0x3140
testb $0x1, -0x85(%rbp)
jne 0x9b56
jmp 0x9b62
movq -0xc8(%rbp), %rdi
callq 0x3190
jmp 0x9bd3
movq -0xb8(%rbp), %rdi
addq $0x60, %rdi
callq 0xbb20
movq -0xb8(%rbp), %rdi
movq %rax, -0x90(%rbp)
addq $0x60, %rdi
callq 0xbb50
movq %rax, -0x98(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0xa0(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x9c(%rbp)
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0xa0(%rbp), %rdx
callq 0x9c80
movq %rax, -0xa8(%rbp)
addq $0xd0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x33c0
nopl (%rax)
// File: Phidelux[P]terminal-table/src/table.cpp
// Function: bornageek::utils::termtab::Table::numColumns() const
const std::uint16_t Table::numColumns() const {
        std::uint16_t max = 0;
        std::vector<Row> rows = this->rowsWithHeadings();
        std::for_each(rows.begin(), rows.end(),
          [&max](const Row &row) {
            if(row.numCells() > max) {
              max = row.numCells();
            }
          });

        return max;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movw $0x0, -0xa(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xa3b0
movq -0x68(%rbp), %rdi
callq 0xbb20
movq -0x68(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0xbb50
movq %rax, -0x38(%rbp)
leaq -0xa(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xa520
movq %rax, -0x60(%rbp)
jmp 0x9c3c
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0x6a(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7660
movw -0x6a(%rbp), %ax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7660
movq -0x48(%rbp), %rdi
callq 0x33c0
nopl (%rax)