#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 *, ...);
int main(int argc, char **argv) {
  int counters[5] = {0, 1, 2, 3, 4};
  char letters[5] = {'a', 'b', 'c', 'd', 'e'};
  float sample_data[500] = {
      [0] = 100.0, [3] = 300.5, [1] = 500.5, [2] = 678.45};
  float more_data[] = {[0] = 1.0, [49] = 100.20, [99] = 456.34};
  int array_values[10] = {0, 1, 4, 9, 16};
  int i;
  for (i = 5; i < 10; ++i) {
    array_values[i] = i * i;
  }
  for (i = 0; i < 10; ++i) {
    printf("array_values[%i] = %i\n", i, array_values[i]);
  }
  char word[] = {'H', 'e', 'l', 'l', 'o', '!'};
  printf("word[] contains: ");
  for (i = 0; i < 6; ++i) {
    printf("%c", word[i]);
  }
  printf("\n");
  for (i = 0; i < 6; ++i) {
    printf("word[%i] = %c\n", i, word[i]);
  }
  int a[5][2] = {{0, 0}, {1, 2}, {2, 4}, {3, 6}, {4, 8}};
  int j;
  printf("\nMultidimensional arrays:\n");
  printf("a[1][1] is %i\n", a[1][1]);
  printf("\nThe entire array contains the following:\n\n");
  for (i = 0; i < 5; ++i) {
    for (j = 0; j < 2; ++j) {
      printf("a[%i][%i] = %i\n", i, j, a[i][j]);
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa20,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    0xed0(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    0xecd(%rip),%rax
mov    %rax,-0x28(%rbp)
mov    0xecb(%rip),%eax
mov    %eax,-0x20(%rbp)
mov    0xec6(%rip),%eax
mov    %eax,-0x35(%rbp)
mov    0xec1(%rip),%al
mov    %al,-0x31(%rbp)
lea    -0x810(%rbp),%rdi
xor    %esi,%esi
mov    $0x7d0,%edx
call   1040 <memset@plt>
movss  0xe83(%rip),%xmm0
movss  %xmm0,-0x810(%rbp)
ff
movss  0xe6f(%rip),%xmm0
movss  %xmm0,-0x80c(%rbp)
ff
movss  0xe5b(%rip),%xmm0
movss  %xmm0,-0x808(%rbp)
ff
movss  0xe47(%rip),%xmm0
movss  %xmm0,-0x804(%rbp)
ff
lea    -0x9a0(%rbp),%rdi
xor    %esi,%esi
mov    $0x190,%edx
call   1040 <memset@plt>
movss  0xe20(%rip),%xmm0
movss  %xmm0,-0x9a0(%rbp)
ff
movss  0xe0c(%rip),%xmm0
movss  %xmm0,-0x8dc(%rbp)
ff
movss  0xdf8(%rip),%xmm0
movss  %xmm0,-0x814(%rbp)
ff
lea    -0x9d0(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1040 <memset@plt>
movl   $0x1,-0x9cc(%rbp)
movl   $0x4,-0x9c8(%rbp)
movl   $0x9,-0x9c4(%rbp)
movl   $0x10,-0x9c0(%rbp)
movl   $0x5,-0x9d4(%rbp)
cmpl   $0xa,-0x9d4(%rbp)
jge    1291 <main+0x161>
mov    -0x9d4(%rbp),%ecx
imul   -0x9d4(%rbp),%ecx
movslq -0x9d4(%rbp),%rax
mov    %ecx,-0x9d0(%rbp,%rax,4)
mov    -0x9d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d4(%rbp)
jmp    1255 <main+0x125>
movl   $0x0,-0x9d4(%rbp)
cmpl   $0xa,-0x9d4(%rbp)
jge    12de <main+0x1ae>
mov    -0x9d4(%rbp),%esi
movslq -0x9d4(%rbp),%rax
mov    -0x9d0(%rbp,%rax,4),%edx
lea    0xda5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x9d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d4(%rbp)
jmp    129b <main+0x16b>
mov    0xd55(%rip),%eax
mov    %eax,-0x9da(%rbp)
mov    0xd4c(%rip),%ax
mov    %ax,-0x9d6(%rbp)
lea    0xd80(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9d4(%rbp)
cmpl   $0x6,-0x9d4(%rbp)
jge    134e <main+0x21e>
movslq -0x9d4(%rbp),%rax
movsbl -0x9da(%rbp,%rax,1),%esi
ff
lea    0xd5e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x9d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d4(%rbp)
jmp    1310 <main+0x1e0>
lea    0xda2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9d4(%rbp)
cmpl   $0x6,-0x9d4(%rbp)
jge    13aa <main+0x27a>
mov    -0x9d4(%rbp),%esi
movslq -0x9d4(%rbp),%rax
movsbl -0x9da(%rbp,%rax,1),%edx
ff
lea    0xd05(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x9d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d4(%rbp)
jmp    1366 <main+0x236>
lea    -0xa10(%rbp),%rdi
lea    0xc88(%rip),%rsi
mov    $0x28,%edx
call   1050 <memcpy@plt>
lea    0xcda(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xa04(%rbp),%esi
lea    0xce1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xce2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9d4(%rbp)
cmpl   $0x5,-0x9d4(%rbp)
jge    1486 <main+0x356>
movl   $0x0,-0xa14(%rbp)
cmpl   $0x2,-0xa14(%rbp)
jge    146d <main+0x33d>
mov    -0x9d4(%rbp),%esi
mov    -0xa14(%rbp),%edx
movslq -0x9d4(%rbp),%rcx
lea    -0xa10(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0xa14(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
lea    0xca7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xa14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa14(%rbp)
jmp    1413 <main+0x2e3>
jmp    1472 <main+0x342>
mov    -0x9d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d4(%rbp)
jmp    13fc <main+0x2cc>
xor    %eax,%eax
add    $0xa20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
lea    0xec8(%rip),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
xor    %edx,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x1,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x4,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x9,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x10,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x5,%esi
mov    $0x19,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x6,%esi
mov    $0x24,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x7,%esi
mov    $0x31,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x8,%esi
mov    $0x40,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x9,%esi
mov    $0x51,%edx
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xe16(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x48,%edi
call   1030 <putchar@plt>
mov    $0x65,%edi
call   1030 <putchar@plt>
mov    $0x6c,%edi
call   1030 <putchar@plt>
mov    $0x6c,%edi
call   1030 <putchar@plt>
mov    $0x6f,%edi
call   1030 <putchar@plt>
mov    $0x21,%edi
call   1030 <putchar@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xdd4(%rip),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x48,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x65,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x6c,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x6c,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x6f,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x5,%esi
mov    $0x21,%edx
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xd86(%rip),%rdi
call   1040 <puts@plt>
lea    0xd5b(%rip),%rdi
mov    $0x2,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xd81(%rip),%rdi
call   1040 <puts@plt>
lea    0xd4b(%rip),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x1,%edx
xor    %ecx,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
xor    %edx,%edx
mov    $0x1,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x1,%edx
mov    $0x2,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
xor    %edx,%edx
mov    $0x2,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x1,%edx
mov    $0x4,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x3,%esi
xor    %edx,%edx
mov    $0x3,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x6,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x4,%esi
xor    %edx,%edx
mov    $0x4,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    $0x8,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
pop    %rbx
ret

LLVM IR (-O0):
@__const.main.counters = [5 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4]
@__const.main.letters = [5 x i8] c"abcde"
@.str = [23 x i8] c"array_values[%i] = %i\0A\00"
@__const.main.word = [6 x i8] c"Hello!"
@.str.1 = [18 x i8] c"word[] contains: \00"
@.str.2 = [3 x i8] c"%c\00"
@.str.3 = [2 x i8] c"\0A\00"
@.str.4 = [15 x i8] c"word[%i] = %c\0A\00"
@__const.main.a = [5 x [2 x i32]] [[2 x i32] zeroinitializer, [2 x i32] [i32 1, i32 2], [2 x i32] [i32 2, i32 4], [2 x i32] [i32 3, i32 6], [2 x i32] [i32 4, i32 8]]
@.str.5 = [27 x i8] c"\0AMultidimensional arrays:\0A\00"
@.str.6 = [15 x i8] c"a[1][1] is %i\0A\00"
@.str.7 = [44 x i8] c"\0AThe entire array contains the following:\0A\0A\00"
@.str.8 = [16 x i8] c"a[%i][%i] = %i\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [5 x i32]
%7 = alloca [5 x i8]
%8 = alloca [500 x float]
%9 = alloca [100 x float]
%10 = alloca [10 x i32]
%11 = alloca i32
%12 = alloca [6 x i8]
%13 = alloca [5 x [2 x i32]]
%14 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%15 = bitcast [5 x i32]* %6 to i8*
%16 = bitcast [5 x i8]* %7 to i8*
%17 = bitcast [500 x float]* %8 to i8*
%18 = bitcast i8* %17 to <{ float, float, float, float, [496 x float] }>*
%19 = getelementptr inbounds <{ float, float, float, float, [496 x float] }>, <{ float, float, float, float, [496 x float] }>* %18, i32 0, i32 0
store float 1.000000e+02, float* %19
%20 = getelementptr inbounds <{ float, float, float, float, [496 x float] }>, <{ float, float, float, float, [496 x float] }>* %18, i32 0, i32 1
store float 5.005000e+02, float* %20
%21 = getelementptr inbounds <{ float, float, float, float, [496 x float] }>, <{ float, float, float, float, [496 x float] }>* %18, i32 0, i32 2
store float 0x40853399A0000000, float* %21
%22 = getelementptr inbounds <{ float, float, float, float, [496 x float] }>, <{ float, float, float, float, [496 x float] }>* %18, i32 0, i32 3
store float 3.005000e+02, float* %22
%23 = bitcast [100 x float]* %9 to i8*
%24 = bitcast i8* %23 to [100 x float]*
%25 = getelementptr inbounds [100 x float], [100 x float]* %24, i32 0, i32 0
store float 1.000000e+00, float* %25
%26 = getelementptr inbounds [100 x float], [100 x float]* %24, i32 0, i32 49
store float 0x40590CCCC0000000, float* %26
%27 = getelementptr inbounds [100 x float], [100 x float]* %24, i32 0, i32 99
store float 0x407C8570A0000000, float* %27
%28 = bitcast [10 x i32]* %10 to i8*
%29 = bitcast i8* %28 to [10 x i32]*
%30 = getelementptr inbounds [10 x i32], [10 x i32]* %29, i32 0, i32 1
store i32 1, i32* %30
%31 = getelementptr inbounds [10 x i32], [10 x i32]* %29, i32 0, i32 2
store i32 4, i32* %31
%32 = getelementptr inbounds [10 x i32], [10 x i32]* %29, i32 0, i32 3
store i32 9, i32* %32
%33 = getelementptr inbounds [10 x i32], [10 x i32]* %29, i32 0, i32 4
store i32 16, i32* %33
store i32 5, i32* %11
br label %34
34: ; preds = %44, %2
%35 = load i32, i32* %11
%36 = icmp slt i32 %35, 10
br i1 %36, label %37, label %47
37: ; preds = %34
%38 = load i32, i32* %11
%39 = load i32, i32* %11
%40 = mul nsw i32 %38, %39
%41 = load i32, i32* %11
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [10 x i32], [10 x i32]* %10, i64 0, i64 %42
store i32 %40, i32* %43
br label %44
44: ; preds = %37
%45 = load i32, i32* %11
%46 = add nsw i32 %45, 1
store i32 %46, i32* %11
br label %34
47: ; preds = %34
store i32 0, i32* %11
br label %48
48: ; preds = %58, %47
%49 = load i32, i32* %11
%50 = icmp slt i32 %49, 10
br i1 %50, label %51, label %61
51: ; preds = %48
%52 = load i32, i32* %11
%53 = load i32, i32* %11
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [10 x i32], [10 x i32]* %10, i64 0, i64 %54
%56 = load i32, i32* %55
%57 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 %52, i32 %56)
br label %58
58: ; preds = %51
%59 = load i32, i32* %11
%60 = add nsw i32 %59, 1
store i32 %60, i32* %11
br label %48
61: ; preds = %48
%62 = bitcast [6 x i8]* %12 to i8*
%63 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %11
br label %64
64: ; preds = %74, %61
%65 = load i32, i32* %11
%66 = icmp slt i32 %65, 6
br i1 %66, label %67, label %77
67: ; preds = %64
%68 = load i32, i32* %11
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [6 x i8], [6 x i8]* %12, i64 0, i64 %69
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
%73 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32 %72)
br label %74
74: ; preds = %67
%75 = load i32, i32* %11
%76 = add nsw i32 %75, 1
store i32 %76, i32* %11
br label %64
77: ; preds = %64
%78 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %11
br label %79
79: ; preds = %90, %77
%80 = load i32, i32* %11
%81 = icmp slt i32 %80, 6
br i1 %81, label %82, label %93
82: ; preds = %79
%83 = load i32, i32* %11
%84 = load i32, i32* %11
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [6 x i8], [6 x i8]* %12, i64 0, i64 %85
%87 = load i8, i8* %86
%88 = sext i8 %87 to i32
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i32 %83, i32 %88)
br label %90
90: ; preds = %82
%91 = load i32, i32* %11
%92 = add nsw i32 %91, 1
store i32 %92, i32* %11
br label %79
93: ; preds = %79
%94 = bitcast [5 x [2 x i32]]* %13 to i8*
%95 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.5, i64 0, i64 0))
%96 = getelementptr inbounds [5 x [2 x i32]], [5 x [2 x i32]]* %13, i64 0, i64 1
%97 = getelementptr inbounds [2 x i32], [2 x i32]* %96, i64 0, i64 1
%98 = load i32, i32* %97
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.6, i64 0, i64 0), i32 %98)
%100 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %11
br label %101
101: ; preds = %123, %93
%102 = load i32, i32* %11
%103 = icmp slt i32 %102, 5
br i1 %103, label %104, label %126
104: ; preds = %101
store i32 0, i32* %14
br label %105
105: ; preds = %119, %104
%106 = load i32, i32* %14
%107 = icmp slt i32 %106, 2
br i1 %107, label %108, label %122
108: ; preds = %105
%109 = load i32, i32* %11
%110 = load i32, i32* %14
%111 = load i32, i32* %11
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [5 x [2 x i32]], [5 x [2 x i32]]* %13, i64 0, i64 %112
%114 = load i32, i32* %14
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [2 x i32], [2 x i32]* %113, i64 0, i64 %115
%117 = load i32, i32* %116
%118 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i64 0, i64 0), i32 %109, i32 %110, i32 %117)
br label %119
119: ; preds = %108
%120 = load i32, i32* %14
%121 = add nsw i32 %120, 1
store i32 %121, i32* %14
br label %105
122: ; preds = %105
br label %123
123: ; preds = %122
%124 = load i32, i32* %11
%125 = add nsw i32 %124, 1
store i32 %125, i32* %11
br label %101
126: ; preds = %101
ret i32 0
}

LLVM IR (-O2):
@.str = [23 x i8] c"array_values[%i] = %i\0A\00"
@.str.1 = [18 x i8] c"word[] contains: \00"
@.str.4 = [15 x i8] c"word[%i] = %c\0A\00"
@.str.6 = [15 x i8] c"a[1][1] is %i\0A\00"
@.str.8 = [16 x i8] c"a[%i][%i] = %i\0A\00"
@str = [26 x i8] c"\0AMultidimensional arrays:\00"
@str.9 = [43 x i8] c"\0AThe entire array contains the following:\0A\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 0, i32 0)
%4 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 1, i32 1)
%5 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 2, i32 4)
%6 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 3, i32 9)
%7 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 4, i32 16)
%8 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 5, i32 25)
%9 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 6, i32 36)
%10 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 7, i32 49)
%11 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 8, i32 64)
%12 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 9, i32 81)
%13 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0))
%14 = tail call i32 @putchar(i32 72)
%15 = tail call i32 @putchar(i32 101)
%16 = tail call i32 @putchar(i32 108)
%17 = tail call i32 @putchar(i32 108)
%18 = tail call i32 @putchar(i32 111)
%19 = tail call i32 @putchar(i32 33)
%20 = tail call i32 @putchar(i32 10)
%21 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i32 0, i32 72)
%22 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i32 1, i32 101)
%23 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i32 2, i32 108)
%24 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i32 3, i32 108)
%25 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i32 4, i32 111)
%26 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i32 5, i32 33)
%27 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str, i64 0, i64 0))
%28 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.6, i64 0, i64 0), i32 2)
%29 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @str.9, i64 0, i64 0))
%30 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i64 0, i64 0), i32 0, i32 0, i32 0)
%31 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i64 0, i64 0), i32 0, i32 1, i32 0)
%32 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i64 0, i64 0), i32 1, i32 0, i32 1)
%33 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i64 0, i64 0), i32 1, i32 1, i32 2)
%34 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i64 0, i64 0), i32 2, i32 0, i32 2)
%35 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i64 0, i64 0), i32 2, i32 1, i32 4)
%36 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i64 0, i64 0), i32 3, i32 0, i32 3)
%37 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i64 0, i64 0), i32 3, i32 1, i32 6)
%38 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i64 0, i64 0), i32 4, i32 0, i32 4)
%39 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i64 0, i64 0), i32 4, i32 1, i32 8)
ret i32 0
}