#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 Lovasz_condition(float **, float **, int, int);
int /*<<< orphan*/ gram_schmidt(int, int **, float **, float **);
double norm_squared(float *, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ size_reduce(int **, float **, int, int);
int /*<<< orphan*/ swap(int **, int, int);
void LLL_Algorithm() {
  int n = 10, i, j;
  float short_vector[10], initial_vector[10];
  int lovasz_cond;
  float b_tilde[10][10], u[10][10];
  int basis[10][10] = {{88, 62, 15, 25, 17, 90, 15, 3, 85, 78},
                       {99, 18, 31, 59, 97, 13, 20, 42, 37, 72},
                       {22, 100, 61, 34, 7, 45, 51, 30, 61, 89},
                       {15, 94, 8, 86, 1, 8, 29, 10, 77, 79},
                       {73, 35, 65, 36, 13, 20, 39, 77, 18, 4},
                       {46, 58, 80, 53, 58, 48, 96, 16, 97, 47},
                       {21, 14, 23, 18, 88, 71, 72, 36, 49, 45},
                       {49, 12, 22, 65, 63, 53, 18, 85, 41, 22},
                       {65, 64, 8, 83, 51, 65, 60, 28, 56, 72},
                       {2, 78, 52, 14, 2, 32, 1, 56, 50, 57}};
  printf("The initial basis is\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("%d\t", basis[i][j]);
    }
    printf("\n");
  }
  for (i = 0; i < n; i++) {
    initial_vector[i] = basis[i][0];
  }
  printf("\n\nNorm squared of the initial b1 vector is %f\n\n",
         norm_squared(initial_vector, n));
  while (1 == 1) {
    gram_schmidt(n, basis, b_tilde, u);
    for (i = 0; i < n; i++) {
      size_reduce(basis, u, i, n);
      lovasz_cond = Lovasz_condition(b_tilde, u, i - 1, n);
      if (lovasz_cond == 0) {
        swap(basis, i - 1, n);
        break;
      }
    }
    if (lovasz_cond == 1) {
      break;
    }
  }
  printf("The final basis is\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("%d\t", basis[i][j]);
    }
    printf("\n");
  }
  for (i = 0; i < n; i++) {
    short_vector[i] = basis[i][0];
  }
  printf("\n\nNorm squared of the short vector is %f\n\n",
         norm_squared(short_vector, n));
}


x86 assembly (clang, -O0):
<LLL_Algorithm>:
push   %rbp
mov    %rsp,%rbp
sub    $0x530,%rsp
movl   $0xa,-0x4(%rbp)
lea    -0x530(%rbp),%rdi
lea    0xe70(%rip),%rsi
mov    $0x190,%edx
call   1080 <memcpy@plt>
lea    0xfef(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    121f <LLL_Algorithm+0xaf>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1203 <LLL_Algorithm+0x93>
movslq -0x8(%rbp),%rcx
lea    -0x530(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xfb8(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11c2 <LLL_Algorithm+0x52>
lea    0xfce(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11af <LLL_Algorithm+0x3f>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1260 <LLL_Algorithm+0xf0>
movslq -0x8(%rbp),%rcx
lea    -0x530(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
cvtsi2ssl (%rax),%xmm0
movslq -0x8(%rbp),%rax
movss  %xmm0,-0x70(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1226 <LLL_Algorithm+0xb6>
lea    -0x70(%rbp),%rdi
mov    -0x4(%rbp),%esi
call   1050 <norm_squared@plt>
lea    0xf37(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x4(%rbp),%edi
lea    -0x530(%rbp),%rsi
lea    -0x210(%rbp),%rdx
lea    -0x3a0(%rbp),%rcx
call   1040 <gram_schmidt@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1319 <LLL_Algorithm+0x1a9>
lea    -0x530(%rbp),%rdi
lea    -0x3a0(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    -0x4(%rbp),%ecx
call   1070 <size_reduce@plt>
lea    -0x210(%rbp),%rdi
lea    -0x3a0(%rbp),%rsi
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
mov    -0x4(%rbp),%ecx
call   1030 <Lovasz_condition@plt>
mov    %eax,-0x74(%rbp)
cmpl   $0x0,-0x74(%rbp)
jne    1306 <LLL_Algorithm+0x196>
lea    -0x530(%rbp),%rdi
mov    -0x8(%rbp),%esi
sub    $0x1,%esi
mov    -0x4(%rbp),%edx
call   1090 <swap@plt>
jmp    1319 <LLL_Algorithm+0x1a9>
jmp    130b <LLL_Algorithm+0x19b>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    129e <LLL_Algorithm+0x12e>
cmpl   $0x1,-0x74(%rbp)
jne    1328 <LLL_Algorithm+0x1b8>
jmp    132d <LLL_Algorithm+0x1bd>
jmp    127a <LLL_Algorithm+0x10a>
lea    0xea6(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13b2 <LLL_Algorithm+0x242>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1396 <LLL_Algorithm+0x226>
movslq -0x8(%rbp),%rcx
lea    -0x530(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xe25(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1355 <LLL_Algorithm+0x1e5>
lea    0xe3b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1342 <LLL_Algorithm+0x1d2>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13f3 <LLL_Algorithm+0x283>
movslq -0x8(%rbp),%rcx
lea    -0x530(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
cvtsi2ssl (%rax),%xmm0
movslq -0x8(%rbp),%rax
movss  %xmm0,-0x40(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13b9 <LLL_Algorithm+0x249>
lea    -0x40(%rbp),%rdi
mov    -0x4(%rbp),%esi
call   1050 <norm_squared@plt>
lea    0xde8(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
add    $0x530,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LLL_Algorithm>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x518,%rsp
lea    0xe7c(%rip),%rsi
lea    0x60(%rsp),%rdi
mov    $0x190,%edx
call   10a0 <memcpy@plt>
lea    0x1055(%rip),%rdi
call   1070 <puts@plt>
mov    $0x58,%esi
mov    $0x28,%ebp
lea    0xfe0(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x3c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x40(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x44(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x48(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x4c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x50(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x54(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x58(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x5c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
cmp    $0x190,%rbp
je     1278 <LLL_Algorithm+0xe8>
mov    0x60(%rsp,%rbp,1),%esi
add    $0x28,%rbp
jmp    11d0 <LLL_Algorithm+0x40>
movaps 0xd81(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0xd85(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movabs $0x4000000042820000,%rax
mov    %rax,0x50(%rsp)
lea    0x30(%rsp),%rdi
mov    $0xa,%esi
call   1060 <norm_squared@plt>
lea    0xeff(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
lea    0x60(%rsp),%r15
lea    0x380(%rsp),%r14
lea    0x1f0(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0xa,%edi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %rbx,%rcx
call   1050 <gram_schmidt@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
xor    %edx,%edx
mov    $0xa,%ecx
call   1090 <size_reduce@plt>
mov    $0xffffffff,%ebp
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0xffffffff,%edx
mov    $0xa,%ecx
call   1030 <Lovasz_condition@plt>
test   %eax,%eax
je     1520 <LLL_Algorithm+0x390>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x1,%edx
mov    $0xa,%ecx
call   1090 <size_reduce@plt>
xor    %ebp,%ebp
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %edx,%edx
mov    $0xa,%ecx
call   1030 <Lovasz_condition@plt>
test   %eax,%eax
je     1520 <LLL_Algorithm+0x390>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x2,%edx
mov    $0xa,%ecx
call   1090 <size_reduce@plt>
mov    $0x1,%ebp
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0x1,%edx
mov    $0xa,%ecx
call   1030 <Lovasz_condition@plt>
test   %eax,%eax
je     1520 <LLL_Algorithm+0x390>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x3,%edx
mov    $0xa,%ecx
call   1090 <size_reduce@plt>
mov    $0x2,%ebp
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0x2,%edx
mov    $0xa,%ecx
call   1030 <Lovasz_condition@plt>
test   %eax,%eax
je     1520 <LLL_Algorithm+0x390>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x4,%edx
mov    $0xa,%ecx
call   1090 <size_reduce@plt>
mov    $0x3,%ebp
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0x3,%edx
mov    $0xa,%ecx
call   1030 <Lovasz_condition@plt>
test   %eax,%eax
je     1520 <LLL_Algorithm+0x390>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x5,%edx
mov    $0xa,%ecx
call   1090 <size_reduce@plt>
mov    $0x4,%ebp
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0x4,%edx
mov    $0xa,%ecx
call   1030 <Lovasz_condition@plt>
test   %eax,%eax
je     1520 <LLL_Algorithm+0x390>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x6,%edx
mov    $0xa,%ecx
call   1090 <size_reduce@plt>
mov    $0x5,%ebp
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0x5,%edx
mov    $0xa,%ecx
call   1030 <Lovasz_condition@plt>
test   %eax,%eax
je     1520 <LLL_Algorithm+0x390>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x7,%edx
mov    $0xa,%ecx
call   1090 <size_reduce@plt>
mov    $0x6,%ebp
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0x6,%edx
mov    $0xa,%ecx
call   1030 <Lovasz_condition@plt>
test   %eax,%eax
je     1520 <LLL_Algorithm+0x390>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x8,%edx
mov    $0xa,%ecx
call   1090 <size_reduce@plt>
mov    $0x7,%ebp
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0x7,%edx
mov    $0xa,%ecx
call   1030 <Lovasz_condition@plt>
test   %eax,%eax
je     1520 <LLL_Algorithm+0x390>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    $0x9,%edx
mov    $0xa,%ecx
call   1090 <size_reduce@plt>
mov    $0x8,%ebp
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0x8,%edx
mov    $0xa,%ecx
call   1030 <Lovasz_condition@plt>
test   %eax,%eax
je     1520 <LLL_Algorithm+0x390>
nopl   0x0(%rax,%rax,1)
cmp    $0x1,%eax
jne    12e0 <LLL_Algorithm+0x150>
jmp    153a <LLL_Algorithm+0x3aa>
nopl   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebp,%esi
mov    $0xa,%edx
call   10b0 <swap@plt>
xor    %eax,%eax
cmp    $0x1,%eax
jne    12e0 <LLL_Algorithm+0x150>
lea    0xce3(%rip),%rdi
call   1070 <puts@plt>
mov    $0x24,%ebp
lea    0xc5e(%rip),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x3c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x40(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x44(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x48(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x4c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x50(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x54(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x58(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x5c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x60(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
add    $0x28,%rbp
cmp    $0x1b4,%rbp
jne    1560 <LLL_Algorithm+0x3d0>
movss  0x88(%rsp),%xmm0
movaps 0x100(%rsp),%xmm1
unpcklpd 0x60(%rsp),%xmm0
movss  0xb0(%rsp),%xmm2
movss  0xd8(%rsp),%xmm3
movlhps %xmm2,%xmm3
shufps $0x22,%xmm3,%xmm0
cvtdq2ps %xmm0,%xmm0
movaps %xmm0,(%rsp)
movss  0x128(%rsp),%xmm0
movlhps %xmm1,%xmm0
movss  0x150(%rsp),%xmm1
movss  0x178(%rsp),%xmm2
movlhps %xmm1,%xmm2
shufps $0x22,%xmm2,%xmm0
cvtdq2ps %xmm0,%xmm0
movaps %xmm0,0x10(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ssl 0x1a0(%rsp),%xmm0
movss  %xmm0,0x20(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ssl 0x1c8(%rsp),%xmm0
movss  %xmm0,0x24(%rsp)
mov    %rsp,%rdi
mov    $0xa,%esi
call   1060 <norm_squared@plt>
lea    0xb41(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
add    $0x518,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.LLL_Algorithm.basis = [10 x [10 x i32]] [[10 x i32] [i32 88, i32 62, i32 15, i32 25, i32 17, i32 90, i32 15, i32 3, i32 85, i32 78], [10 x i32] [i32 99, i32 18, i32 31, i32 59, i32 97, i32 13, i32 20, i32 42, i32 37, i32 72], [10 x i32] [i32 22, i32 100, i32 61, i32 34, i32 7, i32 45, i32 51, i32 30, i32 61, i32 89], [10 x i32] [i32 15, i32 94, i32 8, i32 86, i32 1, i32 8, i32 29, i32 10, i32 77, i32 79], [10 x i32] [i32 73, i32 35, i32 65, i32 36, i32 13, i32 20, i32 39, i32 77, i32 18, i32 4], [10 x i32] [i32 46, i32 58, i32 80, i32 53, i32 58, i32 48, i32 96, i32 16, i32 97, i32 47], [10 x i32] [i32 21, i32 14, i32 23, i32 18, i32 88, i32 71, i32 72, i32 36, i32 49, i32 45], [10 x i32] [i32 49, i32 12, i32 22, i32 65, i32 63, i32 53, i32 18, i32 85, i32 41, i32 22], [10 x i32] [i32 65, i32 64, i32 8, i32 83, i32 51, i32 65, i32 60, i32 28, i32 56, i32 72], [10 x i32] [i32 2, i32 78, i32 52, i32 14, i32 2, i32 32, i32 1, i32 56, i32 50, i32 57]]
@.str = [22 x i8] c"The initial basis is\0A\00"
@.str.1 = [4 x i8] c"%d\09\00"
@.str.2 = [2 x i8] c"\0A\00"
@.str.3 = [48 x i8] c"\0A\0ANorm squared of the initial b1 vector is %f\0A\0A\00"
@.str.4 = [20 x i8] c"The final basis is\0A\00"
@.str.5 = [43 x i8] c"\0A\0ANorm squared of the short vector is %f\0A\0A\00"
define void @LLL_Algorithm() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca [10 x float]
%5 = alloca [10 x float]
%6 = alloca i32
%7 = alloca [10 x [10 x float]]
%8 = alloca [10 x [10 x float]]
%9 = alloca [10 x [10 x i32]]
store i32 10, i32* %1
%10 = bitcast [10 x [10 x i32]]* %9 to i8*
%11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %2
br label %12
12: ; preds = %35, %0
%13 = load i32, i32* %2
%14 = load i32, i32* %1
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %38
16: ; preds = %12
store i32 0, i32* %3
br label %17
17: ; preds = %30, %16
%18 = load i32, i32* %3
%19 = load i32, i32* %1
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %33
21: ; preds = %17
%22 = load i32, i32* %2
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %9, i64 0, i64 %23
%25 = load i32, i32* %3
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [10 x i32], [10 x i32]* %24, i64 0, i64 %26
%28 = load i32, i32* %27
%29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %28)
br label %30
30: ; preds = %21
%31 = load i32, i32* %3
%32 = add nsw i32 %31, 1
store i32 %32, i32* %3
br label %17
33: ; preds = %17
%34 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %35
35: ; preds = %33
%36 = load i32, i32* %2
%37 = add nsw i32 %36, 1
store i32 %37, i32* %2
br label %12
38: ; preds = %12
store i32 0, i32* %2
br label %39
39: ; preds = %53, %38
%40 = load i32, i32* %2
%41 = load i32, i32* %1
%42 = icmp slt i32 %40, %41
br i1 %42, label %43, label %56
43: ; preds = %39
%44 = load i32, i32* %2
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %9, i64 0, i64 %45
%47 = getelementptr inbounds [10 x i32], [10 x i32]* %46, i64 0, i64 0
%48 = load i32, i32* %47
%49 = sitofp i32 %48 to float
%50 = load i32, i32* %2
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 %51
store float %49, float* %52
br label %53
53: ; preds = %43
%54 = load i32, i32* %2
%55 = add nsw i32 %54, 1
store i32 %55, i32* %2
br label %39
56: ; preds = %39
%57 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 0
%58 = load i32, i32* %1
%59 = call double @norm_squared(float* %57, i32 %58)
%60 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.3, i64 0, i64 0), double %59)
br label %61
61: ; preds = %56, %107
%62 = load i32, i32* %1
%63 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %9, i64 0, i64 0
%64 = bitcast [10 x i32]* %63 to i32**
%65 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %7, i64 0, i64 0
%66 = bitcast [10 x float]* %65 to float**
%67 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %8, i64 0, i64 0
%68 = bitcast [10 x float]* %67 to float**
%69 = call i32 @gram_schmidt(i32 %62, i32** %64, float** %66, float** %68)
store i32 0, i32* %2
br label %70
70: ; preds = %100, %61
%71 = load i32, i32* %2
%72 = load i32, i32* %1
%73 = icmp slt i32 %71, %72
br i1 %73, label %74, label %103
74: ; preds = %70
%75 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %9, i64 0, i64 0
%76 = bitcast [10 x i32]* %75 to i32**
%77 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %8, i64 0, i64 0
%78 = bitcast [10 x float]* %77 to float**
%79 = load i32, i32* %2
%80 = load i32, i32* %1
%81 = call i32 @size_reduce(i32** %76, float** %78, i32 %79, i32 %80)
%82 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %7, i64 0, i64 0
%83 = bitcast [10 x float]* %82 to float**
%84 = getelementptr inbounds [10 x [10 x float]], [10 x [10 x float]]* %8, i64 0, i64 0
%85 = bitcast [10 x float]* %84 to float**
%86 = load i32, i32* %2
%87 = sub nsw i32 %86, 1
%88 = load i32, i32* %1
%89 = call i32 @Lovasz_condition(float** %83, float** %85, i32 %87, i32 %88)
store i32 %89, i32* %6
%90 = load i32, i32* %6
%91 = icmp eq i32 %90, 0
br i1 %91, label %92, label %99
92: ; preds = %74
%93 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %9, i64 0, i64 0
%94 = bitcast [10 x i32]* %93 to i32**
%95 = load i32, i32* %2
%96 = sub nsw i32 %95, 1
%97 = load i32, i32* %1
%98 = call i32 @swap(i32** %94, i32 %96, i32 %97)
br label %103
99: ; preds = %74
br label %100
100: ; preds = %99
%101 = load i32, i32* %2
%102 = add nsw i32 %101, 1
store i32 %102, i32* %2
br label %70
103: ; preds = %92, %70
%104 = load i32, i32* %6
%105 = icmp eq i32 %104, 1
br i1 %105, label %106, label %107
106: ; preds = %103
br label %108
107: ; preds = %103
br label %61
108: ; preds = %106
%109 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.4, i64 0, i64 0))
store i32 0, i32* %2
br label %110
110: ; preds = %133, %108
%111 = load i32, i32* %2
%112 = load i32, i32* %1
%113 = icmp slt i32 %111, %112
br i1 %113, label %114, label %136
114: ; preds = %110
store i32 0, i32* %3
br label %115
115: ; preds = %128, %114
%116 = load i32, i32* %3
%117 = load i32, i32* %1
%118 = icmp slt i32 %116, %117
br i1 %118, label %119, label %131
119: ; preds = %115
%120 = load i32, i32* %2
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %9, i64 0, i64 %121
%123 = load i32, i32* %3
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [10 x i32], [10 x i32]* %122, i64 0, i64 %124
%126 = load i32, i32* %125
%127 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %126)
br label %128
128: ; preds = %119
%129 = load i32, i32* %3
%130 = add nsw i32 %129, 1
store i32 %130, i32* %3
br label %115
131: ; preds = %115
%132 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %133
133: ; preds = %131
%134 = load i32, i32* %2
%135 = add nsw i32 %134, 1
store i32 %135, i32* %2
br label %110
136: ; preds = %110
store i32 0, i32* %2
br label %137
137: ; preds = %151, %136
%138 = load i32, i32* %2
%139 = load i32, i32* %1
%140 = icmp slt i32 %138, %139
br i1 %140, label %141, label %154
141: ; preds = %137
%142 = load i32, i32* %2
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %9, i64 0, i64 %143
%145 = getelementptr inbounds [10 x i32], [10 x i32]* %144, i64 0, i64 0
%146 = load i32, i32* %145
%147 = sitofp i32 %146 to float
%148 = load i32, i32* %2
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 %149
store float %147, float* %150
br label %151
151: ; preds = %141
%152 = load i32, i32* %2
%153 = add nsw i32 %152, 1
store i32 %153, i32* %2
br label %137
154: ; preds = %137
%155 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 0
%156 = load i32, i32* %1
%157 = call double @norm_squared(float* %155, i32 %156)
%158 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.5, i64 0, i64 0), double %157)
ret void
}

LLVM IR (-O2):
@__const.LLL_Algorithm.basis = [10 x [10 x i32]] [[10 x i32] [i32 88, i32 62, i32 15, i32 25, i32 17, i32 90, i32 15, i32 3, i32 85, i32 78], [10 x i32] [i32 99, i32 18, i32 31, i32 59, i32 97, i32 13, i32 20, i32 42, i32 37, i32 72], [10 x i32] [i32 22, i32 100, i32 61, i32 34, i32 7, i32 45, i32 51, i32 30, i32 61, i32 89], [10 x i32] [i32 15, i32 94, i32 8, i32 86, i32 1, i32 8, i32 29, i32 10, i32 77, i32 79], [10 x i32] [i32 73, i32 35, i32 65, i32 36, i32 13, i32 20, i32 39, i32 77, i32 18, i32 4], [10 x i32] [i32 46, i32 58, i32 80, i32 53, i32 58, i32 48, i32 96, i32 16, i32 97, i32 47], [10 x i32] [i32 21, i32 14, i32 23, i32 18, i32 88, i32 71, i32 72, i32 36, i32 49, i32 45], [10 x i32] [i32 49, i32 12, i32 22, i32 65, i32 63, i32 53, i32 18, i32 85, i32 41, i32 22], [10 x i32] [i32 65, i32 64, i32 8, i32 83, i32 51, i32 65, i32 60, i32 28, i32 56, i32 72], [10 x i32] [i32 2, i32 78, i32 52, i32 14, i32 2, i32 32, i32 1, i32 56, i32 50, i32 57]]
@.str.1 = [4 x i8] c"%d\09\00"
@.str.3 = [48 x i8] c"\0A\0ANorm squared of the initial b1 vector is %f\0A\0A\00"
@.str.5 = [43 x i8] c"\0A\0ANorm squared of the short vector is %f\0A\0A\00"
@str = [21 x i8] c"The initial basis is\00"
@str.6 = [19 x i8] c"The final basis is\00"
define void @LLL_Algorithm() {
%1 = alloca [10 x float]
%2 = alloca [10 x float]
%3 = alloca [10 x [10 x float]]
%4 = alloca [10 x [10 x float]]
%5 = alloca [10 x [10 x i32]]
%6 = bitcast [10 x float]* %1 to i8*
%7 = bitcast [10 x float]* %2 to i8*
%8 = bitcast [10 x [10 x float]]* %3 to i8*
%9 = bitcast [10 x [10 x float]]* %4 to i8*
%10 = bitcast [10 x [10 x i32]]* %5 to i8*
%11 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str, i64 0, i64 0))
br label %12
12: ; preds = %46, %0
%13 = phi i32 [ 88, %0 ], [ %48, %46 ]
%14 = phi i64 [ 0, %0 ], [ %44, %46 ]
%15 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %13)
%16 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %14, i64 1
%17 = load i32, i32* %16
%18 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %17)
%19 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %14, i64 2
%20 = load i32, i32* %19
%21 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %20)
%22 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %14, i64 3
%23 = load i32, i32* %22
%24 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %23)
%25 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %14, i64 4
%26 = load i32, i32* %25
%27 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %26)
%28 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %14, i64 5
%29 = load i32, i32* %28
%30 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %29)
%31 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %14, i64 6
%32 = load i32, i32* %31
%33 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %32)
%34 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %14, i64 7
%35 = load i32, i32* %34
%36 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %35)
%37 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %14, i64 8
%38 = load i32, i32* %37
%39 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %38)
%40 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %14, i64 9
%41 = load i32, i32* %40
%42 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %41)
%43 = tail call i32 @putchar(i32 10)
%44 = add nuw nsw i64 %14, 1
%45 = icmp eq i64 %44, 10
br i1 %45, label %49, label %46
46: ; preds = %12
%47 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %44, i64 0
%48 = load i32, i32* %47
br label %12
49: ; preds = %12
%50 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 0
%51 = bitcast [10 x float]* %2 to <4 x float>*
store <4 x float> <float 8.800000e+01, float 9.900000e+01, float 2.200000e+01, float 1.500000e+01>, <4 x float>* %51
%52 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 4
%53 = bitcast float* %52 to <4 x float>*
store <4 x float> <float 7.300000e+01, float 4.600000e+01, float 2.100000e+01, float 4.900000e+01>, <4 x float>* %53
%54 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 8
store float 6.500000e+01, float* %54
%55 = getelementptr inbounds [10 x float], [10 x float]* %2, i64 0, i64 9
store float 2.000000e+00, float* %55
%56 = call double @norm_squared(float* %50, i32 10)
%57 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.3, i64 0, i64 0), double %56)
%58 = bitcast [10 x [10 x i32]]* %5 to i32**
%59 = bitcast [10 x [10 x float]]* %3 to float**
%60 = bitcast [10 x [10 x float]]* %4 to float**
br label %61
61: ; preds = %105, %49
%62 = call i32 @gram_schmidt(i32 10, i32** %58, float** %59, float** %60)
%63 = call i32 @size_reduce(i32** %58, float** %60, i32 0, i32 10)
%64 = call i32 @Lovasz_condition(float** %59, float** %60, i32 -1, i32 10)
%65 = icmp eq i32 %64, 0
br i1 %65, label %102, label %66
66: ; preds = %61
%67 = call i32 @size_reduce(i32** %58, float** %60, i32 1, i32 10)
%68 = call i32 @Lovasz_condition(float** %59, float** %60, i32 0, i32 10)
%69 = icmp eq i32 %68, 0
br i1 %69, label %102, label %70
70: ; preds = %66
%71 = call i32 @size_reduce(i32** %58, float** %60, i32 2, i32 10)
%72 = call i32 @Lovasz_condition(float** %59, float** %60, i32 1, i32 10)
%73 = icmp eq i32 %72, 0
br i1 %73, label %102, label %74
74: ; preds = %70
%75 = call i32 @size_reduce(i32** %58, float** %60, i32 3, i32 10)
%76 = call i32 @Lovasz_condition(float** %59, float** %60, i32 2, i32 10)
%77 = icmp eq i32 %76, 0
br i1 %77, label %102, label %78
78: ; preds = %74
%79 = call i32 @size_reduce(i32** %58, float** %60, i32 4, i32 10)
%80 = call i32 @Lovasz_condition(float** %59, float** %60, i32 3, i32 10)
%81 = icmp eq i32 %80, 0
br i1 %81, label %102, label %82
82: ; preds = %78
%83 = call i32 @size_reduce(i32** %58, float** %60, i32 5, i32 10)
%84 = call i32 @Lovasz_condition(float** %59, float** %60, i32 4, i32 10)
%85 = icmp eq i32 %84, 0
br i1 %85, label %102, label %86
86: ; preds = %82
%87 = call i32 @size_reduce(i32** %58, float** %60, i32 6, i32 10)
%88 = call i32 @Lovasz_condition(float** %59, float** %60, i32 5, i32 10)
%89 = icmp eq i32 %88, 0
br i1 %89, label %102, label %90
90: ; preds = %86
%91 = call i32 @size_reduce(i32** %58, float** %60, i32 7, i32 10)
%92 = call i32 @Lovasz_condition(float** %59, float** %60, i32 6, i32 10)
%93 = icmp eq i32 %92, 0
br i1 %93, label %102, label %94
94: ; preds = %90
%95 = call i32 @size_reduce(i32** %58, float** %60, i32 8, i32 10)
%96 = call i32 @Lovasz_condition(float** %59, float** %60, i32 7, i32 10)
%97 = icmp eq i32 %96, 0
br i1 %97, label %102, label %98
98: ; preds = %94
%99 = call i32 @size_reduce(i32** %58, float** %60, i32 9, i32 10)
%100 = call i32 @Lovasz_condition(float** %59, float** %60, i32 8, i32 10)
%101 = icmp eq i32 %100, 0
br i1 %101, label %102, label %105
102: ; preds = %98, %94, %90, %86, %82, %78, %74, %70, %66, %61
%103 = phi i32 [ -1, %61 ], [ 0, %66 ], [ 1, %70 ], [ 2, %74 ], [ 3, %78 ], [ 4, %82 ], [ 5, %86 ], [ 6, %90 ], [ 7, %94 ], [ 8, %98 ]
%104 = call i32 @swap(i32** %58, i32 %103, i32 10)
br label %105
105: ; preds = %98, %102
%106 = phi i32 [ 0, %102 ], [ %100, %98 ]
%107 = icmp eq i32 %106, 1
br i1 %107, label %108, label %61
108: ; preds = %105
%109 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str.6, i64 0, i64 0))
br label %110
110: ; preds = %108, %110
%111 = phi i64 [ 0, %108 ], [ %143, %110 ]
%112 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %111, i64 0
%113 = load i32, i32* %112
%114 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %113)
%115 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %111, i64 1
%116 = load i32, i32* %115
%117 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %116)
%118 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %111, i64 2
%119 = load i32, i32* %118
%120 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %119)
%121 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %111, i64 3
%122 = load i32, i32* %121
%123 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %122)
%124 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %111, i64 4
%125 = load i32, i32* %124
%126 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %125)
%127 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %111, i64 5
%128 = load i32, i32* %127
%129 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %128)
%130 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %111, i64 6
%131 = load i32, i32* %130
%132 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %131)
%133 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %111, i64 7
%134 = load i32, i32* %133
%135 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %134)
%136 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %111, i64 8
%137 = load i32, i32* %136
%138 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %137)
%139 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 %111, i64 9
%140 = load i32, i32* %139
%141 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %140)
%142 = call i32 @putchar(i32 10)
%143 = add nuw nsw i64 %111, 1
%144 = icmp eq i64 %143, 10
br i1 %144, label %145, label %110
145: ; preds = %110
%146 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 9, i64 0
%147 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 8, i64 0
%148 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 7, i64 0
%149 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 6, i64 0
%150 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 5, i64 0
%151 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 4, i64 0
%152 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 3, i64 0
%153 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 2, i64 0
%154 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %5, i64 0, i64 1, i64 0
%155 = bitcast [10 x [10 x i32]]* %5 to <4 x i32>*
%156 = load <4 x i32>, <4 x i32>* %155
%157 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 0
%158 = load i32, i32* %154
%159 = load i32, i32* %153
%160 = load i32, i32* %152
%161 = insertelement <4 x i32> %156, i32 %158, i64 1
%162 = insertelement <4 x i32> %161, i32 %159, i64 2
%163 = insertelement <4 x i32> %162, i32 %160, i64 3
%164 = sitofp <4 x i32> %163 to <4 x float>
%165 = bitcast [10 x float]* %1 to <4 x float>*
store <4 x float> %164, <4 x float>* %165
%166 = bitcast i32* %151 to <4 x i32>*
%167 = load <4 x i32>, <4 x i32>* %166
%168 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 4
%169 = load i32, i32* %150
%170 = load i32, i32* %149
%171 = load i32, i32* %148
%172 = insertelement <4 x i32> %167, i32 %169, i64 1
%173 = insertelement <4 x i32> %172, i32 %170, i64 2
%174 = insertelement <4 x i32> %173, i32 %171, i64 3
%175 = sitofp <4 x i32> %174 to <4 x float>
%176 = bitcast float* %168 to <4 x float>*
store <4 x float> %175, <4 x float>* %176
%177 = load i32, i32* %147
%178 = sitofp i32 %177 to float
%179 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 8
store float %178, float* %179
%180 = load i32, i32* %146
%181 = sitofp i32 %180 to float
%182 = getelementptr inbounds [10 x float], [10 x float]* %1, i64 0, i64 9
store float %181, float* %182
%183 = call double @norm_squared(float* %157, i32 10)
%184 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.5, i64 0, i64 0), double %183)
ret void
}