LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Linkerist[P]xs/src/io.cc
// Function: edit_list_file()
void
edit_list_file(void)
{
 string editor = getenv("EDITOR");
 if (editor.empty()) {
  // FIXME: how to detect debian and the /usr/bin/editor rule?
  struct stat buf;
  if (stat("/usr/bin/editor", &buf) == 0)
   editor = "/usr/bin/editor";
  else
   editor = "vi";
 }

 endwin();
 list_to_file();
 if(system((editor + " \"" + get_listfile() + "\"").c_str())){};
 list_from_file();
 refresh();
 init_curses();
 display_list();
}

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
leaq 0x43fc(%rip), %rdi      # 0x9b2d
callq 0x33d0
movq %rsp, %rbx
leaq 0x80(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43c8
cmpq $0x0, 0x8(%rbx)
jne 0x577f
leaq 0x3acf(%rip), %rbx      # 0x9229
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
leaq 0x3ac6(%rip), %rsi      # 0x9239
cmoveq %rbx, %rsi
movq %rsp, %rdi
callq 0x3630
callq 0x3390
callq 0x50f4
leaq 0x3aac(%rip), %rdx      # 0x923c
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x4489
leaq 0x20(%rsp), %rdi
callq 0x3a10
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x4403
leaq 0x3a7b(%rip), %rdx      # 0x923d
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x44c1
movq 0x80(%rsp), %rdi
callq 0x32b0
leaq 0x80(%rsp), %rdi
callq 0x36a8
leaq 0x60(%rsp), %rdi
callq 0x36a8
leaq 0x20(%rsp), %rdi
callq 0x36a8
leaq 0x40(%rsp), %rdi
callq 0x36a8
callq 0x46cc
callq 0x35b0
callq 0x6ad0
callq 0x79a6
movq %rsp, %rdi
callq 0x36a8
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
jmp 0x5874
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x36a8
jmp 0x5848
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x36a8
jmp 0x5857
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x36a8
jmp 0x5866
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x36a8
jmp 0x5877
jmp 0x5874
movq %rax, %rbx
movq %rsp, %rdi
callq 0x36a8
movq %rbx, %rdi
callq 0x35d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Linkerist[P]xs/src/ui.cc
// Function: set_areas()
void
set_areas(void)
{
 getmaxyx(stdscr, terminal_height, terminal_width); // get win-dims
 xmax = terminal_width - 1;
 display_area_ymin = 0;
 display_area_ymax = terminal_height - 3;
 modeliney = terminal_height - 2;
 msg_area_y = terminal_height - 1;
}

// Assembly:
movq 0x7541(%rip), %rax      # 0xdfc0
movq (%rax), %rcx
testq %rcx, %rcx
je 0x6a95
movswl 0x4(%rcx), %eax
incl %eax
movswl 0x6(%rcx), %ecx
incl %ecx
jmp 0x6a9a
pushq $-0x1
popq %rax
movl %eax, %ecx
movl %eax, 0x7ab4(%rip)      # 0xe554
movl %ecx, 0x7aaa(%rip)      # 0xe550
andl $0x0, 0x7ab3(%rip)      # 0xe560
decl %ecx
movl %ecx, 0x7aa3(%rip)      # 0xe558
leal -0x3(%rax), %ecx
movl %ecx, 0x7a9e(%rip)      # 0xe55c
leal -0x2(%rax), %ecx
movl %ecx, 0x7a9d(%rip)      # 0xe564
decl %eax
movl %eax, 0x7a99(%rip)      # 0xe568
retq
// File: /workspace/github_cpp_makefile_star2_O2/Linkerist[P]xs/src/ui.cc
// Function: init_curses()
void
init_curses(void)
{
 initscr();               // init curses screen
 //savetty();             // ??
 nonl();                  // no newline
 cbreak();                // not in cooked mode: char immediately available
 noecho();                // chars are not echoed
 keypad(stdscr, true);    // Arrow keys etc
 leaveok(stdscr, TRUE);   // Don't show the...
 curs_set(0);             // ...cursor
 set_areas();

 curses_running = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x34e0
callq 0x3420
callq 0x3100
callq 0x3380
movq 0x74d1(%rip), %r14      # 0xdfc0
movq (%r14), %rdi
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x3140
movq (%r14), %rdi
movl %ebx, %esi
callq 0x34a0
xorl %edi, %edi
callq 0x3290
callq 0x6a78
movb $0x1, 0x7a57(%rip)      # 0xe570
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Linkerist[P]xs/src/ui.cc
// Function: toggle_mode()
void
toggle_mode(void)
{
 if (mode == LIST) {
  mode = BROWSE;
  list_from_dir(".");
 } else {
  // list was empty at start
  if (listfile_empty) {
   if (!default_list.empty()) {
	// but isn't now
	list_to_file();
	list_from_file();
	mode = LIST;
   } else {
	// ok, we have nothing to show here
	message("No List entry. Staying in BROWSE mode");
	mode = BROWSE;
	list_from_dir(".");
   }
  } else {
   // the "normal" case;
   // disable Needle and reload the list!
   NeedleGiven = false;
   Needle = NULL;
   list_from_file();
   yoffset = 0;
   shorties_offset = 0;
   CurrPosition = 0;
   mode = LIST;
  }
 }
}

// Assembly:
pushq %rbx
leaq 0x7267(%rip), %rbx      # 0xe4d8
cmpl $0x0, (%rbx)
je 0x72e1
leaq 0x7262(%rip), %rax      # 0xe4df
cmpb $0x1, (%rax)
jne 0x729e
leaq 0x71f7(%rip), %rax      # 0xe480
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x72d5
callq 0x50f4
callq 0x46cc
jmp 0x72d0
leaq 0x71fb(%rip), %rax      # 0xe4a0
movb $0x0, (%rax)
leaq 0x71e9(%rip), %rax      # 0xe498
andq $0x0, (%rax)
callq 0x46cc
andl $0x0, 0x72ad(%rip)      # 0xe56c
andl $0x0, 0x72ae(%rip)      # 0xe574
leaq 0x71d7(%rip), %rax      # 0xe4a4
andl $0x0, (%rax)
andl $0x0, (%rbx)
popq %rbx
retq
leaq 0x2b72(%rip), %rdi      # 0x9e4e
callq 0x7931
movl $0x1, (%rbx)
leaq 0x1ec6(%rip), %rdi      # 0x91b4
popq %rbx
jmp 0x4a75
// File: /workspace/github_cpp_makefile_star2_O2/Linkerist[P]xs/src/ui.cc
// Function: swap_two_entries(int)
void
swap_two_entries(int advance_afterwards)
{
 int switch_index;
 if (advance_afterwards >= 0)
  switch_index = CurrPosition + 1;
 else
  switch_index = CurrPosition - 1;

 // ranges check:
 if (switch_index > int(default_list.size()) || switch_index < 0) {
  beep();
  return;
 }

 if (mode == LIST && !NeedleGiven) {
  pair<string, string> tmp = default_list[CurrPosition];
  default_list[CurrPosition] = default_list[switch_index];
  default_list[switch_index] = tmp;
  cur_pos_adjust(advance_afterwards);
  display_list();
 } else
  beep();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq 0x6c39(%rip), %r12      # 0xe4a4
movslq (%r12), %rax
movl %edi, %ebp
sarl $0x1f, %ebp
orl $0x1, %ebp
addl %eax, %ebp
js 0x78ac
leaq 0x6bfe(%rip), %r15      # 0xe480
movq (%r15), %rsi
movq 0x8(%r15), %rcx
subq %rsi, %rcx
shrq $0x6, %rcx
cmpl %ecx, %ebp
jg 0x78ac
leaq 0x6c3d(%rip), %rcx      # 0xe4d8
cmpl $0x0, (%rcx)
jne 0x78ac
leaq 0x6bf9(%rip), %rcx      # 0xe4a0
cmpb $0x0, (%rcx)
je 0x78bd
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3090
movl %edi, %ebx
shlq $0x6, %rax
addq %rax, %rsi
movq %rsp, %rdi
callq 0x7f92
movl %ebp, %r14d
movq (%r15), %rax
shlq $0x6, %r14
leaq (%rax,%r14), %rsi
movslq (%r12), %rdi
shlq $0x6, %rdi
addq %rax, %rdi
callq 0x7fcc
addq (%r15), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x7fcc
pushq $0x1
popq %rsi
movl %ebx, %edi
callq 0x5299
callq 0x79a6
movq %rsp, %rdi
callq 0x460a
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x460a
movq %rbx, %rdi
callq 0x35d0
// File: /workspace/github_cpp_makefile_star2_O2/Linkerist[P]xs/src/ui.cc
// Function: message(char const*)
void
message(const char * msg)
{
 if (curses_running) {
  move(msg_area_y, 0);
  clrtoeol();
  printw("%s [any key to continue]", msg);
  refresh();
  getch();
  move(msg_area_y, 0);
  clrtoeol();
 } else
  printf("%s\n", msg);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x6c31(%rip)      # 0xe570
jne 0x7997
movl 0x6c21(%rip), %edi      # 0xe568
xorl %esi, %esi
callq 0x3240
movq 0x666b(%rip), %r14      # 0xdfc0
movq (%r14), %rdi
callq 0x3360
leaq 0x1f92(%rip), %rdi      # 0x98f6
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3320
callq 0x35b0
movq (%r14), %rdi
callq 0x3130
movl 0x6be7(%rip), %edi      # 0xe568
xorl %esi, %esi
callq 0x3240
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3360
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3530
// File: /workspace/github_cpp_makefile_star2_O2/Linkerist[P]xs/src/ui.cc
// Function: get_desc_from_user[abi:cxx11]()
string
get_desc_from_user(void)
{
 char desc[DESCRIPTION_MAXLENGTH + 1];
 move(msg_area_y, 0);
 clrtoeol();
 printw("Enter description (<ENTER> to quit): ");
 refresh();
 echo();
 getnstr(desc, DESCRIPTION_MAXLENGTH);
 noecho();
 move(msg_area_y, 0);
 clrtoeol();

 return string(desc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x67f1(%rip), %edi      # 0xe568
xorl %esi, %esi
callq 0x3240
movq 0x623b(%rip), %r15      # 0xdfc0
movq (%r15), %rdi
callq 0x3360
leaq 0x1b3c(%rip), %rdi      # 0x98d0
xorl %eax, %eax
callq 0x3320
callq 0x35b0
callq 0x3110
movq (%r15), %rdi
leaq 0x10(%rsp), %r14
pushq $0x12
popq %rdx
movq %r14, %rsi
callq 0x34f0
callq 0x3380
movl 0x67a5(%rip), %edi      # 0xe568
xorl %esi, %esi
callq 0x3240
movq (%r15), %rdi
callq 0x3360
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43c8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Linkerist[P]xs/src/ui.cc
// Function: last_dirname(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string
last_dirname(string path)
{
 if (path.at(path.size() - 1) == '/')
  path = path.substr(0, path.size() - 1);

 string dirname = path.substr(path.find_last_of('/') + 1);

 return dirname;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
decq %rsi
movq %r14, %rdi
callq 0x3640
cmpb $0x2f, (%rax)
jne 0x7e3c
movq 0x8(%r14), %rcx
decq %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3340
movq %r14, %rdi
movq %r15, %rsi
callq 0x33e0
movq %r15, %rdi
callq 0x36a8
pushq $0x2f
popq %rsi
pushq $-0x1
popq %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x3670
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x3340
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Linkerist[P]xs/src/ui.cc
// Function: update_modeline()
void
update_modeline(void)
{
 move(modeliney, 0);
 clrtoeol();
 move(modeliney, 0);
 attron(A_REVERSE);

 string curmode;
 char modechar;

 if (mode == LIST) {
  curmode = "List";
  modechar = 'L';
 } else {
  curmode = "Browse";
  modechar = 'B';
 }

 string cwd = get_cwd_as_string();
 attron(A_BOLD);
 printw("%c: %s ", modechar, cwd.c_str());
 //   printw(" yoff: %d shoff: %d currpos: %d ", yoffset,shorties_offset,CurrPosition);
 attroff(A_BOLD);
 hline(' ', xmax);
 attroff(A_REVERSE);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl 0x66ea(%rip), %edi      # 0xe564
xorl %esi, %esi
callq 0x3240
movq 0x6138(%rip), %r14      # 0xdfc0
movq (%r14), %rdi
callq 0x3360
movl 0x66ce(%rip), %edi      # 0xe564
xorl %esi, %esi
callq 0x3240
movq (%r14), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x3190
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x6614(%rip), %rax      # 0xe4d8
cmpl $0x0, (%rax)
je 0x7ede
leaq 0x1fa9(%rip), %rsi      # 0x9e79
leaq 0x8(%rsp), %rdi
callq 0x3630
pushq $0x42
jmp 0x7ef1
leaq 0x1f8f(%rip), %rsi      # 0x9e74
leaq 0x8(%rsp), %rdi
callq 0x3630
pushq $0x4c
popq %rbx
leaq 0x28(%rsp), %rdi
callq 0x3cc8
movq (%r14), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x3190
movq 0x28(%rsp), %rdx
leaq 0x1f69(%rip), %rdi      # 0x9e80
movl %ebx, %esi
xorl %eax, %eax
callq 0x3320
movq (%r14), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x3400
movq (%r14), %rdi
movl 0x6620(%rip), %edx      # 0xe558
pushq $0x20
popq %rsi
callq 0x32c0
movq (%r14), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x3400
leaq 0x28(%rsp), %rdi
callq 0x36a8
leaq 0x8(%rsp), %rdi
callq 0x36a8
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x7f6d
movq %rax, %rbx
jmp 0x7f7f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x36a8
leaq 0x8(%rsp), %rdi
callq 0x36a8
movq %rbx, %rdi
callq 0x35d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/LoadDB.cc
// Function: Open_DB_Test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Open_DB_Test(string filename) {

    Options opts;
    KVDS *db = KVDS::Open_KVDS(filename.c_str(), opts);

    Iterator* it = db->NewIterator();
    cout << "Iterator the db: First to Last" << endl;
    for(it->SeekToFirst(); it->Valid(); it->Next()) {
        cout << it->Key() << ": " << it->Value() << endl;
    }
    sleep(3);
    cout << "Iterator the db: Last to First" << endl;
    for(it->SeekToLast(); it->Valid(); it->Prev()) {
        cout << it->Key() << ": " << it->Value() << endl;
    }
    delete it;
    delete db;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
leaq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0x14534
movq (%rbx), %rax
pushq $0xa
popq %rcx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x10774
movq %rax, 0x50(%rsp)
movq %rax, %rdi
callq 0x10734
movq %rax, %r14
movq 0x2a562(%rip), %rdi     # 0x30fd0
leaq 0x17591(%rip), %rsi     # 0x1e006
callq 0x6400
movq %rax, %rdi
callq 0x61c0
pushq $0x10
popq %rax
leaq 0x78(%rsp), %r12
leaq 0x17f80(%rip), %r13     # 0x1ea11
leaq 0x58(%rsp), %rbp
pushq $0x28
popq %r15
movq (%r14), %rcx
movq %r14, %rdi
callq *(%rcx,%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
testb %al, %al
je 0x6b0d
movq (%r14), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x38(%rax)
movq 0x2a50d(%rip), %rdi     # 0x30fd0
movq %r12, %rsi
callq 0x63b0
movq %rax, %rdi
movq %r13, %rsi
callq 0x6400
movq %rax, %rbx
movq (%r14), %rax
movq %rbp, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x63b0
movq %rax, %rdi
callq 0x61c0
movq %rbp, %rdi
callq 0x6788
movq %r12, %rdi
callq 0x6788
movq %r15, %rax
jmp 0x6a9a
pushq $0x3
popq %rdi
callq 0x6330
movq 0x2a4b4(%rip), %rdi     # 0x30fd0
leaq 0x17502(%rip), %rsi     # 0x1e025
callq 0x6400
movq %rax, %rdi
callq 0x61c0
pushq $0x18
popq %rax
leaq 0x78(%rsp), %r12
leaq 0x17ed2(%rip), %r13     # 0x1ea11
leaq 0x58(%rsp), %rbp
pushq $0x30
popq %r15
movq (%r14), %rcx
movq %r14, %rdi
callq *(%rcx,%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
testb %al, %al
je 0x6bbb
movq (%r14), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x38(%rax)
movq 0x2a45f(%rip), %rdi     # 0x30fd0
movq %r12, %rsi
callq 0x63b0
movq %rax, %rdi
movq %r13, %rsi
callq 0x6400
movq %rax, %rbx
movq (%r14), %rax
movq %rbp, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x63b0
movq %rax, %rdi
callq 0x61c0
movq %rbp, %rdi
callq 0x6788
movq %r12, %rdi
callq 0x6788
movq %r15, %rax
jmp 0x6b48
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x50(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6be9
jmp 0x6be9
jmp 0x6be9
jmp 0x6bee
movq %rax, %rbx
jmp 0x6bfb
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x6788
leaq 0x78(%rsp), %rdi
callq 0x6788
movq %rbx, %rdi
callq 0x6680
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/LoadDB.cc
// Function: main
int main(int argc, char** argv) {

    string filename = argv[1];

    Open_DB_Test(filename);
    std::cout << "load process success" << std::endl;
    //Open_DB_Test(filename);
    return 0;
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq 0x8(%rsi), %rsi
leaq 0x30(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x6150
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x6530
leaq 0x10(%rsp), %rdi
callq 0x6a1c
leaq 0x10(%rsp), %rdi
callq 0x6788
movq 0x2a380(%rip), %rdi     # 0x30fd0
leaq 0x173ed(%rip), %rsi     # 0x1e044
callq 0x6400
movq %rax, %rdi
callq 0x61c0
leaq 0x30(%rsp), %rdi
callq 0x6788
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6788
jmp 0x6c88
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6788
movq %rbx, %rdi
callq 0x6680
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_options/./acutest.h
// Function: acutest_finish_test_line_
static void
acutest_finish_test_line_(int result)
{
    if(acutest_tap_) {
        const char* str = (result == 0) ? "ok" : "not ok";

        printf("%s %d - %s\n", str, acutest_current_index_ + 1, acutest_current_test_->name);

        if(result == 0  &&  acutest_timer_) {
            printf("# Duration: ");
            acutest_timer_print_diff_();
            printf("\n");
        }
    } else {
        int color = (result == 0) ? ACUTEST_COLOR_GREEN_INTENSIVE_ : ACUTEST_COLOR_RED_INTENSIVE_;
        const char* str = (result == 0) ? "OK" : "FAILED";
        printf("[ ");
        acutest_colored_printf_(color, "%s", str);
        printf(" ]");

        if(result == 0  &&  acutest_timer_) {
            printf("  ");
            acutest_timer_print_diff_();
        }

        printf("\n");
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
cmpb $0x1, 0x7747(%rip)      # 0xa2e0
jne 0x2bed
testl %ebx, %ebx
leaq 0x38a6(%rip), %rax      # 0x644a
leaq 0x389b(%rip), %rsi      # 0x6446
cmoveq %rax, %rsi
movl 0x7753(%rip), %edx      # 0xa308
incl %edx
movq 0x75ca(%rip), %rax      # 0xa188
movq (%rax), %rcx
leaq 0x3885(%rip), %rdi      # 0x644d
xorl %eax, %eax
callq 0x2120
testl %ebx, %ebx
jne 0x2c65
cmpl $0x0, 0x772e(%rip)      # 0xa30c
je 0x2c65
leaq 0x386e(%rip), %rdi      # 0x6459
jmp 0x2c4d
xorl %ebp, %ebp
testl %ebx, %ebx
sete %bpl
leaq 0x386a(%rip), %rax      # 0x6466
leaq 0x3866(%rip), %r14      # 0x6469
cmoveq %rax, %r14
xorl $0x5, %ebp
leaq 0x385f(%rip), %rdi      # 0x6470
xorl %eax, %eax
callq 0x2120
leaq 0x3436(%rip), %rsi      # 0x6055
movl %ebp, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2cc7
leaq 0x3841(%rip), %rdi      # 0x6473
xorl %eax, %eax
callq 0x2120
testl %ebx, %ebx
jne 0x2c59
cmpl $0x0, 0x76c8(%rip)      # 0xa30c
je 0x2c59
leaq 0x3e8b(%rip), %rdi      # 0x6ad8
xorl %eax, %eax
callq 0x2120
callq 0x4cc2
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_options/simple_options_test.c
// Function: split_string
static void split_string(void)
{
	char input[] = " Command arg1 \targ2  arg3 missing ";
	int argc;
	const char *argv[4];
	argc = opt_parse_split_string(input, argv, 4);
	TEST_CHECK(argc == 4);
	TEST_CHECK(strcmp(argv[0], "Command") == 0);
	TEST_CHECK(strcmp(argv[1], "arg1") == 0);
	TEST_CHECK(strcmp(argv[2], "arg2") == 0);
	TEST_CHECK(strcmp(argv[3], "arg3") == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movaps 0x2efa(%rip), %xmm0     # 0x7330
leaq 0x20(%rsp), %rdi
movaps %xmm0, 0x10(%rdi)
movaps 0x2eda(%rip), %xmm0     # 0x7320
movaps %xmm0, (%rdi)
movl $0x20676e, 0x1f(%rdi)   # imm = 0x20676E
movq %rsp, %r15
pushq $0x4
popq %rdx
movq %r15, %rsi
callq 0x2944
xorl %edi, %edi
cmpl $0x4, %eax
sete %dil
leaq 0x2419(%rip), %r14      # 0x6887
leaq 0x1be0(%rip), %rbx      # 0x6055
leaq 0x25b7(%rip), %r8       # 0x6a33
pushq $0x29
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x29b8
movq (%r15), %rdi
leaq 0x25a7(%rip), %rsi      # 0x6a3d
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x259b(%rip), %r8       # 0x6a45
pushq $0x2a
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x29b8
movq 0x8(%r15), %rdi
leaq 0x25a0(%rip), %rsi      # 0x6a65
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x2591(%rip), %r8       # 0x6a6a
pushq $0x2b
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x29b8
movq 0x10(%r15), %rdi
leaq 0x2593(%rip), %rsi      # 0x6a87
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x2584(%rip), %r8       # 0x6a8c
pushq $0x2c
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x29b8
movq 0x18(%r15), %rdi
leaq 0x2586(%rip), %rsi      # 0x6aa9
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x2577(%rip), %r8       # 0x6aae
pushq $0x2d
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x29b8
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_options/simple_options_test.c
// Function: bad_strings
static void bad_strings(void)
{
	int argc;
	const char *argv[4];

	char empty[] = "";
	argc = opt_parse_split_string(empty, argv, 4);
	TEST_CHECK(argc == 0);

	char blank[] = "     ";
	argc = opt_parse_split_string(blank, argv, 4);
	TEST_CHECK(argc == 0);

	char middle[] = "   fnord   ";
	argc = opt_parse_split_string(middle, argv, 4);
	TEST_CHECK(argc == 1);
	TEST_CHECK(strcmp(argv[0], "fnord") == 0);

	char single[] = "single";
	argc = opt_parse_split_string(single, argv, 4);
	TEST_CHECK(argc == 1);
	TEST_CHECK(strcmp(argv[0], "single") == 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0xf(%rsp), %rdi
movb $0x0, (%rdi)
leaq 0x30(%rsp), %r15
pushq $0x4
popq %rbp
movq %r15, %rsi
movl %ebp, %edx
callq 0x2944
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x22ff(%rip), %r14      # 0x6887
leaq 0x1ac6(%rip), %rbx      # 0x6055
leaq 0x2535(%rip), %r12      # 0x6acb
pushq $0x37
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x29b8
leaq 0x10(%rsp), %rdi
movw $0x20, 0x4(%rdi)
movl $0x20202020, (%rdi)     # imm = 0x20202020
movq %r15, %rsi
movl %ebp, %edx
callq 0x2944
xorl %edi, %edi
testl %eax, %eax
sete %dil
pushq $0x3b
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x29b8
movabsq $0x64726f6e66202020, %rax # imm = 0x64726F6E66202020
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
movl $0x202020, 0x8(%rdi)    # imm = 0x202020
movq %r15, %rsi
movl %ebp, %edx
callq 0x2944
xorl %edi, %edi
cmpl $0x1, %eax
sete %dil
leaq 0x24d5(%rip), %r12      # 0x6ae7
pushq $0x3f
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x29b8
movq (%r15), %rdi
leaq 0x222a(%rip), %rsi      # 0x6859
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x24ae(%rip), %r8       # 0x6af1
pushq $0x40
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x29b8
leaq 0x18(%rsp), %rdi
movl $0x656c67, 0x3(%rdi)    # imm = 0x656C67
movl $0x676e6973, (%rdi)     # imm = 0x676E6973
leaq 0x24a3(%rip), %r13      # 0x6b0f
movq %r15, %rsi
movl %ebp, %edx
callq 0x2944
xorl %edi, %edi
cmpl $0x1, %eax
sete %dil
pushq $0x44
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x29b8
movq (%r15), %rdi
movq %r13, %rsi
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x246a(%rip), %r8       # 0x6b16
pushq $0x45
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x29b8
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_options/simple_options_test.c
// Function: required
static void required(void)
{
	struct option_entry entries[] = {
		{"foo", 'f', NULL, OPTION_FLAG_required},
		{NULL},
	};
	const char *args[] = {"program"};
	TEST_CHECK(opt_parse(1, args, entries) < 0);
	const char *new_args[] = {"program", "-f"};
	TEST_CHECK(opt_parse(2, new_args, entries) >= 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
leaq 0x53f0(%rip), %rsi      # 0x9cf0
pushq $0xc
popq %rcx
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x1f35(%rip), %rax      # 0x684a
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
pushq $0x1
popq %rdi
movq %rbx, %rdx
callq 0x253c
shrl $0x1f, %eax
leaq 0x1f55(%rip), %r15      # 0x6887
leaq 0x171c(%rip), %r14      # 0x6055
leaq 0x223a(%rip), %r8       # 0x6b7a
pushq $0x66
popq %rdx
movl %eax, %edi
movq %r15, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x29b8
movaps 0x53f7(%rip), %xmm0     # 0x9d50
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
pushq $0x2
popq %rdi
movq %rbx, %rdx
callq 0x253c
notl %eax
shrl $0x1f, %eax
leaq 0x2225(%rip), %r8       # 0x6b9d
pushq $0x68
popq %rdx
movl %eax, %edi
movq %r15, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x29b8
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_options/simple_options_test.c
// Function: equals_values
static void equals_values(void)
{
	const char *foo = NULL;
	const char *fnord = NULL;
	struct option_entry entries[] = {
		{"foo", 'f', NULL, OPTION_FLAG_string, .string = &foo},
		{"fnord", 'n', NULL, OPTION_FLAG_string, .string = &fnord},
		{NULL},
	};
	const char *args[] = {"program", "-f=wibble", "--fnord=blah"};

	TEST_CHECK(opt_parse(3, args, entries) >= 0);
	TEST_CHECK(strcmp(fnord, "blah") == 0);
	TEST_CHECK(strcmp(foo, "wibble") == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %rsp, %r12
andq $0x0, (%r12)
leaq 0x1fc4(%rip), %rax      # 0x6b76
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
movb $0x66, 0x8(%rdx)
andq $0x0, 0x10(%rdx)
pushq $0x4
popq %rax
movl %eax, 0x18(%rdx)
movq %r15, 0x20(%rdx)
xorl %ecx, %ecx
movb %cl, 0x28(%rdx)
leaq 0x1c80(%rip), %rsi      # 0x6859
movq %rsi, 0x30(%rdx)
movb $0x6e, 0x38(%rdx)
andq $0x0, 0x40(%rdx)
movl %eax, 0x48(%rdx)
movq %r12, 0x50(%rdx)
movb %cl, 0x58(%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rdx)
movaps %xmm0, 0x70(%rdx)
movaps %xmm0, 0x80(%rdx)
movq 0x51d7(%rip), %rax      # 0x9de0
leaq 0x10(%rsp), %rsi
movq %rax, 0x10(%rsi)
movaps 0x51b7(%rip), %xmm0     # 0x9dd0
movaps %xmm0, (%rsi)
pushq $0x3
popq %rdi
callq 0x253c
notl %eax
shrl $0x1f, %eax
leaq 0x1c57(%rip), %r14      # 0x6887
leaq 0x141e(%rip), %rbx      # 0x6055
leaq 0x2045(%rip), %r8       # 0x6c83
movl %eax, %edi
movq %r14, %rsi
movl $0x8f, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x29b8
movq (%r12), %rdi
leaq 0x2021(%rip), %rsi      # 0x6c7e
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x2033(%rip), %r8       # 0x6ca4
movq %r14, %rsi
movl $0x90, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x29b8
movq (%r15), %rdi
leaq 0x1fe2(%rip), %rsi      # 0x6c6f
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x201e(%rip), %r8       # 0x6cbf
movq %r14, %rsi
movl $0x91, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x29b8
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/hinrikHelga[P]Botnet/server.cpp
// Function: listenOtherServer(int)
void listenOtherServer(int socket)
{
    int nread;                                  // Bytes read from socket
    char buffer[1025];                          // Buffer for reading input

    while(true)
    {
       memset(buffer, 0, sizeof(buffer));
       nread = read(socket, buffer, sizeof(buffer));

       if(nread < 0)                      // Server has dropped us
       {
          printf("Over and Out\n");
          exit(0);
       }
       else if(nread > 0)
       {
          printf("%s\n", buffer);
       }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
movl %edi, %ebx
leaq -0x420(%rbp), %r14
movl $0x401, %edx            # imm = 0x401
movq %r14, %rdi
xorl %esi, %esi
callq 0x2130
movl $0x401, %edx            # imm = 0x401
movl %ebx, %edi
movq %r14, %rsi
callq 0x22a0
testl %eax, %eax
js 0x2561
je 0x2533
movq %r14, %rdi
callq 0x22d0
jmp 0x2533
leaq 0x1d1a(%rip), %rdi      # 0x4282
callq 0x22d0
xorl %edi, %edi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/hinrikHelga[P]Botnet/server.cpp
// Function: closeClient(int, fd_set*, int*)
void closeClient(int clientSocket, fd_set *openSockets, int *maxfds)
{
     // Remove client from the connectedServers list
     connectedServers.erase(clientSocket);

     // If this client's socket is maxfds then the next lowest
     // one has to be determined. Socket fd's can be reused by the Kernel,
     // so there aren't any nice ways to do this.

     if(*maxfds == clientSocket)
     {
        for(auto const& p : connectedServers)
        {
            *maxfds = std::max(*maxfds, p.second->sock);
        }
     }

     // And remove from the list of open sockets.

     FD_CLR(clientSocket, openSockets);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
leaq -0x2c(%rbp), %r15
movl %edi, (%r15)
leaq 0x3c4a(%rip), %rdi      # 0x61e0
movq %r15, %rsi
callq 0x31e2
movl (%r14), %r12d
movl (%r15), %r15d
cmpl %r15d, %r12d
jne 0x25d6
movq 0x3c48(%rip), %rax      # 0x61f8
leaq 0x3c31(%rip), %r13      # 0x61e8
cmpq %r13, %rax
je 0x25d6
movq 0x28(%rax), %rcx
movl (%rcx), %ecx
cmpl %ecx, %r12d
cmovlel %ecx, %r12d
movl %r12d, (%r14)
movq %rax, %rdi
callq 0x2150
jmp 0x25b7
pushq $-0x2
popq %rsi
movl %r15d, %ecx
rolq %cl, %rsi
pushq $0x40
popq %rcx
movl %r15d, %eax
cltd
idivl %ecx
cltq
andq %rsi, (%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/hinrikHelga[P]Botnet/server.cpp
// Function: openTcpSocket(int)
int openTcpSocket(int portno)
{
   struct sockaddr_in sk_addr;   // address settings for bind()
   int sock;                     // socket opened for this port
int set = 1;                  // for setsockopt


   // Create socket for connection

   if((sock = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0)) < 0)
   {
      perror("Failed to open TCP socket");
      return(-1);
   }

   if(setNonBlocking(sock) < 0)
   {
      perror("Failed to make non-blocking!");
      exit(1);
   }

   // Turn on SO_REUSEADDR to allow socket to be quickly reused after
   // program exit.

   if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &set, sizeof(set)) < 0)
   {
      perror("Failed to set SO_REUSEADDR:");
   }

   memset(&sk_addr, 0, sizeof(sk_addr));

   sk_addr.sin_family      = AF_INET;
   sk_addr.sin_addr.s_addr = INADDR_ANY;
   sk_addr.sin_port        = htons(portno);

   // Bind to socket to listen for connections from clients

   if(bind(sock, (struct sockaddr *)&sk_addr, sizeof(sk_addr)) < 0)
   {
      perror("Failed to bind to socket:");
      return(-1);
   }

   else
   {
      setNonBlocking(sock);
      return(sock);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edi, %r14d
movl $0x1, -0x14(%rbp)
pushq $0x2
popq %rdi
movl $0x801, %esi            # imm = 0x801
xorl %edx, %edx
callq 0x2080
testl %eax, %eax
js 0x26aa
movl %eax, %ebx
movl %eax, %edi
callq 0x25fd
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
leaq -0x14(%rbp), %rcx
pushq $0x4
popq %r8
movl %ebx, %edi
callq 0x2320
testl %eax, %eax
js 0x26b3
leaq -0x24(%rbp), %rsi
andq $0x0, 0x8(%rsi)
movw $0x2, (%rsi)
andl $0x0, 0x4(%rsi)
rolw $0x8, %r14w
movw %r14w, 0x2(%rsi)
pushq $0x10
popq %rdx
movl %ebx, %edi
callq 0x2060
testl %eax, %eax
js 0x26c1
movl %ebx, %edi
callq 0x25fd
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1953(%rip), %rdi      # 0x4004
jmp 0x26c8
leaq 0x1964(%rip), %rdi      # 0x401e
callq 0x2190
jmp 0x266e
leaq 0x1972(%rip), %rdi      # 0x403a
callq 0x2190
pushq $-0x1
popq %rbx
jmp 0x269f
// File: /workspace/github_cpp_makefile_star2_O2/ruippeixotog[P]algo-lib/kuhn-munkres.cpp
// Function: kuhnAdd(int, int)
void kuhnAdd(int x, int n) {
  s[x] = true;
  for(int y = 0; y < n; y++)
    if(rem[y] != -INF && rem[y] > lx[x] + ly[y] - w[x][y])
      rem[y] = lx[x] + ly[y] - w[x][y], remx[y] = x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movslq %edi, %rax
leaq 0x3d37f4(%rip), %rdx    # 0x3d4940
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
movl $0x1, (%rdx,%rax,4)
shlq $0x2, %rsi
imulq $0xfa0, %rax, %rdx      # imm = 0xFA0
leaq 0x3d4774(%rip), %r8     # 0x3d58e0
leaq 0x3d85ed(%rip), %r9     # 0x3d9760
leaq 0x3d9586(%rip), %r10    # 0x3da700
leaq 0x2ebf(%rip), %r11      # 0x4040
leaq 0x3d56f8(%rip), %rbx    # 0x3d6880
cmpq %rcx, %rsi
je 0x11bb
movl (%rcx,%r8), %ebp
cmpl $0xc4653600, %ebp       # imm = 0xC4653600
je 0x11b5
movl (%rcx,%r10), %r14d
addl (%r9,%rax,4), %r14d
leaq (%rdx,%rcx), %r15
subl (%r11,%r15), %r14d
cmpl %r14d, %ebp
jle 0x11b5
movl %r14d, (%rcx,%r8)
movl %edi, (%rcx,%rbx)
addq $0x4, %rcx
jmp 0x1188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dfrodriguezp[P]PiCM-cpp/./init.h
// Function: bool isInArray<Json::Value>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Json::Value)
bool isInArray(std::string element, T A)
{
    for (Int i = 0; i < A.size(); ++i)
    {
        if (A[i] == element)
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movq %rsp, %r15
movl %eax, %r12d
movq %rbx, %rdi
callq 0x23d0
movl %eax, %ebp
cmpl %eax, %r12d
jae 0x493b
movq %rbx, %rdi
movl %r12d, %esi
callq 0x21f0
movq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x2390
movq %r13, %rdi
movq %r15, %rsi
callq 0x22d0
movl %eax, %r13d
movq %r15, %rdi
callq 0x2100
leal 0x1(%r12), %eax
testb %r13b, %r13b
je 0x48f0
cmpl %ebp, %r12d
setb %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2430
nop
// File: /workspace/github_cpp_makefile_star2_O2/dfrodriguezp[P]PiCM-cpp/functions.cc
// Function: ifft(std::valarray<std::complex<double>>&)
void ifft(CArray &x)
{
    // conjugate the complex numbers
    x = x.apply(std::conj);

    // forward fft
    fft(x);

    // conjugate the complex numbers again
    x = x.apply(std::conj);

    // scale the numbers
    x /= x.size();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, (%r14)
leaq 0x16ac(%rip), %r15      # 0x763c
movq %r15, 0x8(%r14)
movq %r14, %rsi
callq 0x764e
movq %rbx, %rdi
callq 0x5dec
movq %rbx, (%r14)
movq %r15, 0x8(%r14)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x764e
movsd (%rbx), %xmm0
unpcklps 0x34cc(%rip), %xmm0     # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x34d4(%rip), %xmm0     # 0x94a0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd %xmm1, (%r14)
andq $0x0, 0x8(%r14)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x76ac
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dfrodriguezp[P]PiCM-cpp/functions.cc
// Function: valarraysVector(unsigned int const&, unsigned int const&)
VecArr valarraysVector(const Int &rows, const Int &cols)
{
    VecArr f;
    Array zeros(0.0, cols);
    for (Int i = 0; i < rows; ++i)
    {
        f.push_back(zeros);
    }

    return f;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
movl (%rdx), %edx
movq %rsp, %rdi
callq 0x7708
xorl %ebp, %ebp
movq %rsp, %r15
cmpl (%r14), %ebp
jae 0x610c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x49ca
incl %ebp
jmp 0x60f8
movq 0x8(%rsp), %rdi
callq 0x2230
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x6136
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x4b46
movq %r14, %rdi
callq 0x2430
// File: /workspace/github_cpp_makefile_star2_O2/dfrodriguezp[P]PiCM-cpp/functions.cc
// Function: update(std::vector<std::valarray<double>, std::allocator<std::valarray<double>>>&, std::vector<std::valarray<double>, std::allocator<std::valarray<double>>>&, std::vector<double, std::allocator<double>> const&, std::vector<unsigned int, std::allocator<unsigned int>> const&, std::vector<std::valarray<double>, std::allocator<std::valarray<double>>> const&, std::valarray<double> const&, double const&, double const&, double const&, unsigned int const&)
void update(VecArr &positions,
            VecArr &velocities,
            const std::vector<Real> &QoverM,
            const std::vector<Int> &moves,
            const VecArr &E, const Array &B,
            const Real &Lx, const Real &Ly,
            const Real &dt, const Int &N)
{
    boris(velocities, QoverM, moves, E, B, dt, N);
    for (Int p = 0; p < N; ++p)
    {
        if (moves.at(p))
        {
            positions.at(p) += velocities.at(p) * dt;
            positions.at(p)[0] = mod(positions.at(p)[0], Lx);
            positions.at(p)[1] = mod(positions.at(p)[1], Ly);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x78(%rsp), %r12
movq 0x70(%rsp), %r9
movq %r12, (%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %rax, %r8
callq 0x7131
xorl %r13d, %r13d
leaq 0x18(%rsp), %rbp
movl (%r12), %eax
cmpq %rax, %r13
jae 0x757a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x78b2
cmpl $0x0, (%rax)
je 0x7572
movq %r14, %rdi
movq %r13, %rsi
callq 0x4d3a
movq 0x70(%rsp), %rcx
movsd (%rcx), %xmm0
movq %rax, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x4d3a
movq %rax, %rdi
movq %rbp, %rsi
callq 0x7acc
movq %r15, %rdi
movq %r13, %rsi
callq 0x4d3a
movq 0x8(%rax), %rdi
movq 0x60(%rsp), %rsi
callq 0x6060
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x4d3a
movq 0x8(%rax), %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r15, %rdi
movq %r13, %rsi
callq 0x4d3a
movq 0x8(%rax), %rdi
addq $0x8, %rdi
movq 0x68(%rsp), %rsi
callq 0x6060
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x4d3a
movq 0x8(%rax), %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
incq %r13
jmp 0x74a7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Unreality3D[P]Unreality3D/indie-studio/source/MapGenerator/MapGenerator.cpp
// Function: Map::set_seed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void				Map::set_seed(std::string seed)
{
  int		nbr = 0;

  for(size_t i = 0; i < seed.length();i++)
    nbr += static_cast<int>(seed[i]);
  _seed = nbr;
}

// Assembly:
movq 0x8(%rsi), %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x357b
movq (%rsi), %r8
movsbl (%r8,%rdx), %r8d
addl %r8d, %eax
incq %rdx
jmp 0x3566
movl %eax, 0x1c(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Unreality3D[P]Unreality3D/indie-studio/source/MapGenerator/MapGenerator.cpp
// Function: Map::split()
void	Map::split()
{
  bool				split = true;

  while (split)
    {
      split = false;
      for(size_t i = 0; i < _leafs.size();i++)
	{
	  if ((_leafs[i].leftChild == NULL && _leafs[i].rightChild == NULL)
	      && (_leafs[i]._size.x > room_max_size.x || _leafs[i]._size.y > room_max_size.y)
	      && (_leafs[i].split(room_min_size)))
	    {
	      _leafs.push_back(*_leafs[i].leftChild);
	      _leafs.push_back(*_leafs[i].rightChild);
	      split = true;
	    }
	}
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %rax, %r15
jae 0x37e2
movq %r15, %r13
shlq $0x5, %r13
cmpq $0x0, 0x10(%rdi,%r13)
jne 0x37dd
addq %r13, %rdi
cmpq $0x0, 0x18(%rdi)
je 0x37f3
incq %r15
jmp 0x37b0
xorl %r15d, %r15d
testb $0x1, %r12b
movl $0x0, %r12d
jne 0x37b0
jmp 0x3835
movl 0x8(%rdi), %eax
cmpl 0xc(%rbx), %eax
jg 0x3803
movl 0xc(%rdi), %eax
cmpl 0x10(%rbx), %eax
jle 0x37dd
movq 0x14(%rbx), %rsi
callq 0x3350
testb %al, %al
je 0x37dd
movq (%r14), %rax
movq 0x10(%rax,%r13), %rsi
movq %r14, %rdi
callq 0x33e0
movq (%r14), %rax
movq 0x18(%rax,%r13), %rsi
movq %r14, %rdi
callq 0x33e0
movb $0x1, %r12b
jmp 0x37dd
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Unreality3D[P]Unreality3D/indie-studio/source/MapGenerator/MapGenerator.cpp
// Function: Map::blank_map()
void	Map::blank_map()
{
  std::string	tmp;
  for (int x = 0; x < map_size.x + 4; x++)
    tmp += ".";
  for (int i = 0; i < map_size.y + 4; i++)
    _map.push_back(tmp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %ebp, %ebp
leaq 0x17b1(%rip), %r14      # 0x5018
leaq 0x8(%rsp), %r15
movl 0x4(%rbx), %eax
addl $0x4, %eax
cmpl %eax, %ebp
jge 0x3885
movq %r15, %rdi
movq %r14, %rsi
callq 0x3410
incl %ebp
jmp 0x386c
leaq 0x58(%rbx), %r14
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movl 0x8(%rbx), %eax
addl $0x4, %eax
cmpl %eax, %ebp
jge 0x38a9
movq %r14, %rdi
movq %r15, %rsi
callq 0x3120
incl %ebp
jmp 0x3890
leaq 0x8(%rsp), %rdi
callq 0x30f0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Unreality3D[P]Unreality3D/indie-studio/source/MapGenerator/MapGenerator.cpp
// Function: Map::draw_rooms()
void	Map::draw_rooms()
{
  int	x = 0;
  int	y = 0;

  for (size_t i = 0;i < _rooms.size();i++)
    {
      x = _rooms[i]._size.x + _rooms[i]._pos.x + 2;
      y = _rooms[i]._size.y + _rooms[i]._pos.y + 2;
      for (int p = _rooms[i]._pos.y + 1; p <= y;p++)
	{
	  for (int o = _rooms[i]._pos.x + 1; o <= x;o++)
	    {
	      if (o == x || o == _rooms[i]._pos.x + 1)
		_map[p][o] = '#';
	      else if  (p == y || p == _rooms[i]._pos.y + 1)
	      	_map[p][o] = '#';
	      else
		_map[p][o] = ' ';
	    }
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %ecx, %ecx
movabsq $0x14, %rsi
movq 0x40(%rdi), %r8
movq 0x48(%rdi), %rax
subq %r8, %rax
cqto
idivq %rsi
cmpq %rax, %rcx
jae 0x39a2
imulq $0x14, %rcx, %rax
movl (%r8,%rax), %r11d
movl 0x8(%r8,%rax), %ebx
leal (%rbx,%r11), %r9d
addl $0x2, %r9d
movl 0xc(%r8,%rax), %r10d
movslq 0x4(%r8,%rax), %rdx
leal (%r10,%rdx), %r8d
addl $0x2, %r8d
movslq %r9d, %r9
movslq %r8d, %r10
addl %ebx, %r11d
incl %r11d
cmpq %r10, %rdx
jge 0x399a
leaq 0x1(%rdx), %rbx
movq 0x40(%rdi), %r14
movslq (%r14,%rax), %r14
movq %rbx, %r15
shlq $0x5, %r15
cmpq %r9, %r14
jge 0x3995
movb $0x23, %bpl
cmpl %r14d, %r11d
je 0x3983
movq 0x40(%rdi), %r12
cmpl (%r12,%rax), %r14d
je 0x3983
cmpl %ebx, %r8d
je 0x3983
addq %rax, %r12
xorl %r13d, %r13d
cmpl %edx, 0x4(%r12)
sete %r13b
leal (%r13,%r13,2), %ebp
orl $0x20, %ebp
movq 0x58(%rdi), %r12
movq (%r12,%r15), %r12
movb %bpl, 0x1(%r12,%r14)
incq %r14
jmp 0x3950
movq %rbx, %rdx
jmp 0x3938
incq %rcx
jmp 0x38ec
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Unreality3D[P]Unreality3D/indie-studio/source/MapGenerator/MgUtils.cpp
// Function: Leaf::split(Size)
bool	Leaf::split(Size roomMin)
{
  bool	splitB;

  if (leftChild != NULL && rightChild != NULL)
    return false;
  if (_size.x > _size.y)
    splitB = false;
  else
    splitB = true;
  int max = (splitB ? _size.y : _size.x) - (splitB ? roomMin.y : roomMin.x);
  if (max < (splitB ? roomMin.y : roomMin.x))
    return false;
  int splitPos = random_range((splitB ? roomMin.y : roomMin.x), max);
  if (splitB)
    {
      leftChild =  new Leaf(Size(_pos.x, _pos.y), Size(_size.x, splitPos));
      rightChild =  new Leaf(Size(_pos.x, _pos.y + splitPos), Size(_size.x, _size.y - splitPos));
    }
  else
    {
      leftChild =  new Leaf(Size(_pos.x, _pos.y), Size(splitPos, _size.y));
      rightChild =  new Leaf(Size(_pos.x + splitPos, _pos.y), Size(_size.x - splitPos, _size.y));
    }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x4868
cmpq $0x0, 0x18(%rbx)
jne 0x4888
movq %rsi, %rdi
shrq $0x20, %rdi
movl 0x8(%rbx), %ebp
movl 0xc(%rbx), %r15d
cmpl %r15d, %ebp
movl %r15d, %eax
cmovgl %ebp, %eax
cmovgl %esi, %edi
subl %edi, %eax
cmpl %edi, %eax
jge 0x488f
xorl %eax, %eax
jmp 0x4951
movl %eax, %esi
callq 0x3230
movl %eax, %r14d
pushq $0x20
popq %rdi
callq 0x3250
movl (%rbx), %ecx
movl 0x4(%rbx), %r12d
movq %r12, %r13
shlq $0x20, %r13
movq %rcx, (%rsp)
leaq (%rcx,%r13), %rdx
leaq 0x10(%rax), %rcx
cmpl %r15d, %ebp
jle 0x48fe
movl 0xc(%rbx), %r15d
shlq $0x20, %r15
movl %r14d, %esi
orq %r15, %rsi
movq %rdx, (%rax)
movq %rsi, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq %rax, 0x10(%rbx)
pushq $0x20
popq %rdi
callq 0x3250
movq (%rsp), %rdx
addl %r14d, %edx
movl 0x8(%rbx), %ecx
subl %r14d, %ecx
orq %rdx, %r13
orq %r15, %rcx
movq %r13, (%rax)
jmp 0x4940
movl 0x8(%rbx), %r15d
movq %r14, %rsi
shlq $0x20, %rsi
orq %r15, %rsi
movq %rdx, (%rax)
movq %rsi, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq %rax, 0x10(%rbx)
pushq $0x20
popq %rdi
callq 0x3250
addl %r14d, %r12d
movl 0xc(%rbx), %ecx
subl %r14d, %ecx
shlq $0x20, %r12
addq (%rsp), %r12
shlq $0x20, %rcx
orq %r15, %rcx
movq %r12, (%rax)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rax, 0x18(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Unreality3D[P]Unreality3D/indie-studio/source/MapGenerator/MgUtils.cpp
// Function: Leaf::create_rooms(std::vector<Rooms, std::allocator<Rooms>>&, Size)
void	Leaf::create_rooms(std::vector<Rooms>& _rooms, Size maxS)
{
  if (leftChild != NULL || rightChild != NULL)
    {
      if (leftChild != NULL)
	leftChild->create_rooms(_rooms, maxS);
      if (rightChild != NULL)
	rightChild->create_rooms(_rooms, maxS);
    }
  else
    {
      if (_size.x <= maxS.x && _size.y <= maxS.y)
	{
	  ++ids;
	  _rooms.push_back(Rooms(_pos, _size, ids));
	}
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rax
movq %rdi, %rcx
orq %rax, %rcx
je 0x49a2
testq %rdi, %rdi
je 0x4998
movq %rbx, %rsi
movq %r15, %rdx
callq 0x33a0
movq 0x18(%r14), %r14
jmp 0x499b
movq %rax, %r14
testq %r14, %r14
jne 0x4972
jmp 0x49d5
cmpl %r15d, 0x8(%r14)
jg 0x49d5
shrq $0x20, %r15
cmpl %r15d, 0xc(%r14)
jg 0x49d5
movl 0x2878(%rip), %eax      # 0x7230
incl %eax
movl %eax, 0x2870(%rip)      # 0x7230
movups (%r14), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl %eax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x3060
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lhartmann[P]orangepi-i2s-steppers/stepper_test.cpp
// Function: main
int main() {
	Stepper s;
	s.prepare(10,100);
	for (int i=0; i<120; ++i) {
		cout
			<< i << " "
			<< (s.step() ? "STEP " : "     ")
			<< (s.done() ? "DONE " : "     ")
			<< endl;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movaps 0xe3c(%rip), %xmm0      # 0x2010
leaq -0x3c(%rbp), %rax
movups %xmm0, (%rax)
movl $0xffffffce, 0x10(%rax) # imm = 0xFFFFFFCE
xorl %r14d, %r14d
leaq 0xe34(%rip), %r15       # 0x2020
leaq 0xe33(%rip), %r12       # 0x2026
leaq 0xe32(%rip), %rbx       # 0x202c
cmpl $0x78, %r14d
je 0x125d
movq 0x2dd1(%rip), %rdi      # 0x3fd8
movl %r14d, %esi
callq 0x1070
movq %rax, %rdi
leaq 0xe11(%rip), %rsi       # 0x202a
callq 0x1050
movq %rax, %r13
leaq -0x3c(%rbp), %rdi
callq 0x126e
testb %al, %al
movq %r12, %rsi
cmovneq %r15, %rsi
movq %r13, %rdi
callq 0x1050
movl -0x3c(%rbp), %ecx
cmpl -0x38(%rbp), %ecx
movq %r12, %rsi
cmoveq %rbx, %rsi
movq %rax, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x1030
incl %r14d
jmp 0x11fa
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/examples/studentT/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "d1.txt";

    load(datafile, "ms", 2);

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x6c0, %rsp            # imm = 0x6C0
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x43905(%rip), %r14     # 0x646c0
leaq 0x2625b(%rip), %rsi     # 0x4701d
movq %r14, %rdi
callq 0x6770
leaq 0x8(%rsp), %rdx
movl $0x2, (%rdx)
leaq 0x1b705(%rip), %rsi     # 0x3c4e1
movq %r14, %rdi
callq 0x2100f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x210b8
pushq $0x32
popq %rsi
movq %r14, %rdi
callq 0x21104
leaq 0x8(%rsp), %rdi
callq 0x212ca
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x212ca
movq %rbx, %rdi
callq 0x66e0