void bn_mul_comba4(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[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);
  r[4] = c2;
  c2 = 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);
  r[5] = c3;
  c3 = 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);
  r[6] = c1;
  r[7] = c2;
}


x86 assembly (clang, -O0):
<bn_mul_comba4>:
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_comba4+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_comba4+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_comba4+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_comba4+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_comba4+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_comba4+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    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    1522 <bn_mul_comba4+0x422>
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    157b <bn_mul_comba4+0x47b>
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)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x20(%rax)
movq   $0x0,-0x38(%rbp)
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    163c <bn_mul_comba4+0x53c>
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)
mov    -0x40(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x28(%rax)
movq   $0x0,-0x40(%rbp)
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)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x30(%rax)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x38(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<bn_mul_comba4>:
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    %r11d,%r11d
add    %rdx,%rbx
adc    $0x0,%r11
mov    %rcx,(%rdi)
mov    (%rsi),%rax
mulq   0x8(%r9)
add    %rax,%rbx
adc    $0x0,%rdx
xor    %r14d,%r14d
add    %rdx,%r11
adc    $0x0,%r14
mov    0x8(%rsi),%rax
mulq   (%r9)
add    %rax,%rbx
adc    $0x0,%rdx
add    %rdx,%r11
adc    $0x0,%r14
mov    %rbx,0x8(%rdi)
mov    0x10(%rsi),%rax
mulq   (%r9)
add    %rax,%r11
adc    $0x0,%rdx
xor    %r10d,%r10d
add    %rdx,%r14
adc    $0x0,%r10
mov    0x8(%rsi),%rax
mulq   0x8(%r9)
add    %rax,%r11
adc    $0x0,%rdx
add    %rdx,%r14
adc    $0x0,%r10
mov    (%rsi),%rax
mulq   0x10(%r9)
add    %rax,%r11
adc    $0x0,%rdx
add    %rdx,%r14
adc    $0x0,%r10
mov    %r11,0x10(%rdi)
mov    (%rsi),%rax
mulq   0x18(%r9)
add    %rax,%r14
adc    $0x0,%rdx
xor    %r11d,%r11d
add    %rdx,%r10
adc    $0x0,%r11
mov    0x8(%rsi),%rax
mulq   0x10(%r9)
add    %rax,%r14
adc    $0x0,%rdx
add    %rdx,%r10
adc    $0x0,%r11
mov    0x10(%rsi),%rax
mulq   0x8(%r9)
add    %rax,%r14
adc    $0x0,%rdx
add    %rdx,%r10
adc    $0x0,%r11
mov    0x18(%rsi),%rax
mulq   (%r9)
add    %rax,%r14
adc    $0x0,%rdx
add    %rdx,%r10
adc    $0x0,%r11
mov    %r14,0x18(%rdi)
mov    0x18(%rsi),%rax
mulq   0x8(%r9)
add    %rax,%r10
adc    $0x0,%rdx
xor    %ecx,%ecx
add    %rdx,%r11
adc    $0x0,%rcx
mov    0x10(%rsi),%rax
mulq   0x10(%r9)
add    %rax,%r10
adc    $0x0,%rdx
add    %rdx,%r11
adc    $0x0,%rcx
mov    0x8(%rsi),%rax
mulq   0x18(%r9)
add    %rax,%r10
adc    $0x0,%rdx
add    %rdx,%r11
adc    $0x0,%rcx
mov    %r10,0x20(%rdi)
mov    0x10(%rsi),%rax
mulq   0x18(%r9)
add    %rax,%r11
adc    $0x0,%rdx
xor    %ebx,%ebx
add    %rdx,%rcx
adc    $0x0,%rbx
mov    0x18(%rsi),%rax
mulq   0x10(%r9)
add    %rax,%r11
adc    $0x0,%rdx
add    %rdx,%rcx
adc    $0x0,%rbx
mov    %r11,0x28(%rdi)
mov    0x18(%rsi),%rax
mulq   0x18(%r9)
add    %rax,%rcx
adc    $0x0,%rdx
add    %rdx,%rbx
adc    $0x0,%r8
mov    %rcx,0x30(%rdi)
mov    %rbx,0x38(%rdi)
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @bn_mul_comba4(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 3
%247 = load i64, i64* %246
%248 = load i64*, i64** %6
%249 = getelementptr inbounds i64, i64* %248, i64 1
%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 2
%269 = load i64, i64* %268
%270 = load i64*, i64** %6
%271 = getelementptr inbounds i64, i64* %270, i64 2
%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 1
%291 = load i64, i64* %290
%292 = load i64*, i64** %6
%293 = getelementptr inbounds i64, i64* %292, i64 3
%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
%310 = load i64, i64* %10
%311 = load i64*, i64** %4
%312 = getelementptr inbounds i64, i64* %311, i64 4
store i64 %310, i64* %312
store i64 0, i64* %10
br label %313
313: ; preds = %309
%314 = load i64*, i64** %5
%315 = getelementptr inbounds i64, i64* %314, i64 2
%316 = load i64, i64* %315
%317 = load i64*, i64** %6
%318 = getelementptr inbounds i64, i64* %317, i64 3
%319 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %316, i64* elementtype(i64) %318)
%320 = extractvalue { i64, i64 } %319, 0
%321 = extractvalue { i64, i64 } %319, 1
store i64 %320, i64* %7
store i64 %321, i64* %8
%322 = load i64, i64* %11
%323 = load i64, i64* %8
%324 = load i64, i64* %7
%325 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %324, i32 0, i64 %322, i64 %323)
%326 = extractvalue { i64, i64 } %325, 0
%327 = extractvalue { i64, i64 } %325, 1
store i64 %326, i64* %11
store i64 %327, i64* %8
%328 = load i64, i64* %9
%329 = load i64, i64* %10
%330 = load i64, i64* %8
%331 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %330, i32 0, i64 %328, i64 %329)
%332 = extractvalue { i64, i64 } %331, 0
%333 = extractvalue { i64, i64 } %331, 1
store i64 %332, i64* %9
store i64 %333, i64* %10
br label %334
334: ; preds = %313
br label %335
335: ; preds = %334
%336 = load i64*, i64** %5
%337 = getelementptr inbounds i64, i64* %336, i64 3
%338 = load i64, i64* %337
%339 = load i64*, i64** %6
%340 = getelementptr inbounds i64, i64* %339, i64 2
%341 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %338, i64* elementtype(i64) %340)
%342 = extractvalue { i64, i64 } %341, 0
%343 = extractvalue { i64, i64 } %341, 1
store i64 %342, i64* %7
store i64 %343, i64* %8
%344 = load i64, i64* %11
%345 = load i64, i64* %8
%346 = load i64, i64* %7
%347 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %346, i32 0, i64 %344, i64 %345)
%348 = extractvalue { i64, i64 } %347, 0
%349 = extractvalue { i64, i64 } %347, 1
store i64 %348, i64* %11
store i64 %349, i64* %8
%350 = load i64, i64* %9
%351 = load i64, i64* %10
%352 = load i64, i64* %8
%353 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %352, i32 0, i64 %350, i64 %351)
%354 = extractvalue { i64, i64 } %353, 0
%355 = extractvalue { i64, i64 } %353, 1
store i64 %354, i64* %9
store i64 %355, i64* %10
br label %356
356: ; preds = %335
%357 = load i64, i64* %11
%358 = load i64*, i64** %4
%359 = getelementptr inbounds i64, i64* %358, i64 5
store i64 %357, i64* %359
store i64 0, i64* %11
br label %360
360: ; preds = %356
%361 = load i64*, i64** %5
%362 = getelementptr inbounds i64, i64* %361, i64 3
%363 = load i64, i64* %362
%364 = load i64*, i64** %6
%365 = getelementptr inbounds i64, i64* %364, i64 3
%366 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %363, i64* elementtype(i64) %365)
%367 = extractvalue { i64, i64 } %366, 0
%368 = extractvalue { i64, i64 } %366, 1
store i64 %367, i64* %7
store i64 %368, i64* %8
%369 = load i64, i64* %9
%370 = load i64, i64* %8
%371 = load i64, i64* %7
%372 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %371, i32 0, i64 %369, i64 %370)
%373 = extractvalue { i64, i64 } %372, 0
%374 = extractvalue { i64, i64 } %372, 1
store i64 %373, i64* %9
store i64 %374, i64* %8
%375 = load i64, i64* %10
%376 = load i64, i64* %11
%377 = load i64, i64* %8
%378 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %377, i32 0, i64 %375, i64 %376)
%379 = extractvalue { i64, i64 } %378, 0
%380 = extractvalue { i64, i64 } %378, 1
store i64 %379, i64* %10
store i64 %380, i64* %11
br label %381
381: ; preds = %360
%382 = load i64, i64* %9
%383 = load i64*, i64** %4
%384 = getelementptr inbounds i64, i64* %383, i64 6
store i64 %382, i64* %384
%385 = load i64, i64* %10
%386 = load i64*, i64** %4
%387 = getelementptr inbounds i64, i64* %386, i64 7
store i64 %385, i64* %387
ret void
}

LLVM IR (-O2):
define void @bn_mul_comba4(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 = load i64, i64* %101
%114 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %113, i64* elementtype(i64) %15)
%115 = extractvalue { i64, i64 } %114, 0
%116 = extractvalue { i64, i64 } %114, 1
%117 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %115, i32 0, i64 %110, i64 %116)
%118 = extractvalue { i64, i64 } %117, 0
%119 = extractvalue { i64, i64 } %117, 1
%120 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %119, i32 0, i64 %111, i64 0)
%121 = extractvalue { i64, i64 } %120, 0
%122 = extractvalue { i64, i64 } %120, 1
%123 = load i64, i64* %37
%124 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %123, i64* elementtype(i64) %59)
%125 = extractvalue { i64, i64 } %124, 0
%126 = extractvalue { i64, i64 } %124, 1
%127 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %125, i32 0, i64 %118, i64 %126)
%128 = extractvalue { i64, i64 } %127, 0
%129 = extractvalue { i64, i64 } %127, 1
%130 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %129, i32 0, i64 %121, i64 %122)
%131 = extractvalue { i64, i64 } %130, 0
%132 = extractvalue { i64, i64 } %130, 1
%133 = load i64, i64* %25
%134 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %133, i64* elementtype(i64) %71)
%135 = extractvalue { i64, i64 } %134, 0
%136 = extractvalue { i64, i64 } %134, 1
%137 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %135, i32 0, i64 %128, i64 %136)
%138 = extractvalue { i64, i64 } %137, 0
%139 = extractvalue { i64, i64 } %137, 1
%140 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %139, i32 0, i64 %131, i64 %132)
%141 = extractvalue { i64, i64 } %140, 0
%142 = extractvalue { i64, i64 } %140, 1
%143 = getelementptr inbounds i64, i64* %0, i64 4
store i64 %138, i64* %143
%144 = load i64, i64* %37
%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 %141, 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 0)
%152 = extractvalue { i64, i64 } %151, 0
%153 = extractvalue { i64, i64 } %151, 1
%154 = load i64, i64* %101
%155 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %154, i64* elementtype(i64) %59)
%156 = extractvalue { i64, i64 } %155, 0
%157 = extractvalue { i64, i64 } %155, 1
%158 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %156, i32 0, i64 %149, i64 %157)
%159 = extractvalue { i64, i64 } %158, 0
%160 = extractvalue { i64, i64 } %158, 1
%161 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %160, i32 0, i64 %152, i64 %153)
%162 = extractvalue { i64, i64 } %161, 0
%163 = extractvalue { i64, i64 } %161, 1
%164 = getelementptr inbounds i64, i64* %0, i64 5
store i64 %159, i64* %164
%165 = load i64, i64* %101
%166 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %165, i64* elementtype(i64) %71)
%167 = extractvalue { i64, i64 } %166, 0
%168 = extractvalue { i64, i64 } %166, 1
%169 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %167, i32 0, i64 %162, i64 %168)
%170 = extractvalue { i64, i64 } %169, 0
%171 = extractvalue { i64, i64 } %169, 1
%172 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %171, i32 0, i64 %163, i64 0)
%173 = extractvalue { i64, i64 } %172, 0
%174 = getelementptr inbounds i64, i64* %0, i64 6
store i64 %170, i64* %174
%175 = getelementptr inbounds i64, i64* %0, i64 7
store i64 %173, i64* %175
ret void
}