LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: bgrewriteaofCommand
void bgrewriteaofCommand(client *c) {
    if (server.aof_child_pid != -1) {
        addReplyError(c,"Background append only file rewriting already in progress");
    } else if (server.rdb_child_pid != -1) {
        server.aof_rewrite_scheduled = 1;
        addReplyStatus(c,"Background append only file rewriting scheduled");
    } else if (rewriteAppendOnlyFileBackground() == C_OK) {
        addReplyStatus(c,"Background append only file rewriting started");
    } else {
        addReply(c,shared.err);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x103fe5(%rip), %rax    # 0x1781d8
cmpl $-0x1, 0x69c(%rax)
je 0x7420e
movq -0x8(%rbp), %rdi
leaq 0xcbc5f(%rip), %rsi     # 0x13fe66
callq 0x42f90
jmp 0x74275
leaq 0x103fc3(%rip), %rax    # 0x1781d8
cmpl $-0x1, 0x730(%rax)
je 0x74241
leaq 0x103fb3(%rip), %rax    # 0x1781d8
movl $0x1, 0x698(%rax)
movq -0x8(%rbp), %rdi
leaq 0xcbc66(%rip), %rsi     # 0x13fea0
callq 0x43180
jmp 0x74273
callq 0x715a0
cmpl $0x0, %eax
jne 0x7425d
movq -0x8(%rbp), %rdi
leaq 0xcbc7a(%rip), %rsi     # 0x13fed0
callq 0x43180
jmp 0x74271
movq -0x8(%rbp), %rdi
leaq 0x1049d8(%rip), %rax    # 0x178c40
movq 0x10(%rax), %rsi
callq 0x42cc0
jmp 0x74273
jmp 0x74275
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/pubsub.c
// Function: pubsubSubscribeChannel
int pubsubSubscribeChannel(client *c, robj *channel) {
    dictEntry *de;
    list *clients = NULL;
    int retval = 0;

    /* Add the channel to the client -> channels hash table */
    if (dictAdd(c->pubsub_channels,channel,NULL) == DICT_OK) {
        retval = 1;
        incrRefCount(channel);
        /* Add the client to the channel -> list of clients hash table */
        de = dictFind(server.pubsub_channels,channel);
        if (de == NULL) {
            clients = listCreate();
            dictAdd(server.pubsub_channels,channel,clients);
            incrRefCount(channel);
        } else {
            clients = dictGetVal(de);
        }
        listAddNodeTail(clients,c);
    }
    /* Notify the client */
    addReply(c,shared.mbulkhdr[3]);
    addReply(c,shared.subscribebulk);
    addReplyBulk(c,channel);
    addReplyLongLong(c,clientSubscriptionsCount(c));
    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2d8c0
cmpl $0x0, %eax
jne 0x74966
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x487b0
leaq 0x1038d5(%rip), %rax    # 0x1781d8
movq 0x988(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2dcb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7494d
callq 0x26e20
movq %rax, -0x20(%rbp)
leaq 0x1038aa(%rip), %rax    # 0x1781d8
movq 0x988(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2d8c0
movq -0x10(%rbp), %rdi
callq 0x487b0
jmp 0x74959
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x27000
movq -0x8(%rbp), %rdi
leaq 0x1042cf(%rip), %rax    # 0x178c40
movq 0x13a48(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rdi
leaq 0x1042b8(%rip), %rax    # 0x178c40
movq 0x108(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43630
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x74870
movq -0x30(%rbp), %rdi
movslq %eax, %rsi
callq 0x43780
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/pubsub.c
// Function: pubsubSubscribePattern
int pubsubSubscribePattern(client *c, robj *pattern) {
    int retval = 0;

    if (listSearchKey(c->pubsub_patterns,pattern) == NULL) {
        retval = 1;
        pubsubPattern *pat;
        listAddNodeTail(c->pubsub_patterns,pattern);
        incrRefCount(pattern);
        pat = zmalloc(sizeof(*pat));
        pat->pattern = getDecodedObject(pattern);
        pat->client = c;
        listAddNodeTail(server.pubsub_patterns,pat);
    }
    /* Notify the client */
    addReply(c,shared.mbulkhdr[3]);
    addReply(c,shared.psubscribebulk);
    addReplyBulk(c,pattern);
    addReplyLongLong(c,clientSubscriptionsCount(c));
    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x274d0
cmpq $0x0, %rax
jne 0x74c19
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x27000
movq -0x10(%rbp), %rdi
callq 0x487b0
movl $0x10, %edi
callq 0x3acd0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x494f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
leaq 0x1035cf(%rip), %rax    # 0x1781d8
movq 0x990(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x27000
movq -0x8(%rbp), %rdi
leaq 0x10401c(%rip), %rax    # 0x178c40
movq 0x13a48(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rdi
leaq 0x104005(%rip), %rax    # 0x178c40
movq 0x118(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43630
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x74870
movq -0x28(%rbp), %rdi
movslq %eax, %rsi
callq 0x43780
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/pubsub.c
// Function: pubsubUnsubscribePattern
int pubsubUnsubscribePattern(client *c, robj *pattern, int notify) {
    listNode *ln;
    pubsubPattern pat;
    int retval = 0;

    incrRefCount(pattern); /* Protect the object. May be the same we remove */
    if ((ln = listSearchKey(c->pubsub_patterns,pattern)) != NULL) {
        retval = 1;
        listDelNode(c->pubsub_patterns,ln);
        pat.client = c;
        pat.pattern = pattern;
        ln = listSearchKey(server.pubsub_patterns,&pat);
        listDelNode(server.pubsub_patterns,ln);
    }
    /* Notify the client */
    if (notify) {
        addReply(c,shared.mbulkhdr[3]);
        addReply(c,shared.punsubscribebulk);
        addReplyBulk(c,pattern);
        addReplyLongLong(c,dictSize(c->pubsub_channels)+
                       listLength(c->pubsub_patterns));
    }
    decrRefCount(pattern);
    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x487b0
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x274d0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x74d1e
movl $0x1, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x271e0
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x1034e5(%rip), %rax    # 0x1781d8
movq 0x990(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x274d0
movq %rax, -0x20(%rbp)
leaq 0x1034ca(%rip), %rax    # 0x1781d8
movq 0x990(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x271e0
cmpl $0x0, -0x14(%rbp)
je 0x74d95
movq -0x8(%rbp), %rdi
leaq 0x103f11(%rip), %rax    # 0x178c40
movq 0x13a48(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rdi
leaq 0x103efa(%rip), %rax    # 0x178c40
movq 0x120(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43630
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
addq 0x48(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rax
addq 0x28(%rax), %rsi
callq 0x43780
movq -0x10(%rbp), %rdi
callq 0x48f70
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/pubsub.c
// Function: pubsubUnsubscribeAllChannels
int pubsubUnsubscribeAllChannels(client *c, int notify) {
    dictIterator *di = dictGetSafeIterator(c->pubsub_channels);
    dictEntry *de;
    int count = 0;

    while((de = dictNext(di)) != NULL) {
        robj *channel = dictGetKey(de);

        count += pubsubUnsubscribeChannel(c,channel,notify);
    }
    /* We were subscribed to nothing? Still reply to the client. */
    if (notify && count == 0) {
        addReply(c,shared.mbulkhdr[3]);
        addReply(c,shared.unsubscribebulk);
        addReply(c,shared.nullbulk);
        addReplyLongLong(c,dictSize(c->pubsub_channels)+
                       listLength(c->pubsub_patterns));
    }
    dictReleaseIterator(di);
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rdi
callq 0x2e470
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2e4a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x74e10
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x749d0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x74dda
cmpl $0x0, -0xc(%rbp)
je 0x74e94
cmpl $0x0, -0x24(%rbp)
jne 0x74e94
movq -0x8(%rbp), %rdi
leaq 0x103e19(%rip), %rax    # 0x178c40
movq 0x13a48(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rdi
leaq 0x103e02(%rip), %rax    # 0x178c40
movq 0x110(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rdi
leaq 0x103deb(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
addq 0x48(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rax
addq 0x28(%rax), %rsi
callq 0x43780
movq -0x18(%rbp), %rdi
callq 0x2e600
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/pubsub.c
// Function: pubsubUnsubscribeAllPatterns
int pubsubUnsubscribeAllPatterns(client *c, int notify) {
    listNode *ln;
    listIter li;
    int count = 0;

    listRewind(c->pubsub_patterns,&li);
    while ((ln = listNext(&li)) != NULL) {
        robj *pattern = ln->value;

        count += pubsubUnsubscribePattern(c,pattern,notify);
    }
    if (notify && count == 0) {
        /* We were subscribed to nothing? Still reply to the client. */
        addReply(c,shared.mbulkhdr[3]);
        addReply(c,shared.punsubscribebulk);
        addReply(c,shared.nullbulk);
        addReplyLongLong(c,dictSize(c->pubsub_channels)+
                       listLength(c->pubsub_patterns));
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x27320
leaq -0x28(%rbp), %rdi
callq 0x27380
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x74f11
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x74c80
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x74eda
cmpl $0x0, -0xc(%rbp)
je 0x74f95
cmpl $0x0, -0x2c(%rbp)
jne 0x74f95
movq -0x8(%rbp), %rdi
leaq 0x103d18(%rip), %rax    # 0x178c40
movq 0x13a48(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rdi
leaq 0x103d01(%rip), %rax    # 0x178c40
movq 0x120(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rdi
leaq 0x103cea(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
addq 0x48(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rax
addq 0x28(%rax), %rsi
callq 0x43780
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/pubsub.c
// Function: subscribeCommand
void subscribeCommand(client *c) {
    int j;

    for (j = 1; j < c->argc; j++)
        pubsubSubscribeChannel(c,c->argv[j]);
    c->flags |= CLIENT_PUBSUB;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x75283
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x748b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x75253
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
orl $0x40000, %ecx          # imm = 0x40000
movl %ecx, 0x98(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/pubsub.c
// Function: unsubscribeCommand
void unsubscribeCommand(client *c) {
    if (c->argc == 1) {
        pubsubUnsubscribeAllChannels(c,1);
    } else {
        int j;

        for (j = 1; j < c->argc; j++)
            pubsubUnsubscribeChannel(c,c->argv[j],1);
    }
    if (clientSubscriptionsCount(c) == 0) c->flags &= ~CLIENT_PUBSUB;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jne 0x752c6
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x74db0
jmp 0x75304
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x75302
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x1, %edx
callq 0x749d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x752cd
jmp 0x75304
movq -0x8(%rbp), %rdi
callq 0x74870
cmpl $0x0, %eax
jne 0x75328
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
andl $0xfffbffff, %ecx       # imm = 0xFFFBFFFF
movl %ecx, 0x98(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/pubsub.c
// Function: psubscribeCommand
void psubscribeCommand(client *c) {
    int j;

    for (j = 1; j < c->argc; j++)
        pubsubSubscribePattern(c,c->argv[j]);
    c->flags |= CLIENT_PUBSUB;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x75373
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x74b80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x75343
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
orl $0x40000, %ecx          # imm = 0x40000
movl %ecx, 0x98(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/pubsub.c
// Function: punsubscribeCommand
void punsubscribeCommand(client *c) {
    if (c->argc == 1) {
        pubsubUnsubscribeAllPatterns(c,1);
    } else {
        int j;

        for (j = 1; j < c->argc; j++)
            pubsubUnsubscribePattern(c,c->argv[j],1);
    }
    if (clientSubscriptionsCount(c) == 0) c->flags &= ~CLIENT_PUBSUB;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jne 0x753b6
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x74eb0
jmp 0x753f4
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x753f2
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x1, %edx
callq 0x74c80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x753bd
jmp 0x753f4
movq -0x8(%rbp), %rdi
callq 0x74870
cmpl $0x0, %eax
jne 0x75418
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
andl $0xfffbffff, %ecx       # imm = 0xFFFBFFFF
movl %ecx, 0x98(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/pubsub.c
// Function: publishCommand
void publishCommand(client *c) {
    int receivers = pubsubPublishMessage(c->argv[1],c->argv[2]);
    if (server.cluster_enabled)
        clusterPropagatePublish(c->argv[1],c->argv[2]);
    else
        forceCommandPropagation(c,PROPAGATE_REPL);
    addReplyLongLong(c,receivers);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x74fa0
movl %eax, -0xc(%rbp)
leaq 0x102d85(%rip), %rax    # 0x1781d8
cmpl $0x0, 0x99c(%rax)
je 0x7547b
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x81820
jmp 0x75489
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x33ca0
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x43780
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/multi.c
// Function: freeClientMultiState
void freeClientMultiState(client *c) {
    int j;

    for (j = 0; j < c->mstate.count; j++) {
        int i;
        multiCmd *mc = c->mstate.commands+j;

        for (i = 0; i < mc->argc; i++)
            decrRefCount(mc->argv[i]);
        zfree(mc->argv);
    }
    zfree(c->mstate.commands);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x158(%rcx), %eax
jge 0x75805
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x757ee
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x48f70
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x757c3
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3afa0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x75793
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rdi
callq 0x3afa0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/multi.c
// Function: queueMultiCommand
void queueMultiCommand(client *c) {
    multiCmd *mc;
    int j;

    c->mstate.commands = zrealloc(c->mstate.commands,
            sizeof(multiCmd)*(c->mstate.count+1));
    mc = c->mstate.commands+c->mstate.count;
    mc->cmd = c->cmd;
    mc->argc = c->argc;
    mc->argv = zmalloc(sizeof(robj*)*c->argc);
    memcpy(mc->argv,c->argv,sizeof(robj*)*c->argc);
    for (j = 0; j < c->argc; j++)
        incrRefCount(mc->argv[j]);
    c->mstate.count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x158(%rax), %eax
addl $0x1, %eax
cltq
imulq $0x18, %rax, %rsi
callq 0x3ae40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x150(%rax)
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x158(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq 0x38(%rax), %rdi
shlq $0x3, %rdi
callq 0x3acd0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x38(%rax), %rdx
shlq $0x3, %rdx
callq 0x26c60
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x75909
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x487b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x758de
movq -0x8(%rbp), %rax
movl 0x158(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x158(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/multi.c
// Function: discardTransaction
void discardTransaction(client *c) {
    freeClientMultiState(c);
    initClientMultiState(c);
    c->flags &= ~(CLIENT_MULTI|CLIENT_DIRTY_CAS|CLIENT_DIRTY_EXEC);
    unwatchAllKeys(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x75780
movq -0x8(%rbp), %rdi
callq 0x75750
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
andl $0xffffefd7, %ecx       # imm = 0xFFFFEFD7
movl %ecx, 0x98(%rax)
movq -0x8(%rbp), %rdi
callq 0x75980
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/multi.c
// Function: unwatchAllKeys
void unwatchAllKeys(client *c) {
    listIter li;
    listNode *ln;

    if (listLength(c->watched_keys) == 0) return;
    listRewind(c->watched_keys,&li);
    while((ln = listNext(&li))) {
        list *clients;
        watchedKey *wk;

        /* Lookup the watched key -> clients list and remove the client
         * from the list */
        wk = listNodeValue(ln);
        clients = dictFetchValue(wk->db->watched_keys, wk->key);
        serverAssertWithInfo(c,NULL,clients != NULL);
        listDelNode(clients,listSearchKey(clients,c));
        /* Kill the entry at all if this was the only client */
        if (listLength(clients) == 0)
            dictDelete(wk->db->watched_keys, wk->key);
        /* Remove this watched key from the client->watched list */
        listDelNode(c->watched_keys,ln);
        decrRefCount(wk->key);
        zfree(wk);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rax
cmpq $0x0, 0x28(%rax)
jne 0x759a3
jmp 0x75a9c
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x27320
leaq -0x18(%rbp), %rdi
callq 0x27380
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x75a9c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0x2e280
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x759ff
jmp 0x75a2a
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xca831(%rip), %rdx     # 0x14023f
leaq 0xca83a(%rip), %rcx     # 0x14024f
movl $0xf7, %r8d
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x274d0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x271e0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x75a6e
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0x2de50
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x271e0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x48f70
movq -0x30(%rbp), %rdi
callq 0x3afa0
jmp 0x759b7
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/multi.c
// Function: multiCommand
void multiCommand(client *c) {
    if (c->flags & CLIENT_MULTI) {
        addReplyError(c,"MULTI calls can not be nested");
        return;
    }
    c->flags |= CLIENT_MULTI;
    addReply(c,shared.ok);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x75b20
movq -0x8(%rbp), %rdi
leaq 0xca6df(%rip), %rsi     # 0x1401f8
callq 0x42f90
jmp 0x75b47
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0x98(%rax)
movq -0x8(%rbp), %rdi
leaq 0x103102(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/multi.c
// Function: discardCommand
void discardCommand(client *c) {
    if (!(c->flags & CLIENT_MULTI)) {
        addReplyError(c,"DISCARD without MULTI");
        return;
    }
    discardTransaction(c);
    addReply(c,shared.ok);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x75b80
movq -0x8(%rbp), %rdi
leaq 0xca69d(%rip), %rsi     # 0x140216
callq 0x42f90
jmp 0x75b9d
movq -0x8(%rbp), %rdi
callq 0x75930
movq -0x8(%rbp), %rdi
leaq 0x1030ac(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/multi.c
// Function: execCommandPropagateMulti
void execCommandPropagateMulti(client *c) {
    robj *multistring = createStringObject("MULTI",5);

    propagate(server.multiCommand,c->db->id,&multistring,1,
              PROPAGATE_AOF|PROPAGATE_REPL);
    decrRefCount(multistring);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xca676(%rip), %rdi     # 0x140239
movl $0x5, %esi
callq 0x486a0
movq %rax, -0x10(%rbp)
leaq 0x102600(%rip), %rax    # 0x1781d8
movq 0x348(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %esi
leaq -0x10(%rbp), %rdx
movl $0x1, %ecx
movl $0x3, %r8d
callq 0x33b80
movq -0x10(%rbp), %rdi
callq 0x48f70
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/multi.c
// Function: watchForKey
void watchForKey(client *c, robj *key) {
    list *clients = NULL;
    listIter li;
    listNode *ln;
    watchedKey *wk;

    /* Check if we are already watching for this key */
    listRewind(c->watched_keys,&li);
    while((ln = listNext(&li))) {
        wk = listNodeValue(ln);
        if (wk->db == c->db && equalStringObjects(key,wk->key))
            return; /* Key already watched */
    }
    /* This key is not already watched in this DB. Let's add it */
    clients = dictFetchValue(c->db->watched_keys,key);
    if (!clients) {
        clients = listCreate();
        dictAdd(c->db->watched_keys,key,clients);
        incrRefCount(key);
    }
    listAddNodeTail(clients,c);
    /* Add the new key to the list of keys watched by this client */
    wk = zmalloc(sizeof(*wk));
    wk->key = key;
    wk->db = c->db;
    incrRefCount(key);
    listAddNodeTail(c->watched_keys,wk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x27320
leaq -0x28(%rbp), %rdi
callq 0x27380
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x75f49
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x75f47
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
callq 0x49840
cmpl $0x0, %eax
je 0x75f47
jmp 0x75fe7
jmp 0x75efc
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2e280
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x75f94
callq 0x26e20
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2d8c0
movq -0x10(%rbp), %rdi
callq 0x487b0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x27000
movl $0x10, %edi
callq 0x3acd0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x487b0
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x27000
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/multi.c
// Function: touchWatchedKey
void touchWatchedKey(redisDb *db, robj *key) {
    list *clients;
    listIter li;
    listNode *ln;

    if (dictSize(db->watched_keys) == 0) return;
    clients = dictFetchValue(db->watched_keys, key);
    if (!clients) return;

    /* Mark all the clients watching this key as CLIENT_DIRTY_CAS */
    /* Check if we are already watching for this key */
    listRewind(clients,&li);
    while((ln = listNext(&li))) {
        client *c = listNodeValue(ln);

        c->flags |= CLIENT_DIRTY_CAS;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
addq 0x48(%rcx), %rax
cmpq $0x0, %rax
jne 0x76020
jmp 0x7607f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2e280
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7603e
jmp 0x7607f
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x27320
leaq -0x28(%rbp), %rdi
callq 0x27380
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x7607f
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x98(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x98(%rax)
jmp 0x7604b
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/multi.c
// Function: touchWatchedKeysOnFlush
void touchWatchedKeysOnFlush(int dbid) {
    listIter li1, li2;
    listNode *ln;

    /* For every client, check all the waited keys */
    listRewind(server.clients,&li1);
    while((ln = listNext(&li1))) {
        client *c = listNodeValue(ln);
        listRewind(c->watched_keys,&li2);
        while((ln = listNext(&li2))) {
            watchedKey *wk = listNodeValue(ln);

            /* For every watched key matching the specified DB, if the
             * key exists, mark the client as dirty, as the key will be
             * removed. */
            if (dbid == -1 || wk->db->id == dbid) {
                if (dictFind(wk->db->dict, wk->key->ptr) != NULL)
                    c->flags |= CLIENT_DIRTY_CAS;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
leaq 0x102136(%rip), %rax    # 0x1781d8
movq 0x1c8(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x27320
leaq -0x18(%rbp), %rdi
callq 0x27380
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x7615b
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x1a0(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x27320
leaq -0x28(%rbp), %rdi
callq 0x27380
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x76156
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpl $-0x1, -0x4(%rbp)
je 0x7611e
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x30(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x76154
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
callq 0x2dcb0
cmpq $0x0, %rax
je 0x76152
movq -0x38(%rbp), %rax
movl 0x98(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x98(%rax)
jmp 0x76154
jmp 0x760e9
jmp 0x760b2
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/multi.c
// Function: watchCommand
void watchCommand(client *c) {
    int j;

    if (c->flags & CLIENT_MULTI) {
        addReplyError(c,"WATCH inside MULTI is not allowed");
        return;
    }
    for (j = 1; j < c->argc; j++)
        watchForKey(c,c->argv[j]);
    addReply(c,shared.ok);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x761a0
movq -0x8(%rbp), %rdi
leaq 0xca0be(%rip), %rsi     # 0x140257
callq 0x42f90
jmp 0x761eb
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x761d7
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x75ed0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x761a7
movq -0x8(%rbp), %rdi
leaq 0x102a5e(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/debug.c
// Function: xorDigest
void xorDigest(unsigned char *digest, void *ptr, size_t len) {
    SHA1_CTX ctx;
    unsigned char hash[20], *s = ptr;
    int j;

    SHA1Init(&ctx);
    SHA1Update(&ctx,s,len);
    SHA1Final(hash,&ctx);

    for (j = 0; j < 20; j++)
        digest[j] ^= hash[j];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x74(%rbp), %rdi
callq 0x3f9d0
movq -0x98(%rbp), %rsi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq -0x74(%rbp), %rdi
callq 0x3fa30
leaq -0x90(%rbp), %rdi
leaq -0x74(%rbp), %rsi
callq 0x3fb40
movl $0x0, -0x9c(%rbp)
cmpl $0x14, -0x9c(%rbp)
jge 0x762e8
movslq -0x9c(%rbp), %rax
movzbl -0x90(%rbp,%rax), %esi
movq -0x8(%rbp), %rax
movslq -0x9c(%rbp), %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x762ab
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/debug.c
// Function: mixDigest
void mixDigest(unsigned char *digest, void *ptr, size_t len) {
    SHA1_CTX ctx;
    char *s = ptr;

    xorDigest(digest,s,len);
    SHA1Init(&ctx);
    SHA1Update(&ctx,digest,20);
    SHA1Final(digest,&ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x76250
leaq -0x74(%rbp), %rdi
callq 0x3f9d0
movq -0x8(%rbp), %rsi
leaq -0x74(%rbp), %rdi
movl $0x14, %edx
callq 0x3fa30
movq -0x8(%rbp), %rdi
leaq -0x74(%rbp), %rsi
callq 0x3fb40
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/debug.c
// Function: serverAssert
void _serverAssert(char *estr, char *file, int line) {
    bugReportStart();
    serverLog(LL_WARNING,"=== ASSERTION FAILED ===");
    serverLog(LL_WARNING,"==> %s:%d '%s' is not true",file,line,estr);
#ifdef HAVE_BACKTRACE
    server.assert_failed = estr;
    server.assert_file = file;
    server.assert_line = line;
    serverLog(LL_WARNING,"(forcing SIGSEGV to print the bug report.)");
#endif
    *((char*)-1) = 'x';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
callq 0x784b0
movl $0x3, %edi
leaq 0xc9fc6(%rip), %rsi     # 0x140cca
movb $0x0, %al
callq 0x2fc60
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %r8
movl $0x3, %edi
leaq 0xc9fc1(%rip), %rsi     # 0x140ce3
movb $0x0, %al
callq 0x2fc60
movq -0x8(%rbp), %rcx
leaq 0x1014a4(%rip), %rax    # 0x1781d8
movq %rcx, 0xa28(%rax)
movq -0x10(%rbp), %rcx
leaq 0x101492(%rip), %rax    # 0x1781d8
movq %rcx, 0xa30(%rax)
movl -0x14(%rbp), %ecx
leaq 0x101481(%rip), %rax    # 0x1781d8
movl %ecx, 0xa38(%rax)
movl $0x3, %edi
leaq 0xc9f95(%rip), %rsi     # 0x140cfe
movb $0x0, %al
callq 0x2fc60
movq $-0x1, %rax
movb $0x78, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/debug.c
// Function: serverPanic
void _serverPanic(char *msg, char *file, int line) {
    bugReportStart();
    serverLog(LL_WARNING,"------------------------------------------------");
    serverLog(LL_WARNING,"!!! Software Failure. Press left mouse button to continue");
    serverLog(LL_WARNING,"Guru Meditation: %s #%s:%d",msg,file,line);
#ifdef HAVE_BACKTRACE
    serverLog(LL_WARNING,"(forcing SIGSEGV in order to print the stack trace)");
#endif
    serverLog(LL_WARNING,"------------------------------------------------");
    *((char*)-1) = 'x';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
callq 0x784b0
movl $0x3, %edi
leaq 0xca112(%rip), %rsi     # 0x140eb6
movb $0x0, %al
callq 0x2fc60
movl $0x3, %edi
leaq 0xca130(%rip), %rsi     # 0x140ee7
movb $0x0, %al
callq 0x2fc60
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
movl $0x3, %edi
leaq 0xca14b(%rip), %rsi     # 0x140f21
movb $0x0, %al
callq 0x2fc60
movl $0x3, %edi
leaq 0xca153(%rip), %rsi     # 0x140f3c
movb $0x0, %al
callq 0x2fc60
movl $0x3, %edi
leaq 0xca0ba(%rip), %rsi     # 0x140eb6
movb $0x0, %al
callq 0x2fc60
movq $-0x1, %rax
movb $0x78, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/debug.c
// Function: bugReportStart
void bugReportStart(void) {
    if (server.bug_report_start == 0) {
        serverLogRaw(LL_WARNING|LL_RAW,
        "\n\n=== REDIS BUG REPORT START: Cut & paste starting from here ===\n");
        server.bug_report_start = 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xffd1d(%rip), %rax     # 0x1781d8
cmpl $0x0, 0xa3c(%rax)
jne 0x784e6
movl $0x403, %edi            # imm = 0x403
leaq 0xc8aa0(%rip), %rsi     # 0x140f70
callq 0x2fa20
leaq 0xffcfc(%rip), %rax     # 0x1781d8
movl $0x1, 0xa3c(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/debug.c
// Function: serverAssertPrintClientInfo
void _serverAssertPrintClientInfo(client *c) {
    int j;

    bugReportStart();
    serverLog(LL_WARNING,"=== ASSERTION FAILED CLIENT CONTEXT ===");
    serverLog(LL_WARNING,"client->flags = %d", c->flags);
    serverLog(LL_WARNING,"client->fd = %d", c->fd);
    serverLog(LL_WARNING,"client->argc = %d", c->argc);
    for (j=0; j < c->argc; j++) {
        char buf[128];
        char *arg;

        if (c->argv[j]->type == OBJ_STRING && sdsEncodedObject(c->argv[j])) {
            arg = (char*) c->argv[j]->ptr;
        } else {
            snprintf(buf,sizeof(buf),"Object type: %u, encoding: %u",
                c->argv[j]->type, c->argv[j]->encoding);
            arg = buf;
        }
        serverLog(LL_WARNING,"client->argv[%d] = \"%s\" (refcount: %d)",
            j, arg, c->argv[j]->refcount);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
callq 0x784b0
movl $0x3, %edi
leaq 0xc8819(%rip), %rsi     # 0x140d29
movb $0x0, %al
callq 0x2fc60
movq -0x8(%rbp), %rax
movl 0x98(%rax), %edx
movl $0x3, %edi
leaq 0xc8824(%rip), %rsi     # 0x140d51
movb $0x0, %al
callq 0x2fc60
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movl $0x3, %edi
leaq 0xc881d(%rip), %rsi     # 0x140d64
movb $0x0, %al
callq 0x2fc60
movq -0x8(%rbp), %rax
movl 0x38(%rax), %edx
movl $0x3, %edi
leaq 0xc8813(%rip), %rsi     # 0x140d74
movb $0x0, %al
callq 0x2fc60
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x78687
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x785f0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x785d3
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x785f0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
jmp 0x78648
leaq -0x90(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %ecx
andl $0xf, %ecx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl (%rax), %r8d
shrl $0x4, %r8d
andl $0xf, %r8d
movl $0x80, %esi
leaq 0xc8753(%rip), %rdx     # 0x140d86
movb $0x0, %al
callq 0x26120
leaq -0x90(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0xc(%rbp), %edx
movq -0x98(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rsi
movq (%rax,%rsi,8), %rax
movl 0x4(%rax), %r8d
movl $0x3, %edi
leaq 0xc8732(%rip), %rsi     # 0x140da4
movb $0x0, %al
callq 0x2fc60
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7856f
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/debug.c
// Function: logStackContent
void logStackContent(void **sp) {
    int i;
    for (i = 15; i >= 0; i--) {
        unsigned long addr = (unsigned long) sp+i;
        unsigned long val = (unsigned long) sp[i];

        if (sizeof(long) == 4)
            serverLog(LL_WARNING, "(%08lx) -> %08lx", addr, val);
        else
            serverLog(LL_WARNING, "(%016lx) -> %016lx", addr, val);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0xf, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x7895e
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x3, %edi
leaq 0xc8666(%rip), %rsi     # 0x140fb2
movb $0x0, %al
callq 0x2fc60
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x78913
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/debug.c
// Function: openDirectLogFiledes
int openDirectLogFiledes(void) {
    int log_to_stdout = server.logfile[0] == '\0';
    int fd = log_to_stdout ?
        STDOUT_FILENO :
        open(server.logfile, O_APPEND|O_CREAT|O_WRONLY, 0644);
    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xff6b9(%rip), %rax     # 0x1781d8
movq 0x7a0(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x78b47
movl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x78b69
leaq 0xff68a(%rip), %rax     # 0x1781d8
movq 0x7a0(%rax), %rdi
movl $0x441, %esi            # imm = 0x441
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x266a0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/debug.c
// Function: logStackTrace
void logStackTrace(ucontext_t *uc) {
    void *trace[101];
    int trace_size = 0, fd = openDirectLogFiledes();

    if (fd == -1) return; /* If we can't log there is anything to do. */

    /* Generate the stack trace */
    trace_size = backtrace(trace+1, 100);

    if (getMcontextEip(uc) != NULL) {
        char *msg1 = "EIP:\n";
        char *msg2 = "\nBacktrace:\n";
        if (write(fd,msg1,strlen(msg1)) == -1) {/* Avoid warning. */};
        trace[0] = getMcontextEip(uc);
        backtrace_symbols_fd(trace, 1, fd);
        if (write(fd,msg2,strlen(msg2)) == -1) {/* Avoid warning. */};
    }

    /* Write symbols to log file */
    backtrace_symbols_fd(trace+1, trace_size, fd);

    /* Cleanup */
    closeDirectLogFiledes(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x370, %rsp            # imm = 0x370
movq %rdi, -0x8(%rbp)
movl $0x0, -0x334(%rbp)
callq 0x78b10
movl %eax, -0x338(%rbp)
cmpl $-0x1, -0x338(%rbp)
jne 0x78bf2
jmp 0x78d12
leaq -0x330(%rbp), %rdi
addq $0x8, %rdi
movl $0x64, %esi
callq 0x26140
movl %eax, -0x334(%rbp)
movq -0x8(%rbp), %rdi
callq 0x78d20
cmpq $0x0, %rax
je 0x78ceb
leaq 0xc848d(%rip), %rax     # 0x1410b4
movq %rax, -0x340(%rbp)
leaq 0xc8485(%rip), %rax     # 0x1410ba
movq %rax, -0x348(%rbp)
movl -0x338(%rbp), %eax
movl %eax, -0x354(%rbp)
movq -0x340(%rbp), %rax
movq %rax, -0x350(%rbp)
movq -0x340(%rbp), %rdi
callq 0x264f0
movl -0x354(%rbp), %edi
movq -0x350(%rbp), %rsi
movq %rax, %rdx
callq 0x26bc0
cmpq $-0x1, %rax
jne 0x78c7f
jmp 0x78c7f
movq -0x8(%rbp), %rdi
callq 0x78d20
movq %rax, -0x330(%rbp)
leaq -0x330(%rbp), %rdi
movl -0x338(%rbp), %edx
movl $0x1, %esi
callq 0x26a00
movl -0x338(%rbp), %eax
movl %eax, -0x364(%rbp)
movq -0x348(%rbp), %rax
movq %rax, -0x360(%rbp)
movq -0x348(%rbp), %rdi
callq 0x264f0
movl -0x364(%rbp), %edi
movq -0x360(%rbp), %rsi
movq %rax, %rdx
callq 0x26bc0
cmpq $-0x1, %rax
jne 0x78ce9
jmp 0x78ce9
jmp 0x78ceb
leaq -0x330(%rbp), %rdi
addq $0x8, %rdi
movl -0x334(%rbp), %esi
movl -0x338(%rbp), %edx
callq 0x26a00
movl -0x338(%rbp), %edi
callq 0x78b80
addq $0x370, %rsp            # imm = 0x370
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/debug.c
// Function: logCurrentClient
void logCurrentClient(void) {
    if (server.current_client == NULL) return;

    client *cc = server.current_client;
    sds client;
    int j;

    serverLogRaw(LL_WARNING|LL_RAW, "\n------ CURRENT CLIENT INFO ------\n");
    client = catClientInfoString(sdsempty(),cc);
    serverLog(LL_WARNING|LL_RAW,"%s\n", client);
    sdsfree(client);
    for (j = 0; j < cc->argc; j++) {
        robj *decoded;

        decoded = getDecodedObject(cc->argv[j]);
        serverLog(LL_WARNING|LL_RAW,"argv[%d]: '%s'\n", j,
            (char*)decoded->ptr);
        decrRefCount(decoded);
    }
    /* Check if the first argument, usually a key, is found inside the
     * selected DB, and if so print info about the associated object. */
    if (cc->argc >= 1) {
        robj *val, *key;
        dictEntry *de;

        key = getDecodedObject(cc->argv[1]);
        de = dictFind(cc->db->dict, key->ptr);
        if (de) {
            val = dictGetVal(de);
            serverLog(LL_WARNING,"key '%s' found in DB containing the following object:", (char*)key->ptr);
            serverLogObjectDebugInfo(val);
        }
        decrRefCount(key);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0xff489(%rip), %rax     # 0x1781d8
cmpq $0x0, 0x1f0(%rax)
jne 0x78d5e
jmp 0x78e8f
leaq 0xff473(%rip), %rax     # 0x1781d8
movq 0x1f0(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x403, %edi            # imm = 0x403
leaq 0xc834b(%rip), %rsi     # 0x1410c7
callq 0x2fa20
callq 0x384f0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x455c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movl $0x403, %edi            # imm = 0x403
leaq 0xd4a5c(%rip), %rsi     # 0x14d802
movb $0x0, %al
callq 0x2fc60
movq -0x10(%rbp), %rdi
callq 0x38620
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x78e14
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x494f0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x403, %edi            # imm = 0x403
leaq 0xc82f2(%rip), %rsi     # 0x1410eb
movb $0x0, %al
callq 0x2fc60
movq -0x20(%rbp), %rdi
callq 0x48f70
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x78dbd
movq -0x8(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jl 0x78e8f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x494f0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2dcb0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x78e86
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0x3, %edi
leaq 0xc8285(%rip), %rsi     # 0x1410fb
movb $0x0, %al
callq 0x2fc60
movq -0x28(%rbp), %rdi
callq 0x78690
movq -0x30(%rbp), %rdi
callq 0x48f70
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)