LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: getCursorPosition
static int getCursorPosition(int ifd, int ofd) {
    char buf[32];
    int cols, rows;
    unsigned int i = 0;

    /* Report cursor location */
    if (write(ofd, "\x1b[6n", 4) != 4) return -1;

    /* Read the response: ESC [ rows ; cols R */
    while (i < sizeof(buf)-1) {
        if (read(ifd,buf+i,1) != 1) break;
        if (buf[i] == 'R') break;
        i++;
    }
    buf[i] = '\0';

    /* Parse it. */
    if (buf[0] != ESC || buf[1] != '[') return -1;
    if (sscanf(buf+2,"%d;%d",&rows,&cols) != 2) return -1;
    return cols;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0xc(%rbp), %edi
leaq 0x69d9d(%rip), %rsi     # 0x8e2dc
movl $0x4, %edx
callq 0x10150
cmpq $0x4, %rax
je 0x2455b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x245f4
jmp 0x2455d
movl -0x3c(%rbp), %eax
cmpq $0x1f, %rax
jae 0x2459f
movl -0x8(%rbp), %edi
leaq -0x30(%rbp), %rsi
movl -0x3c(%rbp), %eax
addq %rax, %rsi
movl $0x1, %edx
callq 0x102b0
cmpq $0x1, %rax
je 0x24585
jmp 0x2459f
movl -0x3c(%rbp), %eax
movsbl -0x30(%rbp,%rax), %eax
cmpl $0x52, %eax
jne 0x24594
jmp 0x2459f
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2455d
movl -0x3c(%rbp), %eax
movb $0x0, -0x30(%rbp,%rax)
movsbl -0x30(%rbp), %eax
cmpl $0x1b, %eax
jne 0x245b9
movsbl -0x2f(%rbp), %eax
cmpl $0x5b, %eax
je 0x245c2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x245f4
leaq -0x30(%rbp), %rdi
addq $0x2, %rdi
leaq 0x69d10(%rip), %rsi     # 0x8e2e1
leaq -0x38(%rbp), %rdx
leaq -0x34(%rbp), %rcx
movb $0x0, %al
callq 0x10440
cmpl $0x2, %eax
je 0x245ee
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x245f4
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: freeCompletions
static void freeCompletions(linenoiseCompletions *lc) {
    size_t i;
    for (i = 0; i < lc->len; i++)
        free(lc->cvec[i]);
    if (lc->cvec != NULL)
        free(lc->cvec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x24674
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10050
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x24644
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2468c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_bootstrap_calloc
void *
bootstrap_calloc(size_t num, size_t size)
{
	size_t num_size;

	num_size = num * size;
	if (unlikely(num_size == 0)) {
		assert(num == 0 || size == 0);
		num_size = 1;
	}

	return (a0ialloc(num_size, true, false));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
imulq -0x10(%rbp), %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 0x25d92
jmp 0x25d88
jmp 0x25d8a
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x246f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_arena_init
arena_t *
arena_init(unsigned ind)
{
	arena_t *arena;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x7b8c6(%rip), %rdi     # 0xa16c8
callq 0x25e30
movl -0x4(%rbp), %edi
callq 0x25e50
movq %rax, -0x10(%rbp)
leaq 0x7b8ae(%rip), %rdi     # 0xa16c8
callq 0x25f70
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: arena_init_locked
static arena_t *
arena_init_locked(unsigned ind)
{
	arena_t *arena;

	/* Expand arenas if necessary. */
	assert(ind <= narenas_total);
	if (ind > MALLOCX_ARENA_MAX)
		return (NULL);
	if (ind == narenas_total) {
		unsigned narenas_new = narenas_total + 1;
		arena_t **arenas_new =
		    (arena_t **)a0malloc(CACHELINE_CEILING(narenas_new *
		    sizeof(arena_t *)));
		if (arenas_new == NULL)
			return (NULL);
		memcpy(arenas_new, arenas, narenas_total * sizeof(arena_t *));
		arenas_new[ind] = NULL;
		/*
		 * Deallocate only if arenas came from a0malloc() (not
		 * base_alloc()).
		 */
		if (narenas_total != narenas_auto)
			a0dalloc(arenas);
		arenas = arenas_new;
		narenas_total = narenas_new;
	}

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

	/* Actually initialize the arena. */
	arena = arenas[ind] = arena_new(ind);
	return (arena);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
jmp 0x25e5d
cmpl $0xffe, -0xc(%rbp)      # imm = 0xFFE
jbe 0x25e73
movq $0x0, -0x8(%rbp)
jmp 0x25f5e
movl -0xc(%rbp), %eax
cmpl 0x7b874(%rip), %eax     # 0xa16f0
jne 0x25f15
movl 0x7b868(%rip), %eax     # 0xa16f0
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
addq $0x3f, %rdi
andq $-0x40, %rdi
callq 0x246c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x25ebc
movq $0x0, -0x8(%rbp)
jmp 0x25f5e
movq -0x28(%rbp), %rdi
movq 0x7b831(%rip), %rsi     # 0xa16f8
movl 0x7b823(%rip), %eax     # 0xa16f0
movl %eax, %edx
shlq $0x3, %rdx
callq 0x103b0
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl 0x7b803(%rip), %eax     # 0xa16f0
cmpl 0x7b80d(%rip), %eax     # 0xa1700
je 0x25f01
movq 0x7b7fc(%rip), %rdi     # 0xa16f8
callq 0x25330
movq -0x28(%rbp), %rax
movq %rax, 0x7b7ec(%rip)     # 0xa16f8
movl -0x1c(%rbp), %eax
movl %eax, 0x7b7db(%rip)     # 0xa16f0
movq 0x7b7dc(%rip), %rax     # 0xa16f8
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x25f3c
jmp 0x25f30
jmp 0x25f32
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x25f5e
movl -0xc(%rbp), %edi
callq 0x43250
movq 0x7b7ad(%rip), %rcx     # 0xa16f8
movl -0xc(%rbp), %edx
movq %rax, (%rcx,%rdx,8)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_narenas_total_get
unsigned
narenas_total_get(void)
{
	unsigned narenas;

	malloc_mutex_lock(&arenas_lock);
	narenas = narenas_total;
	malloc_mutex_unlock(&arenas_lock);

	return (narenas);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x7b729(%rip), %rdi     # 0xa16c8
callq 0x25e30
movl 0x7b746(%rip), %eax     # 0xa16f0
movl %eax, -0x4(%rbp)
leaq 0x7b714(%rip), %rdi     # 0xa16c8
callq 0x25f70
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_arena_migrate
void
arena_migrate(tsd_t *tsd, unsigned oldind, unsigned newind)
{
	arena_t *oldarena, *newarena;

	malloc_mutex_lock(&arenas_lock);
	oldarena = arenas[oldind];
	newarena = arenas[newind];
	oldarena->nthreads--;
	newarena->nthreads++;
	malloc_mutex_unlock(&arenas_lock);
	tsd_arena_set(tsd, newarena);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
leaq 0x7b6df(%rip), %rdi     # 0xa16c8
callq 0x25e30
movq 0x7b703(%rip), %rax     # 0xa16f8
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq 0x7b6f1(%rip), %rax     # 0xa16f8
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
leaq 0x7b695(%rip), %rdi     # 0xa16c8
callq 0x25f70
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_arena_nbound
unsigned
arena_nbound(unsigned ind)
{
	unsigned nthreads;

	malloc_mutex_lock(&arenas_lock);
	nthreads = arenas[ind]->nthreads;
	malloc_mutex_unlock(&arenas_lock);
	return (nthreads);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x7b656(%rip), %rdi     # 0xa16c8
callq 0x25e30
movq 0x7b67a(%rip), %rax     # 0xa16f8
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %eax
movl %eax, -0x8(%rbp)
leaq 0x7b636(%rip), %rdi     # 0xa16c8
callq 0x25f70
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: arena_bind_locked
static void
arena_bind_locked(tsd_t *tsd, unsigned ind)
{
	arena_t *arena;

	arena = arenas[ind];
	arena->nthreads++;

	if (tsd_nominal(tsd))
		tsd_arena_set(tsd, arena);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq 0x7b1f2(%rip), %rax     # 0xa16f8
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rdi
callq 0x26380
testb $0x1, %al
jne 0x2652d
jmp 0x26549
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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);
}

// 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 0x265ee
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x26600
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: arena_unbind
static void
arena_unbind(tsd_t *tsd, unsigned ind)
{
	arena_t *arena;

	malloc_mutex_lock(&arenas_lock);
	arena = arenas[ind];
	arena->nthreads--;
	malloc_mutex_unlock(&arenas_lock);
	tsd_arena_set(tsd, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
leaq 0x7b0b2(%rip), %rdi     # 0xa16c8
callq 0x25e30
movq 0x7b0d6(%rip), %rax     # 0xa16f8
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
leaq 0x7b087(%rip), %rdi     # 0xa16c8
callq 0x25f70
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_arenas_cache_cleanup
void
arenas_cache_cleanup(tsd_t *tsd)
{
	arena_t **arenas_cache;

	arenas_cache = tsd_arenas_cache_get(tsd);
	if (arenas_cache != NULL) {
		tsd_arenas_cache_set(tsd, NULL);
		a0dalloc(arenas_cache);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x266c4
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rdi
callq 0x25330
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_u2rz
JEMALLOC_INLINE size_t
u2rz(size_t usize)
{
	size_t ret;

	if (usize <= SMALL_MAXCLASS) {
		szind_t binind = size2index(usize);
		ret = arena_bin_info[binind].redzone_size;
	} else
		ret = 0;

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
cmpq $0x3800, -0x28(%rbp)    # imm = 0x3800
ja 0x2f73a
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1000, -0x20(%rbp)    # imm = 0x1000
setbe %al
testb $0x1, %al
jne 0x2f6df
jmp 0x2f70b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
shrq $0x3, %rcx
leaq 0x5f586(%rip), %rax     # 0x8ec80
movzbl (%rax,%rcx), %eax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x14(%rbp)
jmp 0x2f717
movq -0x20(%rbp), %rdi
callq 0x3ba60
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %ecx
leaq 0x71ff7(%rip), %rax     # 0xa1720
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2f742
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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();
		ifree(tsd, ptr, tcache_get(tsd, false));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2f95e
movq 0x6f865(%rip), %rcx     # 0x9efe8
movq %fs:0x0, %rax
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
testb $0x1, %al
jne 0x2f7a6
jmp 0x2f8af
movq -0x58(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2f829
movq -0x58(%rbp), %rax
movl $0x1, (%rax)
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x6f820(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x30(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x7372b(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x6f7f6(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x2f824
leaq 0x5f82a(%rip), %rdi     # 0x8f039
callq 0x7c0e0
testb $0x1, 0x71e85(%rip)     # 0xa16a0
je 0x2f822
callq 0x10070
jmp 0x2f824
jmp 0x2f8ad
movq -0x58(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x2f8a9
movq -0x58(%rbp), %rax
movl $0x3, (%rax)
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x6f79d(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x28(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x736a8(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x6f773(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x2f8a7
leaq 0x5f7a7(%rip), %rdi     # 0x8f039
callq 0x7c0e0
testb $0x1, 0x71e02(%rip)     # 0xa16a0
je 0x2f8a5
callq 0x10070
jmp 0x2f8a7
jmp 0x2f8ab
jmp 0x2f8ab
jmp 0x2f8ad
jmp 0x2f8af
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x41(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x2f8ff
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x2f94d
cmpq $0x0, -0x50(%rbp)
sete %al
testb $0x1, %al
jne 0x2f90d
jmp 0x2f945
movq -0x40(%rbp), %rdi
callq 0x26380
testb $0x1, %al
jne 0x2f91c
jmp 0x2f945
movq -0x40(%rbp), %rdi
callq 0x79eb0
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
movq -0x38(%rbp), %rdx
callq 0x2e940
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_arena_get
JEMALLOC_INLINE arena_t *
arena_get(tsd_t *tsd, unsigned ind, bool init_if_missing,
    bool refresh_if_missing)
{
	arena_t *arena;
	arena_t **arenas_cache = tsd_arenas_cache_get(tsd);

	/* init_if_missing requires refresh_if_missing. */
	assert(!init_if_missing || refresh_if_missing);

	if (unlikely(arenas_cache == NULL)) {
		/* arenas_cache hasn't been initialized yet. */
		return (arena_get_hard(tsd, ind, init_if_missing));
	}
	if (unlikely(ind >= tsd_narenas_cache_get(tsd))) {
		/*
		 * ind is invalid, cache is old (too small), or arena to be
		 * initialized.
		 */
		return (refresh_if_missing ? arena_get_hard(tsd, ind,
		    init_if_missing) : NULL);
	}
	arena = arenas_cache[ind];
	if (likely(arena != NULL) || !refresh_if_missing)
		return (arena);
	return (arena_get_hard(tsd, ind, init_if_missing));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
andb $0x1, %cl
movb %cl, -0x35(%rbp)
andb $0x1, %al
movb %al, -0x36(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x365cc
cmpq $0x0, -0x48(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x36602
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x260a0
movq %rax, -0x28(%rbp)
jmp 0x366b2
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
setae %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x36662
testb $0x1, -0x36(%rbp)
je 0x36650
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x260a0
movq %rax, -0x50(%rbp)
jmp 0x36658
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x36658
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x366b2
movq -0x48(%rbp), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x36690
testb $0x1, -0x36(%rbp)
jne 0x3669a
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x366b2
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x260a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_jemalloc_prefork
void
jemalloc_prefork(void)
#else
JEMALLOC_EXPORT void
_malloc_prefork(void)
#endif
{
	unsigned i;

#ifdef JEMALLOC_MUTEX_INIT_CB
	if (!malloc_initialized())
		return;
#endif
	assert(malloc_initialized());

	/* Acquire all mutexes in a safe order. */
	ctl_prefork();
	prof_prefork();
	malloc_mutex_prefork(&arenas_lock);
	for (i = 0; i < narenas_total; i++) {
		if (arenas[i] != NULL)
			arena_prefork(arenas[i]);
	}
	chunk_prefork();
	base_prefork();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0x3a4ca
callq 0x53110
callq 0x69340
leaq 0x671ed(%rip), %rdi     # 0xa16c8
callq 0x643d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x67200(%rip), %eax     # 0xa16f0
jae 0x3a523
movq 0x671ff(%rip), %rax     # 0xa16f8
movl -0x4(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x3a516
movq 0x671ee(%rip), %rax     # 0xa16f8
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x44900
jmp 0x3a518
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3a4e7
callq 0x517e0
callq 0x4fa00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_jemalloc_postfork_parent
void
jemalloc_postfork_parent(void)
#else
JEMALLOC_EXPORT void
_malloc_postfork(void)
#endif
{
	unsigned i;

#ifdef JEMALLOC_MUTEX_INIT_CB
	if (!malloc_initialized())
		return;
#endif
	assert(malloc_initialized());

	/* Release all mutexes, now that fork() has completed. */
	base_postfork_parent();
	chunk_postfork_parent();
	for (i = 0; i < narenas_total; i++) {
		if (arenas[i] != NULL)
			arena_postfork_parent(arenas[i]);
	}
	malloc_mutex_postfork_parent(&arenas_lock);
	prof_postfork_parent();
	ctl_postfork_parent();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0x3a54a
callq 0x4fa20
callq 0x517f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x6718c(%rip), %eax     # 0xa16f0
jae 0x3a597
movq 0x6718b(%rip), %rax     # 0xa16f8
movl -0x4(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x3a58a
movq 0x6717a(%rip), %rax     # 0xa16f8
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x44990
jmp 0x3a58c
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3a55b
leaq 0x6712a(%rip), %rdi     # 0xa16c8
callq 0x64410
callq 0x693f0
callq 0x53130
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_jemalloc_postfork_child
void
jemalloc_postfork_child(void)
{
	unsigned i;

	assert(malloc_initialized());

	/* Release all mutexes, now that fork() has completed. */
	base_postfork_child();
	chunk_postfork_child();
	for (i = 0; i < narenas_total; i++) {
		if (arenas[i] != NULL)
			arena_postfork_child(arenas[i]);
	}
	malloc_mutex_postfork_child(&arenas_lock);
	prof_postfork_child();
	ctl_postfork_child();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0x3a5ca
callq 0x4fa40
callq 0x51800
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x6710c(%rip), %eax     # 0xa16f0
jae 0x3a617
movq 0x6710b(%rip), %rax     # 0xa16f8
movl -0x4(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x3a60a
movq 0x670fa(%rip), %rax     # 0xa16f8
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x44a20
jmp 0x3a60c
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3a5db
leaq 0x670aa(%rip), %rdi     # 0xa16c8
callq 0x64450
callq 0x694a0
callq 0x53150
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_a0
static bool
malloc_init_hard_a0(void)
{
	bool ret;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x66d91(%rip), %rdi     # 0xa13e0
callq 0x25e30
callq 0x3a680
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq 0x66d7b(%rip), %rdi     # 0xa13e0
callq 0x25f70
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_a0_locked
static bool
malloc_init_hard_a0_locked(void)
{

	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();
		}
	}
	if (base_boot())
		return (true);
	if (chunk_boot())
		return (true);
	if (ctl_boot())
		return (true);
	if (config_prof)
		prof_boot1();
	if (arena_boot())
		return (true);
	if (config_tcache && tcache_boot())
		return (true);
	if (malloc_mutex_init(&arenas_lock))
		return (true);
	/*
	 * Create enough scaffolding to allow recursive allocation in
	 * malloc_ncpus().
	 */
	narenas_total = narenas_auto = 1;
	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(0) == NULL)
		return (true);
	malloc_init_state = malloc_init_a0_initialized;
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x10520
movq %rax, 0x67084(%rip)     # 0xa1718
callq 0x3a7c0
leaq 0x687f8(%rip), %rax     # 0xa2e98
testb $0x1, (%rax)
je 0x3a6d4
leaq 0x1024(%rip), %rdi      # 0x3b6d0
callq 0x86750
cmpl $0x0, %eax
je 0x3a6d2
leaq 0x547c9(%rip), %rdi     # 0x8ee86
callq 0x7c0e0
testb $0x1, 0x66fd7(%rip)     # 0xa16a0
je 0x3a6d0
callq 0x10070
jmp 0x3a6d2
jmp 0x3a6d4
callq 0x4f9b0
testb $0x1, %al
jne 0x3a6df
jmp 0x3a6e8
movb $0x1, -0x1(%rbp)
jmp 0x3a7aa
callq 0x51710
testb $0x1, %al
jne 0x3a6f3
jmp 0x3a6fc
movb $0x1, -0x1(%rbp)
jmp 0x3a7aa
callq 0x530d0
testb $0x1, %al
jne 0x3a707
jmp 0x3a710
movb $0x1, -0x1(%rbp)
jmp 0x3a7aa
callq 0x436c0
testb $0x1, %al
jne 0x3a71b
jmp 0x3a724
movb $0x1, -0x1(%rbp)
jmp 0x3a7aa
callq 0x7bc90
testb $0x1, %al
jne 0x3a72f
jmp 0x3a735
movb $0x1, -0x1(%rbp)
jmp 0x3a7aa
leaq 0x66f8c(%rip), %rdi     # 0xa16c8
callq 0x64360
testb $0x1, %al
jne 0x3a747
jmp 0x3a74d
movb $0x1, -0x1(%rbp)
jmp 0x3a7aa
movl $0x1, 0x66fa9(%rip)     # 0xa1700
movl $0x1, 0x66f8f(%rip)     # 0xa16f0
leaq 0x66f58(%rip), %rax     # 0xa16c0
movq %rax, 0x66f89(%rip)     # 0xa16f8
movq 0x66f82(%rip), %rdi     # 0xa16f8
movl 0x66f84(%rip), %eax     # 0xa1700
movl %eax, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x10250
xorl %edi, %edi
callq 0x25df0
cmpq $0x0, %rax
jne 0x3a79c
movb $0x1, -0x1(%rbp)
jmp 0x3a7aa
movl $0x2, 0x66c32(%rip)     # 0xa13d8
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/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: stats_print_atexit
static void
stats_print_atexit(void)
{

	if (config_tcache && config_stats) {
		unsigned narenas, i;

		/*
		 * Merge stats from extant threads.  This is racy, since
		 * individual threads do not lock when recording tcache stats
		 * events.  As a consequence, the final stats may be slightly
		 * out of date by the time they are reported, if other threads
		 * continue to allocate.
		 */
		for (i = 0, narenas = narenas_total_get(); i < narenas; i++) {
			arena_t *arena = arenas[i];
			if (arena != NULL) {
				tcache_t *tcache;

				/*
				 * tcache_stats_merge() locks bins, so if any
				 * code is introduced that acquires both arena
				 * and bin locks in the opposite order,
				 * deadlocks may result.
				 */
				malloc_mutex_lock(&arena->lock);
				ql_foreach(tcache, &arena->tcache_ql, link) {
					tcache_stats_merge(tcache, arena);
				}
				malloc_mutex_unlock(&arena->lock);
			}
		}
	}
	je_malloc_stats_print(NULL, NULL, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x8(%rbp)
callq 0x25f90
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x3b78c
movq 0x65ffe(%rip), %rax     # 0xa16f8
movl -0x8(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3b77c
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x25e30
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3b76f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x79d90
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xa8(%rcx), %rax
je 0x3b75d
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3b765
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x3b765
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3b728
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x25f70
jmp 0x3b77e
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3b6e7
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
movq %rdx, %rsi
callq 0x39e80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_arena_choose
JEMALLOC_INLINE arena_t *
arena_choose(tsd_t *tsd, arena_t *arena)
{
	arena_t *ret;

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

	if (unlikely((ret = tsd_arena_get(tsd)) == NULL))
		ret = arena_choose_hard(tsd);

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3ba01
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3ba4a
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3ba42
movq -0x20(%rbp), %rdi
callq 0x263a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_size2index_compute
JEMALLOC_INLINE szind_t
size2index_compute(size_t size)
{

#if (NTBINS != 0)
	if (size <= (ZU(1) << LG_TINY_MAXCLASS)) {
		size_t lg_tmin = LG_TINY_MAXCLASS - NTBINS + 1;
		size_t lg_ceil = lg_floor(pow2_ceil(size));
		return (lg_ceil < lg_tmin ? 0 : lg_ceil - lg_tmin);
	}
#endif
	{
		size_t x = unlikely(ZI(size) < 0) ? ((size<<1) ?
		    (ZU(1)<<(LG_SIZEOF_PTR+3)) : ((ZU(1)<<(LG_SIZEOF_PTR+3))-1))
		    : lg_floor((size<<1)-1);
		size_t shift = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM) ? 0 :
		    x - (LG_SIZE_CLASS_GROUP + LG_QUANTUM);
		size_t grp = shift << LG_SIZE_CLASS_GROUP;

		size_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;
		size_t mod = ((((size-1) & delta_inverse_mask) >> lg_delta)) &
		    ((ZU(1) << LG_SIZE_CLASS_GROUP) - 1);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
setl %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3baa4
movq -0x8(%rbp), %rdx
shlq %rdx
movl $0x3f, %eax
movl $0x40, %ecx
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, -0x48(%rbp)
jmp 0x3bab8
movq -0x8(%rbp), %rdi
shlq %rdi
subq $0x1, %rdi
callq 0x3bb60
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x5, -0x10(%rbp)
jae 0x3bacf
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x3badb
movq -0x10(%rbp), %rax
subq $0x5, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x20(%rbp)
cmpq $0x6, -0x10(%rbp)
jae 0x3bb01
movl $0x3, %eax
movq %rax, -0x58(%rbp)
jmp 0x3bb11
movq -0x10(%rbp), %rax
subq $0x2, %rax
subq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq $-0x1, %rax
shlq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
subq $0x1, %rax
andq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
shrq %cl, %rax
andq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq $0x0, %rax
addq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/atomic.h
// Function: je_atomic_add_uint64
JEMALLOC_INLINE uint64_t
atomic_add_uint64(uint64_t *p, uint64_t x)
{
	uint64_t t = x;

	asm volatile (
	    "lock; xaddq %0, %1;"
	    : "+r" (t), "=m" (*p) /* Outputs. */
	    : "m" (*p) /* Inputs. */
	    );

	return (t + x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rdx
lock
xaddq %rax, (%rcx)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard
static bool
malloc_init_hard(void)
{

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

	if (malloc_init_state != malloc_init_a0_initialized &&
	    malloc_init_hard_a0_locked()) {
		malloc_mutex_unlock(&init_lock);
		return (true);
	}
	if (malloc_tsd_boot0()) {
		malloc_mutex_unlock(&init_lock);
		return (true);
	}
	if (config_prof && prof_boot2()) {
		malloc_mutex_unlock(&init_lock);
		return (true);
	}

	malloc_init_hard_recursible();

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

	malloc_mutex_unlock(&init_lock);
	malloc_tsd_boot1();
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x65761(%rip), %rdi     # 0xa13e0
callq 0x25e30
callq 0x3bd30
testb $0x1, %al
jne 0x3bc9f
leaq 0x6574c(%rip), %rdi     # 0xa13e0
callq 0x25f70
movb $0x0, -0x1(%rbp)
jmp 0x3bd19
cmpl $0x2, 0x65732(%rip)     # 0xa13d8
je 0x3bcc5
callq 0x3a680
testb $0x1, %al
jne 0x3bcb3
jmp 0x3bcc5
leaq 0x65726(%rip), %rdi     # 0xa13e0
callq 0x25f70
movb $0x1, -0x1(%rbp)
jmp 0x3bd19
callq 0x7f760
testb $0x1, %al
jne 0x3bcd0
jmp 0x3bce2
leaq 0x65709(%rip), %rdi     # 0xa13e0
callq 0x25f70
movb $0x1, -0x1(%rbp)
jmp 0x3bd19
callq 0x3bde0
callq 0x3be50
testb $0x1, %al
jne 0x3bcf2
jmp 0x3bd04
leaq 0x656e7(%rip), %rdi     # 0xa13e0
callq 0x25f70
movb $0x1, -0x1(%rbp)
jmp 0x3bd19
leaq 0x656d5(%rip), %rdi     # 0xa13e0
callq 0x25f70
callq 0x7f8f0
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/gplessis[P]dotdeb-redis/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) {
		/* Busy-wait until the initializing thread completes. */
		do {
			malloc_mutex_unlock(&init_lock);
			CPU_SPINWAIT;
			malloc_mutex_lock(&init_lock);
		} while (!malloc_initialized());
		return (false);
	}
#endif
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x65699(%rip)     # 0xa13d8
je 0x3bd66
movq 0x659d0(%rip), %rax     # 0xa1718
movq %rax, -0x10(%rbp)
callq 0x10520
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jne 0x3bd6c
cmpl $0x1, 0x65674(%rip)     # 0xa13d8
jne 0x3bd6c
movb $0x0, -0x1(%rbp)
jmp 0x3bdc8
cmpq $0x0, 0x659a4(%rip)     # 0xa1718
je 0x3bdc4
movq 0x6599b(%rip), %rax     # 0xa1718
movq %rax, -0x18(%rbp)
callq 0x10520
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
je 0x3bdc4
jmp 0x3bd94
leaq 0x65645(%rip), %rdi     # 0xa13e0
callq 0x25f70
pause
leaq 0x65637(%rip), %rdi     # 0xa13e0
callq 0x25e30
cmpl $0x0, 0x65623(%rip)     # 0xa13d8
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3bd94
movb $0x0, -0x1(%rbp)
jmp 0x3bdc8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_recursible
static void
malloc_init_hard_recursible(void)
{

	malloc_init_state = malloc_init_recursible;
	malloc_mutex_unlock(&init_lock);

	ncpus = malloc_ncpus();

#if (!defined(JEMALLOC_MUTEX_INIT_CB) && !defined(JEMALLOC_ZONE) \
    && !defined(_WIN32) && !defined(__native_client__))
	/* LinuxThreads's 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();
	}
#endif
	malloc_mutex_lock(&init_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, 0x655ea(%rip)     # 0xa13d8
leaq 0x655eb(%rip), %rdi     # 0xa13e0
callq 0x25f70
callq 0x3bf70
movl %eax, 0x6590b(%rip)     # 0xa1710
leaq -0x194c(%rip), %rdi     # 0x3a4c0
leaq -0x18d3(%rip), %rsi     # 0x3a540
leaq -0x185a(%rip), %rdx     # 0x3a5c0
callq 0x86770
cmpl $0x0, %eax
je 0x3be40
leaq 0x531bb(%rip), %rdi     # 0x8efe6
callq 0x7c0e0
testb $0x1, 0x65869(%rip)     # 0xa16a0
je 0x3be3e
callq 0x10070
jmp 0x3be40
leaq 0x65599(%rip), %rdi     # 0xa13e0
callq 0x25e30
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_finish
static bool
malloc_init_hard_finish(void)
{

	if (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;
	/*
	 * Make sure that the arenas array can be allocated.  In practice, this
	 * limit is enough to allow the allocator to function, but the ctl
	 * machinery will fail to allocate memory at far lower limits.
	 */
	if (narenas_auto > chunksize / sizeof(arena_t *)) {
		narenas_auto = chunksize / sizeof(arena_t *);
		malloc_printf("<jemalloc>: Reducing narenas to limit (%d)\n",
		    narenas_auto);
	}
	narenas_total = narenas_auto;

	/* Allocate and initialize arenas. */
	arenas = (arena_t **)base_alloc(sizeof(arena_t *) * narenas_total);
	if (arenas == NULL)
		return (true);
	/*
	 * Zero the array.  In practice, this should always be pre-zeroed,
	 * since it was just mmap()ed, but let's be sure.
	 */
	memset(arenas, 0, sizeof(arena_t *) * narenas_total);
	/* Copy the pointer to the one arena that was already initialized. */
	arenas[0] = a0;

	malloc_init_state = malloc_init_initialized;
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x644a0
testb $0x1, %al
jne 0x3be63
jmp 0x3be6c
movb $0x1, -0x1(%rbp)
jmp 0x3bf5b
cmpq $0x0, 0x65844(%rip)     # 0xa16b8
jne 0x3bea0
cmpl $0x1, 0x65893(%rip)     # 0xa1710
jbe 0x3be93
movl 0x6588b(%rip), %eax     # 0xa1710
shll $0x2, %eax
movl %eax, %eax
movq %rax, 0x65827(%rip)     # 0xa16b8
jmp 0x3be9e
movq $0x1, 0x6581a(%rip) # 0xa16b8
jmp 0x3bea0
movq 0x65811(%rip), %rax     # 0xa16b8
movl %eax, 0x65853(%rip)     # 0xa1700
movl 0x6584d(%rip), %eax     # 0xa1700
leaq 0x6686e(%rip), %rcx     # 0xa2728
movq (%rcx), %rcx
shrq $0x3, %rcx
cmpq %rcx, %rax
jbe 0x3beee
leaq 0x6685b(%rip), %rax     # 0xa2728
movq (%rax), %rax
shrq $0x3, %rax
movl %eax, 0x65826(%rip)     # 0xa1700
movl 0x65820(%rip), %esi     # 0xa1700
leaq 0x53126(%rip), %rdi     # 0x8f00d
movb $0x0, %al
callq 0x7f490
movl 0x6580c(%rip), %eax     # 0xa1700
movl %eax, 0x657f6(%rip)     # 0xa16f0
movl 0x657f0(%rip), %eax     # 0xa16f0
movl %eax, %edi
shlq $0x3, %rdi
callq 0x4f320
movq %rax, 0x657e6(%rip)     # 0xa16f8
cmpq $0x0, 0x657de(%rip)     # 0xa16f8
jne 0x3bf22
movb $0x1, -0x1(%rbp)
jmp 0x3bf5b
movq 0x657cf(%rip), %rdi     # 0xa16f8
movl 0x657c1(%rip), %eax     # 0xa16f0
movl %eax, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x10250
movq 0x6577d(%rip), %rcx     # 0xa16c0
movq 0x657ae(%rip), %rax     # 0xa16f8
movq %rcx, (%rax)
movl $0x0, 0x65481(%rip)     # 0xa13d8
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/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_cache_maybe_insert
void
arena_chunk_cache_maybe_insert(arena_t *arena, extent_node_t *node, bool cache)
{

	if (cache) {
		extent_node_dirty_linkage_init(node);
		extent_node_dirty_insert(node, &arena->runs_dirty,
		    &arena->chunks_cache);
		arena->ndirty += arena_chunk_dirty_npages(node);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x3c013
movq -0x10(%rbp), %rdi
callq 0x3c020
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x158, %rsi            # imm = 0x158
movq -0x8(%rbp), %rdx
addq $0x168, %rdx            # imm = 0x168
callq 0x3c070
movq -0x10(%rbp), %rdi
callq 0x3c120
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq 0xe8(%rax), %rcx
movq %rcx, 0xe8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_cache_maybe_remove
void
arena_chunk_cache_maybe_remove(arena_t *arena, extent_node_t *node, bool dirty)
{

	if (dirty) {
		extent_node_dirty_remove(node);
		assert(arena->ndirty >= arena_chunk_dirty_npages(node));
		arena->ndirty -= arena_chunk_dirty_npages(node);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x3c189
movq -0x10(%rbp), %rdi
callq 0x3c190
jmp 0x3c168
movq -0x10(%rbp), %rdi
callq 0x3c120
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xe8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_node_alloc
extent_node_t *
arena_node_alloc(arena_t *arena)
{
	extent_node_t *node;

	malloc_mutex_lock(&arena->node_cache_mtx);
	node = ql_last(&arena->node_cache, ql_link);
	if (node == NULL) {
		malloc_mutex_unlock(&arena->node_cache_mtx);
		return (base_alloc(sizeof(extent_node_t)));
	}
	ql_tail_remove(&arena->node_cache, extent_node_t, ql_link);
	malloc_mutex_unlock(&arena->node_cache_mtx);
	return (node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x3f0, %rdi            # imm = 0x3F0
callq 0x3c3a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x3e8(%rax)
je 0x3c26f
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3c277
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x3c277
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3c2a9
movq -0x10(%rbp), %rdi
addq $0x3f0, %rdi            # imm = 0x3F0
callq 0x3c3c0
movl $0x68, %edi
callq 0x4f320
movq %rax, -0x8(%rbp)
jmp 0x3c389
jmp 0x3c2ab
movq -0x10(%rbp), %rax
cmpq $0x0, 0x3e8(%rax)
je 0x3c2ce
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x3c2d6
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x3c2d6
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x3c309
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x3e8(%rax)
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
cmpq -0x20(%rbp), %rax
je 0x3c35e
jmp 0x3c31c
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
jmp 0x3c36d
movq -0x10(%rbp), %rax
movq $0x0, 0x3e8(%rax)
jmp 0x3c36f
jmp 0x3c371
movq -0x10(%rbp), %rdi
addq $0x3f0, %rdi            # imm = 0x3F0
callq 0x3c3c0
movq -0x18(%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/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_node_dalloc
void
arena_node_dalloc(arena_t *arena, extent_node_t *node)
{

	malloc_mutex_lock(&arena->node_cache_mtx);
	ql_elm_new(node, ql_link);
	ql_tail_insert(&arena->node_cache, node, ql_link);
	malloc_mutex_unlock(&arena->node_cache_mtx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x3f0, %rdi            # imm = 0x3F0
callq 0x3c3a0
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
jmp 0x3c41a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x3e8(%rax)
je 0x3c479
jmp 0x3c42a
movq -0x8(%rbp), %rax
movq 0x3e8(%rax), %rax
movq 0x50(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x3e8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x3e8(%rax), %rax
movq %rcx, 0x50(%rax)
jmp 0x3c479
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x3e8(%rax)
movq -0x8(%rbp), %rdi
addq $0x3f0, %rdi            # imm = 0x3F0
callq 0x3c3c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_alloc_huge
void *
arena_chunk_alloc_huge(arena_t *arena, size_t usize, size_t alignment,
    bool *zero)
{
	void *ret;
	chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;
	size_t csize = CHUNK_CEILING(usize);

	malloc_mutex_lock(&arena->lock);

	/* Optimistically update stats. */
	if (config_stats) {
		arena_huge_malloc_stats_update(arena, usize);
		arena->stats.mapped += usize;
	}
	arena->nactive += (usize >> LG_PAGE);

	ret = chunk_alloc_cache(arena, &chunk_hooks, NULL, csize, alignment,
	    zero, true);
	malloc_mutex_unlock(&arena->lock);
	if (ret == NULL) {
		ret = arena_chunk_alloc_huge_hard(arena, &chunk_hooks, usize,
		    alignment, zero, csize);
	}

	if (config_stats && ret != NULL)
		stats_cactive_add(usize);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10250
movq -0x10(%rbp), %rax
leaq 0x6624d(%rip), %rcx     # 0xa2730
addq (%rcx), %rax
leaq 0x66243(%rip), %rcx     # 0xa2730
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c5c0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
shrq $0xc, %rcx
movq -0x8(%rbp), %rax
addq 0xe0(%rax), %rcx
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rdi
movq -0x68(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq -0x60(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, (%rsp)
callq 0x50480
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
cmpq $0x0, -0x28(%rbp)
jne 0x3c59c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x68(%rbp), %r9
leaq -0x60(%rbp), %rsi
callq 0x3c6b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3c5ac
movq -0x10(%rbp), %rdi
callq 0x3c770
movq -0x28(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)