void bn_sqr_comba4(unsigned long *r, unsigned long *a) {
  unsigned long t1, t2;
  unsigned long c1, c2, c3;
  c1 = 0;
  c2 = 0;
  c3 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[0]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+r"(c3) : "d"(t2), "g"(0) : "cc");
  } while (0);
  r[0] = c1;
  c1 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[1]), "m"((a)[0]) : "cc");
    asm("addq %0,%0; adcq %2,%1" : "+d"(t2), "+r"(c1) : "g"(0) : "cc");
    asm("addq %0,%0; adcq %2,%1" : "+a"(t1), "+d"(t2) : "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+r"(c1) : "d"(t2), "g"(0) : "cc");
  } while (0);
  r[1] = c2;
  c2 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[1]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+r"(c2) : "d"(t2), "g"(0) : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[2]), "m"((a)[0]) : "cc");
    asm("addq %0,%0; adcq %2,%1" : "+d"(t2), "+r"(c2) : "g"(0) : "cc");
    asm("addq %0,%0; adcq %2,%1" : "+a"(t1), "+d"(t2) : "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+r"(c2) : "d"(t2), "g"(0) : "cc");
  } while (0);
  r[2] = c3;
  c3 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[3]), "m"((a)[0]) : "cc");
    asm("addq %0,%0; adcq %2,%1" : "+d"(t2), "+r"(c3) : "g"(0) : "cc");
    asm("addq %0,%0; adcq %2,%1" : "+a"(t1), "+d"(t2) : "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+r"(c3) : "d"(t2), "g"(0) : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[2]), "m"((a)[1]) : "cc");
    asm("addq %0,%0; adcq %2,%1" : "+d"(t2), "+r"(c3) : "g"(0) : "cc");
    asm("addq %0,%0; adcq %2,%1" : "+a"(t1), "+d"(t2) : "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+r"(c3) : "d"(t2), "g"(0) : "cc");
  } while (0);
  r[3] = c1;
  c1 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[2]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+r"(c1) : "d"(t2), "g"(0) : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[3]), "m"((a)[1]) : "cc");
    asm("addq %0,%0; adcq %2,%1" : "+d"(t2), "+r"(c1) : "g"(0) : "cc");
    asm("addq %0,%0; adcq %2,%1" : "+a"(t1), "+d"(t2) : "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+r"(c1) : "d"(t2), "g"(0) : "cc");
  } while (0);
  r[4] = c2;
  c2 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[3]), "m"((a)[2]) : "cc");
    asm("addq %0,%0; adcq %2,%1" : "+d"(t2), "+r"(c2) : "g"(0) : "cc");
    asm("addq %0,%0; adcq %2,%1" : "+a"(t1), "+d"(t2) : "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+r"(c2) : "d"(t2), "g"(0) : "cc");
  } while (0);
  r[5] = c3;
  c3 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[3]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+r"(c3) : "d"(t2), "g"(0) : "cc");
  } while (0);
  r[6] = c1;
  r[7] = c2;
}


x86 assembly (clang, -O0):
<bn_sqr_comba4>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x10(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rax
add    %rdx,%rdx
adc    $0x0,%rax
mov    %rdx,-0x20(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rax,%rax
adc    $0x0,%rdx
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x8(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1265 <bn_sqr_comba4+0x165>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rdx
mov    -0x30(%rbp),%rax
add    %rdx,%rdx
adc    $0x0,%rax
mov    %rdx,-0x20(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rax,%rax
adc    $0x0,%rdx
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x10(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x10(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rdx
mov    -0x38(%rbp),%rax
add    %rdx,%rdx
adc    $0x0,%rax
mov    %rdx,-0x20(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rax,%rax
adc    $0x0,%rdx
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    137a <bn_sqr_comba4+0x27a>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rdx
mov    -0x38(%rbp),%rax
add    %rdx,%rdx
adc    $0x0,%rax
mov    %rdx,-0x20(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rax,%rax
adc    $0x0,%rdx
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x18(%rax)
movq   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
jmp    1461 <bn_sqr_comba4+0x361>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rax
add    %rdx,%rdx
adc    $0x0,%rax
mov    %rdx,-0x20(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rax,%rax
adc    $0x0,%rdx
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x20(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x10,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rdx
mov    -0x30(%rbp),%rax
add    %rdx,%rdx
adc    $0x0,%rax
mov    %rdx,-0x20(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rax,%rax
adc    $0x0,%rdx
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x28(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x30(%rax)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x38(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<bn_sqr_comba4>:
mov    (%rsi),%rax
mul    %rax
xor    %ecx,%ecx
add    %rax,%rcx
adc    $0x0,%rdx
xor    %r9d,%r9d
xor    %r10d,%r10d
add    %rdx,%r9
adc    $0x0,%r10
mov    %rcx,(%rdi)
mov    0x8(%rsi),%rax
mulq   (%rsi)
xor    %r8d,%r8d
add    %rdx,%rdx
adc    $0x0,%r8
add    %rax,%rax
adc    $0x0,%rdx
add    %rax,%r9
adc    $0x0,%rdx
add    %rdx,%r10
adc    $0x0,%r8
mov    %r9,0x8(%rdi)
mov    0x8(%rsi),%rax
mul    %rax
add    %rax,%r10
adc    $0x0,%rdx
xor    %r9d,%r9d
add    %rdx,%r8
adc    $0x0,%r9
mov    0x10(%rsi),%rax
mulq   (%rsi)
add    %rdx,%rdx
adc    $0x0,%r9
add    %rax,%rax
adc    $0x0,%rdx
add    %rax,%r10
adc    $0x0,%rdx
add    %rdx,%r8
adc    $0x0,%r9
mov    %r10,0x10(%rdi)
mov    0x18(%rsi),%rax
mulq   (%rsi)
xor    %r10d,%r10d
add    %rdx,%rdx
adc    $0x0,%r10
add    %rax,%rax
adc    $0x0,%rdx
add    %rax,%r8
adc    $0x0,%rdx
add    %rdx,%r9
adc    $0x0,%r10
mov    0x10(%rsi),%rax
mulq   0x8(%rsi)
add    %rdx,%rdx
adc    $0x0,%r10
add    %rax,%rax
adc    $0x0,%rdx
add    %rax,%r8
adc    $0x0,%rdx
add    %rdx,%r9
adc    $0x0,%r10
mov    %r8,0x18(%rdi)
mov    0x10(%rsi),%rax
mul    %rax
add    %rax,%r9
adc    $0x0,%rdx
xor    %r8d,%r8d
add    %rdx,%r10
adc    $0x0,%r8
mov    0x18(%rsi),%rax
mulq   0x8(%rsi)
add    %rdx,%rdx
adc    $0x0,%r8
add    %rax,%rax
adc    $0x0,%rdx
add    %rax,%r9
adc    $0x0,%rdx
add    %rdx,%r10
adc    $0x0,%r8
mov    %r9,0x20(%rdi)
mov    0x18(%rsi),%rax
mulq   0x10(%rsi)
xor    %ecx,%ecx
add    %rdx,%rdx
adc    $0x0,%rcx
add    %rax,%rax
adc    $0x0,%rdx
xor    %r9d,%r9d
add    %rax,%r10
adc    $0x0,%rdx
add    %rdx,%r8
adc    $0x0,%rcx
mov    %r10,0x28(%rdi)
mov    0x18(%rsi),%rax
mul    %rax
add    %rax,%r8
adc    $0x0,%rdx
add    %rdx,%rcx
adc    $0x0,%r9
mov    %r8,0x30(%rdi)
mov    %rcx,0x38(%rdi)
ret

LLVM IR (-O0):
define void @bn_sqr_comba4(i64* %0, i64* %1) {
%3 = alloca i64*
%4 = alloca i64*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
store i64* %0, i64** %3
store i64* %1, i64** %4
store i64 0, i64* %7
store i64 0, i64* %8
store i64 0, i64* %9
br label %10
10: ; preds = %2
%11 = load i64*, i64** %4
%12 = getelementptr inbounds i64, i64* %11, i64 0
%13 = load i64, i64* %12
%14 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %13)
%15 = extractvalue { i64, i64 } %14, 0
%16 = extractvalue { i64, i64 } %14, 1
store i64 %15, i64* %5
store i64 %16, i64* %6
%17 = load i64, i64* %7
%18 = load i64, i64* %6
%19 = load i64, i64* %5
%20 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %19, i32 0, i64 %17, i64 %18)
%21 = extractvalue { i64, i64 } %20, 0
%22 = extractvalue { i64, i64 } %20, 1
store i64 %21, i64* %7
store i64 %22, i64* %6
%23 = load i64, i64* %8
%24 = load i64, i64* %9
%25 = load i64, i64* %6
%26 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %25, i32 0, i64 %23, i64 %24)
%27 = extractvalue { i64, i64 } %26, 0
%28 = extractvalue { i64, i64 } %26, 1
store i64 %27, i64* %8
store i64 %28, i64* %9
br label %29
29: ; preds = %10
%30 = load i64, i64* %7
%31 = load i64*, i64** %3
%32 = getelementptr inbounds i64, i64* %31, i64 0
store i64 %30, i64* %32
store i64 0, i64* %7
br label %33
33: ; preds = %29
%34 = load i64*, i64** %4
%35 = getelementptr inbounds i64, i64* %34, i64 1
%36 = load i64, i64* %35
%37 = load i64*, i64** %4
%38 = getelementptr inbounds i64, i64* %37, i64 0
%39 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %36, i64* elementtype(i64) %38)
%40 = extractvalue { i64, i64 } %39, 0
%41 = extractvalue { i64, i64 } %39, 1
store i64 %40, i64* %5
store i64 %41, i64* %6
%42 = load i64, i64* %6
%43 = load i64, i64* %7
%44 = call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={dx},=r,imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %42, i64 %43)
%45 = extractvalue { i64, i64 } %44, 0
%46 = extractvalue { i64, i64 } %44, 1
store i64 %45, i64* %6
store i64 %46, i64* %7
%47 = load i64, i64* %5
%48 = load i64, i64* %6
%49 = call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={ax},={dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %47, i64 %48)
%50 = extractvalue { i64, i64 } %49, 0
%51 = extractvalue { i64, i64 } %49, 1
store i64 %50, i64* %5
store i64 %51, i64* %6
%52 = load i64, i64* %8
%53 = load i64, i64* %6
%54 = load i64, i64* %5
%55 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %54, i32 0, i64 %52, i64 %53)
%56 = extractvalue { i64, i64 } %55, 0
%57 = extractvalue { i64, i64 } %55, 1
store i64 %56, i64* %8
store i64 %57, i64* %6
%58 = load i64, i64* %9
%59 = load i64, i64* %7
%60 = load i64, i64* %6
%61 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %60, i32 0, i64 %58, i64 %59)
%62 = extractvalue { i64, i64 } %61, 0
%63 = extractvalue { i64, i64 } %61, 1
store i64 %62, i64* %9
store i64 %63, i64* %7
br label %64
64: ; preds = %33
%65 = load i64, i64* %8
%66 = load i64*, i64** %3
%67 = getelementptr inbounds i64, i64* %66, i64 1
store i64 %65, i64* %67
store i64 0, i64* %8
br label %68
68: ; preds = %64
%69 = load i64*, i64** %4
%70 = getelementptr inbounds i64, i64* %69, i64 1
%71 = load i64, i64* %70
%72 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %71)
%73 = extractvalue { i64, i64 } %72, 0
%74 = extractvalue { i64, i64 } %72, 1
store i64 %73, i64* %5
store i64 %74, i64* %6
%75 = load i64, i64* %9
%76 = load i64, i64* %6
%77 = load i64, i64* %5
%78 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %77, i32 0, i64 %75, i64 %76)
%79 = extractvalue { i64, i64 } %78, 0
%80 = extractvalue { i64, i64 } %78, 1
store i64 %79, i64* %9
store i64 %80, i64* %6
%81 = load i64, i64* %7
%82 = load i64, i64* %8
%83 = load i64, i64* %6
%84 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %83, i32 0, i64 %81, i64 %82)
%85 = extractvalue { i64, i64 } %84, 0
%86 = extractvalue { i64, i64 } %84, 1
store i64 %85, i64* %7
store i64 %86, i64* %8
br label %87
87: ; preds = %68
br label %88
88: ; preds = %87
%89 = load i64*, i64** %4
%90 = getelementptr inbounds i64, i64* %89, i64 2
%91 = load i64, i64* %90
%92 = load i64*, i64** %4
%93 = getelementptr inbounds i64, i64* %92, i64 0
%94 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %91, i64* elementtype(i64) %93)
%95 = extractvalue { i64, i64 } %94, 0
%96 = extractvalue { i64, i64 } %94, 1
store i64 %95, i64* %5
store i64 %96, i64* %6
%97 = load i64, i64* %6
%98 = load i64, i64* %8
%99 = call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={dx},=r,imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %97, i64 %98)
%100 = extractvalue { i64, i64 } %99, 0
%101 = extractvalue { i64, i64 } %99, 1
store i64 %100, i64* %6
store i64 %101, i64* %8
%102 = load i64, i64* %5
%103 = load i64, i64* %6
%104 = call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={ax},={dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %102, i64 %103)
%105 = extractvalue { i64, i64 } %104, 0
%106 = extractvalue { i64, i64 } %104, 1
store i64 %105, i64* %5
store i64 %106, i64* %6
%107 = load i64, i64* %9
%108 = load i64, i64* %6
%109 = load i64, i64* %5
%110 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %109, i32 0, i64 %107, i64 %108)
%111 = extractvalue { i64, i64 } %110, 0
%112 = extractvalue { i64, i64 } %110, 1
store i64 %111, i64* %9
store i64 %112, i64* %6
%113 = load i64, i64* %7
%114 = load i64, i64* %8
%115 = load i64, i64* %6
%116 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %115, i32 0, i64 %113, i64 %114)
%117 = extractvalue { i64, i64 } %116, 0
%118 = extractvalue { i64, i64 } %116, 1
store i64 %117, i64* %7
store i64 %118, i64* %8
br label %119
119: ; preds = %88
%120 = load i64, i64* %9
%121 = load i64*, i64** %3
%122 = getelementptr inbounds i64, i64* %121, i64 2
store i64 %120, i64* %122
store i64 0, i64* %9
br label %123
123: ; preds = %119
%124 = load i64*, i64** %4
%125 = getelementptr inbounds i64, i64* %124, i64 3
%126 = load i64, i64* %125
%127 = load i64*, i64** %4
%128 = getelementptr inbounds i64, i64* %127, i64 0
%129 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %126, i64* elementtype(i64) %128)
%130 = extractvalue { i64, i64 } %129, 0
%131 = extractvalue { i64, i64 } %129, 1
store i64 %130, i64* %5
store i64 %131, i64* %6
%132 = load i64, i64* %6
%133 = load i64, i64* %9
%134 = call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={dx},=r,imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %132, i64 %133)
%135 = extractvalue { i64, i64 } %134, 0
%136 = extractvalue { i64, i64 } %134, 1
store i64 %135, i64* %6
store i64 %136, i64* %9
%137 = load i64, i64* %5
%138 = load i64, i64* %6
%139 = call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={ax},={dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %137, i64 %138)
%140 = extractvalue { i64, i64 } %139, 0
%141 = extractvalue { i64, i64 } %139, 1
store i64 %140, i64* %5
store i64 %141, i64* %6
%142 = load i64, i64* %7
%143 = load i64, i64* %6
%144 = load i64, i64* %5
%145 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %144, i32 0, i64 %142, i64 %143)
%146 = extractvalue { i64, i64 } %145, 0
%147 = extractvalue { i64, i64 } %145, 1
store i64 %146, i64* %7
store i64 %147, i64* %6
%148 = load i64, i64* %8
%149 = load i64, i64* %9
%150 = load i64, i64* %6
%151 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %150, i32 0, i64 %148, i64 %149)
%152 = extractvalue { i64, i64 } %151, 0
%153 = extractvalue { i64, i64 } %151, 1
store i64 %152, i64* %8
store i64 %153, i64* %9
br label %154
154: ; preds = %123
br label %155
155: ; preds = %154
%156 = load i64*, i64** %4
%157 = getelementptr inbounds i64, i64* %156, i64 2
%158 = load i64, i64* %157
%159 = load i64*, i64** %4
%160 = getelementptr inbounds i64, i64* %159, i64 1
%161 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %158, i64* elementtype(i64) %160)
%162 = extractvalue { i64, i64 } %161, 0
%163 = extractvalue { i64, i64 } %161, 1
store i64 %162, i64* %5
store i64 %163, i64* %6
%164 = load i64, i64* %6
%165 = load i64, i64* %9
%166 = call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={dx},=r,imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %164, i64 %165)
%167 = extractvalue { i64, i64 } %166, 0
%168 = extractvalue { i64, i64 } %166, 1
store i64 %167, i64* %6
store i64 %168, i64* %9
%169 = load i64, i64* %5
%170 = load i64, i64* %6
%171 = call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={ax},={dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %169, i64 %170)
%172 = extractvalue { i64, i64 } %171, 0
%173 = extractvalue { i64, i64 } %171, 1
store i64 %172, i64* %5
store i64 %173, i64* %6
%174 = load i64, i64* %7
%175 = load i64, i64* %6
%176 = load i64, i64* %5
%177 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %176, i32 0, i64 %174, i64 %175)
%178 = extractvalue { i64, i64 } %177, 0
%179 = extractvalue { i64, i64 } %177, 1
store i64 %178, i64* %7
store i64 %179, i64* %6
%180 = load i64, i64* %8
%181 = load i64, i64* %9
%182 = load i64, i64* %6
%183 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %182, i32 0, i64 %180, i64 %181)
%184 = extractvalue { i64, i64 } %183, 0
%185 = extractvalue { i64, i64 } %183, 1
store i64 %184, i64* %8
store i64 %185, i64* %9
br label %186
186: ; preds = %155
%187 = load i64, i64* %7
%188 = load i64*, i64** %3
%189 = getelementptr inbounds i64, i64* %188, i64 3
store i64 %187, i64* %189
store i64 0, i64* %7
br label %190
190: ; preds = %186
%191 = load i64*, i64** %4
%192 = getelementptr inbounds i64, i64* %191, i64 2
%193 = load i64, i64* %192
%194 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %193)
%195 = extractvalue { i64, i64 } %194, 0
%196 = extractvalue { i64, i64 } %194, 1
store i64 %195, i64* %5
store i64 %196, i64* %6
%197 = load i64, i64* %8
%198 = load i64, i64* %6
%199 = load i64, i64* %5
%200 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %199, i32 0, i64 %197, i64 %198)
%201 = extractvalue { i64, i64 } %200, 0
%202 = extractvalue { i64, i64 } %200, 1
store i64 %201, i64* %8
store i64 %202, i64* %6
%203 = load i64, i64* %9
%204 = load i64, i64* %7
%205 = load i64, i64* %6
%206 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %205, i32 0, i64 %203, i64 %204)
%207 = extractvalue { i64, i64 } %206, 0
%208 = extractvalue { i64, i64 } %206, 1
store i64 %207, i64* %9
store i64 %208, i64* %7
br label %209
209: ; preds = %190
br label %210
210: ; preds = %209
%211 = load i64*, i64** %4
%212 = getelementptr inbounds i64, i64* %211, i64 3
%213 = load i64, i64* %212
%214 = load i64*, i64** %4
%215 = getelementptr inbounds i64, i64* %214, i64 1
%216 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %213, i64* elementtype(i64) %215)
%217 = extractvalue { i64, i64 } %216, 0
%218 = extractvalue { i64, i64 } %216, 1
store i64 %217, i64* %5
store i64 %218, i64* %6
%219 = load i64, i64* %6
%220 = load i64, i64* %7
%221 = call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={dx},=r,imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %219, i64 %220)
%222 = extractvalue { i64, i64 } %221, 0
%223 = extractvalue { i64, i64 } %221, 1
store i64 %222, i64* %6
store i64 %223, i64* %7
%224 = load i64, i64* %5
%225 = load i64, i64* %6
%226 = call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={ax},={dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %224, i64 %225)
%227 = extractvalue { i64, i64 } %226, 0
%228 = extractvalue { i64, i64 } %226, 1
store i64 %227, i64* %5
store i64 %228, i64* %6
%229 = load i64, i64* %8
%230 = load i64, i64* %6
%231 = load i64, i64* %5
%232 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %231, i32 0, i64 %229, i64 %230)
%233 = extractvalue { i64, i64 } %232, 0
%234 = extractvalue { i64, i64 } %232, 1
store i64 %233, i64* %8
store i64 %234, i64* %6
%235 = load i64, i64* %9
%236 = load i64, i64* %7
%237 = load i64, i64* %6
%238 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %237, i32 0, i64 %235, i64 %236)
%239 = extractvalue { i64, i64 } %238, 0
%240 = extractvalue { i64, i64 } %238, 1
store i64 %239, i64* %9
store i64 %240, i64* %7
br label %241
241: ; preds = %210
%242 = load i64, i64* %8
%243 = load i64*, i64** %3
%244 = getelementptr inbounds i64, i64* %243, i64 4
store i64 %242, i64* %244
store i64 0, i64* %8
br label %245
245: ; preds = %241
%246 = load i64*, i64** %4
%247 = getelementptr inbounds i64, i64* %246, i64 3
%248 = load i64, i64* %247
%249 = load i64*, i64** %4
%250 = getelementptr inbounds i64, i64* %249, i64 2
%251 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %248, i64* elementtype(i64) %250)
%252 = extractvalue { i64, i64 } %251, 0
%253 = extractvalue { i64, i64 } %251, 1
store i64 %252, i64* %5
store i64 %253, i64* %6
%254 = load i64, i64* %6
%255 = load i64, i64* %8
%256 = call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={dx},=r,imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %254, i64 %255)
%257 = extractvalue { i64, i64 } %256, 0
%258 = extractvalue { i64, i64 } %256, 1
store i64 %257, i64* %6
store i64 %258, i64* %8
%259 = load i64, i64* %5
%260 = load i64, i64* %6
%261 = call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={ax},={dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %259, i64 %260)
%262 = extractvalue { i64, i64 } %261, 0
%263 = extractvalue { i64, i64 } %261, 1
store i64 %262, i64* %5
store i64 %263, i64* %6
%264 = load i64, i64* %9
%265 = load i64, i64* %6
%266 = load i64, i64* %5
%267 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %266, i32 0, i64 %264, i64 %265)
%268 = extractvalue { i64, i64 } %267, 0
%269 = extractvalue { i64, i64 } %267, 1
store i64 %268, i64* %9
store i64 %269, i64* %6
%270 = load i64, i64* %7
%271 = load i64, i64* %8
%272 = load i64, i64* %6
%273 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %272, i32 0, i64 %270, i64 %271)
%274 = extractvalue { i64, i64 } %273, 0
%275 = extractvalue { i64, i64 } %273, 1
store i64 %274, i64* %7
store i64 %275, i64* %8
br label %276
276: ; preds = %245
%277 = load i64, i64* %9
%278 = load i64*, i64** %3
%279 = getelementptr inbounds i64, i64* %278, i64 5
store i64 %277, i64* %279
store i64 0, i64* %9
br label %280
280: ; preds = %276
%281 = load i64*, i64** %4
%282 = getelementptr inbounds i64, i64* %281, i64 3
%283 = load i64, i64* %282
%284 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %283)
%285 = extractvalue { i64, i64 } %284, 0
%286 = extractvalue { i64, i64 } %284, 1
store i64 %285, i64* %5
store i64 %286, i64* %6
%287 = load i64, i64* %7
%288 = load i64, i64* %6
%289 = load i64, i64* %5
%290 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %289, i32 0, i64 %287, i64 %288)
%291 = extractvalue { i64, i64 } %290, 0
%292 = extractvalue { i64, i64 } %290, 1
store i64 %291, i64* %7
store i64 %292, i64* %6
%293 = load i64, i64* %8
%294 = load i64, i64* %9
%295 = load i64, i64* %6
%296 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %295, i32 0, i64 %293, i64 %294)
%297 = extractvalue { i64, i64 } %296, 0
%298 = extractvalue { i64, i64 } %296, 1
store i64 %297, i64* %8
store i64 %298, i64* %9
br label %299
299: ; preds = %280
%300 = load i64, i64* %7
%301 = load i64*, i64** %3
%302 = getelementptr inbounds i64, i64* %301, i64 6
store i64 %300, i64* %302
%303 = load i64, i64* %8
%304 = load i64*, i64** %3
%305 = getelementptr inbounds i64, i64* %304, i64 7
store i64 %303, i64* %305
ret void
}

LLVM IR (-O2):
define void @bn_sqr_comba4(i64* nocapture writeonly %0, i64* %1) {
%3 = load i64, i64* %1
%4 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %3)
%5 = extractvalue { i64, i64 } %4, 0
%6 = extractvalue { i64, i64 } %4, 1
%7 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %5, i32 0, i64 0, i64 %6)
%8 = extractvalue { i64, i64 } %7, 0
%9 = extractvalue { i64, i64 } %7, 1
%10 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %9, i32 0, i64 0, i64 0)
%11 = extractvalue { i64, i64 } %10, 0
%12 = extractvalue { i64, i64 } %10, 1
store i64 %8, i64* %0
%13 = getelementptr inbounds i64, i64* %1, i64 1
%14 = load i64, i64* %13
%15 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %14, i64* elementtype(i64) %1)
%16 = extractvalue { i64, i64 } %15, 0
%17 = extractvalue { i64, i64 } %15, 1
%18 = tail call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={dx},=r,imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %17, i64 0)
%19 = extractvalue { i64, i64 } %18, 0
%20 = extractvalue { i64, i64 } %18, 1
%21 = tail call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={ax},={dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %16, i64 %19)
%22 = extractvalue { i64, i64 } %21, 0
%23 = extractvalue { i64, i64 } %21, 1
%24 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %22, i32 0, i64 %11, i64 %23)
%25 = extractvalue { i64, i64 } %24, 0
%26 = extractvalue { i64, i64 } %24, 1
%27 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %26, i32 0, i64 %12, i64 %20)
%28 = extractvalue { i64, i64 } %27, 0
%29 = extractvalue { i64, i64 } %27, 1
%30 = getelementptr inbounds i64, i64* %0, i64 1
store i64 %25, i64* %30
%31 = load i64, i64* %13
%32 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %31)
%33 = extractvalue { i64, i64 } %32, 0
%34 = extractvalue { i64, i64 } %32, 1
%35 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %33, i32 0, i64 %28, i64 %34)
%36 = extractvalue { i64, i64 } %35, 0
%37 = extractvalue { i64, i64 } %35, 1
%38 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %37, i32 0, i64 %29, i64 0)
%39 = extractvalue { i64, i64 } %38, 0
%40 = extractvalue { i64, i64 } %38, 1
%41 = getelementptr inbounds i64, i64* %1, i64 2
%42 = load i64, i64* %41
%43 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %42, i64* elementtype(i64) %1)
%44 = extractvalue { i64, i64 } %43, 0
%45 = extractvalue { i64, i64 } %43, 1
%46 = tail call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={dx},=r,imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %45, i64 %40)
%47 = extractvalue { i64, i64 } %46, 0
%48 = extractvalue { i64, i64 } %46, 1
%49 = tail call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={ax},={dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %44, i64 %47)
%50 = extractvalue { i64, i64 } %49, 0
%51 = extractvalue { i64, i64 } %49, 1
%52 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %50, i32 0, i64 %36, i64 %51)
%53 = extractvalue { i64, i64 } %52, 0
%54 = extractvalue { i64, i64 } %52, 1
%55 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %54, i32 0, i64 %39, i64 %48)
%56 = extractvalue { i64, i64 } %55, 0
%57 = extractvalue { i64, i64 } %55, 1
%58 = getelementptr inbounds i64, i64* %0, i64 2
store i64 %53, i64* %58
%59 = getelementptr inbounds i64, i64* %1, i64 3
%60 = load i64, i64* %59
%61 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %60, i64* elementtype(i64) %1)
%62 = extractvalue { i64, i64 } %61, 0
%63 = extractvalue { i64, i64 } %61, 1
%64 = tail call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={dx},=r,imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %63, i64 0)
%65 = extractvalue { i64, i64 } %64, 0
%66 = extractvalue { i64, i64 } %64, 1
%67 = tail call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={ax},={dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %62, i64 %65)
%68 = extractvalue { i64, i64 } %67, 0
%69 = extractvalue { i64, i64 } %67, 1
%70 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %68, i32 0, i64 %56, i64 %69)
%71 = extractvalue { i64, i64 } %70, 0
%72 = extractvalue { i64, i64 } %70, 1
%73 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %72, i32 0, i64 %57, i64 %66)
%74 = extractvalue { i64, i64 } %73, 0
%75 = extractvalue { i64, i64 } %73, 1
%76 = load i64, i64* %41
%77 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %76, i64* elementtype(i64) %13)
%78 = extractvalue { i64, i64 } %77, 0
%79 = extractvalue { i64, i64 } %77, 1
%80 = tail call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={dx},=r,imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %79, i64 %75)
%81 = extractvalue { i64, i64 } %80, 0
%82 = extractvalue { i64, i64 } %80, 1
%83 = tail call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={ax},={dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %78, i64 %81)
%84 = extractvalue { i64, i64 } %83, 0
%85 = extractvalue { i64, i64 } %83, 1
%86 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %84, i32 0, i64 %71, i64 %85)
%87 = extractvalue { i64, i64 } %86, 0
%88 = extractvalue { i64, i64 } %86, 1
%89 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %88, i32 0, i64 %74, i64 %82)
%90 = extractvalue { i64, i64 } %89, 0
%91 = extractvalue { i64, i64 } %89, 1
%92 = getelementptr inbounds i64, i64* %0, i64 3
store i64 %87, i64* %92
%93 = load i64, i64* %41
%94 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %93)
%95 = extractvalue { i64, i64 } %94, 0
%96 = extractvalue { i64, i64 } %94, 1
%97 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %95, i32 0, i64 %90, i64 %96)
%98 = extractvalue { i64, i64 } %97, 0
%99 = extractvalue { i64, i64 } %97, 1
%100 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %99, i32 0, i64 %91, i64 0)
%101 = extractvalue { i64, i64 } %100, 0
%102 = extractvalue { i64, i64 } %100, 1
%103 = load i64, i64* %59
%104 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %103, i64* elementtype(i64) %13)
%105 = extractvalue { i64, i64 } %104, 0
%106 = extractvalue { i64, i64 } %104, 1
%107 = tail call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={dx},=r,imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %106, i64 %102)
%108 = extractvalue { i64, i64 } %107, 0
%109 = extractvalue { i64, i64 } %107, 1
%110 = tail call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={ax},={dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %105, i64 %108)
%111 = extractvalue { i64, i64 } %110, 0
%112 = extractvalue { i64, i64 } %110, 1
%113 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %111, i32 0, i64 %98, i64 %112)
%114 = extractvalue { i64, i64 } %113, 0
%115 = extractvalue { i64, i64 } %113, 1
%116 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %115, i32 0, i64 %101, i64 %109)
%117 = extractvalue { i64, i64 } %116, 0
%118 = extractvalue { i64, i64 } %116, 1
%119 = getelementptr inbounds i64, i64* %0, i64 4
store i64 %114, i64* %119
%120 = load i64, i64* %59
%121 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %120, i64* elementtype(i64) %41)
%122 = extractvalue { i64, i64 } %121, 0
%123 = extractvalue { i64, i64 } %121, 1
%124 = tail call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={dx},=r,imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %123, i64 0)
%125 = extractvalue { i64, i64 } %124, 0
%126 = extractvalue { i64, i64 } %124, 1
%127 = tail call { i64, i64 } asm "addq $0,$0; adcq $2,$1", "={ax},={dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 0, i64 %122, i64 %125)
%128 = extractvalue { i64, i64 } %127, 0
%129 = extractvalue { i64, i64 } %127, 1
%130 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %128, i32 0, i64 %117, i64 %129)
%131 = extractvalue { i64, i64 } %130, 0
%132 = extractvalue { i64, i64 } %130, 1
%133 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %132, i32 0, i64 %118, i64 %126)
%134 = extractvalue { i64, i64 } %133, 0
%135 = extractvalue { i64, i64 } %133, 1
%136 = getelementptr inbounds i64, i64* %0, i64 5
store i64 %131, i64* %136
%137 = load i64, i64* %59
%138 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(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,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %139, i32 0, i64 %134, i64 %140)
%142 = extractvalue { i64, i64 } %141, 0
%143 = extractvalue { i64, i64 } %141, 1
%144 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %143, i32 0, i64 %135, i64 0)
%145 = extractvalue { i64, i64 } %144, 0
%146 = getelementptr inbounds i64, i64* %0, i64 6
store i64 %142, i64* %146
%147 = getelementptr inbounds i64, i64* %0, i64 7
store i64 %145, i64* %147
ret void
}