#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 /*<<< orphan*/ printf(char *, unsigned long long);
int main() {
  const int max = 20;
  int numerator[max];
  int denominator[max];
  int i;
  for (i = 0; i < max; i++) {
    denominator[i] = i + 1;
    numerator[i] = i + max + 1;
  }
  for (i = 0; i < max; i++) {
    int j;
    for (j = 0; j < max; j++) {
      if ((denominator[i] != 1) && (!(numerator[j] % denominator[i]))) {
        numerator[j] = numerator[j] / denominator[i];
        denominator[i] = 1;
      }
    }
  }
  unsigned long long num = 1;
  unsigned long long denom = 1;
  for (i = 0; i < max; i++) {
    num *= numerator[i];
    denom *= denominator[i];
  }
  printf("%llu\n", num / denom);
  return (0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x14,-0x8(%rbp)
mov    %rsp,%rax
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x14,-0x14(%rbp)
jge    1171 <main+0x61>
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0xd0(%rbp,%rax,4)
mov    -0x14(%rbp),%ecx
add    $0x14,%ecx
add    $0x1,%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1137 <main+0x27>
movl   $0x0,-0x14(%rbp)
cmpl   $0x14,-0x14(%rbp)
jge    1215 <main+0x105>
movl   $0x0,-0x18(%rbp)
cmpl   $0x14,-0x18(%rbp)
jge    1202 <main+0xf2>
movslq -0x14(%rbp),%rax
cmpl   $0x1,-0xd0(%rbp,%rax,4)
01
je     11ef <main+0xdf>
movslq -0x18(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%eax
movslq -0x14(%rbp),%rcx
cltd
idivl  -0xd0(%rbp,%rcx,4)
cmp    $0x0,%edx
jne    11ef <main+0xdf>
movslq -0x18(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%eax
movslq -0x14(%rbp),%rcx
cltd
idivl  -0xd0(%rbp,%rcx,4)
mov    %eax,%ecx
movslq -0x18(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
movslq -0x14(%rbp),%rax
movl   $0x1,-0xd0(%rbp,%rax,4)
jmp    11f4 <main+0xe4>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1189 <main+0x79>
jmp    1207 <main+0xf7>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1178 <main+0x68>
movq   $0x1,-0x20(%rbp)
movq   $0x1,-0x28(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x14,-0x14(%rbp)
jge    126b <main+0x15b>
movslq -0x14(%rbp),%rax
movslq -0x80(%rbp,%rax,4),%rax
imul   -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movslq -0x14(%rbp),%rax
movslq -0xd0(%rbp,%rax,4),%rax
ff
imul   -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    122c <main+0x11c>
mov    -0x20(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x28(%rbp)
mov    %rax,%rsi
lea    0xd7f(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
sub    $0xa8,%rsp
movaps 0xee2(%rip),%xmm0
movaps %xmm0,(%rsp)
movaps 0xee7(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xeeb(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xeef(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0xef3(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xef7(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0xefb(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0xeff(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
movaps 0xf00(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0xf04(%rip),%xmm0
movaps %xmm0,0x90(%rsp)
mov    $0x1,%esi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
jmp    11bf <main+0xaf>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x1,%esi
add    $0x1,%rdi
cmp    $0x14,%rdi
je     11e0 <main+0xd0>
cmp    $0x1,%esi
je     11b0 <main+0xa0>
mov    0x50(%rsp,%rdi,4),%eax
cltd
idiv   %esi
test   %edx,%edx
jne    11b5 <main+0xa5>
mov    %eax,0x50(%rsp,%rdi,4)
jmp    11b0 <main+0xa0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %esi,(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    $0x14,%rcx
je     11f2 <main+0xe2>
mov    (%rsp,%rcx,4),%esi
jmp    11a0 <main+0x90>
movslq 0x50(%rsp),%rax
movslq (%rsp),%rcx
movslq 0x54(%rsp),%rdx
imul   %rax,%rdx
movslq 0x4(%rsp),%rax
imul   %rcx,%rax
movslq 0x58(%rsp),%rcx
movslq 0x8(%rsp),%rsi
movslq 0x5c(%rsp),%rdi
imul   %rcx,%rdi
imul   %rdx,%rdi
movslq 0xc(%rsp),%rcx
imul   %rsi,%rcx
imul   %rax,%rcx
movslq 0x60(%rsp),%rax
movslq 0x10(%rsp),%rdx
movslq 0x64(%rsp),%rsi
imul   %rax,%rsi
movslq 0x14(%rsp),%rax
imul   %rdx,%rax
movslq 0x68(%rsp),%rdx
imul   %rsi,%rdx
imul   %rdi,%rdx
movslq 0x18(%rsp),%rsi
imul   %rax,%rsi
imul   %rcx,%rsi
movslq 0x6c(%rsp),%rax
movslq 0x1c(%rsp),%rcx
movslq 0x70(%rsp),%rdi
imul   %rax,%rdi
movslq 0x20(%rsp),%rax
imul   %rcx,%rax
movslq 0x74(%rsp),%rcx
imul   %rdi,%rcx
movslq 0x24(%rsp),%rdi
imul   %rax,%rdi
movslq 0x78(%rsp),%rax
imul   %rcx,%rax
imul   %rdx,%rax
movslq 0x28(%rsp),%rcx
imul   %rdi,%rcx
imul   %rsi,%rcx
movslq 0x7c(%rsp),%rdx
movslq 0x2c(%rsp),%rsi
movslq 0x80(%rsp),%rdi
imul   %rdx,%rdi
movslq 0x30(%rsp),%rdx
imul   %rsi,%rdx
movslq 0x84(%rsp),%rsi
imul   %rdi,%rsi
movslq 0x34(%rsp),%rdi
imul   %rdx,%rdi
movslq 0x88(%rsp),%rdx
imul   %rsi,%rdx
movslq 0x38(%rsp),%rsi
imul   %rdi,%rsi
movslq 0x8c(%rsp),%rdi
imul   %rdx,%rdi
imul   %rax,%rdi
movslq 0x3c(%rsp),%rdx
imul   %rsi,%rdx
imul   %rcx,%rdx
movslq 0x90(%rsp),%rax
movslq 0x40(%rsp),%rcx
movslq 0x94(%rsp),%rsi
imul   %rax,%rsi
movslq 0x44(%rsp),%rax
imul   %rcx,%rax
movslq 0x98(%rsp),%rcx
imul   %rsi,%rcx
movslq 0x48(%rsp),%rsi
imul   %rax,%rsi
movslq 0x9c(%rsp),%rax
imul   %rcx,%rax
imul   %rdi,%rax
movslq 0x4c(%rsp),%rcx
imul   %rsi,%rcx
imul   %rdx,%rcx
mov    %rax,%rdx
or     %rcx,%rdx
shr    $0x20,%rdx
je     137c <main+0x26c>
xor    %edx,%edx
div    %rcx
jmp    1380 <main+0x270>
xor    %edx,%edx
div    %ecx
lea    0xd19(%rip),%rdi
mov    %rax,%rsi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xa8,%rsp
ret

LLVM IR (-O0):
@.str = [6 x i8] c"%llu\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i64
%7 = alloca i64
store i32 0, i32* %1
store i32 20, i32* %2
%8 = call i8* @llvm.stacksave()
store i8* %8, i8** %3
%9 = alloca i32, i64 20
%10 = alloca i32, i64 20
store i32 0, i32* %4
br label %11
11: ; preds = %26, %0
%12 = load i32, i32* %4
%13 = icmp slt i32 %12, 20
br i1 %13, label %14, label %29
14: ; preds = %11
%15 = load i32, i32* %4
%16 = add nsw i32 %15, 1
%17 = load i32, i32* %4
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds i32, i32* %10, i64 %18
store i32 %16, i32* %19
%20 = load i32, i32* %4
%21 = add nsw i32 %20, 20
%22 = add nsw i32 %21, 1
%23 = load i32, i32* %4
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i32, i32* %9, i64 %24
store i32 %22, i32* %25
br label %26
26: ; preds = %14
%27 = load i32, i32* %4
%28 = add nsw i32 %27, 1
store i32 %28, i32* %4
br label %11
29: ; preds = %11
store i32 0, i32* %4
br label %30
30: ; preds = %75, %29
%31 = load i32, i32* %4
%32 = icmp slt i32 %31, 20
br i1 %32, label %33, label %78
33: ; preds = %30
store i32 0, i32* %5
br label %34
34: ; preds = %71, %33
%35 = load i32, i32* %5
%36 = icmp slt i32 %35, 20
br i1 %36, label %37, label %74
37: ; preds = %34
%38 = load i32, i32* %4
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i32, i32* %10, i64 %39
%41 = load i32, i32* %40
%42 = icmp ne i32 %41, 1
br i1 %42, label %43, label %70
43: ; preds = %37
%44 = load i32, i32* %5
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %9, i64 %45
%47 = load i32, i32* %46
%48 = load i32, i32* %4
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i32, i32* %10, i64 %49
%51 = load i32, i32* %50
%52 = srem i32 %47, %51
%53 = icmp ne i32 %52, 0
br i1 %53, label %70, label %54
54: ; preds = %43
%55 = load i32, i32* %5
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i32, i32* %9, i64 %56
%58 = load i32, i32* %57
%59 = load i32, i32* %4
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i32, i32* %10, i64 %60
%62 = load i32, i32* %61
%63 = sdiv i32 %58, %62
%64 = load i32, i32* %5
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i32, i32* %9, i64 %65
store i32 %63, i32* %66
%67 = load i32, i32* %4
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %10, i64 %68
store i32 1, i32* %69
br label %70
70: ; preds = %54, %43, %37
br label %71
71: ; preds = %70
%72 = load i32, i32* %5
%73 = add nsw i32 %72, 1
store i32 %73, i32* %5
br label %34
74: ; preds = %34
br label %75
75: ; preds = %74
%76 = load i32, i32* %4
%77 = add nsw i32 %76, 1
store i32 %77, i32* %4
br label %30
78: ; preds = %30
store i64 1, i64* %6
store i64 1, i64* %7
store i32 0, i32* %4
br label %79
79: ; preds = %97, %78
%80 = load i32, i32* %4
%81 = icmp slt i32 %80, 20
br i1 %81, label %82, label %100
82: ; preds = %79
%83 = load i32, i32* %4
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i32, i32* %9, i64 %84
%86 = load i32, i32* %85
%87 = sext i32 %86 to i64
%88 = load i64, i64* %6
%89 = mul i64 %88, %87
store i64 %89, i64* %6
%90 = load i32, i32* %4
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i32, i32* %10, i64 %91
%93 = load i32, i32* %92
%94 = sext i32 %93 to i64
%95 = load i64, i64* %7
%96 = mul i64 %95, %94
store i64 %96, i64* %7
br label %97
97: ; preds = %82
%98 = load i32, i32* %4
%99 = add nsw i32 %98, 1
store i32 %99, i32* %4
br label %79
100: ; preds = %79
%101 = load i64, i64* %6
%102 = load i64, i64* %7
%103 = udiv i64 %101, %102
%104 = call i32 @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i64 %103)
store i32 0, i32* %1
%105 = load i8*, i8** %3
%106 = load i32, i32* %1
ret i32 %106
}

LLVM IR (-O2):
@.str = [6 x i8] c"%llu\0A\00"
define i32 @main() {
%1 = alloca [20 x i32]
%2 = alloca [20 x i32]
%3 = bitcast [20 x i32]* %2 to <4 x i32>*
store <4 x i32> <i32 1, i32 2, i32 3, i32 4>, <4 x i32>* %3
%4 = bitcast [20 x i32]* %1 to <4 x i32>*
store <4 x i32> <i32 21, i32 22, i32 23, i32 24>, <4 x i32>* %4
%5 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 4
%6 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 4
%7 = bitcast i32* %5 to <4 x i32>*
store <4 x i32> <i32 5, i32 6, i32 7, i32 8>, <4 x i32>* %7
%8 = bitcast i32* %6 to <4 x i32>*
store <4 x i32> <i32 25, i32 26, i32 27, i32 28>, <4 x i32>* %8
%9 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 8
%10 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 8
%11 = bitcast i32* %9 to <4 x i32>*
store <4 x i32> <i32 9, i32 10, i32 11, i32 12>, <4 x i32>* %11
%12 = bitcast i32* %10 to <4 x i32>*
store <4 x i32> <i32 29, i32 30, i32 31, i32 32>, <4 x i32>* %12
%13 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 12
%14 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 12
%15 = bitcast i32* %13 to <4 x i32>*
store <4 x i32> <i32 13, i32 14, i32 15, i32 16>, <4 x i32>* %15
%16 = bitcast i32* %14 to <4 x i32>*
store <4 x i32> <i32 33, i32 34, i32 35, i32 36>, <4 x i32>* %16
%17 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 16
%18 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 16
%19 = bitcast i32* %17 to <4 x i32>*
store <4 x i32> <i32 17, i32 18, i32 19, i32 20>, <4 x i32>* %19
%20 = bitcast i32* %18 to <4 x i32>*
store <4 x i32> <i32 37, i32 38, i32 39, i32 40>, <4 x i32>* %20
br label %21
21: ; preds = %43, %0
%22 = phi i32 [ 1, %0 ], [ %45, %43 ]
%23 = phi i64 [ 0, %0 ], [ %41, %43 ]
%24 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %23
br label %25
25: ; preds = %21, %36
%26 = phi i64 [ 0, %21 ], [ %38, %36 ]
%27 = phi i32 [ %22, %21 ], [ %37, %36 ]
%28 = icmp eq i32 %27, 1
br i1 %28, label %36, label %29
29: ; preds = %25
%30 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 %26
%31 = load i32, i32* %30
%32 = srem i32 %31, %27
%33 = sdiv i32 %31, %27
%34 = icmp eq i32 %32, 0
br i1 %34, label %35, label %36
35: ; preds = %29
store i32 %33, i32* %30
br label %36
36: ; preds = %25, %29, %35
%37 = phi i32 [ 1, %25 ], [ %27, %29 ], [ 1, %35 ]
%38 = add nuw nsw i64 %26, 1
%39 = icmp eq i64 %38, 20
br i1 %39, label %40, label %25
40: ; preds = %36
store i32 %37, i32* %24
%41 = add nuw nsw i64 %23, 1
%42 = icmp eq i64 %41, 20
br i1 %42, label %46, label %43
43: ; preds = %40
%44 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %41
%45 = load i32, i32* %44
br label %21
46: ; preds = %40
%47 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 19
%48 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 19
%49 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 18
%50 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 18
%51 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 17
%52 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 17
%53 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 15
%54 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 15
%55 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 14
%56 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 14
%57 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 13
%58 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 13
%59 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 11
%60 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 11
%61 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 10
%62 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 10
%63 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 9
%64 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 9
%65 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 7
%66 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 7
%67 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 6
%68 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 6
%69 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 5
%70 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 5
%71 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 0
%72 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 3
%73 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 0
%74 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 3
%75 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 2
%76 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 2
%77 = getelementptr inbounds [20 x i32], [20 x i32]* %1, i64 0, i64 1
%78 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 1
%79 = load i32, i32* %71
%80 = sext i32 %79 to i64
%81 = load i32, i32* %73
%82 = sext i32 %81 to i64
%83 = load i32, i32* %77
%84 = sext i32 %83 to i64
%85 = mul nsw i64 %80, %84
%86 = load i32, i32* %78
%87 = sext i32 %86 to i64
%88 = mul nsw i64 %82, %87
%89 = load i32, i32* %75
%90 = sext i32 %89 to i64
%91 = mul i64 %85, %90
%92 = load i32, i32* %76
%93 = sext i32 %92 to i64
%94 = mul i64 %88, %93
%95 = load i32, i32* %72
%96 = sext i32 %95 to i64
%97 = mul i64 %91, %96
%98 = load i32, i32* %74
%99 = sext i32 %98 to i64
%100 = mul i64 %94, %99
%101 = load i32, i32* %6
%102 = sext i32 %101 to i64
%103 = mul i64 %97, %102
%104 = load i32, i32* %5
%105 = sext i32 %104 to i64
%106 = mul i64 %100, %105
%107 = load i32, i32* %69
%108 = sext i32 %107 to i64
%109 = mul i64 %103, %108
%110 = load i32, i32* %70
%111 = sext i32 %110 to i64
%112 = mul i64 %106, %111
%113 = load i32, i32* %67
%114 = sext i32 %113 to i64
%115 = mul i64 %109, %114
%116 = load i32, i32* %68
%117 = sext i32 %116 to i64
%118 = mul i64 %112, %117
%119 = load i32, i32* %65
%120 = sext i32 %119 to i64
%121 = mul i64 %115, %120
%122 = load i32, i32* %66
%123 = sext i32 %122 to i64
%124 = mul i64 %118, %123
%125 = load i32, i32* %10
%126 = sext i32 %125 to i64
%127 = mul i64 %121, %126
%128 = load i32, i32* %9
%129 = sext i32 %128 to i64
%130 = mul i64 %124, %129
%131 = load i32, i32* %63
%132 = sext i32 %131 to i64
%133 = mul i64 %127, %132
%134 = load i32, i32* %64
%135 = sext i32 %134 to i64
%136 = mul i64 %130, %135
%137 = load i32, i32* %61
%138 = sext i32 %137 to i64
%139 = mul i64 %133, %138
%140 = load i32, i32* %62
%141 = sext i32 %140 to i64
%142 = mul i64 %136, %141
%143 = load i32, i32* %59
%144 = sext i32 %143 to i64
%145 = mul i64 %139, %144
%146 = load i32, i32* %60
%147 = sext i32 %146 to i64
%148 = mul i64 %142, %147
%149 = load i32, i32* %14
%150 = sext i32 %149 to i64
%151 = mul i64 %145, %150
%152 = load i32, i32* %13
%153 = sext i32 %152 to i64
%154 = mul i64 %148, %153
%155 = load i32, i32* %57
%156 = sext i32 %155 to i64
%157 = mul i64 %151, %156
%158 = load i32, i32* %58
%159 = sext i32 %158 to i64
%160 = mul i64 %154, %159
%161 = load i32, i32* %55
%162 = sext i32 %161 to i64
%163 = mul i64 %157, %162
%164 = load i32, i32* %56
%165 = sext i32 %164 to i64
%166 = mul i64 %160, %165
%167 = load i32, i32* %53
%168 = sext i32 %167 to i64
%169 = mul i64 %163, %168
%170 = load i32, i32* %54
%171 = sext i32 %170 to i64
%172 = mul i64 %166, %171
%173 = load i32, i32* %18
%174 = sext i32 %173 to i64
%175 = mul i64 %169, %174
%176 = load i32, i32* %17
%177 = sext i32 %176 to i64
%178 = mul i64 %172, %177
%179 = load i32, i32* %51
%180 = sext i32 %179 to i64
%181 = mul i64 %175, %180
%182 = load i32, i32* %52
%183 = sext i32 %182 to i64
%184 = mul i64 %178, %183
%185 = load i32, i32* %49
%186 = sext i32 %185 to i64
%187 = mul i64 %181, %186
%188 = load i32, i32* %50
%189 = sext i32 %188 to i64
%190 = mul i64 %184, %189
%191 = load i32, i32* %47
%192 = sext i32 %191 to i64
%193 = mul i64 %187, %192
%194 = load i32, i32* %48
%195 = sext i32 %194 to i64
%196 = mul i64 %190, %195
%197 = udiv i64 %193, %196
%198 = tail call i32 @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i64 %197)
ret i32 0
}