// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/bitops.c
// Function: bitfieldCommand
void bitfieldCommand(client *c) {
    robj *o;
    size_t bitoffset;
    int j, numops = 0, changes = 0;
    struct bitfieldOp *ops = NULL; /* Array of ops to execute at end. */
    int owtype = BFOVERFLOW_WRAP; /* Overflow type. */
    int readonly = 1;
    size_t higest_write_offset = 0;

    for (j = 2; j < c->argc; j++) {
        int remargs = c->argc-j-1; /* Remaining args other than current. */
        char *subcmd = c->argv[j]->ptr; /* Current command name. */
        int opcode; /* Current operation code. */
        long long i64 = 0;  /* Signed SET value. */
        int sign = 0; /* Signed or unsigned type? */
        int bits = 0; /* Bitfield width in bits. */

        if (!strcasecmp(subcmd,"get") && remargs >= 2)
            opcode = BITFIELDOP_GET;
        else if (!strcasecmp(subcmd,"set") && remargs >= 3)
            opcode = BITFIELDOP_SET;
        else if (!strcasecmp(subcmd,"incrby") && remargs >= 3)
            opcode = BITFIELDOP_INCRBY;
        else if (!strcasecmp(subcmd,"overflow") && remargs >= 1) {
            char *owtypename = c->argv[j+1]->ptr;
            j++;
            if (!strcasecmp(owtypename,"wrap"))
                owtype = BFOVERFLOW_WRAP;
            else if (!strcasecmp(owtypename,"sat"))
                owtype = BFOVERFLOW_SAT;
            else if (!strcasecmp(owtypename,"fail"))
                owtype = BFOVERFLOW_FAIL;
            else {
                addReplyError(c,"Invalid OVERFLOW type specified");
                zfree(ops);
                return;
            }
            continue;
        } else {
            addReply(c,shared.syntaxerr);
            zfree(ops);
            return;
        }

        /* Get the type and offset arguments, common to all the ops. */
        if (getBitfieldTypeFromArgument(c,c->argv[j+1],&sign,&bits) != C_OK) {
            zfree(ops);
            return;
        }

        if (getBitOffsetFromArgument(c,c->argv[j+2],&bitoffset,1,bits) != C_OK){
            zfree(ops);
            return;
        }

        if (opcode != BITFIELDOP_GET) {
            readonly = 0;
            if (higest_write_offset < bitoffset + bits - 1)
                higest_write_offset = bitoffset + bits - 1;
            /* INCRBY and SET require another argument. */
            if (getLongLongFromObjectOrReply(c,c->argv[j+3],&i64,NULL) != C_OK){
                zfree(ops);
                return;
            }
        }

        /* Populate the array of operations we'll process. */
        ops = zrealloc(ops,sizeof(*ops)*(numops+1));
        ops[numops].offset = bitoffset;
        ops[numops].i64 = i64;
        ops[numops].opcode = opcode;
        ops[numops].owtype = owtype;
        ops[numops].bits = bits;
        ops[numops].sign = sign;
        numops++;

        j += 3 - (opcode == BITFIELDOP_GET);
    }

    if (readonly) {
        /* Lookup for read is ok if key doesn't exit, but errors
         * if it's not a string. */
        o = lookupKeyRead(c->db,c->argv[1]);
        if (o != NULL && checkType(c,o,OBJ_STRING)) return;
    } else {
        /* Lookup by making room up to the farest bit reached by
         * this operation. */
        if ((o = lookupStringForBitCommand(c,
            higest_write_offset)) == NULL) return;
    }

    addReplyMultiBulkLen(c,numops);

    /* Actually process the operations. */
    for (j = 0; j < numops; j++) {
        struct bitfieldOp *thisop = ops+j;

        /* Execute the operation. */
        if (thisop->opcode == BITFIELDOP_SET ||
            thisop->opcode == BITFIELDOP_INCRBY)
        {
            /* SET and INCRBY: We handle both with the same code path
             * for simplicity. SET return value is the previous value so
             * we need fetch & store as well. */

            /* We need two different but very similar code paths for signed
             * and unsigned operations, since the set of functions to get/set
             * the integers and the used variables types are different. */
            if (thisop->sign) {
                int64_t oldval, newval, wrapped, retval;
                int overflow;

                oldval = getSignedBitfield(o->ptr,thisop->offset,
                        thisop->bits);

                if (thisop->opcode == BITFIELDOP_INCRBY) {
                    newval = oldval + thisop->i64;
                    overflow = checkSignedBitfieldOverflow(oldval,
                            thisop->i64,thisop->bits,thisop->owtype,&wrapped);
                    if (overflow) newval = wrapped;
                    retval = newval;
                } else {
                    newval = thisop->i64;
                    overflow = checkSignedBitfieldOverflow(newval,
                            0,thisop->bits,thisop->owtype,&wrapped);
                    if (overflow) newval = wrapped;
                    retval = oldval;
                }

                /* On overflow of type is "FAIL", don't write and return
                 * NULL to signal the condition. */
                if (!(overflow && thisop->owtype == BFOVERFLOW_FAIL)) {
                    addReplyLongLong(c,retval);
                    setSignedBitfield(o->ptr,thisop->offset,
                                      thisop->bits,newval);
                } else {
                    addReply(c,shared.nullbulk);
                }
            } else {
                uint64_t oldval, newval, wrapped, retval;
                int overflow;

                oldval = getUnsignedBitfield(o->ptr,thisop->offset,
                        thisop->bits);

                if (thisop->opcode == BITFIELDOP_INCRBY) {
                    newval = oldval + thisop->i64;
                    overflow = checkUnsignedBitfieldOverflow(oldval,
                            thisop->i64,thisop->bits,thisop->owtype,&wrapped);
                    if (overflow) newval = wrapped;
                    retval = newval;
                } else {
                    newval = thisop->i64;
                    overflow = checkUnsignedBitfieldOverflow(newval,
                            0,thisop->bits,thisop->owtype,&wrapped);
                    if (overflow) newval = wrapped;
                    retval = oldval;
                }
                /* On overflow of type is "FAIL", don't write and return
                 * NULL to signal the condition. */
                if (!(overflow && thisop->owtype == BFOVERFLOW_FAIL)) {
                    addReplyLongLong(c,retval);
                    setUnsignedBitfield(o->ptr,thisop->offset,
                                        thisop->bits,newval);
                } else {
                    addReply(c,shared.nullbulk);
                }
            }
            changes++;
        } else {
            /* GET */
            unsigned char buf[9];
            long strlen = 0;
            unsigned char *src = NULL;
            char llbuf[LONG_STR_SIZE];

            if (o != NULL)
                src = getObjectReadOnlyString(o,&strlen,llbuf);

            /* For GET we use a trick: before executing the operation
             * copy up to 9 bytes to a local buffer, so that we can easily
             * execute up to 64 bit operations that are at actual string
             * object boundaries. */
            memset(buf,0,9);
            int i;
            size_t byte = thisop->offset >> 3;
            for (i = 0; i < 9; i++) {
                if (src == NULL || i+byte >= (size_t)strlen) break;
                buf[i] = src[i+byte];
            }

            /* Now operate on the copied buffer which is guaranteed
             * to be zero-padded. */
            if (thisop->sign) {
                int64_t val = getSignedBitfield(buf,thisop->offset-(byte*8),
                                            thisop->bits);
                addReplyLongLong(c,val);
            } else {
                uint64_t val = getUnsignedBitfield(buf,thisop->offset-(byte*8),
                                            thisop->bits);
                addReplyLongLong(c,val);
            }
        }
    }

    if (changes) {
        signalModifiedKey(c->db,c->argv[1]);
        notifyKeyspaceEvent(NOTIFY_STRING,"setbit",c->argv[1],c->db->id);
        server.dirty += changes;
    }
    zfree(ops);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x1, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x2, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x9273d
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
subl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
movl $0x0, -0x68(%rbp)
movq -0x50(%rbp), %rdi
leaq 0xa52ba(%rip), %rsi     # 0x1376e5
callq 0x26300
cmpl $0x0, %eax
jne 0x92447
cmpl $0x2, -0x44(%rbp)
jl 0x92447
movl $0x0, -0x54(%rbp)
jmp 0x92588
movq -0x50(%rbp), %rdi
leaq 0xa63e3(%rip), %rsi     # 0x138835
callq 0x26300
cmpl $0x0, %eax
jne 0x9246e
cmpl $0x3, -0x44(%rbp)
jl 0x9246e
movl $0x1, -0x54(%rbp)
jmp 0x92586
movq -0x50(%rbp), %rdi
leaq 0xa527d(%rip), %rsi     # 0x1376f6
callq 0x26300
cmpl $0x0, %eax
jne 0x92495
cmpl $0x3, -0x44(%rbp)
jl 0x92495
movl $0x2, -0x54(%rbp)
jmp 0x92584
movq -0x50(%rbp), %rdi
leaq 0xab491(%rip), %rsi     # 0x13d931
callq 0x26300
cmpl $0x0, %eax
jne 0x9255f
cmpl $0x1, -0x44(%rbp)
jl 0x9255f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x70(%rbp), %rdi
leaq 0xb3a06(%rip), %rsi     # 0x145eef
callq 0x26300
cmpl $0x0, %eax
jne 0x924fc
movl $0x0, -0x34(%rbp)
jmp 0x9255a
movq -0x70(%rbp), %rdi
leaq 0xb39ed(%rip), %rsi     # 0x145ef4
callq 0x26300
cmpl $0x0, %eax
jne 0x9251a
movl $0x1, -0x34(%rbp)
jmp 0x92558
movq -0x70(%rbp), %rdi
leaq 0xaf281(%rip), %rsi     # 0x1417a6
callq 0x26300
cmpl $0x0, %eax
jne 0x92538
movl $0x2, -0x34(%rbp)
jmp 0x92556
movq -0x8(%rbp), %rdi
leaq 0xb39b5(%rip), %rsi     # 0x145ef8
callq 0x42f90
movq -0x30(%rbp), %rdi
callq 0x3afa0
jmp 0x92c89
jmp 0x92558
jmp 0x9255a
jmp 0x9272f
movq -0x8(%rbp), %rdi
leaq 0xe66d6(%rip), %rax     # 0x178c40
movq 0x80(%rax), %rsi
callq 0x42cc0
movq -0x30(%rbp), %rdi
callq 0x3afa0
jmp 0x92c89
jmp 0x92586
jmp 0x92588
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq 0x90e90
cmpl $0x0, %eax
je 0x925c1
movq -0x30(%rbp), %rdi
callq 0x3afa0
jmp 0x92c89
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movl -0x68(%rbp), %r8d
leaq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x90d00
cmpl $0x0, %eax
je 0x925ff
movq -0x30(%rbp), %rdi
callq 0x3afa0
jmp 0x92c89
cmpl $0x0, -0x54(%rbp)
je 0x92672
movl $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x68(%rbp), %rdx
addq %rdx, %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x92637
movq -0x18(%rbp), %rax
movslq -0x68(%rbp), %rcx
addq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x60(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x49ea0
cmpl $0x0, %eax
je 0x92670
movq -0x30(%rbp), %rdi
callq 0x3afa0
jmp 0x92c89
jmp 0x92672
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x5, %rsi
callq 0x3ae40
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x54(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, 0x14(%rax)
movl -0x68(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
movl -0x64(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, 0x1c(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x54(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %ecx
movl $0x3, %eax
subl %ecx, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x923d2
cmpl $0x0, -0x38(%rbp)
je 0x92782
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4a6c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x92780
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x92780
jmp 0x92c89
jmp 0x927a0
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x90fa0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x9279e
jmp 0x92c89
jmp 0x927a0
movq -0x8(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x437f0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x92c19
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
cmpl $0x1, 0x10(%rax)
je 0x927eb
movq -0x78(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0x92aae
movq -0x78(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x92948
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x78(%rbp), %rax
movq (%rax), %rsi
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rdx
callq 0x908c0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0x9288a
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rdx
movq -0x78(%rbp), %rax
movl 0x14(%rax), %ecx
leaq -0x90(%rbp), %r8
callq 0x90a80
movl %eax, -0x9c(%rbp)
cmpl $0x0, -0x9c(%rbp)
je 0x9287a
movq -0x90(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x928e7
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rdx
movq -0x78(%rbp), %rax
movl 0x14(%rax), %ecx
xorl %eax, %eax
movl %eax, %esi
leaq -0x90(%rbp), %r8
callq 0x90a80
movl %eax, -0x9c(%rbp)
cmpl $0x0, -0x9c(%rbp)
je 0x928dc
movq -0x90(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpl $0x0, -0x9c(%rbp)
je 0x928fa
movq -0x78(%rbp), %rax
cmpl $0x2, 0x14(%rax)
je 0x9292f
movq -0x8(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x43780
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x78(%rbp), %rax
movq (%rax), %rsi
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rdx
movq -0x88(%rbp), %rcx
callq 0x907e0
jmp 0x92943
movq -0x8(%rbp), %rdi
leaq 0xe6306(%rip), %rax     # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x92aa0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x78(%rbp), %rax
movq (%rax), %rsi
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rdx
callq 0x90820
movq %rax, -0xa8(%rbp)
movq -0x78(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0x929e2
movq -0xa8(%rbp), %rax
movq -0x78(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rdi
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rdx
movq -0x78(%rbp), %rax
movl 0x14(%rax), %ecx
leaq -0xb8(%rbp), %r8
callq 0x90940
movl %eax, -0xc4(%rbp)
cmpl $0x0, -0xc4(%rbp)
je 0x929d2
movq -0xb8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0xc0(%rbp)
jmp 0x92a42
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rdx
movq -0x78(%rbp), %rax
movl 0x14(%rax), %ecx
xorl %eax, %eax
movl %eax, %esi
leaq -0xb8(%rbp), %r8
callq 0x90940
movl %eax, -0xc4(%rbp)
cmpl $0x0, -0xc4(%rbp)
je 0x92a34
movq -0xb8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpl $0x0, -0xc4(%rbp)
je 0x92a55
movq -0x78(%rbp), %rax
cmpl $0x2, 0x14(%rax)
je 0x92a8a
movq -0x8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x43780
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x78(%rbp), %rax
movq (%rax), %rsi
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rdx
movq -0xb0(%rbp), %rcx
callq 0x906f0
jmp 0x92a9e
movq -0x8(%rbp), %rdi
leaq 0xe61ab(%rip), %rax     # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x92aa0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x92c09
movq $0x0, -0xd8(%rbp)
movq $0x0, -0xe0(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x92ae9
movq -0x10(%rbp), %rdi
leaq -0x100(%rbp), %rdx
leaq -0xd8(%rbp), %rsi
callq 0x91090
movq %rax, -0xe0(%rbp)
leaq -0xcd(%rbp), %rdi
xorl %esi, %esi
movl $0x9, %edx
callq 0x26110
movq -0x78(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x110(%rbp)
movl $0x0, -0x104(%rbp)
cmpl $0x9, -0x104(%rbp)
jge 0x92b7b
cmpq $0x0, -0xe0(%rbp)
je 0x92b42
movslq -0x104(%rbp), %rax
addq -0x110(%rbp), %rax
cmpq -0xd8(%rbp), %rax
jb 0x92b44
jmp 0x92b7b
movq -0xe0(%rbp), %rax
movslq -0x104(%rbp), %rcx
addq -0x110(%rbp), %rcx
movb (%rax,%rcx), %cl
movslq -0x104(%rbp), %rax
movb %cl, -0xcd(%rbp,%rax)
movl -0x104(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x104(%rbp)
jmp 0x92b18
movq -0x78(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x92bc7
leaq -0xcd(%rbp), %rdi
movq -0x78(%rbp), %rax
movq (%rax), %rsi
movq -0x110(%rbp), %rax
shlq $0x3, %rax
subq %rax, %rsi
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rdx
callq 0x908c0
movq %rax, -0x118(%rbp)
movq -0x8(%rbp), %rdi
movq -0x118(%rbp), %rsi
callq 0x43780
jmp 0x92c07
leaq -0xcd(%rbp), %rdi
movq -0x78(%rbp), %rax
movq (%rax), %rsi
movq -0x110(%rbp), %rax
shlq $0x3, %rax
subq %rax, %rsi
movq -0x78(%rbp), %rax
movslq 0x18(%rax), %rdx
callq 0x90820
movq %rax, -0x120(%rbp)
movq -0x8(%rbp), %rdi
movq -0x120(%rbp), %rsi
callq 0x43780
jmp 0x92c09
jmp 0x92c0b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x927b4
cmpl $0x0, -0x24(%rbp)
je 0x92c80
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4aa60
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x8, %edi
leaq 0xa4895(%rip), %rsi     # 0x1374f0
callq 0x9ce20
movslq -0x24(%rbp), %rcx
leaq 0xe556d(%rip), %rax     # 0x1781d8
addq 0x720(%rax), %rcx
leaq 0xe555f(%rip), %rax     # 0x1781d8
movq %rcx, 0x720(%rax)
movq -0x30(%rbp), %rdi
callq 0x3afa0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)