LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: parasail_can_use_avx512bw
int parasail_can_use_avx512bw()
{
    static int avx512bw_features_available = -1;
    /* test is performed once */
    if (avx512bw_features_available < 0 )
        avx512bw_features_available = has_intel_avx512bw_features();
    return avx512bw_features_available;
}

// Assembly:
movl 0x212c0f(%rip), %esi    # 0x7dbb54
testl %esi, %esi
jns 0x5c8f8a
pushq %rbx
xorl %esi, %esi
xorl %ebx, %ebx
xorl %ecx, %ecx
movl $0x1, %eax
cpuid
btl $0x1b, %ecx
jae 0x5c8f83
xorl %esi, %esi
xorl %ecx, %ecx
xgetbv
notl %eax
testb $-0x1a, %al
jne 0x5c8f83
movl $0x7, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
notl %ebx
xorl %esi, %esi
testl $0xc0020000, %ebx       # imm = 0xC0020000
sete %sil
movl %esi, 0x212bcb(%rip)    # 0x7dbb54
popq %rbx
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: parasail_can_use_avx512f
int parasail_can_use_avx512f()
{
    static int avx512f_features_available = -1;
    /* test is performed once */
    if (avx512f_features_available < 0 )
        avx512f_features_available = has_intel_avx512f_features();
    return avx512f_features_available;
}

// Assembly:
movl 0x212bc5(%rip), %esi    # 0x7dbb58
testl %esi, %esi
jns 0x5c8fd8
pushq %rbx
xorl %esi, %esi
xorl %ebx, %ebx
xorl %ecx, %ecx
movl $0x1, %eax
cpuid
btl $0x1b, %ecx
jae 0x5c8fd1
xorl %esi, %esi
xorl %ecx, %ecx
xgetbv
notl %eax
testb $-0x1a, %al
jne 0x5c8fd1
movl $0x7, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
notl %ebx
xorl %esi, %esi
testl $0x1c010000, %ebx       # imm = 0x1C010000
sete %sil
movl %esi, 0x212b81(%rip)    # 0x7dbb58
popq %rbx
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: parasail_can_use_avx2
int parasail_can_use_avx2()
{
    static int the_4th_gen_features_available = -1;
    /* test is performed once */
    if (the_4th_gen_features_available < 0 )
        the_4th_gen_features_available = check_4th_gen_intel_core_features();

    return the_4th_gen_features_available;
}

// Assembly:
movl 0x212b7b(%rip), %eax    # 0x7dbb5c
testl %eax, %eax
js 0x5c8fe6
retq
pushq %rbx
movl $0x7, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
movl %ebx, %eax
shrl $0x5, %eax
andl $0x1, %eax
movl %eax, 0x212b5c(%rip)    # 0x7dbb5c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: parasail_can_use_sse41
int parasail_can_use_sse41()
{
    static int can_use_sse41 = -1;
    /* test is performed once */
    if (can_use_sse41 < 0)
        can_use_sse41 = check_sse41();

    return can_use_sse41;
}

// Assembly:
movl 0x212b58(%rip), %esi    # 0x7dbb60
testl %esi, %esi
jns 0x5c9035
pushq %rbx
xorl %esi, %esi
xorl %ebx, %ebx
xorl %eax, %eax
xorl %ecx, %ecx
cpuid
testl %eax, %eax
je 0x5c902e
movl $0x1, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
movl %ecx, %esi
shrl $0x13, %esi
andl $0x1, %esi
movl %esi, 0x212b2c(%rip)    # 0x7dbb60
popq %rbx
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: parasail_can_use_sse2
int parasail_can_use_sse2()
{
    static int can_use_sse2 = -1;
    /* test is performed once */
    if (can_use_sse2 < 0)
        can_use_sse2 = check_sse2();

    return can_use_sse2;
}

// Assembly:
movl 0x212b26(%rip), %esi    # 0x7dbb64
testl %esi, %esi
jns 0x5c906b
pushq %rbx
xorl %esi, %esi
xorl %ebx, %ebx
xorl %eax, %eax
xorl %ecx, %ecx
cpuid
testl %eax, %eax
je 0x5c9064
movl $0x1, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
movl %edx, %esi
shrl $0x1a, %esi
andl $0x1, %esi
movl %esi, 0x212afa(%rip)    # 0x7dbb64
popq %rbx
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/saulvargas[P]re-C-sys/test_usersim.c
// Function: main
int main(int argc, char** argv) {
    FILE* user_data;
    FILE* item_data;
    int N_users;
    int N_items;
    int N_prefs;
    int binary;
    recdata_t* recdata;
    int uid;
    int i;
    similarity_t* similarity;
    idpairs_t* pairs;

    if (!read_args(argc, argv, &user_data, &item_data, &N_users, &N_items, &N_prefs, &binary)) {
        return EXIT_FAILURE;
    }

    recdata = recdata_simple_create(user_data, item_data, N_users, N_items, N_prefs, binary);
    
    fclose(user_data);
    fclose(item_data);

    if (!binary) {
        similarity = similarity_veccosine_create(recdata);
    } else {
        similarity = similarity_setcosine_create(recdata);
    }

    for (uid = 0; uid < recdata->N_users; uid++) {
        pairs = similarity_calculate(similarity, uid, 100);

        for (i = 0; i < idpairs_size(pairs); i++) {
            printf("%d\t%d\t%.4f\n", uid, idpairs_keys(pairs)[i], idpairs_values(pairs)[i]);
        }
        
        idpairs_close_deep(pairs);
    }
 
    similarity_close(similarity);
    
    recdata_close(recdata);
    
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0xc(%rsp), %rax
leaq 0x1c(%rsp), %r10
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x24(%rsp), %r8
leaq 0x20(%rsp), %r9
pushq %rax
pushq %r10
callq 0x26a0
addq $0x10, %rsp
testl %eax, %eax
je 0x1291
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
movl 0x20(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movl 0xc(%rsp), %r9d
callq 0x16a9
movq %rax, %r14
movq 0x30(%rsp), %rdi
callq 0x1060
movq 0x28(%rsp), %rdi
callq 0x1060
cmpl $0x0, 0xc(%rsp)
je 0x129b
movq %r14, %rdi
callq 0x1967
jmp 0x12a3
movl $0x1, %eax
jmp 0x1338
movq %r14, %rdi
callq 0x1c32
movq %rax, 0x10(%rsp)
cmpl $0x0, (%r14)
jle 0x1324
xorl %r15d, %r15d
leaq 0x1d4c(%rip), %r12      # 0x3004
movq 0x10(%rsp), %rdi
movl %r15d, %esi
movl $0x64, %edx
callq 0x17e0
movq %rax, %r13
movq %rax, %rdi
callq 0x25bd
testl %eax, %eax
jle 0x1314
xorl %ebx, %ebx
movq %r13, %rdi
callq 0x25c0
movl (%rax,%rbx,4), %ebp
movq %r13, %rdi
callq 0x25c5
movsd (%rax,%rbx,8), %xmm0
movq %r12, %rdi
movl %r15d, %esi
movl %ebp, %edx
movb $0x1, %al
callq 0x1080
incq %rbx
movq %r13, %rdi
callq 0x25bd
cltq
cmpq %rax, %rbx
jl 0x12db
movq %r13, %rdi
callq 0x2599
incl %r15d
cmpl (%r14), %r15d
jl 0x12b8
movq 0x10(%rsp), %rdi
callq 0x17f0
movq %r14, %rdi
callq 0x1380
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/agraf[P]kvmbench/l3cache.c
// Function: main
int main(int argc, char **argv)
{
    int i;
    sigset_t fSigSet;

    sigemptyset(&fSigSet);
    sigaddset(&fSigSet, SIGUSR1);
    pthread_sigmask(SIG_BLOCK, &fSigSet, NULL);

    pthread_create(&threads[0], NULL, notifier_thread, NULL);
    pthread_create(&threads[1], NULL, waiter_thread, NULL);

    for (i=0; i<(sizeof(threads) / sizeof(threads[0])); i++) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1080
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
xorl %edi, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x10a0
leaq 0x2e91(%rip), %rdi      # 0x40b0
leaq 0x47(%rip), %rdx        # 0x126d
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x10b0
leaq 0x2e82(%rip), %rdi      # 0x40b8
leaq 0x64(%rip), %rdx        # 0x12a1
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x10b0
movq 0x2e63(%rip), %rdi      # 0x40b0
xorl %esi, %esi
callq 0x10d0
movq 0x2e5d(%rip), %rdi      # 0x40b8
xorl %esi, %esi
callq 0x10d0
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/agraf[P]kvmbench/l3cache.c
// Function: notifier_thread
static void *notifier_thread(void *opaque)
{
    while (sig_state != SIG_STATE_IDLE) ;
    while (1) {
//printf("[%d] trigger\n", gettid());
        sig_state = SIG_STATE_SENDING;
        pthread_kill(threads[1], SIGUSR1);
        while (sig_state != SIG_STATE_IDLE) ;
    }

    return NULL;
}

// Assembly:
pushq %rax
movl 0x2e2c(%rip), %eax      # 0x40a0
cmpl $0x1, %eax
jne 0x126e
movl $0x2, 0x2e1d(%rip)      # 0x40a0
movq 0x2e2e(%rip), %rdi      # 0x40b8
movl $0xa, %esi
callq 0x1070
movl 0x2e06(%rip), %eax      # 0x40a0
cmpl $0x1, %eax
jne 0x1294
jmp 0x1279
// File: /workspace/github_c_makefile_star2_O3/agraf[P]kvmbench/l3cache.c
// Function: waiter_thread
static void *waiter_thread(void *opaque)
{
    struct timeval tv_start;
    struct timeval tv_end;
    struct timeval tv;
    uint64_t loops = 0;
    struct sigaction sa = {
        .sa_handler = sig_handler,
    };

    sigset_t fSigSet;

    sigemptyset(&fSigSet);
    sigaddset(&fSigSet, SIGUSR1);
    pthread_sigmask(SIG_UNBLOCK, &fSigSet, NULL);

    sigaction(SIGUSR1, &sa, NULL);

    assert(!gettimeofday(&tv_start, NULL));
    tv_end = tv_start;
    tv_end.tv_sec += 1;

    sig_state = SIG_STATE_IDLE;

    while(1) {
        assert(!gettimeofday(&tv, NULL));
        if ((tv.tv_sec >= tv_end.tv_sec) && (tv.tv_usec >= tv_end.tv_usec))
            break;

        loops++;
//printf("[%d] pre-received \n", gettid());
        while (sig_state != SIG_STATE_RECEIVED) ;
//printf("[%d] recevied\n", gettid());
        sig_state = SIG_STATE_IDLE;
    }

    printf("Number of sleeps: %ld\n", loops);
    exit(0);
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
leaq 0x2aaa(%rip), %rsi      # 0x3d60
leaq 0xa0(%rsp), %rbx
movl $0x98, %edx
movq %rbx, %rdi
callq 0x1090
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x1080
movq %r14, %rdi
movl $0xa, %esi
callq 0x10e0
movl $0x1, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x10a0
movl $0xa, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1030
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x1050
testl %eax, %eax
jne 0x138c
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r12
movl $0x1, 0x2d79(%rip)      # 0x40a0
movq %rsp, %rdi
xorl %esi, %esi
callq 0x1050
testl %eax, %eax
jne 0x136d
xorl %ebx, %ebx
movq %rsp, %r14
cmpq %r15, (%rsp)
jle 0x1347
cmpq %r12, 0x8(%rsp)
jge 0x13ab
movl 0x2d53(%rip), %eax      # 0x40a0
cmpl $0x3, %eax
jne 0x1347
incq %rbx
movl $0x1, 0x2d41(%rip)      # 0x40a0
movq %r14, %rdi
xorl %esi, %esi
callq 0x1050
testl %eax, %eax
je 0x133a
leaq 0xcd5(%rip), %rdi       # 0x2049
leaq 0xca8(%rip), %rsi       # 0x2023
leaq 0xcab(%rip), %rcx       # 0x202d
movl $0x47, %edx
callq 0x1060
leaq 0xc71(%rip), %rdi       # 0x2004
leaq 0xc89(%rip), %rsi       # 0x2023
leaq 0xc8c(%rip), %rcx       # 0x202d
movl $0x40, %edx
callq 0x1060
leaq 0xcb0(%rip), %rdi       # 0x2062
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
xorl %edi, %edi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/wtakuo[P]SVM/vmdebug.c
// Function: dump_vm
void dump_vm (long nsteps, Bcode *ip, Bcode code[],
              Value *lv, Value *fp, Value *sp, Value *vs_base,
              Value gv[], size_t gv_size, vm_mode_t mode) {
    long i;
    Value *p;
    if (mode == vm_normal_mode) return;

    /* global variables */
    for (i = 0; i < gv_size; i++) {
        printf("gv[%ld]=0x%08lx ", i, gv[i]);
        if ((i+1) % 4 == 0) printf("\n");
    }
    if (i % 4 != 0) printf("\n");
    /* value stack */
    i = 0;
    for (p = vs_base - 1; p >= sp; p--) {
        printf("vs[%ld]=0x%08lx ", vs_base - 1 - p, *p);
        if ((i+1) % 4 == 0) printf("\n");
        i++;
    }
    if (i % 4 != 0) printf("\n");
    /* machine state */
    printf("lv=%p (%ld), fp=%p (%ld), sp=%p (%ld)\n", 
           lv, vs_base - lv, 
           fp, vs_base - fp,
           sp, vs_base - sp);
    /* next instruction */
    printf("nsteps=%ld, ip=%p, pc=%ld, inst=%s\n",
           nsteps, 
           ip,
           ip - code, 
           instr_name(ip[0]));

    if (mode == vm_step_mode) {
        printf("next? [Y/n]");
        switch (getchar()) {
        case 'n':
        case 'N':
            exit(EXIT_SUCCESS);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x0, 0x88(%rsp)
je 0x1788
movq %r9, %r12
movq %rcx, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x80(%rsp), %rbx
movq 0x70(%rsp), %r13
testq %rbx, %rbx
je 0x168e
movq 0x78(%rsp), %rbp
leaq 0xabc(%rip), %r14       # 0x210e
xorl %r15d, %r15d
movq (%rbp,%r15,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1050
incq %r15
testb $0x3, %r15b
jne 0x167a
movl $0xa, %edi
callq 0x1040
cmpq %r15, %rbx
jne 0x1655
testb $0x3, %bl
je 0x168e
movl $0xa, %edi
callq 0x1040
leaq -0x8(%r13), %r15
cmpq %r12, %r15
jb 0x16e7
leaq 0xa81(%rip), %r14       # 0x211f
xorl %ebx, %ebx
xorl %ebp, %ebp
movq %rbx, %rsi
sarq $0x3, %rsi
movq (%r15), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1050
leal 0x1(%rbp), %eax
testb $0x3, %al
jne 0x16c7
movl $0xa, %edi
callq 0x1040
addq $-0x8, %r15
addq $0x8, %rbx
incq %rbp
cmpq %r12, %r15
jae 0x16a2
testb $0x3, %bpl
je 0x16e7
movl $0xa, %edi
callq 0x1040
movq %r13, %rdx
movq 0x18(%rsp), %rsi
subq %rsi, %rdx
sarq $0x3, %rdx
movq %r13, %r8
movq 0x20(%rsp), %rcx
subq %rcx, %r8
sarq $0x3, %r8
subq %r12, %r13
sarq $0x3, %r13
movq %r13, (%rsp)
leaq 0xa19(%rip), %rdi       # 0x2130
movq %r12, %r9
xorl %eax, %eax
callq 0x1050
movq 0x30(%rsp), %rdx
movq %rdx, %rcx
subq 0x28(%rsp), %rcx
movzbl (%rdx), %eax
cmpq $0x36, %rax
ja 0x1747
leaq 0xaf6(%rip), %rsi       # 0x2234
movslq (%rsi,%rax,4), %r8
addq %rsi, %r8
jmp 0x174e
leaq 0xae0(%rip), %r8        # 0x222e
movl 0x88(%rsp), %ebx
movq 0x10(%rsp), %rsi
leaq 0x9f6(%rip), %rdi       # 0x2157
xorl %eax, %eax
callq 0x1050
cmpl $0x2, %ebx
jne 0x1788
leaq 0xa07(%rip), %rdi       # 0x217b
xorl %eax, %eax
callq 0x1050
callq 0x1060
orl $0x20, %eax
cmpl $0x6e, %eax
je 0x1797
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x10b0
nop
// File: /workspace/github_c_makefile_star2_O3/wtakuo[P]SVM/vmtest.c
// Function: main
int main (int argc, char *argv[]) {
    vm_mode_t mode = vm_normal_mode;
    int n = 0;
    int i = 1;

    while (i < argc && argv[i][0] == '-') {
        char *arg = argv[i];
        int j = 1;
        while (arg[j] != '\0') {
            switch (arg[j]) {
            case 't':
                mode = vm_trace_mode;
                break;
            case 's':
                mode = vm_step_mode;
                break;
            default:
                fprintf(stderr, "usage: %s [-t][-s] [n]\n", argv[0]);
                return EXIT_FAILURE;
            }
            j++;
        }
        i++;
    }
    if (i < argc) {
        n = atoi(argv[i]);
    }

    vmtest(n, mode);

    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %eax
xorl %ebx, %ebx
movl $0x0, %ebp
movl $0x0, %edi
cmpl $0x2, %eax
jl 0x1815
movl %eax, %eax
xorl %ebp, %ebp
movl $0x1, %ecx
movq (%rsi,%rcx,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x180e
incq %rdi
movzbl (%rdi), %r8d
cmpl $0x73, %r8d
je 0x17e2
movl $0x1, %edx
cmpl $0x74, %r8d
je 0x17e7
jmp 0x17ee
movl $0x2, %edx
incq %rdi
movl %edx, %ebp
jmp 0x17cb
testl %r8d, %r8d
jne 0x17ff
incq %rcx
cmpq %rax, %rcx
jne 0x17bf
xorl %edi, %edi
jmp 0x1815
movq %rsi, %rdi
callq 0x1104
movl $0x1, %ebx
jmp 0x181c
callq 0x10a0
movl %eax, %edi
movl %ebp, %esi
callq 0x1828
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/wtakuo[P]SVM/test3.c
// Function: vmtest
void vmtest (int n, vm_mode_t trace) {
    int codelen = sizeof(code)/sizeof(Bcode);
    Function f = new_function(2, 0, code + 12, codelen - 12);
    gv[0] = (Value)n;
    gv[1] = (Value)f;

    vm(code, codelen, vs_base, VS_SIZE, gv, GV_SIZE, trace);

    delete_function(f);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0x2841(%rip), %rdx      # 0x407c
movl $0x2, %edi
movl $0x17, %ecx
xorl %esi, %esi
callq 0x15b4
movq %rax, %r14
leaq 0x281a(%rip), %rdi      # 0x4070
movslq %ebp, %rax
movq %rax, 0x2850(%rip)      # 0x40b0
leaq 0x2849(%rip), %r8       # 0x40b0
movq %r14, 0x284a(%rip)      # 0x40b8
movl %ebx, (%rsp)
leaq 0x3078(%rip), %rdx      # 0x48f0
movl $0x23, %esi
movl $0x100, %ecx            # imm = 0x100
movl $0x8, %r9d
callq 0x121c
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x15f7
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_mallocx.cold.3
JEMALLOC_ALWAYS_INLINE size_t
s2u(size_t size)
{

	assert(size > 0);
	if (likely(size <= LOOKUP_MAXCLASS))
		return (s2u_lookup(size));
	return (s2u_compute(size));
}

// Assembly:
cmpq $0x1001, %rdi           # imm = 0x1001
jae 0xbe01
leaq -0x1(%rdi), %rax
shrq $0x3, %rax
leaq 0x3005c(%rip), %rcx     # 0x3be40
movzbl (%rax,%rcx), %eax
leaq 0x2f8d1(%rip), %rcx     # 0x3b6c0
movq (%rcx,%rax,8), %rax
movq %rax, (%rsi)
cmpq %rdi, %rax
jae 0xbdfe
movb $0x1, %al
retq
xorl %eax, %eax
retq
movabsq $0x7000000000000000, %rax # imm = 0x7000000000000000
cmpq %rax, %rdi
ja 0xbe40
leaq -0x1(,%rdi,2), %rax
bsrq %rax, %rax
movl %eax, %ecx
addb $-0x3, %cl
pushq $-0x1
popq %rdx
shlq %cl, %rdx
cmpl $0x6, %eax
notq %rdx
pushq $0x7
popq %rax
cmovaeq %rdx, %rax
leaq (%rax,%rdi), %rcx
notq %rax
andq %rcx, %rax
jmp 0xbdf3
xorl %eax, %eax
jmp 0xbdf3
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_dalloc_small
void
arena_dalloc_small(tsdn_t *tsdn, arena_t *arena, arena_chunk_t *chunk,
    void *ptr, size_t pageind)
{
	arena_chunk_map_bits_t *bitselm;

	if (config_debug) {
		/* arena_ptr_small_binind_get() does extra sanity checking. */
		assert(arena_ptr_small_binind_get(ptr, arena_mapbits_get(chunk,
		    pageind)) != BININD_INVALID);
	}
	bitselm = arena_bitselm_get_mutable(chunk, pageind);
	arena_dalloc_bin(tsdn, arena, chunk, ptr, pageind, bitselm);
	arena_decay_tick(tsdn, arena);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x237b2
testq %r14, %r14
je 0xda2c
movl (%rbx), %esi
movq 0x38(%r14), %rax
testq %rax, %rax
je 0xda34
cmpl %esi, 0x40(%r14)
jbe 0xda34
leaq (%rax,%rsi,8), %rax
testq %rax, %rax
je 0xda2c
movl (%rax), %ecx
testl %ecx, %ecx
jle 0xda3e
decl %ecx
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x1ade7
jmp 0xda1d
movl 0x4(%rax), %ecx
movl %ecx, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x225b4
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_dalloc_large
void
arena_dalloc_large(tsdn_t *tsdn, arena_t *arena, arena_chunk_t *chunk,
    void *ptr)
{

	malloc_mutex_lock(tsdn, &arena->lock);
	arena_dalloc_large_locked_impl(tsdn, arena, chunk, ptr, false);
	malloc_mutex_unlock(tsdn, &arena->lock);
	arena_decay_tick(tsdn, arena);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %r13
movq %r13, %rdi
callq 0xb5a0
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x23865
movq %r13, %rdi
callq 0xb380
testq %r14, %r14
je 0xdabd
movl (%rbx), %esi
movq 0x38(%r14), %rax
testq %rax, %rax
je 0xdac7
cmpl %esi, 0x40(%r14)
jbe 0xdac7
leaq (%rax,%rsi,8), %rax
testq %rax, %rax
je 0xdabd
movl (%rax), %ecx
testl %ecx, %ecx
jle 0xdad1
decl %ecx
movl %ecx, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1ade7
jmp 0xdaae
movl 0x4(%rax), %ecx
movl %ecx, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x225b4
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_avail_insert
static void
arena_avail_insert(arena_t *arena, arena_chunk_t *chunk, size_t pageind,
    size_t npages)
{
	pszind_t pind = psz2ind(run_quantize_floor(arena_miscelm_size_get(
	    arena_miscelm_get_const(chunk, pageind))));
	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));
	assert((npages << LG_PAGE) < chunksize);
	assert(pind2sz(pind) <= chunksize);
	arena_run_heap_insert(&arena->runs_avail[pind],
	    arena_miscelm_get_mutable(chunk, pageind));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3e3db(%rip), %rcx     # 0x4cfc8
imulq $0x60, %rdx, %rax
addq %rsi, %rax
addq %rcx, %rax
xorl %r15d, %r15d
xorl %edx, %edx
subq 0x3e3bd(%rip), %rdx     # 0x4cfc0
imulq $0x60, %rdx, %r14
addq %rax, %r14
leaq 0x3e4bf(%rip), %rax     # 0x4d0d0
movq (%rax), %rsi
notq %rsi
andq %r14, %rsi
addq %rsi, %rcx
movq %r14, %rax
subq %rcx, %rax
pushq $0x60
popq %rcx
xorl %edx, %edx
divq %rcx
movq 0x78(%rsi,%rax,8), %rdi
shrq %rdi
andq $-0x1000, %rdi          # imm = 0xF000
callq 0x24efb
movabsq $0x7000000000000000, %rcx # imm = 0x7000000000000000
cmpq %rcx, %rax
ja 0xeccd
leaq -0x1(,%rax,2), %rcx
bsrq %rcx, %rcx
movl %ecx, %edx
subl $0xe, %edx
cmovbl %r15d, %edx
movl %ecx, %esi
addb $-0x3, %sil
cmpl $0xf, %ecx
movzbl %sil, %esi
pushq $0xc
popq %rcx
cmovael %esi, %ecx
decq %rax
shrq %cl, %rax
shlq %cl, %rax
shrq %cl, %rax
andl $0x3, %eax
leal (%rax,%rdx,4), %ecx
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq 0x2318(%rbx,%rcx,8), %rax
testq %rax, %rax
je 0xecba
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
testq %rcx, %rcx
je 0xecb1
movq %r14, (%rcx)
movq %rax, (%r14)
addq $0x8, %rax
jmp 0xecc4
leaq (%rbx,%rcx,8), %rax
addq $0x2318, %rax           # imm = 0x2318
movq %r14, (%rax)
popq %rbx
popq %r14
popq %r15
retq
movl $0xc7, %ecx
jmp 0xec88
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_avail_remove
static void
arena_avail_remove(arena_t *arena, arena_chunk_t *chunk, size_t pageind,
    size_t npages)
{
	pszind_t pind = psz2ind(run_quantize_floor(arena_miscelm_size_get(
	    arena_miscelm_get_const(chunk, pageind))));
	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));
	assert((npages << LG_PAGE) < chunksize);
	assert(pind2sz(pind) <= chunksize);
	arena_run_heap_remove(&arena->runs_avail[pind],
	    arena_miscelm_get_mutable(chunk, pageind));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3e2e5(%rip), %rcx     # 0x4cfc8
imulq $0x60, %rdx, %rax
addq %rsi, %rax
addq %rcx, %rax
xorl %r15d, %r15d
xorl %edx, %edx
subq 0x3e2c7(%rip), %rdx     # 0x4cfc0
imulq $0x60, %rdx, %r14
addq %rax, %r14
leaq 0x3e3c9(%rip), %rax     # 0x4d0d0
movq (%rax), %rsi
notq %rsi
andq %r14, %rsi
addq %rsi, %rcx
movq %r14, %rax
subq %rcx, %rax
pushq $0x60
popq %rcx
xorl %edx, %edx
divq %rcx
movq 0x78(%rsi,%rax,8), %rdi
shrq %rdi
andq $-0x1000, %rdi          # imm = 0xF000
callq 0x24efb
movabsq $0x7000000000000000, %rcx # imm = 0x7000000000000000
cmpq %rcx, %rax
ja 0xed96
leaq -0x1(,%rax,2), %rcx
bsrq %rcx, %rcx
movl %ecx, %edx
subl $0xe, %edx
cmovbl %r15d, %edx
movl %ecx, %esi
addb $-0x3, %sil
cmpl $0xf, %ecx
movzbl %sil, %esi
pushq $0xc
popq %rcx
cmovael %esi, %ecx
decq %rax
shrq %cl, %rax
shlq %cl, %rax
shrq %cl, %rax
andl $0x3, %eax
leal (%rax,%rdx,4), %eax
leaq (%rbx,%rax,8), %rdi
addq $0x2318, %rdi           # imm = 0x2318
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x25391
movl $0xc7, %eax
jmp 0xed7e
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_run_alloc_large_helper
static arena_run_t *
arena_run_alloc_large_helper(arena_t *arena, size_t size, bool zero)
{
	arena_run_t *run = arena_run_first_best_fit(arena, size);
	if (run != NULL) {
		if (arena_run_split_large(arena, run, size, zero))
			run = NULL;
	}
	return (run);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
callq 0xf339
testq %rax, %rax
je 0xf75d
movq %rax, %rbx
movzbl %bpl, %r8d
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x24f71
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmoveq %rbx, %rax
jmp 0xf75f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/quarantine.c
// Function: quarantine_init
static quarantine_t *
quarantine_init(tsdn_t *tsdn, size_t lg_maxobjs)
{
	quarantine_t *quarantine;
	size_t size;

	size = offsetof(quarantine_t, objs) + ((ZU(1) << lg_maxobjs) *
	    sizeof(quarantine_obj_t));
	quarantine = (quarantine_t *)iallocztm(tsdn, size, size2index(size),
	    false, NULL, true, arena_get(TSDN_NULL, 0, true), true);
	if (quarantine == NULL)
		return (NULL);
	quarantine->curbytes = 0;
	quarantine->curobjs = 0;
	quarantine->first = 0;
	quarantine->lg_maxobjs = lg_maxobjs;

	return (quarantine);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
pushq $0x10
popq %rax
movl %ebx, %ecx
shlq %cl, %rax
movq %rdi, %r14
leaq 0x20(%rax), %r15
cmpq $0xfe0, %rax            # imm = 0xFE0
ja 0x10dd6
addq $0x1f, %rax
shrq $0x3, %rax
leaq 0x2b128(%rip), %rcx     # 0x3be40
movzbl (%rcx,%rax), %ebp
leaq 0x3b88d(%rip), %rax     # 0x4c5b0
movq (%rax), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0x10de5
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xccb3
movq %rax, %r15
testq %rax, %rax
je 0x10dc4
leaq 0x3c37f(%rip), %r13     # 0x4d0d0
movq (%r13), %rax
notq %rax
andq %r15, %rax
cmpq %rax, %r15
je 0x10e06
movq (%rax), %r12
cmpq %rax, %r15
je 0x10e20
movq %r15, %rcx
subq %rax, %rcx
shrq $0xc, %rcx
leaq 0x3c23f(%rip), %rdx     # 0x4cfc0
subq (%rdx), %rcx
movq 0x78(%rax,%rcx,8), %rax
movl %eax, %ecx
shrl $0x5, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
je 0x10e30
movl %ecx, %eax
leaq 0x2a91a(%rip), %rcx     # 0x3b6c0
movq (%rcx,%rax,8), %rax
lock
xaddq %rax, 0x90(%r12)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq %rbx, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x10e44
movl %eax, %ebp
jmp 0x10d1c
xorl %esi, %esi
lock
xaddq %rsi, (%rax)
testq %rsi, %rsi
jne 0x10d32
xorl %edi, %edi
xorl %esi, %esi
callq 0x1acc9
movq %rax, %rsi
jmp 0x10d32
movq %r15, %rdi
callq 0x2e203
movq %rax, %r12
movq (%r13), %rax
notq %rax
andq %r15, %rax
jmp 0x10d67
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e344
jmp 0x10daa
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x10daa
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/src/redis-benchmark.c
// Function: showThroughput
int showThroughput(struct aeEventLoop *eventLoop, long long id, void *clientData) {
    UNUSED(eventLoop);
    UNUSED(id);
    UNUSED(clientData);

    if (config.liveclients == 0) {
        fprintf(stderr,"All clients disconnected... aborting.\n");
        exit(1);
    }
    if (config.csv) return 250;
    if (config.idlemode == 1) {
        printf("clients: %d\r", config.liveclients);
        fflush(stdout);
	return 250;
    }
    float dt = (float)(mstime()-config.start)/1000.0;
    float rps = (float)config.requests_finished/dt;
    printf("%s: %.2f\r", config.title, rps);
    fflush(stdout);
    return 250; /* every 250ms */
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl 0x38146(%rip), %esi     # 0x4c45c
testl %esi, %esi
je 0x143cd
cmpl $0x0, 0x3818f(%rip)     # 0x4c4b4
jne 0x143c2
cmpl $0x1, 0x3818a(%rip)     # 0x4c4bc
jne 0x14344
leaq 0x24fcc(%rip), %rdi     # 0x39307
xorl %eax, %eax
callq 0xb1c0
jmp 0x143b3
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb200
imulq $0x3e8, (%rbx), %rcx    # imm = 0x3E8
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%rbx)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
addq %rcx, %rdx
subq 0x3810a(%rip), %rdx     # 0x4c488
cvtsi2ss %rdx, %xmm0
divss 0x24e65(%rip), %xmm0    # 0x391f0
cvtsi2ssl 0x380d5(%rip), %xmm1 # 0x4c468
divss %xmm0, %xmm1
movq 0x38102(%rip), %rsi     # 0x4c4a0
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x24f68(%rip), %rdi     # 0x39314
movb $0x1, %al
callq 0xb1c0
movq 0x37c06(%rip), %rax     # 0x4bfc0
movq (%rax), %rdi
callq 0xb3a0
movl $0xfa, %eax
addq $0x10, %rsp
popq %rbx
retq
callq 0xb620
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/src/redis-benchmark.c
// Function: test_is_selected
int test_is_selected(char *name) {
    char buf[256];
    int l = strlen(name);

    if (config.tests == NULL) return 1;
    buf[0] = ',';
    memcpy(buf+1,name,l);
    buf[l+1] = ',';
    buf[l+2] = '\0';
    return strstr(config.tests,buf) != NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq 0x380ea(%rip), %rbx     # 0x4c4d0
testq %rbx, %rbx
je 0x14453
movq %rdi, %r14
callq 0xb190
movb $0x2c, %bpl
leaq 0x1(%rsp), %rdi
movb %bpl, -0x1(%rdi)
movslq %eax, %rdx
movq %rax, %r15
shlq $0x20, %r15
movq %r14, %rsi
callq 0xb340
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %r15, %rax
sarq $0x20, %rax
movb %bpl, (%rsp,%rax)
movabsq $0x200000000, %rax      # imm = 0x200000000
addq %r15, %rax
sarq $0x20, %rax
movb $0x0, (%rsp,%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xb590
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0x14458
movl $0x1, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/src/redis-benchmark.c
// Function: createMissingClients
static void createMissingClients(client c) {
    int n = 0;

    while(config.liveclients < config.numclients) {
        createClient(NULL,0,c);

        /* Listen backlog is quite limited on most systems */
        if (++n > 64) {
            usleep(50000);
            n = 0;
        }
    }
}

// Assembly:
movl 0x3752d(%rip), %eax     # 0x4c45c
cmpl 0x37523(%rip), %eax     # 0x4c458
jge 0x14f7a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x14baa
cmpl $0x40, %r14d
jge 0x14f58
incl %r14d
jmp 0x14f65
movl $0xc350, %edi           # imm = 0xC350
callq 0xb5e0
xorl %r14d, %r14d
movl 0x374f1(%rip), %eax     # 0x4c45c
cmpl 0x374e7(%rip), %eax     # 0x4c458
jl 0x14f41
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/src/redis-benchmark.c
// Function: freeClient
static void freeClient(client c) {
    listNode *ln;
    aeDeleteFileEvent(config.el,c->context->fd,AE_WRITABLE);
    aeDeleteFileEvent(config.el,c->context->fd,AE_READABLE);
    redisFree(c->context);
    sdsfree(c->obuf);
    zfree(c->randptr);
    zfree(c);
    config.liveclients--;
    ln = listSearchKey(config.clients,c);
    assert(ln != NULL);
    listDelNode(config.clients,ln);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x36fdf(%rip), %rdi     # 0x4c438
movq (%rbx), %rax
movl 0x84(%rax), %esi
movl $0x2, %edx
callq 0x12826
movq 0x36fc5(%rip), %rdi     # 0x4c438
movq (%rbx), %rax
movl 0x84(%rax), %esi
movl $0x1, %edx
callq 0x12826
movq (%rbx), %rdi
callq 0x1721e
movq 0x8(%rbx), %rdi
callq 0x18229
movq 0x10(%rbx), %rdi
callq 0x15c27
movq %rbx, %rdi
callq 0x15c27
decl 0x36fae(%rip)           # 0x4c45c
movq 0x36ff3(%rip), %rdi     # 0x4c4a8
movq %rbx, %rsi
callq 0x15a20
testq %rax, %rax
je 0x154d2
movq 0x36fdf(%rip), %rdi     # 0x4c4a8
movq %rax, %rsi
popq %rbx
jmp 0x158e1
leaq 0x24177(%rip), %rdi     # 0x39650
leaq 0x2417b(%rip), %rsi     # 0x3965b
leaq 0x24186(%rip), %rcx     # 0x3966d
movl $0x87, %edx
callq 0xb210
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: a0ialloc
static void *
a0ialloc(size_t size, bool zero, bool is_metadata)
{

	if (unlikely(malloc_init_a0()))
		return (NULL);

	return (iallocztm(TSDN_NULL, size, size2index(size), zero, NULL,
	    is_metadata, arena_get(TSDN_NULL, 0, true), true));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x3, 0x31935(%rip)     # 0x4c35c
je 0x1aaf5
cmpq $0x1000, %rbx           # imm = 0x1000
ja 0x1ab06
leaq -0x1(%rbx), %rax
shrq $0x3, %rax
leaq 0x213f7(%rip), %rcx     # 0x3be40
movzbl (%rax,%rcx), %r15d
movq 0x31b5b(%rip), %rax     # 0x4c5b0
movq (%rax), %rsi
testq %rsi, %rsi
je 0x1ab16
movzbl %r14b, %r8d
xorl %edi, %edi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0xccb3
movq %rax, %rbx
testb %bpl, %bpl
je 0x1aae7
testq %rbx, %rbx
je 0x1aae7
leaq 0x3264a(%rip), %r15     # 0x4d0d0
movq (%r15), %rax
notq %rax
andq %rbx, %rax
cmpq %rax, %rbx
je 0x1ab37
movq (%rax), %r14
cmpq %rax, %rbx
je 0x1ab50
movq %rbx, %rcx
subq %rax, %rcx
shrq $0xc, %rcx
leaq 0x3250b(%rip), %rdx     # 0x4cfc0
subq (%rdx), %rcx
movq 0x78(%rax,%rcx,8), %rax
movl %eax, %ecx
shrl $0x5, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
je 0x1ab5c
movl %ecx, %eax
leaq 0x20be6(%rip), %rcx     # 0x3b6c0
movq (%rcx,%rax,8), %rax
lock
xaddq %rax, 0x90(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x20609
testb %al, %al
je 0x1aa2d
xorl %ebx, %ebx
jmp 0x1aae7
movq %rbx, %rdi
callq 0xb765
movl %eax, %r15d
jmp 0x1aa4e
xorl %esi, %esi
lock
xaddq %rsi, (%rax)
testq %rsi, %rsi
jne 0x1aa61
xorl %edi, %edi
xorl %esi, %esi
callq 0x1acc9
movq %rax, %rsi
jmp 0x1aa61
movq %rbx, %rdi
callq 0x2e203
movq %rax, %r14
movq (%r15), %rax
notq %rax
andq %rbx, %rax
jmp 0x1aa9b
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2e344
jmp 0x1aade
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x1aade
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_arena_init
arena_t *
arena_init(tsdn_t *tsdn, unsigned ind)
{
	arena_t *arena;

	malloc_mutex_lock(tsdn, &arenas_lock);
	arena = arena_init_locked(tsdn, ind);
	malloc_mutex_unlock(tsdn, &arenas_lock);
	return (arena);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x3186e(%rip), %r15     # 0x4c548
movq %r15, %rdi
callq 0xb5a0
movq %r14, %rdi
movl %ebx, %esi
callq 0x1ad00
movq %rax, %rbx
movq %r15, %rdi
callq 0xb380
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: arena_init_locked
static arena_t *
arena_init_locked(tsdn_t *tsdn, unsigned ind)
{
	arena_t *arena;

	assert(ind <= narenas_total_get());
	if (ind > MALLOCX_ARENA_MAX)
		return (NULL);
	if (ind == narenas_total_get())
		narenas_total_inc();

	/*
	 * Another thread may have already initialized arenas[ind] if it's an
	 * auto arena.
	 */
	arena = arena_get(tsdn, ind, false);
	if (arena != NULL) {
		assert(ind < narenas_auto);
		return (arena);
	}

	/* Actually initialize the arena. */
	arena = arena_new(tsdn, ind);
	arena_set(ind, arena);
	return (arena);
}

// Assembly:
cmpl $0xffe, %esi            # imm = 0xFFE
jbe 0x1ad0b
xorl %eax, %eax
retq
pushq %rbx
xorl %eax, %eax
lock
xaddl %eax, 0x3182a(%rip)     # 0x4c540
cmpl %esi, %eax
jne 0x1ad27
movl $0x1, %eax
lock
xaddl %eax, 0x31819(%rip)     # 0x4c540
movq 0x31882(%rip), %rcx     # 0x4c5b0
movl %esi, %ebx
movq (%rcx,%rbx,8), %rax
testq %rax, %rax
je 0x1ad3b
popq %rbx
retq
xorl %eax, %eax
lock
xaddq %rax, (%rcx,%rbx,8)
testq %rax, %rax
jne 0x1ad39
callq 0x23db1
movq 0x3185c(%rip), %rcx     # 0x4c5b0
movq %rax, %rdx
xchgq %rdx, (%rcx,%rbx,8)
jmp 0x1ad39
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_arena_migrate
void
arena_migrate(tsd_t *tsd, unsigned oldind, unsigned newind)
{
	arena_t *oldarena, *newarena;

	oldarena = arena_get(tsd_tsdn(tsd), oldind, false);
	newarena = arena_get(tsd_tsdn(tsd), newind, false);
	arena_nthreads_dec(oldarena, false);
	arena_nthreads_inc(newarena, false);
	tsd_arena_set(tsd, newarena);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x31845(%rip), %rax     # 0x4c5b0
movl %esi, %ecx
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0x1ad9e
movl %edx, %ecx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x1adaf
xorl %esi, %esi
callq 0x23d94
movq %r14, %rdi
xorl %esi, %esi
callq 0x23d86
movq %r14, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
lock
xaddq %rdi, (%rax,%rcx,8)
movq 0x31803(%rip), %rax     # 0x4c5b0
jmp 0x1ad76
xorl %r14d, %r14d
lock
xaddq %r14, (%rax,%rcx,8)
jmp 0x1ad81
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_arena_get
JEMALLOC_INLINE arena_t *
arena_get(tsdn_t *tsdn, unsigned ind, bool init_if_missing)
{
	arena_t *ret;

	assert(ind <= MALLOCX_ARENA_MAX);

	ret = arenas[ind];
	if (unlikely(ret == NULL)) {
		ret = atomic_read_p((void *)&arenas[ind]);
		if (init_if_missing && unlikely(ret == NULL))
			ret = arena_init(tsdn, ind);
	}
	return (ret);
}

// Assembly:
movq 0x317ef(%rip), %rcx     # 0x4c5b0
movl %esi, %r8d
movq (%rcx,%r8,8), %rax
testq %rax, %rax
jne 0x1ade6
xorl %eax, %eax
lock
xaddq %rax, (%rcx,%r8,8)
testq %rax, %rax
sete %cl
andb %dl, %cl
cmpb $0x1, %cl
je 0x1acc9
retq
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_free
JEMALLOC_NOTHROW
je_free(void *ptr)
{

	UTRACE(ptr, 0, 0);
	if (likely(ptr != NULL)) {
		tsd_t *tsd = tsd_fetch();
		witness_assert_lockless(tsd_tsdn(tsd));
		if (likely(!malloc_slow))
			ifree(tsd, ptr, tcache_get(tsd, false), false);
		else
			ifree(tsd, ptr, tcache_get(tsd, false), true);
		witness_assert_lockless(tsd_tsdn(tsd));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1d2aa
movq %rdi, %rbx
movq 0x2ed61(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %r14
addq %rax, %r14
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x1d2b2
cmpl $0x2, %ecx
je 0x1d2bb
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbd10
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %fs:(%rax)
jmp 0x1d2c2
movl $0x3, %fs:(%rax)
leaq 0x3020b(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %r14, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x1d29f
leaq 0x1ef23(%rip), %rdi     # 0x3c201
callq 0x3645c
cmpb $0x1, 0x2f236(%rip)     # 0x4c520
jne 0x1d29f
callq 0xb070
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_dallocx
JEMALLOC_NOTHROW
je_dallocx(void *ptr, int flags)
{
	tsd_t *tsd;
	tcache_t *tcache;

	assert(ptr != NULL);
	assert(malloc_initialized() || IS_INITIALIZER);

	tsd = tsd_fetch();
	witness_assert_lockless(tsd_tsdn(tsd));
	if (unlikely((flags & MALLOCX_TCACHE_MASK) != 0)) {
		if ((flags & MALLOCX_TCACHE_MASK) == MALLOCX_TCACHE_NONE)
			tcache = NULL;
		else
			tcache = tcaches_get(tsd, MALLOCX_TCACHE_GET(flags));
	} else
		tcache = tcache_get(tsd, false);

	UTRACE(ptr, 0, 0);
	if (likely(!malloc_slow))
		ifree(tsd, ptr, tcache, false);
	else
		ifree(tsd, ptr, tcache, true);
	witness_assert_lockless(tsd_tsdn(tsd));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %rbx
movq 0x2cbfe(%rip), %r12     # 0x4bfe8
movq %fs:0x0, %r14
addq %r12, %r14
movl %fs:(%r12), %eax
testl %eax, %eax
je 0x1f43b
cmpl $0x2, %eax
je 0x1f47f
andl $0xfff00, %r15d         # imm = 0xFFF00
jne 0x1f42e
movq %fs:0x8(%r12), %rdx
movzbl 0x2cf3e(%rip), %ecx     # 0x4c358
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1cfd3
cmpl $0x100, %r15d           # imm = 0x100
jne 0x1f446
xorl %edx, %edx
jmp 0x1f413
movl $0x1, %fs:(%r12)
jmp 0x1f488
shrl $0x8, %r15d
addl $-0x2, %r15d
leaq 0x2e033(%rip), %rax     # 0x4d488
movq (%rax), %r13
movq (%r13,%r15,8), %rdx
testq %rdx, %rdx
jne 0x1f413
movq %fs:0x30(%r12), %rsi
testq %rsi, %rsi
je 0x1f4bf
movq %r14, %rdi
callq 0x10eca
movq %rax, %rdx
movq %rax, (%r13,%r15,8)
jmp 0x1f413
movl $0x3, %fs:(%r12)
leaq 0x2e045(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %r14, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x1f404
leaq 0x1cd59(%rip), %rdi     # 0x3c201
callq 0x3645c
cmpb $0x1, 0x2d06c(%rip)     # 0x4c520
jne 0x1f404
callq 0xb070
movq %r14, %rdi
xorl %esi, %esi
callq 0x1af15
movq %rax, %rsi
jmp 0x1f46d
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_mallctl
JEMALLOC_NOTHROW
je_mallctl(const char *name, void *oldp, size_t *oldlenp, void *newp,
    size_t newlen)
{
	int ret;
	tsd_t *tsd;

	if (unlikely(malloc_init()))
		return (EAGAIN);

	tsd = tsd_fetch();
	witness_assert_lockless(tsd_tsdn(tsd));
	ret = ctl_byname(tsd, name, oldp, oldlenp, newp, newlen);
	witness_assert_lockless(tsd_tsdn(tsd));
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
cmpl $0x0, 0x2c68b(%rip)     # 0x4c35c
jne 0x1fd25
movq %fs:0x0, %rbp
addq 0x2c305(%rip), %rbp     # 0x4bfe8
cmpq $0x0, 0x2c83d(%rip)     # 0x4c528
jne 0x1fd42
movq 0x2c2f4(%rip), %rax     # 0x4bfe8
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x1fd4c
cmpl $0x2, %ecx
je 0x1fd55
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x278ec
callq 0x2158b
testb %al, %al
je 0x1fcd3
movl $0xb, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rdi
callq 0xc5c5
jmp 0x1fced
movl $0x1, %fs:(%rax)
jmp 0x1fd5c
movl $0x3, %fs:(%rax)
leaq 0x2d771(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbp, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x1fd00
leaq 0x1c489(%rip), %rdi     # 0x3c201
callq 0x3645c
cmpb $0x1, 0x2c79c(%rip)     # 0x4c520
jne 0x1fd00
callq 0xb070
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_mallctlnametomib
JEMALLOC_NOTHROW
je_mallctlnametomib(const char *name, size_t *mibp, size_t *miblenp)
{
	int ret;
	tsdn_t *tsdn;

	if (unlikely(malloc_init()))
		return (EAGAIN);

	tsdn = tsdn_fetch();
	witness_assert_lockless(tsdn);
	ret = ctl_nametomib(tsdn, name, mibp, miblenp);
	witness_assert_lockless(tsdn);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x2c5b5(%rip)     # 0x4c35c
jne 0x1fe06
cmpq $0x0, 0x2c777(%rip)     # 0x4c528
jne 0x1fe20
leaq 0x2d6f6(%rip), %rax     # 0x4d4b0
cmpb $0x1, (%rax)
jne 0x1fde7
movq 0x2c222(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %r12
addq %rax, %r12
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x1fe27
cmpl $0x2, %ecx
jne 0x1fdea
movl $0x3, %fs:(%rax)
jmp 0x1fe2e
xorl %r12d, %r12d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x27c9a
callq 0x2158b
testb %al, %al
je 0x1fda9
movl $0xb, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xc623
jmp 0x1fdb3
movl $0x1, %fs:(%rax)
leaq 0x2d69f(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %r12, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x1fdea
leaq 0x1c3b7(%rip), %rdi     # 0x3c201
callq 0x3645c
cmpb $0x1, 0x2c6ca(%rip)     # 0x4c520
jne 0x1fdea
callq 0xb070
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_mallctlbymib
JEMALLOC_NOTHROW
je_mallctlbymib(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
  void *newp, size_t newlen)
{
	int ret;
	tsd_t *tsd;

	if (unlikely(malloc_init()))
		return (EAGAIN);

	tsd = tsd_fetch();
	witness_assert_lockless(tsd_tsdn(tsd));
	ret = ctl_bymib(tsd, mib, miblen, oldp, oldlenp, newp, newlen);
	witness_assert_lockless(tsd_tsdn(tsd));
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %r9
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbp
cmpl $0x0, 0x2c4d8(%rip)     # 0x4c35c
jne 0x1feda
movq %fs:0x0, %rbx
addq 0x2c152(%rip), %rbx     # 0x4bfe8
cmpq $0x0, 0x2c68a(%rip)     # 0x4c528
jne 0x1fef0
movq 0x2c141(%rip), %rax     # 0x4bfe8
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x1ff04
cmpl $0x2, %ecx
je 0x1ff0d
movq %r12, (%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x27cf2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r9, %rbx
callq 0x2158b
movq %rbx, %r9
testb %al, %al
je 0x1fe86
movl $0xb, %eax
jmp 0x1fecb
movq %rbx, %rdi
movq %r9, 0x10(%rsp)
callq 0xc6a7
movq 0x10(%rsp), %r9
jmp 0x1fea0
movl $0x1, %fs:(%rax)
jmp 0x1ff14
movl $0x3, %fs:(%rax)
leaq 0x2d5b9(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
movq %r9, 0x10(%rsp)
callq 0xb5b0
movq 0x10(%rsp), %r9
testl %eax, %eax
je 0x1feb3
leaq 0x1c2c7(%rip), %rdi     # 0x3c201
callq 0x3645c
movq 0x10(%rsp), %r9
cmpb $0x1, 0x2c5d5(%rip)     # 0x4c520
jne 0x1feb3
callq 0xb070
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_malloc_stats_print
JEMALLOC_NOTHROW
je_malloc_stats_print(void (*write_cb)(void *, const char *), void *cbopaque,
    const char *opts)
{
	tsdn_t *tsdn;

	tsdn = tsdn_fetch();
	witness_assert_lockless(tsdn);
	stats_print(write_cb, cbopaque, opts);
	witness_assert_lockless(tsdn);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2d545(%rip), %rax     # 0x4d4b0
cmpb $0x1, (%rax)
jne 0x1ff8f
movq 0x2c071(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rsi
addq %rax, %rsi
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x1ffa2
cmpl $0x2, %ecx
je 0x1ffab
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x305b4
movl $0x1, %fs:(%rax)
jmp 0x1ffb2
movl $0x3, %fs:(%rax)
leaq 0x2d51b(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
callq 0xb5b0
testl %eax, %eax
je 0x1ff8f
leaq 0x1c236(%rip), %rdi     # 0x3c201
callq 0x3645c
cmpb $0x1, 0x2c549(%rip)     # 0x4c520
jne 0x1ff8f
callq 0xb070
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_malloc_usable_size
JEMALLOC_NOTHROW
je_malloc_usable_size(JEMALLOC_USABLE_SIZE_CONST void *ptr)
{
	size_t ret;
	tsdn_t *tsdn;

	assert(malloc_initialized() || IS_INITIALIZER);
	malloc_thread_init();

	tsdn = tsdn_fetch();
	witness_assert_lockless(tsdn);

	if (config_ivsalloc)
		ret = ivsalloc(tsdn, ptr, config_prof);
	else
		ret = (ptr == NULL) ? 0 : isalloc(tsdn, ptr, config_prof);

	witness_assert_lockless(tsdn);
	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x2c53b(%rip)     # 0x4c528
jne 0x2008a
leaq 0x2d4b6(%rip), %rax     # 0x4d4b0
cmpb $0x1, (%rax)
jne 0x2002e
movq 0x2bfe2(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %r14
addq %rax, %r14
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x200b7
cmpl $0x2, %ecx
jne 0x20031
movl $0x3, %fs:(%rax)
jmp 0x200be
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x20080
leaq 0x2d093(%rip), %rax     # 0x4d0d0
movq (%rax), %rax
notq %rax
andq %rbx, %rax
cmpq %rbx, %rax
je 0x20094
subq %rax, %rbx
shrq $0xc, %rbx
leaq 0x2cf67(%rip), %rcx     # 0x4cfc0
subq (%rcx), %rbx
movq 0x78(%rax,%rbx,8), %rax
movl %eax, %ecx
shrl $0x5, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
je 0x200a6
movl %ecx, %eax
leaq 0x1b646(%rip), %rcx     # 0x3b6c0
movq (%rcx,%rax,8), %rax
jmp 0x20082
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xc705
jmp 0x1fff3
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e344
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x20082
movl $0x1, %fs:(%rax)
leaq 0x2d40f(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %r14, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x20031
leaq 0x1c123(%rip), %rdi     # 0x3c201
callq 0x3645c
cmpb $0x1, 0x2c436(%rip)     # 0x4c520
jne 0x20031
callq 0xb070