LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sentinel.c
// Function: sentinelHandleDictOfRedisInstances
void sentinelHandleDictOfRedisInstances(dict *instances) {
    dictIterator *di;
    dictEntry *de;
    sentinelRedisInstance *switch_to_promoted = NULL;

    /* There are a number of things we need to perform against every master. */
    di = dictGetIterator(instances);
    while((de = dictNext(di)) != NULL) {
        sentinelRedisInstance *ri = dictGetVal(de);

        sentinelHandleRedisInstance(ri);
        if (ri->flags & SRI_MASTER) {
            sentinelHandleDictOfRedisInstances(ri->slaves);
            sentinelHandleDictOfRedisInstances(ri->sentinels);
            if (ri->failover_state == SENTINEL_FAILOVER_STATE_UPDATE_CONFIG) {
                switch_to_promoted = ri;
            }
        }
    }
    if (switch_to_promoted)
        sentinelFailoverSwitchToPromotedSlave(switch_to_promoted);
    dictReleaseIterator(di);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2e400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e4a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9c880
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9c720
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x9c87e
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x9c7f0
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x9c7f0
movq -0x28(%rbp), %rax
cmpl $0x6, 0xf0(%rax)
jne 0x9c87c
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x9c87e
jmp 0x9c811
cmpq $0x0, -0x20(%rbp)
je 0x9c890
movq -0x20(%rbp), %rdi
callq 0x9c5a0
movq -0x10(%rbp), %rdi
callq 0x2e600
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sentinel.c
// Function: sentinelCheckTiltCondition
void sentinelCheckTiltCondition(void) {
    mstime_t now = mstime();
    mstime_t delta = now - sentinel.previous_time;

    if (delta < 0 || delta > SENTINEL_TILT_TRIGGER) {
        sentinel.tilt = 1;
        sentinel.tilt_start_time = mstime();
        sentinelEvent(LL_WARNING,"+tilt",NULL,"#tilt mode entered");
    }
    sentinel.previous_time = mstime();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x2ff70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
subq 0xf079c(%rip), %rax     # 0x18d058
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x9c8d1
cmpq $0x7d0, -0x10(%rbp)     # imm = 0x7D0
jle 0x9c905
movl $0x1, 0xf076d(%rip)     # 0x18d048
callq 0x2ff70
movq %rax, 0xf0769(%rip)     # 0x18d050
movl $0x3, %edi
leaq 0xaab78(%rip), %rsi     # 0x14746b
xorl %eax, %eax
movl %eax, %edx
leaq 0xaab73(%rip), %rcx     # 0x147471
movb $0x0, %al
callq 0x94990
callq 0x2ff70
movq %rax, 0xf0747(%rip)     # 0x18d058
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sentinel.c
// Function: sentinelTimer
void sentinelTimer(void) {
    sentinelCheckTiltCondition();
    sentinelHandleDictOfRedisInstances(sentinel.masters);
    sentinelRunPendingScripts();
    sentinelCollectTerminatedScripts();
    sentinelKillTimedoutScripts();

    /* We continuously change the frequency of the Redis "timer interrupt"
     * in order to desynchronize every Sentinel from every other.
     * This non-determinism avoids that Sentinels started at the same time
     * exactly continue to stay synchronized asking to be voted at the
     * same time again and again (resulting in nobody likely winning the
     * election because of split brain voting). */
    server.hz = CONFIG_DEFAULT_HZ + rand() % CONFIG_DEFAULT_HZ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x9c8a0
movq 0xf0710(%rip), %rdi     # 0x18d040
callq 0x9c7f0
callq 0x95190
callq 0x95360
callq 0x954e0
callq 0x26b80
movl $0xa, %ecx
cltd
idivl %ecx
addl $0xa, %edx
leaq 0xdb87d(%rip), %rax     # 0x1781d8
movl %edx, 0x20(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sentinel.c
// Function: redisAeAddRead
static void redisAeAddRead(void *privdata) {
    redisAeEvents *e = (redisAeEvents*)privdata;
    aeEventLoop *loop = e->loop;
    if (!e->reading) {
        e->reading = 1;
        aeCreateFileEvent(loop,e->fd,AE_READABLE,redisAeReadEvent,e);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x9c9b5
movq -0x10(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %r8
movl $0x1, %edx
leaq 0x150(%rip), %rcx       # 0x9cb00
callq 0x2a8f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sentinel.c
// Function: redisAeDelRead
static void redisAeDelRead(void *privdata) {
    redisAeEvents *e = (redisAeEvents*)privdata;
    aeEventLoop *loop = e->loop;
    if (e->reading) {
        e->reading = 0;
        aeDeleteFileEvent(loop,e->fd,AE_READABLE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x9ca0a
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movl $0x1, %edx
callq 0x2aab0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sentinel.c
// Function: redisAeAddWrite
static void redisAeAddWrite(void *privdata) {
    redisAeEvents *e = (redisAeEvents*)privdata;
    aeEventLoop *loop = e->loop;
    if (!e->writing) {
        e->writing = 1;
        aeCreateFileEvent(loop,e->fd,AE_WRITABLE,redisAeWriteEvent,e);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x9ca65
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %r8
movl $0x2, %edx
leaq 0xd0(%rip), %rcx        # 0x9cb30
callq 0x2a8f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sentinel.c
// Function: redisAeDelWrite
static void redisAeDelWrite(void *privdata) {
    redisAeEvents *e = (redisAeEvents*)privdata;
    aeEventLoop *loop = e->loop;
    if (e->writing) {
        e->writing = 0;
        aeDeleteFileEvent(loop,e->fd,AE_WRITABLE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x9caba
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movl $0x2, %edx
callq 0x2aab0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sentinel.c
// Function: redisAeCleanup
static void redisAeCleanup(void *privdata) {
    redisAeEvents *e = (redisAeEvents*)privdata;
    redisAeDelRead(privdata);
    redisAeDelWrite(privdata);
    zfree(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9c9c0
movq -0x8(%rbp), %rdi
callq 0x9ca70
movq -0x10(%rbp), %rdi
callq 0x3afa0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/notify.c
// Function: keyspaceEventsStringToFlags
int keyspaceEventsStringToFlags(char *classes) {
    char *p = classes;
    int c, flags = 0;

    while((c = *p++) != '\0') {
        switch(c) {
        case 'A': flags |= NOTIFY_ALL; break;
        case 'g': flags |= NOTIFY_GENERIC; break;
        case '$': flags |= NOTIFY_STRING; break;
        case 'l': flags |= NOTIFY_LIST; break;
        case 's': flags |= NOTIFY_SET; break;
        case 'h': flags |= NOTIFY_HASH; break;
        case 'z': flags |= NOTIFY_ZSET; break;
        case 'x': flags |= NOTIFY_EXPIRED; break;
        case 'e': flags |= NOTIFY_EVICTED; break;
        case 'K': flags |= NOTIFY_KEYSPACE; break;
        case 'E': flags |= NOTIFY_KEYEVENT; break;
        default: return -1;
        }
    }
    return flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x9cc4d
movl -0x1c(%rbp), %eax
addl $-0x24, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x56, %eax
ja 0x9cc3f
movq -0x28(%rbp), %rax
leaq 0xaa8cf(%rip), %rcx     # 0x147484
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x20(%rbp), %eax
orl $0x3fc, %eax            # imm = 0x3FC
movl %eax, -0x20(%rbp)
jmp 0x9cc48
movl -0x20(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x20(%rbp)
jmp 0x9cc48
movl -0x20(%rbp), %eax
orl $0x8, %eax
movl %eax, -0x20(%rbp)
jmp 0x9cc48
movl -0x20(%rbp), %eax
orl $0x10, %eax
movl %eax, -0x20(%rbp)
jmp 0x9cc48
movl -0x20(%rbp), %eax
orl $0x20, %eax
movl %eax, -0x20(%rbp)
jmp 0x9cc48
movl -0x20(%rbp), %eax
orl $0x40, %eax
movl %eax, -0x20(%rbp)
jmp 0x9cc48
movl -0x20(%rbp), %eax
orl $0x80, %eax
movl %eax, -0x20(%rbp)
jmp 0x9cc48
movl -0x20(%rbp), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, -0x20(%rbp)
jmp 0x9cc48
movl -0x20(%rbp), %eax
orl $0x200, %eax            # imm = 0x200
movl %eax, -0x20(%rbp)
jmp 0x9cc48
movl -0x20(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9cc48
movl -0x20(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x20(%rbp)
jmp 0x9cc48
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9cc53
jmp 0x9cb77
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/setproctitle.c
// Function: spt_copyenv
static int spt_copyenv(char *oldenv[]) {
	extern char **environ;
	char *eq;
	int i, error;

	if (environ != oldenv)
		return 0;

	if ((error = spt_clearenv()))
		goto error;

	for (i = 0; oldenv[i]; i++) {
		if (!(eq = strchr(oldenv[i], '=')))
			continue;

		*eq = '\0';
		error = (0 != setenv(oldenv[i], eq + 1, 1))? errno : 0;
		*eq = '=';

		if (error)
			goto error;
	}

	return 0;
error:
	environ = oldenv;

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq 0xd5d55(%rip), %rax     # 0x172fa8
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x9d268
movl $0x0, -0x4(%rbp)
jmp 0x9d338
callq 0x9d6c0
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x9d27a
jmp 0x9d324
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x9d31b
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x3d, %esi
callq 0x267f0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x9d2b6
jmp 0x9d30d
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movl $0x1, %edx
callq 0x26830
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x9d2ef
callq 0x26880
movl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x9d2f6
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x9d2f6
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb $0x3d, (%rax)
cmpl $0x0, -0x20(%rbp)
je 0x9d30b
jmp 0x9d324
jmp 0x9d30d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9d281
movl $0x0, -0x4(%rbp)
jmp 0x9d338
movq -0x10(%rbp), %rcx
movq 0xd5c79(%rip), %rax     # 0x172fa8
movq %rcx, (%rax)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/setproctitle.c
// Function: spt_copyargs
static int spt_copyargs(int argc, char *argv[]) {
	char *tmp;
	int i;

	for (i = 1; i < argc || (i >= argc && argv[i]); i++) {
		if (!argv[i])
			continue;

		if (!(tmp = strdup(argv[i])))
			return errno;

		argv[i] = tmp;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movb $0x1, %al
cmpl -0x8(%rbp), %ecx
movb %al, -0x1d(%rbp)
jl 0x9d399
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0x1e(%rbp)
jl 0x9d393
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x9d3a2
jmp 0x9d3f8
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x9d3b3
jmp 0x9d3ea
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x268b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x9d3da
callq 0x26880
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x9d3ff
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9d366
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/blocked.c
// Function: getTimeoutFromObjectOrReply
int getTimeoutFromObjectOrReply(client *c, robj *object, mstime_t *timeout, int unit) {
    long long tval;

    if (getLongLongFromObjectOrReply(c,object,&tval,
        "timeout is not an integer or out of range") != C_OK)
        return C_ERR;

    if (tval < 0) {
        addReplyError(c,"timeout is negative");
        return C_ERR;
    }

    if (tval > 0) {
        if (unit == UNIT_SECONDS) tval *= 1000;
        tval += mstime();
    }
    *timeout = tval;

    return C_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq 0xa9f1a(%rip), %rcx     # 0x147614
callq 0x49ea0
cmpl $0x0, %eax
je 0x9d70d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9d765
cmpq $0x0, -0x30(%rbp)
jge 0x9d72d
movq -0x10(%rbp), %rdi
leaq 0xa9f1f(%rip), %rsi     # 0x14763e
callq 0x42f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9d765
cmpq $0x0, -0x30(%rbp)
jle 0x9d753
cmpl $0x0, -0x24(%rbp)
jne 0x9d746
imulq $0x3e8, -0x30(%rbp), %rax # imm = 0x3E8
movq %rax, -0x30(%rbp)
callq 0x2ff70
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/blocked.c
// Function: processUnblockedClients
void processUnblockedClients(void) {
    listNode *ln;
    client *c;

    while (listLength(server.unblocked_clients)) {
        ln = listFirst(server.unblocked_clients);
        serverAssert(ln != NULL);
        c = ln->value;
        listDelNode(server.unblocked_clients,ln);
        c->flags &= ~CLIENT_UNBLOCKED;

        /* Process remaining data in the input buffer, unless the client
         * is blocked again. Actually processInputBuffer() checks that the
         * client is not blocked before to proceed, but things may change and
         * the code is conceptually more correct this way. */
        if (!(c->flags & CLIENT_BLOCKED)) {
            if (c->querybuf && sdslen(c->querybuf) > 0) {
                processInputBuffer(c);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xdaa09(%rip), %rax     # 0x1781d8
movq 0x920(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x9d89a
leaq 0xda9f0(%rip), %rax     # 0x1781d8
movq 0x920(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9d7ff
jmp 0x9d821
leaq 0x9d2de(%rip), %rdi     # 0x13aae4
leaq 0xa9e45(%rip), %rsi     # 0x147652
movl $0x73, %edx
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0xda9a4(%rip), %rax     # 0x1781d8
movq 0x920(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x271e0
movq -0x10(%rbp), %rax
movl 0x98(%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
movl %ecx, 0x98(%rax)
movq -0x10(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x9d895
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x9d893
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x9d8a0
cmpq $0x0, %rax
jbe 0x9d893
movq -0x10(%rbp), %rdi
callq 0x45360
jmp 0x9d895
jmp 0x9d7c8
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/blocked.c
// Function: unblockClient
void unblockClient(client *c) {
    if (c->btype == BLOCKED_LIST) {
        unblockClientWaitingData(c);
    } else if (c->btype == BLOCKED_WAIT) {
        unblockClientWaitingReplicas(c);
    } else {
        serverPanic("Unknown btype in unblockClient().");
    }
    /* Clear the flags, and put the client in the unblocked list so that
     * we'll process new commands in its query buffer ASAP. */
    c->flags &= ~CLIENT_BLOCKED;
    c->btype = BLOCKED_NONE;
    server.bpop_blocked_clients--;
    /* The client may already be into the unblocked list because of a previous
     * blocking operation, don't add back it into the list multiple times. */
    if (!(c->flags & CLIENT_UNBLOCKED)) {
        c->flags |= CLIENT_UNBLOCKED;
        listAddNodeTail(server.unblocked_clients,c);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x168(%rax)
jne 0x9d954
movq -0x8(%rbp), %rdi
callq 0x5ac30
jmp 0x9d990
movq -0x8(%rbp), %rax
cmpl $0x2, 0x168(%rax)
jne 0x9d96c
movq -0x8(%rbp), %rdi
callq 0x52270
jmp 0x9d98e
leaq 0xa9ce9(%rip), %rdi     # 0x14765c
leaq 0xa9cd8(%rip), %rsi     # 0x147652
movl $0x8c, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x9d990
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
andl $-0x11, %ecx
movl %ecx, 0x98(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x168(%rax)
leaq 0xda820(%rip), %rax     # 0x1781d8
movl 0x918(%rax), %ecx
addl $-0x1, %ecx
leaq 0xda810(%rip), %rax     # 0x1781d8
movl %ecx, 0x918(%rax)
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x9da0f
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
orl $0x80, %ecx
movl %ecx, 0x98(%rax)
leaq 0xda7d9(%rip), %rax     # 0x1781d8
movq 0x920(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x27000
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/blocked.c
// Function: replyToBlockedClientTimedOut
void replyToBlockedClientTimedOut(client *c) {
    if (c->btype == BLOCKED_LIST) {
        addReply(c,shared.nullmultibulk);
    } else if (c->btype == BLOCKED_WAIT) {
        addReplyLongLong(c,replicationCountAcksByOffset(c->bpop.reploffset));
    } else {
        serverPanic("Unknown btype in replyToBlockedClientTimedOut().");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x168(%rax)
jne 0x9da4f
movq -0x8(%rbp), %rdi
leaq 0xdb1fc(%rip), %rax     # 0x178c40
movq 0x58(%rax), %rsi
callq 0x42cc0
jmp 0x9daa6
movq -0x8(%rbp), %rax
cmpl $0x2, 0x168(%rax)
jne 0x9da82
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x190(%rax), %rdi
callq 0x520e0
movq -0x10(%rbp), %rdi
movslq %eax, %rsi
callq 0x43780
jmp 0x9daa4
leaq 0xa9bf7(%rip), %rdi     # 0x147680
leaq 0xa9bc2(%rip), %rsi     # 0x147652
movl $0xa3, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x9daa6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/blocked.c
// Function: disconnectAllBlockedClients
void disconnectAllBlockedClients(void) {
    listNode *ln;
    listIter li;

    listRewind(server.clients,&li);
    while((ln = listNext(&li))) {
        client *c = listNodeValue(ln);

        if (c->flags & CLIENT_BLOCKED) {
            addReplySds(c,sdsnew(
                "-UNBLOCKED force unblock from blocking operation, "
                "instance state changed (master -> slave?)\r\n"));
            unblockClient(c);
            c->flags |= CLIENT_CLOSE_AFTER_REPLY;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0xda719(%rip), %rax     # 0x1781d8
movq 0x1c8(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x27320
leaq -0x18(%rbp), %rdi
callq 0x27380
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x9db3e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x9db3c
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xa9ba4(%rip), %rdi     # 0x1476b3
callq 0x38510
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x42e50
movq -0x20(%rbp), %rdi
callq 0x9d930
movq -0x20(%rbp), %rax
movl 0x98(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x98(%rax)
jmp 0x9dacf
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/hyperloglog.c
// Function: hllPatLen
int hllPatLen(unsigned char *ele, size_t elesize, long *regp) {
    uint64_t hash, bit, index;
    int count;

    /* Count the number of zeroes starting from bit HLL_REGISTERS
     * (that is a power of two corresponding to the first bit we don't use
     * as index). The max run can be 64-P+1 bits.
     *
     * Note that the final "1" ending the sequence of zeroes must be
     * included in the count, so if we find "001" the count is 3, and
     * the smallest count possible is no zeroes at all, just a 1 bit
     * at the first position, that is a count of 1.
     *
     * This may sound like inefficient, but actually in the average case
     * there are high probabilities to find a 1 after a few iterations. */
    hash = MurmurHash64A(ele,elesize,0xadc83b19ULL);
    index = hash & HLL_P_MASK; /* Register index. */
    hash |= ((uint64_t)1<<63); /* Make sure the loop terminates. */
    bit = HLL_REGISTERS; /* First bit not used to address the register. */
    count = 1; /* Initialized to 1 since we count the "00000...1" pattern. */
    while((hash & bit) == 0) {
        count++;
        bit <<= 1;
    }
    *regp = (int) index;
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
movl $0xadc83b19, %edx       # imm = 0xADC83B19
callq 0x9db50
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq $0x3fff, %rax           # imm = 0x3FFF
movq %rax, -0x30(%rbp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x4000, -0x28(%rbp)    # imm = 0x4000
movl $0x1, -0x34(%rbp)
movq -0x20(%rbp), %rax
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
jne 0x9ddaf
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x28(%rbp)
jmp 0x9dd8b
movq -0x30(%rbp), %rax
movslq %eax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/hyperloglog.c
// Function: hllDenseAdd
int hllDenseAdd(uint8_t *registers, unsigned char *ele, size_t elesize) {
    uint8_t oldcount, count;
    long index;

    /* Update the register if this element produced a longer run of zeroes. */
    count = hllPatLen(ele,elesize,&index);
    HLL_DENSE_GET_REGISTER(oldcount,registers,index);
    if (count > oldcount) {
        HLL_DENSE_SET_REGISTER(registers,index,count);
        return 1;
    } else {
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x9dd30
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
imulq $0x6, -0x30(%rbp), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movq %rax, -0x40(%rbp)
imulq $0x6, -0x30(%rbp), %rax
andq $0x7, %rax
movq %rax, -0x48(%rbp)
movl $0x8, %eax
subq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %eax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
shrq %cl, %rax
movq -0x60(%rbp), %rdx
movq -0x50(%rbp), %rcx
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
andq $0x3f, %rax
movb %al, -0x21(%rbp)
movzbl -0x22(%rbp), %eax
movzbl -0x21(%rbp), %ecx
cmpl %ecx, %eax
jle 0x9df55
jmp 0x9de86
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
imulq $0x6, -0x30(%rbp), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movq %rax, -0x70(%rbp)
imulq $0x6, -0x30(%rbp), %rax
andq $0x7, %rax
movq %rax, -0x78(%rbp)
movl $0x8, %eax
subq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
movzbl -0x22(%rbp), %eax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rax
movl %eax, %ecx
movl $0x3f, %esi
shll %cl, %esi
xorl $-0x1, %esi
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
movzbl (%rax,%rcx), %edx
andl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x88(%rbp), %rsi
movq -0x78(%rbp), %rcx
shlq %cl, %rsi
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
movzbl (%rax,%rcx), %edx
orq %rsi, %rdx
movb %dl, (%rax,%rcx)
movq -0x80(%rbp), %rax
movl %eax, %ecx
movl $0x3f, %esi
sarl %cl, %esi
xorl $-0x1, %esi
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %edx
andl %esi, %edx
movb %dl, 0x1(%rax,%rcx)
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rcx
shrq %cl, %rsi
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %edx
orq %rsi, %rdx
movb %dl, 0x1(%rax,%rcx)
movl $0x1, -0x4(%rbp)
jmp 0x9df5c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/hyperloglog.c
// Function: hllAdd
int hllAdd(robj *o, unsigned char *ele, size_t elesize) {
    struct hllhdr *hdr = o->ptr;
    switch(hdr->encoding) {
    case HLL_DENSE: return hllDenseAdd(hdr->registers,ele,elesize);
    case HLL_SPARSE: return hllSparseAdd(o,ele,elesize);
    default: return -1; /* Invalid representation. */
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x9f74b
jmp 0x9f741
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x9f765
jmp 0x9f77b
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9ddd0
movl %eax, -0x4(%rbp)
jmp 0x9f782
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9e6f0
movl %eax, -0x4(%rbp)
jmp 0x9f782
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/hyperloglog.c
// Function: createHLLObject
robj *createHLLObject(void) {
    robj *o;
    struct hllhdr *hdr;
    sds s;
    uint8_t *p;
    int sparselen = HLL_HDR_SIZE +
                    (((HLL_REGISTERS+(HLL_SPARSE_XZERO_MAX_LEN-1)) /
                     HLL_SPARSE_XZERO_MAX_LEN)*2);
    int aux;

    /* Populate the sparse representation with as many XZERO opcodes as
     * needed to represent all the registers. */
    aux = HLL_REGISTERS;
    s = sdsnewlen(NULL,sparselen);
    p = (uint8_t*)s + HLL_HDR_SIZE;
    while(aux) {
        int xzero = HLL_SPARSE_XZERO_MAX_LEN;
        if (xzero > aux) xzero = aux;
        HLL_SPARSE_XZERO_SET(p,xzero);
        p += 2;
        aux -= xzero;
    }
    serverAssert((p-(uint8_t*)s) == sparselen);

    /* Create the actual object. */
    o = createObject(OBJ_STRING,s);
    hdr = o->ptr;
    memcpy(hdr->magic,"HYLL",4);
    hdr->encoding = HLL_SPARSE;
    return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x12, -0x24(%rbp)
movl $0x4000, -0x28(%rbp)    # imm = 0x4000
movslq -0x24(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x38230
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x9fab4
movl $0x4000, -0x2c(%rbp)    # imm = 0x4000
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x9fa6e
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x9fa70
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
sarl $0x8, %eax
orl $0x40, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x30(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x28(%rbp)
jmp 0x9fa53
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movslq -0x24(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9faca
jmp 0x9faec
leaq 0xa7d2c(%rip), %rdi     # 0x1477fd
leaq 0xa7cea(%rip), %rsi     # 0x1477c2
movl $0x457, %edx            # imm = 0x457
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x18(%rbp), %rsi
xorl %edi, %edi
callq 0x48480
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xa7d09(%rip), %ecx     # 0x14781a
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x4(%rax)
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/src/hyperloglog.c
// Function: isHLLObjectOrReply
int isHLLObjectOrReply(client *c, robj *o) {
    struct hllhdr *hdr;

    /* Key exists, check type */
    if (checkType(c,o,OBJ_STRING))
        return C_ERR; /* Error already sent. */

    if (!sdsEncodedObject(o)) goto invalid;
    if (stringObjectLen(o) < sizeof(*hdr)) goto invalid;
    hdr = o->ptr;

    /* Magic should be "HYLL". */
    if (hdr->magic[0] != 'H' || hdr->magic[1] != 'Y' ||
        hdr->magic[2] != 'L' || hdr->magic[3] != 'L') goto invalid;

    if (hdr->encoding > HLL_MAX_ENCODING) goto invalid;

    /* Dense representation string length should match exactly. */
    if (hdr->encoding == HLL_DENSE &&
        stringObjectLen(o) != HLL_DENSE_SIZE) goto invalid;

    /* All tests passed. */
    return C_OK;

invalid:
    addReplySds(c,
        sdsnew("-WRONGTYPE Key is not a valid "
               "HyperLogLog string value.\r\n"));
    return C_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x9fb60
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9fc38
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x9fb87
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x9fb87
jmp 0x9fc11
movq -0x18(%rbp), %rdi
callq 0x498c0
cmpq $0x10, %rax
jae 0x9fb98
jmp 0x9fc11
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x48, %eax
jne 0x9fbd7
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x59, %eax
jne 0x9fbd7
movq -0x20(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x4c, %eax
jne 0x9fbd7
movq -0x20(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x4c, %eax
je 0x9fbd9
jmp 0x9fc11
movq -0x20(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x1, %eax
jle 0x9fbe8
jmp 0x9fc11
movq -0x20(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
jne 0x9fc08
movq -0x18(%rbp), %rdi
callq 0x498c0
cmpq $0x3010, %rax           # imm = 0x3010
je 0x9fc08
jmp 0x9fc11
movl $0x0, -0x4(%rbp)
jmp 0x9fc38
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xa7bff(%rip), %rdi     # 0x14781f
callq 0x38510
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x42e50
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/latency.c
// Function: THPIsEnabled
int THPIsEnabled(void) {
    char buf[1024];

    FILE *fp = fopen("/sys/kernel/mm/transparent_hugepage/enabled","r");
    if (!fp) return 0;
    if (fgets(buf,sizeof(buf),fp) == NULL) {
        fclose(fp);
        return 0;
    }
    fclose(fp);
    return (strstr(buf,"[never]") == NULL) ? 1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
leaq 0xa68ea(%rip), %rdi     # 0x147a0c
leaq 0x996a0(%rip), %rsi     # 0x13a7c9
callq 0x26ae0
movq %rax, -0x418(%rbp)
cmpq $0x0, -0x418(%rbp)
jne 0xa1148
movl $0x0, -0x4(%rbp)
jmp 0xa11ae
leaq -0x410(%rbp), %rdi
movq -0x418(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x26440
cmpq $0x0, %rax
jne 0xa117b
movq -0x418(%rbp), %rdi
callq 0x26a10
movl $0x0, -0x4(%rbp)
jmp 0xa11ae
movq -0x418(%rbp), %rdi
callq 0x26a10
leaq -0x410(%rbp), %rdi
leaq 0xa68a3(%rip), %rsi     # 0x147a38
callq 0x266c0
movq %rax, %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/latency.c
// Function: latencyAddSample
void latencyAddSample(char *event, mstime_t latency) {
    struct latencyTimeSeries *ts = dictFetchValue(server.latency_events,event);
    time_t now = time(NULL);
    int prev;

    /* Create the time series if it does not exist. */
    if (ts == NULL) {
        ts = zmalloc(sizeof(*ts));
        ts->idx = 0;
        ts->max = 0;
        memset(ts->samples,0,sizeof(ts->samples));
        dictAdd(server.latency_events,zstrdup(event),ts);
    }

    /* If the previous sample is in the same second, we update our old sample
     * if this latency is > of the old one, or just return. */
    prev = (ts->idx + LATENCY_TS_LEN - 1) % LATENCY_TS_LEN;
    if (ts->samples[prev].time == now) {
        if (latency > ts->samples[prev].latency)
            ts->samples[prev].latency = latency;
        return;
    }

    ts->samples[ts->idx].time = time(NULL);
    ts->samples[ts->idx].latency = latency;
    if (latency > ts->max) ts->max = latency;

    ts->idx++;
    if (ts->idx == LATENCY_TS_LEN) ts->idx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xd6fb1(%rip), %rax     # 0x1781d8
movq 0xa20(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x2e280
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x26ce0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa12b1
movl $0x508, %edi            # imm = 0x508
callq 0x3acd0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x500, %edx            # imm = 0x500
callq 0x26110
leaq 0xd6f4b(%rip), %rax     # 0x1781d8
movq 0xa20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b040
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x2d8c0
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $0xa0, %eax
subl $0x1, %eax
movl $0xa0, %ecx
cltd
idivl %ecx
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movslq 0x8(%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jne 0xa1306
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movl 0xc(%rcx,%rdx,8), %ecx
cmpq %rcx, %rax
jle 0xa1304
movq -0x10(%rbp), %rax
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, 0xc(%rax,%rcx,8)
jmp 0xa1373
xorl %eax, %eax
movl %eax, %edi
callq 0x26ce0
movl %eax, %edx
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, 0x8(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl %eax, %edx
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, 0xc(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jle 0xa1352
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0xa0, (%rax)
jne 0xa1373
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/latency.c
// Function: latencyResetEvent
int latencyResetEvent(char *event_to_reset) {
    dictIterator *di;
    dictEntry *de;
    int resets = 0;

    di = dictGetSafeIterator(server.latency_events);
    while((de = dictNext(di)) != NULL) {
        char *event = dictGetKey(de);

        if (event_to_reset == NULL || strcasecmp(event,event_to_reset) == 0) {
            dictDelete(server.latency_events, event);
            resets++;
        }
    }
    dictReleaseIterator(di);
    return resets;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0xd6e3e(%rip), %rax     # 0x1781d8
movq 0xa20(%rax), %rdi
callq 0x2e470
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e4a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa1403
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa13e1
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x26300
cmpl $0x0, %eax
jne 0xa1401
leaq 0xd6df0(%rip), %rax     # 0x1781d8
movq 0xa20(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2de50
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa13aa
movq -0x10(%rbp), %rdi
callq 0x2e600
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/latency.c
// Function: latencyCommandReplyWithSamples
void latencyCommandReplyWithSamples(client *c, struct latencyTimeSeries *ts) {
    void *replylen = addDeferredMultiBulkLength(c);
    int samples = 0, j;

    for (j = 0; j < LATENCY_TS_LEN; j++) {
        int i = (ts->idx + j) % LATENCY_TS_LEN;

        if (ts->samples[i].time == 0) continue;
        addReplyMultiBulkLen(c,2);
        addReplyLongLong(c,ts->samples[i].time);
        addReplyLongLong(c,ts->samples[i].latency);
        samples++;
    }
    setDeferredMultiBulkLength(c,replylen,samples);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x432a0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0xa0, -0x20(%rbp)
jge 0xa1f38
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl -0x20(%rbp), %eax
movl $0xa0, %ecx
cltd
idivl %ecx
movl %edx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, 0x8(%rax,%rcx,8)
jne 0xa1ee9
jmp 0xa1f2d
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x437f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movslq 0x8(%rax,%rcx,8), %rsi
callq 0x43780
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0xc(%rax,%rcx,8), %eax
movl %eax, %esi
callq 0x43780
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xa1ebb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x43310
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/latency.c
// Function: latencyCommandReplyWithLatestEvents
void latencyCommandReplyWithLatestEvents(client *c) {
    dictIterator *di;
    dictEntry *de;

    addReplyMultiBulkLen(c,dictSize(server.latency_events));
    di = dictGetIterator(server.latency_events);
    while((de = dictNext(di)) != NULL) {
        char *event = dictGetKey(de);
        struct latencyTimeSeries *ts = dictGetVal(de);
        int last = (ts->idx + LATENCY_TS_LEN - 1) % LATENCY_TS_LEN;

        addReplyMultiBulkLen(c,4);
        addReplyBulkCString(c,event);
        addReplyLongLong(c,ts->samples[last].time);
        addReplyLongLong(c,ts->samples[last].latency);
        addReplyLongLong(c,ts->max);
    }
    dictReleaseIterator(di);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd6271(%rip), %rax     # 0x1781d8
movq 0xa20(%rax), %rax
movq 0x28(%rax), %rsi
leaq 0xd625f(%rip), %rax     # 0x1781d8
movq 0xa20(%rax), %rax
addq 0x48(%rax), %rsi
callq 0x437f0
leaq 0xd6248(%rip), %rax     # 0x1781d8
movq 0xa20(%rax), %rdi
callq 0x2e400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e4a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa2046
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
addl $0xa0, %eax
subl $0x1, %eax
movl $0xa0, %ecx
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x437f0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43580
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movslq 0x8(%rax,%rcx,8), %rsi
callq 0x43780
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl 0xc(%rax,%rcx,8), %eax
movl %eax, %esi
callq 0x43780
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x43780
jmp 0xa1fa0
movq -0x10(%rbp), %rdi
callq 0x2e600
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sparkline.c
// Function: createSparklineSequence
struct sequence *createSparklineSequence(void) {
    struct sequence *seq = zmalloc(sizeof(*seq));
    seq->length = 0;
    seq->samples = NULL;
    return seq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x3acd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sparkline.c
// Function: sparklineSequenceAddSample
void sparklineSequenceAddSample(struct sequence *seq, double value, char *label) {
    label = (label == NULL || label[0] == '\0') ? NULL : zstrdup(label);
    if (seq->length == 0) {
        seq->min = seq->max = value;
    } else {
        if (value < seq->min) seq->min = value;
        else if (value > seq->max) seq->max = value;
    }
    seq->samples = zrealloc(seq->samples,sizeof(struct sample)*(seq->length+1));
    seq->samples[seq->length].value = value;
    seq->samples[seq->length].label = label;
    seq->length++;
    if (label) seq->labels++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa26a8
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa26b0
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0xa26bd
movq -0x18(%rbp), %rdi
callq 0x3b040
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xa26e7
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
jmp 0xa272d
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa270b
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
jmp 0xa272b
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
ucomisd 0x18(%rax), %xmm0
jbe 0xa2729
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
jmp 0xa272b
jmp 0xa272d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x4, %rsi
callq 0x3ae40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdx
movslq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0xa27b1
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sparkline.c
// Function: freeSparklineSequence
void freeSparklineSequence(struct sequence *seq) {
    int j;

    for (j = 0; j < seq->length; j++)
        zfree(seq->samples[j].label);
    zfree(seq->samples);
    zfree(seq);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xa2805
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x3afa0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa27d3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3afa0
movq -0x8(%rbp), %rdi
callq 0x3afa0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sparkline.c
// Function: sparklineRender
sds sparklineRender(sds output, struct sequence *seq, int columns, int rows, int flags) {
    int j;

    for (j = 0; j < seq->length; j += columns) {
        int sublen = (seq->length-j) < columns ? (seq->length-j) : columns;

        if (j != 0) output = sdscatlen(output,"\n",1);
        output = sparklineRenderRange(output, seq, rows, j, sublen, flags);
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xa2bcd
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xa2b78
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0xa2b7e
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xa2ba3
movq -0x8(%rbp), %rdi
leaq 0x972a4(%rip), %rsi     # 0x139e39
movl $0x1, %edx
callq 0x39040
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
movl -0x1c(%rbp), %r9d
callq 0xa2830
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xa2b51
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)