LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0xc(%rdi), %ecx
incl %eax
movl %eax, 0x4(%rdi)
movl (%r12), %esi
movl 0x10(%rdi), %r8d
movq %rcx, %rdi
shlq $0x5, %rdi
addq %r14, %rdi
addq $0x200, %rdi            # imm = 0x200
subl (%rdi,%r8,8), %esi
incl %esi
movb $0x1, %bpl
cmpl %esi, %eax
jl 0x8b22
leaq 0x200(%r14), %r15
leaq 0x14(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %rdx, 0x8(%rsp)
callq 0x89a8
movl 0x4(%r13), %eax
movl %eax, 0x4(%rbx)
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %edx
incl %ecx
movl %ecx, 0x8(%rbx)
movl 0x4(%r12), %esi
movl 0x10(%rbx), %eax
shlq $0x5, %rdx
addq %r15, %rdx
subl 0x4(%rdx,%rax,8), %esi
incl %esi
cmpl %esi, %ecx
jl 0x8b22
leaq 0x288(%r14), %r12
movl %eax, %edi
callq 0x98c3
movl %eax, 0x10(%rbx)
movl 0xc(%rbx), %ecx
testl %eax, %eax
jne 0x8aef
movl %ecx, %edi
callq 0x98b1
movl %eax, 0xc(%rbx)
testl %eax, %eax
je 0x8b20
movl %eax, %ecx
movl 0x10(%rbx), %eax
movl %ecx, %edx
movl %eax, %esi
leaq (%r12,%rdx,4), %rdx
cmpb $0x0, (%rsi,%rdx)
jne 0x8acb
leaq 0x14(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
movl %eax, %r8d
callq 0x89a8
movq 0x4(%r12), %rax
movq %rax, 0x4(%rbx)
jmp 0x8b22
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
movq %r14, 0x10(%rsp)
movl (%r14,%r13,4), %r12d
cmpl $0x1, %r12d
je 0x8b76
testl %r12d, %r12d
jne 0x8b8f
movl $0x7, %edx
movq %rbx, %rdi
leaq 0x280f(%rip), %rsi      # 0xb383
jmp 0x8b85
movl $0x7, %edx
movq %rbx, %rdi
leaq 0x2806(%rip), %rsi      # 0xb38b
callq 0x21b0
jmp 0x8c60
leal -0x2(%r12), %ebp
leal 0xd(%r12), %r14d
testl %ebp, %ebp
movl %ebp, %r15d
cmovsl %r14d, %r15d
movl $0x3, %edx
movq %rbx, %rdi
leaq 0x27e2(%rip), %rsi      # 0xb393
callq 0x21b0
movslq %ebp, %rax
imulq $0x2aaaaaab, %rax, %rax # imm = 0x2AAAAAAB
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
addl %eax, %eax
leal (%rax,%rax,2), %eax
negl %eax
leal (%r12,%rax), %esi
decl %esi
movq %rbx, %rdi
callq 0x2290
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
leaq 0x27a7(%rip), %rsi      # 0xb39b
callq 0x21b0
movb $0x20, %al
cmpl $0x1f, %r14d
jb 0x8c13
movl %r15d, %eax
sarl $0x4, %eax
cltq
leaq 0x2790(%rip), %rcx      # 0xb3a0
movb (%rax,%rcx), %al
andl $-0x10, %r15d
negl %r15d
leal (%r12,%r15), %r14d
addl $-0x2, %r14d
movb %al, 0x6(%rsp)
movl $0x1, %edx
movq %rbp, %rdi
leaq 0x6(%rsp), %rsi
callq 0x21b0
movslq %r14d, %rcx
leaq 0x275e(%rip), %rdx      # 0xb3a0
movb (%rcx,%rdx), %cl
movb %cl, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0x7(%rsp), %rsi
callq 0x21b0
movq 0x10(%rsp), %r14
incq %r13
cmpq $0x20, %r13
jne 0x8b56
movl $0x5, %edx
movq %rbx, %rdi
leaq 0x271b(%rip), %rsi      # 0xb397
callq 0x21b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq 0x8(%rsp), %rax
incq %rax
subq $-0x80, %r14
cmpq $0x20, %rax
jne 0x8b49
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl 0x4(%rcx), %ecx
testl %ecx, %ecx
jle 0x90a2
movq %rdx, %r15
movq %rsi, %r12
movl (%r14), %eax
xorl %ebp, %ebp
testl %eax, %eax
jle 0x9098
xorl %r13d, %r13d
movslq (%r15), %rcx
leal (%rcx,%r13), %eax
movslq 0x4(%r15), %rdx
leal (%rdx,%rbp), %esi
shlq $0x20, %rsi
orq %rsi, %rax
movq %rax, (%rsp)
leaq (%rcx,%rdx,8), %rcx
addq %r12, %rcx
cmpb $0x1, (%r13,%rcx)
jne 0x9089
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x907e
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x9089
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x52fe
movl (%r14), %eax
incq %r13
cmpl %eax, %r13d
jl 0x9042
movl 0x4(%r14), %ecx
incl %ebp
addq $0x8, %r12
cmpl %ecx, %ebp
jl 0x903b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x90cb
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]procon26/procon26.cpp
// Function: void shrink_cell<int, 32, void shrink_cell<int, 32>(int const (&) [32][32], point_t&, point_t&, int)::'lambda'(int)>(int const (&) [32][32], point_t&, point_t&, void shrink_cell<int, 32>(int const (&) [32][32], point_t&, point_t&, int)::'lambda'(int))
void shrink_cell(T const (& a)[N][N], point_t & offset, point_t & size, F pred) {
    int & x = offset.x;
    int & y = offset.y;
    int & w = size.x;
    int & h = size.y;
    shrink_cell_helper(h, [&](int dy){ return pred(a[y+dy ][x    ]); }, [&](){ x += 1; w -= 1; });
    shrink_cell_helper(w, [&](int dx){ return pred(a[y    ][x+dx ]); }, [&](){ y += 1; h -= 1; });
    shrink_cell_helper(h, [&](int dy){ return pred(a[y+dy ][x+w-1]); }, [&](){         w -= 1; });
    shrink_cell_helper(w, [&](int dx){ return pred(a[y+h-1][x+dx ]); }, [&](){         h -= 1; });
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x4(%rdx), %r8d
movq %r8, %r9
shlq $0x7, %r9
movslq (%rsi), %r10
testl %r8d, %r8d
jle 0x91e1
movslq 0x4(%rsi), %rax
movl (%rcx), %r11d
movq %rax, %rbx
shlq $0x7, %rbx
leaq (%rbx,%r10,4), %rbx
addq %rdi, %rbx
xorl %r14d, %r14d
cmpl (%rbx,%r14), %r11d
jne 0x91eb
subq $-0x80, %r14
cmpq %r14, %r9
jne 0x91d2
incl %r10d
movl %r10d, (%rsi)
decl (%rdx)
jmp 0x91b2
movl (%rdx), %r8d
testl %r8d, %r8d
jle 0x9218
movslq %eax, %r10
movslq (%rsi), %r11
movl (%rcx), %r9d
shlq $0x7, %r10
leaq (%r10,%r11,4), %r10
addq %rdi, %r10
xorl %r11d, %r11d
cmpl (%r10,%r11,4), %r9d
jne 0x9225
incq %r11
cmpq %r11, %r8
jne 0x920a
incl %eax
movl %eax, 0x4(%rsi)
decl 0x4(%rdx)
movl 0x4(%rsi), %eax
jmp 0x91ee
movl (%rdx), %eax
movl 0x4(%rdx), %r8d
movq %r8, %r9
shlq $0x7, %r9
leal -0x1(%rax), %r10d
testl %r8d, %r8d
jle 0x9267
movslq 0x4(%rsi), %rbx
movl (%rcx), %r11d
shlq $0x7, %rbx
movl (%rsi), %ebp
addl %r10d, %ebp
movslq %ebp, %r14
leaq (%rbx,%r14,4), %rbx
addq %rdi, %rbx
xorl %r14d, %r14d
cmpl (%rbx,%r14), %r11d
jne 0x9270
subq $-0x80, %r14
cmpq %r14, %r9
jne 0x9258
decl %eax
movl %eax, (%rdx)
decl %r10d
jmp 0x9236
movl %eax, %r9d
leal -0x1(%r8), %r10d
testl %eax, %eax
jle 0x92a6
movslq (%rsi), %rbx
movl (%rcx), %r11d
movl 0x4(%rsi), %ebp
addl %r10d, %ebp
movslq %ebp, %r14
shlq $0x7, %r14
leaq (%r14,%rbx,4), %rbx
addq %rdi, %rbx
xorl %r14d, %r14d
cmpl (%rbx,%r14,4), %r11d
jne 0x92b2
incq %r14
cmpq %r14, %r9
jne 0x9298
decl %r8d
movl %r8d, 0x4(%rdx)
decl %r10d
jmp 0x9277
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0xf(%rsp), %r15
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2200
cmpb $0x30, 0xf(%rsp)
setne (%r14,%r13)
incq %r13
cmpq $0x20, %r13
jne 0x9782
incq %r12
addq $0x20, %r14
cmpq $0x20, %r12
jne 0x977f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0xf(%rsp), %r15
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2200
cmpb $0x30, 0xf(%rsp)
setne (%r14,%r13)
incq %r13
cmpq $0x8, %r13
jne 0x97dc
incq %r12
addq $0x8, %r14
cmpq $0x8, %r12
jne 0x97d9
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9764
leaq 0x4(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20d0
movl (%r15), %esi
leal -0x1(%rsi), %eax
cmpl $0x100, %eax            # imm = 0x100
jae 0x9892
addq $0x400, %r14            # imm = 0x400
movq %r14, %rdi
callq 0x9ba6
cmpl $0x0, 0x4(%rsp)
jle 0x9883
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x97be
incq %r12
movslq 0x4(%rsp), %rax
addq $0x40, %r15
cmpq %rax, %r12
jl 0x9864
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b18(%rip), %rdi      # 0xb3b1
leaq 0x1b25(%rip), %rsi      # 0xb3c5
leaq 0x1b29(%rip), %rcx      # 0xb3d0
movl $0x19, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x6212(%rip), %r14      # 0xfff0
leaq 0x164b(%rip), %rsi      # 0xb430
movq %r14, %rdi
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x2290
leaq 0x163e(%rip), %rsi      # 0xb43c
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20a0
movq 0x61b3(%rip), %rdi      # 0xffc8
leaq 0x636c(%rip), %rsi      # 0x10188
callq 0x9a47
leaq 0x1689(%rip), %rsi      # 0xb4b1
movq %r14, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20a0
movl 0x6332(%rip), %esi      # 0x10170
movq %r14, %rdi
callq 0x2290
leaq 0x153c(%rip), %rsi      # 0xb389
movq %rax, %rdi
callq 0x2170
movl 0x6319(%rip), %esi      # 0x10174
movq %rax, %rdi
callq 0x2290
movq %rax, %rdi
callq 0x20a0
movl %ebx, %edi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %r15
movzwl 0x2c(%rdi), %r12d
movq (%rdi), %rdi
callq 0x4b72
movl %eax, %ebx
cmpw $0x0, 0x2c(%r15)
je 0x3dae
movw $0x1, %r13w
xorl %ebp, %ebp
movq (%r15), %rdi
leal (%r14,%r13), %eax
decl %eax
movzwl %ax, %esi
callq 0x4e66
addl %eax, %ebp
incl %r13d
cmpw 0x2c(%r15), %r13w
jbe 0x3d8f
jmp 0x3db0
xorl %ebp, %ebp
decl %r12d
imull %r12d, %ebx
addl %ebx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movl %edx, %ebp
movq %rdi, %rbx
movq 0x10(%rsi), %rcx
testq %rcx, %rcx
je 0x3f49
movq 0x8(%rsi), %rdx
xorl %edi, %edi
xorl %eax, %eax
xorl %r8d, %r8d
cmpb $0xa, (%rdx,%rdi)
sete %r8b
addl %r8d, %eax
incq %rdi
cmpq %rdi, %rcx
jne 0x3f2f
incl %eax
jmp 0x3f4d
movw $0x1, %ax
cmpw %bp, %ax
jbe 0x3fcb
addq $0x8, %rsi
movq %rsp, %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2240
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
xorl %r12d, %r12d
movq (%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2280
incl %r12d
cmpw %bp, %r12w
jbe 0x3f7c
movq %rbx, %rsi
callq 0x4030
movq 0x7001(%rip), %rsi      # 0xafb8
movq %rsp, %rdi
callq 0x21e0
leaq 0x78(%rsp), %rdi
callq 0x2050
jmp 0x3fe4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x320a(%rip), %rdx      # 0x71e3
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x374a
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ff9
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x400f
movq (%r15), %rsi
incq %rsi
callq 0x2180
movq 0x6fa2(%rip), %rsi      # 0xafb8
movq %rsp, %rdi
callq 0x21e0
leaq 0x78(%rsp), %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %rsi
addq %r14, %rsi
movq 0x6f4d(%rip), %rdx      # 0xaf98
movq %r14, %rdi
callq 0x457f
movq (%rbx), %rcx
movq %r14, %rsi
subq %rcx, %rsi
movq 0x8(%rbx), %rdx
addq %rcx, %rdx
cmpq %rax, %rdx
je 0x4078
subq %r14, %rax
movq %rbx, %rdi
movq %rax, %rdx
callq 0x21c0
jmp 0x4080
movq %rsi, 0x8(%rbx)
movb $0x0, (%rcx,%rsi)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq 0x6ef7(%rip), %rcx      # 0xaf98
movq %rsp, %r14
movq %r14, %rdi
callq 0x4650
movq (%r14), %rax
movq %rax, %rcx
subq (%rbx), %rcx
movq %rcx, 0x8(%rbx)
movb $0x0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x70(%rdi), %rax
movups 0x60(%rdi), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, 0x60(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x70(%rdi)
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
leaq 0x20(%rsp), %r14
movaps %xmm1, (%r14)
movq %rcx, 0x10(%r14)
callq 0x3c0c
movq %r14, %rdi
callq 0x3c0c
movq (%r15), %r14
movq 0x8(%r15), %rbp
cmpq %rbp, %r14
je 0x48c9
leaq 0x60(%rbx), %r12
leaq 0x8(%rsp), %r15
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6774
movq %r12, %rdi
movq %r13, %rsi
callq 0x625a
movq %r15, %rdi
callq 0x3c54
addq $0x18, %r14
cmpq %rbp, %r14
jne 0x489f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x3c54
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
callq 0x4ab4
cmpw %bp, %ax
jb 0x496f
movq 0x60(%r14), %rbx
movq 0x68(%r14), %r12
movl (%r15), %eax
shlq $0x20, %rax
movzwl %bp, %ecx
orq %rax, %rcx
movq %rcx, (%rsp)
cmpq %r12, %rbx
je 0x4962
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
callq 0x688c
cmpw (%rsp), %ax
jbe 0x4959
movq %rbx, %rdi
callq 0x6858
movzwl (%rsp), %ecx
leaq (%rcx,%rcx,2), %rdi
shll $0x4, %edi
addq (%rax), %rdi
movq %r14, %rsi
callq 0x3d4c
addq $0x20, %rbx
cmpq %r12, %rbx
jne 0x492d
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4ab4
movzwl %ax, %esi
leaq 0x20(%rsp), %rdi
callq 0x5cce
leaq 0x2838(%rip), %rsi      # 0x71d0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x5c5e
leaq 0x2836(%rip), %rsi      # 0x71e4
leaq 0x40(%rsp), %rdi
callq 0x2290
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x49d9
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x49e5
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x2200
xorl %ebp, %ebp
movq 0x65bd(%rip), %rsi      # 0xafd0
movq 0x65ae(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4a43
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x4a43
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4a5e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4a79
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
testb %bpl, %bpl
jne 0x4aa3
jmp 0x4aab
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4aa3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x4aa3
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x503c
movq (%r14), %rbx
movq 0x8(%r14), %r14
xorl %ebp, %ebp
cmpq %r14, %rbx
je 0x4af7
movq %rbx, %rdi
callq 0x688c
cmpw %bp, %ax
jbe 0x4af1
movq %rbx, %rdi
callq 0x688c
movl %eax, %ebp
addq $0x20, %rbx
jmp 0x4ad5
leaq 0x8(%rsp), %rdi
callq 0x3c0c
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3c0c
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/Phidelux[P]terminal-table/src/table.cpp
// Function: bornageek::utils::termtab::Table::columnWidth(unsigned short) const
const std::uint16_t Table::columnWidth(const std::uint16_t n) const {
        if(n > this->numColumns()) {
          throw std::out_of_range("The table just has " 
                + std::to_string(this->numColumns()) + " columns.");
        }

        std::uint16_t max = 0;

        std::vector<Row> rows = this->rowsWithHeadings();
        std::for_each(rows.begin(), rows.end(),
          [&max, n](const Row &row) { 
            if(n < row.numCells() && row.cellWidth(n) > max) {
              max = row.cellWidth(n);
            } 
          });

        return max;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x4ab4
cmpw %bx, %ax
jb 0x4eeb
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x503c
movq (%r15), %r14
movq 0x8(%r15), %r12
xorl %ebp, %ebp
cmpq %r12, %r14
je 0x4ed4
movzwl %bx, %r15d
movq %r14, %rdi
callq 0x688c
cmpw %bx, %ax
jbe 0x4ecb
movq %r14, %rdi
movl %r15d, %esi
callq 0x689c
cmpw %bp, %ax
jbe 0x4ecb
movq %r14, %rdi
movl %r15d, %esi
callq 0x689c
movl %eax, %ebp
addq $0x20, %r14
cmpq %r12, %r14
jne 0x4ea1
movq %rsp, %rdi
callq 0x3c0c
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4ab4
movzwl %ax, %esi
leaq 0x20(%rsp), %rdi
callq 0x5cce
leaq 0x22bc(%rip), %rsi      # 0x71d0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x5c5e
leaq 0x22ba(%rip), %rsi      # 0x71e4
leaq 0x40(%rsp), %rdi
callq 0x2290
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4f55
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x4f61
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x2200
xorl %ebp, %ebp
movq 0x6041(%rip), %rsi      # 0xafd0
movq 0x6032(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4fbf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x4fbf
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4fda
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4ff5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
testb %bpl, %bpl
jne 0x501f
jmp 0x5034
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x501f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x501f
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
jmp 0x5034
movq %rax, %r14
movq %rsp, %rdi
callq 0x3c0c
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/Phidelux[P]terminal-table/src/table.cpp
// Function: bornageek::utils::termtab::Table::rowsWithHeadings() const
const std::vector<Row> Table::rowsWithHeadings() const {
        std::vector<Row> rows = this->rows();

        if(this->mHeadings.numCells() > 0) {
          rows.insert(rows.begin(), this->headings());
        }

        return rows;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x60, %rsi
callq 0x5e96
leaq 0x40(%r14), %rdi
callq 0x688c
testw %ax, %ax
je 0x509b
movq (%rbx), %r12
movq 0x40(%r14), %rax
leaq 0x10(%rsp), %r15
movq %rax, -0x8(%r15)
addq $0x48, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x6046
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5f20
movq %r15, %rdi
callq 0x3c54
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x3c54
jmp 0x50bc
jmp 0x50b9
movq %rax, %r14
movq %rbx, %rdi
callq 0x3c0c
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/Phidelux[P]terminal-table/src/table.cpp
// Function: bornageek::utils::termtab::Table::row(unsigned short)
Row& Table::row(const std::uint16_t n) {
        if(n >= this->mRows.size()) {
          throw std::out_of_range("The table just has " 
                + std::to_string(this->mRows.size()) + " rows.");
        }

        return this->mRows[n];
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %esi, %ecx
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rcx, %rdx
jbe 0x51cf
shll $0x5, %ecx
addq %rcx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
movq 0x68(%r14), %rsi
subq 0x60(%r14), %rsi
sarq $0x5, %rsi
leaq 0x8(%rsp), %rdi
callq 0x5e05
leaq 0x1fd4(%rip), %rsi      # 0x71d0
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5c5e
leaq 0x1fdc(%rip), %rsi      # 0x71ee
leaq 0x48(%rsp), %rdi
callq 0x2290
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x523d
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x524a
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x2200
xorl %ebp, %ebp
movq 0x5d56(%rip), %rsi      # 0xafd0
movq 0x5d47(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x52ab
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x52ab
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52c6
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52e1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
testb %bpl, %bpl
jne 0x530b
jmp 0x5313
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x530b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x530b
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/Phidelux[P]terminal-table/src/table.cpp
// Function: bornageek::utils::termtab::Table::renderSeparator[abi:cxx11](char, char, char, char) const
const std::string Table::renderSeparator(
            const char left, const char mid, 
            const char right, const char sep) const {
        std::stringstream ss;

        ss << left;

        for(std::size_t i = 0; i < this->numColumns(); i++) {
          std::uint16_t width = this->columnWidth(i) 
                  + this->mStyle.paddingLeft() + this->mStyle.paddingRight();

          for(std::size_t j = 0 ; j < width; j++ ) { 
            ss << sep;
          }

          if(i+1 < this->numColumns()) {
            ss << mid;
          } else {
            ss << right;
          }
        }

        ss << std::endl;

        return ss.str();
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %r9d, %ebp
movl %r8d, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl %edx, %ebx
movq %rsi, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x20e0
leaq 0x30(%rsp), %r14
leaq 0x7(%rsp), %rsi
movb %bl, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x21a0
xorl %r13d, %r13d
leaq 0x7(%rsp), %rbx
movq 0x8(%rsp), %rdi
callq 0x4ab4
movzwl %ax, %eax
cmpq %rax, %r13
jae 0x5438
movzwl %r13w, %esi
movq 0x8(%rsp), %rdi
callq 0x4e66
movl %eax, %r15d
movq 0x8(%rsp), %rdi
callq 0x2550
movl %eax, %r12d
movq 0x8(%rsp), %rdi
callq 0x255e
addl %r12d, %eax
addl %r15d, %eax
testw %ax, %ax
je 0x53e9
movzwl %ax, %r15d
movb %bpl, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21a0
decq %r15
jne 0x53cf
movq 0x8(%rsp), %rdi
callq 0x4ab4
incq %r13
movzwl %ax, %eax
cmpq %rax, %r13
jae 0x541b
movl 0x10(%rsp), %eax
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21a0
jmp 0x5382
movl 0x14(%rsp), %eax
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21a0
jmp 0x5382
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x2220
movq 0x5b29(%rip), %rsi      # 0xafa0
leaq 0x20(%rsp), %rdi
callq 0x2110
leaq 0xa0(%rsp), %rdi
callq 0x2050
movq 0x18(%rsp), %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x54ab
jmp 0x54ab
jmp 0x54ab
movq %rax, %rbx
movq 0x5aeb(%rip), %rsi      # 0xafa0
leaq 0x20(%rsp), %rdi
callq 0x2110
leaq 0xa0(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/obj_loader.cpp
// Function: OBJ_FileLoader::OBJ_FileLoader(char const*)
OBJ_FileLoader::OBJ_FileLoader(const char* fname)
{
	std::ifstream fin(fname, std::ios_base::in);
	if(fin.fail()) { throw( Ghulbus::gbException(Ghulbus::gbException::GB_FAILED,
	                                             "Could not open obj file for read") ); }
	ReadFile(fin);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsp, %rdi
movl $0x8, %edx
callq 0x2370
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x2831
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2894
movq %rsp, %rdi
callq 0x2060
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movl $0x18, %edi
callq 0x20e0
movq %rax, %r14
leaq 0x77db(%rip), %rdx      # 0xa020
movq %rax, %rdi
movl $0x1, %esi
callq 0x8330
leaq 0xc537(%rip), %rsi      # 0xed90
leaq 0x5afc(%rip), %rdx      # 0x835c
movq %r14, %rdi
callq 0x2320
movq %rax, %r14
jmp 0x2878
movq %rax, %r14
movq %rsp, %rdi
callq 0x2060
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x288c
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/obj_loader.cpp
// Function: OBJ_Mesh::SetName(char const*)
void OBJ_Mesh::SetName(char const* name) {
	if(m_name) { delete[] m_name;  m_name = NULL; }
	size_t size = strlen(name) + 1;
	m_name = new char[size];
	strcpy(m_name, name);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x3e64
callq 0x2250
movq $0x0, 0x60(%r14)
movq %rbx, %rdi
callq 0x20c0
leaq 0x1(%rax), %rdi
callq 0x2030
movq %rax, 0x60(%r14)
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/obj_loader.cpp
// Function: OBJ_Mesh::OBJ_Mesh(OBJ_Mesh const&)
OBJ_Mesh::OBJ_Mesh(OBJ_Mesh const& rhs)
	:m_name(NULL)
{
	//copy construct:
	this->SetName(rhs.m_name);
	this->SetGeometry(rhs.m_geometry);
	this->SetNormals(rhs.m_normals);
	this->SetTextureData(rhs.m_texcoords);
	this->SetFaceData(rhs.m_faces);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x30(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x60(%rdi)
movq 0x60(%rsi), %rsi
callq 0x3e44
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40ba
leaq 0x18(%r12), %rsi
movq %rbx, %rdi
callq 0x4110
leaq 0x30(%r12), %rsi
movq %rbx, %rdi
callq 0x4178
addq $0x48, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x41e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r12
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x40a3
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2415
movq %r12, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/ps2_iconsys.cpp
// Function: IconSys::DecodeTitle(unsigned char const*, char*)
void IconSys::DecodeTitle(unsigned char const * str_in, char* str_out)
{
	unsigned char t1, t2;

	for(int i=0; i<68; i+=2) {
		t1 = str_in[i];		//each S-JIS character consists of two bytes
		t2 = str_in[i+1];

		switch(t1) {
			case 0x00:
				if(t2 == 0x00) {
					str_out[i>>1] = '\0';
					return;
				} else {
					str_out[i>>1] = '?';
				}
				break;
			case 0x81:
				if(t2 == 0x40) {
					str_out[i>>1] = ' ';
				} else if(t2 == 0x46) {
					str_out[i>>1] = ':';
				} else if(t2 == 0x5E) {
					str_out[i>>1] = '/';
				} else if(t2 == 0x69) {
					str_out[i>>1] = '(';
				} else if(t2 == 0x6A) {
					str_out[i>>1] = ')';
				} else if(t2 == 0x6D) {
					str_out[i>>1] = '[';
				} else if(t2 == 0x6E) {
					str_out[i>>1] = ']';
				} else if(t2 == 0x6F) {
					str_out[i>>1] = '{';
				} else if(t2 == 0x70) {
					str_out[i>>1] = '}';
				} else {
					str_out[i>>1] = '?';
				}
				break;
			case 0x82:
				if((t2 >= 0x4f) && (t2 <= 0x7A)) {
					//digits (0-9), capital letters (A-Z)
					str_out[i>>1] = t2-31;
				} else if( (t2 >= 0x81) && (t2 <= 0x9B) ) {
					//lowercase letters (a-z)
					str_out[i>>1] = t2-32;
				} else if(t2 == 0x3F) {
					str_out[i>>1] = ' ';
				}  else {
					str_out[i>>1] = '?';
				}
				break;			
			default:
				str_out[i>>1] = '?';
				break;
		}
	}
}

// Assembly:
movq $-0x2, %rax
leaq 0x56ea(%rip), %rcx      # 0xa188
movzbl 0x2(%rdi,%rax), %r8d
movzbl 0x3(%rdi,%rax), %edx
cmpl $0x82, %r8d
je 0x4ae8
cmpl $0x81, %r8d
je 0x4acd
testl %r8d, %r8d
jne 0x4ac8
testl %edx, %edx
je 0x4b54
movb $0x3f, (%rsi)
jmp 0x4b42
cmpl $0x68, %edx
jle 0x4b08
addl $-0x69, %edx
cmpl $0x7, %edx
ja 0x4ac8
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movb $0x28, (%rsi)
jmp 0x4b42
leal -0x4f(%rdx), %r8d
cmpb $0x2b, %r8b
ja 0x4af7
addb $-0x1f, %dl
jmp 0x4b04
leal 0x7f(%rdx), %r8d
cmpb $0x1a, %r8b
ja 0x4b1c
addb $-0x20, %dl
movb %dl, (%rsi)
jmp 0x4b42
cmpl $0x40, %edx
je 0x4b21
cmpl $0x46, %edx
je 0x4b3f
cmpl $0x5e, %edx
jne 0x4ac8
movb $0x2f, (%rsi)
jmp 0x4b42
cmpl $0x3f, %edx
jne 0x4ac8
movb $0x20, (%rsi)
jmp 0x4b42
movb $0x7b, (%rsi)
jmp 0x4b42
movb $0x5b, (%rsi)
jmp 0x4b42
movb $0x5d, (%rsi)
jmp 0x4b42
movb $0x29, (%rsi)
jmp 0x4b42
movb $0x7d, (%rsi)
jmp 0x4b42
movb $0x3a, (%rsi)
incq %rsi
addq $0x2, %rax
cmpq $0x42, %rax
jb 0x4a9e
retq
movb $0x0, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/ps2_iconsys.cpp
// Function: IconSys::GetTitleString(char const*, unsigned int, char*)
void IconSys::GetTitleString(char const * str_in, unsigned int pos_linebreak, char * str_out)
{
	unsigned int i, j;
	pos_linebreak = pos_linebreak >> 1;				//remember S-JIS uses two bytes per character!
	if( (pos_linebreak>0) && (pos_linebreak < 33) ) {
		for(i=0, j=0; i<pos_linebreak; i++, j++) {
			str_out[i] = str_in[j];
		}
		str_out[i++] = '\n';
	} else {
		i = 0;
		j = 0;
	}
	for(; (i<35) || (str_in[i] == '\0'); i++, j++) {
		str_out[i] = str_in[j];
	}
}

// Assembly:
leal -0x2(%rsi), %r8d
xorl %ecx, %ecx
movl $0x0, %eax
cmpl $0x3f, %r8d
ja 0x4d19
shrl %esi
movl %esi, %eax
xorl %ecx, %ecx
movb (%rdi,%rcx), %r8b
movb %r8b, (%rdx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x4cf1
leal 0x1(%rsi), %ecx
movb $0xa, (%rdx,%rsi)
movl %esi, %eax
jmp 0x4d19
movl %eax, %ecx
movb (%rdi,%rcx), %cl
movb %cl, (%rdx,%rsi)
leal 0x1(%rsi), %ecx
incl %eax
movl %ecx, %esi
cmpl $0x23, %ecx
jb 0x4d0c
cmpb $0x0, (%rdi,%rsi)
je 0x4d0c
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/ps2_iconsys.cpp
// Function: IconSys::SetToDefault()
void IconSys::SetToDefault() {
	File.ps2d_string[0] = 'P';  File.ps2d_string[1] = 'S';  
	File.ps2d_string[2] = '2';  File.ps2d_string[3] = 'D';
	File.reserve1 = 0;
	File.offset_2nd_line = 32;
	File.reserve2 = 0;
	File.bg_opacity = 0;
	File.bg_color_upperleft[0]  = 0x80;  File.bg_color_upperleft[1]  = 0x80;
	File.bg_color_upperleft[2]  = 0x80;  File.bg_color_upperleft[3]  = 0x00;
	File.bg_color_upperright[0] = 0x80;  File.bg_color_upperright[1] = 0x80;
	File.bg_color_upperright[2] = 0x80;  File.bg_color_upperright[3] = 0x00;
	File.bg_color_lowerleft[0]  = 0x80;  File.bg_color_lowerleft[1]  = 0x80;
	File.bg_color_lowerleft[2]  = 0x80;  File.bg_color_lowerleft[3]  = 0x00;
	File.bg_color_lowerright[0] = 0x80;  File.bg_color_lowerright[1] = 0x80;
	File.bg_color_lowerright[2] = 0x80;  File.bg_color_lowerright[3] = 0x00;
	File.light1_direction[0] =  0.5f;  File.light1_direction[1] =  0.5f;
	File.light1_direction[2] =  0.5f;  File.light1_direction[3] =  0.0f;
	File.light2_direction[0] =  0.0f;  File.light2_direction[1] = -0.4f;
	File.light2_direction[2] = -0.1f;  File.light2_direction[3] =  0.0f;
	File.light3_direction[0] = -0.5f;  File.light3_direction[1] = -0.5f;
	File.light3_direction[2] =  0.5f;  File.light3_direction[3] =  0.0f;
	File.light1_color[0] = 1.0f;  File.light1_color[1] = 1.0f;
	File.light1_color[2] = 1.0f;  File.light1_color[3] = 0.0f;
	File.light2_color[0] = 1.0f;  File.light2_color[1] = 1.0f;
	File.light2_color[2] = 1.0f;  File.light2_color[3] = 0.0f;
	File.light3_color[0] = 1.0f;  File.light3_color[1] = 1.0f;
	File.light3_color[2] = 1.0f;  File.light3_color[3] = 0.0f;
	File.light_ambient_color[0] = 1.0f;  File.light_ambient_color[1] = 1.0f;
	File.light_ambient_color[2] = 1.0f;  File.light_ambient_color[3] = 0.0f;
	SetTitle("DEFAULT");
	SetIconFilename("ICON.ICN");
	SetIconCopyFilename("ICON.ICN");
	SetIconDeleteFilename("ICON.ICN");
	memset(File.reserve3, 0, 512); 
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x20000044325350, %rax # imm = 0x20000044325350
movq %rax, (%rdi)
movaps 0x5467(%rip), %xmm0     # 0xa1b0
movups %xmm0, 0x8(%rdi)
movaps 0x546c(%rip), %xmm0     # 0xa1c0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq $0x80, 0x48(%rdi)
movaps 0x5461(%rip), %xmm0     # 0xa1d0
movups %xmm0, 0x50(%rdi)
movaps 0x5466(%rip), %xmm0     # 0xa1e0
movups %xmm0, 0x60(%rdi)
movaps 0x546b(%rip), %xmm0     # 0xa1f0
movups %xmm0, 0x70(%rdi)
movaps 0x5470(%rip), %xmm0     # 0xa200
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0xa0(%rdi)
movups %xmm0, 0xb0(%rdi)
leaq 0x5497(%rip), %rsi      # 0xa24a
callq 0x4f2c
leaq 0x5493(%rip), %r14      # 0xa252
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4fb6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x502e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x50a6
addq $0x1c4, %rbx            # imm = 0x1C4
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/ps2_iconsys.cpp
// Function: IconSys::IconSys(char const*)
IconSys::IconSys(const char* fname)
{
	std::ifstream fin(fname, std::ios_base::in | std::ios_base::binary);
	if(fin.fail()) { throw( Ghulbus::gbException(Ghulbus::gbException::GB_FAILED,
	                                             "Could not open icon file for read") ); }

	fin.read( reinterpret_cast<char*>(&File), sizeof(File) );
	if(fin.fail()) {
		fin.close();
		throw( Ghulbus::gbException(Ghulbus::gbException::GB_FAILED,
			                        "File read error") ); 
	}
	fin.close();

	/*if(!CheckValidity(File)) { 
		throw( Ghulbus::gbException(Ghulbus::gbException::GB_FAILED,
			                        "File seems to be corrupted") ); 
	}*/

	DecodeTitle(File.title, decoded_title);
	GetTitleString(decoded_title, File.offset_2nd_line, title_str);
	strcpy(title_str_single_line, title_str);
	char* tmp = strchr(title_str_single_line, '\n');
	if(tmp) { *tmp = ' '; }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0xc, %edx
callq 0x2370
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x4ec7
leaq 0x8(%rsp), %rdi
movl $0x3c4, %edx            # imm = 0x3C4
movq %rbx, %rsi
callq 0x2240
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x4ed0
leaq 0x8(%rsp), %rdi
callq 0x2050
leaq 0xc0(%rbx), %rdi
leaq 0x3c4(%rbx), %r14
movq %r14, %rsi
callq 0x4a90
movzwl 0x6(%rbx), %esi
leaq 0x3e6(%rbx), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x4cda
addq $0x409, %rbx            # imm = 0x409
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2180
movq %rbx, %rdi
movl $0xa, %esi
callq 0x20a0
testq %rax, %rax
je 0x4eb0
movb $0x20, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x2060
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
leaq 0x534a(%rip), %rbx      # 0xa218
jmp 0x4ee1
leaq 0x8(%rsp), %rdi
callq 0x2050
leaq 0x5359(%rip), %rbx      # 0xa23a
movl $0x18, %edi
callq 0x20e0
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x8330
leaq 0x9e8b(%rip), %rsi      # 0xed90
leaq 0x3450(%rip), %rdx      # 0x835c
movq %r14, %rdi
callq 0x2320
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/ps2_iconsys.cpp
// Function: IconSys::SetTitle(char const*)
void IconSys::SetTitle(char const* str) {
	size_t len = strlen(str);
	if(len > 32) {
		throw( Ghulbus::gbException( Ghulbus::gbException::GB_ILLEGALPARAMETER,
			                         "Title string exceeds character limit" ) );
	}
	//write ASCII string:
	memcpy(decoded_title, str, len+1);
	//write S-JIS string:
	EncodeTitle(decoded_title, File.title);
	//update linebreaks (remember the / 2 since File is referring to SJIS):
	SetLinebreak(File.offset_2nd_line / 2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20c0
cmpq $0x21, %rax
jae 0x4f7f
leaq 0x3c4(%rbx), %r15
incq %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2140
leaq 0xc0(%rbx), %rsi
movq %r15, %rdi
callq 0x4b58
movzwl 0x6(%rbx), %esi
shrl %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5126
movl $0x18, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x52c8(%rip), %rdx      # 0xa25b
movq %rax, %rdi
movl $0x3, %esi
callq 0x8330
leaq 0x9de9(%rip), %rsi      # 0xed90
leaq 0x33ae(%rip), %rdx      # 0x835c
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/ps2_iconsys.cpp
// Function: IconSys::SetIconFilename(char const*)
void IconSys::SetIconFilename(char const* fname) {
	if(strlen(fname) > 32) {
		throw( Ghulbus::gbException( Ghulbus::gbException::GB_ILLEGALPARAMETER ) );
	}
	for(size_t i=0; i<64; i++) {
		if(i < strlen(fname)) {
			File.icon_file[i] = fname[i];
		} else {
			File.icon_file[i] = 0;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20c0
cmpq $0x20, %rax
ja 0x4ffe
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x20c0
cmpq %rax, %r15
jae 0x4fe5
movb (%rbx,%r15), %al
jmp 0x4fe7
xorl %eax, %eax
movb %al, 0x104(%r14,%r15)
incq %r15
cmpq $0x40, %r15
jne 0x4fd2
popq %rbx
popq %r14
popq %r15
retq
movl $0x18, %edi
callq 0x20e0
movq %rax, %rbx
movq %rax, %rdi
movl $0x3, %esi
callq 0x831a
leaq 0x9d71(%rip), %rsi      # 0xed90
leaq 0x3336(%rip), %rdx      # 0x835c
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/ps2_iconsys.cpp
// Function: IconSys::SetIconCopyFilename(char const*)
void IconSys::SetIconCopyFilename(char const* fname) {
	if(strlen(fname) > 32) {
		throw( Ghulbus::gbException( Ghulbus::gbException::GB_ILLEGALPARAMETER ) );
	}
	for(size_t i=0; i<64; i++) {
		if(i < strlen(fname)) {
			File.icon_copy_file[i] = fname[i];
		} else {
			File.icon_copy_file[i] = 0;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20c0
cmpq $0x20, %rax
ja 0x5076
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x20c0
cmpq %rax, %r15
jae 0x505d
movb (%rbx,%r15), %al
jmp 0x505f
xorl %eax, %eax
movb %al, 0x144(%r14,%r15)
incq %r15
cmpq $0x40, %r15
jne 0x504a
popq %rbx
popq %r14
popq %r15
retq
movl $0x18, %edi
callq 0x20e0
movq %rax, %rbx
movq %rax, %rdi
movl $0x3, %esi
callq 0x831a
leaq 0x9cf9(%rip), %rsi      # 0xed90
leaq 0x32be(%rip), %rdx      # 0x835c
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/ps2_iconsys.cpp
// Function: IconSys::SetIconDeleteFilename(char const*)
void IconSys::SetIconDeleteFilename(char const* fname) {
	if(strlen(fname) > 32) {
		throw( Ghulbus::gbException( Ghulbus::gbException::GB_ILLEGALPARAMETER ) );
	}
	for(size_t i=0; i<64; i++) {
		if(i < strlen(fname)) {
			File.icon_delete_file[i] = fname[i];
		} else {
			File.icon_delete_file[i] = 0;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20c0
cmpq $0x20, %rax
ja 0x50ee
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x20c0
cmpq %rax, %r15
jae 0x50d5
movb (%rbx,%r15), %al
jmp 0x50d7
xorl %eax, %eax
movb %al, 0x184(%r14,%r15)
incq %r15
cmpq $0x40, %r15
jne 0x50c2
popq %rbx
popq %r14
popq %r15
retq
movl $0x18, %edi
callq 0x20e0
movq %rax, %rbx
movq %rax, %rdi
movl $0x3, %esi
callq 0x831a
leaq 0x9c81(%rip), %rsi      # 0xed90
leaq 0x3246(%rip), %rdx      # 0x835c
movq %rbx, %rdi
callq 0x2320