LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/overfl0[P]iojack/syscalls.cpp
// Function: postOpenHook(processInfo*, user_regs_struct&, int&, int&)
void postOpenHook(processInfo *pi, user_regs_struct &regs, int &saveRegs, int &unused)
{
    //printf("[%d] Got open(%lx, %lu, %lu) syscall! (returned: %d)\n", pi->pid, pi->orig_regs.ARG1, pi->orig_regs.ARG2, pi->orig_regs.ARG3, (int)regs.RAX);
    if((int)regs.RAX < 0)
        return;

    #define MAX_FILE_LEN 100
    char fileName[MAX_FILE_LEN + 1];
    pi->readStrncpy(fileName, pi->orig_regs.ARG1, MAX_FILE_LEN);
    fileName[MAX_FILE_LEN] = '\0';
    #undef MAX_FILE_LEN

    //printf("[%d] open(%s) = %d\n", pi->pid, fileName, (int)regs.RAX);

    // Check if opening a terminal
    if(!strncmp(fileName, "/dev/pts/", strlen("/dev/pts/"))
    || !strncmp(fileName, "/dev/tty",  strlen("/dev/tty")))
    {
        if((pi->orig_regs.ARG2 & 3) == O_RDONLY || (pi->orig_regs.ARG2 & 3) == O_RDWR)
        {
            pi->stdin.insert(regs.RAX);
        }

        if((pi->orig_regs.ARG2 & 3) == O_WRONLY || (pi->orig_regs.ARG2 & 3) == O_RDWR)
        {
            pi->stdout.insert(regs.RAX);
            pi->stderr.insert(regs.RAX);
        }
    }
}

// Assembly:
testb $-0x80, 0x53(%rsi)
jne 0x5669
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x88(%rdi), %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rsi
movl $0x64, %ecx
callq 0x44b6
movb $0x0, 0x64(%r15)
movq (%r15), %rax
movabsq $0x7374702f7665642f, %rcx # imm = 0x7374702F7665642F
xorq %rax, %rcx
movzbl 0x8(%r15), %edx
xorq $0x2f, %rdx
orq %rcx, %rdx
je 0x55f2
movabsq $0x7974742f7665642f, %rcx # imm = 0x7974742F7665642F
cmpq %rcx, %rax
jne 0x565d
movq 0x80(%rbx), %rax
testb $0x1, %al
jne 0x561b
leaq 0xf0(%rbx), %rdi
movl 0x50(%r14), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
callq 0x4b7e
movq 0x80(%rbx), %rax
andl $0x3, %eax
decq %rax
cmpq $0x1, %rax
ja 0x565d
leaq 0x120(%rbx), %rdi
movl 0x50(%r14), %eax
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
movq %r15, %rsi
callq 0x4b7e
addq $0x150, %rbx            # imm = 0x150
movl 0x50(%r14), %eax
movl %eax, (%r15)
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x4b7e
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/overfl0[P]iojack/syscalls.cpp
// Function: initSyscallHooks()
void initSyscallHooks()
{
    setPreHook  (SYS_write,    preWriteHook);
    setPreHook  (SYS_read,     preReadHook);
    setFakedHook(SYS_read,     fakedReadHook);
    setPreHook(SYS_select,     preSelectHook);
    setFakedHook(SYS_select,   fakeSelectHook);
    setPreHook(SYS_pselect6,   preSelectHook);  // like select() but atomically sets and
    setFakedHook(SYS_pselect6, fakeSelectHook); // unsets sigprocmask() before and after select()
    setPreHook  (SYS_poll,     prePollHook);
    setFakedHook(SYS_poll,     fakePollHook);
    setPostHook (SYS_close,    postCloseHook);
    setPostHook (SYS_dup,      postDupHook);
    setPostHook (SYS_dup2,     postDup2Hook);
    setPostHook (SYS_dup3,     postDup3Hook);
    setPostHook (SYS_fcntl,    postFcntlHook);
    setPostHook (SYS_open,     postOpenHook);
    setPostHook (SYS_ioctl,    postIoctlHook);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq -0x774(%rip), %rsi      # 0x4fa9
movl $0x1, %edi
callq 0x4d38
leaq -0x87f(%rip), %rsi      # 0x4eaf
xorl %edi, %edi
callq 0x4d38
leaq -0x828(%rip), %rsi      # 0x4f14
xorl %edi, %edi
callq 0x4d8d
leaq -0x6e3(%rip), %rbx      # 0x5067
movl $0x17, %edi
movq %rbx, %rsi
callq 0x4d38
leaq -0x65e(%rip), %r14      # 0x5100
movl $0x17, %edi
movq %r14, %rsi
callq 0x4d8d
movl $0x10e, %edi            # imm = 0x10E
movq %rbx, %rsi
callq 0x4d38
movl $0x10e, %edi            # imm = 0x10E
movq %r14, %rsi
callq 0x4d8d
leaq -0x4b6(%rip), %rsi      # 0x52d6
movl $0x7, %edi
callq 0x4d38
leaq -0x3d9(%rip), %rsi      # 0x53c4
movl $0x7, %edi
callq 0x4d8d
leaq -0x2da(%rip), %rsi      # 0x54d4
movl $0x3, %edi
callq 0x4de2
leaq -0x2d9(%rip), %rsi      # 0x54e6
movl $0x20, %edi
callq 0x4de2
leaq -0x2d6(%rip), %rsi      # 0x54fa
movl $0x21, %edi
callq 0x4de2
leaq -0x2ae(%rip), %rsi      # 0x5533
movl $0x124, %edi            # imm = 0x124
callq 0x4de2
leaq -0x294(%rip), %rsi      # 0x555e
movl $0x48, %edi
callq 0x4de2
leaq -0x278(%rip), %rsi      # 0x558b
movl $0x2, %edi
callq 0x4de2
leaq -0x1aa(%rip), %rsi      # 0x566a
movl $0x10, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4de2
nop
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/virtualsNscope.cc
// Function: main
int main()
{
    D1 dobj, *dp = &dobj;
    dp->fcn(42); // ok: static call to D1::fcn(int)

    Base bobj;  D1 d1obj; D2 d2obj;

    Base *bp1 = &bobj, *bp2 = &d1obj, *bp3 = &d2obj;
    bp1->fcn(); // virtual call, will call Base::fcn at run time
    bp2->fcn(); // virtual call, will call Base::fcn at run time
    bp3->fcn(); // virtual call, will call D2::fcn at run time

	D1 *d1p = &d1obj; D2 *d2p = &d2obj;
	d1p->f2(); // virtual call, will call D1::f2() at run time
	d2p->f2(); // virtual call, will call D2::f2() at run time
	Base *p1 = &d2obj; D1 *p2 = &d2obj; D2 *p3 =  &d2obj;
	p2->fcn(42);  // statically bound, calls D1::fcn(int)
	p3->fcn(42);  // statically bound, calls D2::fcn(int)

    Base* bp = &d1obj; D1 *dp1 = &d2obj; D2 *dp2 = &d2obj;
    dp1->fcn(10); // static call to D1::fcn(int)
    dp2->fcn(10); // static call to D2::fcn(int)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x121e
leaq 0x2996(%rip), %rax      # 0x3d58
leaq -0x10(%rbp), %rbx
movq %rax, (%rbx)
callq 0x11cc
callq 0x11cc
callq 0x1310
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
callq 0x1362
callq 0x121e
callq 0x12be
callq 0x121e
callq 0x12be
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: f_bool_check_file(char*)
bool f_bool_check_file(char *parseFile){
    for(size_t i = 0; i < strlen(parseFile); i++){
        if((parseFile[i] >= 'A' && parseFile[i] <= 'Z') || (parseFile[i] >= 'a' && parseFile[i] <= 'z') || (parseFile[i] <= '9' && parseFile[i] >= '0')){continue;}
        else{
            perror("Invalid file format name. Try accepted file format range: A-Z, a-z, 0-9.\n");
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x4190
movb $0x1, %bl
testq %rax, %rax
je 0x4cdf
movb (%r14), %cl
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x4c9f
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x19, %cl
ja 0x4cd1
leaq -0x1(%rax), %rdx
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x4cdf
movb 0x1(%r14,%rcx), %sil
leal -0x30(%rsi), %edi
incq %rcx
cmpb $0xa, %dil
jb 0x4ca5
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x1a, %sil
jb 0x4ca5
cmpq %rax, %rcx
setae %bl
jmp 0x4cd3
xorl %ebx, %ebx
leaq 0x10482(%rip), %rdi     # 0x1515c
callq 0x42e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: f_void_socket_error(int)
void f_void_socket_error(int int_socket){

    if(int_socket < 0){

        if(errno == ENOTCONN){
        /* Socket is not connected */
            fprintf(stderr, "Socket not connected: %s\n", strerror(errno));
            close(int_socket);
            exit(EXIT_FAILURE);

        }
        else if(errno == EINTR){
        /* interrupted sytem call */
            fprintf(stderr, "Interrupted system call: %s\n", strerror(errno));
            close(int_socket);
            exit(EXIT_FAILURE);
        }
        else if(errno == ENOTSOCK){
        /* Not a socket */
            fprintf(stderr, "Not a socket: %s\n", strerror(errno));
            close(int_socket);
            exit(EXIT_FAILURE);
        }
        else if(errno == EOPNOTSUPP){
        /*Operation not supported on socket */
            fprintf(stderr, "Operation not supported on socket: %s\n", strerror(errno));
            close(int_socket);
            exit(EXIT_FAILURE);
        }
        else{
        perror("Socket operation failed\n");
        close(int_socket);
        exit(EXIT_FAILURE);
        }
    }
    else{
        perror("Socket operation failed\n");
        close(int_socket);
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
jns 0x4dc3
callq 0x4050
movl (%rax), %eax
cmpl $0x5e, %eax
jg 0x4d9c
cmpl $0x4, %eax
je 0x4dd1
cmpl $0x58, %eax
jne 0x4dc3
movq 0x19242(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x58, %edi
callq 0x4110
leaq 0x1050e(%rip), %rsi     # 0x152a8
jmp 0x4e09
cmpl $0x5f, %eax
je 0x4dee
cmpl $0x6b, %eax
jne 0x4dc3
movq 0x1921b(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x6b, %edi
callq 0x4110
leaq 0x104b0(%rip), %rsi     # 0x15271
jmp 0x4e09
leaq 0x10517(%rip), %rdi     # 0x152e1
callq 0x42e0
jmp 0x4e16
movq 0x191f0(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x4, %edi
callq 0x4110
leaq 0x1049f(%rip), %rsi     # 0x1528b
jmp 0x4e09
movq 0x191d3(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x5f, %edi
callq 0x4110
leaq 0x104b1(%rip), %rsi     # 0x152ba
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4500
movl %ebx, %edi
callq 0x46d0
movl $0x1, %edi
callq 0x4420
// File: /workspace/github_cpp_makefile_star2_O3/Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: f_void_setsocket_error(int)
void f_void_setsocket_error(int int_setsocket){

    if(int_setsocket < 0){

        if(errno == EBADF){
            fprintf(stderr, "Argument socket is not a valid descriptor.: %s\n", strerror(errno));
            close(int_setsocket);
            exit(EXIT_FAILURE);
        }
        else if(errno == ENOTSOCK){
            fprintf(stderr, "Argument sockfd is a file, not a socket.: %s\n", strerror(errno));
            close(int_setsocket);
            exit(EXIT_FAILURE);
        }
        else{
            perror("Set Socket operation failure\n");
            close(int_setsocket);
            exit(EXIT_FAILURE);
        }
    }
    else{
        perror("Set Socket operation failure\n");
        close(int_setsocket);
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
jns 0x4e5f
callq 0x4050
movl (%rax), %eax
cmpl $0x58, %eax
je 0x4e6d
cmpl $0x9, %eax
jne 0x4e5f
movq 0x1917f(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x9, %edi
callq 0x4110
leaq 0x1049d(%rip), %rsi     # 0x152fa
jmp 0x4e88
leaq 0x104f2(%rip), %rdi     # 0x15358
callq 0x42e0
jmp 0x4e95
movq 0x19154(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x58, %edi
callq 0x4110
leaq 0x104a2(%rip), %rsi     # 0x1532a
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4500
movl %ebx, %edi
callq 0x46d0
movl $0x1, %edi
callq 0x4420
// File: /workspace/github_cpp_makefile_star2_O3/Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: f_void_bind_error(int)
void f_void_bind_error(int bind){

    if(bind < 0){

        if(errno == EADDRINUSE){
            fprintf(stderr, "The given address is already in use.: %s\n", strerror(errno));
            close(bind);
            exit(EXIT_FAILURE);
        }
        else if(errno == EBADF){
            fprintf(stderr, "Socket is not a valid file descriptor: %s\n", strerror(errno));
            close(bind);
            exit(EXIT_FAILURE);
        }
        else if(errno == ENOTSOCK){
            fprintf(stderr, "The file descriptor sockfd does not refer to a socket.: %s\n", strerror(errno));
            close(bind);
            exit(EXIT_FAILURE);
        }
        else if(errno == EINVAL){
            fprintf(stderr, "The socket is already bound to an address.: %s\n", strerror(errno));
            close(bind);
            exit(EXIT_FAILURE);
        }
        else{
            perror("Socket failed to bind\n");
            close(bind);
            exit(EXIT_FAILURE);
        }
    }
    else{
        perror("Socket failed to bind\n");
        close(bind);
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
jns 0x4f0a
callq 0x4050
movl (%rax), %eax
cmpl $0x57, %eax
jg 0x4ee3
cmpl $0x9, %eax
je 0x4f18
cmpl $0x16, %eax
jne 0x4f0a
movq 0x190fb(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x16, %edi
callq 0x4110
leaq 0x10526(%rip), %rsi     # 0x15407
jmp 0x4f50
cmpl $0x58, %eax
je 0x4f35
cmpl $0x62, %eax
jne 0x4f0a
movq 0x190d4(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x62, %edi
callq 0x4110
leaq 0x1046e(%rip), %rsi     # 0x15376
jmp 0x4f50
leaq 0x10526(%rip), %rdi     # 0x15437
callq 0x42e0
jmp 0x4f5d
movq 0x190a9(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x9, %edi
callq 0x4110
leaq 0x1046d(%rip), %rsi     # 0x153a0
jmp 0x4f50
movq 0x1908c(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x58, %edi
callq 0x4110
leaq 0x1047b(%rip), %rsi     # 0x153cb
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4500
movl %ebx, %edi
callq 0x46d0
movl $0x1, %edi
callq 0x4420
// File: /workspace/github_cpp_makefile_star2_O3/Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: f_void_listen_error(int)
void f_void_listen_error(int socket_listen){

    if(socket_listen < 0){

        if(errno == EADDRINUSE){
            fprintf(stderr, "Another socket is listening on same port: %s\n", strerror(errno));
            close(socket_listen);
            exit(EXIT_FAILURE);
        }
        else if(errno == EBADF){
            fprintf(stderr, "Socket is not a valid file descriptor: %s\n", strerror(errno));
            close(socket_listen);
            exit(EXIT_FAILURE);
        }
        else if(errno == EOPNOTSUPP){
            fprintf(stderr, "The socket is not of a type that supports the listen() operation.: %s\n", strerror(errno));
            close(socket_listen);
            exit(EXIT_FAILURE);
        }
        else{
            perror("Server failed to start listenting\n");
            close(socket_listen);
            exit(EXIT_FAILURE);
        }
    }
    else{
        perror("Server failed to start listenting\n");
        close(socket_listen);
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
jns 0x4fab
callq 0x4050
movl (%rax), %eax
cmpl $0x9, %eax
je 0x4fd6
cmpl $0x5f, %eax
je 0x4fb9
cmpl $0x62, %eax
jne 0x4fab
movq 0x19033(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x62, %edi
callq 0x4110
leaq 0x104a5(%rip), %rsi     # 0x1544e
jmp 0x4ff1
leaq 0x10511(%rip), %rdi     # 0x154c3
callq 0x42e0
jmp 0x4ffe
movq 0x19008(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x5f, %edi
callq 0x4110
leaq 0x104a8(%rip), %rsi     # 0x1547c
jmp 0x4ff1
movq 0x18feb(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0x9, %edi
callq 0x4110
leaq 0x103af(%rip), %rsi     # 0x153a0
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4500
movl %ebx, %edi
callq 0x46d0
movl $0x1, %edi
callq 0x4420
// File: /workspace/github_cpp_makefile_star2_O3/Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: f_void_getaddrinfo_error(int, addrinfo*)
void f_void_getaddrinfo_error(int status,struct addrinfo *res){

    if(status < 0){

        if(errno == EAI_AGAIN){
            fprintf(stderr,"The name server returned a temporary failure indication. Try again later: %s\n",strerror(errno));
            freeaddrinfo(res);
            exit(EXIT_FAILURE);
        }
        else if(errno == EAI_SOCKTYPE){
            fprintf(stderr,"The requested socket type is not supported: %s\n",strerror(errno));
            freeaddrinfo(res);
            exit(EXIT_FAILURE);
        }
        else if(errno == EAI_BADFLAGS){
            fprintf(stderr,"hints.ai_flags contains invalid flags: %s\n",strerror(errno));
            freeaddrinfo(res);
            exit(EXIT_FAILURE);
        }
        else if(errno == EAI_SOCKTYPE){
            fprintf(stderr,"Other system error, check errno for details: %s\n",strerror(errno));
            freeaddrinfo(res);
            exit(EXIT_FAILURE);
        }
        else{
            perror("Failed on getaddrinfo.\n");
            freeaddrinfo(res);
            exit(EXIT_FAILURE);
        } 
    }
    else{
        perror("Failed to translate server socket.\n");
        freeaddrinfo(res);
        exit(EXIT_FAILURE);
    } 
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %edi, %edi
jns 0x507d
callq 0x4050
movl (%rax), %eax
cmpl $-0x7, %eax
je 0x50a8
cmpl $-0x1, %eax
je 0x508b
cmpl $-0x3, %eax
jne 0x50e2
movq 0x18f61(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x4110
leaq 0x1055d(%rip), %rsi     # 0x155d8
jmp 0x50c3
leaq 0x10615(%rip), %rdi     # 0x15699
callq 0x42e0
jmp 0x50d0
movq 0x18f36(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4110
leaq 0x105b0(%rip), %rsi     # 0x15656
jmp 0x50c3
movq 0x18f19(%rip), %rax     # 0x1dfc8
movq (%rax), %r14
movl $0xfffffff9, %edi       # imm = 0xFFFFFFF9
callq 0x4110
leaq 0x10563(%rip), %rsi     # 0x15626
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4500
movq %rbx, %rdi
callq 0x4490
movl $0x1, %edi
callq 0x4420
leaq 0x10598(%rip), %rdi     # 0x15681
jmp 0x5084
// File: /workspace/github_cpp_makefile_star2_O3/Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: f_client_req_found(int, int)
void f_client_req_found(int fetch_file_fd,int clientSocket){
    
    struct stat buf;
    fstat(fetch_file_fd,&buf);

    int int_ch_content = buf.st_size;
    char server_length[10];

    char msg200[] = "HTTP/1.1 200 OK\r\n";
    char msgContent[] = "Content-Length: ";
    char term[] = "\r\n\r\n";

    sprintf(server_length,"%d",int_ch_content);

    write(clientSocket,msg200,strlen(msg200));
    write(clientSocket,msgContent,strlen(msgContent));
    write(clientSocket,server_length,strlen(server_length));
    write(clientSocket,term,strlen(term));
    return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %esi, %ebx
leaq 0x18(%rsp), %r14
movq %r14, %rsi
callq 0x45d0
movl 0x30(%r14), %edx
leaq 0x106cf(%rip), %rsi     # 0x157f4
leaq 0xe(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x4080
leaq 0x110f5(%rip), %rsi     # 0x16230
movl $0x11, %edx
movl %ebx, %edi
callq 0x4130
leaq 0x11102(%rip), %rsi     # 0x16250
movl $0x10, %edx
movl %ebx, %edi
callq 0x4130
movq %r14, %rdi
callq 0x4190
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x4130
leaq 0x103fc(%rip), %rsi     # 0x15572
movl $0x4, %edx
movl %ebx, %edi
addq $0xa8, %rsp
popq %rbx
popq %r14
jmp 0x4130
// File: /workspace/github_cpp_makefile_star2_O3/Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: f_regex_overkill_parse(char*, char*, char*)
bool f_regex_overkill_parse(char *request, char *file,char *protocol){

    char buffer_for_regex[80]; 

        strcpy (buffer_for_regex,request);
        strcat (buffer_for_regex,file);
        strcat (buffer_for_regex,protocol);

        std::regex ea("(GET|PUT)[/]?[a-zA-Z0-9]{10}HTTP/1.1"); 
        bool matcha = regex_match(buffer_for_regex, ea);
        return matcha;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x4330
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4620
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4620
leaq 0x1050f(%rip), %rsi     # 0x156ea
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x68e4
movq %rbx, %rdi
callq 0x4190
leaq (%rsp,%rax), %rsi
addq $0x40, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x1207b
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5230
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4360
leaq 0x20(%rsp), %rdi
callq 0x694c
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5262
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4360
leaq 0x20(%rsp), %rdi
callq 0x694c
movq %rbx, %rdi
callq 0x4610
// File: /workspace/github_cpp_makefile_star2_O3/Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: create_worker(unsigned long*, int*, command_line_inputs*)
void create_worker(pthread_t *workerArr, int *thread_array,struct command_line_inputs *configs){
                                       
    size_t s1;                                                           
    pthread_attr_t attr;                                                            
    char msg[100];
    int index,ret,rc;       
    int numWorker = configs->N_threads;
    free(&configs);                                               
                                                                                
   rc = pthread_attr_init(&attr);                                               
   
   if(rc == -1){                                                              
      perror("error in pthread_attr_init");                                     
      exit(1);                                                                  
   }                                                                            
    /* Make thread safe set stack size attributes */                                                               
   s1 = 4096;                                                                   
   rc = pthread_attr_setstacksize(&attr, s1);                                   
   
   if(rc == -1){                                                              
      perror("error in pthread_attr_setstacksize");                             
      exit(2);                                                                  
   } 
    /* Dispatcher - N Thread Pool */
	for(index = 0; index < numWorker; index++){
        
        thread_array[index] = index;
        ret = pthread_create(&workerArr[index],&attr, worker_thread, &thread_array[index]);
        
        if(ret){
			sprintf(msg, "Failed on pthread_create()%d\n", ret);
            exit(EXIT_FAILURE); 
		}		
	}
    free(&thread_array); 
    free(&workerArr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdx), %r13d
movq %rsp, %rdi
callq 0x4400
leaq 0x18(%rsp), %rdi
callq 0x4430
cmpl $-0x1, %eax
je 0x60ef
leaq 0x18(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x44c0
cmpl $-0x1, %eax
je 0x60f4
testl %r13d, %r13d
jle 0x60aa
xorl %ebp, %ebp
leaq 0x7b(%rip), %r15        # 0x60f9
leaq 0x18(%rsp), %r12
movl %ebp, (%rbx)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x4670
testl %eax, %eax
jne 0x60d0
incq %rbp
addq $0x8, %r14
addq $0x4, %rbx
cmpq %rbp, %r13
jne 0x6083
leaq 0x8(%rsp), %rdi
callq 0x4400
leaq 0x10(%rsp), %rdi
callq 0x4400
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf75e(%rip), %rsi      # 0x15835
leaq 0x50(%rsp), %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x4080
movl $0x1, %edi
callq 0x4420
callq 0x47c9
callq 0x47b4
// File: /workspace/github_cpp_makefile_star2_O3/patmorin[P]rotate/rotatetest.cpp
// Function: void rotate_gcd<unsigned int, unsigned long>(unsigned int*, unsigned long, unsigned long)
void rotate_gcd(T *a, I n, I r) {
    I g = gcd(n, r);
    I m = n / g;
    for (I k = 0; k < g; k++) {
        I i = k;
        T t = a[i];
        for (I j = 0; j < m; j++) {
            I inxt = (i+r);
						inxt = inxt >= n ? inxt-n : inxt; // avoid mod in favour of cmov
            T t2 = a[inxt];
            a[inxt] = t;
            t = t2;
            i = inxt;
        }
    }
}

// Assembly:
movq %rdx, %rcx
movq %rsi, %rax
movq %rdx, %r8
xorl %edx, %edx
divq %r8
movq %r8, %rax
testq %rdx, %rdx
jne 0x2a3b
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
xorl %edx, %edx
divq %r8
xorl %r9d, %r9d
cmpq $0x1, %r8
movq %r8, %rdx
adcq $0x0, %rdx
cmpq %rsi, %r8
ja 0x2a99
movl (%rdi,%r9,4), %ebx
xorl %r10d, %r10d
movq %r9, %r11
addq %rcx, %r11
cmpq %rsi, %r11
jb 0x2a81
movq %rsi, %r14
jmp 0x2a84
xorl %r14d, %r14d
subq %r14, %r11
incq %r10
movl (%rdi,%r11,4), %ebp
movl %ebx, (%rdi,%r11,4)
movl %ebp, %ebx
cmpq %rax, %r10
jb 0x2a74
incq %r9
cmpq %rdx, %r9
jne 0x2a65
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/patmorin[P]rotate/rotatetest.cpp
// Function: void speed_test<unsigned int, unsigned long>(unsigned int*, unsigned long, unsigned long, void (*)(unsigned int*, unsigned long, unsigned long))
void speed_test(T *a, I n, I r, void(*rot)(T*,I,I)) {
    auto start = std::chrono::high_resolution_clock::now();
    rot(a, n, r);
    auto stop =  std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed = stop - start;
    std::cout << elapsed.count() << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x2050
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *%rbx
callq 0x2050
subq %r13, %rax
movq 0x244a(%rip), %rdi      # 0x4fc8
vcvtsi2sd %rax, %xmm0, %xmm0
vdivsd 0x58d(%rip), %xmm0, %xmm0 # 0x3118
callq 0x2160
movq %rax, %rbx
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lishen2[P]Excel_formula_parser_cpp/main.cpp
// Function: main
int main(int argc, char* argv[])
{
	const char szFormula1[] = "=1+3+5";
	FormulaParser parser1(szFormula1);
	parser1.parserToToken1();
	parser1.parserToToken2();
	printParser(parser1);

	
	const char szFormula2[] = "=IF(R13C3>DATE(2002,1,6),0,IF(ISERROR(R[41]C[2]),0,IF(R13C3>=R[41]C[2],0, IF(AND(R[23]C[11]>=55,R[24]C[11]>=20),R53C3,0))))";
	FormulaParser parser2(szFormula2);
	parser2.parserToToken1();
	parser2.parserToToken2();
	printParser(parser2);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
leaq -0x10(%rbp), %rsi
movl $0x352b33, 0x3(%rsi)    # imm = 0x352B33
movl $0x332b313d, (%rsi)     # imm = 0x332B313D
leaq -0x170(%rbp), %rbx
movq %rbx, %rdi
callq 0x2998
movq %rbx, %rdi
callq 0x2ae6
leaq -0x170(%rbp), %rdi
callq 0x37f0
leaq -0x170(%rbp), %rdi
callq 0x2459
leaq 0x292d(%rip), %rsi      # 0x5020
leaq -0x1f0(%rbp), %rax
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl $0x292929, 0x78(%rax)   # imm = 0x292929
leaq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x2998
leaq -0xc0(%rbp), %rdi
callq 0x2ae6
leaq -0xc0(%rbp), %rdi
callq 0x37f0
leaq -0xc0(%rbp), %rdi
callq 0x2459
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0x2912
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2760
movq -0x70(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0xa0(%rbp), %rdi
testq %rdi, %rdi
je 0x277b
movq -0x90(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
leaq -0xb0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x279a
movq -0xb0(%rbp), %rsi
incq %rsi
callq 0x2180
leaq -0x118(%rbp), %rbx
movq %rbx, %rdi
callq 0x2912
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x27c1
movq -0x120(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x150(%rbp), %rdi
testq %rdi, %rdi
je 0x27dc
movq -0x140(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
leaq -0x160(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27fb
movq -0x160(%rbp), %rsi
incq %rsi
callq 0x2180
xorl %eax, %eax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %rbp
retq
jmp 0x281a
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x28b2
jmp 0x281d
movq %rax, %rbx
leaq -0x170(%rbp), %rdi
callq 0x28b2
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/lishen2[P]Excel_formula_parser_cpp/FormulaParser.cpp
// Function: ExcelFormula::FormulaParser::clear()
void FormulaParser::clear()
	{
		for(vector<Token*>::const_iterator it = m_tokens.begin();
				it != m_tokens.end();
				++it)
		{
			delete *it;	
		}

		m_tokens.clear();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r15
cmpq 0x28(%rdi), %r15
je 0x3ca4
movq %rdi, %rbx
movq (%r15), %r14
testq %r14, %r14
je 0x3c80
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x3c80
movq (%rax), %rsi
incq %rsi
callq 0x2180
movl $0x28, %esi
movq %r14, %rdi
callq 0x2180
addq $0x8, %r15
cmpq 0x28(%rbx), %r15
jne 0x3c61
movq 0x20(%rbx), %rax
cmpq %rax, %r15
je 0x3ca4
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lishen2[P]Excel_formula_parser_cpp/StrUtils.cpp
// Function: StrUtils::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
string StrUtils::trim(string& value)
{
	//trim begin
	for(size_t i = 0; i < value.size(); ++i)
	{
		if (!isEmpChar(value[i]))
		{
			value.erase(0, i);
			break;
		}
	}

	//trim end
	for(size_t i = value.size() - 1;
			i >= 0; --i)
	{
		if (!isEmpChar(value[i]))
		{
			value.erase(i + 1);
			break;
		}
	}

	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x400f
movq (%r14), %rax
xorl %edx, %edx
movzbl (%rax,%rdx), %esi
cmpl $0x9, %esi
je 0x4005
cmpl $0x20, %esi
jne 0x4013
incq %rdx
cmpq %rdx, %rcx
jne 0x3ff7
jmp 0x4021
xorl %ecx, %ecx
jmp 0x4021
movq %r14, %rdi
xorl %esi, %esi
callq 0x2060
movq 0x8(%r14), %rcx
movq (%r14), %rax
movq %rcx, %rdx
movzbl -0x1(%rax,%rdx), %esi
cmpl $0x20, %esi
je 0x4036
cmpl $0x9, %esi
jne 0x403b
decq %rdx
jmp 0x4027
cmpq %rdx, %rcx
jb 0x4069
movq %rdx, 0x8(%r14)
movb $0x0, (%rax,%rdx)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3ea0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1144(%rip), %rdi      # 0x51b4
leaq 0x1129(%rip), %rsi      # 0x51a0
xorl %eax, %eax
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/lishen2[P]Excel_formula_parser_cpp/StrUtils.cpp
// Function: StrUtils::indexOf(int, char const**, char const*)
int StrUtils::indexOf(const int argc, const char* array[], const char* szStr)
{
	int retVal = -1;
	for(int i = 0; i < argc; ++i)
	{
		if (strcmp(array[i], szStr) == 0)
			return i;
	}
	return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %edi, %edi
jle 0x4112
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r13d
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movq %r14, %rsi
callq 0x21d0
testl %eax, %eax
je 0x410f
incq %r12
cmpq %r12, %r13
jne 0x40f5
jmp 0x4112
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lishen2[P]Excel_formula_parser_cpp/TokenArray.cpp
// Function: ExcelFormula::TokenArray::getCurrent()
Token* TokenArray::getCurrent()
	{
		if (m_index >= m_tokens.size() || m_index < 0)
		{
			return NULL;
		}
		else
		{
			return m_tokens[m_index];
		}
	}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x442d
pushq %rbp
movq %rsp, %rbp
movq (%rcx,%rax,8), %rax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/lishen2[P]Excel_formula_parser_cpp/TokenArray.cpp
// Function: ExcelFormula::TokenArray::releaseAll()
void TokenArray::releaseAll()
	{
		for(vector<Token*>::const_iterator it = m_tokens.begin();
				it != m_tokens.end();
				++it)
		{
			delete (*it);
		}
		m_tokens.clear();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
cmpq 0x10(%rdi), %r15
je 0x4550
movq %rdi, %rbx
movq (%r15), %r14
testq %r14, %r14
je 0x452c
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x452c
movq (%rax), %rsi
incq %rsi
callq 0x2180
movl $0x28, %esi
movq %r14, %rdi
callq 0x2180
addq $0x8, %r15
cmpq 0x10(%rbx), %r15
jne 0x450d
movq 0x8(%rbx), %rax
cmpq %rax, %r15
je 0x4550
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lishen2[P]Excel_formula_parser_cpp/TokenStack.cpp
// Function: ExcelFormula::TokenStack::pop()
Token* TokenStack::pop()
	{
		if (m_stack.empty())
		{
			return NULL;
		}
		else
		{
			
			Token* efToken = m_stack.top()->clone();
			m_stack.pop();
			efToken->setSubtype(Token::Stop);
			return efToken;
			
			/*
			Token* topElement = m_stack.top();
			m_stack.pop();
			return topElement ;
			*/
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x47e7
movq %rdi, %rbx
cmpq 0x38(%rdi), %rax
jne 0x47c9
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
callq 0x4282
movq %rax, %r14
movq %rbx, %rdi
callq 0x4a2e
movl $0x2, 0x24(%r14)
jmp 0x47ea
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pfnet-research[P]pml/src/MDP.cpp
// Function: mdp::operator<<(std::ostream&, mdp::command_t const&)
std::ostream& operator<<(std::ostream& os, command_t const& command) {
    if (command.branches.empty())
        return os;
    os << "[] " << *command.guard << " -> ";
    os << *command.branches[0].prob << " : " << *command.branches[0].update;
    for (size_t i=1; i<command.branches.size(); ++i)
        os << "+" << *command.branches[i].prob << " : " << *command.branches[i].update;
    os << ";";
    return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %rax
cmpq 0x18(%rsi), %rax
je 0xa119
movq %rsi, %r14
leaq 0x3b134(%rip), %rsi     # 0x45159
movl $0x3, %edx
movq %rbx, %rdi
callq 0x9350
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1a66f
leaq 0x3ef55(%rip), %rsi     # 0x48f99
movl $0x4, %edx
movq %rax, %rdi
callq 0x9350
movq 0x10(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1a66f
movq %rax, %r15
leaq 0x3dbbe(%rip), %rsi     # 0x47c28
movl $0x3, %edx
movq %rax, %rdi
callq 0x9350
movq 0x10(%r14), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0x1a66f
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
cmpq $0x21, %rax
jb 0xa105
movl $0x1, %ebp
xorl %r15d, %r15d
leaq 0x3db84(%rip), %r12     # 0x47c28
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x3b0aa(%rip), %rsi     # 0x4515d
callq 0x9350
movq 0x10(%r14), %rax
movq 0x20(%rax,%r15), %rsi
movq %rbx, %rdi
callq 0x1a66f
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x9350
movq 0x10(%r14), %rax
movq 0x30(%rax,%r15), %rsi
movq %r13, %rdi
callq 0x1a66f
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
incq %rbp
sarq $0x5, %rax
addq $0x20, %r15
cmpq %rax, %rbp
jb 0xa0a4
leaq 0x3b053(%rip), %rsi     # 0x4515f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9350
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pfnet-research[P]pml/src/MDP.cpp
// Function: mdp::operator<<(std::ostream&, mdp::mdp_t const&)
std::ostream& operator<<(std::ostream& os, mdp_t const& mdp) {
    os << "mdp" << std::endl << std::endl;
    os << "module " << mdp.module_name << std::endl << std::endl;

    for (auto const& var : mdp.variables)
        os << var << std::endl;
    for (auto const& cnst : mdp.constants)
        os << cnst << std::endl;

    os << std::endl;

    for (auto const& command : mdp.commands)
        os << command << std::endl;

    os << std::endl;
    os << "endmodule";
    return os;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x42a37(%rip), %rsi     # 0x4cb78
movl $0x3, %edx
callq 0x9350
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x92c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x91c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x92c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x91c0
leaq 0x3afbe(%rip), %rsi     # 0x45161
movl $0x7, %edx
movq %rbx, %rdi
callq 0x9350
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x9350
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x92c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x91c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x92c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x91c0
movq 0x20(%r14), %r15
movq 0x28(%r14), %r13
cmpq %r13, %r15
je 0xa25b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b388
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x92c0
movsbl %al, %esi
movq %r12, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x91c0
addq $0x30, %r15
jmp 0xa21b
movq 0x38(%r14), %r15
movq 0x40(%r14), %r13
cmpq %r13, %r15
je 0xa2a3
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19f50
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x92c0
movsbl %al, %esi
movq %r12, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x91c0
addq $0x28, %r15
jmp 0xa263
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x92c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x91c0
movq 0x50(%r14), %r15
movq 0x58(%r14), %r14
cmpq %r14, %r15
je 0xa30f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9fff
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x92c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x91c0
addq $0x28, %r15
jmp 0xa2d2
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x92c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x91c0
leaq 0x3ae2c(%rip), %rsi     # 0x45169
movl $0x9, %edx
movq %rbx, %rdi
callq 0x9350
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/pfnet-research[P]pml/src/MDP.cpp
// Function: mdp::operator==(mdp::mdp_t const&, mdp::mdp_t const&)
bool operator==(mdp_t const& lhs, mdp_t const& rhs) {
    if (lhs.variables.size() != rhs.variables.size())
        return false;

    for (size_t i=0; i<lhs.variables.size(); ++i) {
        if (lhs.variables[i] != rhs.variables[i])
            return false;
    }

    if (lhs.commands.size() != rhs.commands.size())
        return false;

    for (size_t i=0; i<lhs.commands.size(); ++i) {
        if (lhs.commands[i] != rhs.commands[i])
            return false;
    }
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movq 0x28(%r14), %rax
movq %rax, %rcx
subq %rdi, %rcx
movq 0x28(%rsi), %rdx
subq 0x20(%rsi), %rdx
cmpq %rdx, %rcx
jne 0xa4db
movq %rsi, %rbx
cmpq %rdi, %rax
je 0xa477
xorl %r15d, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r13d, %r13d
addq %r15, %rdi
movq 0x20(%rbx), %rsi
addq %r15, %rsi
callq 0x1b4d5
testb %al, %al
je 0xa4db
incq %r13
movq 0x20(%r14), %rdi
movq 0x28(%r14), %rax
subq %rdi, %rax
sarq $0x4, %rax
imulq %r12, %rax
addq $0x30, %r15
cmpq %rax, %r13
jb 0xa441
movq 0x50(%r14), %rdi
movq 0x58(%r14), %rax
movq %rax, %rcx
subq %rdi, %rcx
movq 0x58(%rbx), %rdx
subq 0x50(%rbx), %rdx
cmpq %rdx, %rcx
jne 0xa4db
cmpq %rdi, %rax
je 0xa4e7
xorl %r15d, %r15d
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
xorl %r13d, %r13d
addq %r15, %rdi
movq 0x50(%rbx), %rsi
addq %r15, %rsi
callq 0xa38e
testb %al, %al
je 0xa4dd
incq %r13
movq 0x50(%r14), %rdi
movq 0x58(%r14), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
imulq %r12, %rcx
addq $0x28, %r15
cmpq %rcx, %r13
jb 0xa4a7
jmp 0xa4dd
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0xa4dd
nop
// File: /workspace/github_cpp_makefile_star2_O3/pfnet-research[P]pml/./include/environment.hpp
// Function: environment_t<ast::expr_t>::lookup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
ptr<element_t> lookup(std::string const& name) const {
        for (auto const& e : elems) {
            if (e.first == name)
                return e.second;
        }
        return nullptr;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xc9f7
movq (%rsi), %r12
movq (%rdx), %r14
movq 0x8(%rdx), %r15
shlq $0x4, %rax
leaq (%rax,%rax,2), %r13
testq %r12, %r12
je 0xca37
cmpq %r15, 0x8(%r12)
jne 0xc9ed
testq %r15, %r15
je 0xca0a
movq (%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9300
testl %eax, %eax
je 0xca0a
addq $0x30, %r12
addq $-0x30, %r13
jne 0xc9c9
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x20(%r12), %rax
movq %rax, (%rbx)
movq 0x28(%r12), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xc9fd
movq 0x55589(%rip), %rcx     # 0x61fb0
cmpb $0x0, (%rcx)
je 0xca31
incl 0x8(%rax)
jmp 0xc9fd
lock
incl 0x8(%rax)
jmp 0xc9fd
leaq 0x38e56(%rip), %rdi     # 0x45894
leaq 0x38982(%rip), %rsi     # 0x453c7
leaq 0x3a2d6(%rip), %rcx     # 0x46d22
movl $0x8e, %edx
callq 0x91a0
// File: /workspace/github_cpp_makefile_star2_O3/pfnet-research[P]pml/src/logic.cpp
// Function: logic::to_debug_string[abi:cxx11](logic::domain_kind_t)
std::string to_debug_string(domain_kind_t kind) {
    switch (kind) {
    case domain_kind_t::Int:
        return "Int";
    case domain_kind_t::Bool:
        return "Bool";
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
testl %esi, %esi
je 0x12fd0
leaq 0x341bc(%rip), %rsi     # 0x47183
leaq 0x341b9(%rip), %rdx     # 0x47187
jmp 0x12fde
leaq 0x341a8(%rip), %rsi     # 0x4717f
leaq 0x341a4(%rip), %rdx     # 0x47182
movq %rbx, %rdi
callq 0x116f8
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/pfnet-research[P]pml/./include/result.hpp
// Function: result_t<ast::dependent_type_t, parser::error_t>::clear()
void clear() {
        if (m_is_ok)
            m_ok.~T();
        else
            m_error.~E();
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x50(%rdi)
jne 0x28373
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x28352
callq 0xa946
movq 0x18(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x2836a
movq (%rax), %rsi
incq %rsi
callq 0x92e0
movq %rbx, %rdi
popq %rbx
jmp 0xce82
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x2838c
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x92e0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/pfnet-research[P]pml/src/mdp_constant.cpp
// Function: mdp::operator<<(std::ostream&, mdp::constant_t const&)
std::ostream& operator<<(std::ostream& os, constant_t const& cnst) {
    // in PRISM v4.4, somehow can not use 'const' keyword
    if (cnst.is_int()) {
        int val = cnst.as_int();
        os << cnst.name << " : [" << val << " .. " << val+1 << "] init " << val << ";";
    } else {
        int val = cnst.as_bool();
        os << cnst.name << " bool init " << std::boolalpha << val << ";";
    }
    return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl 0x20(%rsi), %eax
movl %eax, %ecx
sarl $0x1f, %ecx
movq %rsi, %rdi
cmpl %eax, %ecx
jne 0x19fe7
callq 0x1a04e
movl %eax, %r14d
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x9350
movq %rax, %r15
leaq 0x2dd7f(%rip), %rsi     # 0x47d0c
movl $0x4, %edx
movq %rax, %rdi
callq 0x9350
movq %r15, %rdi
movl %r14d, %esi
callq 0x94c0
movq %rax, %r15
leaq 0x32c8c(%rip), %rsi     # 0x4cc3b
movl $0x4, %edx
movq %rax, %rdi
callq 0x9350
leal 0x1(%r14), %esi
movq %r15, %rdi
callq 0x94c0
movq %rax, %r15
leaq 0x2dd3f(%rip), %rsi     # 0x47d11
movl $0x7, %edx
movq %rax, %rdi
callq 0x9350
movq %r15, %rdi
movl %r14d, %esi
jmp 0x1a027
callq 0x1a0a0
movzbl %al, %ebp
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x9350
movq %rax, %r14
leaq 0x2e09d(%rip), %rsi     # 0x480a5
movl $0xb, %edx
movq %rax, %rdi
callq 0x9350
movq (%r14), %rax
movq -0x18(%rax), %rax
orl $0x1, 0x18(%r14,%rax)
movq %r14, %rdi
movl %ebp, %esi
callq 0x94c0
leaq 0x2b12c(%rip), %rsi     # 0x4515f
movl $0x1, %edx
movq %rax, %rdi
callq 0x9350
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pfnet-research[P]pml/src/mdp_expr.cpp
// Function: mdp::operator<<(std::ostream&, mdp::binop_kind_t)
std::ostream& operator<<(std::ostream& os, binop_kind_t kind) {
    switch (kind) {
    case binop_kind_t::Mul:
        os << "*"; break;
    case binop_kind_t::Div:
        os << "/"; break;
    case binop_kind_t::Add:
        os << "+"; break;
    case binop_kind_t::Sub:
        os << "-"; break;
    case binop_kind_t::Lt:
        os << "<"; break;
    case binop_kind_t::Leq:
        os << "<="; break;
    case binop_kind_t::Geq:
        os << ">="; break;
    case binop_kind_t::Gt:
        os << ">"; break;
    case binop_kind_t::Eq:
        os << "="; break;
    case binop_kind_t::Neq:
        os << "!="; break;
    case binop_kind_t::And:
        os << "&"; break;
    case binop_kind_t::Or:
        os << "|"; break;
    case binop_kind_t::Iff:
        os << "<=>"; break;
    case binop_kind_t::Impl:
        os << "=>"; break;
    }
    return os;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0xd, %esi
ja 0x1a66a
movl %esi, %eax
leaq 0x2d866(%rip), %rcx     # 0x47e34
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2cede(%rip), %rsi     # 0x474bc
jmp 0x1a65d
leaq 0x2cf20(%rip), %rsi     # 0x47507
jmp 0x1a65d
leaq 0x2cf19(%rip), %rsi     # 0x47509
jmp 0x1a65d
leaq 0x2d8ae(%rip), %rsi     # 0x47ea7
movl $0x3, %edx
jmp 0x1a662
leaq 0x2d89d(%rip), %rsi     # 0x47ea4
jmp 0x1a646
leaq 0x2ab4d(%rip), %rsi     # 0x4515d
jmp 0x1a65d
leaq 0x2cea1(%rip), %rsi     # 0x474ba
jmp 0x1a65d
leaq 0x2dca5(%rip), %rsi     # 0x482c7
jmp 0x1a65d
leaq 0x2dc9f(%rip), %rsi     # 0x482ca
jmp 0x1a65d
leaq 0x2ced7(%rip), %rsi     # 0x4750b
jmp 0x1a646
leaq 0x2d86b(%rip), %rsi     # 0x47ea8
jmp 0x1a646
leaq 0x2cec8(%rip), %rsi     # 0x4750e
movl $0x2, %edx
jmp 0x1a662
leaq 0x2ceb1(%rip), %rsi     # 0x47505
jmp 0x1a65d
leaq 0x2d848(%rip), %rsi     # 0x47ea5
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9350
movq %rbx, %rax
popq %rbx
retq