LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: enableRawMode
static int enableRawMode(int fd) {
    struct termios raw;

    if (!isatty(STDIN_FILENO)) goto fatal;
    if (!atexit_registered) {
        atexit(linenoiseAtExit);
        atexit_registered = 1;
    }
    if (tcgetattr(fd,&orig_termios) == -1) goto fatal;

    raw = orig_termios;  /* modify the original mode */
    /* input modes: no break, no CR to NL, no parity check, no strip char,
     * no start/stop output control. */
    raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
    /* output modes - disable post processing */
    raw.c_oflag &= ~(OPOST);
    /* control modes - set 8 bit chars */
    raw.c_cflag |= (CS8);
    /* local modes - choing off, canonical off, no extended functions,
     * no signal chars (^Z,^C) */
    raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
    /* control chars - set return condition: min number of bytes and timer.
     * We want read to return every single byte, without timeout. */
    raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */

    /* put terminal in raw mode after flushing */
    if (tcsetattr(fd,TCSAFLUSH,&raw) < 0) goto fatal;
    rawmode = 1;
    return 0;

fatal:
    errno = ENOTTY;
    return -1;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
xorl %edi, %edi
callq 0x100f0
testl %eax, %eax
je 0x1b6ec
cmpb $0x0, 0x3af80(%rip)     # 0x565d8
jne 0x1b66d
leaq 0xb29(%rip), %rdi       # 0x1c18a
callq 0x3ae90
movb $0x1, 0x3af6b(%rip)     # 0x565d8
leaq 0x3af68(%rip), %rsi     # 0x565dc
xorl %edi, %edi
callq 0x10570
cmpl $-0x1, %eax
je 0x1b6ec
movups 0x3af55(%rip), %xmm0    # 0x565dc
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movups 0x3af58(%rip), %xmm0    # 0x565ec
movaps %xmm0, 0x10(%rdx)
movups 0x3af69(%rip), %xmm0    # 0x56608
movups %xmm0, 0x2c(%rdx)
movups 0x3af52(%rip), %xmm0    # 0x565fc
movaps %xmm0, 0x20(%rdx)
movaps (%rdx), %xmm0
movaps 0x268c8(%rip), %xmm1    # 0x41f80
andps %xmm0, %xmm1
orps 0x268ce(%rip), %xmm0    # 0x41f90
shufps $0x32, %xmm1, %xmm0     # xmm0 = xmm0[2,0],xmm1[3,0]
shufps $0x84, %xmm0, %xmm1     # xmm1 = xmm1[0,1],xmm0[0,2]
movaps %xmm1, (%rdx)
movw $0x100, 0x16(%rdx)      # imm = 0x100
xorl %ebx, %ebx
pushq $0x2
popq %rsi
xorl %edi, %edi
callq 0x10580
testl %eax, %eax
js 0x1b6ec
movb $0x1, 0x3af2e(%rip)     # 0x56618
jmp 0x1b6fa
callq 0x100a0
movl $0x19, (%rax)
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseHistoryAdd
int linenoiseHistoryAdd(const char *line) {
    char *linecopy;

    if (history_max_len == 0) return 0;

    /* Initialization on first call. */
    if (history == NULL) {
        history = malloc(sizeof(char*)*history_max_len);
        if (history == NULL) return 0;
        memset(history,0,(sizeof(char*)*history_max_len));
    }

    /* Don't add duplicated lines. */
    if (history_len && !strcmp(history[history_len-1], line)) return 0;

    /* Add an heap allocated copy of the line in the history.
     * If we reached the max length, remove the older line. */
    linecopy = strdup(line);
    if (!linecopy) return 0;
    if (history_len == history_max_len) {
        free(history[0]);
        memmove(history,history+1,sizeof(char*)*(history_max_len-1));
        history_len--;
    }
    history[history_len] = linecopy;
    history_len++;
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x3a460(%rip), %r15d    # 0x56348
movq 0x3a6e1(%rip), %rbx     # 0x565d0
testq %rbx, %rbx
jne 0x1bf13
leaq (,%r15,8), %rsi
pushq $0x1
popq %rdi
callq 0x10370
movq %rax, %rbx
movq %rax, 0x3a6c2(%rip)     # 0x565d0
testq %rax, %rax
je 0x1bf7b
movslq 0x3a6ae(%rip), %r12     # 0x565c8
testq %r12, %r12
je 0x1bf30
movq -0x8(%rbx,%r12,8), %rdi
movq %r14, %rsi
callq 0x10380
testl %eax, %eax
je 0x1bf7b
movq %r14, %rdi
callq 0x10680
testq %rax, %rax
je 0x1bf7b
movq %rax, %r14
cmpl %r15d, %r12d
jne 0x1bf67
movq (%rbx), %rdi
callq 0x10060
leaq 0x8(%rbx), %rsi
decl %r15d
leaq (,%r15,8), %rdx
movq %rbx, %rdi
callq 0x10540
movl %r15d, %r12d
movslq %r12d, %rax
movq %r14, (%rbx,%rax,8)
incl %eax
movl %eax, 0x3a652(%rip)     # 0x565c8
pushq $0x1
popq %rax
jmp 0x1bf7d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseHistorySetMaxLen
int linenoiseHistorySetMaxLen(int len) {
    char **new;

    if (len < 1) return 0;
    if (history) {
        int tocopy = history_len;

        new = malloc(sizeof(char*)*len);
        if (new == NULL) return 0;

        /* If we can't copy everything, free the elements we'll not use. */
        if (len < tocopy) {
            int j;

            for (j = 0; j < tocopy-len; j++) free(history[j]);
            tocopy = len;
        }
        memset(new,0,sizeof(char*)*len);
        memcpy(new,history+(history_len-tocopy), sizeof(char*)*tocopy);
        free(history);
        history = new;
    }
    history_max_len = len;
    if (history_len > history_max_len)
        history_len = history_max_len;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %ebp, %ebp
testl %edi, %edi
jle 0x1c064
movl %edi, %ebx
movq 0x3a626(%rip), %r14     # 0x565d0
movl 0x3a617(%rip), %r13d    # 0x565c8
testq %r14, %r14
je 0x1c050
movl %ebx, %r12d
shlq $0x3, %r12
movq %r12, %rdi
callq 0x10450
testq %rax, %rax
je 0x1c064
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
movl %r13d, %eax
subl %ebx, %r13d
jle 0x1c005
movl %eax, 0xc(%rsp)
testl %r13d, %r13d
movl $0x0, %r15d
cmovgl %r13d, %r15d
cmpq %rbp, %r15
je 0x1c00e
movq (%r14,%rbp,8), %rdi
callq 0x10060
incq %rbp
jmp 0x1bff2
movl %eax, 0x8(%rsp)
movl %eax, %r13d
jmp 0x1c01a
movslq %r13d, %rbp
movl %ebx, 0x8(%rsp)
movl 0xc(%rsp), %r13d
movq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x10270
leaq (%r14,%rbp,8), %rsi
movslq 0x8(%rsp), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0x10400
movq %r14, %rdi
callq 0x10060
movq %r15, 0x3a580(%rip)     # 0x565d0
movl %ebx, 0x3a2f2(%rip)     # 0x56348
pushq $0x1
popq %rbp
cmpl %ebx, %r13d
jle 0x1c064
movl %ebx, 0x3a564(%rip)     # 0x565c8
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseHistorySave
int linenoiseHistorySave(const char *filename) {
    mode_t old_umask = umask(S_IXUSR|S_IRWXG|S_IRWXO);
    FILE *fp;
    int j;

    fp = fopen(filename,"w");
    umask(old_umask);
    if (fp == NULL) return -1;
    chmod(filename,S_IRUSR|S_IWUSR);
    for (j = 0; j < history_len; j++)
        fprintf(fp,"%s\n",history[j]);
    fclose(fp);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x7f
popq %rdi
callq 0x103d0
movl %eax, %ebp
leaq 0x22dcd(%rip), %rsi     # 0x3ee5d
movq %r14, %rdi
callq 0x105a0
movq %rax, %rbx
movl %ebp, %edi
callq 0x103d0
testq %rbx, %rbx
je 0x1c0f3
movq %r14, %rdi
movl $0x180, %esi            # imm = 0x180
callq 0x104f0
leaq 0x23dec(%rip), %r14     # 0x3fea7
xorl %r15d, %r15d
movslq 0x3a503(%rip), %rax     # 0x565c8
cmpq %rax, %r15
jge 0x1c0e7
movq 0x3a4ff(%rip), %rax     # 0x565d0
movq (%rax,%r15,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x103b0
incq %r15
jmp 0x1c0be
movq %rbx, %rdi
callq 0x101b0
xorl %eax, %eax
jmp 0x1c0f6
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseHistoryLoad
int linenoiseHistoryLoad(const char *filename) {
    FILE *fp = fopen(filename,"r");
    char buf[LINENOISE_MAX_LINE];

    if (fp == NULL) return -1;

    while (fgets(buf,LINENOISE_MAX_LINE,fp) != NULL) {
        char *p;

        p = strchr(buf,'\r');
        if (!p) p = strchr(buf,'\n');
        if (p) *p = '\0';
        linenoiseHistoryAdd(buf);
    }
    fclose(fp);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
leaq 0x25d88(%rip), %rsi     # 0x41e9d
callq 0x105a0
testq %rax, %rax
je 0x1c179
movq %rax, %rbx
movq %rsp, %r14
pushq $0xd
popq %rbp
pushq $0xa
popq %r15
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdx
callq 0x10330
testq %rax, %rax
je 0x1c16d
movq %r14, %rdi
movl %ebp, %esi
callq 0x101e0
testq %rax, %rax
jne 0x1c160
movq %r14, %rdi
movl %r15d, %esi
callq 0x101e0
testq %rax, %rax
je 0x1c163
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x1bed6
jmp 0x1c12c
movq %rbx, %rdi
callq 0x101b0
xorl %eax, %eax
jmp 0x1c17c
pushq $-0x1
popq %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x25ec9(%rip), %rsi     # 0x420b0
pushq $0x1
popq %rdi
pushq $0x4
popq %rdx
callq 0x10170
pushq $-0x1
popq %rbx
cmpq $0x4, %rax
jne 0x1c26d
xorl %eax, %eax
pushq $0x1
popq %r14
movq %rax, %r15
cmpq $0x1f, %rax
je 0x1c22e
leaq (%rsp,%r15), %rsi
addq $0x10, %rsi
xorl %edi, %edi
movq %r14, %rdx
callq 0x102f0
cmpq $0x1, %rax
jne 0x1c22e
leaq 0x1(%r15), %rax
cmpb $0x52, 0x10(%rsp,%r15)
jne 0x1c201
movb $0x0, 0x10(%rsp,%r15)
cmpb $0x1b, 0x10(%rsp)
jne 0x1c26d
cmpb $0x5b, 0x11(%rsp)
jne 0x1c26d
leaq 0x12(%rsp), %rdi
leaq 0x25e67(%rip), %rsi     # 0x420b5
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0x10480
cmpl $0x2, %eax
jne 0x1c26a
movl 0x8(%rsp), %ebx
jmp 0x1c26d
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x3a0d7(%rip), %r14     # 0x56648
movq %r14, %rdi
callq 0x106d0
movl %ebx, %edi
callq 0x1c596
movq %rax, %rbx
movq %r14, %rdi
callq 0x10440
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0xffe, %edi            # imm = 0xFFE
jbe 0x1c5a1
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpl %edi, 0x3a0bc(%rip)     # 0x56670
jne 0x1c61b
leal 0x47(,%rbx,8), %edi
andl $0x1ffc0, %edi          # imm = 0x1FFC0
callq 0x1c2a0
testq %rax, %rax
je 0x1c642
movq %rax, %r14
leal 0x1(%rbx), %ebp
movq 0x3a09e(%rip), %r15     # 0x56678
movl 0x3a08f(%rip), %r13d    # 0x56670
movq %r13, %rdx
shlq $0x3, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x10400
movl %ebx, %r12d
andq $0x0, (%r14,%r12,8)
cmpl 0x3a07e(%rip), %r13d    # 0x56680
je 0x1c60c
movq %r15, %rdi
callq 0x1c41b
movq %r14, 0x3a065(%rip)     # 0x56678
movl %ebp, 0x3a057(%rip)     # 0x56670
jmp 0x1c625
movq 0x3a056(%rip), %r14     # 0x56678
movl %ebx, %r12d
movq (%r14,%r12,8), %rax
testq %rax, %rax
jne 0x1c644
movl %ebx, %edi
callq 0x25953
movq 0x3a03c(%rip), %rcx     # 0x56678
movq %rax, (%rcx,%r12,8)
jmp 0x1c644
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
leaq 0x39feb(%rip), %rbx     # 0x56648
movq %rbx, %rdi
callq 0x106d0
movl 0x3a005(%rip), %ebp     # 0x56670
movq %rbx, %rdi
callq 0x10440
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x39fb7(%rip), %r15     # 0x56648
movq %r15, %rdi
callq 0x106d0
movq 0x39fd8(%rip), %rax     # 0x56678
movl %ebp, %ecx
movq (%rax,%rcx,8), %rcx
movl %ebx, %edx
movq (%rax,%rdx,8), %rbx
decl 0x4(%rcx)
incl 0x4(%rbx)
movq %r15, %rdi
callq 0x10440
movq %rbx, 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x39f72(%rip), %r14     # 0x56648
movq %r14, %rdi
callq 0x106d0
movq 0x39f93(%rip), %rax     # 0x56678
movl %ebx, %ecx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %ebx
movq %r14, %rdi
callq 0x10440
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_arena_choose_hard
arena_t *
arena_choose_hard(tsd_t *tsd)
{
	arena_t *ret;

	if (narenas_auto > 1) {
		unsigned i, choose, first_null;

		choose = 0;
		first_null = narenas_auto;
		malloc_mutex_lock(&arenas_lock);
		assert(a0get() != NULL);
		for (i = 1; i < narenas_auto; i++) {
			if (arenas[i] != NULL) {
				/*
				 * Choose the first arena that has the lowest
				 * number of threads assigned to it.
				 */
				if (arenas[i]->nthreads <
				    arenas[choose]->nthreads)
					choose = i;
			} else if (first_null == narenas_auto) {
				/*
				 * Record the index of the first uninitialized
				 * arena, in case all extant arenas are in use.
				 *
				 * NB: It is possible for there to be
				 * discontinuities in terms of initialized
				 * versus uninitialized arenas, due to the
				 * "thread.arena" mallctl.
				 */
				first_null = i;
			}
		}

		if (arenas[choose]->nthreads == 0
		    || first_null == narenas_auto) {
			/*
			 * Use an unloaded arena, or the least loaded arena if
			 * all arenas are already initialized.
			 */
			ret = arenas[choose];
		} else {
			/* Initialize a new arena. */
			choose = first_null;
			ret = arena_init_locked(choose);
			if (ret == NULL) {
				malloc_mutex_unlock(&arenas_lock);
				return (NULL);
			}
		}
		arena_bind_locked(tsd, choose);
		malloc_mutex_unlock(&arenas_lock);
	} else {
		ret = a0get();
		arena_bind(tsd, 0);
	}

	return (ret);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x39e39(%rip), %ebp     # 0x56680
cmpl $0x2, %ebp
jb 0x1c8bf
leaq 0x39df5(%rip), %rdi     # 0x56648
callq 0x106d0
movl 0x39e22(%rip), %ecx     # 0x56680
movq 0x39e13(%rip), %rdx     # 0x56678
xorl %eax, %eax
pushq $0x1
popq %rsi
movl %eax, %edi
cmpq %rcx, %rsi
jae 0x1c89a
movq (%rdx,%rsi,8), %r8
testq %r8, %r8
je 0x1c890
movl 0x4(%r8), %r8d
movq (%rdx,%rdi,8), %r9
movl %esi, %edi
cmpl 0x4(%r9), %r8d
jb 0x1c88c
movl %eax, %edi
movl %edi, %eax
jmp 0x1c895
cmpl %ecx, %ebp
cmovel %esi, %ebp
incq %rsi
jmp 0x1c86a
movq (%rdx,%rdi,8), %r14
cmpl $0x0, 0x4(%r14)
je 0x1c8d4
cmpl %ecx, %ebp
je 0x1c8d4
movl %ebp, %edi
callq 0x1c596
movq %rax, %r14
movl %ebp, %eax
testq %r14, %r14
jne 0x1c8d4
xorl %r14d, %r14d
jmp 0x1c8ed
movq 0x39d7a(%rip), %r14     # 0x56640
leaq 0x39d7b(%rip), %rdi     # 0x56648
callq 0x106d0
xorl %eax, %eax
movq 0x39d9d(%rip), %rcx     # 0x56678
movl %eax, %eax
movq (%rcx,%rax,8), %rax
incl 0x4(%rax)
cmpl $0x1, (%rbx)
jne 0x1c8ed
movq %rax, 0x28(%rbx)
leaq 0x39d54(%rip), %rdi     # 0x56648
callq 0x10440
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x3800, %rdi           # imm = 0x3800
ja 0x1e6d5
pushq %rax
cmpq $0x1000, %rdi           # imm = 0x1000
ja 0x1e6d8
decq %rdi
shrq $0x3, %rdi
leaq 0x24446(%rip), %rax     # 0x42b00
movzbl (%rdi,%rax), %eax
movl %eax, %eax
imulq $0x60, %rax, %rax
leaq 0x37fd5(%rip), %rcx     # 0x566a0
movq 0x8(%rcx,%rax), %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
callq 0x21e78
jmp 0x1e6be
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1e721
movq %rdi, %rbx
movq 0x358fd(%rip), %r15     # 0x53ff0
movq %fs:0x0, %r14
addq %r15, %r14
movl %fs:(%r15), %eax
testl %eax, %eax
je 0x1e727
cmpl $0x2, %eax
je 0x1e731
movq %fs:0x8(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1e3d8
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %fs:(%r15)
jmp 0x1e739
movl $0x3, %fs:(%r15)
leaq 0x396d4(%rip), %rax     # 0x57e14
movl (%rax), %edi
movq %r14, %rsi
callq 0x106f0
testl %eax, %eax
je 0x1e70c
leaq 0x24764(%rip), %rdi     # 0x42eb9
callq 0x37d1c
cmpb $0x1, 0x37ebf(%rip)     # 0x56620
jne 0x1e70c
callq 0x10090
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_dallocx
JEMALLOC_NOTHROW
je_dallocx(void *ptr, int flags)
{
	tsd_t *tsd;
	tcache_t *tcache;

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

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

	UTRACE(ptr, 0, 0);
	ifree(tsd_fetch(), ptr, tcache);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movq 0x33c41(%rip), %r13     # 0x53ff0
movq %fs:0x0, %r14
addq %r13, %r14
movl %fs:(%r13), %eax
testl %eax, %eax
je 0x20417
cmpl $0x2, %eax
je 0x2046e
andl $0xfff00, %r15d         # imm = 0xFFF00
jne 0x20409
movq %fs:0x8(%r13), %r12
movl %fs:(%r13), %eax
testl %eax, %eax
je 0x20422
cmpl $0x2, %eax
je 0x204ab
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e3d8
cmpl $0x100, %r15d           # imm = 0x100
jne 0x20430
xorl %r12d, %r12d
jmp 0x203db
movl $0x1, %fs:(%r13)
jmp 0x20477
movl $0x1, %fs:(%r13)
jmp 0x204b4
shrl $0x8, %r15d
addl $-0x2, %r15d
leaq 0x37989(%rip), %rax     # 0x57dc8
movq (%rax), %rbp
movq (%rbp,%r15,8), %r12
testq %r12, %r12
jne 0x203db
movq %r14, %rdi
xorl %esi, %esi
callq 0x21e62
movq %r14, %rdi
movq %rax, %rsi
callq 0x375ec
movq %rax, %r12
movq %rax, (%rbp,%r15,8)
jmp 0x203db
movl $0x3, %fs:(%r13)
leaq 0x37996(%rip), %rax     # 0x57e14
movl (%rax), %edi
movq %r14, %rsi
callq 0x106f0
testl %eax, %eax
je 0x203cd
leaq 0x22a22(%rip), %rdi     # 0x42eb9
callq 0x37d1c
cmpb $0x1, 0x3617d(%rip)     # 0x56620
jne 0x203cd
jmp 0x204e6
movl $0x3, %fs:(%r13)
leaq 0x37959(%rip), %rax     # 0x57e14
movl (%rax), %edi
movq %r14, %rsi
callq 0x106f0
testl %eax, %eax
je 0x203ed
leaq 0x229e5(%rip), %rdi     # 0x42eb9
callq 0x37d1c
cmpb $0x1, 0x36140(%rip)     # 0x56620
jne 0x203ed
callq 0x10090
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_malloc_usable_size
JEMALLOC_NOTHROW
je_malloc_usable_size(JEMALLOC_USABLE_SIZE_CONST void *ptr)
{
	size_t ret;

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

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

	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x355b2(%rip)     # 0x56628
jne 0x210cf
testq %rbx, %rbx
je 0x210c7
leaq 0x3662c(%rip), %rax     # 0x576b0
movq (%rax), %rax
notq %rax
andq %rbx, %rax
cmpq %rbx, %rax
je 0x21104
subq %rax, %rbx
shrq $0xc, %rbx
leaq 0x364b8(%rip), %rcx     # 0x57558
subq (%rcx), %rbx
movq 0x68(%rax,%rbx,8), %rax
movl %eax, %ecx
shrl $0x5, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
je 0x21111
movl %ecx, %eax
leaq 0x212bf(%rip), %rcx     # 0x42380
movq (%rcx,%rax,8), %rax
jmp 0x210c9
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x32f1a(%rip), %r15     # 0x53ff0
movq %fs:0x0, %r14
addq %r15, %r14
movl %fs:(%r15), %eax
testl %eax, %eax
je 0x21122
cmpl $0x2, %eax
je 0x2112c
cmpq $0x0, %fs:0x48(%r15)
jne 0x21078
movq %r14, %rdi
callq 0x32f9c
jmp 0x21078
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x311c1
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x210c9
movl $0x1, %fs:(%r15)
jmp 0x21134
movl $0x3, %fs:(%r15)
leaq 0x36cd9(%rip), %rax     # 0x57e14
movl (%rax), %edi
movq %r14, %rsi
callq 0x106f0
testl %eax, %eax
je 0x210ef
leaq 0x21d69(%rip), %rdi     # 0x42eb9
callq 0x37d1c
cmpb $0x1, 0x354c4(%rip)     # 0x56620
jne 0x210ef
callq 0x10090
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
callq 0x28ac3
callq 0x29a2a
xorl %ebx, %ebx
movl 0x353b6(%rip), %eax     # 0x56670
movl %eax, %ecx
cmpq %rcx, %rbx
jae 0x212e1
movq 0x353b0(%rip), %rcx     # 0x56678
movq (%rcx,%rbx,8), %rdi
testq %rdi, %rdi
je 0x212dc
callq 0x26667
movl 0x35394(%rip), %eax     # 0x56670
incq %rbx
jmp 0x212ba
leaq 0x35360(%rip), %rdi     # 0x56648
callq 0x31316
callq 0x32db2
popq %rbx
jmp 0x2a3db
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x1c653
movl %eax, %r12d
xorl %r13d, %r13d
cmpq %r12, %r13
je 0x21e2d
movq 0x34895(%rip), %rax     # 0x56678
movq (%rax,%r13,8), %rbx
testq %rbx, %rbx
je 0x21e28
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x106d0
movq 0xa8(%rbx), %r15
testq %r15, %r15
je 0x21e20
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3743c
movq (%r15), %r15
cmpq 0xa8(%rbx), %r15
jne 0x21dff
xorl %r15d, %r15d
jmp 0x21dff
movq %r14, %rdi
callq 0x10440
incq %r13
jmp 0x21dd7
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x341fc
// File: /workspace/github_c_makefile_star2_O2/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:
testl %edx, %edx
je 0x2210e
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsi), %rax
movq %rax, 0x28(%rsi)
movq %rax, 0x30(%rsi)
movq %rsi, 0x38(%rsi)
movq %rsi, 0x40(%rsi)
leaq 0x158(%rdi), %rsi
leaq 0x168(%rdi), %rdx
movq %r14, %rdi
callq 0x2210f
movq 0x10(%r14), %rax
shrq $0xc, %rax
addq %rax, 0xe8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testl %edx, %edx
je 0x2216e
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2216f
movq 0x10(%r14), %rax
shrq $0xc, %rax
subq %rax, 0xe8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x3f0(%rdi), %rbx
movq %rbx, %rdi
callq 0x106d0
movq 0x3e8(%r15), %rax
testq %rax, %rax
je 0x22202
movq 0x50(%rax), %r14
testq %r14, %r14
je 0x22202
cmpq %r14, %rax
jne 0x221df
movq 0x48(%rax), %rax
movq %rax, 0x3e8(%r15)
cmpq %r14, %rax
je 0x22217
movq 0x48(%r14), %rax
movq 0x50(%r14), %rcx
movq %rax, 0x48(%rcx)
movq 0x50(%r14), %rcx
movq %rcx, 0x50(%rax)
movq %r14, 0x48(%r14)
movq %r14, 0x50(%r14)
jmp 0x2221f
movq %rbx, %rdi
callq 0x10440
pushq $0x68
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x287c8
andq $0x0, 0x3e8(%r15)
movq %rbx, %rdi
callq 0x10440
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x3f0(%rdi), %r14
movq %r14, %rdi
callq 0x106d0
movq %rbx, 0x48(%rbx)
movq %rbx, 0x50(%rbx)
movq 0x3e8(%r15), %rax
testq %rax, %rax
je 0x22284
movq 0x50(%rax), %rax
movq %rax, 0x50(%rbx)
movq 0x3e8(%r15), %rcx
movq %rcx, 0x48(%rbx)
movq %rbx, 0x48(%rax)
movq 0x3e8(%r15), %rax
movq %rbx, 0x50(%rax)
movq 0x48(%rbx), %rbx
movq %rbx, 0x3e8(%r15)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10440
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r12
movaps %xmm0, 0x20(%r12)
andq $0x0, 0x30(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x353d4(%rip), %rax     # 0x576b0
movq (%rax), %rbp
leaq (%rsi,%rbp), %rax
notq %rbp
andq %rax, %rbp
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x106d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x223bc
addq %rbx, 0x30(%r14)
movq %rbx, %r13
shrq $0xc, %r13
addq %r13, 0xe0(%r14)
movl $0x1, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rbp, %rcx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x28fe6
movq %rax, %r12
movq %r15, %rdi
callq 0x10440
testq %r12, %r12
jne 0x22373
leaq 0xf(%rsp), %rax
movb $0x1, (%rax)
movq %rax, (%rsp)
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %rbp, %rcx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x294b0
testq %rax, %rax
je 0x22391
movq %rax, %r12
leaq 0x35a2e(%rip), %rax     # 0x57da8
lock
xaddq %rbx, (%rax)
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x106d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x266c6
subq %rbx, 0x30(%r14)
subq %r13, 0xe0(%r14)
movq %r15, %rdi
callq 0x10440
xorl %r12d, %r12d
jmp 0x2237f
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_huge_malloc_stats_update
static void
arena_huge_malloc_stats_update(arena_t *arena, size_t usize)
{
	szind_t index = size2index(usize) - nlclasses - NBINS;

	cassert(config_stats);

	arena->stats.nmalloc_huge++;
	arena->stats.allocated_huge += usize;
	arena->stats.hstats[index].nmalloc++;
	arena->stats.hstats[index].curhchunks++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1000, %rsi           # imm = 0x1000
ja 0x22429
leaq -0x1(%r14), %rax
shrq $0x3, %rax
leaq 0x20722(%rip), %rcx     # 0x42b00
movzbl (%rcx,%rax), %eax
subl 0x35168(%rip), %eax     # 0x57550
addl $-0x27, %eax
movq %r14, %xmm0
shufpd $0x2, 0x20ae7(%rip), %xmm0 # xmm0 = xmm0[0],mem[1]
movdqu 0x80(%rbx), %xmm1
paddq %xmm1, %xmm0
movdqu %xmm0, 0x80(%rbx)
movq 0xa0(%rbx), %rcx
imulq $0x18, %rax, %rax
incq (%rcx,%rax)
incq 0x10(%rcx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x284a4
jmp 0x223e2
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_dalloc_huge
void
arena_chunk_dalloc_huge(arena_t *arena, void *chunk, size_t usize)
{
	chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;
	size_t csize;

	csize = CHUNK_CEILING(usize);
	malloc_mutex_lock(&arena->lock);
	if (config_stats) {
		arena_huge_dalloc_stats_update(arena, usize);
		arena->stats.mapped -= usize;
		stats_cactive_sub(usize);
	}
	arena->nactive -= (usize >> LG_PAGE);

	chunk_dalloc_cache(arena, &chunk_hooks, chunk, csize, true);
	malloc_mutex_unlock(&arena->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, 0x20(%r12)
andq $0x0, 0x30(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x35242(%rip), %rax     # 0x576b0
movq (%rax), %r13
leaq (%rdx,%r13), %rax
notq %r13
andq %rax, %r13
leaq 0x8(%rdi), %rbp
movq %rbp, %rdi
callq 0x106d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x224df
subq %r15, 0x30(%r14)
movq %r15, %rax
negq %rax
leaq 0x35905(%rip), %rcx     # 0x57da8
lock
xaddq %rax, (%rcx)
shrq $0xc, %r15
subq %r15, 0xe0(%r14)
pushq $0x1
popq %r8
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x29533
movq %rbp, %rdi
callq 0x10440
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_huge_dalloc_stats_update
static void
arena_huge_dalloc_stats_update(arena_t *arena, size_t usize)
{
	szind_t index = size2index(usize) - nlclasses - NBINS;

	cassert(config_stats);

	arena->stats.ndalloc_huge++;
	arena->stats.allocated_huge -= usize;
	arena->stats.hstats[index].ndalloc++;
	arena->stats.hstats[index].curhchunks--;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1000, %rsi           # imm = 0x1000
ja 0x22543
leaq -0x1(%r14), %rax
shrq $0x3, %rax
leaq 0x205ff(%rip), %rcx     # 0x42b00
movzbl (%rcx,%rax), %eax
subl 0x35045(%rip), %eax     # 0x57550
incq 0x90(%rbx)
subq %r14, 0x80(%rbx)
addl $-0x27, %eax
movq 0xa0(%rbx), %rcx
imulq $0x18, %rax, %rax
movdqu 0x8(%rcx,%rax), %xmm0
paddq 0x209bb(%rip), %xmm0    # 0x42ef0
movdqu %xmm0, 0x8(%rcx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x284a4
jmp 0x22505
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_ralloc_huge_similar
void
arena_chunk_ralloc_huge_similar(arena_t *arena, void *chunk, size_t oldsize,
    size_t usize)
{

	assert(CHUNK_CEILING(oldsize) == CHUNK_CEILING(usize));
	assert(oldsize != usize);

	malloc_mutex_lock(&arena->lock);
	if (config_stats)
		arena_huge_ralloc_stats_update(arena, oldsize, usize);
	if (oldsize < usize) {
		size_t udiff = usize - oldsize;
		arena->nactive += udiff >> LG_PAGE;
		if (config_stats)
			stats_cactive_add(udiff);
	} else {
		size_t udiff = oldsize - usize;
		arena->nactive -= udiff >> LG_PAGE;
		if (config_stats)
			stats_cactive_sub(udiff);
	}
	malloc_mutex_unlock(&arena->lock);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x106d0
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x225dc
movq %r12, %rax
movq 0xe0(%r15), %rcx
subq %r14, %rax
jae 0x225a9
subq %r12, %r14
movq %r14, %rax
shrq $0xc, %rax
addq %rax, %rcx
movq %rcx, 0xe0(%r15)
leaq 0x35806(%rip), %rax     # 0x57da8
lock
xaddq %r14, (%rax)
jmp 0x225c9
movq %rax, %rdx
shrq $0xc, %rdx
subq %rdx, %rcx
movq %rcx, 0xe0(%r15)
negq %rax
leaq 0x357e4(%rip), %rcx     # 0x57da8
lock
xaddq %rax, (%rcx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10440
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_ralloc_huge_shrink
void
arena_chunk_ralloc_huge_shrink(arena_t *arena, void *chunk, size_t oldsize,
    size_t usize)
{
	size_t udiff = oldsize - usize;
	size_t cdiff = CHUNK_CEILING(oldsize) - CHUNK_CEILING(usize);

	malloc_mutex_lock(&arena->lock);
	if (config_stats) {
		arena_huge_ralloc_stats_update(arena, oldsize, usize);
		if (cdiff != 0) {
			arena->stats.mapped -= cdiff;
			stats_cactive_sub(udiff);
		}
	}
	arena->nactive -= udiff >> LG_PAGE;

	if (cdiff != 0) {
		chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;
		void *nchunk = (void *)((uintptr_t)chunk +
		    CHUNK_CEILING(usize));

		chunk_dalloc_cache(arena, &chunk_hooks, nchunk, cdiff, true);
	}
	malloc_mutex_unlock(&arena->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, (%rsp)
movq %rdi, %rbx
movq %rdx, %rbp
subq %rcx, %rbp
leaq 0x3508b(%rip), %rax     # 0x576b0
movq (%rax), %r14
leaq (%r14,%rdx), %r12
movq %r14, %rax
notq %rax
andq %rax, %r12
addq %rcx, %r14
andq %rax, %r14
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0x106d0
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x225dc
subq %r14, %r12
jne 0x22669
shrq $0xc, %rbp
subq %rbp, 0xe0(%rbx)
jmp 0x226c8
subq %r12, 0x30(%rbx)
movq %rbp, %rax
negq %rax
leaq 0x3572e(%rip), %rcx     # 0x57da8
lock
xaddq %rax, (%rcx)
shrq $0xc, %rbp
subq %rbp, 0xe0(%rbx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
andq $0x0, 0x30(%rsi)
leaq 0x35007(%rip), %rax     # 0x576b0
movq (%rax), %rdx
addq %rdx, %r13
notq %rdx
andq %r13, %rdx
addq (%rsp), %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r12, %rcx
callq 0x29533
movq 0x8(%rsp), %rdi
callq 0x10440
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_lg_dirty_mult_get
ssize_t
arena_lg_dirty_mult_get(arena_t *arena)
{
	ssize_t lg_dirty_mult;

	malloc_mutex_lock(&arena->lock);
	lg_dirty_mult = arena->lg_dirty_mult;
	malloc_mutex_unlock(&arena->lock);

	return (lg_dirty_mult);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x106d0
movq 0xd0(%rbx), %rbx
movq %r14, %rdi
callq 0x10440
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_lg_dirty_mult_set
bool
arena_lg_dirty_mult_set(arena_t *arena, ssize_t lg_dirty_mult)
{

	if (!arena_lg_dirty_mult_valid(lg_dirty_mult))
		return (true);

	malloc_mutex_lock(&arena->lock);
	arena->lg_dirty_mult = lg_dirty_mult;
	arena_maybe_purge(arena);
	malloc_mutex_unlock(&arena->lock);

	return (false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq -0x40(%rsi), %r12
cmpq $-0x41, %r12
jb 0x229dc
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x106d0
movq %r14, 0xd0(%rbx)
movq %rbx, %rdi
callq 0x229ef
movq %r15, %rdi
callq 0x10440
cmpq $-0x41, %r12
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_maybe_purge
void
arena_maybe_purge(arena_t *arena)
{

	/* Don't purge if the option is disabled. */
	if (arena->lg_dirty_mult < 0)
		return;
	/* Don't recursively purge. */
	if (arena->purging)
		return;
	/*
	 * Iterate, since preventing recursive purging could otherwise leave too
	 * many dirty pages.
	 */
	while (true) {
		size_t threshold = (arena->nactive >> arena->lg_dirty_mult);
		if (threshold < chunk_npages)
			threshold = chunk_npages;
		/*
		 * Don't purge unless the number of purgeable pages exceeds the
		 * threshold.
		 */
		if (arena->ndirty <= threshold)
			return;
		arena_purge(arena, false);
	}
}

// Assembly:
movq 0xd0(%rdi), %rcx
testq %rcx, %rcx
js 0x22a12
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0xd8(%rdi)
je 0x22a13
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x34c9e(%rip), %r14     # 0x576b8
movq 0xe0(%rbx), %rax
shrq %cl, %rax
movq (%r14), %rcx
cmpq %rcx, %rax
cmovbeq %rcx, %rax
cmpq %rax, 0xe8(%rbx)
jbe 0x22a0b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x22a4a
movq 0xd0(%rbx), %rcx
jmp 0x22a1a
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_reg_alloc
JEMALLOC_INLINE_C void *
arena_run_reg_alloc(arena_run_t *run, arena_bin_info_t *bin_info)
{
	void *ret;
	unsigned regind;
	arena_chunk_map_misc_t *miscelm;
	void *rpages;

	assert(run->nfree > 0);
	assert(!bitmap_full(run->bitmap, &bin_info->bitmap_info));

	regind = bitmap_sfu(run->bitmap, &bin_info->bitmap_info);
	miscelm = arena_run_to_miscelm(run);
	rpages = arena_miscelm_to_rpages(miscelm);
	ret = (void *)((uintptr_t)rpages + (uintptr_t)bin_info->reg0_offset +
	    (uintptr_t)(bin_info->reg_interval * regind));
	run->nfree--;
	return (ret);
}

// Assembly:
leaq 0x8(%rdi), %rdx
movl 0x30(%rsi), %r9d
leal -0x1(%r9), %eax
movq 0x38(%rsi,%rax,8), %rcx
movq 0x8(%rdi,%rcx,8), %rcx
bsfq %rcx, %r8
movabsq $-0x1, %rcx
cmoveq %rcx, %r8
subq $0x1, %rax
jb 0x23106
movq 0x38(%rsi,%rax,8), %r10
leaq (%rdx,%r10,8), %r10
movq (%r10,%r8,8), %r10
shlq $0x6, %r8
bsfq %r10, %r10
cmoveq %rcx, %r10
addq %r10, %r8
jmp 0x230e2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rax
shrq $0x6, %rax
movq (%rdx,%rax,8), %r11
movabsq $0x1, %r10
movq %r10, %rbx
movl %r8d, %ecx
shlq %cl, %rbx
movq %r11, %rcx
btcq %r8, %rcx
movq %rcx, (%rdx,%rax,8)
cmpq %rbx, %r11
jne 0x2317f
movabsq $0x8, %r11
leaq -0x7(%r11), %rcx
cmpq %r9, %rcx
jae 0x2317f
movq %rax, %rbx
shrq $0x6, %rbx
movq (%rsi,%r11,8), %r14
movq %r10, %r15
movl %eax, %ecx
shlq %cl, %r15
leaq (%rdx,%r14,8), %rcx
movq (%rcx,%rbx,8), %r14
movq %r14, %r12
btcq %rax, %r12
movq %r12, (%rcx,%rbx,8)
incq %r11
movq %rbx, %rax
cmpq %r15, %r14
je 0x23145
leaq -0x10(%rdi), %rax
leaq 0x34526(%rip), %rcx     # 0x576b0
movq (%rcx), %rcx
notq %rcx
andq %rax, %rcx
movq 0x343c6(%rip), %rax     # 0x57560
addq %rcx, %rax
negq %rax
addq %rdi, %rax
addq $-0x10, %rax
movabsq $0x60, %r9
xorl %edx, %edx
divq %r9
addq 0x3439b(%rip), %rax     # 0x57558
shlq $0xc, %rax
movl %r8d, %edx
imulq 0x10(%rsi), %rdx
movl 0x58(%rsi), %esi
addq %rsi, %rdx
addq %rcx, %rdx
addq %rdx, %rax
decl 0x4(%rdi)
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_alloc_junk_small
void
arena_alloc_junk_small(void *ptr, arena_bin_info_t *bin_info, bool zero)
{

	if (zero) {
		size_t redzone_size = bin_info->redzone_size;
		memset((void *)((uintptr_t)ptr - redzone_size), 0xa5,
		    redzone_size);
		memset((void *)((uintptr_t)ptr + bin_info->reg_size), 0xa5,
		    redzone_size);
	} else {
		memset((void *)((uintptr_t)ptr - bin_info->redzone_size), 0xa5,
		    bin_info->reg_interval);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x233d4
movq 0x8(%r14), %r15
movq %rbx, %rdi
subq %r15, %rdi
movl $0xa5, %esi
movq %r15, %rdx
callq 0x10270
addq (%r14), %rbx
movq %rbx, %rdi
movl $0xa5, %esi
movq %r15, %rdx
jmp 0x233e4
subq 0x8(%r14), %rbx
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movl $0xa5, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x10270
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_dalloc_junk_small
void
arena_dalloc_junk_small(void *ptr, arena_bin_info_t *bin_info)
{
	size_t redzone_size = bin_info->redzone_size;

	arena_redzones_validate(ptr, bin_info, false);
	memset((void *)((uintptr_t)ptr - redzone_size), 0x5a,
	    bin_info->reg_interval);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
subq 0x8(%rsi), %r14
xorl %edx, %edx
callq 0x23419
movq 0x10(%rbx), %rdx
pushq $0x5a
popq %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10270
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_redzones_validate
static void
arena_redzones_validate(void *ptr, arena_bin_info_t *bin_info, bool reset)
{
	bool error = false;

	if (opt_junk_alloc) {
		size_t size = bin_info->reg_size;
		size_t redzone_size = bin_info->redzone_size;
		size_t i;

		for (i = 1; i <= redzone_size; i++) {
			uint8_t *byte = (uint8_t *)((uintptr_t)ptr - i);
			if (*byte != 0xa5) {
				error = true;
				arena_redzone_corruption(ptr, size, false, i,
				    *byte);
				if (reset)
					*byte = 0xa5;
			}
		}
		for (i = 0; i < redzone_size; i++) {
			uint8_t *byte = (uint8_t *)((uintptr_t)ptr + size + i);
			if (*byte != 0xa5) {
				error = true;
				arena_redzone_corruption(ptr, size, true, i,
				    *byte);
				if (reset)
					*byte = 0xa5;
			}
		}
	}

	if (opt_abort && error)
		abort();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x331f6(%rip), %rax     # 0x56621
cmpb $0x1, (%rax)
jne 0x234c5
movl %edx, %ebx
movq %rdi, %r14
movq (%rsi), %r15
movq 0x8(%rsi), %r13
leaq -0x1(%rdi), %rbp
pushq $0x1
popq %r12
xorl %eax, %eax
cmpq %r13, %r12
ja 0x2347d
movb (%rbp), %cl
cmpb $-0x5b, %cl
je 0x23475
movzbl %cl, %r8d
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x28453
movb $0x1, %al
testb %bl, %bl
je 0x23475
movb $-0x5b, (%rbp)
incq %r12
decq %rbp
jmp 0x2344a
leaq (%r15,%r14), %rbp
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x234b8
movb (%rbp,%r12), %cl
cmpb $-0x5b, %cl
je 0x234b3
movzbl %cl, %r8d
movq %r14, %rdi
movq %r15, %rsi
pushq $0x1
popq %rdx
movq %r12, %rcx
callq 0x28453
movb $0x1, %al
testb %bl, %bl
je 0x234b3
movb $-0x5b, (%r12,%rbp)
incq %r12
jmp 0x23484
leaq 0x33161(%rip), %rcx     # 0x56620
andb (%rcx), %al
cmpb $0x1, %al
je 0x234d4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x10090
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_quarantine_junk_small
void
arena_quarantine_junk_small(void *ptr, size_t usize)
{
	szind_t binind;
	arena_bin_info_t *bin_info;
	cassert(config_fill);
	assert(opt_junk_free);
	assert(opt_quarantine);
	assert(usize <= SMALL_MAXCLASS);

	binind = size2index(usize);
	bin_info = &arena_bin_info[binind];
	arena_redzones_validate(ptr, bin_info, true);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x1000, %rsi           # imm = 0x1000
ja 0x23514
decq %rsi
shrq $0x3, %rsi
leaq 0x1f60c(%rip), %rax     # 0x42b00
movzbl (%rax,%rsi), %eax
movl %eax, %eax
imulq $0x60, %rax, %rax
leaq 0x3319b(%rip), %rsi     # 0x566a0
addq %rax, %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x23419
movq %rsi, %rdi
callq 0x284a4
jmp 0x234f8