#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 gcd(int, int);
unsigned int spec_num(int m, int n) {
  if (m == 0)
    return 1;
  int i, j, k, p = m, q = n, x;
  unsigned int pu = 1.0, pd = 1.0;
  if ((double)n / (double)m < 2.0)
    p = q - p;
  int d[64], u[64];
  for (k = 0, i = q; i >= q - p + 1; i--)
    u[++k] = i;
  u[0] = k;
  for (i = 1; i <= p; i++)
    d[i] = i;
  for (i = 1; i <= u[0]; i++)
    if (u[i] != 1)
      for (j = 1; j <= p; j++)
        if (d[j] != 1) {
          x = gcd(u[i], d[j]);
          u[i] /= x;
          d[j] /= x;
        }
  for (i = 1; i <= u[0]; i++)
    if (u[i] != 1)
      pu *= u[i];
  return pu;
}


x86 assembly (clang, -O0):
<spec_num>:
push   %rbp
mov    %rsp,%rbp
sub    $0x240,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cmpl   $0x0,-0x8(%rbp)
jne    1137 <spec_num+0x27>
movl   $0x1,-0x4(%rbp)
jmp    132f <spec_num+0x21f>
mov    -0x8(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
movl   $0x1,-0x28(%rbp)
movl   $0x1,-0x2c(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm1
cvtsi2sdl -0x8(%rbp),%xmm0
divsd  %xmm0,%xmm1
movsd  0xe99(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    117a <spec_num+0x6a>
mov    -0x20(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     11be <spec_num+0xae>
mov    -0x10(%rbp),%ecx
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
cltq
mov    %ecx,-0x230(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1187 <spec_num+0x77>
mov    -0x18(%rbp),%eax
mov    %eax,-0x230(%rbp)
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     11f6 <spec_num+0xe6>
mov    -0x10(%rbp),%ecx
movslq -0x10(%rbp),%rax
mov    %ecx,-0x130(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11ce <spec_num+0xbe>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x230(%rbp),%eax
jg     12dc <spec_num+0x1cc>
movslq -0x10(%rbp),%rax
cmpl   $0x1,-0x230(%rbp,%rax,4)
01
je     12c9 <spec_num+0x1b9>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     12c4 <spec_num+0x1b4>
movslq -0x14(%rbp),%rax
cmpl   $0x1,-0x130(%rbp,%rax,4)
01
je     12b1 <spec_num+0x1a1>
movslq -0x10(%rbp),%rax
mov    -0x230(%rbp,%rax,4),%edi
movslq -0x14(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%esi
call   1030 <gcd@plt>
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
movslq -0x10(%rbp),%rax
mov    %rax,-0x240(%rbp)
mov    -0x230(%rbp,%rax,4),%eax
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x240(%rbp),%rax
mov    %ecx,-0x230(%rbp,%rax,4)
mov    -0x24(%rbp),%ecx
movslq -0x14(%rbp),%rax
mov    %rax,-0x238(%rbp)
mov    -0x130(%rbp,%rax,4),%eax
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x238(%rbp),%rax
mov    %ecx,-0x130(%rbp,%rax,4)
jmp    12b6 <spec_num+0x1a6>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1225 <spec_num+0x115>
jmp    12c9 <spec_num+0x1b9>
jmp    12ce <spec_num+0x1be>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11fd <spec_num+0xed>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x230(%rbp),%eax
jg     1329 <spec_num+0x219>
movslq -0x10(%rbp),%rax
cmpl   $0x1,-0x230(%rbp,%rax,4)
01
je     1316 <spec_num+0x206>
movslq -0x10(%rbp),%rax
mov    -0x230(%rbp,%rax,4),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    131b <spec_num+0x20b>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12e3 <spec_num+0x1d3>
mov    -0x28(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x240,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<spec_num>:
test   %edi,%edi
je     1173 <spec_num+0x63>
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x228,%rsp
cvtsi2sd %esi,%xmm0
cvtsi2sd %edi,%xmm1
divsd  %xmm1,%xmm0
mov    %esi,%r12d
sub    %edi,%r12d
movsd  0xec1(%rip),%xmm1
ucomisd %xmm0,%xmm1
cmovbe %edi,%r12d
mov    $0x1,%eax
test   %r12d,%r12d
jle    175e <spec_num+0x64e>
mov    %esi,%ebx
sub    %r12d,%ebx
lea    -0x1(%rsi),%ecx
cmp    %ecx,%ebx
mov    %ecx,%edx
cmovl  %ebx,%edx
sub    %edx,%ecx
cmp    $0x7,%ecx
jae    1179 <spec_num+0x69>
xor    %r13d,%r13d
jmp    12e0 <spec_num+0x1d0>
mov    $0x1,%eax
ret
add    $0x1,%rcx
mov    %rcx,%r13
and    $0xfffffffffffffff8,%r13
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  0xe7b(%rip),%xmm0
lea    -0x8(%r13),%rdi
mov    %rdi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdi
jae    11b6 <spec_num+0xa6>
xor    %edi,%edi
jmp    127f <spec_num+0x16f>
and    $0xfffffffffffffffc,%rdx
xor    %edi,%edi
movdqa 0xe5b(%rip),%xmm8
movdqa 0xe62(%rip),%xmm9
movdqa 0xe69(%rip),%xmm10
movdqa 0xe71(%rip),%xmm4
movdqa 0xe79(%rip),%xmm5
movdqa 0xe81(%rip),%xmm6
movdqa 0xe89(%rip),%xmm7
movdqa 0xe91(%rip),%xmm1
nop
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,0x24(%rsp,%rdi,4)
movdqu %xmm2,0x34(%rsp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x44(%rsp,%rdi,4)
movdqu %xmm3,0x54(%rsp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x64(%rsp,%rdi,4)
movdqu %xmm3,0x74(%rsp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x84(%rsp,%rdi,4)
movdqu %xmm3,0x94(%rsp,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdx
jne    1200 <spec_num+0xf0>
test   %rbp,%rbp
je     12ce <spec_num+0x1be>
movdqa 0xd94(%rip),%xmm1
movdqa 0xd9c(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
lea    0x0(,%rdi,4),%rdx
or     $0x4,%rdx
movdqu %xmm0,0x20(%rsp,%rdx,1)
movdqu %xmm3,0x30(%rsp,%rdx,1)
add    $0x8,%rdi
paddd  %xmm2,%xmm0
add    $0xffffffffffffffff,%rbp
jne    12a0 <spec_num+0x190>
cmp    %r13,%rcx
je     12f0 <spec_num+0x1e0>
sub    %r13d,%esi
cs nopw 0x0(%rax,%rax,1)
mov    %esi,0x24(%rsp,%r13,4)
add    $0x1,%r13
add    $0xffffffff,%esi
cmp    %ebx,%esi
jg     12e0 <spec_num+0x1d0>
lea    -0x1(%r13),%rbp
test   %r12d,%r12d
setle  0xf(%rsp)
jle    133e <spec_num+0x22e>
mov    %r12d,%ebx
mov    $0x1,%ecx
cmp    $0x8,%r12d
jb     148d <spec_num+0x37d>
mov    %ebx,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    1348 <spec_num+0x238>
movdqa 0xd69(%rip),%xmm0
xor    %esi,%esi
jmp    1435 <spec_num+0x325>
movb   $0x1,0xf(%rsp)
jmp    14b0 <spec_num+0x3a0>
and    $0xfffffffffffffffc,%rdi
movdqa 0xd4c(%rip),%xmm0
xor    %esi,%esi
movdqa 0xd51(%rip),%xmm8
movdqa 0xd58(%rip),%xmm9
movdqa 0xd5f(%rip),%xmm10
movdqa 0xd67(%rip),%xmm4
movdqa 0xd6f(%rip),%xmm5
movdqa 0xd77(%rip),%xmm6
movdqa 0xd7f(%rip),%xmm7
movdqa 0xd87(%rip),%xmm1
nopl   0x0(%rax)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,0x124(%rsp,%rsi,4)
movdqu %xmm2,0x134(%rsp,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x144(%rsp,%rsi,4)
movdqu %xmm3,0x154(%rsp,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x164(%rsp,%rsi,4)
movdqu %xmm3,0x174(%rsp,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x184(%rsp,%rsi,4)
movdqu %xmm3,0x194(%rsp,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    13a0 <spec_num+0x290>
test   %rdx,%rdx
je     1484 <spec_num+0x374>
movdqa 0xc6e(%rip),%xmm1
movdqa 0xc76(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rsi,4),%rdi
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
or     $0x4,%rdi
movdqu %xmm0,0x120(%rsp,%rdi,1)
movdqu %xmm3,0x130(%rsp,%rdi,1)
add    $0x8,%rsi
paddd  %xmm2,%xmm0
add    $0xffffffffffffffff,%rdx
jne    1450 <spec_num+0x340>
cmp    %rcx,%rbx
je     14b0 <spec_num+0x3a0>
or     $0x1,%rcx
add    $0x1,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ecx,0x120(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    14a0 <spec_num+0x390>
test   %r13d,%r13d
je     175e <spec_num+0x64e>
add    $0x1,%r12d
mov    %rbp,0x10(%rsp)
lea    0x2(%rbp),%eax
mov    %rax,0x18(%rsp)
mov    $0x1,%r14d
jmp    14eb <spec_num+0x3db>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r14
cmp    0x18(%rsp),%r14
je     154c <spec_num+0x43c>
mov    0x20(%rsp,%r14,4),%ebp
cmp    $0x1,%ebp
sete   %al
or     0xf(%rsp),%al
jne    14e0 <spec_num+0x3d0>
mov    $0x1,%r15d
jmp    1519 <spec_num+0x409>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r15
cmp    %r15,%r12
je     14e0 <spec_num+0x3d0>
mov    0x120(%rsp,%r15,4),%ebx
cmp    $0x1,%ebx
je     1510 <spec_num+0x400>
mov    %ebp,%edi
mov    %ebx,%esi
call   1030 <gcd@plt>
mov    %eax,%ecx
mov    %ebp,%eax
cltd
idiv   %ecx
mov    %eax,%ebp
mov    %eax,0x20(%rsp,%r14,4)
mov    %ebx,%eax
cltd
idiv   %ecx
mov    %eax,0x120(%rsp,%r15,4)
jmp    1510 <spec_num+0x400>
test   %r13d,%r13d
mov    0x10(%rsp),%rbp
mov    $0x1,%eax
je     175e <spec_num+0x64e>
add    $0x2,%ebp
lea    -0x1(%rbp),%rbx
cmp    $0x8,%rbx
jae    157b <spec_num+0x46b>
mov    $0x1,%eax
mov    $0x1,%ecx
jmp    1750 <spec_num+0x640>
mov    %rbx,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    15af <spec_num+0x49f>
movdqa 0xb8c(%rip),%xmm0
xor    %esi,%esi
movdqa %xmm0,%xmm1
jmp    16a2 <spec_num+0x592>
and    $0xfffffffffffffffc,%rdi
movdqa 0xb75(%rip),%xmm0
xor    %esi,%esi
movdqa %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
pshufd $0xf5,%xmm0,%xmm4
movdqu 0x24(%rsp,%rsi,4),%xmm3
movdqu 0x34(%rsp,%rsi,4),%xmm2
movdqu 0x44(%rsp,%rsi,4),%xmm5
movdqu 0x54(%rsp,%rsi,4),%xmm6
pshufd $0xf5,%xmm3,%xmm7
pmuludq %xmm4,%xmm7
pmuludq %xmm0,%xmm3
pshufd $0xf5,%xmm1,%xmm0
pshufd $0xf5,%xmm2,%xmm4
pmuludq %xmm0,%xmm4
pmuludq %xmm1,%xmm2
pmuludq %xmm5,%xmm3
pshufd $0xf5,%xmm5,%xmm0
pmuludq %xmm7,%xmm0
pmuludq %xmm6,%xmm2
pshufd $0xf5,%xmm6,%xmm1
pmuludq %xmm4,%xmm1
movdqu 0x64(%rsp,%rsi,4),%xmm4
movdqu 0x74(%rsp,%rsi,4),%xmm5
pshufd $0xf5,%xmm4,%xmm6
pmuludq %xmm0,%xmm6
pmuludq %xmm4,%xmm3
pshufd $0xf5,%xmm5,%xmm4
pmuludq %xmm1,%xmm4
pmuludq %xmm5,%xmm2
movdqu 0x84(%rsp,%rsi,4),%xmm1
movdqu 0x94(%rsp,%rsi,4),%xmm5
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm0
pshufd $0xf5,%xmm1,%xmm1
pmuludq %xmm6,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
pmuludq %xmm5,%xmm2
pshufd $0xe8,%xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    15d0 <spec_num+0x4c0>
movdqa %xmm0,%xmm2
movdqa %xmm1,%xmm3
test   %rdx,%rdx
je     171a <spec_num+0x60a>
nop
lea    0x0(,%rsi,4),%rdi
or     $0x4,%rdi
movdqu 0x20(%rsp,%rdi,1),%xmm2
movdqu 0x30(%rsp,%rdi,1),%xmm3
pshufd $0xf5,%xmm2,%xmm4
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm4,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
pshufd $0xf5,%xmm3,%xmm0
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pshufd $0xf5,%xmm1,%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm0
punpckldq %xmm0,%xmm3
add    $0x8,%rsi
movdqa %xmm2,%xmm0
movdqa %xmm3,%xmm1
add    $0xffffffffffffffff,%rdx
jne    16b0 <spec_num+0x5a0>
pshufd $0xf5,%xmm2,%xmm0
pshufd $0xf5,%xmm3,%xmm1
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm3
pshufd $0xee,%xmm3,%xmm0
pmuludq %xmm3,%xmm0
pshufd $0xaa,%xmm1,%xmm2
pmuludq %xmm1,%xmm2
pmuludq %xmm0,%xmm2
movd   %xmm2,%eax
cmp    %rcx,%rbx
je     175e <spec_num+0x64e>
or     $0x1,%rcx
nop
imul   0x20(%rsp,%rcx,4),%eax
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    1750 <spec_num+0x640>
add    $0x228,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @spec_num(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [64 x i32]
%15 = alloca [64 x i32]
store i32 %0, i32* %4
store i32 %1, i32* %5
%16 = load i32, i32* %4
%17 = icmp eq i32 %16, 0
br i1 %17, label %18, label %19
18: ; preds = %2
store i32 1, i32* %3
br label %144
19: ; preds = %2
%20 = load i32, i32* %4
store i32 %20, i32* %9
%21 = load i32, i32* %5
store i32 %21, i32* %10
store i32 1, i32* %12
store i32 1, i32* %13
%22 = load i32, i32* %5
%23 = sitofp i32 %22 to double
%24 = load i32, i32* %4
%25 = sitofp i32 %24 to double
%26 = fdiv double %23, %25
%27 = fcmp olt double %26, 2.000000e+00
br i1 %27, label %28, label %32
28: ; preds = %19
%29 = load i32, i32* %10
%30 = load i32, i32* %9
%31 = sub nsw i32 %29, %30
store i32 %31, i32* %9
br label %32
32: ; preds = %28, %19
store i32 0, i32* %8
%33 = load i32, i32* %10
store i32 %33, i32* %6
br label %34
34: ; preds = %47, %32
%35 = load i32, i32* %6
%36 = load i32, i32* %10
%37 = load i32, i32* %9
%38 = sub nsw i32 %36, %37
%39 = add nsw i32 %38, 1
%40 = icmp sge i32 %35, %39
br i1 %40, label %41, label %50
41: ; preds = %34
%42 = load i32, i32* %6
%43 = load i32, i32* %8
%44 = add nsw i32 %43, 1
store i32 %44, i32* %8
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [64 x i32], [64 x i32]* %15, i64 0, i64 %45
store i32 %42, i32* %46
br label %47
47: ; preds = %41
%48 = load i32, i32* %6
%49 = add nsw i32 %48, -1
store i32 %49, i32* %6
br label %34
50: ; preds = %34
%51 = load i32, i32* %8
%52 = getelementptr inbounds [64 x i32], [64 x i32]* %15, i64 0, i64 0
store i32 %51, i32* %52
store i32 1, i32* %6
br label %53
53: ; preds = %62, %50
%54 = load i32, i32* %6
%55 = load i32, i32* %9
%56 = icmp sle i32 %54, %55
br i1 %56, label %57, label %65
57: ; preds = %53
%58 = load i32, i32* %6
%59 = load i32, i32* %6
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [64 x i32], [64 x i32]* %14, i64 0, i64 %60
store i32 %58, i32* %61
br label %62
62: ; preds = %57
%63 = load i32, i32* %6
%64 = add nsw i32 %63, 1
store i32 %64, i32* %6
br label %53
65: ; preds = %53
store i32 1, i32* %6
br label %66
66: ; preds = %116, %65
%67 = load i32, i32* %6
%68 = getelementptr inbounds [64 x i32], [64 x i32]* %15, i64 0, i64 0
%69 = load i32, i32* %68
%70 = icmp sle i32 %67, %69
br i1 %70, label %71, label %119
71: ; preds = %66
%72 = load i32, i32* %6
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [64 x i32], [64 x i32]* %15, i64 0, i64 %73
%75 = load i32, i32* %74
%76 = icmp ne i32 %75, 1
br i1 %76, label %77, label %115
77: ; preds = %71
store i32 1, i32* %7
br label %78
78: ; preds = %111, %77
%79 = load i32, i32* %7
%80 = load i32, i32* %9
%81 = icmp sle i32 %79, %80
br i1 %81, label %82, label %114
82: ; preds = %78
%83 = load i32, i32* %7
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [64 x i32], [64 x i32]* %14, i64 0, i64 %84
%86 = load i32, i32* %85
%87 = icmp ne i32 %86, 1
br i1 %87, label %88, label %110
88: ; preds = %82
%89 = load i32, i32* %6
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [64 x i32], [64 x i32]* %15, i64 0, i64 %90
%92 = load i32, i32* %91
%93 = load i32, i32* %7
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [64 x i32], [64 x i32]* %14, i64 0, i64 %94
%96 = load i32, i32* %95
%97 = call i32 @gcd(i32 %92, i32 %96)
store i32 %97, i32* %11
%98 = load i32, i32* %11
%99 = load i32, i32* %6
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [64 x i32], [64 x i32]* %15, i64 0, i64 %100
%102 = load i32, i32* %101
%103 = sdiv i32 %102, %98
store i32 %103, i32* %101
%104 = load i32, i32* %11
%105 = load i32, i32* %7
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [64 x i32], [64 x i32]* %14, i64 0, i64 %106
%108 = load i32, i32* %107
%109 = sdiv i32 %108, %104
store i32 %109, i32* %107
br label %110
110: ; preds = %88, %82
br label %111
111: ; preds = %110
%112 = load i32, i32* %7
%113 = add nsw i32 %112, 1
store i32 %113, i32* %7
br label %78
114: ; preds = %78
br label %115
115: ; preds = %114, %71
br label %116
116: ; preds = %115
%117 = load i32, i32* %6
%118 = add nsw i32 %117, 1
store i32 %118, i32* %6
br label %66
119: ; preds = %66
store i32 1, i32* %6
br label %120
120: ; preds = %139, %119
%121 = load i32, i32* %6
%122 = getelementptr inbounds [64 x i32], [64 x i32]* %15, i64 0, i64 0
%123 = load i32, i32* %122
%124 = icmp sle i32 %121, %123
br i1 %124, label %125, label %142
125: ; preds = %120
%126 = load i32, i32* %6
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [64 x i32], [64 x i32]* %15, i64 0, i64 %127
%129 = load i32, i32* %128
%130 = icmp ne i32 %129, 1
br i1 %130, label %131, label %138
131: ; preds = %125
%132 = load i32, i32* %6
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [64 x i32], [64 x i32]* %15, i64 0, i64 %133
%135 = load i32, i32* %134
%136 = load i32, i32* %12
%137 = mul i32 %136, %135
store i32 %137, i32* %12
br label %138
138: ; preds = %131, %125
br label %139
139: ; preds = %138
%140 = load i32, i32* %6
%141 = add nsw i32 %140, 1
store i32 %141, i32* %6
br label %120
142: ; preds = %120
%143 = load i32, i32* %12
store i32 %143, i32* %3
br label %144
144: ; preds = %142, %18
%145 = load i32, i32* %3
ret i32 %145
}

LLVM IR (-O2):
define i32 @spec_num(i32 %0, i32 %1) {
%3 = alloca [64 x i32]
%4 = alloca [64 x i32]
%5 = icmp eq i32 %0, 0
br i1 %5, label %321, label %6
6: ; preds = %2
%7 = sitofp i32 %1 to double
%8 = sitofp i32 %0 to double
%9 = fdiv double %7, %8
%10 = fcmp olt double %9, 2.000000e+00
%11 = sub nsw i32 %1, %0
%12 = select i1 %10, i32 %11, i32 %0
%13 = bitcast [64 x i32]* %3 to i8*
%14 = bitcast [64 x i32]* %4 to i8*
%15 = sub i32 %1, %12
%16 = icmp sgt i32 %12, 0
br i1 %16, label %17, label %319
17: ; preds = %6
%18 = add i32 %1, -1
%19 = call i32 @llvm.smin.i32(i32 %15, i32 %18)
%20 = sub i32 %18, %19
%21 = zext i32 %20 to i64
%22 = add nuw nsw i64 %21, 1
%23 = icmp ult i32 %20, 7
br i1 %23, label %94, label %24
24: ; preds = %17
%25 = and i64 %22, 8589934584
%26 = trunc i64 %25 to i32
%27 = sub i32 %1, %26
%28 = insertelement <4 x i32> poison, i32 %1, i64 0
%29 = shufflevector <4 x i32> %28, <4 x i32> poison, <4 x i32> zeroinitializer
%30 = add <4 x i32> %29, <i32 0, i32 -1, i32 -2, i32 -3>
%31 = add nsw i64 %25, -8
%32 = lshr exact i64 %31, 3
%33 = add nuw nsw i64 %32, 1
%34 = and i64 %33, 3
%35 = icmp ult i64 %31, 24
br i1 %35, label %73, label %36
36: ; preds = %24
%37 = and i64 %33, 4611686018427387900
br label %38
38: ; preds = %38, %36
%39 = phi i64 [ 0, %36 ], [ %69, %38 ]
%40 = phi <4 x i32> [ %30, %36 ], [ %70, %38 ]
%41 = phi i64 [ 0, %36 ], [ %71, %38 ]
%42 = add <4 x i32> %40, <i32 -4, i32 -4, i32 -4, i32 -4>
%43 = or i64 %39, 1
%44 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %43
%45 = bitcast i32* %44 to <4 x i32>*
store <4 x i32> %40, <4 x i32>* %45
%46 = getelementptr inbounds i32, i32* %44, i64 4
%47 = bitcast i32* %46 to <4 x i32>*
store <4 x i32> %42, <4 x i32>* %47
%48 = add <4 x i32> %40, <i32 -8, i32 -8, i32 -8, i32 -8>
%49 = add <4 x i32> %40, <i32 -12, i32 -12, i32 -12, i32 -12>
%50 = or i64 %39, 9
%51 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %50
%52 = bitcast i32* %51 to <4 x i32>*
store <4 x i32> %48, <4 x i32>* %52
%53 = getelementptr inbounds i32, i32* %51, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
store <4 x i32> %49, <4 x i32>* %54
%55 = add <4 x i32> %40, <i32 -16, i32 -16, i32 -16, i32 -16>
%56 = add <4 x i32> %40, <i32 -20, i32 -20, i32 -20, i32 -20>
%57 = or i64 %39, 17
%58 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %57
%59 = bitcast i32* %58 to <4 x i32>*
store <4 x i32> %55, <4 x i32>* %59
%60 = getelementptr inbounds i32, i32* %58, i64 4
%61 = bitcast i32* %60 to <4 x i32>*
store <4 x i32> %56, <4 x i32>* %61
%62 = add <4 x i32> %40, <i32 -24, i32 -24, i32 -24, i32 -24>
%63 = add <4 x i32> %40, <i32 -28, i32 -28, i32 -28, i32 -28>
%64 = or i64 %39, 25
%65 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %64
%66 = bitcast i32* %65 to <4 x i32>*
store <4 x i32> %62, <4 x i32>* %66
%67 = getelementptr inbounds i32, i32* %65, i64 4
%68 = bitcast i32* %67 to <4 x i32>*
store <4 x i32> %63, <4 x i32>* %68
%69 = add nuw i64 %39, 32
%70 = add <4 x i32> %40, <i32 -32, i32 -32, i32 -32, i32 -32>
%71 = add i64 %41, 4
%72 = icmp eq i64 %71, %37
br i1 %72, label %73, label %38
73: ; preds = %38, %24
%74 = phi i64 [ 0, %24 ], [ %69, %38 ]
%75 = phi <4 x i32> [ %30, %24 ], [ %70, %38 ]
%76 = icmp eq i64 %34, 0
br i1 %76, label %91, label %77
77: ; preds = %73, %77
%78 = phi i64 [ %87, %77 ], [ %74, %73 ]
%79 = phi <4 x i32> [ %88, %77 ], [ %75, %73 ]
%80 = phi i64 [ %89, %77 ], [ 0, %73 ]
%81 = add <4 x i32> %79, <i32 -4, i32 -4, i32 -4, i32 -4>
%82 = or i64 %78, 1
%83 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %82
%84 = bitcast i32* %83 to <4 x i32>*
store <4 x i32> %79, <4 x i32>* %84
%85 = getelementptr inbounds i32, i32* %83, i64 4
%86 = bitcast i32* %85 to <4 x i32>*
store <4 x i32> %81, <4 x i32>* %86
%87 = add nuw i64 %78, 8
%88 = add <4 x i32> %79, <i32 -8, i32 -8, i32 -8, i32 -8>
%89 = add i64 %80, 1
%90 = icmp eq i64 %89, %34
br i1 %90, label %91, label %77
91: ; preds = %77, %73
%92 = icmp eq i64 %22, %25
%93 = add nsw i64 %25, -1
br i1 %92, label %104, label %94
94: ; preds = %17, %91
%95 = phi i64 [ 0, %17 ], [ %25, %91 ]
%96 = phi i32 [ %1, %17 ], [ %27, %91 ]
br label %97
97: ; preds = %94, %97
%98 = phi i64 [ %100, %97 ], [ %95, %94 ]
%99 = phi i32 [ %102, %97 ], [ %96, %94 ]
%100 = add nuw nsw i64 %98, 1
%101 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %100
store i32 %99, i32* %101
%102 = add nsw i32 %99, -1
%103 = icmp sgt i32 %102, %15
br i1 %103, label %97, label %104
104: ; preds = %97, %91
%105 = phi i64 [ %93, %91 ], [ %98, %97 ]
%106 = phi i64 [ %25, %91 ], [ %100, %97 ]
%107 = trunc i64 %106 to i32
%108 = icmp slt i32 %12, 1
br i1 %108, label %181, label %109
109: ; preds = %104
%110 = add nuw i32 %12, 1
%111 = zext i32 %110 to i64
%112 = add nsw i64 %111, -1
%113 = icmp ult i64 %112, 8
br i1 %113, label %179, label %114
114: ; preds = %109
%115 = and i64 %112, -8
%116 = or i64 %115, 1
%117 = add nsw i64 %115, -8
%118 = lshr exact i64 %117, 3
%119 = add nuw nsw i64 %118, 1
%120 = and i64 %119, 3
%121 = icmp ult i64 %117, 24
br i1 %121, label %159, label %122
122: ; preds = %114
%123 = and i64 %119, 4611686018427387900
br label %124
124: ; preds = %124, %122
%125 = phi i64 [ 0, %122 ], [ %155, %124 ]
%126 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %122 ], [ %156, %124 ]
%127 = phi i64 [ 0, %122 ], [ %157, %124 ]
%128 = or i64 %125, 1
%129 = add <4 x i32> %126, <i32 4, i32 4, i32 4, i32 4>
%130 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 %128
%131 = bitcast i32* %130 to <4 x i32>*
store <4 x i32> %126, <4 x i32>* %131
%132 = getelementptr inbounds i32, i32* %130, i64 4
%133 = bitcast i32* %132 to <4 x i32>*
store <4 x i32> %129, <4 x i32>* %133
%134 = add <4 x i32> %126, <i32 8, i32 8, i32 8, i32 8>
%135 = or i64 %125, 9
%136 = add <4 x i32> %126, <i32 12, i32 12, i32 12, i32 12>
%137 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 %135
%138 = bitcast i32* %137 to <4 x i32>*
store <4 x i32> %134, <4 x i32>* %138
%139 = getelementptr inbounds i32, i32* %137, i64 4
%140 = bitcast i32* %139 to <4 x i32>*
store <4 x i32> %136, <4 x i32>* %140
%141 = add <4 x i32> %126, <i32 16, i32 16, i32 16, i32 16>
%142 = or i64 %125, 17
%143 = add <4 x i32> %126, <i32 20, i32 20, i32 20, i32 20>
%144 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 %142
%145 = bitcast i32* %144 to <4 x i32>*
store <4 x i32> %141, <4 x i32>* %145
%146 = getelementptr inbounds i32, i32* %144, i64 4
%147 = bitcast i32* %146 to <4 x i32>*
store <4 x i32> %143, <4 x i32>* %147
%148 = add <4 x i32> %126, <i32 24, i32 24, i32 24, i32 24>
%149 = or i64 %125, 25
%150 = add <4 x i32> %126, <i32 28, i32 28, i32 28, i32 28>
%151 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 %149
%152 = bitcast i32* %151 to <4 x i32>*
store <4 x i32> %148, <4 x i32>* %152
%153 = getelementptr inbounds i32, i32* %151, i64 4
%154 = bitcast i32* %153 to <4 x i32>*
store <4 x i32> %150, <4 x i32>* %154
%155 = add nuw i64 %125, 32
%156 = add <4 x i32> %126, <i32 32, i32 32, i32 32, i32 32>
%157 = add i64 %127, 4
%158 = icmp eq i64 %157, %123
br i1 %158, label %159, label %124
159: ; preds = %124, %114
%160 = phi i64 [ 0, %114 ], [ %155, %124 ]
%161 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %114 ], [ %156, %124 ]
%162 = icmp eq i64 %120, 0
br i1 %162, label %177, label %163
163: ; preds = %159, %163
%164 = phi i64 [ %173, %163 ], [ %160, %159 ]
%165 = phi <4 x i32> [ %174, %163 ], [ %161, %159 ]
%166 = phi i64 [ %175, %163 ], [ 0, %159 ]
%167 = or i64 %164, 1
%168 = add <4 x i32> %165, <i32 4, i32 4, i32 4, i32 4>
%169 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 %167
%170 = bitcast i32* %169 to <4 x i32>*
store <4 x i32> %165, <4 x i32>* %170
%171 = getelementptr inbounds i32, i32* %169, i64 4
%172 = bitcast i32* %171 to <4 x i32>*
store <4 x i32> %168, <4 x i32>* %172
%173 = add nuw i64 %164, 8
%174 = add <4 x i32> %165, <i32 8, i32 8, i32 8, i32 8>
%175 = add i64 %166, 1
%176 = icmp eq i64 %175, %120
br i1 %176, label %177, label %163
177: ; preds = %163, %159
%178 = icmp eq i64 %112, %115
br i1 %178, label %181, label %179
179: ; preds = %109, %177
%180 = phi i64 [ 1, %109 ], [ %116, %177 ]
br label %189
181: ; preds = %189, %177, %104
%182 = phi i1 [ true, %104 ], [ %108, %177 ], [ %108, %189 ]
%183 = icmp eq i32 %107, 0
br i1 %183, label %319, label %184
184: ; preds = %181
%185 = add i32 %12, 1
%186 = add nuw i64 %105, 2
%187 = and i64 %186, 4294967295
%188 = zext i32 %185 to i64
br label %288
189: ; preds = %179, %189
%190 = phi i64 [ %193, %189 ], [ %180, %179 ]
%191 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 %190
%192 = trunc i64 %190 to i32
store i32 %192, i32* %191
%193 = add nuw nsw i64 %190, 1
%194 = icmp eq i64 %193, %111
br i1 %194, label %181, label %189
195: ; preds = %308
br i1 %183, label %319, label %196
196: ; preds = %195
%197 = add nuw i64 %105, 2
%198 = and i64 %197, 4294967295
%199 = add nsw i64 %198, -1
%200 = icmp ult i64 %199, 8
br i1 %200, label %285, label %201
201: ; preds = %196
%202 = and i64 %199, -8
%203 = or i64 %202, 1
%204 = add nsw i64 %202, -8
%205 = lshr exact i64 %204, 3
%206 = add nuw nsw i64 %205, 1
%207 = and i64 %206, 3
%208 = icmp ult i64 %204, 24
br i1 %208, label %255, label %209
209: ; preds = %201
%210 = and i64 %206, 4611686018427387900
br label %211
211: ; preds = %211, %209
%212 = phi i64 [ 0, %209 ], [ %252, %211 ]
%213 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %209 ], [ %250, %211 ]
%214 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %209 ], [ %251, %211 ]
%215 = phi i64 [ 0, %209 ], [ %253, %211 ]
%216 = or i64 %212, 1
%217 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %216
%218 = bitcast i32* %217 to <4 x i32>*
%219 = load <4 x i32>, <4 x i32>* %218
%220 = getelementptr inbounds i32, i32* %217, i64 4
%221 = bitcast i32* %220 to <4 x i32>*
%222 = load <4 x i32>, <4 x i32>* %221
%223 = mul <4 x i32> %219, %213
%224 = mul <4 x i32> %222, %214
%225 = or i64 %212, 9
%226 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %225
%227 = bitcast i32* %226 to <4 x i32>*
%228 = load <4 x i32>, <4 x i32>* %227
%229 = getelementptr inbounds i32, i32* %226, i64 4
%230 = bitcast i32* %229 to <4 x i32>*
%231 = load <4 x i32>, <4 x i32>* %230
%232 = mul <4 x i32> %228, %223
%233 = mul <4 x i32> %231, %224
%234 = or i64 %212, 17
%235 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %234
%236 = bitcast i32* %235 to <4 x i32>*
%237 = load <4 x i32>, <4 x i32>* %236
%238 = getelementptr inbounds i32, i32* %235, i64 4
%239 = bitcast i32* %238 to <4 x i32>*
%240 = load <4 x i32>, <4 x i32>* %239
%241 = mul <4 x i32> %237, %232
%242 = mul <4 x i32> %240, %233
%243 = or i64 %212, 25
%244 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %243
%245 = bitcast i32* %244 to <4 x i32>*
%246 = load <4 x i32>, <4 x i32>* %245
%247 = getelementptr inbounds i32, i32* %244, i64 4
%248 = bitcast i32* %247 to <4 x i32>*
%249 = load <4 x i32>, <4 x i32>* %248
%250 = mul <4 x i32> %246, %241
%251 = mul <4 x i32> %249, %242
%252 = add nuw i64 %212, 32
%253 = add i64 %215, 4
%254 = icmp eq i64 %253, %210
br i1 %254, label %255, label %211
255: ; preds = %211, %201
%256 = phi <4 x i32> [ undef, %201 ], [ %250, %211 ]
%257 = phi <4 x i32> [ undef, %201 ], [ %251, %211 ]
%258 = phi i64 [ 0, %201 ], [ %252, %211 ]
%259 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %201 ], [ %250, %211 ]
%260 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %201 ], [ %251, %211 ]
%261 = icmp eq i64 %207, 0
br i1 %261, label %279, label %262
262: ; preds = %255, %262
%263 = phi i64 [ %276, %262 ], [ %258, %255 ]
%264 = phi <4 x i32> [ %274, %262 ], [ %259, %255 ]
%265 = phi <4 x i32> [ %275, %262 ], [ %260, %255 ]
%266 = phi i64 [ %277, %262 ], [ 0, %255 ]
%267 = or i64 %263, 1
%268 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %267
%269 = bitcast i32* %268 to <4 x i32>*
%270 = load <4 x i32>, <4 x i32>* %269
%271 = getelementptr inbounds i32, i32* %268, i64 4
%272 = bitcast i32* %271 to <4 x i32>*
%273 = load <4 x i32>, <4 x i32>* %272
%274 = mul <4 x i32> %270, %264
%275 = mul <4 x i32> %273, %265
%276 = add nuw i64 %263, 8
%277 = add i64 %266, 1
%278 = icmp eq i64 %277, %207
br i1 %278, label %279, label %262
279: ; preds = %262, %255
%280 = phi <4 x i32> [ %256, %255 ], [ %274, %262 ]
%281 = phi <4 x i32> [ %257, %255 ], [ %275, %262 ]
%282 = mul <4 x i32> %281, %280
%283 = call i32 @llvm.vector.reduce.mul.v4i32(<4 x i32> %282)
%284 = icmp eq i64 %199, %202
br i1 %284, label %319, label %285
285: ; preds = %196, %279
%286 = phi i64 [ 1, %196 ], [ %203, %279 ]
%287 = phi i32 [ 1, %196 ], [ %283, %279 ]
br label %311
288: ; preds = %184, %308
%289 = phi i64 [ 1, %184 ], [ %309, %308 ]
%290 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %289
%291 = load i32, i32* %290
%292 = icmp eq i32 %291, 1
%293 = select i1 %292, i1 true, i1 %182
br i1 %293, label %308, label %294
294: ; preds = %288, %304
%295 = phi i32 [ %305, %304 ], [ %291, %288 ]
%296 = phi i64 [ %306, %304 ], [ 1, %288 ]
%297 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 %296
%298 = load i32, i32* %297
%299 = icmp eq i32 %298, 1
br i1 %299, label %304, label %300
300: ; preds = %294
%301 = tail call i32 @gcd(i32 %295, i32 %298)
%302 = sdiv i32 %295, %301
store i32 %302, i32* %290
%303 = sdiv i32 %298, %301
store i32 %303, i32* %297
br label %304
304: ; preds = %294, %300
%305 = phi i32 [ %295, %294 ], [ %302, %300 ]
%306 = add nuw nsw i64 %296, 1
%307 = icmp eq i64 %306, %188
br i1 %307, label %308, label %294
308: ; preds = %304, %288
%309 = add nuw nsw i64 %289, 1
%310 = icmp eq i64 %309, %187
br i1 %310, label %195, label %288
311: ; preds = %285, %311
%312 = phi i64 [ %317, %311 ], [ %286, %285 ]
%313 = phi i32 [ %316, %311 ], [ %287, %285 ]
%314 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %312
%315 = load i32, i32* %314
%316 = mul i32 %315, %313
%317 = add nuw nsw i64 %312, 1
%318 = icmp eq i64 %317, %198
br i1 %318, label %319, label %311
319: ; preds = %311, %279, %6, %181, %195
%320 = phi i32 [ 1, %195 ], [ 1, %181 ], [ 1, %6 ], [ %283, %279 ], [ %316, %311 ]
br label %321
321: ; preds = %2, %319
%322 = phi i32 [ %320, %319 ], [ 1, %2 ]
ret i32 %322
}