// File: /workspace/github_cpp_makefile_star2_O2/fieryzig[P]GameServer/./Common/rapidjson/include/rapidjson/reader.h
// Function: void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseNumber<0u, rapidjson::GenericStringStream<rapidjson::UTF8<char>>, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>&)
void ParseNumber(InputStream& is, Handler& handler) {
        internal::StreamLocalCopy<InputStream> copy(is);
        NumberStream<InputStream,
            ((parseFlags & kParseNumbersAsStringsFlag) != 0) ?
                ((parseFlags & kParseInsituFlag) == 0) :
                ((parseFlags & kParseFullPrecisionFlag) != 0),
            (parseFlags & kParseNumbersAsStringsFlag) != 0 &&
                (parseFlags & kParseInsituFlag) == 0> s(*this, copy.s);

        size_t startOffset = s.Tell();
        double d = 0.0;
        bool useNanOrInf = false;

        // Parse minus
        bool minus = Consume(s, '-');

        // Parse int: zero / ( digit1-9 *DIGIT )
        unsigned i = 0;
        uint64_t i64 = 0;
        bool use64bit = false;
        int significandDigit = 0;
        if (RAPIDJSON_UNLIKELY(s.Peek() == '0')) {
            i = 0;
            s.TakePush();
        }
        else if (RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9')) {
            i = static_cast<unsigned>(s.TakePush() - '0');

            if (minus)
                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                    if (RAPIDJSON_UNLIKELY(i >= 214748364)) { // 2^31 = 2147483648
                        if (RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8')) {
                            i64 = i;
                            use64bit = true;
                            break;
                        }
                    }
                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
                    significandDigit++;
                }
            else
                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                    if (RAPIDJSON_UNLIKELY(i >= 429496729)) { // 2^32 - 1 = 4294967295
                        if (RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5')) {
                            i64 = i;
                            use64bit = true;
                            break;
                        }
                    }
                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
                    significandDigit++;
                }
        }
        // Parse NaN or Infinity here
        else if ((parseFlags & kParseNanAndInfFlag) && RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N'))) {
            useNanOrInf = true;
            if (RAPIDJSON_LIKELY(Consume(s, 'N') && Consume(s, 'a') && Consume(s, 'N'))) {
                d = std::numeric_limits<double>::quiet_NaN();
            }
            else if (RAPIDJSON_LIKELY(Consume(s, 'I') && Consume(s, 'n') && Consume(s, 'f'))) {
                d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
                if (RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
                                                            && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y'))))
                    RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
            }
            else
                RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
        }
        else
            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());

        // Parse 64bit int
        bool useDouble = false;
        if (use64bit) {
            if (minus)
                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                     if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808
                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8')) {
                            d = static_cast<double>(i64);
                            useDouble = true;
                            break;
                        }
                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
                    significandDigit++;
                }
            else
                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                    if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615
                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5')) {
                            d = static_cast<double>(i64);
                            useDouble = true;
                            break;
                        }
                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
                    significandDigit++;
                }
        }

        // Force double for big integer
        if (useDouble) {
            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                if (RAPIDJSON_UNLIKELY(d >= 1.7976931348623157e307)) // DBL_MAX / 10.0
                    RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
                d = d * 10 + (s.TakePush() - '0');
            }
        }

        // Parse frac = decimal-point 1*DIGIT
        int expFrac = 0;
        size_t decimalPosition;
        if (Consume(s, '.')) {
            decimalPosition = s.Length();

            if (RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9')))
                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());

            if (!useDouble) {
#if RAPIDJSON_64BIT
                // Use i64 to store significand in 64-bit architecture
                if (!use64bit)
                    i64 = i;

                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                    if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
                        break;
                    else {
                        i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
                        --expFrac;
                        if (i64 != 0)
                            significandDigit++;
                    }
                }

                d = static_cast<double>(i64);
#else
                // Use double to store significand in 32-bit architecture
                d = static_cast<double>(use64bit ? i64 : i);
#endif
                useDouble = true;
            }

            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                if (significandDigit < 17) {
                    d = d * 10.0 + (s.TakePush() - '0');
                    --expFrac;
                    if (RAPIDJSON_LIKELY(d > 0.0))
                        significandDigit++;
                }
                else
                    s.TakePush();
            }
        }
        else
            decimalPosition = s.Length(); // decimal position at the end of integer.

        // Parse exp = e [ minus / plus ] 1*DIGIT
        int exp = 0;
        if (Consume(s, 'e') || Consume(s, 'E')) {
            if (!useDouble) {
                d = static_cast<double>(use64bit ? i64 : i);
                useDouble = true;
            }

            bool expMinus = false;
            if (Consume(s, '+'))
                ;
            else if (Consume(s, '-'))
                expMinus = true;

            if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                exp = static_cast<int>(s.Take() - '0');
                if (expMinus) {
                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
                        if (exp >= 214748364) {                         // Issue #313: prevent overflow exponent
                            while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9'))  // Consume the rest of exponent
                                s.Take();
                        }
                    }
                }
                else {  // positive exp
                    int maxExp = 308 - expFrac;
                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
                        if (RAPIDJSON_UNLIKELY(exp > maxExp))
                            RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
                    }
                }
            }
            else
                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());

            if (expMinus)
                exp = -exp;
        }

        // Finish parsing, call event according to the type of number.
        bool cont = true;

        if (parseFlags & kParseNumbersAsStringsFlag) {
            if (parseFlags & kParseInsituFlag) {
                s.Pop();  // Pop stack no matter if it will be used or not.
                typename InputStream::Ch* head = is.PutBegin();
                const size_t length = s.Tell() - startOffset;
                RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
                // unable to insert the \0 character here, it will erase the comma after this number
                const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
                cont = handler.RawNumber(str, SizeType(length), false);
            }
            else {
                SizeType numCharsToCopy = static_cast<SizeType>(s.Length());
                StringStream srcStream(s.Pop());
                StackStream<typename TargetEncoding::Ch> dstStream(stack_);
                while (numCharsToCopy--) {
                    Transcoder<UTF8<>, TargetEncoding>::Transcode(srcStream, dstStream);
                }
                dstStream.Put('\0');
                const typename TargetEncoding::Ch* str = dstStream.Pop();
                const SizeType length = static_cast<SizeType>(dstStream.Length()) - 1;
                cont = handler.RawNumber(str, SizeType(length), true);
            }
        }
        else {
           size_t length = s.Length();
           const char* decimal = s.Pop();  // Pop stack no matter if it will be used or not.

           if (useDouble) {
               int p = exp + expFrac;
               if (parseFlags & kParseFullPrecisionFlag)
                   d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
               else
                   d = internal::StrtodNormalPrecision(d, p);

               cont = handler.Double(minus ? -d : d);
           }
           else if (useNanOrInf) {
               cont = handler.Double(d);
           }
           else {
               if (use64bit) {
                   if (minus)
                       cont = handler.Int64(static_cast<int64_t>(~i64 + 1));
                   else
                       cont = handler.Uint64(i64);
               }
               else {
                   if (minus)
                       cont = handler.Int(static_cast<int32_t>(~i + 1));
                   else
                       cont = handler.Uint(i);
               }
           }
        }
        if (RAPIDJSON_UNLIKELY(!cont))
            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, -0x38(%rbp)
movq (%rsi), %r13
movb (%r13), %r14b
movl %r14d, %eax
movq %r13, %rdi
cmpb $0x2d, %r14b
jne 0x3f75
leaq 0x1(%r13), %rdi
movb 0x1(%r13), %al
movq 0x8(%rbx), %rcx
movq %rcx, -0x30(%rbp)
cmpb $0x30, %al
movq %rdx, -0x40(%rbp)
movq %rbx, -0x48(%rbp)
je 0x4297
leal -0x31(%rax), %ecx
cmpb $0x8, %cl
ja 0x4260
incq %rdi
movzbl %al, %esi
addl $-0x30, %esi
xorl %ecx, %ecx
cmpb $0x2d, %r14b
jne 0x3fe6
movb (%rdi,%rcx), %bl
leal -0x30(%rbx), %eax
cmpb $0x9, %al
ja 0x407a
cmpl $0xccccccc, %esi        # imm = 0xCCCCCCC
jae 0x3fd0
movzbl %bl, %eax
imull $0xa, %esi, %esi
addl %eax, %esi
addl $-0x30, %esi
incq %rcx
jmp 0x3faa
jne 0x3fde
cmpb $0x38, %bl
jbe 0x3fc0
movl $0xccccccc, %esi        # imm = 0xCCCCCCC
movb $0x39, %bl
addq %rcx, %rdi
movq %rdi, %r15
jmp 0x4024
movb (%rdi,%rcx), %bl
leal -0x30(%rbx), %eax
cmpb $0x9, %al
ja 0x407a
cmpl $0x19999999, %esi       # imm = 0x19999999
jae 0x400c
movzbl %bl, %eax
imull $0xa, %esi, %esi
addl %eax, %esi
addl $-0x30, %esi
incq %rcx
jmp 0x3fe6
jne 0x4259
movl $0x19999999, %eax       # imm = 0x19999999
cmpb $0x35, %bl
jbe 0x3ffc
addq %rcx, %rdi
movq %rdi, %r15
movl %eax, %esi
movl %esi, %eax
cmpb $0x2d, %r14b
jne 0x4093
movabsq $0xccccccccccccccb, %rdi # imm = 0xCCCCCCCCCCCCCCB
leaq 0x1(%rdi), %r8
leal -0x30(%rbx), %r9d
cmpb $0x9, %r9b
ja 0x413e
cmpq %rdi, %rax
ja 0x4065
imulq $0xa, %rax, %r9
andb $0xf, %bl
movzbl %bl, %eax
addq %r9, %rax
incl %ecx
movb 0x1(%r15), %bl
incq %r15
jmp 0x403a
cmpq %r8, %rax
setne %r9b
cmpb $0x39, %bl
setae %r10b
orb %r9b, %r10b
jne 0x40df
jmp 0x404d
addq %rcx, %rdi
xorps %xmm0, %xmm0
xorl %r12d, %r12d
xorl %r9d, %r9d
xorl %eax, %eax
xorl %r8d, %r8d
movq %rdi, %r15
jmp 0x4155
movabsq $0x1999999999999998, %rdi # imm = 0x1999999999999998
leaq 0x1(%rdi), %r8
leal -0x30(%rbx), %r9d
cmpb $0x9, %r9b
ja 0x413e
cmpq %rdi, %rax
ja 0x40cc
imulq $0xa, %rax, %r9
andb $0xf, %bl
movzbl %bl, %eax
addq %r9, %rax
incl %ecx
movb 0x1(%r15), %bl
incq %r15
jmp 0x40a1
cmpq %r8, %rax
setne %r9b
cmpb $0x36, %bl
setae %r10b
orb %r9b, %r10b
je 0x40b4
movq %rax, %xmm1
punpckldq 0x2f24(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2f2c(%rip), %xmm1     # 0x7020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x2f38(%rip), %xmm1     # 0x7040
movsd 0x2f38(%rip), %xmm2     # 0x7048
leal -0x30(%rbx), %edi
cmpb $0x9, %dil
ja 0x414c
ucomisd %xmm1, %xmm0
jae 0x4234
movzbl %bl, %edx
addl $-0x30, %edx
cvtsi2sd %edx, %xmm3
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
movb 0x1(%r15), %bl
incq %r15
jmp 0x4110
xorps %xmm0, %xmm0
movb $0x1, %r8b
xorl %r12d, %r12d
xorl %r9d, %r9d
jmp 0x4155
movb $0x1, %r12b
movb $0x1, %r9b
movb $0x1, %r8b
xorl %edi, %edi
movl %esi, %r11d
cmpb $0x2e, %bl
jne 0x42b5
movb 0x1(%r15), %bl
incq %r15
leal -0x3a(%rbx), %r10d
cmpb $-0xb, %r10b
jbe 0x427d
xorl %r10d, %r10d
testb %r12b, %r12b
jne 0x41e4
testb %r8b, %r8b
cmoveq %r11, %rax
xorl %r10d, %r10d
cmpb $0x30, %bl
jl 0x41c0
cmpb $0x39, %bl
ja 0x41c0
movq %rax, %r9
shrq $0x35, %r9
jne 0x41c0
imulq $0xa, %rax, %r9
movzbl %bl, %eax
movb 0x1(%r15), %bl
incq %r15
addl $-0x30, %eax
decl %r10d
xorl %r12d, %r12d
addq %r9, %rax
setne %r12b
addl %r12d, %ecx
jmp 0x418a
movq %rax, %xmm1
punpckldq 0x2e43(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2e4b(%rip), %xmm1     # 0x7020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movb $0x1, %r9b
movsd 0x2e5c(%rip), %xmm1     # 0x7048
xorpd %xmm2, %xmm2
cmpb $0x30, %bl
jl 0x4229
cmpb $0x39, %bl
ja 0x42b8
cmpl $0x10, %ecx
jg 0x4220
movzbl %bl, %edx
addl $-0x30, %edx
cvtsi2sd %edx, %xmm3
mulsd %xmm1, %xmm0
addsd %xmm3, %xmm0
decl %r10d
ucomisd %xmm2, %xmm0
jbe 0x4220
incl %ecx
movb 0x1(%r15), %bl
incq %r15
jmp 0x41f0
xorl %edi, %edi
movq -0x48(%rbp), %rbx
jmp 0x43cb
movq -0x38(%rbp), %rcx
cmpl $0x0, 0x30(%rcx)
jne 0x44be
movl $0xd, 0x30(%rcx)
movq %r13, %rdi
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rbx
jmp 0x43b3
movl %esi, %eax
jmp 0x401c
movq -0x38(%rbp), %rcx
cmpl $0x0, 0x30(%rcx)
jne 0x44dd
movl $0x3, 0x30(%rcx)
movq %rdi, %r15
jmp 0x43af
movq -0x38(%rbp), %rcx
cmpl $0x0, 0x30(%rcx)
jne 0x44fc
movl $0xe, 0x30(%rcx)
movq %r15, %rdi
jmp 0x424c
movb 0x1(%rdi), %bl
incq %rdi
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
xorl %r9d, %r9d
xorl %ecx, %ecx
xorl %eax, %eax
xorl %r8d, %r8d
xorl %esi, %esi
jmp 0x408b
xorl %r10d, %r10d
movzbl %bl, %ecx
orl $0x20, %ecx
cmpl $0x65, %ecx
jne 0x422b
testb %r8b, %r8b
cmovneq %rax, %r11
movzbl %r9b, %ecx
pushq $0x1
popq %r9
testb %cl, %cl
cmovnel %ecx, %r9d
movq -0x48(%rbp), %rbx
jne 0x4303
movq %r11, %xmm1
punpckldq 0x2d21(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2d29(%rip), %xmm1     # 0x7020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movb 0x1(%r15), %dl
cmpb $0x2b, %dl
setne %cl
jne 0x448c
movb 0x2(%r15), %dl
addq $0x2, %r15
leal -0x30(%rdx), %edi
cmpb $0x9, %dil
ja 0x4455
incq %r15
movzbl %dl, %edx
addl $-0x30, %edx
testb %cl, %cl
je 0x4371
movq %r15, %rdi
movzbl (%r15), %r11d
leal -0x30(%r11), %r15d
cmpb $0x9, %r15b
ja 0x43bf
imull $0xa, %edx, %edx
leaq 0x1(%rdi), %r15
addl %r11d, %edx
addl $-0x30, %edx
cmpl $0xccccccc, %edx        # imm = 0xCCCCCCC
jl 0x4335
movb 0x1(%rdi), %r11b
incq %rdi
addb $-0x30, %r11b
cmpb $0xa, %r11b
jb 0x435b
movq %rdi, %r15
jmp 0x4335
movl $0x134, %edi            # imm = 0x134
subl %r10d, %edi
movzbl (%r15), %r11d
leal -0x30(%r11), %r12d
cmpb $0x9, %r12b
ja 0x43c2
imull $0xa, %edx, %edx
incq %r15
addl %r11d, %edx
addl $-0x30, %edx
cmpl %edi, %edx
jle 0x4379
movq -0x38(%rbp), %rcx
cmpl $0x0, 0x30(%rcx)
jne 0x449f
movl $0xd, 0x30(%rcx)
movq %r13, %rdi
movq -0x30(%rbp), %rax
subq %rax, %rdi
movq %rdi, 0x38(%rcx)
jmp 0x443f
movq %rdi, %r15
movl %edx, %edi
negl %edi
testb %cl, %cl
cmovel %edx, %edi
testb %r9b, %r9b
je 0x43f1
addl %r10d, %edi
callq 0x50e7
cmpb $0x2d, %r14b
jne 0x43e6
xorpd 0x2c4a(%rip), %xmm0     # 0x7030
movq -0x40(%rbp), %rdi
callq 0x5108
jmp 0x4437
testb %r8b, %r8b
je 0x440d
cmpb $0x2d, %r14b
jne 0x4420
negq %rax
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x5140
jmp 0x4437
cmpb $0x2d, %r14b
jne 0x442e
negl %esi
movq -0x40(%rbp), %rdi
callq 0x5194
jmp 0x4437
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x516a
jmp 0x4437
movq -0x40(%rbp), %rdi
callq 0x51d0
testb %al, %al
je 0x4472
movq -0x30(%rbp), %rax
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x38(%rbp), %rcx
cmpl $0x0, 0x30(%rcx)
jne 0x451b
movl $0xf, 0x30(%rcx)
movq %r15, %rdi
jmp 0x43af
movq -0x38(%rbp), %rcx
cmpl $0x0, 0x30(%rcx)
jne 0x453a
movl $0x10, 0x30(%rcx)
jmp 0x43ac
cmpb $0x2d, %dl
je 0x4313
incq %r15
xorl %ecx, %ecx
jmp 0x431b
leaq 0x2ef7(%rip), %rdi      # 0x739d
leaq 0x2f01(%rip), %rsi      # 0x73ae
leaq 0x4077(%rip), %rcx      # 0x852b
movl $0x517, %edx            # imm = 0x517
callq 0x2190
leaq 0x2ed8(%rip), %rdi      # 0x739d
leaq 0x2ee2(%rip), %rsi      # 0x73ae
leaq 0x4058(%rip), %rcx      # 0x852b
movl $0x4c4, %edx            # imm = 0x4C4
callq 0x2190
leaq 0x2eb9(%rip), %rdi      # 0x739d
leaq 0x2ec3(%rip), %rsi      # 0x73ae
leaq 0x4039(%rip), %rcx      # 0x852b
movl $0x4a3, %edx            # imm = 0x4A3
callq 0x2190
leaq 0x2e9a(%rip), %rdi      # 0x739d
leaq 0x2ea4(%rip), %rsi      # 0x73ae
leaq 0x401a(%rip), %rcx      # 0x852b
movl $0x4d0, %edx            # imm = 0x4D0
callq 0x2190
leaq 0x2e7b(%rip), %rdi      # 0x739d
leaq 0x2e85(%rip), %rsi      # 0x73ae
leaq 0x3ffb(%rip), %rcx      # 0x852b
movl $0x51c, %edx            # imm = 0x51C
callq 0x2190
leaq 0x2e5c(%rip), %rdi      # 0x739d
leaq 0x2e66(%rip), %rsi      # 0x73ae
leaq 0x3fdc(%rip), %rcx      # 0x852b
movl $0x55c, %edx            # imm = 0x55C
callq 0x2190
jmp 0x455b
movq %r15, (%rbx)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, %rdi
callq 0x2340