LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jafrado[P]magdec/magdec.c
// Function: lookup_magdev
float lookup_magdev(float lat, float lon, int year)
{
	int i, n;
	int lati, loni;
	magdec_correction_t* c = NULL;
	
	lati = (int)lat;
	loni = (int)lon;
	
	//printf("lookup: %d,%d\n", lati, loni);

	if (year <= 2019) { 
		c = &corr[0];
		n = n_magdec_entries;
	}
	else { 
		c = &corr_2020[0];
		n = n_magdec_entries_2020;
	}
	
	for (i = 0; i < n; i++){ 
		if ((c[i].lat == lati) && (c[i].lon == loni) && 
		    (c[i].year == year)){
		  // printf("entry %d - %d, %d\n", i, corr[i].lat, corr[i].lon);
			break;
		}
	}
	if (i < n)
		return c[i].magdec;
	else { 
		printf("WARNING: %2.2f, %2.2f not in database for %d,"
		       " correction most likely incorrect\n", lat, lon, year);
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movl %edi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
cvttss2si -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
cvttss2si -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x7e3, -0x10(%rbp)     # imm = 0x7E3
jg 0x137f
leaq 0x2e83(%rip), %rax      # 0x41f0
movq %rax, -0x28(%rbp)
leaq 0x2fc638(%rip), %rax    # 0x2fd9b0
movl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x1396
leaq 0x2fc63a(%rip), %rax    # 0x2fd9c0
movq %rax, -0x28(%rbp)
leaq 0x8ef5af(%rip), %rax    # 0x8f0940
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x13f8
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x13eb
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x20(%rbp), %eax
jne 0x13eb
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x13eb
jmp 0x13f8
jmp 0x13ed
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x139d
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x141b
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss 0xc(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1446
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movl -0x10(%rbp), %esi
leaq 0xd3d(%rip), %rdi       # 0x2174
movb $0x2, %al
callq 0x1030
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PARKINHYO[P]BlackjackGame/shm/shm_client.c
// Function: set_shutdown
void *set_shutdown ()
{
        printf("[SIGNAL] : Got shutdown signal\n");
        shmctl( gnShmID2, IPC_RMID, 0 );
        printf("[SIGNAL] : Shared meory segment marked for deletion\n");;
        semctl( gnSemID2, IPC_RMID, 0 );
        printf("[SIGNAL] : Semapore segment marked for deletion\n");
        exit (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1b1e(%rip), %rdi      # 0x3069
movb $0x0, %al
callq 0x1090
movl 0x3c38(%rip), %edi      # 0x5190
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x10f0
leaq 0x1b1f(%rip), %rdi      # 0x3089
movb $0x0, %al
callq 0x1090
movl 0x3c1d(%rip), %edi      # 0x5194
xorl %edx, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x1110
leaq 0x1b35(%rip), %rdi      # 0x30be
movb $0x0, %al
callq 0x1090
movl $0x1, %edi
callq 0x1160
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0x2d(%rbp)
jge 0x21a0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x21ac
jmp 0x2247
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x2239
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
subl $0x73, %eax
je 0x21fd
jmp 0x21ea
movl -0x34(%rbp), %eax
subl $0x74, %eax
jne 0x2206
jmp 0x21f4
movl $0x1, -0x14(%rbp)
jmp 0x222e
movl $0x2, -0x14(%rbp)
jmp 0x222e
movq 0x2deb(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x10f2(%rip), %rsi      # 0x3310
movb $0x0, %al
callq 0x1060
movl $0x1, -0x4(%rbp)
jmp 0x2275
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x21c3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x217b
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2263
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1090
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x2280
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x23, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0xc, %eax
movslq %eax, %rcx
movl $0x2, %edi
xorl %eax, %eax
movl %eax, %esi
leaq 0x2dc2(%rip), %rdx      # 0x5070
addq $0xc, %rdx
callq 0x1c20
movq %rax, -0x18(%rbp)
movslq -0x4(%rbp), %rax
movq %rax, 0x2dea(%rip)      # 0x50b0
movq -0x18(%rbp), %rax
movq %rax, 0x2de7(%rip)      # 0x50b8
movslq -0xc(%rbp), %rsi
movq 0x2dbc(%rip), %rdx      # 0x5098
movl -0x8(%rbp), %eax
leaq 0x2d8a(%rip), %rdi      # 0x5070
movl $0x100, %ecx            # imm = 0x100
leaq 0x2dbe(%rip), %r8       # 0x50b0
movl $0x8, %r9d
movl %eax, (%rsp)
callq 0x11b0
movq -0x18(%rbp), %rdi
callq 0x1ca0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x0, 0x94af1(%rip)     # 0xa343c
jne 0xe96f
movq 0x946a4(%rip), %rax     # 0xa2ff8
movq (%rax), %rdi
leaq 0x80240(%rip), %rsi     # 0x8eb9e
movb $0x0, %al
callq 0xb2e0
movl $0x1, %edi
callq 0xb4f0
cmpl $0x0, 0x94b1e(%rip)     # 0xa3494
je 0xe984
movl $0xfa, -0x4(%rbp)
jmp 0xea29
cmpl $0x1, 0x94b11(%rip)     # 0xa349c
jne 0xe9b9
movl 0x94aa9(%rip), %esi     # 0xa343c
leaq 0x8022b(%rip), %rdi     # 0x8ebc5
movb $0x0, %al
callq 0xb1a0
movq 0x94628(%rip), %rax     # 0xa2fd0
movq (%rax), %rdi
callq 0xb380
movl $0xfa, -0x4(%rbp)
jmp 0xea29
callq 0xea40
subq 0x94aa3(%rip), %rax     # 0xa3468
cvtsi2ss %rax, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x7f7d2(%rip), %xmm1    # 0x8e1a8
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
cvtsi2ssl 0x94a5d(%rip), %xmm0 # 0xa3448
divss -0x24(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movq 0x94a84(%rip), %rsi     # 0xa3480
movss -0x28(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x801c6(%rip), %rdi     # 0x8ebd2
movb $0x1, %al
callq 0xb1a0
movq 0x945b6(%rip), %rax     # 0xa2fd0
movq (%rax), %rdi
callq 0xb380
movl $0xfa, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/src/redis-benchmark.c
// Function: mstime
static long long mstime(void) {
    struct timeval tv;
    long long mst;

    gettimeofday(&tv, NULL);
    mst = ((long long)tv.tv_sec)*1000;
    mst += tv.tv_usec/1000;
    return mst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb1e0
imulq $0x3e8, -0x10(%rbp), %rax # imm = 0x3E8
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb170
movl %eax, -0x114(%rbp)
cmpq $0x0, 0x949fa(%rip)     # 0xa34b0
jne 0xeac1
movl $0x1, -0x4(%rbp)
jmp 0xeb2b
movb $0x2c, -0x110(%rbp)
leaq -0x110(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rsi
movslq -0x114(%rbp), %rdx
callq 0xb310
movl -0x114(%rbp), %eax
addl $0x1, %eax
cltq
movb $0x2c, -0x110(%rbp,%rax)
movl -0x114(%rbp), %eax
addl $0x2, %eax
cltq
movb $0x0, -0x110(%rbp,%rax)
movq 0x949a0(%rip), %rdi     # 0xa34b0
leaq -0x110(%rbp), %rsi
callq 0xb570
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl 0x93b43(%rip), %eax     # 0xa343c
cmpl 0x93b39(%rip), %eax     # 0xa3438
jge 0xf932
movq -0x8(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0xf3f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x40, %eax
jle 0xf930
movl $0xc350, %edi           # imm = 0xC350
callq 0xb5b0
movl $0x0, -0xc(%rbp)
jmp 0xf8f3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/src/redis-benchmark.c
// Function: benchmark
static void benchmark(char *title, char *cmd, int len) {
    client c;

    config.title = title;
    config.requests_issued = 0;
    config.requests_finished = 0;

    c = createClient(cmd,len,NULL);
    createMissingClients(c);

    config.start = mstime();
    aeMain(config.el);
    config.totlatency = mstime()-config.start;

    showLatencyReport();
    freeAllClients();
}

// 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 %rax, 0x93b22(%rip)     # 0xa3480
movl $0x0, 0x93adc(%rip)     # 0xa3444
movl $0x0, 0x93ad6(%rip)     # 0xa3448
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xf3f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf8e0
callq 0xea40
movq %rax, 0x93acc(%rip)     # 0xa3468
movq 0x93a75(%rip), %rdi     # 0xa3418
callq 0xc830
callq 0xea40
subq 0x93ab4(%rip), %rax     # 0xa3468
movq %rax, 0x93ab5(%rip)     # 0xa3470
callq 0x10190
callq 0x103b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x937f5(%rip), %rdi     # 0xa3418
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x84(%rax), %esi
movl $0x2, %edx
callq 0xbcb0
movq 0x937d7(%rip), %rdi     # 0xa3418
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x84(%rax), %esi
movl $0x1, %edx
callq 0xbcb0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12e30
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x15120
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10f90
movq -0x8(%rbp), %rdi
callq 0x10f90
movl 0x937af(%rip), %eax     # 0xa343c
addl $-0x1, %eax
movl %eax, 0x937a6(%rip)     # 0xa343c
movq 0x937eb(%rip), %rdi     # 0xa3488
movq -0x8(%rbp), %rsi
callq 0x10ad0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xfcb3
jmp 0xfcd2
leaq 0x7f31b(%rip), %rdi     # 0x8efd5
leaq 0x7f31f(%rip), %rsi     # 0x8efe0
movl $0x87, %edx
leaq 0x7f325(%rip), %rcx     # 0x8eff2
callq 0xb1f0
movq 0x937af(%rip), %rdi     # 0xa3488
movq -0x10(%rbp), %rsi
callq 0x107e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/src/redis-benchmark.c
// Function: randomizeClientKey
static void randomizeClientKey(client c) {
    size_t i;

    for (i = 0; i < c->randlen; i++) {
        char *p = c->randptr[i]+11;
        size_t r = random() % config.randomkeys_keyspacelen;
        size_t j;

        for (j = 0; j < 12; j++) {
            *p = '0'+r%10;
            r/=10;
            p--;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0xfdab
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0xb, %rax
movq %rax, -0x18(%rbp)
callq 0xb340
movslq 0x9371e(%rip), %rcx     # 0xa3458
cqto
idivq %rcx
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0xc, -0x28(%rbp)
jae 0xfd98
movq -0x20(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0x30, %rdx
movb %dl, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xfd4b
jmp 0xfd9a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xfd04
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/src/redis-benchmark.c
// Function: ustime
static long long ustime(void) {
    struct timeval tv;
    long long ust;

    gettimeofday(&tv, NULL);
    ust = ((long)tv.tv_sec)*1000000;
    ust += tv.tv_usec;
    return ust;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb1e0
imulq $0xf4240, -0x10(%rbp), %rax # imm = 0xF4240
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/src/redis-benchmark.c
// Function: clientDone
static void clientDone(client c) {
    if (config.requests_finished == config.requests) {
        freeClient(c);
        aeStop(config.el);
        return;
    }
    if (config.keepalive) {
        resetClient(c);
    } else {
        config.liveclients--;
        createMissingClients(c);
        config.liveclients++;
        freeClient(c);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x933b6(%rip), %eax     # 0xa3448
cmpl 0x933a8(%rip), %eax     # 0xa3440
jne 0x100b1
movq -0x8(%rbp), %rdi
callq 0xfc10
movq 0x9336e(%rip), %rdi     # 0xa3418
callq 0xbad0
jmp 0x100f5
cmpl $0x0, 0x933a4(%rip)     # 0xa345c
je 0x100c5
movq -0x8(%rbp), %rdi
callq 0x10100
jmp 0x100f5
movl 0x93371(%rip), %eax     # 0xa343c
addl $-0x1, %eax
movl %eax, 0x93368(%rip)     # 0xa343c
movq -0x8(%rbp), %rdi
callq 0xf8e0
movl 0x93359(%rip), %eax     # 0xa343c
addl $0x1, %eax
movl %eax, 0x93350(%rip)     # 0xa343c
movq -0x8(%rbp), %rdi
callq 0xfc10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/src/redis-benchmark.c
// Function: resetClient
static void resetClient(client c) {
    aeDeleteFileEvent(config.el,c->context->fd,AE_WRITABLE);
    aeDeleteFileEvent(config.el,c->context->fd,AE_READABLE);
    aeCreateFileEvent(config.el,c->context->fd,AE_WRITABLE,writeHandler,c);
    c->written = 0;
    c->pending = config.pipeline;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x93305(%rip), %rdi     # 0xa3418
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x84(%rax), %esi
movl $0x2, %edx
callq 0xbcb0
movq 0x932e7(%rip), %rdi     # 0xa3418
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x84(%rax), %esi
movl $0x1, %edx
callq 0xbcb0
movq 0x932c9(%rip), %rdi     # 0xa3418
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x84(%rax), %esi
movq -0x8(%rbp), %r8
movl $0x2, %edx
leaq -0x70c(%rip), %rcx      # 0xfa60
callq 0xbaf0
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movl 0x932dd(%rip), %ecx     # 0xa3460
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/src/redis-benchmark.c
// Function: freeAllClients
static void freeAllClients(void) {
    listNode *ln = config.clients->head, *next;

    while(ln) {
        next = ln->next;
        freeClient(ln->value);
        ln = next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x930c9(%rip), %rax     # 0xa3488
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x103f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xfc10
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x103c6
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x8967e(%rip), %rsi     # 0xa3528
callq 0x19ee0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x19f30
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x8965e(%rip), %rsi     # 0xa3528
callq 0x19fd0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
jmp 0x19f41
cmpl $0xffe, -0x14(%rbp)     # imm = 0xFFE
jbe 0x19f54
movq $0x0, -0x8(%rbp)
jmp 0x19fb8
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x19e40
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jne 0x19f6d
callq 0x39ca0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x1a080
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x19f94
jmp 0x19f88
jmp 0x19f8a
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19fb8
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x43590
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x39cc0
movq -0x20(%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/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movl %edx, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
xorl %edx, %edx
callq 0x1a080
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x30(%rbp), %esi
xorl %edx, %edx
callq 0x1a080
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x434f0
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x434b0
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
jmp 0x1a098
movq 0x894f1(%rip), %rax     # 0xa3590
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x1a112
movq 0x894c6(%rip), %rdi     # 0xa3590
movl -0xc(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x39d60
movq %rax, -0x18(%rbp)
testb $0x1, -0xd(%rbp)
je 0x1a110
cmpq $0x0, -0x18(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x1a110
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x19e90
movq %rax, -0x18(%rbp)
jmp 0x1a112
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: arena_bind
static void
arena_bind(tsd_t *tsd, unsigned ind, bool internal)
{
	arena_t *arena;

	if (!tsd_nominal(tsd))
		return;

	arena = arena_get(tsd_tsdn(tsd), ind, false);
	arena_nthreads_inc(arena, internal);

	if (internal)
		tsd_iarena_set(tsd, arena);
	else
		tsd_arena_set(tsd, arena);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
andb $0x1, %al
movb %al, -0x35(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1a400
testb $0x1, %al
jne 0x1a7b5
jmp 0x1a820
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x34(%rbp), %esi
xorl %edx, %edx
callq 0x1a080
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x434b0
testb $0x1, -0x35(%rbp)
je 0x1a804
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x1a820
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_iarena_cleanup
void
iarena_cleanup(tsd_t *tsd)
{
	arena_t *iarena;

	iarena = tsd_iarena_get(tsd);
	if (iarena != NULL)
		arena_unbind(tsd, iarena->ind, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1a893
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
movl $0x1, %edx
callq 0x1a8a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: arena_unbind
static void
arena_unbind(tsd_t *tsd, unsigned ind, bool internal)
{
	arena_t *arena;

	arena = arena_get(tsd_tsdn(tsd), ind, false);
	arena_nthreads_dec(arena, internal);
	if (internal)
		tsd_iarena_set(tsd, NULL);
	else
		tsd_arena_set(tsd, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
andb $0x1, %al
movb %al, -0x35(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x34(%rbp), %esi
xorl %edx, %edx
callq 0x1a080
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x434f0
testb $0x1, -0x35(%rbp)
je 0x1a905
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x1a921
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_arena_cleanup
void
arena_cleanup(tsd_t *tsd)
{
	arena_t *arena;

	arena = tsd_arena_get(tsd);
	if (arena != NULL)
		arena_unbind(tsd, arena->ind, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1a970
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
xorl %edx, %edx
callq 0x1a8a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_arenas_tdata_cleanup
void
arenas_tdata_cleanup(tsd_t *tsd)
{
	arena_tdata_t *arenas_tdata;

	/* Prevent tsd->arenas_tdata from being (re)created. */
	*tsd_arenas_tdata_bypassp_get(tsd) = true;

	arenas_tdata = tsd_arenas_tdata_get(tsd);
	if (arenas_tdata != NULL) {
		tsd_arenas_tdata_set(tsd, NULL);
		a0dalloc(arenas_tdata);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x44(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1a9e4
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x38(%rbp), %rdi
callq 0x19280
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
leaq 0x6dc15(%rip), %rax     # 0xa4510
testb $0x1, (%rax)
jne 0x3690d
movq $0x0, -0x40(%rbp)
jmp 0x36a86
movb $0x0, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq 0x6c6d0(%rip), %rcx     # 0xa2ff0
movq %fs:0x0, %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x36952
xorl %eax, %eax
testb $0x1, %al
jne 0x3693e
jmp 0x36952
cmpq $0x0, -0x30(%rbp)
jne 0x36952
movq $0x0, -0x20(%rbp)
jmp 0x36a76
movq -0x30(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
testb $0x1, %al
jne 0x36965
jmp 0x36a6e
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x369e8
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x6c669(%rip), %rax     # 0xa2ff0
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x68, %edx
callq 0xb310
leaq 0x6db8c(%rip), %rax     # 0xa4534
movl (%rax), %edi
movq 0x6c63f(%rip), %rax     # 0xa2ff0
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0xb590
cmpl $0x0, %eax
je 0x369e3
leaq 0x5a4ac(%rip), %rdi     # 0x90e7a
callq 0x828c0
testb $0x1, 0x6cb26(%rip)     # 0xa3500
je 0x369e1
callq 0xb050
jmp 0x369e3
jmp 0x36a6c
movq -0x30(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x36a68
movq -0x30(%rbp), %rax
movl $0x3, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x6c5e6(%rip), %rax     # 0xa2ff0
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x68, %edx
callq 0xb310
leaq 0x6db09(%rip), %rax     # 0xa4534
movl (%rax), %edi
movq 0x6c5bc(%rip), %rax     # 0xa2ff0
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0xb590
cmpl $0x0, %eax
je 0x36a66
leaq 0x5a429(%rip), %rdi     # 0x90e7a
callq 0x828c0
testb $0x1, 0x6caa3(%rip)     # 0xa3500
je 0x36a64
callq 0xb050
jmp 0x36a66
jmp 0x36a6a
jmp 0x36a6a
jmp 0x36a6c
jmp 0x36a6e
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x28580
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x78940
movq -0x60(%rbp), %rdi
callq 0x28580
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_a0
static bool
malloc_init_hard_a0(void)
{
	bool ret;

	malloc_mutex_lock(TSDN_NULL, &init_lock);
	ret = malloc_init_hard_a0_locked();
	malloc_mutex_unlock(TSDN_NULL, &init_lock);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
leaq 0x6b1fd(%rip), %rsi     # 0xa3340
callq 0x19ee0
callq 0x38170
andb $0x1, %al
movb %al, -0x1(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x6b1e3(%rip), %rsi     # 0xa3340
callq 0x19fd0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_a0_locked
static bool
malloc_init_hard_a0_locked()
{

	malloc_initializer = INITIALIZER;

	if (config_prof)
		prof_boot0();
	malloc_conf_init();
	if (opt_stats_print) {
		/* Print statistics at exit. */
		if (atexit(stats_print_atexit) != 0) {
			malloc_write("<jemalloc>: Error in atexit()\n");
			if (opt_abort)
				abort();
		}
	}
	pages_boot();
	if (base_boot())
		return (true);
	if (chunk_boot())
		return (true);
	if (ctl_boot())
		return (true);
	if (config_prof)
		prof_boot1();
	arena_boot();
	if (config_tcache && tcache_boot(TSDN_NULL))
		return (true);
	if (malloc_mutex_init(&arenas_lock, "arenas", WITNESS_RANK_ARENAS))
		return (true);
	/*
	 * Create enough scaffolding to allow recursive allocation in
	 * malloc_ncpus().
	 */
	narenas_auto = 1;
	narenas_total_set(narenas_auto);
	arenas = &a0;
	memset(arenas, 0, sizeof(arena_t *) * narenas_auto);
	/*
	 * Initialize one arena here.  The rest are lazily created in
	 * arena_choose_hard().
	 */
	if (arena_init(TSDN_NULL, 0) == NULL)
		return (true);

	malloc_init_state = malloc_init_a0_initialized;

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb440
movq %rax, 0x6b414(%rip)     # 0xa3598
callq 0x382c0
leaq 0x6c338(%rip), %rax     # 0xa44c8
testb $0x1, (%rax)
je 0x381c4
leaq 0x1254(%rip), %rdi      # 0x393f0
callq 0x8d120
cmpl $0x0, %eax
je 0x381c2
leaq 0x58af4(%rip), %rdi     # 0x90ca1
callq 0x828c0
testb $0x1, 0x6b347(%rip)     # 0xa3500
je 0x381c0
callq 0xb050
jmp 0x381c2
jmp 0x381c4
callq 0x672c0
callq 0x50950
testb $0x1, %al
jne 0x381d4
jmp 0x381dd
movb $0x1, -0x1(%rbp)
jmp 0x382a8
callq 0x52ca0
testb $0x1, %al
jne 0x381e8
jmp 0x381f1
movb $0x1, -0x1(%rbp)
jmp 0x382a8
callq 0x54540
testb $0x1, %al
jne 0x381fc
jmp 0x38205
movb $0x1, -0x1(%rbp)
jmp 0x382a8
callq 0x439b0
xorl %eax, %eax
movl %eax, %edi
callq 0x81bc0
testb $0x1, %al
jne 0x38219
jmp 0x38222
movb $0x1, -0x1(%rbp)
jmp 0x382a8
leaq 0x6b2ff(%rip), %rdi     # 0xa3528
leaq 0x5a298(%rip), %rsi     # 0x924c8
movl $0x2, %edx
callq 0x66ad0
testb $0x1, %al
jne 0x38240
jmp 0x38246
movb $0x1, -0x1(%rbp)
jmp 0x382a8
movl $0x1, 0x6b328(%rip)     # 0xa3578
movl 0x6b322(%rip), %edi     # 0xa3578
callq 0x39670
leaq 0x6b2b6(%rip), %rax     # 0xa3518
movq %rax, 0x6b327(%rip)     # 0xa3590
movq 0x6b320(%rip), %rdi     # 0xa3590
movl 0x6b302(%rip), %eax     # 0xa3578
movl %eax, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0xb210
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
callq 0x19e90
cmpq $0x0, %rax
jne 0x3829a
movb $0x1, -0x1(%rbp)
jmp 0x382a8
movl $0x2, 0x6b098(%rip)     # 0xa333c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/atomic.h
// Function: je_atomic_write_uint32
JEMALLOC_INLINE void
atomic_write_uint32(uint32_t *p, uint32_t x)
{

	asm volatile (
	    "xchgl %1, %0;" /* Lock is implied by xchgl. */
	    : "=m" (*p), "+r" (x) /* Outputs. */
	    : "m" (*p) /* Inputs. */
	    : "memory" /* Clobbers. */
	    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rdx
xchgl %eax, (%rcx)
movl %eax, -0xc(%rbp)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_arena_choose_impl
JEMALLOC_INLINE arena_t *
arena_choose_impl(tsd_t *tsd, arena_t *arena, bool internal)
{
	arena_t *ret;

	if (arena != NULL)
		return (arena);

	ret = internal ? tsd_iarena_get(tsd) : tsd_arena_get(tsd);
	if (unlikely(ret == NULL))
		ret = arena_choose_hard(tsd, internal);

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
andb $0x1, %al
movb %al, -0x39(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x39968
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x399e6
testb $0x1, -0x39(%rbp)
je 0x3998c
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x399a8
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x399de
movq -0x30(%rbp), %rdi
movb -0x39(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1a460
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/ticker.h
// Function: je_ticker_ticks
JEMALLOC_INLINE bool
ticker_ticks(ticker_t *ticker, int32_t nticks)
{

	if (unlikely(ticker->tick < nticks)) {
		ticker->tick = ticker->nticks;
		return (true);
	}
	ticker->tick -= nticks;
	return(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
setl %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x39a5b
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x39a6c
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_size2index_compute
JEMALLOC_INLINE szind_t
size2index_compute(size_t size)
{

	if (unlikely(size > HUGE_MAXCLASS))
		return (NSIZES);
#if (NTBINS != 0)
	if (size <= (ZU(1) << LG_TINY_MAXCLASS)) {
		szind_t lg_tmin = LG_TINY_MAXCLASS - NTBINS + 1;
		szind_t lg_ceil = lg_floor(pow2_ceil_zu(size));
		return (lg_ceil < lg_tmin ? 0 : lg_ceil - lg_tmin);
	}
#endif
	{
		szind_t x = lg_floor((size<<1)-1);
		szind_t shift = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM) ? 0 :
		    x - (LG_SIZE_CLASS_GROUP + LG_QUANTUM);
		szind_t grp = shift << LG_SIZE_CLASS_GROUP;

		szind_t lg_delta = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM + 1)
		    ? LG_QUANTUM : x - LG_SIZE_CLASS_GROUP - 1;

		size_t delta_inverse_mask = ZI(-1) << lg_delta;
		szind_t mod = ((((size-1) & delta_inverse_mask) >> lg_delta)) &
		    ((ZU(1) << LG_SIZE_CLASS_GROUP) - 1);

		szind_t index = NTBINS + grp + mod;
		return (index);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movabsq $0x7000000000000000, %rax # imm = 0x7000000000000000
cmpq %rax, -0x10(%rbp)
seta %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x39b2a
movl $0xeb, -0x4(%rbp)
jmp 0x39bc2
movq -0x10(%rbp), %rdi
shlq %rdi
subq $0x1, %rdi
callq 0x39bd0
movl %eax, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jae 0x39b4a
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x39b53
movl -0x14(%rbp), %eax
subl $0x5, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x6, -0x14(%rbp)
jae 0x39b72
movl $0x3, %eax
movl %eax, -0x38(%rbp)
jmp 0x39b7e
movl -0x14(%rbp), %eax
subl $0x2, %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
movq $-0x1, %rax
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
andq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
shrq %cl, %rax
andq $0x3, %rax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x0, %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard
static bool
malloc_init_hard(void)
{
	tsd_t *tsd;

#if defined(_WIN32) && _WIN32_WINNT < 0x0600
	_init_init_lock();
#endif
	malloc_mutex_lock(TSDN_NULL, &init_lock);
	if (!malloc_init_hard_needed()) {
		malloc_mutex_unlock(TSDN_NULL, &init_lock);
		return (false);
	}

	if (malloc_init_state != malloc_init_a0_initialized &&
	    malloc_init_hard_a0_locked()) {
		malloc_mutex_unlock(TSDN_NULL, &init_lock);
		return (true);
	}

	malloc_mutex_unlock(TSDN_NULL, &init_lock);
	/* Recursive allocation relies on functional tsd. */
	tsd = malloc_tsd_boot0();
	if (tsd == NULL)
		return (true);
	if (malloc_init_hard_recursible())
		return (true);
	malloc_mutex_lock(tsd_tsdn(tsd), &init_lock);

	if (config_prof && prof_boot2(tsd)) {
		malloc_mutex_unlock(tsd_tsdn(tsd), &init_lock);
		return (true);
	}

	if (malloc_init_hard_finish(tsd_tsdn(tsd))) {
		malloc_mutex_unlock(tsd_tsdn(tsd), &init_lock);
		return (true);
	}

	malloc_mutex_unlock(tsd_tsdn(tsd), &init_lock);
	malloc_tsd_boot1();
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
movl %eax, %edi
leaq 0x6959d(%rip), %rsi     # 0xa3340
callq 0x19ee0
callq 0x39eb0
testb $0x1, %al
jne 0x39dca
xorl %eax, %eax
movl %eax, %edi
leaq 0x69584(%rip), %rsi     # 0xa3340
callq 0x19fd0
movb $0x0, -0x21(%rbp)
jmp 0x39e9c
cmpl $0x2, 0x6956b(%rip)     # 0xa333c
je 0x39df7
callq 0x38170
testb $0x1, %al
jne 0x39dde
jmp 0x39df7
xorl %eax, %eax
movl %eax, %edi
leaq 0x69557(%rip), %rsi     # 0xa3340
callq 0x19fd0
movb $0x1, -0x21(%rbp)
jmp 0x39e9c
xorl %eax, %eax
movl %eax, %edi
leaq 0x6953e(%rip), %rsi     # 0xa3340
callq 0x19fd0
callq 0x82560
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x39e1d
movb $0x1, -0x21(%rbp)
jmp 0x39e9c
callq 0x39f70
testb $0x1, %al
jne 0x39e28
jmp 0x39e2e
movb $0x1, -0x21(%rbp)
jmp 0x39e9c
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x694ff(%rip), %rsi     # 0xa3340
callq 0x19ee0
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39fe0
testb $0x1, %al
jne 0x39e5d
jmp 0x39e7b
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x694d0(%rip), %rsi     # 0xa3340
callq 0x19fd0
movb $0x1, -0x21(%rbp)
jmp 0x39e9c
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x694b2(%rip), %rsi     # 0xa3340
callq 0x19fd0
callq 0x82740
movb $0x0, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_needed
static bool
malloc_init_hard_needed(void)
{

	if (malloc_initialized() || (IS_INITIALIZER && malloc_init_state ==
	    malloc_init_recursible)) {
		/*
		 * Another thread initialized the allocator before this one
		 * acquired init_lock, or this thread is the initializing
		 * thread, and it is recursively allocating.
		 */
		return (false);
	}
#ifdef JEMALLOC_THREADED_INIT
	if (malloc_initializer != NO_INITIALIZER && !IS_INITIALIZER) {
		spin_t spinner;

		/* Busy-wait until the initializing thread completes. */
		spin_init(&spinner);
		do {
			malloc_mutex_unlock(TSDN_NULL, &init_lock);
			spin_adaptive(&spinner);
			malloc_mutex_lock(TSDN_NULL, &init_lock);
		} while (!malloc_initialized());
		return (false);
	}
#endif
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x6947d(%rip)     # 0xa333c
je 0x39ee6
movq 0x696d0(%rip), %rax     # 0xa3598
movq %rax, -0x10(%rbp)
callq 0xb440
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jne 0x39eec
cmpl $0x1, 0x69458(%rip)     # 0xa333c
jne 0x39eec
movb $0x0, -0x1(%rbp)
jmp 0x39f5e
cmpq $0x0, 0x696a4(%rip)     # 0xa3598
je 0x39f5a
movq 0x6969b(%rip), %rax     # 0xa3598
movq %rax, -0x18(%rbp)
callq 0xb440
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
je 0x39f5a
leaq -0x8(%rbp), %rdi
callq 0x3a0d0
xorl %eax, %eax
movl %eax, %edi
leaq 0x6941a(%rip), %rsi     # 0xa3340
callq 0x19fd0
leaq -0x8(%rbp), %rdi
callq 0x3a0f0
xorl %eax, %eax
movl %eax, %edi
leaq 0x69401(%rip), %rsi     # 0xa3340
callq 0x19ee0
cmpl $0x0, 0x693f1(%rip)     # 0xa333c
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x39f1b
movb $0x0, -0x1(%rbp)
jmp 0x39f5e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_recursible
static bool
malloc_init_hard_recursible(void)
{

	malloc_init_state = malloc_init_recursible;

	ncpus = malloc_ncpus();

#if (defined(JEMALLOC_HAVE_PTHREAD_ATFORK) && !defined(JEMALLOC_MUTEX_INIT_CB) \
    && !defined(JEMALLOC_ZONE) && !defined(_WIN32) && \
    !defined(__native_client__))
	/* LinuxThreads' pthread_atfork() allocates. */
	if (pthread_atfork(jemalloc_prefork, jemalloc_postfork_parent,
	    jemalloc_postfork_child) != 0) {
		malloc_write("<jemalloc>: Error in pthread_atfork()\n");
		if (opt_abort)
			abort();
		return (true);
	}
#endif

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, 0x693ba(%rip)     # 0xa333c
callq 0x3a140
movl %eax, 0x695fb(%rip)     # 0xa3588
leaq -0x2bf4(%rip), %rdi     # 0x373a0
leaq -0x285b(%rip), %rsi     # 0x37740
leaq -0x2622(%rip), %rdx     # 0x37980
callq 0x8d140
cmpl $0x0, %eax
je 0x39fcc
leaq 0x56eeb(%rip), %rdi     # 0x90e9e
callq 0x828c0
testb $0x1, 0x69541(%rip)     # 0xa3500
je 0x39fc6
callq 0xb050
movb $0x1, -0x1(%rbp)
jmp 0x39fd0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_finish
static bool
malloc_init_hard_finish(tsdn_t *tsdn)
{

	if (malloc_mutex_boot())
		return (true);

	if (opt_narenas == 0) {
		/*
		 * For SMP systems, create more than one arena per CPU by
		 * default.
		 */
		if (ncpus > 1)
			opt_narenas = ncpus << 2;
		else
			opt_narenas = 1;
	}
	narenas_auto = opt_narenas;
	/*
	 * Limit the number of arenas to the indexing range of MALLOCX_ARENA().
	 */
	if (narenas_auto > MALLOCX_ARENA_MAX) {
		narenas_auto = MALLOCX_ARENA_MAX;
		malloc_printf("<jemalloc>: Reducing narenas to limit (%d)\n",
		    narenas_auto);
	}
	narenas_total_set(narenas_auto);

	/* Allocate and initialize arenas. */
	arenas = (arena_t **)base_alloc(tsdn, sizeof(arena_t *) *
	    (MALLOCX_ARENA_MAX+1));
	if (arenas == NULL)
		return (true);
	/* Copy the pointer to the one arena that was already initialized. */
	arena_set(0, a0);

	malloc_init_state = malloc_init_initialized;
	malloc_slow_flag_init();

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
callq 0x66c80
testb $0x1, %al
jne 0x39ff7
jmp 0x3a000
movb $0x1, -0x1(%rbp)
jmp 0x3a0b6
cmpl $0x0, 0x6950d(%rip)     # 0xa3514
jne 0x3a02f
cmpl $0x1, 0x69578(%rip)     # 0xa3588
jbe 0x3a023
movl 0x69570(%rip), %eax     # 0xa3588
shll $0x2, %eax
movl %eax, 0x694f3(%rip)     # 0xa3514
jmp 0x3a02d
movl $0x1, 0x694e7(%rip)     # 0xa3514
jmp 0x3a02f
movl 0x694df(%rip), %eax     # 0xa3514
movl %eax, 0x6953d(%rip)     # 0xa3578
cmpl $0xffe, 0x69533(%rip)   # imm = 0xFFE
jbe 0x3a065
movl $0xffe, 0x69527(%rip)   # imm = 0xFFE
movl 0x69521(%rip), %esi     # 0xa3578
leaq 0x56e67(%rip), %rdi     # 0x90ec5
movb $0x0, %al
callq 0x85c20
movl 0x6950d(%rip), %edi     # 0xa3578
callq 0x39670
movq -0x10(%rbp), %rdi
movl $0x7ff8, %esi           # imm = 0x7FF8
callq 0x50230
movq %rax, 0x6950b(%rip)     # 0xa3590
cmpq $0x0, 0x69503(%rip)     # 0xa3590
jne 0x3a095
movb $0x1, -0x1(%rbp)
jmp 0x3a0b6
movq 0x6947c(%rip), %rsi     # 0xa3518
xorl %edi, %edi
callq 0x39cc0
movl $0x0, 0x6928f(%rip)     # 0xa333c
callq 0x3a180
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)