#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*/ pivoting(float **, int, int);
int /*<<< orphan*/ printf(char *, ...);
void solve(float **arr, int n, int flag) {
  int i, j, k;
  float m, y;
  float x[n];
  for (k = 0; k < n - 1; k++) {
    if (flag)
      pivoting(arr, k, n);
    for (i = k + 1; i < n; i++) {
      m = arr[i][k] / arr[k][k];
      for (j = k; j <= n; j++)
        arr[i][j] -= m * arr[k][j];
    }
  }
  printf("\nUpper triangular Coefficient matrix and augmented matrix is :\n");
  for (j = 0; j < n; j++) {
    for (i = 0; i <= n; i++) {
      if (i == n)
        printf(" |  %f ", arr[j][i]);
      else
        printf("%f ", arr[j][i]);
    }
    printf("\n");
  }
  printf("\nSolutions of the Given Equations are :-\n");
  for (i = n - 1; i >= 0; i--) {
    y = 0;
    for (j = i + 1; j < n; j++)
      y += arr[i][j] * x[j];
    x[i] = (arr[i][n] - y) / arr[i][i];
  }
  for (i = 0; i < n; i++)
    printf("x[%d] = %f\n", i, x[i]);
}


x86 assembly (clang, -O0):
<solve>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0xc(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x30(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x40(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    125e <solve+0x13e>
cmpl   $0x0,-0x10(%rbp)
je     118a <solve+0x6a>
mov    -0x8(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0xc(%rbp),%edx
call   1040 <pivoting@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    124b <solve+0x12b>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1238 <solve+0x118>
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11d4 <solve+0xb4>
jmp    123d <solve+0x11d>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1193 <solve+0x73>
jmp    1250 <solve+0x130>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1160 <solve+0x40>
lea    0xd9b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1320 <solve+0x200>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1304 <solve+0x1e4>
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    12ca <solve+0x1aa>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd82(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
jmp    12f1 <solve+0x1d1>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd5a(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
jmp    12f6 <solve+0x1d6>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1286 <solve+0x166>
lea    0xd65(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1273 <solve+0x153>
lea    0xd21(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     13ea <solve+0x2ca>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13a0 <solve+0x280>
mov    -0x40(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x18(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1352 <solve+0x232>
mov    -0x40(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0xc(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x14(%rbp),%rdx
divss  (%rcx,%rdx,4),%xmm0
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1337 <solve+0x217>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    142d <solve+0x30d>
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%esi
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc5a(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13f1 <solve+0x2d1>
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<solve>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %edx,-0x4c(%rbp)
mov    %esi,%r13d
mov    %rsp,%rcx
lea    0xf(,%r13,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rsp
mov    %rsi,-0x30(%rbp)
cmp    $0x2,%esi
mov    %rdi,-0x38(%rbp)
jl     147b <solve+0x33b>
mov    -0x30(%rbp),%rax
add    $0xffffffff,%eax
mov    %rax,-0x70(%rbp)
lea    0x1(%r13),%r14
mov    %r13,%r11
not    %r11
lea    -0x8(%r13),%rax
mov    %rax,-0x58(%rbp)
mov    $0x1,%eax
mov    %rax,-0x48(%rbp)
mov    $0xd,%eax
mov    %rax,-0x40(%rbp)
xor    %ebx,%ebx
movaps 0xe44(%rip),%xmm7
mov    %r11,-0x60(%rbp)
jmp    11ed <solve+0xad>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addq   $0x1,-0x48(%rbp)
addq   $0x1,-0x40(%rbp)
addq   $0xffffffffffffffff,-0x58(%rbp)
mov    -0x80(%rbp),%rbx
cmp    -0x70(%rbp),%rbx
je     147b <solve+0x33b>
cmpl   $0x0,-0x4c(%rbp)
je     120d <solve+0xcd>
mov    %ebx,%esi
mov    -0x30(%rbp),%rdx
call   1060 <pivoting@plt>
movaps 0xdfb(%rip),%xmm7
mov    -0x60(%rbp),%r11
mov    -0x38(%rbp),%rdi
lea    0x1(%rbx),%rax
mov    %rax,-0x80(%rbp)
cmp    %r13,%rax
jae    11d0 <solve+0x90>
mov    -0x58(%rbp),%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %rbx,%r15
not    %r15
lea    (%r15,%r14,1),%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0xa0(%rbp)
shr    $0x3,%rcx
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x78(%rbp)
add    %r14,%r15
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
mov    (%rdi,%rbx,8),%rsi
mov    -0x48(%rbp),%r10
lea    (%rsi,%r10,4),%rax
mov    %rax,-0xa8(%rbp)
lea    (%rsi,%r14,4),%rax
mov    %rax,-0xb0(%rbp)
lea    0x1(%rbx),%r12
mov    %r15,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,-0x90(%rbp)
add    %rbx,%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0x40(%rbp),%rax
lea    (%rsi,%rax,4),%r9
jmp    12ad <solve+0x16d>
nopl   (%rax)
add    $0x1,%r10
cmp    %r13,%r10
je     11d0 <solve+0x90>
mov    (%rdi,%r10,8),%r8
movss  (%rsi,%rbx,4),%xmm1
movss  (%r8,%rbx,4),%xmm2
movaps %xmm2,%xmm0
xorps  %xmm7,%xmm0
divss  %xmm1,%xmm0
mulss  %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%r8,%rbx,4)
cmp    %r14,%r12
je     12a0 <solve+0x160>
mov    %r12,%rcx
cmp    $0x8,%r15
jb     1400 <solve+0x2c0>
mov    -0x48(%rbp),%rax
lea    (%r8,%rax,4),%rax
cmp    -0xb0(%rbp),%rax
jae    130b <solve+0x1cb>
lea    (%r8,%r14,4),%rax
mov    %r12,%rcx
cmp    %rax,-0xa8(%rbp)
jb     1400 <solve+0x2c0>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x8,-0xa0(%rbp)
08
jae    1324 <solve+0x1e4>
xor    %r11d,%r11d
jmp    13a7 <solve+0x267>
mov    -0x40(%rbp),%rax
lea    (%r8,%rax,4),%rdi
mov    -0x78(%rbp),%rax
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%r9,%r11,4),%xmm2
movups -0x20(%r9,%r11,4),%xmm3
mulps  %xmm1,%xmm2
movups -0x30(%rdi,%r11,4),%xmm4
addps  %xmm2,%xmm4
movups -0x20(%rdi,%r11,4),%xmm2
movups -0x10(%rdi,%r11,4),%xmm5
movups (%rdi,%r11,4),%xmm6
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm4,-0x30(%rdi,%r11,4)
movups %xmm3,-0x20(%rdi,%r11,4)
movups -0x10(%r9,%r11,4),%xmm2
movups (%r9,%r11,4),%xmm3
mulps  %xmm1,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm6,%xmm3
movups %xmm2,-0x10(%rdi,%r11,4)
movups %xmm3,(%rdi,%r11,4)
add    $0x10,%r11
add    $0xfffffffffffffffe,%rax
jne    1340 <solve+0x200>
testb  $0x1,-0x98(%rbp)
je     13e0 <solve+0x2a0>
add    %r12,%r11
movups (%rsi,%r11,4),%xmm2
movups 0x10(%rsi,%r11,4),%xmm3
movups (%r8,%r11,4),%xmm4
movups 0x10(%r8,%r11,4),%xmm5
mulps  %xmm1,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%r8,%r11,4)
movups %xmm3,0x10(%r8,%r11,4)
mov    -0x88(%rbp),%rcx
cmp    -0x90(%rbp),%r15
mov    -0x38(%rbp),%rdi
mov    -0x60(%rbp),%r11
je     12a0 <solve+0x160>
nopl   0x0(%rax)
mov    %r14d,%edx
sub    %ecx,%edx
mov    %rcx,%rax
test   $0x1,%dl
je     1426 <solve+0x2e6>
movss  (%rsi,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%r8,%rcx,4),%xmm1
movss  %xmm1,(%r8,%rcx,4)
lea    0x1(%rcx),%rax
not    %rcx
cmp    %r11,%rcx
je     12a0 <solve+0x160>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%r8,%rax,4),%xmm1
movss  %xmm1,(%r8,%rax,4)
movss  0x4(%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%r8,%rax,4),%xmm1
movss  %xmm1,0x4(%r8,%rax,4)
add    $0x2,%rax
cmp    %rax,%r14
jne    1440 <solve+0x300>
jmp    12a0 <solve+0x160>
lea    0xba2(%rip),%rdi
call   1040 <puts@plt>
mov    -0x30(%rbp),%rax
test   %eax,%eax
jle    1620 <solve+0x4e0>
lea    0x1(%rax),%r14d
xor    %ebx,%ebx
mov    -0x38(%rbp),%r12
nopl   (%rax)
mov    %r13,%r15
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
cmp    %r13,%r15
mov    (%r12,%rbx,8),%rax
lea    0xb56(%rip),%rdi
lea    0xb4b(%rip),%rcx
cmove  %rcx,%rdi
movss  (%rax,%r13,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%r13
cmp    %r13,%r14
jne    14b0 <solve+0x370>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%rbx
cmp    %r15,%rbx
mov    %r15,%r13
jne    14a0 <solve+0x360>
lea    0xb63(%rip),%rdi
call   1040 <puts@plt>
mov    -0x30(%rbp),%r14
test   %r14d,%r14d
mov    -0x68(%rbp),%r15
jle    166f <solve+0x52f>
mov    %r13,%r11
neg    %r11
lea    (%r15,%r13,4),%rcx
xor    %esi,%esi
mov    %r13,%r8
jmp    155b <solve+0x41b>
nopw   0x0(%rax,%rax,1)
movss  (%rbx,%r13,4),%xmm1
subss  %xmm0,%xmm1
divss  (%rbx,%r8,4),%xmm1
movss  %xmm1,(%r15,%r8,4)
add    $0x1,%esi
add    $0x1,%r11
add    $0xfffffffffffffffc,%rcx
cmp    $0x1,%r10
jle    163a <solve+0x4fa>
mov    %r8,%r10
add    $0xffffffffffffffff,%r8
mov    -0x38(%rbp),%rax
mov    -0x8(%rax,%r10,8),%rbx
xorps  %xmm0,%xmm0
cmp    %r13,%r10
jge    1530 <solve+0x3f0>
lea    -0x1(%rsi),%r9d
test   $0x3,%sil
je     15b4 <solve+0x474>
mov    %esi,%edx
and    $0x3,%edx
lea    (%rbx,%r10,4),%rax
xorps  %xmm0,%xmm0
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdi,4),%xmm1
mulss  (%rcx,%rdi,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %edi,%edx
jne    1590 <solve+0x450>
sub    %r11,%rdi
cmp    $0x3,%r9d
jae    15d0 <solve+0x490>
jmp    1530 <solve+0x3f0>
xorps  %xmm0,%xmm0
mov    %r10,%rdi
cmp    $0x3,%r9d
jb     1530 <solve+0x3f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rbx,%rdi,4),%xmm1
movss  0x4(%rbx,%rdi,4),%xmm2
mulss  (%r15,%rdi,4),%xmm1
mulss  0x4(%r15,%rdi,4),%xmm2
addss  %xmm0,%xmm1
movss  0x8(%rbx,%rdi,4),%xmm3
mulss  0x8(%r15,%rdi,4),%xmm3
addss  %xmm1,%xmm2
movss  0xc(%rbx,%rdi,4),%xmm0
mulss  0xc(%r15,%rdi,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%rdi
cmp    %edi,%r13d
jne    15d0 <solve+0x490>
jmp    1530 <solve+0x3f0>
lea    0xa3c(%rip),%rdi
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <puts@plt>
test   %r14d,%r14d
jle    166f <solve+0x52f>
xor    %ebx,%ebx
lea    0x9d0(%rip),%r14
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    %ebx,%esi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r13
jne    1650 <solve+0x510>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [64 x i8] c"\0AUpper triangular Coefficient matrix and augmented matrix is :\0A\00"
@.str.1 = [8 x i8] c" | %f \00"
@.str.2 = [4 x i8] c"%f \00"
@.str.3 = [2 x i8] c"\0A\00"
@.str.4 = [42 x i8] c"\0ASolutions of the Given Equations are :-\0A\00"
@.str.5 = [12 x i8] c"x[%d] = %f\0A\00"
define void @solve(float** %0, i32 %1, i32 %2) {
%4 = alloca float**
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca float
%11 = alloca float
%12 = alloca i8*
%13 = alloca i64
store float** %0, float*** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%14 = load i32, i32* %5
%15 = zext i32 %14 to i64
%16 = call i8* @llvm.stacksave()
store i8* %16, i8** %12
%17 = alloca float, i64 %15
store i64 %15, i64* %13
store i32 0, i32* %9
br label %18
18: ; preds = %93, %3
%19 = load i32, i32* %9
%20 = load i32, i32* %5
%21 = sub nsw i32 %20, 1
%22 = icmp slt i32 %19, %21
br i1 %22, label %23, label %96
23: ; preds = %18
%24 = load i32, i32* %6
%25 = icmp ne i32 %24, 0
br i1 %25, label %26, label %31
26: ; preds = %23
%27 = load float**, float*** %4
%28 = load i32, i32* %9
%29 = load i32, i32* %5
%30 = call i32 @pivoting(float** %27, i32 %28, i32 %29)
br label %31
31: ; preds = %26, %23
%32 = load i32, i32* %9
%33 = add nsw i32 %32, 1
store i32 %33, i32* %7
br label %34
34: ; preds = %89, %31
%35 = load i32, i32* %7
%36 = load i32, i32* %5
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %92
38: ; preds = %34
%39 = load float**, float*** %4
%40 = load i32, i32* %7
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds float*, float** %39, i64 %41
%43 = load float*, float** %42
%44 = load i32, i32* %9
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds float, float* %43, i64 %45
%47 = load float, float* %46
%48 = load float**, float*** %4
%49 = load i32, i32* %9
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds float*, float** %48, i64 %50
%52 = load float*, float** %51
%53 = load i32, i32* %9
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds float, float* %52, i64 %54
%56 = load float, float* %55
%57 = fdiv float %47, %56
store float %57, float* %10
%58 = load i32, i32* %9
store i32 %58, i32* %8
br label %59
59: ; preds = %85, %38
%60 = load i32, i32* %8
%61 = load i32, i32* %5
%62 = icmp sle i32 %60, %61
br i1 %62, label %63, label %88
63: ; preds = %59
%64 = load float, float* %10
%65 = load float**, float*** %4
%66 = load i32, i32* %9
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float*, float** %65, i64 %67
%69 = load float*, float** %68
%70 = load i32, i32* %8
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float, float* %69, i64 %71
%73 = load float, float* %72
%74 = load float**, float*** %4
%75 = load i32, i32* %7
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds float*, float** %74, i64 %76
%78 = load float*, float** %77
%79 = load i32, i32* %8
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds float, float* %78, i64 %80
%82 = load float, float* %81
%83 = fneg float %64
%84 = call float @llvm.fmuladd.f32(float %83, float %73, float %82)
store float %84, float* %81
br label %85
85: ; preds = %63
%86 = load i32, i32* %8
%87 = add nsw i32 %86, 1
store i32 %87, i32* %8
br label %59
88: ; preds = %59
br label %89
89: ; preds = %88
%90 = load i32, i32* %7
%91 = add nsw i32 %90, 1
store i32 %91, i32* %7
br label %34
92: ; preds = %34
br label %93
93: ; preds = %92
%94 = load i32, i32* %9
%95 = add nsw i32 %94, 1
store i32 %95, i32* %9
br label %18
96: ; preds = %18
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %8
br label %98
98: ; preds = %141, %96
%99 = load i32, i32* %8
%100 = load i32, i32* %5
%101 = icmp slt i32 %99, %100
br i1 %101, label %102, label %144
102: ; preds = %98
store i32 0, i32* %7
br label %103
103: ; preds = %136, %102
%104 = load i32, i32* %7
%105 = load i32, i32* %5
%106 = icmp sle i32 %104, %105
br i1 %106, label %107, label %139
107: ; preds = %103
%108 = load i32, i32* %7
%109 = load i32, i32* %5
%110 = icmp eq i32 %108, %109
br i1 %110, label %111, label %123
111: ; preds = %107
%112 = load float**, float*** %4
%113 = load i32, i32* %8
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds float*, float** %112, i64 %114
%116 = load float*, float** %115
%117 = load i32, i32* %7
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds float, float* %116, i64 %118
%120 = load float, float* %119
%121 = fpext float %120 to double
%122 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0), double %121)
br label %135
123: ; preds = %107
%124 = load float**, float*** %4
%125 = load i32, i32* %8
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds float*, float** %124, i64 %126
%128 = load float*, float** %127
%129 = load i32, i32* %7
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds float, float* %128, i64 %130
%132 = load float, float* %131
%133 = fpext float %132 to double
%134 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %133)
br label %135
135: ; preds = %123, %111
br label %136
136: ; preds = %135
%137 = load i32, i32* %7
%138 = add nsw i32 %137, 1
store i32 %138, i32* %7
br label %103
139: ; preds = %103
%140 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
br label %141
141: ; preds = %139
%142 = load i32, i32* %8
%143 = add nsw i32 %142, 1
store i32 %143, i32* %8
br label %98
144: ; preds = %98
%145 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.4, i64 0, i64 0))
%146 = load i32, i32* %5
%147 = sub nsw i32 %146, 1
store i32 %147, i32* %7
br label %148
148: ; preds = %202, %144
%149 = load i32, i32* %7
%150 = icmp sge i32 %149, 0
br i1 %150, label %151, label %205
151: ; preds = %148
store float 0.000000e+00, float* %11
%152 = load i32, i32* %7
%153 = add nsw i32 %152, 1
store i32 %153, i32* %8
br label %154
154: ; preds = %174, %151
%155 = load i32, i32* %8
%156 = load i32, i32* %5
%157 = icmp slt i32 %155, %156
br i1 %157, label %158, label %177
158: ; preds = %154
%159 = load float**, float*** %4
%160 = load i32, i32* %7
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds float*, float** %159, i64 %161
%163 = load float*, float** %162
%164 = load i32, i32* %8
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds float, float* %163, i64 %165
%167 = load float, float* %166
%168 = load i32, i32* %8
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %17, i64 %169
%171 = load float, float* %170
%172 = load float, float* %11
%173 = call float @llvm.fmuladd.f32(float %167, float %171, float %172)
store float %173, float* %11
br label %174
174: ; preds = %158
%175 = load i32, i32* %8
%176 = add nsw i32 %175, 1
store i32 %176, i32* %8
br label %154
177: ; preds = %154
%178 = load float**, float*** %4
%179 = load i32, i32* %7
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds float*, float** %178, i64 %180
%182 = load float*, float** %181
%183 = load i32, i32* %5
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds float, float* %182, i64 %184
%186 = load float, float* %185
%187 = load float, float* %11
%188 = fsub float %186, %187
%189 = load float**, float*** %4
%190 = load i32, i32* %7
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds float*, float** %189, i64 %191
%193 = load float*, float** %192
%194 = load i32, i32* %7
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds float, float* %193, i64 %195
%197 = load float, float* %196
%198 = fdiv float %188, %197
%199 = load i32, i32* %7
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds float, float* %17, i64 %200
store float %198, float* %201
br label %202
202: ; preds = %177
%203 = load i32, i32* %7
%204 = add nsw i32 %203, -1
store i32 %204, i32* %7
br label %148
205: ; preds = %148
store i32 0, i32* %7
br label %206
206: ; preds = %218, %205
%207 = load i32, i32* %7
%208 = load i32, i32* %5
%209 = icmp slt i32 %207, %208
br i1 %209, label %210, label %221
210: ; preds = %206
%211 = load i32, i32* %7
%212 = load i32, i32* %7
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds float, float* %17, i64 %213
%215 = load float, float* %214
%216 = fpext float %215 to double
%217 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i64 0, i64 0), i32 %211, double %216)
br label %218
218: ; preds = %210
%219 = load i32, i32* %7
%220 = add nsw i32 %219, 1
store i32 %220, i32* %7
br label %206
221: ; preds = %206
%222 = load i8*, i8** %12
ret void
}

LLVM IR (-O2):
@.str.1 = [8 x i8] c" | %f \00"
@.str.2 = [4 x i8] c"%f \00"
@.str.5 = [12 x i8] c"x[%d] = %f\0A\00"
@str = [63 x i8] c"\0AUpper triangular Coefficient matrix and augmented matrix is :\00"
@str.6 = [41 x i8] c"\0ASolutions of the Given Equations are :-\00"
define void @solve(float** %0, i32 %1, i32 %2) {
%4 = zext i32 %1 to i64
%5 = alloca float, i64 %4
%6 = icmp sgt i32 %1, 1
br i1 %6, label %7, label %172
7: ; preds = %3
%8 = add nsw i32 %1, -1
%9 = icmp eq i32 %2, 0
%10 = add nuw i32 %1, 1
%11 = zext i32 %1 to i64
%12 = zext i32 %8 to i64
%13 = zext i32 %10 to i64
%14 = sub nsw i64 0, %13
br label %18
15: ; preds = %169, %31
%16 = add nuw nsw i64 %19, 1
%17 = icmp eq i64 %32, %12
br i1 %17, label %172, label %18
18: ; preds = %7, %15
%19 = phi i64 [ 1, %7 ], [ %16, %15 ]
%20 = phi i64 [ 0, %7 ], [ %32, %15 ]
%21 = xor i64 %20, -1
%22 = add nsw i64 %21, %13
%23 = add i64 %22, -8
%24 = lshr i64 %23, 3
%25 = add nuw nsw i64 %24, 1
%26 = xor i64 %20, -1
%27 = add nsw i64 %26, %13
br i1 %9, label %31, label %28
28: ; preds = %18
%29 = trunc i64 %20 to i32
%30 = tail call i32 @pivoting(float** %0, i32 %29, i32 %1)
br label %31
31: ; preds = %28, %18
%32 = add nuw nsw i64 %20, 1
%33 = icmp ult i64 %32, %11
br i1 %33, label %34, label %15
34: ; preds = %31
%35 = getelementptr inbounds float*, float** %0, i64 %20
%36 = load float*, float** %35
%37 = getelementptr inbounds float, float* %36, i64 %20
%38 = getelementptr float, float* %36, i64 %19
%39 = getelementptr float, float* %36, i64 %13
%40 = add nuw nsw i64 %20, 1
%41 = icmp eq i64 %40, %13
%42 = icmp ult i64 %27, 8
%43 = and i64 %27, -8
%44 = add i64 %40, %43
%45 = and i64 %25, 1
%46 = icmp ult i64 %23, 8
%47 = and i64 %25, 4611686018427387902
%48 = icmp eq i64 %45, 0
%49 = icmp eq i64 %27, %43
br label %50
50: ; preds = %169, %34
%51 = phi i64 [ %19, %34 ], [ %170, %169 ]
%52 = getelementptr inbounds float*, float** %0, i64 %51
%53 = load float*, float** %52
%54 = load float, float* %37
%55 = getelementptr inbounds float, float* %53, i64 %20
%56 = load float, float* %55
%57 = fneg float %56
%58 = fdiv float %57, %54
%59 = getelementptr inbounds float, float* %53, i64 %20
%60 = tail call float @llvm.fmuladd.f32(float %58, float %54, float %56)
store float %60, float* %59
br i1 %41, label %169, label %61
61: ; preds = %50
br i1 %42, label %135, label %62
62: ; preds = %61
%63 = getelementptr float, float* %53, i64 %19
%64 = getelementptr float, float* %53, i64 %13
%65 = icmp ult float* %63, %39
%66 = icmp ult float* %38, %64
%67 = and i1 %65, %66
br i1 %67, label %135, label %68
68: ; preds = %62
%69 = insertelement <4 x float> poison, float %58, i64 0
%70 = shufflevector <4 x float> %69, <4 x float> poison, <4 x i32> zeroinitializer
%71 = insertelement <4 x float> poison, float %58, i64 0
%72 = shufflevector <4 x float> %71, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %46, label %114, label %73
73: ; preds = %68, %73
%74 = phi i64 [ %111, %73 ], [ 0, %68 ]
%75 = phi i64 [ %112, %73 ], [ 0, %68 ]
%76 = add i64 %40, %74
%77 = getelementptr inbounds float, float* %36, i64 %76
%78 = bitcast float* %77 to <4 x float>*
%79 = load <4 x float>, <4 x float>* %78
%80 = getelementptr inbounds float, float* %77, i64 4
%81 = bitcast float* %80 to <4 x float>*
%82 = load <4 x float>, <4 x float>* %81
%83 = getelementptr inbounds float, float* %53, i64 %76
%84 = bitcast float* %83 to <4 x float>*
%85 = load <4 x float>, <4 x float>* %84
%86 = getelementptr inbounds float, float* %83, i64 4
%87 = bitcast float* %86 to <4 x float>*
%88 = load <4 x float>, <4 x float>* %87
%89 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %70, <4 x float> %79, <4 x float> %85)
%90 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %72, <4 x float> %82, <4 x float> %88)
%91 = bitcast float* %83 to <4 x float>*
store <4 x float> %89, <4 x float>* %91
%92 = bitcast float* %86 to <4 x float>*
store <4 x float> %90, <4 x float>* %92
%93 = or i64 %74, 8
%94 = add i64 %40, %93
%95 = getelementptr inbounds float, float* %36, i64 %94
%96 = bitcast float* %95 to <4 x float>*
%97 = load <4 x float>, <4 x float>* %96
%98 = getelementptr inbounds float, float* %95, i64 4
%99 = bitcast float* %98 to <4 x float>*
%100 = load <4 x float>, <4 x float>* %99
%101 = getelementptr inbounds float, float* %53, i64 %94
%102 = bitcast float* %101 to <4 x float>*
%103 = load <4 x float>, <4 x float>* %102
%104 = getelementptr inbounds float, float* %101, i64 4
%105 = bitcast float* %104 to <4 x float>*
%106 = load <4 x float>, <4 x float>* %105
%107 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %70, <4 x float> %97, <4 x float> %103)
%108 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %72, <4 x float> %100, <4 x float> %106)
%109 = bitcast float* %101 to <4 x float>*
store <4 x float> %107, <4 x float>* %109
%110 = bitcast float* %104 to <4 x float>*
store <4 x float> %108, <4 x float>* %110
%111 = add nuw i64 %74, 16
%112 = add i64 %75, 2
%113 = icmp eq i64 %112, %47
br i1 %113, label %114, label %73
114: ; preds = %73, %68
%115 = phi i64 [ 0, %68 ], [ %111, %73 ]
br i1 %48, label %134, label %116
116: ; preds = %114
%117 = add i64 %40, %115
%118 = getelementptr inbounds float, float* %36, i64 %117
%119 = bitcast float* %118 to <4 x float>*
%120 = load <4 x float>, <4 x float>* %119
%121 = getelementptr inbounds float, float* %118, i64 4
%122 = bitcast float* %121 to <4 x float>*
%123 = load <4 x float>, <4 x float>* %122
%124 = getelementptr inbounds float, float* %53, i64 %117
%125 = bitcast float* %124 to <4 x float>*
%126 = load <4 x float>, <4 x float>* %125
%127 = getelementptr inbounds float, float* %124, i64 4
%128 = bitcast float* %127 to <4 x float>*
%129 = load <4 x float>, <4 x float>* %128
%130 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %70, <4 x float> %120, <4 x float> %126)
%131 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %72, <4 x float> %123, <4 x float> %129)
%132 = bitcast float* %124 to <4 x float>*
store <4 x float> %130, <4 x float>* %132
%133 = bitcast float* %127 to <4 x float>*
store <4 x float> %131, <4 x float>* %133
br label %134
134: ; preds = %114, %116
br i1 %49, label %169, label %135
135: ; preds = %62, %61, %134
%136 = phi i64 [ %40, %62 ], [ %40, %61 ], [ %44, %134 ]
%137 = sub i64 %13, %136
%138 = xor i64 %136, -1
%139 = and i64 %137, 1
%140 = icmp eq i64 %139, 0
br i1 %140, label %149, label %141
141: ; preds = %135
%142 = getelementptr inbounds float, float* %36, i64 %136
%143 = load float, float* %142
%144 = getelementptr inbounds float, float* %53, i64 %136
%145 = load float, float* %144
%146 = getelementptr inbounds float, float* %53, i64 %136
%147 = tail call float @llvm.fmuladd.f32(float %58, float %143, float %145)
store float %147, float* %146
%148 = add nuw nsw i64 %136, 1
br label %149
149: ; preds = %141, %135
%150 = phi i64 [ %136, %135 ], [ %148, %141 ]
%151 = icmp eq i64 %138, %14
br i1 %151, label %169, label %152
152: ; preds = %149, %152
%153 = phi i64 [ %167, %152 ], [ %150, %149 ]
%154 = getelementptr inbounds float, float* %36, i64 %153
%155 = load float, float* %154
%156 = getelementptr inbounds float, float* %53, i64 %153
%157 = load float, float* %156
%158 = getelementptr inbounds float, float* %53, i64 %153
%159 = tail call float @llvm.fmuladd.f32(float %58, float %155, float %157)
store float %159, float* %158
%160 = add nuw nsw i64 %153, 1
%161 = getelementptr inbounds float, float* %36, i64 %160
%162 = load float, float* %161
%163 = getelementptr inbounds float, float* %53, i64 %160
%164 = load float, float* %163
%165 = getelementptr inbounds float, float* %53, i64 %160
%166 = tail call float @llvm.fmuladd.f32(float %58, float %162, float %164)
store float %166, float* %165
%167 = add nuw nsw i64 %153, 2
%168 = icmp eq i64 %167, %13
br i1 %168, label %169, label %152
169: ; preds = %149, %152, %134, %50
%170 = add nuw nsw i64 %51, 1
%171 = icmp eq i64 %170, %4
br i1 %171, label %15, label %50
172: ; preds = %15, %3
%173 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str, i64 0, i64 0))
%174 = icmp sgt i32 %1, 0
br i1 %174, label %177, label %175
175: ; preds = %172
%176 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str.6, i64 0, i64 0))
br label %282
177: ; preds = %172
%178 = add nuw i32 %1, 1
%179 = zext i32 %178 to i64
br label %180
180: ; preds = %194, %177
%181 = phi i64 [ 0, %177 ], [ %196, %194 ]
%182 = getelementptr inbounds float*, float** %0, i64 %181
br label %183
183: ; preds = %180, %183
%184 = phi i64 [ 0, %180 ], [ %192, %183 ]
%185 = icmp eq i64 %184, %4
%186 = load float*, float** %182
%187 = select i1 %185, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0)
%188 = getelementptr inbounds float, float* %186, i64 %184
%189 = load float, float* %188
%190 = fpext float %189 to double
%191 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) %187, double %190)
%192 = add nuw nsw i64 %184, 1
%193 = icmp eq i64 %192, %179
br i1 %193, label %194, label %183
194: ; preds = %183
%195 = tail call i32 @putchar(i32 10)
%196 = add nuw nsw i64 %181, 1
%197 = icmp eq i64 %196, %4
br i1 %197, label %198, label %180
198: ; preds = %194
%199 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str.6, i64 0, i64 0))
br i1 %174, label %200, label %282
200: ; preds = %198
%201 = zext i32 %1 to i64
br label %202
202: ; preds = %200, %261
%203 = phi i32 [ 0, %200 ], [ %272, %261 ]
%204 = phi i64 [ %201, %200 ], [ %207, %261 ]
%205 = phi i64 [ %201, %200 ], [ %271, %261 ]
%206 = add i32 %203, -1
%207 = add nsw i64 %204, -1
%208 = icmp slt i64 %204, %201
%209 = getelementptr inbounds float*, float** %0, i64 %207
%210 = load float*, float** %209
br i1 %208, label %211, label %261
211: ; preds = %202
%212 = and i32 %203, 3
%213 = icmp eq i32 %212, 0
br i1 %213, label %226, label %214
214: ; preds = %211, %214
%215 = phi i64 [ %223, %214 ], [ %205, %211 ]
%216 = phi float [ %222, %214 ], [ 0.000000e+00, %211 ]
%217 = phi i32 [ %224, %214 ], [ 0, %211 ]
%218 = getelementptr inbounds float, float* %210, i64 %215
%219 = load float, float* %218
%220 = getelementptr inbounds float, float* %5, i64 %215
%221 = load float, float* %220
%222 = tail call float @llvm.fmuladd.f32(float %219, float %221, float %216)
%223 = add nsw i64 %215, 1
%224 = add i32 %217, 1
%225 = icmp eq i32 %224, %212
br i1 %225, label %226, label %214
226: ; preds = %214, %211
%227 = phi float [ undef, %211 ], [ %222, %214 ]
%228 = phi i64 [ %205, %211 ], [ %223, %214 ]
%229 = phi float [ 0.000000e+00, %211 ], [ %222, %214 ]
%230 = icmp ult i32 %206, 3
br i1 %230, label %261, label %232
231: ; preds = %261
br i1 %174, label %273, label %282
232: ; preds = %226, %232
%233 = phi i64 [ %258, %232 ], [ %228, %226 ]
%234 = phi float [ %257, %232 ], [ %229, %226 ]
%235 = getelementptr inbounds float, float* %210, i64 %233
%236 = load float, float* %235
%237 = getelementptr inbounds float, float* %5, i64 %233
%238 = load float, float* %237
%239 = tail call float @llvm.fmuladd.f32(float %236, float %238, float %234)
%240 = add nsw i64 %233, 1
%241 = getelementptr inbounds float, float* %210, i64 %240
%242 = load float, float* %241
%243 = getelementptr inbounds float, float* %5, i64 %240
%244 = load float, float* %243
%245 = tail call float @llvm.fmuladd.f32(float %242, float %244, float %239)
%246 = add nsw i64 %233, 2
%247 = getelementptr inbounds float, float* %210, i64 %246
%248 = load float, float* %247
%249 = getelementptr inbounds float, float* %5, i64 %246
%250 = load float, float* %249
%251 = tail call float @llvm.fmuladd.f32(float %248, float %250, float %245)
%252 = add nsw i64 %233, 3
%253 = getelementptr inbounds float, float* %210, i64 %252
%254 = load float, float* %253
%255 = getelementptr inbounds float, float* %5, i64 %252
%256 = load float, float* %255
%257 = tail call float @llvm.fmuladd.f32(float %254, float %256, float %251)
%258 = add nsw i64 %233, 4
%259 = trunc i64 %258 to i32
%260 = icmp eq i32 %259, %1
br i1 %260, label %261, label %232
261: ; preds = %226, %232, %202
%262 = phi float [ 0.000000e+00, %202 ], [ %227, %226 ], [ %257, %232 ]
%263 = getelementptr inbounds float, float* %210, i64 %201
%264 = load float, float* %263
%265 = fsub float %264, %262
%266 = getelementptr inbounds float, float* %210, i64 %207
%267 = load float, float* %266
%268 = fdiv float %265, %267
%269 = getelementptr inbounds float, float* %5, i64 %207
store float %268, float* %269
%270 = icmp sgt i64 %204, 1
%271 = add nsw i64 %205, -1
%272 = add i32 %203, 1
br i1 %270, label %202, label %231
273: ; preds = %231, %273
%274 = phi i64 [ %280, %273 ], [ 0, %231 ]
%275 = getelementptr inbounds float, float* %5, i64 %274
%276 = load float, float* %275
%277 = fpext float %276 to double
%278 = trunc i64 %274 to i32
%279 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i64 0, i64 0), i32 %278, double %277)
%280 = add nuw nsw i64 %274, 1
%281 = icmp eq i64 %280, %4
br i1 %281, label %282, label %273
282: ; preds = %273, %198, %175, %231
ret void
}