// File: /workspace/github_cpp_makefile_star2_O3/Pyboon[P]sage/./Eigen/src/Core/products/TriangularSolverMatrix.h
// Function: Eigen::internal::triangular_solve_matrix<std::complex<double>, long, 1, 2, false, 0, 0>::run(long, long, std::complex<double> const*, long, std::complex<double>*, long, Eigen::internal::level3_blocking<std::complex<double>, std::complex<double>>&)
EIGEN_DONT_INLINE void triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor>::run(
    Index size, Index otherSize,
    const Scalar* _tri, Index triStride,
    Scalar* _other, Index otherStride,
    level3_blocking<Scalar,Scalar>& blocking)
  {
    Index cols = otherSize;

    typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> TriMapper;
    typedef blas_data_mapper<Scalar, Index, ColMajor> OtherMapper;
    TriMapper tri(_tri, triStride);
    OtherMapper other(_other, otherStride);

    typedef gebp_traits<Scalar,Scalar> Traits;

    enum {
      SmallPanelWidth   = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
      IsLower = (Mode&Lower) == Lower
    };

    Index kc = blocking.kc();                   // cache block size along the K direction
    Index mc = (std::min)(size,blocking.mc());  // cache block size along the M direction

    std::size_t sizeA = kc*mc;
    std::size_t sizeB = kc*cols;

    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());

    conj_if<Conjugate> conj;
    gebp_kernel<Scalar, Scalar, Index, OtherMapper, Traits::mr, Traits::nr, Conjugate, false> gebp_kernel;
    gemm_pack_lhs<Scalar, Index, TriMapper, Traits::mr, Traits::LhsProgress, TriStorageOrder> pack_lhs;
    gemm_pack_rhs<Scalar, Index, OtherMapper, Traits::nr, ColMajor, false, true> pack_rhs;

    // the goal here is to subdivise the Rhs panels such that we keep some cache
    // coherence when accessing the rhs elements
    std::ptrdiff_t l1, l2, l3;
    manage_caching_sizes(GetAction, &l1, &l2, &l3);
    Index subcols = cols>0 ? l2/(4 * sizeof(Scalar) * std::max<Index>(otherStride,size)) : 0;
    subcols = std::max<Index>((subcols/Traits::nr)*Traits::nr, Traits::nr);

    for(Index k2=IsLower ? 0 : size;
        IsLower ? k2<size : k2>0;
        IsLower ? k2+=kc : k2-=kc)
    {
      const Index actual_kc = (std::min)(IsLower ? size-k2 : k2, kc);

      // We have selected and packed a big horizontal panel R1 of rhs. Let B be the packed copy of this panel,
      // and R2 the remaining part of rhs. The corresponding vertical panel of lhs is split into
      // A11 (the triangular part) and A21 the remaining rectangular part.
      // Then the high level algorithm is:
      //  - B = R1                    => general block copy (done during the next step)
      //  - R1 = A11^-1 B             => tricky part
      //  - update B from the new R1  => actually this has to be performed continuously during the above step
      //  - R2 -= A21 * B             => GEPP

      // The tricky part: compute R1 = A11^-1 B while updating B from R1
      // The idea is to split A11 into multiple small vertical panels.
      // Each panel can be split into a small triangular part T1k which is processed without optimization,
      // and the remaining small part T2k which is processed using gebp with appropriate block strides
      for(Index j2=0; j2<cols; j2+=subcols)
      {
        Index actual_cols = (std::min)(cols-j2,subcols);
        // for each small vertical panels [T1k^T, T2k^T]^T of lhs
        for (Index k1=0; k1<actual_kc; k1+=SmallPanelWidth)
        {
          Index actualPanelWidth = std::min<Index>(actual_kc-k1, SmallPanelWidth);
          // tr solve
          for (Index k=0; k<actualPanelWidth; ++k)
          {
            // TODO write a small kernel handling this (can be shared with trsv)
            Index i  = IsLower ? k2+k1+k : k2-k1-k-1;
            Index rs = actualPanelWidth - k - 1; // remaining size
            Index s  = TriStorageOrder==RowMajor ? (IsLower ? k2+k1 : i+1)
                                                 :  IsLower ? i+1 : i-rs;

            Scalar a = (Mode & UnitDiag) ? Scalar(1) : Scalar(1)/conj(tri(i,i));
            for (Index j=j2; j<j2+actual_cols; ++j)
            {
              if (TriStorageOrder==RowMajor)
              {
                Scalar b(0);
                const Scalar* l = &tri(i,s);
                Scalar* r = &other(s,j);
                for (Index i3=0; i3<k; ++i3)
                  b += conj(l[i3]) * r[i3];

                other(i,j) = (other(i,j) - b)*a;
              }
              else
              {
                Scalar b = (other(i,j) *= a);
                Scalar* r = &other(s,j);
                const Scalar* l = &tri(s,i);
                for (Index i3=0;i3<rs;++i3)
                  r[i3] -= b * conj(l[i3]);
              }
            }
          }

          Index lengthTarget = actual_kc-k1-actualPanelWidth;
          Index startBlock   = IsLower ? k2+k1 : k2-k1-actualPanelWidth;
          Index blockBOffset = IsLower ? k1 : lengthTarget;

          // update the respective rows of B from other
          pack_rhs(blockB+actual_kc*j2, other.getSubMapper(startBlock,j2), actualPanelWidth, actual_cols, actual_kc, blockBOffset);

          // GEBP
          if (lengthTarget>0)
          {
            Index startTarget  = IsLower ? k2+k1+actualPanelWidth : k2-actual_kc;

            pack_lhs(blockA, tri.getSubMapper(startTarget,startBlock), actualPanelWidth, lengthTarget);

            gebp_kernel(other.getSubMapper(startTarget,j2), blockA, blockB+actual_kc*j2, lengthTarget, actualPanelWidth, actual_cols, Scalar(-1),
                        actualPanelWidth, actual_kc, 0, blockBOffset);
          }
        }
      }
      
      // R2 -= A21 * B => GEPP
      {
        Index start = IsLower ? k2+kc : 0;
        Index end   = IsLower ? size : k2-kc;
        for(Index i2=start; i2<end; i2+=mc)
        {
          const Index actual_mc = (std::min)(mc,end-i2);
          if (actual_mc>0)
          {
            pack_lhs(blockA, tri.getSubMapper(i2, IsLower ? k2 : k2-kc), actual_kc, actual_mc);

            gebp_kernel(other.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, Scalar(-1), -1, -1, 0, 0);
          }
        }
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %r9, -0x58(%rbp)
movq %r8, -0x98(%rbp)
movq %rcx, -0x90(%rbp)
movq %rdx, -0xf8(%rbp)
movq 0x10(%rbp), %rbx
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rdx
cmpq %rdi, %rax
cmovgeq %rdi, %rax
movq %rax, -0xb8(%rbp)
imulq %rdx, %rax
movq %rax, -0xa8(%rbp)
shrq $0x3c, %rax
jne 0x19a56
movq %rsi, %r14
movq %rdi, %r15
movq (%rbx), %rax
movq %rax, -0x68(%rbp)
testq %rax, %rax
je 0x1920a
xorl %eax, %eax
jmp 0x19257
movq -0xa8(%rbp), %rax
movq %rax, %rdi
shlq $0x4, %rdi
cmpq $0x2000, %rax           # imm = 0x2000
ja 0x19237
movq %rsp, %rax
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %rax
movq %rax, %rsp
movq %rax, -0x68(%rbp)
jmp 0x19257
movq %rdx, %r12
callq 0x3360
testb $0xf, %al
jne 0x19afa
movq %rax, -0x68(%rbp)
testq %rax, %rax
movq %r12, %rdx
je 0x19afc
movq %rax, -0x38(%rbp)
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFFF
movq %rdx, %rcx
imulq %r14, %rcx
movq %rcx, -0xa0(%rbp)
cmpq %rax, %rcx
ja 0x19a84
movq 0x8(%rbx), %rax
movq %rax, -0x80(%rbp)
testq %rax, %rax
je 0x19296
movq $0x0, -0x78(%rbp)
movq %r15, %rbx
jmp 0x192ee
movq -0xa0(%rbp), %rax
movq %rax, %rdi
shlq $0x4, %rdi
cmpq $0x2000, %rax           # imm = 0x2000
movq %r15, %rbx
ja 0x192ca
movq %rsp, %rcx
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %rcx
movq %rcx, %rsp
movq %rcx, -0x78(%rbp)
movq %rcx, -0x80(%rbp)
jmp 0x192ee
movq %rdx, %r12
callq 0x3360
testb $0xf, %al
jne 0x19b01
movq %rax, -0x80(%rbp)
movq %rax, -0x78(%rbp)
testq %rax, %rax
movq %r12, %rdx
je 0x19b20
movb 0x15fa4(%rip), %al      # 0x2f298
testb %al, %al
movq %r14, -0x88(%rbp)
movq %rdx, -0xb0(%rbp)
je 0x19ab2
testq %r14, %r14
jle 0x19347
movq 0x15f72(%rip), %rax     # 0x2f288
movq %rdx, %rsi
movq -0x58(%rbp), %rdx
cmpq %rbx, %rdx
movq %rbx, %rcx
cmovgq %rdx, %rcx
shlq $0x6, %rcx
xorl %edx, %edx
divq %rcx
movq %rsi, %rdx
leaq 0x3(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
movq %rcx, %rax
andq $-0x4, %rax
jmp 0x19349
xorl %eax, %eax
cmpq $0x5, %rax
movl $0x4, %ecx
cmovlq %rcx, %rax
movq %rax, -0xc0(%rbp)
testq %rbx, %rbx
jle 0x19a1b
movq %rbx, %rsi
shlq $0x4, %rsi
movq -0x98(%rbp), %rax
addq %rsi, %rax
movq %rax, -0x108(%rbp)
movq %rdx, %rax
shlq $0x4, %rax
negq %rax
movq %rax, -0x158(%rbp)
movq -0x58(%rbp), %rax
movq %rax, %rcx
imulq -0xc0(%rbp), %rcx
shlq $0x4, %rcx
movq %rcx, -0x168(%rbp)
shlq $0x4, %rax
movq %rax, -0x1d0(%rbp)
leaq -0x1(%rbx), %rax
movq -0x90(%rbp), %rcx
imulq %rcx, %rax
shlq $0x4, %rax
movq %rdx, %rdi
movq -0xf8(%rbp), %rdx
addq %rdx, %rsi
addq %rax, %rsi
movq %rsi, -0x120(%rbp)
movq %rcx, %rax
shlq $0x4, %rax
movq %rax, %rsi
xorq $-0x10, %rsi
imulq %rdi, %rsi
movq %rsi, -0x150(%rbp)
movq %rcx, %rsi
notq %rsi
shlq $0x6, %rsi
movq %rsi, -0x188(%rbp)
negq %rax
movq %rax, -0x1b0(%rbp)
movq %rbx, %rax
subq %rdi, %rax
movq %rcx, %rsi
movq %rax, -0x118(%rbp)
imulq %rax, %rsi
shlq $0x4, %rsi
addq %rdx, %rsi
movq %rdi, %rdx
movq %rsi, -0x110(%rbp)
movq %rdi, %rax
imulq %rcx, %rax
shlq $0x4, %rax
negq %rax
movq %rax, -0x148(%rbp)
movq -0xb8(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x170(%rbp)
cmpq %rbx, %rdx
movq %rbx, %r13
cmovlq %rdx, %r13
testq %r14, %r14
movq %r13, -0xd0(%rbp)
jle 0x198d1
movq %rbx, %rcx
subq %r13, %rcx
shlq $0x4, %rcx
movq -0xf8(%rbp), %rax
movq %rcx, -0x160(%rbp)
addq %rcx, %rax
movq %rax, -0x178(%rbp)
movq -0xc0(%rbp), %rax
movq -0x108(%rbp), %rcx
movq %rcx, -0xc8(%rbp)
xorl %edx, %edx
movq %rbx, -0x1b8(%rbp)
movq %rdx, -0xe8(%rbp)
subq %rdx, %r14
cmpq %r14, %rax
movq %r14, -0x1c0(%rbp)
cmovlq %rax, %r14
movq %r14, -0xd8(%rbp)
testq %r13, %r13
jle 0x1989b
movq -0xe8(%rbp), %rax
movq -0xd8(%rbp), %rcx
addq %rax, %rcx
movq %rcx, -0x1d8(%rbp)
movq %rax, %rcx
imulq %r13, %rcx
shlq $0x4, %rcx
addq -0x80(%rbp), %rcx
movq %rcx, -0x130(%rbp)
movq %rax, %rcx
imulq -0x58(%rbp), %rcx
shlq $0x4, %rcx
addq -0x98(%rbp), %rcx
movq -0x160(%rbp), %rax
movq %rcx, -0x190(%rbp)
addq %rcx, %rax
movq %rax, -0x180(%rbp)
movq -0x120(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0x128(%rbp)
movq %r13, %rcx
xorl %edx, %edx
movl $0x4, %eax
cmpq %rax, %rcx
movq %rcx, -0x198(%rbp)
cmovlq %rcx, %rax
cmpq $0x2, %rax
movl $0x1, %ecx
cmovgeq %rax, %rcx
movq %rcx, -0x1c8(%rbp)
subq %rdx, %r13
cmpq $0x4, %r13
movl $0x4, %ecx
cmovlq %r13, %rcx
movq %rcx, -0xf0(%rbp)
movq %r13, -0x1a0(%rbp)
testq %r13, %r13
movq %rdx, -0x138(%rbp)
jle 0x1974d
shlq $0x4, %rax
movq -0x128(%rbp), %rcx
subq %rax, %rcx
movq %rcx, -0x1a8(%rbp)
movq -0xe0(%rbp), %rcx
subq %rax, %rcx
movq %rcx, -0x100(%rbp)
xorl %ecx, %ecx
movq %rcx, -0x140(%rbp)
addq %rdx, %rcx
notq %rcx
addq %rbx, %rcx
movq %rcx, %rax
imulq -0x90(%rbp), %rax
shlq $0x4, %rax
addq -0xf8(%rbp), %rax
shlq $0x4, %rcx
movsd (%rcx,%rax), %xmm2
movq %rcx, -0x1e0(%rbp)
movsd 0x8(%rcx,%rax), %xmm3
xorps %xmm1, %xmm1
movsd 0x3dd2(%rip), %xmm0     # 0x1d3f0
callq 0x3180
movsd %xmm0, -0x1f8(%rbp)
movsd %xmm1, -0x1f0(%rbp)
cmpq $0x0, -0x1c0(%rbp)
jle 0x19713
movq -0x140(%rbp), %r15
notq %r15
addq -0xf0(%rbp), %r15
movq -0x1a8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0xe8(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
imulq -0x58(%rbp), %rdi
shlq $0x4, %rdi
movq -0x98(%rbp), %rax
movq -0x1e0(%rbp), %rcx
addq %rcx, %rax
addq %rax, %rdi
leaq -0x1f8(%rbp), %rsi
callq 0xff34
movupd (%rax), %xmm0
movapd %xmm0, -0x210(%rbp)
testq %r15, %r15
leaq -0x50(%rbp), %r14
jle 0x196ed
movq -0x100(%rbp), %r12
movq -0x70(%rbp), %r13
xorl %ebx, %ebx
movaps -0x210(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xff34
movupd (%r13), %xmm0
subpd -0x50(%rbp), %xmm0
movupd %xmm0, (%r13)
incq %rbx
addq $0x10, %r13
addq $0x10, %r12
cmpq %r15, %rbx
jl 0x196b6
movq -0x1e8(%rbp), %rdi
incq %rdi
movq -0x70(%rbp), %rax
addq -0x1d0(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq -0x1d8(%rbp), %rdi
jl 0x19664
movq -0x140(%rbp), %rcx
incq %rcx
movq -0x100(%rbp), %rax
addq -0x1b0(%rbp), %rax
movq %rax, -0x100(%rbp)
cmpq -0x1c8(%rbp), %rcx
movq -0x1b8(%rbp), %rbx
movq -0x138(%rbp), %rdx
jne 0x195d7
movq -0xf0(%rbp), %rcx
movq -0x1a0(%rbp), %r12
subq %rcx, %r12
movq %rbx, %r14
subq %rdx, %r14
subq %rcx, %r14
movq %r14, %rax
shlq $0x4, %rax
addq -0x190(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
subq $0x8, %rsp
leaq -0x59(%rbp), %rdi
movq -0x130(%rbp), %rsi
leaq -0x50(%rbp), %r15
movq %r15, %rdx
movq -0xd8(%rbp), %r8
movq -0xd0(%rbp), %r13
movq %r13, %r9
pushq %r12
callq 0x16af6
addq $0x10, %rsp
testq %r12, %r12
jle 0x1985f
movq -0x90(%rbp), %rax
imulq %rax, %r14
shlq $0x4, %r14
addq -0x178(%rbp), %r14
movq %r14, -0x50(%rbp)
movq %rax, -0x48(%rbp)
subq $0x8, %rsp
leaq -0x29(%rbp), %rdi
movq -0x68(%rbp), %r14
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %r15
movq -0xf0(%rbp), %r12
movq %r12, %rcx
movq %r15, %r8
xorl %r9d, %r9d
pushq $0x0
callq 0x16d14
addq $0x10, %rsp
movq -0x180(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
subq $0x8, %rsp
xorps %xmm1, %xmm1
leaq -0x2a(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq %r14, %rdx
movq -0x130(%rbp), %rcx
movq %r15, %r8
movq %r12, %r9
movsd 0x3bdc(%rip), %xmm0     # 0x1d420
pushq %r15
pushq $0x0
pushq %r13
pushq %r12
pushq -0xd8(%rbp)
movq -0x38(%rbp), %r14
callq 0x16d8e
addq $0x30, %rsp
movq -0x138(%rbp), %rdx
addq $0x4, %rdx
movq -0x198(%rbp), %rcx
addq $-0x4, %rcx
addq $-0x40, -0x128(%rbp)
movq -0xe0(%rbp), %rax
addq -0x188(%rbp), %rax
movq %rax, -0xe0(%rbp)
cmpq %r13, %rdx
jl 0x1955a
movq -0xc0(%rbp), %rax
movq -0xe8(%rbp), %rdx
addq %rax, %rdx
movq -0xc8(%rbp), %rcx
addq -0x168(%rbp), %rcx
movq %rcx, -0xc8(%rbp)
movq -0x88(%rbp), %r14
cmpq %r14, %rdx
jl 0x194b8
subq -0xb0(%rbp), %rbx
movq -0xb8(%rbp), %rax
jle 0x19a1b
movq -0x98(%rbp), %r14
movq -0x110(%rbp), %r15
movq -0x118(%rbp), %rdx
xorl %r13d, %r13d
movq %rdx, %r12
subq %rax, %rdx
cmovgeq %rax, %r12
testq %r12, %r12
jle 0x199ba
movq %rdx, -0x70(%rbp)
movq %r15, -0x50(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x48(%rbp)
subq $0x8, %rsp
leaq -0x29(%rbp), %rdi
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq %r12, %r8
xorl %r9d, %r9d
pushq $0x0
callq 0x16d14
addq $0x10, %rsp
movq %r14, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
subq $0x30, %rsp
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%rsp)
movq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq -0x88(%rbp), %rax
movq %rax, (%rsp)
xorps %xmm1, %xmm1
leaq -0x2a(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x80(%rbp), %rcx
movq %r12, %r8
movq -0xd0(%rbp), %r9
movsd 0x3a7a(%rip), %xmm0     # 0x1d420
callq 0x16d8e
addq $0x30, %rsp
movq -0xb8(%rbp), %rax
movq -0x70(%rbp), %rdx
addq %rax, %r13
movq -0x170(%rbp), %rcx
addq %rcx, %r15
addq %rcx, %r14
cmpq %rbx, %r13
jl 0x198fd
movq -0x158(%rbp), %rax
addq %rax, -0x108(%rbp)
movq -0x150(%rbp), %rax
addq %rax, -0x120(%rbp)
movq -0xb0(%rbp), %rdx
subq %rdx, -0x118(%rbp)
movq -0x148(%rbp), %rax
addq %rax, -0x110(%rbp)
testq %rbx, %rbx
movq -0x88(%rbp), %r14
jg 0x1945e
cmpq $0x2001, -0xa0(%rbp) # imm = 0x2001
jb 0x19a31
movq -0x78(%rbp), %rdi
callq 0x3310
cmpq $0x2001, -0xa8(%rbp) # imm = 0x2001
movq -0x38(%rbp), %rdi
jb 0x19a47
callq 0x3310
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3130
movq 0x15559(%rip), %rcx     # 0x2efc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1555b(%rip), %rsi     # 0x2efd0
movq 0x1552c(%rip), %rdx     # 0x2efa8
movq %rax, %rdi
callq 0x3430
movl $0x8, %edi
callq 0x3130
movq 0x1552b(%rip), %rcx     # 0x2efc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1552d(%rip), %rsi     # 0x2efd0
movq 0x154fe(%rip), %rdx     # 0x2efa8
movq %rax, %rdi
callq 0x3430
leaq 0x157df(%rip), %rdi     # 0x2f298
movq %rdx, %r12
callq 0x3470
movq %r12, %rdx
testl %eax, %eax
je 0x1930a
leaq 0x157ad(%rip), %rdi     # 0x2f280
callq 0x120d8
leaq 0x157b9(%rip), %rdi     # 0x2f298
callq 0x31a0
movq -0x88(%rbp), %r14
movq %r15, %rbx
movq -0xb0(%rbp), %rdx
jmp 0x1930a
jmp 0x19b01
jmp 0x19a56
leaq 0x2df3(%rip), %rdi      # 0x1c8fb
leaq 0x2ea6(%rip), %rsi      # 0x1c9b5
leaq 0x2ebe(%rip), %rcx      # 0x1c9d4
movl $0xa1, %edx
callq 0x31b0
movl $0x8, %edi
callq 0x3130
movq 0x1548f(%rip), %rcx     # 0x2efc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x15491(%rip), %rsi     # 0x2efd0
movq 0x15462(%rip), %rdx     # 0x2efa8
movq %rax, %rdi
callq 0x3430
movq %rax, %rbx
leaq 0x15740(%rip), %rdi     # 0x2f298
callq 0x3190
jmp 0x19b78
jmp 0x19b61
movq %rax, %rbx
movq -0x38(%rbp), %r14
jmp 0x19b92
jmp 0x19b75
jmp 0x19b75
movq %rax, %rbx
jmp 0x19b7c
jmp 0x19b75
movq %rax, %rbx
movq -0x38(%rbp), %r14
cmpq $0x2001, -0xa0(%rbp) # imm = 0x2001
movq -0x78(%rbp), %rdi
jb 0x19b92
callq 0x3310
cmpq $0x2001, -0xa8(%rbp) # imm = 0x2001
jb 0x19ba7
movq %r14, %rdi
callq 0x3310
movq %rbx, %rdi
callq 0x3450
nop