void bn_mul_comba8(unsigned long *r, unsigned long *a, unsigned long *b) {
  unsigned long t1, t2;
  unsigned long c1, c2, c3;
  c1 = 0;
  c2 = 0;
  c3 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"(a[0]), "m"(b[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[0]), "m"(b[1]) : "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[1]), "m"(b[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 %3" : "=a"(t1), "=d"(t2) : "a"(a[2]), "m"(b[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[1]), "m"(b[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[0]), "m"(b[2]) : "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[0]), "m"(b[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[1]), "m"(b[2]) : "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"(b[1]) : "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[3]), "m"(b[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 %3" : "=a"(t1), "=d"(t2) : "a"(a[4]), "m"(b[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[3]), "m"(b[1]) : "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[2]), "m"(b[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[1]), "m"(b[3]) : "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[0]), "m"(b[4]) : "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[0]), "m"(b[5]) : "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[1]), "m"(b[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[2]), "m"(b[3]) : "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"(b[2]) : "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"(b[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[5]), "m"(b[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 %3" : "=a"(t1), "=d"(t2) : "a"(a[6]), "m"(b[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"(b[1]) : "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"(b[2]) : "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[3]), "m"(b[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[2]), "m"(b[4]) : "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[1]), "m"(b[5]) : "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[0]), "m"(b[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);
  r[6] = c1;
  c1 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"(a[0]), "m"(b[7]) : "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[1]), "m"(b[6]) : "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[2]), "m"(b[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[3]), "m"(b[4]) : "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"(b[3]) : "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"(b[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[6]), "m"(b[1]) : "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"(b[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 %3" : "=a"(t1), "=d"(t2) : "a"(a[7]), "m"(b[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[6]), "m"(b[2]) : "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"(b[3]) : "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"(b[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[3]), "m"(b[5]) : "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"(b[6]) : "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[1]), "m"(b[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[8] = c3;
  c3 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"(a[2]), "m"(b[7]) : "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[3]), "m"(b[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[4]), "m"(b[5]) : "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"(b[4]) : "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"(b[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[7]), "m"(b[2]) : "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 %3" : "=a"(t1), "=d"(t2) : "a"(a[7]), "m"(b[3]) : "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"(b[4]) : "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"(b[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[4]), "m"(b[6]) : "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"(b[7]) : "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[4]), "m"(b[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);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"(a[5]), "m"(b[6]) : "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"(b[5]) : "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"(b[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);
  r[11] = c3;
  c3 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"(a[7]), "m"(b[5]) : "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"(b[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[5]), "m"(b[7]) : "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[6]), "m"(b[7]) : "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"(b[6]) : "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 %3" : "=a"(t1), "=d"(t2) : "a"(a[7]), "m"(b[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_mul_comba8>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    11e2 <bn_mul_comba8+0xe2>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x18(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x8(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x18(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    129b <bn_mul_comba8+0x19b>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    12f4 <bn_mul_comba8+0x1f4>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x10(%rax)
movq   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x18,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    13b3 <bn_mul_comba8+0x2b3>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    140c <bn_mul_comba8+0x30c>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    1465 <bn_mul_comba8+0x365>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x18(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x18(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x18(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    151e <bn_mul_comba8+0x41e>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1577 <bn_mul_comba8+0x477>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    15d0 <bn_mul_comba8+0x4d0>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x18,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1629 <bn_mul_comba8+0x529>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x20,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x20(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x28,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    16e8 <bn_mul_comba8+0x5e8>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x20,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1741 <bn_mul_comba8+0x641>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x18,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    179a <bn_mul_comba8+0x69a>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    17f3 <bn_mul_comba8+0x6f3>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    184c <bn_mul_comba8+0x74c>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x18(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x28(%rax)
movq   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x18(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    1905 <bn_mul_comba8+0x805>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    195e <bn_mul_comba8+0x85e>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    19b7 <bn_mul_comba8+0x8b7>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x18,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    1a10 <bn_mul_comba8+0x910>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x20,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    1a69 <bn_mul_comba8+0x969>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x28,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    1ac2 <bn_mul_comba8+0x9c2>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x30,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x30(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x38,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1b81 <bn_mul_comba8+0xa81>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x30,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1bda <bn_mul_comba8+0xada>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x28,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1c33 <bn_mul_comba8+0xb33>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x20,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1c8c <bn_mul_comba8+0xb8c>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x18,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1ce5 <bn_mul_comba8+0xbe5>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1d3e <bn_mul_comba8+0xc3e>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1d97 <bn_mul_comba8+0xc97>
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x18(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x38(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1e54 <bn_mul_comba8+0xd54>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1ead <bn_mul_comba8+0xdad>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x18,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1f06 <bn_mul_comba8+0xe06>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x20,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1f5f <bn_mul_comba8+0xe5f>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x28,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1fb8 <bn_mul_comba8+0xeb8>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x30,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    2011 <bn_mul_comba8+0xf11>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x38,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x40(%rax)
movq   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x38,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    20d2 <bn_mul_comba8+0xfd2>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x30,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    212b <bn_mul_comba8+0x102b>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x28,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    2184 <bn_mul_comba8+0x1084>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x20,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    21dd <bn_mul_comba8+0x10dd>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x18,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    2236 <bn_mul_comba8+0x1136>
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x48(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x18,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    22f7 <bn_mul_comba8+0x11f7>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x20,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    2350 <bn_mul_comba8+0x1250>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x28,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    23a9 <bn_mul_comba8+0x12a9>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x30,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    2402 <bn_mul_comba8+0x1302>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x38,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x50(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x38,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    24c3 <bn_mul_comba8+0x13c3>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x30,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    251c <bn_mul_comba8+0x141c>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x28,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    2575 <bn_mul_comba8+0x1475>
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x20,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x58(%rax)
movq   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x28,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    2636 <bn_mul_comba8+0x1536>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x30,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
jmp    268f <bn_mul_comba8+0x158f>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x38,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x60(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x38,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
jmp    2750 <bn_mul_comba8+0x1650>
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x30,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x68(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x18(%rbp),%rcx
add    $0x38,%rcx
mulq   (%rcx)
mov    %rax,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x70(%rax)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x78(%rax)
pop    %rbp
ret

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

LLVM IR (-O0):
define void @bn_mul_comba8(i64* %0, i64* %1, i64* %2) {
%4 = alloca i64*
%5 = alloca i64*
%6 = alloca i64*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
store i64* %0, i64** %4
store i64* %1, i64** %5
store i64* %2, i64** %6
store i64 0, i64* %9
store i64 0, i64* %10
store i64 0, i64* %11
br label %12
12: ; preds = %3
%13 = load i64*, i64** %5
%14 = getelementptr inbounds i64, i64* %13, i64 0
%15 = load i64, i64* %14
%16 = load i64*, i64** %6
%17 = getelementptr inbounds i64, i64* %16, i64 0
%18 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %15, i64* elementtype(i64) %17)
%19 = extractvalue { i64, i64 } %18, 0
%20 = extractvalue { i64, i64 } %18, 1
store i64 %19, i64* %7
store i64 %20, i64* %8
%21 = load i64, i64* %9
%22 = load i64, i64* %8
%23 = load i64, i64* %7
%24 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %23, i32 0, i64 %21, i64 %22)
%25 = extractvalue { i64, i64 } %24, 0
%26 = extractvalue { i64, i64 } %24, 1
store i64 %25, i64* %9
store i64 %26, i64* %8
%27 = load i64, i64* %10
%28 = load i64, i64* %11
%29 = load i64, i64* %8
%30 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %29, i32 0, i64 %27, i64 %28)
%31 = extractvalue { i64, i64 } %30, 0
%32 = extractvalue { i64, i64 } %30, 1
store i64 %31, i64* %10
store i64 %32, i64* %11
br label %33
33: ; preds = %12
%34 = load i64, i64* %9
%35 = load i64*, i64** %4
%36 = getelementptr inbounds i64, i64* %35, i64 0
store i64 %34, i64* %36
store i64 0, i64* %9
br label %37
37: ; preds = %33
%38 = load i64*, i64** %5
%39 = getelementptr inbounds i64, i64* %38, i64 0
%40 = load i64, i64* %39
%41 = load i64*, i64** %6
%42 = getelementptr inbounds i64, i64* %41, i64 1
%43 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %40, i64* elementtype(i64) %42)
%44 = extractvalue { i64, i64 } %43, 0
%45 = extractvalue { i64, i64 } %43, 1
store i64 %44, i64* %7
store i64 %45, i64* %8
%46 = load i64, i64* %10
%47 = load i64, i64* %8
%48 = load i64, i64* %7
%49 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %48, i32 0, i64 %46, i64 %47)
%50 = extractvalue { i64, i64 } %49, 0
%51 = extractvalue { i64, i64 } %49, 1
store i64 %50, i64* %10
store i64 %51, i64* %8
%52 = load i64, i64* %11
%53 = load i64, i64* %9
%54 = load i64, i64* %8
%55 = 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 %52, i64 %53)
%56 = extractvalue { i64, i64 } %55, 0
%57 = extractvalue { i64, i64 } %55, 1
store i64 %56, i64* %11
store i64 %57, i64* %9
br label %58
58: ; preds = %37
br label %59
59: ; preds = %58
%60 = load i64*, i64** %5
%61 = getelementptr inbounds i64, i64* %60, i64 1
%62 = load i64, i64* %61
%63 = load i64*, i64** %6
%64 = getelementptr inbounds i64, i64* %63, i64 0
%65 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %62, i64* elementtype(i64) %64)
%66 = extractvalue { i64, i64 } %65, 0
%67 = extractvalue { i64, i64 } %65, 1
store i64 %66, i64* %7
store i64 %67, i64* %8
%68 = load i64, i64* %10
%69 = load i64, i64* %8
%70 = load i64, i64* %7
%71 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %70, i32 0, i64 %68, i64 %69)
%72 = extractvalue { i64, i64 } %71, 0
%73 = extractvalue { i64, i64 } %71, 1
store i64 %72, i64* %10
store i64 %73, i64* %8
%74 = load i64, i64* %11
%75 = load i64, i64* %9
%76 = load i64, i64* %8
%77 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %76, i32 0, i64 %74, i64 %75)
%78 = extractvalue { i64, i64 } %77, 0
%79 = extractvalue { i64, i64 } %77, 1
store i64 %78, i64* %11
store i64 %79, i64* %9
br label %80
80: ; preds = %59
%81 = load i64, i64* %10
%82 = load i64*, i64** %4
%83 = getelementptr inbounds i64, i64* %82, i64 1
store i64 %81, i64* %83
store i64 0, i64* %10
br label %84
84: ; preds = %80
%85 = load i64*, i64** %5
%86 = getelementptr inbounds i64, i64* %85, i64 2
%87 = load i64, i64* %86
%88 = load i64*, i64** %6
%89 = getelementptr inbounds i64, i64* %88, i64 0
%90 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %87, i64* elementtype(i64) %89)
%91 = extractvalue { i64, i64 } %90, 0
%92 = extractvalue { i64, i64 } %90, 1
store i64 %91, i64* %7
store i64 %92, i64* %8
%93 = load i64, i64* %11
%94 = load i64, i64* %8
%95 = load i64, i64* %7
%96 = 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 %93, i64 %94)
%97 = extractvalue { i64, i64 } %96, 0
%98 = extractvalue { i64, i64 } %96, 1
store i64 %97, i64* %11
store i64 %98, i64* %8
%99 = load i64, i64* %9
%100 = load i64, i64* %10
%101 = load i64, i64* %8
%102 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %101, i32 0, i64 %99, i64 %100)
%103 = extractvalue { i64, i64 } %102, 0
%104 = extractvalue { i64, i64 } %102, 1
store i64 %103, i64* %9
store i64 %104, i64* %10
br label %105
105: ; preds = %84
br label %106
106: ; preds = %105
%107 = load i64*, i64** %5
%108 = getelementptr inbounds i64, i64* %107, i64 1
%109 = load i64, i64* %108
%110 = load i64*, i64** %6
%111 = getelementptr inbounds i64, i64* %110, i64 1
%112 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %109, i64* elementtype(i64) %111)
%113 = extractvalue { i64, i64 } %112, 0
%114 = extractvalue { i64, i64 } %112, 1
store i64 %113, i64* %7
store i64 %114, i64* %8
%115 = load i64, i64* %11
%116 = load i64, i64* %8
%117 = load i64, i64* %7
%118 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %117, i32 0, i64 %115, i64 %116)
%119 = extractvalue { i64, i64 } %118, 0
%120 = extractvalue { i64, i64 } %118, 1
store i64 %119, i64* %11
store i64 %120, i64* %8
%121 = load i64, i64* %9
%122 = load i64, i64* %10
%123 = load i64, i64* %8
%124 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %123, i32 0, i64 %121, i64 %122)
%125 = extractvalue { i64, i64 } %124, 0
%126 = extractvalue { i64, i64 } %124, 1
store i64 %125, i64* %9
store i64 %126, i64* %10
br label %127
127: ; preds = %106
br label %128
128: ; preds = %127
%129 = load i64*, i64** %5
%130 = getelementptr inbounds i64, i64* %129, i64 0
%131 = load i64, i64* %130
%132 = load i64*, i64** %6
%133 = getelementptr inbounds i64, i64* %132, i64 2
%134 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %131, i64* elementtype(i64) %133)
%135 = extractvalue { i64, i64 } %134, 0
%136 = extractvalue { i64, i64 } %134, 1
store i64 %135, i64* %7
store i64 %136, i64* %8
%137 = load i64, i64* %11
%138 = load i64, i64* %8
%139 = load i64, i64* %7
%140 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %139, i32 0, i64 %137, i64 %138)
%141 = extractvalue { i64, i64 } %140, 0
%142 = extractvalue { i64, i64 } %140, 1
store i64 %141, i64* %11
store i64 %142, i64* %8
%143 = load i64, i64* %9
%144 = load i64, i64* %10
%145 = load i64, i64* %8
%146 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %145, i32 0, i64 %143, i64 %144)
%147 = extractvalue { i64, i64 } %146, 0
%148 = extractvalue { i64, i64 } %146, 1
store i64 %147, i64* %9
store i64 %148, i64* %10
br label %149
149: ; preds = %128
%150 = load i64, i64* %11
%151 = load i64*, i64** %4
%152 = getelementptr inbounds i64, i64* %151, i64 2
store i64 %150, i64* %152
store i64 0, i64* %11
br label %153
153: ; preds = %149
%154 = load i64*, i64** %5
%155 = getelementptr inbounds i64, i64* %154, i64 0
%156 = load i64, i64* %155
%157 = load i64*, i64** %6
%158 = getelementptr inbounds i64, i64* %157, i64 3
%159 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %156, i64* elementtype(i64) %158)
%160 = extractvalue { i64, i64 } %159, 0
%161 = extractvalue { i64, i64 } %159, 1
store i64 %160, i64* %7
store i64 %161, i64* %8
%162 = load i64, i64* %9
%163 = load i64, i64* %8
%164 = load i64, i64* %7
%165 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %164, i32 0, i64 %162, i64 %163)
%166 = extractvalue { i64, i64 } %165, 0
%167 = extractvalue { i64, i64 } %165, 1
store i64 %166, i64* %9
store i64 %167, i64* %8
%168 = load i64, i64* %10
%169 = load i64, i64* %11
%170 = load i64, i64* %8
%171 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %170, i32 0, i64 %168, i64 %169)
%172 = extractvalue { i64, i64 } %171, 0
%173 = extractvalue { i64, i64 } %171, 1
store i64 %172, i64* %10
store i64 %173, i64* %11
br label %174
174: ; preds = %153
br label %175
175: ; preds = %174
%176 = load i64*, i64** %5
%177 = getelementptr inbounds i64, i64* %176, i64 1
%178 = load i64, i64* %177
%179 = load i64*, i64** %6
%180 = getelementptr inbounds i64, i64* %179, i64 2
%181 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %178, i64* elementtype(i64) %180)
%182 = extractvalue { i64, i64 } %181, 0
%183 = extractvalue { i64, i64 } %181, 1
store i64 %182, i64* %7
store i64 %183, i64* %8
%184 = load i64, i64* %9
%185 = load i64, i64* %8
%186 = load i64, i64* %7
%187 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %186, i32 0, i64 %184, i64 %185)
%188 = extractvalue { i64, i64 } %187, 0
%189 = extractvalue { i64, i64 } %187, 1
store i64 %188, i64* %9
store i64 %189, i64* %8
%190 = load i64, i64* %10
%191 = load i64, i64* %11
%192 = load i64, i64* %8
%193 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %192, i32 0, i64 %190, i64 %191)
%194 = extractvalue { i64, i64 } %193, 0
%195 = extractvalue { i64, i64 } %193, 1
store i64 %194, i64* %10
store i64 %195, i64* %11
br label %196
196: ; preds = %175
br label %197
197: ; preds = %196
%198 = load i64*, i64** %5
%199 = getelementptr inbounds i64, i64* %198, i64 2
%200 = load i64, i64* %199
%201 = load i64*, i64** %6
%202 = getelementptr inbounds i64, i64* %201, i64 1
%203 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %200, i64* elementtype(i64) %202)
%204 = extractvalue { i64, i64 } %203, 0
%205 = extractvalue { i64, i64 } %203, 1
store i64 %204, i64* %7
store i64 %205, i64* %8
%206 = load i64, i64* %9
%207 = load i64, i64* %8
%208 = load i64, i64* %7
%209 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %208, i32 0, i64 %206, i64 %207)
%210 = extractvalue { i64, i64 } %209, 0
%211 = extractvalue { i64, i64 } %209, 1
store i64 %210, i64* %9
store i64 %211, i64* %8
%212 = load i64, i64* %10
%213 = load i64, i64* %11
%214 = load i64, i64* %8
%215 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %214, i32 0, i64 %212, i64 %213)
%216 = extractvalue { i64, i64 } %215, 0
%217 = extractvalue { i64, i64 } %215, 1
store i64 %216, i64* %10
store i64 %217, i64* %11
br label %218
218: ; preds = %197
br label %219
219: ; preds = %218
%220 = load i64*, i64** %5
%221 = getelementptr inbounds i64, i64* %220, i64 3
%222 = load i64, i64* %221
%223 = load i64*, i64** %6
%224 = getelementptr inbounds i64, i64* %223, i64 0
%225 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %222, i64* elementtype(i64) %224)
%226 = extractvalue { i64, i64 } %225, 0
%227 = extractvalue { i64, i64 } %225, 1
store i64 %226, i64* %7
store i64 %227, i64* %8
%228 = load i64, i64* %9
%229 = load i64, i64* %8
%230 = load i64, i64* %7
%231 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %230, i32 0, i64 %228, i64 %229)
%232 = extractvalue { i64, i64 } %231, 0
%233 = extractvalue { i64, i64 } %231, 1
store i64 %232, i64* %9
store i64 %233, i64* %8
%234 = load i64, i64* %10
%235 = load i64, i64* %11
%236 = load i64, i64* %8
%237 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %236, i32 0, i64 %234, i64 %235)
%238 = extractvalue { i64, i64 } %237, 0
%239 = extractvalue { i64, i64 } %237, 1
store i64 %238, i64* %10
store i64 %239, i64* %11
br label %240
240: ; preds = %219
%241 = load i64, i64* %9
%242 = load i64*, i64** %4
%243 = getelementptr inbounds i64, i64* %242, i64 3
store i64 %241, i64* %243
store i64 0, i64* %9
br label %244
244: ; preds = %240
%245 = load i64*, i64** %5
%246 = getelementptr inbounds i64, i64* %245, i64 4
%247 = load i64, i64* %246
%248 = load i64*, i64** %6
%249 = getelementptr inbounds i64, i64* %248, i64 0
%250 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %247, i64* elementtype(i64) %249)
%251 = extractvalue { i64, i64 } %250, 0
%252 = extractvalue { i64, i64 } %250, 1
store i64 %251, i64* %7
store i64 %252, i64* %8
%253 = load i64, i64* %10
%254 = load i64, i64* %8
%255 = load i64, i64* %7
%256 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %255, i32 0, i64 %253, i64 %254)
%257 = extractvalue { i64, i64 } %256, 0
%258 = extractvalue { i64, i64 } %256, 1
store i64 %257, i64* %10
store i64 %258, i64* %8
%259 = load i64, i64* %11
%260 = load i64, i64* %9
%261 = load i64, i64* %8
%262 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %261, i32 0, i64 %259, i64 %260)
%263 = extractvalue { i64, i64 } %262, 0
%264 = extractvalue { i64, i64 } %262, 1
store i64 %263, i64* %11
store i64 %264, i64* %9
br label %265
265: ; preds = %244
br label %266
266: ; preds = %265
%267 = load i64*, i64** %5
%268 = getelementptr inbounds i64, i64* %267, i64 3
%269 = load i64, i64* %268
%270 = load i64*, i64** %6
%271 = getelementptr inbounds i64, i64* %270, i64 1
%272 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %269, i64* elementtype(i64) %271)
%273 = extractvalue { i64, i64 } %272, 0
%274 = extractvalue { i64, i64 } %272, 1
store i64 %273, i64* %7
store i64 %274, i64* %8
%275 = load i64, i64* %10
%276 = load i64, i64* %8
%277 = load i64, i64* %7
%278 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %277, i32 0, i64 %275, i64 %276)
%279 = extractvalue { i64, i64 } %278, 0
%280 = extractvalue { i64, i64 } %278, 1
store i64 %279, i64* %10
store i64 %280, i64* %8
%281 = load i64, i64* %11
%282 = load i64, i64* %9
%283 = load i64, i64* %8
%284 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %283, i32 0, i64 %281, i64 %282)
%285 = extractvalue { i64, i64 } %284, 0
%286 = extractvalue { i64, i64 } %284, 1
store i64 %285, i64* %11
store i64 %286, i64* %9
br label %287
287: ; preds = %266
br label %288
288: ; preds = %287
%289 = load i64*, i64** %5
%290 = getelementptr inbounds i64, i64* %289, i64 2
%291 = load i64, i64* %290
%292 = load i64*, i64** %6
%293 = getelementptr inbounds i64, i64* %292, i64 2
%294 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %291, i64* elementtype(i64) %293)
%295 = extractvalue { i64, i64 } %294, 0
%296 = extractvalue { i64, i64 } %294, 1
store i64 %295, i64* %7
store i64 %296, i64* %8
%297 = load i64, i64* %10
%298 = load i64, i64* %8
%299 = load i64, i64* %7
%300 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %299, i32 0, i64 %297, i64 %298)
%301 = extractvalue { i64, i64 } %300, 0
%302 = extractvalue { i64, i64 } %300, 1
store i64 %301, i64* %10
store i64 %302, i64* %8
%303 = load i64, i64* %11
%304 = load i64, i64* %9
%305 = load i64, i64* %8
%306 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %305, i32 0, i64 %303, i64 %304)
%307 = extractvalue { i64, i64 } %306, 0
%308 = extractvalue { i64, i64 } %306, 1
store i64 %307, i64* %11
store i64 %308, i64* %9
br label %309
309: ; preds = %288
br label %310
310: ; preds = %309
%311 = load i64*, i64** %5
%312 = getelementptr inbounds i64, i64* %311, i64 1
%313 = load i64, i64* %312
%314 = load i64*, i64** %6
%315 = getelementptr inbounds i64, i64* %314, i64 3
%316 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %313, i64* elementtype(i64) %315)
%317 = extractvalue { i64, i64 } %316, 0
%318 = extractvalue { i64, i64 } %316, 1
store i64 %317, i64* %7
store i64 %318, i64* %8
%319 = load i64, i64* %10
%320 = load i64, i64* %8
%321 = load i64, i64* %7
%322 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %321, i32 0, i64 %319, i64 %320)
%323 = extractvalue { i64, i64 } %322, 0
%324 = extractvalue { i64, i64 } %322, 1
store i64 %323, i64* %10
store i64 %324, i64* %8
%325 = load i64, i64* %11
%326 = load i64, i64* %9
%327 = load i64, i64* %8
%328 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %327, i32 0, i64 %325, i64 %326)
%329 = extractvalue { i64, i64 } %328, 0
%330 = extractvalue { i64, i64 } %328, 1
store i64 %329, i64* %11
store i64 %330, i64* %9
br label %331
331: ; preds = %310
br label %332
332: ; preds = %331
%333 = load i64*, i64** %5
%334 = getelementptr inbounds i64, i64* %333, i64 0
%335 = load i64, i64* %334
%336 = load i64*, i64** %6
%337 = getelementptr inbounds i64, i64* %336, i64 4
%338 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %335, i64* elementtype(i64) %337)
%339 = extractvalue { i64, i64 } %338, 0
%340 = extractvalue { i64, i64 } %338, 1
store i64 %339, i64* %7
store i64 %340, i64* %8
%341 = load i64, i64* %10
%342 = load i64, i64* %8
%343 = load i64, i64* %7
%344 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %343, i32 0, i64 %341, i64 %342)
%345 = extractvalue { i64, i64 } %344, 0
%346 = extractvalue { i64, i64 } %344, 1
store i64 %345, i64* %10
store i64 %346, i64* %8
%347 = load i64, i64* %11
%348 = load i64, i64* %9
%349 = load i64, i64* %8
%350 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %349, i32 0, i64 %347, i64 %348)
%351 = extractvalue { i64, i64 } %350, 0
%352 = extractvalue { i64, i64 } %350, 1
store i64 %351, i64* %11
store i64 %352, i64* %9
br label %353
353: ; preds = %332
%354 = load i64, i64* %10
%355 = load i64*, i64** %4
%356 = getelementptr inbounds i64, i64* %355, i64 4
store i64 %354, i64* %356
store i64 0, i64* %10
br label %357
357: ; preds = %353
%358 = load i64*, i64** %5
%359 = getelementptr inbounds i64, i64* %358, i64 0
%360 = load i64, i64* %359
%361 = load i64*, i64** %6
%362 = getelementptr inbounds i64, i64* %361, i64 5
%363 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %360, i64* elementtype(i64) %362)
%364 = extractvalue { i64, i64 } %363, 0
%365 = extractvalue { i64, i64 } %363, 1
store i64 %364, i64* %7
store i64 %365, i64* %8
%366 = load i64, i64* %11
%367 = load i64, i64* %8
%368 = load i64, i64* %7
%369 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},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* %11
store i64 %371, i64* %8
%372 = load i64, i64* %9
%373 = load i64, i64* %10
%374 = load i64, i64* %8
%375 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %374, i32 0, i64 %372, i64 %373)
%376 = extractvalue { i64, i64 } %375, 0
%377 = extractvalue { i64, i64 } %375, 1
store i64 %376, i64* %9
store i64 %377, i64* %10
br label %378
378: ; preds = %357
br label %379
379: ; preds = %378
%380 = load i64*, i64** %5
%381 = getelementptr inbounds i64, i64* %380, i64 1
%382 = load i64, i64* %381
%383 = load i64*, i64** %6
%384 = getelementptr inbounds i64, i64* %383, i64 4
%385 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %382, i64* elementtype(i64) %384)
%386 = extractvalue { i64, i64 } %385, 0
%387 = extractvalue { i64, i64 } %385, 1
store i64 %386, i64* %7
store i64 %387, i64* %8
%388 = load i64, i64* %11
%389 = load i64, i64* %8
%390 = load i64, i64* %7
%391 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %390, i32 0, i64 %388, i64 %389)
%392 = extractvalue { i64, i64 } %391, 0
%393 = extractvalue { i64, i64 } %391, 1
store i64 %392, i64* %11
store i64 %393, i64* %8
%394 = load i64, i64* %9
%395 = load i64, i64* %10
%396 = load i64, i64* %8
%397 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %396, i32 0, i64 %394, i64 %395)
%398 = extractvalue { i64, i64 } %397, 0
%399 = extractvalue { i64, i64 } %397, 1
store i64 %398, i64* %9
store i64 %399, i64* %10
br label %400
400: ; preds = %379
br label %401
401: ; preds = %400
%402 = load i64*, i64** %5
%403 = getelementptr inbounds i64, i64* %402, i64 2
%404 = load i64, i64* %403
%405 = load i64*, i64** %6
%406 = getelementptr inbounds i64, i64* %405, i64 3
%407 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %404, i64* elementtype(i64) %406)
%408 = extractvalue { i64, i64 } %407, 0
%409 = extractvalue { i64, i64 } %407, 1
store i64 %408, i64* %7
store i64 %409, i64* %8
%410 = load i64, i64* %11
%411 = load i64, i64* %8
%412 = load i64, i64* %7
%413 = 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 %410, i64 %411)
%414 = extractvalue { i64, i64 } %413, 0
%415 = extractvalue { i64, i64 } %413, 1
store i64 %414, i64* %11
store i64 %415, i64* %8
%416 = load i64, i64* %9
%417 = load i64, i64* %10
%418 = load i64, i64* %8
%419 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %418, i32 0, i64 %416, i64 %417)
%420 = extractvalue { i64, i64 } %419, 0
%421 = extractvalue { i64, i64 } %419, 1
store i64 %420, i64* %9
store i64 %421, i64* %10
br label %422
422: ; preds = %401
br label %423
423: ; preds = %422
%424 = load i64*, i64** %5
%425 = getelementptr inbounds i64, i64* %424, i64 3
%426 = load i64, i64* %425
%427 = load i64*, i64** %6
%428 = getelementptr inbounds i64, i64* %427, i64 2
%429 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %426, i64* elementtype(i64) %428)
%430 = extractvalue { i64, i64 } %429, 0
%431 = extractvalue { i64, i64 } %429, 1
store i64 %430, i64* %7
store i64 %431, i64* %8
%432 = load i64, i64* %11
%433 = load i64, i64* %8
%434 = load i64, i64* %7
%435 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %434, i32 0, i64 %432, i64 %433)
%436 = extractvalue { i64, i64 } %435, 0
%437 = extractvalue { i64, i64 } %435, 1
store i64 %436, i64* %11
store i64 %437, i64* %8
%438 = load i64, i64* %9
%439 = load i64, i64* %10
%440 = load i64, i64* %8
%441 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %440, i32 0, i64 %438, i64 %439)
%442 = extractvalue { i64, i64 } %441, 0
%443 = extractvalue { i64, i64 } %441, 1
store i64 %442, i64* %9
store i64 %443, i64* %10
br label %444
444: ; preds = %423
br label %445
445: ; preds = %444
%446 = load i64*, i64** %5
%447 = getelementptr inbounds i64, i64* %446, i64 4
%448 = load i64, i64* %447
%449 = load i64*, i64** %6
%450 = getelementptr inbounds i64, i64* %449, i64 1
%451 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %448, i64* elementtype(i64) %450)
%452 = extractvalue { i64, i64 } %451, 0
%453 = extractvalue { i64, i64 } %451, 1
store i64 %452, i64* %7
store i64 %453, i64* %8
%454 = load i64, i64* %11
%455 = load i64, i64* %8
%456 = load i64, i64* %7
%457 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %456, i32 0, i64 %454, i64 %455)
%458 = extractvalue { i64, i64 } %457, 0
%459 = extractvalue { i64, i64 } %457, 1
store i64 %458, i64* %11
store i64 %459, i64* %8
%460 = load i64, i64* %9
%461 = load i64, i64* %10
%462 = load i64, i64* %8
%463 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %462, i32 0, i64 %460, i64 %461)
%464 = extractvalue { i64, i64 } %463, 0
%465 = extractvalue { i64, i64 } %463, 1
store i64 %464, i64* %9
store i64 %465, i64* %10
br label %466
466: ; preds = %445
br label %467
467: ; preds = %466
%468 = load i64*, i64** %5
%469 = getelementptr inbounds i64, i64* %468, i64 5
%470 = load i64, i64* %469
%471 = load i64*, i64** %6
%472 = getelementptr inbounds i64, i64* %471, i64 0
%473 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %470, i64* elementtype(i64) %472)
%474 = extractvalue { i64, i64 } %473, 0
%475 = extractvalue { i64, i64 } %473, 1
store i64 %474, i64* %7
store i64 %475, i64* %8
%476 = load i64, i64* %11
%477 = load i64, i64* %8
%478 = load i64, i64* %7
%479 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %478, i32 0, i64 %476, i64 %477)
%480 = extractvalue { i64, i64 } %479, 0
%481 = extractvalue { i64, i64 } %479, 1
store i64 %480, i64* %11
store i64 %481, i64* %8
%482 = load i64, i64* %9
%483 = load i64, i64* %10
%484 = load i64, i64* %8
%485 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %484, i32 0, i64 %482, i64 %483)
%486 = extractvalue { i64, i64 } %485, 0
%487 = extractvalue { i64, i64 } %485, 1
store i64 %486, i64* %9
store i64 %487, i64* %10
br label %488
488: ; preds = %467
%489 = load i64, i64* %11
%490 = load i64*, i64** %4
%491 = getelementptr inbounds i64, i64* %490, i64 5
store i64 %489, i64* %491
store i64 0, i64* %11
br label %492
492: ; preds = %488
%493 = load i64*, i64** %5
%494 = getelementptr inbounds i64, i64* %493, i64 6
%495 = load i64, i64* %494
%496 = load i64*, i64** %6
%497 = getelementptr inbounds i64, i64* %496, i64 0
%498 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %495, i64* elementtype(i64) %497)
%499 = extractvalue { i64, i64 } %498, 0
%500 = extractvalue { i64, i64 } %498, 1
store i64 %499, i64* %7
store i64 %500, i64* %8
%501 = load i64, i64* %9
%502 = load i64, i64* %8
%503 = load i64, i64* %7
%504 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %503, i32 0, i64 %501, i64 %502)
%505 = extractvalue { i64, i64 } %504, 0
%506 = extractvalue { i64, i64 } %504, 1
store i64 %505, i64* %9
store i64 %506, i64* %8
%507 = load i64, i64* %10
%508 = load i64, i64* %11
%509 = load i64, i64* %8
%510 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %509, i32 0, i64 %507, i64 %508)
%511 = extractvalue { i64, i64 } %510, 0
%512 = extractvalue { i64, i64 } %510, 1
store i64 %511, i64* %10
store i64 %512, i64* %11
br label %513
513: ; preds = %492
br label %514
514: ; preds = %513
%515 = load i64*, i64** %5
%516 = getelementptr inbounds i64, i64* %515, i64 5
%517 = load i64, i64* %516
%518 = load i64*, i64** %6
%519 = getelementptr inbounds i64, i64* %518, i64 1
%520 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %517, i64* elementtype(i64) %519)
%521 = extractvalue { i64, i64 } %520, 0
%522 = extractvalue { i64, i64 } %520, 1
store i64 %521, i64* %7
store i64 %522, i64* %8
%523 = load i64, i64* %9
%524 = load i64, i64* %8
%525 = load i64, i64* %7
%526 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %525, i32 0, i64 %523, i64 %524)
%527 = extractvalue { i64, i64 } %526, 0
%528 = extractvalue { i64, i64 } %526, 1
store i64 %527, i64* %9
store i64 %528, i64* %8
%529 = load i64, i64* %10
%530 = load i64, i64* %11
%531 = load i64, i64* %8
%532 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %531, i32 0, i64 %529, i64 %530)
%533 = extractvalue { i64, i64 } %532, 0
%534 = extractvalue { i64, i64 } %532, 1
store i64 %533, i64* %10
store i64 %534, i64* %11
br label %535
535: ; preds = %514
br label %536
536: ; preds = %535
%537 = load i64*, i64** %5
%538 = getelementptr inbounds i64, i64* %537, i64 4
%539 = load i64, i64* %538
%540 = load i64*, i64** %6
%541 = getelementptr inbounds i64, i64* %540, i64 2
%542 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %539, i64* elementtype(i64) %541)
%543 = extractvalue { i64, i64 } %542, 0
%544 = extractvalue { i64, i64 } %542, 1
store i64 %543, i64* %7
store i64 %544, i64* %8
%545 = load i64, i64* %9
%546 = load i64, i64* %8
%547 = load i64, i64* %7
%548 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %547, i32 0, i64 %545, i64 %546)
%549 = extractvalue { i64, i64 } %548, 0
%550 = extractvalue { i64, i64 } %548, 1
store i64 %549, i64* %9
store i64 %550, i64* %8
%551 = load i64, i64* %10
%552 = load i64, i64* %11
%553 = load i64, i64* %8
%554 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %553, i32 0, i64 %551, i64 %552)
%555 = extractvalue { i64, i64 } %554, 0
%556 = extractvalue { i64, i64 } %554, 1
store i64 %555, i64* %10
store i64 %556, i64* %11
br label %557
557: ; preds = %536
br label %558
558: ; preds = %557
%559 = load i64*, i64** %5
%560 = getelementptr inbounds i64, i64* %559, i64 3
%561 = load i64, i64* %560
%562 = load i64*, i64** %6
%563 = getelementptr inbounds i64, i64* %562, i64 3
%564 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %561, i64* elementtype(i64) %563)
%565 = extractvalue { i64, i64 } %564, 0
%566 = extractvalue { i64, i64 } %564, 1
store i64 %565, i64* %7
store i64 %566, i64* %8
%567 = load i64, i64* %9
%568 = load i64, i64* %8
%569 = load i64, i64* %7
%570 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %569, i32 0, i64 %567, i64 %568)
%571 = extractvalue { i64, i64 } %570, 0
%572 = extractvalue { i64, i64 } %570, 1
store i64 %571, i64* %9
store i64 %572, i64* %8
%573 = load i64, i64* %10
%574 = load i64, i64* %11
%575 = load i64, i64* %8
%576 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %575, i32 0, i64 %573, i64 %574)
%577 = extractvalue { i64, i64 } %576, 0
%578 = extractvalue { i64, i64 } %576, 1
store i64 %577, i64* %10
store i64 %578, i64* %11
br label %579
579: ; preds = %558
br label %580
580: ; preds = %579
%581 = load i64*, i64** %5
%582 = getelementptr inbounds i64, i64* %581, i64 2
%583 = load i64, i64* %582
%584 = load i64*, i64** %6
%585 = getelementptr inbounds i64, i64* %584, i64 4
%586 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %583, i64* elementtype(i64) %585)
%587 = extractvalue { i64, i64 } %586, 0
%588 = extractvalue { i64, i64 } %586, 1
store i64 %587, i64* %7
store i64 %588, i64* %8
%589 = load i64, i64* %9
%590 = load i64, i64* %8
%591 = load i64, i64* %7
%592 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %591, i32 0, i64 %589, i64 %590)
%593 = extractvalue { i64, i64 } %592, 0
%594 = extractvalue { i64, i64 } %592, 1
store i64 %593, i64* %9
store i64 %594, i64* %8
%595 = load i64, i64* %10
%596 = load i64, i64* %11
%597 = load i64, i64* %8
%598 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %597, i32 0, i64 %595, i64 %596)
%599 = extractvalue { i64, i64 } %598, 0
%600 = extractvalue { i64, i64 } %598, 1
store i64 %599, i64* %10
store i64 %600, i64* %11
br label %601
601: ; preds = %580
br label %602
602: ; preds = %601
%603 = load i64*, i64** %5
%604 = getelementptr inbounds i64, i64* %603, i64 1
%605 = load i64, i64* %604
%606 = load i64*, i64** %6
%607 = getelementptr inbounds i64, i64* %606, i64 5
%608 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %605, i64* elementtype(i64) %607)
%609 = extractvalue { i64, i64 } %608, 0
%610 = extractvalue { i64, i64 } %608, 1
store i64 %609, i64* %7
store i64 %610, i64* %8
%611 = load i64, i64* %9
%612 = load i64, i64* %8
%613 = load i64, i64* %7
%614 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %613, i32 0, i64 %611, i64 %612)
%615 = extractvalue { i64, i64 } %614, 0
%616 = extractvalue { i64, i64 } %614, 1
store i64 %615, i64* %9
store i64 %616, i64* %8
%617 = load i64, i64* %10
%618 = load i64, i64* %11
%619 = load i64, i64* %8
%620 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %619, i32 0, i64 %617, i64 %618)
%621 = extractvalue { i64, i64 } %620, 0
%622 = extractvalue { i64, i64 } %620, 1
store i64 %621, i64* %10
store i64 %622, i64* %11
br label %623
623: ; preds = %602
br label %624
624: ; preds = %623
%625 = load i64*, i64** %5
%626 = getelementptr inbounds i64, i64* %625, i64 0
%627 = load i64, i64* %626
%628 = load i64*, i64** %6
%629 = getelementptr inbounds i64, i64* %628, i64 6
%630 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %627, i64* elementtype(i64) %629)
%631 = extractvalue { i64, i64 } %630, 0
%632 = extractvalue { i64, i64 } %630, 1
store i64 %631, i64* %7
store i64 %632, i64* %8
%633 = load i64, i64* %9
%634 = load i64, i64* %8
%635 = load i64, i64* %7
%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* %8
%639 = load i64, i64* %10
%640 = load i64, i64* %11
%641 = load i64, i64* %8
%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* %10
store i64 %644, i64* %11
br label %645
645: ; preds = %624
%646 = load i64, i64* %9
%647 = load i64*, i64** %4
%648 = getelementptr inbounds i64, i64* %647, i64 6
store i64 %646, i64* %648
store i64 0, i64* %9
br label %649
649: ; preds = %645
%650 = load i64*, i64** %5
%651 = getelementptr inbounds i64, i64* %650, i64 0
%652 = load i64, i64* %651
%653 = load i64*, i64** %6
%654 = getelementptr inbounds i64, i64* %653, i64 7
%655 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %652, i64* elementtype(i64) %654)
%656 = extractvalue { i64, i64 } %655, 0
%657 = extractvalue { i64, i64 } %655, 1
store i64 %656, i64* %7
store i64 %657, i64* %8
%658 = load i64, i64* %10
%659 = load i64, i64* %8
%660 = load i64, i64* %7
%661 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %660, i32 0, i64 %658, i64 %659)
%662 = extractvalue { i64, i64 } %661, 0
%663 = extractvalue { i64, i64 } %661, 1
store i64 %662, i64* %10
store i64 %663, i64* %8
%664 = load i64, i64* %11
%665 = load i64, i64* %9
%666 = load i64, i64* %8
%667 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %666, i32 0, i64 %664, i64 %665)
%668 = extractvalue { i64, i64 } %667, 0
%669 = extractvalue { i64, i64 } %667, 1
store i64 %668, i64* %11
store i64 %669, i64* %9
br label %670
670: ; preds = %649
br label %671
671: ; preds = %670
%672 = load i64*, i64** %5
%673 = getelementptr inbounds i64, i64* %672, i64 1
%674 = load i64, i64* %673
%675 = load i64*, i64** %6
%676 = getelementptr inbounds i64, i64* %675, i64 6
%677 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %674, i64* elementtype(i64) %676)
%678 = extractvalue { i64, i64 } %677, 0
%679 = extractvalue { i64, i64 } %677, 1
store i64 %678, i64* %7
store i64 %679, i64* %8
%680 = load i64, i64* %10
%681 = load i64, i64* %8
%682 = load i64, i64* %7
%683 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %682, i32 0, i64 %680, i64 %681)
%684 = extractvalue { i64, i64 } %683, 0
%685 = extractvalue { i64, i64 } %683, 1
store i64 %684, i64* %10
store i64 %685, i64* %8
%686 = load i64, i64* %11
%687 = load i64, i64* %9
%688 = load i64, i64* %8
%689 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %688, i32 0, i64 %686, i64 %687)
%690 = extractvalue { i64, i64 } %689, 0
%691 = extractvalue { i64, i64 } %689, 1
store i64 %690, i64* %11
store i64 %691, i64* %9
br label %692
692: ; preds = %671
br label %693
693: ; preds = %692
%694 = load i64*, i64** %5
%695 = getelementptr inbounds i64, i64* %694, i64 2
%696 = load i64, i64* %695
%697 = load i64*, i64** %6
%698 = getelementptr inbounds i64, i64* %697, i64 5
%699 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %696, i64* elementtype(i64) %698)
%700 = extractvalue { i64, i64 } %699, 0
%701 = extractvalue { i64, i64 } %699, 1
store i64 %700, i64* %7
store i64 %701, i64* %8
%702 = load i64, i64* %10
%703 = load i64, i64* %8
%704 = load i64, i64* %7
%705 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %704, i32 0, i64 %702, i64 %703)
%706 = extractvalue { i64, i64 } %705, 0
%707 = extractvalue { i64, i64 } %705, 1
store i64 %706, i64* %10
store i64 %707, i64* %8
%708 = load i64, i64* %11
%709 = load i64, i64* %9
%710 = load i64, i64* %8
%711 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %710, i32 0, i64 %708, i64 %709)
%712 = extractvalue { i64, i64 } %711, 0
%713 = extractvalue { i64, i64 } %711, 1
store i64 %712, i64* %11
store i64 %713, i64* %9
br label %714
714: ; preds = %693
br label %715
715: ; preds = %714
%716 = load i64*, i64** %5
%717 = getelementptr inbounds i64, i64* %716, i64 3
%718 = load i64, i64* %717
%719 = load i64*, i64** %6
%720 = getelementptr inbounds i64, i64* %719, i64 4
%721 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %718, i64* elementtype(i64) %720)
%722 = extractvalue { i64, i64 } %721, 0
%723 = extractvalue { i64, i64 } %721, 1
store i64 %722, i64* %7
store i64 %723, i64* %8
%724 = load i64, i64* %10
%725 = load i64, i64* %8
%726 = load i64, i64* %7
%727 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %726, i32 0, i64 %724, i64 %725)
%728 = extractvalue { i64, i64 } %727, 0
%729 = extractvalue { i64, i64 } %727, 1
store i64 %728, i64* %10
store i64 %729, i64* %8
%730 = load i64, i64* %11
%731 = load i64, i64* %9
%732 = load i64, i64* %8
%733 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %732, i32 0, i64 %730, i64 %731)
%734 = extractvalue { i64, i64 } %733, 0
%735 = extractvalue { i64, i64 } %733, 1
store i64 %734, i64* %11
store i64 %735, i64* %9
br label %736
736: ; preds = %715
br label %737
737: ; preds = %736
%738 = load i64*, i64** %5
%739 = getelementptr inbounds i64, i64* %738, i64 4
%740 = load i64, i64* %739
%741 = load i64*, i64** %6
%742 = getelementptr inbounds i64, i64* %741, i64 3
%743 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %740, i64* elementtype(i64) %742)
%744 = extractvalue { i64, i64 } %743, 0
%745 = extractvalue { i64, i64 } %743, 1
store i64 %744, i64* %7
store i64 %745, i64* %8
%746 = load i64, i64* %10
%747 = load i64, i64* %8
%748 = load i64, i64* %7
%749 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %748, i32 0, i64 %746, i64 %747)
%750 = extractvalue { i64, i64 } %749, 0
%751 = extractvalue { i64, i64 } %749, 1
store i64 %750, i64* %10
store i64 %751, i64* %8
%752 = load i64, i64* %11
%753 = load i64, i64* %9
%754 = load i64, i64* %8
%755 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %754, i32 0, i64 %752, i64 %753)
%756 = extractvalue { i64, i64 } %755, 0
%757 = extractvalue { i64, i64 } %755, 1
store i64 %756, i64* %11
store i64 %757, i64* %9
br label %758
758: ; preds = %737
br label %759
759: ; preds = %758
%760 = load i64*, i64** %5
%761 = getelementptr inbounds i64, i64* %760, i64 5
%762 = load i64, i64* %761
%763 = load i64*, i64** %6
%764 = getelementptr inbounds i64, i64* %763, i64 2
%765 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %762, i64* elementtype(i64) %764)
%766 = extractvalue { i64, i64 } %765, 0
%767 = extractvalue { i64, i64 } %765, 1
store i64 %766, i64* %7
store i64 %767, i64* %8
%768 = load i64, i64* %10
%769 = load i64, i64* %8
%770 = load i64, i64* %7
%771 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %770, i32 0, i64 %768, i64 %769)
%772 = extractvalue { i64, i64 } %771, 0
%773 = extractvalue { i64, i64 } %771, 1
store i64 %772, i64* %10
store i64 %773, i64* %8
%774 = load i64, i64* %11
%775 = load i64, i64* %9
%776 = load i64, i64* %8
%777 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %776, i32 0, i64 %774, i64 %775)
%778 = extractvalue { i64, i64 } %777, 0
%779 = extractvalue { i64, i64 } %777, 1
store i64 %778, i64* %11
store i64 %779, i64* %9
br label %780
780: ; preds = %759
br label %781
781: ; preds = %780
%782 = load i64*, i64** %5
%783 = getelementptr inbounds i64, i64* %782, i64 6
%784 = load i64, i64* %783
%785 = load i64*, i64** %6
%786 = getelementptr inbounds i64, i64* %785, i64 1
%787 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %784, i64* elementtype(i64) %786)
%788 = extractvalue { i64, i64 } %787, 0
%789 = extractvalue { i64, i64 } %787, 1
store i64 %788, i64* %7
store i64 %789, i64* %8
%790 = load i64, i64* %10
%791 = load i64, i64* %8
%792 = load i64, i64* %7
%793 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %792, i32 0, i64 %790, i64 %791)
%794 = extractvalue { i64, i64 } %793, 0
%795 = extractvalue { i64, i64 } %793, 1
store i64 %794, i64* %10
store i64 %795, i64* %8
%796 = load i64, i64* %11
%797 = load i64, i64* %9
%798 = load i64, i64* %8
%799 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},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* %11
store i64 %801, i64* %9
br label %802
802: ; preds = %781
br label %803
803: ; preds = %802
%804 = load i64*, i64** %5
%805 = getelementptr inbounds i64, i64* %804, i64 7
%806 = load i64, i64* %805
%807 = load i64*, i64** %6
%808 = getelementptr inbounds i64, i64* %807, i64 0
%809 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %806, i64* elementtype(i64) %808)
%810 = extractvalue { i64, i64 } %809, 0
%811 = extractvalue { i64, i64 } %809, 1
store i64 %810, i64* %7
store i64 %811, i64* %8
%812 = load i64, i64* %10
%813 = load i64, i64* %8
%814 = load i64, i64* %7
%815 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %814, i32 0, i64 %812, i64 %813)
%816 = extractvalue { i64, i64 } %815, 0
%817 = extractvalue { i64, i64 } %815, 1
store i64 %816, i64* %10
store i64 %817, i64* %8
%818 = load i64, i64* %11
%819 = load i64, i64* %9
%820 = load i64, i64* %8
%821 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %820, i32 0, i64 %818, i64 %819)
%822 = extractvalue { i64, i64 } %821, 0
%823 = extractvalue { i64, i64 } %821, 1
store i64 %822, i64* %11
store i64 %823, i64* %9
br label %824
824: ; preds = %803
%825 = load i64, i64* %10
%826 = load i64*, i64** %4
%827 = getelementptr inbounds i64, i64* %826, i64 7
store i64 %825, i64* %827
store i64 0, i64* %10
br label %828
828: ; preds = %824
%829 = load i64*, i64** %5
%830 = getelementptr inbounds i64, i64* %829, i64 7
%831 = load i64, i64* %830
%832 = load i64*, i64** %6
%833 = getelementptr inbounds i64, i64* %832, i64 1
%834 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %831, i64* elementtype(i64) %833)
%835 = extractvalue { i64, i64 } %834, 0
%836 = extractvalue { i64, i64 } %834, 1
store i64 %835, i64* %7
store i64 %836, i64* %8
%837 = load i64, i64* %11
%838 = load i64, i64* %8
%839 = load i64, i64* %7
%840 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %839, i32 0, i64 %837, i64 %838)
%841 = extractvalue { i64, i64 } %840, 0
%842 = extractvalue { i64, i64 } %840, 1
store i64 %841, i64* %11
store i64 %842, i64* %8
%843 = load i64, i64* %9
%844 = load i64, i64* %10
%845 = load i64, i64* %8
%846 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %845, i32 0, i64 %843, i64 %844)
%847 = extractvalue { i64, i64 } %846, 0
%848 = extractvalue { i64, i64 } %846, 1
store i64 %847, i64* %9
store i64 %848, i64* %10
br label %849
849: ; preds = %828
br label %850
850: ; preds = %849
%851 = load i64*, i64** %5
%852 = getelementptr inbounds i64, i64* %851, i64 6
%853 = load i64, i64* %852
%854 = load i64*, i64** %6
%855 = getelementptr inbounds i64, i64* %854, i64 2
%856 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %853, i64* elementtype(i64) %855)
%857 = extractvalue { i64, i64 } %856, 0
%858 = extractvalue { i64, i64 } %856, 1
store i64 %857, i64* %7
store i64 %858, i64* %8
%859 = load i64, i64* %11
%860 = load i64, i64* %8
%861 = load i64, i64* %7
%862 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %861, i32 0, i64 %859, i64 %860)
%863 = extractvalue { i64, i64 } %862, 0
%864 = extractvalue { i64, i64 } %862, 1
store i64 %863, i64* %11
store i64 %864, i64* %8
%865 = load i64, i64* %9
%866 = load i64, i64* %10
%867 = load i64, i64* %8
%868 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %867, i32 0, i64 %865, i64 %866)
%869 = extractvalue { i64, i64 } %868, 0
%870 = extractvalue { i64, i64 } %868, 1
store i64 %869, i64* %9
store i64 %870, i64* %10
br label %871
871: ; preds = %850
br label %872
872: ; preds = %871
%873 = load i64*, i64** %5
%874 = getelementptr inbounds i64, i64* %873, i64 5
%875 = load i64, i64* %874
%876 = load i64*, i64** %6
%877 = getelementptr inbounds i64, i64* %876, i64 3
%878 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %875, i64* elementtype(i64) %877)
%879 = extractvalue { i64, i64 } %878, 0
%880 = extractvalue { i64, i64 } %878, 1
store i64 %879, i64* %7
store i64 %880, i64* %8
%881 = load i64, i64* %11
%882 = load i64, i64* %8
%883 = load i64, i64* %7
%884 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %883, i32 0, i64 %881, i64 %882)
%885 = extractvalue { i64, i64 } %884, 0
%886 = extractvalue { i64, i64 } %884, 1
store i64 %885, i64* %11
store i64 %886, i64* %8
%887 = load i64, i64* %9
%888 = load i64, i64* %10
%889 = load i64, i64* %8
%890 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %889, i32 0, i64 %887, i64 %888)
%891 = extractvalue { i64, i64 } %890, 0
%892 = extractvalue { i64, i64 } %890, 1
store i64 %891, i64* %9
store i64 %892, i64* %10
br label %893
893: ; preds = %872
br label %894
894: ; preds = %893
%895 = load i64*, i64** %5
%896 = getelementptr inbounds i64, i64* %895, i64 4
%897 = load i64, i64* %896
%898 = load i64*, i64** %6
%899 = getelementptr inbounds i64, i64* %898, i64 4
%900 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %897, i64* elementtype(i64) %899)
%901 = extractvalue { i64, i64 } %900, 0
%902 = extractvalue { i64, i64 } %900, 1
store i64 %901, i64* %7
store i64 %902, i64* %8
%903 = load i64, i64* %11
%904 = load i64, i64* %8
%905 = load i64, i64* %7
%906 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %905, i32 0, i64 %903, i64 %904)
%907 = extractvalue { i64, i64 } %906, 0
%908 = extractvalue { i64, i64 } %906, 1
store i64 %907, i64* %11
store i64 %908, i64* %8
%909 = load i64, i64* %9
%910 = load i64, i64* %10
%911 = load i64, i64* %8
%912 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %911, i32 0, i64 %909, i64 %910)
%913 = extractvalue { i64, i64 } %912, 0
%914 = extractvalue { i64, i64 } %912, 1
store i64 %913, i64* %9
store i64 %914, i64* %10
br label %915
915: ; preds = %894
br label %916
916: ; preds = %915
%917 = load i64*, i64** %5
%918 = getelementptr inbounds i64, i64* %917, i64 3
%919 = load i64, i64* %918
%920 = load i64*, i64** %6
%921 = getelementptr inbounds i64, i64* %920, i64 5
%922 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %919, i64* elementtype(i64) %921)
%923 = extractvalue { i64, i64 } %922, 0
%924 = extractvalue { i64, i64 } %922, 1
store i64 %923, i64* %7
store i64 %924, i64* %8
%925 = load i64, i64* %11
%926 = load i64, i64* %8
%927 = load i64, i64* %7
%928 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %927, i32 0, i64 %925, i64 %926)
%929 = extractvalue { i64, i64 } %928, 0
%930 = extractvalue { i64, i64 } %928, 1
store i64 %929, i64* %11
store i64 %930, i64* %8
%931 = load i64, i64* %9
%932 = load i64, i64* %10
%933 = load i64, i64* %8
%934 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %933, i32 0, i64 %931, i64 %932)
%935 = extractvalue { i64, i64 } %934, 0
%936 = extractvalue { i64, i64 } %934, 1
store i64 %935, i64* %9
store i64 %936, i64* %10
br label %937
937: ; preds = %916
br label %938
938: ; preds = %937
%939 = load i64*, i64** %5
%940 = getelementptr inbounds i64, i64* %939, i64 2
%941 = load i64, i64* %940
%942 = load i64*, i64** %6
%943 = getelementptr inbounds i64, i64* %942, i64 6
%944 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %941, i64* elementtype(i64) %943)
%945 = extractvalue { i64, i64 } %944, 0
%946 = extractvalue { i64, i64 } %944, 1
store i64 %945, i64* %7
store i64 %946, i64* %8
%947 = load i64, i64* %11
%948 = load i64, i64* %8
%949 = load i64, i64* %7
%950 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %949, i32 0, i64 %947, i64 %948)
%951 = extractvalue { i64, i64 } %950, 0
%952 = extractvalue { i64, i64 } %950, 1
store i64 %951, i64* %11
store i64 %952, i64* %8
%953 = load i64, i64* %9
%954 = load i64, i64* %10
%955 = load i64, i64* %8
%956 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %955, i32 0, i64 %953, i64 %954)
%957 = extractvalue { i64, i64 } %956, 0
%958 = extractvalue { i64, i64 } %956, 1
store i64 %957, i64* %9
store i64 %958, i64* %10
br label %959
959: ; preds = %938
br label %960
960: ; preds = %959
%961 = load i64*, i64** %5
%962 = getelementptr inbounds i64, i64* %961, i64 1
%963 = load i64, i64* %962
%964 = load i64*, i64** %6
%965 = getelementptr inbounds i64, i64* %964, i64 7
%966 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %963, i64* elementtype(i64) %965)
%967 = extractvalue { i64, i64 } %966, 0
%968 = extractvalue { i64, i64 } %966, 1
store i64 %967, i64* %7
store i64 %968, i64* %8
%969 = load i64, i64* %11
%970 = load i64, i64* %8
%971 = load i64, i64* %7
%972 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %971, i32 0, i64 %969, i64 %970)
%973 = extractvalue { i64, i64 } %972, 0
%974 = extractvalue { i64, i64 } %972, 1
store i64 %973, i64* %11
store i64 %974, i64* %8
%975 = load i64, i64* %9
%976 = load i64, i64* %10
%977 = load i64, i64* %8
%978 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %977, i32 0, i64 %975, i64 %976)
%979 = extractvalue { i64, i64 } %978, 0
%980 = extractvalue { i64, i64 } %978, 1
store i64 %979, i64* %9
store i64 %980, i64* %10
br label %981
981: ; preds = %960
%982 = load i64, i64* %11
%983 = load i64*, i64** %4
%984 = getelementptr inbounds i64, i64* %983, i64 8
store i64 %982, i64* %984
store i64 0, i64* %11
br label %985
985: ; preds = %981
%986 = load i64*, i64** %5
%987 = getelementptr inbounds i64, i64* %986, i64 2
%988 = load i64, i64* %987
%989 = load i64*, i64** %6
%990 = getelementptr inbounds i64, i64* %989, i64 7
%991 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %988, i64* elementtype(i64) %990)
%992 = extractvalue { i64, i64 } %991, 0
%993 = extractvalue { i64, i64 } %991, 1
store i64 %992, i64* %7
store i64 %993, i64* %8
%994 = load i64, i64* %9
%995 = load i64, i64* %8
%996 = load i64, i64* %7
%997 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %996, i32 0, i64 %994, i64 %995)
%998 = extractvalue { i64, i64 } %997, 0
%999 = extractvalue { i64, i64 } %997, 1
store i64 %998, i64* %9
store i64 %999, i64* %8
%1000 = load i64, i64* %10
%1001 = load i64, i64* %11
%1002 = load i64, i64* %8
%1003 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1002, i32 0, i64 %1000, i64 %1001)
%1004 = extractvalue { i64, i64 } %1003, 0
%1005 = extractvalue { i64, i64 } %1003, 1
store i64 %1004, i64* %10
store i64 %1005, i64* %11
br label %1006
1006: ; preds = %985
br label %1007
1007: ; preds = %1006
%1008 = load i64*, i64** %5
%1009 = getelementptr inbounds i64, i64* %1008, i64 3
%1010 = load i64, i64* %1009
%1011 = load i64*, i64** %6
%1012 = getelementptr inbounds i64, i64* %1011, i64 6
%1013 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1010, i64* elementtype(i64) %1012)
%1014 = extractvalue { i64, i64 } %1013, 0
%1015 = extractvalue { i64, i64 } %1013, 1
store i64 %1014, i64* %7
store i64 %1015, i64* %8
%1016 = load i64, i64* %9
%1017 = load i64, i64* %8
%1018 = load i64, i64* %7
%1019 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1018, i32 0, i64 %1016, i64 %1017)
%1020 = extractvalue { i64, i64 } %1019, 0
%1021 = extractvalue { i64, i64 } %1019, 1
store i64 %1020, i64* %9
store i64 %1021, i64* %8
%1022 = load i64, i64* %10
%1023 = load i64, i64* %11
%1024 = load i64, i64* %8
%1025 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1024, i32 0, i64 %1022, i64 %1023)
%1026 = extractvalue { i64, i64 } %1025, 0
%1027 = extractvalue { i64, i64 } %1025, 1
store i64 %1026, i64* %10
store i64 %1027, i64* %11
br label %1028
1028: ; preds = %1007
br label %1029
1029: ; preds = %1028
%1030 = load i64*, i64** %5
%1031 = getelementptr inbounds i64, i64* %1030, i64 4
%1032 = load i64, i64* %1031
%1033 = load i64*, i64** %6
%1034 = getelementptr inbounds i64, i64* %1033, i64 5
%1035 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1032, i64* elementtype(i64) %1034)
%1036 = extractvalue { i64, i64 } %1035, 0
%1037 = extractvalue { i64, i64 } %1035, 1
store i64 %1036, i64* %7
store i64 %1037, i64* %8
%1038 = load i64, i64* %9
%1039 = load i64, i64* %8
%1040 = load i64, i64* %7
%1041 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1040, i32 0, i64 %1038, i64 %1039)
%1042 = extractvalue { i64, i64 } %1041, 0
%1043 = extractvalue { i64, i64 } %1041, 1
store i64 %1042, i64* %9
store i64 %1043, i64* %8
%1044 = load i64, i64* %10
%1045 = load i64, i64* %11
%1046 = load i64, i64* %8
%1047 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1046, i32 0, i64 %1044, i64 %1045)
%1048 = extractvalue { i64, i64 } %1047, 0
%1049 = extractvalue { i64, i64 } %1047, 1
store i64 %1048, i64* %10
store i64 %1049, i64* %11
br label %1050
1050: ; preds = %1029
br label %1051
1051: ; preds = %1050
%1052 = load i64*, i64** %5
%1053 = getelementptr inbounds i64, i64* %1052, i64 5
%1054 = load i64, i64* %1053
%1055 = load i64*, i64** %6
%1056 = getelementptr inbounds i64, i64* %1055, i64 4
%1057 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1054, i64* elementtype(i64) %1056)
%1058 = extractvalue { i64, i64 } %1057, 0
%1059 = extractvalue { i64, i64 } %1057, 1
store i64 %1058, i64* %7
store i64 %1059, i64* %8
%1060 = load i64, i64* %9
%1061 = load i64, i64* %8
%1062 = load i64, i64* %7
%1063 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1062, i32 0, i64 %1060, i64 %1061)
%1064 = extractvalue { i64, i64 } %1063, 0
%1065 = extractvalue { i64, i64 } %1063, 1
store i64 %1064, i64* %9
store i64 %1065, i64* %8
%1066 = load i64, i64* %10
%1067 = load i64, i64* %11
%1068 = load i64, i64* %8
%1069 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1068, i32 0, i64 %1066, i64 %1067)
%1070 = extractvalue { i64, i64 } %1069, 0
%1071 = extractvalue { i64, i64 } %1069, 1
store i64 %1070, i64* %10
store i64 %1071, i64* %11
br label %1072
1072: ; preds = %1051
br label %1073
1073: ; preds = %1072
%1074 = load i64*, i64** %5
%1075 = getelementptr inbounds i64, i64* %1074, i64 6
%1076 = load i64, i64* %1075
%1077 = load i64*, i64** %6
%1078 = getelementptr inbounds i64, i64* %1077, i64 3
%1079 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1076, i64* elementtype(i64) %1078)
%1080 = extractvalue { i64, i64 } %1079, 0
%1081 = extractvalue { i64, i64 } %1079, 1
store i64 %1080, i64* %7
store i64 %1081, i64* %8
%1082 = load i64, i64* %9
%1083 = load i64, i64* %8
%1084 = load i64, i64* %7
%1085 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1084, i32 0, i64 %1082, i64 %1083)
%1086 = extractvalue { i64, i64 } %1085, 0
%1087 = extractvalue { i64, i64 } %1085, 1
store i64 %1086, i64* %9
store i64 %1087, i64* %8
%1088 = load i64, i64* %10
%1089 = load i64, i64* %11
%1090 = load i64, i64* %8
%1091 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1090, i32 0, i64 %1088, i64 %1089)
%1092 = extractvalue { i64, i64 } %1091, 0
%1093 = extractvalue { i64, i64 } %1091, 1
store i64 %1092, i64* %10
store i64 %1093, i64* %11
br label %1094
1094: ; preds = %1073
br label %1095
1095: ; preds = %1094
%1096 = load i64*, i64** %5
%1097 = getelementptr inbounds i64, i64* %1096, i64 7
%1098 = load i64, i64* %1097
%1099 = load i64*, i64** %6
%1100 = getelementptr inbounds i64, i64* %1099, i64 2
%1101 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1098, i64* elementtype(i64) %1100)
%1102 = extractvalue { i64, i64 } %1101, 0
%1103 = extractvalue { i64, i64 } %1101, 1
store i64 %1102, i64* %7
store i64 %1103, i64* %8
%1104 = load i64, i64* %9
%1105 = load i64, i64* %8
%1106 = load i64, i64* %7
%1107 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1106, i32 0, i64 %1104, i64 %1105)
%1108 = extractvalue { i64, i64 } %1107, 0
%1109 = extractvalue { i64, i64 } %1107, 1
store i64 %1108, i64* %9
store i64 %1109, i64* %8
%1110 = load i64, i64* %10
%1111 = load i64, i64* %11
%1112 = load i64, i64* %8
%1113 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1112, i32 0, i64 %1110, i64 %1111)
%1114 = extractvalue { i64, i64 } %1113, 0
%1115 = extractvalue { i64, i64 } %1113, 1
store i64 %1114, i64* %10
store i64 %1115, i64* %11
br label %1116
1116: ; preds = %1095
%1117 = load i64, i64* %9
%1118 = load i64*, i64** %4
%1119 = getelementptr inbounds i64, i64* %1118, i64 9
store i64 %1117, i64* %1119
store i64 0, i64* %9
br label %1120
1120: ; preds = %1116
%1121 = load i64*, i64** %5
%1122 = getelementptr inbounds i64, i64* %1121, i64 7
%1123 = load i64, i64* %1122
%1124 = load i64*, i64** %6
%1125 = getelementptr inbounds i64, i64* %1124, i64 3
%1126 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1123, i64* elementtype(i64) %1125)
%1127 = extractvalue { i64, i64 } %1126, 0
%1128 = extractvalue { i64, i64 } %1126, 1
store i64 %1127, i64* %7
store i64 %1128, i64* %8
%1129 = load i64, i64* %10
%1130 = load i64, i64* %8
%1131 = load i64, i64* %7
%1132 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1131, i32 0, i64 %1129, i64 %1130)
%1133 = extractvalue { i64, i64 } %1132, 0
%1134 = extractvalue { i64, i64 } %1132, 1
store i64 %1133, i64* %10
store i64 %1134, i64* %8
%1135 = load i64, i64* %11
%1136 = load i64, i64* %9
%1137 = load i64, i64* %8
%1138 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1137, i32 0, i64 %1135, i64 %1136)
%1139 = extractvalue { i64, i64 } %1138, 0
%1140 = extractvalue { i64, i64 } %1138, 1
store i64 %1139, i64* %11
store i64 %1140, i64* %9
br label %1141
1141: ; preds = %1120
br label %1142
1142: ; preds = %1141
%1143 = load i64*, i64** %5
%1144 = getelementptr inbounds i64, i64* %1143, i64 6
%1145 = load i64, i64* %1144
%1146 = load i64*, i64** %6
%1147 = getelementptr inbounds i64, i64* %1146, i64 4
%1148 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1145, i64* elementtype(i64) %1147)
%1149 = extractvalue { i64, i64 } %1148, 0
%1150 = extractvalue { i64, i64 } %1148, 1
store i64 %1149, i64* %7
store i64 %1150, i64* %8
%1151 = load i64, i64* %10
%1152 = load i64, i64* %8
%1153 = load i64, i64* %7
%1154 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1153, i32 0, i64 %1151, i64 %1152)
%1155 = extractvalue { i64, i64 } %1154, 0
%1156 = extractvalue { i64, i64 } %1154, 1
store i64 %1155, i64* %10
store i64 %1156, i64* %8
%1157 = load i64, i64* %11
%1158 = load i64, i64* %9
%1159 = load i64, i64* %8
%1160 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1159, i32 0, i64 %1157, i64 %1158)
%1161 = extractvalue { i64, i64 } %1160, 0
%1162 = extractvalue { i64, i64 } %1160, 1
store i64 %1161, i64* %11
store i64 %1162, i64* %9
br label %1163
1163: ; preds = %1142
br label %1164
1164: ; preds = %1163
%1165 = load i64*, i64** %5
%1166 = getelementptr inbounds i64, i64* %1165, i64 5
%1167 = load i64, i64* %1166
%1168 = load i64*, i64** %6
%1169 = getelementptr inbounds i64, i64* %1168, i64 5
%1170 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1167, i64* elementtype(i64) %1169)
%1171 = extractvalue { i64, i64 } %1170, 0
%1172 = extractvalue { i64, i64 } %1170, 1
store i64 %1171, i64* %7
store i64 %1172, i64* %8
%1173 = load i64, i64* %10
%1174 = load i64, i64* %8
%1175 = load i64, i64* %7
%1176 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1175, i32 0, i64 %1173, i64 %1174)
%1177 = extractvalue { i64, i64 } %1176, 0
%1178 = extractvalue { i64, i64 } %1176, 1
store i64 %1177, i64* %10
store i64 %1178, i64* %8
%1179 = load i64, i64* %11
%1180 = load i64, i64* %9
%1181 = load i64, i64* %8
%1182 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1181, i32 0, i64 %1179, i64 %1180)
%1183 = extractvalue { i64, i64 } %1182, 0
%1184 = extractvalue { i64, i64 } %1182, 1
store i64 %1183, i64* %11
store i64 %1184, i64* %9
br label %1185
1185: ; preds = %1164
br label %1186
1186: ; preds = %1185
%1187 = load i64*, i64** %5
%1188 = getelementptr inbounds i64, i64* %1187, i64 4
%1189 = load i64, i64* %1188
%1190 = load i64*, i64** %6
%1191 = getelementptr inbounds i64, i64* %1190, i64 6
%1192 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1189, i64* elementtype(i64) %1191)
%1193 = extractvalue { i64, i64 } %1192, 0
%1194 = extractvalue { i64, i64 } %1192, 1
store i64 %1193, i64* %7
store i64 %1194, i64* %8
%1195 = load i64, i64* %10
%1196 = load i64, i64* %8
%1197 = load i64, i64* %7
%1198 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1197, i32 0, i64 %1195, i64 %1196)
%1199 = extractvalue { i64, i64 } %1198, 0
%1200 = extractvalue { i64, i64 } %1198, 1
store i64 %1199, i64* %10
store i64 %1200, i64* %8
%1201 = load i64, i64* %11
%1202 = load i64, i64* %9
%1203 = load i64, i64* %8
%1204 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1203, i32 0, i64 %1201, i64 %1202)
%1205 = extractvalue { i64, i64 } %1204, 0
%1206 = extractvalue { i64, i64 } %1204, 1
store i64 %1205, i64* %11
store i64 %1206, i64* %9
br label %1207
1207: ; preds = %1186
br label %1208
1208: ; preds = %1207
%1209 = load i64*, i64** %5
%1210 = getelementptr inbounds i64, i64* %1209, i64 3
%1211 = load i64, i64* %1210
%1212 = load i64*, i64** %6
%1213 = getelementptr inbounds i64, i64* %1212, i64 7
%1214 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1211, i64* elementtype(i64) %1213)
%1215 = extractvalue { i64, i64 } %1214, 0
%1216 = extractvalue { i64, i64 } %1214, 1
store i64 %1215, i64* %7
store i64 %1216, i64* %8
%1217 = load i64, i64* %10
%1218 = load i64, i64* %8
%1219 = load i64, i64* %7
%1220 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1219, i32 0, i64 %1217, i64 %1218)
%1221 = extractvalue { i64, i64 } %1220, 0
%1222 = extractvalue { i64, i64 } %1220, 1
store i64 %1221, i64* %10
store i64 %1222, i64* %8
%1223 = load i64, i64* %11
%1224 = load i64, i64* %9
%1225 = load i64, i64* %8
%1226 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1225, i32 0, i64 %1223, i64 %1224)
%1227 = extractvalue { i64, i64 } %1226, 0
%1228 = extractvalue { i64, i64 } %1226, 1
store i64 %1227, i64* %11
store i64 %1228, i64* %9
br label %1229
1229: ; preds = %1208
%1230 = load i64, i64* %10
%1231 = load i64*, i64** %4
%1232 = getelementptr inbounds i64, i64* %1231, i64 10
store i64 %1230, i64* %1232
store i64 0, i64* %10
br label %1233
1233: ; preds = %1229
%1234 = load i64*, i64** %5
%1235 = getelementptr inbounds i64, i64* %1234, i64 4
%1236 = load i64, i64* %1235
%1237 = load i64*, i64** %6
%1238 = getelementptr inbounds i64, i64* %1237, i64 7
%1239 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1236, i64* elementtype(i64) %1238)
%1240 = extractvalue { i64, i64 } %1239, 0
%1241 = extractvalue { i64, i64 } %1239, 1
store i64 %1240, i64* %7
store i64 %1241, i64* %8
%1242 = load i64, i64* %11
%1243 = load i64, i64* %8
%1244 = load i64, i64* %7
%1245 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1244, i32 0, i64 %1242, i64 %1243)
%1246 = extractvalue { i64, i64 } %1245, 0
%1247 = extractvalue { i64, i64 } %1245, 1
store i64 %1246, i64* %11
store i64 %1247, i64* %8
%1248 = load i64, i64* %9
%1249 = load i64, i64* %10
%1250 = load i64, i64* %8
%1251 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1250, i32 0, i64 %1248, i64 %1249)
%1252 = extractvalue { i64, i64 } %1251, 0
%1253 = extractvalue { i64, i64 } %1251, 1
store i64 %1252, i64* %9
store i64 %1253, i64* %10
br label %1254
1254: ; preds = %1233
br label %1255
1255: ; preds = %1254
%1256 = load i64*, i64** %5
%1257 = getelementptr inbounds i64, i64* %1256, i64 5
%1258 = load i64, i64* %1257
%1259 = load i64*, i64** %6
%1260 = getelementptr inbounds i64, i64* %1259, i64 6
%1261 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1258, i64* elementtype(i64) %1260)
%1262 = extractvalue { i64, i64 } %1261, 0
%1263 = extractvalue { i64, i64 } %1261, 1
store i64 %1262, i64* %7
store i64 %1263, i64* %8
%1264 = load i64, i64* %11
%1265 = load i64, i64* %8
%1266 = load i64, i64* %7
%1267 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1266, i32 0, i64 %1264, i64 %1265)
%1268 = extractvalue { i64, i64 } %1267, 0
%1269 = extractvalue { i64, i64 } %1267, 1
store i64 %1268, i64* %11
store i64 %1269, i64* %8
%1270 = load i64, i64* %9
%1271 = load i64, i64* %10
%1272 = load i64, i64* %8
%1273 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1272, i32 0, i64 %1270, i64 %1271)
%1274 = extractvalue { i64, i64 } %1273, 0
%1275 = extractvalue { i64, i64 } %1273, 1
store i64 %1274, i64* %9
store i64 %1275, i64* %10
br label %1276
1276: ; preds = %1255
br label %1277
1277: ; preds = %1276
%1278 = load i64*, i64** %5
%1279 = getelementptr inbounds i64, i64* %1278, i64 6
%1280 = load i64, i64* %1279
%1281 = load i64*, i64** %6
%1282 = getelementptr inbounds i64, i64* %1281, i64 5
%1283 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1280, i64* elementtype(i64) %1282)
%1284 = extractvalue { i64, i64 } %1283, 0
%1285 = extractvalue { i64, i64 } %1283, 1
store i64 %1284, i64* %7
store i64 %1285, i64* %8
%1286 = load i64, i64* %11
%1287 = load i64, i64* %8
%1288 = load i64, i64* %7
%1289 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1288, i32 0, i64 %1286, i64 %1287)
%1290 = extractvalue { i64, i64 } %1289, 0
%1291 = extractvalue { i64, i64 } %1289, 1
store i64 %1290, i64* %11
store i64 %1291, i64* %8
%1292 = load i64, i64* %9
%1293 = load i64, i64* %10
%1294 = load i64, i64* %8
%1295 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1294, i32 0, i64 %1292, i64 %1293)
%1296 = extractvalue { i64, i64 } %1295, 0
%1297 = extractvalue { i64, i64 } %1295, 1
store i64 %1296, i64* %9
store i64 %1297, i64* %10
br label %1298
1298: ; preds = %1277
br label %1299
1299: ; preds = %1298
%1300 = load i64*, i64** %5
%1301 = getelementptr inbounds i64, i64* %1300, i64 7
%1302 = load i64, i64* %1301
%1303 = load i64*, i64** %6
%1304 = getelementptr inbounds i64, i64* %1303, i64 4
%1305 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1302, i64* elementtype(i64) %1304)
%1306 = extractvalue { i64, i64 } %1305, 0
%1307 = extractvalue { i64, i64 } %1305, 1
store i64 %1306, i64* %7
store i64 %1307, i64* %8
%1308 = load i64, i64* %11
%1309 = load i64, i64* %8
%1310 = load i64, i64* %7
%1311 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1310, i32 0, i64 %1308, i64 %1309)
%1312 = extractvalue { i64, i64 } %1311, 0
%1313 = extractvalue { i64, i64 } %1311, 1
store i64 %1312, i64* %11
store i64 %1313, i64* %8
%1314 = load i64, i64* %9
%1315 = load i64, i64* %10
%1316 = load i64, i64* %8
%1317 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1316, i32 0, i64 %1314, i64 %1315)
%1318 = extractvalue { i64, i64 } %1317, 0
%1319 = extractvalue { i64, i64 } %1317, 1
store i64 %1318, i64* %9
store i64 %1319, i64* %10
br label %1320
1320: ; preds = %1299
%1321 = load i64, i64* %11
%1322 = load i64*, i64** %4
%1323 = getelementptr inbounds i64, i64* %1322, i64 11
store i64 %1321, i64* %1323
store i64 0, i64* %11
br label %1324
1324: ; preds = %1320
%1325 = load i64*, i64** %5
%1326 = getelementptr inbounds i64, i64* %1325, i64 7
%1327 = load i64, i64* %1326
%1328 = load i64*, i64** %6
%1329 = getelementptr inbounds i64, i64* %1328, i64 5
%1330 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1327, i64* elementtype(i64) %1329)
%1331 = extractvalue { i64, i64 } %1330, 0
%1332 = extractvalue { i64, i64 } %1330, 1
store i64 %1331, i64* %7
store i64 %1332, i64* %8
%1333 = load i64, i64* %9
%1334 = load i64, i64* %8
%1335 = load i64, i64* %7
%1336 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1335, i32 0, i64 %1333, i64 %1334)
%1337 = extractvalue { i64, i64 } %1336, 0
%1338 = extractvalue { i64, i64 } %1336, 1
store i64 %1337, i64* %9
store i64 %1338, i64* %8
%1339 = load i64, i64* %10
%1340 = load i64, i64* %11
%1341 = load i64, i64* %8
%1342 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1341, i32 0, i64 %1339, i64 %1340)
%1343 = extractvalue { i64, i64 } %1342, 0
%1344 = extractvalue { i64, i64 } %1342, 1
store i64 %1343, i64* %10
store i64 %1344, i64* %11
br label %1345
1345: ; preds = %1324
br label %1346
1346: ; preds = %1345
%1347 = load i64*, i64** %5
%1348 = getelementptr inbounds i64, i64* %1347, i64 6
%1349 = load i64, i64* %1348
%1350 = load i64*, i64** %6
%1351 = getelementptr inbounds i64, i64* %1350, i64 6
%1352 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1349, i64* elementtype(i64) %1351)
%1353 = extractvalue { i64, i64 } %1352, 0
%1354 = extractvalue { i64, i64 } %1352, 1
store i64 %1353, i64* %7
store i64 %1354, i64* %8
%1355 = load i64, i64* %9
%1356 = load i64, i64* %8
%1357 = load i64, i64* %7
%1358 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1357, i32 0, i64 %1355, i64 %1356)
%1359 = extractvalue { i64, i64 } %1358, 0
%1360 = extractvalue { i64, i64 } %1358, 1
store i64 %1359, i64* %9
store i64 %1360, i64* %8
%1361 = load i64, i64* %10
%1362 = load i64, i64* %11
%1363 = load i64, i64* %8
%1364 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1363, i32 0, i64 %1361, i64 %1362)
%1365 = extractvalue { i64, i64 } %1364, 0
%1366 = extractvalue { i64, i64 } %1364, 1
store i64 %1365, i64* %10
store i64 %1366, i64* %11
br label %1367
1367: ; preds = %1346
br label %1368
1368: ; preds = %1367
%1369 = load i64*, i64** %5
%1370 = getelementptr inbounds i64, i64* %1369, i64 5
%1371 = load i64, i64* %1370
%1372 = load i64*, i64** %6
%1373 = getelementptr inbounds i64, i64* %1372, i64 7
%1374 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1371, i64* elementtype(i64) %1373)
%1375 = extractvalue { i64, i64 } %1374, 0
%1376 = extractvalue { i64, i64 } %1374, 1
store i64 %1375, i64* %7
store i64 %1376, i64* %8
%1377 = load i64, i64* %9
%1378 = load i64, i64* %8
%1379 = load i64, i64* %7
%1380 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1379, i32 0, i64 %1377, i64 %1378)
%1381 = extractvalue { i64, i64 } %1380, 0
%1382 = extractvalue { i64, i64 } %1380, 1
store i64 %1381, i64* %9
store i64 %1382, i64* %8
%1383 = load i64, i64* %10
%1384 = load i64, i64* %11
%1385 = load i64, i64* %8
%1386 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1385, i32 0, i64 %1383, i64 %1384)
%1387 = extractvalue { i64, i64 } %1386, 0
%1388 = extractvalue { i64, i64 } %1386, 1
store i64 %1387, i64* %10
store i64 %1388, i64* %11
br label %1389
1389: ; preds = %1368
%1390 = load i64, i64* %9
%1391 = load i64*, i64** %4
%1392 = getelementptr inbounds i64, i64* %1391, i64 12
store i64 %1390, i64* %1392
store i64 0, i64* %9
br label %1393
1393: ; preds = %1389
%1394 = load i64*, i64** %5
%1395 = getelementptr inbounds i64, i64* %1394, i64 6
%1396 = load i64, i64* %1395
%1397 = load i64*, i64** %6
%1398 = getelementptr inbounds i64, i64* %1397, i64 7
%1399 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1396, i64* elementtype(i64) %1398)
%1400 = extractvalue { i64, i64 } %1399, 0
%1401 = extractvalue { i64, i64 } %1399, 1
store i64 %1400, i64* %7
store i64 %1401, i64* %8
%1402 = load i64, i64* %10
%1403 = load i64, i64* %8
%1404 = load i64, i64* %7
%1405 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1404, i32 0, i64 %1402, i64 %1403)
%1406 = extractvalue { i64, i64 } %1405, 0
%1407 = extractvalue { i64, i64 } %1405, 1
store i64 %1406, i64* %10
store i64 %1407, i64* %8
%1408 = load i64, i64* %11
%1409 = load i64, i64* %9
%1410 = load i64, i64* %8
%1411 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1410, i32 0, i64 %1408, i64 %1409)
%1412 = extractvalue { i64, i64 } %1411, 0
%1413 = extractvalue { i64, i64 } %1411, 1
store i64 %1412, i64* %11
store i64 %1413, i64* %9
br label %1414
1414: ; preds = %1393
br label %1415
1415: ; preds = %1414
%1416 = load i64*, i64** %5
%1417 = getelementptr inbounds i64, i64* %1416, i64 7
%1418 = load i64, i64* %1417
%1419 = load i64*, i64** %6
%1420 = getelementptr inbounds i64, i64* %1419, i64 6
%1421 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1418, i64* elementtype(i64) %1420)
%1422 = extractvalue { i64, i64 } %1421, 0
%1423 = extractvalue { i64, i64 } %1421, 1
store i64 %1422, i64* %7
store i64 %1423, i64* %8
%1424 = load i64, i64* %10
%1425 = load i64, i64* %8
%1426 = load i64, i64* %7
%1427 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1426, i32 0, i64 %1424, i64 %1425)
%1428 = extractvalue { i64, i64 } %1427, 0
%1429 = extractvalue { i64, i64 } %1427, 1
store i64 %1428, i64* %10
store i64 %1429, i64* %8
%1430 = load i64, i64* %11
%1431 = load i64, i64* %9
%1432 = load i64, i64* %8
%1433 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1432, i32 0, i64 %1430, i64 %1431)
%1434 = extractvalue { i64, i64 } %1433, 0
%1435 = extractvalue { i64, i64 } %1433, 1
store i64 %1434, i64* %11
store i64 %1435, i64* %9
br label %1436
1436: ; preds = %1415
%1437 = load i64, i64* %10
%1438 = load i64*, i64** %4
%1439 = getelementptr inbounds i64, i64* %1438, i64 13
store i64 %1437, i64* %1439
store i64 0, i64* %10
br label %1440
1440: ; preds = %1436
%1441 = load i64*, i64** %5
%1442 = getelementptr inbounds i64, i64* %1441, i64 7
%1443 = load i64, i64* %1442
%1444 = load i64*, i64** %6
%1445 = getelementptr inbounds i64, i64* %1444, i64 7
%1446 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1443, i64* elementtype(i64) %1445)
%1447 = extractvalue { i64, i64 } %1446, 0
%1448 = extractvalue { i64, i64 } %1446, 1
store i64 %1447, i64* %7
store i64 %1448, i64* %8
%1449 = load i64, i64* %11
%1450 = load i64, i64* %8
%1451 = load i64, i64* %7
%1452 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1451, i32 0, i64 %1449, i64 %1450)
%1453 = extractvalue { i64, i64 } %1452, 0
%1454 = extractvalue { i64, i64 } %1452, 1
store i64 %1453, i64* %11
store i64 %1454, i64* %8
%1455 = load i64, i64* %9
%1456 = load i64, i64* %10
%1457 = load i64, i64* %8
%1458 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %1457, i32 0, i64 %1455, i64 %1456)
%1459 = extractvalue { i64, i64 } %1458, 0
%1460 = extractvalue { i64, i64 } %1458, 1
store i64 %1459, i64* %9
store i64 %1460, i64* %10
br label %1461
1461: ; preds = %1440
%1462 = load i64, i64* %11
%1463 = load i64*, i64** %4
%1464 = getelementptr inbounds i64, i64* %1463, i64 14
store i64 %1462, i64* %1464
%1465 = load i64, i64* %9
%1466 = load i64*, i64** %4
%1467 = getelementptr inbounds i64, i64* %1466, i64 15
store i64 %1465, i64* %1467
ret void
}

LLVM IR (-O2):
define void @bn_mul_comba8(i64* nocapture writeonly %0, i64* nocapture %1, i64* %2) {
%4 = load i64, i64* %1
%5 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %4, i64* elementtype(i64) %2)
%6 = extractvalue { i64, i64 } %5, 0
%7 = extractvalue { i64, i64 } %5, 1
%8 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %6, i32 0, i64 0, i64 %7)
%9 = extractvalue { i64, i64 } %8, 0
%10 = extractvalue { i64, i64 } %8, 1
%11 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %10, i32 0, i64 0, i64 0)
%12 = extractvalue { i64, i64 } %11, 0
%13 = extractvalue { i64, i64 } %11, 1
store i64 %9, i64* %0
%14 = load i64, i64* %1
%15 = getelementptr inbounds i64, i64* %2, i64 1
%16 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %14, i64* elementtype(i64) %15)
%17 = extractvalue { i64, i64 } %16, 0
%18 = extractvalue { i64, i64 } %16, 1
%19 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %17, i32 0, i64 %12, i64 %18)
%20 = extractvalue { i64, i64 } %19, 0
%21 = extractvalue { i64, i64 } %19, 1
%22 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %21, i32 0, i64 %13, i64 0)
%23 = extractvalue { i64, i64 } %22, 0
%24 = extractvalue { i64, i64 } %22, 1
%25 = getelementptr inbounds i64, i64* %1, i64 1
%26 = load i64, i64* %25
%27 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %26, i64* elementtype(i64) %2)
%28 = extractvalue { i64, i64 } %27, 0
%29 = extractvalue { i64, i64 } %27, 1
%30 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %28, i32 0, i64 %20, i64 %29)
%31 = extractvalue { i64, i64 } %30, 0
%32 = extractvalue { i64, i64 } %30, 1
%33 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %32, i32 0, i64 %23, i64 %24)
%34 = extractvalue { i64, i64 } %33, 0
%35 = extractvalue { i64, i64 } %33, 1
%36 = getelementptr inbounds i64, i64* %0, i64 1
store i64 %31, i64* %36
%37 = getelementptr inbounds i64, i64* %1, i64 2
%38 = load i64, i64* %37
%39 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %38, i64* elementtype(i64) %2)
%40 = extractvalue { i64, i64 } %39, 0
%41 = extractvalue { i64, i64 } %39, 1
%42 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %40, i32 0, i64 %34, i64 %41)
%43 = extractvalue { i64, i64 } %42, 0
%44 = extractvalue { i64, i64 } %42, 1
%45 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %44, i32 0, i64 %35, i64 0)
%46 = extractvalue { i64, i64 } %45, 0
%47 = extractvalue { i64, i64 } %45, 1
%48 = load i64, i64* %25
%49 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %48, i64* elementtype(i64) %15)
%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 %43, 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 %46, i64 %47)
%56 = extractvalue { i64, i64 } %55, 0
%57 = extractvalue { i64, i64 } %55, 1
%58 = load i64, i64* %1
%59 = getelementptr inbounds i64, i64* %2, i64 2
%60 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %58, i64* elementtype(i64) %59)
%61 = extractvalue { i64, i64 } %60, 0
%62 = extractvalue { i64, i64 } %60, 1
%63 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %61, i32 0, i64 %53, i64 %62)
%64 = extractvalue { i64, i64 } %63, 0
%65 = extractvalue { i64, i64 } %63, 1
%66 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %65, i32 0, i64 %56, i64 %57)
%67 = extractvalue { i64, i64 } %66, 0
%68 = extractvalue { i64, i64 } %66, 1
%69 = getelementptr inbounds i64, i64* %0, i64 2
store i64 %64, i64* %69
%70 = load i64, i64* %1
%71 = getelementptr inbounds i64, i64* %2, i64 3
%72 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %70, i64* elementtype(i64) %71)
%73 = extractvalue { i64, i64 } %72, 0
%74 = extractvalue { i64, i64 } %72, 1
%75 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %73, i32 0, i64 %67, i64 %74)
%76 = extractvalue { i64, i64 } %75, 0
%77 = extractvalue { i64, i64 } %75, 1
%78 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %77, i32 0, i64 %68, i64 0)
%79 = extractvalue { i64, i64 } %78, 0
%80 = extractvalue { i64, i64 } %78, 1
%81 = load i64, i64* %25
%82 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %81, i64* elementtype(i64) %59)
%83 = extractvalue { i64, i64 } %82, 0
%84 = extractvalue { i64, i64 } %82, 1
%85 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %83, i32 0, i64 %76, i64 %84)
%86 = extractvalue { i64, i64 } %85, 0
%87 = extractvalue { i64, i64 } %85, 1
%88 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %87, i32 0, i64 %79, i64 %80)
%89 = extractvalue { i64, i64 } %88, 0
%90 = extractvalue { i64, i64 } %88, 1
%91 = load i64, i64* %37
%92 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %91, i64* elementtype(i64) %15)
%93 = extractvalue { i64, i64 } %92, 0
%94 = extractvalue { i64, i64 } %92, 1
%95 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %93, i32 0, i64 %86, i64 %94)
%96 = extractvalue { i64, i64 } %95, 0
%97 = extractvalue { i64, i64 } %95, 1
%98 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %97, i32 0, i64 %89, i64 %90)
%99 = extractvalue { i64, i64 } %98, 0
%100 = extractvalue { i64, i64 } %98, 1
%101 = getelementptr inbounds i64, i64* %1, i64 3
%102 = load i64, i64* %101
%103 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %102, i64* elementtype(i64) %2)
%104 = extractvalue { i64, i64 } %103, 0
%105 = extractvalue { i64, i64 } %103, 1
%106 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %104, i32 0, i64 %96, i64 %105)
%107 = extractvalue { i64, i64 } %106, 0
%108 = extractvalue { i64, i64 } %106, 1
%109 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %108, i32 0, i64 %99, i64 %100)
%110 = extractvalue { i64, i64 } %109, 0
%111 = extractvalue { i64, i64 } %109, 1
%112 = getelementptr inbounds i64, i64* %0, i64 3
store i64 %107, i64* %112
%113 = getelementptr inbounds i64, i64* %1, i64 4
%114 = load i64, i64* %113
%115 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %114, i64* elementtype(i64) %2)
%116 = extractvalue { i64, i64 } %115, 0
%117 = extractvalue { i64, i64 } %115, 1
%118 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %116, i32 0, i64 %110, i64 %117)
%119 = extractvalue { i64, i64 } %118, 0
%120 = extractvalue { i64, i64 } %118, 1
%121 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %120, i32 0, i64 %111, i64 0)
%122 = extractvalue { i64, i64 } %121, 0
%123 = extractvalue { i64, i64 } %121, 1
%124 = load i64, i64* %101
%125 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %124, i64* elementtype(i64) %15)
%126 = extractvalue { i64, i64 } %125, 0
%127 = extractvalue { i64, i64 } %125, 1
%128 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %126, i32 0, i64 %119, i64 %127)
%129 = extractvalue { i64, i64 } %128, 0
%130 = extractvalue { i64, i64 } %128, 1
%131 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %130, i32 0, i64 %122, i64 %123)
%132 = extractvalue { i64, i64 } %131, 0
%133 = extractvalue { i64, i64 } %131, 1
%134 = load i64, i64* %37
%135 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %134, i64* elementtype(i64) %59)
%136 = extractvalue { i64, i64 } %135, 0
%137 = extractvalue { i64, i64 } %135, 1
%138 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %136, i32 0, i64 %129, i64 %137)
%139 = extractvalue { i64, i64 } %138, 0
%140 = extractvalue { i64, i64 } %138, 1
%141 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %140, i32 0, i64 %132, i64 %133)
%142 = extractvalue { i64, i64 } %141, 0
%143 = extractvalue { i64, i64 } %141, 1
%144 = load i64, i64* %25
%145 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %144, i64* elementtype(i64) %71)
%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 %139, 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 %142, i64 %143)
%152 = extractvalue { i64, i64 } %151, 0
%153 = extractvalue { i64, i64 } %151, 1
%154 = load i64, i64* %1
%155 = getelementptr inbounds i64, i64* %2, i64 4
%156 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %154, i64* elementtype(i64) %155)
%157 = extractvalue { i64, i64 } %156, 0
%158 = extractvalue { i64, i64 } %156, 1
%159 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %157, i32 0, i64 %149, i64 %158)
%160 = extractvalue { i64, i64 } %159, 0
%161 = extractvalue { i64, i64 } %159, 1
%162 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %161, i32 0, i64 %152, i64 %153)
%163 = extractvalue { i64, i64 } %162, 0
%164 = extractvalue { i64, i64 } %162, 1
%165 = getelementptr inbounds i64, i64* %0, i64 4
store i64 %160, i64* %165
%166 = load i64, i64* %1
%167 = getelementptr inbounds i64, i64* %2, i64 5
%168 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %166, i64* elementtype(i64) %167)
%169 = extractvalue { i64, i64 } %168, 0
%170 = extractvalue { i64, i64 } %168, 1
%171 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %169, i32 0, i64 %163, i64 %170)
%172 = extractvalue { i64, i64 } %171, 0
%173 = extractvalue { i64, i64 } %171, 1
%174 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %173, i32 0, i64 %164, i64 0)
%175 = extractvalue { i64, i64 } %174, 0
%176 = extractvalue { i64, i64 } %174, 1
%177 = load i64, i64* %25
%178 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %177, i64* elementtype(i64) %155)
%179 = extractvalue { i64, i64 } %178, 0
%180 = extractvalue { i64, i64 } %178, 1
%181 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %179, i32 0, i64 %172, i64 %180)
%182 = extractvalue { i64, i64 } %181, 0
%183 = extractvalue { i64, i64 } %181, 1
%184 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %183, i32 0, i64 %175, i64 %176)
%185 = extractvalue { i64, i64 } %184, 0
%186 = extractvalue { i64, i64 } %184, 1
%187 = load i64, i64* %37
%188 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %187, i64* elementtype(i64) %71)
%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 %182, 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 %186)
%195 = extractvalue { i64, i64 } %194, 0
%196 = extractvalue { i64, i64 } %194, 1
%197 = load i64, i64* %101
%198 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %197, i64* elementtype(i64) %59)
%199 = extractvalue { i64, i64 } %198, 0
%200 = extractvalue { i64, i64 } %198, 1
%201 = tail 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 %192, i64 %200)
%202 = extractvalue { i64, i64 } %201, 0
%203 = extractvalue { i64, i64 } %201, 1
%204 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %203, i32 0, i64 %195, i64 %196)
%205 = extractvalue { i64, i64 } %204, 0
%206 = extractvalue { i64, i64 } %204, 1
%207 = load i64, i64* %113
%208 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %207, i64* elementtype(i64) %15)
%209 = extractvalue { i64, i64 } %208, 0
%210 = extractvalue { i64, i64 } %208, 1
%211 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %209, i32 0, i64 %202, i64 %210)
%212 = extractvalue { i64, i64 } %211, 0
%213 = extractvalue { i64, i64 } %211, 1
%214 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %213, i32 0, i64 %205, i64 %206)
%215 = extractvalue { i64, i64 } %214, 0
%216 = extractvalue { i64, i64 } %214, 1
%217 = getelementptr inbounds i64, i64* %1, i64 5
%218 = load i64, i64* %217
%219 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %218, i64* elementtype(i64) %2)
%220 = extractvalue { i64, i64 } %219, 0
%221 = extractvalue { i64, i64 } %219, 1
%222 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %220, i32 0, i64 %212, i64 %221)
%223 = extractvalue { i64, i64 } %222, 0
%224 = extractvalue { i64, i64 } %222, 1
%225 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %224, i32 0, i64 %215, i64 %216)
%226 = extractvalue { i64, i64 } %225, 0
%227 = extractvalue { i64, i64 } %225, 1
%228 = getelementptr inbounds i64, i64* %0, i64 5
store i64 %223, i64* %228
%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) %2)
%232 = extractvalue { i64, i64 } %231, 0
%233 = extractvalue { i64, i64 } %231, 1
%234 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %232, i32 0, i64 %226, i64 %233)
%235 = extractvalue { i64, i64 } %234, 0
%236 = extractvalue { i64, i64 } %234, 1
%237 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %236, i32 0, i64 %227, i64 0)
%238 = extractvalue { i64, i64 } %237, 0
%239 = extractvalue { i64, i64 } %237, 1
%240 = load i64, i64* %217
%241 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %240, i64* elementtype(i64) %15)
%242 = extractvalue { i64, i64 } %241, 0
%243 = extractvalue { i64, i64 } %241, 1
%244 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %242, i32 0, i64 %235, i64 %243)
%245 = extractvalue { i64, i64 } %244, 0
%246 = extractvalue { i64, i64 } %244, 1
%247 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %246, i32 0, i64 %238, i64 %239)
%248 = extractvalue { i64, i64 } %247, 0
%249 = extractvalue { i64, i64 } %247, 1
%250 = load i64, i64* %113
%251 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %250, i64* elementtype(i64) %59)
%252 = extractvalue { i64, i64 } %251, 0
%253 = extractvalue { i64, i64 } %251, 1
%254 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %252, i32 0, i64 %245, i64 %253)
%255 = extractvalue { i64, i64 } %254, 0
%256 = extractvalue { i64, i64 } %254, 1
%257 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %256, i32 0, i64 %248, i64 %249)
%258 = extractvalue { i64, i64 } %257, 0
%259 = extractvalue { i64, i64 } %257, 1
%260 = load i64, i64* %101
%261 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %260, i64* elementtype(i64) %71)
%262 = extractvalue { i64, i64 } %261, 0
%263 = extractvalue { i64, i64 } %261, 1
%264 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %262, i32 0, i64 %255, i64 %263)
%265 = extractvalue { i64, i64 } %264, 0
%266 = extractvalue { i64, i64 } %264, 1
%267 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %266, i32 0, i64 %258, i64 %259)
%268 = extractvalue { i64, i64 } %267, 0
%269 = extractvalue { i64, i64 } %267, 1
%270 = load i64, i64* %37
%271 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %270, i64* elementtype(i64) %155)
%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 %265, 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 %268, i64 %269)
%278 = extractvalue { i64, i64 } %277, 0
%279 = extractvalue { i64, i64 } %277, 1
%280 = load i64, i64* %25
%281 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %280, i64* elementtype(i64) %167)
%282 = extractvalue { i64, i64 } %281, 0
%283 = extractvalue { i64, i64 } %281, 1
%284 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %282, i32 0, i64 %275, i64 %283)
%285 = extractvalue { i64, i64 } %284, 0
%286 = extractvalue { i64, i64 } %284, 1
%287 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %286, i32 0, i64 %278, i64 %279)
%288 = extractvalue { i64, i64 } %287, 0
%289 = extractvalue { i64, i64 } %287, 1
%290 = load i64, i64* %1
%291 = getelementptr inbounds i64, i64* %2, i64 6
%292 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %290, i64* elementtype(i64) %291)
%293 = extractvalue { i64, i64 } %292, 0
%294 = extractvalue { i64, i64 } %292, 1
%295 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %293, i32 0, i64 %285, i64 %294)
%296 = extractvalue { i64, i64 } %295, 0
%297 = extractvalue { i64, i64 } %295, 1
%298 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %297, i32 0, i64 %288, i64 %289)
%299 = extractvalue { i64, i64 } %298, 0
%300 = extractvalue { i64, i64 } %298, 1
%301 = getelementptr inbounds i64, i64* %0, i64 6
store i64 %296, i64* %301
%302 = load i64, i64* %1
%303 = getelementptr inbounds i64, i64* %2, i64 7
%304 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %302, i64* elementtype(i64) %303)
%305 = extractvalue { i64, i64 } %304, 0
%306 = extractvalue { i64, i64 } %304, 1
%307 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %305, i32 0, i64 %299, i64 %306)
%308 = extractvalue { i64, i64 } %307, 0
%309 = extractvalue { i64, i64 } %307, 1
%310 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %309, i32 0, i64 %300, i64 0)
%311 = extractvalue { i64, i64 } %310, 0
%312 = extractvalue { i64, i64 } %310, 1
%313 = load i64, i64* %25
%314 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %313, i64* elementtype(i64) %291)
%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 %308, 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 %312)
%321 = extractvalue { i64, i64 } %320, 0
%322 = extractvalue { i64, i64 } %320, 1
%323 = load i64, i64* %37
%324 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %323, i64* elementtype(i64) %167)
%325 = extractvalue { i64, i64 } %324, 0
%326 = extractvalue { i64, i64 } %324, 1
%327 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %325, i32 0, i64 %318, i64 %326)
%328 = extractvalue { i64, i64 } %327, 0
%329 = extractvalue { i64, i64 } %327, 1
%330 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %329, i32 0, i64 %321, i64 %322)
%331 = extractvalue { i64, i64 } %330, 0
%332 = extractvalue { i64, i64 } %330, 1
%333 = load i64, i64* %101
%334 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %333, i64* elementtype(i64) %155)
%335 = extractvalue { i64, i64 } %334, 0
%336 = extractvalue { i64, i64 } %334, 1
%337 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %335, i32 0, i64 %328, i64 %336)
%338 = extractvalue { i64, i64 } %337, 0
%339 = extractvalue { i64, i64 } %337, 1
%340 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %339, i32 0, i64 %331, i64 %332)
%341 = extractvalue { i64, i64 } %340, 0
%342 = extractvalue { i64, i64 } %340, 1
%343 = load i64, i64* %113
%344 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %343, i64* elementtype(i64) %71)
%345 = extractvalue { i64, i64 } %344, 0
%346 = extractvalue { i64, i64 } %344, 1
%347 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %345, i32 0, i64 %338, i64 %346)
%348 = extractvalue { i64, i64 } %347, 0
%349 = extractvalue { i64, i64 } %347, 1
%350 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %349, i32 0, i64 %341, i64 %342)
%351 = extractvalue { i64, i64 } %350, 0
%352 = extractvalue { i64, i64 } %350, 1
%353 = load i64, i64* %217
%354 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %353, i64* elementtype(i64) %59)
%355 = extractvalue { i64, i64 } %354, 0
%356 = extractvalue { i64, i64 } %354, 1
%357 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %355, i32 0, i64 %348, i64 %356)
%358 = extractvalue { i64, i64 } %357, 0
%359 = extractvalue { i64, i64 } %357, 1
%360 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %359, i32 0, i64 %351, i64 %352)
%361 = extractvalue { i64, i64 } %360, 0
%362 = extractvalue { i64, i64 } %360, 1
%363 = load i64, i64* %229
%364 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %363, i64* elementtype(i64) %15)
%365 = extractvalue { i64, i64 } %364, 0
%366 = extractvalue { i64, i64 } %364, 1
%367 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %365, i32 0, i64 %358, i64 %366)
%368 = extractvalue { i64, i64 } %367, 0
%369 = extractvalue { i64, i64 } %367, 1
%370 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %369, i32 0, i64 %361, i64 %362)
%371 = extractvalue { i64, i64 } %370, 0
%372 = extractvalue { i64, i64 } %370, 1
%373 = getelementptr inbounds i64, i64* %1, i64 7
%374 = load i64, i64* %373
%375 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %374, i64* elementtype(i64) %2)
%376 = extractvalue { i64, i64 } %375, 0
%377 = extractvalue { i64, i64 } %375, 1
%378 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %376, i32 0, i64 %368, i64 %377)
%379 = extractvalue { i64, i64 } %378, 0
%380 = extractvalue { i64, i64 } %378, 1
%381 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %380, i32 0, i64 %371, i64 %372)
%382 = extractvalue { i64, i64 } %381, 0
%383 = extractvalue { i64, i64 } %381, 1
%384 = getelementptr inbounds i64, i64* %0, i64 7
store i64 %379, i64* %384
%385 = load i64, i64* %373
%386 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %385, i64* elementtype(i64) %15)
%387 = extractvalue { i64, i64 } %386, 0
%388 = extractvalue { i64, i64 } %386, 1
%389 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %387, i32 0, i64 %382, i64 %388)
%390 = extractvalue { i64, i64 } %389, 0
%391 = extractvalue { i64, i64 } %389, 1
%392 = tail 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 %383, i64 0)
%393 = extractvalue { i64, i64 } %392, 0
%394 = extractvalue { i64, i64 } %392, 1
%395 = load i64, i64* %229
%396 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %395, i64* elementtype(i64) %59)
%397 = extractvalue { i64, i64 } %396, 0
%398 = extractvalue { i64, i64 } %396, 1
%399 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %397, i32 0, i64 %390, i64 %398)
%400 = extractvalue { i64, i64 } %399, 0
%401 = extractvalue { i64, i64 } %399, 1
%402 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %401, i32 0, i64 %393, i64 %394)
%403 = extractvalue { i64, i64 } %402, 0
%404 = extractvalue { i64, i64 } %402, 1
%405 = load i64, i64* %217
%406 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %405, i64* elementtype(i64) %71)
%407 = extractvalue { i64, i64 } %406, 0
%408 = extractvalue { i64, i64 } %406, 1
%409 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %407, i32 0, i64 %400, i64 %408)
%410 = extractvalue { i64, i64 } %409, 0
%411 = extractvalue { i64, i64 } %409, 1
%412 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %411, i32 0, i64 %403, i64 %404)
%413 = extractvalue { i64, i64 } %412, 0
%414 = extractvalue { i64, i64 } %412, 1
%415 = load i64, i64* %113
%416 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %415, i64* elementtype(i64) %155)
%417 = extractvalue { i64, i64 } %416, 0
%418 = extractvalue { i64, i64 } %416, 1
%419 = tail 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 %410, i64 %418)
%420 = extractvalue { i64, i64 } %419, 0
%421 = extractvalue { i64, i64 } %419, 1
%422 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %421, i32 0, i64 %413, i64 %414)
%423 = extractvalue { i64, i64 } %422, 0
%424 = extractvalue { i64, i64 } %422, 1
%425 = load i64, i64* %101
%426 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %425, i64* elementtype(i64) %167)
%427 = extractvalue { i64, i64 } %426, 0
%428 = extractvalue { i64, i64 } %426, 1
%429 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %427, i32 0, i64 %420, i64 %428)
%430 = extractvalue { i64, i64 } %429, 0
%431 = extractvalue { i64, i64 } %429, 1
%432 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %431, i32 0, i64 %423, i64 %424)
%433 = extractvalue { i64, i64 } %432, 0
%434 = extractvalue { i64, i64 } %432, 1
%435 = load i64, i64* %37
%436 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %435, i64* elementtype(i64) %291)
%437 = extractvalue { i64, i64 } %436, 0
%438 = extractvalue { i64, i64 } %436, 1
%439 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %437, i32 0, i64 %430, i64 %438)
%440 = extractvalue { i64, i64 } %439, 0
%441 = extractvalue { i64, i64 } %439, 1
%442 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %441, i32 0, i64 %433, i64 %434)
%443 = extractvalue { i64, i64 } %442, 0
%444 = extractvalue { i64, i64 } %442, 1
%445 = load i64, i64* %25
%446 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %445, i64* elementtype(i64) %303)
%447 = extractvalue { i64, i64 } %446, 0
%448 = extractvalue { i64, i64 } %446, 1
%449 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %447, i32 0, i64 %440, i64 %448)
%450 = extractvalue { i64, i64 } %449, 0
%451 = extractvalue { i64, i64 } %449, 1
%452 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %451, i32 0, i64 %443, i64 %444)
%453 = extractvalue { i64, i64 } %452, 0
%454 = extractvalue { i64, i64 } %452, 1
%455 = getelementptr inbounds i64, i64* %0, i64 8
store i64 %450, i64* %455
%456 = load i64, i64* %37
%457 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %456, i64* elementtype(i64) %303)
%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,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %458, i32 0, i64 %453, i64 %459)
%461 = extractvalue { i64, i64 } %460, 0
%462 = extractvalue { i64, i64 } %460, 1
%463 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %462, i32 0, i64 %454, i64 0)
%464 = extractvalue { i64, i64 } %463, 0
%465 = extractvalue { i64, i64 } %463, 1
%466 = load i64, i64* %101
%467 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %466, i64* elementtype(i64) %291)
%468 = extractvalue { i64, i64 } %467, 0
%469 = extractvalue { i64, i64 } %467, 1
%470 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %468, i32 0, i64 %461, i64 %469)
%471 = extractvalue { i64, i64 } %470, 0
%472 = extractvalue { i64, i64 } %470, 1
%473 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %472, i32 0, i64 %464, i64 %465)
%474 = extractvalue { i64, i64 } %473, 0
%475 = extractvalue { i64, i64 } %473, 1
%476 = load i64, i64* %113
%477 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %476, i64* elementtype(i64) %167)
%478 = extractvalue { i64, i64 } %477, 0
%479 = extractvalue { i64, i64 } %477, 1
%480 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %478, i32 0, i64 %471, i64 %479)
%481 = extractvalue { i64, i64 } %480, 0
%482 = extractvalue { i64, i64 } %480, 1
%483 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %482, i32 0, i64 %474, i64 %475)
%484 = extractvalue { i64, i64 } %483, 0
%485 = extractvalue { i64, i64 } %483, 1
%486 = load i64, i64* %217
%487 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %486, i64* elementtype(i64) %155)
%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 %481, 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 %484, i64 %485)
%494 = extractvalue { i64, i64 } %493, 0
%495 = extractvalue { i64, i64 } %493, 1
%496 = load i64, i64* %229
%497 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %496, i64* elementtype(i64) %71)
%498 = extractvalue { i64, i64 } %497, 0
%499 = extractvalue { i64, i64 } %497, 1
%500 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %498, i32 0, i64 %491, i64 %499)
%501 = extractvalue { i64, i64 } %500, 0
%502 = extractvalue { i64, i64 } %500, 1
%503 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %502, i32 0, i64 %494, i64 %495)
%504 = extractvalue { i64, i64 } %503, 0
%505 = extractvalue { i64, i64 } %503, 1
%506 = load i64, i64* %373
%507 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %506, i64* elementtype(i64) %59)
%508 = extractvalue { i64, i64 } %507, 0
%509 = extractvalue { i64, i64 } %507, 1
%510 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %508, i32 0, i64 %501, i64 %509)
%511 = extractvalue { i64, i64 } %510, 0
%512 = extractvalue { i64, i64 } %510, 1
%513 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %512, i32 0, i64 %504, i64 %505)
%514 = extractvalue { i64, i64 } %513, 0
%515 = extractvalue { i64, i64 } %513, 1
%516 = getelementptr inbounds i64, i64* %0, i64 9
store i64 %511, i64* %516
%517 = load i64, i64* %373
%518 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %517, i64* elementtype(i64) %71)
%519 = extractvalue { i64, i64 } %518, 0
%520 = extractvalue { i64, i64 } %518, 1
%521 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %519, i32 0, i64 %514, i64 %520)
%522 = extractvalue { i64, i64 } %521, 0
%523 = extractvalue { i64, i64 } %521, 1
%524 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %523, i32 0, i64 %515, i64 0)
%525 = extractvalue { i64, i64 } %524, 0
%526 = extractvalue { i64, i64 } %524, 1
%527 = load i64, i64* %229
%528 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %527, i64* elementtype(i64) %155)
%529 = extractvalue { i64, i64 } %528, 0
%530 = extractvalue { i64, i64 } %528, 1
%531 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %529, i32 0, i64 %522, i64 %530)
%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,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %533, i32 0, i64 %525, i64 %526)
%535 = extractvalue { i64, i64 } %534, 0
%536 = extractvalue { i64, i64 } %534, 1
%537 = load i64, i64* %217
%538 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %537, i64* elementtype(i64) %167)
%539 = extractvalue { i64, i64 } %538, 0
%540 = extractvalue { i64, i64 } %538, 1
%541 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %539, i32 0, i64 %532, i64 %540)
%542 = extractvalue { i64, i64 } %541, 0
%543 = extractvalue { i64, i64 } %541, 1
%544 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %543, i32 0, i64 %535, i64 %536)
%545 = extractvalue { i64, i64 } %544, 0
%546 = extractvalue { i64, i64 } %544, 1
%547 = load i64, i64* %113
%548 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %547, i64* elementtype(i64) %291)
%549 = extractvalue { i64, i64 } %548, 0
%550 = extractvalue { i64, i64 } %548, 1
%551 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %549, i32 0, i64 %542, i64 %550)
%552 = extractvalue { i64, i64 } %551, 0
%553 = extractvalue { i64, i64 } %551, 1
%554 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %553, i32 0, i64 %545, i64 %546)
%555 = extractvalue { i64, i64 } %554, 0
%556 = extractvalue { i64, i64 } %554, 1
%557 = load i64, i64* %101
%558 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %557, i64* elementtype(i64) %303)
%559 = extractvalue { i64, i64 } %558, 0
%560 = extractvalue { i64, i64 } %558, 1
%561 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %559, i32 0, i64 %552, i64 %560)
%562 = extractvalue { i64, i64 } %561, 0
%563 = extractvalue { i64, i64 } %561, 1
%564 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %563, i32 0, i64 %555, i64 %556)
%565 = extractvalue { i64, i64 } %564, 0
%566 = extractvalue { i64, i64 } %564, 1
%567 = getelementptr inbounds i64, i64* %0, i64 10
store i64 %562, i64* %567
%568 = load i64, i64* %113
%569 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %568, i64* elementtype(i64) %303)
%570 = extractvalue { i64, i64 } %569, 0
%571 = extractvalue { i64, i64 } %569, 1
%572 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %570, i32 0, i64 %565, i64 %571)
%573 = extractvalue { i64, i64 } %572, 0
%574 = extractvalue { i64, i64 } %572, 1
%575 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %574, i32 0, i64 %566, i64 0)
%576 = extractvalue { i64, i64 } %575, 0
%577 = extractvalue { i64, i64 } %575, 1
%578 = load i64, i64* %217
%579 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %578, i64* elementtype(i64) %291)
%580 = extractvalue { i64, i64 } %579, 0
%581 = extractvalue { i64, i64 } %579, 1
%582 = tail 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 %573, i64 %581)
%583 = extractvalue { i64, i64 } %582, 0
%584 = extractvalue { i64, i64 } %582, 1
%585 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %584, i32 0, i64 %576, i64 %577)
%586 = extractvalue { i64, i64 } %585, 0
%587 = extractvalue { i64, i64 } %585, 1
%588 = load i64, i64* %229
%589 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %588, i64* elementtype(i64) %167)
%590 = extractvalue { i64, i64 } %589, 0
%591 = extractvalue { i64, i64 } %589, 1
%592 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %590, i32 0, i64 %583, i64 %591)
%593 = extractvalue { i64, i64 } %592, 0
%594 = extractvalue { i64, i64 } %592, 1
%595 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %594, i32 0, i64 %586, i64 %587)
%596 = extractvalue { i64, i64 } %595, 0
%597 = extractvalue { i64, i64 } %595, 1
%598 = load i64, i64* %373
%599 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %598, i64* elementtype(i64) %155)
%600 = extractvalue { i64, i64 } %599, 0
%601 = extractvalue { i64, i64 } %599, 1
%602 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %600, i32 0, i64 %593, i64 %601)
%603 = extractvalue { i64, i64 } %602, 0
%604 = extractvalue { i64, i64 } %602, 1
%605 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %604, i32 0, i64 %596, i64 %597)
%606 = extractvalue { i64, i64 } %605, 0
%607 = extractvalue { i64, i64 } %605, 1
%608 = getelementptr inbounds i64, i64* %0, i64 11
store i64 %603, i64* %608
%609 = load i64, i64* %373
%610 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %609, i64* elementtype(i64) %167)
%611 = extractvalue { i64, i64 } %610, 0
%612 = extractvalue { i64, i64 } %610, 1
%613 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %611, i32 0, i64 %606, i64 %612)
%614 = extractvalue { i64, i64 } %613, 0
%615 = extractvalue { i64, i64 } %613, 1
%616 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %615, i32 0, i64 %607, i64 0)
%617 = extractvalue { i64, i64 } %616, 0
%618 = extractvalue { i64, i64 } %616, 1
%619 = load i64, i64* %229
%620 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %619, i64* elementtype(i64) %291)
%621 = extractvalue { i64, i64 } %620, 0
%622 = extractvalue { i64, i64 } %620, 1
%623 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %621, i32 0, i64 %614, i64 %622)
%624 = extractvalue { i64, i64 } %623, 0
%625 = extractvalue { i64, i64 } %623, 1
%626 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %625, i32 0, i64 %617, i64 %618)
%627 = extractvalue { i64, i64 } %626, 0
%628 = extractvalue { i64, i64 } %626, 1
%629 = load i64, i64* %217
%630 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %629, i64* elementtype(i64) %303)
%631 = extractvalue { i64, i64 } %630, 0
%632 = extractvalue { i64, i64 } %630, 1
%633 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %631, i32 0, i64 %624, i64 %632)
%634 = extractvalue { i64, i64 } %633, 0
%635 = extractvalue { i64, i64 } %633, 1
%636 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %635, i32 0, i64 %627, i64 %628)
%637 = extractvalue { i64, i64 } %636, 0
%638 = extractvalue { i64, i64 } %636, 1
%639 = getelementptr inbounds i64, i64* %0, i64 12
store i64 %634, i64* %639
%640 = load i64, i64* %229
%641 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %640, i64* elementtype(i64) %303)
%642 = extractvalue { i64, i64 } %641, 0
%643 = extractvalue { i64, i64 } %641, 1
%644 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %642, i32 0, i64 %637, i64 %643)
%645 = extractvalue { i64, i64 } %644, 0
%646 = extractvalue { i64, i64 } %644, 1
%647 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %646, i32 0, i64 %638, i64 0)
%648 = extractvalue { i64, i64 } %647, 0
%649 = extractvalue { i64, i64 } %647, 1
%650 = load i64, i64* %373
%651 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %650, i64* elementtype(i64) %291)
%652 = extractvalue { i64, i64 } %651, 0
%653 = extractvalue { i64, i64 } %651, 1
%654 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %652, i32 0, i64 %645, i64 %653)
%655 = extractvalue { i64, i64 } %654, 0
%656 = extractvalue { i64, i64 } %654, 1
%657 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %656, i32 0, i64 %648, i64 %649)
%658 = extractvalue { i64, i64 } %657, 0
%659 = extractvalue { i64, i64 } %657, 1
%660 = getelementptr inbounds i64, i64* %0, i64 13
store i64 %655, i64* %660
%661 = load i64, i64* %373
%662 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %661, i64* elementtype(i64) %303)
%663 = extractvalue { i64, i64 } %662, 0
%664 = extractvalue { i64, i64 } %662, 1
%665 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %663, i32 0, i64 %658, i64 %664)
%666 = extractvalue { i64, i64 } %665, 0
%667 = extractvalue { i64, i64 } %665, 1
%668 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %667, i32 0, i64 %659, i64 0)
%669 = extractvalue { i64, i64 } %668, 0
%670 = getelementptr inbounds i64, i64* %0, i64 14
store i64 %666, i64* %670
%671 = getelementptr inbounds i64, i64* %0, i64 15
store i64 %669, i64* %671
ret void
}