// File: mshabbirhasan[P]ups-indel/include/seqan/bam_io/bam_sam_conversion.h
// Function: void seqan::_assignTagsSamToBamOneTag<seqan::String<char, seqan::Alloc<void>>, seqan::RecordReader<seqan::Stream<seqan::CharArray<char const*>>, seqan::SinglePass<void>>>(seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::Stream<seqan::CharArray<char const*>>, seqan::SinglePass<void>>&, seqan::String<char, seqan::Alloc<void>>&)
void _assignTagsSamToBamOneTag(TTarget & target, TRecordReader & reader, CharString & buffer)
{
    SEQAN_ASSERT_NOT(atEnd(reader));
    int res = readNChars(target, reader, 2);  // Read tag name.
    (void)res;  // If run without assertions.
    SEQAN_ASSERT_EQ(res, 0);
    SEQAN_ASSERT_NOT(atEnd(reader));

    clear(buffer);
    res = readNChars(buffer, reader, 3);  // Read ':<type>:'.
    SEQAN_ASSERT_EQ(res, 0);
    SEQAN_ASSERT_EQ(buffer[0], ':');
    SEQAN_ASSERT_EQ(buffer[2], ':');
    char t = buffer[1];
    appendValue(target, t);

    SEQAN_ASSERT_NOT(atEnd(reader));

    switch (t)
    {
    case 'A':
        clear(buffer);
        res = readNChars(target, reader, 1);
        SEQAN_ASSERT_EQ(res, 0);
        break;
    case 'i':
        {
            clear(buffer);
            res = readUntilTabOrLineBreak(buffer, reader);
            SEQAN_ASSERT(res == 0 || res == EOF_BEFORE_SUCCESS);
            __int32 x = 0;
            bool b = lexicalCast2<__int32>(x, buffer);
            (void)b;
            SEQAN_ASSERT(b);
            char const * ptr = reinterpret_cast<char const *>(&x);
            for (int i = 0; i < 4; ++i, ++ptr)
                appendValue(target, *ptr);
        }
        break;
    case 'f':
        {
            clear(buffer);
            res = readUntilTabOrLineBreak(buffer, reader);
            SEQAN_ASSERT(res == 0 || res == EOF_BEFORE_SUCCESS);
            float x = 0;
            bool b = lexicalCast2<float>(x, buffer);
            (void)b;
            SEQAN_ASSERT(b);
            char const * ptr = reinterpret_cast<char const *>(&x);
            for (int i = 0; i < 4; ++i, ++ptr)
                appendValue(target, *ptr);
        }
        break;
    case 'H':
    case 'Z':
        {
            // TODO(holtgrew): Could test on even length in case of 'H'.
            res = readUntilTabOrLineBreak(target, reader);
            SEQAN_ASSERT(res == 0 || res == EOF_BEFORE_SUCCESS);
            appendValue(target, '\0');
        }
        break;
    case 'B':
        {
            CharString buffer2; // TODO(holtgrew): Also give from outside.

            // Read type.
            clear(buffer);
            res = readNChars(buffer, reader, 1);
            SEQAN_ASSERT_EQ(res, 0);
            char t2 = back(buffer);
            appendValue(target, t2);

            // Read array contents.
            clear(buffer);
            res = readUntilTabOrLineBreak(buffer, reader);
            SEQAN_ASSERT(res == 0 || res == EOF_BEFORE_SUCCESS);
            typename Iterator<CharString, Rooted>::Type it, it2;
            // Search first non-comma position.
            it = begin(buffer, Rooted());
            for (;!atEnd(it) && *it == ','; ++it)
                continue;
            // Count number of entries.
            __int32 nEntries = !atEnd(it);  // At least one if array not empty.
            for (it2 = it; !atEnd(it2); ++it2)
                nEntries += (*it2 == ',');
            // Write out array length to result.
            char const * ptr = reinterpret_cast<char const *>(&nEntries);
            for (int i = 0; i < 4; ++i, ++ptr)
                appendValue(target, *ptr);

            // Now, write out the arrays, depending on the entry type.
            // TODO(holtgrew): Whee, this could be a bit more compact...
            switch (t2)
            {
            case 'c':
                for (int i = 0; i < nEntries; ++i)
                {
                    SEQAN_ASSERT_NOT(atEnd(it));
                    clear(buffer2);
                    for (; !atEnd(it) && *it != ',' && *it != '\t'; goNext(it))
                        appendValue(buffer2, *it);
                    __int16 x = 0;  // short to avoid textual interpretation in lexicalCast<> below.
                    bool b = lexicalCast2<__int16>(x, buffer2);
                    (void)b;
                    SEQAN_ASSERT(b);
                    appendValue(target, static_cast<__int8>(x));
                    if (!atEnd(it) && *it == ',')
                        goNext(it);  // Skip ','.
                    else
                        break;  // End of field or end of string.
                }
                break;
            case 'C':
                for (int i = 0; i < nEntries; ++i)
                {
                    SEQAN_ASSERT_NOT(atEnd(it));
                    clear(buffer2);
                    for (; !atEnd(it) && *it != ',' && *it != '\t'; goNext(it))
                        appendValue(buffer2, *it);
                    __uint16 x = 0;  // short to avoid textual interpretation in lexicalCast<> below.
                    bool b = lexicalCast2<__uint16>(x, buffer2);
                    (void)b;
                    SEQAN_ASSERT(b);
                    appendValue(target, static_cast<__int8>(x));
                    if (!atEnd(it) && *it == ',')
                        goNext(it);  // Skip ','.
                    else
                        break;  // End of field or end of string.
                }
                break;
            case 's':
                for (int i = 0; i < nEntries; ++i)
                {
                    SEQAN_ASSERT_NOT(atEnd(it));
                    clear(buffer2);
                    for (; !atEnd(it) && *it != ',' && *it != '\t'; goNext(it))
                        appendValue(buffer2, *it);
                    __int16 x = 0;
                    bool b = lexicalCast2<__int16>(x, buffer2);
                    (void)b;
                    SEQAN_ASSERT(b);
                    char const * ptr = reinterpret_cast<char const *>(&x);  // write out byte-wise
                    for (int i = 0; i < 2; ++i, ++ptr)
                        appendValue(target, *ptr);
                    if (!atEnd(it) && *it == ',')
                        goNext(it);  // Skip ','.
                    else
                        break;  // End of field or end of string.
                }
                break;
            case 'S':
                for (int i = 0; i < nEntries; ++i)
                {
                    SEQAN_ASSERT_NOT(atEnd(it));
                    clear(buffer2);
                    for (; !atEnd(it) && *it != ',' && *it != '\t'; goNext(it))
                        appendValue(buffer2, *it);
                    __uint16 x = 0;
                    bool b = lexicalCast2<__uint16>(x, buffer2);
                    (void)b;
                    SEQAN_ASSERT(b);
                    char const * ptr = reinterpret_cast<char const *>(&x);  // write out byte-wise
                    for (int i = 0; i < 2; ++i, ++ptr)
                        appendValue(target, *ptr);
                    if (!atEnd(it) && *it == ',')
                        goNext(it);  // Skip ','.
                    else
                        break;  // End of field or end of string.
                }
                break;
            case 'i':
                for (int i = 0; i < nEntries; ++i)
                {
                    SEQAN_ASSERT_NOT(atEnd(it));
                    clear(buffer2);
                    for (; !atEnd(it) && *it != ',' && *it != '\t'; goNext(it))
                        appendValue(buffer2, *it);
                    __int32 x = 0;
                    bool b = lexicalCast2<__int32>(x, buffer2);
                    (void)b;
                    SEQAN_ASSERT(b);
                    char const * ptr = reinterpret_cast<char const *>(&x);  // write out byte-wise
                    for (int i = 0; i < 4; ++i, ++ptr)
                        appendValue(target, *ptr);
                    if (!atEnd(it) && *it == ',')
                        goNext(it);  // Skip ','.
                    else
                        break;  // End of field or end of string.
                }
                break;
            case 'I':
                for (int i = 0; i < nEntries; ++i)
                {
                    SEQAN_ASSERT_NOT(atEnd(it));
                    clear(buffer2);
                    for (; !atEnd(it) && *it != ',' && *it != '\t'; goNext(it))
                        appendValue(buffer2, *it);
                    __uint32 x = 0;
                    bool b = lexicalCast2<__uint32>(x, buffer2);
                    (void)b;
                    SEQAN_ASSERT(b);
                    char const * ptr = reinterpret_cast<char const *>(&x);  // write out byte-wise
                    for (int i = 0; i < 4; ++i, ++ptr)
                        appendValue(target, *ptr);
                    if (!atEnd(it) && *it == ',')
                        goNext(it);  // Skip ','.
                    else
                        break;  // End of field or end of string.
                }
                break;
            case 'f':
                for (int i = 0; i < nEntries; ++i)
                {
                    SEQAN_ASSERT_NOT(atEnd(it));
                    clear(buffer2);
                    for (; !atEnd(it) && *it != ',' && *it != '\t'; goNext(it))
                        appendValue(buffer2, *it);
                    float x = 0;
                    bool b = lexicalCast2<float>(x, buffer2);
                    (void)b;
                    SEQAN_ASSERT(b);
                    char const * ptr = reinterpret_cast<char const *>(&x);  // write out byte-wise
                    for (int i = 0; i < 4; ++i, ++ptr)
                        appendValue(target, *ptr);
                    if (!atEnd(it) && *it == ',')
                        goNext(it);  // Skip ','.
                    else
                        break;  // End of field or end of string.
                }
                break;
            default:
                SEQAN_FAIL("Invalid array type: %c!", t2);
            }
        }
        break;
    default:
        SEQAN_ASSERT_FAIL("Invalid tag type: %c!", t);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp            # imm = 0x320
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1eb60
andb $0x1, %al
movb %al, -0x19(%rbp)
leaq 0x9d74(%rip), %rdi      # 0x28aa0
movl $0x41, %esi
leaq -0x19(%rbp), %rdx
leaq 0x9d8e(%rip), %rcx      # 0x28aca
callq 0x1ecc0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ed49
jmp 0x1ed4e
callq 0xb2a0
jmp 0x1ed50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x20b30
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0x9d2d(%rip), %rdi      # 0x28aa0
movl $0x44, %esi
leaq -0x20(%rbp), %rdx
leaq 0x9d6f(%rip), %rcx      # 0x28af2
leaq -0x24(%rbp), %r8
leaq 0x9ce6(%rip), %r9       # 0x28a74
callq 0x12050
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ed9b
jmp 0x1eda0
callq 0xb2a0
jmp 0x1eda2
jmp 0x1eda4
movq -0x10(%rbp), %rdi
callq 0x1eb60
andb $0x1, %al
movb %al, -0x25(%rbp)
leaq 0x9ce7(%rip), %rdi      # 0x28aa0
movl $0x45, %esi
leaq -0x25(%rbp), %rdx
leaq 0x9d01(%rip), %rcx      # 0x28aca
callq 0x1ecc0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1edd6
jmp 0x1eddb
callq 0xb2a0
jmp 0x1eddd
movq -0x18(%rbp), %rdi
callq 0x13670
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3, %edx
callq 0x20b30
movl %eax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
leaq 0x9c97(%rip), %rdi      # 0x28aa0
movl $0x49, %esi
leaq -0x20(%rbp), %rdx
leaq 0x9cd9(%rip), %rcx      # 0x28af2
leaq -0x2c(%rbp), %r8
leaq 0x9c50(%rip), %r9       # 0x28a74
callq 0x12050
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ee31
jmp 0x1ee36
callq 0xb2a0
jmp 0x1ee38
jmp 0x1ee3a
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x20c30
movq %rax, %rdx
movb $0x3a, -0x2d(%rbp)
leaq 0x9c4d(%rip), %rdi      # 0x28aa0
movl $0x4a, %esi
leaq 0x9c97(%rip), %rcx      # 0x28af6
leaq -0x2d(%rbp), %r8
leaq 0x9c96(%rip), %r9       # 0x28b00
callq 0x20be0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ee77
jmp 0x1ee7c
callq 0xb2a0
jmp 0x1ee7e
jmp 0x1ee80
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x20c30
movq %rax, %rdx
movb $0x3a, -0x2e(%rbp)
leaq 0x9c04(%rip), %rdi      # 0x28aa0
movl $0x4b, %esi
leaq 0x9c5c(%rip), %rcx      # 0x28b04
leaq -0x2e(%rbp), %r8
leaq 0x9c4d(%rip), %r9       # 0x28b00
callq 0x20be0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1eec0
jmp 0x1eec5
callq 0xb2a0
jmp 0x1eec7
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x20c30
movb (%rax), %al
movb %al, -0x2f(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2f(%rbp), %rsi
callq 0x176a0
movq -0x10(%rbp), %rdi
callq 0x1eb60
andb $0x1, %al
movb %al, -0x30(%rbp)
leaq 0x9ba4(%rip), %rdi      # 0x28aa0
movl $0x4f, %esi
leaq -0x30(%rbp), %rdx
leaq 0x9bbe(%rip), %rcx      # 0x28aca
callq 0x1ecc0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ef19
jmp 0x1ef1e
callq 0xb2a0
jmp 0x1ef20
movsbl -0x2f(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x190(%rbp)
subl $0x28, %eax
ja 0x20714
movq -0x190(%rbp), %rax
leaq 0x90bd(%rip), %rcx      # 0x28004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0x13670
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x20b30
movl %eax, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
leaq 0x9b24(%rip), %rdi      # 0x28aa0
movl $0x56, %esi
leaq -0x20(%rbp), %rdx
leaq 0x9b66(%rip), %rcx      # 0x28af2
leaq -0x34(%rbp), %r8
leaq 0x9add(%rip), %r9       # 0x28a74
callq 0x12050
xorb $-0x1, %al
testb $0x1, %al
jne 0x1efa4
jmp 0x1efa9
callq 0xb2a0
jmp 0x1efab
jmp 0x2073b
movq -0x18(%rbp), %rdi
callq 0x13670
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20c60
movl %eax, -0x20(%rbp)
movb $0x1, %al
cmpl $0x0, -0x20(%rbp)
movb %al, -0x191(%rbp)
je 0x1efe7
cmpl $0x400, -0x20(%rbp)     # imm = 0x400
sete %al
movb %al, -0x191(%rbp)
movb -0x191(%rbp), %al
andb $0x1, %al
movb %al, -0x35(%rbp)
leaq 0x9aa7(%rip), %rdi      # 0x28aa0
movl $0x5c, %esi
leaq -0x35(%rbp), %rdx
leaq 0x9b05(%rip), %rcx      # 0x28b0e
callq 0x11cb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1f016
jmp 0x1f01b
callq 0xb2a0
jmp 0x1f01d
movl $0x0, -0x3c(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x3c(%rbp), %rdi
callq 0x1e990
andb $0x1, %al
movb %al, -0x3d(%rbp)
leaq 0x9a63(%rip), %rdi      # 0x28aa0
movl $0x60, %esi
leaq -0x3d(%rbp), %rdx
leaq 0x9a51(%rip), %rcx      # 0x28a9e
callq 0x11cb0
testb $0x1, %al
jne 0x1f05b
callq 0xb2a0
jmp 0x1f05d
leaq -0x3c(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
cmpl $0x4, -0x4c(%rbp)
jge 0x1f096
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x176a0
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x1f06c
jmp 0x2073b
movq -0x18(%rbp), %rdi
callq 0x13670
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20c60
movl %eax, -0x20(%rbp)
movb $0x1, %al
cmpl $0x0, -0x20(%rbp)
movb %al, -0x192(%rbp)
je 0x1f0d2
cmpl $0x400, -0x20(%rbp)     # imm = 0x400
sete %al
movb %al, -0x192(%rbp)
movb -0x192(%rbp), %al
andb $0x1, %al
movb %al, -0x4d(%rbp)
leaq 0x99bc(%rip), %rdi      # 0x28aa0
movl $0x6a, %esi
leaq -0x4d(%rbp), %rdx
leaq 0x9a1a(%rip), %rcx      # 0x28b0e
callq 0x11cb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1f101
jmp 0x1f106
callq 0xb2a0
jmp 0x1f108
xorps %xmm0, %xmm0
movss %xmm0, -0x54(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x54(%rbp), %rdi
callq 0x20c90
andb $0x1, %al
movb %al, -0x55(%rbp)
leaq 0x9977(%rip), %rdi      # 0x28aa0
movl $0x6e, %esi
leaq -0x55(%rbp), %rdx
leaq 0x9965(%rip), %rcx      # 0x28a9e
callq 0x11cb0
testb $0x1, %al
jne 0x1f147
callq 0xb2a0
jmp 0x1f149
leaq -0x54(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
cmpl $0x4, -0x64(%rbp)
jge 0x1f182
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x176a0
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x1f158
jmp 0x2073b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20c60
movl %eax, -0x20(%rbp)
movb $0x1, %al
cmpl $0x0, -0x20(%rbp)
movb %al, -0x193(%rbp)
je 0x1f1b5
cmpl $0x400, -0x20(%rbp)     # imm = 0x400
sete %al
movb %al, -0x193(%rbp)
movb -0x193(%rbp), %al
andb $0x1, %al
movb %al, -0x65(%rbp)
leaq 0x98d9(%rip), %rdi      # 0x28aa0
movl $0x79, %esi
leaq -0x65(%rbp), %rdx
leaq 0x9937(%rip), %rcx      # 0x28b0e
callq 0x11cb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1f1e4
jmp 0x1f1e9
callq 0xb2a0
jmp 0x1f1eb
movq -0x8(%rbp), %rdi
movb $0x0, -0x66(%rbp)
leaq -0x66(%rbp), %rsi
callq 0x176a0
jmp 0x2073b
leaq -0x80(%rbp), %rdi
callq 0xb3a0
movq -0x18(%rbp), %rdi
callq 0x13670
jmp 0x1f215
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x20b30
movl %eax, -0x198(%rbp)
jmp 0x1f22f
movl -0x198(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x90(%rbp)
leaq 0x9857(%rip), %rdi      # 0x28aa0
leaq 0x98a2(%rip), %rcx      # 0x28af2
leaq 0x981d(%rip), %r9       # 0x28a74
movl $0x84, %esi
leaq -0x20(%rbp), %rdx
leaq -0x90(%rbp), %r8
callq 0x12050
movb %al, -0x199(%rbp)
jmp 0x1f274
movb -0x199(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1f282
jmp 0x1f2ab
callq 0xb2a0
jmp 0x1f289
jmp 0x1f2ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xb7b0
jmp 0x20744
jmp 0x1f2ad
jmp 0x1f2af
movq -0x18(%rbp), %rdi
callq 0x20d80
movq %rax, -0x1a8(%rbp)
jmp 0x1f2c1
movq -0x1a8(%rbp), %rax
movb (%rax), %al
movb %al, -0x91(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x91(%rbp), %rsi
callq 0x176a0
jmp 0x1f2e2
movq -0x18(%rbp), %rdi
callq 0x13670
jmp 0x1f2ed
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20c60
movl %eax, -0x1ac(%rbp)
jmp 0x1f302
movl -0x1ac(%rbp), %eax
movl %eax, -0x20(%rbp)
movb $0x1, %al
cmpl $0x0, -0x20(%rbp)
movb %al, -0x1ad(%rbp)
je 0x1f329
cmpl $0x400, -0x20(%rbp)     # imm = 0x400
sete %al
movb %al, -0x1ad(%rbp)
movb -0x1ad(%rbp), %al
andb $0x1, %al
movb %al, -0x92(%rbp)
leaq 0x9762(%rip), %rdi      # 0x28aa0
leaq 0x97c9(%rip), %rcx      # 0x28b0e
movl $0x8b, %esi
leaq -0x92(%rbp), %rdx
callq 0x11cb0
movb %al, -0x1ae(%rbp)
jmp 0x1f35e
movb -0x1ae(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1f36c
jmp 0x1f375
callq 0xb2a0
jmp 0x1f373
jmp 0x1f375
jmp 0x1f377
jmp 0x1f379
leaq -0xa8(%rbp), %rdi
callq 0x20dc0
jmp 0x1f387
leaq -0xb8(%rbp), %rdi
callq 0x20dc0
jmp 0x1f395
movq -0x18(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x11280
jmp 0x1f3a7
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x20de0
jmp 0x1f3bc
jmp 0x1f3be
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x1af(%rbp)
jmp 0x1f3d2
movb -0x1af(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1b0(%rbp)
jne 0x1f412
jmp 0x1f3e7
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x1b8(%rbp)
jmp 0x1f3fc
movq -0x1b8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
sete %al
movb %al, -0x1b0(%rbp)
movb -0x1b0(%rbp), %al
testb $0x1, %al
jne 0x1f41e
jmp 0x1f430
jmp 0x1f420
leaq -0xa8(%rbp), %rdi
callq 0x20e70
jmp 0x1f42e
jmp 0x1f3be
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x1b9(%rbp)
jmp 0x1f444
movb -0x1b9(%rbp), %al
notb %al
movzbl %al, %eax
andl $0x1, %eax
movl %eax, -0xd0(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x20de0
jmp 0x1f46d
jmp 0x1f46f
leaq -0xb8(%rbp), %rdi
callq 0x20e10
movb %al, -0x1ba(%rbp)
jmp 0x1f483
movb -0x1ba(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1f491
jmp 0x1f4d7
leaq -0xb8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x1c8(%rbp)
jmp 0x1f4a6
movq -0x1c8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addl -0xd0(%rbp), %eax
movl %eax, -0xd0(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x20e70
jmp 0x1f4d5
jmp 0x1f46f
leaq -0xd0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl $0x0, -0xdc(%rbp)
cmpl $0x4, -0xdc(%rbp)
jge 0x1f52f
movq -0x8(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0x176a0
jmp 0x1f50a
jmp 0x1f50c
movl -0xdc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xdc(%rbp)
movq -0xd8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
jmp 0x1f4ef
movsbl -0x91(%rbp), %eax
addl $-0x43, %eax
movl %eax, %ecx
movq %rcx, -0x1d0(%rbp)
subl $0x30, %eax
ja 0x206d7
movq -0x1d0(%rbp), %rax
leaq 0x8b4f(%rip), %rcx      # 0x280a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0xe0(%rbp)
movl -0xe0(%rbp), %eax
cmpl -0xd0(%rbp), %eax
jge 0x1f7b2
jmp 0x1f580
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x1d1(%rbp)
jmp 0x1f594
movb -0x1d1(%rbp), %al
andb $0x1, %al
movb %al, -0xe1(%rbp)
leaq 0x94f7(%rip), %rdi      # 0x28aa0
leaq 0x9584(%rip), %rcx      # 0x28b34
movl $0xa1, %esi
leaq -0xe1(%rbp), %rdx
callq 0x1ecc0
movb %al, -0x1d2(%rbp)
jmp 0x1f5c9
movb -0x1d2(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1f5d7
jmp 0x1f5e0
callq 0xb2a0
jmp 0x1f5de
jmp 0x1f5e0
jmp 0x1f5e2
jmp 0x1f5e4
leaq -0x80(%rbp), %rdi
callq 0x13670
jmp 0x1f5ef
jmp 0x1f5f1
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x1d3(%rbp)
jmp 0x1f605
movb -0x1d3(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1d4(%rbp)
jne 0x1f671
jmp 0x1f61a
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x1e0(%rbp)
jmp 0x1f62f
movq -0x1e0(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2c, %ecx
movb %al, -0x1d4(%rbp)
je 0x1f671
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x1e8(%rbp)
jmp 0x1f65b
movq -0x1e8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
setne %al
movb %al, -0x1d4(%rbp)
movb -0x1d4(%rbp), %al
testb $0x1, %al
jne 0x1f67d
jmp 0x1f6b9
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x1f0(%rbp)
jmp 0x1f692
movq -0x1f0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x176a0
jmp 0x1f6a4
jmp 0x1f6a6
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x1f6b4
jmp 0x1f5f1
movw $0x0, -0xe4(%rbp)
leaq -0xe4(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x20ec0
movb %al, -0x1f1(%rbp)
jmp 0x1f6da
movb -0x1f1(%rbp), %al
andb $0x1, %al
movb %al, -0xe5(%rbp)
leaq 0x93b1(%rip), %rdi      # 0x28aa0
leaq 0x93a8(%rip), %rcx      # 0x28a9e
movl $0xa8, %esi
leaq -0xe5(%rbp), %rdx
callq 0x11cb0
movb %al, -0x1f2(%rbp)
jmp 0x1f70f
movb -0x1f2(%rbp), %al
testb $0x1, %al
jne 0x1f724
jmp 0x1f71b
callq 0xb2a0
jmp 0x1f722
jmp 0x1f724
jmp 0x1f726
jmp 0x1f728
movq -0x8(%rbp), %rdi
movb -0xe4(%rbp), %al
movb %al, -0xe6(%rbp)
leaq -0xe6(%rbp), %rsi
callq 0x20fb0
jmp 0x1f746
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x1f3(%rbp)
jmp 0x1f75a
movb -0x1f3(%rbp), %al
testb $0x1, %al
jne 0x1f79a
jmp 0x1f766
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x200(%rbp)
jmp 0x1f77b
movq -0x200(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x1f79a
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x1f798
jmp 0x1f79c
jmp 0x1f7b2
jmp 0x1f79e
movl -0xe0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xe0(%rbp)
jmp 0x1f56c
jmp 0x20709
movl $0x0, -0xec(%rbp)
movl -0xec(%rbp), %eax
cmpl -0xd0(%rbp), %eax
jge 0x1fa07
jmp 0x1f7d5
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x201(%rbp)
jmp 0x1f7e9
movb -0x201(%rbp), %al
andb $0x1, %al
movb %al, -0xed(%rbp)
leaq 0x92a2(%rip), %rdi      # 0x28aa0
leaq 0x932f(%rip), %rcx      # 0x28b34
movl $0xb3, %esi
leaq -0xed(%rbp), %rdx
callq 0x1ecc0
movb %al, -0x202(%rbp)
jmp 0x1f81e
movb -0x202(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1f82c
jmp 0x1f835
callq 0xb2a0
jmp 0x1f833
jmp 0x1f835
jmp 0x1f837
jmp 0x1f839
leaq -0x80(%rbp), %rdi
callq 0x13670
jmp 0x1f844
jmp 0x1f846
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x203(%rbp)
jmp 0x1f85a
movb -0x203(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x204(%rbp)
jne 0x1f8c6
jmp 0x1f86f
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x210(%rbp)
jmp 0x1f884
movq -0x210(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2c, %ecx
movb %al, -0x204(%rbp)
je 0x1f8c6
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x218(%rbp)
jmp 0x1f8b0
movq -0x218(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
setne %al
movb %al, -0x204(%rbp)
movb -0x204(%rbp), %al
testb $0x1, %al
jne 0x1f8d2
jmp 0x1f90e
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x220(%rbp)
jmp 0x1f8e7
movq -0x220(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x176a0
jmp 0x1f8f9
jmp 0x1f8fb
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x1f909
jmp 0x1f846
movw $0x0, -0xf0(%rbp)
leaq -0xf0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1e270
movb %al, -0x221(%rbp)
jmp 0x1f92f
movb -0x221(%rbp), %al
andb $0x1, %al
movb %al, -0xf1(%rbp)
leaq 0x915c(%rip), %rdi      # 0x28aa0
leaq 0x9153(%rip), %rcx      # 0x28a9e
movl $0xba, %esi
leaq -0xf1(%rbp), %rdx
callq 0x11cb0
movb %al, -0x222(%rbp)
jmp 0x1f964
movb -0x222(%rbp), %al
testb $0x1, %al
jne 0x1f979
jmp 0x1f970
callq 0xb2a0
jmp 0x1f977
jmp 0x1f979
jmp 0x1f97b
jmp 0x1f97d
movq -0x8(%rbp), %rdi
movb -0xf0(%rbp), %al
movb %al, -0xf2(%rbp)
leaq -0xf2(%rbp), %rsi
callq 0x20fb0
jmp 0x1f99b
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x223(%rbp)
jmp 0x1f9af
movb -0x223(%rbp), %al
testb $0x1, %al
jne 0x1f9ef
jmp 0x1f9bb
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x230(%rbp)
jmp 0x1f9d0
movq -0x230(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x1f9ef
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x1f9ed
jmp 0x1f9f1
jmp 0x1fa07
jmp 0x1f9f3
movl -0xec(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xec(%rbp)
jmp 0x1f7c1
jmp 0x20709
movl $0x0, -0xf8(%rbp)
movl -0xf8(%rbp), %eax
cmpl -0xd0(%rbp), %eax
jge 0x1fc96
jmp 0x1fa2a
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x231(%rbp)
jmp 0x1fa3e
movb -0x231(%rbp), %al
andb $0x1, %al
movb %al, -0xf9(%rbp)
leaq 0x904d(%rip), %rdi      # 0x28aa0
leaq 0x90da(%rip), %rcx      # 0x28b34
movl $0xc5, %esi
leaq -0xf9(%rbp), %rdx
callq 0x1ecc0
movb %al, -0x232(%rbp)
jmp 0x1fa73
movb -0x232(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1fa81
jmp 0x1fa8a
callq 0xb2a0
jmp 0x1fa88
jmp 0x1fa8a
jmp 0x1fa8c
jmp 0x1fa8e
leaq -0x80(%rbp), %rdi
callq 0x13670
jmp 0x1fa99
jmp 0x1fa9b
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x233(%rbp)
jmp 0x1faaf
movb -0x233(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x234(%rbp)
jne 0x1fb1b
jmp 0x1fac4
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x240(%rbp)
jmp 0x1fad9
movq -0x240(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2c, %ecx
movb %al, -0x234(%rbp)
je 0x1fb1b
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x248(%rbp)
jmp 0x1fb05
movq -0x248(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
setne %al
movb %al, -0x234(%rbp)
movb -0x234(%rbp), %al
testb $0x1, %al
jne 0x1fb27
jmp 0x1fb63
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x250(%rbp)
jmp 0x1fb3c
movq -0x250(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x176a0
jmp 0x1fb4e
jmp 0x1fb50
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x1fb5e
jmp 0x1fa9b
movw $0x0, -0xfc(%rbp)
leaq -0xfc(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x20ec0
movb %al, -0x251(%rbp)
jmp 0x1fb84
movb -0x251(%rbp), %al
andb $0x1, %al
movb %al, -0xfd(%rbp)
leaq 0x8f07(%rip), %rdi      # 0x28aa0
leaq 0x8efe(%rip), %rcx      # 0x28a9e
movl $0xcc, %esi
leaq -0xfd(%rbp), %rdx
callq 0x11cb0
movb %al, -0x252(%rbp)
jmp 0x1fbb9
movb -0x252(%rbp), %al
testb $0x1, %al
jne 0x1fbce
jmp 0x1fbc5
callq 0xb2a0
jmp 0x1fbcc
jmp 0x1fbce
jmp 0x1fbd0
jmp 0x1fbd2
leaq -0xfc(%rbp), %rax
movq %rax, -0x108(%rbp)
movl $0x0, -0x10c(%rbp)
cmpl $0x2, -0x10c(%rbp)
jge 0x1fc2a
movq -0x8(%rbp), %rdi
movq -0x108(%rbp), %rsi
callq 0x176a0
jmp 0x1fc05
jmp 0x1fc07
movl -0x10c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10c(%rbp)
movq -0x108(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x108(%rbp)
jmp 0x1fbea
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x253(%rbp)
jmp 0x1fc3e
movb -0x253(%rbp), %al
testb $0x1, %al
jne 0x1fc7e
jmp 0x1fc4a
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x260(%rbp)
jmp 0x1fc5f
movq -0x260(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x1fc7e
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x1fc7c
jmp 0x1fc80
jmp 0x1fc96
jmp 0x1fc82
movl -0xf8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xf8(%rbp)
jmp 0x1fa16
jmp 0x20709
movl $0x0, -0x110(%rbp)
movl -0x110(%rbp), %eax
cmpl -0xd0(%rbp), %eax
jge 0x1ff25
jmp 0x1fcb9
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x261(%rbp)
jmp 0x1fccd
movb -0x261(%rbp), %al
andb $0x1, %al
movb %al, -0x111(%rbp)
leaq 0x8dbe(%rip), %rdi      # 0x28aa0
leaq 0x8e4b(%rip), %rcx      # 0x28b34
movl $0xd9, %esi
leaq -0x111(%rbp), %rdx
callq 0x1ecc0
movb %al, -0x262(%rbp)
jmp 0x1fd02
movb -0x262(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1fd10
jmp 0x1fd19
callq 0xb2a0
jmp 0x1fd17
jmp 0x1fd19
jmp 0x1fd1b
jmp 0x1fd1d
leaq -0x80(%rbp), %rdi
callq 0x13670
jmp 0x1fd28
jmp 0x1fd2a
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x263(%rbp)
jmp 0x1fd3e
movb -0x263(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x264(%rbp)
jne 0x1fdaa
jmp 0x1fd53
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x270(%rbp)
jmp 0x1fd68
movq -0x270(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2c, %ecx
movb %al, -0x264(%rbp)
je 0x1fdaa
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x278(%rbp)
jmp 0x1fd94
movq -0x278(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
setne %al
movb %al, -0x264(%rbp)
movb -0x264(%rbp), %al
testb $0x1, %al
jne 0x1fdb6
jmp 0x1fdf2
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x280(%rbp)
jmp 0x1fdcb
movq -0x280(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x176a0
jmp 0x1fddd
jmp 0x1fddf
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x1fded
jmp 0x1fd2a
movw $0x0, -0x114(%rbp)
leaq -0x114(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1e270
movb %al, -0x281(%rbp)
jmp 0x1fe13
movb -0x281(%rbp), %al
andb $0x1, %al
movb %al, -0x115(%rbp)
leaq 0x8c78(%rip), %rdi      # 0x28aa0
leaq 0x8c6f(%rip), %rcx      # 0x28a9e
movl $0xe0, %esi
leaq -0x115(%rbp), %rdx
callq 0x11cb0
movb %al, -0x282(%rbp)
jmp 0x1fe48
movb -0x282(%rbp), %al
testb $0x1, %al
jne 0x1fe5d
jmp 0x1fe54
callq 0xb2a0
jmp 0x1fe5b
jmp 0x1fe5d
jmp 0x1fe5f
jmp 0x1fe61
leaq -0x114(%rbp), %rax
movq %rax, -0x120(%rbp)
movl $0x0, -0x124(%rbp)
cmpl $0x2, -0x124(%rbp)
jge 0x1feb9
movq -0x8(%rbp), %rdi
movq -0x120(%rbp), %rsi
callq 0x176a0
jmp 0x1fe94
jmp 0x1fe96
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
movq -0x120(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x120(%rbp)
jmp 0x1fe79
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x283(%rbp)
jmp 0x1fecd
movb -0x283(%rbp), %al
testb $0x1, %al
jne 0x1ff0d
jmp 0x1fed9
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x290(%rbp)
jmp 0x1feee
movq -0x290(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x1ff0d
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x1ff0b
jmp 0x1ff0f
jmp 0x1ff25
jmp 0x1ff11
movl -0x110(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x110(%rbp)
jmp 0x1fca5
jmp 0x20709
movl $0x0, -0x128(%rbp)
movl -0x128(%rbp), %eax
cmpl -0xd0(%rbp), %eax
jge 0x201b5
jmp 0x1ff48
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x291(%rbp)
jmp 0x1ff5c
movb -0x291(%rbp), %al
andb $0x1, %al
movb %al, -0x129(%rbp)
leaq 0x8b2f(%rip), %rdi      # 0x28aa0
leaq 0x8bbc(%rip), %rcx      # 0x28b34
movl $0xed, %esi
leaq -0x129(%rbp), %rdx
callq 0x1ecc0
movb %al, -0x292(%rbp)
jmp 0x1ff91
movb -0x292(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ff9f
jmp 0x1ffa8
callq 0xb2a0
jmp 0x1ffa6
jmp 0x1ffa8
jmp 0x1ffaa
jmp 0x1ffac
leaq -0x80(%rbp), %rdi
callq 0x13670
jmp 0x1ffb7
jmp 0x1ffb9
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x293(%rbp)
jmp 0x1ffcd
movb -0x293(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x294(%rbp)
jne 0x20039
jmp 0x1ffe2
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x2a0(%rbp)
jmp 0x1fff7
movq -0x2a0(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2c, %ecx
movb %al, -0x294(%rbp)
je 0x20039
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x2a8(%rbp)
jmp 0x20023
movq -0x2a8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
setne %al
movb %al, -0x294(%rbp)
movb -0x294(%rbp), %al
testb $0x1, %al
jne 0x20045
jmp 0x20081
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x2b0(%rbp)
jmp 0x2005a
movq -0x2b0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x176a0
jmp 0x2006c
jmp 0x2006e
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x2007c
jmp 0x1ffb9
movl $0x0, -0x130(%rbp)
leaq -0x130(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1e990
movb %al, -0x2b1(%rbp)
jmp 0x200a3
movb -0x2b1(%rbp), %al
andb $0x1, %al
movb %al, -0x131(%rbp)
leaq 0x89e8(%rip), %rdi      # 0x28aa0
leaq 0x89df(%rip), %rcx      # 0x28a9e
movl $0xf4, %esi
leaq -0x131(%rbp), %rdx
callq 0x11cb0
movb %al, -0x2b2(%rbp)
jmp 0x200d8
movb -0x2b2(%rbp), %al
testb $0x1, %al
jne 0x200ed
jmp 0x200e4
callq 0xb2a0
jmp 0x200eb
jmp 0x200ed
jmp 0x200ef
jmp 0x200f1
leaq -0x130(%rbp), %rax
movq %rax, -0x140(%rbp)
movl $0x0, -0x144(%rbp)
cmpl $0x4, -0x144(%rbp)
jge 0x20149
movq -0x8(%rbp), %rdi
movq -0x140(%rbp), %rsi
callq 0x176a0
jmp 0x20124
jmp 0x20126
movl -0x144(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x144(%rbp)
movq -0x140(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x140(%rbp)
jmp 0x20109
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x2b3(%rbp)
jmp 0x2015d
movb -0x2b3(%rbp), %al
testb $0x1, %al
jne 0x2019d
jmp 0x20169
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x2c0(%rbp)
jmp 0x2017e
movq -0x2c0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x2019d
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x2019b
jmp 0x2019f
jmp 0x201b5
jmp 0x201a1
movl -0x128(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x128(%rbp)
jmp 0x1ff34
jmp 0x20709
movl $0x0, -0x148(%rbp)
movl -0x148(%rbp), %eax
cmpl -0xd0(%rbp), %eax
jge 0x20445
jmp 0x201d8
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x2c1(%rbp)
jmp 0x201ec
movb -0x2c1(%rbp), %al
andb $0x1, %al
movb %al, -0x149(%rbp)
leaq 0x889f(%rip), %rdi      # 0x28aa0
leaq 0x892c(%rip), %rcx      # 0x28b34
movl $0x101, %esi            # imm = 0x101
leaq -0x149(%rbp), %rdx
callq 0x1ecc0
movb %al, -0x2c2(%rbp)
jmp 0x20221
movb -0x2c2(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2022f
jmp 0x20238
callq 0xb2a0
jmp 0x20236
jmp 0x20238
jmp 0x2023a
jmp 0x2023c
leaq -0x80(%rbp), %rdi
callq 0x13670
jmp 0x20247
jmp 0x20249
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x2c3(%rbp)
jmp 0x2025d
movb -0x2c3(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x2c4(%rbp)
jne 0x202c9
jmp 0x20272
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x2d0(%rbp)
jmp 0x20287
movq -0x2d0(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2c, %ecx
movb %al, -0x2c4(%rbp)
je 0x202c9
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x2d8(%rbp)
jmp 0x202b3
movq -0x2d8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
setne %al
movb %al, -0x2c4(%rbp)
movb -0x2c4(%rbp), %al
testb $0x1, %al
jne 0x202d5
jmp 0x20311
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x2e0(%rbp)
jmp 0x202ea
movq -0x2e0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x176a0
jmp 0x202fc
jmp 0x202fe
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x2030c
jmp 0x20249
movl $0x0, -0x150(%rbp)
leaq -0x150(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x137b0
movb %al, -0x2e1(%rbp)
jmp 0x20333
movb -0x2e1(%rbp), %al
andb $0x1, %al
movb %al, -0x151(%rbp)
leaq 0x8758(%rip), %rdi      # 0x28aa0
leaq 0x874f(%rip), %rcx      # 0x28a9e
movl $0x108, %esi            # imm = 0x108
leaq -0x151(%rbp), %rdx
callq 0x11cb0
movb %al, -0x2e2(%rbp)
jmp 0x20368
movb -0x2e2(%rbp), %al
testb $0x1, %al
jne 0x2037d
jmp 0x20374
callq 0xb2a0
jmp 0x2037b
jmp 0x2037d
jmp 0x2037f
jmp 0x20381
leaq -0x150(%rbp), %rax
movq %rax, -0x160(%rbp)
movl $0x0, -0x164(%rbp)
cmpl $0x4, -0x164(%rbp)
jge 0x203d9
movq -0x8(%rbp), %rdi
movq -0x160(%rbp), %rsi
callq 0x176a0
jmp 0x203b4
jmp 0x203b6
movl -0x164(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x164(%rbp)
movq -0x160(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x160(%rbp)
jmp 0x20399
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x2e3(%rbp)
jmp 0x203ed
movb -0x2e3(%rbp), %al
testb $0x1, %al
jne 0x2042d
jmp 0x203f9
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x2f0(%rbp)
jmp 0x2040e
movq -0x2f0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x2042d
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x2042b
jmp 0x2042f
jmp 0x20445
jmp 0x20431
movl -0x148(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x148(%rbp)
jmp 0x201c4
jmp 0x20709
movl $0x0, -0x168(%rbp)
movl -0x168(%rbp), %eax
cmpl -0xd0(%rbp), %eax
jge 0x206d5
jmp 0x20468
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x2f1(%rbp)
jmp 0x2047c
movb -0x2f1(%rbp), %al
andb $0x1, %al
movb %al, -0x169(%rbp)
leaq 0x860f(%rip), %rdi      # 0x28aa0
leaq 0x869c(%rip), %rcx      # 0x28b34
movl $0x115, %esi            # imm = 0x115
leaq -0x169(%rbp), %rdx
callq 0x1ecc0
movb %al, -0x2f2(%rbp)
jmp 0x204b1
movb -0x2f2(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x204bf
jmp 0x204c8
callq 0xb2a0
jmp 0x204c6
jmp 0x204c8
jmp 0x204ca
jmp 0x204cc
leaq -0x80(%rbp), %rdi
callq 0x13670
jmp 0x204d7
jmp 0x204d9
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x2f3(%rbp)
jmp 0x204ed
movb -0x2f3(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x2f4(%rbp)
jne 0x20559
jmp 0x20502
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x300(%rbp)
jmp 0x20517
movq -0x300(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2c, %ecx
movb %al, -0x2f4(%rbp)
je 0x20559
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x308(%rbp)
jmp 0x20543
movq -0x308(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
setne %al
movb %al, -0x2f4(%rbp)
movb -0x2f4(%rbp), %al
testb $0x1, %al
jne 0x20565
jmp 0x205a1
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x310(%rbp)
jmp 0x2057a
movq -0x310(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x176a0
jmp 0x2058c
jmp 0x2058e
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x2059c
jmp 0x204d9
movl $0x0, -0x170(%rbp)
leaq -0x170(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x20c90
movb %al, -0x311(%rbp)
jmp 0x205c3
movb -0x311(%rbp), %al
andb $0x1, %al
movb %al, -0x171(%rbp)
leaq 0x84c8(%rip), %rdi      # 0x28aa0
leaq 0x84bf(%rip), %rcx      # 0x28a9e
movl $0x11c, %esi            # imm = 0x11C
leaq -0x171(%rbp), %rdx
callq 0x11cb0
movb %al, -0x312(%rbp)
jmp 0x205f8
movb -0x312(%rbp), %al
testb $0x1, %al
jne 0x2060d
jmp 0x20604
callq 0xb2a0
jmp 0x2060b
jmp 0x2060d
jmp 0x2060f
jmp 0x20611
leaq -0x170(%rbp), %rax
movq %rax, -0x180(%rbp)
movl $0x0, -0x184(%rbp)
cmpl $0x4, -0x184(%rbp)
jge 0x20669
movq -0x8(%rbp), %rdi
movq -0x180(%rbp), %rsi
callq 0x176a0
jmp 0x20644
jmp 0x20646
movl -0x184(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x184(%rbp)
movq -0x180(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x180(%rbp)
jmp 0x20629
leaq -0xa8(%rbp), %rdi
callq 0x20e10
movb %al, -0x313(%rbp)
jmp 0x2067d
movb -0x313(%rbp), %al
testb $0x1, %al
jne 0x206bd
jmp 0x20689
leaq -0xa8(%rbp), %rdi
callq 0x20e50
movq %rax, -0x320(%rbp)
jmp 0x2069e
movq -0x320(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x206bd
leaq -0xa8(%rbp), %rdi
callq 0x20e90
jmp 0x206bb
jmp 0x206bf
jmp 0x206d5
jmp 0x206c1
movl -0x168(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x168(%rbp)
jmp 0x20454
jmp 0x20709
jmp 0x206d9
movsbl -0x91(%rbp), %ecx
leaq 0x83b9(%rip), %rdi      # 0x28aa0
leaq 0x8450(%rip), %rdx      # 0x28b3e
xorl %eax, %eax
movl $0x127, %esi            # imm = 0x127
callq 0xb130
jmp 0x206fc
callq 0xb2a0
jmp 0x20703
jmp 0x20705
jmp 0x20707
jmp 0x20709
leaq -0x80(%rbp), %rdi
callq 0xb7b0
jmp 0x2073b
jmp 0x20716
movsbl -0x2f(%rbp), %ecx
leaq 0x837f(%rip), %rdi      # 0x28aa0
movl $0x12c, %esi            # imm = 0x12C
leaq 0x8429(%rip), %rdx      # 0x28b56
movb $0x0, %al
callq 0xb130
callq 0xb2a0
jmp 0x2073b
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x4770