LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/Board.cpp
// Function: Board::move(int, Edge)
bool Board::move(int player, Edge move)
{
    assert(is_move_valid(move));

    int oldscore = score[player];

    edges[edge_index(move)] = true;

    for_each_adjacent_node(move, [&] (Node node)
            { if (this->degree(node) == 4) ++score[player]; });

    return oldscore != score[player];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl %edx, %esi
callq 0x2890
testb %al, %al
je 0x2870
movslq %r14d, %r8
movswl %bp, %r12d
testb $0x1, %bpl
jne 0x2718
movl %r12d, %ecx
sarl $0x8, %ecx
movl (%rbx), %r13d
imull %r13d, %ecx
movsbl %r12b, %eax
sarl %eax
jmp 0x2739
movl (%rbx), %r13d
movl 0x4(%rbx), %ecx
incl %ecx
imull %r13d, %ecx
movl %r12d, %eax
sarl $0x8, %eax
leal 0x1(%r13), %edx
imull %eax, %edx
movsbl %r12b, %eax
sarl %eax
addl %edx, %eax
addl %ecx, %eax
movl 0x8(%rbx,%r8,4), %r15d
movslq %eax, %rcx
leal 0x3f(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
addq 0x10(%rbx), %rax
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
leaq 0x3f(%rdx), %rsi
andq %rcx, %rsi
xorl %edi, %edi
cmpq %rdx, %rsi
setbe %dil
movl $0x1, %edx
shlq %cl, %rdx
orq %rdx, -0x8(%rax,%rdi,8)
testb $0x1, %bpl
movq %r8, (%rsp)
jne 0x27e9
movl %r12d, %eax
shrl $0x8, %eax
sarl $0x8, %r12d
movl %r15d, %r14d
testw %ax, %ax
jle 0x27ce
movsbl %bpl, %eax
shrl %eax
movl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl %ebp, %edx
andl %ecx, %edx
movzbl %al, %esi
orl %edx, %esi
addl %ecx, %esi
movq %rbx, %rdi
callq 0x2b3c
movl %r15d, %r14d
cmpl $0x4, %eax
jne 0x27ce
leal 0x1(%r15), %r14d
movq (%rsp), %rax
movl %r14d, 0x8(%rbx,%rax,4)
cmpl %r12d, 0x4(%rbx)
jle 0x285b
movsbl %bpl, %eax
shrl %eax
andl $0xffffff00, %ebp       # imm = 0xFFFFFF00
movzbl %al, %esi
jmp 0x2840
movsbl %bpl, %r12d
movl %r12d, %eax
shrl %eax
sarl %r12d
testw %ax, %ax
jle 0x282e
leal -0x1(%r12), %eax
movl %ebp, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movzbl %al, %esi
orl %ecx, %esi
movq %rbx, %rdi
callq 0x2b3c
movl %r15d, %r14d
cmpl $0x4, %eax
jne 0x2831
leal 0x1(%r15), %r14d
movq (%rsp), %rax
movl %r14d, 0x8(%rbx,%rax,4)
movl (%rbx), %r13d
jmp 0x2831
movl %r15d, %r14d
cmpl %r12d, %r13d
jle 0x285b
andl $0xffffff00, %ebp       # imm = 0xFFFFFF00
movzbl %r12b, %esi
orl %ebp, %esi
movq %rbx, %rdi
callq 0x2b3c
cmpl $0x4, %eax
jne 0x285b
incl %r14d
movq (%rsp), %rax
movl %r14d, 0x8(%rbx,%rax,4)
cmpl %r14d, %r15d
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27b4(%rip), %rdi      # 0x502b
leaq 0x2786(%rip), %rsi      # 0x5004
leaq 0x2789(%rip), %rcx      # 0x500e
movl $0x11, %edx
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/Board.cpp
// Function: Board::is_move_valid(Edge) const
bool Board::is_move_valid(Edge move) const
{
    if (move.dir == HORIZ) {
        if (move.x < 0 || move.x >= width || move.y < 0 || move.y > height)
            return false;
    } else {
        if (move.x < 0 || move.x > width || move.y < 0 || move.y >= height)
            return false;
    }

    return !edges[edge_index(move)];
}

// Assembly:
movl %esi, %eax
movsbl %al, %edx
movl %edx, %ecx
shrl %ecx
testb $0x1, %dl
jne 0x28d9
testw %cx, %cx
js 0x294f
movzwl %cx, %edx
movl (%rdi), %ecx
cmpl %edx, %ecx
jle 0x294f
movswl %ax, %esi
shrl $0x8, %esi
testw %si, %si
js 0x294f
movzwl %si, %esi
cmpl %esi, 0x4(%rdi)
jl 0x294f
movzbl %ah, %eax
imull %eax, %ecx
addl %edx, %ecx
jmp 0x290f
testw %cx, %cx
js 0x294f
movzwl %cx, %edx
movl (%rdi), %ecx
cmpl %edx, %ecx
jl 0x294f
movswl %ax, %esi
shrl $0x8, %esi
testw %si, %si
js 0x294f
movzwl %si, %r8d
movl 0x4(%rdi), %esi
cmpl %r8d, %esi
jle 0x294f
incl %esi
imull %ecx, %esi
movzbl %ah, %eax
incl %ecx
imull %eax, %ecx
addl %edx, %ecx
addl %esi, %ecx
movslq %ecx, %rax
leal 0x3f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq 0x10(%rdi), %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
leaq 0x3f(%rdx), %rsi
andq %rax, %rsi
xorl %edi, %edi
cmpq %rdx, %rsi
setbe %dil
movq -0x8(%rcx,%rdi,8), %rcx
btq %rax, %rcx
setae %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/Board.cpp
// Function: Board::unmove(int, Edge)
void Board::unmove(int player, Edge move)
{
    assert(!is_move_valid(move));

    edges[edge_index(move)] = false;

    for_each_adjacent_node(move, [&] (Node node)
            { if (this->degree(node) == 3) --score[player]; });
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movl %edx, %esi
callq 0x2890
testb %al, %al
jne 0x2ab7
movswl %r14w, %r15d
testb $0x1, %r14b
jne 0x2990
movl %r15d, %ecx
sarl $0x8, %ecx
movl (%rbx), %r12d
imull %r12d, %ecx
movsbl %r15b, %eax
sarl %eax
jmp 0x29b2
movl (%rbx), %r12d
movl 0x4(%rbx), %ecx
incl %ecx
imull %r12d, %ecx
movl %r15d, %eax
sarl $0x8, %eax
leal 0x1(%r12), %edx
imull %eax, %edx
movsbl %r15b, %eax
sarl %eax
addl %edx, %eax
addl %ecx, %eax
movslq %eax, %rcx
leal 0x3f(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
addq 0x10(%rbx), %rax
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
leaq 0x3f(%rdx), %rsi
andq %rcx, %rsi
xorl %edi, %edi
cmpq %rdx, %rsi
setbe %dil
movq $-0x2, %rdx
rolq %cl, %rdx
andq %rdx, -0x8(%rax,%rdi,8)
testb $0x1, %r14b
jne 0x2a4d
movl %r15d, %eax
shrl $0x8, %eax
sarl $0x8, %r15d
testw %ax, %ax
jle 0x2a35
movsbl %r14b, %eax
shrl %eax
movl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl %r14d, %edx
andl %ecx, %edx
movzbl %al, %esi
orl %edx, %esi
addl %ecx, %esi
movq %rbx, %rdi
callq 0x2b3c
cmpl $0x3, %eax
jne 0x2a35
movslq %ebp, %rax
decl 0x8(%rbx,%rax,4)
cmpl %r15d, 0x4(%rbx)
jle 0x2aae
movsbl %r14b, %eax
shrl %eax
andl $0xffffff00, %r14d      # imm = 0xFFFFFF00
movzbl %al, %esi
jmp 0x2a97
movsbl %r14b, %r15d
movl %r15d, %eax
shrl %eax
sarl %r15d
testw %ax, %ax
jle 0x2a87
leal -0x1(%r15), %eax
movl %r14d, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movzbl %al, %esi
orl %ecx, %esi
movq %rbx, %rdi
callq 0x2b3c
cmpl $0x3, %eax
jne 0x2a87
movslq %ebp, %rax
decl 0x8(%rbx,%rax,4)
movl (%rbx), %r12d
cmpl %r15d, %r12d
jle 0x2aae
andl $0xffffff00, %r14d      # imm = 0xFFFFFF00
movzbl %r15b, %esi
orl %r14d, %esi
movq %rbx, %rdi
callq 0x2b3c
cmpl $0x3, %eax
jne 0x2aae
movslq %ebp, %rax
decl 0x8(%rbx,%rax,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x256c(%rip), %rdi      # 0x502a
leaq 0x253f(%rip), %rsi      # 0x5004
leaq 0x2573(%rip), %rcx      # 0x503f
movl $0x1f, %edx
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/Board.cpp
// Function: Board::degree(Node) const
int Board::degree(Node node) const
{
    int sum = 0;
    for_each_adjacent_edge(node, [&] (Edge edge)
            { sum += (int) edges[this->edge_index(edge)]; });
    return sum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %eax
shrl $0x8, %eax
movsbl %al, %r10d
movl (%rdi), %ecx
movl 0x4(%rdi), %r11d
movl %ecx, %r8d
imull %r10d, %r8d
movl %esi, %eax
shll $0x19, %eax
sarl $0x19, %eax
leal (%r8,%rax), %edx
movslq %edx, %rbx
movq 0x10(%rdi), %rdx
leal (%r8,%rax), %edi
addl $0x3f, %edi
testl %ebx, %ebx
cmovnsl %ebx, %edi
sarl $0x6, %edi
movslq %edi, %rdi
leaq (%rdx,%rdi,8), %r9
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
leaq 0x3f(%rdi), %r8
movq %rbx, %r14
andq %r8, %r14
xorl %r15d, %r15d
cmpq %rdi, %r14
setbe %r15b
movq -0x8(%r9,%r15,8), %r14
xorl %r9d, %r9d
btq %rbx, %r14
setb %r9b
leal 0x100(%rsi), %ebx
movswl %bx, %ebx
sarl $0x8, %ebx
imull %ecx, %ebx
leal (%rbx,%rax), %ebp
shll $0x9, %esi
movslq %ebp, %r14
addl %eax, %ebx
addl $0x3f, %ebx
testl %r14d, %r14d
cmovnsl %r14d, %ebx
sarl $0x6, %ebx
movslq %ebx, %rbx
leaq (%rdx,%rbx,8), %rbx
movq %r14, %r15
andq %r8, %r15
xorl %r12d, %r12d
cmpq %rdi, %r15
setbe %r12b
movq -0x8(%rbx,%r12,8), %rbx
btq %r14, %rbx
adcl $0x0, %r9d
incl %r11d
imull %ecx, %r11d
incl %ecx
imull %r10d, %ecx
addl %r11d, %ecx
leal (%rax,%rcx), %r10d
addl $0x3f, %r10d
addl %ecx, %eax
movslq %eax, %r11
testl %r11d, %r11d
cmovnsl %r11d, %r10d
sarl $0x6, %r10d
movslq %r10d, %rax
leaq (%rdx,%rax,8), %rax
movq %r11, %r10
andq %r8, %r10
xorl %ebx, %ebx
cmpq %rdi, %r10
setbe %bl
movq -0x8(%rax,%rbx,8), %r10
xorl %eax, %eax
btq %r11, %r10
setb %al
addl $0x300, %esi            # imm = 0x300
movswl %si, %esi
sarl $0x9, %esi
leal (%rsi,%rcx), %r10d
addl $0x3f, %r10d
addl %esi, %ecx
movslq %ecx, %rcx
testl %ecx, %ecx
cmovnsl %ecx, %r10d
sarl $0x6, %r10d
movslq %r10d, %rsi
leaq (%rdx,%rsi,8), %rdx
movq %rcx, %rsi
andq %r8, %rsi
xorl %r8d, %r8d
cmpq %rdi, %rsi
setbe %r8b
movq -0x8(%rdx,%r8,8), %rdx
btq %rcx, %rdx
adcl %r9d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/Board.cpp
// Function: basename_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string basename_str(const std::string &str)
{
    char *cpy = strdup(str.c_str());
    char *base = basename(cpy);
    std::string ret(base);
    free(cpy);
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x2380
movq %rax, %r14
movq %rax, %rdi
callq 0x22a0
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2e3e
movq %r14, %rdi
callq 0x2230
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/Board.cpp
// Function: Board::set_move_decider(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Board::set_move_decider(const std::string &solver)
{
    std::string base = basename_str(solver);
    if (base == "random") {
        decider = &Board::decide_move_random;
    } else if (base == "first") {
        decider = &Board::decide_move_first;
    } else if (base == "invalid") {
        decider = &Board::decide_move_invalid;
    } else if (base == "timeout") {
        decider = &Board::decide_move_timeout;
    } else if (base == "crash") {
        exit(1);
    } else if (base == "nocheap") {
        decider = &Board::decide_move_nocheap;
    } else {
        fprintf(stderr, "dots solver run with command: %s, cannot decide which move decider to use\n", base.c_str());
        exit(1);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2c96
leaq 0x262c(%rip), %rsi      # 0x531e
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2d70
leaq 0x2358(%rip), %rsi      # 0x505d
leaq 0x8(%rsp), %rdi
callq 0x2070
testl %eax, %eax
je 0x2d79
leaq 0x2349(%rip), %rsi      # 0x5063
leaq 0x8(%rsp), %rdi
callq 0x2070
testl %eax, %eax
je 0x2d82
leaq 0x233c(%rip), %rsi      # 0x506b
leaq 0x8(%rsp), %rdi
callq 0x2070
testl %eax, %eax
je 0x2d8b
leaq 0x232f(%rip), %rsi      # 0x5073
leaq 0x8(%rsp), %rdi
callq 0x2070
testl %eax, %eax
je 0x2dc1
leaq 0x2320(%rip), %rsi      # 0x5079
leaq 0x8(%rsp), %rdi
callq 0x2070
testl %eax, %eax
jne 0x2dcb
leaq 0x1316(%rip), %rax      # 0x4084
jmp 0x2d92
leaq 0x117d(%rip), %rax      # 0x3ef4
jmp 0x2d92
leaq 0x128c(%rip), %rax      # 0x400c
jmp 0x2d92
leaq 0x12d9(%rip), %rax      # 0x4062
jmp 0x2d92
leaq 0x12d6(%rip), %rax      # 0x4068
movq %rax, 0x38(%rbx)
movq $0x0, 0x40(%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2db9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %edi
callq 0x2240
leaq 0x8(%rsp), %rdi
callq 0x23d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/InputOutput.cpp
// Function: read_edge(_IO_FILE*)
Edge read_edge(FILE *fp)
{
    int fd = fileno(fp);

    pollfd pev;
    pev.fd = fd;
    pev.events = POLLIN;
    pev.revents = 0;

    int pollret = poll(&pev, 1, 1000);
    if (pollret == 0) {
        throw std::runtime_error("took too long to move");
    } else if (pollret == -1) {
        printf("error poll'ing fd\n");
        exit(1);
    }

    fcntl(fd, F_SETFL, O_NONBLOCK);
    char buf[80] = {};
    ssize_t nbytes = read(fd, buf, sizeof(buf) - 1);
    fcntl(fd, F_SETFL, 0);

    if (nbytes == 0)
        throw std::runtime_error("exited early");

    char tmp;
    Edge move;
    int x, y;
    sscanf(buf, "(edge %c %d %d)\n", &tmp, &x, &y);

    move.x = x;
    move.y = y;

    if (tmp == 'h')
        move.dir = HORIZ;
    else
        move.dir = VERT;

    return move;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
callq 0x21e0
movl %eax, %ebx
leaq 0x18(%rsp), %rdi
movl %eax, (%rdi)
movl $0x1, 0x4(%rdi)
movl $0x1, %esi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x22b0
cmpl $-0x1, %eax
je 0x310e
testl %eax, %eax
je 0x3124
movl %ebx, %edi
movl $0x4, %esi
movl $0x800, %edx            # imm = 0x800
xorl %eax, %eax
callq 0x2110
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x4f, %edx
movl %ebx, %edi
callq 0x2290
movq %rax, %r14
movl %ebx, %edi
movl $0x4, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2110
testq %r14, %r14
je 0x3142
leaq 0x2032(%rip), %rsi      # 0x50f6
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rbx
leaq 0x14(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x21b0
movl (%r14), %eax
andl $0x7f, %eax
movl (%r15), %ecx
shll $0x8, %ecx
xorl %edx, %edx
cmpb $0x68, (%rbx)
setne %dl
movzwl %cx, %ecx
leal (%rcx,%rax,2), %eax
orl %edx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x21f1(%rip), %rdi      # 0x5306
callq 0x22c0
movl $0x1, %edi
callq 0x2240
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x1fcf(%rip), %rsi      # 0x5107
movq %rax, %rdi
callq 0x20b0
jmp 0x315e
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x1fc7(%rip), %rsi      # 0x511d
movq %rax, %rdi
callq 0x20b0
movq 0x4e93(%rip), %rsi      # 0x7ff8
movq 0x4e64(%rip), %rdx      # 0x7fd0
movq %rbx, %rdi
callq 0x2340
jmp 0x3176
movq %rax, %r14
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/InputOutput.cpp
// Function: Board::print_horiz_edges(int, _IO_FILE*) const
void Board::print_horiz_edges(int y, FILE *fp) const
{
    fprintf(fp, "+");
    for (int x = 0; x < width; ++x) {
        if (edges[edge_index(Edge(HORIZ, x, y))])
            fprintf(fp, "-+");
        else
            fprintf(fp, " +");
    }
    fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x2b, %edi
movq %rdx, %rsi
callq 0x2250
movl (%r14), %eax
testl %eax, %eax
jle 0x326f
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movsbl %bpl, %ebp
xorl %r12d, %r12d
leaq 0x3f(%rcx), %r13
xorl %r15d, %r15d
imull %ebp, %eax
movl %r12d, %ecx
sarl $0x19, %ecx
leal (%rax,%rcx), %edx
movslq %edx, %rdx
addl %ecx, %eax
addl $0x3f, %eax
testl %edx, %edx
cmovnsl %edx, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
addq 0x10(%r14), %rax
movq %rdx, %rcx
andq %r13, %rcx
xorl %esi, %esi
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
cmpq %rdi, %rcx
setbe %sil
movq -0x8(%rax,%rsi,8), %rax
btq %rdx, %rax
leaq 0x1ef9(%rip), %rdi      # 0x513b
jae 0x324b
leaq 0x1eed(%rip), %rdi      # 0x5138
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x23a0
incl %r15d
movl (%r14), %eax
addl $0x2000000, %r12d       # imm = 0x2000000
cmpl %eax, %r15d
jl 0x31f3
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/InputOutput.cpp
// Function: Board::print_vert_edges(int, _IO_FILE*) const
void Board::print_vert_edges(int y, FILE *fp) const
{
    for (int x = 0; x < width; ++x) {
        if (edges[edge_index(Edge(VERT, x, y))])
            fprintf(fp, "|");
        else
            fprintf(fp, " ");

        if (degree(Node(x, y)) == 4)
            fprintf(fp, "#");
        else
            fprintf(fp, " ");
    }

    if (edges[edge_index(Edge(VERT, width, y))])
        fprintf(fp, "|\n");
    else
        fprintf(fp, " \n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
movl (%r14), %eax
testl %eax, %eax
jle 0x3379
movsbl %sil, %r8d
shll $0x8, %esi
movl %esi, 0xc(%rsp)
xorl %r13d, %r13d
leaq 0x3f(%rdi), %rcx
movq %rcx, 0x10(%rsp)
xorl %r12d, %r12d
movl 0x4(%r14), %ecx
incl %ecx
imull %eax, %ecx
incl %eax
movl %r8d, %ebp
imull %r8d, %eax
movl %r13d, %edx
sarl $0x19, %edx
addl %eax, %edx
leal (%rdx,%rcx), %eax
cltq
addl %edx, %ecx
addl $0x3f, %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq 0x10(%r14), %rcx
movq %rax, %rdx
andq 0x10(%rsp), %rdx
xorl %esi, %esi
movq %rdi, %r15
cmpq %rdi, %rdx
setbe %sil
movq -0x8(%rcx,%rsi,8), %rcx
btq %rax, %rcx
movl $0x20, %edi
jae 0x332d
movl $0x7c, %edi
movq %rbx, %rsi
callq 0x2250
movzbl %r12b, %esi
orl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x2b3c
xorl %ecx, %ecx
cmpl $0x4, %eax
sete %cl
leal (%rcx,%rcx,2), %edi
addl $0x20, %edi
movq %rbx, %rsi
callq 0x2250
incl %r12d
movl (%r14), %eax
addl $0x2000000, %r13d       # imm = 0x2000000
cmpl %eax, %r12d
movq %r15, %rdi
movl %ebp, %r8d
jl 0x32cd
jmp 0x337d
movsbl %sil, %r8d
movl 0x4(%r14), %ecx
incl %ecx
imull %eax, %ecx
leal 0x1(%rax), %edx
imull %r8d, %edx
shll $0x19, %eax
sarl $0x19, %eax
addl %edx, %eax
leal (%rax,%rcx), %edx
movslq %edx, %rdx
addl %ecx, %eax
addl $0x3f, %eax
testl %edx, %edx
cmovnsl %edx, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
addq 0x10(%r14), %rax
leaq 0x3f(%rdi), %rcx
andq %rdx, %rcx
xorl %esi, %esi
cmpq %rdi, %rcx
setbe %sil
movq -0x8(%rax,%rsi,8), %rax
btq %rdx, %rax
leaq 0x1d6f(%rip), %rax      # 0x5141
leaq 0x1d65(%rip), %rdi      # 0x513e
cmovaeq %rax, %rdi
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/InputOutput.cpp
// Function: Board::print(_IO_FILE*, int) const
void Board::print(FILE *fp, int player) const
{
    fprintf(fp, "%d %d %d %d\n", width, height, score[player], score[!player]);
    for (int y = 0; y < height; ++y) {
        print_horiz_edges(y, fp);
        print_vert_edges(y, fp);
    }
    print_horiz_edges(height, fp);
    fflush(fp);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
movslq %edx, %rdx
movl 0x8(%rdi,%rdx,4), %r8d
xorl %esi, %esi
testl %edx, %edx
sete %sil
movl 0x8(%rdi,%rsi,4), %r9d
leaq 0x1d1b(%rip), %rsi      # 0x5144
xorl %ebp, %ebp
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x2280
movl 0x4(%r14), %esi
testl %esi, %esi
jle 0x3463
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x31b0
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x328a
incl %ebp
movl 0x4(%r14), %esi
cmpl %esi, %ebp
jl 0x343f
movq %r14, %rdi
movq %rbx, %rdx
callq 0x31b0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/InputOutput.cpp
// Function: Board::read_horiz_edges(int, _IO_FILE*)
void Board::read_horiz_edges(int y, FILE *fp)
{
    int c, x = 0;

    while ((c = fgetc(fp)) != EOF) {
        switch (c) {
            case '\r':
                break;
            case '\n':
                if (x != width) {
                    fprintf(stderr, "x (%d) != width (%d) at newline while reading board\n",
                            x, width);
                    exit(1);
                }
                return;
            case '+':
                break;
            case '-':
                if (x >= width) {
                    fprintf(stderr, "x (%d) >= width (%d) at dash while reading board\n",
                            x, width);
                    exit(1);
                }
                edges[edge_index(Edge(HORIZ, x, y))] = true;
                ++x;
                break;
            case ' ':
                if (x >= width) {
                    fprintf(stderr, "x (%d) >= width (%d) at space while reading board\n",
                            x, width);
                    exit(1);
                }
                edges[edge_index(Edge(HORIZ, x, y))] = false;
                ++x;
                break;
            default:
                fprintf(stderr, "unexpected character %d while reading board\n", c);
                exit(1);
        }
    }

    if (c == EOF)
        exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
movsbl %sil, %ebp
xorl %ebx, %ebx
leaq 0x3f(%r12), %r13
movq %r15, %rdi
callq 0x2300
cmpl $0x1f, %eax
jle 0x3511
cmpl $0x2b, %eax
je 0x34a0
cmpl $0x20, %eax
je 0x3518
cmpl $0x2d, %eax
jne 0x3597
movl (%r14), %esi
cmpl %esi, %ebx
jge 0x35a5
imull %ebp, %esi
movl %ebx, %eax
shll $0x19, %eax
sarl $0x19, %eax
leal (%rsi,%rax), %ecx
movslq %ecx, %rcx
addl %esi, %eax
addl $0x3f, %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
addq 0x10(%r14), %rax
movq %rcx, %rdx
andq %r13, %rdx
xorl %esi, %esi
cmpq %r12, %rdx
setbe %sil
movl $0x1, %edx
shlq %cl, %rdx
orq %rdx, -0x8(%rax,%rsi,8)
jmp 0x3569
cmpl $0xd, %eax
je 0x34a0
jmp 0x3570
movl (%r14), %esi
cmpl %esi, %ebx
jge 0x35ac
imull %ebp, %esi
movl %ebx, %eax
shll $0x19, %eax
sarl $0x19, %eax
leal (%rsi,%rax), %ecx
movslq %ecx, %rcx
addl %esi, %eax
addl $0x3f, %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
addq 0x10(%r14), %rax
movq %rcx, %rdx
andq %r13, %rdx
xorl %esi, %esi
cmpq %r12, %rdx
setbe %sil
movq $-0x2, %rdx
rolq %cl, %rdx
andq %rdx, -0x8(%rax,%rsi,8)
incl %ebx
jmp 0x34a0
cmpl $0xa, %eax
jne 0x358b
movl (%r14), %esi
cmpl %esi, %ebx
jne 0x359e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $-0x1, %eax
jne 0x3597
xorl %edi, %edi
callq 0x2240
movl %eax, %edi
callq 0x2477
movl %ebx, %edi
callq 0x2452
movl %ebx, %edi
callq 0x242d
movl %ebx, %edi
callq 0x2408
nop
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/InputOutput.cpp
// Function: read_board(_IO_FILE*)
Board read_board(FILE *fp)
{
    Board board;

    fscanf(fp, "%d %d %d %d\n", &board.height, &board.width,
            &board.score[0], &board.score[1]);
    if (feof(fp))
        exit(0);

    board.edges.assign(board.width * (board.height + 1) + board.height * (board.width + 1), false);

    for (int y = 0; y < board.height; ++y) {
        board.read_horiz_edges(y, fp);
        board.read_vert_edges(y, fp);
    }
    board.read_horiz_edges(board.height, fp);

    if (feof(fp))
        exit(0);

    return board;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movl %eax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movl %eax, 0x28(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x4(%rdi), %r12
leaq 0x8(%rdi), %r8
leaq 0xc(%rdi), %r9
leaq 0x1993(%rip), %rsi      # 0x5144
movq %r14, %rdi
movq %r12, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2390
movq %r14, %rdi
callq 0x22e0
testl %eax, %eax
jne 0x383c
movl (%rbx), %eax
movl 0x4(%rbx), %ecx
leal 0x1(%rcx), %edx
imull %eax, %edx
incl %eax
imull %ecx, %eax
addl %edx, %eax
movslq %eax, %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x3860
movl (%r12), %esi
testl %esi, %esi
jle 0x3819
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x347a
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x35b4
incl %ebp
movl 0x4(%rbx), %esi
cmpl %esi, %ebp
jl 0x37f6
movq %rbx, %rdi
movq %r14, %rdx
callq 0x347a
movq %r14, %rdi
callq 0x22e0
testl %eax, %eax
jne 0x383c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x2240
jmp 0x3845
movq %rax, %rbx
movq %r15, %rdi
callq 0x2f26
movq %rbx, %rdi
callq 0x2350
movq %rax, %rdi
callq 0x2e7b
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/BasicMoveDeciders.cpp
// Function: Board::decide_move_random()
Edge Board::decide_move_random()
{
    std::vector<Edge> valid_moves;

    std::for_each(edge_begin(), edge_end(), [&] (Edge edge)
            { if (this->is_move_valid(edge)) valid_moves.push_back(edge); });

    int r = 0;

    int fd = open("/dev/urandom", O_RDONLY);
    read(fd, &r, sizeof(r));
    close(fd);

    return valid_moves[r % valid_moves.size()];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
shlq $0x20, %rax
movq %rsp, %r15
movq %rax, (%r15)
movl %ecx, 0x8(%r15)
leaq 0xc(%rsp), %r12
movl (%rsp), %ebp
movl %ebp, 0xc(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2890
testb %al, %al
je 0x3f65
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x3f5a
movl %ebp, (%rsi)
addq $0x4, 0x18(%rsp)
jmp 0x3f65
movq %r14, %rdi
movq %r12, %rdx
callq 0x440c
movq %r15, %rdi
callq 0x43a4
movzwl (%rsp), %eax
cmpw $-0x2, %ax
setb %cl
orb %al, %cl
testb $0x1, %cl
jne 0x3f2f
movl $0x0, (%rsp)
leaq 0x138b(%rip), %rdi      # 0x5318
xorl %esi, %esi
xorl %eax, %eax
callq 0x2160
movl %eax, %ebx
movq %rsp, %rsi
movl $0x4, %edx
movl %eax, %edi
callq 0x2290
movl %ebx, %edi
callq 0x23b0
movslq (%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
subq %rdi, %rcx
sarq $0x2, %rcx
xorl %edx, %edx
divq %rcx
movl (%rdi,%rdx,4), %ebx
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3fe9
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4003
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/BasicMoveDeciders.cpp
// Function: Board::decide_move_first()
Edge Board::decide_move_first()
{
    EdgeIterator it = std::find_if(edge_begin(), edge_end(),
            [&] (Edge edge)
            { return this->is_move_valid(edge); });
    return *it;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
shlq $0x20, %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movl %ecx, 0x8(%r14)
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x2890
testb %al, %al
jne 0x4056
movq %r14, %rdi
callq 0x43a4
movzwl 0x8(%rsp), %eax
cmpw $-0x2, %ax
setb %cl
orb %al, %cl
testb $0x1, %cl
jne 0x402b
movl 0x8(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/./Board.h
// Function: EdgeIterator::operator++()
EdgeIterator &operator++()
        {
            if (edge.dir == HORIZ) {
                if (edge.x < width) {
                    if (edge.y <= height) {
                        ++edge.y;
                    } else {
                        ++edge.x;
                        edge.y = 0;
                    }
                } else {
                    edge.dir = VERT;
                    edge.x = 0;
                    edge.y = 0;
                }
            } else {
                if (edge.x <= width) {
                    if (edge.y < height) {
                        ++edge.y;
                    } else {
                        ++edge.x;
                        edge.y = 0;
                    }
                } else {
                    edge.dir = HORIZ;
                    edge.x = -1;
                    edge.y = -1;
                }
            }
            return *this;
        }

// Assembly:
movq %rdi, %rax
movl (%rdi), %ecx
movl 0x4(%rdi), %edi
movsbl %cl, %edx
movl %edx, %esi
sarl %esi
testb $0x1, %dl
jne 0x43d6
movw $0x1, %dx
cmpl %esi, %edi
jle 0x4408
movswl %cx, %edx
sarl $0x8, %edx
cmpl %edx, 0x8(%rax)
jge 0x43f1
leal 0x2(%rcx), %edx
andl $0xfe, %edx
jmp 0x4408
movw $0xfffe, %dx            # imm = 0xFFFE
cmpl %esi, %edi
jl 0x4408
movswl %cx, %edx
sarl $0x8, %edx
cmpl %edx, 0x8(%rax)
jle 0x43fe
leal 0x100(%rcx), %edx
jmp 0x4408
andl $-0x2, %ecx
addl $0x100, %ecx            # imm = 0x100
movl %ecx, %edx
jmp 0x4408
leal 0x3(,%rsi,2), %ecx
movzbl %cl, %edx
movw %dx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/DotsDriver.cpp
// Function: print_win_info(Board const&, int)
void print_win_info(const Board &board, int winning_player = -1)
{
    int score[2] = {board.get_score(0), board.get_score(1)};

    board.print(stdout);

    if (winning_player == -1) {
        if (score[0] > score[1]) {
            winning_player = 0;
        } else if (score[0] < score[1]) {
            winning_player = 1;
        } else {
            printf("tie game! final score => player 1: %d, player 2: %d\n",
                    score[0], score[1]);
            return;
        }
    }

    printf("player %d wins! final score => player 1: %d, player 2: %d\n",
            winning_player + 1, score[0], score[1]);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movl 0x8(%rdi), %ebp
movl 0xc(%rdi), %ebx
movq 0x377d(%rip), %rax      # 0x7fb8
movq (%rax), %rsi
xorl %edx, %edx
callq 0x33fe
cmpl $-0x1, %r14d
jne 0x485d
movl $0x0, %r14d
cmpl %ebx, %ebp
jg 0x485d
movl $0x1, %r14d
jge 0x4879
incl %r14d
leaq 0xcd9(%rip), %rdi       # 0x5540
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
leaq 0xc8b(%rip), %rdi       # 0x550b
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O3/nikhilYadala[P]Python_to_cpp/Source/src/convert_to_cpp.cpp
// Function: eval_expr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::string eval_expr(std::string& s)
{
	std::string evaled = "";
	if(*s.begin()=='"') {
		std::string subject = "";
		std::string::iterator itr = s.begin()+1;
		for(;*itr!='"';++itr)
			subject.push_back(*itr);

		evaled.append("artificial_string(\""+subject+"\")");

		itr++;
		for(;itr!=s.end();++itr)
			evaled.push_back(*itr);
	}
	if(evaled == "")
		evaled  = s;

	return evaled;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x8acd(%rip), %rdx      # 0xb21e
movq %rdx, %rsi
callq 0x4e32
movq (%r14), %rax
cmpb $0x22, (%rax)
jne 0x286f
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x8aaa(%rip), %rdx      # 0xb21e
leaq -0x68(%rbp), %rdi
movq %rdx, %rsi
callq 0x4e32
movq (%r14), %r13
addq $0x2, %r13
leaq -0x68(%rbp), %r15
movb -0x1(%r13), %al
cmpb $0x22, %al
je 0x27a3
incq %r13
movsbl %al, %esi
movq %r15, %rdi
callq 0x21a0
jmp 0x278b
leaq 0x885a(%rip), %rsi      # 0xb004
leaq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x4b36
leaq 0x8857(%rip), %rsi      # 0xb018
leaq -0x88(%rbp), %rdi
callq 0x23b0
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x27f1
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x27f8
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x282d
callq 0x21c0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2851
callq 0x21c0
jmp 0x2851
movsbl (%r13), %esi
movq %rbx, %rdi
callq 0x21a0
incq %r13
movq (%r14), %rax
addq 0x8(%r14), %rax
cmpq %rax, %r13
jne 0x2841
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x286f
callq 0x21c0
leaq 0x89a8(%rip), %rsi      # 0xb21e
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
jne 0x288d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2110
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28cd
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x28b7
callq 0x21c0
jmp 0x28b7
movq %rax, %r14
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28d7
callq 0x21c0
jmp 0x28d7
jmp 0x28d4
movq %rax, %r14
jmp 0x28e9
jmp 0x28d4
movq %rax, %r14
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x28e9
callq 0x21c0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x28f6
callq 0x21c0
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O3/nikhilYadala[P]Python_to_cpp/Source/src/convert_to_cpp.cpp
// Function: is_symbol(char)
bool is_symbol(char c){
	char symbols[]=" =:;(){}[]|,.&+-<>*/'\n#";

	for(int i=0;symbols[i]!='#';++i)
		if(symbols[i]==c)
			return 1;
	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x88b5(%rip), %rcx      # 0xb1c0
movb (%rax,%rcx), %dl
cmpb %dil, %dl
je 0x2920
leaq 0x1(%rax), %rsi
cmpq $0x15, %rax
movq %rsi, %rax
jne 0x290b
cmpb %dil, %dl
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nikhilYadala[P]Python_to_cpp/Source/src/convert_to_cpp.cpp
// Function: map_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
std::string map_type(std::string s, int l)
{
	if(s=="int")
		return "long int";
	if(s=="float")
		return "float";
	if(s=="s")
		return "artificial_string";
	else {
		std::cout<<"[ WARNING ] Bad type name "<<s<<"!! on line "<<l<<std::endl;
		return s;
	}


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8329(%rip), %rsi      # 0xb03e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x2de8
leaq 0x8316(%rip), %rsi      # 0xb042
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x2dff
leaq 0x8627(%rip), %rsi      # 0xb36a
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x2e16
movq 0xc27e(%rip), %r12      # 0xefd8
leaq 0x82e7(%rip), %rsi      # 0xb048
movl $0x1a, %edx
movq %r12, %rdi
callq 0x2250
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x2250
movq %rax, %r12
leaq 0x82dc(%rip), %rsi      # 0xb063
movl $0xb, %edx
movq %rax, %rdi
callq 0x2250
movq %r12, %rdi
movl %r15d, %esi
callq 0x2350
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x2e35
movq %rdx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x2e3b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x8243(%rip), %rsi      # 0xb039
leaq 0x8244(%rip), %rdx      # 0xb041
jmp 0x2e2b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x8235(%rip), %rsi      # 0xb042
leaq 0x8233(%rip), %rdx      # 0xb047
jmp 0x2e2b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x81fc(%rip), %rsi      # 0xb020
leaq 0x8206(%rip), %rdx      # 0xb031
movq %rbx, %rdi
callq 0x4e32
jmp 0x2e53
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nikhilYadala[P]Python_to_cpp/Source/src/generate_cpp_code.cpp
// Function: main_func(source_code&)
void main_func(source_code& src)
{
	function_declaration _function;
	_function.name="main";
	_function.return_type="int";
	_function.args.push_back(string_pair("",""));
	
	std::string converted_code;
	std::map< std::string,std::string > variables;	//name -> type
	convert_to_cpp(src.functions[0].first,src.functions[0].second,src.lines,converted_code,&_function,variables);
	converted_code.append(" \nreturn 0;");
	src.generated_cpp_code[0].first=converted_code;	//Only 1 line of sparse code maybe extend later
	src.generated_cpp_code[0].second=_function;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq -0xd0(%rbp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0xb0(%rbp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movq %rax, 0x20(%r13)
leaq 0x47d4(%rip), %rcx      # 0xb270
leaq -0xe0(%rbp), %rdi
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2310
leaq -0xc0(%rbp), %r14
movq 0x8(%r14), %rdx
leaq 0x457a(%rip), %rcx      # 0xb03e
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x2310
leaq 0x4743(%rip), %rdx      # 0xb21e
leaq -0x88(%rbp), %rdi
movq %rdx, %rsi
callq 0x6e92
leaq -0xa0(%rbp), %r15
leaq -0x88(%rbp), %rsi
movq %r15, %rdi
callq 0x5742
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b12
callq 0x21c0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b24
callq 0x21c0
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
leaq -0x80(%rbp), %rcx
movl $0x0, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movq 0x50(%rbx), %rax
movslq (%rax), %rdi
movslq 0x4(%rax), %rsi
leaq 0x38(%rbx), %rdx
leaq -0x48(%rbp), %rcx
leaq -0xe0(%rbp), %r8
leaq -0x88(%rbp), %r9
callq 0x2ef8
leaq 0x46f5(%rip), %rsi      # 0xb275
leaq -0x48(%rbp), %rdi
callq 0x23b0
movq 0x80(%rbx), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2110
movq 0x80(%rbx), %rbx
leaq 0x20(%rbx), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x2110
leaq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0x2110
addq $0x60, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f8c
leaq -0x88(%rbp), %rdi
callq 0x7356
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x6be5
callq 0x21c0
movq %r15, %rdi
callq 0x73ba
movq -0xc0(%rbp), %rdi
cmpq %r13, %rdi
leaq -0xd0(%rbp), %rbx
je 0x6c05
callq 0x21c0
movq -0xe0(%rbp), %rdi
cmpq %rbx, %rdi
je 0x6c16
callq 0x21c0
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x4cf8
jmp 0x6c5d
jmp 0x6c3b
movq %rax, %rbx
jmp 0x6c5d
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x7356
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x6c5d
callq 0x21c0
leaq -0xe0(%rbp), %rdi
callq 0x6f08
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O3/nikhilYadala[P]Python_to_cpp/Source/src/convert_to_cpp_classes.cpp
// Function: is_symbol_(char)
bool is_symbol_(char c){
	char symbols[]=" =:;(){}[]|,.&+-<>*/'\n#";

	for(int i=0;symbols[i]!='#';++i)
		if(symbols[i]==c)
			return 1;
	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x2ec4(%rip), %rcx      # 0xb1c0
movb (%rax,%rcx), %dl
cmpb %dil, %dl
je 0x8311
leaq 0x1(%rax), %rsi
cmpq $0x15, %rax
movq %rsi, %rax
jne 0x82fc
cmpb %dil, %dl
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nikhilYadala[P]Python_to_cpp/Source/src/make_classes.cpp
// Function: source_code::make_classes()
void source_code::make_classes()
{
 //splitting of the code into lines has already been done while functionizing
	classes.resize(0); 

	for(std::vector <line_pair>::iterator classes_itr=lines.begin();classes_itr!=lines.end();)
	{

		//itr incrementing to be done in the following code.
		if(classes_itr->first[0]=='c'&&classes_itr->first[1]=='l'&&classes_itr->first[2]=='a'&&classes_itr->first[3]=='s'&&classes_itr->first[4]=='s')
	        {

	            //classes inherited are taken care off in convert_to_cpp_classes.cpp
	            
	        	int space_count=classes_itr->second;
	        	int i1,i2;
	        	i1=classes_itr-lines.begin();
	        	while((((++classes_itr)->second)) > space_count)
					i2=classes_itr-lines.begin()-1;
				classes.push_back(int_pair(i1,i2));

            }
        else
           {
                   classes_itr++;
           }
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x68(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x651c
movq 0x38(%rbx), %r12
movq 0x40(%rbx), %rax
cmpq %rax, %r12
je 0xa597
leaq -0x30(%rbp), %r15
movq (%r12), %rcx
cmpb $0x63, (%rcx)
jne 0xa54e
cmpb $0x6c, 0x1(%rcx)
jne 0xa54e
cmpb $0x61, 0x2(%rcx)
jne 0xa54e
cmpb $0x73, 0x3(%rcx)
jne 0xa54e
cmpb $0x73, 0x4(%rcx)
jne 0xa54e
movl 0x20(%r12), %ecx
movq %r12, %rax
subq 0x38(%rbx), %rax
cmpl %ecx, 0x48(%r12)
jle 0xa559
addq $0x70, %r12
movq %rax, %rdx
movq %r12, %rsi
addq $0x28, %rdx
addq $0x28, %r12
cmpl %ecx, (%rsi)
jg 0xa52b
shrq $0x3, %rdx
imull $0xcccccccd, %edx, %r13d # imm = 0xCCCCCCCD
decl %r13d
addq $-0x48, %r12
jmp 0xa55d
addq $0x28, %r12
cmpq %rax, %r12
jne 0xa4f0
jmp 0xa597
addq $0x28, %r12
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
movl %eax, -0x30(%rbp)
movl %r13d, -0x2c(%rbp)
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0xa586
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x70(%rbx)
jmp 0xa591
movq %r14, %rdi
movq %r15, %rdx
callq 0x6972
movq 0x40(%rbx), %rax
jmp 0xa552
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/panosfoto[P]NGramGraphParallel/src/GraphSimilarity.cpp
// Function: GraphSimilarity::getSimilarityComponents[abi:cxx11]()
std::map<std::string, double> GraphSimilarity::getSimilarityComponents()
{
    // Init result map
    std::map<std::string, double> resultMap;
    // Update components
    resultMap["valueSimilarity"] = this->valueSimilarity;
    resultMap["containmentSimilarity"] = this->containmentSimilarity;
    resultMap["sizeSimilarity"] = this->sizeSimilarity;
    // Return
    return resultMap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x7f60(%rip), %rsi      # 0x1b6c5
leaq 0x7f68(%rip), %rdx      # 0x1b6d4
leaq -0x40(%rbp), %rdi
callq 0x6fa8
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6e86
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x13798
callq 0x6290
movsd 0x10(%r14), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x7f24(%rip), %rsi      # 0x1b6d5
leaq 0x7f32(%rip), %rdx      # 0x1b6ea
callq 0x6fa8
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6e86
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x137e0
callq 0x6290
movsd 0x18(%r14), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x28c4(%rip), %rsi      # 0x160bd
leaq 0x28cb(%rip), %rdx      # 0x160cb
callq 0x6fa8
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x6e86
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x13828
callq 0x6290
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1383e
jmp 0x13851
jmp 0x1383e
jmp 0x13851
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x13854
callq 0x6290
jmp 0x13854
movq %rax, %r14
movq %rbx, %rdi
callq 0x6f06
movq %r14, %rdi
callq 0x6490
// File: /workspace/github_cpp_makefile_star2_O3/panosfoto[P]NGramGraphParallel/src/NGramGraph.cpp
// Function: NGramGraph::NGramGraph()
NGramGraph::NGramGraph()
{
    CorrelationWindow = CORRELATIONWINDOW_DEFAULT_VALUE;
    splitter = nullptr;
    evaluator = nullptr;
    payload = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11314(%rip), %rax     # 0x24ba0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq -0x9(%rbp), %rsi
callq 0x14056
leaq 0x70(%rbx), %rax
movq %rax, 0x40(%rbx)
movq $0x1, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movl $0x3f800000, 0x60(%rbx) # imm = 0x3F800000
movups %xmm0, 0x68(%rbx)
movl $0x0, 0x78(%rbx)
leaq 0x1123c(%rip), %rax     # 0x24b08
movq %rax, (%rbx)
movl $0x3, 0x98(%rbx)
movups %xmm0, 0x80(%rbx)
movq $0x0, 0x90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/panosfoto[P]NGramGraphParallel/src/NGramGraph.cpp
// Function: NGramGraph::NGramGraph(ProximityEvaluator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, StringSplitter*, StringPayload*, unsigned int)
NGramGraph::NGramGraph(ProximityEvaluator<std::string> *newProximityEvaluator, StringSplitter *newSplitter, StringPayload *newPayload, unsigned int CorrelationWindowValue)
{
    evaluator = newProximityEvaluator;
    splitter = newSplitter;
    payload = newPayload;
    CorrelationWindow = CorrelationWindowValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x1128a(%rip), %rax     # 0x24ba0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq -0x29(%rbp), %rsi
callq 0x14056
leaq 0x70(%r13), %rax
movq %rax, 0x40(%r13)
movq $0x1, 0x48(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r13)
movl $0x3f800000, 0x60(%r13) # imm = 0x3F800000
movups %xmm0, 0x68(%r13)
movl $0x0, 0x78(%r13)
leaq 0x111ae(%rip), %rax     # 0x24b08
movq %rax, (%r13)
movq %r12, 0x80(%r13)
movq %r15, 0x88(%r13)
movq %r14, 0x90(%r13)
movl %ebx, 0x98(%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtmidi_build/tests/sysextest.cpp
// Function: mycallback(double, std::vector<unsigned char, std::allocator<unsigned char>>*, void*)
void mycallback( double deltatime, std::vector< unsigned char > *message, void * /*userData*/ )
{
  unsigned int nBytes = message->size();
  for ( unsigned int i=0; i<nBytes; i++ )
    std::cout << "Byte " << i << " = " << (int)message->at(i) << ", ";
  if ( nBytes > 0 )
    std::cout << "stamp = " << deltatime << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rdi), %rax
subq (%rdi), %rax
testl %eax, %eax
je 0x24ae
movq %rdi, %rbx
movq %rax, 0x8(%rsp)
movl %eax, %r13d
xorl %r14d, %r14d
movq 0x2bff(%rip), %r15      # 0x4fd0
leaq 0xc83(%rip), %rbp       # 0x305b
movl $0x5, %edx
movq %r15, %rdi
leaq 0xc6e(%rip), %rsi       # 0x3055
callq 0x2140
movq %r15, %rdi
movq %r14, %rsi
callq 0x2080
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
leaq 0xc5a(%rip), %rsi       # 0x3063
callq 0x2140
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
cmpq %r14, %rdx
jbe 0x24bd
movzbl (%rax,%r14), %esi
movq %r12, %rdi
callq 0x21f0
movl $0x2, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2140
incq %r14
cmpq %r14, %r13
jne 0x23d8
cmpl $0x0, 0x8(%rsp)
je 0x24ae
movq 0x2b7c(%rip), %rbx      # 0x4fd0
leaq 0xc03(%rip), %rsi       # 0x305e
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2140
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x21c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2090
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcb6(%rip), %rdi       # 0x317a
movq %r14, %rsi
xorl %eax, %eax
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: node::update()
void node::update() {
    size = 1;
    sum_adjacent_nodes[0] = adjacent_nodes[0];
    sum_adjacent_nodes[1] = adjacent_nodes[1];
    if(left) {
        size += left->size;
        sum_adjacent_nodes[0] += left->sum_adjacent_nodes[0];
        sum_adjacent_nodes[1] += left->sum_adjacent_nodes[1];
    }
    if(right) {
        size += right->size;
        sum_adjacent_nodes[0] += right->sum_adjacent_nodes[0];
        sum_adjacent_nodes[1] += right->sum_adjacent_nodes[1];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, 0x1c(%rdi)
movl 0x20(%rdi), %ecx
movl %ecx, 0x28(%rdi)
movl 0x24(%rdi), %eax
movl %eax, 0x2c(%rdi)
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x263d
movl 0x1c(%rsi), %edx
incl %edx
movl %edx, 0x1c(%rdi)
addl 0x28(%rsi), %ecx
movl %ecx, 0x28(%rdi)
addl 0x2c(%rsi), %eax
movl %eax, 0x2c(%rdi)
jmp 0x2642
movl $0x1, %edx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x265d
addl 0x1c(%rsi), %edx
movl %edx, 0x1c(%rdi)
addl 0x28(%rsi), %ecx
movl %ecx, 0x28(%rdi)
addl 0x2c(%rsi), %eax
movl %eax, 0x2c(%rdi)
popq %rbp
retq
nop