LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5cc0
andb $0x1, %al
movb %al, -0x25(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5d20
andb $0x1, %al
movb %al, -0x26(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5d60
andb $0x1, %al
movb %al, -0x27(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5e30
andb $0x1, %al
movb %al, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5e80
andb $0x1, %al
movb %al, -0x29(%rbp)
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5c38
movl -0x24(%rbp), %edi
callq 0x5ec0
movb $0x0, -0x1(%rbp)
jmp 0x5ca8
movb -0x26(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5c53
movl -0x24(%rbp), %edi
callq 0x5ef0
movb $0x0, -0x1(%rbp)
jmp 0x5ca8
movb -0x27(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5c6e
movl -0x24(%rbp), %edi
callq 0x5ef0
movb $0x0, -0x1(%rbp)
jmp 0x5ca8
movb -0x28(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5c89
movl -0x24(%rbp), %edi
callq 0x5ef0
movb $0x0, -0x1(%rbp)
jmp 0x5ca8
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5ca4
movl -0x24(%rbp), %edi
callq 0x5ef0
movb $0x0, -0x1(%rbp)
jmp 0x5ca8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x5430
callq 0x5070
cmpl $0x2, (%rax)
je 0x5d01
movl -0x88(%rbp), %eax
andl $0x80, %eax
cmpl $0x80, %eax
je 0x5d01
movb $0x0, -0x1(%rbp)
jmp 0x5d05
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Cristian-Castillo[P]Multithreaded-HTTP-Server/./httpserver_definitions.cpp
// Function: f_bool_check_file_len(char*)
bool f_bool_check_file_len(char *file){
    if(strlen(file) != 10){
        perror("Invalid file format length. Length must be ten characters.\n");
        return false;
    }
    else{
        return true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51f0
cmpq $0xa, %rax
je 0x5d4d
leaq 0x2f4e4(%rip), %rdi     # 0x35226
callq 0x53f0
movb $0x0, -0x1(%rbp)
jmp 0x5d51
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x5e20
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x5db7
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5a, %eax
jle 0x5dfb
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x5dd9
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7a, %eax
jle 0x5dfb
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x5dfd
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x5dfd
jmp 0x5e0f
leaq 0x2f3d8(%rip), %rdi     # 0x351dc
callq 0x53f0
movb $0x0, -0x1(%rbp)
jmp 0x5e24
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5d74
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x609f
callq 0x5070
cmpl $0x6b, (%rax)
jne 0x5fa0
movq 0x49062(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f36a(%rip), %rsi     # 0x352f1
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
callq 0x5070
cmpl $0x4, (%rax)
jne 0x5feb
movq 0x49017(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f339(%rip), %rsi     # 0x3530b
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
callq 0x5070
cmpl $0x58, (%rax)
jne 0x6036
movq 0x48fcc(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f30b(%rip), %rsi     # 0x35328
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
callq 0x5070
cmpl $0x5f, (%rax)
jne 0x6081
movq 0x48f81(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f2d2(%rip), %rsi     # 0x3533a
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
leaq 0x2f2d9(%rip), %rdi     # 0x35361
callq 0x53f0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
leaq 0x2f2bb(%rip), %rdi     # 0x35361
callq 0x53f0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x6189
callq 0x5070
cmpl $0x9, (%rax)
jne 0x6120
movq 0x48ee2(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f273(%rip), %rsi     # 0x3537a
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
callq 0x5070
cmpl $0x58, (%rax)
jne 0x616b
movq 0x48e97(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f258(%rip), %rsi     # 0x353aa
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
leaq 0x2f266(%rip), %rdi     # 0x353d8
callq 0x53f0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
leaq 0x2f248(%rip), %rdi     # 0x353d8
callq 0x53f0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x630f
callq 0x5070
cmpl $0x62, (%rax)
jne 0x6210
movq 0x48df2(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f1ff(%rip), %rsi     # 0x353f6
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
callq 0x5070
cmpl $0x9, (%rax)
jne 0x625b
movq 0x48da7(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f1de(%rip), %rsi     # 0x35420
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
callq 0x5070
cmpl $0x58, (%rax)
jne 0x62a6
movq 0x48d5c(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f1be(%rip), %rsi     # 0x3544b
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
callq 0x5070
cmpl $0x16, (%rax)
jne 0x62f1
movq 0x48d11(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f1af(%rip), %rsi     # 0x35487
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
leaq 0x2f1bf(%rip), %rdi     # 0x354b7
callq 0x53f0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
leaq 0x2f1a1(%rip), %rdi     # 0x354b7
callq 0x53f0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x6444
callq 0x5070
cmpl $0x62, (%rax)
jne 0x6390
movq 0x48c72(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f157(%rip), %rsi     # 0x354ce
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
callq 0x5070
cmpl $0x9, (%rax)
jne 0x63db
movq 0x48c27(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f05e(%rip), %rsi     # 0x35420
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
callq 0x5070
cmpl $0x5f, (%rax)
jne 0x6426
movq 0x48bdc(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f0ef(%rip), %rsi     # 0x354fc
movb $0x0, %al
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
leaq 0x2f116(%rip), %rdi     # 0x35543
callq 0x53f0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
leaq 0x2f0f8(%rip), %rdi     # 0x35543
callq 0x53f0
movl -0x4(%rbp), %edi
callq 0x58b0
movl $0x1, %edi
callq 0x5580
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x6688
callq 0x5070
cmpl $-0x3, (%rax)
jne 0x6585
movq 0x48a7e(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f0ed(%rip), %rsi     # 0x35658
movb $0x0, %al
callq 0x56a0
movq -0x10(%rbp), %rdi
callq 0x5610
movl $0x1, %edi
callq 0x5580
callq 0x5070
cmpl $-0x7, (%rax)
jne 0x65d1
movq 0x48a32(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f0ef(%rip), %rsi     # 0x356a6
movb $0x0, %al
callq 0x56a0
movq -0x10(%rbp), %rdi
callq 0x5610
movl $0x1, %edi
callq 0x5580
callq 0x5070
cmpl $-0x1, (%rax)
jne 0x661d
movq 0x489e6(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f0d3(%rip), %rsi     # 0x356d6
movb $0x0, %al
callq 0x56a0
movq -0x10(%rbp), %rdi
callq 0x5610
movl $0x1, %edi
callq 0x5580
callq 0x5070
cmpl $-0x7, (%rax)
jne 0x6669
movq 0x4899a(%rip), %rax     # 0x4efc8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5150
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f0b2(%rip), %rsi     # 0x35701
movb $0x0, %al
callq 0x56a0
movq -0x10(%rbp), %rdi
callq 0x5610
movl $0x1, %edi
callq 0x5580
leaq 0x2f0c2(%rip), %rdi     # 0x35732
callq 0x53f0
movq -0x10(%rbp), %rdi
callq 0x5610
movl $0x1, %edi
callq 0x5580
leaq 0x2f0bb(%rip), %rdi     # 0x3574a
callq 0x53f0
movq -0x10(%rbp), %rdi
callq 0x5610
movl $0x1, %edi
callq 0x5580
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
leaq -0x98(%rbp), %rsi
callq 0x57a0
movq -0x68(%rbp), %rax
movl %eax, -0x9c(%rbp)
movq 0x2fbaf(%rip), %rax     # 0x362e0
movq %rax, -0xc0(%rbp)
movq 0x2fba9(%rip), %rax     # 0x362e8
movq %rax, -0xb8(%rbp)
movw 0x2fba3(%rip), %ax      # 0x362f0
movw %ax, -0xb0(%rbp)
movq 0x2fba5(%rip), %rax     # 0x36300
movq %rax, -0xe0(%rbp)
movq 0x2fb9f(%rip), %rax     # 0x36308
movq %rax, -0xd8(%rbp)
movb 0x2fb9a(%rip), %al      # 0x36310
movb %al, -0xd0(%rbp)
movl 0x2ee70(%rip), %eax     # 0x355f2
movl %eax, -0xe5(%rbp)
movb 0x2ee68(%rip), %al      # 0x355f6
movb %al, -0xe1(%rbp)
leaq -0xa6(%rbp), %rdi
movl -0x9c(%rbp), %edx
leaq 0x2f102(%rip), %rsi     # 0x358aa
movb $0x0, %al
callq 0x50b0
movl -0x8(%rbp), %eax
movl %eax, -0x124(%rbp)
leaq -0xc0(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x51f0
movl -0x124(%rbp), %edi
movq -0x120(%rbp), %rsi
movq %rax, %rdx
callq 0x5170
movl -0x8(%rbp), %eax
movl %eax, -0x114(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x51f0
movl -0x114(%rbp), %edi
movq -0x110(%rbp), %rsi
movq %rax, %rdx
callq 0x5170
movl -0x8(%rbp), %eax
movl %eax, -0x104(%rbp)
leaq -0xa6(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq -0xa6(%rbp), %rdi
callq 0x51f0
movl -0x104(%rbp), %edi
movq -0x100(%rbp), %rsi
movq %rax, %rdx
callq 0x5170
movl -0x8(%rbp), %eax
movl %eax, -0xf4(%rbp)
leaq -0xe5(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xe5(%rbp), %rdi
callq 0x51f0
movl -0xf4(%rbp), %edi
movq -0xf0(%rbp), %rsi
movq %rax, %rdx
callq 0x5170
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x5450
movq -0xb8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5820
movq -0xb8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5820
leaq 0x2ee79(%rip), %rsi     # 0x3579b
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movl $0x10, %edx
callq 0x8c60
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
xorl %edx, %edx
callq 0x8d00
movb %al, -0xa5(%rbp)
jmp 0x6957
movb -0xa5(%rbp), %al
andb $0x1, %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
movb %al, -0xb9(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x8d50
movb -0xb9(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x8d50
movq -0xa0(%rbp), %rdi
callq 0x5800
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x27f0
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x48(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x1d53
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rax
movq 0x30(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x2c(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x1d3e
movq 0x30(%rsp), %rax
addq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x58(%rsp), %rax
jb 0x1ce3
movq 0x18(%rsp), %rax
subq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x1ced
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movl 0x2c(%rsp), %edx
movq 0x60(%rsp), %rax
movq 0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x1ca7
jmp 0x1d40
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x1c73
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
callq 0x1040
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq *%rax
callq 0x1040
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2850
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x28a0
leaq 0x10(%rsp), %rdi
callq 0x28e0
movq 0x30e2(%rip), %rdi      # 0x4fc8
callq 0x1170
movq %rax, %rdi
movq 0x30c3(%rip), %rsi      # 0x4fb8
callq 0x10b0
addq $0x48, %rsp
retq
nop
// File: lishen2[P]Excel_formula_parser_cpp/main.cpp
// Function: printParser(ExcelFormula::FormulaParser&)
void printParser(FormulaParser& parser)
{
	vector<Token*> tokens = parser.getTokens();
	cout << "Formula:" << parser.getFormula() << endl;
	cout << "Tokens:" << endl;
	
	int indent = 0;
	for(vector<Token*>::iterator it = tokens.begin();
			it != tokens.end();
			++it)
	{
		if((*it)->getSubtype() == Token::Start)
		{
			++indent;
		}
		printIndent(indent);
		cout << (*it)->getPrintableString() << endl;
		if((*it)->getSubtype() == Token::Stop)
		{
			--indent;
		}
	}

	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28b0
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x28d0
movq 0xba85(%rip), %rdi      # 0xdfd0
leaq 0x7ab4(%rip), %rsi      # 0xa006
callq 0x2200
movq %rax, -0x68(%rbp)
jmp 0x255d
movq -0x8(%rbp), %rdi
callq 0x29c0
movq %rax, -0x70(%rbp)
jmp 0x256c
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x2200
movq %rax, -0x78(%rbp)
jmp 0x257f
movq -0x78(%rbp), %rdi
movq 0xba26(%rip), %rsi      # 0xdfb0
callq 0x2240
jmp 0x2591
movq 0xba38(%rip), %rdi      # 0xdfd0
leaq 0x7a70(%rip), %rsi      # 0xa00f
callq 0x2200
movq %rax, -0x80(%rbp)
jmp 0x25aa
movq -0x80(%rbp), %rdi
movq 0xb9fb(%rip), %rsi      # 0xdfb0
callq 0x2240
jmp 0x25bc
movl $0x0, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x29e0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2a50
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2a10
testb $0x1, %al
jne 0x25f3
jmp 0x26e1
leaq -0x38(%rbp), %rdi
callq 0x2a80
movq (%rax), %rdi
callq 0x2aa0
movl %eax, -0x84(%rbp)
jmp 0x260c
movl -0x84(%rbp), %eax
cmpl $0x1, %eax
jne 0x2633
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2633
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2708
movl -0x30(%rbp), %edi
callq 0x24e0
jmp 0x263d
leaq -0x38(%rbp), %rdi
callq 0x2a80
movq (%rax), %rsi
leaq -0x60(%rbp), %rdi
callq 0x70b0
jmp 0x2654
movq 0xb975(%rip), %rdi      # 0xdfd0
leaq -0x60(%rbp), %rsi
callq 0x21c0
movq %rax, -0x90(%rbp)
jmp 0x266d
movq -0x90(%rbp), %rdi
movq 0xb935(%rip), %rsi      # 0xdfb0
callq 0x2240
jmp 0x2682
leaq -0x60(%rbp), %rdi
callq 0x23a8
leaq -0x38(%rbp), %rdi
callq 0x2a80
movq (%rax), %rdi
callq 0x2aa0
movl %eax, -0x94(%rbp)
jmp 0x26a4
movl -0x94(%rbp), %eax
cmpl $0x2, %eax
jne 0x26d1
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x26d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x23a8
jmp 0x2708
jmp 0x26d3
leaq -0x38(%rbp), %rdi
callq 0x2ac0
jmp 0x25d0
movq 0xb8e8(%rip), %rdi      # 0xdfd0
movq 0xb8c1(%rip), %rsi      # 0xdfb0
callq 0x2240
jmp 0x26f6
leaq -0x20(%rbp), %rdi
callq 0x2ae0
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x2ae0
movq -0x28(%rbp), %rdi
callq 0x2320
nopw (%rax,%rax)
// File: 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
subq $0x210, %rsp            # imm = 0x210
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x352b33, -0x15(%rbp)  # imm = 0x352B33
movl $0x332b313d, -0x18(%rbp) # imm = 0x332B313D
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x208(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x3820
movq -0x208(%rbp), %rdi
callq 0x3960
jmp 0x276c
leaq -0xc8(%rbp), %rdi
callq 0x5330
jmp 0x277a
leaq -0xc8(%rbp), %rdi
callq 0x2520
jmp 0x2788
movups 0x78fd(%rip), %xmm0     # 0xa08c
movups %xmm0, -0xe4(%rbp)
movaps 0x78e3(%rip), %xmm0     # 0xa080
movaps %xmm0, -0xf0(%rbp)
movaps 0x78c5(%rip), %xmm0     # 0xa070
movaps %xmm0, -0x100(%rbp)
movaps 0x78a7(%rip), %xmm0     # 0xa060
movaps %xmm0, -0x110(%rbp)
movaps 0x7889(%rip), %xmm0     # 0xa050
movaps %xmm0, -0x120(%rbp)
movaps 0x786b(%rip), %xmm0     # 0xa040
movaps %xmm0, -0x130(%rbp)
movaps 0x784d(%rip), %xmm0     # 0xa030
movaps %xmm0, -0x140(%rbp)
movaps 0x782f(%rip), %xmm0     # 0xa020
movaps %xmm0, -0x150(%rbp)
leaq -0x200(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0x3820
jmp 0x280d
leaq -0x200(%rbp), %rdi
callq 0x3960
jmp 0x281b
leaq -0x200(%rbp), %rdi
callq 0x5330
jmp 0x2829
leaq -0x200(%rbp), %rdi
callq 0x2520
jmp 0x2837
movl $0x0, -0x4(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x2b40
leaq -0xc8(%rbp), %rdi
callq 0x2b40
movl -0x4(%rbp), %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x2894
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x2b40
leaq -0xc8(%rbp), %rdi
callq 0x2b40
movq -0xd0(%rbp), %rdi
callq 0x2320
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x20, %rdi
callq 0x29e0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6140
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x2a50
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6180
testb $0x1, %al
jne 0x5e12
jmp 0x5e4c
leaq -0x10(%rbp), %rdi
callq 0x61c0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5e3f
movq -0x30(%rbp), %rdi
callq 0x61e0
movq -0x30(%rbp), %rdi
movl $0x28, %esi
callq 0x2220
jmp 0x5e41
leaq -0x10(%rbp), %rdi
callq 0x6200
jmp 0x5dee
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x6220
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2160
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x6c0c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2390
movsbl (%rax), %edi
callq 0x6c80
testb $0x1, %al
jne 0x6bfc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x2060
jmp 0x6c0c
jmp 0x6bfe
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6bb3
movq -0x10(%rbp), %rdi
callq 0x2160
subq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jb 0x6c67
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2390
movsbl (%rax), %edi
callq 0x6c80
testb $0x1, %al
jne 0x6c57
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
movq $-0x1, %rdx
callq 0x2060
jmp 0x6c67
jmp 0x6c59
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6c1d
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20d0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: lishen2[P]Excel_formula_parser_cpp/StrUtils.cpp
// Function: StrUtils::isEmpChar(char)
bool StrUtils::isEmpChar(const char c)
{
	static const char empChar[] = {' ', '\t'};
	static const int empLen = 2;

	for(int i = 0; i < empLen; ++i)
	{
		if (c == empChar[i]) return true;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x6cc1
movsbl -0x2(%rbp), %eax
movslq -0x8(%rbp), %rdx
leaq 0x34a2(%rip), %rcx      # 0xa148
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x6cb4
movb $0x1, -0x1(%rbp)
jmp 0x6cc5
jmp 0x6cb6
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x6c91
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x6dd8
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x22c0
cmpl $0x0, %eax
jne 0x6dcb
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6dde
jmp 0x6dcd
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6da1
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lishen2[P]Excel_formula_parser_cpp/Token.cpp
// Function: ExcelFormula::Token::operator==(ExcelFormula::Token&)
bool Token::operator==(Token& token) {
		if (token.getType() == getType()
				&& token.getSubtype() == getSubtype()
				&& token.getStrValue().compare(getStrValue()) == 0)
			return true;
		else
			return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6000
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
callq 0x6000
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jne 0x70a1
movq -0x18(%rbp), %rdi
callq 0x2aa0
movq -0x28(%rbp), %rdi
movl %eax, -0x2c(%rbp)
callq 0x2aa0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jne 0x70a1
movq -0x18(%rbp), %rdi
callq 0x60a0
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x60a0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x2030
cmpl $0x0, %eax
jne 0x70a1
movb $0x1, -0x1(%rbp)
jmp 0x70a5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
callq 0x3080
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x75da
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jae 0x75e4
movq $0x0, -0x8(%rbp)
jmp 0x75fe
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq (%rax), %rsi
callq 0x7850
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
callq 0x29e0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6140
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x2a50
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6180
testb $0x1, %al
jne 0x7802
jmp 0x783c
leaq -0x10(%rbp), %rdi
callq 0x61c0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x782f
movq -0x30(%rbp), %rdi
callq 0x61e0
movq -0x30(%rbp), %rdi
movl $0x28, %esi
callq 0x2220
jmp 0x7831
leaq -0x10(%rbp), %rdi
callq 0x6200
jmp 0x77de
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x6220
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x8650
testb $0x1, %al
jne 0x857f
jmp 0x8589
movq $0x0, -0x8(%rbp)
jmp 0x85bd
movq -0x20(%rbp), %rdi
callq 0x8670
movq (%rax), %rdi
callq 0x7340
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x8690
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x60d0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0xc390
testb $0x1, %al
jne 0xae73
jmp 0xae80
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xafec
movq -0x10(%rbp), %rdi
leaq 0x8e2e2(%rip), %rsi     # 0x9916d
callq 0xa3b0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc3d0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x32260
movq %rax, %rdi
leaq 0x92837(%rip), %rsi     # 0x9d6ea
callq 0xa3b0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc400
movq %rax, %rdi
callq 0xc3d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x32260
movq %rax, %rdi
leaq 0x91499(%rip), %rsi     # 0x9c388
callq 0xa3b0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc400
movq %rax, %rdi
addq $0x10, %rdi
callq 0xc3d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x32260
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0xc420
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0xafd4
movq -0x10(%rbp), %rdi
leaq 0x8e218(%rip), %rsi     # 0x99171
callq 0xa3b0
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
callq 0xc400
movq %rax, %rdi
callq 0xc3d0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x32260
movq %rax, %rdi
leaq 0x913f7(%rip), %rsi     # 0x9c388
callq 0xa3b0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
callq 0xc400
movq %rax, %rdi
addq $0x10, %rdi
callq 0xc3d0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x32260
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xaf29
movq -0x10(%rbp), %rdi
leaq 0x8e194(%rip), %rsi     # 0x99173
callq 0xa3b0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x970b2(%rip), %rsi     # 0xa20cd
callq 0xa3b0
movq %rax, %rdi
movq 0xdbf2e(%rip), %rsi     # 0xe6f58
callq 0xa400
movq %rax, %rdi
movq 0xdbf1f(%rip), %rsi     # 0xe6f58
callq 0xa400
movq -0x8(%rbp), %rdi
leaq 0x8e12c(%rip), %rsi     # 0x99175
callq 0xa3b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xa340
movq %rax, %rdi
movq 0xdbef4(%rip), %rsi     # 0xe6f58
callq 0xa400
movq %rax, %rdi
movq 0xdbee5(%rip), %rsi     # 0xe6f58
callq 0xa400
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc440
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc470
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc4a0
testb $0x1, %al
jne 0xb0b1
jmp 0xb0e5
leaq -0x20(%rbp), %rdi
callq 0xc4e0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x33610
movq %rax, %rdi
movq 0xdbe83(%rip), %rsi     # 0xe6f58
callq 0xa400
leaq -0x20(%rbp), %rdi
callq 0xc500
jmp 0xb09e
movq -0x10(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xc520
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xc550
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc580
testb $0x1, %al
jne 0xb11e
jmp 0xb152
leaq -0x40(%rbp), %rdi
callq 0xc5c0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x30670
movq %rax, %rdi
movq 0xdbe16(%rip), %rsi     # 0xe6f58
callq 0xa400
leaq -0x40(%rbp), %rdi
callq 0xc5e0
jmp 0xb10b
movq -0x8(%rbp), %rdi
movq 0xdbdfb(%rip), %rsi     # 0xe6f58
callq 0xa400
movq -0x10(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0xc600
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0xc630
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xc660
testb $0x1, %al
jne 0xb19b
jmp 0xb1cf
leaq -0x60(%rbp), %rdi
callq 0xc6a0
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xae50
movq %rax, %rdi
movq 0xdbd99(%rip), %rsi     # 0xe6f58
callq 0xa400
leaq -0x60(%rbp), %rdi
callq 0xc6c0
jmp 0xb188
movq -0x8(%rbp), %rdi
movq 0xdbd7e(%rip), %rsi     # 0xe6f58
callq 0xa400
movq -0x8(%rbp), %rdi
leaq 0x8df93(%rip), %rsi     # 0x9917d
callq 0xa3b0
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0xbc90
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0xbc90
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xb363
movb $0x0, -0x1(%rbp)
jmp 0xb488
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0xbc90
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xb3dd
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
callq 0xc760
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
callq 0xc760
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xb4a0
testb $0x1, %al
jne 0xb3c4
jmp 0xb3cd
movb $0x0, -0x1(%rbp)
jmp 0xb488
jmp 0xb3cf
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb36b
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xc210
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0xc210
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0xb40d
movb $0x0, -0x1(%rbp)
jmp 0xb488
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xc210
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0xb484
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
movq -0x28(%rbp), %rsi
callq 0xc780
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
movq -0x28(%rbp), %rsi
callq 0xc780
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xb4d0
testb $0x1, %al
jne 0xb46e
jmp 0xb474
movb $0x0, -0x1(%rbp)
jmp 0xb488
jmp 0xb476
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb415
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pfnet-research[P]pml/./include/expr_ast.hpp
// Function: ast::is_value(ast::expr_t const&)
inline static bool is_value(expr_t const& e) {
    switch (e.kind()) {
    case expr_kind_t::Int:
    case expr_kind_t::Bool:
    case expr_kind_t::Var:
        return true;
    default:
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, %ecx
movl %ecx, %eax
addl $-0x11, %eax
movl %ecx, -0x14(%rbp)
subl $0x2, %eax
jb 0x11bf3
jmp 0x11be9
movl -0x14(%rbp), %eax
subl $0x14, %eax
jne 0x11bf9
jmp 0x11bf3
movb $0x1, -0x1(%rbp)
jmp 0x11bfd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)