// File: /workspace/github_cpp_makefile_star2_O1/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, -0x60(%rbp)
movq %r8, -0x98(%rbp)
movq %rcx, -0x90(%rbp)
movq %rdx, -0xe8(%rbp)
movq 0x10(%rbp), %rbx
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
cmpq %rdi, %rax
cmovgeq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rcx, -0x70(%rbp)
imulq %rcx, %rax
movq %rax, -0xa8(%rbp)
shrq $0x3c, %rax
jne 0x1a0b5
movq %rsi, %r14
movq %rdi, %r15
movq (%rbx), %rax
movq %rax, -0x88(%rbp)
testq %rax, %rax
je 0x1986d
xorl %eax, %eax
jmp 0x198ba
movq -0xa8(%rbp), %rax
movq %rax, %rdi
shlq $0x4, %rdi
cmpq $0x2000, %rax           # imm = 0x2000
ja 0x1989d
movq %rsp, %rax
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %rax
movq %rax, %rsp
movq %rax, -0x88(%rbp)
jmp 0x198ba
callq 0x3370
testb $0xf, %al
jne 0x1a14d
movq %rax, -0x88(%rbp)
testq %rax, %rax
je 0x1a14f
movq %rax, -0x38(%rbp)
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFFF
movq -0x70(%rbp), %rcx
imulq %r14, %rcx
movq %rcx, -0xa0(%rbp)
cmpq %rax, %rcx
ja 0x1a0e3
movq 0x8(%rbx), %rax
movq %rax, -0x78(%rbp)
testq %rax, %rax
je 0x198f5
xorl %r12d, %r12d
movq %r15, %rbx
jmp 0x19944
movq -0xa0(%rbp), %rax
movq %rax, %rdi
shlq $0x4, %rdi
cmpq $0x2000, %rax           # imm = 0x2000
movq %r15, %rbx
ja 0x19925
movq %rsp, %r12
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %r12
movq %r12, %rsp
movq %r12, -0x78(%rbp)
jmp 0x19944
callq 0x3370
movq %rax, %r12
testb $0xf, %r12b
jne 0x1a154
movq %r12, -0x78(%rbp)
testq %r12, %r12
je 0x1a173
movb 0x15956(%rip), %al      # 0x2f2a0
testb %al, %al
movq %r14, -0x80(%rbp)
movq %r12, -0x58(%rbp)
je 0x1a111
testq %r14, %r14
jle 0x1998e
movq 0x1592a(%rip), %rax     # 0x2f290
movq -0x60(%rbp), %rdx
cmpq %rbx, %rdx
movq %rbx, %rcx
cmovgq %rdx, %rcx
shlq $0x6, %rcx
xorl %edx, %edx
divq %rcx
leaq 0x3(%rax), %rsi
testq %rax, %rax
cmovnsq %rax, %rsi
andq $-0x4, %rsi
jmp 0x19990
xorl %esi, %esi
cmpq $0x5, %rsi
movl $0x4, %eax
cmovlq %rax, %rsi
testq %rbx, %rbx
jle 0x1a07b
movq %rbx, %rdi
shlq $0x4, %rdi
movq -0x98(%rbp), %rax
addq %rdi, %rax
movq %rax, -0x110(%rbp)
movq -0x70(%rbp), %rax
shlq $0x4, %rax
negq %rax
movq %rax, -0x160(%rbp)
movq -0x60(%rbp), %rax
movq %rax, %rcx
imulq %rsi, %rcx
shlq $0x4, %rcx
movq %rcx, -0x170(%rbp)
shlq $0x4, %rax
movq %rax, -0x1d8(%rbp)
leaq -0x1(%rbx), %rax
movq -0x90(%rbp), %rcx
imulq %rcx, %rax
shlq $0x4, %rax
movq -0xe8(%rbp), %rdx
addq %rdx, %rdi
addq %rax, %rdi
movq %rdi, -0x118(%rbp)
movq -0x70(%rbp), %rax
movq %rcx, %rdi
shlq $0x4, %rdi
movq %rdi, %r8
xorq $-0x10, %r8
imulq %rax, %r8
movq %r8, -0x158(%rbp)
movq %rcx, %r8
notq %r8
shlq $0x6, %r8
movq %r8, -0x190(%rbp)
negq %rdi
movq %rdi, -0x1b0(%rbp)
movq %rbx, %rdi
subq %rax, %rdi
movq %rcx, %r8
movq %rdi, -0x108(%rbp)
imulq %rdi, %r8
shlq $0x4, %r8
addq %rdx, %r8
movq %r8, -0x100(%rbp)
movq %rax, %rdx
imulq %rcx, %rdx
shlq $0x4, %rdx
negq %rdx
movq %rdx, -0x150(%rbp)
movq -0xb0(%rbp), %rcx
shlq $0x4, %rcx
movq %rcx, -0x178(%rbp)
movq %rsi, -0x120(%rbp)
cmpq %rbx, %rax
movq %rbx, %r12
cmovlq %rax, %r12
testq %r14, %r14
movq %r12, -0xc0(%rbp)
jle 0x19f1e
movq %rbx, %rcx
subq %r12, %rcx
shlq $0x4, %rcx
movq -0xe8(%rbp), %rax
movq %rcx, -0x168(%rbp)
addq %rcx, %rax
movq %rax, -0x180(%rbp)
movq -0x110(%rbp), %rax
movq %rax, -0xb8(%rbp)
xorl %ecx, %ecx
movq %rbx, -0x1b8(%rbp)
movq %rcx, -0xd8(%rbp)
subq %rcx, %r14
cmpq %r14, %rsi
movq %r14, -0x1c0(%rbp)
cmovlq %rsi, %r14
movq %r14, -0xc8(%rbp)
testq %r12, %r12
jle 0x19eeb
movq -0xd8(%rbp), %rax
movq -0xc8(%rbp), %rcx
addq %rax, %rcx
movq %rcx, -0x1e0(%rbp)
movq %rax, %rcx
imulq %r12, %rcx
shlq $0x4, %rcx
addq -0x78(%rbp), %rcx
movq %rcx, -0x128(%rbp)
movq %rax, %rcx
imulq -0x60(%rbp), %rcx
shlq $0x4, %rcx
addq -0x98(%rbp), %rcx
movq -0x168(%rbp), %rax
movq %rcx, -0x198(%rbp)
addq %rcx, %rax
movq %rax, -0x188(%rbp)
movq -0x118(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x130(%rbp)
movq %r12, %rcx
xorl %r15d, %r15d
movl $0x4, %eax
cmpq %rax, %rcx
movq %rcx, -0x1a0(%rbp)
cmovlq %rcx, %rax
cmpq $0x2, %rax
movl $0x1, %ecx
movq %rax, %rdx
cmovgeq %rax, %rcx
movq %rcx, -0x1c8(%rbp)
subq %r15, %r12
cmpq $0x4, %r12
movl $0x4, %eax
cmovlq %r12, %rax
movq %rax, -0xe0(%rbp)
movq %r12, -0x1a8(%rbp)
testq %r12, %r12
movq %r15, -0x138(%rbp)
jle 0x19d98
shlq $0x4, %rdx
negq %rdx
movq %rdx, -0x1d0(%rbp)
movq -0xd0(%rbp), %rax
xorl %ecx, %ecx
movq %rax, -0x148(%rbp)
movq %rcx, -0x140(%rbp)
addq %r15, %rcx
notq %rcx
addq %rbx, %rcx
movq %rcx, %rax
imulq -0x90(%rbp), %rax
shlq $0x4, %rax
addq -0xe8(%rbp), %rax
shlq $0x4, %rcx
movsd (%rcx,%rax), %xmm2
movq %rcx, -0x1e8(%rbp)
movsd 0x8(%rcx,%rax), %xmm3
xorpd %xmm1, %xmm1
movsd 0x377c(%rip), %xmm0     # 0x1d3d0
callq 0x3180
movsd %xmm0, -0x1f8(%rbp)
movsd %xmm1, -0x1f0(%rbp)
cmpq $0x0, -0x1c0(%rbp)
jle 0x19d65
movq -0x140(%rbp), %r12
notq %r12
addq -0xe0(%rbp), %r12
movq -0x130(%rbp), %r15
movq -0xd8(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
imulq -0x60(%rbp), %rdi
shlq $0x4, %rdi
movq -0x98(%rbp), %rax
movq -0x1e8(%rbp), %rcx
addq %rcx, %rax
addq %rax, %rdi
leaq -0x1f8(%rbp), %rsi
callq 0xfe6c
movupd (%rax), %xmm0
movapd %xmm0, -0x210(%rbp)
testq %r12, %r12
leaq -0x50(%rbp), %r13
movq -0x148(%rbp), %rcx
jle 0x19d47
movq -0x1d0(%rbp), %rbx
xorl %r14d, %r14d
movq %r15, -0xf8(%rbp)
leaq (%rcx,%rbx), %rsi
movaps -0x210(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movq %r13, %rdi
movq %rcx, %r15
callq 0xfe6c
movq %r15, %rcx
movq -0xf8(%rbp), %r15
movsd (%r15,%rbx), %xmm0
subsd -0x50(%rbp), %xmm0
movsd 0x8(%r15,%rbx), %xmm1
subsd -0x48(%rbp), %xmm1
movsd %xmm0, (%r15,%rbx)
movsd %xmm1, 0x8(%r15,%rbx)
incq %r14
addq $0x10, %rbx
cmpq %r12, %r14
jl 0x19cf3
movq -0xf0(%rbp), %rdi
incq %rdi
addq -0x1d8(%rbp), %r15
cmpq -0x1e0(%rbp), %rdi
jl 0x19c96
movq -0x140(%rbp), %rcx
incq %rcx
movq -0x148(%rbp), %rax
addq -0x1b0(%rbp), %rax
cmpq -0x1c8(%rbp), %rcx
movq -0x1b8(%rbp), %rbx
movq -0x138(%rbp), %r15
jne 0x19c05
movq -0xe0(%rbp), %rcx
movq -0x1a8(%rbp), %r13
subq %rcx, %r13
movq %rbx, %r14
subq %r15, %r14
subq %rcx, %r14
movq %r14, %rax
shlq $0x4, %rax
addq -0x198(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
subq $0x8, %rsp
leaq -0x61(%rbp), %rdi
movq -0x128(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq -0xc8(%rbp), %r8
movq -0xc0(%rbp), %r12
movq %r12, %r9
pushq %r13
callq 0x170f6
addq $0x10, %rsp
testq %r13, %r13
jle 0x19eaf
movq %r12, %r15
movq -0x90(%rbp), %rax
imulq %rax, %r14
shlq $0x4, %r14
addq -0x180(%rbp), %r14
movq %r14, -0x50(%rbp)
movq %rax, -0x48(%rbp)
subq $0x8, %rsp
leaq -0x29(%rbp), %rdi
movq -0x88(%rbp), %r14
movq %r14, %rsi
leaq -0x50(%rbp), %rdx
movq -0xe0(%rbp), %r12
movq %r12, %rcx
movq %r13, %r8
xorl %r9d, %r9d
pushq $0x0
callq 0x17314
addq $0x10, %rsp
movq -0x188(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
subq $0x8, %rsp
xorpd %xmm1, %xmm1
leaq -0x2a(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq %r14, %rdx
movq -0x128(%rbp), %rcx
movq %r13, %r8
movq %r12, %r9
movsd 0x356f(%rip), %xmm0     # 0x1d400
pushq %r13
pushq $0x0
pushq %r15
pushq %r12
pushq -0xc8(%rbp)
movq -0x38(%rbp), %r14
callq 0x173e8
addq $0x30, %rsp
movq %r15, %r12
movq -0x138(%rbp), %r15
addq $0x4, %r15
movq -0x1a0(%rbp), %rcx
addq $-0x4, %rcx
addq $-0x40, -0x130(%rbp)
movq -0xd0(%rbp), %rax
addq -0x190(%rbp), %rax
movq %rax, -0xd0(%rbp)
cmpq %r12, %r15
jl 0x19b96
movq -0x120(%rbp), %rsi
movq -0xd8(%rbp), %rcx
addq %rsi, %rcx
movq -0xb8(%rbp), %rax
addq -0x170(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x80(%rbp), %r14
cmpq %r14, %rcx
jl 0x19af3
subq -0x70(%rbp), %rbx
movq -0xb0(%rbp), %rax
jle 0x1a02e
movq -0x98(%rbp), %r14
movq -0x100(%rbp), %r15
movq -0x108(%rbp), %rdx
xorl %r13d, %r13d
movq %rdx, %r8
subq %rax, %rdx
cmovgeq %rax, %r8
testq %r8, %r8
jle 0x1a015
movq %rdx, -0xf0(%rbp)
movq %r15, -0x50(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x48(%rbp)
subq $0x8, %rsp
leaq -0x29(%rbp), %rdi
movq -0x88(%rbp), %r12
movq %r12, %rsi
leaq -0x50(%rbp), %rdx
movq -0xc0(%rbp), %rcx
movq %r8, -0xf8(%rbp)
xorl %r9d, %r9d
pushq $0x0
callq 0x17314
addq $0x10, %rsp
movq %r14, -0x50(%rbp)
movq -0x60(%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 -0x80(%rbp), %rax
movq %rax, (%rsp)
xorpd %xmm1, %xmm1
leaq -0x2a(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq %r12, %rdx
movq -0x78(%rbp), %rcx
movq -0xf8(%rbp), %r8
movq -0xc0(%rbp), %r9
movsd 0x3402(%rip), %xmm0     # 0x1d400
callq 0x173e8
addq $0x30, %rsp
movq -0xb0(%rbp), %rax
movq -0xf0(%rbp), %rdx
addq %rax, %r13
movq -0x178(%rbp), %rcx
addq %rcx, %r15
addq %rcx, %r14
cmpq %rbx, %r13
jl 0x19f47
movq -0x160(%rbp), %rax
addq %rax, -0x110(%rbp)
movq -0x158(%rbp), %rax
addq %rax, -0x118(%rbp)
movq -0x70(%rbp), %rax
subq %rax, -0x108(%rbp)
movq -0x150(%rbp), %rcx
addq %rcx, -0x100(%rbp)
testq %rbx, %rbx
movq -0x80(%rbp), %r14
movq -0x58(%rbp), %r12
movq -0x120(%rbp), %rsi
jg 0x19aa0
cmpq $0x2001, -0xa0(%rbp) # imm = 0x2001
jb 0x1a090
movq %r12, %rdi
callq 0x3320
cmpq $0x2001, -0xa8(%rbp) # imm = 0x2001
movq -0x38(%rbp), %rdi
jb 0x1a0a6
callq 0x3320
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3130
movq 0x14efa(%rip), %rcx     # 0x2efc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x14efc(%rip), %rsi     # 0x2efd0
movq 0x14ecd(%rip), %rdx     # 0x2efa8
movq %rax, %rdi
callq 0x3440
movl $0x8, %edi
callq 0x3130
movq 0x14ecc(%rip), %rcx     # 0x2efc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x14ece(%rip), %rsi     # 0x2efd0
movq 0x14e9f(%rip), %rdx     # 0x2efa8
movq %rax, %rdi
callq 0x3440
leaq 0x15188(%rip), %rdi     # 0x2f2a0
callq 0x3480
testl %eax, %eax
je 0x1995a
leaq 0x1515c(%rip), %rdi     # 0x2f288
callq 0x1242a
leaq 0x15168(%rip), %rdi     # 0x2f2a0
callq 0x31a0
movq -0x80(%rbp), %r14
movq %r15, %rbx
movq -0x58(%rbp), %r12
jmp 0x1995a
jmp 0x1a154
jmp 0x1a0b5
leaq 0x2780(%rip), %rdi      # 0x1c8db
leaq 0x2833(%rip), %rsi      # 0x1c995
leaq 0x284b(%rip), %rcx      # 0x1c9b4
movl $0xa1, %edx
callq 0x31b0
movl $0x8, %edi
callq 0x3130
movq 0x14e3c(%rip), %rcx     # 0x2efc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x14e3e(%rip), %rsi     # 0x2efd0
movq 0x14e0f(%rip), %rdx     # 0x2efa8
movq %rax, %rdi
callq 0x3440
movq %rax, %rbx
leaq 0x150f5(%rip), %rdi     # 0x2f2a0
callq 0x3190
jmp 0x1a1cb
jmp 0x1a1b4
movq %rax, %rbx
movq -0x38(%rbp), %r14
jmp 0x1a1e5
jmp 0x1a1c8
jmp 0x1a1c8
movq %rax, %rbx
jmp 0x1a1cf
jmp 0x1a1c8
movq %rax, %rbx
movq -0x38(%rbp), %r14
movq -0x58(%rbp), %rdi
cmpq $0x2001, -0xa0(%rbp) # imm = 0x2001
jb 0x1a1e5
callq 0x3320
cmpq $0x2001, -0xa8(%rbp) # imm = 0x2001
jb 0x1a1fa
movq %r14, %rdi
callq 0x3320
movq %rbx, %rdi
callq 0x3460