// File: /workspace/github_c_makefile_star2_O3/vtereshkov[P]umka-lang/src/umka_vm.c
// Function: doFillReprBuf
static int doFillReprBuf(const Slot *slot, const Type *type, char *buf, int maxLen, int depth, bool pretty, bool dereferenced, Storage *storage, Error *error)
{
    enum {MAX_DEPTH = 20};

    int len = 0;

    if (depth == MAX_DEPTH)
    {
        len += snprintf(buf + len, maxLen, "...");
        return len;
    }

    switch (type->kind)
    {
        case TYPE_VOID:     len += snprintf(buf + len, maxLen, "void");                                                             break;
        case TYPE_INT8:
        case TYPE_INT16:
        case TYPE_INT32:
        case TYPE_INT:
        case TYPE_UINT8:
        case TYPE_UINT16:
        case TYPE_UINT32:   len += snprintf(buf + len, maxLen, "%lld", (long long int)slot->intVal);                                break;
        case TYPE_UINT:     len += snprintf(buf + len, maxLen, "%llu", (unsigned long long int)slot->uintVal);                      break;
        case TYPE_BOOL:     len += snprintf(buf + len, maxLen, slot->intVal ? "true" : "false");                                    break;
        case TYPE_CHAR:
        {
            const char *format = (unsigned char)slot->intVal >= ' ' ? "'%c'" : "0x%02X";
            len += snprintf(buf + len, maxLen, format, (unsigned char)slot->intVal);
            break;
        }
        case TYPE_REAL32:
        case TYPE_REAL:     len += snprintf(buf + len, maxLen, "%lg", slot->realVal);                                               break;
        case TYPE_PTR:
        {
            len += snprintf(buf + len, maxLen, "%p", slot->ptrVal);

            if (dereferenced && slot->ptrVal && type->base->kind != TYPE_VOID)
            {
                Slot dataSlot = {.ptrVal = slot->ptrVal};
                doDerefImpl(&dataSlot, type->base->kind, error);

                len += snprintf(buf + len, maxLen, " -> ");
                len += doPrintIndented(buf + len, maxLen, depth, pretty, '(');
                len += doFillReprBuf(&dataSlot, type->base, buf + len, maxLen, depth + 1, pretty, dereferenced, storage, error);
                len += doPrintIndented(buf + len, maxLen, depth, pretty, ')');
            }
            break;
        }
        case TYPE_WEAKPTR:  len += snprintf(buf + len, maxLen, "%llx", (unsigned long long int)slot->weakPtrVal);                   break;
        case TYPE_STR:
        {
            doCheckStr((char *)slot->ptrVal, error);
            len += snprintf(buf + len, maxLen, "\"%s\"", slot->ptrVal ? (char *)slot->ptrVal : "");
            break;
        }
        case TYPE_ARRAY:
        {
            len += doPrintIndented(buf + len, maxLen, depth, pretty, '[');

            char *itemPtr = slot->ptrVal;
            const int itemSize = type->base->size;

            for (int i = 0; i < type->numItems; i++)
            {
                Slot itemSlot = {.ptrVal = itemPtr};
                doDerefImpl(&itemSlot, type->base->kind, error);
                len += doFillReprBuf(&itemSlot, type->base, buf + len, maxLen, depth + 1, pretty, dereferenced, storage, error);

                if (i < type->numItems - 1)
                    len += doPrintIndented(buf + len, maxLen, depth, pretty, ' ');

                itemPtr += itemSize;
            }

            len += doPrintIndented(buf + len, maxLen, depth, pretty, ']');
            break;
        }

        case TYPE_DYNARRAY:
        {
            len += doPrintIndented(buf + len, maxLen, depth, pretty, '[');

            const DynArray *array = slot->ptrVal;
            if (array && array->data)
            {
                char *itemPtr = array->data;
                for (int i = 0; i < getDims(array)->len; i++)
                {
                    Slot itemSlot = {.ptrVal = itemPtr};
                    doDerefImpl(&itemSlot, type->base->kind, error);
                    len += doFillReprBuf(&itemSlot, type->base, buf + len, maxLen, depth + 1, pretty, dereferenced, storage, error);

                    if (i < getDims(array)->len - 1)
                        len += doPrintIndented(buf + len, maxLen, depth, pretty, ' ');

                    itemPtr += array->itemSize;
                }
            }

            len += doPrintIndented(buf + len, maxLen, depth, pretty, ']');
            break;
        }

        case TYPE_MAP:
        {
            len += doPrintIndented(buf + len, maxLen, depth, pretty, '{');

            Map *map = slot->ptrVal;
            if (map && map->root)
            {
                const Type *keyType = typeMapKey(map->type);
                const Type *itemType = typeMapItem(map->type);

                void *keys = storageAdd(storage, map->root->len * keyType->size);

                doGetMapKeys(map, keys, error);

                char *keyPtr = (char *)keys;
                for (int i = 0; i < map->root->len; i++)
                {
                    Slot keySlot = {.ptrVal = keyPtr};
                    doDerefImpl(&keySlot, keyType->kind, error);
                    len += doFillReprBuf(&keySlot, keyType, buf + len, maxLen, depth + 1, pretty, dereferenced, storage, error);

                    len += snprintf(buf + len, maxLen, ": ");

                    const MapNode *node = *doGetMapNode(map, keySlot, false, NULL, error);
                    if (UNLIKELY(!node))
                        error->runtimeHandler(error->context, ERR_RUNTIME, "Map node is null");

                    Slot itemSlot = {.ptrVal = node->data};
                    doDerefImpl(&itemSlot, itemType->kind, error);
                    len += doFillReprBuf(&itemSlot, itemType, buf + len, maxLen, depth + 1, pretty, dereferenced, storage, error);

                    if (i < map->root->len - 1)
                        len += doPrintIndented(buf + len, maxLen, depth, pretty, ' ');

                    keyPtr += keyType->size;
                }

                storageRemove(storage, keys);
            }

            len += doPrintIndented(buf + len, maxLen, depth, pretty, '}');
            break;
        }


        case TYPE_STRUCT:
        case TYPE_CLOSURE:
        {
            len += doPrintIndented(buf + len, maxLen, depth, pretty, '{');

            bool skipNames = typeExprListStruct(type);

            for (int i = 0; i < type->numItems; i++)
            {
                Slot fieldSlot = {.ptrVal = (char *)slot->ptrVal + type->field[i]->offset};
                doDerefImpl(&fieldSlot, type->field[i]->type->kind, error);
                if (!skipNames)
                    len += snprintf(buf + len, maxLen, "%s: ", type->field[i]->name);
                len += doFillReprBuf(&fieldSlot, type->field[i]->type, buf + len, maxLen, depth + 1, pretty, dereferenced, storage, error);

                if (i < type->numItems - 1)
                    len += doPrintIndented(buf + len, maxLen, depth, pretty, ' ');
            }

            len += doPrintIndented(buf + len, maxLen, depth, pretty, '}');
            break;
        }

        case TYPE_INTERFACE:
        {
            const Interface *interface = (Interface *)slot->ptrVal;
            if (interface->self)
            {
                Slot selfSlot = {.ptrVal = interface->self};
                doDerefImpl(&selfSlot, interface->selfType->base->kind, error);

                if (pretty)
                {
                    char selfTypeBuf[DEFAULT_STR_LEN + 1];
                    len += snprintf(buf + len, maxLen, "%s", typeSpelling(interface->selfType->base, selfTypeBuf));
                    len += doPrintIndented(buf + len, maxLen, depth, pretty, '(');
                }

                len += doFillReprBuf(&selfSlot, interface->selfType->base, buf + len, maxLen, depth + 1, pretty, dereferenced, storage, error);

                if (pretty)
                    len += doPrintIndented(buf + len, maxLen, depth, pretty, ')');
            }
            else
                len += snprintf(buf + len, maxLen, "null");
            break;
        }

        case TYPE_FIBER:    len += snprintf(buf + len, maxLen, "fiber @ %p", slot->ptrVal);                break;
        case TYPE_FN:       len += snprintf(buf + len, maxLen, "fn @ %lld", (long long int)slot->intVal);  break;
        default:            break;
    }

    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %r9d, 0x4(%rsp)
movl %ecx, %r9d
movq %rdx, %r14
cmpl $0x14, %r8d
jne 0x45eee
movslq %r9d, %rsi
leaq 0x31e4e(%rip), %rdx     # 0x77d21
movq %r14, %rdi
xorl %eax, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3170
movq %rsi, %rbp
movl (%rsi), %eax
xorl %ebx, %ebx
addl $-0x2, %eax
cmpl $0x18, %eax
ja 0x46ebd
movq %rdi, %r15
movq %r8, 0x30(%rsp)
movq 0x1f0(%rsp), %r13
movq 0x1e8(%rsp), %rcx
movq %rcx, 0x50(%rsp)
movb 0x1e0(%rsp), %r12b
leaq 0x334af(%rip), %rcx     # 0x793dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
movq %r14, 0x58(%rsp)
movl %r9d, 0x1c(%rsp)
jmpq *%rax
movslq %r9d, %rsi
movq (%r15), %rcx
leaq 0x35421(%rip), %rdx     # 0x7b36e
movq %r14, %rdi
xorl %eax, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3170
movq %r15, 0x40(%rsp)
movslq %r9d, %rsi
leaq 0x353fc(%rip), %rdx     # 0x7b373
movq %r14, %rdi
movq %rsi, 0x10(%rsp)
movl $0x7b, %ecx
xorl %eax, %eax
callq 0x3170
movl %eax, %r15d
cmpb $0x0, 0x4(%rsp)
je 0x45fc6
movslq %r15d, %rdi
addq %r14, %rdi
movq 0x30(%rsp), %rax
leal 0x4(,%rax,4), %ecx
leaq 0x353c8(%rip), %rdx     # 0x7b376
movq 0x10(%rsp), %rsi
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
addl %r15d, %eax
movl %eax, %r15d
cmpl $0x16, (%rbp)
jne 0x46009
cmpb $0x1, 0x14(%rbp)
jne 0x46009
cmpl $0x0, 0x10(%rbp)
setg %al
movl %eax, 0x38(%rsp)
jmp 0x46011
movslq %r9d, %rsi
movsd (%r15), %xmm0
leaq 0x35136(%rip), %rdx     # 0x7b124
movq %r14, %rdi
movb $0x1, %al
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3170
movl $0x0, 0x38(%rsp)
cmpl $0x0, 0x10(%rbp)
jle 0x46206
movq 0x30(%rsp), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x48(%rsp)
leal 0x4(,%rax,4), %eax
movl %eax, 0x78(%rsp)
movzbl %r12b, %eax
movq %rax, 0x20(%rsp)
movzbl 0x4(%rsp), %eax
movl %eax, 0x2c(%rsp)
xorl %ebx, %ebx
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rbp), %rcx
movq (%rcx,%rbx,8), %rcx
movslq 0x110(%rcx), %r12
addq %rax, %r12
movq %r12, 0x90(%rsp)
movq 0x108(%rcx), %rcx
movl (%rcx), %r14d
testq %rax, %rax
je 0x461eb
addl $-0x4, %r14d
cmpl $0x16, %r14d
ja 0x461cb
leaq 0x3340c(%rip), %rcx     # 0x7949c
movslq (%rcx,%r14,4), %rax
addq %rcx, %rax
movq 0x58(%rsp), %r14
jmpq *%rax
movq (%r12), %rax
jmp 0x460e6
movzbl (%r12), %eax
jmp 0x460e6
movslq (%r12), %rax
jmp 0x460e6
movl (%r12), %eax
jmp 0x460e6
xorps %xmm0, %xmm0
cvtss2sd (%r12), %xmm0
jmp 0x460d6
movsbq (%r12), %rax
jmp 0x460e6
movswq (%r12), %rax
jmp 0x460e6
movsd (%r12), %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x460ee
movzwl (%r12), %eax
movq %rax, 0x90(%rsp)
movq 0x28(%rbp), %rax
cmpb $0x0, 0x38(%rsp)
jne 0x4611e
movslq %r15d, %r15
leaq (%r14,%r15), %rdi
movq (%rax,%rbx,8), %rcx
movq 0x10(%rsp), %rsi
leaq 0x35249(%rip), %rdx     # 0x7b359
xorl %eax, %eax
callq 0x3170
addl %eax, %r15d
movq 0x28(%rbp), %rax
movl 0x1c(%rsp), %ecx
movq 0x50(%rsp), %r10
movq (%rax,%rbx,8), %rax
movq 0x108(%rax), %rsi
movslq %r15d, %r15
leaq (%r14,%r15), %rdx
subq $0x8, %rsp
leaq 0x98(%rsp), %rdi
movl 0x50(%rsp), %r8d
movl 0x34(%rsp), %r9d
pushq %r13
pushq %r10
pushq 0x38(%rsp)
callq 0x45ea7
addq $0x20, %rsp
addl %eax, %r15d
movslq 0x10(%rbp), %rcx
movq %rcx, %rax
decq %rax
cmpq %rax, %rbx
jge 0x461ba
movslq %r15d, %rdi
addq %r14, %rdi
cmpb $0x0, 0x4(%rsp)
je 0x4619e
movq 0x10(%rsp), %rsi
leaq 0x351eb(%rip), %rdx     # 0x7b376
movl 0x78(%rsp), %ecx
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
jmp 0x461b1
movq 0x10(%rsp), %rsi
leaq 0x2e314(%rip), %rdx     # 0x744be
xorl %eax, %eax
callq 0x3170
addl %r15d, %eax
movl 0x10(%rbp), %ecx
movl %eax, %r15d
incq %rbx
movslq %ecx, %rax
cmpq %rax, %rbx
jl 0x46046
jmp 0x46206
movq 0x20(%r13), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2fe35(%rip), %rdx     # 0x76010
xorl %eax, %eax
callq *0x8(%r13)
movq 0x58(%rsp), %r14
jmp 0x460ee
movq 0x20(%r13), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2fe05(%rip), %rdx     # 0x76000
xorl %eax, %eax
callq *0x8(%r13)
jmp 0x4607b
movslq %r15d, %rax
addq %rax, %r14
xorl %eax, %eax
cmpb $0x0, 0x4(%rsp)
je 0x46e29
movq 0x30(%rsp), %rcx
testl %ecx, %ecx
jle 0x46e13
shll $0x2, %ecx
leaq 0x35146(%rip), %rdx     # 0x7b376
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
jmp 0x46e29
movq %r15, %rbx
movl %r12d, %r15d
movslq %r9d, %rsi
leaq 0x35119(%rip), %rdx     # 0x7b373
movq %r14, %rdi
movq %rsi, 0x68(%rsp)
movl $0x7b, %ecx
xorl %eax, %eax
callq 0x3170
movl %eax, %r12d
cmpb $0x0, 0x4(%rsp)
je 0x462a9
movslq %r12d, %rdi
addq %r14, %rdi
movq 0x30(%rsp), %rax
leal 0x4(,%rax,4), %ecx
leaq 0x350e5(%rip), %rdx     # 0x7b376
movq 0x68(%rsp), %rsi
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
addl %r12d, %eax
movl %eax, %r12d
movq (%rbx), %rbp
testq %rbp, %rbp
je 0x46dc0
movq 0x8(%rbp), %rax
testq %rax, %rax
je 0x46dc0
leaq 0x8(%rbp), %rcx
movq %rcx, 0x48(%rsp)
movq (%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rcx
movq 0x108(%rdx), %rdx
movq 0x8(%rdx), %rdx
movq 0x108(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x20(%rsp)
movq %rdx, 0x70(%rsp)
movslq 0xc0(%rdx), %rsi
imulq (%rax), %rsi
movq 0x50(%rsp), %rdi
callq 0x7a70
leaq 0x90(%rsp), %rbx
movl $0x0, (%rbx)
movq 0x8(%rbp), %rsi
movq %rbp, %rdi
movq %rax, 0x198(%rsp)
movq %rax, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x47253
movslq (%rbx), %rax
movq 0x8(%rbp), %rcx
cmpq %rax, (%rcx)
jne 0x4722d
testq %rax, %rax
jle 0x46dae
leaq 0x8(%r13), %rax
movq %rax, 0x40(%rsp)
leaq 0x20(%r13), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2c(%rsp)
leal 0x4(,%rax,4), %eax
movl %eax, 0x8c(%rsp)
movzbl %r15b, %eax
movq %rax, 0x78(%rsp)
movzbl 0x4(%rsp), %eax
movl %eax, 0x64(%rsp)
leaq 0x331b7(%rip), %r15     # 0x79554
xorl %ebx, %ebx
movq 0x198(%rsp), %rdx
movq 0x70(%rsp), %rsi
movq %rbx, 0x1a0(%rsp)
movq %rdx, 0x90(%rsp)
movl (%rsi), %ebx
testq %rdx, %rdx
movq %rdx, 0x80(%rsp)
je 0x4673e
addl $-0x4, %ebx
cmpl $0x16, %ebx
ja 0x465e6
leaq 0x33116(%rip), %rcx     # 0x794f8
movslq (%rcx,%rbx,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdx), %rbx
jmp 0x4642f
movq %rdx, %rbx
jmp 0x46437
movzbl (%rdx), %ebx
jmp 0x4642f
movsd (%rdx), %xmm0
jmp 0x4640b
movl (%rdx), %ebx
jmp 0x4642f
xorps %xmm0, %xmm0
cvtss2sd (%rdx), %xmm0
movsd %xmm0, 0x90(%rsp)
movq %xmm0, %rbx
jmp 0x46437
movslq (%rdx), %rbx
jmp 0x4642f
movzwl (%rdx), %ebx
jmp 0x4642f
movsbq (%rdx), %rbx
jmp 0x4642f
movswq (%rdx), %rbx
movq %rbx, 0x90(%rsp)
movslq %r12d, %r12
leaq (%r14,%r12), %rdx
subq $0x8, %rsp
leaq 0x98(%rsp), %rdi
movl 0x24(%rsp), %ecx
movl 0x34(%rsp), %r8d
movl 0x6c(%rsp), %r9d
pushq %r13
pushq 0x60(%rsp)
pushq 0x90(%rsp)
callq 0x45ea7
addq $0x20, %rsp
addl %eax, %r12d
movq %r12, 0x10(%rsp)
movslq %r12d, %rdi
addq %r14, %rdi
movq 0x68(%rsp), %rsi
leaq 0x34ed3(%rip), %rdx     # 0x7b35b
xorl %eax, %eax
callq 0x3170
movl %eax, %r14d
movq 0x48(%rsp), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x4676d
movq 0x10(%rsp), %rcx
addl %r14d, %ecx
movq %rcx, 0x10(%rsp)
movq 0x48(%rsp), %r12
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x46575
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq 0x108(%rax), %rax
movq 0x8(%rax), %rdx
movl (%rdx), %eax
addl $-0x4, %eax
cmpl $0x16, %eax
ja 0x46526
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq (%r14), %r14
jmp 0x4655e
movzbl (%r14), %r14d
jmp 0x4655e
movslq (%r14), %r14
jmp 0x4655e
movzwl (%r14), %r14d
jmp 0x4655e
movl (%r14), %r14d
jmp 0x4655e
movsbq (%r14), %r14
jmp 0x4655e
movswq (%r14), %r14
jmp 0x4655e
xorps %xmm0, %xmm0
cvtss2sd (%r14), %xmm0
movq %xmm0, %r14
jmp 0x4655e
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2fad6(%rip), %rdx     # 0x76010
xorl %eax, %eax
movq 0x40(%rsp), %rcx
callq *(%rcx)
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq 0x108(%rax), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rcx
callq 0x45be0
testq %rax, %rax
jle 0x4657e
movq (%r12), %rax
addq $0x20, %rax
movq %rax, %r12
jmp 0x46588
movq (%r12), %r12
jns 0x4659a
addq $0x18, %r12
movq (%r12), %rax
testq %rax, %rax
jne 0x464b5
jmp 0x4721e
testq %r12, %r12
je 0x4721e
movq 0x10(%r12), %rbx
movq %rbx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %r14d
testq %rbx, %rbx
je 0x467a0
addl $-0x4, %r14d
cmpl $0x16, %r14d
ja 0x4671c
leaq 0x32fdd(%rip), %rcx     # 0x795b0
movslq (%rcx,%r14,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rax
jmp 0x4663d
movzbl (%rbx), %eax
jmp 0x4663d
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rdx, %rbx
leaq 0x2fa13(%rip), %rdx     # 0x76010
xorl %eax, %eax
movq 0x40(%rsp), %rcx
callq *(%rcx)
movq 0x70(%rsp), %rsi
jmp 0x46437
movslq (%rbx), %rax
jmp 0x4663d
movl (%rbx), %eax
jmp 0x4663d
xorps %xmm0, %xmm0
cvtss2sd (%rbx), %xmm0
jmp 0x46632
movsbq (%rbx), %rax
jmp 0x4663d
movswq (%rbx), %rax
jmp 0x4663d
movsd (%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x46642
movzwl (%rbx), %eax
movq %rax, 0x8(%rsp)
movslq 0x10(%rsp), %r12
movq 0x58(%rsp), %r14
leaq (%r14,%r12), %rdx
subq $0x8, %rsp
leaq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %ecx
movl 0x34(%rsp), %r8d
movl 0x6c(%rsp), %r9d
pushq %r13
pushq 0x60(%rsp)
pushq 0x90(%rsp)
callq 0x45ea7
addq $0x20, %rsp
addl %eax, %r12d
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
leaq -0x1(%rcx), %rax
movq 0x1a0(%rsp), %rbx
cmpq %rbx, %rax
jle 0x466f4
movslq %r12d, %rdi
addq %r14, %rdi
cmpb $0x0, 0x4(%rsp)
je 0x466d0
movq 0x68(%rsp), %rsi
leaq 0x34cbc(%rip), %rdx     # 0x7b376
movl 0x8c(%rsp), %ecx
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
jmp 0x466e3
movq 0x68(%rsp), %rsi
leaq 0x2dde2(%rip), %rdx     # 0x744be
xorl %eax, %eax
callq 0x3170
addl %r12d, %eax
movq 0x48(%rsp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movl %eax, %r12d
movq 0x70(%rsp), %rsi
movq 0x80(%rsp), %rdx
movslq 0xc0(%rsi), %rax
addq %rax, %rdx
incq %rbx
cmpq %rbx, %rcx
jg 0x463ac
jmp 0x46dae
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2f8e0(%rip), %rdx     # 0x76010
xorl %eax, %eax
movq 0x40(%rsp), %rcx
callq *(%rcx)
jmp 0x46642
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2f8ae(%rip), %rdx     # 0x76000
xorl %eax, %eax
movq 0x40(%rsp), %rcx
callq *(%rcx)
movq 0x80(%rsp), %rdx
movq 0x70(%rsp), %rsi
jmp 0x463cf
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x34acd(%rip), %rdx     # 0x7b24e
xorl %eax, %eax
movq 0x40(%rsp), %rcx
callq *(%rcx)
movq 0x48(%rsp), %rax
movq (%rax), %rax
testq %rax, %rax
jne 0x464a3
jmp 0x4721e
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2f84c(%rip), %rdx     # 0x76000
xorl %eax, %eax
movq 0x40(%rsp), %rcx
callq *(%rcx)
jmp 0x465be
movq (%r15), %rbx
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x46e04
movq %rcx, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdx
movl (%rdx), %edx
addl $-0x4, %edx
cmpl $0x16, %edx
movb %r12b, 0x64(%rsp)
ja 0x47072
leaq 0x32c48(%rip), %rsi     # 0x79440
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movq (%rcx), %rcx
jmp 0x46f00
movslq %r9d, %rsi
cmpq $0x0, (%r15)
leaq 0x2bbe2(%rip), %rax     # 0x723f9
leaq 0x2bbd6(%rip), %rdx     # 0x723f4
cmoveq %rax, %rdx
jmp 0x45ed3
movslq %r9d, %rsi
movq (%r15), %rcx
leaq 0x34b32(%rip), %rdx     # 0x7b366
movq %r14, %rdi
movq %rsi, 0x10(%rsp)
xorl %eax, %eax
callq 0x3170
movl %eax, %ebx
testb %r12b, %r12b
je 0x46ebd
movq (%r15), %rax
testq %rax, %rax
je 0x46ebd
movq 0x8(%rbp), %rcx
movl (%rcx), %ecx
cmpl $0x2, %ecx
je 0x46ebd
movq %rax, 0x90(%rsp)
addl $-0x4, %ecx
cmpl $0x16, %ecx
ja 0x471fe
leaq 0x32e40(%rip), %rdx     # 0x796c4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
movq 0x10(%rsp), %r15
jmpq *%rcx
movq (%rax), %rax
jmp 0x470c3
movslq %r9d, %rsi
movq (%r15), %rcx
leaq 0x34ac2(%rip), %rdx     # 0x7b369
jmp 0x45f4d
movzbl (%r15), %ecx
cmpl $0x20, %ecx
leaq 0x34a73(%rip), %rax     # 0x7b32d
leaq 0x34a71(%rip), %rdx     # 0x7b332
cmovaeq %rax, %rdx
movslq %r9d, %rsi
movq %r14, %rdi
xorl %eax, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3170
movslq %r9d, %rsi
leaq 0x2f98d(%rip), %rdx     # 0x7627a
jmp 0x45ed3
movslq %r9d, %rsi
movq (%r15), %rcx
leaq 0x34a29(%rip), %rdx     # 0x7b328
jmp 0x45f4d
movslq %r9d, %rsi
movq (%r15), %rcx
leaq 0x34a4d(%rip), %rdx     # 0x7b35e
jmp 0x45f4d
movslq %r9d, %rsi
movq (%r15), %rcx
leaq 0x34a1b(%rip), %rdx     # 0x7b33e
jmp 0x45f4d
movl %r12d, %ebx
movslq %r9d, %rsi
leaq 0x34a3e(%rip), %rdx     # 0x7b373
movq %r14, %rdi
movq %rsi, 0x20(%rsp)
movl $0x5b, %ecx
xorl %eax, %eax
callq 0x3170
movl %eax, %r12d
cmpb $0x0, 0x4(%rsp)
je 0x46984
movslq %r12d, %rdi
addq %r14, %rdi
movq 0x30(%rsp), %rax
leal 0x4(,%rax,4), %ecx
leaq 0x34a0a(%rip), %rdx     # 0x7b376
movq 0x20(%rsp), %rsi
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
addl %r12d, %eax
movl %eax, %r12d
cmpl $0x0, 0x10(%rbp)
jle 0x46b21
movq 0x8(%rbp), %rax
movslq 0xc0(%rax), %rax
movq %rax, 0x10(%rsp)
movq (%r15), %r15
movq 0x30(%rsp), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x40(%rsp)
leal 0x4(,%rax,4), %eax
movl %eax, 0x2c(%rsp)
movzbl %bl, %eax
movq %rax, 0x38(%rsp)
movzbl 0x4(%rsp), %eax
movl %eax, 0x48(%rsp)
xorl %ebx, %ebx
movq %r15, 0x90(%rsp)
movq 0x8(%rbp), %rax
movl (%rax), %r14d
testq %r15, %r15
je 0x46b06
addl $-0x4, %r14d
cmpl $0x16, %r14d
ja 0x46aeb
leaq 0x32c70(%rip), %rcx     # 0x79668
movslq (%rcx,%r14,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r15), %rax
jmp 0x46a40
movzbl (%r15), %eax
jmp 0x46a40
movslq (%r15), %rax
jmp 0x46a40
movl (%r15), %eax
jmp 0x46a40
xorps %xmm0, %xmm0
cvtss2sd (%r15), %xmm0
jmp 0x46a31
movsbq (%r15), %rax
jmp 0x46a40
movswq (%r15), %rax
jmp 0x46a40
movsd (%r15), %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x46a48
movzwl (%r15), %eax
movq %rax, 0x90(%rsp)
movq 0x8(%rbp), %rsi
movslq %r12d, %r12
movq 0x58(%rsp), %r14
leaq (%r14,%r12), %rdx
subq $0x8, %rsp
leaq 0x98(%rsp), %rdi
movl 0x24(%rsp), %ecx
movl 0x48(%rsp), %r8d
movl 0x50(%rsp), %r9d
pushq %r13
pushq 0x60(%rsp)
pushq 0x50(%rsp)
callq 0x45ea7
addq $0x20, %rsp
addl %eax, %r12d
movl 0x10(%rbp), %ecx
leal -0x1(%rcx), %eax
cmpl %eax, %ebx
jge 0x46ada
movslq %r12d, %rdi
addq %r14, %rdi
cmpb $0x0, 0x4(%rsp)
je 0x46abe
movq 0x20(%rsp), %rsi
leaq 0x348cb(%rip), %rdx     # 0x7b376
movl 0x2c(%rsp), %ecx
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
jmp 0x46ad1
movq 0x20(%rsp), %rsi
leaq 0x2d9f4(%rip), %rdx     # 0x744be
xorl %eax, %eax
callq 0x3170
addl %r12d, %eax
movl 0x10(%rbp), %ecx
movl %eax, %r12d
addq 0x10(%rsp), %r15
incl %ebx
cmpl %ecx, %ebx
jl 0x469cb
jmp 0x46b21
movq 0x20(%r13), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2f515(%rip), %rdx     # 0x76010
xorl %eax, %eax
callq *0x8(%r13)
jmp 0x46a48
movq 0x20(%r13), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2f4ea(%rip), %rdx     # 0x76000
xorl %eax, %eax
callq *0x8(%r13)
jmp 0x469e3
movslq %r12d, %rax
jmp 0x46d6d
movslq %r9d, %rsi
movq (%r15), %rax
testq %rax, %rax
leaq 0x3063d(%rip), %rcx     # 0x77176
cmovneq %rax, %rcx
leaq 0x347ff(%rip), %rdx     # 0x7b343
jmp 0x45f4d
movq %r15, %rbx
movl %r12d, %r15d
movslq %r9d, %rsi
leaq 0x3481a(%rip), %rdx     # 0x7b373
movq %r14, %rdi
movq %rsi, 0x20(%rsp)
movl $0x5b, %ecx
xorl %eax, %eax
callq 0x3170
movl %eax, %r12d
cmpb $0x0, 0x4(%rsp)
je 0x46ba8
movslq %r12d, %rdi
addq %r14, %rdi
movq 0x30(%rsp), %rax
leal 0x4(,%rax,4), %ecx
leaq 0x347e6(%rip), %rdx     # 0x7b376
movq 0x20(%rsp), %rsi
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
addl %r12d, %eax
movl %eax, %r12d
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x46d65
movq 0x10(%rcx), %rbx
testq %rbx, %rbx
je 0x46d65
cmpq $0x0, -0x10(%rbx)
jle 0x46d65
movq 0x30(%rsp), %rax
leal 0x1(%rax), %edx
movl %edx, 0x40(%rsp)
leal 0x4(,%rax,4), %eax
movl %eax, 0x2c(%rsp)
movzbl %r15b, %eax
movq %rax, 0x38(%rsp)
movzbl 0x4(%rsp), %eax
movl %eax, 0x48(%rsp)
xorl %r14d, %r14d
movq %rcx, 0x10(%rsp)
movq %rbx, 0x90(%rsp)
movq 0x8(%rbp), %rax
movl (%rax), %r15d
testq %rbx, %rbx
je 0x46d4a
addl $-0x4, %r15d
cmpl $0x16, %r15d
ja 0x46d2f
leaq 0x329e2(%rip), %rcx     # 0x7960c
movslq (%rcx,%r15,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rax
jmp 0x46c6d
movzbl (%rbx), %eax
jmp 0x46c6d
movslq (%rbx), %rax
jmp 0x46c6d
movl (%rbx), %eax
jmp 0x46c6d
xorps %xmm0, %xmm0
cvtss2sd (%rbx), %xmm0
jmp 0x46c5f
movsbq (%rbx), %rax
jmp 0x46c6d
movswq (%rbx), %rax
jmp 0x46c6d
movsd (%rbx), %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x46c75
movzwl (%rbx), %eax
movq %rax, 0x90(%rsp)
movq 0x8(%rbp), %rsi
movslq %r12d, %r12
movq 0x58(%rsp), %r15
leaq (%r15,%r12), %rdx
subq $0x8, %rsp
leaq 0x98(%rsp), %rdi
movl 0x24(%rsp), %ecx
movl 0x48(%rsp), %r8d
movl 0x50(%rsp), %r9d
pushq %r13
pushq 0x60(%rsp)
pushq 0x50(%rsp)
callq 0x45ea7
addq $0x20, %rsp
addl %eax, %r12d
movq 0x10(%rsp), %rdx
movq 0x10(%rdx), %rax
movq -0x10(%rax), %rcx
leaq -0x1(%rcx), %rax
cmpq %r14, %rax
jle 0x46d1d
movslq %r12d, %rdi
addq %r15, %rdi
cmpb $0x0, 0x4(%rsp)
je 0x46cf7
movq 0x20(%rsp), %rsi
leaq 0x34692(%rip), %rdx     # 0x7b376
movl 0x2c(%rsp), %ecx
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
jmp 0x46d0a
movq 0x20(%rsp), %rsi
leaq 0x2d7bb(%rip), %rdx     # 0x744be
xorl %eax, %eax
callq 0x3170
addl %r12d, %eax
movq 0x10(%rsp), %rdx
movq 0x10(%rdx), %rcx
movq -0x10(%rcx), %rcx
movl %eax, %r12d
addq 0x8(%rdx), %rbx
incq %r14
cmpq %r14, %rcx
jg 0x46bfd
jmp 0x46d65
movq 0x20(%r13), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2f2d1(%rip), %rdx     # 0x76010
xorl %eax, %eax
callq *0x8(%r13)
jmp 0x46c75
movq 0x20(%r13), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2f2a6(%rip), %rdx     # 0x76000
xorl %eax, %eax
callq *0x8(%r13)
jmp 0x46c15
movslq %r12d, %rax
movq 0x58(%rsp), %r14
addq %rax, %r14
xorl %eax, %eax
cmpb $0x0, 0x4(%rsp)
je 0x46e65
movq 0x30(%rsp), %rcx
testl %ecx, %ecx
jle 0x46e4f
shll $0x2, %ecx
leaq 0x345e2(%rip), %rdx     # 0x7b376
movq %r14, %rdi
movq 0x20(%rsp), %rsi
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
jmp 0x46e65
movq 0x50(%rsp), %rdi
movq 0x198(%rsp), %rsi
callq 0x7bb0
movslq %r12d, %rax
addq %rax, %r14
xorl %eax, %eax
cmpb $0x0, 0x4(%rsp)
movq 0x30(%rsp), %rcx
je 0x46e97
testl %ecx, %ecx
jle 0x46e81
shll $0x2, %ecx
leaq 0x3458c(%rip), %rdx     # 0x7b376
movq %r14, %rdi
movq 0x68(%rsp), %rsi
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
jmp 0x46e97
movslq %r9d, %rsi
leaq 0x34646(%rip), %rdx     # 0x7b454
jmp 0x45ed3
leaq 0x3035b(%rip), %rdx     # 0x77175
movq %r14, %rdi
movq 0x10(%rsp), %rsi
xorl %eax, %eax
callq 0x3170
movslq %eax, %rbx
addq %rbx, %r14
leaq 0x3453d(%rip), %rdx     # 0x7b373
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movl $0x7d, %ecx
xorl %eax, %eax
callq 0x3170
addl %r15d, %ebx
jmp 0x46ebb
leaq 0x3031f(%rip), %rdx     # 0x77175
movq %r14, %rdi
movq 0x20(%rsp), %rsi
xorl %eax, %eax
callq 0x3170
movslq %eax, %rbx
addq %rbx, %r14
leaq 0x34501(%rip), %rdx     # 0x7b373
movq %r14, %rdi
movq 0x20(%rsp), %rsi
movl $0x5d, %ecx
jmp 0x46eb1
leaq 0x302ed(%rip), %rdx     # 0x77175
movq %r14, %rdi
movq 0x68(%rsp), %rsi
xorl %eax, %eax
callq 0x3170
movslq %eax, %rbx
addq %rbx, %r14
leaq 0x344cf(%rip), %rdx     # 0x7b373
movq %r14, %rdi
movq 0x68(%rsp), %rsi
movl $0x7d, %ecx
xorl %eax, %eax
callq 0x3170
addl %r12d, %ebx
addl %eax, %ebx
movl %ebx, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl (%rcx), %ecx
jmp 0x46f00
movslq (%rcx), %rcx
jmp 0x46f00
movl (%rcx), %ecx
jmp 0x46f00
cvtss2sd (%rcx), %xmm0
jmp 0x46ef5
movsbq (%rcx), %rcx
jmp 0x46f00
movswq (%rcx), %rcx
jmp 0x46f00
movsd (%rcx), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x46f05
movzwl (%rcx), %ecx
movq %rcx, 0x8(%rsp)
xorl %r12d, %r12d
cmpb $0x0, 0x4(%rsp)
je 0x46fad
movq %rbx, 0x10(%rsp)
movslq 0x1c(%rsp), %rbx
movq 0x8(%rax), %rdi
leaq 0x90(%rsp), %rsi
callq 0x19e8a
leaq 0x30de2(%rip), %rdx     # 0x77d17
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0x3170
movslq %eax, %rbp
movq 0x58(%rsp), %rax
leaq (%rax,%rbp), %r14
leaq 0x3441b(%rip), %rdx     # 0x7b373
movq %r14, %rdi
movq %rbx, %rsi
movl $0x28, %ecx
xorl %eax, %eax
callq 0x3170
movslq %eax, %r12
addq %r12, %r14
movq 0x30(%rsp), %r15
leal 0x4(,%r15,4), %ecx
leaq 0x343f2(%rip), %rdx     # 0x7b376
movq %r14, %rdi
movq 0x58(%rsp), %r14
movq %rbx, %rsi
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
addl %ebp, %r12d
addl %eax, %r12d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
jmp 0x46fb2
movq 0x30(%rsp), %r15
movq 0x8(%rax), %rsi
movslq %r12d, %rbx
leaq (%r14,%rbx), %rdx
leal 0x1(%r15), %r8d
subq $0x8, %rsp
movzbl 0x6c(%rsp), %eax
movl 0xc(%rsp), %ebp
movzbl %bpl, %r9d
leaq 0x10(%rsp), %rdi
movl 0x24(%rsp), %r12d
movl %r12d, %ecx
pushq %r13
pushq 0x60(%rsp)
pushq %rax
callq 0x45ea7
addq $0x20, %rsp
addl %eax, %ebx
testb %bpl, %bpl
je 0x46ebd
movslq %ebx, %rax
addq %rax, %r14
movl %r12d, %ecx
movq %r14, %r12
movslq %ecx, %r14
testl %r15d, %r15d
jle 0x47031
shll $0x2, %r15d
leaq 0x3435d(%rip), %rdx     # 0x7b376
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %ecx
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
jmp 0x47045
leaq 0x3013d(%rip), %rdx     # 0x77175
movq %r12, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3170
movslq %eax, %r15
addq %r15, %r12
leaq 0x34321(%rip), %rdx     # 0x7b373
movq %r12, %rdi
movq %r14, %rsi
movl $0x29, %ecx
xorl %eax, %eax
callq 0x3170
addl %ebx, %r15d
addl %eax, %r15d
movl %r15d, %ebx
jmp 0x46ebd
movq 0x20(%r13), %rdi
leaq 0x2ef93(%rip), %rdx     # 0x76010
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq *0x8(%r13)
movq 0x8(%rbx), %rax
jmp 0x46f05
movzbl (%rax), %eax
jmp 0x470c3
movslq (%rax), %rax
jmp 0x470c3
movl (%rax), %eax
jmp 0x470c3
cvtss2sd (%rax), %xmm0
jmp 0x470b5
movsbq (%rax), %rax
jmp 0x470c3
movswq (%rax), %rax
jmp 0x470c3
movsd (%rax), %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x470cb
movzwl (%rax), %eax
movq %rax, 0x90(%rsp)
movslq %ebx, %rdi
addq %r14, %rdi
leaq 0x34261(%rip), %rdx     # 0x7b339
movq %r15, %rsi
xorl %eax, %eax
callq 0x3170
movl %eax, %r12d
addl %ebx, %r12d
movq %r14, %rax
movslq %r12d, %r14
addq %rax, %r14
leaq 0x3427b(%rip), %rdx     # 0x7b373
movq %r14, %rdi
movq %r15, %rsi
movl $0x28, %ecx
xorl %eax, %eax
callq 0x3170
movl %eax, %ebx
cmpb $0x0, 0x4(%rsp)
je 0x47141
movslq %ebx, %rax
addq %rax, %r14
movq 0x30(%rsp), %rax
leal 0x4(,%rax,4), %ecx
leaq 0x3424a(%rip), %rdx     # 0x7b376
movq %r14, %rdi
movq %r15, %rsi
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
addl %eax, %ebx
addl %r12d, %ebx
movq 0x8(%rbp), %rsi
movslq %ebx, %rax
movq 0x58(%rsp), %rbx
leaq (%rbx,%rax), %rdx
movq 0x30(%rsp), %rbp
leal 0x1(%rbp), %r8d
subq $0x8, %rsp
movl 0xc(%rsp), %r14d
movzbl %r14b, %r9d
leaq 0x98(%rsp), %rdi
movl 0x24(%rsp), %ecx
pushq %r13
movq %rax, %r13
pushq 0x60(%rsp)
pushq $0x1
callq 0x45ea7
addq $0x20, %rsp
addl %eax, %r13d
movslq %r13d, %r12
addq %rbx, %r12
testb %r14b, %r14b
movl $0x0, %eax
je 0x471d7
testl %ebp, %ebp
jle 0x471c3
movq %rbp, %rcx
shll $0x2, %ecx
leaq 0x341c8(%rip), %rdx     # 0x7b376
movq %r12, %rdi
movq %r15, %rsi
movl $0x20, %r8d
xorl %eax, %eax
callq 0x3170
jmp 0x471d7
leaq 0x2ffab(%rip), %rdx     # 0x77175
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3170
movslq %eax, %rbx
addq %rbx, %r12
leaq 0x3418f(%rip), %rdx     # 0x7b373
movq %r12, %rdi
movq %r15, %rsi
movl $0x29, %ecx
xorl %eax, %eax
callq 0x3170
addl %r13d, %ebx
jmp 0x46ebb
movq 0x20(%r13), %rdi
leaq 0x2ee07(%rip), %rdx     # 0x76010
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq *0x8(%r13)
movq 0x10(%rsp), %r15
jmp 0x470cb
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x4f82
movq 0x20(%r13), %rdi
leaq 0x34143(%rip), %rdx     # 0x7b37b
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq *0x8(%r13)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
jmp 0x4634f