LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/app/genipasat/genipasat.c
// Function: die
static void die (const char * fmt, ...) {
  va_list ap;
  fflush (stderr);
  printf ("*** genipasat: ");
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
  exit (1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1cef
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x15302(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
callq 0x1160
leaq 0xe592(%rip), %rdi      # 0x10297
xorl %eax, %eax
callq 0x10c0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movq %r14, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1170
movq 0x15295(%rip), %rbx     # 0x16fd0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1110
movq (%rbx), %rdi
callq 0x1160
movl $0x1, %edi
callq 0x11e0
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/app/genipasat/genipasat.c
// Function: msg
static void msg (const char * fmt, ...) {
  va_list ap;
  fflush (stderr);
  printf ("c [genipasat] ");
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1dbb
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x15236(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
callq 0x1160
leaq 0xe4d6(%rip), %rdi      # 0x102a7
xorl %eax, %eax
callq 0x10c0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movq %r14, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1170
movq 0x151c9(%rip), %rbx     # 0x16fd0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1110
movq (%rbx), %rdi
callq 0x1160
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/app/genipasat/genipasat.c
// Function: pipeit
static FILE * pipeit (const char * name, const char * fmt) {
  char * cmd = malloc (strlen (name) + strlen (fmt) + 20);
  FILE * res;
  sprintf (cmd, fmt, name);
  res = popen (cmd, "r");
  free (cmd);
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x10b0
movq %rax, %r15
movq %rbx, %rdi
callq 0x10b0
leaq (%r15,%rax), %rdi
addq $0x14, %rdi
callq 0x1150
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x11d0
leaq 0x10d87(%rip), %rsi     # 0x12c35
movq %r15, %rdi
callq 0x1190
movq %rax, %rbx
movq %r15, %rdi
callq 0x1040
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/app/genipasat/genipasat.c
// Function: perr
static void perr (const char * fmt, ...) {
  va_list ap;
  fflush (stderr);
  printf ("*** genipasat: parse error in '%s' line '%d': ", name, lineno);
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
  exit (1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1f2b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x150c6(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
callq 0x1160
movq 0x151ef(%rip), %rsi     # 0x17130
movl 0x151d9(%rip), %edx     # 0x17120
leaq 0xe368(%rip), %rdi      # 0x102b6
xorl %eax, %eax
callq 0x10c0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movq %r14, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1170
movq 0x1504c(%rip), %rbx     # 0x16fd0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1110
movq (%rbx), %rdi
callq 0x1160
movl $0x1, %edi
callq 0x11e0
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/app/genipasat/genipasat.c
// Function: getime
static double getime (void) {
  struct rusage u;
  double res;
  if (getrusage (RUSAGE_SELF, &u)) return 0;
  res = u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec;
  res += u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec;
  return res;
}

// Assembly:
subq $0x98, %rsp
leaq 0x8(%rsp), %rsi
xorl %edi, %edi
callq 0x11b0
xorpd %xmm0, %xmm0
testl %eax, %eax
jne 0x1ff9
cvtsi2sdq 0x8(%rsp), %xmm1
cvtsi2sdq 0x10(%rsp), %xmm2
movsd 0xe034(%rip), %xmm3     # 0x10008
mulsd %xmm3, %xmm2
cvtsi2sdq 0x18(%rsp), %xmm4
xorps %xmm0, %xmm0
cvtsi2sdq 0x20(%rsp), %xmm0
addsd %xmm1, %xmm2
mulsd %xmm3, %xmm0
addsd %xmm4, %xmm0
addsd %xmm2, %xmm0
addq $0x98, %rsp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/./eventhandler/timeserver.hpp
// Function: RequestHandler::HandleError()
virtual void HandleError()
    {
        fprintf(stderr, "client %d closed\n", m_handle);
        close(m_handle);
        g_reactor.RemoveHandler(this);
        delete this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x4b61(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
movl 0x8(%rbx), %edx
leaq 0x1ce2(%rip), %rsi      # 0x4166
xorl %eax, %eax
callq 0x2270
movl 0x8(%rbx), %edi
callq 0x2300
leaq 0x5536(%rip), %r15      # 0x79d0
movq (%r15), %r14
testq %r14, %r14
jne 0x24b8
pushq $0x8
popq %rdi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x39e0
movq %r14, (%r15)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x35a4
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/reactor_server_test.cc
// Function: main
int main(int argc, char **argv)
{
    if (argc < 3) {
        fprintf(stderr, "usage: %s ip port\n", argv[0]);
        return EXIT_FAILURE;
    }

    /**
     * 命令行参数，第1个是 IP ，第2个是 port 。
     * （1）启动服务器。
    */
    TimeServer server(argv[1], atoi(argv[2]));
    if (!server.Start()) {
        fprintf(stderr, "start server failed\n");
        return EXIT_FAILURE;
    }
    fprintf(stderr, "server started!\n");

    heap_timer *printtask = new heap_timer(5);
    printtask->cb_func = printHelloworld;

    fprintf(stderr, "register a task which will be run is five seconds!\n");
    g_reactor.RegisterTimerTask(printtask);

    /**
     * （3）向 Reactor 中注册事件处理器：server 。
    */
    g_reactor.RegisterHandler(&server, reactor::kReadEvent);

    while (true) {
        /**
         * （4）监控并分发事件到各个事件处理器。
        */
        g_reactor.HandleEvents();
    }
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpl $0x2, %edi
jg 0x26ae
movq %rsi, %rdi
callq 0x241e
jmp 0x275e
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %rdi
callq 0x22a0
movl %eax, %ebp
leaq 0x45e4(%rip), %r15      # 0x6ca8
leaq 0x20(%rsp), %rbx
movq %r15, -0x10(%rbx)
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28e6
movw %bp, 0x20(%rbx)
leaq 0x10(%rsp), %rdi
callq 0x2826
movq 0x48e6(%rip), %rcx      # 0x6fd8
movq (%rcx), %rcx
testb %al, %al
je 0x274e
leaq 0x1963(%rip), %rdi      # 0x4063
movl $0x10, %esi
movl $0x1, %edx
callq 0x22f0
movl $0x18, %edi
callq 0x21e0
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x23bf
testb $0x1, %al
je 0x276e
movl $0x8, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x39e0
leaq 0x5287(%rip), %rax      # 0x79d0
movq %r14, (%rax)
jmp 0x2773
leaq 0x10(%rsp), %rsi
movq %rcx, %rdi
movq %rbx, %rdx
callq 0x2377
movl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x3658
leaq 0x524b(%rip), %rbx      # 0x79d0
movq (%rbx), %r14
testq %r14, %r14
jne 0x27a5
movl $0x8, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x39e0
movq %r14, (%rbx)
movq (%r14), %rdi
leaq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x3512
movq (%rbx), %r14
testq %r14, %r14
jne 0x27d7
movl $0x8, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x39e0
movq %r14, (%rbx)
movq (%r14), %rdi
callq 0x3604
jmp 0x27b7
jmp 0x27fb
jmp 0x27e9
jmp 0x27e9
jmp 0x27fb
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x2200
jmp 0x27fe
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq %r15, -0x20(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x281d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/./eventhandler/timeserver.hpp
// Function: TimeServer::Start()
bool Start()
    {
        m_handle = socket(AF_INET, SOCK_STREAM, 0);
        if (!IsValidHandle(m_handle)) {
            ReportSocketError("socket");
            return false;
        }

        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(m_port);
        addr.sin_addr.s_addr = inet_addr(m_ip.c_str());
        if (bind(m_handle, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
            ReportSocketError("bind");
            return false;
        }

        if (listen(m_handle, 10) < 0) {
            ReportSocketError("listen");
            return false;
        }
        return true;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2080
movl %eax, 0x8(%rbx)
testl %eax, %eax
js 0x289e
leaq 0x8(%rsp), %r14
movw $0x2, (%r14)
movzwl 0x30(%rbx), %eax
rolw $0x8, %ax
movw %ax, 0x2(%r14)
movq 0x10(%rbx), %rdi
callq 0x21f0
movl %eax, 0x4(%r14)
movl 0x8(%rbx), %edi
movq %r14, %rsi
movl $0x10, %edx
callq 0x2050
testl %eax, %eax
js 0x28a7
movl 0x8(%rbx), %edi
movl $0xa, %esi
callq 0x2220
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
js 0x28b0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x18d3(%rip), %rdi      # 0x4178
jmp 0x28b7
leaq 0x18d1(%rip), %rdi      # 0x417f
jmp 0x28b7
leaq 0x18cd(%rip), %rdi      # 0x4184
callq 0x2320
xorl %eax, %eax
jmp 0x2896
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/./eventhandler/timeserver.hpp
// Function: TimeServer::HandleRead()
virtual void HandleRead()
    {
        struct sockaddr addr;
        socklen_t addrlen = sizeof(addr);
        reactor::handle_t handle = accept(m_handle, &addr, &addrlen);
        if (!IsValidHandle(handle)) {
            ReportSocketError("accept");
        } else {
            /**
             * 对该新连接注册读写事件。
            */
            RequestHandler *handler = new RequestHandler(handle);
            if (g_reactor.RegisterHandler(handler, reactor::kReadEvent) != 0) {
                fprintf(stderr, "error: register handler failed\n");
                delete handler;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x4(%rsp), %rdx
movl $0x10, (%rdx)
movl 0x8(%rdi), %edi
leaq 0x8(%rsp), %rsi
callq 0x20a0
testl %eax, %eax
js 0x29e4
movl %eax, %ebp
movl $0x10, %edi
callq 0x21e0
movq %rax, %rbx
leaq 0x4378(%rip), %rax      # 0x6d10
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
leaq 0x502b(%rip), %r15      # 0x79d0
movq (%r15), %r14
testq %r14, %r14
jne 0x29c5
movl $0x8, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x39e0
movq %r14, (%r15)
movq (%r14), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x3512
testl %eax, %eax
jne 0x29f2
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16e7(%rip), %rdi      # 0x40d2
callq 0x2320
jmp 0x29d9
movq %rbx, %rdi
callq 0x243c
jmp 0x29d9
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/./eventhandler/timeserver.hpp
// Function: RequestHandler::HandleRead()
virtual void HandleRead()
    {
        memset(g_read_buffer, 0, sizeof(g_read_buffer));
        int len = recv(m_handle, g_read_buffer, BUFFERSIZE, 0);
        if (len > 0) {
            if (strncasecmp("time", g_read_buffer, 4) == 0) {
                g_reactor.RegisterHandler(this, reactor::kWriteEvent);
            } else if (strncasecmp("exit", g_read_buffer, 4) == 0) {
                close(m_handle);
                g_reactor.RemoveHandler(this);
                delete this;
            } else {
                fprintf(stderr, "Invalid request: %s", g_read_buffer);
                close(m_handle);
                g_reactor.RemoveHandler(this);
                delete this;
            }
        } else {
            ReportSocketError("recv");
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x46f3(%rip), %r14      # 0x71c0
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x2130
movl 0x8(%rbx), %edi
movl $0x400, %edx            # imm = 0x400
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x20b0
testl %eax, %eax
jle 0x2bb6
leaq 0x15fc(%rip), %rdi      # 0x40f9
leaq 0x46bc(%rip), %rsi      # 0x71c0
movl $0x4, %edx
callq 0x2240
testl %eax, %eax
je 0x2b7a
leaq 0x15e5(%rip), %rdi      # 0x40fe
leaq 0x46a0(%rip), %rsi      # 0x71c0
movl $0x4, %edx
callq 0x2240
testl %eax, %eax
jne 0x2bc7
movl 0x8(%rbx), %edi
callq 0x2300
leaq 0x4e8f(%rip), %r15      # 0x79d0
movq (%r15), %r14
testq %r14, %r14
jne 0x2b61
movl $0x8, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x39e0
movq %r14, (%r15)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x35a4
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
leaq 0x4e4f(%rip), %r15      # 0x79d0
movq (%r15), %r14
testq %r14, %r14
jne 0x2ba1
movl $0x8, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x39e0
movq %r14, (%r15)
movq (%r14), %rdi
movq %rbx, %rsi
movl $0x2, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x3512
leaq 0x155a(%rip), %rdi      # 0x4117
popq %rbx
popq %r14
popq %r15
jmp 0x2320
movq 0x440a(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
leaq 0x152b(%rip), %rsi      # 0x4103
leaq 0x45e1(%rip), %rdx      # 0x71c0
xorl %eax, %eax
callq 0x2270
movl 0x8(%rbx), %edi
callq 0x2300
leaq 0x4ddb(%rip), %r15      # 0x79d0
movq (%r15), %r14
testq %r14, %r14
jne 0x2b61
movl $0x8, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x39e0
jmp 0x2b5e
jmp 0x2c1f
jmp 0x2c1f
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/./eventhandler/timeserver.hpp
// Function: RequestHandler::HandleWrite()
virtual void HandleWrite()
    {
        struct tm *ttime;
        char now[64];
        time_t tt;

        memset(now, 0, 64);
        tt = time(nullptr);
        ttime = localtime(&tt);
        strftime(now, 64, "%Y-%m-%d %H:%M:%S", ttime);

        memset(g_write_buffer, 0, sizeof(g_write_buffer));
        int len = sprintf(g_write_buffer, "current time: %s\r\n", now);
        len = send(m_handle, g_write_buffer, len, 0);
        if (len > 0) {
            fprintf(stderr, "send response to client, fd=%d\n", (int)m_handle);
            g_reactor.RegisterHandler(this, reactor::kReadEvent);
        } else {
            ReportSocketError("send");
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x30(%r14)
xorl %edi, %edi
callq 0x21d0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x2180
leaq 0x14a2(%rip), %rdx      # 0x411c
movl $0x40, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0x21a0
leaq 0x492f(%rip), %r15      # 0x75c0
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
xorl %esi, %esi
callq 0x2130
leaq 0x1487(%rip), %rsi      # 0x412e
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2070
movl 0x8(%rbx), %edi
movslq %eax, %rdx
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x2110
testl %eax, %eax
jle 0x2d1c
movq 0x4309(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
movl 0x8(%rbx), %edx
leaq 0x1465(%rip), %rsi      # 0x4141
xorl %eax, %eax
callq 0x2270
leaq 0x4ce6(%rip), %r15      # 0x79d0
movq (%r15), %r14
testq %r14, %r14
jne 0x2d0a
movl $0x8, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x39e0
movq %r14, (%r15)
movq (%r14), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x3512
jmp 0x2d28
leaq 0x143e(%rip), %rdi      # 0x4161
callq 0x2320
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/eventDemultiplexer/event_demultiplexer.cc
// Function: reactor::EpollDemultiplexer::RequestEvent(int, unsigned int)
int EpollDemultiplexer::RequestEvent(handle_t handle, event_t evt)
{
    epoll_event ep_evt;
    ep_evt.data.fd = handle;
    ep_evt.events = 0;

    if (evt & kReadEvent) {
        ep_evt.events |= EPOLLIN;
    }
    if (evt & kWriteEvent) {
        ep_evt.events |= EPOLLOUT;
    }
    ep_evt.events |= EPOLLONESHOT;

    if (epoll_ctl(m_epoll_fd, EPOLL_CTL_MOD, handle, &ep_evt) != 0) {
        if (errno == ENOENT) {
            if (epoll_ctl(m_epoll_fd, EPOLL_CTL_ADD, handle, &ep_evt) != 0) {
                return -errno;
            }
            ++m_fd_num;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0xc(%rsp), %rcx
movl %esi, 0x4(%rcx)
movl %edx, %eax
andl $0x1, %eax
andl $0x2, %edx
leal (%rax,%rdx,2), %eax
addl $0x40000000, %eax       # imm = 0x40000000
movl %eax, (%rcx)
movl 0x8(%rdi), %edi
movl $0x3, %esi
movl %r14d, %edx
callq 0x2260
xorl %ebp, %ebp
testl %eax, %eax
je 0x2fd6
callq 0x2040
cmpl $0x2, (%rax)
jne 0x2fd6
movq %rax, %r15
movl 0x8(%rbx), %edi
leaq 0xc(%rsp), %rcx
movl $0x1, %esi
movl %r14d, %edx
callq 0x2260
testl %eax, %eax
je 0x2fd3
xorl %ebp, %ebp
subl (%r15), %ebp
jmp 0x2fd6
incl 0xc(%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/./other/timeheap.hpp
// Function: time_heap::tick()
void tick()
    {
        heap_timer *tmp = array[0];
        time_t cur = time(nullptr);
        while (!empty()) {
            if (!tmp) {
                break;
            }
            if (tmp->expire > cur) {
                break;
            }
            if (array[0]->cb_func) {
                array[0]->cb_func(array[0]->user_data);
            }
            pop_timer();
            tmp = array[0];
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %r15
xorl %edi, %edi
callq 0x21d0
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
je 0x3180
popq %rbx
popq %r14
popq %r15
retq
cmpq %r14, (%r15)
jg 0x317a
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0x319a
movq 0x10(%rcx), %rdi
callq *%rax
movq %rbx, %rdi
callq 0x31b6
cmpq $0x0, 0x10(%rbx)
je 0x317a
movq (%rbx), %rax
movq (%rax), %r15
testq %r15, %r15
jne 0x3180
jmp 0x317a
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/./other/timeheap.hpp
// Function: time_heap::percolate_down(unsigned long)
void percolate_down(size_t hole)
    {
        heap_timer *temp = array[hole];
        size_t child = 0;
        for (; ((hole * 2 + 1) <= (cur_size - 1)); hole = child) {
            child = hole * 2 + 1;
            if ((child < (cur_size - 1)) && (array[child + 1]->expire < array[child]->expire)) {
                ++child;
            }
            if (array[child]->expire < temp->expire) {
                array[hole] = array[child];
            } else {
                break;
            }
        }
        array[hole] = temp;
    }

// Assembly:
pushq %rbx
movq (%rdi), %rdx
movq 0x10(%rdi), %rcx
movq (%rdx,%rsi,8), %rax
decq %rcx
leaq (%rsi,%rsi), %r10
cmpq %rcx, %r10
jae 0x3266
movq (%rax), %r9
movq %r10, %r8
orq $0x1, %r8
movq (%rdi), %rdx
cmpq %rcx, %r8
jae 0x3248
movq 0x10(%rdx,%r10,8), %r11
movq (%r11), %r11
movq (%rdx,%r8,8), %rbx
cmpq (%rbx), %r11
jge 0x3248
addq $0x2, %r10
movq %r10, %r8
movq (%rdx,%r8,8), %r10
cmpq %r9, (%r10)
jge 0x3266
movq %r10, (%rdx,%rsi,8)
leaq (%r8,%r8), %r10
movq %r8, %rsi
cmpq %rcx, %r10
jb 0x3221
movq (%rdi), %rdx
jmp 0x3269
movq %rsi, %r8
movq %rax, (%rdx,%r8,8)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/reactor/reactor.cc
// Function: reactor::ReactorImplementation::RegisterHandler(reactor::EventHandler*, unsigned int)
int ReactorImplementation::RegisterHandler(EventHandler *handler, event_t evt)
{
    if (handler == nullptr) {
        return -1;
    }
    handle_t handle = handler->GetHandle();
    std::map<handle_t, EventHandler *>::iterator it = m_handlers.find(handle);
    if (it == m_handlers.end()) {
        m_handlers[handle] = handler;
    }
    return m_demultiplexer->RequestEvent(handle, evt);
}

// Assembly:
testq %rsi, %rsi
je 0x359e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movl %eax, 0x4(%rsp)
movq 0x18(%r14), %rcx
testq %rcx, %rcx
je 0x356d
leaq 0x10(%r14), %rsi
movq %rsi, %rdx
xorl %edi, %edi
cmpl %eax, 0x20(%rcx)
setl %dil
cmovgeq %rcx, %rdx
movq 0x10(%rcx,%rdi,8), %rcx
testq %rcx, %rcx
jne 0x354c
cmpq %rsi, %rdx
je 0x356d
cmpl 0x20(%rdx), %eax
jge 0x3585
leaq 0x8(%r14), %rdi
leaq 0x4(%rsp), %r12
movq %r12, %rsi
callq 0x30ea
movq %r15, (%rax)
movl (%r12), %eax
movq (%r14), %rdi
movq (%rdi), %rcx
movl %eax, %esi
movl %ebx, %edx
callq *0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/reactor/reactor.cc
// Function: reactor::ReactorImplementation::RemoveHandler(reactor::EventHandler*)
int ReactorImplementation::RemoveHandler(EventHandler *handler)
{
    if (handler == nullptr) {
        return -1;
    }

    handle_t handle = handler->GetHandle();
    m_handlers.erase(handle);
    return m_demultiplexer->UnrequestEvent(handle);
}

// Assembly:
testq %rsi, %rsi
je 0x35fe
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
leaq 0x8(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x38bc
movq %r15, %rdi
movq %rax, %rsi
callq 0x393a
movq (%rbx), %rdi
movl (%r14), %esi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/reactor/reactor.cc
// Function: reactor::ReactorImplementation::HandleEvents()
void ReactorImplementation::HandleEvents()
{
    int timeout = 0;
    if (m_eventtimer->top() == nullptr) {
        timeout = 0;
    } else {
        timeout = ((m_eventtimer->top())->expire - time(nullptr)) * 1000;
    }
    m_demultiplexer->WaitEvents(&m_handlers, timeout, m_eventtimer);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rcx
xorl %edx, %edx
cmpq $0x0, 0x10(%rcx)
je 0x363f
movq (%rcx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x363f
movl (%rax), %ebp
xorl %edi, %edi
callq 0x21d0
subl %eax, %ebp
imull $0x3e8, %ebp, %edx      # imm = 0x3E8
movq 0x38(%rbx), %rcx
movq (%rbx), %rdi
addq $0x8, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/reactor/reactor.cc
// Function: reactor::Reactor::RegisterTimerTask(heap_timer*)
int ReactorImplementation::RegisterTimerTask(heap_timer *timerevent)
{
    if (timerevent == nullptr) {
        return -1;
    }
    m_eventtimer->add_timer(timerevent);
    return 0;
}

// Assembly:
testq %rsi, %rsi
je 0x3671
pushq %rax
movq (%rdi), %rax
movq 0x38(%rax), %rdi
callq 0x3774
xorl %eax, %eax
addq $0x8, %rsp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/./other/timeheap.hpp
// Function: time_heap::add_timer(heap_timer*)
int add_timer(heap_timer *timer)
    {
        if (timer == nullptr) {
            return -1;
        }
        if (cur_size >= capacity) {
            resize();
        }
        int hole = cur_size++;
        int parent = 0;
        for (; hole > 0; hole = parent) {
            parent = (hole - 1) / 2;
            if (array[parent]->expire <= timer->expire) {
                break;
            }
            array[hole] = array[parent];
        }
        array[hole] = timer;
        return 0;
    }

// Assembly:
testq %rsi, %rsi
je 0x37e0
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
cmpq 0x8(%rdi), %rax
jb 0x3799
movq %r14, %rdi
callq 0x3836
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%r14)
testl %eax, %eax
jle 0x37ca
movq (%rbx), %rdx
leal -0x1(%rax), %esi
movl %esi, %ecx
shrl %ecx
movq (%r14), %rdi
movq (%rdi,%rcx,8), %r8
cmpq %rdx, (%r8)
jle 0x37ca
movl %eax, %eax
movq %r8, (%rdi,%rax,8)
movl %ecx, %eax
cmpl $0x1, %esi
ja 0x37a8
jmp 0x37cc
movl %eax, %ecx
movq (%r14), %rax
movslq %ecx, %rcx
movq %rbx, (%rax,%rcx,8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/./other/timeheap.hpp
// Function: time_heap::resize()
void resize()
    {
        heap_timer **temp = new heap_timer *[2 * capacity];
        for (size_t i = 0; i < 2 * capacity; ++i) {
            temp[i] = nullptr;
        }
        if (!temp) {
            throw std::exception();
        }
        capacity = 2 * capacity;
        for (size_t i = 0; i < cur_size; ++i) {
            temp[i] = array[i];
        }
        delete[] array;
        array = temp;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movabsq $0x7000000000000000, %rax # imm = 0x7000000000000000
andq %r12, %rax
movq %r12, %r15
shlq $0x4, %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
callq 0x2030
movq %rax, %r14
addq %r12, %r12
je 0x387e
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2130
movq %r12, 0x8(%rbx)
movq (%rbx), %rdi
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x38a2
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %rdx
movq %rdx, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x3890
jmp 0x38a7
testq %rdi, %rdi
je 0x38ac
callq 0x2250
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rvthak[P]Makefile-Maker/input.cpp
// Function: InputManager(int, char const**, Makefile&)
void InputManager(int argc, char const **argv, Makefile &mk){

	// No parameters
	if(argc==1){ printf(" (i) > No arguments given using defaults..\n"); return; }
	
	// Only one parameter => use it as a name
	else if(argc==2){ 
		if( argv[1][0]!='-' ){
			printf(" (i) > Only one argument given. Using '%s' as a Name\n", argv[1]);
			mk.setName(argv[1]);
			return;
		}
	}

	// More than one parameter
	int count=1; // Start from 2nd argument
	argc=argc-1; // Use argc as a total counter

	while(count<=argc){
		// HandleParameter changes count for ease
		if( HandleParameter(count, argc, argv, mk)!=0 ){ exit(1); } 
	}

	// Compilation Parameter read mode
	if(mk.getCompParam()){ mk.readCompParam(); }

	// Execution Parameter read mode
	if(mk.getExecParam()){ mk.readExecParam(); }

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
cmpl $0x2, %edi
je 0x24a6
cmpl $0x1, %r15d
jne 0x24af
leaq 0x2e92(%rip), %rdi      # 0x5326
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2240
movq 0x8(%r14), %rsi
cmpb $0x2d, (%rsi)
jne 0x2519
leaq 0x10(%rsp), %r12
movl $0x1, (%r12)
leal -0x1(%r15), %eax
leaq 0xc(%rsp), %r13
movl %eax, (%r13)
cmpl %r15d, 0x10(%rsp)
jge 0x24ef
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2597
testl %eax, %eax
je 0x24c9
movl $0x1, %edi
callq 0x21d0
movq %rbx, %rdi
callq 0x3c2e
testb %al, %al
je 0x2503
movq %rbx, %rdi
callq 0x4162
movq %rbx, %rdi
callq 0x3c36
testb %al, %al
je 0x2563
movq %rbx, %rdi
callq 0x41c8
jmp 0x2563
leaq 0x2ae4(%rip), %rdi      # 0x5004
xorl %eax, %eax
callq 0x2040
movq 0x8(%r14), %rsi
leaq 0x10(%rsp), %r14
leaq 0xb(%rsp), %rdx
movq %r14, %rdi
callq 0x34ec
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3cc4
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2563
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2190
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x258f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/rvthak[P]Makefile-Maker/input.cpp
// Function: printInputFormat()
void printInputFormat(void){
	printf("\n          ------ Argument Format ------ \n // Default values on ()\n");
	printf(" >> Set Executable Name:     -n < name (a.out) >\n");
	printf(" >> Set Source file Format:  -f < source file format (.cpp) >\n");
	printf(" >> Set Header file Format:  -h < header file format (.hpp) >\n");
	printf(" >> Set Compiler:            -c < compiler name (g++) >\n");
	printf(" >> Toggle gdb:                     -db  (1)\n");
	printf(" >> Toggle valgrind:                -vg  (1)\n");
	printf(" >> Toggle compilation parameters:  -p   (0)\n");
	printf(" >> Toggle execution parameters:    -e   (0)\n");
	printf(" >> Toggle auto project organizer:  -org (0)\n");
	printf(" >> Print help:                     --help\n");
	
	printf("\n (i)> The <...> fields are REQUIRED right after their corresponding parameter\n");
	printf(" (i)> Rogue Strings and Non-Supported parameters will cause termination\n");
	printf(" (i)> Give Format by writing just the last chars (example: file.c => -f c) \n");
	return;
}

// Assembly:
pushq %rax
leaq 0x27eb(%rip), %rdi      # 0x5351
callq 0x2240
leaq 0x2822(%rip), %rdi      # 0x5394
callq 0x2240
leaq 0x2847(%rip), %rdi      # 0x53c5
callq 0x2240
leaq 0x2879(%rip), %rdi      # 0x5403
callq 0x2240
leaq 0x28ab(%rip), %rdi      # 0x5441
callq 0x2240
leaq 0x28d7(%rip), %rdi      # 0x5479
callq 0x2240
leaq 0x28f8(%rip), %rdi      # 0x54a6
callq 0x2240
leaq 0x2919(%rip), %rdi      # 0x54d3
callq 0x2240
leaq 0x293a(%rip), %rdi      # 0x5500
callq 0x2240
leaq 0x295b(%rip), %rdi      # 0x552d
callq 0x2240
leaq 0x297c(%rip), %rdi      # 0x555a
callq 0x2240
leaq 0x299b(%rip), %rdi      # 0x5585
callq 0x2240
leaq 0x29de(%rip), %rdi      # 0x55d4
callq 0x2240
leaq 0x2a1a(%rip), %rdi      # 0x561c
popq %rax
jmp 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/rvthak[P]Makefile-Maker/main.cpp
// Function: main
int main(int argc, char const **argv){

	// Create a Makefile with default values
	Makefile mk;

	// Parse the user arguments and update Makefile values
	InputManager(argc, argv, mk);

	// Get a list of files from the targeted directory
	SystemInput(mk);

	// Create and write the actual makefile
	Output(mk);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x370c
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x246c
leaq 0x8(%rsp), %rdi
callq 0x2c60
leaq 0x8(%rsp), %rdi
callq 0x42c4
leaq 0x8(%rsp), %rdi
callq 0x362c
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x362c
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/rvthak[P]Makefile-Maker/makefileS.cpp
// Function: Makefile::Makefile(Makefile const&)
Makefile::Makefile(const Makefile &mkfl){
	Name=mkfl.Name;
	Compiler=mkfl.Compiler;
	SourceFormat=mkfl.SourceFormat;
	HeaderFormat=mkfl.HeaderFormat;
	debugEnable=mkfl.debugEnable;
	valgrindEnable=mkfl.valgrindEnable;
	installEnable=mkfl.installEnable;
	parameterEnable=mkfl.parameterEnable;
	execParamEnable=mkfl.execParamEnable;
	organizeEnable=mkfl.organizeEnable;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x30(%rsp)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x28(%rsp)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x20(%rsp)
leaq 0x70(%rdi), %rcx
movq %rcx, (%rsp)
movq %rcx, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0x98(%rdi), %rbp
movq %rbp, 0x88(%rdi)
movq %rax, 0x90(%rdi)
movb %al, 0x98(%rdi)
leaq 0xb8(%rdi), %r15
movq %r15, 0xa8(%rdi)
movq %rax, 0xb0(%rdi)
movb %al, 0xb8(%rdi)
leaq 0xd8(%rdi), %r14
movq %r14, 0xc8(%rdi)
movq %rax, 0xd0(%rdi)
movb %al, 0xd8(%rdi)
leaq 0xf8(%rdi), %r12
movq %r12, 0xe8(%rdi)
movq %rax, 0xf0(%rdi)
movb %al, 0xf8(%rdi)
callq 0x20f0
leaq 0x20(%r13), %rsi
movq 0x30(%rsp), %rdi
callq 0x20f0
leaq 0x40(%r13), %rsi
movq 0x28(%rsp), %rdi
callq 0x20f0
leaq 0x60(%r13), %rsi
movq 0x20(%rsp), %rdi
callq 0x20f0
movl 0x80(%r13), %eax
movl %eax, 0x80(%rbx)
movb 0x84(%r13), %al
movb %al, 0x84(%rbx)
movb 0x85(%r13), %al
movb %al, 0x85(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq 0xe8(%rbx), %rdi
cmpq %r12, %rdi
je 0x3ac5
movq (%r12), %rsi
incq %rsi
callq 0x2190
movq 0xc8(%rbx), %rdi
cmpq %r14, %rdi
je 0x3adc
movq (%r14), %rsi
incq %rsi
callq 0x2190
movq 0xa8(%rbx), %rdi
cmpq %r15, %rdi
je 0x3af3
movq (%r15), %rsi
incq %rsi
callq 0x2190
movq 0x88(%rbx), %rdi
cmpq %rbp, %rdi
je 0x3b0b
movq (%rbp), %rsi
incq %rsi
callq 0x2190
movq 0x20(%rsp), %rax
movq (%rax), %rdi
cmpq (%rsp), %rdi
je 0x3b28
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2190
movq 0x28(%rsp), %rax
movq (%rax), %rdi
cmpq 0x8(%rsp), %rdi
je 0x3b47
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2190
movq 0x30(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0x3b66
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2190
movq (%rbx), %rdi
cmpq 0x18(%rsp), %rdi
je 0x3b80
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2190
movq %r13, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflBody[abi:cxx11]()
string mkflBody(void){
	string buf;
	buf+="\nall: $(OUT)\n\n";
	buf+="$(OUT): $(OBJS)\n";
	buf+="\t$(CXX) -o $(OUT) $(OBJS)\n\n";
	buf+="%.o: %.c\n";
	buf+="\t$(CXX) -c -o $@ $<\n\n";
	buf+="run: $(OUT)\n";
	buf+="\t./$(OUT) $(EXECUTION_PARAMETERS)\n\n";
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x1080(%rip), %rsi      # 0x589a
callq 0x22b0
leaq 0x1083(%rip), %rsi      # 0x58a9
movq %rbx, %rdi
callq 0x22b0
leaq 0x1085(%rip), %rsi      # 0x58ba
movq %rbx, %rdi
callq 0x22b0
leaq 0x1092(%rip), %rsi      # 0x58d6
movq %rbx, %rdi
callq 0x22b0
leaq 0x108d(%rip), %rsi      # 0x58e0
movq %rbx, %rdi
callq 0x22b0
leaq 0x1094(%rip), %rsi      # 0x58f6
movq %rbx, %rdi
callq 0x22b0
leaq 0x1092(%rip), %rsi      # 0x5903
movq %rbx, %rdi
callq 0x22b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4898
movq (%r15), %rsi
incq %rsi
callq 0x2190
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflInst[abi:cxx11]()
string mkflInst(void){
	string buf;
	buf+="\ninstall: $(OUT)\n";
	buf+="\tsudo cp $(OUT) /usr/local/bin\n";
	buf+="\t@echo Program Installed in /usr/local/bin\n";
	buf+="\t@echo You can now delete this folder safely\n\n";
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x1065(%rip), %rsi      # 0x5927
callq 0x22b0
leaq 0x106b(%rip), %rsi      # 0x5939
movq %rbx, %rdi
callq 0x22b0
leaq 0x107c(%rip), %rsi      # 0x5959
movq %rbx, %rdi
callq 0x22b0
leaq 0x1099(%rip), %rsi      # 0x5985
movq %rbx, %rdi
callq 0x22b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4913
movq (%r15), %rsi
incq %rsi
callq 0x2190
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflDB[abi:cxx11]()
string mkflDB(void){
	string buf;
	buf+="db: clean param\n";
	buf+="param: CXXFLAGS += -g\n";
	buf+="param: $(OUT)\n\n";
	buf+="gdb: db\n";
	buf+="\tgdb $(OUT)\n\n";
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x1077(%rip), %rsi      # 0x59b4
callq 0x22b0
leaq 0x107c(%rip), %rsi      # 0x59c5
movq %rbx, %rdi
callq 0x22b0
leaq 0x1084(%rip), %rsi      # 0x59dc
movq %rbx, %rdi
callq 0x22b0
leaq 0x1085(%rip), %rsi      # 0x59ec
movq %rbx, %rdi
callq 0x22b0
leaq 0x107f(%rip), %rsi      # 0x59f5
movq %rbx, %rdi
callq 0x22b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x499d
movq (%r15), %rsi
incq %rsi
callq 0x2190
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflVal[abi:cxx11](bool)
string mkflVal(bool dbflag){
	string buf;

	if(!dbflag){
		buf+="db: clean param\n";
		buf+="param: CXXFLAGS += -g\n";
		buf+="param: $(OUT)\n\n";
	}
	
	buf+="vg: db\n";
	buf+="\tvalgrind $(EXECUTION_PARAMETERS) ./$(OUT)\n\n";

	buf+="vgleak: db\n";
	buf+="\tvalgrind --leak-check=full ./$(OUT) $(EXECUTION_PARAMETERS)\n\n";

	buf+="vgext: db\n";
	buf+="\tvalgrind --leak-check=full --show-leak-kinds=all --leak-resolution=high --track-origins=yes --vgdb=yes ./$(OUT) $(EXECUTION_PARAMETERS)\n\n";

	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %esi, %esi
jne 0x49f1
leaq 0xfe9(%rip), %rsi       # 0x59b4
movq %rbx, %rdi
callq 0x22b0
leaq 0xfeb(%rip), %rsi       # 0x59c5
movq %rbx, %rdi
callq 0x22b0
leaq 0xff3(%rip), %rsi       # 0x59dc
movq %rbx, %rdi
callq 0x22b0
leaq 0x100b(%rip), %rsi      # 0x5a03
movq %rbx, %rdi
callq 0x22b0
leaq 0x1004(%rip), %rsi      # 0x5a0b
movq %rbx, %rdi
callq 0x22b0
leaq 0x1022(%rip), %rsi      # 0x5a38
movq %rbx, %rdi
callq 0x22b0
leaq 0x101f(%rip), %rsi      # 0x5a44
movq %rbx, %rdi
callq 0x22b0
leaq 0x104f(%rip), %rsi      # 0x5a83
movq %rbx, %rdi
callq 0x22b0
leaq 0x104b(%rip), %rsi      # 0x5a8e
movq %rbx, %rdi
callq 0x22b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4a6a
movq (%r15), %rsi
incq %rsi
callq 0x2190
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflClean[abi:cxx11]()
string mkflClean(void){
	string buf;

	buf+=".PHONY: clean\n";
	buf+="clean:\n";
	buf+="\trm -f *.o\n";
	
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x1085(%rip), %rsi      # 0x5b19
callq 0x22b0
leaq 0x1088(%rip), %rsi      # 0x5b28
movq %rbx, %rdi
callq 0x22b0
leaq 0x1081(%rip), %rsi      # 0x5b30
movq %rbx, %rdi
callq 0x22b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4ad6
movq (%r15), %rsi
incq %rsi
callq 0x2190
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_07.cc
// Function: populate(std::shared_ptr<std::vector<int, std::allocator<int>>>)
shared_ptr<vector<int>> populate(shared_ptr<vector<int>> vec)
{
	int item;

	while (cin >> item) {
		vec->push_back(item);
	}

	return vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2cf9(%rip), %rdi      # 0x3fe0
leaq -0x24(%rbp), %rsi
callq 0x1060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1346
leaq -0x24(%rbp), %r15
movq 0x2cd7(%rip), %r12      # 0x3fe0
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1325
movl -0x24(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x132d
movq %r15, %rdx
callq 0x15dc
movq %r12, %rdi
movq %r15, %rsi
callq 0x1060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x1309
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%r14)
movq %rcx, (%rbx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]cpp-loadtxt/./src/loadtxt.hpp
// Function: loadtxt<double>::convert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T convert(const string& s) {
        if constexpr (std::is_same_v<T, int>)
            return stoi(s);
        else if constexpr (std::is_same_v<T, long>)
            return stol(s);
        else if constexpr (std::is_same_v<T, long long>)
            return stoll(s);
        else if constexpr (std::is_same_v<T, unsigned long long>)
            return stoull(s);
        
        return stod(s);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rsi), %r14
callq 0x2030
movq %rax, %rbx
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
cmpq %r14, (%r15)
je 0x42a8
movl (%rbx), %eax
testl %eax, %eax
je 0x4298
cmpl $0x22, %eax
jne 0x429b
leaq 0x12ae(%rip), %rdi      # 0x5541
callq 0x2220
movl %r12d, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1292(%rip), %rdi      # 0x5541
callq 0x2110
cmpl $0x0, (%rbx)
jne 0x42bc
movl %r12d, (%rbx)
movq %rax, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::store_string(Srl::String const&)
pair<const String*, size_t> Environment::store_string(const String& str)
{
    if(str.size() < 1) {
        return { &Environment::EmptyString, EmptyStringHash };
    }

    auto conv = conv_str(str, this->str_buffer, Environment::Str_Encoding);
    auto hash = hash_fnc(conv);

    auto* str_ptr = this->str_table.get(conv);

    if(str_ptr) {
        return { str_ptr, hash };
    }

    String new_str(conv);

    if(!new_str.block.try_store_local()) {
        new_str.block.extern_data = Aux::copy(this->heap, conv).ptr;
    }

    str_ptr = this->str_table.insert(new_str, new_str).second;
    return { str_ptr, hash };
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, 0x8(%rsi)
je 0xe673
movq %rdi, %rbp
leaq 0x220(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0xe543
movq %rax, %r13
movq %rdx, %r12
movq %rax, %rdi
movq %rdx, %rsi
callq 0xb580
movq %rax, %rbx
leaq 0x58(%rbp), %r14
leaq 0x8(%rsp), %r15
movq %r13, (%r15)
movl %r12d, 0x8(%r15)
movw $0x10c, 0xc(%r15)       # imm = 0x10C
movb $0x0, 0xe(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0xb880
testq %rax, %rax
jne 0xe6d5
movq %r13, 0x8(%rsp)
movl %r12d, 0x10(%rsp)
movw $0x10c, 0x14(%rsp)      # imm = 0x10C
movb $0x0, 0x16(%rsp)
cmpl $0x8, %r12d
ja 0xe683
testl %r12d, %r12d
je 0xe6aa
xorl %eax, %eax
movb (%r13,%rax), %cl
movb %cl, 0x8(%rsp,%rax)
incq %rax
movl 0x10(%rsp), %r12d
cmpq %r12, %rax
jb 0xe656
movb $0x1, 0x16(%rsp)
jmp 0xe6b2
movq 0x188c6(%rip), %rax     # 0x26f40
movq 0x1947f(%rip), %rbx     # 0x27b00
jmp 0xe6d5
addq $0x8, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xb4f0
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xb790
movq %r15, 0x8(%rsp)
jmp 0xe6b2
movb $0x1, 0x16(%rsp)
xorl %r12d, %r12d
movl %r12d, %esi
movq %r15, %rdi
callq 0xb580
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %rcx, %r8
callq 0xb650
movq %rdx, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::store_value(Srl::Node&, Srl::Value const&, Srl::String const&)
Link<Value>* Environment::store_value(Node& parent, const Value& value, const String& name)
{
    auto* link = this->create_link(parent.values, value, name);
    auto& block = link->field.block;

    if(!block.stored_local && !block.try_store_local()) {
        block.extern_data = Aux::copy(this->heap, { block.extern_data, block.size }).ptr;
    }

    return link;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x28(%rsi), %r12
movq %rcx, %rsi
callq 0xb390
leaq 0x8(%rsp), %r13
movq %rax, -0x8(%r13)
movq %rdx, (%r13)
leaq 0x30(%r15), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq %rbx, %rcx
callq 0xba10
movq 0x38(%r15), %rbx
movq -0x8(%r13), %rax
movq %rax, 0x18(%rbx)
cmpb $0x0, 0x2e(%rbx)
jne 0xeaf1
movl 0x28(%rbx), %r12d
movq 0x20(%rbx), %r15
cmpq $0x8, %r12
ja 0xeacd
testq %r12, %r12
je 0xeac7
xorl %eax, %eax
movb (%r15,%rax), %cl
movb %cl, 0x20(%rbx,%rax)
incq %rax
movl 0x28(%rbx), %ecx
cmpq %rcx, %rax
jb 0xeab4
movb $0x1, 0x2e(%rbx)
jmp 0xeaf1
addq $0x8, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xb4f0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb790
movq %r14, 0x20(%rbx)
addq $0x10, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq