void bn_sqr_comba4(unsigned long *r, const unsigned long *a) {
  unsigned long t1, t2;
  unsigned long c1, c2, c3;
  c1 = 0;
  c2 = 0;
  c3 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[0]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+r"(c3) : "d"(t2), "g"(0) : "cc");
  } while (0);
  r[0] = c1;
  c1 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[1]), "m"((a)[0]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[1] = c2;
  c2 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[1]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+r"(c2) : "d"(t2), "g"(0) : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[2]), "m"((a)[0]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[2] = c3;
  c3 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[3]), "m"((a)[0]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[2]), "m"((a)[1]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c1), "+r"(c2), "+r"(c3)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[3] = c1;
  c1 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[2]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c3), "+r"(c1) : "d"(t2), "g"(0) : "cc");
  } while (0);
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[3]), "m"((a)[1]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c2), "+r"(c3), "+r"(c1)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[4] = c2;
  c2 = 0;
  do {
    asm("mulq %3" : "=a"(t1), "=d"(t2) : "a"((a)[3]), "m"((a)[2]) : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
    asm("addq %3,%0; adcq %4,%1; adcq %5,%2"
        : "+r"(c3), "+r"(c1), "+r"(c2)
        : "r"(t1), "r"(t2), "g"(0)
        : "cc");
  } while (0);
  r[5] = c3;
  c3 = 0;
  do {
    asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[3]) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c1), "+d"(t2) : "a"(t1), "g"(0) : "cc");
    asm("addq %2,%0; adcq %3,%1" : "+r"(c2), "+r"(c3) : "d"(t2), "g"(0) : "cc");
  } while (0);
  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    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x8(%rax)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1252 <bn_sqr_comba4+0x152>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x10(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x10(%rbp),%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1341 <bn_sqr_comba4+0x241>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x18(%rax)
movq   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
jmp    1415 <bn_sqr_comba4+0x315>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x10(%rbp),%rcx
add    $0x8,%rcx
mulq   (%rcx)
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x28(%rbp)
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    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdi
add    %rsi,%rdx
adc    %rdi,%rcx
adc    $0x0,%rax
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x28(%rax)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mul    %rax
mov    %rax,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    %rax,%rcx
adc    $0x0,%rdx
mov    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rdx
add    %rdx,%rcx
adc    $0x0,%rax
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
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    %r8d,%r8d
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    %ecx,%ecx
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%rcx
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%rcx
mov    %r9,0x8(%rdi)
mov    0x8(%rsi),%rax
mul    %rax
add    %rax,%r10
adc    $0x0,%rdx
xor    %r9d,%r9d
add    %rdx,%rcx
adc    $0x0,%r9
mov    0x10(%rsi),%rax
mulq   (%rsi)
add    %rax,%r10
adc    %rdx,%rcx
adc    $0x0,%r9
add    %rax,%r10
adc    %rdx,%rcx
adc    $0x0,%r9
mov    %r10,0x10(%rdi)
mov    0x18(%rsi),%rax
mulq   (%rsi)
xor    %r10d,%r10d
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
mov    0x10(%rsi),%rax
mulq   0x8(%rsi)
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
add    %rax,%rcx
adc    %rdx,%r9
adc    $0x0,%r10
mov    %rcx,0x18(%rdi)
mov    0x10(%rsi),%rax
mul    %rax
add    %rax,%r9
adc    $0x0,%rdx
xor    %ecx,%ecx
add    %rdx,%r10
adc    $0x0,%rcx
mov    0x18(%rsi),%rax
mulq   0x8(%rsi)
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%rcx
add    %rax,%r9
adc    %rdx,%r10
adc    $0x0,%rcx
mov    %r9,0x20(%rdi)
mov    0x18(%rsi),%rax
mulq   0x10(%rsi)
xor    %r9d,%r9d
add    %rax,%r10
adc    %rdx,%rcx
adc    $0x0,%r9
add    %rax,%r10
adc    %rdx,%rcx
adc    $0x0,%r9
mov    %r10,0x28(%rdi)
mov    0x18(%rsi),%rax
mul    %rax
add    %rax,%rcx
adc    $0x0,%rdx
add    %rdx,%r9
adc    $0x0,%r8
mov    %rcx,0x30(%rdi)
mov    %r9,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* %8
%43 = load i64, i64* %9
%44 = load i64, i64* %7
%45 = load i64, i64* %5
%46 = load i64, i64* %6
%47 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %45, i64 %46, i32 0, i64 %42, i64 %43, i64 %44)
%48 = extractvalue { i64, i64, i64 } %47, 0
%49 = extractvalue { i64, i64, i64 } %47, 1
%50 = extractvalue { i64, i64, i64 } %47, 2
store i64 %48, i64* %8
store i64 %49, i64* %9
store i64 %50, i64* %7
%51 = load i64, i64* %8
%52 = load i64, i64* %9
%53 = load i64, i64* %7
%54 = load i64, i64* %5
%55 = load i64, i64* %6
%56 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %54, i64 %55, i32 0, i64 %51, i64 %52, i64 %53)
%57 = extractvalue { i64, i64, i64 } %56, 0
%58 = extractvalue { i64, i64, i64 } %56, 1
%59 = extractvalue { i64, i64, i64 } %56, 2
store i64 %57, i64* %8
store i64 %58, i64* %9
store i64 %59, i64* %7
br label %60
60: ; preds = %33
%61 = load i64, i64* %8
%62 = load i64*, i64** %3
%63 = getelementptr inbounds i64, i64* %62, i64 1
store i64 %61, i64* %63
store i64 0, i64* %8
br label %64
64: ; preds = %60
%65 = load i64*, i64** %4
%66 = getelementptr inbounds i64, i64* %65, i64 1
%67 = load i64, i64* %66
%68 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %67)
%69 = extractvalue { i64, i64 } %68, 0
%70 = extractvalue { i64, i64 } %68, 1
store i64 %69, i64* %5
store i64 %70, i64* %6
%71 = load i64, i64* %9
%72 = load i64, i64* %6
%73 = load i64, i64* %5
%74 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %73, i32 0, i64 %71, i64 %72)
%75 = extractvalue { i64, i64 } %74, 0
%76 = extractvalue { i64, i64 } %74, 1
store i64 %75, i64* %9
store i64 %76, i64* %6
%77 = load i64, i64* %7
%78 = load i64, i64* %8
%79 = load i64, i64* %6
%80 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %79, i32 0, i64 %77, i64 %78)
%81 = extractvalue { i64, i64 } %80, 0
%82 = extractvalue { i64, i64 } %80, 1
store i64 %81, i64* %7
store i64 %82, i64* %8
br label %83
83: ; preds = %64
br label %84
84: ; preds = %83
%85 = load i64*, i64** %4
%86 = getelementptr inbounds i64, i64* %85, i64 2
%87 = load i64, i64* %86
%88 = load i64*, i64** %4
%89 = getelementptr inbounds i64, i64* %88, i64 0
%90 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %87, i64* elementtype(i64) %89)
%91 = extractvalue { i64, i64 } %90, 0
%92 = extractvalue { i64, i64 } %90, 1
store i64 %91, i64* %5
store i64 %92, i64* %6
%93 = load i64, i64* %9
%94 = load i64, i64* %7
%95 = load i64, i64* %8
%96 = load i64, i64* %5
%97 = load i64, i64* %6
%98 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %96, i64 %97, i32 0, i64 %93, i64 %94, i64 %95)
%99 = extractvalue { i64, i64, i64 } %98, 0
%100 = extractvalue { i64, i64, i64 } %98, 1
%101 = extractvalue { i64, i64, i64 } %98, 2
store i64 %99, i64* %9
store i64 %100, i64* %7
store i64 %101, i64* %8
%102 = load i64, i64* %9
%103 = load i64, i64* %7
%104 = load i64, i64* %8
%105 = load i64, i64* %5
%106 = load i64, i64* %6
%107 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %105, i64 %106, i32 0, i64 %102, i64 %103, i64 %104)
%108 = extractvalue { i64, i64, i64 } %107, 0
%109 = extractvalue { i64, i64, i64 } %107, 1
%110 = extractvalue { i64, i64, i64 } %107, 2
store i64 %108, i64* %9
store i64 %109, i64* %7
store i64 %110, i64* %8
br label %111
111: ; preds = %84
%112 = load i64, i64* %9
%113 = load i64*, i64** %3
%114 = getelementptr inbounds i64, i64* %113, i64 2
store i64 %112, i64* %114
store i64 0, i64* %9
br label %115
115: ; preds = %111
%116 = load i64*, i64** %4
%117 = getelementptr inbounds i64, i64* %116, i64 3
%118 = load i64, i64* %117
%119 = load i64*, i64** %4
%120 = getelementptr inbounds i64, i64* %119, i64 0
%121 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %118, i64* elementtype(i64) %120)
%122 = extractvalue { i64, i64 } %121, 0
%123 = extractvalue { i64, i64 } %121, 1
store i64 %122, i64* %5
store i64 %123, i64* %6
%124 = load i64, i64* %7
%125 = load i64, i64* %8
%126 = load i64, i64* %9
%127 = load i64, i64* %5
%128 = load i64, i64* %6
%129 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %127, i64 %128, i32 0, i64 %124, i64 %125, i64 %126)
%130 = extractvalue { i64, i64, i64 } %129, 0
%131 = extractvalue { i64, i64, i64 } %129, 1
%132 = extractvalue { i64, i64, i64 } %129, 2
store i64 %130, i64* %7
store i64 %131, i64* %8
store i64 %132, i64* %9
%133 = load i64, i64* %7
%134 = load i64, i64* %8
%135 = load i64, i64* %9
%136 = load i64, i64* %5
%137 = load i64, i64* %6
%138 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %136, i64 %137, i32 0, i64 %133, i64 %134, i64 %135)
%139 = extractvalue { i64, i64, i64 } %138, 0
%140 = extractvalue { i64, i64, i64 } %138, 1
%141 = extractvalue { i64, i64, i64 } %138, 2
store i64 %139, i64* %7
store i64 %140, i64* %8
store i64 %141, i64* %9
br label %142
142: ; preds = %115
br label %143
143: ; preds = %142
%144 = load i64*, i64** %4
%145 = getelementptr inbounds i64, i64* %144, i64 2
%146 = load i64, i64* %145
%147 = load i64*, i64** %4
%148 = getelementptr inbounds i64, i64* %147, i64 1
%149 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %146, i64* elementtype(i64) %148)
%150 = extractvalue { i64, i64 } %149, 0
%151 = extractvalue { i64, i64 } %149, 1
store i64 %150, i64* %5
store i64 %151, i64* %6
%152 = load i64, i64* %7
%153 = load i64, i64* %8
%154 = load i64, i64* %9
%155 = load i64, i64* %5
%156 = load i64, i64* %6
%157 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %155, i64 %156, i32 0, i64 %152, i64 %153, i64 %154)
%158 = extractvalue { i64, i64, i64 } %157, 0
%159 = extractvalue { i64, i64, i64 } %157, 1
%160 = extractvalue { i64, i64, i64 } %157, 2
store i64 %158, i64* %7
store i64 %159, i64* %8
store i64 %160, i64* %9
%161 = load i64, i64* %7
%162 = load i64, i64* %8
%163 = load i64, i64* %9
%164 = load i64, i64* %5
%165 = load i64, i64* %6
%166 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %164, i64 %165, i32 0, i64 %161, i64 %162, i64 %163)
%167 = extractvalue { i64, i64, i64 } %166, 0
%168 = extractvalue { i64, i64, i64 } %166, 1
%169 = extractvalue { i64, i64, i64 } %166, 2
store i64 %167, i64* %7
store i64 %168, i64* %8
store i64 %169, i64* %9
br label %170
170: ; preds = %143
%171 = load i64, i64* %7
%172 = load i64*, i64** %3
%173 = getelementptr inbounds i64, i64* %172, i64 3
store i64 %171, i64* %173
store i64 0, i64* %7
br label %174
174: ; preds = %170
%175 = load i64*, i64** %4
%176 = getelementptr inbounds i64, i64* %175, i64 2
%177 = load i64, i64* %176
%178 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %177)
%179 = extractvalue { i64, i64 } %178, 0
%180 = extractvalue { i64, i64 } %178, 1
store i64 %179, i64* %5
store i64 %180, i64* %6
%181 = load i64, i64* %8
%182 = load i64, i64* %6
%183 = load i64, i64* %5
%184 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %183, i32 0, i64 %181, i64 %182)
%185 = extractvalue { i64, i64 } %184, 0
%186 = extractvalue { i64, i64 } %184, 1
store i64 %185, i64* %8
store i64 %186, i64* %6
%187 = load i64, i64* %9
%188 = load i64, i64* %7
%189 = load i64, i64* %6
%190 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %189, i32 0, i64 %187, i64 %188)
%191 = extractvalue { i64, i64 } %190, 0
%192 = extractvalue { i64, i64 } %190, 1
store i64 %191, i64* %9
store i64 %192, i64* %7
br label %193
193: ; preds = %174
br label %194
194: ; preds = %193
%195 = load i64*, i64** %4
%196 = getelementptr inbounds i64, i64* %195, i64 3
%197 = load i64, i64* %196
%198 = load i64*, i64** %4
%199 = getelementptr inbounds i64, i64* %198, i64 1
%200 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %197, i64* elementtype(i64) %199)
%201 = extractvalue { i64, i64 } %200, 0
%202 = extractvalue { i64, i64 } %200, 1
store i64 %201, i64* %5
store i64 %202, i64* %6
%203 = load i64, i64* %8
%204 = load i64, i64* %9
%205 = load i64, i64* %7
%206 = load i64, i64* %5
%207 = load i64, i64* %6
%208 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %206, i64 %207, i32 0, i64 %203, i64 %204, i64 %205)
%209 = extractvalue { i64, i64, i64 } %208, 0
%210 = extractvalue { i64, i64, i64 } %208, 1
%211 = extractvalue { i64, i64, i64 } %208, 2
store i64 %209, i64* %8
store i64 %210, i64* %9
store i64 %211, i64* %7
%212 = load i64, i64* %8
%213 = load i64, i64* %9
%214 = load i64, i64* %7
%215 = load i64, i64* %5
%216 = load i64, i64* %6
%217 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %215, i64 %216, i32 0, i64 %212, i64 %213, i64 %214)
%218 = extractvalue { i64, i64, i64 } %217, 0
%219 = extractvalue { i64, i64, i64 } %217, 1
%220 = extractvalue { i64, i64, i64 } %217, 2
store i64 %218, i64* %8
store i64 %219, i64* %9
store i64 %220, i64* %7
br label %221
221: ; preds = %194
%222 = load i64, i64* %8
%223 = load i64*, i64** %3
%224 = getelementptr inbounds i64, i64* %223, i64 4
store i64 %222, i64* %224
store i64 0, i64* %8
br label %225
225: ; preds = %221
%226 = load i64*, i64** %4
%227 = getelementptr inbounds i64, i64* %226, i64 3
%228 = load i64, i64* %227
%229 = load i64*, i64** %4
%230 = getelementptr inbounds i64, i64* %229, i64 2
%231 = call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %228, i64* elementtype(i64) %230)
%232 = extractvalue { i64, i64 } %231, 0
%233 = extractvalue { i64, i64 } %231, 1
store i64 %232, i64* %5
store i64 %233, i64* %6
%234 = load i64, i64* %9
%235 = load i64, i64* %7
%236 = load i64, i64* %8
%237 = load i64, i64* %5
%238 = load i64, i64* %6
%239 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %237, i64 %238, i32 0, i64 %234, i64 %235, i64 %236)
%240 = extractvalue { i64, i64, i64 } %239, 0
%241 = extractvalue { i64, i64, i64 } %239, 1
%242 = extractvalue { i64, i64, i64 } %239, 2
store i64 %240, i64* %9
store i64 %241, i64* %7
store i64 %242, i64* %8
%243 = load i64, i64* %9
%244 = load i64, i64* %7
%245 = load i64, i64* %8
%246 = load i64, i64* %5
%247 = load i64, i64* %6
%248 = call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %246, i64 %247, i32 0, i64 %243, i64 %244, i64 %245)
%249 = extractvalue { i64, i64, i64 } %248, 0
%250 = extractvalue { i64, i64, i64 } %248, 1
%251 = extractvalue { i64, i64, i64 } %248, 2
store i64 %249, i64* %9
store i64 %250, i64* %7
store i64 %251, i64* %8
br label %252
252: ; preds = %225
%253 = load i64, i64* %9
%254 = load i64*, i64** %3
%255 = getelementptr inbounds i64, i64* %254, i64 5
store i64 %253, i64* %255
store i64 0, i64* %9
br label %256
256: ; preds = %252
%257 = load i64*, i64** %4
%258 = getelementptr inbounds i64, i64* %257, i64 3
%259 = load i64, i64* %258
%260 = call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %259)
%261 = extractvalue { i64, i64 } %260, 0
%262 = extractvalue { i64, i64 } %260, 1
store i64 %261, i64* %5
store i64 %262, i64* %6
%263 = load i64, i64* %7
%264 = load i64, i64* %6
%265 = load i64, i64* %5
%266 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %265, i32 0, i64 %263, i64 %264)
%267 = extractvalue { i64, i64 } %266, 0
%268 = extractvalue { i64, i64 } %266, 1
store i64 %267, i64* %7
store i64 %268, i64* %6
%269 = load i64, i64* %8
%270 = load i64, i64* %9
%271 = load i64, i64* %6
%272 = call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %271, i32 0, i64 %269, i64 %270)
%273 = extractvalue { i64, i64 } %272, 0
%274 = extractvalue { i64, i64 } %272, 1
store i64 %273, i64* %8
store i64 %274, i64* %9
br label %275
275: ; preds = %256
%276 = load i64, i64* %7
%277 = load i64*, i64** %3
%278 = getelementptr inbounds i64, i64* %277, i64 6
store i64 %276, i64* %278
%279 = load i64, i64* %8
%280 = load i64*, i64** %3
%281 = getelementptr inbounds i64, i64* %280, i64 7
store i64 %279, i64* %281
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, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %16, i64 %17, i32 0, i64 %11, i64 %12, i64 0)
%19 = extractvalue { i64, i64, i64 } %18, 0
%20 = extractvalue { i64, i64, i64 } %18, 1
%21 = extractvalue { i64, i64, i64 } %18, 2
%22 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %16, i64 %17, i32 0, i64 %19, i64 %20, i64 %21)
%23 = extractvalue { i64, i64, i64 } %22, 0
%24 = extractvalue { i64, i64, i64 } %22, 1
%25 = extractvalue { i64, i64, i64 } %22, 2
%26 = getelementptr inbounds i64, i64* %0, i64 1
store i64 %23, i64* %26
%27 = load i64, i64* %13
%28 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %27)
%29 = extractvalue { i64, i64 } %28, 0
%30 = extractvalue { i64, i64 } %28, 1
%31 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %29, i32 0, i64 %24, i64 %30)
%32 = extractvalue { i64, i64 } %31, 0
%33 = extractvalue { i64, i64 } %31, 1
%34 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %33, i32 0, i64 %25, i64 0)
%35 = extractvalue { i64, i64 } %34, 0
%36 = extractvalue { i64, i64 } %34, 1
%37 = getelementptr inbounds i64, i64* %1, i64 2
%38 = load i64, i64* %37
%39 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %38, i64* elementtype(i64) %1)
%40 = extractvalue { i64, i64 } %39, 0
%41 = extractvalue { i64, i64 } %39, 1
%42 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %40, i64 %41, i32 0, i64 %32, i64 %35, i64 %36)
%43 = extractvalue { i64, i64, i64 } %42, 0
%44 = extractvalue { i64, i64, i64 } %42, 1
%45 = extractvalue { i64, i64, i64 } %42, 2
%46 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %40, i64 %41, i32 0, i64 %43, i64 %44, i64 %45)
%47 = extractvalue { i64, i64, i64 } %46, 0
%48 = extractvalue { i64, i64, i64 } %46, 1
%49 = extractvalue { i64, i64, i64 } %46, 2
%50 = getelementptr inbounds i64, i64* %0, i64 2
store i64 %47, i64* %50
%51 = getelementptr inbounds i64, i64* %1, i64 3
%52 = load i64, i64* %51
%53 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %52, i64* elementtype(i64) %1)
%54 = extractvalue { i64, i64 } %53, 0
%55 = extractvalue { i64, i64 } %53, 1
%56 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %54, i64 %55, i32 0, i64 %48, i64 %49, i64 0)
%57 = extractvalue { i64, i64, i64 } %56, 0
%58 = extractvalue { i64, i64, i64 } %56, 1
%59 = extractvalue { i64, i64, i64 } %56, 2
%60 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %54, i64 %55, i32 0, i64 %57, i64 %58, i64 %59)
%61 = extractvalue { i64, i64, i64 } %60, 0
%62 = extractvalue { i64, i64, i64 } %60, 1
%63 = extractvalue { i64, i64, i64 } %60, 2
%64 = load i64, i64* %37
%65 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %64, i64* elementtype(i64) %13)
%66 = extractvalue { i64, i64 } %65, 0
%67 = extractvalue { i64, i64 } %65, 1
%68 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %66, i64 %67, i32 0, i64 %61, i64 %62, i64 %63)
%69 = extractvalue { i64, i64, i64 } %68, 0
%70 = extractvalue { i64, i64, i64 } %68, 1
%71 = extractvalue { i64, i64, i64 } %68, 2
%72 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %66, i64 %67, i32 0, i64 %69, i64 %70, i64 %71)
%73 = extractvalue { i64, i64, i64 } %72, 0
%74 = extractvalue { i64, i64, i64 } %72, 1
%75 = extractvalue { i64, i64, i64 } %72, 2
%76 = getelementptr inbounds i64, i64* %0, i64 3
store i64 %73, i64* %76
%77 = load i64, i64* %37
%78 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %77)
%79 = extractvalue { i64, i64 } %78, 0
%80 = extractvalue { i64, i64 } %78, 1
%81 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,={dx},{ax},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %79, i32 0, i64 %74, i64 %80)
%82 = extractvalue { i64, i64 } %81, 0
%83 = extractvalue { i64, i64 } %81, 1
%84 = tail call { i64, i64 } asm "addq $2,$0; adcq $3,$1", "=r,=r,{dx},imr,0,1,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %83, i32 0, i64 %75, i64 0)
%85 = extractvalue { i64, i64 } %84, 0
%86 = extractvalue { i64, i64 } %84, 1
%87 = load i64, i64* %51
%88 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %87, i64* elementtype(i64) %13)
%89 = extractvalue { i64, i64 } %88, 0
%90 = extractvalue { i64, i64 } %88, 1
%91 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %89, i64 %90, i32 0, i64 %82, i64 %85, i64 %86)
%92 = extractvalue { i64, i64, i64 } %91, 0
%93 = extractvalue { i64, i64, i64 } %91, 1
%94 = extractvalue { i64, i64, i64 } %91, 2
%95 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %89, i64 %90, i32 0, i64 %92, i64 %93, i64 %94)
%96 = extractvalue { i64, i64, i64 } %95, 0
%97 = extractvalue { i64, i64, i64 } %95, 1
%98 = extractvalue { i64, i64, i64 } %95, 2
%99 = getelementptr inbounds i64, i64* %0, i64 4
store i64 %96, i64* %99
%100 = load i64, i64* %51
%101 = tail call { i64, i64 } asm "mulq $3", "={ax},={dx},{ax},*m,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %100, i64* elementtype(i64) %37)
%102 = extractvalue { i64, i64 } %101, 0
%103 = extractvalue { i64, i64 } %101, 1
%104 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %102, i64 %103, i32 0, i64 %97, i64 %98, i64 0)
%105 = extractvalue { i64, i64, i64 } %104, 0
%106 = extractvalue { i64, i64, i64 } %104, 1
%107 = extractvalue { i64, i64, i64 } %104, 2
%108 = tail call { i64, i64, i64 } asm "addq $3,$0; adcq $4,$1; adcq $5,$2", "=r,=r,=r,r,r,imr,0,1,2,~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %102, i64 %103, i32 0, i64 %105, i64 %106, i64 %107)
%109 = extractvalue { i64, i64, i64 } %108, 0
%110 = extractvalue { i64, i64, i64 } %108, 1
%111 = extractvalue { i64, i64, i64 } %108, 2
%112 = getelementptr inbounds i64, i64* %0, i64 5
store i64 %109, i64* %112
%113 = load i64, i64* %51
%114 = tail call { i64, i64 } asm "mulq $2", "={ax},={dx},{ax},~{cc},~{dirflag},~{fpsr},~{flags}"(i64 %113)
%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 = getelementptr inbounds i64, i64* %0, i64 6
store i64 %118, i64* %122
%123 = getelementptr inbounds i64, i64* %0, i64 7
store i64 %121, i64* %123
ret void
}