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