LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: f_getopt(int, char**, command_line_inputs*)
void f_getopt(int argc, char *argv[], struct command_line_inputs *configs){

    int option;
    /* Make sure the -N flag followed by a number is utitlized correctly and only once */
    int Nflag = 0; 
    /* Make sure the -r flag is utlizied correctly and only once */
    int Rflag = 0; 

    configs->N_threads = 4;
    configs->Redundancy = 0;
    while((option = getopt(argc, argv, "rN:")) != -1){

        switch(option){
            case 'N':
                if(Nflag == 1){
                    fprintf(stderr, "Error: same flag used twice.\n");
                    exit(EXIT_FAILURE);
                }
                else{
                    if(atoi(optarg) == 0){
                        fprintf(stderr, "Usage: (-N <integer>).\n");
                        exit(EXIT_FAILURE);
                    }
                    configs->N_threads = atoi(optarg);
                    Nflag += 1;
                }
                continue;
            case 'r':
                if(Rflag == 1){
                    fprintf(stderr, "Error: same flag used twice.\n");
                    exit(EXIT_FAILURE);
                }
                else{
                    configs->Redundancy = 1;
                    Rflag += 1;
                }
                
                continue;
            default: /* '?' */
                fprintf(stderr, "Options:(-r) or (-N <integer>). \n");
                exit(EXIT_FAILURE);
        }
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq $0x4, (%rdx)
xorl %r13d, %r13d
movb $0x1, %r12b
leaq 0x10615(%rip), %r15     # 0x150f8
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x40a0
cmpl $0x72, %eax
jne 0x4b09
testl %r13d, %r13d
jne 0x4b42
movl $0x1, 0x4(%rbx)
movl $0x1, %r13d
jmp 0x4ae3
cmpl $-0x1, %eax
je 0x4b33
cmpl $0x4e, %eax
jne 0x4b47
testb $0x1, %r12b
je 0x4b4c
movq 0x1a478(%rip), %rax     # 0x1ef98
movq (%rax), %rdi
callq 0x4580
testl %eax, %eax
je 0x4b51
movl %eax, (%rbx)
xorl %r12d, %r12d
jmp 0x4ae3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4720
callq 0x478f
callq 0x4745
callq 0x476a
// File: /workspace/github_cpp_makefile_star2_O1/Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: f_bool_check_vitality(char*, char*, char*, int)
bool f_bool_check_vitality(char *file_name,char *protocol,char *request,int client_connect){

        /* Do you have rights to the goods ? */
        bool check_file_access = f_bool_permissions(file_name);
        /* Check length of file must be = 10 ASCII */
        bool check_file_length = f_bool_check_file_len(file_name);
        /* Checking valid resource names A-Z/a-z/0-9 */
        bool check_file_format = f_bool_check_file(file_name);
        /* Check file permissions */
        bool check_request = f_bool_check_request(request);
        /* Check HTTP/1.1 version */
        bool check_protocol = check_http_protocol(protocol);

        if(check_file_access == false){
            f_void_client_error_forbid(client_connect);
            return false;
        }
        else if(check_file_length == false){
            f_void_400(client_connect);
            return false;
        }
        else if(check_file_format == false){
            f_void_400(client_connect);
            return false;
        }
        else if(check_request == false){
            f_void_400(client_connect);
            return false;
        }
        else if(check_protocol == false){
            f_void_400(client_connect);
            return false;
        }
        else {return true;}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x4c20
movl %eax, %ebp
movq %r12, %rdi
callq 0x4190
movq %rax, %r13
cmpq $0xa, %rax
jne 0x4c0f
cmpq $0xa, %r13
setne %r13b
movq %r12, %rdi
callq 0x4c76
movl %eax, %r12d
movq %r14, %rdi
callq 0x4cea
movl %eax, %r14d
leaq 0x10b59(%rip), %rsi     # 0x15706
movq %r15, %rdi
callq 0x44d0
testl %eax, %eax
setne %al
andb %bpl, %r12b
xorb $0x1, %r12b
orb %r13b, %r12b
xorb $0x1, %r14b
orb %r12b, %r14b
orb %al, %r14b
cmpb $0x1, %r14b
jne 0x4bf9
leaq 0x1090b(%rip), %rax     # 0x154e6
leaq 0x10934(%rip), %rsi     # 0x15516
testb %bpl, %bpl
cmovneq %rax, %rsi
testb %r12b, %r12b
cmoveq %rax, %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0x4200
xorb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10590(%rip), %rdi     # 0x151a6
callq 0x42e0
jmp 0x4b88
// File: /workspace/github_cpp_makefile_star2_O1/Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: f_bool_permissions(char*)
bool f_bool_permissions(char *file_name){

    struct stat is_file_allowed;
    stat(file_name,&is_file_allowed);

    if(errno != ENOENT && (is_file_allowed.st_mode & S_IWUSR) != S_IWUSR ){ return false;}
    else{ return true;}
}

// Assembly:
subq $0x98, %rsp
leaq 0x8(%rsp), %rsi
callq 0x4310
callq 0x4050
cmpl $0x2, (%rax)
je 0x4c46
testb $-0x80, 0x20(%rsp)
jne 0x4c46
xorl %eax, %eax
jmp 0x4c48
movb $0x1, %al
addq $0x98, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4190
testq %rax, %rax
sete %bpl
je 0x4ce1
movb (%rbx), %cl
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x4c9f
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x19, %cl
ja 0x4cd0
leaq -0x1(%rax), %rdx
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x4cde
movb 0x1(%rbx,%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 %bpl
leaq 0x10485(%rip), %rdi     # 0x1515c
callq 0x42e0
jmp 0x4ce1
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4dc4
callq 0x4050
movl (%rax), %eax
cmpl $0x5e, %eax
jg 0x4d9d
cmpl $0x4, %eax
je 0x4dd2
cmpl $0x58, %eax
jne 0x4dc4
movq 0x1a241(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x58, %edi
callq 0x4110
leaq 0x1050d(%rip), %rsi     # 0x152a8
jmp 0x4e0a
cmpl $0x5f, %eax
je 0x4def
cmpl $0x6b, %eax
jne 0x4dc4
movq 0x1a21a(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x6b, %edi
callq 0x4110
leaq 0x104af(%rip), %rsi     # 0x15271
jmp 0x4e0a
leaq 0x10516(%rip), %rdi     # 0x152e1
callq 0x42e0
jmp 0x4e17
movq 0x1a1ef(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x4, %edi
callq 0x4110
leaq 0x1049e(%rip), %rsi     # 0x1528b
jmp 0x4e0a
movq 0x1a1d2(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x5f, %edi
callq 0x4110
leaq 0x104b0(%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_O1/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 0x4e60
callq 0x4050
movl (%rax), %eax
cmpl $0x58, %eax
je 0x4e6e
cmpl $0x9, %eax
jne 0x4e60
movq 0x1a17e(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x9, %edi
callq 0x4110
leaq 0x1049c(%rip), %rsi     # 0x152fa
jmp 0x4e89
leaq 0x104f1(%rip), %rdi     # 0x15358
callq 0x42e0
jmp 0x4e96
movq 0x1a153(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x58, %edi
callq 0x4110
leaq 0x104a1(%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_O1/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 0x4f0b
callq 0x4050
movl (%rax), %eax
cmpl $0x57, %eax
jg 0x4ee4
cmpl $0x9, %eax
je 0x4f19
cmpl $0x16, %eax
jne 0x4f0b
movq 0x1a0fa(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x16, %edi
callq 0x4110
leaq 0x10525(%rip), %rsi     # 0x15407
jmp 0x4f51
cmpl $0x58, %eax
je 0x4f36
cmpl $0x62, %eax
jne 0x4f0b
movq 0x1a0d3(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x62, %edi
callq 0x4110
leaq 0x1046d(%rip), %rsi     # 0x15376
jmp 0x4f51
leaq 0x10525(%rip), %rdi     # 0x15437
callq 0x42e0
jmp 0x4f5e
movq 0x1a0a8(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x9, %edi
callq 0x4110
leaq 0x1046c(%rip), %rsi     # 0x153a0
jmp 0x4f51
movq 0x1a08b(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x58, %edi
callq 0x4110
leaq 0x1047a(%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_O1/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 0x4fac
callq 0x4050
movl (%rax), %eax
cmpl $0x9, %eax
je 0x4fd7
cmpl $0x5f, %eax
je 0x4fba
cmpl $0x62, %eax
jne 0x4fac
movq 0x1a032(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x62, %edi
callq 0x4110
leaq 0x104a4(%rip), %rsi     # 0x1544e
jmp 0x4ff2
leaq 0x10510(%rip), %rdi     # 0x154c3
callq 0x42e0
jmp 0x4fff
movq 0x1a007(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x5f, %edi
callq 0x4110
leaq 0x104a7(%rip), %rsi     # 0x1547c
jmp 0x4ff2
movq 0x19fea(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0x9, %edi
callq 0x4110
leaq 0x103ae(%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_O1/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 0x507e
callq 0x4050
movl (%rax), %eax
cmpl $-0x7, %eax
je 0x50a9
cmpl $-0x1, %eax
je 0x508c
cmpl $-0x3, %eax
jne 0x50e3
movq 0x19f60(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x4110
leaq 0x1055c(%rip), %rsi     # 0x155d8
jmp 0x50c4
leaq 0x10614(%rip), %rdi     # 0x15699
callq 0x42e0
jmp 0x50d1
movq 0x19f35(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4110
leaq 0x105af(%rip), %rsi     # 0x15656
jmp 0x50c4
movq 0x19f18(%rip), %rax     # 0x1efc8
movq (%rax), %r14
movl $0xfffffff9, %edi       # imm = 0xFFFFFFF9
callq 0x4110
leaq 0x10562(%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 0x10597(%rip), %rdi     # 0x15681
jmp 0x5085
// File: /workspace/github_cpp_makefile_star2_O1/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 0x106ce(%rip), %rsi     # 0x157f4
leaq 0xe(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x4080
leaq 0x110f4(%rip), %rsi     # 0x16230
movl $0x11, %edx
movl %ebx, %edi
callq 0x4130
leaq 0x11101(%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 0x103fb(%rip), %rsi     # 0x15572
movl $0x4, %edx
movl %ebx, %edi
addq $0xa8, %rsp
popq %rbx
popq %r14
jmp 0x4130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1050e(%rip), %rsi     # 0x156ea
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x69fa
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 0x1216f
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5231
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4360
leaq 0x20(%rsp), %rdi
callq 0x6a62
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5263
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4360
leaq 0x20(%rsp), %rdi
callq 0x6a62
movq %rbx, %rdi
callq 0x4610
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
leaq 0x10(%rsp), %rdi
movq %rdx, (%rdi)
movl (%rdx), %r13d
callq 0x4400
leaq 0x18(%rsp), %rdi
callq 0x4430
cmpl $-0x1, %eax
je 0x61f9
leaq 0x18(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x44c0
cmpl $-0x1, %eax
je 0x61fe
testl %r13d, %r13d
jle 0x61b6
xorl %ebp, %ebp
leaq 0x79(%rip), %r15        # 0x6203
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 0x61da
incq %rbp
addq $0x8, %r14
addq $0x4, %rbx
cmpq %rbp, %r13
jne 0x618f
movq %rsp, %rdi
callq 0x4400
leaq 0x8(%rsp), %rdi
callq 0x4400
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf654(%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_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2dfe
movq %rax, %rcx
xorl %esi, %esi
movq %r14, %rax
xorl %edx, %edx
divq %rcx
cmpq $0x1, %rcx
movq %rcx, %rdx
adcq $0x0, %rdx
cmpq %r14, %rcx
ja 0x2acb
movl (%r15,%rsi,4), %r9d
xorl %edi, %edi
movq %rsi, %r8
addq %rbx, %r8
cmpq %r14, %r8
jb 0x2ab2
movq %r14, %r10
jmp 0x2ab5
xorl %r10d, %r10d
subq %r10, %r8
movl (%r15,%r8,4), %r10d
movl %r9d, (%r15,%r8,4)
incq %rdi
movl %r10d, %r9d
cmpq %rax, %rdi
jb 0x2aa5
incq %rsi
cmpq %rdx, %rsi
jne 0x2a97
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
vcvtsi2sd %rax, %xmm0, %xmm0
vdivsd 0x561(%rip), %xmm0, %xmm0 # 0x3118
movq 0x240a(%rip), %rdi      # 0x4fc8
callq 0x2160
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x298c
movq %rbx, %rdi
callq 0x2ada
leaq -0x170(%rbp), %rdi
callq 0x3700
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 0x298c
leaq -0xc0(%rbp), %rdi
callq 0x2ada
leaq -0xc0(%rbp), %rdi
callq 0x3700
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_O1/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 %rdi, %rbx
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %rax
cmpq %rax, %r15
je 0x3c38
movq (%r15), %r14
testq %r14, %r14
je 0x3c2e
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x3c21
movq (%rax), %rsi
incq %rsi
callq 0x2180
movl $0x28, %esi
movq %r14, %rdi
callq 0x2180
addq $0x8, %r15
movq 0x28(%rbx), %rax
jmp 0x3bfd
movq 0x20(%rbx), %rcx
cmpq %rcx, %rax
je 0x3c45
movq %rcx, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
testq %rax, %rax
je 0x3fc8
movq (%r14), %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %sil
cmpb $0x20, %sil
je 0x3fb4
movb $0x1, %r8b
testb $0x1, %r8b
je 0x3fbe
movl %r8d, %edi
xorl %r8d, %r8d
cmpb $0x9, %sil
jne 0x3f9c
testb $0x1, %dil
je 0x3fbe
incq %rdx
cmpq %rax, %rdx
jne 0x3f8f
jmp 0x3fc8
movq %r14, %rdi
xorl %esi, %esi
callq 0x2060
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rcx, %rsi
movq %rsi, %rdx
decq %rsi
movb -0x1(%rax,%rdx), %dil
cmpb $0x20, %dil
je 0x3fd2
movb $0x1, %r9b
testb $0x1, %r9b
je 0x3ffe
movl %r9d, %r8d
xorl %r9d, %r9d
cmpb $0x9, %dil
jne 0x3fe6
testb $0x1, %r8b
jne 0x3fd2
cmpq %rdx, %rcx
jb 0x402c
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 0x3e40
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1181(%rip), %rdi      # 0x51b4
leaq 0x1166(%rip), %rsi      # 0x51a0
xorl %eax, %eax
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40e0
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 0x40dd
incq %r12
cmpq %r12, %r13
jne 0x40c3
jmp 0x40e0
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4401
pushq %rbp
movq %rsp, %rbp
movq (%rcx,%rax,8), %rax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %rax
cmpq %rax, %r15
je 0x4518
movq (%r15), %r14
testq %r14, %r14
je 0x450e
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x4501
movq (%rax), %rsi
incq %rsi
callq 0x2180
movl $0x28, %esi
movq %r14, %rdi
callq 0x2180
addq $0x8, %r15
movq 0x10(%rbx), %rax
jmp 0x44dd
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x4525
movq %rcx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x47af
movq %rdi, %rbx
cmpq 0x38(%rdi), %rax
jne 0x4791
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
callq 0x4252
movq %rax, %r14
movq %rbx, %rdi
callq 0x49f6
movl $0x2, 0x24(%r14)
jmp 0x47b2
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa1a5
movq %rsi, %r14
leaq 0x3b0a8(%rip), %rsi     # 0x45159
movl $0x3, %edx
movq %rbx, %rdi
callq 0x9350
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1a8bb
leaq 0x3eec9(%rip), %rsi     # 0x48f99
movl $0x4, %edx
movq %rax, %rdi
callq 0x9350
movq 0x10(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1a8bb
movq %rax, %r15
leaq 0x3db32(%rip), %rsi     # 0x47c28
movl $0x3, %edx
movq %rax, %rdi
callq 0x9350
movq 0x10(%r14), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0x1a8bb
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
cmpq $0x21, %rax
jb 0xa191
movl $0x1, %ebp
xorl %r15d, %r15d
leaq 0x3daf8(%rip), %r12     # 0x47c28
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x3b01e(%rip), %rsi     # 0x4515d
callq 0x9350
movq 0x10(%r14), %rax
movq 0x20(%rax,%r15), %rsi
movq %rbx, %rdi
callq 0x1a8bb
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 0x1a8bb
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
incq %rbp
sarq $0x5, %rax
addq $0x20, %r15
cmpq %rax, %rbp
jb 0xa130
leaq 0x3afc7(%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_O1/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 0x429ab(%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 0x3af32(%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 0xa2e7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b608
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 0xa2a7
movq 0x38(%r14), %r15
movq 0x40(%r14), %r13
cmpq %r13, %r15
je 0xa32f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a140
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 0xa2ef
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 0xa39b
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa08b
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 0xa35e
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 0x3ada0(%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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
sete %bpl
je 0xcaf8
movq (%rsi), %r15
movq (%rdx), %r14
movq 0x8(%rdx), %r12
shlq $0x4, %rax
leaq (%rax,%rax,2), %r13
testq %r15, %r15
je 0xcb10
movq 0x8(%r15), %rdx
cmpq %r12, %rdx
jne 0xcab9
testq %rdx, %rdx
je 0xcac9
movq (%r15), %rdi
movq %r14, %rsi
callq 0x9300
testl %eax, %eax
je 0xcac9
addq $0x30, %r15
addq $-0x30, %r13
sete %bpl
jne 0xca97
jmp 0xcaf8
movq 0x20(%r15), %rax
movq %rax, (%rbx)
movq 0x28(%r15), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xcaf2
movq 0x564cc(%rip), %rcx     # 0x62fb0
cmpb $0x0, (%rcx)
je 0xcaee
incl 0x8(%rax)
jmp 0xcaf2
lock
incl 0x8(%rax)
testb $0x1, %bpl
je 0xcafe
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38d7d(%rip), %rdi     # 0x45894
leaq 0x388a9(%rip), %rsi     # 0x453c7
leaq 0x3a1fd(%rip), %rcx     # 0x46d22
movl $0x8e, %edx
callq 0x91a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x131ab
leaq 0x33fe1(%rip), %rsi     # 0x47183
leaq 0x33fde(%rip), %rdx     # 0x47187
jmp 0x131b9
leaq 0x33fcd(%rip), %rsi     # 0x4717f
leaq 0x33fc9(%rip), %rdx     # 0x47182
movq %rbx, %rdi
callq 0x11866
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28513
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x284f2
callq 0xaa12
movq 0x18(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x2850a
movq (%rax), %rsi
incq %rsi
callq 0x92e0
movq %rbx, %rdi
popq %rbx
jmp 0xcf76
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x2852c
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x92e0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a1d7
callq 0x1a23e
movl %eax, %r14d
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x9350
movq %rax, %r15
leaq 0x2db8f(%rip), %rsi     # 0x47d0c
movl $0x4, %edx
movq %rax, %rdi
callq 0x9350
movq %r15, %rdi
movl %r14d, %esi
callq 0x94c0
movq %rax, %r15
leaq 0x32a9c(%rip), %rsi     # 0x4cc3b
movl $0x4, %edx
movq %rax, %rdi
callq 0x9350
leal 0x1(%r14), %esi
movq %r15, %rdi
callq 0x94c0
movq %rax, %r15
leaq 0x2db4f(%rip), %rsi     # 0x47d11
movl $0x7, %edx
movq %rax, %rdi
callq 0x9350
movq %r15, %rdi
movl %r14d, %esi
jmp 0x1a217
callq 0x1a290
movzbl %al, %ebp
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x9350
movq %rax, %r14
leaq 0x2dead(%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 0x2af3c(%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_O1/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 0x1a8b6
movl %esi, %eax
leaq 0x2d61a(%rip), %rcx     # 0x47e34
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2cc92(%rip), %rsi     # 0x474bc
jmp 0x1a8a9
leaq 0x2ccd4(%rip), %rsi     # 0x47507
jmp 0x1a8a9
leaq 0x2cccd(%rip), %rsi     # 0x47509
jmp 0x1a8a9
leaq 0x2d662(%rip), %rsi     # 0x47ea7
movl $0x3, %edx
jmp 0x1a8ae
leaq 0x2d651(%rip), %rsi     # 0x47ea4
jmp 0x1a892
leaq 0x2a901(%rip), %rsi     # 0x4515d
jmp 0x1a8a9
leaq 0x2cc55(%rip), %rsi     # 0x474ba
jmp 0x1a8a9
leaq 0x2da59(%rip), %rsi     # 0x482c7
jmp 0x1a8a9
leaq 0x2da53(%rip), %rsi     # 0x482ca
jmp 0x1a8a9
leaq 0x2cc8b(%rip), %rsi     # 0x4750b
jmp 0x1a892
leaq 0x2d61f(%rip), %rsi     # 0x47ea8
jmp 0x1a892
leaq 0x2cc7c(%rip), %rsi     # 0x4750e
movl $0x2, %edx
jmp 0x1a8ae
leaq 0x2cc65(%rip), %rsi     # 0x47505
jmp 0x1a8a9
leaq 0x2d5fc(%rip), %rsi     # 0x47ea5
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9350
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/pfnet-research[P]pml/src/mdp_variable.cpp
// Function: mdp::operator<<(std::ostream&, mdp::variable_t const&)
std::ostream& operator<<(std::ostream& os, variable_t const& var) {
    if (var.is_int()) { // bounded integer
        std::string const& name = var.name;
        int min = var.as_int().bound.min;
        int max = var.as_int().bound.max;
        int init = var.as_int().init;
        if (min == max)
            os << name << " : int init " << min << ";";
        else
            os << name << " : [" << min << ".." << max << "] init " << init << ";";
    } else { // bool
        os << var.name << ": bool init " << std::boolalpha << var.as_bool().init << ";";
    }
    return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rsi), %eax
movl %eax, %ecx
sarl $0x1f, %ecx
cmpl %eax, %ecx
jne 0x1b675
movq %r14, %rdi
callq 0x1b7f8
movl (%rax), %ebp
movq %r14, %rdi
callq 0x1b7f8
movl 0x4(%rax), %r12d
movq %r14, %rdi
callq 0x1b7f8
cmpl %r12d, %ebp
jne 0x1b6bd
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x9350
movq %rax, %r14
leaq 0x2ca36(%rip), %rsi     # 0x48094
movl $0xc, %edx
movq %rax, %rdi
callq 0x9350
movq %r14, %rdi
movl %ebp, %esi
jmp 0x1b730
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x9350
movq %rax, %r15
leaq 0x2ca16(%rip), %rsi     # 0x480a4
movl $0xc, %edx
movq %rax, %rdi
callq 0x9350
movq (%r15), %rax
movq -0x18(%rax), %rax
orl $0x1, 0x18(%r15,%rax)
movq %r14, %rdi
callq 0x1b848
movzbl (%rax), %esi
movq %r15, %rdi
callq 0x9490
jmp 0x1b735
movl 0x8(%rax), %r15d
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x9350
movq %rax, %r14
leaq 0x2c632(%rip), %rsi     # 0x47d0c
movl $0x4, %edx
movq %rax, %rdi
callq 0x9350
movq %r14, %rdi
movl %ebp, %esi
callq 0x94c0
movq %rax, %r14
leaq 0x2c9a6(%rip), %rsi     # 0x480a1
movl $0x2, %edx
movq %rax, %rdi
callq 0x9350
movq %r14, %rdi
movl %r12d, %esi
callq 0x94c0
movq %rax, %r14
leaq 0x2c5f4(%rip), %rsi     # 0x47d11
movl $0x7, %edx
movq %rax, %rdi
callq 0x9350
movq %r14, %rdi
movl %r15d, %esi
callq 0x94c0
leaq 0x29a23(%rip), %rsi     # 0x4515f
movl $0x1, %edx
movq %rax, %rdi
callq 0x9350
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/pfnet-research[P]pml/src/mdp_variable.cpp
// Function: mdp::operator==(mdp::variable_t const&, mdp::variable_t const&)
bool operator==(variable_t const& lhs, variable_t const& rhs) {
    if (lhs.is_int() != rhs.is_int())
        return false;

    if (lhs.is_int()) {
        return lhs.name == rhs.name &&
            lhs.as_int().init == rhs.as_int().init;
    } else {
        return lhs.name == rhs.name &&
            lhs.as_bool().init == rhs.as_bool().init;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x20(%rdi), %eax
movl %eax, %ecx
sarl $0x1f, %ecx
cmpl %eax, %ecx
sete %dl
movl 0x20(%rsi), %esi
movl %esi, %edi
sarl $0x1f, %edi
cmpl %esi, %edi
sete %sil
xorb %dl, %sil
je 0x1b786
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%r14), %rdx
movq 0x8(%rbx), %rsi
cmpl %eax, %ecx
jne 0x1b7c3
cmpq %rsi, %rdx
jne 0x1b77f
testq %rdx, %rdx
je 0x1b7ab
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x9300
testl %eax, %eax
jne 0x1b77f
movq %r14, %rdi
callq 0x1b7f8
movl 0x8(%rax), %ebp
movq %rbx, %rdi
callq 0x1b7f8
cmpl 0x8(%rax), %ebp
jmp 0x1b7f2
cmpq %rsi, %rdx
jne 0x1b77f
testq %rdx, %rdx
je 0x1b7dc
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x9300
testl %eax, %eax
jne 0x1b77f
movq %r14, %rdi
callq 0x1b848
movb (%rax), %bpl
movq %rbx, %rdi
callq 0x1b848
cmpb (%rax), %bpl
sete %al
jmp 0x1b781
nop