LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d97(%rip), %edi      # 0xe578
xorl %esi, %esi
callq 0x3250
movq 0x47d1(%rip), %r15      # 0xdfc0
movq (%r15), %rdi
callq 0x3390
leaq 0x10d2(%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 0x4d4b(%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 0x4b08
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4c5c(%rip), %edi      # 0xe574
xorl %esi, %esi
callq 0x3250
movq 0x469a(%rip), %r15      # 0xdfc0
movq (%r15), %rdi
callq 0x3390
movl 0x4c40(%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 0x4b82(%rip), %rax      # 0xe4e8
cmpl $0x0, (%rax)
je 0x998b
movl $0x42, %ebx
leaq 0x1502(%rip), %rcx      # 0xae79
movq %rsp, %rdi
movl $0x6, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3580
jmp 0x99a9
movl $0x4c, %ebx
leaq 0x14dd(%rip), %rcx      # 0xae74
movq %rsp, %rdi
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3580
leaq 0x20(%rsp), %rdi
callq 0x40a1
movq (%r15), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x31a0
movq 0x20(%rsp), %rdx
leaq 0x14b2(%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 0x4b79(%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 0x9a23
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3350
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x9a39
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3350
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x9a45
movq %rax, %rbx
jmp 0x9a68
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a68
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3350
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x9a7e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rdi
callq 0x3620
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9cbe
leaq 0x8(%rsp), %rdi
callq 0x98ac
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x9c29
callq 0x6400
movq 0x293a0(%rip), %rbx     # 0x32fd0
leaq 0x1740b(%rip), %rsi     # 0x21042
movl $0x14, %edx
movq %rbx, %rdi
callq 0x6460
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x6410
movsbl %al, %esi
movq 0x2936e(%rip), %rdi     # 0x32fd0
callq 0x6050
movq %rax, %rdi
callq 0x62d0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c82
callq 0x6400
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x9ca3
callq 0x6400
jmp 0x9ca3
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9cb6
callq 0x6400
movq %rbx, %rdi
callq 0x6680
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x747b(%rip)      # 0xa2e0
jne 0x2eb9
testl %ebx, %ebx
leaq 0x35da(%rip), %rax      # 0x644a
leaq 0x35cf(%rip), %rsi      # 0x6446
cmoveq %rax, %rsi
movl 0x7487(%rip), %edx      # 0xa308
incl %edx
movq 0x72fe(%rip), %rax      # 0xa188
movq (%rax), %rcx
leaq 0x35b9(%rip), %rdi      # 0x644d
xorl %eax, %eax
callq 0x2120
testl %ebx, %ebx
jne 0x2f33
cmpl $0x0, 0x7462(%rip)      # 0xa30c
je 0x2f33
leaq 0x35a2(%rip), %rdi      # 0x6459
jmp 0x2f19
xorl %ebp, %ebp
testl %ebx, %ebx
sete %bpl
leaq 0x359e(%rip), %rax      # 0x6466
leaq 0x359a(%rip), %r14      # 0x6469
cmoveq %rax, %r14
xorl $0x5, %ebp
leaq 0x3593(%rip), %rdi      # 0x6470
xorl %eax, %eax
callq 0x2120
leaq 0x316a(%rip), %rsi      # 0x6055
movl %ebp, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2f9e
leaq 0x3575(%rip), %rdi      # 0x6473
xorl %eax, %eax
callq 0x2120
testl %ebx, %ebx
jne 0x2f25
cmpl $0x0, 0x73fc(%rip)      # 0xa30c
je 0x2f25
leaq 0x3bc2(%rip), %rdi      # 0x6adb
xorl %eax, %eax
callq 0x2120
callq 0x5127
movl $0xa, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ae0(%rip), %xmm0     # 0x7330
leaq 0x20(%rsp), %rdi
movaps %xmm0, 0x10(%rdi)
movaps 0x2ac0(%rip), %xmm0     # 0x7320
movaps %xmm0, (%rdi)
movl $0x20676e, 0x1f(%rdi)   # imm = 0x20676E
movq %rsp, %r15
movq %r15, %rsi
movl $0x4, %edx
callq 0x2c18
xorl %edi, %edi
cmpl $0x4, %eax
sete %dil
leaq 0x2000(%rip), %r14      # 0x688a
leaq 0x17c4(%rip), %rbx      # 0x6055
leaq 0x219e(%rip), %r8       # 0x6a36
movq %r14, %rsi
movl $0x29, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c94
movq (%r15), %rdi
leaq 0x218c(%rip), %rsi      # 0x6a40
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x2180(%rip), %r8       # 0x6a48
movq %r14, %rsi
movl $0x2a, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c94
movq 0x8(%r15), %rdi
leaq 0x2183(%rip), %rsi      # 0x6a68
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x2174(%rip), %r8       # 0x6a6d
movq %r14, %rsi
movl $0x2b, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c94
movq 0x10(%r15), %rdi
leaq 0x2174(%rip), %rsi      # 0x6a8a
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x2165(%rip), %r8       # 0x6a8f
movq %r14, %rsi
movl $0x2c, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c94
movq 0x18(%r15), %rdi
leaq 0x2165(%rip), %rsi      # 0x6aac
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x2156(%rip), %r8       # 0x6ab1
movq %r14, %rsi
movl $0x2d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c94
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c18
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x1edd(%rip), %r14      # 0x688a
leaq 0x16a1(%rip), %rbx      # 0x6055
leaq 0x2113(%rip), %r12      # 0x6ace
movq %r14, %rsi
movl $0x37, %edx
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2c94
leaq 0x10(%rsp), %rdi
movw $0x20, 0x4(%rdi)
movl $0x20202020, (%rdi)     # imm = 0x20202020
movq %r15, %rsi
movl $0x4, %edx
callq 0x2c18
xorl %edi, %edi
testl %eax, %eax
sete %dil
movq %r14, %rsi
movl $0x3b, %edx
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2c94
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 0x2c18
xorl %edi, %edi
cmpl $0x1, %eax
sete %dil
leaq 0x20a9(%rip), %r12      # 0x6aea
movq %r14, %rsi
movl $0x3f, %edx
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2c94
movq (%r15), %rdi
leaq 0x1dfc(%rip), %rsi      # 0x685c
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x2080(%rip), %r8       # 0x6af4
movq %r14, %rsi
movl $0x40, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c94
leaq 0x18(%rsp), %rdi
movl $0x656c67, 0x3(%rdi)    # imm = 0x656C67
movl $0x676e6973, (%rdi)     # imm = 0x676E6973
leaq 0x2073(%rip), %r13      # 0x6b12
movq %r15, %rsi
movl $0x4, %edx
callq 0x2c18
xorl %edi, %edi
cmpl $0x1, %eax
sete %dil
movq %r14, %rsi
movl $0x44, %edx
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2c94
movq (%r15), %rdi
movq %r13, %rsi
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x2035(%rip), %r8       # 0x6b19
movq %r14, %rsi
movl $0x45, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c94
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4fa6(%rip), %rsi      # 0x9cf0
leaq 0x20(%rsp), %rbx
movl $0xc, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x1aec(%rip), %rax      # 0x684d
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x1, %edi
movq %rbx, %rdx
callq 0x276a
shrl $0x1f, %eax
leaq 0x1b0a(%rip), %r15      # 0x688a
leaq 0x12ce(%rip), %r14      # 0x6055
leaq 0x1def(%rip), %r8       # 0x6b7d
movl %eax, %edi
movq %r15, %rsi
movl $0x66, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2c94
movaps 0x4fa7(%rip), %xmm0     # 0x9d50
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x2, %edi
movq %rbx, %rdx
callq 0x276a
notl %eax
shrl $0x1f, %eax
leaq 0x1dd6(%rip), %r8       # 0x6ba0
movl %eax, %edi
movq %r15, %rsi
movl $0x68, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2c94
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b62(%rip), %rcx      # 0x6b79
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 0x181f(%rip), %rsi      # 0x685c
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 0x4d74(%rip), %rax      # 0x9de0
leaq 0x10(%rsp), %rsi
movq %rax, 0x10(%rsi)
movaps 0x4d54(%rip), %xmm0     # 0x9dd0
movaps %xmm0, (%rsi)
movl $0x3, %edi
callq 0x276a
notl %eax
shrl $0x1f, %eax
leaq 0x17f5(%rip), %r14      # 0x688a
leaq 0xfb9(%rip), %rbx       # 0x6055
leaq 0x1be3(%rip), %r8       # 0x6c86
movl %eax, %edi
movq %r14, %rsi
movl $0x8f, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c94
movq (%r12), %rdi
leaq 0x1bbf(%rip), %rsi      # 0x6c81
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x1bd1(%rip), %r8       # 0x6ca7
movq %r14, %rsi
movl $0x90, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c94
movq (%r15), %rdi
leaq 0x1b80(%rip), %rsi      # 0x6c72
callq 0x2190
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x1bbc(%rip), %r8       # 0x6cc2
movq %r14, %rsi
movl $0x91, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2c94
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x51f0(%rip), %xmm1 # 0xa320
movsd 0xf88(%rip), %xmm2      # 0x60c0
mulsd %xmm2, %xmm1
cvtsi2sdq 0x51e3(%rip), %xmm0 # 0xa328
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0x51bb(%rip), %xmm1 # 0xa310
cvtsi2sdq 0x51ba(%rip), %xmm3 # 0xa318
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm3
subsd %xmm3, %xmm0
divsd %xmm2, %xmm0
leaq 0x1301(%rip), %rdi      # 0x6476
movb $0x1, %al
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2170
movl $0x401, %edx            # imm = 0x401
movl %ebx, %edi
movq %r14, %rsi
callq 0x2300
testl %eax, %eax
js 0x2643
testl %eax, %eax
je 0x2613
movq %r14, %rdi
callq 0x2330
jmp 0x2613
leaq 0x1c62(%rip), %rdi      # 0x42ac
callq 0x2330
xorl %edi, %edi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3618
movq %r12, %rdi
movq %rax, %rsi
callq 0x3694
movl (%r15), %r15d
cmpl %r15d, (%r14)
jne 0x26c9
movq 0x3b8b(%rip), %rax      # 0x6228
leaq 0x3b74(%rip), %r12      # 0x6218
cmpq %r12, %rax
je 0x26c9
movl (%r14), %r13d
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 0x26ac
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_O1/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 0x27db
movl %eax, %ebx
leaq -0x30(%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 0x27e4
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%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 0x27f2
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 0x1822(%rip), %rdi      # 0x4004
jmp 0x27f9
leaq 0x1833(%rip), %rdi      # 0x401e
callq 0x2200
jmp 0x2788
leaq 0x1841(%rip), %rdi      # 0x403a
callq 0x2200
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x27d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq %edi, %rax
leaq 0x3d37fa(%rip), %rcx    # 0x3d4940
movl $0x1, (%rcx,%rax,4)
testl %esi, %esi
jle 0x11c0
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ecx
imulq $0xfa0, %rax, %rdx      # imm = 0xFA0
shlq $0x2, %rcx
xorl %esi, %esi
leaq 0x3d4773(%rip), %r8     # 0x3d58e0
leaq 0x3d85ec(%rip), %r9     # 0x3d9760
leaq 0x3d9585(%rip), %r10    # 0x3da700
leaq 0x2ebe(%rip), %r11      # 0x4040
leaq 0x3d56f7(%rip), %rbx    # 0x3d6880
movl (%rsi,%r8), %ebp
cmpl $0xc4653600, %ebp       # imm = 0xC4653600
je 0x11b1
movl (%rsi,%r10), %r14d
addl (%r9,%rax,4), %r14d
leaq (%rdx,%rsi), %r15
subl (%r11,%r15), %r14d
cmpl %r14d, %ebp
jle 0x11b1
movl %r14d, (%rsi,%r8)
movl %edi, (%rsi,%rbx)
addq $0x4, %rsi
cmpq %rsi, %rcx
jne 0x1189
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rdi
callq 0x3400
testl %eax, %eax
setne %bpl
je 0x6e9b
xorl %r15d, %r15d
movq %rsp, %r12
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3230
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x33c0
movq %r13, %rdi
movq %r12, %rsi
callq 0x3320
movl %eax, %r13d
movq %r12, %rdi
callq 0x3120
testb %r13b, %r13b
jne 0x6e9b
incl %r15d
movq %rbx, %rdi
callq 0x3400
cmpl %eax, %r15d
setb %bpl
jb 0x6e53
andb $0x1, %bpl
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x83b8
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movapd 0x30ff(%rip), %xmm0     # 0xb490
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 0x8391
movq %rbx, %rdi
callq 0x818c
movq (%rbx), %rax
testq %rax, %rax
je 0x83fd
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movapd 0x30ba(%rip), %xmm0     # 0xb490
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 0x83d6
movq (%rbx), %r14
testq %r14, %r14
jle 0x845e
movq %r14, %xmm0
punpckldq 0x308e(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
movq 0x8(%rbx), %rbx
subpd 0x3092(%rip), %xmm0     # 0xb4b0
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 0x8436
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl (%rdx), %r12d
movq %r12, (%rsp)
leaq (,%r12,8), %r15
movq %r15, %rdi
callq 0x3290
movq %rax, 0x8(%rsp)
testq %r12, %r12
je 0x859c
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3150
cmpl $0x0, (%r14)
je 0x85b9
xorl %ebp, %ebp
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6ec4
incl %ebp
cmpl (%r14), %ebp
jb 0x85a7
movq 0x8(%rsp), %rdi
callq 0x3270
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x85e5
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x3270
movq %rbx, %rdi
callq 0x6ff6
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O1/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 0x96e3
cmpl $0x0, (%rbp)
je 0xa18e
xorl %ebx, %ebx
movl %ebx, %ebx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rbx, %rdx
jbe 0xa19d
cmpl $0x0, (%rax,%rbx,4)
je 0xa183
movq (%r15), %rcx
movq 0x8(%r15), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rbx, %rdx
jbe 0xa19d
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
cmpq %rbx, %rdx
jbe 0xa19d
movq %rbx, %r13
shlq $0x4, %r13
movq (%rax,%r13), %rdx
addq %r13, %rax
testq %rdx, %rdx
je 0xa12a
movq 0x50(%rsp), %rsi
movsd (%rsi), %xmm0
movq 0x8(%rax), %rsi
movq 0x8(%rcx,%r13), %rcx
xorl %edi, %edi
movsd (%rcx,%rdi,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%rsi,%rdi,8), %xmm1
movsd %xmm1, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0xa10f
movq 0x8(%rax), %rdi
movq 0x40(%rsp), %rsi
callq 0x84e9
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
cmpq %rbx, %rdx
jbe 0xa19d
movq 0x8(%rax,%r13), %rdi
movsd %xmm0, (%rdi)
addq $0x8, %rdi
movq 0x48(%rsp), %rsi
callq 0x84e9
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
cmpq %rbx, %rdx
jbe 0xa19d
movq 0x8(%rax,%r13), %rax
movsd %xmm0, 0x8(%rax)
incl %ebx
cmpl (%rbp), %ebx
jb 0xa095
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11b1(%rip), %rdi      # 0xb355
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
testq %rax, %rax
je 0x2540
movq (%rsi), %rdx
xorl %esi, %esi
xorl %ecx, %ecx
movsbl (%rdx,%rsi), %r8d
addl %r8d, %ecx
incq %rsi
cmpq %rsi, %rax
jne 0x252e
jmp 0x2542
xorl %ecx, %ecx
movl %ecx, 0x1c(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x28(%rbx), %rdi
cmpq %rdi, 0x30(%rbx)
je 0x2915
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %r12d, %r12d
cmpq $0x0, 0x10(%rdi,%r15)
jne 0x285f
cmpq $0x0, 0x18(%rdi,%r15)
je 0x287f
incq %r12
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r15
cmpq %rax, %r12
jb 0x284f
jmp 0x290b
movl 0x8(%rdi,%r15), %eax
cmpl 0xc(%rbx), %eax
jg 0x2893
movl 0xc(%rdi,%r15), %eax
cmpl 0x10(%rbx), %eax
jle 0x285f
addq %r15, %rdi
movq 0x14(%rbx), %rsi
callq 0x22e0
testb %al, %al
je 0x285f
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rsi
movq 0x10(%rax,%r15), %rdx
cmpq 0x38(%rbx), %rsi
je 0x28cb
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x30(%rbx)
jmp 0x28d3
movq %r14, %rdi
callq 0x2290
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rsi
movq 0x18(%rax,%r15), %rdx
cmpq 0x38(%rbx), %rsi
je 0x28fb
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x30(%rbx)
jmp 0x2903
movq %r14, %rdi
callq 0x2290
movb $0x1, %r13b
jmp 0x285f
testb $0x1, %r13b
jne 0x2838
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2973
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x26bf(%rip), %r14      # 0x5018
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2370
movl 0x4(%rbx), %eax
addl $0x3, %eax
incl %ebp
cmpl %eax, %ebp
jl 0x295c
cmpl $-0x3, 0x8(%rbx)
jl 0x299c
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 0x2985
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x29aa
callq 0x2210
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29b9
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x29ca
callq 0x2210
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d97
cmpq $0x0, 0x18(%rbx)
je 0x3d97
xorl %eax, %eax
jmp 0x3e92
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
setge %al
jl 0x3e92
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 0x3e3d
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 0x3e81
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
orq %rdi, %rax
je 0x3edc
testq %rdi, %rdi
je 0x3ed1
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2320
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x3eb4
jmp 0x3f30
cmpl %r15d, 0x8(%r14)
jg 0x3f30
shrq $0x20, %r15
cmpl %r15d, 0xc(%r14)
jg 0x3f30
movl 0x32ee(%rip), %eax      # 0x71e0
incl %eax
movl %eax, 0x32e6(%rip)      # 0x71e0
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movl %eax, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3f25
movl 0x10(%rsp), %eax
movl %eax, 0x10(%rsi)
movaps (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x14, 0x8(%rbx)
jmp 0x3f30
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x2130
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xa, -0x34(%rbp)
movl $0x64, -0x30(%rbp)
movl $0xffffffce, %r15d      # imm = 0xFFFFFFCE
xorl %ebx, %ebx
movl $0xa, -0x2c(%rbp)
xorl %r14d, %r14d
movq 0x2dc4(%rip), %rdi      # 0x3fd8
movl %ebx, %esi
callq 0x1090
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0xde1(%rip), %rsi       # 0x200e
callq 0x1070
addl -0x34(%rbp), %r15d
testl %r15d, %r15d
jle 0x1268
incl %r14d
cmpl -0x2c(%rbp), %r14d
jne 0x1274
xorl %r14d, %r14d
leaq 0xdb6(%rip), %rsi       # 0x2004
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x30(%rbp)
xorl %r15d, %r15d
jmp 0x127f
leaq 0xd9b(%rip), %r13       # 0x200a
movq %r13, %rsi
jmp 0x1286
subl -0x30(%rbp), %r15d
leaq 0xd85(%rip), %rsi       # 0x2004
leaq 0xd84(%rip), %r13       # 0x200a
movl $0x5, %edx
movq %r12, %rdi
callq 0x1070
cmpl -0x2c(%rbp), %r14d
leaq 0xd72(%rip), %rax       # 0x2010
cmoveq %rax, %r13
movl $0x5, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1070
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r12, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
incl %ebx
cmpl $0x78, %ebx
jne 0x120d
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_O1/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 0x32852(%rip), %rdx     # 0x53548
leaq 0x32843(%rip), %r14     # 0x53540
leaq 0x2468d(%rip), %rcx     # 0x45391
movl $0x6, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x8(%rsp), %rdx
movl $0x2, (%rdx)
leaq 0x1e7c3(%rip), %rsi     # 0x3f4e9
movq %r14, %rdi
callq 0x20f1d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x21020
movq %r14, %rdi
movl $0x32, %esi
callq 0x210f2
leaq 0x8(%rsp), %rdi
callq 0x212d0
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x212d0
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb87d
movq 0x2a7cd(%rip), %r14     # 0x35ff0
leaq 0x1e86d(%rip), %rsi     # 0x2a097
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 0x2a79b(%rip), %rdi     # 0x35ff0
callq 0x5030
movq %rax, %rdi
callq 0x5160
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1efef(%rip), %rdx     # 0x2a85f
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xc126
jmp 0xb8f7
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 0xbdce
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 0xc126
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb8f7
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 0xb915
jmp 0xb933
jmp 0xb933
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb936
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5200
jmp 0xb936
jmp 0xb933
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x50a0
movq %rbx, %rdi
callq 0x53b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xada8
movl %eax, %ebp
addl $-0x5, %ebp
cmpl $0x14, %ebp
ja 0xad99
movq %r14, %rdi
callq 0xada8
movb %al, (%rbx)
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e4aa
vmovaps (%r14), %xmm0
vxorps %xmm1, %xmm1, %xmm1
vmovaps %xmm1, (%r14)
movq 0x38(%rbx), %rdi
vmovups %xmm0, 0x30(%rbx)
testq %rdi, %rdi
je 0xad6f
callq 0xb01a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xad7e
callq 0xb01a
movsbl (%rbx), %esi
imull %esi, %esi
movw %si, 0x2(%rbx)
leaq 0x10(%rbx), %rdi
callq 0xae28
movq %rbx, %rdi
callq 0xae5c
cmpl $0x15, %ebp
setb %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x78fd0000, 0x4(%rdi)  # imm = 0x78FD0000
leaq 0x2804e(%rip), %rax     # 0x32ec2
movb (%rax), %al
movb %al, 0x8(%rdi)
leaq 0x28046(%rip), %rax     # 0x32ec6
movb (%rax), %al
movb %al, 0x9(%rdi)
movq $0x0, 0x28(%rdi)
cmpb $0x0, (%rdi)
jle 0xaf7f
xorl %eax, %eax
movabsq $0xff00ff00ff00, %rsi   # imm = 0xFF00FF00FF00
movabsq $0xff00ff00ff, %r8      # imm = 0xFF00FF00FF
movsbl (%rdi), %r11d
testl %r11d, %r11d
jle 0xaf72
movsbl %al, %r9d
xorl %r10d, %r10d
movl %r11d, %ecx
imull %r9d, %ecx
movsbl %r10b, %ebx
addl %ecx, %ebx
leaq 0x27fed(%rip), %rcx     # 0x32ec1
movb (%rcx), %bpl
leaq 0x27fe2(%rip), %rcx     # 0x32ec0
movb (%rcx), %r15b
movl %eax, %ecx
imull %r11d, %ecx
addl %r10d, %ecx
movswq %cx, %rcx
leaq (%rcx,%rcx,2), %r12
movswq %bx, %rbx
shlq $0x5, %r12
addq 0x30(%rdi), %r12
movl $0x3, %r13d
xorl %r14d, %r14d
xorl %ecx, %ecx
cmpl $0xffff0000, (%r12,%rcx) # imm = 0xFFFF0000
movl $0x0, %edx
cmovaeq %r13, %rdx
orq %rdx, %r14
shlq $0x2, %r13
addq $0x4, %rcx
cmpq $0x60, %rcx
jne 0xaf09
cmpl %r11d, %eax
movzbl %bpl, %ecx
movzbl %r15b, %edx
cmovll %ecx, %edx
movq %r14, %rcx
shlq $0x8, %rcx
andq %rsi, %rcx
shrq $0x8, %r14
andq %r8, %r14
orq %rcx, %r14
movq 0x10(%rdi), %rcx
shlq $0x4, %rbx
movb %dl, (%rcx,%rbx)
movb $0x0, 0x1(%rcx,%rbx)
movq %r14, 0x8(%rcx,%rbx)
incl %r10d
movsbl (%rdi), %r11d
cmpl %r11d, %r10d
jl 0xaec0
incl %eax
movsbl (%rdi), %ecx
cmpl %ecx, %eax
jl 0xaeac
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/gomoku/agentmcts.cpp
// Function: Morat::Gomoku::AgentMCTS::AgentMCTS(Morat::Gomoku::Board const&)
AgentMCTS::AgentMCTS(const Board & b) : Agent(b), pool(this) {
	nodes = 0;
	runs = 0;
	gclimit = 5;

	profile     = false;
	ponder      = false;
//#ifdef SINGLE_THREAD ... make sure only 1 thread
	numthreads  = 1;
	pool.set_num_threads(numthreads);
	maxmem      = 1000*1024*1024;

	msrave      = -2;
	msexplore   = 0;

	explore     = 0;
	parentexplore = false;
	ravefactor  = 500;
	decrrave    = 200;
	knowledge   = true;
	userave     = 1;
	useexplore  = 1;
	fpurgency   = 1;
	rollouts    = 1;
	dynwiden    = 0;
	logdynwiden = (dynwiden ? std::log(dynwiden) : 0);

	shortrave   = false;
	keeptree    = true;
	minimax     = 2;
	visitexpand = 1;
	gcsolved    = 100000;

	localreply  = 0;
	locality    = 0;

	weightedrandom = false;
	lastgoodreply  = false;

	for(int i = 0; i < 4096; i++)
		gammas[i] = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x11d56
leaq 0x36b11(%rip), %rax     # 0x45890
movq %rax, (%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x40c0(%rbx)
movw $0x0, 0x40e0(%rbx)
leaq 0x24128(%rip), %rax     # 0x32ec6
movb (%rax), %al
movb %al, 0x40e2(%rbx)
movl $0xfc78fd00, 0x40e3(%rbx) # imm = 0xFC78FD00
movb $0x78, 0x40e7(%rbx)
movq $0x0, 0x40e8(%rbx)
leaq 0x4110(%rbx), %r14
movq %r14, %rdi
vzeroupper
callq 0x11dc0
leaq 0x54d0(%rbx), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x11e52
xorl %eax, %eax
movq %rax, 0x40f0(%rbx)
movq %rax, 0x4100(%rbx)
movl $0x5, 0x40f8(%rbx)
movb %al, 0x60(%rbx)
movb %al, 0x50(%rbx)
movl $0x1, 0x54(%rbx)
movq %r12, %rdi
movl $0x1, %esi
callq 0x11ede
movq $0x3e800000, 0x58(%rbx) # imm = 0x3E800000
vmovss 0x203ae(%rip), %xmm0    # 0x2f1d8
vmovlps %xmm0, 0x64(%rbx)
movb $0x0, 0x6c(%rbx)
vmovsd 0x20425(%rip), %xmm0    # 0x2f260
vmovsd %xmm0, 0x70(%rbx)
movl $0x43480000, 0x78(%rbx) # imm = 0x43480000
movb $0x1, 0x7c(%rbx)
vbroadcastss 0x20388(%rip), %xmm0 # 0x2f1dc
vmovlps %xmm0, 0x80(%rbx)
movabsq $0x13f800000, %rax      # imm = 0x13F800000
movq %rax, 0x88(%rbx)
movq $0x0, 0x90(%rbx)
movw $0x100, 0x98(%rbx)      # imm = 0x100
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rax, 0x9c(%rbx)
movl $0x186a0, 0xa4(%rbx)    # imm = 0x186A0
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0xac(%rbx)
xorl %eax, %eax
vbroadcastss 0x20328(%rip), %zmm0 # 0x2f1dc
vmovups %zmm0, 0xbc(%rbx,%rax,4)
addq $0x10, %rax
cmpq $0x1000, %rax           # imm = 0x1000
jne 0xeeb4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
vzeroupper
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x12076
jmp 0xeeea
movq %rax, %r15
movq %r14, %rdi
callq 0x120b8
jmp 0xeef7
movq %rax, %r15
leaq 0x40c0(%rbx), %rdi
callq 0x12102
movq %rbx, %rdi
callq 0x13354
movq %r15, %rdi
callq 0x5670
nop