LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisGetReply
int redisGetReply(redisContext *c, void **reply) {
    int wdone = 0;
    void *aux = NULL;

    /* Try to read pending replies */
    if (redisGetReplyFromReader(c,&aux) == REDIS_ERR)
        return REDIS_ERR;

    /* For the blocking context, flush output buffer and read reply */
    if (aux == NULL && c->flags & REDIS_BLOCK) {
        /* Write until done */
        do {
            if (redisBufferWrite(c,&wdone) == REDIS_ERR)
                return REDIS_ERR;
        } while (!wdone);

        /* Read until there is a reply */
        do {
            if (redisBufferRead(c) == REDIS_ERR)
                return REDIS_ERR;
            if (redisGetReplyFromReader(c,&aux) == REDIS_ERR)
                return REDIS_ERR;
        } while (aux == NULL);
    }

    /* Set reply object */
    if (reply != NULL) *reply = aux;
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3240
cmpl $-0x1, %eax
jne 0x65bd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x665a
cmpq $0x0, -0x28(%rbp)
jne 0x6641
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6641
jmp 0x65d8
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x3120
cmpl $-0x1, %eax
jne 0x65f3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x665a
jmp 0x65f5
cmpl $0x0, -0x1c(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x65d8
jmp 0x6604
movq -0x10(%rbp), %rdi
callq 0x3460
cmpl $-0x1, %eax
jne 0x661b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x665a
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3240
cmpl $-0x1, %eax
jne 0x6636
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x665a
jmp 0x6638
cmpq $0x0, -0x28(%rbp)
je 0x6604
jmp 0x6641
cmpq $0x0, -0x18(%rbp)
je 0x6653
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: _redisAppendCommand
int __redisAppendCommand(redisContext *c, const char *cmd, size_t len) {
    sds newbuf;

    newbuf = sdscatlen(c->obuf,cmd,len);
    if (newbuf == NULL) {
        __redisSetError(c,REDIS_ERR_OOM,"Out of memory");
        return REDIS_ERR;
    }

    c->obuf = newbuf;
    return REDIS_OK;
}

// 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 0x90(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3420
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x66c5
movq -0x10(%rbp), %rdi
movl $0x5, %esi
leaq 0x6bf0(%rip), %rdx      # 0xd2a7
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x66db
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisvAppendCommand
int redisvAppendCommand(redisContext *c, const char *format, va_list ap) {
    char *cmd;
    int len;

    len = redisvFormatCommand(&cmd,format,ap);
    if (len == -1) {
        __redisSetError(c,REDIS_ERR_OOM,"Out of memory");
        return REDIS_ERR;
    } else if (len == -2) {
        __redisSetError(c,REDIS_ERR_OTHER,"Invalid format string");
        return REDIS_ERR;
    }

    if (__redisAppendCommand(c,cmd,len) != REDIS_OK) {
        free(cmd);
        return REDIS_ERR;
    }

    free(cmd);
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x3500
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x678c
movq -0x10(%rbp), %rdi
movl $0x5, %esi
leaq 0x6b29(%rip), %rdx      # 0xd2a7
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x67ea
cmpl $-0x2, -0x2c(%rbp)
jne 0x67b0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x6b13(%rip), %rdx      # 0xd2b5
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x67ea
jmp 0x67b2
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x3560
cmpl $0x0, %eax
je 0x67da
movq -0x28(%rbp), %rdi
callq 0x3040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x67ea
movq -0x28(%rbp), %rdi
callq 0x3040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisAppendCommand
int redisAppendCommand(redisContext *c, const char *format, ...) {
    va_list ap;
    int ret;

    va_start(ap,format);
    ret = redisvAppendCommand(c,format,ap);
    va_end(ap);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x683b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3170
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisAppendCommandArgv
int redisAppendCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen) {
    sds cmd;
    int len;

    len = redisFormatSdsCommandArgv(&cmd,argc,argv,argvlen);
    if (len == -1) {
        __redisSetError(c,REDIS_ERR_OOM,"Out of memory");
        return REDIS_ERR;
    }

    if (__redisAppendCommand(c,cmd,len) != REDIS_OK) {
        sdsfree(cmd);
        return REDIS_ERR;
    }

    sdsfree(cmd);
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %rdi
callq 0x31e0
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x68f2
movq -0x10(%rbp), %rdi
movl $0x5, %esi
leaq 0x69c3(%rip), %rdx      # 0xd2a7
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x692a
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x3560
cmpl $0x0, %eax
je 0x691a
movq -0x30(%rbp), %rdi
callq 0x3280
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x692a
movq -0x30(%rbp), %rdi
callq 0x3280
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: _redisBlockForReply
static void *__redisBlockForReply(redisContext *c) {
    void *reply;

    if (c->flags & REDIS_BLOCK) {
        if (redisGetReply(c,&reply) != REDIS_OK)
            return NULL;
        return reply;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x69d4
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x34f0
cmpl $0x0, %eax
je 0x69ca
movq $0x0, -0x8(%rbp)
jmp 0x69dc
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x69dc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisCommand
void *redisCommand(redisContext *c, const char *format, ...) {
    va_list ap;
    void *reply = NULL;
    va_start(ap,format);
    reply = redisvCommand(c,format,ap);
    va_end(ap);
    return reply;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x6a2b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x30b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: createStringObject
static void *createStringObject(const redisReadTask *task, char *str, size_t len) {
    redisReply *r, *parent;
    char *buf;

    r = createReplyObject(task->type);
    if (r == NULL)
        return NULL;

    buf = malloc(len+1);
    if (buf == NULL) {
        freeReplyObject(r);
        return NULL;
    }

    assert(task->type == REDIS_REPLY_ERROR  ||
           task->type == REDIS_REPLY_STATUS ||
           task->type == REDIS_REPLY_STRING);

    /* Copy string value */
    memcpy(buf,str,len);
    buf[len] = '\0';
    r->str = buf;
    r->len = len;

    if (task->parent) {
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY);
        parent->element[task->idx] = r;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x6e90
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6b37
movq $0x0, -0x8(%rbp)
jmp 0x6c3c
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
callq 0x3350
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6b65
movq -0x28(%rbp), %rdi
callq 0x33f0
movq $0x0, -0x8(%rbp)
jmp 0x6c3c
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
je 0x6b80
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
je 0x6b80
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x6b82
jmp 0x6ba1
leaq 0x6742(%rip), %rdi      # 0xd2cb
leaq 0x6587(%rip), %rsi      # 0xd117
movl $0x76, %edx
leaq 0x6797(%rip), %rcx      # 0xd333
callq 0x31c0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32f0
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6c34
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x6bfd
jmp 0x6c1c
leaq 0x676f(%rip), %rdi      # 0xd373
leaq 0x650c(%rip), %rsi      # 0xd117
movl $0x80, %edx
leaq 0x671c(%rip), %rcx      # 0xd333
callq 0x31c0
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: createArrayObject
static void *createArrayObject(const redisReadTask *task, int elements) {
    redisReply *r, *parent;

    r = createReplyObject(REDIS_REPLY_ARRAY);
    if (r == NULL)
        return NULL;

    if (elements > 0) {
        r->element = calloc(elements,sizeof(redisReply*));
        if (r->element == NULL) {
            freeReplyObject(r);
            return NULL;
        }
    }

    r->elements = elements;

    if (task->parent) {
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY);
        parent->element[task->idx] = r;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x2, %edi
callq 0x6e90
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6c81
movq $0x0, -0x8(%rbp)
jmp 0x6d31
cmpl $0x0, -0x14(%rbp)
jle 0x6cc0
movslq -0x14(%rbp), %rdi
movl $0x8, %esi
callq 0x3290
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x6cbe
movq -0x20(%rbp), %rdi
callq 0x33f0
movq $0x0, -0x8(%rbp)
jmp 0x6d31
jmp 0x6cc0
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6d29
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x6cf2
jmp 0x6d11
leaq 0x667a(%rip), %rdi      # 0xd373
leaq 0x6417(%rip), %rsi      # 0xd117
movl $0x99, %edx
leaq 0x6689(%rip), %rcx      # 0xd395
callq 0x31c0
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: createIntegerObject
static void *createIntegerObject(const redisReadTask *task, long long value) {
    redisReply *r, *parent;

    r = createReplyObject(REDIS_REPLY_INTEGER);
    if (r == NULL)
        return NULL;

    r->integer = value;

    if (task->parent) {
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY);
        parent->element[task->idx] = r;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x3, %edi
callq 0x6e90
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6d6f
movq $0x0, -0x8(%rbp)
jmp 0x6de0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6dd8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x6da1
jmp 0x6dc0
leaq 0x65cb(%rip), %rdi      # 0xd373
leaq 0x6368(%rip), %rsi      # 0xd117
movl $0xaa, %edx
leaq 0x660e(%rip), %rcx      # 0xd3c9
callq 0x31c0
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: createNilObject
static void *createNilObject(const redisReadTask *task) {
    redisReply *r, *parent;

    r = createReplyObject(REDIS_REPLY_NIL);
    if (r == NULL)
        return NULL;

    if (task->parent) {
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY);
        parent->element[task->idx] = r;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x4, %edi
callq 0x6e90
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6e1b
movq $0x0, -0x8(%rbp)
jmp 0x6e80
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6e78
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x6e41
jmp 0x6e60
leaq 0x652b(%rip), %rdi      # 0xd373
leaq 0x62c8(%rip), %rsi      # 0xd117
movl $0xb9, %edx
leaq 0x65aa(%rip), %rcx      # 0xd405
callq 0x31c0
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: createReplyObject
static redisReply *createReplyObject(int type) {
    redisReply *r = calloc(1,sizeof(*r));

    if (r == NULL)
        return NULL;

    r->type = type;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x3290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6ebf
movq $0x0, -0x8(%rbp)
jmp 0x6ed0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsnewlen
sds sdsnewlen(const void *init, size_t initlen) {
    struct sdshdr *sh;

    if (init) {
        sh = malloc(sizeof *sh+initlen+1);
    } else {
        sh = calloc(sizeof *sh+initlen+1,1);
    }
    if (sh == NULL) return NULL;
    sh->len = initlen;
    sh->free = 0;
    if (initlen && init)
        memcpy(sh->buf, init, initlen);
    sh->buf[initlen] = '\0';
    return (char*)sh->buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6f4e
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x1, %rdi
callq 0x3350
movq %rax, -0x20(%rbp)
jmp 0x6f68
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x3290
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6f79
movq $0x0, -0x8(%rbp)
jmp 0x6fcc
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x6fb3
cmpq $0x0, -0x10(%rbp)
je 0x6fb3
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x32f0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, 0x8(%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsupdatelen
void sdsupdatelen(sds s) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);
    int reallen = strlen(s);
    sh->free += (sh->len-reallen);
    sh->len = reallen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3140
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
subl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsclear
void sdsclear(sds s) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);
    sh->free += sh->len;
    sh->len = 0;
    sh->buf[0] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsMakeRoomFor
sds sdsMakeRoomFor(sds s, size_t addlen) {
    struct sdshdr *sh, *newsh;
    size_t free = sdsavail(s);
    size_t len, newlen;

    if (free >= addlen) return s;
    len = sdslen(s);
    sh = (void*) (s-sizeof *sh);
    newlen = (len+addlen);
    if (newlen < SDS_MAX_PREALLOC)
        newlen *= 2;
    else
        newlen += SDS_MAX_PREALLOC;
    newsh = realloc(sh, sizeof *newsh+newlen+1);
    if (newsh == NULL) return NULL;

    newsh->free = newlen - len;
    return newsh->buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6f00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x7174
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7205
movq -0x10(%rbp), %rdi
callq 0x6ee0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x100000, -0x40(%rbp)  # imm = 0x100000
jae 0x71b0
movq -0x40(%rbp), %rax
shlq %rax
movq %rax, -0x40(%rbp)
jmp 0x71be
movq -0x40(%rbp), %rax
addq $0x100000, %rax         # imm = 0x100000
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
addq $0x1, %rsi
callq 0x33a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x71e8
movq $0x0, -0x8(%rbp)
jmp 0x7205
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsRemoveFreeSpace
sds sdsRemoveFreeSpace(sds s) {
    struct sdshdr *sh;

    sh = (void*) (s-sizeof *sh);
    sh = realloc(sh, sizeof *sh+sh->len+1);
    sh->free = 0;
    return sh->buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
addq $0x8, %rsi
addq $0x1, %rsi
callq 0x33a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsIncrLen
void sdsIncrLen(sds s, int incr) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);

    assert(sh->free >= incr);
    sh->len += incr;
    sh->free -= incr;
    assert(sh->free >= 0);
    s[sh->len] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0x72b9
jmp 0x72d8
leaq 0x62a0(%rip), %rdi      # 0xd560
leaq 0x62aa(%rip), %rsi      # 0xd571
movl $0xcb, %edx
leaq 0x62a4(%rip), %rcx      # 0xd577
callq 0x31c0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x72fe
jmp 0x731d
leaq 0x628c(%rip), %rdi      # 0xd591
leaq 0x6265(%rip), %rsi      # 0xd571
movl $0xce, %edx
leaq 0x625f(%rip), %rcx      # 0xd577
callq 0x31c0
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsgrowzero
sds sdsgrowzero(sds s, size_t len) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);
    size_t totlen, curlen = sh->len;

    if (len <= curlen) return s;
    s = sdsMakeRoomFor(s,len-curlen);
    if (s == NULL) return NULL;

    /* Make sure added region doesn't contain garbage */
    sh = (void*)(s-sizeof *sh);
    memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */
    totlen = sh->len+sh->free;
    sh->len = len;
    sh->free = totlen-sh->len;
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0x737e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7409
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq -0x30(%rbp), %rsi
callq 0x31d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x73a4
movq $0x0, -0x8(%rbp)
jmp 0x7409
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq -0x30(%rbp), %rdx
addq $0x1, %rdx
xorl %esi, %esi
callq 0x3200
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
addl 0x4(%rcx), %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdscatlen
sds sdscatlen(sds s, const void *t, size_t len) {
    struct sdshdr *sh;
    size_t curlen = sdslen(s);

    s = sdsMakeRoomFor(s,len);
    if (s == NULL) return NULL;
    sh = (void*) (s-sizeof *sh);
    memcpy(s+curlen, t, len);
    sh->len = curlen+len;
    sh->free = sh->free-len;
    s[curlen+len] = '\0';
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6ee0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x31d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7463
movq $0x0, -0x8(%rbp)
jmp 0x74c1
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32f0
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movslq 0x4(%rax), %rax
subq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
addq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdscpylen
sds sdscpylen(sds s, const char *t, size_t len) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);
    size_t totlen = sh->free+sh->len;

    if (totlen < len) {
        s = sdsMakeRoomFor(s,len-sh->len);
        if (s == NULL) return NULL;
        sh = (void*) (s-sizeof *sh);
        totlen = sh->free+sh->len;
    }
    memcpy(s, t, len);
    s[len] = '\0';
    sh->len = len;
    sh->free = totlen-len;
    return s;
}

// 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
addq $-0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
addl (%rcx), %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x75d8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
movslq (%rax), %rax
subq %rax, %rsi
callq 0x31d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x75b9
movq $0x0, -0x8(%rbp)
jmp 0x761a
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
addl (%rcx), %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32f0
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsll2str
int sdsll2str(char *s, long long value) {
    char *p, aux;
    unsigned long long v;
    size_t l;

    /* Generate the string representation, this method produces
     * an reversed string. */
    v = (value < 0) ? -value : value;
    p = s;
    do {
        *p++ = '0'+(v%10);
        v /= 10;
    } while(v);
    if (value < 0) *p++ = '-';

    /* Compute length and add null term. */
    l = p-s;
    *p = '\0';

    /* Reverse the string. */
    p--;
    while(s < p) {
        aux = *s;
        *s = *p;
        *p = aux;
        s++;
        p--;
    }
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x768f
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x7697
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0x30, %rdx
movb %dl, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x76a7
cmpq $0x0, -0x10(%rbp)
jge 0x76fe
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x2d, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x7762
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7720
movq -0x30(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsull2str
int sdsull2str(char *s, unsigned long long v) {
    char *p, aux;
    size_t l;

    /* Generate the string representation, this method produces
     * an reversed string. */
    p = s;
    do {
        *p++ = '0'+(v%10);
        v /= 10;
    } while(v);

    /* Compute length and add null term. */
    l = p-s;
    *p = '\0';

    /* Reverse the string. */
    p--;
    while(s < p) {
        aux = *s;
        *s = *p;
        *p = aux;
        s++;
        p--;
    }
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0x30, %rdx
movb %dl, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7784
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x7826
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x77e4
movq -0x28(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdscatvprintf
sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
    va_list cpy;
    char *buf, *t;
    size_t buflen = 16;

    while(1) {
        buf = malloc(buflen);
        if (buf == NULL) return NULL;
        buf[buflen-2] = '\0';
        va_copy(cpy,ap);
        vsnprintf(buf, buflen, fmt, cpy);
        if (buf[buflen-2] != '\0') {
            free(buf);
            buflen *= 2;
            continue;
        }
        break;
    }
    t = sdscat(s, buf);
    free(buf);
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x10, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3350
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x786d
movq $0x0, -0x8(%rbp)
jmp 0x78fa
movq -0x48(%rbp), %rax
movq -0x58(%rbp), %rcx
subq $0x2, %rcx
movb $0x0, (%rax,%rcx)
leaq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x30d0
movq -0x48(%rbp), %rax
movq -0x58(%rbp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x78d6
movq -0x48(%rbp), %rdi
callq 0x3040
movq -0x58(%rbp), %rax
shlq %rax
movq %rax, -0x58(%rbp)
jmp 0x784c
jmp 0x78d8
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x3380
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3040
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdstrim
void sdstrim(sds s, const char *cset) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);
    char *start, *end, *sp, *ep;
    size_t len;

    sp = start = s;
    ep = end = s+sdslen(s)-1;
    while(sp <= end && strchr(cset, *sp)) sp++;
    while(ep > start && strchr(cset, *ep)) ep--;
    len = (sp > ep) ? 0 : ((ep-sp)+1);
    if (sh->buf != sp) memmove(sh->buf, sp, len);
    sh->buf[len] = '\0';
    sh->free = sh->free+(sh->len-len);
    sh->len = len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6ee0
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x49(%rbp)
ja 0x8078
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
callq 0x3180
cmpq $0x0, %rax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x8081
jmp 0x808f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x804f
jmp 0x8091
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x4a(%rbp)
jbe 0x80ba
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movsbl (%rax), %esi
callq 0x3180
cmpq $0x0, %rax
setne %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
testb $0x1, %al
jne 0x80c3
jmp 0x80d1
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x8091
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jbe 0x80e3
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x80f6
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
cmpq -0x30(%rbp), %rax
je 0x8121
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x3410
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movb $0x0, 0x8(%rax,%rcx)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
subq -0x40(%rbp), %rcx
addq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x40(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsrange
void sdsrange(sds s, int start, int end) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);
    size_t newlen, len = sdslen(s);

    if (len == 0) return;
    if (start < 0) {
        start = len+start;
        if (start < 0) start = 0;
    }
    if (end < 0) {
        end = len+end;
        if (end < 0) end = 0;
    }
    newlen = (start > end) ? 0 : (end-start)+1;
    if (newlen != 0) {
        if (start >= (signed)len) {
            newlen = 0;
        } else if (end >= (signed)len) {
            end = len-1;
            newlen = (start > end) ? 0 : (end-start)+1;
        }
    } else {
        start = 0;
    }
    if (start && newlen) memmove(sh->buf, sh->buf+start, newlen);
    sh->buf[newlen] = 0;
    sh->free = sh->free+(sh->len-newlen);
    sh->len = newlen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6ee0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8197
jmp 0x82c7
cmpl $0x0, -0xc(%rbp)
jge 0x81ba
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x81b8
movl $0x0, -0xc(%rbp)
jmp 0x81ba
cmpl $0x0, -0x10(%rbp)
jge 0x81dd
movq -0x28(%rbp), %rax
movslq -0x10(%rbp), %rcx
addq %rcx, %rax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x81db
movl $0x0, -0x10(%rbp)
jmp 0x81dd
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x81ec
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x81f8
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cltq
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x825b
movl -0xc(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl %ecx, %eax
jl 0x821d
movq $0x0, -0x20(%rbp)
jmp 0x8259
movl -0x10(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl %ecx, %eax
jl 0x8257
movq -0x28(%rbp), %rax
subq $0x1, %rax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x8242
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x824e
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cltq
movq %rax, -0x20(%rbp)
jmp 0x8259
jmp 0x8262
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x828f
cmpq $0x0, -0x20(%rbp)
je 0x828f
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movslq -0xc(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x3410
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, 0x8(%rax,%rcx)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
subq -0x20(%rbp), %rcx
addq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdscmp
int sdscmp(const sds s1, const sds s2) {
    size_t l1, l2, minlen;
    int cmp;

    l1 = sdslen(s1);
    l2 = sdslen(s2);
    minlen = (l1 < l2) ? l1 : l2;
    cmp = memcmp(s1,s2,minlen);
    if (cmp == 0) return l1-l2;
    return cmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6ee0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6ee0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x83ce
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x83d6
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3260
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x8405
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x840b
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsfreesplitres
void sdsfreesplitres(sds *tokens, int count) {
    if (!tokens) return;
    while(count--)
        sdsfree(tokens[count]);
    free(tokens);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8668
jmp 0x8696
jmp 0x866a
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x868d
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3280
jmp 0x866a
movq -0x8(%rbp), %rdi
callq 0x3040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsfromlonglong
sds sdsfromlonglong(long long value) {
    char buf[32], *p;
    unsigned long long v;

    v = (value < 0) ? -value : value;
    p = buf+31; /* point to the last character */
    do {
        *p-- = '0'+(v%10);
        v /= 10;
    } while(v);
    if (value < 0) *p-- = '-';
    p++;
    return sdsnewlen(p,32-(p-buf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x86bf
xorl %eax, %eax
subq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x86c7
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rax
addq $0x1f, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0x30, %rdx
movb %dl, %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movq -0x40(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x86db
cmpq $0x0, -0x8(%rbp)
jge 0x8732
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
movb $0x2d, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x38(%rbp), %rax
leaq -0x30(%rbp), %rcx
subq %rcx, %rax
movl $0x20, %esi
subq %rax, %rsi
callq 0x32c0
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdscatrepr
sds sdscatrepr(sds s, const char *p, size_t len) {
    s = sdscatlen(s,"\"",1);
    while(len--) {
        switch(*p) {
        case '\\':
        case '"':
            s = sdscatprintf(s,"\\%c",*p);
            break;
        case '\n': s = sdscatlen(s,"\\n",2); break;
        case '\r': s = sdscatlen(s,"\\r",2); break;
        case '\t': s = sdscatlen(s,"\\t",2); break;
        case '\a': s = sdscatlen(s,"\\a",2); break;
        case '\b': s = sdscatlen(s,"\\b",2); break;
        default:
            if (isprint(*p))
                s = sdscatprintf(s,"%c",*p);
            else
                s = sdscatprintf(s,"\\x%02x",(unsigned char)*p);
            break;
        }
        p++;
    }
    return sdscatlen(s,"\"",1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x523d(%rip), %rsi      # 0xd9bc
movl $0x1, %edx
callq 0x3420
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x8924
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x7, %eax
je 0x887f
jmp 0x87bb
movl -0x1c(%rbp), %eax
subl $0x8, %eax
je 0x889a
jmp 0x87c9
movl -0x1c(%rbp), %eax
subl $0x9, %eax
je 0x8861
jmp 0x87d7
movl -0x1c(%rbp), %eax
subl $0xa, %eax
je 0x8825
jmp 0x87e1
movl -0x1c(%rbp), %eax
subl $0xd, %eax
je 0x8843
jmp 0x87eb
movl -0x1c(%rbp), %eax
subl $0x22, %eax
je 0x8803
jmp 0x87f5
movl -0x1c(%rbp), %eax
subl $0x5c, %eax
jne 0x88b5
jmp 0x8803
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
leaq 0x4d8a(%rip), %rsi      # 0xd59f
movb $0x0, %al
callq 0x3150
movq %rax, -0x8(%rbp)
jmp 0x8913
movq -0x8(%rbp), %rdi
leaq 0x4d73(%rip), %rsi      # 0xd5a3
movl $0x2, %edx
callq 0x3420
movq %rax, -0x8(%rbp)
jmp 0x8913
movq -0x8(%rbp), %rdi
leaq 0x4d58(%rip), %rsi      # 0xd5a6
movl $0x2, %edx
callq 0x3420
movq %rax, -0x8(%rbp)
jmp 0x8913
movq -0x8(%rbp), %rdi
leaq 0x4d3d(%rip), %rsi      # 0xd5a9
movl $0x2, %edx
callq 0x3420
movq %rax, -0x8(%rbp)
jmp 0x8913
movq -0x8(%rbp), %rdi
leaq 0x4d22(%rip), %rsi      # 0xd5ac
movl $0x2, %edx
callq 0x3420
movq %rax, -0x8(%rbp)
jmp 0x8913
movq -0x8(%rbp), %rdi
leaq 0x4d0a(%rip), %rsi      # 0xd5af
movl $0x2, %edx
callq 0x3420
movq %rax, -0x8(%rbp)
jmp 0x8913
callq 0x3530
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x88f4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
leaq 0x4cb9(%rip), %rsi      # 0xd5a0
movb $0x0, %al
callq 0x3150
movq %rax, -0x8(%rbp)
jmp 0x8911
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl (%rax), %edx
leaq 0x4cac(%rip), %rsi      # 0xd5b2
movb $0x0, %al
callq 0x3150
movq %rax, -0x8(%rbp)
jmp 0x8913
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x878d
movq -0x8(%rbp), %rdi
leaq 0x508d(%rip), %rsi      # 0xd9bc
movl $0x1, %edx
callq 0x3420
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: hex_digit_to_int
int hex_digit_to_int(char c) {
    switch(c) {
    case '0': return 0;
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    case '7': return 7;
    case '8': return 8;
    case '9': return 9;
    case 'a': case 'A': return 10;
    case 'b': case 'B': return 11;
    case 'c': case 'C': return 12;
    case 'd': case 'D': return 13;
    case 'e': case 'E': return 14;
    case 'f': case 'F': return 15;
    default: return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
addl $-0x30, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x36, %eax
ja 0x8a7a
movq -0x10(%rbp), %rax
leaq 0x4a59(%rip), %rcx      # 0xd434
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x8a81
movl $0x1, -0x4(%rbp)
jmp 0x8a81
movl $0x2, -0x4(%rbp)
jmp 0x8a81
movl $0x3, -0x4(%rbp)
jmp 0x8a81
movl $0x4, -0x4(%rbp)
jmp 0x8a81
movl $0x5, -0x4(%rbp)
jmp 0x8a81
movl $0x6, -0x4(%rbp)
jmp 0x8a81
movl $0x7, -0x4(%rbp)
jmp 0x8a81
movl $0x8, -0x4(%rbp)
jmp 0x8a81
movl $0x9, -0x4(%rbp)
jmp 0x8a81
movl $0xa, -0x4(%rbp)
jmp 0x8a81
movl $0xb, -0x4(%rbp)
jmp 0x8a81
movl $0xc, -0x4(%rbp)
jmp 0x8a81
movl $0xd, -0x4(%rbp)
jmp 0x8a81
movl $0xe, -0x4(%rbp)
jmp 0x8a81
movl $0xf, -0x4(%rbp)
jmp 0x8a81
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsmapchars
sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) {
    size_t j, i, l = sdslen(s);

    for (j = 0; j < l; j++) {
        for (i = 0; i < setlen; i++) {
            if (s[j] == from[i]) {
                s[j] = to[i];
                break;
            }
        }
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6ee0
movq %rax, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x8fbd
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x8fad
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x8f9d
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x8fad
jmp 0x8f9f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x8f5f
jmp 0x8faf
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8f4d
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)