// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_vococov_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])
            {
               // (v0 o0 c0) o1 (c1 o2 v1)
               const details::voc_base_node<Type>* voc = static_cast<details::voc_base_node<Type>*>(branch[0]);
               const details::cov_base_node<Type>* cov = static_cast<details::cov_base_node<Type>*>(branch[1]);
               const Type  c0 = voc->c();
               const Type& v0 = voc->v();
               const Type  c1 = cov->c();
               const Type& v1 = cov->v();
               const details::operator_type o0 = voc->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = cov->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())
               {
                  // (v0 + c0) + (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(("(v0 + c0) + (c1 + v1) --> (covov) (c0 + c1) + v0 + v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 + c0) - (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(("(v0 + c0) - (c1 + v1) --> (covov) (c0 - c1) + v0 - v1\n"));

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

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

                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c0) * (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(("(v0 * c0) * (c1 * v1) --> (covov) (c0 * c1) * v0 * v1\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c0) / (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(("(v0 * c0) / (c1 * v1) --> (covov) (c0 / c1) * (v0 * v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c0) * (c1 / v1) --> (covov) (c1 / c0) * (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", (c1 / c0), v0, v1, result);

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

                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c0) / (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(("(v0 * c0) / (c1 / v1) --> (covov) (c0 / c1) * (v0 * v1)\n"));

                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c0) / (c1 * v1) --> (covov) (1 / (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", Type(1) / (c0 * c1), v0, v1, result);

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

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

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

                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c) +/- (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(("(v0 * c) +/- (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), v0, c0, 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_), v0, c0, 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, 0x38(%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, 0x40(%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 0x1ff9a7
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x1ff9a7
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1ff99f
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x1ff9a7
movq %r14, %rdi
callq 0x1ea63e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1ff9d5
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x1ff9d5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1ff9cd
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x1ff9d5
movq %rbx, %rdi
callq 0x1ea63e
movq $0x0, 0x8(%rsp)
movq 0x68(%r15), %rax
cmpb $0x1, 0xd6(%rax)
jne 0x1fff80
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 0x1ffa91
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19456d(%rip), %rsi    # 0x393f87
leaq 0x19456d(%rip), %rdx    # 0x393f8e
leaq 0x10(%rsp), %rdi
callq 0x1e4740
movq 0x58(%r15), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2092ce
movq %rax, %rbx
movq 0x58(%r15), %r15
addq $0x8, %r15
cmpq %rax, %r15
je 0x1ffcbb
movl $0xfffffc18, %eax       # imm = 0xFFFFFC18
addl 0x48(%rbx), %eax
cmpl $0x1e, %eax
ja 0x1ffcb4
movl %eax, %eax
leaq 0x33f821(%rip), %rcx    # 0x53f288
movq (%rcx,%rax,8), %r12
leaq 0x33f90e(%rip), %rcx    # 0x53f380
movq (%rcx,%rax,8), %r13
movl $0x38, %edi
callq 0x11e0f0
movsd 0x30(%rsp), %xmm0
addsd 0x48(%rsp), %xmm0
jmp 0x1ffb23
movl %r12d, %edx
xorl $0x3, %edx
orl %edx, %eax
orl %ecx, %eax
jne 0x1ffb52
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1944ce(%rip), %rsi    # 0x393f7f
leaq 0x1944ce(%rip), %rdx    # 0x393f86
leaq 0x10(%rsp), %rdi
callq 0x1e4740
movq 0x58(%r15), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2092ce
movq %rax, %rbx
movq 0x58(%r15), %r15
addq $0x8, %r15
cmpq %rax, %r15
je 0x1ffcbb
movl $0xfffffc18, %eax       # imm = 0xFFFFFC18
addl 0x48(%rbx), %eax
cmpl $0x1e, %eax
ja 0x1ffcb4
movl %eax, %eax
leaq 0x33f78a(%rip), %rcx    # 0x53f288
movq (%rcx,%rax,8), %r12
leaq 0x33f877(%rip), %rcx    # 0x53f380
movq (%rcx,%rax,8), %r13
movl $0x38, %edi
callq 0x11e0f0
movsd 0x30(%rsp), %xmm0
subsd 0x48(%rsp), %xmm0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %r12, (%rax)
movq %r13, 0x8(%rax)
movsd %xmm0, 0x20(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x30(%rax)
jmp 0x1ffcb6
movl %r13d, %eax
xorl $0x3, %eax
orl %edx, %eax
movl %ebp, %ecx
xorl $0x3, %ecx
orl %eax, %ecx
jne 0x1ffc18
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x194408(%rip), %rsi    # 0x393f7f
leaq 0x194408(%rip), %rdx    # 0x393f86
leaq 0x10(%rsp), %rdi
callq 0x1e4740
movq 0x58(%r15), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2092ce
movq %rax, %rbx
movq 0x58(%r15), %r15
addq $0x8, %r15
cmpq %rax, %r15
je 0x1ffcbb
movl $0xfffffc18, %eax       # imm = 0xFFFFFC18
addl 0x48(%rbx), %eax
cmpl $0x1e, %eax
ja 0x1ffcb4
movl %eax, %eax
leaq 0x33f4d4(%rip), %rcx    # 0x53f098
movq (%rcx,%rax,8), %r12
leaq 0x33f5c1(%rip), %rcx    # 0x53f190
movq (%rcx,%rax,8), %r13
movl $0x38, %edi
callq 0x11e0f0
movsd 0x30(%rsp), %xmm0
addsd 0x48(%rsp), %xmm0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %r12, (%rax)
movq %r13, 0x8(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x28(%rax)
movsd %xmm0, 0x30(%rax)
jmp 0x1ffcb6
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 0x1ffce0
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19437a(%rip), %rsi    # 0x393fbf
leaq 0x19437a(%rip), %rdx    # 0x393fc6
leaq 0x10(%rsp), %rdi
callq 0x1e4740
movq 0x58(%r15), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2092ce
movq %rax, %rbx
movq 0x58(%r15), %r15
addq $0x8, %r15
cmpq %rax, %r15
je 0x1ffcbb
movl $0xfffffc18, %eax       # imm = 0xFFFFFC18
addl 0x48(%rbx), %eax
cmpl $0x1e, %eax
ja 0x1ffcb4
movl %eax, %eax
leaq 0x33f5fe(%rip), %rcx    # 0x53f288
movq (%rcx,%rax,8), %r12
leaq 0x33f6eb(%rip), %rcx    # 0x53f380
movq (%rcx,%rax,8), %r13
movl $0x38, %edi
callq 0x11e0f0
movsd 0x30(%rsp), %xmm0
mulsd 0x48(%rsp), %xmm0
jmp 0x1ffb23
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1ffcd2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
cmpq %rbx, %r15
jne 0x200002
jmp 0x20009f
movl %r12d, %edx
xorl $0x5, %edx
movl %eax, %edi
orl %edx, %edi
sete %r8b
orl %ecx, %edi
jne 0x1ffd40
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1942b5(%rip), %rsi    # 0x393fb7
leaq 0x1942b5(%rip), %rdx    # 0x393fbe
leaq 0x10(%rsp), %rdi
callq 0x1e4740
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 0x20e656
jmp 0x1ffec4
movl %r13d, %edi
xorl $0x5, %edi
orl %edi, %esi
movl %ebp, %r9d
xorl $0x5, %r9d
orl %esi, %r9d
jne 0x1ffda2
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x194253(%rip), %rsi    # 0x393fb7
leaq 0x194253(%rip), %rdx    # 0x393fbe
leaq 0x10(%rsp), %rdi
callq 0x1e4740
movsd 0x48(%rsp), %xmm0
divsd 0x30(%rsp), %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x20e656
jmp 0x1ffec4
cmpl $0x5, %ebp
setne %sil
xorb $0x1, %r8b
orb %sil, %r8b
jne 0x1ffe00
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1941fd(%rip), %rsi    # 0x393fbf
leaq 0x1941fd(%rip), %rdx    # 0x393fc6
leaq 0x10(%rsp), %rdi
callq 0x1e4740
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 0x20e656
jmp 0x1ffec4
orl %edx, %edi
sete %dl
orl %ecx, %edi
jne 0x1ffe60
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19419e(%rip), %rsi    # 0x393fb7
leaq 0x19419e(%rip), %rdx    # 0x393fbe
leaq 0x10(%rsp), %rdi
callq 0x1e4740
movsd 0x30(%rsp), %xmm1
mulsd 0x48(%rsp), %xmm1
movsd 0x1891e2(%rip), %xmm0   # 0x389020
divsd %xmm1, %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x20e656
jmp 0x1ffec4
cmpl $0x5, %ebp
setne %sil
xorb $0x1, %dl
orb %sil, %dl
jne 0x1ffeea
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x194140(%rip), %rsi    # 0x393fbf
leaq 0x194140(%rip), %rdx    # 0x393fc6
leaq 0x10(%rsp), %rdi
callq 0x1e4740
movsd 0x30(%rsp), %xmm1
mulsd 0x48(%rsp), %xmm1
movsd 0x18917c(%rip), %xmm0   # 0x389020
divsd %xmm1, %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x20afa6
movl %eax, %ebx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1ffedd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
testb %bl, %bl
jne 0x200002
jmp 0x20009f
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 0x1fff80
cmpl $0x2, %r12d
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x1940d0(%rip), %rax    # 0x394007
leaq 0x1940d1(%rip), %rsi    # 0x39400f
cmoveq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x11e210
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movsd 0x30(%rsp), %xmm0
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x20e656
testb %al, %al
je 0x20011e
movq 0x8(%rsp), %r15
jmp 0x200121
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
callq 0x231e60
movq 0x60(%r15), %rdi
movq %rbx, %rsi
callq 0x214ed4
movq %rax, %rbx
movq 0x60(%r15), %r14
addq $0x8, %r14
cmpq %rax, %r14
je 0x1fffe2
movl 0x48(%rbx), %eax
leaq 0x54(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movsd 0x30(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movq 0x40(%rsp), %rcx
callq 0x2321c8
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ffffd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
cmpq %rbx, %r14
je 0x20000c
movq 0x8(%rsp), %r15
jmp 0x2000a2
movq 0x48(%r15), %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x20009f
addq $0x8, %rax
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 0x200027
cmpq %rax, %rdx
je 0x20009f
cmpl 0x20(%rdx), %r13d
jl 0x20009f
movq 0x28(%rdx), %rbx
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 0x200054
cmpq %rax, %rdx
je 0x20009f
cmpl 0x20(%rdx), %r12d
jl 0x20009f
movq 0x28(%rdx), %r14
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 0x20007e
cmpq %rax, %rdx
je 0x20009f
cmpl 0x20(%rdx), %ebp
jge 0x2000b4
xorl %r15d, %r15d
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rdx), %r12
movl $0x58, %edi
callq 0x11e0f0
movq %rax, %r15
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x305d78(%rip), %rax    # 0x505e50
movq %rax, (%r15)
leaq 0x305dbe(%rip), %rax    # 0x505ea0
movq %rax, 0x8(%r15)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%r15)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%r15)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x30(%r15)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%r15)
movq %rbx, 0x40(%r15)
movq %r14, 0x48(%r15)
movq %r12, 0x50(%r15)
jmp 0x2000a2
xorl %r15d, %r15d
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x2000a2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x2000a2
jmp 0x20016a
jmp 0x20016a
jmp 0x20016a
jmp 0x200165
jmp 0x20016a
jmp 0x200165
jmp 0x20016a
jmp 0x200165
jmp 0x20016a
jmp 0x200165
jmp 0x20016a
jmp 0x200165
jmp 0x200165
jmp 0x20016a
jmp 0x200165
jmp 0x20016a
jmp 0x200165
jmp 0x20016a
movq %rax, %rbx
jmp 0x200197
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
jne 0x20018a
jmp 0x200197
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x200197
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
nop