// File: /workspace/github_cpp_makefile_star2_O3/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 0x1fe777
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x1fe777
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1fe76f
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x1fe777
movq %r14, %rdi
callq 0x1ea63e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1fe7a5
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x1fe7a5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1fe79d
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x1fe7a5
movq %rbx, %rdi
callq 0x1ea63e
movq $0x0, 0x8(%rsp)
movq 0x68(%r15), %rax
cmpb $0x1, 0xd6(%rax)
jne 0x1fee78
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 0x1fe861
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19579d(%rip), %rsi    # 0x393f87
leaq 0x19579d(%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 0x1fea60
movl $0xfffffc18, %eax       # imm = 0xFFFFFC18
addl 0x48(%rbx), %eax
cmpl $0x1e, %eax
ja 0x1fea59
movl %eax, %eax
leaq 0x340a51(%rip), %rcx    # 0x53f288
movq (%rcx,%rax,8), %r12
leaq 0x340b3e(%rip), %rcx    # 0x53f380
movq (%rcx,%rax,8), %r13
movl $0x38, %edi
callq 0x11e0f0
movsd 0x30(%rsp), %xmm0
addsd 0x48(%rsp), %xmm0
jmp 0x1fea2d
movl %r12d, %edx
xorl $0x3, %edx
orl %edx, %eax
orl %ecx, %eax
jne 0x1fe8f8
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1956fe(%rip), %rsi    # 0x393f7f
leaq 0x1956fe(%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 0x1fea60
movl $0xfffffc18, %eax       # imm = 0xFFFFFC18
addl 0x48(%rbx), %eax
cmpl $0x1e, %eax
ja 0x1fea59
movl %eax, %eax
leaq 0x3409ba(%rip), %rcx    # 0x53f288
movq (%rcx,%rax,8), %r12
leaq 0x340aa7(%rip), %rcx    # 0x53f380
movq (%rcx,%rax,8), %r13
movl $0x38, %edi
callq 0x11e0f0
movsd 0x30(%rsp), %xmm0
subsd 0x48(%rsp), %xmm0
jmp 0x1fea2d
movl %r13d, %eax
xorl $0x3, %eax
orl %edx, %eax
movl %ebp, %ecx
xorl $0x3, %ecx
orl %eax, %ecx
jne 0x1fe994
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x195662(%rip), %rsi    # 0x393f7f
leaq 0x195662(%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 0x1fea60
movl $0xfffffc18, %eax       # imm = 0xFFFFFC18
addl 0x48(%rbx), %eax
cmpl $0x1e, %eax
ja 0x1fea59
movl %eax, %eax
leaq 0x34091e(%rip), %rcx    # 0x53f288
movq (%rcx,%rax,8), %r12
leaq 0x340a0b(%rip), %rcx    # 0x53f380
movq (%rcx,%rax,8), %r13
movl $0x38, %edi
callq 0x11e0f0
movsd 0x48(%rsp), %xmm0
subsd 0x30(%rsp), %xmm0
jmp 0x1fea2d
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 0x1fea85
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1955fc(%rip), %rsi    # 0x393fbf
leaq 0x1955fc(%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 0x1fea60
movl $0xfffffc18, %eax       # imm = 0xFFFFFC18
addl 0x48(%rbx), %eax
cmpl $0x1e, %eax
ja 0x1fea59
movl %eax, %eax
leaq 0x340880(%rip), %rcx    # 0x53f288
movq (%rcx,%rax,8), %r12
leaq 0x34096d(%rip), %rcx    # 0x53f380
movq (%rcx,%rax,8), %r13
movl $0x38, %edi
callq 0x11e0f0
movsd 0x30(%rsp), %xmm0
mulsd 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 0x1fea5b
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1fea77
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
cmpq %rbx, %r15
jne 0x1feefa
jmp 0x1fef97
movl %r12d, %r10d
xorl $0x5, %r10d
movl %eax, %ecx
orl %r10d, %ecx
sete %r8b
orl %edx, %ecx
jne 0x1feae7
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19550e(%rip), %rsi    # 0x393fb7
leaq 0x19550e(%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 0x1fed3a
movl %r13d, %ecx
xorl $0x5, %ecx
orl %ecx, %r9d
sete %dil
movl %ebp, %esi
xorl $0x5, %esi
orl %esi, %r9d
jne 0x1feb58
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1954b1(%rip), %rsi    # 0x393fbf
leaq 0x1954b1(%rip), %rdx    # 0x393fc6
leaq 0x10(%rsp), %rdi
callq 0x1e4740
movsd 0x30(%rsp), %xmm1
mulsd 0x48(%rsp), %xmm1
movsd 0x18a4ed(%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 0x1fed3a
orl %ecx, %r10d
sete %r9b
orl %esi, %r10d
jne 0x1febb2
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x195443(%rip), %rsi    # 0x393fb7
leaq 0x195443(%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 0x1fed3a
cmpl $0x5, %ebp
setne %r10b
xorb $0x1, %r8b
orb %r10b, %r8b
jne 0x1fec10
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19544d(%rip), %rsi    # 0x39401f
leaq 0x19544d(%rip), %rdx    # 0x394026
leaq 0x10(%rsp), %rdi
callq 0x1e4740
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 0x20e656
jmp 0x1fed3a
cmpl $0x4, %ebp
setne %r8b
xorb $0x1, %r9b
orb %r8b, %r9b
jne 0x1fec7a
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1953ef(%rip), %rsi    # 0x39401f
leaq 0x1953ef(%rip), %rdx    # 0x394026
leaq 0x10(%rsp), %rdi
callq 0x1e4740
movsd 0x30(%rsp), %xmm1
mulsd 0x48(%rsp), %xmm1
movsd 0x18a3cb(%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 0x1fed3a
cmpl $0x2, %ebp
setne %r8b
xorb $0x1, %dil
orb %dil, %r8b
jne 0x1fecdd
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x195709(%rip), %rsi    # 0x3943a3
leaq 0x19570d(%rip), %rdx    # 0x3943ae
leaq 0x10(%rsp), %rdi
callq 0x1e4740
movsd 0x18a36d(%rip), %xmm0   # 0x389020
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 0x22a8b6
jmp 0x1fed3a
cmpl $0x3, %ebp
setne %r8b
orb %r8b, %dil
jne 0x1fed60
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1956e6(%rip), %rsi    # 0x3943df
leaq 0x1956ea(%rip), %rdx    # 0x3943ea
leaq 0x10(%rsp), %rdi
callq 0x1e4740
movsd 0x18a30e(%rip), %xmm0   # 0x389020
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 0x22a8b6
movl %eax, %ebx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1fed53
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
testb %bl, %bl
jne 0x1feefa
jmp 0x1fef97
movsd 0x30(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
ucomisd %xmm1, %xmm0
setp %dil
setne %r8b
orb %dil, %r8b
orl %edx, %eax
setne %al
orb %r8b, %al
jne 0x1feded
movl %r12d, %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x1fee78
cmpl $0x2, %r12d
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x195253(%rip), %rax    # 0x394007
leaq 0x195254(%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
jmp 0x1fee66
ucomisd %xmm1, %xmm0
setnp %al
sete %dl
andb %al, %dl
orl %esi, %ecx
movl %r12d, %eax
andl $-0x2, %eax
xorl $0x2, %eax
orl %ecx, %eax
sete %al
andb %dl, %al
cmpb $0x1, %al
jne 0x1fee78
cmpl $0x2, %r12d
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x195140(%rip), %rax    # 0x393f6f
leaq 0x195161(%rip), %rsi    # 0x393f97
cmoveq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x11e210
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
movsd 0x30(%rsp), %xmm0
callq 0x20afa6
testb %al, %al
je 0x1ff016
movq 0x8(%rsp), %r15
jmp 0x1ff019
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
callq 0x22a930
movq 0x60(%r15), %rdi
movq %rbx, %rsi
callq 0x214ed4
movq %rax, %rbx
movq 0x60(%r15), %r14
addq $0x8, %r14
cmpq %rax, %r14
movsd 0x30(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
je 0x1feeda
movl 0x48(%rbx), %eax
leaq 0x54(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x22ac98
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1feef5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
cmpq %rbx, %r14
je 0x1fef04
movq 0x8(%rsp), %r15
jmp 0x1fef9a
movq 0x48(%r15), %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x1fef97
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 0x1fef1f
cmpq %rax, %rdx
je 0x1fef97
cmpl 0x20(%rdx), %r13d
jl 0x1fef97
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 0x1fef4c
cmpq %rax, %rdx
je 0x1fef97
cmpl 0x20(%rdx), %r12d
jl 0x1fef97
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 0x1fef76
cmpq %rax, %rdx
je 0x1fef97
cmpl 0x20(%rdx), %ebp
jge 0x1fefac
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 0x2fff20(%rip), %rax    # 0x4feef0
movq %rax, (%r15)
leaq 0x2fff66(%rip), %rax    # 0x4fef40
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 0x1fef9a
xorl %r15d, %r15d
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1fef9a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x1fef9a
jmp 0x1ff06e
jmp 0x1ff06e
jmp 0x1ff06e
jmp 0x1ff06e
jmp 0x1ff06e
jmp 0x1ff069
jmp 0x1ff06e
jmp 0x1ff069
jmp 0x1ff06e
jmp 0x1ff069
jmp 0x1ff06e
jmp 0x1ff069
jmp 0x1ff06e
jmp 0x1ff069
jmp 0x1ff06e
jmp 0x1ff069
jmp 0x1ff06e
jmp 0x1ff069
jmp 0x1ff069
jmp 0x1ff06e
jmp 0x1ff069
jmp 0x1ff06e
jmp 0x1ff069
jmp 0x1ff06e
movq %rax, %rbx
jmp 0x1ff09b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
jne 0x1ff08e
jmp 0x1ff09b
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ff09b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
nop