void bn_sqr_comba8(unsigned long *r, const unsigned long *a) {
  unsigned long t1, t2;
  unsigned long c1, c2, c3;
  c1 = 0;
  c2 = 0;
  c3 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[0]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+r"(c3) : "d"(t2), "g"(0) : "cc");
  } while (0);
  r[0] = c1;
  c1 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[1]), "m"((a)[0]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[1] = c2;
  c2 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[1]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+r"(c2) : "d"(t2), "g"(0) : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[2]), "m"((a)[0]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[2] = c3;
  c3 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[3]), "m"((a)[0]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[2]), "m"((a)[1]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[3] = c1;
  c1 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[2]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+r"(c1) : "d"(t2), "g"(0) : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[3]), "m"((a)[1]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[4]), "m"((a)[0]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[4] = c2;
  c2 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[5]), "m"((a)[0]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[4]), "m"((a)[1]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[3]), "m"((a)[2]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[5] = c3;
  c3 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[3]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+r"(c3) : "d"(t2), "g"(0) : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[4]), "m"((a)[2]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[5]), "m"((a)[1]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[6]), "m"((a)[0]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[6] = c1;
  c1 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[7]), "m"((a)[0]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[6]), "m"((a)[1]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[5]), "m"((a)[2]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[4]), "m"((a)[3]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[7] = c2;
  c2 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[4]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+r"(c2) : "d"(t2), "g"(0) : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[5]), "m"((a)[3]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[6]), "m"((a)[2]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[7]), "m"((a)[1]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[8] = c3;
  c3 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[7]), "m"((a)[2]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[6]), "m"((a)[3]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[5]), "m"((a)[4]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[9] = c1;
  c1 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[5]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+r"(c1) : "d"(t2), "g"(0) : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[6]), "m"((a)[4]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[7]), "m"((a)[3]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[10] = c2;
  c2 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[7]), "m"((a)[4]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[6]), "m"((a)[5]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[11] = c3;
  c3 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[6]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+r"(c3) : "d"(t2), "g"(0) : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[7]), "m"((a)[5]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[12] = c1;
  c1 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[7]), "m"((a)[6]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[13] = c2;
  c2 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[7]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+r"(c2) : "d"(t2), "g"(0) : "cc");
  } while (0);
  r[14] = c3;
  r[15] = c1;
}


x86 assembly (clang, -O0):
<bn_sqr_comba8>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x10(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x8(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1252 <bn_sqr_comba8+0x152>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x10(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x10(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1341 <bn_sqr_comba8+0x241>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x18(%rax)
movq   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
jmp    1415 <bn_sqr_comba8+0x315>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
jmp    1489 <bn_sqr_comba8+0x389>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x10(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x20(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x10(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1578 <bn_sqr_comba8+0x478>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
jmp    15ec <bn_sqr_comba8+0x4ec>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x28(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    16c0 <bn_sqr_comba8+0x5c0>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1734 <bn_sqr_comba8+0x634>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    17a8 <bn_sqr_comba8+0x6a8>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x10(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x30(%rax)
movq   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x10(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
jmp    1897 <bn_sqr_comba8+0x797>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
jmp    190b <bn_sqr_comba8+0x80b>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
jmp    197f <bn_sqr_comba8+0x87f>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x18,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x38(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1a53 <bn_sqr_comba8+0x953>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x18,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1ac7 <bn_sqr_comba8+0x9c7>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1b3b <bn_sqr_comba8+0xa3b>
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x40(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1c32 <bn_sqr_comba8+0xb32>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x18,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1ca6 <bn_sqr_comba8+0xba6>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x20,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x48(%rax)
movq   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
jmp    1d7a <bn_sqr_comba8+0xc7a>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x20,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
jmp    1dee <bn_sqr_comba8+0xcee>
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x18,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x50(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x20,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1ee5 <bn_sqr_comba8+0xde5>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x28,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x58(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1fb9 <bn_sqr_comba8+0xeb9>
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x28,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x60(%rax)
movq   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x30,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x68(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x70(%rax)
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x78(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<bn_sqr_comba8>:
mov    (%rsi),%rax
mul    %rax
xor    %r8d,%r8d
xor    %ecx,%ecx
add    %rax,%rcx
adc    $0x0,%rdx
xor    %r10d,%r10d
xor    %r9d,%r9d
add    %rdx,%r10
adc    $0x0,%r9
mov    %rcx,(%rdi)
mov    0x8(%rsi),%rax
mulq   (%rsi)
xor    %ecx,%ecx
add    %rax,%r10
adc    %rdx,%r9
adc    $0x0,%rcx
add    %rax,%r10
adc    %rdx,%r9
adc    $0x0,%rcx
mov    %r10,0x8(%rdi)
mov    0x8(%rsi),%rax
mul    %rax
add    %rax,%r9
adc    $0x0,%rdx
xor    %r11d,%r11d
add    %rdx,%rcx
adc    $0x0,%r11
mov    0x10(%rsi),%rax
mulq   (%rsi)
add    %rax,%r9
adc    %rdx,%rcx
adc    $0x0,%r11
add    %rax,%r9
adc    %rdx,%rcx
adc    $0x0,%r11
mov    %r9,0x10(%rdi)
mov    0x18(%rsi),%rax
mulq   (%rsi)
xor    %r9d,%r9d
add    %rax,%rcx
adc    %rdx,%r11
adc    $0x0,%r9
add    %rax,%rcx
adc    %rdx,%r11
adc    $0x0,%r9
mov    0x10(%rsi),%rax
mulq   0x8(%rsi)
add    %rax,%rcx
adc    %rdx,%r11
adc    $0x0,%r9
add    %rax,%rcx
adc    %rdx,%r11
adc    $0x0,%r9
mov    %rcx,0x18(%rdi)
mov    0x10(%rsi),%rax
mul    %rax
add    %rax,%r11
adc    $0x0,%rdx
xor    %r10d,%r10d
add    %rdx,%r9
adc    $0x0,%r10
mov    0x18(%rsi),%rax
mulq   0x8(%rsi)
add    %rax,%r11
adc    %rdx,%r9
adc    $0x0,%r10
add    %rax,%r11
adc    %rdx,%r9
adc    $0x0,%r10
mov    0x20(%rsi),%rax
mulq   (%rsi)
add    %rax,%r11
adc    %rdx,%r9
adc    $0x0,%r10
add    %rax,%r11
adc    %rdx,%r9
adc    $0x0,%r10
mov    %r11,0x20(%rdi)
mov    0x28(%rsi),%rax
mulq   (%rsi)
xor    %ecx,%ecx
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%rcx
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%rcx
mov    0x20(%rsi),%rax
mulq   0x8(%rsi)
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%rcx
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%rcx
mov    0x18(%rsi),%rax
mulq   0x10(%rsi)
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%rcx
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%rcx
mov    %r9,0x28(%rdi)
mov    0x18(%rsi),%rax
mul    %rax
add    %rax,%r10
adc    $0x0,%rdx
xor    %r9d,%r9d
add    %rdx,%rcx
adc    $0x0,%r9
mov    0x20(%rsi),%rax
mulq   0x10(%rsi)
add    %rax,%r10
adc    %rdx,%rcx
adc    $0x0,%r9
add    %rax,%r10
adc    %rdx,%rcx
adc    $0x0,%r9
mov    0x28(%rsi),%rax
mulq   0x8(%rsi)
add    %rax,%r10
adc    %rdx,%rcx
adc    $0x0,%r9
add    %rax,%r10
adc    %rdx,%rcx
adc    $0x0,%r9
mov    0x30(%rsi),%rax
mulq   (%rsi)
add    %rax,%r10
adc    %rdx,%rcx
adc    $0x0,%r9
add    %rax,%r10
adc    %rdx,%rcx
adc    $0x0,%r9
mov    %r10,0x30(%rdi)
mov    0x38(%rsi),%rax
mulq   (%rsi)
xor    %r10d,%r10d
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
mov    0x30(%rsi),%rax
mulq   0x8(%rsi)
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
mov    0x28(%rsi),%rax
mulq   0x10(%rsi)
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
mov    0x20(%rsi),%rax
mulq   0x18(%rsi)
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
mov    %rcx,0x38(%rdi)
mov    0x20(%rsi),%rax
mul    %rax
add    %rax,%r9
adc    $0x0,%rdx
xor    %r11d,%r11d
add    %rdx,%r10
adc    $0x0,%r11
mov    0x28(%rsi),%rax
mulq   0x18(%rsi)
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%r11
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%r11
mov    0x30(%rsi),%rax
mulq   0x10(%rsi)
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%r11
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%r11
mov    0x38(%rsi),%rax
mulq   0x8(%rsi)
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%r11
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%r11
mov    %r9,0x40(%rdi)
mov    0x38(%rsi),%rax
mulq   0x10(%rsi)
xor    %ecx,%ecx
add    %rax,%r10
adc    %rdx,%r11
adc    $0x0,%rcx
add    %rax,%r10
adc    %rdx,%r11
adc    $0x0,%rcx
mov    0x30(%rsi),%rax
mulq   0x18(%rsi)
add    %rax,%r10
adc    %rdx,%r11
adc    $0x0,%rcx
add    %rax,%r10
adc    %rdx,%r11
adc    $0x0,%rcx
mov    0x28(%rsi),%rax
mulq   0x20(%rsi)
add    %rax,%r10
adc    %rdx,%r11
adc    $0x0,%rcx
add    %rax,%r10
adc    %rdx,%r11
adc    $0x0,%rcx
mov    %r10,0x48(%rdi)
mov    0x28(%rsi),%rax
mul    %rax
add    %rax,%r11
adc    $0x0,%rdx
xor    %r9d,%r9d
add    %rdx,%rcx
adc    $0x0,%r9
mov    0x30(%rsi),%rax
mulq   0x20(%rsi)
add    %rax,%r11
adc    %rdx,%rcx
adc    $0x0,%r9
add    %rax,%r11
adc    %rdx,%rcx
adc    $0x0,%r9
mov    0x38(%rsi),%rax
mulq   0x18(%rsi)
add    %rax,%r11
adc    %rdx,%rcx
adc    $0x0,%r9
add    %rax,%r11
adc    %rdx,%rcx
adc    $0x0,%r9
mov    %r11,0x50(%rdi)
mov    0x38(%rsi),%rax
mulq   0x20(%rsi)
xor    %r10d,%r10d
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
mov    0x30(%rsi),%rax
mulq   0x28(%rsi)
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
mov    %rcx,0x58(%rdi)
mov    0x30(%rsi),%rax
mul    %rax
add    %rax,%r9
adc    $0x0,%rdx
xor    %ecx,%ecx
add    %rdx,%r10
adc    $0x0,%rcx
mov    0x38(%rsi),%rax
mulq   0x28(%rsi)
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%rcx
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%rcx
mov    %r9,0x60(%rdi)
mov    0x38(%rsi),%rax
mulq   0x30(%rsi)
xor    %r9d,%r9d
add    %rax,%r10
adc    %rdx,%rcx
adc    $0x0,%r9
add    %rax,%r10
adc    %rdx,%rcx
adc    $0x0,%r9
mov    %r10,0x68(%rdi)
mov    0x38(%rsi),%rax
mul    %rax
add    %rax,%rcx
adc    $0x0,%rdx
add    %rdx,%r9
adc    $0x0,%r8
mov    %rcx,0x70(%rdi)
mov    %r9,0x78(%rdi)
ret

LLVM IR (-O0):
define void @bn_sqr_comba8(i64* %0, i64* %1) {
%3 = alloca i64*
%4 = alloca i64*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
store i64* %0, i64** %3
store i64* %1, i64** %4
store i64 0, i64* %7
store i64 0, i64* %8
store i64 0, i64* %9
br label %10
10: ; preds = %2
%11 = load i64*, i64** %4
%12 = getelementptr inbounds i64, i64* %11, i64 0
%13 = load i64, i64* %12
%14 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %13)
%15 = extractvalue { i64, i64 } %14, 0
%16 = extractvalue { i64, i64 } %14, 1
store i64 %15, i64* %5
store i64 %16, i64* %6
%17 = load i64, i64* %7
%18 = load i64, i64* %6
%19 = load i64, i64* %5
%20 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %19, i32 0, i64 %17, i64 %18)
%21 = extractvalue { i64, i64 } %20, 0
%22 = extractvalue { i64, i64 } %20, 1
store i64 %21, i64* %7
store i64 %22, i64* %6
%23 = load i64, i64* %8
%24 = load i64, i64* %9
%25 = load i64, i64* %6
%26 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %25, i32 0, i64 %23, i64 %24)
%27 = extractvalue { i64, i64 } %26, 0
%28 = extractvalue { i64, i64 } %26, 1
store i64 %27, i64* %8
store i64 %28, i64* %9
br label %29
29: ; preds = %10
%30 = load i64, i64* %7
%31 = load i64*, i64** %3
%32 = getelementptr inbounds i64, i64* %31, i64 0
store i64 %30, i64* %32
store i64 0, i64* %7
br label %33
33: ; preds = %29
%34 = load i64*, i64** %4
%35 = getelementptr inbounds i64, i64* %34, i64 1
%36 = load i64, i64* %35
%37 = load i64*, i64** %4
%38 = getelementptr inbounds i64, i64* %37, i64 0
%39 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %36, i64* elementtype(i64) %38)
%40 = extractvalue { i64, i64 } %39, 0
%41 = extractvalue { i64, i64 } %39, 1
store i64 %40, i64* %5
store i64 %41, i64* %6
%42 = load i64, i64* %8
%43 = load i64, i64* %9
%44 = load i64, i64* %7
%45 = load i64, i64* %5
%46 = load i64, i64* %6
%47 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %45, i64 %46, i32 0, i64 %42, i64 %43, i64 %44)
%48 = extractvalue { i64, i64, i64 } %47, 0
%49 = extractvalue { i64, i64, i64 } %47, 1
%50 = extractvalue { i64, i64, i64 } %47, 2
store i64 %48, i64* %8
store i64 %49, i64* %9
store i64 %50, i64* %7
%51 = load i64, i64* %8
%52 = load i64, i64* %9
%53 = load i64, i64* %7
%54 = load i64, i64* %5
%55 = load i64, i64* %6
%56 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %54, i64 %55, i32 0, i64 %51, i64 %52, i64 %53)
%57 = extractvalue { i64, i64, i64 } %56, 0
%58 = extractvalue { i64, i64, i64 } %56, 1
%59 = extractvalue { i64, i64, i64 } %56, 2
store i64 %57, i64* %8
store i64 %58, i64* %9
store i64 %59, i64* %7
br label %60
60: ; preds = %33
%61 = load i64, i64* %8
%62 = load i64*, i64** %3
%63 = getelementptr inbounds i64, i64* %62, i64 1
store i64 %61, i64* %63
store i64 0, i64* %8
br label %64
64: ; preds = %60
%65 = load i64*, i64** %4
%66 = getelementptr inbounds i64, i64* %65, i64 1
%67 = load i64, i64* %66
%68 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %67)
%69 = extractvalue { i64, i64 } %68, 0
%70 = extractvalue { i64, i64 } %68, 1
store i64 %69, i64* %5
store i64 %70, i64* %6
%71 = load i64, i64* %9
%72 = load i64, i64* %6
%73 = load i64, i64* %5
%74 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %73, i32 0, i64 %71, i64 %72)
%75 = extractvalue { i64, i64 } %74, 0
%76 = extractvalue { i64, i64 } %74, 1
store i64 %75, i64* %9
store i64 %76, i64* %6
%77 = load i64, i64* %7
%78 = load i64, i64* %8
%79 = load i64, i64* %6
%80 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %79, i32 0, i64 %77, i64 %78)
%81 = extractvalue { i64, i64 } %80, 0
%82 = extractvalue { i64, i64 } %80, 1
store i64 %81, i64* %7
store i64 %82, i64* %8
br label %83
83: ; preds = %64
br label %84
84: ; preds = %83
%85 = load i64*, i64** %4
%86 = getelementptr inbounds i64, i64* %85, i64 2
%87 = load i64, i64* %86
%88 = load i64*, i64** %4
%89 = getelementptr inbounds i64, i64* %88, i64 0
%90 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %87, i64* elementtype(i64) %89)
%91 = extractvalue { i64, i64 } %90, 0
%92 = extractvalue { i64, i64 } %90, 1
store i64 %91, i64* %5
store i64 %92, i64* %6
%93 = load i64, i64* %9
%94 = load i64, i64* %7
%95 = load i64, i64* %8
%96 = load i64, i64* %5
%97 = load i64, i64* %6
%98 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %96, i64 %97, i32 0, i64 %93, i64 %94, i64 %95)
%99 = extractvalue { i64, i64, i64 } %98, 0
%100 = extractvalue { i64, i64, i64 } %98, 1
%101 = extractvalue { i64, i64, i64 } %98, 2
store i64 %99, i64* %9
store i64 %100, i64* %7
store i64 %101, i64* %8
%102 = load i64, i64* %9
%103 = load i64, i64* %7
%104 = load i64, i64* %8
%105 = load i64, i64* %5
%106 = load i64, i64* %6
%107 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %105, i64 %106, i32 0, i64 %102, i64 %103, i64 %104)
%108 = extractvalue { i64, i64, i64 } %107, 0
%109 = extractvalue { i64, i64, i64 } %107, 1
%110 = extractvalue { i64, i64, i64 } %107, 2
store i64 %108, i64* %9
store i64 %109, i64* %7
store i64 %110, i64* %8
br label %111
111: ; preds = %84
%112 = load i64, i64* %9
%113 = load i64*, i64** %3
%114 = getelementptr inbounds i64, i64* %113, i64 2
store i64 %112, i64* %114
store i64 0, i64* %9
br label %115
115: ; preds = %111
%116 = load i64*, i64** %4
%117 = getelementptr inbounds i64, i64* %116, i64 3
%118 = load i64, i64* %117
%119 = load i64*, i64** %4
%120 = getelementptr inbounds i64, i64* %119, i64 0
%121 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %118, i64* elementtype(i64) %120)
%122 = extractvalue { i64, i64 } %121, 0
%123 = extractvalue { i64, i64 } %121, 1
store i64 %122, i64* %5
store i64 %123, i64* %6
%124 = load i64, i64* %7
%125 = load i64, i64* %8
%126 = load i64, i64* %9
%127 = load i64, i64* %5
%128 = load i64, i64* %6
%129 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %127, i64 %128, i32 0, i64 %124, i64 %125, i64 %126)
%130 = extractvalue { i64, i64, i64 } %129, 0
%131 = extractvalue { i64, i64, i64 } %129, 1
%132 = extractvalue { i64, i64, i64 } %129, 2
store i64 %130, i64* %7
store i64 %131, i64* %8
store i64 %132, i64* %9
%133 = load i64, i64* %7
%134 = load i64, i64* %8
%135 = load i64, i64* %9
%136 = load i64, i64* %5
%137 = load i64, i64* %6
%138 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %136, i64 %137, i32 0, i64 %133, i64 %134, i64 %135)
%139 = extractvalue { i64, i64, i64 } %138, 0
%140 = extractvalue { i64, i64, i64 } %138, 1
%141 = extractvalue { i64, i64, i64 } %138, 2
store i64 %139, i64* %7
store i64 %140, i64* %8
store i64 %141, i64* %9
br label %142
142: ; preds = %115
br label %143
143: ; preds = %142
%144 = load i64*, i64** %4
%145 = getelementptr inbounds i64, i64* %144, i64 2
%146 = load i64, i64* %145
%147 = load i64*, i64** %4
%148 = getelementptr inbounds i64, i64* %147, i64 1
%149 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %146, i64* elementtype(i64) %148)
%150 = extractvalue { i64, i64 } %149, 0
%151 = extractvalue { i64, i64 } %149, 1
store i64 %150, i64* %5
store i64 %151, i64* %6
%152 = load i64, i64* %7
%153 = load i64, i64* %8
%154 = load i64, i64* %9
%155 = load i64, i64* %5
%156 = load i64, i64* %6
%157 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %155, i64 %156, i32 0, i64 %152, i64 %153, i64 %154)
%158 = extractvalue { i64, i64, i64 } %157, 0
%159 = extractvalue { i64, i64, i64 } %157, 1
%160 = extractvalue { i64, i64, i64 } %157, 2
store i64 %158, i64* %7
store i64 %159, i64* %8
store i64 %160, i64* %9
%161 = load i64, i64* %7
%162 = load i64, i64* %8
%163 = load i64, i64* %9
%164 = load i64, i64* %5
%165 = load i64, i64* %6
%166 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %164, i64 %165, i32 0, i64 %161, i64 %162, i64 %163)
%167 = extractvalue { i64, i64, i64 } %166, 0
%168 = extractvalue { i64, i64, i64 } %166, 1
%169 = extractvalue { i64, i64, i64 } %166, 2
store i64 %167, i64* %7
store i64 %168, i64* %8
store i64 %169, i64* %9
br label %170
170: ; preds = %143
%171 = load i64, i64* %7
%172 = load i64*, i64** %3
%173 = getelementptr inbounds i64, i64* %172, i64 3
store i64 %171, i64* %173
store i64 0, i64* %7
br label %174
174: ; preds = %170
%175 = load i64*, i64** %4
%176 = getelementptr inbounds i64, i64* %175, i64 2
%177 = load i64, i64* %176
%178 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %177)
%179 = extractvalue { i64, i64 } %178, 0
%180 = extractvalue { i64, i64 } %178, 1
store i64 %179, i64* %5
store i64 %180, i64* %6
%181 = load i64, i64* %8
%182 = load i64, i64* %6
%183 = load i64, i64* %5
%184 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %183, i32 0, i64 %181, i64 %182)
%185 = extractvalue { i64, i64 } %184, 0
%186 = extractvalue { i64, i64 } %184, 1
store i64 %185, i64* %8
store i64 %186, i64* %6
%187 = load i64, i64* %9
%188 = load i64, i64* %7
%189 = load i64, i64* %6
%190 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %189, i32 0, i64 %187, i64 %188)
%191 = extractvalue { i64, i64 } %190, 0
%192 = extractvalue { i64, i64 } %190, 1
store i64 %191, i64* %9
store i64 %192, i64* %7
br label %193
193: ; preds = %174
br label %194
194: ; preds = %193
%195 = load i64*, i64** %4
%196 = getelementptr inbounds i64, i64* %195, i64 3
%197 = load i64, i64* %196
%198 = load i64*, i64** %4
%199 = getelementptr inbounds i64, i64* %198, i64 1
%200 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %197, i64* elementtype(i64) %199)
%201 = extractvalue { i64, i64 } %200, 0
%202 = extractvalue { i64, i64 } %200, 1
store i64 %201, i64* %5
store i64 %202, i64* %6
%203 = load i64, i64* %8
%204 = load i64, i64* %9
%205 = load i64, i64* %7
%206 = load i64, i64* %5
%207 = load i64, i64* %6
%208 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %206, i64 %207, i32 0, i64 %203, i64 %204, i64 %205)
%209 = extractvalue { i64, i64, i64 } %208, 0
%210 = extractvalue { i64, i64, i64 } %208, 1
%211 = extractvalue { i64, i64, i64 } %208, 2
store i64 %209, i64* %8
store i64 %210, i64* %9
store i64 %211, i64* %7
%212 = load i64, i64* %8
%213 = load i64, i64* %9
%214 = load i64, i64* %7
%215 = load i64, i64* %5
%216 = load i64, i64* %6
%217 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %215, i64 %216, i32 0, i64 %212, i64 %213, i64 %214)
%218 = extractvalue { i64, i64, i64 } %217, 0
%219 = extractvalue { i64, i64, i64 } %217, 1
%220 = extractvalue { i64, i64, i64 } %217, 2
store i64 %218, i64* %8
store i64 %219, i64* %9
store i64 %220, i64* %7
br label %221
221: ; preds = %194
br label %222
222: ; preds = %221
%223 = load i64*, i64** %4
%224 = getelementptr inbounds i64, i64* %223, i64 4
%225 = load i64, i64* %224
%226 = load i64*, i64** %4
%227 = getelementptr inbounds i64, i64* %226, i64 0
%228 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %225, i64* elementtype(i64) %227)
%229 = extractvalue { i64, i64 } %228, 0
%230 = extractvalue { i64, i64 } %228, 1
store i64 %229, i64* %5
store i64 %230, i64* %6
%231 = load i64, i64* %8
%232 = load i64, i64* %9
%233 = load i64, i64* %7
%234 = load i64, i64* %5
%235 = load i64, i64* %6
%236 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %234, i64 %235, i32 0, i64 %231, i64 %232, i64 %233)
%237 = extractvalue { i64, i64, i64 } %236, 0
%238 = extractvalue { i64, i64, i64 } %236, 1
%239 = extractvalue { i64, i64, i64 } %236, 2
store i64 %237, i64* %8
store i64 %238, i64* %9
store i64 %239, i64* %7
%240 = load i64, i64* %8
%241 = load i64, i64* %9
%242 = load i64, i64* %7
%243 = load i64, i64* %5
%244 = load i64, i64* %6
%245 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %243, i64 %244, i32 0, i64 %240, i64 %241, i64 %242)
%246 = extractvalue { i64, i64, i64 } %245, 0
%247 = extractvalue { i64, i64, i64 } %245, 1
%248 = extractvalue { i64, i64, i64 } %245, 2
store i64 %246, i64* %8
store i64 %247, i64* %9
store i64 %248, i64* %7
br label %249
249: ; preds = %222
%250 = load i64, i64* %8
%251 = load i64*, i64** %3
%252 = getelementptr inbounds i64, i64* %251, i64 4
store i64 %250, i64* %252
store i64 0, i64* %8
br label %253
253: ; preds = %249
%254 = load i64*, i64** %4
%255 = getelementptr inbounds i64, i64* %254, i64 5
%256 = load i64, i64* %255
%257 = load i64*, i64** %4
%258 = getelementptr inbounds i64, i64* %257, i64 0
%259 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %256, i64* elementtype(i64) %258)
%260 = extractvalue { i64, i64 } %259, 0
%261 = extractvalue { i64, i64 } %259, 1
store i64 %260, i64* %5
store i64 %261, i64* %6
%262 = load i64, i64* %9
%263 = load i64, i64* %7
%264 = load i64, i64* %8
%265 = load i64, i64* %5
%266 = load i64, i64* %6
%267 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %265, i64 %266, i32 0, i64 %262, i64 %263, i64 %264)
%268 = extractvalue { i64, i64, i64 } %267, 0
%269 = extractvalue { i64, i64, i64 } %267, 1
%270 = extractvalue { i64, i64, i64 } %267, 2
store i64 %268, i64* %9
store i64 %269, i64* %7
store i64 %270, i64* %8
%271 = load i64, i64* %9
%272 = load i64, i64* %7
%273 = load i64, i64* %8
%274 = load i64, i64* %5
%275 = load i64, i64* %6
%276 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %274, i64 %275, i32 0, i64 %271, i64 %272, i64 %273)
%277 = extractvalue { i64, i64, i64 } %276, 0
%278 = extractvalue { i64, i64, i64 } %276, 1
%279 = extractvalue { i64, i64, i64 } %276, 2
store i64 %277, i64* %9
store i64 %278, i64* %7
store i64 %279, i64* %8
br label %280
280: ; preds = %253
br label %281
281: ; preds = %280
%282 = load i64*, i64** %4
%283 = getelementptr inbounds i64, i64* %282, i64 4
%284 = load i64, i64* %283
%285 = load i64*, i64** %4
%286 = getelementptr inbounds i64, i64* %285, i64 1
%287 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %284, i64* elementtype(i64) %286)
%288 = extractvalue { i64, i64 } %287, 0
%289 = extractvalue { i64, i64 } %287, 1
store i64 %288, i64* %5
store i64 %289, i64* %6
%290 = load i64, i64* %9
%291 = load i64, i64* %7
%292 = load i64, i64* %8
%293 = load i64, i64* %5
%294 = load i64, i64* %6
%295 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %293, i64 %294, i32 0, i64 %290, i64 %291, i64 %292)
%296 = extractvalue { i64, i64, i64 } %295, 0
%297 = extractvalue { i64, i64, i64 } %295, 1
%298 = extractvalue { i64, i64, i64 } %295, 2
store i64 %296, i64* %9
store i64 %297, i64* %7
store i64 %298, i64* %8
%299 = load i64, i64* %9
%300 = load i64, i64* %7
%301 = load i64, i64* %8
%302 = load i64, i64* %5
%303 = load i64, i64* %6
%304 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %302, i64 %303, i32 0, i64 %299, i64 %300, i64 %301)
%305 = extractvalue { i64, i64, i64 } %304, 0
%306 = extractvalue { i64, i64, i64 } %304, 1
%307 = extractvalue { i64, i64, i64 } %304, 2
store i64 %305, i64* %9
store i64 %306, i64* %7
store i64 %307, i64* %8
br label %308
308: ; preds = %281
br label %309
309: ; preds = %308
%310 = load i64*, i64** %4
%311 = getelementptr inbounds i64, i64* %310, i64 3
%312 = load i64, i64* %311
%313 = load i64*, i64** %4
%314 = getelementptr inbounds i64, i64* %313, i64 2
%315 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %312, i64* elementtype(i64) %314)
%316 = extractvalue { i64, i64 } %315, 0
%317 = extractvalue { i64, i64 } %315, 1
store i64 %316, i64* %5
store i64 %317, i64* %6
%318 = load i64, i64* %9
%319 = load i64, i64* %7
%320 = load i64, i64* %8
%321 = load i64, i64* %5
%322 = load i64, i64* %6
%323 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %321, i64 %322, i32 0, i64 %318, i64 %319, i64 %320)
%324 = extractvalue { i64, i64, i64 } %323, 0
%325 = extractvalue { i64, i64, i64 } %323, 1
%326 = extractvalue { i64, i64, i64 } %323, 2
store i64 %324, i64* %9
store i64 %325, i64* %7
store i64 %326, i64* %8
%327 = load i64, i64* %9
%328 = load i64, i64* %7
%329 = load i64, i64* %8
%330 = load i64, i64* %5
%331 = load i64, i64* %6
%332 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %330, i64 %331, i32 0, i64 %327, i64 %328, i64 %329)
%333 = extractvalue { i64, i64, i64 } %332, 0
%334 = extractvalue { i64, i64, i64 } %332, 1
%335 = extractvalue { i64, i64, i64 } %332, 2
store i64 %333, i64* %9
store i64 %334, i64* %7
store i64 %335, i64* %8
br label %336
336: ; preds = %309
%337 = load i64, i64* %9
%338 = load i64*, i64** %3
%339 = getelementptr inbounds i64, i64* %338, i64 5
store i64 %337, i64* %339
store i64 0, i64* %9
br label %340
340: ; preds = %336
%341 = load i64*, i64** %4
%342 = getelementptr inbounds i64, i64* %341, i64 3
%343 = load i64, i64* %342
%344 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %343)
%345 = extractvalue { i64, i64 } %344, 0
%346 = extractvalue { i64, i64 } %344, 1
store i64 %345, i64* %5
store i64 %346, i64* %6
%347 = load i64, i64* %7
%348 = load i64, i64* %6
%349 = load i64, i64* %5
%350 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %349, i32 0, i64 %347, i64 %348)
%351 = extractvalue { i64, i64 } %350, 0
%352 = extractvalue { i64, i64 } %350, 1
store i64 %351, i64* %7
store i64 %352, i64* %6
%353 = load i64, i64* %8
%354 = load i64, i64* %9
%355 = load i64, i64* %6
%356 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %355, i32 0, i64 %353, i64 %354)
%357 = extractvalue { i64, i64 } %356, 0
%358 = extractvalue { i64, i64 } %356, 1
store i64 %357, i64* %8
store i64 %358, i64* %9
br label %359
359: ; preds = %340
br label %360
360: ; preds = %359
%361 = load i64*, i64** %4
%362 = getelementptr inbounds i64, i64* %361, i64 4
%363 = load i64, i64* %362
%364 = load i64*, i64** %4
%365 = getelementptr inbounds i64, i64* %364, i64 2
%366 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %363, i64* elementtype(i64) %365)
%367 = extractvalue { i64, i64 } %366, 0
%368 = extractvalue { i64, i64 } %366, 1
store i64 %367, i64* %5
store i64 %368, i64* %6
%369 = load i64, i64* %7
%370 = load i64, i64* %8
%371 = load i64, i64* %9
%372 = load i64, i64* %5
%373 = load i64, i64* %6
%374 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %372, i64 %373, i32 0, i64 %369, i64 %370, i64 %371)
%375 = extractvalue { i64, i64, i64 } %374, 0
%376 = extractvalue { i64, i64, i64 } %374, 1
%377 = extractvalue { i64, i64, i64 } %374, 2
store i64 %375, i64* %7
store i64 %376, i64* %8
store i64 %377, i64* %9
%378 = load i64, i64* %7
%379 = load i64, i64* %8
%380 = load i64, i64* %9
%381 = load i64, i64* %5
%382 = load i64, i64* %6
%383 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %381, i64 %382, i32 0, i64 %378, i64 %379, i64 %380)
%384 = extractvalue { i64, i64, i64 } %383, 0
%385 = extractvalue { i64, i64, i64 } %383, 1
%386 = extractvalue { i64, i64, i64 } %383, 2
store i64 %384, i64* %7
store i64 %385, i64* %8
store i64 %386, i64* %9
br label %387
387: ; preds = %360
br label %388
388: ; preds = %387
%389 = load i64*, i64** %4
%390 = getelementptr inbounds i64, i64* %389, i64 5
%391 = load i64, i64* %390
%392 = load i64*, i64** %4
%393 = getelementptr inbounds i64, i64* %392, i64 1
%394 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %391, i64* elementtype(i64) %393)
%395 = extractvalue { i64, i64 } %394, 0
%396 = extractvalue { i64, i64 } %394, 1
store i64 %395, i64* %5
store i64 %396, i64* %6
%397 = load i64, i64* %7
%398 = load i64, i64* %8
%399 = load i64, i64* %9
%400 = load i64, i64* %5
%401 = load i64, i64* %6
%402 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %400, i64 %401, i32 0, i64 %397, i64 %398, i64 %399)
%403 = extractvalue { i64, i64, i64 } %402, 0
%404 = extractvalue { i64, i64, i64 } %402, 1
%405 = extractvalue { i64, i64, i64 } %402, 2
store i64 %403, i64* %7
store i64 %404, i64* %8
store i64 %405, i64* %9
%406 = load i64, i64* %7
%407 = load i64, i64* %8
%408 = load i64, i64* %9
%409 = load i64, i64* %5
%410 = load i64, i64* %6
%411 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %409, i64 %410, i32 0, i64 %406, i64 %407, i64 %408)
%412 = extractvalue { i64, i64, i64 } %411, 0
%413 = extractvalue { i64, i64, i64 } %411, 1
%414 = extractvalue { i64, i64, i64 } %411, 2
store i64 %412, i64* %7
store i64 %413, i64* %8
store i64 %414, i64* %9
br label %415
415: ; preds = %388
br label %416
416: ; preds = %415
%417 = load i64*, i64** %4
%418 = getelementptr inbounds i64, i64* %417, i64 6
%419 = load i64, i64* %418
%420 = load i64*, i64** %4
%421 = getelementptr inbounds i64, i64* %420, i64 0
%422 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %419, i64* elementtype(i64) %421)
%423 = extractvalue { i64, i64 } %422, 0
%424 = extractvalue { i64, i64 } %422, 1
store i64 %423, i64* %5
store i64 %424, i64* %6
%425 = load i64, i64* %7
%426 = load i64, i64* %8
%427 = load i64, i64* %9
%428 = load i64, i64* %5
%429 = load i64, i64* %6
%430 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %428, i64 %429, i32 0, i64 %425, i64 %426, i64 %427)
%431 = extractvalue { i64, i64, i64 } %430, 0
%432 = extractvalue { i64, i64, i64 } %430, 1
%433 = extractvalue { i64, i64, i64 } %430, 2
store i64 %431, i64* %7
store i64 %432, i64* %8
store i64 %433, i64* %9
%434 = load i64, i64* %7
%435 = load i64, i64* %8
%436 = load i64, i64* %9
%437 = load i64, i64* %5
%438 = load i64, i64* %6
%439 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %437, i64 %438, i32 0, i64 %434, i64 %435, i64 %436)
%440 = extractvalue { i64, i64, i64 } %439, 0
%441 = extractvalue { i64, i64, i64 } %439, 1
%442 = extractvalue { i64, i64, i64 } %439, 2
store i64 %440, i64* %7
store i64 %441, i64* %8
store i64 %442, i64* %9
br label %443
443: ; preds = %416
%444 = load i64, i64* %7
%445 = load i64*, i64** %3
%446 = getelementptr inbounds i64, i64* %445, i64 6
store i64 %444, i64* %446
store i64 0, i64* %7
br label %447
447: ; preds = %443
%448 = load i64*, i64** %4
%449 = getelementptr inbounds i64, i64* %448, i64 7
%450 = load i64, i64* %449
%451 = load i64*, i64** %4
%452 = getelementptr inbounds i64, i64* %451, i64 0
%453 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %450, i64* elementtype(i64) %452)
%454 = extractvalue { i64, i64 } %453, 0
%455 = extractvalue { i64, i64 } %453, 1
store i64 %454, i64* %5
store i64 %455, i64* %6
%456 = load i64, i64* %8
%457 = load i64, i64* %9
%458 = load i64, i64* %7
%459 = load i64, i64* %5
%460 = load i64, i64* %6
%461 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %459, i64 %460, i32 0, i64 %456, i64 %457, i64 %458)
%462 = extractvalue { i64, i64, i64 } %461, 0
%463 = extractvalue { i64, i64, i64 } %461, 1
%464 = extractvalue { i64, i64, i64 } %461, 2
store i64 %462, i64* %8
store i64 %463, i64* %9
store i64 %464, i64* %7
%465 = load i64, i64* %8
%466 = load i64, i64* %9
%467 = load i64, i64* %7
%468 = load i64, i64* %5
%469 = load i64, i64* %6
%470 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %468, i64 %469, i32 0, i64 %465, i64 %466, i64 %467)
%471 = extractvalue { i64, i64, i64 } %470, 0
%472 = extractvalue { i64, i64, i64 } %470, 1
%473 = extractvalue { i64, i64, i64 } %470, 2
store i64 %471, i64* %8
store i64 %472, i64* %9
store i64 %473, i64* %7
br label %474
474: ; preds = %447
br label %475
475: ; preds = %474
%476 = load i64*, i64** %4
%477 = getelementptr inbounds i64, i64* %476, i64 6
%478 = load i64, i64* %477
%479 = load i64*, i64** %4
%480 = getelementptr inbounds i64, i64* %479, i64 1
%481 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %478, i64* elementtype(i64) %480)
%482 = extractvalue { i64, i64 } %481, 0
%483 = extractvalue { i64, i64 } %481, 1
store i64 %482, i64* %5
store i64 %483, i64* %6
%484 = load i64, i64* %8
%485 = load i64, i64* %9
%486 = load i64, i64* %7
%487 = load i64, i64* %5
%488 = load i64, i64* %6
%489 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %487, i64 %488, i32 0, i64 %484, i64 %485, i64 %486)
%490 = extractvalue { i64, i64, i64 } %489, 0
%491 = extractvalue { i64, i64, i64 } %489, 1
%492 = extractvalue { i64, i64, i64 } %489, 2
store i64 %490, i64* %8
store i64 %491, i64* %9
store i64 %492, i64* %7
%493 = load i64, i64* %8
%494 = load i64, i64* %9
%495 = load i64, i64* %7
%496 = load i64, i64* %5
%497 = load i64, i64* %6
%498 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %496, i64 %497, i32 0, i64 %493, i64 %494, i64 %495)
%499 = extractvalue { i64, i64, i64 } %498, 0
%500 = extractvalue { i64, i64, i64 } %498, 1
%501 = extractvalue { i64, i64, i64 } %498, 2
store i64 %499, i64* %8
store i64 %500, i64* %9
store i64 %501, i64* %7
br label %502
502: ; preds = %475
br label %503
503: ; preds = %502
%504 = load i64*, i64** %4
%505 = getelementptr inbounds i64, i64* %504, i64 5
%506 = load i64, i64* %505
%507 = load i64*, i64** %4
%508 = getelementptr inbounds i64, i64* %507, i64 2
%509 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %506, i64* elementtype(i64) %508)
%510 = extractvalue { i64, i64 } %509, 0
%511 = extractvalue { i64, i64 } %509, 1
store i64 %510, i64* %5
store i64 %511, i64* %6
%512 = load i64, i64* %8
%513 = load i64, i64* %9
%514 = load i64, i64* %7
%515 = load i64, i64* %5
%516 = load i64, i64* %6
%517 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %515, i64 %516, i32 0, i64 %512, i64 %513, i64 %514)
%518 = extractvalue { i64, i64, i64 } %517, 0
%519 = extractvalue { i64, i64, i64 } %517, 1
%520 = extractvalue { i64, i64, i64 } %517, 2
store i64 %518, i64* %8
store i64 %519, i64* %9
store i64 %520, i64* %7
%521 = load i64, i64* %8
%522 = load i64, i64* %9
%523 = load i64, i64* %7
%524 = load i64, i64* %5
%525 = load i64, i64* %6
%526 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %524, i64 %525, i32 0, i64 %521, i64 %522, i64 %523)
%527 = extractvalue { i64, i64, i64 } %526, 0
%528 = extractvalue { i64, i64, i64 } %526, 1
%529 = extractvalue { i64, i64, i64 } %526, 2
store i64 %527, i64* %8
store i64 %528, i64* %9
store i64 %529, i64* %7
br label %530
530: ; preds = %503
br label %531
531: ; preds = %530
%532 = load i64*, i64** %4
%533 = getelementptr inbounds i64, i64* %532, i64 4
%534 = load i64, i64* %533
%535 = load i64*, i64** %4
%536 = getelementptr inbounds i64, i64* %535, i64 3
%537 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %534, i64* elementtype(i64) %536)
%538 = extractvalue { i64, i64 } %537, 0
%539 = extractvalue { i64, i64 } %537, 1
store i64 %538, i64* %5
store i64 %539, i64* %6
%540 = load i64, i64* %8
%541 = load i64, i64* %9
%542 = load i64, i64* %7
%543 = load i64, i64* %5
%544 = load i64, i64* %6
%545 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %543, i64 %544, i32 0, i64 %540, i64 %541, i64 %542)
%546 = extractvalue { i64, i64, i64 } %545, 0
%547 = extractvalue { i64, i64, i64 } %545, 1
%548 = extractvalue { i64, i64, i64 } %545, 2
store i64 %546, i64* %8
store i64 %547, i64* %9
store i64 %548, i64* %7
%549 = load i64, i64* %8
%550 = load i64, i64* %9
%551 = load i64, i64* %7
%552 = load i64, i64* %5
%553 = load i64, i64* %6
%554 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %552, i64 %553, i32 0, i64 %549, i64 %550, i64 %551)
%555 = extractvalue { i64, i64, i64 } %554, 0
%556 = extractvalue { i64, i64, i64 } %554, 1
%557 = extractvalue { i64, i64, i64 } %554, 2
store i64 %555, i64* %8
store i64 %556, i64* %9
store i64 %557, i64* %7
br label %558
558: ; preds = %531
%559 = load i64, i64* %8
%560 = load i64*, i64** %3
%561 = getelementptr inbounds i64, i64* %560, i64 7
store i64 %559, i64* %561
store i64 0, i64* %8
br label %562
562: ; preds = %558
%563 = load i64*, i64** %4
%564 = getelementptr inbounds i64, i64* %563, i64 4
%565 = load i64, i64* %564
%566 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %565)
%567 = extractvalue { i64, i64 } %566, 0
%568 = extractvalue { i64, i64 } %566, 1
store i64 %567, i64* %5
store i64 %568, i64* %6
%569 = load i64, i64* %9
%570 = load i64, i64* %6
%571 = load i64, i64* %5
%572 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %571, i32 0, i64 %569, i64 %570)
%573 = extractvalue { i64, i64 } %572, 0
%574 = extractvalue { i64, i64 } %572, 1
store i64 %573, i64* %9
store i64 %574, i64* %6
%575 = load i64, i64* %7
%576 = load i64, i64* %8
%577 = load i64, i64* %6
%578 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %577, i32 0, i64 %575, i64 %576)
%579 = extractvalue { i64, i64 } %578, 0
%580 = extractvalue { i64, i64 } %578, 1
store i64 %579, i64* %7
store i64 %580, i64* %8
br label %581
581: ; preds = %562
br label %582
582: ; preds = %581
%583 = load i64*, i64** %4
%584 = getelementptr inbounds i64, i64* %583, i64 5
%585 = load i64, i64* %584
%586 = load i64*, i64** %4
%587 = getelementptr inbounds i64, i64* %586, i64 3
%588 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %585, i64* elementtype(i64) %587)
%589 = extractvalue { i64, i64 } %588, 0
%590 = extractvalue { i64, i64 } %588, 1
store i64 %589, i64* %5
store i64 %590, i64* %6
%591 = load i64, i64* %9
%592 = load i64, i64* %7
%593 = load i64, i64* %8
%594 = load i64, i64* %5
%595 = load i64, i64* %6
%596 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %594, i64 %595, i32 0, i64 %591, i64 %592, i64 %593)
%597 = extractvalue { i64, i64, i64 } %596, 0
%598 = extractvalue { i64, i64, i64 } %596, 1
%599 = extractvalue { i64, i64, i64 } %596, 2
store i64 %597, i64* %9
store i64 %598, i64* %7
store i64 %599, i64* %8
%600 = load i64, i64* %9
%601 = load i64, i64* %7
%602 = load i64, i64* %8
%603 = load i64, i64* %5
%604 = load i64, i64* %6
%605 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %603, i64 %604, i32 0, i64 %600, i64 %601, i64 %602)
%606 = extractvalue { i64, i64, i64 } %605, 0
%607 = extractvalue { i64, i64, i64 } %605, 1
%608 = extractvalue { i64, i64, i64 } %605, 2
store i64 %606, i64* %9
store i64 %607, i64* %7
store i64 %608, i64* %8
br label %609
609: ; preds = %582
br label %610
610: ; preds = %609
%611 = load i64*, i64** %4
%612 = getelementptr inbounds i64, i64* %611, i64 6
%613 = load i64, i64* %612
%614 = load i64*, i64** %4
%615 = getelementptr inbounds i64, i64* %614, i64 2
%616 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %613, i64* elementtype(i64) %615)
%617 = extractvalue { i64, i64 } %616, 0
%618 = extractvalue { i64, i64 } %616, 1
store i64 %617, i64* %5
store i64 %618, i64* %6
%619 = load i64, i64* %9
%620 = load i64, i64* %7
%621 = load i64, i64* %8
%622 = load i64, i64* %5
%623 = load i64, i64* %6
%624 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %622, i64 %623, i32 0, i64 %619, i64 %620, i64 %621)
%625 = extractvalue { i64, i64, i64 } %624, 0
%626 = extractvalue { i64, i64, i64 } %624, 1
%627 = extractvalue { i64, i64, i64 } %624, 2
store i64 %625, i64* %9
store i64 %626, i64* %7
store i64 %627, i64* %8
%628 = load i64, i64* %9
%629 = load i64, i64* %7
%630 = load i64, i64* %8
%631 = load i64, i64* %5
%632 = load i64, i64* %6
%633 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %631, i64 %632, i32 0, i64 %628, i64 %629, i64 %630)
%634 = extractvalue { i64, i64, i64 } %633, 0
%635 = extractvalue { i64, i64, i64 } %633, 1
%636 = extractvalue { i64, i64, i64 } %633, 2
store i64 %634, i64* %9
store i64 %635, i64* %7
store i64 %636, i64* %8
br label %637
637: ; preds = %610
br label %638
638: ; preds = %637
%639 = load i64*, i64** %4
%640 = getelementptr inbounds i64, i64* %639, i64 7
%641 = load i64, i64* %640
%642 = load i64*, i64** %4
%643 = getelementptr inbounds i64, i64* %642, i64 1
%644 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %641, i64* elementtype(i64) %643)
%645 = extractvalue { i64, i64 } %644, 0
%646 = extractvalue { i64, i64 } %644, 1
store i64 %645, i64* %5
store i64 %646, i64* %6
%647 = load i64, i64* %9
%648 = load i64, i64* %7
%649 = load i64, i64* %8
%650 = load i64, i64* %5
%651 = load i64, i64* %6
%652 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %650, i64 %651, i32 0, i64 %647, i64 %648, i64 %649)
%653 = extractvalue { i64, i64, i64 } %652, 0
%654 = extractvalue { i64, i64, i64 } %652, 1
%655 = extractvalue { i64, i64, i64 } %652, 2
store i64 %653, i64* %9
store i64 %654, i64* %7
store i64 %655, i64* %8
%656 = load i64, i64* %9
%657 = load i64, i64* %7
%658 = load i64, i64* %8
%659 = load i64, i64* %5
%660 = load i64, i64* %6
%661 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %659, i64 %660, i32 0, i64 %656, i64 %657, i64 %658)
%662 = extractvalue { i64, i64, i64 } %661, 0
%663 = extractvalue { i64, i64, i64 } %661, 1
%664 = extractvalue { i64, i64, i64 } %661, 2
store i64 %662, i64* %9
store i64 %663, i64* %7
store i64 %664, i64* %8
br label %665
665: ; preds = %638
%666 = load i64, i64* %9
%667 = load i64*, i64** %3
%668 = getelementptr inbounds i64, i64* %667, i64 8
store i64 %666, i64* %668
store i64 0, i64* %9
br label %669
669: ; preds = %665
%670 = load i64*, i64** %4
%671 = getelementptr inbounds i64, i64* %670, i64 7
%672 = load i64, i64* %671
%673 = load i64*, i64** %4
%674 = getelementptr inbounds i64, i64* %673, i64 2
%675 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %672, i64* elementtype(i64) %674)
%676 = extractvalue { i64, i64 } %675, 0
%677 = extractvalue { i64, i64 } %675, 1
store i64 %676, i64* %5
store i64 %677, i64* %6
%678 = load i64, i64* %7
%679 = load i64, i64* %8
%680 = load i64, i64* %9
%681 = load i64, i64* %5
%682 = load i64, i64* %6
%683 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %681, i64 %682, i32 0, i64 %678, i64 %679, i64 %680)
%684 = extractvalue { i64, i64, i64 } %683, 0
%685 = extractvalue { i64, i64, i64 } %683, 1
%686 = extractvalue { i64, i64, i64 } %683, 2
store i64 %684, i64* %7
store i64 %685, i64* %8
store i64 %686, i64* %9
%687 = load i64, i64* %7
%688 = load i64, i64* %8
%689 = load i64, i64* %9
%690 = load i64, i64* %5
%691 = load i64, i64* %6
%692 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %690, i64 %691, i32 0, i64 %687, i64 %688, i64 %689)
%693 = extractvalue { i64, i64, i64 } %692, 0
%694 = extractvalue { i64, i64, i64 } %692, 1
%695 = extractvalue { i64, i64, i64 } %692, 2
store i64 %693, i64* %7
store i64 %694, i64* %8
store i64 %695, i64* %9
br label %696
696: ; preds = %669
br label %697
697: ; preds = %696
%698 = load i64*, i64** %4
%699 = getelementptr inbounds i64, i64* %698, i64 6
%700 = load i64, i64* %699
%701 = load i64*, i64** %4
%702 = getelementptr inbounds i64, i64* %701, i64 3
%703 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %700, i64* elementtype(i64) %702)
%704 = extractvalue { i64, i64 } %703, 0
%705 = extractvalue { i64, i64 } %703, 1
store i64 %704, i64* %5
store i64 %705, i64* %6
%706 = load i64, i64* %7
%707 = load i64, i64* %8
%708 = load i64, i64* %9
%709 = load i64, i64* %5
%710 = load i64, i64* %6
%711 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %709, i64 %710, i32 0, i64 %706, i64 %707, i64 %708)
%712 = extractvalue { i64, i64, i64 } %711, 0
%713 = extractvalue { i64, i64, i64 } %711, 1
%714 = extractvalue { i64, i64, i64 } %711, 2
store i64 %712, i64* %7
store i64 %713, i64* %8
store i64 %714, i64* %9
%715 = load i64, i64* %7
%716 = load i64, i64* %8
%717 = load i64, i64* %9
%718 = load i64, i64* %5
%719 = load i64, i64* %6
%720 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %718, i64 %719, i32 0, i64 %715, i64 %716, i64 %717)
%721 = extractvalue { i64, i64, i64 } %720, 0
%722 = extractvalue { i64, i64, i64 } %720, 1
%723 = extractvalue { i64, i64, i64 } %720, 2
store i64 %721, i64* %7
store i64 %722, i64* %8
store i64 %723, i64* %9
br label %724
724: ; preds = %697
br label %725
725: ; preds = %724
%726 = load i64*, i64** %4
%727 = getelementptr inbounds i64, i64* %726, i64 5
%728 = load i64, i64* %727
%729 = load i64*, i64** %4
%730 = getelementptr inbounds i64, i64* %729, i64 4
%731 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %728, i64* elementtype(i64) %730)
%732 = extractvalue { i64, i64 } %731, 0
%733 = extractvalue { i64, i64 } %731, 1
store i64 %732, i64* %5
store i64 %733, i64* %6
%734 = load i64, i64* %7
%735 = load i64, i64* %8
%736 = load i64, i64* %9
%737 = load i64, i64* %5
%738 = load i64, i64* %6
%739 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %737, i64 %738, i32 0, i64 %734, i64 %735, i64 %736)
%740 = extractvalue { i64, i64, i64 } %739, 0
%741 = extractvalue { i64, i64, i64 } %739, 1
%742 = extractvalue { i64, i64, i64 } %739, 2
store i64 %740, i64* %7
store i64 %741, i64* %8
store i64 %742, i64* %9
%743 = load i64, i64* %7
%744 = load i64, i64* %8
%745 = load i64, i64* %9
%746 = load i64, i64* %5
%747 = load i64, i64* %6
%748 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %746, i64 %747, i32 0, i64 %743, i64 %744, i64 %745)
%749 = extractvalue { i64, i64, i64 } %748, 0
%750 = extractvalue { i64, i64, i64 } %748, 1
%751 = extractvalue { i64, i64, i64 } %748, 2
store i64 %749, i64* %7
store i64 %750, i64* %8
store i64 %751, i64* %9
br label %752
752: ; preds = %725
%753 = load i64, i64* %7
%754 = load i64*, i64** %3
%755 = getelementptr inbounds i64, i64* %754, i64 9
store i64 %753, i64* %755
store i64 0, i64* %7
br label %756
756: ; preds = %752
%757 = load i64*, i64** %4
%758 = getelementptr inbounds i64, i64* %757, i64 5
%759 = load i64, i64* %758
%760 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %759)
%761 = extractvalue { i64, i64 } %760, 0
%762 = extractvalue { i64, i64 } %760, 1
store i64 %761, i64* %5
store i64 %762, i64* %6
%763 = load i64, i64* %8
%764 = load i64, i64* %6
%765 = load i64, i64* %5
%766 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %765, i32 0, i64 %763, i64 %764)
%767 = extractvalue { i64, i64 } %766, 0
%768 = extractvalue { i64, i64 } %766, 1
store i64 %767, i64* %8
store i64 %768, i64* %6
%769 = load i64, i64* %9
%770 = load i64, i64* %7
%771 = load i64, i64* %6
%772 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %771, i32 0, i64 %769, i64 %770)
%773 = extractvalue { i64, i64 } %772, 0
%774 = extractvalue { i64, i64 } %772, 1
store i64 %773, i64* %9
store i64 %774, i64* %7
br label %775
775: ; preds = %756
br label %776
776: ; preds = %775
%777 = load i64*, i64** %4
%778 = getelementptr inbounds i64, i64* %777, i64 6
%779 = load i64, i64* %778
%780 = load i64*, i64** %4
%781 = getelementptr inbounds i64, i64* %780, i64 4
%782 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %779, i64* elementtype(i64) %781)
%783 = extractvalue { i64, i64 } %782, 0
%784 = extractvalue { i64, i64 } %782, 1
store i64 %783, i64* %5
store i64 %784, i64* %6
%785 = load i64, i64* %8
%786 = load i64, i64* %9
%787 = load i64, i64* %7
%788 = load i64, i64* %5
%789 = load i64, i64* %6
%790 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %788, i64 %789, i32 0, i64 %785, i64 %786, i64 %787)
%791 = extractvalue { i64, i64, i64 } %790, 0
%792 = extractvalue { i64, i64, i64 } %790, 1
%793 = extractvalue { i64, i64, i64 } %790, 2
store i64 %791, i64* %8
store i64 %792, i64* %9
store i64 %793, i64* %7
%794 = load i64, i64* %8
%795 = load i64, i64* %9
%796 = load i64, i64* %7
%797 = load i64, i64* %5
%798 = load i64, i64* %6
%799 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %797, i64 %798, i32 0, i64 %794, i64 %795, i64 %796)
%800 = extractvalue { i64, i64, i64 } %799, 0
%801 = extractvalue { i64, i64, i64 } %799, 1
%802 = extractvalue { i64, i64, i64 } %799, 2
store i64 %800, i64* %8
store i64 %801, i64* %9
store i64 %802, i64* %7
br label %803
803: ; preds = %776
br label %804
804: ; preds = %803
%805 = load i64*, i64** %4
%806 = getelementptr inbounds i64, i64* %805, i64 7
%807 = load i64, i64* %806
%808 = load i64*, i64** %4
%809 = getelementptr inbounds i64, i64* %808, i64 3
%810 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %807, i64* elementtype(i64) %809)
%811 = extractvalue { i64, i64 } %810, 0
%812 = extractvalue { i64, i64 } %810, 1
store i64 %811, i64* %5
store i64 %812, i64* %6
%813 = load i64, i64* %8
%814 = load i64, i64* %9
%815 = load i64, i64* %7
%816 = load i64, i64* %5
%817 = load i64, i64* %6
%818 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %816, i64 %817, i32 0, i64 %813, i64 %814, i64 %815)
%819 = extractvalue { i64, i64, i64 } %818, 0
%820 = extractvalue { i64, i64, i64 } %818, 1
%821 = extractvalue { i64, i64, i64 } %818, 2
store i64 %819, i64* %8
store i64 %820, i64* %9
store i64 %821, i64* %7
%822 = load i64, i64* %8
%823 = load i64, i64* %9
%824 = load i64, i64* %7
%825 = load i64, i64* %5
%826 = load i64, i64* %6
%827 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %825, i64 %826, i32 0, i64 %822, i64 %823, i64 %824)
%828 = extractvalue { i64, i64, i64 } %827, 0
%829 = extractvalue { i64, i64, i64 } %827, 1
%830 = extractvalue { i64, i64, i64 } %827, 2
store i64 %828, i64* %8
store i64 %829, i64* %9
store i64 %830, i64* %7
br label %831
831: ; preds = %804
%832 = load i64, i64* %8
%833 = load i64*, i64** %3
%834 = getelementptr inbounds i64, i64* %833, i64 10
store i64 %832, i64* %834
store i64 0, i64* %8
br label %835
835: ; preds = %831
%836 = load i64*, i64** %4
%837 = getelementptr inbounds i64, i64* %836, i64 7
%838 = load i64, i64* %837
%839 = load i64*, i64** %4
%840 = getelementptr inbounds i64, i64* %839, i64 4
%841 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %838, i64* elementtype(i64) %840)
%842 = extractvalue { i64, i64 } %841, 0
%843 = extractvalue { i64, i64 } %841, 1
store i64 %842, i64* %5
store i64 %843, i64* %6
%844 = load i64, i64* %9
%845 = load i64, i64* %7
%846 = load i64, i64* %8
%847 = load i64, i64* %5
%848 = load i64, i64* %6
%849 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %847, i64 %848, i32 0, i64 %844, i64 %845, i64 %846)
%850 = extractvalue { i64, i64, i64 } %849, 0
%851 = extractvalue { i64, i64, i64 } %849, 1
%852 = extractvalue { i64, i64, i64 } %849, 2
store i64 %850, i64* %9
store i64 %851, i64* %7
store i64 %852, i64* %8
%853 = load i64, i64* %9
%854 = load i64, i64* %7
%855 = load i64, i64* %8
%856 = load i64, i64* %5
%857 = load i64, i64* %6
%858 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %856, i64 %857, i32 0, i64 %853, i64 %854, i64 %855)
%859 = extractvalue { i64, i64, i64 } %858, 0
%860 = extractvalue { i64, i64, i64 } %858, 1
%861 = extractvalue { i64, i64, i64 } %858, 2
store i64 %859, i64* %9
store i64 %860, i64* %7
store i64 %861, i64* %8
br label %862
862: ; preds = %835
br label %863
863: ; preds = %862
%864 = load i64*, i64** %4
%865 = getelementptr inbounds i64, i64* %864, i64 6
%866 = load i64, i64* %865
%867 = load i64*, i64** %4
%868 = getelementptr inbounds i64, i64* %867, i64 5
%869 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %866, i64* elementtype(i64) %868)
%870 = extractvalue { i64, i64 } %869, 0
%871 = extractvalue { i64, i64 } %869, 1
store i64 %870, i64* %5
store i64 %871, i64* %6
%872 = load i64, i64* %9
%873 = load i64, i64* %7
%874 = load i64, i64* %8
%875 = load i64, i64* %5
%876 = load i64, i64* %6
%877 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %875, i64 %876, i32 0, i64 %872, i64 %873, i64 %874)
%878 = extractvalue { i64, i64, i64 } %877, 0
%879 = extractvalue { i64, i64, i64 } %877, 1
%880 = extractvalue { i64, i64, i64 } %877, 2
store i64 %878, i64* %9
store i64 %879, i64* %7
store i64 %880, i64* %8
%881 = load i64, i64* %9
%882 = load i64, i64* %7
%883 = load i64, i64* %8
%884 = load i64, i64* %5
%885 = load i64, i64* %6
%886 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %884, i64 %885, i32 0, i64 %881, i64 %882, i64 %883)
%887 = extractvalue { i64, i64, i64 } %886, 0
%888 = extractvalue { i64, i64, i64 } %886, 1
%889 = extractvalue { i64, i64, i64 } %886, 2
store i64 %887, i64* %9
store i64 %888, i64* %7
store i64 %889, i64* %8
br label %890
890: ; preds = %863
%891 = load i64, i64* %9
%892 = load i64*, i64** %3
%893 = getelementptr inbounds i64, i64* %892, i64 11
store i64 %891, i64* %893
store i64 0, i64* %9
br label %894
894: ; preds = %890
%895 = load i64*, i64** %4
%896 = getelementptr inbounds i64, i64* %895, i64 6
%897 = load i64, i64* %896
%898 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %897)
%899 = extractvalue { i64, i64 } %898, 0
%900 = extractvalue { i64, i64 } %898, 1
store i64 %899, i64* %5
store i64 %900, i64* %6
%901 = load i64, i64* %7
%902 = load i64, i64* %6
%903 = load i64, i64* %5
%904 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %903, i32 0, i64 %901, i64 %902)
%905 = extractvalue { i64, i64 } %904, 0
%906 = extractvalue { i64, i64 } %904, 1
store i64 %905, i64* %7
store i64 %906, i64* %6
%907 = load i64, i64* %8
%908 = load i64, i64* %9
%909 = load i64, i64* %6
%910 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %909, i32 0, i64 %907, i64 %908)
%911 = extractvalue { i64, i64 } %910, 0
%912 = extractvalue { i64, i64 } %910, 1
store i64 %911, i64* %8
store i64 %912, i64* %9
br label %913
913: ; preds = %894
br label %914
914: ; preds = %913
%915 = load i64*, i64** %4
%916 = getelementptr inbounds i64, i64* %915, i64 7
%917 = load i64, i64* %916
%918 = load i64*, i64** %4
%919 = getelementptr inbounds i64, i64* %918, i64 5
%920 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %917, i64* elementtype(i64) %919)
%921 = extractvalue { i64, i64 } %920, 0
%922 = extractvalue { i64, i64 } %920, 1
store i64 %921, i64* %5
store i64 %922, i64* %6
%923 = load i64, i64* %7
%924 = load i64, i64* %8
%925 = load i64, i64* %9
%926 = load i64, i64* %5
%927 = load i64, i64* %6
%928 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %926, i64 %927, i32 0, i64 %923, i64 %924, i64 %925)
%929 = extractvalue { i64, i64, i64 } %928, 0
%930 = extractvalue { i64, i64, i64 } %928, 1
%931 = extractvalue { i64, i64, i64 } %928, 2
store i64 %929, i64* %7
store i64 %930, i64* %8
store i64 %931, i64* %9
%932 = load i64, i64* %7
%933 = load i64, i64* %8
%934 = load i64, i64* %9
%935 = load i64, i64* %5
%936 = load i64, i64* %6
%937 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %935, i64 %936, i32 0, i64 %932, i64 %933, i64 %934)
%938 = extractvalue { i64, i64, i64 } %937, 0
%939 = extractvalue { i64, i64, i64 } %937, 1
%940 = extractvalue { i64, i64, i64 } %937, 2
store i64 %938, i64* %7
store i64 %939, i64* %8
store i64 %940, i64* %9
br label %941
941: ; preds = %914
%942 = load i64, i64* %7
%943 = load i64*, i64** %3
%944 = getelementptr inbounds i64, i64* %943, i64 12
store i64 %942, i64* %944
store i64 0, i64* %7
br label %945
945: ; preds = %941
%946 = load i64*, i64** %4
%947 = getelementptr inbounds i64, i64* %946, i64 7
%948 = load i64, i64* %947
%949 = load i64*, i64** %4
%950 = getelementptr inbounds i64, i64* %949, i64 6
%951 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %948, i64* elementtype(i64) %950)
%952 = extractvalue { i64, i64 } %951, 0
%953 = extractvalue { i64, i64 } %951, 1
store i64 %952, i64* %5
store i64 %953, i64* %6
%954 = load i64, i64* %8
%955 = load i64, i64* %9
%956 = load i64, i64* %7
%957 = load i64, i64* %5
%958 = load i64, i64* %6
%959 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %957, i64 %958, i32 0, i64 %954, i64 %955, i64 %956)
%960 = extractvalue { i64, i64, i64 } %959, 0
%961 = extractvalue { i64, i64, i64 } %959, 1
%962 = extractvalue { i64, i64, i64 } %959, 2
store i64 %960, i64* %8
store i64 %961, i64* %9
store i64 %962, i64* %7
%963 = load i64, i64* %8
%964 = load i64, i64* %9
%965 = load i64, i64* %7
%966 = load i64, i64* %5
%967 = load i64, i64* %6
%968 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %966, i64 %967, i32 0, i64 %963, i64 %964, i64 %965)
%969 = extractvalue { i64, i64, i64 } %968, 0
%970 = extractvalue { i64, i64, i64 } %968, 1
%971 = extractvalue { i64, i64, i64 } %968, 2
store i64 %969, i64* %8
store i64 %970, i64* %9
store i64 %971, i64* %7
br label %972
972: ; preds = %945
%973 = load i64, i64* %8
%974 = load i64*, i64** %3
%975 = getelementptr inbounds i64, i64* %974, i64 13
store i64 %973, i64* %975
store i64 0, i64* %8
br label %976
976: ; preds = %972
%977 = load i64*, i64** %4
%978 = getelementptr inbounds i64, i64* %977, i64 7
%979 = load i64, i64* %978
%980 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %979)
%981 = extractvalue { i64, i64 } %980, 0
%982 = extractvalue { i64, i64 } %980, 1
store i64 %981, i64* %5
store i64 %982, i64* %6
%983 = load i64, i64* %9
%984 = load i64, i64* %6
%985 = load i64, i64* %5
%986 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %985, i32 0, i64 %983, i64 %984)
%987 = extractvalue { i64, i64 } %986, 0
%988 = extractvalue { i64, i64 } %986, 1
store i64 %987, i64* %9
store i64 %988, i64* %6
%989 = load i64, i64* %7
%990 = load i64, i64* %8
%991 = load i64, i64* %6
%992 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %991, i32 0, i64 %989, i64 %990)
%993 = extractvalue { i64, i64 } %992, 0
%994 = extractvalue { i64, i64 } %992, 1
store i64 %993, i64* %7
store i64 %994, i64* %8
br label %995
995: ; preds = %976
%996 = load i64, i64* %9
%997 = load i64*, i64** %3
%998 = getelementptr inbounds i64, i64* %997, i64 14
store i64 %996, i64* %998
%999 = load i64, i64* %7
%1000 = load i64*, i64** %3
%1001 = getelementptr inbounds i64, i64* %1000, i64 15
store i64 %999, i64* %1001
ret void
}

LLVM IR (-O2):
define void @bn_sqr_comba8(i64* nocapture writeonly %0, i64* %1) {
%3 = load i64, i64* %1
%4 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %3)
%5 = extractvalue { i64, i64 } %4, 0
%6 = extractvalue { i64, i64 } %4, 1
%7 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %5, i32 0, i64 0, i64 %6)
%8 = extractvalue { i64, i64 } %7, 0
%9 = extractvalue { i64, i64 } %7, 1
%10 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %9, i32 0, i64 0, i64 0)
%11 = extractvalue { i64, i64 } %10, 0
%12 = extractvalue { i64, i64 } %10, 1
store i64 %8, i64* %0
%13 = getelementptr inbounds i64, i64* %1, i64 1
%14 = load i64, i64* %13
%15 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %14, i64* elementtype(i64) %1)
%16 = extractvalue { i64, i64 } %15, 0
%17 = extractvalue { i64, i64 } %15, 1
%18 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %16, i64 %17, i32 0, i64 %11, i64 %12, i64 0)
%19 = extractvalue { i64, i64, i64 } %18, 0
%20 = extractvalue { i64, i64, i64 } %18, 1
%21 = extractvalue { i64, i64, i64 } %18, 2
%22 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %16, i64 %17, i32 0, i64 %19, i64 %20, i64 %21)
%23 = extractvalue { i64, i64, i64 } %22, 0
%24 = extractvalue { i64, i64, i64 } %22, 1
%25 = extractvalue { i64, i64, i64 } %22, 2
%26 = getelementptr inbounds i64, i64* %0, i64 1
store i64 %23, i64* %26
%27 = load i64, i64* %13
%28 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %27)
%29 = extractvalue { i64, i64 } %28, 0
%30 = extractvalue { i64, i64 } %28, 1
%31 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %29, i32 0, i64 %24, i64 %30)
%32 = extractvalue { i64, i64 } %31, 0
%33 = extractvalue { i64, i64 } %31, 1
%34 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %33, i32 0, i64 %25, i64 0)
%35 = extractvalue { i64, i64 } %34, 0
%36 = extractvalue { i64, i64 } %34, 1
%37 = getelementptr inbounds i64, i64* %1, i64 2
%38 = load i64, i64* %37
%39 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %38, i64* elementtype(i64) %1)
%40 = extractvalue { i64, i64 } %39, 0
%41 = extractvalue { i64, i64 } %39, 1
%42 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %40, i64 %41, i32 0, i64 %32, i64 %35, i64 %36)
%43 = extractvalue { i64, i64, i64 } %42, 0
%44 = extractvalue { i64, i64, i64 } %42, 1
%45 = extractvalue { i64, i64, i64 } %42, 2
%46 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %40, i64 %41, i32 0, i64 %43, i64 %44, i64 %45)
%47 = extractvalue { i64, i64, i64 } %46, 0
%48 = extractvalue { i64, i64, i64 } %46, 1
%49 = extractvalue { i64, i64, i64 } %46, 2
%50 = getelementptr inbounds i64, i64* %0, i64 2
store i64 %47, i64* %50
%51 = getelementptr inbounds i64, i64* %1, i64 3
%52 = load i64, i64* %51
%53 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %52, i64* elementtype(i64) %1)
%54 = extractvalue { i64, i64 } %53, 0
%55 = extractvalue { i64, i64 } %53, 1
%56 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %54, i64 %55, i32 0, i64 %48, i64 %49, i64 0)
%57 = extractvalue { i64, i64, i64 } %56, 0
%58 = extractvalue { i64, i64, i64 } %56, 1
%59 = extractvalue { i64, i64, i64 } %56, 2
%60 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %54, i64 %55, i32 0, i64 %57, i64 %58, i64 %59)
%61 = extractvalue { i64, i64, i64 } %60, 0
%62 = extractvalue { i64, i64, i64 } %60, 1
%63 = extractvalue { i64, i64, i64 } %60, 2
%64 = load i64, i64* %37
%65 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %64, i64* elementtype(i64) %13)
%66 = extractvalue { i64, i64 } %65, 0
%67 = extractvalue { i64, i64 } %65, 1
%68 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %66, i64 %67, i32 0, i64 %61, i64 %62, i64 %63)
%69 = extractvalue { i64, i64, i64 } %68, 0
%70 = extractvalue { i64, i64, i64 } %68, 1
%71 = extractvalue { i64, i64, i64 } %68, 2
%72 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %66, i64 %67, i32 0, i64 %69, i64 %70, i64 %71)
%73 = extractvalue { i64, i64, i64 } %72, 0
%74 = extractvalue { i64, i64, i64 } %72, 1
%75 = extractvalue { i64, i64, i64 } %72, 2
%76 = getelementptr inbounds i64, i64* %0, i64 3
store i64 %73, i64* %76
%77 = load i64, i64* %37
%78 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %77)
%79 = extractvalue { i64, i64 } %78, 0
%80 = extractvalue { i64, i64 } %78, 1
%81 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %79, i32 0, i64 %74, i64 %80)
%82 = extractvalue { i64, i64 } %81, 0
%83 = extractvalue { i64, i64 } %81, 1
%84 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %83, i32 0, i64 %75, i64 0)
%85 = extractvalue { i64, i64 } %84, 0
%86 = extractvalue { i64, i64 } %84, 1
%87 = load i64, i64* %51
%88 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %87, i64* elementtype(i64) %13)
%89 = extractvalue { i64, i64 } %88, 0
%90 = extractvalue { i64, i64 } %88, 1
%91 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %89, i64 %90, i32 0, i64 %82, i64 %85, i64 %86)
%92 = extractvalue { i64, i64, i64 } %91, 0
%93 = extractvalue { i64, i64, i64 } %91, 1
%94 = extractvalue { i64, i64, i64 } %91, 2
%95 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %89, i64 %90, i32 0, i64 %92, i64 %93, i64 %94)
%96 = extractvalue { i64, i64, i64 } %95, 0
%97 = extractvalue { i64, i64, i64 } %95, 1
%98 = extractvalue { i64, i64, i64 } %95, 2
%99 = getelementptr inbounds i64, i64* %1, i64 4
%100 = load i64, i64* %99
%101 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %100, i64* elementtype(i64) %1)
%102 = extractvalue { i64, i64 } %101, 0
%103 = extractvalue { i64, i64 } %101, 1
%104 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %102, i64 %103, i32 0, i64 %96, i64 %97, i64 %98)
%105 = extractvalue { i64, i64, i64 } %104, 0
%106 = extractvalue { i64, i64, i64 } %104, 1
%107 = extractvalue { i64, i64, i64 } %104, 2
%108 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %102, i64 %103, i32 0, i64 %105, i64 %106, i64 %107)
%109 = extractvalue { i64, i64, i64 } %108, 0
%110 = extractvalue { i64, i64, i64 } %108, 1
%111 = extractvalue { i64, i64, i64 } %108, 2
%112 = getelementptr inbounds i64, i64* %0, i64 4
store i64 %109, i64* %112
%113 = getelementptr inbounds i64, i64* %1, i64 5
%114 = load i64, i64* %113
%115 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %114, i64* elementtype(i64) %1)
%116 = extractvalue { i64, i64 } %115, 0
%117 = extractvalue { i64, i64 } %115, 1
%118 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %116, i64 %117, i32 0, i64 %110, i64 %111, i64 0)
%119 = extractvalue { i64, i64, i64 } %118, 0
%120 = extractvalue { i64, i64, i64 } %118, 1
%121 = extractvalue { i64, i64, i64 } %118, 2
%122 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %116, i64 %117, i32 0, i64 %119, i64 %120, i64 %121)
%123 = extractvalue { i64, i64, i64 } %122, 0
%124 = extractvalue { i64, i64, i64 } %122, 1
%125 = extractvalue { i64, i64, i64 } %122, 2
%126 = load i64, i64* %99
%127 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %126, i64* elementtype(i64) %13)
%128 = extractvalue { i64, i64 } %127, 0
%129 = extractvalue { i64, i64 } %127, 1
%130 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %128, i64 %129, i32 0, i64 %123, i64 %124, i64 %125)
%131 = extractvalue { i64, i64, i64 } %130, 0
%132 = extractvalue { i64, i64, i64 } %130, 1
%133 = extractvalue { i64, i64, i64 } %130, 2
%134 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %128, i64 %129, i32 0, i64 %131, i64 %132, i64 %133)
%135 = extractvalue { i64, i64, i64 } %134, 0
%136 = extractvalue { i64, i64, i64 } %134, 1
%137 = extractvalue { i64, i64, i64 } %134, 2
%138 = load i64, i64* %51
%139 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %138, i64* elementtype(i64) %37)
%140 = extractvalue { i64, i64 } %139, 0
%141 = extractvalue { i64, i64 } %139, 1
%142 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %140, i64 %141, i32 0, i64 %135, i64 %136, i64 %137)
%143 = extractvalue { i64, i64, i64 } %142, 0
%144 = extractvalue { i64, i64, i64 } %142, 1
%145 = extractvalue { i64, i64, i64 } %142, 2
%146 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %140, i64 %141, i32 0, i64 %143, i64 %144, i64 %145)
%147 = extractvalue { i64, i64, i64 } %146, 0
%148 = extractvalue { i64, i64, i64 } %146, 1
%149 = extractvalue { i64, i64, i64 } %146, 2
%150 = getelementptr inbounds i64, i64* %0, i64 5
store i64 %147, i64* %150
%151 = load i64, i64* %51
%152 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %151)
%153 = extractvalue { i64, i64 } %152, 0
%154 = extractvalue { i64, i64 } %152, 1
%155 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %153, i32 0, i64 %148, i64 %154)
%156 = extractvalue { i64, i64 } %155, 0
%157 = extractvalue { i64, i64 } %155, 1
%158 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %157, i32 0, i64 %149, i64 0)
%159 = extractvalue { i64, i64 } %158, 0
%160 = extractvalue { i64, i64 } %158, 1
%161 = load i64, i64* %99
%162 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %161, i64* elementtype(i64) %37)
%163 = extractvalue { i64, i64 } %162, 0
%164 = extractvalue { i64, i64 } %162, 1
%165 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %163, i64 %164, i32 0, i64 %156, i64 %159, i64 %160)
%166 = extractvalue { i64, i64, i64 } %165, 0
%167 = extractvalue { i64, i64, i64 } %165, 1
%168 = extractvalue { i64, i64, i64 } %165, 2
%169 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %163, i64 %164, i32 0, i64 %166, i64 %167, i64 %168)
%170 = extractvalue { i64, i64, i64 } %169, 0
%171 = extractvalue { i64, i64, i64 } %169, 1
%172 = extractvalue { i64, i64, i64 } %169, 2
%173 = load i64, i64* %113
%174 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %173, i64* elementtype(i64) %13)
%175 = extractvalue { i64, i64 } %174, 0
%176 = extractvalue { i64, i64 } %174, 1
%177 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %175, i64 %176, i32 0, i64 %170, i64 %171, i64 %172)
%178 = extractvalue { i64, i64, i64 } %177, 0
%179 = extractvalue { i64, i64, i64 } %177, 1
%180 = extractvalue { i64, i64, i64 } %177, 2
%181 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %175, i64 %176, i32 0, i64 %178, i64 %179, i64 %180)
%182 = extractvalue { i64, i64, i64 } %181, 0
%183 = extractvalue { i64, i64, i64 } %181, 1
%184 = extractvalue { i64, i64, i64 } %181, 2
%185 = getelementptr inbounds i64, i64* %1, i64 6
%186 = load i64, i64* %185
%187 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %186, i64* elementtype(i64) %1)
%188 = extractvalue { i64, i64 } %187, 0
%189 = extractvalue { i64, i64 } %187, 1
%190 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %188, i64 %189, i32 0, i64 %182, i64 %183, i64 %184)
%191 = extractvalue { i64, i64, i64 } %190, 0
%192 = extractvalue { i64, i64, i64 } %190, 1
%193 = extractvalue { i64, i64, i64 } %190, 2
%194 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %188, i64 %189, i32 0, i64 %191, i64 %192, i64 %193)
%195 = extractvalue { i64, i64, i64 } %194, 0
%196 = extractvalue { i64, i64, i64 } %194, 1
%197 = extractvalue { i64, i64, i64 } %194, 2
%198 = getelementptr inbounds i64, i64* %0, i64 6
store i64 %195, i64* %198
%199 = getelementptr inbounds i64, i64* %1, i64 7
%200 = load i64, i64* %199
%201 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %200, i64* elementtype(i64) %1)
%202 = extractvalue { i64, i64 } %201, 0
%203 = extractvalue { i64, i64 } %201, 1
%204 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %202, i64 %203, i32 0, i64 %196, i64 %197, i64 0)
%205 = extractvalue { i64, i64, i64 } %204, 0
%206 = extractvalue { i64, i64, i64 } %204, 1
%207 = extractvalue { i64, i64, i64 } %204, 2
%208 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %202, i64 %203, i32 0, i64 %205, i64 %206, i64 %207)
%209 = extractvalue { i64, i64, i64 } %208, 0
%210 = extractvalue { i64, i64, i64 } %208, 1
%211 = extractvalue { i64, i64, i64 } %208, 2
%212 = load i64, i64* %185
%213 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %212, i64* elementtype(i64) %13)
%214 = extractvalue { i64, i64 } %213, 0
%215 = extractvalue { i64, i64 } %213, 1
%216 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %214, i64 %215, i32 0, i64 %209, i64 %210, i64 %211)
%217 = extractvalue { i64, i64, i64 } %216, 0
%218 = extractvalue { i64, i64, i64 } %216, 1
%219 = extractvalue { i64, i64, i64 } %216, 2
%220 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %214, i64 %215, i32 0, i64 %217, i64 %218, i64 %219)
%221 = extractvalue { i64, i64, i64 } %220, 0
%222 = extractvalue { i64, i64, i64 } %220, 1
%223 = extractvalue { i64, i64, i64 } %220, 2
%224 = load i64, i64* %113
%225 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %224, i64* elementtype(i64) %37)
%226 = extractvalue { i64, i64 } %225, 0
%227 = extractvalue { i64, i64 } %225, 1
%228 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %226, i64 %227, i32 0, i64 %221, i64 %222, i64 %223)
%229 = extractvalue { i64, i64, i64 } %228, 0
%230 = extractvalue { i64, i64, i64 } %228, 1
%231 = extractvalue { i64, i64, i64 } %228, 2
%232 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %226, i64 %227, i32 0, i64 %229, i64 %230, i64 %231)
%233 = extractvalue { i64, i64, i64 } %232, 0
%234 = extractvalue { i64, i64, i64 } %232, 1
%235 = extractvalue { i64, i64, i64 } %232, 2
%236 = load i64, i64* %99
%237 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %236, i64* elementtype(i64) %51)
%238 = extractvalue { i64, i64 } %237, 0
%239 = extractvalue { i64, i64 } %237, 1
%240 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %238, i64 %239, i32 0, i64 %233, i64 %234, i64 %235)
%241 = extractvalue { i64, i64, i64 } %240, 0
%242 = extractvalue { i64, i64, i64 } %240, 1
%243 = extractvalue { i64, i64, i64 } %240, 2
%244 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %238, i64 %239, i32 0, i64 %241, i64 %242, i64 %243)
%245 = extractvalue { i64, i64, i64 } %244, 0
%246 = extractvalue { i64, i64, i64 } %244, 1
%247 = extractvalue { i64, i64, i64 } %244, 2
%248 = getelementptr inbounds i64, i64* %0, i64 7
store i64 %245, i64* %248
%249 = load i64, i64* %99
%250 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %249)
%251 = extractvalue { i64, i64 } %250, 0
%252 = extractvalue { i64, i64 } %250, 1
%253 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %251, i32 0, i64 %246, i64 %252)
%254 = extractvalue { i64, i64 } %253, 0
%255 = extractvalue { i64, i64 } %253, 1
%256 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %255, i32 0, i64 %247, i64 0)
%257 = extractvalue { i64, i64 } %256, 0
%258 = extractvalue { i64, i64 } %256, 1
%259 = load i64, i64* %113
%260 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %259, i64* elementtype(i64) %51)
%261 = extractvalue { i64, i64 } %260, 0
%262 = extractvalue { i64, i64 } %260, 1
%263 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %261, i64 %262, i32 0, i64 %254, i64 %257, i64 %258)
%264 = extractvalue { i64, i64, i64 } %263, 0
%265 = extractvalue { i64, i64, i64 } %263, 1
%266 = extractvalue { i64, i64, i64 } %263, 2
%267 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %261, i64 %262, i32 0, i64 %264, i64 %265, i64 %266)
%268 = extractvalue { i64, i64, i64 } %267, 0
%269 = extractvalue { i64, i64, i64 } %267, 1
%270 = extractvalue { i64, i64, i64 } %267, 2
%271 = load i64, i64* %185
%272 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %271, i64* elementtype(i64) %37)
%273 = extractvalue { i64, i64 } %272, 0
%274 = extractvalue { i64, i64 } %272, 1
%275 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %273, i64 %274, i32 0, i64 %268, i64 %269, i64 %270)
%276 = extractvalue { i64, i64, i64 } %275, 0
%277 = extractvalue { i64, i64, i64 } %275, 1
%278 = extractvalue { i64, i64, i64 } %275, 2
%279 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %273, i64 %274, i32 0, i64 %276, i64 %277, i64 %278)
%280 = extractvalue { i64, i64, i64 } %279, 0
%281 = extractvalue { i64, i64, i64 } %279, 1
%282 = extractvalue { i64, i64, i64 } %279, 2
%283 = load i64, i64* %199
%284 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %283, i64* elementtype(i64) %13)
%285 = extractvalue { i64, i64 } %284, 0
%286 = extractvalue { i64, i64 } %284, 1
%287 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %285, i64 %286, i32 0, i64 %280, i64 %281, i64 %282)
%288 = extractvalue { i64, i64, i64 } %287, 0
%289 = extractvalue { i64, i64, i64 } %287, 1
%290 = extractvalue { i64, i64, i64 } %287, 2
%291 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %285, i64 %286, i32 0, i64 %288, i64 %289, i64 %290)
%292 = extractvalue { i64, i64, i64 } %291, 0
%293 = extractvalue { i64, i64, i64 } %291, 1
%294 = extractvalue { i64, i64, i64 } %291, 2
%295 = getelementptr inbounds i64, i64* %0, i64 8
store i64 %292, i64* %295
%296 = load i64, i64* %199
%297 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %296, i64* elementtype(i64) %37)
%298 = extractvalue { i64, i64 } %297, 0
%299 = extractvalue { i64, i64 } %297, 1
%300 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %298, i64 %299, i32 0, i64 %293, i64 %294, i64 0)
%301 = extractvalue { i64, i64, i64 } %300, 0
%302 = extractvalue { i64, i64, i64 } %300, 1
%303 = extractvalue { i64, i64, i64 } %300, 2
%304 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %298, i64 %299, i32 0, i64 %301, i64 %302, i64 %303)
%305 = extractvalue { i64, i64, i64 } %304, 0
%306 = extractvalue { i64, i64, i64 } %304, 1
%307 = extractvalue { i64, i64, i64 } %304, 2
%308 = load i64, i64* %185
%309 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %308, i64* elementtype(i64) %51)
%310 = extractvalue { i64, i64 } %309, 0
%311 = extractvalue { i64, i64 } %309, 1
%312 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %310, i64 %311, i32 0, i64 %305, i64 %306, i64 %307)
%313 = extractvalue { i64, i64, i64 } %312, 0
%314 = extractvalue { i64, i64, i64 } %312, 1
%315 = extractvalue { i64, i64, i64 } %312, 2
%316 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %310, i64 %311, i32 0, i64 %313, i64 %314, i64 %315)
%317 = extractvalue { i64, i64, i64 } %316, 0
%318 = extractvalue { i64, i64, i64 } %316, 1
%319 = extractvalue { i64, i64, i64 } %316, 2
%320 = load i64, i64* %113
%321 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %320, i64* elementtype(i64) %99)
%322 = extractvalue { i64, i64 } %321, 0
%323 = extractvalue { i64, i64 } %321, 1
%324 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %322, i64 %323, i32 0, i64 %317, i64 %318, i64 %319)
%325 = extractvalue { i64, i64, i64 } %324, 0
%326 = extractvalue { i64, i64, i64 } %324, 1
%327 = extractvalue { i64, i64, i64 } %324, 2
%328 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %322, i64 %323, i32 0, i64 %325, i64 %326, i64 %327)
%329 = extractvalue { i64, i64, i64 } %328, 0
%330 = extractvalue { i64, i64, i64 } %328, 1
%331 = extractvalue { i64, i64, i64 } %328, 2
%332 = getelementptr inbounds i64, i64* %0, i64 9
store i64 %329, i64* %332
%333 = load i64, i64* %113
%334 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %333)
%335 = extractvalue { i64, i64 } %334, 0
%336 = extractvalue { i64, i64 } %334, 1
%337 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %335, i32 0, i64 %330, i64 %336)
%338 = extractvalue { i64, i64 } %337, 0
%339 = extractvalue { i64, i64 } %337, 1
%340 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %339, i32 0, i64 %331, i64 0)
%341 = extractvalue { i64, i64 } %340, 0
%342 = extractvalue { i64, i64 } %340, 1
%343 = load i64, i64* %185
%344 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %343, i64* elementtype(i64) %99)
%345 = extractvalue { i64, i64 } %344, 0
%346 = extractvalue { i64, i64 } %344, 1
%347 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %345, i64 %346, i32 0, i64 %338, i64 %341, i64 %342)
%348 = extractvalue { i64, i64, i64 } %347, 0
%349 = extractvalue { i64, i64, i64 } %347, 1
%350 = extractvalue { i64, i64, i64 } %347, 2
%351 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %345, i64 %346, i32 0, i64 %348, i64 %349, i64 %350)
%352 = extractvalue { i64, i64, i64 } %351, 0
%353 = extractvalue { i64, i64, i64 } %351, 1
%354 = extractvalue { i64, i64, i64 } %351, 2
%355 = load i64, i64* %199
%356 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %355, i64* elementtype(i64) %51)
%357 = extractvalue { i64, i64 } %356, 0
%358 = extractvalue { i64, i64 } %356, 1
%359 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %357, i64 %358, i32 0, i64 %352, i64 %353, i64 %354)
%360 = extractvalue { i64, i64, i64 } %359, 0
%361 = extractvalue { i64, i64, i64 } %359, 1
%362 = extractvalue { i64, i64, i64 } %359, 2
%363 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %357, i64 %358, i32 0, i64 %360, i64 %361, i64 %362)
%364 = extractvalue { i64, i64, i64 } %363, 0
%365 = extractvalue { i64, i64, i64 } %363, 1
%366 = extractvalue { i64, i64, i64 } %363, 2
%367 = getelementptr inbounds i64, i64* %0, i64 10
store i64 %364, i64* %367
%368 = load i64, i64* %199
%369 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %368, i64* elementtype(i64) %99)
%370 = extractvalue { i64, i64 } %369, 0
%371 = extractvalue { i64, i64 } %369, 1
%372 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %370, i64 %371, i32 0, i64 %365, i64 %366, i64 0)
%373 = extractvalue { i64, i64, i64 } %372, 0
%374 = extractvalue { i64, i64, i64 } %372, 1
%375 = extractvalue { i64, i64, i64 } %372, 2
%376 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %370, i64 %371, i32 0, i64 %373, i64 %374, i64 %375)
%377 = extractvalue { i64, i64, i64 } %376, 0
%378 = extractvalue { i64, i64, i64 } %376, 1
%379 = extractvalue { i64, i64, i64 } %376, 2
%380 = load i64, i64* %185
%381 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %380, i64* elementtype(i64) %113)
%382 = extractvalue { i64, i64 } %381, 0
%383 = extractvalue { i64, i64 } %381, 1
%384 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %382, i64 %383, i32 0, i64 %377, i64 %378, i64 %379)
%385 = extractvalue { i64, i64, i64 } %384, 0
%386 = extractvalue { i64, i64, i64 } %384, 1
%387 = extractvalue { i64, i64, i64 } %384, 2
%388 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %382, i64 %383, i32 0, i64 %385, i64 %386, i64 %387)
%389 = extractvalue { i64, i64, i64 } %388, 0
%390 = extractvalue { i64, i64, i64 } %388, 1
%391 = extractvalue { i64, i64, i64 } %388, 2
%392 = getelementptr inbounds i64, i64* %0, i64 11
store i64 %389, i64* %392
%393 = load i64, i64* %185
%394 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %393)
%395 = extractvalue { i64, i64 } %394, 0
%396 = extractvalue { i64, i64 } %394, 1
%397 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %395, i32 0, i64 %390, i64 %396)
%398 = extractvalue { i64, i64 } %397, 0
%399 = extractvalue { i64, i64 } %397, 1
%400 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %399, i32 0, i64 %391, i64 0)
%401 = extractvalue { i64, i64 } %400, 0
%402 = extractvalue { i64, i64 } %400, 1
%403 = load i64, i64* %199
%404 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %403, i64* elementtype(i64) %113)
%405 = extractvalue { i64, i64 } %404, 0
%406 = extractvalue { i64, i64 } %404, 1
%407 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %405, i64 %406, i32 0, i64 %398, i64 %401, i64 %402)
%408 = extractvalue { i64, i64, i64 } %407, 0
%409 = extractvalue { i64, i64, i64 } %407, 1
%410 = extractvalue { i64, i64, i64 } %407, 2
%411 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %405, i64 %406, i32 0, i64 %408, i64 %409, i64 %410)
%412 = extractvalue { i64, i64, i64 } %411, 0
%413 = extractvalue { i64, i64, i64 } %411, 1
%414 = extractvalue { i64, i64, i64 } %411, 2
%415 = getelementptr inbounds i64, i64* %0, i64 12
store i64 %412, i64* %415
%416 = load i64, i64* %199
%417 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %416, i64* elementtype(i64) %185)
%418 = extractvalue { i64, i64 } %417, 0
%419 = extractvalue { i64, i64 } %417, 1
%420 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %418, i64 %419, i32 0, i64 %413, i64 %414, i64 0)
%421 = extractvalue { i64, i64, i64 } %420, 0
%422 = extractvalue { i64, i64, i64 } %420, 1
%423 = extractvalue { i64, i64, i64 } %420, 2
%424 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %418, i64 %419, i32 0, i64 %421, i64 %422, i64 %423)
%425 = extractvalue { i64, i64, i64 } %424, 0
%426 = extractvalue { i64, i64, i64 } %424, 1
%427 = extractvalue { i64, i64, i64 } %424, 2
%428 = getelementptr inbounds i64, i64* %0, i64 13
store i64 %425, i64* %428
%429 = load i64, i64* %199
%430 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %429)
%431 = extractvalue { i64, i64 } %430, 0
%432 = extractvalue { i64, i64 } %430, 1
%433 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %431, i32 0, i64 %426, i64 %432)
%434 = extractvalue { i64, i64 } %433, 0
%435 = extractvalue { i64, i64 } %433, 1
%436 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %435, i32 0, i64 %427, i64 0)
%437 = extractvalue { i64, i64 } %436, 0
%438 = getelementptr inbounds i64, i64* %0, i64 14
store i64 %434, i64* %438
%439 = getelementptr inbounds i64, i64* %0, i64 15
store i64 %437, i64* %439
ret void
}