// File: /workspace/github_cpp_makefile_star2_O2/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 $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x8(%rdx), %rax
movq %rax, 0x60(%rsp)
movq (%rdx), %r12
movq 0x8(%rdx), %r15
movq (%r12), %rax
movq %r12, %rdi
callq *0x40(%rax)
movsd %xmm0, 0x8(%rsp)
movq (%r12), %rax
movq %r12, %rdi
callq *0x48(%rax)
movq %rax, 0x58(%rsp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x40(%rax)
movsd %xmm0, 0x10(%rsp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x48(%rax)
movq %rax, %rbp
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movl %eax, %r12d
movl %eax, 0x4c(%rsp)
movl (%r13), %r13d
movl %r13d, 0x48(%rsp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movl %eax, %r15d
movl %eax, 0x44(%rsp)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x1ad9c8
movq 0x8(%rbx), %rdi
movq 0x60(%rsp), %rsi
callq 0x1ad9c8
movl %r12d, %edx
movq %rbx, %r12
movl %r13d, %ecx
movq 0x58(%rsp), %r13
andq $0x0, (%rsp)
movq 0x68(%rbx), %rax
cmpb $0x1, 0xd6(%rax)
jne 0x1a8e91
movq %r13, %r14
movq %rbp, %rbx
movl %edx, %eax
xorl $0x2, %eax
movl %ecx, %esi
xorl $0x2, %esi
orl %eax, %esi
movl %r15d, %edi
xorl $0x2, %edi
orl %edi, %esi
jne 0x1a8a36
leaq 0x130c37(%rip), %rsi    # 0x2d9637
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b833a
jmp 0x1a8d69
movl %ecx, %esi
xorl $0x3, %esi
orl %esi, %eax
orl %edi, %eax
jne 0x1a8a7e
leaq 0x130be7(%rip), %rsi    # 0x2d962f
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b833a
jmp 0x1a8d69
movl %edx, %eax
xorl $0x3, %eax
orl %esi, %eax
movl %r15d, %esi
xorl $0x3, %esi
orl %eax, %esi
jne 0x1a8acc
leaq 0x130b99(%rip), %rsi    # 0x2d962f
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x127016
movsd 0x10(%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b833a
jmp 0x1a8d69
movl %edx, %eax
xorl $0x4, %eax
movl %ecx, %r9d
xorl $0x4, %r9d
movl %eax, %esi
orl %r9d, %esi
movl %r15d, %r11d
xorl $0x4, %r11d
orl %r11d, %esi
jne 0x1a8b26
leaq 0x130b7f(%rip), %rsi    # 0x2d966f
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b833a
jmp 0x1a8d69
movl %ecx, %r10d
xorl $0x5, %r10d
movl %eax, %esi
orl %r10d, %esi
sete %r8b
orl %r11d, %esi
jne 0x1a8b78
leaq 0x130b25(%rip), %rsi    # 0x2d9667
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b833a
jmp 0x1a8d69
movl %edx, %ebp
xorl $0x5, %ebp
orl %ebp, %r9d
sete %dil
movl %r15d, %esi
xorl $0x5, %esi
orl %esi, %r9d
jne 0x1a8bd8
leaq 0x130ad9(%rip), %rsi    # 0x2d966f
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
movsd 0x125607(%rip), %xmm0   # 0x2ce1c0
divsd %xmm1, %xmm0
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b833a
jmp 0x1a8d69
orl %ebp, %r10d
sete %r9b
orl %esi, %r10d
jne 0x1a8c21
leaq 0x130a7c(%rip), %rsi    # 0x2d9667
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x127016
movsd 0x10(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b833a
jmp 0x1a8d69
cmpl $0x5, %r15d
setne %r10b
xorb $0x1, %r8b
orb %r10b, %r8b
jne 0x1a8c6f
leaq 0x130a96(%rip), %rsi    # 0x2d96cf
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b833a
jmp 0x1a8d69
cmpl $0x4, %r15d
setne %r8b
xorb $0x1, %r9b
orb %r8b, %r9b
jne 0x1a8cc9
leaq 0x130a48(%rip), %rsi    # 0x2d96cf
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x127016
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
movsd 0x125516(%rip), %xmm0   # 0x2ce1c0
divsd %xmm1, %xmm0
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b833a
jmp 0x1a8d69
cmpl $0x2, %r15d
setne %r8b
xorb $0x1, %dil
orb %dil, %r8b
jne 0x1a8d1c
leaq 0x130d72(%rip), %rsi    # 0x2d9a53
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x127016
movsd 0x1254c8(%rip), %xmm0   # 0x2ce1c0
divsd 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
movsd 0x10(%rsp), %xmm1
callq 0x1dbff2
jmp 0x1a8d69
cmpl $0x3, %r15d
setne %r8b
orb %r8b, %dil
jne 0x1a8d82
leaq 0x130d5f(%rip), %rsi    # 0x2d9a8f
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x127016
movsd 0x125479(%rip), %xmm0   # 0x2ce1c0
divsd 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
movsd 0x10(%rsp), %xmm1
callq 0x1dbff2
movl %eax, %ebx
leaq 0x18(%rsp), %rdi
callq 0x118648
testb %bl, %bl
jne 0x1a8ed4
jmp 0x1a8f5f
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm1, %xmm0
setp %dil
setne %r8b
orb %dil, %r8b
orl %r11d, %eax
setne %al
orb %r8b, %al
jne 0x1a8e0a
movl %ecx, %eax
andl $-0x2, %eax
cmpl $0x2, %eax
movq %rbx, %rbp
movq %r14, %r13
jne 0x1a8e91
leaq 0x28(%rsp), %rax
andq $0x0, -0x8(%rax)
cmpl $0x2, %ecx
movq %rax, -0x10(%rax)
movb $0x0, (%rax)
leaq 0x1308e0(%rip), %rax    # 0x2d96b7
leaq 0x1308e1(%rip), %rsi    # 0x2d96bf
cmoveq %rax, %rsi
leaq 0x18(%rsp), %rdi
callq 0x118600
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movsd 0x8(%rsp), %xmm0
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b833a
jmp 0x1a8e80
ucomisd %xmm1, %xmm0
setnp %al
sete %dil
andb %al, %dil
orl %esi, %ebp
movl %ecx, %eax
andl $-0x2, %eax
xorl $0x2, %eax
orl %ebp, %eax
sete %al
andb %dil, %al
cmpb $0x1, %al
movq %rbx, %rbp
movq %r14, %r13
jne 0x1a8e91
leaq 0x28(%rsp), %rax
andq $0x0, -0x8(%rax)
cmpl $0x2, %ecx
movq %rax, -0x10(%rax)
movb $0x0, (%rax)
leaq 0x1307d0(%rip), %rax    # 0x2d961f
leaq 0x1307f1(%rip), %rsi    # 0x2d9647
cmoveq %rax, %rsi
leaq 0x18(%rsp), %rdi
callq 0x118600
leaq 0x18(%rsp), %rsi
movq %rsp, %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
movsd 0x8(%rsp), %xmm0
callq 0x1b47e0
testb %al, %al
je 0x1a8f73
movq (%rsp), %rbx
jmp 0x1a8f75
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %r8d
callq 0x1dc058
movq %rsp, %r8
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movsd 0x8(%rsp), %xmm0
movq %rbp, %rcx
movsd 0x10(%rsp), %xmm1
callq 0x1dbff2
movl %eax, %ebx
leaq 0x18(%rsp), %rdi
callq 0x118648
testb %bl, %bl
je 0x1a8edd
movq (%rsp), %rbx
jmp 0x1a8f61
leaq 0x18(%rsp), %rdx
andq $0x0, (%rdx)
andq $0x0, 0x38(%rsp)
andq $0x0, 0x50(%rsp)
leaq 0x4c(%rsp), %rsi
movq %r12, %rdi
callq 0x1b28a2
testb %al, %al
je 0x1a8f5f
leaq 0x48(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %r12, %rdi
callq 0x1b28a2
testb %al, %al
je 0x1a8f5f
leaq 0x44(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %r12, %rdi
callq 0x1b28a2
testb %al, %al
je 0x1a8f5f
movq 0x8(%r12), %rdi
movq 0x18(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x50(%rsp), %r9
movq %r13, %rsi
movsd 0x8(%rsp), %xmm0
movq %rbp, %rdx
movsd 0x10(%rsp), %xmm1
callq 0x1e095e
movq %rax, %rbx
jmp 0x1a8f61
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
leaq 0x18(%rsp), %rdi
callq 0x118648
jmp 0x1a8f61
jmp 0x1a8fb8
jmp 0x1a8fb8
jmp 0x1a8fb8
jmp 0x1a8fb8
jmp 0x1a8fb8
jmp 0x1a8fb3
jmp 0x1a8fb8
jmp 0x1a8fb3
jmp 0x1a8fb8
jmp 0x1a8fb3
jmp 0x1a8fb8
jmp 0x1a8fb3
jmp 0x1a8fb8
jmp 0x1a8fb3
jmp 0x1a8fb8
jmp 0x1a8fb3
jmp 0x1a8fb8
jmp 0x1a8fb3
jmp 0x1a8fb8
jmp 0x1a8fb3
jmp 0x1a8fb8
jmp 0x1a8fb3
jmp 0x1a8fb8
jmp 0x1a8fb3
jmp 0x1a8fb8
movq %rax, %rbx
jmp 0x1a8fc5
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop