#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*/ bubblesort(int *, int);
int /*<<< orphan*/ getchar();
int /*<<< orphan*/ printf(char *);
main() {
  printf("===================");
  printf("\nBubble Sort Results\n");
  printf("===================");
  int i, j;
  int array1[800];
  int array2[1600];
  int array3[2400];
  int array4[3200];
  int array5[4000];
  for (i = 0; i < 800; i++) {
    array1[i] = 800 - i;
  }
  for (i = 0; i < 1600; i++) {
    array2[i] = 1600 - i;
  }
  for (i = 0; i < 2400; i++) {
    array3[i] = 2400 - i;
  }
  for (i = 0; i < 3200; i++) {
    array4[i] = 3200 - i;
  }
  for (i = 0; i < 4000; i++) {
    array5[i] = 4000 - i;
  }
  for (j = 1; j < 6; j++) {
    switch (j) {
    case 1: {
      bubblesort(array1, 800);
      break;
    }
    case 2: {
      bubblesort(array2, 1600);
      break;
    }
    case 3: {
      bubblesort(array3, 2400);
      break;
    }
    case 4: {
      bubblesort(array4, 3200);
      break;
    }
    case 5: {
      bubblesort(array5, 4000);
      break;
    }
    }
  }
  getchar();
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xbba0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xecb(%rip),%rdi
call   1030 <printf@plt>
lea    0xed3(%rip),%rdi
call   1030 <printf@plt>
lea    0xeb3(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0x320,-0x8(%rbp)
jge    119b <main+0x6b>
mov    $0x320,%ecx
sub    -0x8(%rbp),%ecx
movslq -0x8(%rbp),%rax
mov    %ecx,-0xc90(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    116d <main+0x3d>
movl   $0x0,-0x8(%rbp)
cmpl   $0x640,-0x8(%rbp)
jge    11d0 <main+0xa0>
mov    $0x640,%ecx
sub    -0x8(%rbp),%ecx
movslq -0x8(%rbp),%rax
mov    %ecx,-0x2590(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11a2 <main+0x72>
movl   $0x0,-0x8(%rbp)
cmpl   $0x960,-0x8(%rbp)
jge    1205 <main+0xd5>
mov    $0x960,%ecx
sub    -0x8(%rbp),%ecx
movslq -0x8(%rbp),%rax
mov    %ecx,-0x4b10(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11d7 <main+0xa7>
movl   $0x0,-0x8(%rbp)
cmpl   $0xc80,-0x8(%rbp)
jge    123a <main+0x10a>
mov    $0xc80,%ecx
sub    -0x8(%rbp),%ecx
movslq -0x8(%rbp),%rax
mov    %ecx,-0x7d10(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    120c <main+0xdc>
movl   $0x0,-0x8(%rbp)
cmpl   $0xfa0,-0x8(%rbp)
jge    126f <main+0x13f>
mov    $0xfa0,%ecx
sub    -0x8(%rbp),%ecx
movslq -0x8(%rbp),%rax
mov    %ecx,-0xbb90(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1241 <main+0x111>
movl   $0x1,-0xc(%rbp)
cmpl   $0x6,-0xc(%rbp)
jge    132b <main+0x1fb>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0xbb98(%rbp)
sub    $0x4,%eax
ja     1318 <main+0x1e8>
mov    -0xbb98(%rbp),%rax
lea    0xd5a(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    -0xc90(%rbp),%rdi
mov    $0x320,%esi
call   1050 <bubblesort@plt>
jmp    1318 <main+0x1e8>
lea    -0x2590(%rbp),%rdi
mov    $0x640,%esi
call   1050 <bubblesort@plt>
jmp    1318 <main+0x1e8>
lea    -0x4b10(%rbp),%rdi
mov    $0x960,%esi
call   1050 <bubblesort@plt>
jmp    1318 <main+0x1e8>
lea    -0x7d10(%rbp),%rdi
mov    $0xc80,%esi
call   1050 <bubblesort@plt>
jmp    1318 <main+0x1e8>
lea    -0xbb90(%rbp),%rdi
mov    $0xfa0,%esi
call   1050 <bubblesort@plt>
jmp    131d <main+0x1ed>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1276 <main+0x146>
mov    $0x0,%al
call   1040 <getchar@plt>
mov    -0x4(%rbp),%eax
add    $0xbba0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0xbb80,%rsp
lea    0x1151(%rip),%rbx
mov    %rbx,%rdi
call   1040 <printf@plt>
lea    0x1156(%rip),%rdi
call   1030 <puts@plt>
mov    %rbx,%rdi
call   1040 <printf@plt>
movdqa 0xe8d(%rip),%xmm1
mov    $0x1c,%eax
movdqa 0xe8f(%rip),%xmm8
movdqa 0xe96(%rip),%xmm9
movdqa 0xe9d(%rip),%xmm10
movdqa 0xea4(%rip),%xmm11
movdqa 0xeac(%rip),%xmm6
movdqa 0xeb4(%rip),%xmm7
movdqa 0xebc(%rip),%xmm2
movdqa 0xec4(%rip),%xmm3
movdqa 0xecc(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm8,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm9,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,-0x70(%rsp,%rax,4)
movdqa %xmm5,-0x60(%rsp,%rax,4)
movdqa %xmm10,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm11,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,-0x50(%rsp,%rax,4)
movdqa %xmm5,-0x40(%rsp,%rax,4)
movdqa %xmm6,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm7,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,-0x30(%rsp,%rax,4)
movdqa %xmm5,-0x20(%rsp,%rax,4)
movdqa %xmm2,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm3,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,-0x10(%rsp,%rax,4)
movdqa %xmm5,(%rsp,%rax,4)
paddd  %xmm0,%xmm1
add    $0x20,%rax
cmp    $0x33c,%rax
jne    11d0 <main+0x90>
movdqa 0xda1(%rip),%xmm1
mov    $0x1c,%eax
movdqa 0xe33(%rip),%xmm8
movdqa 0xe3a(%rip),%xmm9
movdqa 0xe41(%rip),%xmm10
movdqa 0xe48(%rip),%xmm11
movdqa 0xe50(%rip),%xmm6
movdqa 0xe58(%rip),%xmm7
movdqa 0xe60(%rip),%xmm2
movdqa 0xe68(%rip),%xmm3
nopl   0x0(%rax,%rax,1)
movdqa %xmm8,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm9,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0xc10(%rsp,%rax,4)
movdqa %xmm5,0xc20(%rsp,%rax,4)
movdqa %xmm10,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm11,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0xc30(%rsp,%rax,4)
movdqa %xmm5,0xc40(%rsp,%rax,4)
movdqa %xmm6,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm7,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0xc50(%rsp,%rax,4)
movdqa %xmm5,0xc60(%rsp,%rax,4)
movdqa %xmm2,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm3,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0xc70(%rsp,%rax,4)
movdqa %xmm5,0xc80(%rsp,%rax,4)
paddd  %xmm0,%xmm1
add    $0x20,%rax
cmp    $0x65c,%rax
jne    12b0 <main+0x170>
movdqa 0xca8(%rip),%xmm1
mov    $0x1c,%eax
movdqa 0xdba(%rip),%xmm8
movdqa 0xdc1(%rip),%xmm9
movdqa 0xdc8(%rip),%xmm10
movdqa 0xdcf(%rip),%xmm11
movdqa 0xdd7(%rip),%xmm6
movdqa 0xddf(%rip),%xmm7
movdqa 0xde7(%rip),%xmm2
movdqa 0xdef(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa %xmm8,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm9,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0x2510(%rsp,%rax,4)
movdqa %xmm5,0x2520(%rsp,%rax,4)
movdqa %xmm10,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm11,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0x2530(%rsp,%rax,4)
movdqa %xmm5,0x2540(%rsp,%rax,4)
movdqa %xmm6,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm7,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0x2550(%rsp,%rax,4)
movdqa %xmm5,0x2560(%rsp,%rax,4)
movdqa %xmm2,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm3,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0x2570(%rsp,%rax,4)
movdqa %xmm5,0x2580(%rsp,%rax,4)
paddd  %xmm0,%xmm1
add    $0x20,%rax
cmp    $0x97c,%rax
jne    13b0 <main+0x270>
movdqa 0xba8(%rip),%xmm1
mov    $0x1c,%eax
movdqa 0xd3a(%rip),%xmm8
movdqa 0xd41(%rip),%xmm9
movdqa 0xd48(%rip),%xmm10
movdqa 0xd4f(%rip),%xmm11
movdqa 0xd57(%rip),%xmm6
movdqa 0xd5f(%rip),%xmm7
movdqa 0xd67(%rip),%xmm2
movdqa 0xd6f(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa %xmm8,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm9,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0x4a90(%rsp,%rax,4)
movdqa %xmm5,0x4aa0(%rsp,%rax,4)
movdqa %xmm10,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm11,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0x4ab0(%rsp,%rax,4)
movdqa %xmm5,0x4ac0(%rsp,%rax,4)
movdqa %xmm6,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm7,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0x4ad0(%rsp,%rax,4)
movdqa %xmm5,0x4ae0(%rsp,%rax,4)
movdqa %xmm2,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm3,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0x4af0(%rsp,%rax,4)
movdqa %xmm5,0x4b00(%rsp,%rax,4)
paddd  %xmm0,%xmm1
add    $0x20,%rax
cmp    $0xc9c,%rax
jne    14b0 <main+0x370>
movdqa 0xaa8(%rip),%xmm1
mov    $0x1c,%eax
movdqa 0xcba(%rip),%xmm8
movdqa 0xcc1(%rip),%xmm9
movdqa 0xcc8(%rip),%xmm10
movdqa 0xccf(%rip),%xmm11
movdqa 0xcd7(%rip),%xmm6
movdqa 0xcdf(%rip),%xmm7
movdqa 0xce7(%rip),%xmm2
movdqa 0xcef(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa %xmm8,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm9,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0x7c90(%rsp,%rax,4)
movdqa %xmm5,0x7ca0(%rsp,%rax,4)
movdqa %xmm10,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm11,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0x7cb0(%rsp,%rax,4)
movdqa %xmm5,0x7cc0(%rsp,%rax,4)
movdqa %xmm6,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm7,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0x7cd0(%rsp,%rax,4)
movdqa %xmm5,0x7ce0(%rsp,%rax,4)
movdqa %xmm2,%xmm4
psubd  %xmm1,%xmm4
movdqa %xmm3,%xmm5
psubd  %xmm1,%xmm5
movdqa %xmm4,0x7cf0(%rsp,%rax,4)
movdqa %xmm5,0x7d00(%rsp,%rax,4)
paddd  %xmm0,%xmm1
add    $0x20,%rax
cmp    $0xfbc,%rax
jne    15b0 <main+0x470>
mov    %rsp,%rdi
mov    $0x320,%esi
call   1060 <bubblesort@plt>
lea    0xc80(%rsp),%rdi
mov    $0x640,%esi
call   1060 <bubblesort@plt>
lea    0x2580(%rsp),%rdi
mov    $0x960,%esi
call   1060 <bubblesort@plt>
lea    0x4b00(%rsp),%rdi
mov    $0xc80,%esi
call   1060 <bubblesort@plt>
lea    0x7d00(%rsp),%rdi
mov    $0xfa0,%esi
call   1060 <bubblesort@plt>
xor    %eax,%eax
call   1050 <getchar@plt>
xor    %eax,%eax
add    $0xbb80,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
@.str = [20 x i8] c"===================\00"
@str = [21 x i8] c"\0ABubble Sort Results\00"
define i32 @main() {
%1 = alloca [800 x i32]
%2 = alloca [1600 x i32]
%3 = alloca [2400 x i32]
%4 = alloca [3200 x i32]
%5 = alloca [4000 x i32]
%6 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i64 0, i64 0))
%7 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str, i64 0, i64 0))
%8 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i64 0, i64 0))
%9 = bitcast [800 x i32]* %1 to i8*
%10 = bitcast [1600 x i32]* %2 to i8*
%11 = bitcast [2400 x i32]* %3 to i8*
%12 = bitcast [3200 x i32]* %4 to i8*
%13 = bitcast [4000 x i32]* %5 to i8*
br label %14
14: ; preds = %14, %0
%15 = phi i64 [ 0, %0 ], [ %44, %14 ]
%16 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %0 ], [ %45, %14 ]
%17 = getelementptr inbounds [800 x i32], [800 x i32]* %1, i64 0, i64 %15
%18 = sub <4 x i32> <i32 800, i32 800, i32 800, i32 800>, %16
%19 = sub <4 x i32> <i32 796, i32 796, i32 796, i32 796>, %16
%20 = bitcast i32* %17 to <4 x i32>*
store <4 x i32> %18, <4 x i32>* %20
%21 = getelementptr inbounds i32, i32* %17, i64 4
%22 = bitcast i32* %21 to <4 x i32>*
store <4 x i32> %19, <4 x i32>* %22
%23 = or i64 %15, 8
%24 = getelementptr inbounds [800 x i32], [800 x i32]* %1, i64 0, i64 %23
%25 = sub <4 x i32> <i32 792, i32 792, i32 792, i32 792>, %16
%26 = sub <4 x i32> <i32 788, i32 788, i32 788, i32 788>, %16
%27 = bitcast i32* %24 to <4 x i32>*
store <4 x i32> %25, <4 x i32>* %27
%28 = getelementptr inbounds i32, i32* %24, i64 4
%29 = bitcast i32* %28 to <4 x i32>*
store <4 x i32> %26, <4 x i32>* %29
%30 = or i64 %15, 16
%31 = getelementptr inbounds [800 x i32], [800 x i32]* %1, i64 0, i64 %30
%32 = sub <4 x i32> <i32 784, i32 784, i32 784, i32 784>, %16
%33 = sub <4 x i32> <i32 780, i32 780, i32 780, i32 780>, %16
%34 = bitcast i32* %31 to <4 x i32>*
store <4 x i32> %32, <4 x i32>* %34
%35 = getelementptr inbounds i32, i32* %31, i64 4
%36 = bitcast i32* %35 to <4 x i32>*
store <4 x i32> %33, <4 x i32>* %36
%37 = or i64 %15, 24
%38 = getelementptr inbounds [800 x i32], [800 x i32]* %1, i64 0, i64 %37
%39 = sub <4 x i32> <i32 776, i32 776, i32 776, i32 776>, %16
%40 = sub <4 x i32> <i32 772, i32 772, i32 772, i32 772>, %16
%41 = bitcast i32* %38 to <4 x i32>*
store <4 x i32> %39, <4 x i32>* %41
%42 = getelementptr inbounds i32, i32* %38, i64 4
%43 = bitcast i32* %42 to <4 x i32>*
store <4 x i32> %40, <4 x i32>* %43
%44 = add nuw nsw i64 %15, 32
%45 = add <4 x i32> %16, <i32 32, i32 32, i32 32, i32 32>
%46 = icmp eq i64 %44, 800
br i1 %46, label %47, label %14
47: ; preds = %14, %47
%48 = phi i64 [ %77, %47 ], [ 0, %14 ]
%49 = phi <4 x i32> [ %78, %47 ], [ <i32 0, i32 1, i32 2, i32 3>, %14 ]
%50 = getelementptr inbounds [1600 x i32], [1600 x i32]* %2, i64 0, i64 %48
%51 = sub <4 x i32> <i32 1600, i32 1600, i32 1600, i32 1600>, %49
%52 = sub <4 x i32> <i32 1596, i32 1596, i32 1596, i32 1596>, %49
%53 = bitcast i32* %50 to <4 x i32>*
store <4 x i32> %51, <4 x i32>* %53
%54 = getelementptr inbounds i32, i32* %50, i64 4
%55 = bitcast i32* %54 to <4 x i32>*
store <4 x i32> %52, <4 x i32>* %55
%56 = or i64 %48, 8
%57 = getelementptr inbounds [1600 x i32], [1600 x i32]* %2, i64 0, i64 %56
%58 = sub <4 x i32> <i32 1592, i32 1592, i32 1592, i32 1592>, %49
%59 = sub <4 x i32> <i32 1588, i32 1588, i32 1588, i32 1588>, %49
%60 = bitcast i32* %57 to <4 x i32>*
store <4 x i32> %58, <4 x i32>* %60
%61 = getelementptr inbounds i32, i32* %57, i64 4
%62 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> %59, <4 x i32>* %62
%63 = or i64 %48, 16
%64 = getelementptr inbounds [1600 x i32], [1600 x i32]* %2, i64 0, i64 %63
%65 = sub <4 x i32> <i32 1584, i32 1584, i32 1584, i32 1584>, %49
%66 = sub <4 x i32> <i32 1580, i32 1580, i32 1580, i32 1580>, %49
%67 = bitcast i32* %64 to <4 x i32>*
store <4 x i32> %65, <4 x i32>* %67
%68 = getelementptr inbounds i32, i32* %64, i64 4
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> %66, <4 x i32>* %69
%70 = or i64 %48, 24
%71 = getelementptr inbounds [1600 x i32], [1600 x i32]* %2, i64 0, i64 %70
%72 = sub <4 x i32> <i32 1576, i32 1576, i32 1576, i32 1576>, %49
%73 = sub <4 x i32> <i32 1572, i32 1572, i32 1572, i32 1572>, %49
%74 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> %72, <4 x i32>* %74
%75 = getelementptr inbounds i32, i32* %71, i64 4
%76 = bitcast i32* %75 to <4 x i32>*
store <4 x i32> %73, <4 x i32>* %76
%77 = add nuw nsw i64 %48, 32
%78 = add <4 x i32> %49, <i32 32, i32 32, i32 32, i32 32>
%79 = icmp eq i64 %77, 1600
br i1 %79, label %80, label %47
80: ; preds = %47, %80
%81 = phi i64 [ %110, %80 ], [ 0, %47 ]
%82 = phi <4 x i32> [ %111, %80 ], [ <i32 0, i32 1, i32 2, i32 3>, %47 ]
%83 = getelementptr inbounds [2400 x i32], [2400 x i32]* %3, i64 0, i64 %81
%84 = sub <4 x i32> <i32 2400, i32 2400, i32 2400, i32 2400>, %82
%85 = sub <4 x i32> <i32 2396, i32 2396, i32 2396, i32 2396>, %82
%86 = bitcast i32* %83 to <4 x i32>*
store <4 x i32> %84, <4 x i32>* %86
%87 = getelementptr inbounds i32, i32* %83, i64 4
%88 = bitcast i32* %87 to <4 x i32>*
store <4 x i32> %85, <4 x i32>* %88
%89 = or i64 %81, 8
%90 = getelementptr inbounds [2400 x i32], [2400 x i32]* %3, i64 0, i64 %89
%91 = sub <4 x i32> <i32 2392, i32 2392, i32 2392, i32 2392>, %82
%92 = sub <4 x i32> <i32 2388, i32 2388, i32 2388, i32 2388>, %82
%93 = bitcast i32* %90 to <4 x i32>*
store <4 x i32> %91, <4 x i32>* %93
%94 = getelementptr inbounds i32, i32* %90, i64 4
%95 = bitcast i32* %94 to <4 x i32>*
store <4 x i32> %92, <4 x i32>* %95
%96 = or i64 %81, 16
%97 = getelementptr inbounds [2400 x i32], [2400 x i32]* %3, i64 0, i64 %96
%98 = sub <4 x i32> <i32 2384, i32 2384, i32 2384, i32 2384>, %82
%99 = sub <4 x i32> <i32 2380, i32 2380, i32 2380, i32 2380>, %82
%100 = bitcast i32* %97 to <4 x i32>*
store <4 x i32> %98, <4 x i32>* %100
%101 = getelementptr inbounds i32, i32* %97, i64 4
%102 = bitcast i32* %101 to <4 x i32>*
store <4 x i32> %99, <4 x i32>* %102
%103 = or i64 %81, 24
%104 = getelementptr inbounds [2400 x i32], [2400 x i32]* %3, i64 0, i64 %103
%105 = sub <4 x i32> <i32 2376, i32 2376, i32 2376, i32 2376>, %82
%106 = sub <4 x i32> <i32 2372, i32 2372, i32 2372, i32 2372>, %82
%107 = bitcast i32* %104 to <4 x i32>*
store <4 x i32> %105, <4 x i32>* %107
%108 = getelementptr inbounds i32, i32* %104, i64 4
%109 = bitcast i32* %108 to <4 x i32>*
store <4 x i32> %106, <4 x i32>* %109
%110 = add nuw nsw i64 %81, 32
%111 = add <4 x i32> %82, <i32 32, i32 32, i32 32, i32 32>
%112 = icmp eq i64 %110, 2400
br i1 %112, label %113, label %80
113: ; preds = %80, %113
%114 = phi i64 [ %143, %113 ], [ 0, %80 ]
%115 = phi <4 x i32> [ %144, %113 ], [ <i32 0, i32 1, i32 2, i32 3>, %80 ]
%116 = getelementptr inbounds [3200 x i32], [3200 x i32]* %4, i64 0, i64 %114
%117 = sub <4 x i32> <i32 3200, i32 3200, i32 3200, i32 3200>, %115
%118 = sub <4 x i32> <i32 3196, i32 3196, i32 3196, i32 3196>, %115
%119 = bitcast i32* %116 to <4 x i32>*
store <4 x i32> %117, <4 x i32>* %119
%120 = getelementptr inbounds i32, i32* %116, i64 4
%121 = bitcast i32* %120 to <4 x i32>*
store <4 x i32> %118, <4 x i32>* %121
%122 = or i64 %114, 8
%123 = getelementptr inbounds [3200 x i32], [3200 x i32]* %4, i64 0, i64 %122
%124 = sub <4 x i32> <i32 3192, i32 3192, i32 3192, i32 3192>, %115
%125 = sub <4 x i32> <i32 3188, i32 3188, i32 3188, i32 3188>, %115
%126 = bitcast i32* %123 to <4 x i32>*
store <4 x i32> %124, <4 x i32>* %126
%127 = getelementptr inbounds i32, i32* %123, i64 4
%128 = bitcast i32* %127 to <4 x i32>*
store <4 x i32> %125, <4 x i32>* %128
%129 = or i64 %114, 16
%130 = getelementptr inbounds [3200 x i32], [3200 x i32]* %4, i64 0, i64 %129
%131 = sub <4 x i32> <i32 3184, i32 3184, i32 3184, i32 3184>, %115
%132 = sub <4 x i32> <i32 3180, i32 3180, i32 3180, i32 3180>, %115
%133 = bitcast i32* %130 to <4 x i32>*
store <4 x i32> %131, <4 x i32>* %133
%134 = getelementptr inbounds i32, i32* %130, i64 4
%135 = bitcast i32* %134 to <4 x i32>*
store <4 x i32> %132, <4 x i32>* %135
%136 = or i64 %114, 24
%137 = getelementptr inbounds [3200 x i32], [3200 x i32]* %4, i64 0, i64 %136
%138 = sub <4 x i32> <i32 3176, i32 3176, i32 3176, i32 3176>, %115
%139 = sub <4 x i32> <i32 3172, i32 3172, i32 3172, i32 3172>, %115
%140 = bitcast i32* %137 to <4 x i32>*
store <4 x i32> %138, <4 x i32>* %140
%141 = getelementptr inbounds i32, i32* %137, i64 4
%142 = bitcast i32* %141 to <4 x i32>*
store <4 x i32> %139, <4 x i32>* %142
%143 = add nuw nsw i64 %114, 32
%144 = add <4 x i32> %115, <i32 32, i32 32, i32 32, i32 32>
%145 = icmp eq i64 %143, 3200
br i1 %145, label %146, label %113
146: ; preds = %113, %146
%147 = phi i64 [ %176, %146 ], [ 0, %113 ]
%148 = phi <4 x i32> [ %177, %146 ], [ <i32 0, i32 1, i32 2, i32 3>, %113 ]
%149 = getelementptr inbounds [4000 x i32], [4000 x i32]* %5, i64 0, i64 %147
%150 = sub <4 x i32> <i32 4000, i32 4000, i32 4000, i32 4000>, %148
%151 = sub <4 x i32> <i32 3996, i32 3996, i32 3996, i32 3996>, %148
%152 = bitcast i32* %149 to <4 x i32>*
store <4 x i32> %150, <4 x i32>* %152
%153 = getelementptr inbounds i32, i32* %149, i64 4
%154 = bitcast i32* %153 to <4 x i32>*
store <4 x i32> %151, <4 x i32>* %154
%155 = or i64 %147, 8
%156 = getelementptr inbounds [4000 x i32], [4000 x i32]* %5, i64 0, i64 %155
%157 = sub <4 x i32> <i32 3992, i32 3992, i32 3992, i32 3992>, %148
%158 = sub <4 x i32> <i32 3988, i32 3988, i32 3988, i32 3988>, %148
%159 = bitcast i32* %156 to <4 x i32>*
store <4 x i32> %157, <4 x i32>* %159
%160 = getelementptr inbounds i32, i32* %156, i64 4
%161 = bitcast i32* %160 to <4 x i32>*
store <4 x i32> %158, <4 x i32>* %161
%162 = or i64 %147, 16
%163 = getelementptr inbounds [4000 x i32], [4000 x i32]* %5, i64 0, i64 %162
%164 = sub <4 x i32> <i32 3984, i32 3984, i32 3984, i32 3984>, %148
%165 = sub <4 x i32> <i32 3980, i32 3980, i32 3980, i32 3980>, %148
%166 = bitcast i32* %163 to <4 x i32>*
store <4 x i32> %164, <4 x i32>* %166
%167 = getelementptr inbounds i32, i32* %163, i64 4
%168 = bitcast i32* %167 to <4 x i32>*
store <4 x i32> %165, <4 x i32>* %168
%169 = or i64 %147, 24
%170 = getelementptr inbounds [4000 x i32], [4000 x i32]* %5, i64 0, i64 %169
%171 = sub <4 x i32> <i32 3976, i32 3976, i32 3976, i32 3976>, %148
%172 = sub <4 x i32> <i32 3972, i32 3972, i32 3972, i32 3972>, %148
%173 = bitcast i32* %170 to <4 x i32>*
store <4 x i32> %171, <4 x i32>* %173
%174 = getelementptr inbounds i32, i32* %170, i64 4
%175 = bitcast i32* %174 to <4 x i32>*
store <4 x i32> %172, <4 x i32>* %175
%176 = add nuw nsw i64 %147, 32
%177 = add <4 x i32> %148, <i32 32, i32 32, i32 32, i32 32>
%178 = icmp eq i64 %176, 4000
br i1 %178, label %179, label %146
179: ; preds = %146
%180 = getelementptr inbounds [4000 x i32], [4000 x i32]* %5, i64 0, i64 0
%181 = getelementptr inbounds [3200 x i32], [3200 x i32]* %4, i64 0, i64 0
%182 = getelementptr inbounds [2400 x i32], [2400 x i32]* %3, i64 0, i64 0
%183 = getelementptr inbounds [1600 x i32], [1600 x i32]* %2, i64 0, i64 0
%184 = getelementptr inbounds [800 x i32], [800 x i32]* %1, i64 0, i64 0
%185 = call i32 @bubblesort(i32* %184, i32 800)
%186 = call i32 @bubblesort(i32* %183, i32 1600)
%187 = call i32 @bubblesort(i32* %182, i32 2400)
%188 = call i32 @bubblesort(i32* %181, i32 3200)
%189 = call i32 @bubblesort(i32* %180, i32 4000)
%190 = call i32 (...) @getchar()
ret i32 0
}