#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, ...);
main() {
  int v[35] = {2,  5,  29, 3,  26, 21, 14, 10, 9,  1,  30, 17,
               22, 25, 4,  27, 8,  19, 6,  16, 18, 7,  11, 12,
               20, 23, 15, 13, 28, 24, 5,  10, 15, 20, 25};
  int n = 35;
  int gap, i, j, temp;
  for (gap = n / 2; gap > 0; gap /= 2)
    for (i = gap; i < n; i++)
      for (j = i - gap; j >= 0 && v[j] > v[j + gap]; j -= gap) {
        temp = v[j];
        v[j] = v[j + gap];
        v[j + gap] = temp;
      }
  printf("\n");
  for (i = 0; i < n; i++)
    printf("%d ", v[i]);
  printf("\n");
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x90(%rbp),%rdi
lea    0xec0(%rip),%rsi
mov    $0x8c,%edx
call   1040 <memcpy@plt>
movl   $0x23,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x98(%rbp)
jle    129c <main+0x17c>
mov    -0x98(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x94(%rbp),%eax
jge    127e <main+0x15e>
mov    -0x9c(%rbp),%eax
sub    -0x98(%rbp),%eax
mov    %eax,-0xa0(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0xa0(%rbp)
mov    %al,-0xa5(%rbp)
jl     11e7 <main+0xc7>
movslq -0xa0(%rbp),%rax
mov    -0x90(%rbp,%rax,4),%eax
mov    -0xa0(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
cmp    -0x90(%rbp,%rcx,4),%eax
setg   %al
mov    %al,-0xa5(%rbp)
mov    -0xa5(%rbp),%al
test   $0x1,%al
jne    11fa <main+0xda>
jmp    1265 <main+0x145>
movslq -0xa0(%rbp),%rax
mov    -0x90(%rbp,%rax,4),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa0(%rbp),%eax
add    -0x98(%rbp),%eax
cltq
mov    -0x90(%rbp,%rax,4),%ecx
movslq -0xa0(%rbp),%rax
mov    %ecx,-0x90(%rbp,%rax,4)
mov    -0xa4(%rbp),%ecx
mov    -0xa0(%rbp),%eax
add    -0x98(%rbp),%eax
cltq
mov    %ecx,-0x90(%rbp,%rax,4)
mov    -0x98(%rbp),%ecx
mov    -0xa0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xa0(%rbp)
jmp    11a5 <main+0x85>
jmp    126a <main+0x14a>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1181 <main+0x61>
jmp    1283 <main+0x163>
mov    -0x98(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x98(%rbp)
jmp    1168 <main+0x48>
lea    0xde9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x94(%rbp),%eax
jge    12f6 <main+0x1d6>
movslq -0x9c(%rbp),%rax
mov    -0x90(%rbp,%rax,4),%esi
lea    0xdb3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    12b4 <main+0x194>
lea    0xd8f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x90,%rsp
lea    0xec1(%rip),%rsi
mov    %rsp,%rdi
mov    $0x8c,%edx
call   1050 <memcpy@plt>
xor    %eax,%eax
jmp    1159 <main+0x29>
add    $0x1,%rax
cmp    $0x12,%eax
je     1185 <main+0x55>
mov    (%rsp,%rax,4),%ecx
mov    0x44(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1150 <main+0x20>
mov    %edx,(%rsp,%rax,4)
mov    %ecx,0x44(%rsp,%rax,4)
cmp    $0x11,%rax
jb     1150 <main+0x20>
mov    -0x44(%rsp,%rax,4),%ecx
mov    (%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1150 <main+0x20>
mov    %edx,-0x44(%rsp,%rax,4)
mov    %ecx,(%rsp,%rax,4)
jmp    1150 <main+0x20>
xor    %eax,%eax
jmp    1199 <main+0x69>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    $0x1b,%eax
je     11f9 <main+0xc9>
mov    (%rsp,%rax,4),%ecx
mov    0x20(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1190 <main+0x60>
mov    %edx,(%rsp,%rax,4)
mov    %ecx,0x20(%rsp,%rax,4)
cmp    $0x8,%rax
jb     1190 <main+0x60>
mov    -0x20(%rsp,%rax,4),%ecx
mov    (%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1190 <main+0x60>
mov    %edx,-0x20(%rsp,%rax,4)
mov    %ecx,(%rsp,%rax,4)
cmp    $0x10,%rax
jb     1190 <main+0x60>
mov    -0x40(%rsp,%rax,4),%ecx
mov    -0x20(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1190 <main+0x60>
mov    %edx,-0x40(%rsp,%rax,4)
mov    %ecx,-0x20(%rsp,%rax,4)
cmp    $0x18,%rax
jb     1190 <main+0x60>
mov    -0x60(%rsp,%rax,4),%ecx
mov    -0x40(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1190 <main+0x60>
mov    %edx,-0x60(%rsp,%rax,4)
mov    %ecx,-0x40(%rsp,%rax,4)
jmp    1190 <main+0x60>
xor    %eax,%eax
jmp    120d <main+0xdd>
nopl   (%rax)
add    $0x1,%rax
cmp    $0x1f,%eax
je     12f0 <main+0x1c0>
mov    (%rsp,%rax,4),%ecx
mov    0x10(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1200 <main+0xd0>
mov    %edx,(%rsp,%rax,4)
mov    %ecx,0x10(%rsp,%rax,4)
cmp    $0x4,%rax
jb     1200 <main+0xd0>
mov    -0x10(%rsp,%rax,4),%ecx
mov    (%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1200 <main+0xd0>
mov    %edx,-0x10(%rsp,%rax,4)
mov    %ecx,(%rsp,%rax,4)
cmp    $0x8,%rax
jb     1200 <main+0xd0>
mov    -0x20(%rsp,%rax,4),%ecx
mov    -0x10(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1200 <main+0xd0>
mov    %edx,-0x20(%rsp,%rax,4)
mov    %ecx,-0x10(%rsp,%rax,4)
cmp    $0xc,%rax
jb     1200 <main+0xd0>
mov    -0x30(%rsp,%rax,4),%ecx
mov    -0x20(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1200 <main+0xd0>
mov    %edx,-0x30(%rsp,%rax,4)
mov    %ecx,-0x20(%rsp,%rax,4)
cmp    $0x10,%rax
jb     1200 <main+0xd0>
mov    -0x40(%rsp,%rax,4),%ecx
mov    -0x30(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1200 <main+0xd0>
mov    %edx,-0x40(%rsp,%rax,4)
mov    %ecx,-0x30(%rsp,%rax,4)
cmp    $0x14,%rax
jb     1200 <main+0xd0>
mov    -0x50(%rsp,%rax,4),%ecx
mov    -0x40(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1200 <main+0xd0>
mov    %edx,-0x50(%rsp,%rax,4)
mov    %ecx,-0x40(%rsp,%rax,4)
cmp    $0x18,%rax
jb     1200 <main+0xd0>
mov    -0x60(%rsp,%rax,4),%ecx
mov    -0x50(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1200 <main+0xd0>
mov    %edx,-0x60(%rsp,%rax,4)
mov    %ecx,-0x50(%rsp,%rax,4)
cmp    $0x1c,%rax
jb     1200 <main+0xd0>
mov    -0x70(%rsp,%rax,4),%ecx
mov    -0x60(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1200 <main+0xd0>
mov    %edx,-0x70(%rsp,%rax,4)
mov    %ecx,-0x60(%rsp,%rax,4)
jmp    1200 <main+0xd0>
mov    $0x2,%eax
jmp    1309 <main+0x1d9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    $0x23,%eax
je     132e <main+0x1fe>
mov    %rax,%rcx
nopl   0x0(%rax)
mov    -0x8(%rsp,%rcx,4),%edx
mov    (%rsp,%rcx,4),%esi
cmp    %esi,%edx
jle    1300 <main+0x1d0>
mov    %esi,-0x8(%rsp,%rcx,4)
mov    %edx,(%rsp,%rcx,4)
add    $0xfffffffffffffffe,%rcx
cmp    $0x1,%rcx
jg     1310 <main+0x1e0>
jmp    1300 <main+0x1d0>
mov    $0x1,%eax
jmp    1349 <main+0x219>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rax
cmp    $0x23,%eax
je     136a <main+0x23a>
mov    %rax,%rcx
nopl   0x0(%rax)
mov    -0x4(%rsp,%rcx,4),%edx
mov    (%rsp,%rcx,4),%esi
cmp    %esi,%edx
jle    1340 <main+0x210>
mov    %esi,-0x4(%rsp,%rcx,4)
mov    %edx,(%rsp,%rcx,4)
add    $0xffffffffffffffff,%rcx
jg     1350 <main+0x220>
jmp    1340 <main+0x210>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    (%rsp),%esi
lea    0xd0e(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x14(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x34(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x3c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x40(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x44(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x48(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x50(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x54(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x58(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x5c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x60(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x64(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x68(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x6c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x70(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x74(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x78(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x7c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x80(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x84(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x88(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0x90,%rsp
pop    %rbx
ret

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

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