LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc0(%rsp), %rbp
movq %rcx, (%rbp)
leaq 0x4(%rsi), %r13
leaq 0x4(%rdx), %rbx
movl 0x4(%rdx), %edi
movq %rbp, 0x50(%rsp)
movq %r15, 0x58(%rsp)
movq %r13, 0x60(%rsp)
movq %rsi, 0x68(%rsp)
movups 0x50(%rsp), %xmm0
movups 0x60(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x911e
movl (%r12), %edi
movq %rbp, 0x30(%rsp)
movq %r15, 0x38(%rsp)
movq %r13, 0x40(%rsp)
movq %r14, 0x48(%rsp)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r13, %rsi
movq %rbx, %rdx
callq 0x9166
movl 0x4(%r12), %edi
movq %rbp, 0x98(%rsp)
movq %r15, 0xa0(%rsp)
movq %r13, 0xa8(%rsp)
movq %r14, 0xb0(%rsp)
movq %r12, 0xb8(%rsp)
movq %r12, 0x20(%rsp)
movups 0x98(%rsp), %xmm0
movups 0xa8(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r12, %rsi
callq 0x91ae
movl (%r12), %edi
movq %rbp, 0x70(%rsp)
movq %r15, 0x78(%rsp)
movq %r13, 0x80(%rsp)
movq %rbx, 0x88(%rsp)
movq %r14, 0x90(%rsp)
movq %r14, 0x20(%rsp)
movups 0x70(%rsp), %xmm0
movups 0x80(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rsi
callq 0x91f1
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kmyk[P]procon26/procon26.cpp
// Function: void shrink_cell_helper<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))::'lambda'(int), 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))::'lambda'()>(int, int, 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))::'lambda'())
void shrink_cell_helper(int n, F pred, G update) {
    while (true) {
        repeat (i,n) {
            if (pred(i)) return; // if something found, exit
        }
        update(); // shrink
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x30(%rsp), %r15
xorl %r12d, %r12d
testl %edi, %edi
cmovlel %r12d, %ebp
cmpl %ebp, %r12d
jne 0x914b
incl (%r14)
decl (%rbx)
xorl %r12d, %r12d
jmp 0x913c
movq %r15, %rdi
movl %r12d, %esi
callq 0x9234
incl %r12d
testb %al, %al
je 0x913c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x20, %r12
je 0x9b05
xorl %r13d, %r13d
cmpq $0x20, %r13
je 0x9afc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21d0
cmpb $0x30, 0xf(%rsp)
setne (%r14,%r13)
incq %r13
jmp 0x9adc
incq %r12
addq $0x20, %r14
jmp 0x9ad3
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x8, %r12
je 0x9b63
xorl %r13d, %r13d
cmpq $0x8, %r13
je 0x9b5a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21d0
cmpb $0x30, 0xf(%rsp)
setne (%r14,%r13)
incq %r13
jmp 0x9b3a
incq %r12
addq $0x8, %r14
jmp 0x9b31
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9ab8
leaq 0x4(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20c0
movl (%r15), %esi
leal -0x1(%rsi), %eax
cmpl $0x100, %eax            # imm = 0x100
jae 0x9be9
addq $0x400, %r14            # imm = 0x400
movq %r14, %rdi
callq 0x9e4e
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x4(%rsp), %rax
cmpq %rax, %r12
jge 0x9bda
movq (%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x9b16
incq %r12
addq $0x40, %r15
jmp 0x9bb9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x17b1(%rip), %rdi      # 0xb3a1
leaq 0x17be(%rip), %rsi      # 0xb3b5
leaq 0x17c2(%rip), %rcx      # 0xb3c0
pushq $0x19
popq %rdx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7f62(%rip), %r14      # 0x11ff0
leaq 0x138b(%rip), %rsi      # 0xb420
movq %r14, %rdi
callq 0x2140
movq %rax, %rdi
movl %ebx, %esi
callq 0x2260
leaq 0x137e(%rip), %rsi      # 0xb42c
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
movq 0x7f03(%rip), %rdi      # 0x11fc8
leaq 0x80a4(%rip), %rsi      # 0x12170
callq 0x9d14
leaq 0x13c9(%rip), %rsi      # 0xb4a1
movq %r14, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
movl 0x806a(%rip), %esi      # 0x12158
movq %r14, %rdi
callq 0x2260
leaq 0x127c(%rip), %rsi      # 0xb379
movq %rax, %rdi
callq 0x2140
movl 0x8051(%rip), %esi      # 0x1215c
movq %rax, %rdi
callq 0x2260
movq %rax, %rdi
callq 0x2090
movl %ebx, %edi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/kuszmaul[P]6886/lock-overhead.cc
// Function: main
int main(int argc, char *argv[] __attribute__((unused))) {
  assert(argc == 1);
  timeit(global_list,    "global list");
  timeit(per_schedcpu,   "per cpu (\\mintinline{c}{sched\\_cpu()} every time)");
  char name[99];
  snprintf(name, sizeof(name), "per cpu (cache getcpu, refresh every %d", cpu_cache_recheck_freq);
  timeit(per_cachedcpu,  name); 
  timeit(per_thread,     "per thread");
  timeit(in_stack,       "local in stack");
  return 0;
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
cmpl $0x1, %edi
jne 0x1273
leaq 0x170(%rip), %rdi       # 0x136d
leaq 0xe4e(%rip), %rsi       # 0x2052
callq 0x1290
leaq 0x182(%rip), %rdi       # 0x1392
leaq 0xe47(%rip), %rsi       # 0x205e
callq 0x1290
leaq 0xe6d(%rip), %rdx       # 0x2090
movq %rsp, %rbx
pushq $0x63
popq %rsi
pushq $0x20
popq %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10c0
leaq 0x188(%rip), %rdi       # 0x13c5
movq %rbx, %rsi
callq 0x1290
leaq 0x1b4(%rip), %rdi       # 0x1400
leaq 0xe65(%rip), %rsi       # 0x20b8
callq 0x1290
leaq 0x1b6(%rip), %rdi       # 0x1415
leaq 0xe5d(%rip), %rsi       # 0x20c3
callq 0x1290
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
retq
leaq 0xda6(%rip), %rdi       # 0x2020
leaq 0xda9(%rip), %rsi       # 0x202a
leaq 0xdb3(%rip), %rcx       # 0x203b
pushq $0x7c
popq %rdx
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/kuszmaul[P]6886/lock-overhead.cc
// Function: timeit(void (*)(), char const*)
static void timeit(void(*f)(), const char *name) {
  struct timespec start,end;
  clock_gettime(CLOCK_MONOTONIC, &start);
  std::thread a(f);
  std::thread b(f);
  a.join();
  b.join();
  clock_gettime(CLOCK_MONOTONIC, &end);
  printf("%55s & %8.1fns \\\\\n", name, (tdiff(start, end)/N_iterations) * 1e9);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %r14
movq %rdi, (%r14)
pushq $0x1
popq %rdi
leaq 0x10(%rsp), %rsi
callq 0x1080
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1454
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1454
leaq 0x8(%rsp), %rdi
callq 0x10d0
movq %rsp, %rdi
callq 0x10d0
pushq $0x1
popq %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x1080
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq 0x10(%rsp), %rax
cvtsi2sd %rax, %xmm1
subq 0x18(%rsp), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0xcfc(%rip), %xmm0      # 0x2008
addsd %xmm1, %xmm0
divsd 0xcf8(%rip), %xmm0      # 0x2010
mulsd 0xcf8(%rip), %xmm0      # 0x2018
leaq 0xdab(%rip), %rdi       # 0x20d2
movq %rbx, %rsi
movb $0x1, %al
callq 0x1030
movq %rsp, %rdi
callq 0x14bc
leaq 0x8(%rsp), %rdi
callq 0x14bc
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x135b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x14bc
leaq 0x8(%rsp), %rdi
callq 0x14bc
movq %rbx, %rdi
callq 0x10e0
// File: /workspace/github_cpp_makefile_star2_O2/kuszmaul[P]6886/lock-overhead.cc
// Function: atomic_do(datastruct*)
static void atomic_do(datastruct *l) {
  while (__sync_lock_test_and_set(&l->lock, 1)) {
    _mm_pause();
  }
  l->value++;
  __sync_lock_release(&l->lock);
}

// Assembly:
pushq $0x1
popq %rax
movl %eax, %ecx
xchgl %ecx, 0x4(%rdi)
testl %ecx, %ecx
je 0x1449
pause
jmp 0x143c
incl (%rdi)
movl $0x0, 0x4(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4338
movl %eax, %ebx
movw $0x1, %r13w
xorl %ebp, %ebp
cmpw 0x2c(%r15), %r13w
ja 0x386e
movq (%r15), %rdi
movzwl %r14w, %esi
callq 0x4502
addl %eax, %ebp
incl %r13d
incl %r14d
jmp 0x3851
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_O2/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 %rbx
subq $0x188, %rsp            # imm = 0x188
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3888
cmpw %bp, %ax
jbe 0x39b0
addq $0x8, %r15
leaq 0x8(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2260
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
xorl %r15d, %r15d
cmpw %bp, %r15w
ja 0x39c6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2030
incl %r15d
jmp 0x399a
leaq 0x381c(%rip), %rsi      # 0x71d3
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x308a
jmp 0x39d8
movq %rbx, %rsi
callq 0x3a08
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39eb
movq %rax, %r14
movq %rbx, %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %rsi
addq %r14, %rsi
movq 0x7583(%rip), %r15      # 0xafa8
movq %r14, %rdi
movq %r15, %rdx
callq 0x3df9
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2040
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
callq 0x3db4
movq (%r14), %rsi
movq (%rbx), %rdx
addq 0x8(%rbx), %rdx
movq %rbx, %rdi
callq 0x2040
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5732
movq %r15, %rdi
callq 0x368e
movq (%r12), %r13
movq 0x8(%r12), %rbp
leaq 0x8(%rsp), %r12
cmpq %rbp, %r13
je 0x4122
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x591c
movq %r14, %rdi
movq %r15, %rsi
callq 0x53f4
movq %r12, %rdi
callq 0x370a
addq $0x18, %r13
jmp 0x40f6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x370a
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 0x427a
cmpw %bp, %ax
jb 0x41c1
movq 0x60(%r14), %rbx
movq 0x68(%r14), %r12
movl (%r15), %eax
shlq $0x20, %rax
movzwl %bp, %ecx
orq %rax, %rcx
leaq 0x4(%rsp), %r14
movq %rcx, -0x4(%r14)
cmpq %r12, %rbx
je 0x41b4
movq %rbx, %rdi
callq 0x5a18
cmpw (%rsp), %ax
jbe 0x41ae
movq %rbx, %rdi
callq 0x59dc
movzwl (%rsp), %ecx
imulq $0x30, %rcx, %rdi
addq (%rax), %rdi
movq %r14, %rsi
callq 0x3816
addq $0x20, %rbx
jmp 0x4180
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x427a
movzwl %ax, %esi
leaq 0x20(%rsp), %rdi
callq 0x4ea9
leaq 0x2fd8(%rip), %rsi      # 0x71c0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x4e85
leaq 0x2fd6(%rip), %rdx      # 0x71d4
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x4e66
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2210
xorl %ebp, %ebp
movq 0x6dae(%rip), %rsi      # 0xafd0
movq 0x6d9f(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2270
movq %rax, %r14
movq %rsp, %rdi
callq 0x20a0
jmp 0x4244
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rdi
callq 0x20a0
jmp 0x4256
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x20a0
testb %bpl, %bpl
jne 0x426a
jmp 0x4272
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 0x464a
movq (%r14), %rbx
movq 0x8(%r14), %r14
xorl %ebp, %ebp
cmpq %r14, %rbx
je 0x42bd
movq %rbx, %rdi
callq 0x5a18
cmpw %bp, %ax
jbe 0x42b7
movq %rbx, %rdi
callq 0x5a18
movl %eax, %ebp
addq $0x20, %rbx
jmp 0x429b
leaq 0x8(%rsp), %rdi
callq 0x368e
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x368e
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/Phidelux[P]terminal-table/src/table.cpp
// Function: bornageek::utils::termtab::Table::column(unsigned short) const
const std::vector<Cell> Table::column(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::vector<Cell> column(this->mRows.size());

        std::transform(this->mRows.begin(), this->mRows.end(), column.begin(),
          [n](Row row){ return row.cells()[n]; });

        return column;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x427a
cmpw %bx, %ax
jb 0x4425
movq 0x68(%r12), %rsi
subq 0x60(%r12), %rsi
sarq $0x5, %rsi
leaq 0x28(%rsp), %r14
movq %r13, %rdi
movq %r14, %rdx
callq 0x4f02
movq 0x60(%r12), %r15
movq 0x68(%r12), %r12
movq %r13, (%rsp)
movq (%r13), %r13
movzwl %bx, %eax
leaq 0x8(%rsp), %rbx
imulq $0x30, %rax, %rbp
cmpq %r12, %r15
je 0x4412
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f54
movq %rbx, %rdi
callq 0x59dc
movq (%rax), %rsi
addq %rbp, %rsi
movq %r14, %rdi
callq 0x52d8
movq %r13, %rdi
movq %r14, %rsi
callq 0x566a
leaq 0x30(%rsp), %rdi
callq 0x20a0
leaq 0x10(%rsp), %rdi
callq 0x370a
addq $0x20, %r15
addq $0x30, %r13
jmp 0x43c3
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %rbx
movq %r12, %rdi
callq 0x427a
movzwl %ax, %esi
leaq 0x58(%rsp), %rdi
callq 0x4ea9
leaq 0x2d74(%rip), %rsi      # 0x71c0
leaq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x4e85
leaq 0x2d72(%rip), %rdx      # 0x71d4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4e66
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x2210
xorl %ebp, %ebp
movq 0x6b46(%rip), %rsi      # 0xafd0
movq 0x6b37(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2270
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0x44ae
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0x44c0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rdi
callq 0x20a0
testb %bpl, %bpl
jne 0x44d4
jmp 0x44f9
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
jmp 0x44f9
movq %rax, %r14
jmp 0x44f0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x370a
movq (%rsp), %rdi
callq 0x370a
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x427a
cmpw %bx, %ax
jb 0x4584
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x464a
movq (%r15), %r14
movq 0x8(%r15), %r12
xorl %ebp, %ebp
movzwl %bx, %r15d
cmpq %r12, %r14
je 0x456d
movq %r14, %rdi
callq 0x5a18
cmpw %bx, %ax
jbe 0x4567
movq %r14, %rdi
movl %r15d, %esi
callq 0x5a2a
cmpw %bp, %ax
jbe 0x4567
movq %r14, %rdi
movl %r15d, %esi
callq 0x5a2a
movl %eax, %ebp
addq $0x20, %r14
jmp 0x4538
movq %rsp, %rdi
callq 0x368e
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x427a
movzwl %ax, %esi
leaq 0x20(%rsp), %rdi
callq 0x4ea9
leaq 0x2c15(%rip), %rsi      # 0x71c0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x4e85
leaq 0x2c13(%rip), %rdx      # 0x71d4
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x4e66
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2210
xorl %ebp, %ebp
movq 0x69eb(%rip), %rsi      # 0xafd0
movq 0x69dc(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2270
movq %rax, %r14
movq %rsp, %rdi
callq 0x20a0
jmp 0x4607
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rdi
callq 0x20a0
jmp 0x4619
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x20a0
testb %bpl, %bpl
jne 0x462d
jmp 0x4642
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
jmp 0x4642
movq %rax, %r14
movq %rsp, %rdi
callq 0x368e
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x60, %rsi
callq 0x4fc6
addq $0x40, %r14
movq %r14, %rdi
callq 0x5a18
testw %ax, %ax
je 0x4699
movq (%rbx), %r15
movq %rsp, %rdi
movq %r14, %rsi
callq 0x4f54
movq %rsp, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x501a
leaq 0x8(%rsp), %rdi
callq 0x370a
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x370a
jmp 0x46ba
jmp 0x46b7
movq %rax, %r14
movq %rbx, %rdi
callq 0x368e
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x60, %rsp
movl %esi, %ecx
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rcx, %rdx
jbe 0x4781
shll $0x5, %ecx
addq %rcx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %rbx
movq 0x68(%r14), %rsi
subq 0x60(%r14), %rsi
sarq $0x5, %rsi
movq %rsp, %rdi
callq 0x4f84
leaq 0x2a16(%rip), %rsi      # 0x71c0
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x4e85
leaq 0x2a20(%rip), %rdx      # 0x71de
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4e66
movb $0x1, %bpl
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x2210
xorl %ebp, %ebp
movq 0x67ea(%rip), %rsi      # 0xafd0
movq 0x67db(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2270
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x20a0
jmp 0x480a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x20a0
jmp 0x481c
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x20a0
testb %bpl, %bpl
jne 0x482e
jmp 0x4836
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x198, %rsp            # imm = 0x198
movl %r9d, %ebp
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl %ebx, %esi
callq 0x21c0
xorl %ebx, %ebx
movzbl %r13b, %eax
movl %eax, 0x4(%rsp)
movzbl %r12b, %eax
movl %eax, (%rsp)
movsbl %bpl, %ebp
movq %r14, %rdi
callq 0x427a
movzwl %ax, %eax
cmpq %rax, %rbx
jae 0x4915
movzwl %bx, %esi
movq %r14, %rdi
callq 0x4502
movl %eax, %r12d
movq %r14, %rdi
callq 0x24ee
movl %eax, %r13d
movq %r14, %rdi
callq 0x24fc
addl %r13d, %eax
addl %r12d, %eax
movzwl %ax, %r12d
subq $0x1, %r12
jb 0x48ef
movq %r15, %rdi
movl %ebp, %esi
callq 0x21c0
jmp 0x48dd
movq %r14, %rdi
callq 0x427a
incq %rbx
movzwl %ax, %eax
cmpq %rax, %rbx
movl (%rsp), %eax
cmovbl 0x4(%rsp), %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0x21c0
jmp 0x48a2
movq %r15, %rdi
callq 0x20c0
leaq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x2240
leaq 0x10(%rsp), %rdi
callq 0x2130
movq 0x8(%rsp), %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4953
jmp 0x4953
jmp 0x4953
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2130
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movq %rsp, %rdi
pushq $0x8
popq %rdx
callq 0x2340
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x2608
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x265c
movq %rsp, %rdi
callq 0x2060
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
pushq $0x18
popq %rdi
callq 0x20e0
movq %rax, %r14
leaq 0x6a06(%rip), %rdx      # 0x9020
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x7628
leaq 0xc76c(%rip), %rsi      # 0xed98
leaq 0x5021(%rip), %rdx      # 0x7654
movq %r14, %rdi
callq 0x22f0
movq %rax, %r14
jmp 0x264b
movq %rax, %r14
movq %rsp, %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x3996
movq %r14, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3633
callq 0x2230
andq $0x0, 0x60(%r14)
movq %rbx, %rdi
callq 0x20b0
leaq 0x1(%rax), %rdi
callq 0x2030
movq %rax, 0x60(%r14)
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x30(%rdi), %r15
leaq 0x48(%rdi), %r12
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)
andq $0x0, 0x60(%rdi)
movq 0x60(%rsi), %rsi
callq 0x3616
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3843
leaq 0x18(%r13), %rsi
movq %r14, %rdi
callq 0x3843
leaq 0x30(%r13), %rsi
movq %r15, %rdi
callq 0x3843
addq $0x48, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x387b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r13
movq %r12, %rdi
callq 0x3d12
movq %r15, %rdi
callq 0x3cf4
movq %r14, %rdi
callq 0x3cf4
movq %rbx, %rdi
callq 0x3cf4
movq %r13, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/ticky[P]ps2iconsys/src/ps2_iconsys.cpp
// Function: IconSys::CheckValidity(IconSys::File_t const&)
bool IconSys::CheckValidity(IconSys::File_t const& f)
{
	if( (f.ps2d_string[0] != 'P') ||
		(f.ps2d_string[1] != 'S') ||
		(f.ps2d_string[2] != '2') ||
		(f.ps2d_string[3] != 'D') ||
		/* (f.reserve1 != 0) || */ //this is not necessary, see e.g. system configuration file
		(f.reserve2 != 0) ) { return false; }
	for(int i=0; i<512; i++) {
		if(f.reserve3[i] != 0) { return false; }
	}
	return true;
}

// Assembly:
xorl %eax, %eax
cmpl $0x44325350, (%rdi)     # imm = 0x44325350
jne 0x4134
cmpl $0x0, 0x8(%rdi)
jne 0x4134
xorl %ecx, %ecx
cmpq $0x200, %rcx            # imm = 0x200
sete %al
je 0x4134
cmpb $0x0, 0x1c4(%rdi,%rcx)
leaq 0x1(%rcx), %rcx
je 0x411a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
leaq 0x5049(%rip), %rcx      # 0x9188
cmpq $0x43, %rax
ja 0x41fa
movzbl (%rdi,%rax), %r8d
movzbl 0x1(%rdi,%rax), %edx
cmpl $0x82, %r8d
je 0x418f
cmpl $0x81, %r8d
je 0x4177
testl %r8d, %r8d
jne 0x4172
testl %edx, %edx
je 0x41f7
movb $0x3f, (%rsi)
jmp 0x41eb
leal -0x69(%rdx), %r8d
cmpl $0x7, %r8d
ja 0x41af
movslq (%rcx,%r8,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movb $0x28, (%rsi)
jmp 0x41eb
leal -0x4f(%rdx), %r8d
cmpb $0x2b, %r8b
ja 0x419e
addb $-0x1f, %dl
jmp 0x41ab
leal 0x7f(%rdx), %r8d
cmpb $0x1a, %r8b
ja 0x41c0
addb $-0x20, %dl
movb %dl, (%rsi)
jmp 0x41eb
cmpl $0x5e, %edx
je 0x41e8
cmpl $0x46, %edx
je 0x41e3
cmpl $0x40, %edx
je 0x41c5
jmp 0x4172
cmpl $0x3f, %edx
jne 0x4172
movb $0x20, (%rsi)
jmp 0x41eb
movb $0x7b, (%rsi)
jmp 0x41eb
movb $0x5d, (%rsi)
jmp 0x41eb
movb $0x5b, (%rsi)
jmp 0x41eb
movb $0x29, (%rsi)
jmp 0x41eb
movb $0x7d, (%rsi)
jmp 0x41eb
movb $0x3a, (%rsi)
jmp 0x41eb
movb $0x2f, (%rsi)
addq $0x2, %rax
incq %rsi
jmp 0x413f
movb $0x0, (%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x438d
shrl %esi
xorl %eax, %eax
cmpq %rax, %rsi
je 0x4375
movb (%rdi,%rax), %cl
movb %cl, (%rdx,%rax)
incq %rax
jmp 0x4365
leal 0x1(%rsi), %ecx
movb $0xa, (%rdx,%rsi)
movl %esi, %eax
jmp 0x438d
movl %eax, %ecx
movb (%rdi,%rcx), %cl
movb %cl, (%rdx,%rsi)
leal 0x1(%rsi), %ecx
incl %eax
movl %ecx, %esi
cmpl $0x23, %ecx
jb 0x4380
cmpb $0x0, (%rdi,%rsi)
je 0x4380
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4df3(%rip), %xmm0     # 0x91b0
movups %xmm0, 0x8(%rdi)
movaps 0x4df8(%rip), %xmm0     # 0x91c0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq $0x80, 0x48(%rdi)
movaps 0x4ded(%rip), %xmm0     # 0x91d0
movups %xmm0, 0x50(%rdi)
movaps 0x4df2(%rip), %xmm0     # 0x91e0
movups %xmm0, 0x60(%rdi)
movaps 0x4df7(%rip), %xmm0     # 0x91f0
movups %xmm0, 0x70(%rdi)
movaps 0x4dfc(%rip), %xmm0     # 0x9200
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0xa0(%rdi)
movups %xmm0, 0xb0(%rdi)
leaq 0x4e23(%rip), %rsi      # 0x924a
callq 0x4598
leaq 0x4e1f(%rip), %r14      # 0x9252
movq %rbx, %rdi
movq %r14, %rsi
callq 0x461e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4694
movq %rbx, %rdi
movq %r14, %rsi
callq 0x470a
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_O2/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
pushq $0xc
popq %rdx
movq %r14, %rdi
callq 0x2340
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x4537
leaq 0x8(%rsp), %rdi
movl $0x3c4, %edx            # imm = 0x3C4
movq %rbx, %rsi
callq 0x2220
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x4540
leaq 0x8(%rsp), %rdi
callq 0x2050
leaq 0xc0(%rbx), %rdi
leaq 0x3c4(%rbx), %r14
movq %r14, %rsi
callq 0x4136
movzwl 0x6(%rbx), %esi
leaq 0x3e6(%rbx), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x4350
addq $0x409, %rbx            # imm = 0x409
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2170
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x2090
testq %rax, %rax
je 0x4520
movb $0x20, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x2060
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4cda(%rip), %rbx      # 0x9218
jmp 0x4551
leaq 0x8(%rsp), %rdi
callq 0x2050
leaq 0x4ce9(%rip), %rbx      # 0x923a
pushq $0x18
popq %rdi
callq 0x20e0
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x7628
leaq 0xa827(%rip), %rsi      # 0xed98
leaq 0x30dc(%rip), %rdx      # 0x7654
movq %r14, %rdi
callq 0x22f0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20b0
cmpq $0x21, %rax
jae 0x45eb
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 0x41fc
movzwl 0x6(%rbx), %esi
shrl %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4788
pushq $0x18
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x4c5e(%rip), %rdx      # 0x925b
pushq $0x3
popq %rsi
movq %rax, %rdi
callq 0x7628
leaq 0xa789(%rip), %rsi      # 0xed98
leaq 0x303e(%rip), %rdx      # 0x7654
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20b0
cmpq $0x20, %rax
ja 0x4668
xorl %r15d, %r15d
cmpq $0x40, %r15
je 0x4662
movq %rbx, %rdi
callq 0x20b0
cmpq %rax, %r15
jae 0x4653
movb (%rbx,%r15), %al
jmp 0x4655
xorl %eax, %eax
movb %al, 0x104(%r14,%r15)
incq %r15
jmp 0x463a
popq %rbx
popq %r14
popq %r15
retq
pushq $0x18
popq %rdi
callq 0x20e0
movq %rax, %rbx
pushq $0x3
popq %rsi
movq %rax, %rdi
callq 0x7614
leaq 0xa713(%rip), %rsi      # 0xed98
leaq 0x2fc8(%rip), %rdx      # 0x7654
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20b0
cmpq $0x20, %rax
ja 0x46de
xorl %r15d, %r15d
cmpq $0x40, %r15
je 0x46d8
movq %rbx, %rdi
callq 0x20b0
cmpq %rax, %r15
jae 0x46c9
movb (%rbx,%r15), %al
jmp 0x46cb
xorl %eax, %eax
movb %al, 0x144(%r14,%r15)
incq %r15
jmp 0x46b0
popq %rbx
popq %r14
popq %r15
retq
pushq $0x18
popq %rdi
callq 0x20e0
movq %rax, %rbx
pushq $0x3
popq %rsi
movq %rax, %rdi
callq 0x7614
leaq 0xa69d(%rip), %rsi      # 0xed98
leaq 0x2f52(%rip), %rdx      # 0x7654
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20b0
cmpq $0x20, %rax
ja 0x4754
xorl %r15d, %r15d
cmpq $0x40, %r15
je 0x474e
movq %rbx, %rdi
callq 0x20b0
cmpq %rax, %r15
jae 0x473f
movb (%rbx,%r15), %al
jmp 0x4741
xorl %eax, %eax
movb %al, 0x184(%r14,%r15)
incq %r15
jmp 0x4726
popq %rbx
popq %r14
popq %r15
retq
pushq $0x18
popq %rdi
callq 0x20e0
movq %rax, %rbx
pushq $0x3
popq %rsi
movq %rax, %rdi
callq 0x7614
leaq 0xa627(%rip), %rsi      # 0xed98
leaq 0x2edc(%rip), %rdx      # 0x7654
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/ticky[P]ps2iconsys/src/ps2_iconsys.cpp
// Function: IconSys::SetLinebreak(int)
void IconSys::SetLinebreak(int lb) {
	if(lb > 32) {
		throw( Ghulbus::gbException( Ghulbus::gbException::GB_ILLEGALPARAMETER,
									 "Linebreak exceeds character limit" ) );
	}
	File.offset_2nd_line = static_cast<unsigned short>(lb * 2);
	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 %r14
pushq %rbx
pushq %rax
cmpl $0x21, %esi
jge 0x47e0
movq %rdi, %rbx
addl %esi, %esi
movw %si, 0x6(%rdi)
addq $0x3c4, %rdi            # imm = 0x3C4
movzwl %si, %esi
leaq 0x3e6(%rbx), %r14
movq %r14, %rdx
callq 0x4350
addq $0x409, %rbx            # imm = 0x409
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2170
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x2090
testq %rax, %rax
je 0x47d8
movb $0x20, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x18
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x4a8e(%rip), %rdx      # 0x9280
pushq $0x3
popq %rsi
movq %rax, %rdi
callq 0x7628
leaq 0xa594(%rip), %rsi      # 0xed98
leaq 0x2e49(%rip), %rdx      # 0x7654
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ticky[P]ps2iconsys/src/ps2_iconsys.cpp
// Function: IconSys::WriteFile(char const*)
void IconSys::WriteFile(const char * fname) {
	std::ofstream fout(fname, std::ios_base::out | std::ios_base::binary);
	if(fout.fail()) {
		throw( Ghulbus::gbException( Ghulbus::gbException::GB_FAILED,
			                         "Error opening output file for icon.sys") );
	}
	fout.seekp(std::ios::beg);

	//write data:
	fout.write( reinterpret_cast<char*>(&File), sizeof(File) );
	if(fout.fail()) {
		fout.close();
		throw( Ghulbus::gbException( Ghulbus::gbException::GB_FAILED,
			                         "Error writing output file for icon.sys") );
	}
	fout.close();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
pushq $0x14
popq %rdx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x4bee
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21e0
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 0x4bf7
leaq 0x8(%rsp), %rdi
callq 0x2270
leaq 0x8(%rsp), %rdi
callq 0x2290
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
leaq 0x46ad(%rip), %rbx      # 0x92a2
jmp 0x4c08
leaq 0x8(%rsp), %rdi
callq 0x2270
leaq 0x46c1(%rip), %rbx      # 0x92c9
pushq $0x18
popq %rdi
callq 0x20e0
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x7628
leaq 0xa170(%rip), %rsi      # 0xed98
leaq 0x2a25(%rip), %rdx      # 0x7654
movq %r14, %rdi
callq 0x22f0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2290
movq %rbx, %rdi
callq 0x2320