LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bplus_tree/bplus_tree_node.c
// Function: bptn_exist
boolean bptn_exist(bplus_tree_node *bptn, void *value,
                   compare_function compare) {
    ++compare_number;
    int index = bptn_search_index(bptn, value, compare);
    if (compare(bptn->keys[index], value) == 0) {
        return T;
    } else if (bptn->is_leaf) {
        return F;
    }
    return bptn_exist(bptn->pointers[index], value, compare);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x54ed(%rip), %rax      # 0x8168
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x54df(%rip), %rax      # 0x8168
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2910
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x2ccd
leaq 0x23d6(%rip), %rax      # 0x509c
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2d06
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2ce4
leaq 0x23c3(%rip), %rax      # 0x50a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2d06
jmp 0x2ce6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2c60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/compare/compare.c
// Function: compare_string
int compare_string(char *a, char *b) {
    char *ptr_a = a, *ptr_b = b;
    while (*ptr_a != '\0' && *ptr_b != '\0') {
        int res = compare_char_macro(*ptr_a, *ptr_b);
        if (res != 0) {
            return res;
        }
        ++ptr_a;
        ++ptr_b;
    }
    if (*ptr_a != '\0') {
        return 1;
    } else if (*ptr_b != '\0') {
        return -1;
    } else {
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2d(%rbp)
je 0x2ded
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x2df6
jmp 0x2e43
movq 0x536b(%rip), %rax      # 0x8168
addq $0x1, %rax
movq %rax, 0x5360(%rip)      # 0x8168
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x2e29
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2e74
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2dcc
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2e58
movl $0x1, -0x4(%rbp)
jmp 0x2e74
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2e6d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e74
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/file/file.c
// Function: open_file
FILE *open_file(const char *filename, const char *type) {
    FILE *f = fopen(filename, type);
    if (f == 0) {
        printf("Error: Can not open file %s.", filename);
        exit(1);
    }
    return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1170
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2ec4
movq -0x8(%rbp), %rsi
leaq 0x2225(%rip), %rdi      # 0x50d8
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x11b0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/file/file.c
// Function: read_file
int read_file(FILE *f, char *s) {
    int   length = 0;
    char *ptr = s;
    char  c;

    while (1) {
        c = fgetc(f);
        if (c == EOF) {
            if (ptr == s) {
                return 0;
            } else {
                *(ptr) = '\0';
                return length;
            }
        }
        if (c == '\n') {
            if (ptr == s) {
                // continue;
                *(ptr++) = '\n';
                *(ptr++) = '\0';
                return 1;
            } else {
                *(ptr) = '\0';
                return length;
            }
        }
        *(ptr++) = c;
        ++length;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10c0
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $-0x1, %eax
jne 0x2f29
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x2f1a
movl $0x0, -0x4(%rbp)
jmp 0x2f9a
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2f9a
movsbl -0x29(%rbp), %eax
cmpl $0xa, %eax
jne 0x2f78
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x2f69
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0xa, (%rax)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2f9a
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2f9a
movb -0x29(%rbp), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2eef
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/free/free.c
// Function: mp_init
void mp_init(size_type_big max_pool_length, void (*error_callback)()) {
    mp.bucket_number = max_pool_length / (1 << 30) + 1;
    size_type_big left = max_pool_length;

    mp.head = malloc(mp.bucket_number * sizeof(void *));
    mp.length = malloc(mp.bucket_number * sizeof(size_type_small *));
    mp.max_length = malloc(mp.bucket_number * sizeof(size_type_small *));

    for (int i = 0; i < mp.bucket_number; ++i) {
        mp.length[i] = 0;
        if (left < (1 << 30)) {
            mp.head[i] = malloc(left);
            mp.max_length[i] = left;
            break;
        } else {
            mp.head[i] = malloc((1 << 30));
            left -= (1 << 30);
            mp.max_length[i] = (1 << 30);
        }
        if (mp.head[i] == NULL) {
            printf("init error. need " SIZE_TYPE_BIG_FORMAT " bytes\n",
                   max_pool_length);
            error_callback();
        }
    }

    // mp.head = malloc(mp.max_length);
    // mp.length = 0;
    mp.error_callback = error_callback;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
shrq $0x1e, %rax
addq $0x1, %rax
movl %eax, 0x51aa(%rip)      # 0x818c
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq 0x519b(%rip), %rdi      # 0x818c
shlq $0x3, %rdi
callq 0x1140
movq %rax, 0x516f(%rip)      # 0x8170
movslq 0x5184(%rip), %rdi      # 0x818c
shlq $0x3, %rdi
callq 0x1140
movq %rax, 0x5160(%rip)      # 0x8178
movslq 0x516d(%rip), %rdi      # 0x818c
shlq $0x3, %rdi
callq 0x1140
movq %rax, 0x5151(%rip)      # 0x8180
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x514d(%rip), %eax      # 0x818c
jge 0x3107
movq 0x512c(%rip), %rax      # 0x8178
movslq -0x1c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
cmpq $0x40000000, -0x18(%rbp) # imm = 0x40000000
jae 0x3092
movq -0x18(%rbp), %rdi
callq 0x1140
movq %rax, %rdx
movq 0x50fc(%rip), %rax      # 0x8170
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movl %eax, %edx
movq 0x50f7(%rip), %rax      # 0x8180
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x3107
movl $0x40000000, %edi       # imm = 0x40000000
callq 0x1140
movq %rax, %rdx
movq 0x50ca(%rip), %rax      # 0x8170
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
subq $0x40000000, %rax       # imm = 0x40000000
movq %rax, -0x18(%rbp)
movq 0x50bd(%rip), %rax      # 0x8180
movslq -0x1c(%rbp), %rcx
movl $0x40000000, (%rax,%rcx,4) # imm = 0x40000000
movq 0x509b(%rip), %rax      # 0x8170
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x30f7
movq -0x8(%rbp), %rsi
leaq 0x2015(%rip), %rdi      # 0x5100
movb $0x0, %al
callq 0x10a0
movb $0x0, %al
callq *-0x10(%rbp)
jmp 0x30f9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3036
movq -0x10(%rbp), %rax
movq %rax, 0x507e(%rip)      # 0x8190
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/free/free.c
// Function: mp_info
void mp_info() {
    for (int i = 0; i < mp.bucket_number; ++i) {
        printf("bucket %3d, usage " SIZE_TYPE_SMALL_FORMAT
               "/" SIZE_TYPE_SMALL_FORMAT " %.2f%%, " SIZE_TYPE_SMALL_FORMAT
               " left\n",
               i, mp.length[i], mp.max_length[i],
               (mp.max_length[i] == 0
                    ? 100
                    : (double)mp.length[i] / mp.max_length[i] * 100),
               mp.max_length[i] - mp.length[i]);
    }
    printf("total: max_length: " SIZE_TYPE_BIG_FORMAT
           "  now_length: " SIZE_TYPE_BIG_FORMAT "\n",
           mp_get_max_length(), mp_get_length());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x5054(%rip), %eax      # 0x818c
jge 0x3203
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0x502d(%rip), %rax      # 0x8178
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movq 0x5024(%rip), %rax      # 0x8180
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movq 0x5013(%rip), %rax      # 0x8180
movslq -0x4(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x3186
movsd 0x1f79(%rip), %xmm0     # 0x50f8
movsd %xmm0, -0x18(%rbp)
jmp 0x31bb
movq 0x4feb(%rip), %rax      # 0x8178
movslq -0x4(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
movq 0x4fe3(%rip), %rax      # 0x8180
movslq -0x4(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
divsd %xmm1, %xmm0
movsd 0x1f46(%rip), %xmm1     # 0x50f8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x8(%rbp), %ecx
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %esi
movsd -0x18(%rbp), %xmm0
movq 0x4fb0(%rip), %rax      # 0x8180
movslq -0x4(%rbp), %rdi
movl (%rax,%rdi,4), %r8d
movq 0x4f99(%rip), %rax      # 0x8178
movslq -0x4(%rbp), %rdi
subl (%rax,%rdi,4), %r8d
leaq 0x1f2e(%rip), %rdi      # 0x511c
movb $0x1, %al
callq 0x10a0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x312f
callq 0x3280
movq %rax, -0x20(%rbp)
callq 0x3230
movq -0x20(%rbp), %rsi
movq %rax, %rdx
leaq 0x1f26(%rip), %rdi      # 0x5145
movb $0x0, %al
callq 0x10a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/free/free.c
// Function: mp_get_length
size_type_big mp_get_length() {
    size_type_big now_length = 0;
    for (int i = 0; i < mp.bucket_number; ++i) {
        now_length += mp.length[i];
    }
    return now_length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x4f40(%rip), %eax      # 0x818c
jge 0x3270
movq 0x4f23(%rip), %rax      # 0x8178
movslq -0xc(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3243
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/free/free.c
// Function: mp_get_max_length
size_type_big mp_get_max_length() {
    size_type_big max_length = 0;
    for (int i = 0; i < mp.bucket_number; ++i) {
        max_length += mp.max_length[i];
    }
    return max_length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x4ef0(%rip), %eax      # 0x818c
jge 0x32c0
movq 0x4edb(%rip), %rax      # 0x8180
movslq -0xc(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3293
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/free/free.c
// Function: mp_new
void *mp_new(size_type_small length) {
    int bucket;
    for (bucket = 0; bucket < mp.bucket_number; ++bucket) {
        if (mp.length[bucket] + length <= mp.max_length[bucket]) {
            void *ptr = mp.head[bucket] + mp.length[bucket];
            mp.length[bucket] += length;
            return ptr;
        }
    }

    printf("Can not make more memory. The memory pool is "
           "only " SIZE_TYPE_BIG_FORMAT " bytes, "
           "and " SIZE_TYPE_BIG_FORMAT
           " used, can not make more " SIZE_TYPE_SMALL_FORMAT " bytes\n",
           mp_get_max_length(), mp_get_length(), length);
    mp.error_callback();
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x4ea1(%rip), %eax      # 0x818c
jge 0x335e
movq 0x4e84(%rip), %rax      # 0x8178
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0xc(%rbp), %eax
movq 0x4e7b(%rip), %rcx      # 0x8180
movslq -0x10(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jg 0x3351
movq 0x4e5b(%rip), %rax      # 0x8170
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x4e54(%rip), %rcx      # 0x8178
movslq -0x10(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edx
movq 0x4e3b(%rip), %rax      # 0x8178
movslq -0x10(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3394
jmp 0x3353
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x32e2
callq 0x3280
movq %rax, -0x20(%rbp)
callq 0x3230
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movl -0xc(%rbp), %ecx
leaq 0x1df1(%rip), %rdi      # 0x516e
movb $0x0, %al
callq 0x10a0
movb $0x0, %al
callq *0x4e04(%rip)           # 0x8190
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/http/http.c
// Function: get_page
int get_page(char *prefix, char *url, char *ip, uint16_t port, char *reponse,
             int reponse_size) {
    int sock = socket(AF_INET, SOCK_STREAM, 0);

    struct sockaddr_in serv_addr;
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = inet_addr(ip);
    serv_addr.sin_port = htons(port);

    int con = connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    if (con != 0) {
        return F;
    }

    char request[MAX_REQUEST_LENGTH] = "\0";
    strcat(request, "GET ");
    strcat(request, prefix);
    strcat(request, url);
    strcat(request, " HTTP/1.1\r\n");
    strcat(request, "Host:");
    strcat(request, ip);
    strcat(request, "\r\nConnection:Keep-alive\r\n\r\n");

    write(sock, request, sizeof(request));

    int read_length = 0;
    while (1) {
        int ret =
            read(sock, reponse + read_length, reponse_size - read_length - 1);
        if (ret <= 0) {
            break;
        }
        read_length += ret;
    }

    close(sock);
    return read_length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x860, %rsp            # imm = 0x860
movw %cx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x1200
movl %eax, -0x38(%rbp)
movw $0x2, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10f0
movl %eax, -0x44(%rbp)
movzwl -0x22(%rbp), %edi
callq 0x1090
movw %ax, -0x46(%rbp)
movl -0x38(%rbp), %edi
leaq -0x48(%rbp), %rsi
movl $0x10, %edx
callq 0x11c0
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x3424
leaq 0x1c86(%rip), %rax      # 0x50a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x352c
leaq -0x850(%rbp), %rdi
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x10b0
leaq -0x850(%rbp), %rdi
leaq 0x1d90(%rip), %rsi      # 0x51d5
callq 0x11a0
leaq -0x850(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11a0
leaq -0x850(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11a0
leaq -0x850(%rbp), %rdi
leaq 0x1d62(%rip), %rsi      # 0x51da
callq 0x11a0
leaq -0x850(%rbp), %rdi
leaq 0x1d5b(%rip), %rsi      # 0x51e6
callq 0x11a0
leaq -0x850(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11a0
leaq -0x850(%rbp), %rdi
leaq 0x1d3e(%rip), %rsi      # 0x51ec
callq 0x11a0
movl -0x38(%rbp), %edi
leaq -0x850(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x1050
movl $0x0, -0x854(%rbp)
movl -0x38(%rbp), %edi
movq -0x30(%rbp), %rsi
movslq -0x854(%rbp), %rax
addq %rax, %rsi
movl -0x34(%rbp), %eax
subl -0x854(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x10e0
movl %eax, -0x858(%rbp)
cmpl $0x0, -0x858(%rbp)
jg 0x3507
jmp 0x351b
movl -0x858(%rbp), %eax
addl -0x854(%rbp), %eax
movl %eax, -0x854(%rbp)
jmp 0x34d1
movl -0x38(%rbp), %edi
callq 0x10d0
movl -0x854(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x860, %rsp            # imm = 0x860
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/kmp/kmp.c
// Function: kmp_get_next
void kmp_get_next(char *s, int *next) {
    next[0] = -1;

    for (int i = 1;; ++i) {
        if (s[i] == '\0')
            break;
        int t = next[i - 1];
        while (t != -1 && s[t] != s[i - 1])
            t = next[t];
        next[i] = (s[i - 1] == s[t] ? t + 1 : 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x3573
jmp 0x361e
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x35b6
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x35bf
jmp 0x35cf
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
jmp 0x3586
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x35fb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3602
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x3602
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x355d
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/kmp/kmp.c
// Function: kmp_char
void kmp_char(char c, char *pattern, int *pattern_pos, int *next, int *ans) {
    while (*pattern_pos != -1 && compare_char_macro(c, pattern[*pattern_pos])) {
        *pattern_pos = next[*pattern_pos];
    }
    if (!compare_char_macro(pattern[++(*pattern_pos)], '\0')) {
        ++(*ans);
        *pattern_pos =
            next[*pattern_pos - 1] + (next[*pattern_pos - 1] == 0 ? 0 : 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl $-0x1, (%rcx)
movb %al, -0x29(%rbp)
je 0x367e
leaq 0x4b19(%rip), %rax      # 0x8168
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x4b0b(%rip), %rax      # 0x8168
movq %rcx, (%rax)
movsbl -0x1(%rbp), %eax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movslq (%rdx), %rdx
movsbl (%rcx,%rdx), %ecx
subl %ecx, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x3687
jmp 0x369d
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x363a
leaq 0x4ac4(%rip), %rax      # 0x8168
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x4ab6(%rip), %rax      # 0x8168
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdx
movl (%rdx), %ecx
addl $0x1, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
subl $0x0, %eax
cmpl $0x0, %eax
jne 0x3719
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rax,%rdx,4), %esi
movl $0x1, %eax
xorl %edx, %edx
cmpl $0x0, %esi
cmovel %edx, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/link_list/link_list.c
// Function: lk_init
link_list *lk_init() {
    link_list *lk = mp_new(sizeof(link_list));
    lk->head = lk->tail = NULL;
    lk->length = 0;
    return lk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x32d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/link_list/link_list.c
// Function: lk_node
linked_node *lk_node(void *ptr) {
    linked_node *node = NULL;
    if (_link_node_unused == NULL) {
        node = mp_new(sizeof(linked_node));
    } else {
        node = _link_node_unused;
        _link_node_unused = _link_node_unused->next;
    }
    node->next = NULL;
    node->value = ptr;
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, 0x4a0c(%rip)      # 0x8198
jne 0x379e
movl $0x10, %edi
callq 0x32d0
movq %rax, -0x10(%rbp)
jmp 0x37bb
movq 0x49f3(%rip), %rax      # 0x8198
movq %rax, -0x10(%rbp)
movq 0x49e8(%rip), %rax      # 0x8198
movq 0x8(%rax), %rax
movq %rax, 0x49dd(%rip)      # 0x8198
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/link_list/link_list.c
// Function: lk_add
void lk_add(link_list *lk, void *ptr) {
    linked_node *node = lk_node(ptr);
    if (lk_empty(lk)) {
        lk->head = lk->tail = node;
    } else {
        lk->tail->next = node;
        lk->tail = node;
    }
    ++lk->length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3770
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3850
cmpl $0x0, %eax
je 0x3820
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x383c
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/link_list/link_list.c
// Function: lk_remove
void lk_remove(link_list *lk, linked_node *ptr) {
    linked_node *p = lk->head;

    if (p == ptr) {
        p = lk->head = ptr->next;
    } else {
        while (p != NULL && p->next != ptr) {
            p = p->next;
        }
        if (p != NULL && p->next == ptr) {
            p->next = ptr->next;
            --lk->length;
            ptr->next = _link_node_unused;
            _link_node_unused = ptr->next;
        }
    }
    if (lk->tail == ptr) {
        lk->tail = p;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x38b9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, -0x18(%rbp)
jmp 0x3942
jmp 0x38bb
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x38d9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x38e2
jmp 0x38f0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x38bb
cmpq $0x0, -0x18(%rbp)
je 0x3940
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x3940
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x486f(%rip), %rcx      # 0x8198
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x4858(%rip)      # 0x8198
jmp 0x3942
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x395c
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/link_list/link_list.c
// Function: lk_search
linked_node *lk_search(link_list *lk, void *target,
                       boolean (*compare)(void *value, void *target)) {
    if (lk_empty(lk)) {
        return NULL;
    }
    linked_node *ptr = lk->head;

    while (ptr != NULL) {
        if (compare(ptr->value, target)) {
            break;
        }
        ptr = ptr->next;
    }
    return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3850
cmpl $0x0, %eax
je 0x398c
movq $0x0, -0x8(%rbp)
jmp 0x39cc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x39c4
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x39b6
jmp 0x39c4
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3997
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/print/print.c
// Function: begin
void begin(int c) {
    switch (c) {
        case BLACK:
            printf("\033[1;30m");
            break;
        case RED:
            printf("\033[1;31m");
            break;
        case GREEN:
            printf("\033[1;32m");
            break;
        case YELLOW:
            printf("\033[1;33m");
            break;
        case BLUE:
            printf("\033[1;34m");
            break;
        case PINK:
            printf("\033[1;35m");
            break;
        case SKY:
            printf("\033[1;36m");
            break;
        case WHITE:
            printf("\033[1;37m");
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x7, %rax
ja 0x3a8e
movq -0x10(%rbp), %rax
leaq 0x1801(%rip), %rcx      # 0x5208
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1811(%rip), %rdi      # 0x5228
movb $0x0, %al
callq 0x10a0
jmp 0x3a8e
leaq 0x1809(%rip), %rdi      # 0x5230
movb $0x0, %al
callq 0x10a0
jmp 0x3a8e
leaq 0x1801(%rip), %rdi      # 0x5238
movb $0x0, %al
callq 0x10a0
jmp 0x3a8e
leaq 0x17f9(%rip), %rdi      # 0x5240
movb $0x0, %al
callq 0x10a0
jmp 0x3a8e
leaq 0x17f1(%rip), %rdi      # 0x5248
movb $0x0, %al
callq 0x10a0
jmp 0x3a8e
leaq 0x17e9(%rip), %rdi      # 0x5250
movb $0x0, %al
callq 0x10a0
jmp 0x3a8e
leaq 0x17e1(%rip), %rdi      # 0x5258
movb $0x0, %al
callq 0x10a0
jmp 0x3a8e
leaq 0x17d9(%rip), %rdi      # 0x5260
movb $0x0, %al
callq 0x10a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/print/print.c
// Function: print
int print(int c, char *fmt, ...) {
    va_list args; //定义一个va_list类型的变量，用来储存单个参数
    va_start(args, fmt); //使args指向可变参数的第一个参数
    begin(c);
    int ret = vprintf(fmt, args); //必须用vprintf等带V的
    end();
    va_end(args); //结束可变参数的获取
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x3afb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movl -0x4(%rbp), %edi
callq 0x39e0
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1150
movl %eax, -0x34(%rbp)
callq 0x3aa0
movl -0x34(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/print/print.c
// Function: print_err
int print_err(char *fmt, ...) {
    va_list args;
    va_start(args, fmt);
    begin(RED);
    int ret = vfprintf(stderr, fmt, args);
    end();
    va_end(args);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3ba8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movl $0x1, %edi
callq 0x39e0
movq 0x43f7(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1190
movl %eax, -0x24(%rbp)
callq 0x3aa0
movl -0x24(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/print/print.c
// Function: print_ok
int print_ok(char *fmt, ...) {
    va_list args;
    va_start(args, fmt);
    begin(GREEN);
    int ret = vfprintf(stdout, fmt, args);
    end();
    va_end(args);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3c68
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movl $0x2, %edi
callq 0x39e0
movq 0x4317(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1190
movl %eax, -0x24(%rbp)
callq 0x3aa0
movl -0x24(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/radix_tree/radix_tree.c
// Function: rt_init
radix_tree *rt_init(int k) {
    radix_tree *rt = mp_new(sizeof(radix_tree));
    rt->k = k;
    rt->temp = bits_init();
    return rt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x32d0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movb $0x0, %al
callq 0x18e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/radix_tree/radix_tree.c
// Function: rt_add
void rt_add(radix_tree *rt, void *value, int size) {
    rt->temp->start = 0;
    rt->temp->end = size * 8;
    rt->temp->value = value;

    // printf("Add %s ", (char *)value);
    // bits_print(rt->temp);
    // printf("\n");

    rt->root = rtn_add(rt->root, rt->temp, rt->k, T);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x0, 0x8(%rax)
movl -0x14(%rbp), %ecx
shll $0x3, %ecx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x130d(%rip), %rax      # 0x509c
movl (%rax), %ecx
callq 0x4050
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/radix_tree/radix_tree.c
// Function: rt_exist
boolean rt_exist(radix_tree *rt, void *value, int size) {
    rt->temp->start = 0;
    rt->temp->end = size * 8;
    rt->temp->value = value;

    // printf("Search %s ", (char *)value);
    // bits_print(rt->temp);
    // printf("\n");

    return rtn_exist(rt->root, rt->temp, rt->k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x0, 0x8(%rax)
movl -0x14(%rbp), %ecx
shll $0x3, %ecx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x4220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/radix_tree/radix_tree_node.c
// Function: pow2
int pow2(int m) {
    switch (m) {
        case 0:
            return 1;
        case 1:
            return 2;
        case 2:
            return 4;
        case 3:
            return 8;
        default:
            break;
    }
    int t = pow2(m / 2);
    return t * t * (t % 2 ? 2 : 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x3ec0
movq -0x18(%rbp), %rax
leaq 0x13dd(%rip), %rcx      # 0x5270
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x3f07
movl $0x2, -0x4(%rbp)
jmp 0x3f07
movl $0x4, -0x4(%rbp)
jmp 0x3f07
movl $0x8, -0x4(%rbp)
jmp 0x3f07
jmp 0x3ec2
movl -0x8(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edi
callq 0x3e70
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
imull -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl -0x1c(%rbp), %eax
movl %edx, %esi
movl $0x1, %ecx
movl $0x2, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
imull %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/radix_tree/radix_tree_node.c
// Function: rtn_get_child_key
int rtn_get_child_key(bits *value, int prefix, int k) {
    int l = bits_len(value);
    if (prefix > l) {
        print_err("Uncepted error: prefix %d and value is ", prefix);
        bits_print(value);
        print_err("\n");
        exit(1);
    }
    int key = 0;
    for (int i = 0; i < k && i + prefix < l; ++i) {
        key = (key << 1) | bits_get(value, i + prefix);
    }
    return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c20
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x3f68
movl -0xc(%rbp), %esi
leaq 0x1340(%rip), %rdi      # 0x5280
movb $0x0, %al
callq 0x3b70
movq -0x8(%rbp), %rdi
callq 0x1d40
leaq 0x1140(%rip), %rdi      # 0x5097
movb $0x0, %al
callq 0x3b70
movl $0x1, %edi
callq 0x11b0
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x1d(%rbp)
jge 0x3f92
movl -0x1c(%rbp), %eax
addl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x3f9b
jmp 0x3fc7
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
addl -0xc(%rbp), %esi
callq 0x1bb0
movl %eax, %ecx
movl -0x24(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f76
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/radix_tree/radix_tree_node.c
// Function: rtn_init
radix_tree_node *rtn_init(int k) {
    int m = pow2(k);
    ++_radix_node_number;
    _radix_nodemem += sizeof(radix_tree_node) + sizeof(radix_tree_node *) * m;
    radix_tree_node *rtn = mp_new(sizeof(radix_tree_node));
    rtn->children = mp_new(sizeof(radix_tree_node *) * m);
    return rtn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x3e70
movl %eax, -0x8(%rbp)
movl 0x41b4(%rip), %eax      # 0x81a0
addl $0x1, %eax
movl %eax, 0x41ab(%rip)      # 0x81a0
movslq -0x8(%rbp), %rcx
shlq $0x3, %rcx
addq $0x18, %rcx
movslq 0x41a0(%rip), %rax      # 0x81a8
addq %rcx, %rax
movl %eax, 0x4197(%rip)      # 0x81a8
movl $0x18, %edi
callq 0x32d0
movq %rax, -0x10(%rbp)
movslq -0x8(%rbp), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x32d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/radix_tree/radix_tree_node.c
// Function: rtn_exist
boolean rtn_exist(radix_tree_node *rtn, bits *value, int k) {
    if (rtn == NULL) {
        return F;
    }
    ++compare_number;

    int prefix = bits_prefix(rtn->value, value, k);
    if (prefix != bits_len(rtn->value)) {
        return F;
    }

    if (prefix == bits_len(value) && rtn->end_of_value == T) {
        return T;
    }

    int key = rtn_get_child_key(value, prefix, k);
    value->start += prefix;

    return rtn_exist(rtn->children[key], value, k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x424b
leaq 0xe5f(%rip), %rax       # 0x50a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4319
leaq 0x3f16(%rip), %rax      # 0x8168
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x3f08(%rip), %rax      # 0x8168
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x1c40
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1c20
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
je 0x42a4
leaq 0xe03(%rip), %rax       # 0x50a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4319
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c20
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jne 0x42dc
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
leaq 0xdd2(%rip), %rcx       # 0x509c
cmpl (%rcx), %eax
jne 0x42dc
leaq 0xdc7(%rip), %rax       # 0x509c
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4319
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x3f10
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x4220
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/radix_tree/radix_tree_node.c
// Function: rtn_print
void rtn_print(radix_tree_node *rtn, int m) {
    if (rtn == NULL) {
        return;
    }
    printf("%p %d ", rtn, rtn->end_of_value);
    bits_print(rtn->value);
    printf("\n\t");
    for (int i = 0; i < m; ++i) {
        printf("%p ", rtn->children[i]);
    }
    printf("\n");

    for (int i = 0; i < m; ++i) {
        rtn_print(rtn->children[i], m);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x434b
jmp 0x43f5
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xf4b(%rip), %rdi       # 0x52a8
movb $0x0, %al
callq 0x10a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1d40
leaq 0xf37(%rip), %rdi       # 0x52af
movb $0x0, %al
callq 0x10a0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x43b6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xf0e(%rip), %rdi       # 0x52b2
movb $0x0, %al
callq 0x10a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4386
leaq 0xcda(%rip), %rdi       # 0x5097
movb $0x0, %al
callq 0x10a0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x43f5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
callq 0x4330
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x43cb
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/thread/thread.c
// Function: tp_new
thread_pool *tp_new(int thread_number, int mutex_number, thread_function tf) {
    thread_pool *tp = mp_new(sizeof(thread_pool));
    tp->thread_number = thread_number;
    tp->mutex_number = mutex_number;

    tp->thread_list = mp_new(sizeof(pthread_t) * thread_number);

    tp->mutex = mp_new(sizeof(pthread_mutex_t *) * mutex_number);
    for (int i = 0; i < tp->mutex_number; ++i) {
        tp->mutex[i] = mp_new(sizeof(pthread_mutex_t));
        pthread_mutex_init(tp->mutex[i], NULL);
    }

    for (int i = 0; i < tp->thread_number; ++i) {
        int ret = pthread_create(&tp->thread_list[i], NULL, tf, tp);
        if (ret != 0) {
            perror("pthread_create error:" + ret);
            exit(EXIT_FAILURE);
        }
    }

    return tp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x18, %edi
callq 0x32d0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movslq -0x4(%rbp), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x32d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq -0x8(%rbp), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x32d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x46db
movl $0x28, %edi
callq 0x32d0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x468e
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x4744
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x1160
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x4737
movslq -0x24(%rbp), %rax
leaq 0xb91(%rip), %rdi       # 0x52b6
addq %rax, %rdi
callq 0x1180
movl $0x1, %edi
callq 0x11b0
jmp 0x4739
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x46e2
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/thread/thread.c
// Function: tp_wait
void tp_wait(thread_pool *tp) {
    for (int i = 0; i < tp->thread_number; ++i) {
        int ret = pthread_join(tp->thread_list[i], NULL);
        if (ret != 0) {
            perror("pthread_join error: " + ret);
            exit(EXIT_FAILURE);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x47ba
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11d0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x47ad
movslq -0x10(%rbp), %rax
leaq 0xb31(%rip), %rdi       # 0x52cc
addq %rax, %rdi
callq 0x1180
movl $0x1, %edi
callq 0x11b0
jmp 0x47af
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4763
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/thread/thread.c
// Function: tp_lock
void tp_lock(thread_pool *tp, int idx) {
    int ret = pthread_mutex_lock(tp->mutex[idx]);
    if (ret != 0) {
        perror("pthread_mutex_lock error: " + ret);
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x11f0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x480a
movslq -0x10(%rbp), %rax
leaq 0xae9(%rip), %rdi       # 0x52e1
addq %rax, %rdi
callq 0x1180
movl $0x1, %edi
callq 0x11b0
addq $0x10, %rsp
popq %rbp
retq