LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x618d(%rip), %rax      # 0xdfc0
movq (%rax), %rcx
testq %rcx, %rcx
je 0x7e49
movswl 0x4(%rcx), %eax
incl %eax
movswl 0x6(%rcx), %ecx
incl %ecx
jmp 0x7e53
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %eax, 0x670b(%rip)      # 0xe564
movl %ecx, 0x6701(%rip)      # 0xe560
decl %ecx
movl %ecx, 0x6701(%rip)      # 0xe568
movl $0x0, 0x66ff(%rip)      # 0xe570
leal -0x3(%rax), %ecx
movl %ecx, 0x66f2(%rip)      # 0xe56c
leal -0x2(%rax), %ecx
movl %ecx, 0x66f1(%rip)      # 0xe574
decl %eax
movl %eax, 0x66ed(%rip)      # 0xe578
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
callq 0x3510
callq 0x3460
callq 0x3100
callq 0x33d0
movq 0x6118(%rip), %rbx      # 0xdfc0
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x3160
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x34d0
xorl %edi, %edi
callq 0x32a0
callq 0x7e2c
movb $0x1, 0x66ab(%rip)      # 0xe580
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5c1f(%rip), %rbx      # 0xe4e8
cmpl $0x0, (%rbx)
je 0x8940
leaq 0x5c1a(%rip), %rax      # 0xe4ef
cmpb $0x1, (%rax)
jne 0x88fc
leaq 0x5baf(%rip), %rax      # 0xe490
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x8934
callq 0x5cd3
callq 0x4ba4
movl $0x0, (%rbx)
jmp 0x8932
leaq 0x5bad(%rip), %rax      # 0xe4b0
movb $0x0, (%rax)
leaq 0x5b9b(%rip), %rax      # 0xe4a8
movq $0x0, (%rax)
callq 0x4ba4
xorl %eax, %eax
movl %eax, 0x5c5b(%rip)      # 0xe57c
movl %eax, 0x5c5d(%rip)      # 0xe584
leaq 0x5b86(%rip), %rcx      # 0xe4b4
movl %eax, (%rcx)
movl %eax, (%rbx)
popq %rbx
retq
leaq 0x2513(%rip), %rdi      # 0xae4e
callq 0x9214
movl $0x1, (%rbx)
leaq 0x1864(%rip), %rdi      # 0xa1b1
popq %rbx
jmp 0x5102
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x53cd(%rip), %r12      # 0xe4b4
movslq (%r12), %rax
movl %edi, %ebp
sarl $0x1f, %ebp
orl $0x1, %ebp
addl %eax, %ebp
js 0x9129
leaq 0x5392(%rip), %r13      # 0xe490
movq (%r13), %rsi
movq 0x8(%r13), %rcx
subq %rsi, %rcx
shrq $0x6, %rcx
cmpl %ecx, %ebp
jg 0x9129
leaq 0x53d0(%rip), %rcx      # 0xe4e8
cmpl $0x0, (%rcx)
jne 0x9129
leaq 0x538c(%rip), %rcx      # 0xe4b0
cmpb $0x0, (%rcx)
je 0x913c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3090
movl %edi, %ebx
shlq $0x6, %rax
addq %rax, %rsi
leaq 0x8(%rsp), %rdi
callq 0x9a4e
movl %ebp, %r14d
movq (%r13), %rax
shlq $0x6, %r14
leaq (%rax,%r14), %r15
movslq (%r12), %r12
shlq $0x6, %r12
addq %rax, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x31e0
addq $0x20, %r15
addq $0x20, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x31e0
addq (%r13), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x31e0
leaq 0x28(%rsp), %rsi
addq $0x20, %r14
movq %r14, %rdi
callq 0x31e0
movl %ebx, %edi
movl $0x1, %esi
callq 0x5f48
callq 0x9289
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x91d5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3350
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x91f0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3350
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x68c4
movq %rbx, %rdi
callq 0x3620
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x535e(%rip)      # 0xe580
jne 0x927a
movl 0x534e(%rip), %edi      # 0xe578
xorl %esi, %esi
callq 0x3250
movq 0x4d88(%rip), %r14      # 0xdfc0
movq (%r14), %rdi
callq 0x3390
leaq 0x16af(%rip), %rdi      # 0xa8f6
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3340
callq 0x35f0
movq (%r14), %rdi
callq 0x3150
movl 0x5314(%rip), %edi      # 0xe578
xorl %esi, %esi
callq 0x3250
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3390
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3570
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x20, %rsp
movq %rdi, %rbx
movl 0x4dce(%rip), %edi      # 0xe578
xorl %esi, %esi
callq 0x3250
movq 0x4808(%rip), %r15      # 0xdfc0
movq (%r15), %rdi
callq 0x3390
leaq 0x1109(%rip), %rdi      # 0xa8d0
xorl %eax, %eax
callq 0x3340
callq 0x35f0
callq 0x3120
movq (%r15), %rdi
movq %rsp, %r14
movq %r14, %rsi
movl $0x12, %edx
callq 0x3520
callq 0x33d0
movl 0x4d82(%rip), %edi      # 0xe578
xorl %esi, %esi
callq 0x3250
movq (%r15), %rdi
callq 0x3390
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x3180
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b0e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl 0x4c94(%rip), %edi      # 0xe574
xorl %esi, %esi
callq 0x3250
movq 0x46d2(%rip), %r15      # 0xdfc0
movq (%r15), %rdi
callq 0x3390
movl 0x4c78(%rip), %edi      # 0xe574
xorl %esi, %esi
callq 0x3250
movq (%r15), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x31a0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x4bba(%rip), %rax      # 0xe4e8
cmpl $0x0, (%rax)
je 0x9953
movl $0x42, %ebx
leaq 0x153a(%rip), %rcx      # 0xae79
movq %rsp, %rdi
movl $0x6, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3580
jmp 0x9971
movl $0x4c, %ebx
leaq 0x1515(%rip), %rcx      # 0xae74
movq %rsp, %rdi
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3580
leaq 0x20(%rsp), %rdi
callq 0x40a0
movq (%r15), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x31a0
movq 0x20(%rsp), %rdx
leaq 0x14ea(%rip), %rdi      # 0xae80
movl %ebx, %esi
xorl %eax, %eax
callq 0x3340
movq (%r15), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x3450
movq (%r15), %rdi
movl 0x4bb1(%rip), %edx      # 0xe568
movl $0x20, %esi
callq 0x32e0
movq (%r15), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x3450
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x99eb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3350
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x9a01
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3350
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x9a0d
movq %rax, %rbx
jmp 0x9a30
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a30
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3350
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x9a46
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rdi
callq 0x3620
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x48, %rsp
movq 0x8(%rsi), %rsi
leaq 0x28(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x6170
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x9e3e
leaq 0x8(%rsp), %rdi
callq 0x9a2c
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x9da9
callq 0x63f0
movq 0x29220(%rip), %rbx     # 0x32fd0
leaq 0x1728b(%rip), %rsi     # 0x21042
movl $0x14, %edx
movq %rbx, %rdi
callq 0x6450
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x6400
movsbl %al, %esi
movq 0x291ee(%rip), %rdi     # 0x32fd0
callq 0x6050
movq %rax, %rdi
callq 0x62c0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e02
callq 0x63f0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x9e23
callq 0x63f0
jmp 0x9e23
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e36
callq 0x63f0
movq %rbx, %rdi
callq 0x6670
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x74c6(%rip)      # 0xa2e0
jne 0x2e6e
testl %ebx, %ebx
leaq 0x3625(%rip), %rax      # 0x644a
leaq 0x361a(%rip), %rsi      # 0x6446
cmoveq %rax, %rsi
movl 0x74d2(%rip), %edx      # 0xa308
incl %edx
movq 0x7349(%rip), %rax      # 0xa188
movq (%rax), %rcx
leaq 0x3604(%rip), %rdi      # 0x644d
xorl %eax, %eax
callq 0x2120
testl %ebx, %ebx
jne 0x2ee8
cmpl $0x0, 0x74ad(%rip)      # 0xa30c
je 0x2ee8
leaq 0x35ed(%rip), %rdi      # 0x6459
jmp 0x2ece
xorl %ebp, %ebp
testl %ebx, %ebx
sete %bpl
leaq 0x35e9(%rip), %rax      # 0x6466
leaq 0x35e5(%rip), %r14      # 0x6469
cmoveq %rax, %r14
xorl $0x5, %ebp
leaq 0x35de(%rip), %rdi      # 0x6470
xorl %eax, %eax
callq 0x2120
leaq 0x31b5(%rip), %rsi      # 0x6055
movl %ebp, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2f53
leaq 0x35c0(%rip), %rdi      # 0x6473
xorl %eax, %eax
callq 0x2120
testl %ebx, %ebx
jne 0x2eda
cmpl $0x0, 0x7447(%rip)      # 0xa30c
je 0x2eda
leaq 0x3c0a(%rip), %rdi      # 0x6ad8
xorl %eax, %eax
callq 0x2120
callq 0x4fb7
movl $0xa, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c50(%rip), %xmm0     # 0x7330
leaq 0x20(%rsp), %rdi
movaps %xmm0, 0x10(%rdi)
movaps 0x2c30(%rip), %xmm0     # 0x7320
movaps %xmm0, (%rdi)
movl $0x20676e, 0x1f(%rdi)   # imm = 0x20676E
movq %rsp, %r15
movq %r15, %rsi
movl $0x4, %edx
callq 0x2bad
xorl %edi, %edi
cmpl $0x4, %eax
sete %dil
leaq 0x216d(%rip), %r14      # 0x6887
leaq 0x1934(%rip), %rbx      # 0x6055
leaq 0x230b(%rip), %r8       # 0x6a33
movq %r14, %rsi
movl $0x29, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c34
movq (%r15), %rdi
leaq 0x22f9(%rip), %rsi      # 0x6a3d
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x22ed(%rip), %r8       # 0x6a45
movq %r14, %rsi
movl $0x2a, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c34
movq 0x8(%r15), %rdi
leaq 0x22f0(%rip), %rsi      # 0x6a65
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x22e1(%rip), %r8       # 0x6a6a
movq %r14, %rsi
movl $0x2b, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c34
movq 0x10(%r15), %rdi
leaq 0x22e1(%rip), %rsi      # 0x6a87
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x22d2(%rip), %r8       # 0x6a8c
movq %r14, %rsi
movl $0x2c, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c34
movq 0x18(%r15), %rdi
leaq 0x22d2(%rip), %rsi      # 0x6aa9
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x22c3(%rip), %r8       # 0x6aae
movq %r14, %rsi
movl $0x2d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c34
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
leaq 0xf(%rsp), %rdi
movb $0x0, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, %rsi
movl $0x4, %edx
callq 0x2bad
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x204a(%rip), %r14      # 0x6887
leaq 0x1811(%rip), %rbx      # 0x6055
leaq 0x2280(%rip), %r12      # 0x6acb
movq %r14, %rsi
movl $0x37, %edx
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2c34
leaq 0x10(%rsp), %rdi
movw $0x20, 0x4(%rdi)
movl $0x20202020, (%rdi)     # imm = 0x20202020
movq %r15, %rsi
movl $0x4, %edx
callq 0x2bad
xorl %edi, %edi
testl %eax, %eax
sete %dil
movq %r14, %rsi
movl $0x3b, %edx
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2c34
movabsq $0x64726f6e66202020, %rax # imm = 0x64726F6E66202020
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
movl $0x202020, 0x8(%rdi)    # imm = 0x202020
movq %r15, %rsi
movl $0x4, %edx
callq 0x2bad
xorl %edi, %edi
cmpl $0x1, %eax
sete %dil
leaq 0x2216(%rip), %r12      # 0x6ae7
movq %r14, %rsi
movl $0x3f, %edx
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2c34
movq (%r15), %rdi
leaq 0x1f69(%rip), %rsi      # 0x6859
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x21ed(%rip), %r8       # 0x6af1
movq %r14, %rsi
movl $0x40, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c34
leaq 0x18(%rsp), %rdi
movl $0x656c67, 0x3(%rdi)    # imm = 0x656C67
movl $0x676e6973, (%rdi)     # imm = 0x676E6973
leaq 0x21e0(%rip), %r13      # 0x6b0f
movq %r15, %rsi
movl $0x4, %edx
callq 0x2bad
xorl %edi, %edi
cmpl $0x1, %eax
sete %dil
movq %r14, %rsi
movl $0x44, %edx
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2c34
movq (%r15), %rdi
movq %r13, %rsi
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x21a2(%rip), %r8       # 0x6b16
movq %r14, %rsi
movl $0x45, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c34
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5116(%rip), %rsi      # 0x9cf0
leaq 0x20(%rsp), %rbx
movl $0xc, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x1c59(%rip), %rax      # 0x684a
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x1, %edi
movq %rbx, %rdx
callq 0x276e
shrl $0x1f, %eax
leaq 0x1c77(%rip), %r15      # 0x6887
leaq 0x143e(%rip), %r14      # 0x6055
leaq 0x1f5c(%rip), %r8       # 0x6b7a
movl %eax, %edi
movq %r15, %rsi
movl $0x66, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2c34
movaps 0x5117(%rip), %xmm0     # 0x9d50
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x2, %edi
movq %rbx, %rdx
callq 0x276e
notl %eax
shrl $0x1f, %eax
leaq 0x1f43(%rip), %r8       # 0x6b9d
movl %eax, %edi
movq %r15, %rsi
movl $0x68, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2c34
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %eax, %eax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rsp, %r12
movq %rax, (%r12)
leaq 0x1ccf(%rip), %rcx      # 0x6b76
leaq 0x30(%rsp), %rdx
movq %rcx, (%rdx)
movb $0x66, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movl $0x4, %ecx
movl %ecx, 0x18(%rdx)
movq %r15, 0x20(%rdx)
movb %al, 0x28(%rdx)
leaq 0x198c(%rip), %rsi      # 0x6859
movq %rsi, 0x30(%rdx)
movb $0x6e, 0x38(%rdx)
movq %rax, 0x40(%rdx)
movl %ecx, 0x48(%rdx)
movq %r12, 0x50(%rdx)
movb %al, 0x58(%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rdx)
movaps %xmm0, 0x70(%rdx)
movaps %xmm0, 0x80(%rdx)
movq 0x4ee4(%rip), %rax      # 0x9de0
leaq 0x10(%rsp), %rsi
movq %rax, 0x10(%rsi)
movaps 0x4ec4(%rip), %xmm0     # 0x9dd0
movaps %xmm0, (%rsi)
movl $0x3, %edi
callq 0x276e
notl %eax
shrl $0x1f, %eax
leaq 0x1962(%rip), %r14      # 0x6887
leaq 0x1129(%rip), %rbx      # 0x6055
leaq 0x1d50(%rip), %r8       # 0x6c83
movl %eax, %edi
movq %r14, %rsi
movl $0x8f, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c34
movq (%r12), %rdi
leaq 0x1d2c(%rip), %rsi      # 0x6c7e
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x1d3e(%rip), %r8       # 0x6ca4
movq %r14, %rsi
movl $0x90, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c34
movq (%r15), %rdi
leaq 0x1ced(%rip), %rsi      # 0x6c6f
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x1d29(%rip), %r8       # 0x6cbf
movq %r14, %rsi
movl $0x91, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c34
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/AndreRenaud[P]simple_options/./acutest.h
// Function: acutest_timer_print_diff_
static double
    acutest_timer_diff_(struct timespec start, struct timespec end)
    {
        double endns;
        double startns;

        endns = end.tv_sec;
        endns *= 1e9;
        endns += end.tv_nsec;

        startns = start.tv_sec;
        startns *= 1e9;
        startns += start.tv_nsec;

        return ((endns - startns)/ 1e9);
    }

// Assembly:
cvtsi2sdq 0x5360(%rip), %xmm1 # 0xa320
movsd 0x10f8(%rip), %xmm2     # 0x60c0
mulsd %xmm2, %xmm1
cvtsi2sdq 0x5353(%rip), %xmm0 # 0xa328
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0x532b(%rip), %xmm1 # 0xa310
cvtsi2sdq 0x532a(%rip), %xmm3 # 0xa318
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm3
subsd %xmm3, %xmm0
divsd %xmm2, %xmm0
leaq 0x1471(%rip), %rdi      # 0x6476
movb $0x1, %al
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3b98(%rip), %r12      # 0x6210
movq %r12, %rdi
movq %r15, %rsi
callq 0x362a
movq %r12, %rdi
movq %rax, %rsi
callq 0x36ac
movl (%r14), %r13d
movl (%r15), %r15d
cmpl %r15d, %r13d
setne %cl
movq 0x18(%r12), %rax
addq $0x8, %r12
cmpq %r12, %rax
sete %dl
orb %cl, %dl
jne 0x26d1
leaq 0x3b64(%rip), %r12      # 0x6218
movq 0x28(%rax), %rcx
movl (%rcx), %ecx
cmpl %ecx, %r13d
cmovlel %ecx, %r13d
movl %r13d, (%r14)
movq %rax, %rdi
callq 0x21a0
cmpq %r12, %rax
jne 0x26b4
movq $-0x2, %rax
movl %r15d, %ecx
rolq %cl, %rax
leal 0x3f(%r15), %ecx
testl %r15d, %r15d
cmovnsl %r15d, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
andq %rax, (%rbx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl $0x2, %edi
movl $0x801, %esi            # imm = 0x801
xorl %edx, %edx
callq 0x2090
testl %eax, %eax
js 0x27e5
movl %eax, %ebx
leaq -0x28(%rbp), %rdx
movl $0x1, (%rdx)
movl $0x5421, %esi           # imm = 0x5421
movl %eax, %edi
xorl %eax, %eax
callq 0x22f0
leaq -0x14(%rbp), %rcx
movl %ebx, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x2390
testl %eax, %eax
js 0x27ee
leaq -0x28(%rbp), %rsi
movq $0x0, 0x8(%rsi)
movw $0x2, (%rsi)
movl $0x0, 0x4(%rsi)
rolw $0x8, %r14w
movw %r14w, 0x2(%rsi)
movl %ebx, %edi
movl $0x10, %edx
callq 0x2070
testl %eax, %eax
js 0x27fc
leaq -0x18(%rbp), %rdx
movl $0x1, (%rdx)
movl $0x5421, %esi           # imm = 0x5421
movl %ebx, %edi
xorl %eax, %eax
callq 0x22f0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1818(%rip), %rdi      # 0x4004
jmp 0x2803
leaq 0x1829(%rip), %rdi      # 0x401e
callq 0x2200
jmp 0x2790
leaq 0x1837(%rip), %rdi      # 0x403a
callq 0x2200
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x27da
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3400
xorl %ebp, %ebp
testl %eax, %eax
je 0x6ecf
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3230
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x33c0
movq %r12, %rdi
movq %r15, %rsi
callq 0x3320
movl %eax, %r12d
movq %r15, %rdi
callq 0x3120
testb %r12b, %r12b
jne 0x6ed2
incl %ebp
movq %rbx, %rdi
callq 0x3400
cmpl %eax, %ebp
jb 0x6e8c
jmp 0x6ed2
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x83f1
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movapd 0x30d6(%rip), %xmm0     # 0xb4a0
movq 0x8(%rbx), %rsi
movsd (%rsi,%rdx), %xmm1
movsd 0x8(%rsi,%rdx), %xmm2
xorpd %xmm0, %xmm2
movsd %xmm1, (%rcx,%rdx)
movlpd %xmm2, 0x8(%rcx,%rdx)
addq $0x10, %rdx
decq %rax
jne 0x83ca
movq %rbx, %rdi
callq 0x81ec
movq (%rbx), %rax
testq %rax, %rax
je 0x849b
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movapd 0x308d(%rip), %xmm0     # 0xb4a0
movq 0x8(%rbx), %rsi
movsd (%rsi,%rdx), %xmm1
movsd 0x8(%rsi,%rdx), %xmm2
xorpd %xmm0, %xmm2
movsd %xmm1, (%rcx,%rdx)
movlpd %xmm2, 0x8(%rcx,%rdx)
addq $0x10, %rdx
decq %rax
jne 0x8413
movq (%rbx), %r14
testq %r14, %r14
jle 0x849b
movq %r14, %xmm0
punpckldq 0x3061(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
movq 0x8(%rbx), %rbx
subpd 0x3065(%rip), %xmm0     # 0xb4c0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
shlq $0x4, %r14
addq %rbx, %r14
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
xorps %xmm3, %xmm3
movapd (%rsp), %xmm2
callq 0x3170
movsd %xmm0, (%rbx)
movsd %xmm1, 0x8(%rbx)
addq $0x10, %rbx
cmpq %r14, %rbx
jb 0x8473
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl (%rdx), %r13d
movq %r13, 0x8(%rsp)
leaq (,%r13,8), %r12
movq %r12, %rdi
callq 0x3290
movq %rax, %r15
movq %rax, 0x10(%rsp)
testl %r13d, %r13d
je 0x85df
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3150
cmpl $0x0, (%r14)
je 0x8603
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6ef8
incl %ebp
cmpl (%r14), %ebp
jb 0x85ec
movq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x3270
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x862f
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x3270
movq %rbx, %rdi
callq 0x7026
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movq %r9, %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x58(%rsp), %rbp
movq 0x50(%rsp), %r9
movq %rbp, (%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %rax, %r8
callq 0x9721
movl (%rbp), %eax
testl %eax, %eax
je 0xa18b
xorl %ebx, %ebx
movl %ebx, %ebx
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rbx, %rdx
jbe 0xa19a
cmpl $0x0, (%rcx,%rbx,4)
je 0xa181
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
cmpq %rbx, %rdx
jbe 0xa19a
movq (%r12), %rsi
movq 0x8(%r12), %rdx
subq %rsi, %rdx
sarq $0x4, %rdx
cmpq %rbx, %rdx
jbe 0xa19a
movq %rbx, %r13
shlq $0x4, %r13
movq (%rsi,%r13), %rcx
movq 0x8(%rsi,%r13), %rdi
testq %rcx, %rcx
je 0xa129
movq 0x50(%rsp), %rdx
movsd (%rdx), %xmm0
movq 0x8(%rax,%r13), %rax
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdi,%rdx,8), %xmm1
movsd %xmm1, (%rdi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0xa10e
movq 0x40(%rsp), %rsi
callq 0x8526
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
cmpq %rbx, %rdx
jbe 0xa19a
movq 0x8(%rax,%r13), %rdi
movsd %xmm0, (%rdi)
addq $0x8, %rdi
movq 0x48(%rsp), %rsi
callq 0x8526
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
cmpq %rbx, %rdx
jbe 0xa19a
movq 0x8(%rax,%r13), %rax
movsd %xmm0, 0x8(%rax)
movl (%rbp), %eax
incl %ebx
cmpl %eax, %ebx
jb 0xa096
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11c4(%rip), %rdi      # 0xb365
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/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 0x286e
movq %r15, %r13
shlq $0x5, %r13
cmpq $0x0, 0x10(%rdi,%r13)
jne 0x2869
addq %r13, %rdi
cmpq $0x0, 0x18(%rdi)
je 0x2882
incq %r15
jmp 0x283c
xorl %r15d, %r15d
testb $0x1, %r12b
movl $0x0, %r12d
jne 0x283c
jmp 0x290e
movl 0x8(%rdi), %eax
cmpl 0xc(%rbx), %eax
jg 0x2892
movl 0xc(%rdi), %eax
cmpl 0x10(%rbx), %eax
jle 0x2869
movq 0x14(%rbx), %rsi
callq 0x22e0
testb %al, %al
je 0x2869
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rsi
movq 0x10(%rax,%r13), %rdx
cmpq 0x38(%rbx), %rsi
je 0x28ce
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
movq 0x30(%rbx), %rsi
addq $0x20, %rsi
movq %rsi, 0x30(%rbx)
jmp 0x28da
movq %r14, %rdi
callq 0x2290
movq 0x30(%rbx), %rsi
movq 0x28(%rbx), %rax
movq 0x18(%rax,%r13), %rdx
cmpq 0x38(%rbx), %rsi
je 0x28fe
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x30(%rbx)
jmp 0x2906
movq %r14, %rdi
callq 0x2290
movb $0x1, %r12b
jmp 0x2869
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpl $-0x3, 0x4(%rdi)
jl 0x296b
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x16c7(%rip), %r14      # 0x4018
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2370
movl 0x4(%rbx), %eax
addl $0x3, %eax
incl %ebp
cmpl %eax, %ebp
jl 0x2954
cmpl $-0x3, 0x8(%rbx)
jl 0x2994
leaq 0x58(%rbx), %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x20f0
movl 0x8(%rbx), %eax
addl $0x3, %eax
incl %ebp
cmpl %eax, %ebp
jl 0x297d
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x29a2
callq 0x2210
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29b1
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x29c2
callq 0x2210
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c74
cmpq $0x0, 0x18(%rbx)
jne 0x3c98
movq %rsi, %r15
shrq $0x20, %r15
movl 0x8(%rbx), %ebp
movl 0xc(%rbx), %r13d
cmpl %r13d, %ebp
movl %r13d, %r14d
cmovgl %ebp, %r14d
cmovgl %esi, %r15d
subl %r15d, %r14d
subl %r15d, %r14d
jge 0x3c9f
xorl %eax, %eax
jmp 0x3d6f
callq 0x2070
incl %r14d
cltd
idivl %r14d
movl %edx, %r14d
addl %r15d, %r14d
movl $0x20, %edi
callq 0x2240
movl (%rbx), %ecx
movl 0x4(%rbx), %r15d
movq %r15, %r12
shlq $0x20, %r12
movq %rcx, (%rsp)
leaq (%r12,%rcx), %rdx
leaq 0x10(%rax), %rcx
cmpl %r13d, %ebp
jle 0x3d1a
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)
movl $0x20, %edi
callq 0x2240
movq (%rsp), %rdx
addl %r14d, %edx
movl 0x8(%rbx), %ecx
subl %r14d, %ecx
orq %rdx, %r12
orq %r15, %rcx
movq %r12, (%rax)
jmp 0x3d5e
movl 0x8(%rbx), %r12d
movq %r14, %rsi
shlq $0x20, %rsi
orq %r12, %rsi
movq %rdx, (%rax)
movq %rsi, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq %rax, 0x10(%rbx)
movl $0x20, %edi
callq 0x2240
addl %r14d, %r15d
movl 0xc(%rbx), %ecx
subl %r14d, %ecx
shlq $0x20, %r15
addq (%rsp), %r15
shlq $0x20, %rcx
orq %r12, %rcx
movq %r15, (%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_O3/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 0x3dc0
testq %rdi, %rdi
je 0x3db6
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2320
movq 0x18(%r14), %r14
jmp 0x3db9
movq %rax, %r14
testq %r14, %r14
jne 0x3d90
jmp 0x3e14
cmpl %r15d, 0x8(%r14)
jg 0x3e14
shrq $0x20, %r15
cmpl %r15d, 0xc(%r14)
jg 0x3e14
movl 0x240a(%rip), %eax      # 0x61e0
incl %eax
movl %eax, 0x2402(%rip)      # 0x61e0
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movl %eax, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3e09
movl 0x10(%rsp), %eax
movl %eax, 0x10(%rsi)
movaps (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x14, 0x8(%rbx)
jmp 0x3e14
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x2130
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x30151(%rip), %rdx     # 0x50548
leaq 0x30142(%rip), %r14     # 0x50540
leaq 0x224e8(%rip), %rcx     # 0x428ed
movl $0x6, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x8(%rsp), %rdx
movl $0x2, (%rdx)
leaq 0x1d0ea(%rip), %rsi     # 0x3d511
movq %r14, %rdi
callq 0x20627
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x2072a
movq %r14, %rdi
movl $0x32, %esi
callq 0x207fc
leaq 0x8(%rsp), %rdi
callq 0x209da
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x209da
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/main.cpp
// Function: readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string readFile(const std::string &fileName)
{
	std::ifstream fin(fileName.c_str(), std::ios::binary | std::ios::ate);

	if (!fin) {
		std::cerr << "error: could not open the file" << std::endl;
		return "";
	}

	std::ifstream::pos_type fileSize = fin.tellg();
	fin.seekg(0, std::ios::beg);

	std::vector<char> bytes(fileSize);
	fin.read(bytes.data(), fileSize);
	fin.close();

	return std::string(bytes.data(), fileSize);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x6, %edx
callq 0x53d0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
je 0xb85d
movq 0x297ed(%rip), %r14     # 0x34ff0
leaq 0x1d88d(%rip), %rsi     # 0x29097
movl $0x1e, %edx
movq %r14, %rdi
callq 0x5240
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x51d0
movsbl %al, %esi
movq 0x297bb(%rip), %rdi     # 0x34ff0
callq 0x5030
movq %rax, %rdi
callq 0x5160
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1e01f(%rip), %rdx     # 0x2986f
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xc10e
jmp 0xb8d7
leaq 0x20(%rsp), %rdi
callq 0x5390
movq %rax, %r14
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x52c0
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0xbdb4
movq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x52a0
leaq 0x20(%rsp), %rdi
callq 0x5090
movq 0x8(%rsp), %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc10e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb8d7
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5200
leaq 0x20(%rsp), %rdi
callq 0x50a0
movq %rbx, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
jmp 0xb8f5
jmp 0xb913
jmp 0xb913
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb916
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5200
jmp 0xb916
jmp 0xb913
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x50a0
movq %rbx, %rdi
callq 0x53b0
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/gomoku/board.h
// Function: Morat::Gomoku::Board::size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool size(std::string s) {
		if (!valid_size(s))
			return false;
		size_ = from_str<int>(s);
		neighbor_list_ = gen_neighbor_list();
		num_cells_ = vec_size();
		cells_.resize(vec_size());
		clear();
		return true;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
movq %rsi, %r14
callq 0xad58
movl %eax, %ebp
addl $-0x5, %ebp
cmpl $0x14, %ebp
ja 0xad49
movq %r14, %rdi
callq 0xad58
movq %rsp, %r14
movb %al, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e2c8
vmovaps (%r14), %xmm0
vxorps %xmm1, %xmm1, %xmm1
vmovaps %xmm1, (%r14)
movq 0x38(%rbx), %rdi
vmovups %xmm0, 0x30(%rbx)
testq %rdi, %rdi
je 0xad2e
callq 0xafe4
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xad2e
callq 0xafe4
movsbl (%rbx), %esi
leaq 0x10(%rbx), %rdi
imull %esi, %esi
movw %si, 0x2(%rbx)
callq 0xadd8
movq %rbx, %rdi
callq 0xae0c
cmpl $0x15, %ebp
setb %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/gomoku/board.h
// Function: Morat::Gomoku::Board::clear()
void clear() {
		last_move_ = M_NONE;
		num_moves_ = 0;
		to_play_ = Side::P1;
		outcome_ = Outcome::UNKNOWN;
		hash.clear();

		for(int y = 0; y < size_; y++){
			for(int x = 0; x < size_; x++){
				MoveValid pos = move_valid(x, y);
				Side s = (on_board(x, y) ? Side::NONE : Side::UNDEF);
				cells_[pos.xy] = Cell(s, init_pattern(pos));
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x270a5(%rip), %rax     # 0x31ec2
movl $0x78fd0000, 0x4(%rdi)  # imm = 0x78FD0000
movb (%rax), %al
movb %al, 0x8(%rdi)
leaq 0x27096(%rip), %rax     # 0x31ec6
movb (%rax), %al
movb %al, 0x9(%rdi)
movq $0x0, 0x28(%rdi)
movb (%rdi), %bpl
testb %bpl, %bpl
jle 0xaf43
movabsq $0xff00ff00ff, %r8      # imm = 0xFF00FF00FF
xorl %eax, %eax
xorl %r9d, %r9d
testb %bpl, %bpl
jle 0xaf31
movzbl %bpl, %ebx
movsbl %r9b, %r10d
xorl %r11d, %r11d
movl %ebx, %ecx
imull %r10d, %ecx
movsbl %r11b, %edx
leaq 0x27044(%rip), %r13     # 0x31ec1
leaq 0x2703c(%rip), %rsi     # 0x31ec0
addl %ecx, %edx
cmpl %ebx, %r9d
setl %bpl
imull %eax, %ebx
xorl %r14d, %r14d
movb (%r13), %r15b
movb (%rsi), %r12b
addl %r11d, %ebx
movswq %bx, %rcx
movswq %dx, %rbx
xorl %edx, %edx
leaq (%rcx,%rcx,2), %r13
movl $0x3, %ecx
shlq $0x5, %r13
addq 0x30(%rdi), %r13
cmpl $0xffff0000, (%r13,%rdx) # imm = 0xFFFF0000
movl $0x0, %esi
cmovaeq %rcx, %rsi
shlq $0x2, %rcx
addq $0x4, %rdx
orq %rsi, %r14
cmpq $0x60, %rdx
jne 0xaeb8
movzbl %r15b, %ecx
movzbl %r12b, %edx
testb %bpl, %bpl
movabsq $0xff00ff00ff00, %rsi   # imm = 0xFF00FF00FF00
cmovnel %ecx, %edx
movq %r14, %rcx
shlq $0x8, %rcx
shrq $0x8, %r14
shlq $0x4, %rbx
incl %r11d
andq %rsi, %rcx
movq 0x10(%rdi), %rsi
andq %r8, %r14
orq %rcx, %r14
movb %dl, (%rsi,%rbx)
movb $0x0, 0x1(%rsi,%rbx)
movq %r14, 0x8(%rsi,%rbx)
movb (%rdi), %bpl
movsbl %bpl, %ebx
cmpl %ebx, %r11d
jl 0xae6c
jmp 0xaf35
movsbl %bpl, %ebx
incl %r9d
incl %eax
cmpl %ebx, %r9d
jl 0xae58
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq