LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movl 0x87db(%rip), %edi      # 0x17628
xorl %esi, %esi
movl %esi, -0x5c(%rbp)
callq 0x42d0
movq 0x8162(%rip), %rax      # 0x16fc0
movq %rax, -0x58(%rbp)
movq (%rax), %rdi
callq 0x4440
movl -0x5c(%rbp), %eax
leaq 0x1f00(%rip), %rdi      # 0x10d74
callq 0x43e0
callq 0x4700
callq 0x4140
movq -0x58(%rbp), %rax
movq (%rax), %rdi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movl $0x12, %edx
callq 0x4630
callq 0x4490
movl -0x5c(%rbp), %esi
movl 0x877e(%rip), %edi      # 0x17628
callq 0x42d0
movq -0x58(%rbp), %rax
movq (%rax), %rdi
callq 0x4440
leaq -0x21(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x4740
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x5e40
jmp 0xeedb
leaq -0x21(%rbp), %rdi
callq 0x4450
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x4450
movq -0x30(%rbp), %rdi
callq 0x4730
nopl (%rax)
// File: Linkerist[P]xs/src/ui.cc
// Function: last_dirname(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string
last_dirname(string path)
{
 if (path.at(path.size() - 1) == '/')
  path = path.substr(0, path.size() - 1);

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

 return dirname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq %rax, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x42c0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x47c0
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xef8a
movq -0x40(%rbp), %rdi
callq 0x42c0
movq -0x40(%rbp), %rsi
movq %rax, %rcx
subq $0x1, %rcx
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x4400
movq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x44f0
leaq -0x30(%rbp), %rdi
callq 0x4828
movq -0x40(%rbp), %rdi
movb $0x0, -0x31(%rbp)
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x47b0
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
movq $-0x1, %rcx
callq 0x4400
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0xefd1
movq -0x50(%rbp), %rdi
callq 0x4828
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x8636(%rip), %edi      # 0x17624
xorl %esi, %esi
callq 0x42d0
movq 0x7fc4(%rip), %rax      # 0x16fc0
movq (%rax), %rdi
callq 0x4440
movl 0x861a(%rip), %edi      # 0x17624
xorl %esi, %esi
callq 0x42d0
movq 0x7fa8(%rip), %rax      # 0x16fc0
movq (%rax), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x4200
leaq -0x20(%rbp), %rdi
callq 0x4590
leaq 0x855f(%rip), %rax      # 0x17598
cmpl $0x0, (%rax)
jne 0xf067
leaq 0x22d3(%rip), %rsi      # 0x11318
leaq -0x20(%rbp), %rdi
callq 0x4580
jmp 0xf050
movb $0x4c, -0x21(%rbp)
jmp 0xf07d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xf145
leaq 0x22af(%rip), %rsi      # 0x1131d
leaq -0x20(%rbp), %rdi
callq 0x4580
jmp 0xf079
movb $0x42, -0x21(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x51b0
jmp 0xf088
movq 0x7f31(%rip), %rax      # 0x16fc0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x200000, %esi         # imm = 0x200000
callq 0x4200
jmp 0xf0a2
movsbl -0x21(%rbp), %eax
movl %eax, -0x5c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x41a0
movl -0x5c(%rbp), %esi
movq %rax, %rdx
leaq 0x2265(%rip), %rdi      # 0x11324
xorl %eax, %eax
callq 0x43e0
jmp 0xf0c8
movq 0x7ef1(%rip), %rax      # 0x16fc0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x200000, %esi         # imm = 0x200000
callq 0x4520
jmp 0xf0e2
movq 0x7ed7(%rip), %rax      # 0x16fc0
movq (%rax), %rdi
movl 0x8526(%rip), %edx      # 0x17618
movl $0x20, %esi
callq 0x4360
jmp 0xf0fe
movq 0x7ebb(%rip), %rax      # 0x16fc0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x40000, %esi          # imm = 0x40000
callq 0x4520
jmp 0xf118
leaq -0x58(%rbp), %rdi
callq 0x4828
leaq -0x20(%rbp), %rdi
callq 0x4828
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4828
leaq -0x20(%rbp), %rdi
callq 0x4828
movq -0x30(%rbp), %rdi
callq 0x4730
nopw (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movl $0x0, 0x84(%rsp)
movl %edi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8830
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0x8680
jmp 0x9141
leaq 0x57(%rsp), %rdi
callq 0x8540
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x81a0
jmp 0x915c
leaq 0x20(%rsp), %rdi
callq 0x8d20
jmp 0x9168
leaq 0x20(%rsp), %rdi
callq 0x8928
movq 0x66e57(%rip), %rdi     # 0x6ffd0
leaq 0x47ee9(%rip), %rsi     # 0x51069
callq 0x84e0
movq %rax, 0x8(%rsp)
jmp 0x918c
movq 0x8(%rsp), %rdi
movq 0x66e08(%rip), %rsi     # 0x6ffa0
callq 0x8520
jmp 0x919f
movl $0x0, 0x84(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x8928
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x8540
jmp 0x920f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x9205
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8928
leaq 0x58(%rsp), %rdi
callq 0x8928
movq 0x48(%rsp), %rdi
callq 0x8820
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x7ffe(%rip)      # 0xb2d0
je 0x334a
movl -0x4(%rbp), %edx
leaq 0x411e(%rip), %rax      # 0x73fc
leaq 0x411b(%rip), %rcx      # 0x7400
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl 0x7ffe(%rip), %edx      # 0xb2f8
addl $0x1, %edx
movq 0x7e74(%rip), %rax      # 0xb178
movq (%rax), %rcx
leaq 0x40f5(%rip), %rdi      # 0x7403
movb $0x0, %al
callq 0x2100
cmpl $0x0, -0x4(%rbp)
jne 0x3345
cmpl $0x0, 0x7fda(%rip)      # 0xb2fc
je 0x3345
leaq 0x40e4(%rip), %rdi      # 0x740f
movb $0x0, %al
callq 0x2100
callq 0x5f90
leaq 0x4298(%rip), %rdi      # 0x75d6
movb $0x0, %al
callq 0x2100
jmp 0x33dd
movl -0x4(%rbp), %edx
movl $0x5, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %edx
leaq 0x40b5(%rip), %rax      # 0x741f
leaq 0x40ab(%rip), %rcx      # 0x741c
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, -0x20(%rbp)
leaq 0x40a3(%rip), %rdi      # 0x7426
movb $0x0, %al
callq 0x2100
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rdx
leaq 0x3cb9(%rip), %rsi      # 0x7051
movb $0x0, %al
callq 0x3470
leaq 0x4083(%rip), %rdi      # 0x7429
movb $0x0, %al
callq 0x2100
cmpl $0x0, -0x4(%rbp)
jne 0x33cf
cmpl $0x0, 0x7f42(%rip)      # 0xb2fc
je 0x33cf
leaq 0x4d1c(%rip), %rdi      # 0x80df
movb $0x0, %al
callq 0x2100
callq 0x5f90
leaq 0x4200(%rip), %rdi      # 0x75d6
movb $0x0, %al
callq 0x2100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreRenaud[P]simple_options/./acutest.h
// Function: acutest_abort_
void
acutest_abort_(void)
{
    if(acutest_abort_has_jmp_buf_) {
        longjmp(acutest_abort_jmp_buf_, 1);
    } else {
        if(acutest_current_test_ != NULL)
            acutest_fini_(acutest_current_test_->name);
        abort();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x7669(%rip)      # 0xb1d4
je 0x3b7e
leaq 0x766c(%rip), %rdi      # 0xb1e0
movl $0x1, %esi
callq 0x21e0
cmpq $0x0, 0x75f2(%rip)      # 0xb178
je 0x3b97
movq 0x75e9(%rip), %rax      # 0xb178
movq (%rax), %rdi
callq 0x3ba0
callq 0x2050
nopl (%rax)
// File: AndreRenaud[P]simple_options/./acutest.h
// Function: acutest_remember_
static void
acutest_remember_(int i)
{
    if(acutest_test_data_[i].flags & ACUTEST_FLAG_RUN_)
        return;

    acutest_test_data_[i].flags |= ACUTEST_FLAG_RUN_;
    acutest_count_++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x6772(%rip), %rax      # 0xb2c0
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4b66
jmp 0x4b92
movq 0x6753(%rip), %rax      # 0xb2c0
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl (%rax), %ecx
orl $0x1, %ecx
movb %cl, (%rax)
movq 0x6741(%rip), %rax      # 0xb2c8
addq $0x1, %rax
movq %rax, 0x6736(%rip)      # 0xb2c8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreRenaud[P]simple_options/./acutest.h
// Function: acutest_is_tracer_present_
static int
acutest_is_tracer_present_(void)
{
    /* Must be large enough so the line 'TracerPid: ${PID}' can fit in. */
    static const int OVERLAP = 32;

    char buf[256+OVERLAP+1];
    int tracer_present = 0;
    int fd;
    size_t n_read = 0;

    fd = open("/proc/self/status", O_RDONLY);
    if(fd == -1)
        return 0;

    while(1) {
        static const char pattern[] = "TracerPid:";
        const char* field;

        while(n_read < sizeof(buf) - 1) {
            ssize_t n;

            n = read(fd, buf + n_read, sizeof(buf) - 1 - n_read);
            if(n <= 0)
                break;
            n_read += n;
        }
        buf[n_read] = '\0';

        field = strstr(buf, pattern);
        if(field != NULL  &&  field < buf + sizeof(buf) - OVERLAP) {
            pid_t tracer_pid = (pid_t) atoi(field + sizeof(pattern) - 1);
            tracer_present = (tracer_pid != 0);
            break;
        }

        if(n_read == sizeof(buf)-1) {
            memmove(buf, buf + sizeof(buf)-1 - OVERLAP, OVERLAP);
            n_read = OVERLAP;
        } else {
            break;
        }
    }

    close(fd);
    return tracer_present;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rsp, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x3106(%rip), %rdi      # 0x7cce
xorl %esi, %esi
movb $0x0, %al
callq 0x2200
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x4bed
movl $0x0, -0x4(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0x4cf8
jmp 0x4bef
jmp 0x4bf1
jmp 0x4bf3
cmpq $0x120, -0x20(%rbp)     # imm = 0x120
jae 0x4c34
movl -0x18(%rbp), %edi
leaq -0x160(%rbp), %rsi
addq -0x20(%rbp), %rsi
movl $0x120, %edx            # imm = 0x120
subq -0x20(%rbp), %rdx
callq 0x2140
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jg 0x4c26
jmp 0x4c34
movq -0x38(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4bf3
movq -0x20(%rbp), %rax
movb $0x0, -0x160(%rbp,%rax)
leaq -0x160(%rbp), %rdi
leaq 0x24f2(%rip), %rsi      # 0x7140
callq 0x2270
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4c9e
movq -0x30(%rbp), %rax
leaq -0x160(%rbp), %rcx
addq $0x121, %rcx            # imm = 0x121
addq $-0x20, %rcx
cmpq %rcx, %rax
jae 0x4c9e
movq -0x30(%rbp), %rdi
addq $0xb, %rdi
addq $-0x1, %rdi
callq 0x2220
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0x4ce3
cmpq $0x120, -0x20(%rbp)     # imm = 0x120
jne 0x4cdc
leaq -0x160(%rbp), %rax
addq $0x121, %rax            # imm = 0x121
addq $-0x1, %rax
addq $-0x20, %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, -0x150(%rbp)
movaps %xmm0, -0x160(%rbp)
movq $0x20, -0x20(%rbp)
jmp 0x4cde
jmp 0x4ce3
jmp 0x4bef
movl -0x18(%rbp), %edi
callq 0x2130
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x30(%rbp), %rdi
leaq 0x2dcd(%rip), %rsi      # 0x82f0
movl $0x23, %edx
callq 0x21a0
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x4, %edx
callq 0x2f00
movl %eax, -0x34(%rbp)
cmpl $0x4, -0x34(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2939(%rip), %rsi      # 0x7e8e
movl $0x29, %edx
leaq 0x1af0(%rip), %rcx      # 0x7051
leaq 0x2ad2(%rip), %r8       # 0x803a
movb $0x0, %al
callq 0x3080
movq -0x60(%rbp), %rdi
leaq 0x2aca(%rip), %rsi      # 0x8044
callq 0x2170
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x28fd(%rip), %rsi      # 0x7e8e
movl $0x2a, %edx
leaq 0x1ab4(%rip), %rcx      # 0x7051
leaq 0x2aa8(%rip), %r8       # 0x804c
movb $0x0, %al
callq 0x3080
movq -0x58(%rbp), %rdi
leaq 0x2ab6(%rip), %rsi      # 0x806c
callq 0x2170
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x28c1(%rip), %rsi      # 0x7e8e
movl $0x2b, %edx
leaq 0x1a78(%rip), %rcx      # 0x7051
leaq 0x2a91(%rip), %r8       # 0x8071
movb $0x0, %al
callq 0x3080
movq -0x50(%rbp), %rdi
leaq 0x2a9c(%rip), %rsi      # 0x808e
callq 0x2170
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2885(%rip), %rsi      # 0x7e8e
movl $0x2c, %edx
leaq 0x1a3c(%rip), %rcx      # 0x7051
leaq 0x2a77(%rip), %r8       # 0x8093
movb $0x0, %al
callq 0x3080
movq -0x48(%rbp), %rdi
leaq 0x2a82(%rip), %rsi      # 0x80b0
callq 0x2170
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2849(%rip), %rsi      # 0x7e8e
movl $0x2d, %edx
leaq 0x1a00(%rip), %rcx      # 0x7051
leaq 0x2a5d(%rip), %r8       # 0x80b5
movb $0x0, %al
callq 0x3080
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreRenaud[P]simple_options/simple_options_test.c
// Function: bad_strings
static void bad_strings(void)
{
	int argc;
	const char *argv[4];

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x31(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x2120
leaq -0x31(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x4, %edx
callq 0x2f00
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x27de(%rip), %rsi      # 0x7e8e
movl $0x37, %edx
leaq 0x1995(%rip), %rcx      # 0x7051
leaq 0x2a0f(%rip), %r8       # 0x80d2
movb $0x0, %al
callq 0x3080
movl 0x2a0c(%rip), %eax      # 0x80dc
movl %eax, -0x37(%rbp)
movw 0x2a06(%rip), %ax       # 0x80e0
movw %ax, -0x33(%rbp)
leaq -0x37(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x4, %edx
callq 0x2f00
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2788(%rip), %rsi      # 0x7e8e
movl $0x3b, %edx
leaq 0x193f(%rip), %rcx      # 0x7051
leaq 0x29b9(%rip), %r8       # 0x80d2
movb $0x0, %al
callq 0x3080
movq 0x29bb(%rip), %rax      # 0x80e2
movq %rax, -0x43(%rbp)
movl 0x29b9(%rip), %eax      # 0x80ea
movl %eax, -0x3b(%rbp)
leaq -0x43(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x4, %edx
callq 0x2f00
movl %eax, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2732(%rip), %rsi      # 0x7e8e
movl $0x3f, %edx
leaq 0x18e9(%rip), %rcx      # 0x7051
leaq 0x297f(%rip), %r8       # 0x80ee
movb $0x0, %al
callq 0x3080
movq -0x30(%rbp), %rdi
leaq 0x26df(%rip), %rsi      # 0x7e60
callq 0x2170
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x26f6(%rip), %rsi      # 0x7e8e
movl $0x40, %edx
leaq 0x18ad(%rip), %rcx      # 0x7051
leaq 0x294d(%rip), %r8       # 0x80f8
movb $0x0, %al
callq 0x3080
movl 0x295e(%rip), %eax      # 0x8116
movl %eax, -0x4a(%rbp)
movw 0x2958(%rip), %ax       # 0x811a
movw %ax, -0x46(%rbp)
movb 0x2950(%rip), %al       # 0x811c
movb %al, -0x44(%rbp)
leaq -0x4a(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x4, %edx
callq 0x2f00
movl %eax, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2697(%rip), %rsi      # 0x7e8e
movl $0x44, %edx
leaq 0x184e(%rip), %rcx      # 0x7051
leaq 0x28e4(%rip), %r8       # 0x80ee
movb $0x0, %al
callq 0x3080
movq -0x30(%rbp), %rdi
leaq 0x28fa(%rip), %rsi      # 0x8116
callq 0x2170
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x265b(%rip), %rsi      # 0x7e8e
movl $0x45, %edx
leaq 0x1812(%rip), %rcx      # 0x7051
leaq 0x28d7(%rip), %r8       # 0x811d
movb $0x0, %al
callq 0x3080
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x60(%rbp), %rdi
leaq 0x51ea(%rip), %rsi      # 0xace0
movl $0x60, %edx
callq 0x21a0
movq 0x5239(%rip), %rax      # 0xad40
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movl $0x1, %edi
callq 0x2660
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x235f(%rip), %rsi      # 0x7e8e
movl $0x66, %edx
leaq 0x1516(%rip), %rcx      # 0x7051
leaq 0x263f(%rip), %r8       # 0x8181
movb $0x0, %al
callq 0x3080
movq 0x5200(%rip), %rax      # 0xad50
movq %rax, -0x80(%rbp)
movq 0x51fd(%rip), %rax      # 0xad58
movq %rax, -0x78(%rbp)
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movl $0x2, %edi
callq 0x2660
cmpl $0x0, %eax
setge %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x230b(%rip), %rsi      # 0x7e8e
movl $0x68, %edx
leaq 0x14c2(%rip), %rcx      # 0x7051
leaq 0x260e(%rip), %r8       # 0x81a4
movb $0x0, %al
callq 0x3080
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x235b(%rip), %rax      # 0x817d
movq %rax, -0xa0(%rbp)
movb $0x66, -0x98(%rbp)
movq $0x0, -0x90(%rbp)
movl $0x4, -0x88(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x78(%rbp)
leaq 0x2008(%rip), %rax      # 0x7e60
movq %rax, -0x70(%rbp)
movb $0x6e, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
movl $0x4, -0x58(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x48(%rbp)
leaq -0xa0(%rbp), %rdi
addq $0x60, %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2120
movq 0x4f37(%rip), %rax      # 0xadd0
movq %rax, -0xc0(%rbp)
movq 0x4f31(%rip), %rax      # 0xadd8
movq %rax, -0xb8(%rbp)
movq 0x4f2b(%rip), %rax      # 0xade0
movq %rax, -0xb0(%rbp)
leaq -0xc0(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
movl $0x3, %edi
callq 0x2660
cmpl $0x0, %eax
setge %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1fa8(%rip), %rsi      # 0x7e8e
movl $0x8f, %edx
leaq 0x115f(%rip), %rcx      # 0x7051
leaq 0x2391(%rip), %r8       # 0x828a
movb $0x0, %al
callq 0x3080
movq -0x10(%rbp), %rdi
leaq 0x237a(%rip), %rsi      # 0x8285
callq 0x2170
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1f6c(%rip), %rsi      # 0x7e8e
movl $0x90, %edx
leaq 0x1123(%rip), %rcx      # 0x7051
leaq 0x2376(%rip), %r8       # 0x82ab
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rdi
leaq 0x232f(%rip), %rsi      # 0x8276
callq 0x2170
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1f30(%rip), %rsi      # 0x7e8e
movl $0x91, %edx
leaq 0x10e7(%rip), %rcx      # 0x7051
leaq 0x2355(%rip), %r8       # 0x82c6
movb $0x0, %al
callq 0x3080
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreRenaud[P]simple_options/./acutest.h
// Function: acutest_timer_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
cvtsi2sdq -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x1169(%rip), %xmm0     # 0x7160
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdq -0x18(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdq -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x113c(%rip), %xmm0     # 0x7160
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
cvtsi2sdq -0x8(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd 0x1110(%rip), %xmm1     # 0x7160
divsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreRenaud[P]simple_options/./acutest.h
// Function: acutest_lookup_
static int
acutest_lookup_(const char* pattern)
{
    int i;
    int n = 0;

    /* Try exact match. */
    for(i = 0; i < (int) acutest_list_size_; i++) {
        if(strcmp(acutest_list_[i].name, pattern) == 0) {
            acutest_remember_(i);
            n++;
            break;
        }
    }
    if(n > 0)
        return n;

    /* Try word match. */
    for(i = 0; i < (int) acutest_list_size_; i++) {
        if(acutest_name_contains_word_(acutest_list_[i].name, pattern)) {
            acutest_remember_(i);
            n++;
        }
    }
    if(n > 0)
        return n;

    /* Try relaxed match. */
    for(i = 0; i < (int) acutest_list_size_; i++) {
        if(strstr(acutest_list_[i].name, pattern) != NULL) {
            acutest_remember_(i);
            n++;
        }
    }

    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq 0x4f04(%rip), %rcx      # 0xb2b8
cmpl %ecx, %eax
jge 0x63fb
movslq -0x14(%rbp), %rcx
leaq 0x483d(%rip), %rax      # 0xac00
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2170
cmpl $0x0, %eax
jne 0x63ee
movl -0x14(%rbp), %edi
callq 0x4b40
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x63fb
jmp 0x63f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x63aa
cmpl $0x0, -0x18(%rbp)
jle 0x640c
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x64cd
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq 0x4e9b(%rip), %rcx      # 0xb2b8
cmpl %ecx, %eax
jge 0x6462
movslq -0x14(%rbp), %rcx
leaq 0x47d4(%rip), %rax      # 0xac00
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x64e0
cmpl $0x0, %eax
je 0x6455
movl -0x14(%rbp), %edi
callq 0x4b40
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6457
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6413
cmpl $0x0, -0x18(%rbp)
jle 0x6470
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x64cd
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq 0x4e37(%rip), %rcx      # 0xb2b8
cmpl %ecx, %eax
jge 0x64c7
movslq -0x14(%rbp), %rcx
leaq 0x4770(%rip), %rax      # 0xac00
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2270
cmpq $0x0, %rax
je 0x64ba
movl -0x14(%rbp), %edi
callq 0x4b40
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x64bc
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6477
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x410, %rsp            # imm = 0x410
movl %edi, -0x4(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x401, %edx            # imm = 0x401
callq 0x2140
movl -0x4(%rbp), %edi
leaq -0x410(%rbp), %rsi
movl $0x401, %edx            # imm = 0x401
callq 0x2330
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x25f3
leaq 0x4a1f(%rip), %rdi      # 0x7004
movb $0x0, %al
callq 0x2050
xorl %edi, %edi
callq 0x22a0
cmpl $0x0, -0x8(%rbp)
jle 0x260e
leaq -0x410(%rbp), %rsi
leaq 0x4b03(%rip), %rdi      # 0x710a
movb $0x0, %al
callq 0x2050
jmp 0x2610
jmp 0x25ae
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x8be6(%rip), %rdi      # 0xb220
leaq -0x4(%rbp), %rsi
callq 0x3b60
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x26bf
leaq 0x8bcb(%rip), %rax      # 0xb220
movq %rax, -0x20(%rbp)
leaq 0x8bc0(%rip), %rdi      # 0xb220
callq 0x3b90
movq %rax, -0x28(%rbp)
leaq 0x8bb0(%rip), %rdi      # 0xb220
callq 0x3bc0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3bf0
testb $0x1, %al
jne 0x268c
jmp 0x26bd
leaq -0x28(%rbp), %rdi
callq 0x3c20
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3c40
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x3c80
jmp 0x2679
jmp 0x26bf
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
xorq $-0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x48(%rbp), %rdx
movl %eax, %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x2, %edi
movl $0x801, %esi            # imm = 0x801
xorl %edx, %edx
callq 0x2090
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x2783
leaq 0x48a0(%rip), %rdi      # 0x7012
callq 0x21c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2838
movl -0x1c(%rbp), %edi
callq 0x2710
cmpl $0x0, %eax
jge 0x27a6
leaq 0x4895(%rip), %rdi      # 0x702c
callq 0x21c0
movl $0x1, %edi
callq 0x22a0
movl -0x1c(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x20(%rbp), %rcx
movl $0x4, %r8d
callq 0x23c0
cmpl $0x0, %eax
jge 0x27d3
leaq 0x487b(%rip), %rdi      # 0x7049
callq 0x21c0
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2140
movw $0x2, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x8(%rbp), %eax
movzwl %ax, %edi
callq 0x2060
movw %ax, -0x16(%rbp)
movl -0x1c(%rbp), %edi
leaq -0x18(%rbp), %rsi
movl $0x10, %edx
callq 0x2070
cmpl $0x0, %eax
jge 0x282a
leaq 0x4849(%rip), %rdi      # 0x7065
callq 0x21c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2838
movl -0x1c(%rbp), %edi
callq 0x2710
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movslq -0x4(%rsp), %rcx
leaq 0x3d37ec(%rip), %rax    # 0x3d4940
movl $0x1, (%rax,%rcx,4)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
cmpl -0x8(%rsp), %eax
jge 0x1256
movslq -0xc(%rsp), %rcx
leaq 0x3d4763(%rip), %rax    # 0x3d58e0
cvtsi2sdl (%rax,%rcx,4), %xmm0
movsd 0xe7e(%rip), %xmm1      # 0x2008
ucomisd %xmm1, %xmm0
jne 0x1197
jp 0x1197
jmp 0x1244
movslq -0xc(%rsp), %rcx
leaq 0x3d473d(%rip), %rax    # 0x3d58e0
movl (%rax,%rcx,4), %eax
movslq -0x4(%rsp), %rdx
leaq 0x3d85ae(%rip), %rcx    # 0x3d9760
movl (%rcx,%rdx,4), %ecx
movslq -0xc(%rsp), %rsi
leaq 0x3d953f(%rip), %rdx    # 0x3da700
addl (%rdx,%rsi,4), %ecx
movslq -0x4(%rsp), %rsi
leaq 0x2e70(%rip), %rdx      # 0x4040
imulq $0xfa0, %rsi, %rsi      # imm = 0xFA0
addq %rsi, %rdx
movslq -0xc(%rsp), %rsi
subl (%rdx,%rsi,4), %ecx
cmpl %ecx, %eax
jle 0x1244
movslq -0x4(%rsp), %rcx
leaq 0x3d856e(%rip), %rax    # 0x3d9760
movl (%rax,%rcx,4), %edx
movslq -0xc(%rsp), %rcx
leaq 0x3d94ff(%rip), %rax    # 0x3da700
addl (%rax,%rcx,4), %edx
movslq -0x4(%rsp), %rcx
leaq 0x2e30(%rip), %rax      # 0x4040
imulq $0xfa0, %rcx, %rcx      # imm = 0xFA0
addq %rcx, %rax
movslq -0xc(%rsp), %rcx
subl (%rax,%rcx,4), %edx
movslq -0xc(%rsp), %rcx
leaq 0x3d46b2(%rip), %rax    # 0x3d58e0
movl %edx, (%rax,%rcx,4)
movl -0x4(%rsp), %edx
movslq -0xc(%rsp), %rcx
leaq 0x3d563f(%rip), %rax    # 0x3d6880
movl %edx, (%rax,%rcx,4)
jmp 0x1246
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1163
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x60(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x6c(%rbp)
callq 0x34c0
movl %eax, %ecx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jae 0x6f2c
movq -0x60(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3280
movq -0x68(%rbp), %rsi
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3490
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x33e0
movb %al, -0x6d(%rbp)
jmp 0x6eed
leaq -0x48(%rbp), %rdi
callq 0x3140
movb -0x6d(%rbp), %al
testb $0x1, %al
jne 0x6eff
jmp 0x6f1c
movb $0x1, -0x1(%rbp)
jmp 0x6f30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3140
jmp 0x6f3e
jmp 0x6f1e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6ea2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3530
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2fc9(%rip), %rsi      # 0x108c0
movq %rsi, -0x40(%rbp)
callq 0x10880
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x10910
movq -0x8(%rbp), %rdi
callq 0xd530
movq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x10880
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x10910
movq -0x8(%rbp), %rdi
callq 0x10570
movq %rax, %xmm0
movaps 0x6b2b(%rip), %xmm1     # 0x14480
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x6b2f(%rip), %xmm1     # 0x14490
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
leaq -0x38(%rbp), %rdi
xorps %xmm1, %xmm1
callq 0x10a10
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10a40
addq $0x40, %rsp
popq %rbp
retq
nop
// File: dfrodriguezp[P]PiCM-cpp/functions.cc
// Function: sign(double&)
Real sign(Real &x)
{
    if (x < 0)
        return -1.0;
    else if (x > 0)
        return 1.0;
    else
        return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0xd9b4
movsd 0x6ac3(%rip), %xmm0     # 0x14470
movsd %xmm0, -0x8(%rbp)
jmp 0xd9dc
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xd9d4
movsd 0x6643(%rip), %xmm0     # 0x14010
movsd %xmm0, -0x8(%rbp)
jmp 0xd9dc
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x70e0
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %edx
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10b70
jmp 0xdb27
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xdb7a
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x71c0
jmp 0xdb48
jmp 0xdb4a
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xdb2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xdba0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7340
jmp 0xdba0
movb $0x1, -0x19(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7340
testb $0x1, -0x19(%rbp)
jne 0xdb96
movq -0x58(%rbp), %rdi
callq 0x76f0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x76f0
movq -0x40(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq 0x20(%rbp), %r9
movq 0x28(%rbp), %rax
movq %rax, (%rsp)
callq 0xfd80
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq 0x28(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x104ed
movq -0x20(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x110d0
cmpl $0x0, (%rax)
je 0x104dd
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x7c70
movq %rax, %rdi
movq 0x20(%rbp), %rsi
callq 0x118e0
movq %rax, -0x48(%rbp)
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x7c70
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0x11930
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x7c70
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6fb0
movq %rax, %rdi
movq 0x10(%rbp), %rsi
callq 0xda30
movsd %xmm0, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x7c70
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6fb0
movsd -0x58(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x7c70
movq %rax, %rdi
movl $0x1, %esi
callq 0x6fb0
movq %rax, %rdi
movq 0x18(%rbp), %rsi
callq 0xda30
movsd %xmm0, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x7c70
movq %rax, %rdi
movl $0x1, %esi
callq 0x6fb0
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x104df
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x103dc
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x67c0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x6d57
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6b10
movsbl (%rax), %eax
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x6d0e
movq 0x10(%rsp), %rax
movl 0x24(%rsp), %ecx
movl %ecx, 0x1c(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
je 0x7337
movb $0x0, 0x3f(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x28, %rdi
callq 0x6600
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x7332
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x30(%rsp), %rsi
callq 0x6710
cmpq $0x0, 0x10(%rax)
jne 0x731d
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x30(%rsp), %rsi
callq 0x6710
cmpq $0x0, 0x18(%rax)
jne 0x731d
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x30(%rsp), %rsi
callq 0x6710
movq 0x20(%rsp), %rcx
movl 0x8(%rax), %eax
cmpl 0xc(%rcx), %eax
jg 0x728a
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x30(%rsp), %rsi
callq 0x6710
movq 0x20(%rsp), %rcx
movl 0xc(%rax), %eax
cmpl 0x10(%rcx), %eax
jle 0x731d
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x30(%rsp), %rsi
callq 0x6710
movq %rax, %rdi
movq 0x20(%rsp), %rax
movq 0x14(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0x6850
testb $0x1, %al
jne 0x72be
jmp 0x731d
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x8(%rsp)
addq $0x28, %rdi
movq 0x30(%rsp), %rsi
callq 0x6710
movq 0x8(%rsp), %rdi
movq 0x10(%rax), %rsi
callq 0x6ab0
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
addq $0x28, %rdi
movq 0x30(%rsp), %rsi
callq 0x6710
movq 0x10(%rsp), %rdi
movq 0x18(%rax), %rsi
callq 0x6ab0
movb $0x1, 0x3f(%rsp)
jmp 0x731f
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x71e1
jmp 0x71c8
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6760
movl $0x0, 0x1c(%rsp)
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
movl 0x4(%rcx), %ecx
addl $0x4, %ecx
cmpl %ecx, %eax
jge 0x73b2
leaq 0x5c8b(%rip), %rsi      # 0xd008
leaq 0x20(%rsp), %rdi
callq 0x6550
jmp 0x7389
jmp 0x738b
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x7364
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6330
jmp 0x73fe
movl $0x0, 0x8(%rsp)
movq (%rsp), %rcx
movl 0x8(%rsp), %eax
movl 0x8(%rcx), %ecx
addl $0x4, %ecx
cmpl %ecx, %eax
jge 0x73ef
movq (%rsp), %rdi
addq $0x58, %rdi
leaq 0x20(%rsp), %rsi
callq 0x6240
jmp 0x73e0
jmp 0x73e2
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x73ba
leaq 0x20(%rsp), %rdi
callq 0x6330
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x6a10
nopl (%rax,%rax)