// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_covocov_expression0::process(exprtk::parser<double>::expression_generator<double>&, exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (c0 o0 v0) o1 (c1 o2 v1)
               const details::cov_base_node<Type>* cov0 = static_cast<details::cov_base_node<Type>*>(branch[0]);
               const details::cov_base_node<Type>* cov1 = static_cast<details::cov_base_node<Type>*>(branch[1]);
               const Type  c0 = cov0->c();
               const Type& v0 = cov0->v();
               const Type  c1 = cov1->c();
               const Type& v1 = cov1->v();
               const details::operator_type o0 = cov0->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = cov1->operation();

               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);

               expression_node_ptr result = error_node();

               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (c0 + v0) + (c1 + v1) --> (covov) (c0 + c1) + v0 + v1
                  if ((details::e_add == o0) && (details::e_add == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)+t", (c0 + c1), v0, v1, result);

                     exprtk_debug(("(c0 + v0) + (c1 + v1) --> (covov) (c0 + c1) + v0 + v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 + v0) - (c1 + v1) --> (covov) (c0 - c1) + v0 - v1
                  else if ((details::e_add == o0) && (details::e_sub == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)-t", (c0 - c1), v0, v1, result);

                     exprtk_debug(("(c0 + v0) - (c1 + v1) --> (covov) (c0 - c1) + v0 - v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 - v0) - (c1 - v1) --> (covov) (c0 - c1) - v0 + v1
                  else if ((details::e_sub == o0) && (details::e_sub == o1) && (details::e_sub == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t-t)+t", (c0 - c1), v0, v1, result);

                     exprtk_debug(("(c0 - v0) - (c1 - v1) --> (covov) (c0 - c1) - v0 + v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) * (c1 * v1) --> (covov) (c0 * c1) * v0 * v1
                  else if ((details::e_mul == o0) && (details::e_mul == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)*t", (c0 * c1), v0, v1, result);

                     exprtk_debug(("(c0 * v0) * (c1 * v1) --> (covov) (c0 * c1) * v0 * v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) / (c1 * v1) --> (covov) (c0 / c1) * (v0 / v1)
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", (c0 / c1), v0, v1, result);

                     exprtk_debug(("(c0 * v0) / (c1 * v1) --> (covov) (c0 / c1) * (v0 / v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) * (c1 / v1) --> (covov) (c0 * c1) / (v0 * v1)
                  else if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t/(t*t)", (c0 * c1), v0, v1, result);

                     exprtk_debug(("(c0 / v0) * (c1 / v1) --> (covov) (c0 * c1) / (v0 * v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) / (c1 / v1) --> (covov) ((c0 / c1) * v1) / v0
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", (c0 / c1), v1, v0, result);

                     exprtk_debug(("(c0 / v0) / (c1 / v1) --> (covov) ((c0 / c1) * v1) / v0\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) / (c1 / v1) --> (covov) (c0 / c1) * (v0 * v1)
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t*(t*t)", (c0 / c1), v0, v1, result);

                     exprtk_debug(("(c0 * v0) / (c1 / v1) --> (covov) (c0 / c1) * (v0 * v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) / (c1 * v1) --> (covov) (c0 / c1) / (v0 * v1)
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t/(t*t)", (c0 / c1), v0, v1, result);

                     exprtk_debug(("(c0 / v0) / (c1 * v1) --> (covov) (c0 / c1) / (v0 * v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (c * v0) +/- (c * v1) --> (covov) c * (v0 +/- v1)
                  else if (
                            (std::equal_to<T>()(c0,c1)) &&
                            (details::e_mul == o0)      &&
                            (details::e_mul == o2)      &&
                            (
                              (details::e_add == o1) ||
                              (details::e_sub == o1)
                            )
                          )
                  {
                     std::string specfunc;

                     switch (o1)
                     {
                        case details::e_add : specfunc = "t*(t+t)"; break;
                        case details::e_sub : specfunc = "t*(t-t)"; break;
                        default             : return error_node();
                     }

                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, specfunc, c0, v0, v1, result);

                     exprtk_debug(("(c * v0) +/- (c * v1) --> (covov) c * (v0 +/- v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
               }

               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, c1, v1, result);

               if (synthesis_result)
                  return result;

               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);

               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, c1, v1, f0, f1, f2);
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x8(%rdx), %rbx
movq (%rdx), %r13
movq 0x8(%rdx), %rbp
movq (%r13), %rax
movq %r13, %rdi
callq *0x40(%rax)
movsd %xmm0, 0x30(%rsp)
movq (%r13), %rax
movq %r13, %rdi
callq *0x48(%rax)
movq %rax, 0x40(%rsp)
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x40(%rax)
movsd %xmm0, 0x48(%rsp)
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x48(%rax)
movq %rax, 0x38(%rsp)
movq (%r13), %rax
movq %r13, %rdi
callq *0x38(%rax)
movl %eax, %r13d
movl (%r12), %r12d
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x38(%rax)
movl %eax, %ebp
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2052ad
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2052ad
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2052a5
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2052ad
movq %r14, %rdi
callq 0x1f1690
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2052db
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2052db
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2052d3
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2052db
movq %rbx, %rdi
callq 0x1f1690
movq $0x0, 0x8(%rsp)
movq 0x68(%r15), %rax
cmpb $0x1, 0xd6(%rax)
jne 0x205781
movl %r13d, %eax
xorl $0x2, %eax
movl %r12d, %edx
xorl $0x2, %edx
orl %eax, %edx
movl %ebp, %ecx
xorl $0x2, %ecx
orl %ecx, %edx
jne 0x20537c
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b7c13(%rip), %rsi    # 0x3bcf2f
leaq 0x1b7c13(%rip), %rdx    # 0x3bcf36
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movq 0x58(%r15), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2115d4
movq %rax, %rbx
movq 0x58(%r15), %r12
addq $0x8, %r12
cmpq %rax, %r12
je 0x205502
movsd 0x30(%rsp), %xmm0
addsd 0x48(%rsp), %xmm0
movl 0x48(%rbx), %eax
leaq 0x54(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x216cf2
jmp 0x2054fd
movl %r12d, %edx
xorl $0x3, %edx
orl %edx, %eax
orl %ecx, %eax
jne 0x2053f8
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b7b8f(%rip), %rsi    # 0x3bcf27
leaq 0x1b7b8f(%rip), %rdx    # 0x3bcf2e
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movq 0x58(%r15), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2115d4
movq %rax, %rbx
movq 0x58(%r15), %r12
addq $0x8, %r12
cmpq %rax, %r12
je 0x205502
movsd 0x30(%rsp), %xmm0
subsd 0x48(%rsp), %xmm0
movl 0x48(%rbx), %eax
leaq 0x54(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x216cf2
jmp 0x2054fd
movl %r13d, %eax
xorl $0x3, %eax
orl %edx, %eax
movl %ebp, %ecx
xorl $0x3, %ecx
orl %eax, %ecx
jne 0x205479
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b7b1e(%rip), %rsi    # 0x3bcf37
leaq 0x1b7b1e(%rip), %rdx    # 0x3bcf3e
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movq 0x58(%r15), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2115d4
movq %rax, %rbx
movq 0x58(%r15), %r12
addq $0x8, %r12
cmpq %rax, %r12
je 0x205502
movsd 0x30(%rsp), %xmm0
subsd 0x48(%rsp), %xmm0
movl 0x48(%rbx), %eax
leaq 0x54(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x216cf2
jmp 0x2054fd
movl %r13d, %eax
xorl $0x4, %eax
movl %r12d, %esi
xorl $0x4, %esi
movl %eax, %edx
orl %esi, %edx
movl %ebp, %ecx
xorl $0x4, %ecx
orl %ecx, %edx
jne 0x205527
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b7ac1(%rip), %rsi    # 0x3bcf67
leaq 0x1b7ac1(%rip), %rdx    # 0x3bcf6e
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movq 0x58(%r15), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2115d4
movq %rax, %rbx
movq 0x58(%r15), %r12
addq $0x8, %r12
cmpq %rax, %r12
je 0x205502
movsd 0x30(%rsp), %xmm0
mulsd 0x48(%rsp), %xmm0
movl 0x48(%rbx), %eax
leaq 0x54(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x216cf2
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x205519
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
cmpq %rbx, %r12
jne 0x205803
jmp 0x205965
movl %r12d, %edi
xorl $0x5, %edi
movl %eax, %r8d
orl %edi, %r8d
sete %dl
orl %ecx, %r8d
jne 0x205589
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b7a14(%rip), %rsi    # 0x3bcf5f
leaq 0x1b7a14(%rip), %rdx    # 0x3bcf66
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movsd 0x30(%rsp), %xmm0
divsd 0x48(%rsp), %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x216a0c
jmp 0x2056f9
movl %r13d, %r8d
xorl $0x5, %r8d
orl %r8d, %esi
movl %ebp, %r9d
xorl $0x5, %r9d
orl %r9d, %esi
jne 0x2055ed
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b79f0(%rip), %rsi    # 0x3bcf9f
leaq 0x1b79f0(%rip), %rdx    # 0x3bcfa6
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movsd 0x30(%rsp), %xmm0
mulsd 0x48(%rsp), %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x216a0c
jmp 0x2056f9
orl %edi, %r8d
sete %sil
orl %r9d, %r8d
jne 0x205647
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b7956(%rip), %rsi    # 0x3bcf5f
leaq 0x1b7956(%rip), %rdx    # 0x3bcf66
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movsd 0x30(%rsp), %xmm0
divsd 0x48(%rsp), %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x216a0c
jmp 0x2056f9
cmpl $0x5, %ebp
setne %dil
xorb $0x1, %dl
orb %dil, %dl
jne 0x2056a1
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b7959(%rip), %rsi    # 0x3bcfbf
leaq 0x1b7959(%rip), %rdx    # 0x3bcfc6
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movsd 0x30(%rsp), %xmm0
divsd 0x48(%rsp), %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x216a0c
jmp 0x2056f9
cmpl $0x4, %ebp
setne %dl
xorb $0x1, %sil
orb %dl, %sil
jne 0x20571f
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b78df(%rip), %rsi    # 0x3bcf9f
leaq 0x1b78df(%rip), %rdx    # 0x3bcfa6
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movsd 0x30(%rsp), %xmm0
divsd 0x48(%rsp), %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x216a0c
movl %eax, %ebx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x205712
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
testb %bl, %bl
jne 0x205803
jmp 0x205965
movsd 0x30(%rsp), %xmm0
ucomisd 0x48(%rsp), %xmm0
setnp %dl
sete %sil
andb %dl, %sil
orl %ecx, %eax
movl %r12d, %ecx
andl $-0x2, %ecx
xorl $0x2, %ecx
orl %eax, %ecx
sete %al
andb %sil, %al
cmpb $0x1, %al
jne 0x205781
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
cmpl $0x3, %r12d
je 0x20597a
cmpl $0x2, %r12d
jne 0x2059b8
leaq 0x1b7833(%rip), %rsi    # 0x3bcfaf
jmp 0x205981
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
callq 0x23adcc
movq 0x60(%r15), %rdi
movq %rbx, %rsi
callq 0x21d4c8
movq %rax, %rbx
movq 0x60(%r15), %r14
addq $0x8, %r14
cmpq %rax, %r14
je 0x2057e3
movl 0x48(%rbx), %eax
leaq 0x54(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movsd 0x30(%rsp), %xmm0
movq 0x40(%rsp), %rdx
movsd 0x48(%rsp), %xmm1
movq 0x38(%rsp), %rcx
callq 0x23b134
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2057fe
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
cmpq %rbx, %r14
je 0x20580d
movq 0x8(%rsp), %r15
jmp 0x205968
movq 0x48(%r15), %rax
movq 0x10(%rax), %rcx
addq $0x8, %rax
movq %rax, %rdx
testq %rcx, %rcx
je 0x20583f
movq %rcx, %rsi
movq %rax, %rdx
xorl %edi, %edi
cmpl %r13d, 0x20(%rsi)
setl %dil
cmovgeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x205827
movq %rax, %rsi
cmpq %rax, %rdx
je 0x205852
cmpl 0x20(%rdx), %r13d
cmovlq %rax, %rdx
movq %rdx, %rsi
cmpq %rsi, %rax
je 0x20585d
movq 0x28(%rsi), %rbx
jmp 0x20585f
xorl %ebx, %ebx
cmpq %rsi, %rax
je 0x205965
movq %rax, %rdx
testq %rcx, %rcx
je 0x20588e
movq %rcx, %rsi
movq %rax, %rdx
xorl %edi, %edi
cmpl %r12d, 0x20(%rsi)
setl %dil
cmovgeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x205876
movq %rax, %rsi
cmpq %rax, %rdx
je 0x2058a1
cmpl 0x20(%rdx), %r12d
cmovlq %rax, %rdx
movq %rdx, %rsi
cmpq %rsi, %rax
je 0x2058ac
movq 0x28(%rsi), %r14
jmp 0x2058af
xorl %r14d, %r14d
cmpq %rsi, %rax
je 0x205965
movq %rax, %rdx
testq %rcx, %rcx
je 0x2058da
movq %rax, %rdx
xorl %esi, %esi
cmpl %ebp, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rdx
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x2058c3
movq %rax, %rcx
cmpq %rax, %rdx
je 0x2058ec
cmpl 0x20(%rdx), %ebp
cmovlq %rax, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
je 0x2058f7
movq 0x28(%rcx), %r12
jmp 0x2058fa
xorl %r12d, %r12d
cmpq %rcx, %rax
je 0x205965
movl $0x58, %edi
callq 0x1200f0
movq %rax, %r15
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x32f9e1(%rip), %rax    # 0x535300
movq %rax, (%r15)
leaq 0x32fa27(%rip), %rax    # 0x535350
movq %rax, 0x8(%r15)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%r15)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%r15)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x30(%r15)
movq 0x38(%rsp), %rax
movq %rax, 0x38(%r15)
movq %rbx, 0x40(%r15)
movq %r14, 0x48(%r15)
movq %r12, 0x50(%r15)
jmp 0x205968
xorl %r15d, %r15d
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b7636(%rip), %rsi    # 0x3bcfb7
leaq 0x10(%rsp), %rdi
callq 0x120210
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movsd 0x30(%rsp), %xmm0
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x216a0c
testb %al, %al
je 0x2059b8
movq 0x8(%rsp), %r15
jmp 0x2059bb
xorl %r15d, %r15d
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x205968
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x205968
jmp 0x2059fd
jmp 0x2059fd
jmp 0x2059fd
jmp 0x2059f8
jmp 0x2059fd
jmp 0x2059f8
jmp 0x2059fd
jmp 0x2059f8
jmp 0x2059fd
jmp 0x2059f8
jmp 0x2059fd
jmp 0x2059f8
jmp 0x2059f8
jmp 0x2059fd
jmp 0x2059f8
jmp 0x2059fd
jmp 0x2059f8
jmp 0x2059fd
movq %rax, %rbx
jmp 0x205a2a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
jne 0x205a1d
jmp 0x205a2a
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x205a2a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330