// File: Pyboon[P]sage/./Eigen/src/Core/products/TriangularSolverMatrix.h
// Function: Eigen::internal::triangular_solve_matrix<std::complex<double>, long, 1, 5, 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
subq $0x650, %rsp            # imm = 0x650
movq 0x10(%rbp), %rax
movq %rdi, -0x2a8(%rbp)
movq %rsi, -0x2b0(%rbp)
movq %rdx, -0x2b8(%rbp)
movq %rcx, -0x2c0(%rbp)
movq %r8, -0x2c8(%rbp)
movq %r9, -0x2d0(%rbp)
movq -0x2b0(%rbp), %rax
movq %rax, -0x2d8(%rbp)
movq -0x2b8(%rbp), %rcx
movq -0x2c0(%rbp), %rax
leaq -0x2e8(%rbp), %rdx
movq %rdx, -0x280(%rbp)
movq %rcx, -0x288(%rbp)
movq %rax, -0x290(%rbp)
movq -0x280(%rbp), %rdx
movq -0x288(%rbp), %rcx
movq -0x290(%rbp), %rax
movq %rdx, -0x238(%rbp)
movq %rcx, -0x240(%rbp)
movq %rax, -0x248(%rbp)
movq -0x238(%rbp), %rax
movq -0x240(%rbp), %rcx
movq %rcx, (%rax)
movq -0x248(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x2c8(%rbp), %rcx
movq -0x2d0(%rbp), %rax
leaq -0x2f8(%rbp), %rdx
movq %rdx, -0x220(%rbp)
movq %rcx, -0x228(%rbp)
movq %rax, -0x230(%rbp)
movq -0x220(%rbp), %rax
movq -0x228(%rbp), %rcx
movq %rcx, (%rax)
movq -0x230(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rbp), %rdi
callq 0x3f720
movq %rax, -0x300(%rbp)
movq 0x10(%rbp), %rdi
callq 0x3f740
movq %rax, -0x310(%rbp)
leaq -0x2a8(%rbp), %rdi
leaq -0x310(%rbp), %rsi
callq 0x3e940
movq (%rax), %rax
movq %rax, -0x308(%rbp)
movq -0x300(%rbp), %rax
imulq -0x308(%rbp), %rax
movq %rax, -0x318(%rbp)
movq -0x300(%rbp), %rax
imulq -0x2d8(%rbp), %rax
movq %rax, -0x320(%rbp)
movq -0x318(%rbp), %rax
movq %rax, -0x298(%rbp)
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFFF
cmpq %rax, -0x298(%rbp)
jbe 0x51dec
callq 0x14c90
movq 0x10(%rbp), %rdi
callq 0x3f790
cmpq $0x0, %rax
je 0x51e0d
movq 0x10(%rbp), %rdi
callq 0x3f790
movq %rax, -0x538(%rbp)
jmp 0x51e76
movq -0x318(%rbp), %rax
shlq $0x4, %rax
cmpq $0x20000, %rax          # imm = 0x20000
ja 0x51e51
movq -0x318(%rbp), %rcx
shlq $0x4, %rcx
addq $0x1e, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
addq $0x10, %rax
subq $0x1, %rax
andq $-0x10, %rax
movq %rax, -0x540(%rbp)
jmp 0x51e68
movq -0x318(%rbp), %rdi
shlq $0x4, %rdi
callq 0x14db0
movq %rax, -0x540(%rbp)
movq -0x540(%rbp), %rax
movq %rax, -0x538(%rbp)
movq -0x538(%rbp), %rax
movq %rax, -0x328(%rbp)
movq 0x10(%rbp), %rdi
callq 0x3f790
cmpq $0x0, %rax
jne 0x51ea3
movq -0x328(%rbp), %rax
movq %rax, -0x548(%rbp)
jmp 0x51eae
xorl %eax, %eax
movq %rax, -0x548(%rbp)
jmp 0x51eae
movq -0x548(%rbp), %rsi
movq -0x318(%rbp), %rdx
movq -0x318(%rbp), %rax
shlq $0x4, %rax
cmpq $0x20000, %rax          # imm = 0x20000
seta %al
movzbl %al, %ecx
andl $0x1, %ecx
leaq -0x340(%rbp), %rdi
callq 0x32410
movq -0x320(%rbp), %rax
movq %rax, -0x2a0(%rbp)
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFFF
cmpq %rax, -0x2a0(%rbp)
jbe 0x51f0c
callq 0x14c90
jmp 0x51f0a
jmp 0x51f0c
jmp 0x51f0e
movq 0x10(%rbp), %rdi
callq 0x3f7b0
cmpq $0x0, %rax
je 0x51f2f
movq 0x10(%rbp), %rdi
callq 0x3f7b0
movq %rax, -0x550(%rbp)
jmp 0x51faa
movq -0x320(%rbp), %rax
shlq $0x4, %rax
cmpq $0x20000, %rax          # imm = 0x20000
ja 0x51f73
movq -0x320(%rbp), %rcx
shlq $0x4, %rcx
addq $0x1e, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
addq $0x10, %rax
subq $0x1, %rax
andq $-0x10, %rax
movq %rax, -0x558(%rbp)
jmp 0x51f9c
movq -0x320(%rbp), %rdi
shlq $0x4, %rdi
callq 0x14db0
movq %rax, -0x560(%rbp)
jmp 0x51f8c
movq -0x560(%rbp), %rax
movq %rax, -0x558(%rbp)
jmp 0x51f9c
movq -0x558(%rbp), %rax
movq %rax, -0x550(%rbp)
movq -0x550(%rbp), %rax
movq %rax, -0x358(%rbp)
movq 0x10(%rbp), %rdi
callq 0x3f7b0
cmpq $0x0, %rax
jne 0x51fd7
movq -0x358(%rbp), %rax
movq %rax, -0x568(%rbp)
jmp 0x51fe2
xorl %eax, %eax
movq %rax, -0x568(%rbp)
jmp 0x51fe2
movq -0x568(%rbp), %rsi
movq -0x320(%rbp), %rdx
movq %rdx, %rax
shlq $0x4, %rax
subq $0x20001, %rax          # imm = 0x20001
setae %al
movzbl %al, %ecx
leaq -0x370(%rbp), %rdi
callq 0x32410
jmp 0x52011
xorl %edi, %edi
leaq -0x380(%rbp), %rsi
leaq -0x388(%rbp), %rdx
leaq -0x390(%rbp), %rcx
callq 0x3df30
jmp 0x5202f
cmpq $0x0, -0x2d8(%rbp)
jle 0x52079
movq -0x388(%rbp), %rax
movq %rax, -0x578(%rbp)
leaq -0x2d0(%rbp), %rdi
leaq -0x2a8(%rbp), %rsi
callq 0x3e980
movq %rax, %rcx
movq -0x578(%rbp), %rax
movq (%rcx), %rcx
shlq $0x6, %rcx
xorl %edx, %edx
divq %rcx
movq %rax, -0x570(%rbp)
jmp 0x52084
xorl %eax, %eax
movq %rax, -0x570(%rbp)
jmp 0x52084
movq -0x570(%rbp), %rax
movq %rax, -0x398(%rbp)
movq -0x398(%rbp), %rax
movl $0x4, %ecx
cqto
idivq %rcx
shlq $0x2, %rax
movq %rax, -0x3a0(%rbp)
movq $0x4, -0x3a8(%rbp)
leaq -0x3a0(%rbp), %rdi
leaq -0x3a8(%rbp), %rsi
callq 0x3e980
movq (%rax), %rax
movq %rax, -0x398(%rbp)
movq $0x0, -0x3b0(%rbp)
movq -0x3b0(%rbp), %rax
cmpq -0x2a8(%rbp), %rax
jge 0x52e73
movq -0x2a8(%rbp), %rax
subq -0x3b0(%rbp), %rax
movq %rax, -0x3c0(%rbp)
leaq -0x3c0(%rbp), %rdi
leaq -0x300(%rbp), %rsi
callq 0x3e940
movq (%rax), %rax
movq %rax, -0x3b8(%rbp)
movq $0x0, -0x3c8(%rbp)
movq -0x3c8(%rbp), %rax
cmpq -0x2d8(%rbp), %rax
jge 0x52a97
movq -0x2d8(%rbp), %rax
subq -0x3c8(%rbp), %rax
movq %rax, -0x3d8(%rbp)
leaq -0x3d8(%rbp), %rdi
leaq -0x398(%rbp), %rsi
callq 0x3e940
movq (%rax), %rax
movq %rax, -0x3d0(%rbp)
movq $0x0, -0x3e0(%rbp)
movq -0x3e0(%rbp), %rax
cmpq -0x3b8(%rbp), %rax
jge 0x52a7b
movq -0x3b8(%rbp), %rax
subq -0x3e0(%rbp), %rax
movq %rax, -0x3f0(%rbp)
movq $0x4, -0x3f8(%rbp)
leaq -0x3f0(%rbp), %rdi
leaq -0x3f8(%rbp), %rsi
callq 0x3e940
movq (%rax), %rax
movq %rax, -0x3e8(%rbp)
movq $0x0, -0x400(%rbp)
movq -0x400(%rbp), %rax
cmpq -0x3e8(%rbp), %rax
jge 0x52566
movq -0x3b0(%rbp), %rax
addq -0x3e0(%rbp), %rax
addq -0x400(%rbp), %rax
movq %rax, -0x408(%rbp)
movq -0x3e8(%rbp), %rax
subq -0x400(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x410(%rbp)
movq -0x408(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x418(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x52242
jmp 0x52260
leaq -0x428(%rbp), %rdi
movsd 0x1bdd7(%rip), %xmm0    # 0x6e028
xorps %xmm1, %xmm1
callq 0x14330
jmp 0x5225b
jmp 0x52313
leaq -0x438(%rbp), %rdi
movsd 0x1bdb9(%rip), %xmm0    # 0x6e028
xorps %xmm1, %xmm1
callq 0x14330
jmp 0x52279
movq -0x408(%rbp), %rax
leaq -0x2e8(%rbp), %rcx
movq %rcx, -0x250(%rbp)
movq %rax, -0x258(%rbp)
movq %rax, -0x260(%rbp)
movq -0x250(%rbp), %rdx
movq -0x258(%rbp), %rax
movq -0x260(%rbp), %rcx
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
shlq $0x4, %rax
addq %rax, %rsi
leaq -0x371(%rbp), %rdi
callq 0x42900
movq %rax, %rsi
leaq -0x438(%rbp), %rdi
callq 0x538e0
movsd %xmm1, -0x588(%rbp)
movsd %xmm0, -0x580(%rbp)
jmp 0x522f3
movsd -0x588(%rbp), %xmm0
movsd -0x580(%rbp), %xmm1
movsd %xmm1, -0x428(%rbp)
movsd %xmm0, -0x420(%rbp)
movq -0x3c8(%rbp), %rax
movq %rax, -0x440(%rbp)
movq -0x440(%rbp), %rax
movq -0x3c8(%rbp), %rcx
addq -0x3d0(%rbp), %rcx
cmpq %rcx, %rax
jge 0x5254d
movq -0x408(%rbp), %rcx
movq -0x440(%rbp), %rax
leaq -0x2f8(%rbp), %rdx
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdx
movq (%rdx), %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
imulq 0x8(%rdx), %rcx
addq %rcx, %rax
shlq $0x4, %rax
addq %rax, %rdi
leaq -0x428(%rbp), %rsi
callq 0x27030
movq (%rax), %rcx
movq %rcx, -0x450(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x448(%rbp)
movq -0x418(%rbp), %rcx
movq -0x440(%rbp), %rax
leaq -0x2f8(%rbp), %rdx
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rsi
movq (%rsi), %rax
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x458(%rbp)
movq -0x418(%rbp), %rcx
movq -0x408(%rbp), %rax
leaq -0x2e8(%rbp), %rdx
movq %rdx, -0x268(%rbp)
movq %rcx, -0x270(%rbp)
movq %rax, -0x278(%rbp)
movq -0x268(%rbp), %rsi
movq (%rsi), %rax
movq -0x270(%rbp), %rcx
movq -0x278(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x460(%rbp)
movq $0x0, -0x468(%rbp)
movq -0x468(%rbp), %rax
cmpq -0x410(%rbp), %rax
jge 0x52534
movq -0x460(%rbp), %rsi
movq -0x468(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
leaq -0x371(%rbp), %rdi
callq 0x42900
movq %rax, %rsi
leaq -0x450(%rbp), %rdi
callq 0x20310
movsd %xmm1, -0x598(%rbp)
movsd %xmm0, -0x590(%rbp)
jmp 0x5249e
movsd -0x598(%rbp), %xmm0
movsd -0x590(%rbp), %xmm1
movsd %xmm1, -0x478(%rbp)
movsd %xmm0, -0x470(%rbp)
movq -0x458(%rbp), %rdi
movq -0x468(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
leaq -0x478(%rbp), %rsi
callq 0x24fd0
jmp 0x524e1
jmp 0x524e3
movq -0x468(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x468(%rbp)
jmp 0x52448
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x348(%rbp)
movl %eax, -0x34c(%rbp)
jmp 0x52e90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x348(%rbp)
movl %eax, -0x34c(%rbp)
leaq -0x370(%rbp), %rdi
callq 0x35810
jmp 0x52e90
jmp 0x52536
movq -0x440(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x440(%rbp)
jmp 0x52321
jmp 0x5254f
movq -0x400(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x400(%rbp)
jmp 0x521df
movq -0x3b8(%rbp), %rax
movq -0x3e0(%rbp), %rcx
subq %rcx, %rax
movq -0x3e8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x480(%rbp)
movq -0x3b0(%rbp), %rax
movq -0x3e0(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x488(%rbp)
movq -0x3e0(%rbp), %rax
movq %rax, -0x490(%rbp)
movq -0x358(%rbp), %rcx
movq -0x3b8(%rbp), %rdx
movq -0x3c8(%rbp), %rax
imulq %rax, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, -0x5b0(%rbp)
movq -0x488(%rbp), %rcx
leaq -0x2f8(%rbp), %rdx
movq %rdx, -0xa8(%rbp)
movq %rcx, -0xb0(%rbp)
movq %rax, -0xb8(%rbp)
movq -0xa8(%rbp), %rax
movq -0xb0(%rbp), %rdx
movq -0xb8(%rbp), %rcx
movq %rax, -0x68(%rbp)
movq %rdx, -0x70(%rbp)
movq %rcx, -0x78(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rsi
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
imulq %rdi, %rsi
addq %rsi, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rax), %rax
leaq -0xa0(%rbp), %rdx
movq %rdx, -0x80(%rbp)
movq %rcx, -0x88(%rbp)
movq %rax, -0x90(%rbp)
movq -0x80(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, (%rax)
movq -0x90(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0xa0(%rbp), %rax
movq %rax, -0x5a8(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x5a0(%rbp)
movq -0x5b0(%rbp), %rsi
movq -0x5a0(%rbp), %rax
movq -0x5a8(%rbp), %rcx
movq %rcx, -0x4a0(%rbp)
movq %rax, -0x498(%rbp)
movq -0x3e8(%rbp), %rcx
movq -0x3d0(%rbp), %r8
movq -0x3b8(%rbp), %r9
movq -0x490(%rbp), %rdx
subq $0x10, %rsp
movq %rsp, %rax
movq %rdx, (%rax)
leaq -0x374(%rbp), %rdi
leaq -0x4a0(%rbp), %rdx
callq 0x53920
addq $0x10, %rsp
jmp 0x526ee
cmpq $0x0, -0x480(%rbp)
jle 0x52a62
movq -0x3b0(%rbp), %rax
movq -0x3e0(%rbp), %rcx
addq %rcx, %rax
movq -0x3e8(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x4a8(%rbp)
movq -0x328(%rbp), %rax
movq %rax, -0x5c8(%rbp)
movq -0x4a8(%rbp), %rcx
movq -0x488(%rbp), %rax
leaq -0x2e8(%rbp), %rdx
movq %rdx, -0x198(%rbp)
movq %rcx, -0x1a0(%rbp)
movq %rax, -0x1a8(%rbp)
movq -0x198(%rbp), %rax
movq -0x1a0(%rbp), %rdx
movq -0x1a8(%rbp), %rcx
movq %rax, -0x158(%rbp)
movq %rdx, -0x160(%rbp)
movq %rcx, -0x168(%rbp)
movq -0x158(%rbp), %rdi
movq -0x160(%rbp), %rdx
movq -0x168(%rbp), %rsi
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
imulq %rdi, %rsi
addq %rsi, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rax), %rax
leaq -0x190(%rbp), %rdx
movq %rdx, -0x170(%rbp)
movq %rcx, -0x178(%rbp)
movq %rax, -0x180(%rbp)
movq -0x170(%rbp), %rdx
movq -0x178(%rbp), %rcx
movq -0x180(%rbp), %rax
movq %rdx, -0x140(%rbp)
movq %rcx, -0x148(%rbp)
movq %rax, -0x150(%rbp)
movq -0x140(%rbp), %rax
movq -0x148(%rbp), %rcx
movq %rcx, (%rax)
movq -0x150(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x190(%rbp), %rax
movq %rax, -0x5c0(%rbp)
movq -0x188(%rbp), %rax
movq %rax, -0x5b8(%rbp)
movq -0x5c8(%rbp), %rsi
movq -0x5b8(%rbp), %rax
movq -0x5c0(%rbp), %rcx
movq %rcx, -0x4b8(%rbp)
movq %rax, -0x4b0(%rbp)
movq -0x3e8(%rbp), %rcx
movq -0x480(%rbp), %r8
subq $0x10, %rsp
movq %rsp, %rax
movq $0x0, (%rax)
xorl %eax, %eax
movl %eax, %r9d
leaq -0x373(%rbp), %rdi
leaq -0x4b8(%rbp), %rdx
callq 0x540b0
addq $0x10, %rsp
jmp 0x52889
movq -0x4a8(%rbp), %rcx
movq -0x3c8(%rbp), %rax
leaq -0x2f8(%rbp), %rdx
movq %rdx, -0xe8(%rbp)
movq %rcx, -0xf0(%rbp)
movq %rax, -0xf8(%rbp)
movq -0xe8(%rbp), %rax
movq -0xf0(%rbp), %rdx
movq -0xf8(%rbp), %rcx
movq %rax, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq %rcx, -0x60(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rsi
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
imulq %rdi, %rsi
addq %rsi, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rax), %rax
leaq -0xe0(%rbp), %rdx
movq %rdx, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rax, -0xd0(%rbp)
movq -0xc0(%rbp), %rax
movq -0xc8(%rbp), %rcx
movq %rcx, (%rax)
movq -0xd0(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0xe0(%rbp), %rax
movq %rax, -0x5d8(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0x5d0(%rbp)
movq -0x5d0(%rbp), %rax
movq -0x5d8(%rbp), %rcx
movq %rcx, -0x4c8(%rbp)
movq %rax, -0x4c0(%rbp)
movq -0x328(%rbp), %rax
movq %rax, -0x600(%rbp)
movq -0x358(%rbp), %rax
movq -0x3b8(%rbp), %rcx
movq -0x3c8(%rbp), %rdx
imulq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x5f8(%rbp)
movq -0x480(%rbp), %rax
movq %rax, -0x5f0(%rbp)
movq -0x3e8(%rbp), %rax
movq %rax, -0x5e8(%rbp)
movq -0x3d0(%rbp), %rax
movq %rax, -0x5e0(%rbp)
leaq -0x4d8(%rbp), %rdi
movsd 0x1cea9(%rip), %xmm0    # 0x6f880
xorps %xmm1, %xmm1
callq 0x14330
jmp 0x529e1
movq -0x5e8(%rbp), %r9
movq -0x5f0(%rbp), %r8
movq -0x5f8(%rbp), %rcx
movq -0x600(%rbp), %rdx
movq -0x5e0(%rbp), %rsi
movq -0x3e8(%rbp), %rdi
movq -0x3b8(%rbp), %r10
movq -0x490(%rbp), %r11
movsd -0x4d8(%rbp), %xmm0
movsd -0x4d0(%rbp), %xmm1
subq $0x30, %rsp
movq %rsp, %rax
movq %r11, 0x20(%rax)
movq %r10, 0x10(%rax)
movq %rdi, 0x8(%rax)
movq %rsi, (%rax)
movq $0x0, 0x18(%rax)
leaq -0x372(%rbp), %rdi
leaq -0x4c8(%rbp), %rsi
callq 0x543f0
addq $0x30, %rsp
jmp 0x52a60
jmp 0x52a62
jmp 0x52a64
movq -0x3e0(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x3e0(%rbp)
jmp 0x52183
jmp 0x52a7d
movq -0x398(%rbp), %rax
addq -0x3c8(%rbp), %rax
movq %rax, -0x3c8(%rbp)
jmp 0x52132
movq -0x3b0(%rbp), %rax
addq -0x300(%rbp), %rax
movq %rax, -0x4e0(%rbp)
movq -0x2a8(%rbp), %rax
movq %rax, -0x4e8(%rbp)
movq -0x4e0(%rbp), %rax
movq %rax, -0x4f0(%rbp)
movq -0x4f0(%rbp), %rax
cmpq -0x4e8(%rbp), %rax
jge 0x52e57
movq -0x4e8(%rbp), %rax
subq -0x4f0(%rbp), %rax
movq %rax, -0x500(%rbp)
leaq -0x308(%rbp), %rdi
leaq -0x500(%rbp), %rsi
callq 0x3e940
movq (%rax), %rax
movq %rax, -0x4f8(%rbp)
cmpq $0x0, -0x4f8(%rbp)
jle 0x52e3b
movq -0x328(%rbp), %rax
movq %rax, -0x618(%rbp)
movq -0x4f0(%rbp), %rcx
movq -0x3b0(%rbp), %rax
leaq -0x2e8(%rbp), %rdx
movq %rdx, -0x208(%rbp)
movq %rcx, -0x210(%rbp)
movq %rax, -0x218(%rbp)
movq -0x208(%rbp), %rax
movq -0x210(%rbp), %rdx
movq -0x218(%rbp), %rcx
movq %rax, -0x1c8(%rbp)
movq %rdx, -0x1d0(%rbp)
movq %rcx, -0x1d8(%rbp)
movq -0x1c8(%rbp), %rdi
movq -0x1d0(%rbp), %rdx
movq -0x1d8(%rbp), %rsi
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
imulq %rdi, %rsi
addq %rsi, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rax), %rax
leaq -0x200(%rbp), %rdx
movq %rdx, -0x1e0(%rbp)
movq %rcx, -0x1e8(%rbp)
movq %rax, -0x1f0(%rbp)
movq -0x1e0(%rbp), %rdx
movq -0x1e8(%rbp), %rcx
movq -0x1f0(%rbp), %rax
movq %rdx, -0x1b0(%rbp)
movq %rcx, -0x1b8(%rbp)
movq %rax, -0x1c0(%rbp)
movq -0x1b0(%rbp), %rax
movq -0x1b8(%rbp), %rcx
movq %rcx, (%rax)
movq -0x1c0(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x200(%rbp), %rax
movq %rax, -0x610(%rbp)
movq -0x1f8(%rbp), %rax
movq %rax, -0x608(%rbp)
movq -0x618(%rbp), %rsi
movq -0x608(%rbp), %rax
movq -0x610(%rbp), %rcx
movq %rcx, -0x510(%rbp)
movq %rax, -0x508(%rbp)
movq -0x3b8(%rbp), %rcx
movq -0x4f8(%rbp), %r8
subq $0x10, %rsp
movq %rsp, %rax
movq $0x0, (%rax)
xorl %eax, %eax
movl %eax, %r9d
leaq -0x373(%rbp), %rdi
leaq -0x510(%rbp), %rdx
callq 0x540b0
addq $0x10, %rsp
jmp 0x52c87
movq -0x4f0(%rbp), %rax
leaq -0x2f8(%rbp), %rcx
movq %rcx, -0x128(%rbp)
movq %rax, -0x130(%rbp)
movq $0x0, -0x138(%rbp)
movq -0x128(%rbp), %rax
movq -0x130(%rbp), %rdx
movq -0x138(%rbp), %rcx
movq %rax, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rsi
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
imulq %rdi, %rsi
addq %rsi, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rax), %rax
leaq -0x120(%rbp), %rdx
movq %rdx, -0x100(%rbp)
movq %rcx, -0x108(%rbp)
movq %rax, -0x110(%rbp)
movq -0x100(%rbp), %rax
movq -0x108(%rbp), %rcx
movq %rcx, (%rax)
movq -0x110(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x120(%rbp), %rax
movq %rax, -0x628(%rbp)
movq -0x118(%rbp), %rax
movq %rax, -0x620(%rbp)
movq -0x620(%rbp), %rax
movq -0x628(%rbp), %rcx
movq %rcx, -0x520(%rbp)
movq %rax, -0x518(%rbp)
movq -0x328(%rbp), %rax
movq %rax, -0x650(%rbp)
movq -0x358(%rbp), %rax
movq %rax, -0x648(%rbp)
movq -0x4f8(%rbp), %rax
movq %rax, -0x640(%rbp)
movq -0x3b8(%rbp), %rax
movq %rax, -0x638(%rbp)
movq -0x2d8(%rbp), %rax
movq %rax, -0x630(%rbp)
leaq -0x530(%rbp), %rdi
movsd 0x1cac7(%rip), %xmm0    # 0x6f880
xorps %xmm1, %xmm1
callq 0x14330
jmp 0x52dc3
movq -0x638(%rbp), %r9
movq -0x640(%rbp), %r8
movq -0x648(%rbp), %rcx
movq -0x650(%rbp), %rdx
movq -0x630(%rbp), %rsi
movsd -0x530(%rbp), %xmm0
movsd -0x528(%rbp), %xmm1
subq $0x30, %rsp
movq %rsp, %rax
movq %rsi, (%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x18(%rax)
movq $-0x1, 0x10(%rax)
movq $-0x1, 0x8(%rax)
leaq -0x372(%rbp), %rdi
leaq -0x520(%rbp), %rsi
callq 0x543f0
addq $0x30, %rsp
jmp 0x52e39
jmp 0x52e3b
jmp 0x52e3d
movq -0x308(%rbp), %rax
addq -0x4f0(%rbp), %rax
movq %rax, -0x4f0(%rbp)
jmp 0x52ac8
jmp 0x52e59
movq -0x300(%rbp), %rax
addq -0x3b0(%rbp), %rax
movq %rax, -0x3b0(%rbp)
jmp 0x520e1
leaq -0x370(%rbp), %rdi
callq 0x35810
leaq -0x340(%rbp), %rdi
callq 0x35810
movq %rbp, %rsp
popq %rbp
retq
leaq -0x340(%rbp), %rdi
callq 0x35810
movq -0x348(%rbp), %rdi
callq 0x9dc0
nopl (%rax,%rax)