// File: j-faria[P]kima/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: Eigen::internal::lhs_process_one_packet<4, 2l, 1l, double, double, double, double vector[2], double vector[2], double vector[2], double vector[2], Eigen::internal::gebp_traits<double, double, false, false, 1, 0>, Eigen::internal::BlasLinearMapper<double, long, 0, 1>, Eigen::internal::blas_data_mapper<double, long, 0, 0, 1>>::operator()(Eigen::internal::blas_data_mapper<double, long, 0, 0, 1> const&, double const*, double const*, double, long, long, long, long, long, long, int, long, long, long, long, long)
EIGEN_STRONG_INLINE void operator()(
    const DataMapper& res, const LhsScalar* blockA, const RhsScalar* blockB, ResScalar alpha,
    Index peelStart, Index peelEnd, Index strideA, Index strideB, Index offsetA, Index offsetB,
    int prefetch_res_offset, Index peeled_kc, Index pk, Index cols, Index depth, Index packet_cols4)
  {
    GEBPTraits traits;

    // loops on each largest micro horizontal panel of lhs
    // (LhsProgress x depth)
    for(Index i=peelStart; i<peelEnd; i+=LhsProgress)
    {
      // loops on each largest micro vertical panel of rhs (depth * nr)
      for(Index j2=0; j2<packet_cols4; j2+=nr)
      {
        // We select a LhsProgress x nr micro block of res
        // which is entirely stored into 1 x nr registers.

        const LhsScalar* blA = &blockA[i*strideA+offsetA*(LhsProgress)];
        prefetch(&blA[0]);

        // gets res block as register
        AccPacket C0, C1, C2, C3;
        traits.initAcc(C0);
        traits.initAcc(C1);
        traits.initAcc(C2);
        traits.initAcc(C3);
        // To improve instruction pipelining, let's double the accumulation registers:
        //  even k will accumulate in C*, while odd k will accumulate in D*.
        // This trick is crutial to get good performance with FMA, otherwise it is 
        // actually faster to perform separated MUL+ADD because of a naturally
        // better instruction-level parallelism.
        AccPacket D0, D1, D2, D3;
        traits.initAcc(D0);
        traits.initAcc(D1);
        traits.initAcc(D2);
        traits.initAcc(D3);

        LinearMapper r0 = res.getLinearMapper(i, j2 + 0);
        LinearMapper r1 = res.getLinearMapper(i, j2 + 1);
        LinearMapper r2 = res.getLinearMapper(i, j2 + 2);
        LinearMapper r3 = res.getLinearMapper(i, j2 + 3);

        r0.prefetch(prefetch_res_offset);
        r1.prefetch(prefetch_res_offset);
        r2.prefetch(prefetch_res_offset);
        r3.prefetch(prefetch_res_offset);

        // performs "inner" products
        const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
        prefetch(&blB[0]);
        LhsPacket A0, A1;

        for(Index k=0; k<peeled_kc; k+=pk)
        {
          EIGEN_ASM_COMMENT("begin gebp micro kernel 1/half/quarterX4");
          RhsPacketx4 rhs_panel;
          RhsPacket T0;

          internal::prefetch(blB+(48+0));
          peeled_kc_onestep(0, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
          peeled_kc_onestep(1, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
          peeled_kc_onestep(2, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
          peeled_kc_onestep(3, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
          internal::prefetch(blB+(48+16));
          peeled_kc_onestep(4, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
          peeled_kc_onestep(5, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
          peeled_kc_onestep(6, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
          peeled_kc_onestep(7, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);

          blB += pk*4*RhsProgress;
          blA += pk*LhsProgress;

          EIGEN_ASM_COMMENT("end gebp micro kernel 1/half/quarterX4");
        }
        C0 = padd(C0,D0);
        C1 = padd(C1,D1);
        C2 = padd(C2,D2);
        C3 = padd(C3,D3);

        // process remaining peeled loop
        for(Index k=peeled_kc; k<depth; k++)
        {
          RhsPacketx4 rhs_panel;
          RhsPacket T0;
          peeled_kc_onestep(0, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
          blB += 4*RhsProgress;
          blA += LhsProgress;
        }

        ResPacket R0, R1;
        ResPacket alphav = pset1<ResPacket>(alpha);

        R0 = r0.template loadPacket<ResPacket>(0);
        R1 = r1.template loadPacket<ResPacket>(0);
        traits.acc(C0, alphav, R0);
        traits.acc(C1,  alphav, R1);
        r0.storePacket(0, R0);
        r1.storePacket(0, R1);

        R0 = r2.template loadPacket<ResPacket>(0);
        R1 = r3.template loadPacket<ResPacket>(0);
        traits.acc(C2,  alphav, R0);
        traits.acc(C3,  alphav, R1);
        r2.storePacket(0, R0);
        r3.storePacket(0, R1);
      }

      // Deal with remaining columns of the rhs
      for(Index j2=packet_cols4; j2<cols; j2++)
      {
        // One column at a time
        const LhsScalar* blA = &blockA[i*strideA+offsetA*(LhsProgress)];
        prefetch(&blA[0]);

        // gets res block as register
        AccPacket C0;
        traits.initAcc(C0);

        LinearMapper r0 = res.getLinearMapper(i, j2);

        // performs "inner" products
        const RhsScalar* blB = &blockB[j2*strideB+offsetB];
        LhsPacket A0;

        for(Index k= 0; k<peeled_kc; k+=pk)
        {
          EIGEN_ASM_COMMENT("begin gebp micro kernel 1/half/quarterX1");
          RhsPacket B_0;

#define EIGEN_GEBGP_ONESTEP(K)                                          \
	      do {                                                      \
		EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1/half/quarterX1"); \
		EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
    /* FIXME: why unaligned???? */ \
		traits.loadLhsUnaligned(&blA[(0+1*K)*LhsProgress], A0); \
		traits.loadRhs(&blB[(0+K)*RhsProgress], B_0);		\
		traits.madd(A0, B_0, C0, B_0, fix<0>);				\
		EIGEN_ASM_COMMENT("end step of gebp micro kernel 1/half/quarterX1"); \
	      } while(false);

          EIGEN_GEBGP_ONESTEP(0);
          EIGEN_GEBGP_ONESTEP(1);
          EIGEN_GEBGP_ONESTEP(2);
          EIGEN_GEBGP_ONESTEP(3);
          EIGEN_GEBGP_ONESTEP(4);
          EIGEN_GEBGP_ONESTEP(5);
          EIGEN_GEBGP_ONESTEP(6);
          EIGEN_GEBGP_ONESTEP(7);

          blB += pk*RhsProgress;
          blA += pk*LhsProgress;

          EIGEN_ASM_COMMENT("end gebp micro kernel 1/half/quarterX1");
        }

        // process remaining peeled loop
        for(Index k=peeled_kc; k<depth; k++)
        {
          RhsPacket B_0;
          EIGEN_GEBGP_ONESTEP(0);
          blB += RhsProgress;
          blA += LhsProgress;
        }
#undef EIGEN_GEBGP_ONESTEP
        ResPacket R0;
        ResPacket alphav = pset1<ResPacket>(alpha);
        R0 = r0.template loadPacket<ResPacket>(0);
        traits.acc(C0, alphav, R0);
        r0.storePacket(0, R0);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x650, %rsp            # imm = 0x650
movq 0x58(%rbp), %rax
movq 0x50(%rbp), %rax
movq 0x48(%rbp), %rax
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movl 0x30(%rbp), %eax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x368(%rbp)
movq %rsi, -0x370(%rbp)
movq %rdx, -0x378(%rbp)
movq %rcx, -0x380(%rbp)
movsd %xmm0, -0x388(%rbp)
movq %r8, -0x390(%rbp)
movq %r9, -0x398(%rbp)
movq -0x368(%rbp), %rax
movq %rax, -0x638(%rbp)
movq -0x390(%rbp), %rax
movq %rax, -0x3a8(%rbp)
movq -0x3a8(%rbp), %rax
cmpq -0x398(%rbp), %rax
jge 0x480f8
movq $0x0, -0x3b0(%rbp)
movq -0x3b0(%rbp), %rax
cmpq 0x58(%rbp), %rax
jge 0x47a28
movq -0x378(%rbp), %rax
movq -0x3a8(%rbp), %rcx
imulq 0x10(%rbp), %rcx
movq 0x20(%rbp), %rdx
shlq %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x3b8(%rbp)
movq -0x3b8(%rbp), %rdi
callq 0x46840
leaq -0x399(%rbp), %rdi
leaq -0x3d0(%rbp), %rsi
callq 0x46860
leaq -0x399(%rbp), %rdi
leaq -0x3e0(%rbp), %rsi
callq 0x46860
leaq -0x399(%rbp), %rdi
leaq -0x3f0(%rbp), %rsi
callq 0x46860
leaq -0x399(%rbp), %rdi
leaq -0x400(%rbp), %rsi
callq 0x46860
leaq -0x399(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x46860
leaq -0x399(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x46860
leaq -0x399(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x46860
leaq -0x399(%rbp), %rdi
leaq -0x440(%rbp), %rsi
callq 0x46860
movq -0x370(%rbp), %rdx
movq -0x3a8(%rbp), %rcx
movq -0x3b0(%rbp), %rax
addq $0x0, %rax
movq %rdx, -0x2d0(%rbp)
movq %rcx, -0x2d8(%rbp)
movq %rax, -0x2e0(%rbp)
movq -0x2d0(%rbp), %rdx
movq -0x2d8(%rbp), %rcx
movq -0x2e0(%rbp), %rax
movq %rdx, -0x140(%rbp)
movq %rcx, -0x148(%rbp)
movq %rax, -0x150(%rbp)
movq -0x140(%rbp), %rsi
movq (%rsi), %rax
movq -0x148(%rbp), %rcx
movq -0x150(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
leaq -0x2c8(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq %rax, -0x80(%rbp)
movq $0x1, -0x88(%rbp)
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x1, -0x88(%rbp)
je 0x46daf
leaq 0x73eac(%rip), %rdi     # 0xbac43
leaq 0x73ead(%rip), %rsi     # 0xbac4b
movl $0xa9, %edx
leaq 0x75db2(%rip), %rcx     # 0xbcb5c
callq 0x6340
movq -0x2c8(%rbp), %rax
movq %rax, -0x448(%rbp)
movq -0x370(%rbp), %rdx
movq -0x3a8(%rbp), %rcx
movq -0x3b0(%rbp), %rax
addq $0x1, %rax
movq %rdx, -0x2f0(%rbp)
movq %rcx, -0x2f8(%rbp)
movq %rax, -0x300(%rbp)
movq -0x2f0(%rbp), %rdx
movq -0x2f8(%rbp), %rcx
movq -0x300(%rbp), %rax
movq %rdx, -0x128(%rbp)
movq %rcx, -0x130(%rbp)
movq %rax, -0x138(%rbp)
movq -0x128(%rbp), %rsi
movq (%rsi), %rax
movq -0x130(%rbp), %rcx
movq -0x138(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
leaq -0x2e8(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x68(%rbp)
movq $0x1, -0x70(%rbp)
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x1, -0x70(%rbp)
je 0x46e84
leaq 0x73dd7(%rip), %rdi     # 0xbac43
leaq 0x73dd8(%rip), %rsi     # 0xbac4b
movl $0xa9, %edx
leaq 0x75cdd(%rip), %rcx     # 0xbcb5c
callq 0x6340
movq -0x2e8(%rbp), %rax
movq %rax, -0x450(%rbp)
movq -0x370(%rbp), %rdx
movq -0x3a8(%rbp), %rcx
movq -0x3b0(%rbp), %rax
addq $0x2, %rax
movq %rdx, -0x310(%rbp)
movq %rcx, -0x318(%rbp)
movq %rax, -0x320(%rbp)
movq -0x310(%rbp), %rdx
movq -0x318(%rbp), %rcx
movq -0x320(%rbp), %rax
movq %rdx, -0x110(%rbp)
movq %rcx, -0x118(%rbp)
movq %rax, -0x120(%rbp)
movq -0x110(%rbp), %rsi
movq (%rsi), %rax
movq -0x118(%rbp), %rcx
movq -0x120(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
leaq -0x308(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq $0x1, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x1, -0x58(%rbp)
je 0x46f59
leaq 0x73d02(%rip), %rdi     # 0xbac43
leaq 0x73d03(%rip), %rsi     # 0xbac4b
movl $0xa9, %edx
leaq 0x75c08(%rip), %rcx     # 0xbcb5c
callq 0x6340
movq -0x308(%rbp), %rax
movq %rax, -0x458(%rbp)
movq -0x370(%rbp), %rdx
movq -0x3a8(%rbp), %rcx
movq -0x3b0(%rbp), %rax
addq $0x3, %rax
movq %rdx, -0x330(%rbp)
movq %rcx, -0x338(%rbp)
movq %rax, -0x340(%rbp)
movq -0x330(%rbp), %rdx
movq -0x338(%rbp), %rcx
movq -0x340(%rbp), %rax
movq %rdx, -0xf8(%rbp)
movq %rcx, -0x100(%rbp)
movq %rax, -0x108(%rbp)
movq -0xf8(%rbp), %rsi
movq (%rsi), %rax
movq -0x100(%rbp), %rcx
movq -0x108(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
leaq -0x328(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq $0x1, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x1, -0x40(%rbp)
je 0x4702e
leaq 0x73c2d(%rip), %rdi     # 0xbac43
leaq 0x73c2e(%rip), %rsi     # 0xbac4b
movl $0xa9, %edx
leaq 0x75b33(%rip), %rcx     # 0xbcb5c
callq 0x6340
movq -0x328(%rbp), %rax
movq %rax, -0x460(%rbp)
movl 0x30(%rbp), %eax
leaq -0x448(%rbp), %rcx
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
movq -0x258(%rbp), %rcx
movslq -0x25c(%rbp), %rax
movq %rcx, -0x248(%rbp)
movq %rax, -0x250(%rbp)
movq -0x248(%rbp), %rax
movq (%rax), %rdi
movq -0x250(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x46840
movl 0x30(%rbp), %eax
leaq -0x450(%rbp), %rcx
movq %rcx, -0x278(%rbp)
movl %eax, -0x27c(%rbp)
movq -0x278(%rbp), %rcx
movslq -0x27c(%rbp), %rax
movq %rcx, -0x268(%rbp)
movq %rax, -0x270(%rbp)
movq -0x268(%rbp), %rax
movq (%rax), %rdi
movq -0x270(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x46840
movl 0x30(%rbp), %eax
leaq -0x458(%rbp), %rcx
movq %rcx, -0x298(%rbp)
movl %eax, -0x29c(%rbp)
movq -0x298(%rbp), %rcx
movslq -0x29c(%rbp), %rax
movq %rcx, -0x288(%rbp)
movq %rax, -0x290(%rbp)
movq -0x288(%rbp), %rax
movq (%rax), %rdi
movq -0x290(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x46840
movl 0x30(%rbp), %eax
leaq -0x460(%rbp), %rcx
movq %rcx, -0x2b8(%rbp)
movl %eax, -0x2bc(%rbp)
movq -0x2b8(%rbp), %rcx
movslq -0x2bc(%rbp), %rax
movq %rcx, -0x2a8(%rbp)
movq %rax, -0x2b0(%rbp)
movq -0x2a8(%rbp), %rax
movq (%rax), %rdi
movq -0x2b0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x46840
movq -0x380(%rbp), %rax
movq -0x3b0(%rbp), %rcx
imulq 0x18(%rbp), %rcx
movq 0x28(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x468(%rbp)
movq -0x468(%rbp), %rdi
callq 0x46840
movq $0x0, -0x498(%rbp)
movq -0x498(%rbp), %rax
cmpq 0x38(%rbp), %rax
jge 0x47583
movq -0x468(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
callq 0x46840
movq -0x638(%rbp), %rdi
movq -0x3b8(%rbp), %rdx
movq -0x468(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq -0x480(%rbp), %r8
leaq -0x4e0(%rbp), %r9
leaq -0x4f0(%rbp), %r14
leaq -0x3d0(%rbp), %rbx
leaq -0x3e0(%rbp), %r11
leaq -0x3f0(%rbp), %r10
leaq -0x400(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x484c0
movq -0x638(%rbp), %rdi
movq -0x3b8(%rbp), %rdx
movq -0x468(%rbp), %rcx
movl $0x1, %esi
leaq -0x490(%rbp), %r8
leaq -0x4e0(%rbp), %r9
leaq -0x4f0(%rbp), %r14
leaq -0x410(%rbp), %rbx
leaq -0x420(%rbp), %r11
leaq -0x430(%rbp), %r10
leaq -0x440(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x484c0
movq -0x638(%rbp), %rdi
movq -0x3b8(%rbp), %rdx
movq -0x468(%rbp), %rcx
movl $0x2, %esi
leaq -0x480(%rbp), %r8
leaq -0x4e0(%rbp), %r9
leaq -0x4f0(%rbp), %r14
leaq -0x3d0(%rbp), %rbx
leaq -0x3e0(%rbp), %r11
leaq -0x3f0(%rbp), %r10
leaq -0x400(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x484c0
movq -0x638(%rbp), %rdi
movq -0x3b8(%rbp), %rdx
movq -0x468(%rbp), %rcx
movl $0x3, %esi
leaq -0x490(%rbp), %r8
leaq -0x4e0(%rbp), %r9
leaq -0x4f0(%rbp), %r14
leaq -0x410(%rbp), %rbx
leaq -0x420(%rbp), %r11
leaq -0x430(%rbp), %r10
leaq -0x440(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x484c0
movq -0x468(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0x46840
movq -0x638(%rbp), %rdi
movq -0x3b8(%rbp), %rdx
movq -0x468(%rbp), %rcx
movl $0x4, %esi
leaq -0x480(%rbp), %r8
leaq -0x4e0(%rbp), %r9
leaq -0x4f0(%rbp), %r14
leaq -0x3d0(%rbp), %rbx
leaq -0x3e0(%rbp), %r11
leaq -0x3f0(%rbp), %r10
leaq -0x400(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x484c0
movq -0x638(%rbp), %rdi
movq -0x3b8(%rbp), %rdx
movq -0x468(%rbp), %rcx
movl $0x5, %esi
leaq -0x490(%rbp), %r8
leaq -0x4e0(%rbp), %r9
leaq -0x4f0(%rbp), %r14
leaq -0x410(%rbp), %rbx
leaq -0x420(%rbp), %r11
leaq -0x430(%rbp), %r10
leaq -0x440(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x484c0
movq -0x638(%rbp), %rdi
movq -0x3b8(%rbp), %rdx
movq -0x468(%rbp), %rcx
movl $0x6, %esi
leaq -0x480(%rbp), %r8
leaq -0x4e0(%rbp), %r9
leaq -0x4f0(%rbp), %r14
leaq -0x3d0(%rbp), %rbx
leaq -0x3e0(%rbp), %r11
leaq -0x3f0(%rbp), %r10
leaq -0x400(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x484c0
movq -0x638(%rbp), %rdi
movq -0x3b8(%rbp), %rdx
movq -0x468(%rbp), %rcx
movl $0x7, %esi
leaq -0x490(%rbp), %r8
leaq -0x4e0(%rbp), %r9
leaq -0x4f0(%rbp), %r14
leaq -0x410(%rbp), %rbx
leaq -0x420(%rbp), %r11
leaq -0x430(%rbp), %r10
leaq -0x440(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x484c0
movq 0x40(%rbp), %rax
shlq $0x2, %rax
shlq $0x0, %rax
shlq $0x3, %rax
addq -0x468(%rbp), %rax
movq %rax, -0x468(%rbp)
movq 0x40(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq -0x3b8(%rbp), %rax
movq %rax, -0x3b8(%rbp)
movq 0x40(%rbp), %rax
addq -0x498(%rbp), %rax
movq %rax, -0x498(%rbp)
jmp 0x471bf
leaq -0x3d0(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x35b30
movapd %xmm0, -0x3d0(%rbp)
leaq -0x3e0(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x35b30
movapd %xmm0, -0x3e0(%rbp)
leaq -0x3f0(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x35b30
movapd %xmm0, -0x3f0(%rbp)
leaq -0x400(%rbp), %rdi
leaq -0x440(%rbp), %rsi
callq 0x35b30
movapd %xmm0, -0x400(%rbp)
movq 0x38(%rbp), %rax
movq %rax, -0x500(%rbp)
movq -0x500(%rbp), %rax
cmpq 0x50(%rbp), %rax
jge 0x476ad
movq -0x638(%rbp), %rdi
movq -0x3b8(%rbp), %rdx
movq -0x468(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq -0x480(%rbp), %r8
leaq -0x540(%rbp), %r9
leaq -0x550(%rbp), %r14
leaq -0x3d0(%rbp), %rbx
leaq -0x3e0(%rbp), %r11
leaq -0x3f0(%rbp), %r10
leaq -0x400(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x484c0
movq -0x468(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x468(%rbp)
movq -0x3b8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x3b8(%rbp)
movq -0x500(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x500(%rbp)
jmp 0x475fa
leaq -0x388(%rbp), %rdi
callq 0x3ba00
movapd %xmm0, -0x590(%rbp)
leaq -0x448(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq $0x0, -0x1e0(%rbp)
movq -0x1d8(%rbp), %rax
movq (%rax), %rax
movq -0x1e0(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
callq 0x35b10
movapd %xmm0, -0x570(%rbp)
leaq -0x450(%rbp), %rax
movq %rax, -0x1f0(%rbp)
movq $0x0, -0x1f8(%rbp)
movq -0x1f0(%rbp), %rax
movq (%rax), %rax
movq -0x1f8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x1e8(%rbp)
movq -0x1e8(%rbp), %rdi
callq 0x35b10
movapd %xmm0, -0x580(%rbp)
leaq -0x399(%rbp), %rdi
leaq -0x3d0(%rbp), %rsi
leaq -0x590(%rbp), %rdx
leaq -0x570(%rbp), %rcx
callq 0x46a80
leaq -0x399(%rbp), %rdi
leaq -0x3e0(%rbp), %rsi
leaq -0x590(%rbp), %rdx
leaq -0x580(%rbp), %rcx
callq 0x46a80
leaq -0x448(%rbp), %rax
movq %rax, -0x158(%rbp)
movq $0x0, -0x160(%rbp)
leaq -0x570(%rbp), %rax
movq %rax, -0x168(%rbp)
movq -0x158(%rbp), %rax
movq (%rax), %rcx
movq -0x160(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x168(%rbp), %rax
movq %rcx, -0xd0(%rbp)
movq %rax, -0xd8(%rbp)
movq -0xd0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0x3ba60
leaq -0x450(%rbp), %rax
movq %rax, -0x170(%rbp)
movq $0x0, -0x178(%rbp)
leaq -0x580(%rbp), %rax
movq %rax, -0x180(%rbp)
movq -0x170(%rbp), %rax
movq (%rax), %rcx
movq -0x178(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x180(%rbp), %rax
movq %rcx, -0xc0(%rbp)
movq %rax, -0xc8(%rbp)
movq -0xc0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x3ba60
leaq -0x458(%rbp), %rax
movq %rax, -0x208(%rbp)
movq $0x0, -0x210(%rbp)
movq -0x208(%rbp), %rax
movq (%rax), %rax
movq -0x210(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x200(%rbp)
movq -0x200(%rbp), %rdi
callq 0x35b10
movapd %xmm0, -0x570(%rbp)
leaq -0x460(%rbp), %rax
movq %rax, -0x220(%rbp)
movq $0x0, -0x228(%rbp)
movq -0x220(%rbp), %rax
movq (%rax), %rax
movq -0x228(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x218(%rbp)
movq -0x218(%rbp), %rdi
callq 0x35b10
movapd %xmm0, -0x580(%rbp)
leaq -0x399(%rbp), %rdi
leaq -0x3f0(%rbp), %rsi
leaq -0x590(%rbp), %rdx
leaq -0x570(%rbp), %rcx
callq 0x46a80
leaq -0x399(%rbp), %rdi
leaq -0x400(%rbp), %rsi
leaq -0x590(%rbp), %rdx
leaq -0x580(%rbp), %rcx
callq 0x46a80
leaq -0x458(%rbp), %rax
movq %rax, -0x188(%rbp)
movq $0x0, -0x190(%rbp)
leaq -0x570(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x188(%rbp), %rax
movq (%rax), %rcx
movq -0x190(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x198(%rbp), %rax
movq %rcx, -0xb0(%rbp)
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x3ba60
leaq -0x460(%rbp), %rax
movq %rax, -0x1a0(%rbp)
movq $0x0, -0x1a8(%rbp)
leaq -0x580(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movq -0x1a0(%rbp), %rax
movq (%rax), %rcx
movq -0x1a8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x1b0(%rbp), %rax
movq %rcx, -0xa0(%rbp)
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x3ba60
movq -0x3b0(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x3b0(%rbp)
jmp 0x46c02
movq 0x58(%rbp), %rax
movq %rax, -0x598(%rbp)
movq -0x598(%rbp), %rax
cmpq 0x48(%rbp), %rax
jge 0x480df
movq -0x378(%rbp), %rax
movq -0x3a8(%rbp), %rcx
imulq 0x10(%rbp), %rcx
movq 0x20(%rbp), %rdx
shlq %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x5a0(%rbp)
movq -0x5a0(%rbp), %rdi
callq 0x46840
leaq -0x399(%rbp), %rdi
leaq -0x5b0(%rbp), %rsi
callq 0x46860
movq -0x370(%rbp), %rdx
movq -0x3a8(%rbp), %rcx
movq -0x598(%rbp), %rax
movq %rdx, -0x350(%rbp)
movq %rcx, -0x358(%rbp)
movq %rax, -0x360(%rbp)
movq -0x350(%rbp), %rdx
movq -0x358(%rbp), %rcx
movq -0x360(%rbp), %rax
movq %rdx, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rax, -0xf0(%rbp)
movq -0xe0(%rbp), %rsi
movq (%rsi), %rax
movq -0xe8(%rbp), %rcx
movq -0xf0(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
leaq -0x348(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x1, -0x28(%rbp)
je 0x47b51
leaq 0x7310a(%rip), %rdi     # 0xbac43
leaq 0x7310b(%rip), %rsi     # 0xbac4b
movl $0xa9, %edx
leaq 0x75010(%rip), %rcx     # 0xbcb5c
callq 0x6340
movq -0x348(%rbp), %rax
movq %rax, -0x5b8(%rbp)
movq -0x380(%rbp), %rax
movq -0x598(%rbp), %rcx
imulq 0x18(%rbp), %rcx
addq 0x28(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x5c0(%rbp)
movq $0x0, -0x5d8(%rbp)
movq -0x5d8(%rbp), %rax
cmpq 0x38(%rbp), %rax
jge 0x47f28
movq -0x5a0(%rbp), %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rdx
callq 0x485d0
movq -0x5c0(%rbp), %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5f0(%rbp), %rdx
callq 0x46ac0
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rsi
leaq -0x5f0(%rbp), %r8
leaq -0x5b0(%rbp), %rcx
leaq 0xd2b91(%rip), %r9      # 0x11a788
movq %r8, %rdx
callq 0x46af0
jmp 0x47c01
movq -0x5a0(%rbp), %rsi
addq $0x10, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rdx
callq 0x485d0
movq -0x5c0(%rbp), %rsi
addq $0x8, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5f0(%rbp), %rdx
callq 0x46ac0
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rsi
leaq -0x5f0(%rbp), %r8
leaq -0x5b0(%rbp), %rcx
leaq 0xd2b28(%rip), %r9      # 0x11a788
movq %r8, %rdx
callq 0x46af0
jmp 0x47c6a
movq -0x5a0(%rbp), %rsi
addq $0x20, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rdx
callq 0x485d0
movq -0x5c0(%rbp), %rsi
addq $0x10, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5f0(%rbp), %rdx
callq 0x46ac0
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rsi
leaq -0x5f0(%rbp), %r8
leaq -0x5b0(%rbp), %rcx
leaq 0xd2abf(%rip), %r9      # 0x11a788
movq %r8, %rdx
callq 0x46af0
jmp 0x47cd3
movq -0x5a0(%rbp), %rsi
addq $0x30, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rdx
callq 0x485d0
movq -0x5c0(%rbp), %rsi
addq $0x18, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5f0(%rbp), %rdx
callq 0x46ac0
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rsi
leaq -0x5f0(%rbp), %r8
leaq -0x5b0(%rbp), %rcx
leaq 0xd2a56(%rip), %r9      # 0x11a788
movq %r8, %rdx
callq 0x46af0
jmp 0x47d3c
movq -0x5a0(%rbp), %rsi
addq $0x40, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rdx
callq 0x485d0
movq -0x5c0(%rbp), %rsi
addq $0x20, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5f0(%rbp), %rdx
callq 0x46ac0
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rsi
leaq -0x5f0(%rbp), %r8
leaq -0x5b0(%rbp), %rcx
leaq 0xd29ed(%rip), %r9      # 0x11a788
movq %r8, %rdx
callq 0x46af0
jmp 0x47da5
movq -0x5a0(%rbp), %rsi
addq $0x50, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rdx
callq 0x485d0
movq -0x5c0(%rbp), %rsi
addq $0x28, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5f0(%rbp), %rdx
callq 0x46ac0
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rsi
leaq -0x5f0(%rbp), %r8
leaq -0x5b0(%rbp), %rcx
leaq 0xd2984(%rip), %r9      # 0x11a788
movq %r8, %rdx
callq 0x46af0
jmp 0x47e0e
movq -0x5a0(%rbp), %rsi
addq $0x60, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rdx
callq 0x485d0
movq -0x5c0(%rbp), %rsi
addq $0x30, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5f0(%rbp), %rdx
callq 0x46ac0
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rsi
leaq -0x5f0(%rbp), %r8
leaq -0x5b0(%rbp), %rcx
leaq 0xd291b(%rip), %r9      # 0x11a788
movq %r8, %rdx
callq 0x46af0
jmp 0x47e77
movq -0x5a0(%rbp), %rsi
addq $0x70, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rdx
callq 0x485d0
movq -0x5c0(%rbp), %rsi
addq $0x38, %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5f0(%rbp), %rdx
callq 0x46ac0
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rsi
leaq -0x5f0(%rbp), %r8
leaq -0x5b0(%rbp), %rcx
leaq 0xd28b2(%rip), %r9      # 0x11a788
movq %r8, %rdx
callq 0x46af0
movq 0x40(%rbp), %rax
shlq $0x0, %rax
shlq $0x3, %rax
addq -0x5c0(%rbp), %rax
movq %rax, -0x5c0(%rbp)
movq 0x40(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq -0x5a0(%rbp), %rax
movq %rax, -0x5a0(%rbp)
movq 0x40(%rbp), %rax
addq -0x5d8(%rbp), %rax
movq %rax, -0x5d8(%rbp)
jmp 0x47b8f
movq 0x38(%rbp), %rax
movq %rax, -0x5f8(%rbp)
movq -0x5f8(%rbp), %rax
cmpq 0x50(%rbp), %rax
jge 0x47fe0
jmp 0x47f46
movq -0x5a0(%rbp), %rsi
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rdx
callq 0x485d0
movq -0x5c0(%rbp), %rsi
leaq -0x399(%rbp), %rdi
leaq -0x610(%rbp), %rdx
callq 0x46ac0
leaq -0x399(%rbp), %rdi
leaq -0x5d0(%rbp), %rsi
leaq -0x610(%rbp), %r8
leaq -0x5b0(%rbp), %rcx
leaq 0xd27eb(%rip), %r9      # 0x11a788
movq %r8, %rdx
callq 0x46af0
movq -0x5c0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x5c0(%rbp)
movq -0x5a0(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x5a0(%rbp)
movq -0x5f8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x5f8(%rbp)
jmp 0x47f33
leaq -0x388(%rbp), %rdi
callq 0x3ba00
movapd %xmm0, -0x630(%rbp)
leaq -0x5b8(%rbp), %rax
movq %rax, -0x238(%rbp)
movq $0x0, -0x240(%rbp)
movq -0x238(%rbp), %rax
movq (%rax), %rax
movq -0x240(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rdi
callq 0x35b10
movapd %xmm0, -0x620(%rbp)
leaq -0x399(%rbp), %rdi
leaq -0x5b0(%rbp), %rsi
leaq -0x630(%rbp), %rdx
leaq -0x620(%rbp), %rcx
callq 0x46a80
leaq -0x5b8(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movq $0x0, -0x1c0(%rbp)
leaq -0x620(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq -0x1b8(%rbp), %rax
movq (%rax), %rcx
movq -0x1c0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x1c8(%rbp), %rax
movq %rcx, -0x90(%rbp)
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x3ba60
movq -0x598(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x598(%rbp)
jmp 0x47a33
jmp 0x480e1
movq -0x3a8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x3a8(%rbp)
jmp 0x46be3
addq $0x650, %rsp            # imm = 0x650
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop