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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c) +/- (v1 / c) --> (vovoc) (v0 +/- v1) / c
                  else if (
                            (std::equal_to<T>()(c0,c1)) &&
                            (details::e_div == o0)      &&
                            (details::e_div == 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<vtype, vtype, ctype>(expr_gen, specfunc, v0, v1, c0, result);

                     exprtk_debug(("(v0 / c) +/- (v1 / c) --> (vovoc) (v0 +/- v1) / c\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, v1, c1, 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, v1, c1, 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 0x205add
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x205add
movq (%r14), %rdi
testq %rdi, %rdi
je 0x205ad5
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x205add
movq %r14, %rdi
callq 0x1f1690
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x205b0b
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x205b0b
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x205b03
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x205b0b
movq %rbx, %rdi
callq 0x1f1690
movq $0x0, 0x8(%rsp)
movq 0x68(%r15), %rax
cmpb $0x1, 0xd6(%rax)
jne 0x2060fc
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 0x205bb0
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b73e3(%rip), %rsi    # 0x3bcf2f
leaq 0x1b73e3(%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
movsd 0x30(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
je 0x205d44
addsd %xmm1, %xmm0
movl 0x48(%rbx), %eax
leaq 0x54(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x216cf2
jmp 0x205d3f
movl %r12d, %edx
xorl $0x3, %edx
orl %edx, %eax
orl %ecx, %eax
jne 0x205c30
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b735b(%rip), %rsi    # 0x3bcf27
leaq 0x1b735b(%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
movsd 0x30(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
je 0x205d44
subsd %xmm1, %xmm0
movl 0x48(%rbx), %eax
leaq 0x54(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x216cf2
jmp 0x205d3f
movl %r13d, %eax
xorl $0x3, %eax
orl %edx, %eax
movl %ebp, %ecx
xorl $0x3, %ecx
orl %eax, %ecx
jne 0x205cb5
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b72d6(%rip), %rsi    # 0x3bcf27
leaq 0x1b72d6(%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
movsd 0x30(%rsp), %xmm1
movsd 0x48(%rsp), %xmm0
je 0x205d44
subsd %xmm1, %xmm0
movl 0x48(%rbx), %eax
leaq 0x54(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x216cf2
jmp 0x205d3f
movl %r13d, %eax
xorl $0x4, %eax
movl %r12d, %r9d
xorl $0x4, %r9d
movl %eax, %ecx
orl %r9d, %ecx
movl %ebp, %edx
xorl $0x4, %edx
orl %edx, %ecx
jne 0x205d69
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b7283(%rip), %rsi    # 0x3bcf67
leaq 0x1b7283(%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
movsd 0x30(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
je 0x205d44
mulsd %xmm1, %xmm0
movl 0x48(%rbx), %eax
leaq 0x54(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x216cf2
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x205d5b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
cmpq %rbx, %r12
jne 0x20617e
jmp 0x2062e0
movl %r12d, %r10d
xorl $0x5, %r10d
movl %eax, %ecx
orl %r10d, %ecx
sete %r8b
orl %edx, %ecx
jne 0x205dcb
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b71d2(%rip), %rsi    # 0x3bcf5f
leaq 0x1b71d2(%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 0x20601e
movl %r13d, %ecx
xorl $0x5, %ecx
orl %ecx, %r9d
sete %dil
movl %ebp, %esi
xorl $0x5, %esi
orl %esi, %r9d
jne 0x205e3c
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b7175(%rip), %rsi    # 0x3bcf67
leaq 0x1b7175(%rip), %rdx    # 0x3bcf6e
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movsd 0x30(%rsp), %xmm1
mulsd 0x48(%rsp), %xmm1
movsd 0x1ac209(%rip), %xmm0   # 0x3b2020
divsd %xmm1, %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x216a0c
jmp 0x20601e
orl %ecx, %r10d
sete %r9b
orl %esi, %r10d
jne 0x205e96
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b7107(%rip), %rsi    # 0x3bcf5f
leaq 0x1b7107(%rip), %rdx    # 0x3bcf66
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
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 0x216a0c
jmp 0x20601e
cmpl $0x5, %ebp
setne %r10b
xorb $0x1, %r8b
orb %r10b, %r8b
jne 0x205ef4
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b7111(%rip), %rsi    # 0x3bcfc7
leaq 0x1b7111(%rip), %rdx    # 0x3bcfce
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 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x216a0c
jmp 0x20601e
cmpl $0x4, %ebp
setne %r8b
xorb $0x1, %r9b
orb %r8b, %r9b
jne 0x205f5e
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b70b3(%rip), %rsi    # 0x3bcfc7
leaq 0x1b70b3(%rip), %rdx    # 0x3bcfce
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movsd 0x30(%rsp), %xmm1
mulsd 0x48(%rsp), %xmm1
movsd 0x1ac0e7(%rip), %xmm0   # 0x3b2020
divsd %xmm1, %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x216a0c
jmp 0x20601e
cmpl $0x2, %ebp
setne %r8b
xorb $0x1, %dil
orb %dil, %r8b
jne 0x205fc1
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b73cd(%rip), %rsi    # 0x3bd34b
leaq 0x1b73d1(%rip), %rdx    # 0x3bd356
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movsd 0x1ac089(%rip), %xmm0   # 0x3b2020
divsd 0x30(%rsp), %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
movsd 0x48(%rsp), %xmm1
callq 0x240f24
jmp 0x20601e
cmpl $0x3, %ebp
setne %r8b
orb %r8b, %dil
jne 0x206044
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b73aa(%rip), %rsi    # 0x3bd387
leaq 0x1b73ae(%rip), %rdx    # 0x3bd392
leaq 0x10(%rsp), %rdi
callq 0x1eabb8
movsd 0x1ac02a(%rip), %xmm0   # 0x3b2020
divsd 0x30(%rsp), %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
movsd 0x48(%rsp), %xmm1
callq 0x240f24
movl %eax, %ebx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x206037
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
testb %bl, %bl
jne 0x20617e
jmp 0x2062e0
movsd 0x30(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
ucomisd %xmm1, %xmm0
setnp %dil
sete %r8b
andb %dil, %r8b
orl %edx, %eax
movl %r12d, %edx
andl $-0x2, %edx
xorl $0x2, %edx
orl %edx, %eax
sete %al
andb %r8b, %al
cmpb $0x1, %al
jne 0x2060ab
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
cmpl $0x3, %r12d
je 0x2062f5
cmpl $0x2, %r12d
jne 0x206368
leaq 0x1b6f09(%rip), %rsi    # 0x3bcfaf
jmp 0x2062fc
ucomisd %xmm1, %xmm0
setnp %al
sete %dil
andb %al, %dil
orl %esi, %ecx
orl %edx, %ecx
sete %al
andb %dil, %al
cmpb $0x1, %al
jne 0x2060fc
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
cmpl $0x3, %r12d
je 0x20632a
cmpl $0x2, %r12d
jne 0x206368
leaq 0x1b6e20(%rip), %rsi    # 0x3bcf17
jmp 0x206331
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
callq 0x240f9e
movq 0x60(%r15), %rdi
movq %rbx, %rsi
callq 0x21d4c8
movq %rax, %rbx
movq 0x60(%r15), %r14
addq $0x8, %r14
cmpq %rax, %r14
movsd 0x30(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
je 0x20615e
movl 0x48(%rbx), %eax
leaq 0x54(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x241306
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x206179
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
cmpq %rbx, %r14
je 0x206188
movq 0x8(%rsp), %r15
jmp 0x2062e3
movq 0x48(%r15), %rax
movq 0x10(%rax), %rcx
addq $0x8, %rax
movq %rax, %rdx
testq %rcx, %rcx
je 0x2061ba
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 0x2061a2
movq %rax, %rsi
cmpq %rax, %rdx
je 0x2061cd
cmpl 0x20(%rdx), %r13d
cmovlq %rax, %rdx
movq %rdx, %rsi
cmpq %rsi, %rax
je 0x2061d8
movq 0x28(%rsi), %rbx
jmp 0x2061da
xorl %ebx, %ebx
cmpq %rsi, %rax
je 0x2062e0
movq %rax, %rdx
testq %rcx, %rcx
je 0x206209
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 0x2061f1
movq %rax, %rsi
cmpq %rax, %rdx
je 0x20621c
cmpl 0x20(%rdx), %r12d
cmovlq %rax, %rdx
movq %rdx, %rsi
cmpq %rsi, %rax
je 0x206227
movq 0x28(%rsi), %r14
jmp 0x20622a
xorl %r14d, %r14d
cmpq %rsi, %rax
je 0x2062e0
movq %rax, %rdx
testq %rcx, %rcx
je 0x206255
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 0x20623e
movq %rax, %rcx
cmpq %rax, %rdx
je 0x206267
cmpl 0x20(%rdx), %ebp
cmovlq %rax, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
je 0x206272
movq 0x28(%rcx), %r12
jmp 0x206275
xorl %r12d, %r12d
cmpq %rcx, %rax
je 0x2062e0
movl $0x58, %edi
callq 0x1200f0
movq %rax, %r15
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x332816(%rip), %rax    # 0x538ab0
movq %rax, (%r15)
leaq 0x33285c(%rip), %rax    # 0x538b00
movq %rax, 0x8(%r15)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%r15)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%r15)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%r15)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x38(%r15)
movq %rbx, 0x40(%r15)
movq %r14, 0x48(%r15)
movq %r12, 0x50(%r15)
jmp 0x2062e3
xorl %r15d, %r15d
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b6cbb(%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 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x216a0c
jmp 0x20635d
leaq 0x1b6c0e(%rip), %rsi    # 0x3bcf3f
leaq 0x10(%rsp), %rdi
callq 0x120210
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
movsd 0x30(%rsp), %xmm0
callq 0x2132b0
testb %al, %al
je 0x206368
movq 0x8(%rsp), %r15
jmp 0x20636b
xorl %r15d, %r15d
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x2062e3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x2062e3
jmp 0x2063c0
jmp 0x2063c0
jmp 0x2063c0
jmp 0x2063c0
jmp 0x2063c0
jmp 0x2063bb
jmp 0x2063c0
jmp 0x2063bb
jmp 0x2063c0
jmp 0x2063bb
jmp 0x2063c0
jmp 0x2063bb
jmp 0x2063c0
jmp 0x2063bb
jmp 0x2063c0
jmp 0x2063bb
jmp 0x2063c0
jmp 0x2063bb
jmp 0x2063bb
jmp 0x2063c0
jmp 0x2063bb
jmp 0x2063c0
jmp 0x2063bb
jmp 0x2063c0
movq %rax, %rbx
jmp 0x2063ed
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
jne 0x2063e0
jmp 0x2063ed
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2063ed
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
nop