LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/liuhaotian[P]xmppsh/libstrophe/examples/roster.c
// Function: handle_reply
int handle_reply(xmpp_conn_t * const conn,
		 xmpp_stanza_t * const stanza,
		 void * const userdata)
{
    xmpp_stanza_t *query, *item;
    char *type, *name;

    type = xmpp_stanza_get_type(stanza);
    if (strcmp(type, "error") == 0)
	fprintf(stderr, "ERROR: query failed\n");
    else {
	query = xmpp_stanza_get_child_by_name(stanza, "query");
	printf("Roster:\n");
	for (item = xmpp_stanza_get_children(query); item; 
	     item = xmpp_stanza_get_next(item))
	    if ((name = xmpp_stanza_get_attribute(item, "name")))
		printf("\t %s (%s) sub=%s\n", 
		       name,
		       xmpp_stanza_get_attribute(item, "jid"),
		       xmpp_stanza_get_attribute(item, "subscription"));
	    else
		printf("\t %s sub=%s\n",
		       xmpp_stanza_get_attribute(item, "jid"),
		       xmpp_stanza_get_attribute(item, "subscription"));
	printf("END OF LIST\n");
    }

    /* disconnect */
    xmpp_disconnect(conn);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xb425
leaq 0xa4e4(%rip), %rsi      # 0xcaa0
movq %rax, %rdi
callq 0x2270
testl %eax, %eax
je 0x26a9
movq %r14, (%rsp)
leaq 0x9a42(%rip), %rsi      # 0xc019
movq %rbx, %rdi
callq 0xb443
movq %rax, %rbx
leaq 0x9aca(%rip), %rdi      # 0xc0b3
callq 0x22e0
movq %rbx, %rdi
callq 0xb4e2
testq %rax, %rax
je 0x2680
movq %rax, %r14
leaq 0x9d64(%rip), %r15      # 0xc36d
leaq 0x9a21(%rip), %r12      # 0xc031
leaq 0x9a1e(%rip), %r13      # 0xc035
movq %r14, %rdi
movq %r15, %rsi
callq 0xb5dc
movq %rax, %rbp
movq %r14, %rdi
movq %r12, %rsi
callq 0xb5dc
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
callq 0xb5dc
testq %rbp, %rbp
je 0x265c
leaq 0x99d5(%rip), %rdi      # 0xc01f
movq %rbp, %rsi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2030
jmp 0x2670
leaq 0x99df(%rip), %rdi      # 0xc042
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2030
movq %r14, %rdi
callq 0xb4e7
movq %rax, %r14
testq %rax, %rax
jne 0x2617
leaq 0x9a34(%rip), %rdi      # 0xc0bb
callq 0x22e0
movq (%rsp), %r14
movq %r14, %rdi
callq 0x474d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2380
jmp 0x2690
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/test/test_str2int.c
// Function: check_strprint2
static int
check_strprint2(int verbose, const char *str, size_t len, size_t destlen,
                char quote, const char *expect) {
    char buf[100];
    hts_strprint(buf, destlen, quote, str, len);
    if (strcmp(buf, expect) != 0) {
        fprintf(stderr, "hts_strprint failed: length %zu: got \"%.*s\", "
                "expected \"%s\"\n", destlen, (int) destlen, buf, expect);
        return -1;
    }
    else if (verbose) {
        fprintf(stderr, "hts_strprint OK: length %zu: got \"%s\"\n",
                destlen, expect);
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %rax
movq %rsi, %rcx
movl %edi, %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl %r8d, %edx
movq %rax, %r8
callq 0x7d13
movq %r15, %rdi
movq %rbx, %rsi
callq 0x46c0
testl %eax, %eax
jne 0x6d42
xorl %r15d, %r15d
testl %ebp, %ebp
jne 0x6d6e
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xa9297(%rip), %rax     # 0xaffe0
movq (%rax), %rdi
leaq 0x884bb(%rip), %rsi     # 0x8f20e
movq %rsp, %r8
movq %r14, %rdx
movl %r14d, %ecx
movq %rbx, %r9
xorl %eax, %eax
callq 0x4700
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x6d34
movq 0xa926b(%rip), %rax     # 0xaffe0
movq (%rax), %rdi
leaq 0x884cb(%rip), %rsi     # 0x8f24a
xorl %r15d, %r15d
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4700
jmp 0x6d34
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/thirdparty/ctest.h
// Function: color_print
static void color_print(const char* color, const char* text) {
    if (color_output)
        printf("%s%s"ANSI_NORMAL"\n", color, text);
    else
        printf("%s\n", text);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rdx
cmpl $0x0, 0x5590(%rip)      # 0x8128
je 0x2bac
movq %rdi, %rsi
leaq 0x26f2(%rip), %rdi      # 0x5296
xorl %eax, %eax
popq %rbp
jmp 0x2100
movq %rdx, %rdi
popq %rbp
jmp 0x2080
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/utilities.c
// Function: Escape_html
char* Escape_html(char* str)
{
    int len = (int)strlen(str);
    /// In the worst case, string is increased 3 times + '\0'
    char* without_html_str = (char*)calloc((len * 3) + 1, sizeof(char));
    int j = 0;
    for (int i = 0; i < len; i++, j++) {
        if (str[i] == '<') {
            without_html_str[j] = '&';
            without_html_str[j + 1] = 'l';
            without_html_str[j + 2] = 't';
            j += 2;
        } else if (str[i] == '>') {
            without_html_str[j] = '&';
            without_html_str[j + 1] = 'g';
            without_html_str[j + 2] = 't';
            j += 2;
        } else {
            without_html_str[j] = str[i];
        }
    }
    without_html_str[j] = '\0';
    free(str);
    return without_html_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20d0
movq %rax, %r15
leaq (%rax,%rax,2), %rax
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2180
movq %rax, %r14
xorl %eax, %eax
testl %r15d, %r15d
jle 0x3cd2
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movzbl (%rbx,%rcx), %esi
movslq %eax, %rdx
cmpl $0x3e, %esi
je 0x3cad
cmpl $0x3c, %esi
jne 0x3cc2
movw $0x6c26, (%r14,%rdx)    # imm = 0x6C26
jmp 0x3cb4
movw $0x6726, (%r14,%rdx)    # imm = 0x6726
movb $0x74, 0x2(%r14,%rdx)
addq $0x2, %rdx
movl %edx, %eax
jmp 0x3cc6
movb %sil, (%r14,%rdx)
incq %rcx
incl %eax
cmpq %rcx, %r15
jne 0x3c93
cltq
movb $0x0, (%r14,%rax)
movq %rbx, %rdi
callq 0x2030
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/utilities.c
// Function: Get_filename_without_extension
const char* Get_filename_without_extension(char* path)
{
    char* temp_path = (char*)calloc(strlen(path), sizeof(char*));
    strcpy(temp_path, path);
    char* last_dot_ptr = strrchr(path, '.');
    if (last_dot_ptr == NULL) {
        return "";
    }
    int last_dot_index = last_dot_ptr - path;
    temp_path[last_dot_index] = '\0';
    temp_path = strrchr(temp_path, '/');
    return temp_path == NULL ? "" : temp_path + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20d0
movl $0x8, %esi
movq %rax, %rdi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2070
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x2120
testq %rax, %rax
je 0x3d53
subl %ebx, %eax
cltq
movb $0x0, (%r14,%rax)
movq %r14, %rdi
movl $0x2f, %esi
callq 0x2120
leaq 0x1(%rax), %rcx
testq %rax, %rax
leaq 0x1de1(%rip), %rax      # 0x5b2e
cmovneq %rcx, %rax
jmp 0x3d5a
leaq 0x1dd4(%rip), %rax      # 0x5b2e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/utilities.c
// Function: Search_files_recursive
int Search_files_recursive(char* path, char** paths, int* recursive_exit_flag)
{
    DIR* d = opendir(path);
    if (d == NULL) {
        printf("\x1b[31m Error! \x1b[0m Wrong path\n");
        return 0;
    }
    struct dirent* dir;
    while ((dir = readdir(d)) != NULL) {
        /// Hidden and system files check
        if (dir->d_name[0] == '.') {
            continue;
        }
        if (*recursive_exit_flag == MAX_COUNT_OF_FILES) {
            return -1;
        }
        if (dir->d_type != DT_DIR) {
            char* f_path = (char*)calloc(MAX_PATH_LEN, sizeof(char));
            sprintf(f_path, "%s/%s", path, dir->d_name);
            strcpy(paths[*recursive_exit_flag], f_path);
            free(f_path);
            *recursive_exit_flag = *recursive_exit_flag + 1;
        } else if (
                dir->d_type == DT_DIR && strcmp(dir->d_name, ".") != 0
                && strcmp(dir->d_name, "..") != 0) {
            char d_path[MAX_PATH_LEN * 2];
            sprintf(d_path, "%s/%s", path, dir->d_name);
            Search_files_recursive(d_path, paths, recursive_exit_flag);
        }
    }
    closedir(d);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %rbx
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
callq 0x20c0
testq %rax, %rax
je 0x3e3c
movq %rax, %r12
movq %r12, %rdi
callq 0x21c0
testq %rax, %rax
je 0x3e32
cmpb $0x2e, 0x13(%rax)
je 0x3d8e
cmpl $0x1e, (%rbx)
je 0x3e5c
leaq 0x13(%rax), %r13
cmpb $0x4, 0x12(%rax)
jne 0x3de7
leaq -0x230(%rbp), %r14
movq %r14, %rdi
leaq 0x1c9b(%rip), %rsi      # 0x5a64
movq %r15, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2200
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
callq 0x3d5f
jmp 0x3d8e
movl $0xff, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
leaq 0x1c61(%rip), %rsi      # 0x5a64
movq %r15, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2200
movslq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq (%rcx,%rax,8), %rdi
movq %r14, %rsi
callq 0x2070
movq %r14, %rdi
callq 0x2030
incl (%rbx)
jmp 0x3d8e
movq %r12, %rdi
callq 0x2150
jmp 0x3e48
leaq 0x1d66(%rip), %rdi      # 0x5ba9
callq 0x2080
xorl %eax, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3e4a
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/utilities.c
// Function: Get_data_from_document
char** Get_data_from_document(char* paths)
{
    FILE* myfile;
    myfile = fopen(paths, "r");
    if (myfile == NULL) {
        printf("%s%s%s\n", "On path ", paths, " file not found!");
        return 0;
    }
    char* ptrFile;
    int quan_str = 0;
    char** data = (char**)calloc(MAX_QTY_STR, sizeof(char*));
    for (int i = 0; i < MAX_QTY_STR; i++) {
        data[i] = (char*)calloc(MAX_LEN_INP_STR, sizeof(char));
    }
    while (quan_str < MAX_QTY_STR) {
        char* temp = (char*)calloc(MAX_LEN_INP_STR, sizeof(char));
        ptrFile = fgets(temp, MAX_LEN_INP_STR, myfile);
        if (ptrFile == NULL) {
            if (feof(myfile) != 0) {
                break;
            }
        }
        strcpy(data[quan_str], temp);
        quan_str++;
        free(temp);
    }
    fclose(myfile);
    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0x1ce8(%rip), %rsi      # 0x5b60
callq 0x21f0
testq %rax, %rax
je 0x3f1d
movq %rax, %r14
movl $0xc350, %edi           # imm = 0xC350
movl $0x8, %esi
callq 0x2180
movq %rax, %rbx
xorl %r15d, %r15d
movl $0x1f4, %edi            # imm = 0x1F4
movl $0x1, %esi
callq 0x2180
movq %rax, (%rbx,%r15,8)
incq %r15
cmpq $0xc350, %r15           # imm = 0xC350
jne 0x3e9e
xorl %r12d, %r12d
movl $0x1f4, %edi            # imm = 0x1F4
movl $0x1, %esi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
movq %r14, %rdx
callq 0x2160
testq %rax, %rax
jne 0x3ef3
movq %r14, %rdi
callq 0x21a0
testl %eax, %eax
jne 0x3f13
movq (%rbx,%r12,8), %rdi
movq %r15, %rsi
callq 0x2070
incq %r12
movq %r15, %rdi
callq 0x2030
cmpq $0xc350, %r12           # imm = 0xC350
jne 0x3ec0
movq %r14, %rdi
callq 0x20b0
jmp 0x3f3e
leaq 0x1b48(%rip), %rdi      # 0x5a6c
leaq 0x1b49(%rip), %rsi      # 0x5a74
leaq 0x1b4b(%rip), %rcx      # 0x5a7d
xorl %ebx, %ebx
movq %r15, %rdx
xorl %eax, %eax
callq 0x2100
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/utilities.c
// Function: Print_help
void Print_help()
{
    printf("%s\n%s\n",
           "usage: documentary [--version] [--help]",
           "\t  [-inpdir <path>] [-outdir <path>]");
    printf("%s\n", "Available commands");
    printf("\t%s\n", "-inpdir");
    printf("\t%s\n", "-outdir");
    printf("\t%s\n", "--help");
    printf("\t%s\n", "--version");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x1b15(%rip), %rdi      # 0x5a8e
leaq 0x1b15(%rip), %rsi      # 0x5a95
leaq 0x1b36(%rip), %rdx      # 0x5abd
xorl %eax, %eax
callq 0x2100
leaq 0x1b4d(%rip), %rdi      # 0x5ae2
callq 0x2080
leaq 0x1b54(%rip), %rbx      # 0x5af5
leaq 0x1345(%rip), %rsi      # 0x52ed
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2100
leaq 0x1342(%rip), %rsi      # 0x52fb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2100
leaq 0x1362(%rip), %rsi      # 0x532c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2100
leaq 0x1347(%rip), %rsi      # 0x5322
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/utilities.c
// Function: Check_argc
int Check_argc(int argc, char** array_argv)
{
    if (argc == 1) {
        printf("%s\n%s\n",
               "usage: documentary [--version] [--help]",
               "\t  [-inpdir <path>] [-outdir <path>]");
        return 0;
    }
    if (argc > 5 || argc == 4) {
        printf("Error! Invalid number of arguments");
        return 0;
    }
    if (argc == 2) {
        if (strcmp(array_argv[1], HELP_FLAG) == 0) {
            Print_help();
            return 0;
        }
        if (strcmp(array_argv[1], VERSION_FLAG) == 0) {
            printf("%s\n", PROGRAM_VERSION);
            return 0;
        }
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jne 0x4017
leaq 0x1a90(%rip), %rdi      # 0x5a8e
leaq 0x1a90(%rip), %rsi      # 0x5a95
leaq 0x1ab1(%rip), %rdx      # 0x5abd
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2100
jmp 0x4082
cmpl $0x6, %edi
setl %al
cmpl $0x4, %edi
setne %cl
testb %cl, %al
jne 0x4039
leaq 0x1acc(%rip), %rdi      # 0x5afa
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2100
jmp 0x4082
movl $0x1, %ebx
cmpl $0x2, %edi
jne 0x4082
movq 0x8(%rsi), %r14
leaq 0x12de(%rip), %rsi      # 0x532c
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x407b
leaq 0x12c1(%rip), %rsi      # 0x5322
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
jne 0x4082
leaq 0x1aa9(%rip), %rdi      # 0x5b1d
callq 0x2080
jmp 0x4080
callq 0x3f6c
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/comments_check.c
// Function: Check_single_comment
int Check_single_comment(char* str)
{
    size_t len = strlen(str);
    for (unsigned int i = 0; i < len; i++) {
        if (str[i] == '/' && str[i + 1] == '/') {
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20d0
testq %rax, %rax
je 0x4230
movl $0x1, %edx
xorl %ecx, %ecx
cmpb $0x2f, (%rbx,%rcx)
movl %edx, %ecx
jne 0x4228
cmpb $0x2f, (%rbx,%rcx)
je 0x4234
leal 0x1(%rcx), %edx
cmpq %rcx, %rax
ja 0x421a
xorl %eax, %eax
jmp 0x4239
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/comments_delete.c
// Function: Del_multiline_comment_begin
char* Del_multiline_comment_begin(char* str)
{
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] == '/' && str[i + 1] == '*') {
            str[i] = ' ';
            str[i + 1] = ' ';
        }
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
leaq 0x1(%rdi), %rcx
movzbl -0x1(%rcx), %edx
cmpl $0x2f, %edx
je 0x42fc
testl %edx, %edx
jne 0x4307
jmp 0x430c
cmpb $0x2a, (%rcx)
jne 0x4307
movw $0x2020, -0x1(%rcx)     # imm = 0x2020
incq %rcx
jmp 0x42ed
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/comments_delete.c
// Function: Del_multiline_comment_end
char* Del_multiline_comment_end(char* str)
{
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] == '*' && str[i + 1] == '/') {
            str[i] = ' ';
            str[i + 1] = ' ';
        }
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
leaq 0x1(%rdi), %rcx
movzbl -0x1(%rcx), %edx
cmpl $0x2a, %edx
je 0x4328
testl %edx, %edx
jne 0x4333
jmp 0x4338
cmpb $0x2f, (%rcx)
jne 0x4333
movw $0x2020, -0x1(%rcx)     # imm = 0x2020
incq %rcx
jmp 0x4319
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/comments_delete.c
// Function: Del_multiline_comment_stars
char* Del_multiline_comment_stars(char* str)
{
    for (unsigned int i = 0; i < strlen(str); i++) {
        if (str[i] != ' ' && str[i] != '*') {
            break;
        } else if (str[i] != ' ' && str[i] == '*') {
            str[i] = ' ';
            break;
        }
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20d0
testq %rax, %rax
je 0x4371
movl $0x1, %edx
xorl %ecx, %ecx
movzbl (%rbx,%rcx), %esi
cmpl $0x20, %esi
jne 0x4368
movl %edx, %ecx
incl %edx
cmpq %rcx, %rax
ja 0x4354
jmp 0x4371
cmpl $0x2a, %esi
jne 0x4371
movb $0x20, (%rbx,%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/advanced_check.c
// Function: Check_extension
int Check_extension(char* path)
{
    char* valid_extentions[QTY_OF_EXTENSION] = {"cpp", "h", "c"};
    char* temp = Get_file_extension(path);
    for (int i = 0; i < QTY_OF_EXTENSION; i++) {
        if (strcmp(temp, valid_extentions[i]) == 0) {
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x3f4a
movq %rax, %rbx
leaq 0xfa9(%rip), %rsi       # 0x533e
movq %rax, %rdi
callq 0x2190
testl %eax, %eax
je 0x43d6
xorl %ecx, %ecx
leaq 0x181e(%rip), %r14      # 0x5bc8
movq %rcx, %r15
cmpq $0x2, %rcx
je 0x43cb
movslq 0x4(%r14,%r15,4), %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x2190
leaq 0x1(%r15), %rcx
testl %eax, %eax
jne 0x43aa
xorl %eax, %eax
cmpq $0x2, %r15
setb %al
jmp 0x43db
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/advanced_handle.c
// Function: Generate_filename
char* Generate_filename(char* path, char* dest_dir)
{
    long int s_time = 0;
    struct tm* m_time;
    s_time = time(NULL);
    m_time = localtime(&s_time);
    char* str_time = asctime(m_time);
    for (int i = 0; str_time[i] != '\0'; i++) {
        if (str_time[i] == ' ') {
            str_time[i] = '_';
        }
    }
    size_t len = strlen(str_time) - 1;
    if (str_time[len] == '\n') {
        str_time[len] = '\0';
    }
    int max_time_len = 50;
    char* filename = (char*)calloc((strlen(path) + max_time_len), sizeof(char));
    sprintf(filename,
            "%s%s%s%s%s%s",
            dest_dir,
            "/",
            Get_filename_without_extension(path),
            "_",
            str_time,
            ".html");
    return filename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
xorl %edi, %edi
callq 0x21b0
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
callq 0x2050
movq %rax, %rdi
callq 0x20e0
movq %rax, %r14
movzbl (%rax), %ecx
cmpl $0x20, %ecx
je 0x44a5
testl %ecx, %ecx
jne 0x44a8
jmp 0x44ad
movb $0x5f, (%rax)
incq %rax
jmp 0x4497
movq %r14, %rdi
callq 0x20d0
cmpb $0xa, -0x1(%r14,%rax)
jne 0x44c3
movb $0x0, -0x1(%r14,%rax)
movq %r15, %rdi
callq 0x20d0
leaq 0x32(%rax), %rdi
movl $0x1, %esi
callq 0x2180
movq %rax, %r12
movq %r15, %rdi
callq 0x3ced
leaq 0x17db(%rip), %r10      # 0x5cc6
leaq 0x16e2(%rip), %rsi      # 0x5bd4
leaq 0x10a5(%rip), %rcx      # 0x559e
leaq 0x16e1(%rip), %r9       # 0x5be1
movq %r12, %rdi
movq %rbx, %rdx
movq %rax, %r8
xorl %eax, %eax
pushq %r10
pushq %r14
callq 0x2200
addq $0x10, %rsp
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/advanced_handle.c
// Function: Get_document_type
char* Get_document_type(char* path)
{
    char* extension = Get_file_extension(path);
    if (!strcmp(extension, "h")) {
        return "<i>Header file to program code on C/C++</i></br></br>";
    } else if (!strcmp(extension, "c")) {
        return "<i>Program code in language C</i></br></br>";
    } else if (!strcmp(extension, "cpp")) {
        return "<i>Program code in language C++</i></br></br>";
    }
    return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x3f4a
movzbl (%rax), %ecx
cmpl $0x63, %ecx
je 0x454d
cmpl $0x68, %ecx
jne 0x4553
cmpb $0x0, 0x1(%rax)
jne 0x4553
leaq 0x1698(%rip), %rax      # 0x5be3
jmp 0x4576
cmpb $0x0, 0x1(%rax)
je 0x4578
leaq 0xde4(%rip), %rsi       # 0x533e
movq %rax, %rdi
callq 0x2190
testl %eax, %eax
leaq 0x16da(%rip), %rcx      # 0x5c45
leaq 0x15bc(%rip), %rax      # 0x5b2e
cmoveq %rcx, %rax
popq %rbp
retq
leaq 0x169a(%rip), %rax      # 0x5c19
jmp 0x4576
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/morozov312[P]documentary/./src/processing.c
// Function: Check_code
int Check_code(char* str)
{
    int single_flag = Check_single_comment(str);
    int multiline_begin_flag = Check_multiline_comment_begin(str);
    int multiline_end_flag = Check_multiline_comment_end(str);
    if (!single_flag && !multiline_begin_flag && !multiline_end_flag) {
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4200
movl %eax, %r14d
movq %rbx, %rdi
callq 0x4240
movl %eax, %r15d
movq %rbx, %rdi
callq 0x4280
orl %r14d, %r15d
xorl %ecx, %ecx
orl %eax, %r15d
sete %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mflatt[P]gc-demo/refcount/refcount.c
// Function: refcount_dec
void refcount_dec(struct node *p)
{
  if (p) {
    /* Decrement the reference count, and free if it does to zero */
    struct rc_node *rn = NODE_TO_RC(p);
    if (--rn->count == 0) {
      refcount_dec(rn->n.left);
      refcount_dec(rn->n.right);
      raw_free(rn, sizeof(struct rc_node));
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x135c
movq %rdi, %rbx
decl -0x8(%rdi)
je 0x1364
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq -0x8(%rbx), %r14
movq (%rbx), %rdi
callq 0x134b
movq 0x8(%rbx), %rdi
callq 0x134b
movl $0x18, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1316
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/tst/evm.c
// Function: main
int main() {
    test_stop();
    test_mstoreReturn();
    test_math();
    test_shl();
    test_xorSwap();
    test_sgtslt();
    test_sdiv();
    test_smod();
    test_addmod();
    test_mulmod();
    test_exp();
    test_signextend();
    test_spaghetti();
    test_sstore_sload();
    test_sstore_refund();
    test_sstore_gauntlet();
    test_selfbalance();
    test_callEmpty();
    test_callBounce();
    test_coinbase();
    test_extcodecopy();
    test_deepCall();
    test_revertStorage();
    test_revertSload();
    test_log();
    test_sha3();
    test_delegateCall();

    // These last tests will write to stderr; usually we want this to be hushed
    close(2);

    test_staticcallSstore();

    return 0;
}

// Assembly:
pushq %rax
callq 0x3a7c
callq 0x3c9d
callq 0x3f48
callq 0x426f
callq 0x4478
callq 0x476c
callq 0x49ec
callq 0x4c54
callq 0x4ebc
callq 0x5071
callq 0x5226
callq 0x550d
callq 0x56c6
callq 0x5958
callq 0x5c1f
callq 0x5e5d
callq 0x60a7
callq 0x63d8
callq 0x66d9
callq 0x6a2e
callq 0x6e27
callq 0x7992
callq 0x7e70
callq 0x8481
callq 0x93f5
callq 0xa11e
callq 0xb183
movl $0x2, %edi
callq 0x3070
callq 0x88db
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/examples/maths.c
// Function: main
int main(int argc, char **argv) {
  
  mpc_parser_t *Expr  = mpc_new("expression");
  mpc_parser_t *Prod  = mpc_new("product");
  mpc_parser_t *Value = mpc_new("value");
  mpc_parser_t *Maths = mpc_new("maths");
  
  mpca_lang(MPCA_LANG_PREDICTIVE,
    " expression : <product> (('+' | '-') <product>)*; "
    " product : <value>   (('*' | '/')   <value>)*;    "
    " value : /[0-9]+/ | '(' <expression> ')';         "
    " maths : /^/ <expression> /$/;                    ",
    Expr, Prod, Value, Maths, NULL);
  
  mpc_print(Expr);
  mpc_print(Prod);
  mpc_print(Value);
  mpc_print(Maths);
  
  if (argc > 1) {
    
    mpc_result_t r;
    if (mpc_parse_contents(argv[1], Maths, &r)) {
      mpc_ast_print(r.output);
      mpc_ast_delete(r.output);
    } else {
      mpc_err_print(r.error);
      mpc_err_delete(r.error);
    }
    
  } else {

    mpc_result_t r;
    if (mpc_parse_pipe("<stdin>", stdin, Maths, &r)) {
      mpc_ast_print(r.output);
      mpc_ast_delete(r.output);
    } else {
      mpc_err_print(r.error);
      mpc_err_delete(r.error);
    }
  
  }

  mpc_cleanup(4, Expr, Prod, Value, Maths);
  
  return 0;
  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movl %edi, %ebp
leaq 0x9cce(%rip), %rdi      # 0xb004
callq 0x2f5a
movq %rax, %rbx
leaq 0x9cca(%rip), %rdi      # 0xb00f
callq 0x2f5a
movq %rax, %r14
leaq 0x9cc3(%rip), %rdi      # 0xb017
callq 0x2f5a
movq %rax, %r15
leaq 0x9cba(%rip), %rdi      # 0xb01d
callq 0x2f5a
movq %rax, %r12
movq $0x0, (%rsp)
leaq 0x9ca9(%rip), %rsi      # 0xb023
movl $0x1, %edi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x8a52
movq %rbx, %rdi
callq 0x617d
movq %r14, %rdi
callq 0x617d
movq %r15, %rdi
callq 0x617d
movq %r12, %rdi
callq 0x617d
cmpl $0x2, %ebp
jl 0x13cd
movq 0x8(%r13), %rdi
leaq 0x10(%rsp), %r13
movq %r12, %rsi
movq %r13, %rdx
callq 0x2d22
jmp 0x13ee
movq 0xec0c(%rip), %rax      # 0xffe0
movq (%rax), %rsi
leaq 0x9d0e(%rip), %rdi      # 0xb0ec
leaq 0x10(%rsp), %r13
movq %r12, %rdx
movq %r13, %rcx
callq 0x2c5a
movq (%r13), %rdi
testl %eax, %eax
je 0x1407
callq 0x6c07
movq 0x10(%rsp), %rdi
callq 0x67a8
jmp 0x1416
callq 0x1493
movq 0x10(%rsp), %rdi
callq 0x1440
movl $0x4, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x336e
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/mgrosvenor[P]evec/demo2.c
// Function: main
int main(int argc, char** argv)
{
    void* a = evinisz(128);
    evpsh(a, "Test");
    evpsh(a, "Best");
    evpsh(a, "Rest");

    for(int i =0; i < evcnt(a); i++){
        char* s = (char*)evidx(a,i);
        printf("%i: %s\n", i, s);
    }

    a = evfree(a);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x80, %edi
movl $0x8, %esi
callq 0x1284
leaq 0xa16(%rip), %rsi       # 0x2380
movl $0x5, %edx
movq %rax, %rdi
callq 0x163a
leaq 0xa07(%rip), %rsi       # 0x2385
movl $0x5, %edx
movq %rax, %rdi
callq 0x163a
leaq 0x9f8(%rip), %rsi       # 0x238a
movl $0x5, %edx
movq %rax, %rdi
callq 0x163a
movq %rax, %rbx
movq %rax, %rdi
callq 0x1709
testq %rax, %rax
je 0x19e4
leaq 0x9d9(%rip), %r14       # 0x238f
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x174a
movq %r14, %rdi
movl %r15d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
incq %r15
movq %rbx, %rdi
callq 0x1709
cmpq %r15, %rax
ja 0x19b9
movq %rbx, %rdi
callq 0x1909
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/kisom[P]kam/queue.c
// Function: dequeue8
uint8_t
dequeue8(queue8 q)
{
	struct node8	*node;
	uint8_t	val;

	if (NULL == q->head)
		abort();

	node = q->head;
	val = node->val;

	q->head = node->next;
	free(node);
	q->nodes--;
	if (0 == q->nodes)
		q->tail = NULL;
	return val;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x12e8
movb (%rdi), %bpl
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
callq 0x1030
decq 0x10(%rbx)
jne 0x12df
movq $0x0, 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/kisom[P]kam/qtest.c
// Function: main
static void
test_queue8(void)
{
	uint8_t val;
	queue8	st;

	st = new_queue8();
	if (st == NULL) {
		errx(EX_OSERR, "FAILED: malloc failure");
	}

	enqueue8(st, 1);
	enqueue8(st, 2);
	if (1 != (val = dequeue8(st))) {
		fprintf(stderr,
		    "FAILED: should have received 2 from the queue.\n");
		fprintf(stderr,
		    "        (received %d)\n", val);
		exit(EXIT_FAILURE);
	}

	enqueue8(st, 3);
	if (2 != (val = dequeue8(st))) {
		fprintf(stderr,
		    "FAILED: should have received 3 from the queue.\n");
		fprintf(stderr,
		    "        (received %d)\n", val);
		exit(EXIT_FAILURE);
	}
	if (3 != (val = dequeue8(st)))
		errx(EX_SOFTWARE,
		    "FAILED: should have received 1 from the queue.");
	if (!empty_queue8(st))
		errx(EX_SOFTWARE,
		    "FAILED: queue should report empty.");
	enqueue8(st, 5);
	enqueue8(st, 5);
	destroy_queue8(st);
	printf("queue8: OK\n");
}

// Assembly:
pushq %rbx
callq 0x123c
testq %rax, %rax
je 0x14f3
movq %rax, %rbx
movq %rax, %rdi
movl $0x1, %esi
callq 0x1258
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1258
movq %rbx, %rdi
callq 0x12b4
cmpb $0x1, %al
jne 0x1501
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1258
movq %rbx, %rdi
callq 0x12b4
cmpb $0x2, %al
jne 0x1509
movq %rbx, %rdi
callq 0x12b4
cmpb $0x3, %al
jne 0x1511
movq %rbx, %rdi
callq 0x12ed
testl %eax, %eax
je 0x151a
movq %rbx, %rdi
movl $0x5, %esi
callq 0x1258
movq %rbx, %rdi
movl $0x5, %esi
callq 0x1258
movq %rbx, %rdi
callq 0x12f8
leaq 0xbfa(%rip), %rdi       # 0x20e4
callq 0x1050
xorl %eax, %eax
popq %rbx
retq
leaq 0xb0a(%rip), %rsi       # 0x2004
movl $0x47, %edi
jmp 0x1526
movzbl %al, %edi
callq 0x10d0
movzbl %al, %edi
callq 0x110f
leaq 0xb7a(%rip), %rsi       # 0x2092
jmp 0x1521
leaq 0xba0(%rip), %rsi       # 0x20c1
movl $0x46, %edi
xorl %eax, %eax
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/minkcv[P]vm/assembler.c
// Function: countInstructions
int countInstructions(FILE* src)
{
    char* line = NULL;
    size_t toRead = 0; // Read until \n
    ssize_t charsRead;
    uint16_t instrCount = 0;
    while ((charsRead = getline(&line, &toRead, src)) != -1)
    {
        if (line[0] != '\n' && line[0] != '@' && line[0] != ';')
        {
            char* token = strtok(line, " ");
            if (!strcmp(token, "LRL"))
                instrCount++;
            instrCount++;
        }
        free(line);
        line = NULL; // Causes getline to keep reading
    }
    rewind(src);
    return instrCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq -0x38(%rbp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdx
callq 0x1150
cmpq $-0x1, %rax
je 0x1c17
xorl %r14d, %r14d
leaq -0x30(%rbp), %r12
leaq -0x38(%rbp), %r13
movabsq $0x42000000000001, %r15 # imm = 0x42000000000001
movq -0x30(%rbp), %rdi
movzbl (%rdi), %eax
addl $-0xa, %eax
cmpl $0x36, %eax
ja 0x1bc8
btq %rax, %r15
jb 0x1bf2
leaq 0x48e(%rip), %rsi       # 0x205d
callq 0x1130
movq %rax, %rdi
leaq 0x47b(%rip), %rsi       # 0x2059
callq 0x10c0
cmpl $0x1, %eax
adcw $0x0, %r14w
incl %r14d
movq -0x30(%rbp), %rdi
callq 0x1030
movq $0x0, -0x30(%rbp)
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1150
cmpq $-0x1, %rax
jne 0x1bb3
movzwl %r14w, %r14d
movq %rbx, %rdi
callq 0x10b0
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/minkcv[P]vm/assembler.c
// Function: createLabelMap
void createLabelMap(FILE* src, LabelAddress*** labelMap)
{
    char* line = NULL;
    size_t toRead = 0; // Read until \n
    ssize_t charsRead;
    int labelCount = 0;
    uint16_t instrCount = 0;
    while ((charsRead = getline(&line, &toRead, src)) != -1)
    {
        if(line[0] == '@')
        {
            // Create the label entry in labelMap
            char* start = line;
            char* beforeAt = strsep(&line, "@");
            char* labelName = strsep(&line, " ;\n"); // Trim any comments or other text off the end
            LabelAddress* labeladdr = malloc(sizeof(LabelAddress));
            labeladdr->label = malloc(sizeof(char) * (strlen(labelName) + 1));
            strcpy(labeladdr->label, labelName);
            labeladdr->segAddr = instrCount / JUMP_SEGMENT_SIZE;
            labeladdr->offsetAddr = instrCount % JUMP_SEGMENT_SIZE;
            (*labelMap)[labelCount] = labeladdr;
            labelCount++;
            free(start);
            start = NULL;
            labelName = NULL;
            beforeAt = NULL;
            line = NULL;
        }
        else if (line[0] != ';' && line[0] != '\n')
        {
            char* token = strtok(line, " ");
            if (!strcmp(token, "LRL"))
                instrCount++;
            instrCount++;
            free(line);
            line = NULL;
        }
        else
        {
            free(line);
            line = NULL;
        }
    }
    rewind(src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %r14
xorl %r15d, %r15d
leaq -0x30(%rbp), %rdi
movq %r15, (%rdi)
leaq -0x40(%rbp), %rsi
movq %r15, (%rsi)
movq %r14, %rdx
callq 0x1150
cmpq $-0x1, %rax
je 0x1d7a
leaq -0x30(%rbp), %rbx
leaq -0x40(%rbp), %r12
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %r13
movzbl (%r13), %eax
cmpl $0xa, %eax
je 0x1d1f
cmpl $0x3b, %eax
je 0x1d1f
cmpl $0x40, %eax
jne 0x1d24
movq %rbx, %rdi
leaq 0x3b6(%rip), %rsi       # 0x205f
callq 0x1100
movq %rbx, %rdi
leaq 0x39d(%rip), %rsi       # 0x2055
callq 0x1100
movq %r15, %rbx
movq %r14, %r15
movq %rax, %r14
movl $0x10, %edi
callq 0x10f0
movq %rax, %r12
movq %r14, %rdi
callq 0x1090
leaq 0x1(%rax), %rdi
callq 0x10f0
movq %rax, 0x8(%r12)
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %r14
movq %rbx, %r15
leaq -0x30(%rbp), %rbx
callq 0x1050
movl -0x34(%rbp), %eax
rolw $0x8, %ax
movw %ax, (%r12)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movslq %r15d, %r15
movq %r12, (%rax,%r15,8)
leaq -0x40(%rbp), %r12
incl %r15d
movq %r13, %rdi
jmp 0x1d55
movq %r13, %rdi
leaq 0x32f(%rip), %rsi       # 0x205d
callq 0x1130
movq %rax, %rdi
leaq 0x31c(%rip), %rsi       # 0x2059
callq 0x10c0
cmpl $0x1, %eax
movl -0x34(%rbp), %eax
adcw $0x0, %ax
incl %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1030
movq $0x0, -0x30(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1150
cmpq $-0x1, %rax
jne 0x1c7b
movq %r14, %rdi
callq 0x10b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/minkcv[P]vm/assembler.c
// Function: getAddressesOfLabel
void getAddressesOfLabel(char* label, LabelAddress* labelMap[MAX_LABELS], uint8_t* segAddr, uint8_t* offsetAddr)
{
    int i;
    for (i = 0; i < MAX_LABELS; i++)
    {
        LabelAddress* current = labelMap[i];
        if (current != NULL && current->label != NULL)
        {
            if (!strcmp(current->label, label))
            {
                *segAddr = current->segAddr;
                *offsetAddr = current->offsetAddr;
                return;
            }
        }
    }
    printf("Error: Label \"%s\" not defined\n", label);
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbx
testq %rbx, %rbx
je 0x1dcd
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1dcd
movq %r14, %rsi
callq 0x10c0
testl %eax, %eax
je 0x1df4
incq %r13
cmpq $0x400, %r13            # imm = 0x400
jne 0x1daf
leaq 0x330(%rip), %rdi       # 0x2110
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1160
movb (%rbx), %al
movb %al, (%r15)
movb 0x1(%rbx), %al
movq -0x30(%rbp), %rcx
movb %al, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/error.c
// Function: print_do
static ErrorCode _print_do(String const * program, ...)
{
	ErrorCode ret = 0;
	va_list args;
	String const * error;

	va_start(args, program);
	if(program != NULL && string_get_length(program) > 0)
	{
		fputs(program, stderr);
		fputs(": ", stderr);
	}
	if((error = _error_do(&ret, NULL, args)) == NULL
			|| string_get_length(error) == 0)
		error = "Unknown error";
	fputs(error, stderr);
	fputc('\n', stderr);
	va_end(args);
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x48b1
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
testq %rbx, %rbx
je 0x4904
movq %rbx, %rdi
callq 0x4330
testq %rax, %rax
je 0x4904
movq 0xb706(%rip), %r14      # 0xfff0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x42f0
movq (%r14), %rsi
leaq 0x67c4(%rip), %rdi      # 0xb0c3
callq 0x42f0
movl 0xb816(%rip), %ebx      # 0x10120
leaq 0xb70f(%rip), %r14      # 0x10020
movq %r14, %rdi
callq 0x4330
testq %rax, %rax
leaq 0x67a3(%rip), %rdi      # 0xb0c6
cmovneq %r14, %rdi
movq 0xb6c2(%rip), %r14      # 0xfff0
movq (%r14), %rsi
callq 0x42f0
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x43c0
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/array.c
// Function: array_new
Array * array_new(size_t size)
{
	Array * array;

	/* check for overflows */
	if(UINT32_MAX < SIZE_MAX && size > UINT32_MAX)
	{
		error_set_code(-ERANGE, "%s", strerror(ERANGE));
		return NULL;
	}
	if((array = (Array *)object_new(sizeof(*array))) == NULL)
		return NULL;
	array->count = 0;
	array->size = size;
	array->value = NULL;
	return array;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
shrq $0x20, %rax
je 0x4a3d
movl $0x22, %edi
callq 0x47a0
leaq 0x6634(%rip), %rsi      # 0xb05e
xorl %ebx, %ebx
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
jmp 0x4a68
movq %rdi, %r14
movl $0x10, %edi
callq 0x45e0
testq %rax, %rax
je 0x4a66
movq %rax, %rbx
movl $0x0, (%rax)
movl %r14d, 0x4(%rax)
movq $0x0, 0x8(%rax)
jmp 0x4a68
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/array.c
// Function: array_new_copy
Array * array_new_copy(Array const * from)
{
	Array * array;

	if((array = (Array *)object_new(sizeof(*array))) == NULL)
		return NULL;
	array->value = NULL;
	if(array_copy(array, from) != 0)
	{
		array_delete(array);
		return NULL;
	}
	return array;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x10, %edi
callq 0x45e0
testq %rax, %rax
je 0x4ab4
movq %rax, %rbx
movq $0x0, 0x8(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x4340
testl %eax, %eax
je 0x4ab6
movq 0x8(%rbx), %rdi
callq 0x4090
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/array.c
// Function: array_copy
ArrayError array_copy(Array * array, Array const * from)
{
	char * p;

	if((p = (char *)realloc(array->value, from->count * from->size)) == NULL
			&& from->count != 0 && from->size != 0)
		return error_set_code(-errno, "%s", strerror(errno));
	array->count = from->count;
	array->size = from->size;
	array->value = p;
	memcpy(array->value, from->value, array->count * array->size);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movl 0x4(%rsi), %esi
imull (%rbx), %esi
callq 0x45c0
movl (%rbx), %ecx
testq %rax, %rax
je 0x4b08
movl 0x4(%rbx), %edx
movl %ecx, (%r14)
movl %edx, 0x4(%r14)
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rsi
imull %ecx, %edx
movq %rax, %rdi
callq 0x4470
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x4(%rbx), %edx
testl %ecx, %ecx
je 0x4ae4
testl %edx, %edx
je 0x4b3d
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebx
negl %ebx
callq 0x47a0
leaq 0x6534(%rip), %rsi      # 0xb05e
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x45d0
xorl %edx, %edx
jmp 0x4ae4
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/array.c
// Function: array_new_filter
Array * array_new_filter(Array const * from, ArrayFilter func, UserData * data)
{
	Array * array;
	size_t i;
	char * value;

	if((array = array_new(from->size)) == NULL)
		return NULL;
	for(i = 0; i < from->count; i++)
	{
		value = from->value + (from->size * i);
		if(func(value, data) == true)
			if(array_append(array, value) != 0)
			{
				array_delete(array);
				return NULL;
			}
	}
	return array;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x4(%rdi), %edi
callq 0x45b0
testq %rax, %rax
je 0x4bcd
movq %rax, %rbx
cmpl $0x0, (%r12)
je 0x4bcf
xorl %ebp, %ebp
movl 0x4(%r12), %r13d
imulq %rbp, %r13
addq 0x8(%r12), %r13
movq %r13, %rdi
movq %r14, %rsi
callq *%r15
testb %al, %al
je 0x4bae
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4290
testl %eax, %eax
jne 0x4bbc
incq %rbp
movl (%r12), %eax
cmpq %rax, %rbp
jb 0x4b84
jmp 0x4bcf
movq 0x8(%rbx), %rdi
callq 0x4090
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/array.c
// Function: array_append
ArrayError array_append(Array * array, ArrayData * value)
{
	char * p;
	uint64_t offset = array->size * array->count;

	/* check for overflows */
	if(UINT64_MAX - offset < array->size
			|| offset + array->size > SIZE_MAX)
		return error_set_code(-ERANGE, "%s", strerror(ERANGE));
	if((p = (char *)realloc(array->value, offset + array->size)) == NULL)
		return error_set_code(-errno, "%s", strerror(errno));
	array->value = p;
	memcpy(&p[offset], value, array->size);
	array->count++;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %esi
movl (%rdi), %r15d
imull %esi, %r15d
addq %r15, %rsi
movq 0x8(%rdi), %rdi
callq 0x45c0
testq %rax, %rax
je 0x4c26
movq %rax, 0x8(%rbx)
addq %rax, %r15
movl 0x4(%rbx), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4470
incl (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebx
negl %ebx
callq 0x47a0
leaq 0x6421(%rip), %rsi      # 0xb05e
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/array.c
// Function: array_new_filter_swap
Array * array_new_filter_swap(Array const * from, ArrayFilterSwap func,
		UserData * data)
{
	Array * array;
	size_t i;
	char * value;

	if((array = array_new(from->size)) == NULL)
		return NULL;
	for(i = 0; i < from->count; i++)
	{
		value = from->value + (from->size * i);
		if(func(data, value) == true)
			if(array_append(array, value) != 0)
			{
				array_delete(array);
				return NULL;
			}
	}
	return array;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x4(%rdi), %edi
callq 0x45b0
testq %rax, %rax
je 0x4cc4
movq %rax, %rbx
cmpl $0x0, (%r12)
je 0x4cc6
xorl %ebp, %ebp
movl 0x4(%r12), %r13d
imulq %rbp, %r13
addq 0x8(%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
callq *%r15
testb %al, %al
je 0x4ca5
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4290
testl %eax, %eax
jne 0x4cb3
incq %rbp
movl (%r12), %eax
cmpq %rax, %rbp
jb 0x4c7b
jmp 0x4cc6
movq 0x8(%rbx), %rdi
callq 0x4090
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/array.c
// Function: array_get_copy
ArrayError array_get_copy(Array const * array, size_t pos, ArrayData * value)
{
	uint64_t offset;

	if(pos >= array->count)
		return error_set_code(-ERANGE, "%s", strerror(ERANGE));
	offset = pos * array->size;
	memcpy(value, &array->value[offset], array->size);
	return 0;
}

// Assembly:
pushq %rax
movl (%rdi), %eax
cmpq %rsi, %rax
jbe 0x4d13
movl 0x4(%rdi), %eax
imulq %rax, %rsi
addq 0x8(%rdi), %rsi
movq %rdx, %rdi
movq %rax, %rdx
callq 0x4470
xorl %eax, %eax
popq %rcx
retq
movl $0x22, %edi
callq 0x47a0
leaq 0x633a(%rip), %rsi      # 0xb05e
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
movq %rax, %rdx
xorl %eax, %eax
popq %rcx
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/array.c
// Function: array_set
ArrayError array_set(Array * array, size_t pos, ArrayData * value)
{
	uint32_t p = pos + 1;
	uint64_t offset;
	uint64_t curpos;
	void * q;

	/* check for overflows */
	if(pos >= UINT32_MAX)
		return error_set_code(-ERANGE, "%s", strerror(ERANGE));
	offset = pos * array->size;
	if(array->count < p)
	{
		/* grow the array */
		if(UINT64_MAX - offset < array->size
				|| offset + array->size > SIZE_MAX)
			return error_set_code(-ERANGE, "%s", strerror(ERANGE));
		if((q = realloc(array->value, offset + array->size)) == NULL)
			return error_set_code(-errno, "%s", strerror(errno));
		array->value = (char *)q;
		curpos = array->count * array->size;
		memset(&array->value[curpos], 0, offset - curpos);
		array->count = pos + 1;
	}
	/* set the value */
	memcpy(&array->value[offset], value, array->size);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rsi
jb 0x4d7b
movl $0x22, %edi
callq 0x47a0
leaq 0x6300(%rip), %rsi      # 0xb05e
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x45d0
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leal 0x1(%rsi), %ebp
movl 0x4(%rdi), %r12d
imulq %r12, %r14
cmpl %ebp, (%rdi)
jae 0x4dd1
addq %r14, %r12
movq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0x45c0
testq %rax, %rax
je 0x4df7
movq %rax, %r13
movq %rax, 0x8(%r15)
movl 0x4(%r15), %r12d
movl (%r15), %eax
imull %r12d, %eax
movq %r13, %rdi
addq %rax, %rdi
movq %r14, %rdx
subq %rax, %rdx
xorl %esi, %esi
callq 0x4310
movl %ebp, (%r15)
jmp 0x4dd5
movq 0x8(%r15), %r13
addq %r14, %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4470
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebx
negl %ebx
callq 0x47a0
leaq 0x6250(%rip), %rsi      # 0xb05e
movl %ebx, %edi
jmp 0x4d63