// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/bitops.c
// Function: bitopCommand
void bitopCommand(client *c) {
    char *opname = c->argv[1]->ptr;
    robj *o, *targetkey = c->argv[2];
    unsigned long op, j, numkeys;
    robj **objects;      /* Array of source objects. */
    unsigned char **src; /* Array of source strings pointers. */
    unsigned long *len, maxlen = 0; /* Array of length of src strings,
                                       and max len. */
    unsigned long minlen = 0;    /* Min len among the input keys. */
    unsigned char *res = NULL; /* Resulting string. */

    /* Parse the operation name. */
    if ((opname[0] == 'a' || opname[0] == 'A') && !strcasecmp(opname,"and"))
        op = BITOP_AND;
    else if((opname[0] == 'o' || opname[0] == 'O') && !strcasecmp(opname,"or"))
        op = BITOP_OR;
    else if((opname[0] == 'x' || opname[0] == 'X') && !strcasecmp(opname,"xor"))
        op = BITOP_XOR;
    else if((opname[0] == 'n' || opname[0] == 'N') && !strcasecmp(opname,"not"))
        op = BITOP_NOT;
    else {
        addReply(c,shared.syntaxerr);
        return;
    }

    /* Sanity check: NOT accepts only a single key argument. */
    if (op == BITOP_NOT && c->argc != 4) {
        addReplyError(c,"BITOP NOT must be called with a single source key.");
        return;
    }

    /* Lookup keys, and store pointers to the string objects into an array. */
    numkeys = c->argc - 3;
    src = zmalloc(sizeof(unsigned char*) * numkeys);
    len = zmalloc(sizeof(long) * numkeys);
    objects = zmalloc(sizeof(robj*) * numkeys);
    for (j = 0; j < numkeys; j++) {
        o = lookupKeyRead(c->db,c->argv[j+3]);
        /* Handle non-existing keys as empty strings. */
        if (o == NULL) {
            objects[j] = NULL;
            src[j] = NULL;
            len[j] = 0;
            minlen = 0;
            continue;
        }
        /* Return an error if one of the keys is not a string. */
        if (checkType(c,o,OBJ_STRING)) {
            unsigned long i;
            for (i = 0; i < j; i++) {
                if (objects[i])
                    decrRefCount(objects[i]);
            }
            zfree(src);
            zfree(len);
            zfree(objects);
            return;
        }
        objects[j] = getDecodedObject(o);
        src[j] = objects[j]->ptr;
        len[j] = sdslen(objects[j]->ptr);
        if (len[j] > maxlen) maxlen = len[j];
        if (j == 0 || len[j] < minlen) minlen = len[j];
    }

    /* Compute the bit operation, if at least one string is not empty. */
    if (maxlen) {
        res = (unsigned char*) sdsnewlen(NULL,maxlen);
        unsigned char output, byte;
        unsigned long i;

        /* Fast path: as far as we have data for all the input bitmaps we
         * can take a fast path that performs much better than the
         * vanilla algorithm. */
        j = 0;
        if (minlen >= sizeof(unsigned long)*4 && numkeys <= 16) {
            unsigned long *lp[16];
            unsigned long *lres = (unsigned long*) res;

            /* Note: sds pointer is always aligned to 8 byte boundary. */
            memcpy(lp,src,sizeof(unsigned long*)*numkeys);
            memcpy(res,src[0],minlen);

            /* Different branches per different operations for speed (sorry). */
            if (op == BITOP_AND) {
                while(minlen >= sizeof(unsigned long)*4) {
                    for (i = 1; i < numkeys; i++) {
                        lres[0] &= lp[i][0];
                        lres[1] &= lp[i][1];
                        lres[2] &= lp[i][2];
                        lres[3] &= lp[i][3];
                        lp[i]+=4;
                    }
                    lres+=4;
                    j += sizeof(unsigned long)*4;
                    minlen -= sizeof(unsigned long)*4;
                }
            } else if (op == BITOP_OR) {
                while(minlen >= sizeof(unsigned long)*4) {
                    for (i = 1; i < numkeys; i++) {
                        lres[0] |= lp[i][0];
                        lres[1] |= lp[i][1];
                        lres[2] |= lp[i][2];
                        lres[3] |= lp[i][3];
                        lp[i]+=4;
                    }
                    lres+=4;
                    j += sizeof(unsigned long)*4;
                    minlen -= sizeof(unsigned long)*4;
                }
            } else if (op == BITOP_XOR) {
                while(minlen >= sizeof(unsigned long)*4) {
                    for (i = 1; i < numkeys; i++) {
                        lres[0] ^= lp[i][0];
                        lres[1] ^= lp[i][1];
                        lres[2] ^= lp[i][2];
                        lres[3] ^= lp[i][3];
                        lp[i]+=4;
                    }
                    lres+=4;
                    j += sizeof(unsigned long)*4;
                    minlen -= sizeof(unsigned long)*4;
                }
            } else if (op == BITOP_NOT) {
                while(minlen >= sizeof(unsigned long)*4) {
                    lres[0] = ~lres[0];
                    lres[1] = ~lres[1];
                    lres[2] = ~lres[2];
                    lres[3] = ~lres[3];
                    lres+=4;
                    j += sizeof(unsigned long)*4;
                    minlen -= sizeof(unsigned long)*4;
                }
            }
        }

        /* j is set to the next byte to process by the previous loop. */
        for (; j < maxlen; j++) {
            output = (len[0] <= j) ? 0 : src[0][j];
            if (op == BITOP_NOT) output = ~output;
            for (i = 1; i < numkeys; i++) {
                byte = (len[i] <= j) ? 0 : src[i][j];
                switch(op) {
                case BITOP_AND: output &= byte; break;
                case BITOP_OR:  output |= byte; break;
                case BITOP_XOR: output ^= byte; break;
                }
            }
            res[j] = output;
        }
    }
    for (j = 0; j < numkeys; j++) {
        if (objects[j])
            decrRefCount(objects[j]);
    }
    zfree(src);
    zfree(len);
    zfree(objects);

    /* Store the computed value into the target key */
    if (maxlen) {
        o = createObject(OBJ_STRING,res);
        setKey(c->db,targetkey,o);
        notifyKeyspaceEvent(NOTIFY_STRING,"set",targetkey,c->db->id);
        decrRefCount(o);
    } else if (dbDelete(c->db,targetkey)) {
        signalModifiedKey(c->db,targetkey);
        notifyKeyspaceEvent(NOTIFY_GENERIC,"del",targetkey,c->db->id);
    }
    server.dirty++;
    addReplyLongLong(c,maxlen); /* Return the output string length in bytes. */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
je 0x91563
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
jne 0x91585
movq -0x10(%rbp), %rdi
leaq 0xbad8e(%rip), %rsi     # 0x14c2fc
callq 0x26300
cmpl $0x0, %eax
jne 0x91585
movq $0x0, -0x28(%rbp)
jmp 0x9164f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6f, %eax
je 0x9159d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4f, %eax
jne 0x915bf
movq -0x10(%rbp), %rdi
leaq 0xbad59(%rip), %rsi     # 0x14c301
callq 0x26300
cmpl $0x0, %eax
jne 0x915bf
movq $0x1, -0x28(%rbp)
jmp 0x9164d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x78, %eax
je 0x915d7
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x58, %eax
jne 0x915f6
movq -0x10(%rbp), %rdi
leaq 0xbad23(%rip), %rsi     # 0x14c305
callq 0x26300
cmpl $0x0, %eax
jne 0x915f6
movq $0x2, -0x28(%rbp)
jmp 0x9164b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
je 0x9160e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4e, %eax
jne 0x9162d
movq -0x10(%rbp), %rdi
leaq 0xbacde(%rip), %rsi     # 0x14c2f7
callq 0x26300
cmpl $0x0, %eax
jne 0x9162d
movq $0x3, -0x28(%rbp)
jmp 0x91649
movq -0x8(%rbp), %rdi
leaq 0xe7608(%rip), %rax     # 0x178c40
movq 0x80(%rax), %rsi
callq 0x42cc0
jmp 0x91ef7
jmp 0x9164b
jmp 0x9164d
jmp 0x9164f
cmpq $0x3, -0x28(%rbp)
jne 0x91675
movq -0x8(%rbp), %rax
cmpl $0x4, 0x38(%rax)
je 0x91675
movq -0x8(%rbp), %rdi
leaq 0xb4830(%rip), %rsi     # 0x145e9b
callq 0x42f90
jmp 0x91ef7
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
subl $0x3, %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
shlq $0x3, %rdi
callq 0x3acd0
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
shlq $0x3, %rdi
callq 0x3acd0
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
shlq $0x3, %rdi
callq 0x3acd0
movq %rax, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x91860
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rsi
callq 0x4a6c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x91734
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x50(%rbp), %rax
movq -0x30(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq $0x0, -0x60(%rbp)
jmp 0x9184f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x917aa
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x9178a
movq -0x40(%rbp), %rax
movq -0x70(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x9177a
movq -0x40(%rbp), %rax
movq -0x70(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x48f70
jmp 0x9177c
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x91750
movq -0x48(%rbp), %rdi
callq 0x3afa0
movq -0x50(%rbp), %rdi
callq 0x3afa0
movq -0x40(%rbp), %rdi
callq 0x3afa0
jmp 0x91ef7
movq -0x18(%rbp), %rdi
callq 0x494f0
movq %rax, %rdx
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdx
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
callq 0x90e00
movq %rax, %rdx
movq -0x50(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x50(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x58(%rbp), %rax
jbe 0x91824
movq -0x50(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x9183d
movq -0x50(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x60(%rbp), %rax
jae 0x9184d
movq -0x50(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x60(%rbp)
jmp 0x9184f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x916c0
cmpq $0x0, -0x58(%rbp)
je 0x91dce
movq -0x58(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x38230
movq %rax, -0x68(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x20, -0x60(%rbp)
jb 0x91c94
cmpq $0x10, -0x38(%rbp)
ja 0x91c94
movq -0x68(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x100(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdx
shlq $0x3, %rdx
callq 0x26c60
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rax
movq (%rax), %rsi
movq -0x60(%rbp), %rdx
callq 0x26c60
cmpq $0x0, -0x28(%rbp)
jne 0x919d5
jmp 0x918de
cmpq $0x20, -0x60(%rbp)
jb 0x919d0
movq $0x1, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x919a1
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rax
movq (%rax), %rcx
movq -0x108(%rbp), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rax
movq 0x8(%rax), %rcx
movq -0x108(%rbp), %rax
andq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rax
movq 0x10(%rax), %rcx
movq -0x108(%rbp), %rax
andq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rax
movq 0x18(%rax), %rcx
movq -0x108(%rbp), %rax
andq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rcx
addq $0x20, %rcx
movq %rcx, -0x100(%rbp,%rax,8)
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x918f1
movq -0x108(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x108(%rbp)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %rax
subq $0x20, %rax
movq %rax, -0x60(%rbp)
jmp 0x918de
jmp 0x91c92
cmpq $0x1, -0x28(%rbp)
jne 0x91ad9
jmp 0x919e2
cmpq $0x20, -0x60(%rbp)
jb 0x91ad4
movq $0x1, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x91aa5
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rax
movq (%rax), %rcx
movq -0x108(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rax
movq 0x8(%rax), %rcx
movq -0x108(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rax
movq 0x10(%rax), %rcx
movq -0x108(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rax
movq 0x18(%rax), %rcx
movq -0x108(%rbp), %rax
orq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rcx
addq $0x20, %rcx
movq %rcx, -0x100(%rbp,%rax,8)
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x919f5
movq -0x108(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x108(%rbp)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %rax
subq $0x20, %rax
movq %rax, -0x60(%rbp)
jmp 0x919e2
jmp 0x91c90
cmpq $0x2, -0x28(%rbp)
jne 0x91bdd
jmp 0x91ae6
cmpq $0x20, -0x60(%rbp)
jb 0x91bd8
movq $0x1, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x91ba9
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rax
movq (%rax), %rcx
movq -0x108(%rbp), %rax
xorq (%rax), %rcx
movq %rcx, (%rax)
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rax
movq 0x8(%rax), %rcx
movq -0x108(%rbp), %rax
xorq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rax
movq 0x10(%rax), %rcx
movq -0x108(%rbp), %rax
xorq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rax
movq 0x18(%rax), %rcx
movq -0x108(%rbp), %rax
xorq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x80(%rbp), %rax
movq -0x100(%rbp,%rax,8), %rcx
addq $0x20, %rcx
movq %rcx, -0x100(%rbp,%rax,8)
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x91af9
movq -0x108(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x108(%rbp)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %rax
subq $0x20, %rax
movq %rax, -0x60(%rbp)
jmp 0x91ae6
jmp 0x91c8e
cmpq $0x3, -0x28(%rbp)
jne 0x91c8c
jmp 0x91bea
cmpq $0x20, -0x60(%rbp)
jb 0x91c8a
movq -0x108(%rbp), %rax
movq (%rax), %rcx
xorq $-0x1, %rcx
movq -0x108(%rbp), %rax
movq %rcx, (%rax)
movq -0x108(%rbp), %rax
movq 0x8(%rax), %rcx
xorq $-0x1, %rcx
movq -0x108(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x108(%rbp), %rax
movq 0x10(%rax), %rcx
xorq $-0x1, %rcx
movq -0x108(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x108(%rbp), %rax
movq 0x18(%rax), %rcx
xorq $-0x1, %rcx
movq -0x108(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x108(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x108(%rbp)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %rax
subq $0x20, %rax
movq %rax, -0x60(%rbp)
jmp 0x91bea
jmp 0x91c8c
jmp 0x91c8e
jmp 0x91c90
jmp 0x91c92
jmp 0x91c94
jmp 0x91c96
movq -0x30(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0x91dcc
movq -0x50(%rbp), %rax
movq (%rax), %rax
cmpq -0x30(%rbp), %rax
ja 0x91cbb
xorl %eax, %eax
movl %eax, -0x10c(%rbp)
jmp 0x91cd0
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x10c(%rbp)
movl -0x10c(%rbp), %eax
movb %al, -0x71(%rbp)
cmpq $0x3, -0x28(%rbp)
jne 0x91cea
movzbl -0x71(%rbp), %eax
xorl $-0x1, %eax
movb %al, -0x71(%rbp)
movq $0x1, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x91dad
movq -0x50(%rbp), %rax
movq -0x80(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x30(%rbp), %rax
ja 0x91d1c
xorl %eax, %eax
movl %eax, -0x110(%rbp)
jmp 0x91d36
movq -0x48(%rbp), %rax
movq -0x80(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x110(%rbp)
movl -0x110(%rbp), %eax
movb %al, -0x72(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x118(%rbp)
testq %rax, %rax
je 0x91d6f
jmp 0x91d51
movq -0x118(%rbp), %rax
subq $0x1, %rax
je 0x91d7e
jmp 0x91d60
movq -0x118(%rbp), %rax
subq $0x2, %rax
je 0x91d8d
jmp 0x91d9a
movzbl -0x72(%rbp), %ecx
movzbl -0x71(%rbp), %eax
andl %ecx, %eax
movb %al, -0x71(%rbp)
jmp 0x91d9a
movzbl -0x72(%rbp), %ecx
movzbl -0x71(%rbp), %eax
orl %ecx, %eax
movb %al, -0x71(%rbp)
jmp 0x91d9a
movzbl -0x72(%rbp), %ecx
movzbl -0x71(%rbp), %eax
xorl %ecx, %eax
movb %al, -0x71(%rbp)
jmp 0x91d9c
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x91cf2
movb -0x71(%rbp), %dl
movq -0x68(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x91c96
jmp 0x91dce
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x91e10
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x91e00
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x48f70
jmp 0x91e02
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x91dd6
movq -0x48(%rbp), %rdi
callq 0x3afa0
movq -0x50(%rbp), %rdi
callq 0x3afa0
movq -0x40(%rbp), %rdi
callq 0x3afa0
cmpq $0x0, -0x58(%rbp)
je 0x91e81
movq -0x68(%rbp), %rsi
xorl %edi, %edi
callq 0x48480
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4a960
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x8, %edi
leaq 0xa69c4(%rip), %rsi     # 0x138835
callq 0x9ce20
movq -0x18(%rbp), %rdi
callq 0x48f70
jmp 0x91eca
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4ac10
cmpl $0x0, %eax
je 0x91ec8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4aa60
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x4, %edi
leaq 0xa75d5(%rip), %rsi     # 0x139498
callq 0x9ce20
jmp 0x91eca
leaq 0xe6307(%rip), %rax     # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0xe62f5(%rip), %rax     # 0x1781d8
movq %rcx, 0x720(%rax)
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x43780
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq