// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::produceSection()
void Mustache::produceSection() {
        bool useSection = (tokens_.at(currentToken_ - 1) == TOKEN_START_BEGIN_SECTION);
        bool useUnless = (tokens_.at(currentToken_ - 1) == TOKEN_START_UNLESS);
        bool useExistsTest = (tokens_.at(currentToken_ - 1) == TOKEN_START_EXISTS_TEST);

        LOG_START("");
        LOG_END("SECTION := ");
#ifdef DEBUG
        if (useSection) {
                LOG_START(TOKEN_START_BEGIN_SECTION);
        } else if (useUnless) {
                LOG_START(TOKEN_START_UNLESS);
        } else if (useExistsTest) {
                LOG_START(TOKEN_START_EXISTS_TEST);
        } else {
                LOG_START(TOKEN_START_IF);
        }
#endif

        // Token must be (txt)
        CHECK_TOKEN_IS_TEXT();

        // Save var name
        string variableName = tokens_.at(currentToken_);
        ensureValidIdentifier(variableName);
        LOG(" ");
        LOG(variableName);

        json variable;
        bool variable_exists;
        try {
            variable = searchVariableInContext(variableName);
            variable_exists = true;
        } catch(const std::out_of_range& ex) {
            variable = nullptr;
            variable_exists = false;
        } catch(const std::invalid_argument& ex) {
            variable = nullptr;
            variable_exists = false;
        }

        // Is variable malformed
        bool isCorrectType = variable.is_null() || variable.is_boolean() ||
                             variable.is_string() || variable.is_array() ||
                             variable.is_object() || variable.is_number();
        if (!isCorrectType) {
                error("Variable '" + variableName + "' is malformed");
                return;
        }

        CONSUME_TOKEN();
        CHECK_TOKEN_NOT_EMPTY();
        CHECK_TOKEN_IS(TOKEN_END);
        LOG(" ");
        LOG_END(TOKEN_END);

        CONSUME_TOKEN();
        // The logic of section block {{# }}
        // - [ a, b, c, .. ] ==> cycle
        // - [], {}, "", false, null ==> hide
        // - { something }, "something", true ==> view
        // Section always changes context. EG:
        //
        // context = {
        //   "var1": { "one": 1, "two": 2 },
        //   "var2": "value2"
        // }
        //
        // template =  {{# var1 }}{{ one }}{{/ var1 }}
        //
        // output = 1
        //
        if (useSection && variable.is_array() && variable.size() > 0) {
                const TokenIndex savedPosition = currentToken_;
                for (json::iterator it = variable.begin(); it != variable.end(); ++it) {
                        LOG_END(variable);
                        currentToken_ = savedPosition;
                        currentListCounter_ = std::distance(variable.begin(), it);
                        stack_.push(*it);
                        produceMessage();
                        stack_.pop();
                }
                // Reset to 0 after the main cycle
                currentListCounter_ = 0;
        } else {
                // The hide variable is used for {{= }} and {{# }} logic
                bool hide =
                        (variable.is_array() && variable.size() == 0) ||
                        (variable.is_object() && variable.size() == 0) ||
                        (variable.is_string() && variable.get<string>().size() == 0) ||
                        (variable.is_boolean() && !variable.get<bool>()) ||
                        (variable.is_number() && variable.get<int>() == 0) ||
                        (variable.is_null());

                if (useExistsTest) {
                        // The exist test {{0 }} uses a different logic:
                        // If the key do not exists the section is not shown.
                        hide = !variable_exists;
                } else if (useUnless) {
                        // The inverted section {{^ }} uses inverted logic
                        hide = !hide;
                }
                bool oldVisible = visible_;

                // Should the next message be visible?
                visible_ = visible_ && !hide;

                // The only difference from {{# }} and {{= }} {{^ }} {{? }}
                // is the fact that tag {{# }} changes context.
                if (useSection) {
                        stack_.push(variable);
                }
                produceMessage();
                if (useSection) {
                        stack_.pop();
                }

                // Retrieve the old visibility state
                visible_ = oldVisible;
        }

        CHECK_TOKEN_IS(TOKEN_START_END_SECTION);
        LOG(" ");
        LOG(TOKEN_START_END_SECTION);

        CONSUME_TOKEN();
        CHECK_TOKEN_NOT_EMPTY();
        const string& variableNameEnd = tokens_.at(currentToken_);
        LOG(" ");
        LOG(variableNameEnd);
        ensureValidIdentifier(variableName);
        if (variableNameEnd != variableName) {
                error("Expected '" + variableName + "' in closing block (found '" +
                      variableNameEnd + "')");
                return;
        }

        CONSUME_TOKEN();
        CHECK_TOKEN_NOT_EMPTY();
        CHECK_TOKEN_IS(TOKEN_END);
        LOG("  ");
        LOG_END(TOKEN_END);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq 0xe8(%rdi), %r14
leaq -0x1(%r14), %rsi
movq 0xd0(%rdi), %rbx
movq %rdi, -0x48(%rbp)
movq 0xd8(%rdi), %r15
subq %rbx, %r15
sarq $0x5, %r15
cmpq %rsi, %r15
jbe 0x1aeec
shlq $0x5, %rsi
leaq (%rbx,%rsi), %r13
movq 0x8(%rbx,%rsi), %r12
movq 0x22783(%rip), %rax     # 0x3cf60
cmpq 0x8(%rax), %r12
jne 0x1a801
testq %r12, %r12
je 0x1a839
movq (%rax), %rsi
movq (%r13), %rdi
movq %r12, %rdx
callq 0x17bc0
testl %eax, %eax
sete %al
movl %eax, -0x70(%rbp)
jmp 0x1a808
movl $0x0, -0x70(%rbp)
movq 0x22691(%rip), %rax     # 0x3cea0
cmpq 0x8(%rax), %r12
jne 0x1a830
testq %r12, %r12
je 0x1a852
movq (%rax), %rsi
movq (%r13), %rdi
movq %r12, %rdx
callq 0x17bc0
testl %eax, %eax
sete %al
jmp 0x1a854
movl $0x0, -0x3c(%rbp)
jmp 0x1a857
movq 0x22660(%rip), %rax     # 0x3cea0
cmpq $0x0, 0x8(%rax)
sete %al
movl %eax, -0x3c(%rbp)
movb $0x1, %al
movl %eax, -0x70(%rbp)
jmp 0x1a857
movb $0x1, %al
movl %eax, -0x3c(%rbp)
movq 0x226c2(%rip), %rax     # 0x3cf20
cmpq 0x8(%rax), %r12
jne 0x1a87f
testq %r12, %r12
je 0x1a883
movq (%rax), %rsi
movq (%r13), %rdi
movq %r12, %rdx
callq 0x17bc0
testl %eax, %eax
sete %al
jmp 0x1a885
xorl %eax, %eax
jmp 0x1a885
movb $0x1, %al
cmpq %r15, %r14
movq -0x48(%rbp), %r13
je 0x1aef5
movl %eax, -0x98(%rbp)
jae 0x1af23
shlq $0x5, %r14
leaq -0xa8(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rbx,%r14), %rsi
movq 0x8(%rbx,%r14), %rdx
addq %rsi, %rdx
leaq -0xb8(%rbp), %r14
movq %r14, %rdi
callq 0x173d0
movq 0x22619(%rip), %rdx     # 0x3cee8
movq %r14, %rsi
callq 0x18280
leaq -0x38(%rbp), %rbx
movb $0x0, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x17520
movq %rbx, %rdi
movl $0x1, %esi
callq 0x17520
leaq -0x130(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
movq %r13, %rsi
callq 0x17c10
leaq -0x38(%rbp), %rdi
leaq -0x130(%rbp), %r14
movq %r14, %rsi
callq 0x17540
movq %r14, %rdi
callq 0x17d50
xorl %ebx, %ebx
movl %ebx, -0x94(%rbp)
movzbl -0x38(%rbp), %ebx
cmpl $0x8, %ebx
jae 0x1af37
movq 0xe8(%r13), %rax
movq %rax, %r15
leaq 0x1(%rax), %r14
movq %r14, 0xe8(%r13)
movq 0xd0(%r13), %rax
movq 0xd8(%r13), %r12
subq %rax, %r12
sarq $0x5, %r12
cmpq %r12, %r14
je 0x1af84
jae 0x1ae28
shlq $0x5, %r14
movq 0x8(%rax,%r14), %rdx
movq 0x224e9(%rip), %rcx     # 0x3ce78
cmpq 0x8(%rcx), %rdx
jne 0x1ae50
testq %rdx, %rdx
je 0x1a9b4
addq %r14, %rax
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x17bc0
testl %eax, %eax
jne 0x1ae50
addq $0x2, %r15
movq %r15, -0xe0(%rbp)
movq %r15, 0xe8(%r13)
cmpb $0x2, %bl
setne %al
movl -0x70(%rbp), %r14d
movl %r14d, %ecx
xorb $0x1, %cl
orb %al, %cl
jne 0x1ab6d
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x1ab89
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
leaq -0xd0(%rbp), %rcx
leaq -0x38(%rbp), %rax
movq %rax, -0x8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq %r14, 0x10(%rcx)
leaq -0xd8(%rbp), %rdi
callq 0x17c80
leaq -0x88(%rbp), %rbx
leaq 0xf8(%r13), %rax
movq %rax, -0x70(%rbp)
leaq -0x90(%rbp), %r13
leaq -0x68(%rbp), %r15
leaq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %r14, -0x78(%rbp)
movq %r13, %rdi
callq 0x17200
leaq -0xd8(%rbp), %rdi
movq %r13, %rsi
callq 0x17440
testb %al, %al
jne 0x1ab90
movq -0x48(%rbp), %rax
movq -0xe0(%rbp), %rcx
movq %rcx, 0xe8(%rax)
leaq -0x38(%rbp), %rax
movq %rax, -0x120(%rbp)
xorps %xmm0, %xmm0
leaq -0x118(%rbp), %r12
movups %xmm0, (%r12)
movq %r14, -0x108(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x17c80
movq -0xd8(%rbp), %rax
leaq -0xd0(%rbp), %rdx
movq 0x10(%rdx), %rcx
leaq -0x60(%rbp), %rsi
movq %rcx, 0x10(%rsi)
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
movq -0x120(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rbx)
movups (%r12), %xmm0
movups %xmm0, (%rbx)
movq %rax, -0x68(%rbp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x17440
movq %rbx, %r12
movq %r14, %rbx
xorl %r14d, %r14d
testb %al, %al
jne 0x1ab21
movq %r13, %rdi
callq 0x18450
movq %r13, %rdi
movq %r15, %rsi
callq 0x17440
incq %r14
jmp 0x1ab05
movq -0x48(%rbp), %rax
movq %r14, 0xf0(%rax)
leaq -0xd8(%rbp), %rdi
callq 0x179f0
movq %rbx, %r14
movq %r12, %rbx
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x17f90
movq -0x48(%rbp), %rdi
callq 0x17560
movq -0x70(%rbp), %rdi
callq 0x17f20
leaq -0xd8(%rbp), %rdi
callq 0x18450
jmp 0x1aa3b
cmpl $0x1, %ebx
je 0x1abc6
cmpl $0x3, %ebx
je 0x1aba4
cmpl $0x2, %ebx
jne 0x1abd5
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
jne 0x1abd1
movb $0x1, %bl
jmp 0x1ac47
movq -0x48(%rbp), %r13
movq $0x0, 0xf0(%r13)
jmp 0x1aca8
leaq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x18410
cmpq $0x0, -0x88(%rbp)
je 0x1ac33
movb $0x1, %r12b
movb -0x38(%rbp), %bl
jmp 0x1abd8
movq -0x30(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1ab89
xorl %ebx, %ebx
jmp 0x1ac47
xorl %r12d, %r12d
cmpb $0x4, %bl
jne 0x1abfd
leaq -0x68(%rbp), %rdx
movb $0x0, (%rdx)
movq 0x2230d(%rip), %rdi     # 0x3cef8
leaq -0x38(%rbp), %rsi
callq 0x17a20
cmpb $0x1, -0x68(%rbp)
jne 0x1ac23
movb -0x38(%rbp), %bl
leal -0x5(%rbx), %eax
cmpb $0x2, %al
ja 0x1ac27
leaq -0x68(%rbp), %rsi
movl $0x0, (%rsi)
leaq -0x38(%rbp), %rdi
callq 0x17fe0
cmpl $0x0, -0x68(%rbp)
je 0x1ac23
cmpb $0x0, -0x38(%rbp)
jmp 0x1ac29
movb $0x1, %bl
jmp 0x1ac2c
testb %bl, %bl
sete %bl
testb %r12b, %r12b
jne 0x1ac35
jmp 0x1ac47
movb $0x1, %bl
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ac47
callq 0x17ae0
movl -0x3c(%rbp), %eax
xorb %bl, %al
movzbl %al, %eax
movzbl -0x94(%rbp), %ecx
cmpb $0x0, -0x98(%rbp)
cmovel %eax, %ecx
movb 0x148(%r13), %bl
xorb $0x1, %cl
andb %bl, %cl
movb %cl, 0x148(%r13)
testb %r14b, %r14b
je 0x1ac88
leaq 0xf8(%r13), %rdi
leaq -0x38(%rbp), %rsi
callq 0x17f90
movq %r13, %rdi
callq 0x17560
testb %r14b, %r14b
je 0x1aca1
leaq 0xf8(%r13), %rdi
callq 0x17f20
movb %bl, 0x148(%r13)
movq 0xe8(%r13), %r14
movq 0xd0(%r13), %r15
movq 0xd8(%r13), %r12
subq %r15, %r12
sarq $0x5, %r12
cmpq %r12, %r14
je 0x1ae08
jae 0x1ae28
movq %r14, %rax
shlq $0x5, %rax
movq 0x8(%r15,%rax), %rdx
movq 0x222ca(%rip), %rcx     # 0x3cfb0
cmpq 0x8(%rcx), %rdx
jne 0x1ae08
testq %rdx, %rdx
je 0x1ad0b
addq %r15, %rax
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x17bc0
testl %eax, %eax
jne 0x1ae08
incq %r14
movq %r14, 0xe8(%r13)
cmpq %r12, %r14
je 0x1afb2
jae 0x1ae3c
movq 0x221bd(%rip), %rdx     # 0x3cee8
leaq -0xb8(%rbp), %rsi
callq 0x18280
shlq $0x5, %r14
addq %r14, %r15
movq 0x8(%r15), %rdx
cmpq -0xb0(%rbp), %rdx
jne 0x1ae76
testq %rdx, %rdx
je 0x1ad6b
movq -0xb8(%rbp), %rsi
movq (%r15), %rdi
callq 0x17bc0
testl %eax, %eax
jne 0x1ae76
movq 0xe8(%r13), %r14
incq %r14
movq %r14, 0xe8(%r13)
movq 0xd0(%r13), %rax
movq 0xd8(%r13), %r12
subq %rax, %r12
sarq $0x5, %r12
cmpq %r12, %r14
je 0x1afda
jae 0x1ae3c
shlq $0x5, %r14
movq 0x8(%rax,%r14), %rdx
movq 0x220c8(%rip), %rcx     # 0x3ce78
cmpq 0x8(%rcx), %rdx
jne 0x1aecc
testq %rdx, %rdx
je 0x1add5
addq %r14, %rax
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x17bc0
testl %eax, %eax
jne 0x1aecc
leaq -0x38(%rbp), %rdi
callq 0x17d50
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rax
cmpq %rax, %rdi
je 0x1adf6
callq 0x17ae0
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14ebe(%rip), %rsi     # 0x2fccd
movq 0x2219a(%rip), %rdx     # 0x3cfb0
leaq -0x68(%rbp), %rdi
callq 0x17a50
leaq -0x68(%rbp), %rsi
callq 0x17e50
leaq 0x188a5(%rip), %rdi     # 0x336d4
movq %r14, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x180f0
leaq 0x18891(%rip), %rdi     # 0x336d4
movq %r14, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x180f0
leaq 0x14e76(%rip), %rsi     # 0x2fccd
movq 0x2201a(%rip), %rdx     # 0x3ce78
leaq -0x90(%rbp), %rdi
callq 0x17a50
leaq -0x90(%rbp), %rsi
callq 0x17e50
leaq 0x14e78(%rip), %rsi     # 0x2fcf5
leaq -0x150(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x17a50
leaq 0x14e69(%rip), %rsi     # 0x2fd00
leaq -0x150(%rbp), %rdi
callq 0x18660
leaq -0xf0(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1b002
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
jmp 0x1b013
leaq 0x14dfa(%rip), %rsi     # 0x2fccd
movq 0x21f9e(%rip), %rdx     # 0x3ce78
leaq -0x68(%rbp), %rdi
callq 0x17a50
leaq -0x68(%rbp), %rsi
callq 0x17e50
leaq 0x187e1(%rip), %rdi     # 0x336d4
jmp 0x1af2d
leaq -0x80(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x14db1(%rip), %rsi     # 0x2fcb5
leaq 0x14dc1(%rip), %rdx     # 0x2fccc
leaq -0x90(%rbp), %rdi
callq 0x173a0
leaq -0x90(%rbp), %rsi
callq 0x17e50
leaq 0x187aa(%rip), %rdi     # 0x336d4
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x180f0
leaq 0x14d9d(%rip), %rsi     # 0x2fcdb
leaq -0x68(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x17a50
leaq 0x14d91(%rip), %rsi     # 0x2fce6
leaq -0x68(%rbp), %rdi
callq 0x18660
leaq -0x80(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1b073
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
jmp 0x1b081
leaq -0x80(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x14d22(%rip), %rsi     # 0x2fcb5
leaq 0x14d32(%rip), %rdx     # 0x2fccc
leaq -0x90(%rbp), %rdi
callq 0x173a0
leaq -0x90(%rbp), %rsi
callq 0x17e50
leaq -0x58(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x14cf4(%rip), %rsi     # 0x2fcb5
leaq 0x14d04(%rip), %rdx     # 0x2fccc
leaq -0x68(%rbp), %rdi
callq 0x173a0
leaq -0x68(%rbp), %rsi
callq 0x17e50
leaq -0x58(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x14ccc(%rip), %rsi     # 0x2fcb5
leaq 0x14cdc(%rip), %rdx     # 0x2fccc
leaq -0x68(%rbp), %rdi
callq 0x173a0
leaq -0x68(%rbp), %rsi
callq 0x17e50
movq %rdx, -0x100(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xf0(%rbp)
movq 0x8(%rax), %rdx
leaq -0x100(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0xd8(%rbp), %rdi
movq %r15, %rdx
callq 0x180c0
leaq 0x14cd5(%rip), %rsi     # 0x2fd1c
leaq -0xd8(%rbp), %rdi
callq 0x18660
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1b0a4
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x1b0af
movq %rdx, -0x90(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x80(%rbp)
movq 0x8(%rax), %rdx
leaq -0x90(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x17e50
movq %rdx, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
movq 0x8(%rax), %rdx
leaq -0x68(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x17e50
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x1b0e5
callq 0x17ae0
jmp 0x1b0e5
movq %rax, %r14
leaq -0xc8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b115
callq 0x17ae0
jmp 0x1b115
jmp 0x1b283
movq %rax, %r14
testb %r12b, %r12b
jne 0x1b1c2
jmp 0x1b286
movq %rax, %r14
movq -0x100(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1b14d
callq 0x17ae0
jmp 0x1b14d
movq %rax, %r14
movq -0x90(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1b265
callq 0x17ae0
jmp 0x1b265
jmp 0x1b262
movq %rax, %r14
leaq -0x140(%rbp), %rax
jmp 0x1b269
jmp 0x1b160
jmp 0x1b283
movq %rax, %r14
movq -0x68(%rbp), %rdi
jmp 0x1b178
jmp 0x1b283
movq %rax, %r14
movq -0x90(%rbp), %rdi
cmpq %rbx, %rdi
jne 0x1b272
jmp 0x1b286
jmp 0x1b283
jmp 0x1b283
movq %rax, %r14
movq -0x90(%rbp), %rdi
cmpq %rbx, %rdi
jne 0x1b2a2
jmp 0x1b2a7
movq %rax, %r14
jmp 0x1b2a7
jmp 0x1b262
jmp 0x1b283
jmp 0x1b283
movq %rax, %r14
leaq -0x80(%rbp), %rax
jmp 0x1b269
jmp 0x1b283
movq %rax, %r14
cmpl $0x2, %edx
jne 0x1b215
movq %r14, %rdi
callq 0x173f0
leaq -0x160(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x17e00
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x17540
movq %r14, %rdi
callq 0x17d50
movb $0x1, %bl
callq 0x18300
movq -0x48(%rbp), %r13
jmp 0x1a933
cmpl $0x1, %edx
jne 0x1b286
movq %r14, %rdi
callq 0x173f0
leaq -0x170(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x17e00
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x17540
movq %r14, %rdi
callq 0x17d50
movb $0x1, %bl
callq 0x18300
movq -0x48(%rbp), %r13
jmp 0x1a933
jmp 0x1b283
jmp 0x1b283
movq %rax, %r14
jmp 0x1b28f
jmp 0x1b283
movq %rax, %r14
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b286
callq 0x17ae0
jmp 0x1b286
jmp 0x1b283
jmp 0x1b283
jmp 0x1b283
jmp 0x1b283
jmp 0x1b283
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x17d50
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rax
cmpq %rax, %rdi
je 0x1b2a7
callq 0x17ae0
movq %r14, %rdi
callq 0x18490
nop