#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int atoi(char *);
int /*<<< orphan*/ printf(char *, ...);
int main(int argc, char **argv) {
  int x, y, z, N, f;
  N = atoi(argv[1]);
  printf("#ifdef TFM_SQR%d\n"
         "void fp_sqr_comba%d(fp_int *A, fp_int *B)\n"
         "{\n"
         "   fp_digit *a, b[%d], c0, c1, c2, sc0, sc1, sc2;\n"
         "\n"
         "   a = A->dp;\n"
         "   COMBA_START; \n"
         "\n"
         "   /* clear carries */\n"
         "   CLEAR_CARRY;\n"
         "\n"
         "   /* output 0 */\n"
         "   SQRADD(a[0],a[0]);\n"
         "   COMBA_STORE(b[0]);\n",
         N, N, N + N);
  for (x = 1; x < N + N - 1; x++) {
    printf("\n   /* output %d */\n"
           "   CARRY_FORWARD;\n   ",
           x);
    for (f = y = 0; y < N; y++) {
      for (z = 0; z < N; z++) {
        if (z != y && z + y == x && y <= z) {
          ++f;
        }
      }
    }
    if (f <= 2) {
      for (y = 0; y < N; y++) {
        for (z = 0; z < N; z++) {
          if (y <= z && (y + z) == x) {
            if (y == z) {
              printf("SQRADD(a[%d], a[%d]); ", y, y);
            } else {
              printf("SQRADD2(a[%d], a[%d]); ", y, z);
            }
          }
        }
      }
    } else {
      f = 0;
      for (y = 0; y < N; y++) {
        for (z = 0; z < N; z++) {
          if (z != y && z + y == x && y <= z) {
            if (f == 0) {
              printf("SQRADDSC(a[%d], a[%d]); ", y, z);
              f = 1;
            } else {
              printf("SQRADDAC(a[%d], a[%d]); ", y, z);
            }
          }
        }
      }
      printf("SQRADDDB; ");
      if ((x & 1) == 0) {
        printf("SQRADD(a[%d], a[%d]); ", x / 2, x / 2);
      }
    }
    printf("\n   COMBA_STORE(b[%d]);\n", x);
  }
  printf("   COMBA_STORE2(b[%d]);\n", N + N - 1);
  printf("   COMBA_FINI;\n"
         "\n"
         "   B->used = %d;\n"
         "   B->sign = FP_ZPOS;\n"
         "   memcpy(B->dp, b, %d * sizeof(fp_digit));\n"
         "   fp_clamp(B);\n"
         "}\n#endif\n\n\n",
         N + N, N + N);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1040 <atoi@plt>
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x20(%rbp),%ecx
add    -0x20(%rbp),%ecx
lea    0xea7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13e9 <main+0x2c9>
mov    -0x14(%rbp),%esi
lea    0xf72(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    120f <main+0xef>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11fc <main+0xdc>
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     11e9 <main+0xc9>
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    11e9 <main+0xc9>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     11e9 <main+0xc9>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ee <main+0xce>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11ad <main+0x8d>
jmp    1201 <main+0xe1>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    119a <main+0x7a>
cmpl   $0x2,-0x24(%rbp)
jg     12c3 <main+0x1a3>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12be <main+0x19e>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12ab <main+0x18b>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1298 <main+0x178>
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    1298 <main+0x178>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    127f <main+0x15f>
mov    -0x18(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xeae(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1293 <main+0x173>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    0xeac(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1298 <main+0x178>
jmp    129d <main+0x17d>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1233 <main+0x113>
jmp    12b0 <main+0x190>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1220 <main+0x100>
jmp    13ca <main+0x2aa>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1380 <main+0x260>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    136d <main+0x24d>
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     135a <main+0x23a>
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    135a <main+0x23a>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     135a <main+0x23a>
cmpl   $0x0,-0x24(%rbp)
jne    1341 <main+0x221>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    0xe22(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x24(%rbp)
jmp    1355 <main+0x235>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    0xe1b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    135a <main+0x23a>
jmp    135f <main+0x23f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12e4 <main+0x1c4>
jmp    1372 <main+0x252>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12d1 <main+0x1b1>
lea    0xdfb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    13c5 <main+0x2a5>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
lea    0xd63(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    13ca <main+0x2aa>
mov    -0x14(%rbp),%esi
lea    0xdb9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1167 <main+0x47>
mov    -0x20(%rbp),%esi
add    -0x20(%rbp),%esi
sub    $0x1,%esi
lea    0xdad(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x20(%rbp),%esi
add    -0x20(%rbp),%esi
mov    -0x20(%rbp),%edx
add    -0x20(%rbp),%edx
lea    0xdac(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    0x8(%rsi),%rdi
call   1040 <atoi@plt>
mov    %eax,%r13d
lea    0x0(%r13,%r13,1),%ecx
lea    0xefa(%rip),%rdi
mov    %eax,%esi
mov    %eax,%edx
mov    %ecx,0xc(%rsp)
xor    %eax,%eax
call   1030 <printf@plt>
lea    -0x1(%r13,%r13,1),%eax
mov    %eax,0x8(%rsp)
cmp    $0x2,%r13d
jl     1444 <main+0x324>
mov    0x8(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%ecx
cmovge %eax,%ecx
mov    %ecx,0x14(%rsp)
mov    %r13d,%r12d
and    $0xfffffff8,%r12d
mov    $0x1,%ebx
lea    0x1002(%rip),%r15
lea    0x1014(%rip),%r14
mov    %r12d,0x10(%rsp)
jmp    11c6 <main+0xa6>
nopl   0x0(%rax)
lea    0x1026(%rip),%rdi
mov    0x4(%rsp),%ebx
mov    %ebx,%esi
xor    %eax,%eax
call   1030 <printf@plt>
add    $0x1,%ebx
cmp    0x14(%rsp),%ebx
mov    0x10(%rsp),%r12d
je     1444 <main+0x324>
lea    0xf6a(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1030 <printf@plt>
movd   %ebx,%xmm0
pshufd $0x0,%xmm0,%xmm8
mov    %ebx,0x4(%rsp)
mov    %ebx,%edi
xor    %edx,%edx
xor    %ebp,%ebp
jmp    11ff <main+0xdf>
nopl   0x0(%rax)
add    $0x1,%ebp
add    $0xffffffff,%edi
cmp    %r13d,%ebp
je     1350 <main+0x230>
xor    %esi,%esi
cmp    $0x8,%r13d
jb     1320 <main+0x200>
movd   %edx,%xmm1
movd   %ebp,%xmm2
pshufd $0x0,%xmm2,%xmm9
pxor   %xmm2,%xmm2
mov    %r12d,%edx
movdqa 0xdd7(%rip),%xmm11
movdqa 0xdde(%rip),%xmm12
pcmpeqd %xmm13,%xmm13
movdqa 0xde0(%rip),%xmm14
movdqa 0xde7(%rip),%xmm15
nopl   0x0(%rax)
movdqa %xmm11,%xmm7
paddd  %xmm12,%xmm7
movdqa %xmm11,%xmm0
pcmpeqd %xmm9,%xmm0
movdqa %xmm7,%xmm10
pcmpeqd %xmm9,%xmm10
movdqa %xmm11,%xmm4
paddd  %xmm9,%xmm4
movdqa %xmm7,%xmm5
paddd  %xmm9,%xmm5
pcmpeqd %xmm8,%xmm4
pxor   %xmm13,%xmm4
por    %xmm0,%xmm4
pcmpeqd %xmm8,%xmm5
pxor   %xmm13,%xmm5
movdqa %xmm11,%xmm0
pxor   %xmm14,%xmm0
movdqa %xmm9,%xmm6
pxor   %xmm14,%xmm6
movdqa %xmm6,%xmm3
pcmpgtd %xmm0,%xmm3
por    %xmm4,%xmm3
paddd  %xmm3,%xmm1
pxor   %xmm14,%xmm7
pcmpgtd %xmm7,%xmm6
por    %xmm10,%xmm6
por    %xmm5,%xmm6
paddd  %xmm6,%xmm2
psubd  %xmm13,%xmm1
psubd  %xmm13,%xmm2
paddd  %xmm15,%xmm11
add    $0xfffffff8,%edx
jne    1250 <main+0x130>
paddd  %xmm1,%xmm2
pshufd $0xee,%xmm2,%xmm0
paddd  %xmm2,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
mov    %r12d,%esi
cmp    %r12d,%r13d
je     11f0 <main+0xd0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %esi,%edi
sete   %bl
cmp    %esi,%ebp
setne  %al
setbe  %cl
and    %bl,%al
and    %cl,%al
movzbl %al,%eax
add    %eax,%edx
add    $0x1,%esi
cmp    %esi,%r13d
jne    1320 <main+0x200>
jmp    11f0 <main+0xd0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x3,%edx
jge    13c0 <main+0x2a0>
xor    %ebp,%ebp
mov    0x4(%rsp),%r12d
jmp    1370 <main+0x250>
xchg   %ax,%ax
add    $0x1,%ebp
add    $0xffffffff,%r12d
cmp    %r13d,%ebp
je     11a0 <main+0x80>
xor    %ebx,%ebx
jmp    139a <main+0x27a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0xdf1(%rip),%rdi
mov    %ebp,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1030 <printf@plt>
add    $0x1,%ebx
cmp    %ebx,%r13d
je     1360 <main+0x240>
cmp    %ebx,%ebp
ja     1392 <main+0x272>
cmp    %ebx,%r12d
jne    1392 <main+0x272>
cmp    %ebx,%ebp
jne    1380 <main+0x260>
lea    0xdb3(%rip),%rdi
mov    %ebp,%esi
mov    %ebp,%edx
jmp    138b <main+0x26b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %eax,%eax
mov    0x4(%rsp),%ebx
xor    %r12d,%r12d
jmp    13dc <main+0x2bc>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12d
add    $0xffffffff,%ebx
cmp    %r13d,%r12d
je     1410 <main+0x2f0>
xor    %ebp,%ebp
jmp    13e8 <main+0x2c8>
add    $0x1,%ebp
cmp    %ebp,%r13d
je     13d0 <main+0x2b0>
cmp    %ebp,%r12d
ja     13e0 <main+0x2c0>
je     13e0 <main+0x2c0>
cmp    %ebp,%ebx
jne    13e0 <main+0x2c0>
test   %eax,%eax
mov    %r14,%rdi
cmove  %r15,%rdi
mov    %r12d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1030 <printf@plt>
mov    $0x1,%eax
jmp    13e0 <main+0x2c0>
nop
lea    0xdab(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
testb  $0x1,0x4(%rsp)
jne    11a0 <main+0x80>
mov    0x4(%rsp),%edx
shr    %edx
lea    0xd2b(%rip),%rdi
mov    %edx,%esi
xor    %eax,%eax
call   1030 <printf@plt>
jmp    11a0 <main+0x80>
lea    0xd9b(%rip),%rdi
mov    0x8(%rsp),%esi
xor    %eax,%eax
call   1030 <printf@plt>
lea    0xda2(%rip),%rdi
mov    0xc(%rsp),%edx
mov    %edx,%esi
xor    %eax,%eax
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [247 x i8] c"#ifdef TFM_SQR%d\0Avoid fp_sqr_comba%d(fp_int *A, fp_int *B)\0A{\0A fp_digit *a, b[%d], c0, c1, c2, sc0, sc1, sc2;\0A\0A a = A->dp;\0A COMBA_START; \0A\0A /* clear carries */\0A CLEAR_CARRY;\0A\0A /* output 0 */\0A SQRADD(a[0],a[0]);\0A COMBA_STORE(b[0]);\0A\00"
@.str.1 = [42 x i8] c"\0A /* output %d */\0A CARRY_FORWARD;\0A \00"
@.str.2 = [23 x i8] c"SQRADD(a[%d], a[%d]); \00"
@.str.3 = [24 x i8] c"SQRADD2(a[%d], a[%d]); \00"
@.str.4 = [25 x i8] c"SQRADDSC(a[%d], a[%d]); \00"
@.str.5 = [25 x i8] c"SQRADDAC(a[%d], a[%d]); \00"
@.str.6 = [11 x i8] c"SQRADDDB; \00"
@.str.7 = [25 x i8] c"\0A COMBA_STORE(b[%d]);\0A\00"
@.str.8 = [25 x i8] c" COMBA_STORE2(b[%d]);\0A\00"
@.str.9 = [127 x i8] c" COMBA_FINI;\0A\0A B->used = %d;\0A B->sign = FP_ZPOS;\0A memcpy(B->dp, b, %d * sizeof(fp_digit));\0A fp_clamp(B);\0A}\0A#endif\0A\0A\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%11 = load i8**, i8*** %5
%12 = getelementptr inbounds i8*, i8** %11, i64 1
%13 = load i8*, i8** %12
%14 = call i32 @atoi(i8* %13)
store i32 %14, i32* %9
%15 = load i32, i32* %9
%16 = load i32, i32* %9
%17 = load i32, i32* %9
%18 = load i32, i32* %9
%19 = add nsw i32 %17, %18
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([247 x i8], [247 x i8]* @.str, i64 0, i64 0), i32 %15, i32 %16, i32 %19)
store i32 1, i32* %6
br label %21
21: ; preds = %169, %2
%22 = load i32, i32* %6
%23 = load i32, i32* %9
%24 = load i32, i32* %9
%25 = add nsw i32 %23, %24
%26 = sub nsw i32 %25, 1
%27 = icmp slt i32 %22, %26
br i1 %27, label %28, label %172
28: ; preds = %21
%29 = load i32, i32* %6
%30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.1, i64 0, i64 0), i32 %29)
store i32 0, i32* %7
store i32 0, i32* %10
br label %31
31: ; preds = %62, %28
%32 = load i32, i32* %7
%33 = load i32, i32* %9
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %65
35: ; preds = %31
store i32 0, i32* %8
br label %36
36: ; preds = %58, %35
%37 = load i32, i32* %8
%38 = load i32, i32* %9
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %61
40: ; preds = %36
%41 = load i32, i32* %8
%42 = load i32, i32* %7
%43 = icmp ne i32 %41, %42
br i1 %43, label %44, label %57
44: ; preds = %40
%45 = load i32, i32* %8
%46 = load i32, i32* %7
%47 = add nsw i32 %45, %46
%48 = load i32, i32* %6
%49 = icmp eq i32 %47, %48
br i1 %49, label %50, label %57
50: ; preds = %44
%51 = load i32, i32* %7
%52 = load i32, i32* %8
%53 = icmp sle i32 %51, %52
br i1 %53, label %54, label %57
54: ; preds = %50
%55 = load i32, i32* %10
%56 = add nsw i32 %55, 1
store i32 %56, i32* %10
br label %57
57: ; preds = %54, %50, %44, %40
br label %58
58: ; preds = %57
%59 = load i32, i32* %8
%60 = add nsw i32 %59, 1
store i32 %60, i32* %8
br label %36
61: ; preds = %36
br label %62
62: ; preds = %61
%63 = load i32, i32* %7
%64 = add nsw i32 %63, 1
store i32 %64, i32* %7
br label %31
65: ; preds = %31
%66 = load i32, i32* %10
%67 = icmp sle i32 %66, 2
br i1 %67, label %68, label %110
68: ; preds = %65
store i32 0, i32* %7
br label %69
69: ; preds = %106, %68
%70 = load i32, i32* %7
%71 = load i32, i32* %9
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %109
73: ; preds = %69
store i32 0, i32* %8
br label %74
74: ; preds = %102, %73
%75 = load i32, i32* %8
%76 = load i32, i32* %9
%77 = icmp slt i32 %75, %76
br i1 %77, label %78, label %105
78: ; preds = %74
%79 = load i32, i32* %7
%80 = load i32, i32* %8
%81 = icmp sle i32 %79, %80
br i1 %81, label %82, label %101
82: ; preds = %78
%83 = load i32, i32* %7
%84 = load i32, i32* %8
%85 = add nsw i32 %83, %84
%86 = load i32, i32* %6
%87 = icmp eq i32 %85, %86
br i1 %87, label %88, label %101
88: ; preds = %82
%89 = load i32, i32* %7
%90 = load i32, i32* %8
%91 = icmp eq i32 %89, %90
br i1 %91, label %92, label %96
92: ; preds = %88
%93 = load i32, i32* %7
%94 = load i32, i32* %7
%95 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.2, i64 0, i64 0), i32 %93, i32 %94)
br label %100
96: ; preds = %88
%97 = load i32, i32* %7
%98 = load i32, i32* %8
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), i32 %97, i32 %98)
br label %100
100: ; preds = %96, %92
br label %101
101: ; preds = %100, %82, %78
br label %102
102: ; preds = %101
%103 = load i32, i32* %8
%104 = add nsw i32 %103, 1
store i32 %104, i32* %8
br label %74
105: ; preds = %74
br label %106
106: ; preds = %105
%107 = load i32, i32* %7
%108 = add nsw i32 %107, 1
store i32 %108, i32* %7
br label %69
109: ; preds = %69
br label %166
110: ; preds = %65
store i32 0, i32* %10
store i32 0, i32* %7
br label %111
111: ; preds = %151, %110
%112 = load i32, i32* %7
%113 = load i32, i32* %9
%114 = icmp slt i32 %112, %113
br i1 %114, label %115, label %154
115: ; preds = %111
store i32 0, i32* %8
br label %116
116: ; preds = %147, %115
%117 = load i32, i32* %8
%118 = load i32, i32* %9
%119 = icmp slt i32 %117, %118
br i1 %119, label %120, label %150
120: ; preds = %116
%121 = load i32, i32* %8
%122 = load i32, i32* %7
%123 = icmp ne i32 %121, %122
br i1 %123, label %124, label %146
124: ; preds = %120
%125 = load i32, i32* %8
%126 = load i32, i32* %7
%127 = add nsw i32 %125, %126
%128 = load i32, i32* %6
%129 = icmp eq i32 %127, %128
br i1 %129, label %130, label %146
130: ; preds = %124
%131 = load i32, i32* %7
%132 = load i32, i32* %8
%133 = icmp sle i32 %131, %132
br i1 %133, label %134, label %146
134: ; preds = %130
%135 = load i32, i32* %10
%136 = icmp eq i32 %135, 0
br i1 %136, label %137, label %141
137: ; preds = %134
%138 = load i32, i32* %7
%139 = load i32, i32* %8
%140 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.4, i64 0, i64 0), i32 %138, i32 %139)
store i32 1, i32* %10
br label %145
141: ; preds = %134
%142 = load i32, i32* %7
%143 = load i32, i32* %8
%144 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.5, i64 0, i64 0), i32 %142, i32 %143)
br label %145
145: ; preds = %141, %137
br label %146
146: ; preds = %145, %130, %124, %120
br label %147
147: ; preds = %146
%148 = load i32, i32* %8
%149 = add nsw i32 %148, 1
store i32 %149, i32* %8
br label %116
150: ; preds = %116
br label %151
151: ; preds = %150
%152 = load i32, i32* %7
%153 = add nsw i32 %152, 1
store i32 %153, i32* %7
br label %111
154: ; preds = %111
%155 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i64 0, i64 0))
%156 = load i32, i32* %6
%157 = and i32 %156, 1
%158 = icmp eq i32 %157, 0
br i1 %158, label %159, label %165
159: ; preds = %154
%160 = load i32, i32* %6
%161 = sdiv i32 %160, 2
%162 = load i32, i32* %6
%163 = sdiv i32 %162, 2
%164 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.2, i64 0, i64 0), i32 %161, i32 %163)
br label %165
165: ; preds = %159, %154
br label %166
166: ; preds = %165, %109
%167 = load i32, i32* %6
%168 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.7, i64 0, i64 0), i32 %167)
br label %169
169: ; preds = %166
%170 = load i32, i32* %6
%171 = add nsw i32 %170, 1
store i32 %171, i32* %6
br label %21
172: ; preds = %21
%173 = load i32, i32* %9
%174 = load i32, i32* %9
%175 = add nsw i32 %173, %174
%176 = sub nsw i32 %175, 1
%177 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.8, i64 0, i64 0), i32 %176)
%178 = load i32, i32* %9
%179 = load i32, i32* %9
%180 = add nsw i32 %178, %179
%181 = load i32, i32* %9
%182 = load i32, i32* %9
%183 = add nsw i32 %181, %182
%184 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([127 x i8], [127 x i8]* @.str.9, i64 0, i64 0), i32 %180, i32 %183)
ret i32 0
}

LLVM IR (-O2):
@.str = [247 x i8] c"#ifdef TFM_SQR%d\0Avoid fp_sqr_comba%d(fp_int *A, fp_int *B)\0A{\0A fp_digit *a, b[%d], c0, c1, c2, sc0, sc1, sc2;\0A\0A a = A->dp;\0A COMBA_START; \0A\0A /* clear carries */\0A CLEAR_CARRY;\0A\0A /* output 0 */\0A SQRADD(a[0],a[0]);\0A COMBA_STORE(b[0]);\0A\00"
@.str.1 = [42 x i8] c"\0A /* output %d */\0A CARRY_FORWARD;\0A \00"
@.str.2 = [23 x i8] c"SQRADD(a[%d], a[%d]); \00"
@.str.3 = [24 x i8] c"SQRADD2(a[%d], a[%d]); \00"
@.str.4 = [25 x i8] c"SQRADDSC(a[%d], a[%d]); \00"
@.str.5 = [25 x i8] c"SQRADDAC(a[%d], a[%d]); \00"
@.str.6 = [11 x i8] c"SQRADDDB; \00"
@.str.7 = [25 x i8] c"\0A COMBA_STORE(b[%d]);\0A\00"
@.str.8 = [25 x i8] c" COMBA_STORE2(b[%d]);\0A\00"
@.str.9 = [127 x i8] c" COMBA_FINI;\0A\0A B->used = %d;\0A B->sign = FP_ZPOS;\0A memcpy(B->dp, b, %d * sizeof(fp_digit));\0A fp_clamp(B);\0A}\0A#endif\0A\0A\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = getelementptr inbounds i8*, i8** %1, i64 1
%4 = load i8*, i8** %3
%5 = tail call i32 @atoi(i8* %4)
%6 = shl nsw i32 %5, 1
%7 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([247 x i8], [247 x i8]* @.str, i64 0, i64 0), i32 %5, i32 %5, i32 %6)
%8 = add i32 %6, -1
%9 = icmp sgt i32 %5, 1
br i1 %9, label %10, label %138
10: ; preds = %2
%11 = call i32 @llvm.smax.i32(i32 %8, i32 2)
%12 = icmp ult i32 %5, 8
%13 = and i32 %5, -8
%14 = icmp eq i32 %5, %13
br label %15
15: ; preds = %134, %10
%16 = phi i32 [ 1, %10 ], [ %136, %134 ]
%17 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.1, i64 0, i64 0), i32 %16)
%18 = insertelement <4 x i32> poison, i32 %16, i64 0
%19 = shufflevector <4 x i32> %18, <4 x i32> poison, <4 x i32> zeroinitializer
%20 = insertelement <4 x i32> poison, i32 %16, i64 0
%21 = shufflevector <4 x i32> %20, <4 x i32> poison, <4 x i32> zeroinitializer
br label %22
22: ; preds = %78, %15
%23 = phi i32 [ %79, %78 ], [ 0, %15 ]
%24 = phi i32 [ %80, %78 ], [ 0, %15 ]
br i1 %12, label %61, label %25
25: ; preds = %22
%26 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %23, i64 0
%27 = insertelement <4 x i32> poison, i32 %24, i64 0
%28 = shufflevector <4 x i32> %27, <4 x i32> poison, <4 x i32> zeroinitializer
%29 = insertelement <4 x i32> poison, i32 %24, i64 0
%30 = shufflevector <4 x i32> %29, <4 x i32> poison, <4 x i32> zeroinitializer
br label %31
31: ; preds = %31, %25
%32 = phi i32 [ 0, %25 ], [ %55, %31 ]
%33 = phi <4 x i32> [ %26, %25 ], [ %53, %31 ]
%34 = phi <4 x i32> [ zeroinitializer, %25 ], [ %54, %31 ]
%35 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %25 ], [ %56, %31 ]
%36 = add <4 x i32> %35, <i32 4, i32 4, i32 4, i32 4>
%37 = icmp eq <4 x i32> %35, %28
%38 = icmp eq <4 x i32> %36, %30
%39 = add nuw nsw <4 x i32> %35, %28
%40 = add nuw nsw <4 x i32> %36, %30
%41 = icmp ne <4 x i32> %39, %19
%42 = icmp ne <4 x i32> %40, %21
%43 = select <4 x i1> %37, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %41
%44 = select <4 x i1> %38, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %42
%45 = icmp ugt <4 x i32> %28, %35
%46 = icmp ugt <4 x i32> %30, %36
%47 = or <4 x i1> %45, %43
%48 = or <4 x i1> %46, %44
%49 = xor <4 x i1> %47, <i1 true, i1 true, i1 true, i1 true>
%50 = xor <4 x i1> %48, <i1 true, i1 true, i1 true, i1 true>
%51 = zext <4 x i1> %49 to <4 x i32>
%52 = zext <4 x i1> %50 to <4 x i32>
%53 = add <4 x i32> %33, %51
%54 = add <4 x i32> %34, %52
%55 = add nuw i32 %32, 8
%56 = add <4 x i32> %35, <i32 8, i32 8, i32 8, i32 8>
%57 = icmp eq i32 %55, %13
br i1 %57, label %58, label %31
58: ; preds = %31
%59 = add <4 x i32> %54, %53
%60 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %59)
br i1 %14, label %78, label %61
61: ; preds = %22, %58
%62 = phi i32 [ %23, %22 ], [ %60, %58 ]
%63 = phi i32 [ 0, %22 ], [ %13, %58 ]
br label %64
64: ; preds = %61, %64
%65 = phi i32 [ %75, %64 ], [ %62, %61 ]
%66 = phi i32 [ %76, %64 ], [ %63, %61 ]
%67 = icmp eq i32 %66, %24
%68 = add nuw nsw i32 %66, %24
%69 = icmp ne i32 %68, %16
%70 = select i1 %67, i1 true, i1 %69
%71 = icmp ugt i32 %24, %66
%72 = or i1 %71, %70
%73 = xor i1 %72, true
%74 = zext i1 %73 to i32
%75 = add nsw i32 %65, %74
%76 = add nuw nsw i32 %66, 1
%77 = icmp eq i32 %76, %5
br i1 %77, label %78, label %64
78: ; preds = %64, %58
%79 = phi i32 [ %60, %58 ], [ %75, %64 ]
%80 = add nuw nsw i32 %24, 1
%81 = icmp eq i32 %80, %5
br i1 %81, label %82, label %22
82: ; preds = %78
%83 = icmp slt i32 %79, 3
br i1 %83, label %84, label %104
84: ; preds = %82, %101
%85 = phi i32 [ %102, %101 ], [ 0, %82 ]
br label %86
86: ; preds = %84, %98
%87 = phi i32 [ %99, %98 ], [ 0, %84 ]
%88 = icmp ule i32 %85, %87
%89 = add nuw nsw i32 %87, %85
%90 = icmp eq i32 %89, %16
%91 = select i1 %88, i1 %90, i1 false
br i1 %91, label %92, label %98
92: ; preds = %86
%93 = icmp eq i32 %85, %87
br i1 %93, label %94, label %96
94: ; preds = %92
%95 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.2, i64 0, i64 0), i32 %85, i32 %85)
br label %98
96: ; preds = %92
%97 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), i32 %85, i32 %87)
br label %98
98: ; preds = %86, %96, %94
%99 = add nuw nsw i32 %87, 1
%100 = icmp eq i32 %99, %5
br i1 %100, label %101, label %86
101: ; preds = %98
%102 = add nuw nsw i32 %85, 1
%103 = icmp eq i32 %102, %5
br i1 %103, label %134, label %84
104: ; preds = %82, %124
%105 = phi i32 [ %121, %124 ], [ 0, %82 ]
%106 = phi i32 [ %125, %124 ], [ 0, %82 ]
br label %107
107: ; preds = %104, %120
%108 = phi i32 [ %121, %120 ], [ %105, %104 ]
%109 = phi i32 [ %122, %120 ], [ 0, %104 ]
%110 = icmp eq i32 %109, %106
%111 = add nuw nsw i32 %109, %106
%112 = icmp ne i32 %111, %16
%113 = select i1 %110, i1 true, i1 %112
%114 = icmp ugt i32 %106, %109
%115 = or i1 %114, %113
br i1 %115, label %120, label %116
116: ; preds = %107
%117 = icmp eq i32 %108, 0
%118 = select i1 %117, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.5, i64 0, i64 0)
%119 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) %118, i32 %106, i32 %109)
br label %120
120: ; preds = %116, %107
%121 = phi i32 [ %108, %107 ], [ 1, %116 ]
%122 = add nuw nsw i32 %109, 1
%123 = icmp eq i32 %122, %5
br i1 %123, label %124, label %107
124: ; preds = %120
%125 = add nuw nsw i32 %106, 1
%126 = icmp eq i32 %125, %5
br i1 %126, label %127, label %104
127: ; preds = %124
%128 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i64 0, i64 0))
%129 = and i32 %16, 1
%130 = icmp eq i32 %129, 0
br i1 %130, label %131, label %134
131: ; preds = %127
%132 = lshr i32 %16, 1
%133 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.2, i64 0, i64 0), i32 %132, i32 %132)
br label %134
134: ; preds = %101, %127, %131
%135 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.7, i64 0, i64 0), i32 %16)
%136 = add nuw nsw i32 %16, 1
%137 = icmp eq i32 %136, %11
br i1 %137, label %138, label %15
138: ; preds = %134, %2
%139 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.8, i64 0, i64 0), i32 %8)
%140 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([127 x i8], [127 x i8]* @.str.9, i64 0, i64 0), i32 %6, i32 %6)
ret i32 0
}