#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 **malloc(int);
int maxSum(int **, int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, ...);
int main() {
  int **array;
  array = malloc(15 * sizeof(int));
  int i;
  for (i = 0; i < 15; i++) {
    array[i] = (int *)malloc(sizeof(int));
  }
  int array1[] = {75};
  int array2[] = {95, 64};
  int array3[] = {17, 47, 82};
  int array4[] = {18, 35, 87, 10};
  int array5[] = {20, 4, 82, 47, 65};
  int array6[] = {19, 1, 23, 75, 3, 34};
  int array7[] = {88, 2, 77, 73, 7, 63, 67};
  int array8[] = {99, 65, 4, 28, 6, 16, 70, 92};
  int array9[] = {41, 41, 26, 56, 83, 40, 80, 70, 33};
  int array10[] = {41, 48, 72, 33, 47, 32, 37, 16, 94, 29};
  int array11[] = {53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14};
  int array12[] = {70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57};
  int array13[] = {91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48};
  int array14[] = {63, 66, 4, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31};
  int array15[] = {4, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 4, 23};
  array[0] = array1;
  array[1] = array2;
  array[2] = array3;
  array[3] = array4;
  array[4] = array5;
  array[5] = array6;
  array[6] = array7;
  array[7] = array8;
  array[8] = array9;
  array[9] = array10;
  array[10] = array11;
  array[11] = array12;
  array[12] = array13;
  array[13] = array14;
  array[14] = array15;
  int steviloStolpcev = 15;
  int max = maxSum(array, 0, 0);
  printf("Maximum from top to the bottom of the triangle is:\n");
  printf("%d\n", max);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x3c,%edi
call   1060 <malloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0xf,-0x14(%rbp)
jge    1198 <main+0x58>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1167 <main+0x27>
mov    0xe62(%rip),%eax
mov    %eax,-0x18(%rbp)
mov    0xe5c(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    0xe5d(%rip),%rax
mov    %rax,-0x2c(%rbp)
mov    0xe5b(%rip),%eax
mov    %eax,-0x24(%rbp)
mov    0x1039(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0x1036(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0xe43(%rip),%rax
mov    %rax,-0x60(%rbp)
mov    0xe40(%rip),%rax
mov    %rax,-0x58(%rbp)
mov    0xe3e(%rip),%eax
mov    %eax,-0x50(%rbp)
mov    0xe44(%rip),%rax
mov    %rax,-0x80(%rbp)
mov    0xe41(%rip),%rax
mov    %rax,-0x78(%rbp)
mov    0xe3e(%rip),%rax
mov    %rax,-0x70(%rbp)
mov    0xe43(%rip),%rax
mov    %rax,-0xa0(%rbp)
mov    0xe3d(%rip),%rax
mov    %rax,-0x98(%rbp)
mov    0xe37(%rip),%rax
mov    %rax,-0x90(%rbp)
mov    0xe32(%rip),%eax
mov    %eax,-0x88(%rbp)
mov    0xfbd(%rip),%rax
mov    %rax,-0xc0(%rbp)
mov    0xfb7(%rip),%rax
mov    %rax,-0xb8(%rbp)
mov    0xfb1(%rip),%rax
mov    %rax,-0xb0(%rbp)
mov    0xfab(%rip),%rax
mov    %rax,-0xa8(%rbp)
lea    -0xf0(%rbp),%rdi
lea    0xdee(%rip),%rsi
mov    $0x24,%edx
call   1050 <memcpy@plt>
lea    -0x120(%rbp),%rdi
lea    0xe06(%rip),%rsi
mov    $0x28,%edx
call   1050 <memcpy@plt>
lea    -0x150(%rbp),%rdi
lea    0xe1e(%rip),%rsi
mov    $0x2c,%edx
call   1050 <memcpy@plt>
lea    -0x180(%rbp),%rdi
lea    0xe36(%rip),%rsi
mov    $0x30,%edx
call   1050 <memcpy@plt>
lea    -0x1c0(%rbp),%rdi
lea    0xe4e(%rip),%rsi
mov    $0x34,%edx
call   1050 <memcpy@plt>
lea    -0x200(%rbp),%rdi
lea    0xe76(%rip),%rsi
mov    $0x38,%edx
call   1050 <memcpy@plt>
lea    -0x240(%rbp),%rdi
lea    0xe9e(%rip),%rsi
mov    $0x3c,%edx
call   1050 <memcpy@plt>
lea    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
lea    -0x20(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x8(%rax)
lea    -0x2c(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x10(%rax)
lea    -0x40(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x18(%rax)
lea    -0x60(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x20(%rax)
lea    -0x80(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x28(%rax)
lea    -0xa0(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x30(%rax)
lea    -0xc0(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x38(%rax)
lea    -0xf0(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x40(%rax)
lea    -0x120(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x48(%rax)
lea    -0x150(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x50(%rax)
lea    -0x180(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x58(%rax)
lea    -0x1c0(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x60(%rax)
lea    -0x200(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x68(%rax)
lea    -0x240(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x70(%rax)
movl   $0xf,-0x244(%rbp)
mov    -0x10(%rbp),%rdi
xor    %edx,%edx
mov    %edx,%esi
call   1030 <maxSum@plt>
mov    %eax,-0x248(%rbp)
lea    0xe12(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x248(%rbp),%esi
lea    0xe32(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x250,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x230,%rsp
mov    $0x3c,%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    $0x4,%edi
call   1060 <malloc@plt>
movl   $0x4b,0x4(%rsp)
movabs $0x400000005f,%rax
mov    %rax,0x18(%rsp)
mov    0xe00(%rip),%eax
mov    %eax,0x10(%rsp)
mov    0xded(%rip),%rax
mov    %rax,0x8(%rsp)
movaps 0xfd1(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
mov    0xdf6(%rip),%eax
mov    %eax,0x30(%rsp)
movaps 0xddb(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
mov    0xdff(%rip),%rax
mov    %rax,0x50(%rsp)
movaps 0xde3(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movups 0xe03(%rip),%xmm0
movups %xmm0,0xac(%rsp)
movaps 0xde8(%rip),%xmm0
movaps %xmm0,0xa0(%rsp)
movaps 0xf99(%rip),%xmm0
movaps %xmm0,0x140(%rsp)
movaps 0xf7a(%rip),%xmm0
movaps %xmm0,0x130(%rsp)
mov    0xdfc(%rip),%eax
mov    %eax,0x90(%rsp)
movaps 0xdde(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
movaps 0xdbf(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
mov    0xe03(%rip),%rax
mov    %rax,0xe0(%rsp)
movaps 0xde4(%rip),%xmm0
movaps %xmm0,0xd0(%rsp)
movaps 0xdc5(%rip),%xmm0
movaps %xmm0,0xc0(%rsp)
movups 0xe02(%rip),%xmm0
movups %xmm0,0x16c(%rsp)
movaps 0xde7(%rip),%xmm0
movaps %xmm0,0x160(%rsp)
movaps 0xdc8(%rip),%xmm0
movaps %xmm0,0x150(%rsp)
movaps 0xe09(%rip),%xmm0
movaps %xmm0,0x220(%rsp)
movaps 0xdea(%rip),%xmm0
movaps %xmm0,0x210(%rsp)
movaps 0xdcb(%rip),%xmm0
movaps %xmm0,0x200(%rsp)
mov    0xe1d(%rip),%eax
mov    %eax,0x120(%rsp)
movaps 0xdff(%rip),%xmm0
movaps %xmm0,0x110(%rsp)
movaps 0xde0(%rip),%xmm0
movaps %xmm0,0x100(%rsp)
movaps 0xdc1(%rip),%xmm0
movaps %xmm0,0xf0(%rsp)
mov    0xe22(%rip),%rax
mov    %rax,0x1b0(%rsp)
movaps 0xe03(%rip),%xmm0
movaps %xmm0,0x1a0(%rsp)
movaps 0xde4(%rip),%xmm0
movaps %xmm0,0x190(%rsp)
movaps 0xdc5(%rip),%xmm0
movaps %xmm0,0x180(%rsp)
movups 0xe22(%rip),%xmm0
movups %xmm0,0x1ec(%rsp)
movaps 0xe07(%rip),%xmm0
movaps %xmm0,0x1e0(%rsp)
movaps 0xde8(%rip),%xmm0
movaps %xmm0,0x1d0(%rsp)
movaps 0xdc9(%rip),%xmm0
movaps %xmm0,0x1c0(%rsp)
lea    0x4(%rsp),%rax
mov    %rax,(%rbx)
lea    0x18(%rsp),%rax
mov    %rax,0x8(%rbx)
lea    0x8(%rsp),%rax
mov    %rax,0x10(%rbx)
lea    0x60(%rsp),%rax
mov    %rax,0x18(%rbx)
lea    0x20(%rsp),%rax
mov    %rax,0x20(%rbx)
lea    0x40(%rsp),%rax
mov    %rax,0x28(%rbx)
lea    0xa0(%rsp),%rax
mov    %rax,0x30(%rbx)
lea    0x130(%rsp),%rax
mov    %rax,0x38(%rbx)
lea    0x70(%rsp),%rax
mov    %rax,0x40(%rbx)
lea    0xc0(%rsp),%rax
mov    %rax,0x48(%rbx)
lea    0x150(%rsp),%rax
mov    %rax,0x50(%rbx)
lea    0x200(%rsp),%rax
mov    %rax,0x58(%rbx)
lea    0xf0(%rsp),%rax
mov    %rax,0x60(%rbx)
lea    0x180(%rsp),%rax
mov    %rax,0x68(%rbx)
lea    0x1c0(%rsp),%rax
mov    %rax,0x70(%rbx)
mov    %rbx,%rdi
xor    %esi,%esi
xor    %edx,%edx
call   1030 <maxSum@plt>
mov    %eax,%ebx
lea    0xd82(%rip),%rdi
call   1040 <puts@plt>
lea    0xd72(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
add    $0x230,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@__const.main.array1 = [1 x i32] [i32 75]
@__const.main.array2 = [2 x i32] [i32 95, i32 64]
@__const.main.array3 = [3 x i32] [i32 17, i32 47, i32 82]
@__const.main.array4 = [4 x i32] [i32 18, i32 35, i32 87, i32 10]
@__const.main.array5 = [5 x i32] [i32 20, i32 4, i32 82, i32 47, i32 65]
@__const.main.array6 = [6 x i32] [i32 19, i32 1, i32 23, i32 75, i32 3, i32 34]
@__const.main.array7 = [7 x i32] [i32 88, i32 2, i32 77, i32 73, i32 7, i32 63, i32 67]
@__const.main.array8 = [8 x i32] [i32 99, i32 65, i32 4, i32 28, i32 6, i32 16, i32 70, i32 92]
@__const.main.array9 = [9 x i32] [i32 41, i32 41, i32 26, i32 56, i32 83, i32 40, i32 80, i32 70, i32 33]
@__const.main.array10 = [10 x i32] [i32 41, i32 48, i32 72, i32 33, i32 47, i32 32, i32 37, i32 16, i32 94, i32 29]
@__const.main.array11 = [11 x i32] [i32 53, i32 71, i32 44, i32 65, i32 25, i32 43, i32 91, i32 52, i32 97, i32 51, i32 14]
@__const.main.array12 = [12 x i32] [i32 70, i32 11, i32 33, i32 28, i32 77, i32 73, i32 17, i32 78, i32 39, i32 68, i32 17, i32 57]
@__const.main.array13 = [13 x i32] [i32 91, i32 71, i32 52, i32 38, i32 17, i32 14, i32 91, i32 43, i32 58, i32 50, i32 27, i32 29, i32 48]
@__const.main.array14 = [14 x i32] [i32 63, i32 66, i32 4, i32 68, i32 89, i32 53, i32 67, i32 30, i32 73, i32 16, i32 69, i32 87, i32 40, i32 31]
@__const.main.array15 = [15 x i32] [i32 4, i32 62, i32 98, i32 27, i32 23, i32 9, i32 70, i32 98, i32 73, i32 93, i32 38, i32 53, i32 60, i32 4, i32 23]
@.str = [52 x i8] c"Maximum from top to the bottom of the triangle is:\0A\00"
@.str.1 = [4 x i8] c"%d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32**
%3 = alloca i32
%4 = alloca [1 x i32]
%5 = alloca [2 x i32]
%6 = alloca [3 x i32]
%7 = alloca [4 x i32]
%8 = alloca [5 x i32]
%9 = alloca [6 x i32]
%10 = alloca [7 x i32]
%11 = alloca [8 x i32]
%12 = alloca [9 x i32]
%13 = alloca [10 x i32]
%14 = alloca [11 x i32]
%15 = alloca [12 x i32]
%16 = alloca [13 x i32]
%17 = alloca [14 x i32]
%18 = alloca [15 x i32]
%19 = alloca i32
%20 = alloca i32
store i32 0, i32* %1
%21 = call i32** @malloc(i32 60)
store i32** %21, i32*** %2
store i32 0, i32* %3
br label %22
22: ; preds = %32, %0
%23 = load i32, i32* %3
%24 = icmp slt i32 %23, 15
br i1 %24, label %25, label %35
25: ; preds = %22
%26 = call i32** @malloc(i32 4)
%27 = bitcast i32** %26 to i32*
%28 = load i32**, i32*** %2
%29 = load i32, i32* %3
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i32*, i32** %28, i64 %30
store i32* %27, i32** %31
br label %32
32: ; preds = %25
%33 = load i32, i32* %3
%34 = add nsw i32 %33, 1
store i32 %34, i32* %3
br label %22
35: ; preds = %22
%36 = bitcast [1 x i32]* %4 to i8*
%37 = bitcast [2 x i32]* %5 to i8*
%38 = bitcast [3 x i32]* %6 to i8*
%39 = bitcast [4 x i32]* %7 to i8*
%40 = bitcast [5 x i32]* %8 to i8*
%41 = bitcast [6 x i32]* %9 to i8*
%42 = bitcast [7 x i32]* %10 to i8*
%43 = bitcast [8 x i32]* %11 to i8*
%44 = bitcast [9 x i32]* %12 to i8*
%45 = bitcast [10 x i32]* %13 to i8*
%46 = bitcast [11 x i32]* %14 to i8*
%47 = bitcast [12 x i32]* %15 to i8*
%48 = bitcast [13 x i32]* %16 to i8*
%49 = bitcast [14 x i32]* %17 to i8*
%50 = bitcast [15 x i32]* %18 to i8*
%51 = getelementptr inbounds [1 x i32], [1 x i32]* %4, i64 0, i64 0
%52 = load i32**, i32*** %2
%53 = getelementptr inbounds i32*, i32** %52, i64 0
store i32* %51, i32** %53
%54 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 0
%55 = load i32**, i32*** %2
%56 = getelementptr inbounds i32*, i32** %55, i64 1
store i32* %54, i32** %56
%57 = getelementptr inbounds [3 x i32], [3 x i32]* %6, i64 0, i64 0
%58 = load i32**, i32*** %2
%59 = getelementptr inbounds i32*, i32** %58, i64 2
store i32* %57, i32** %59
%60 = getelementptr inbounds [4 x i32], [4 x i32]* %7, i64 0, i64 0
%61 = load i32**, i32*** %2
%62 = getelementptr inbounds i32*, i32** %61, i64 3
store i32* %60, i32** %62
%63 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 0
%64 = load i32**, i32*** %2
%65 = getelementptr inbounds i32*, i32** %64, i64 4
store i32* %63, i32** %65
%66 = getelementptr inbounds [6 x i32], [6 x i32]* %9, i64 0, i64 0
%67 = load i32**, i32*** %2
%68 = getelementptr inbounds i32*, i32** %67, i64 5
store i32* %66, i32** %68
%69 = getelementptr inbounds [7 x i32], [7 x i32]* %10, i64 0, i64 0
%70 = load i32**, i32*** %2
%71 = getelementptr inbounds i32*, i32** %70, i64 6
store i32* %69, i32** %71
%72 = getelementptr inbounds [8 x i32], [8 x i32]* %11, i64 0, i64 0
%73 = load i32**, i32*** %2
%74 = getelementptr inbounds i32*, i32** %73, i64 7
store i32* %72, i32** %74
%75 = getelementptr inbounds [9 x i32], [9 x i32]* %12, i64 0, i64 0
%76 = load i32**, i32*** %2
%77 = getelementptr inbounds i32*, i32** %76, i64 8
store i32* %75, i32** %77
%78 = getelementptr inbounds [10 x i32], [10 x i32]* %13, i64 0, i64 0
%79 = load i32**, i32*** %2
%80 = getelementptr inbounds i32*, i32** %79, i64 9
store i32* %78, i32** %80
%81 = getelementptr inbounds [11 x i32], [11 x i32]* %14, i64 0, i64 0
%82 = load i32**, i32*** %2
%83 = getelementptr inbounds i32*, i32** %82, i64 10
store i32* %81, i32** %83
%84 = getelementptr inbounds [12 x i32], [12 x i32]* %15, i64 0, i64 0
%85 = load i32**, i32*** %2
%86 = getelementptr inbounds i32*, i32** %85, i64 11
store i32* %84, i32** %86
%87 = getelementptr inbounds [13 x i32], [13 x i32]* %16, i64 0, i64 0
%88 = load i32**, i32*** %2
%89 = getelementptr inbounds i32*, i32** %88, i64 12
store i32* %87, i32** %89
%90 = getelementptr inbounds [14 x i32], [14 x i32]* %17, i64 0, i64 0
%91 = load i32**, i32*** %2
%92 = getelementptr inbounds i32*, i32** %91, i64 13
store i32* %90, i32** %92
%93 = getelementptr inbounds [15 x i32], [15 x i32]* %18, i64 0, i64 0
%94 = load i32**, i32*** %2
%95 = getelementptr inbounds i32*, i32** %94, i64 14
store i32* %93, i32** %95
store i32 15, i32* %19
%96 = load i32**, i32*** %2
%97 = call i32 @maxSum(i32** %96, i32 0, i32 0)
store i32 %97, i32* %20
%98 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str, i64 0, i64 0))
%99 = load i32, i32* %20
%100 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %99)
ret i32 0
}

LLVM IR (-O2):
@__const.main.array3 = [3 x i32] [i32 17, i32 47, i32 82]
@__const.main.array4 = [4 x i32] [i32 18, i32 35, i32 87, i32 10]
@__const.main.array5 = [5 x i32] [i32 20, i32 4, i32 82, i32 47, i32 65]
@__const.main.array6 = [6 x i32] [i32 19, i32 1, i32 23, i32 75, i32 3, i32 34]
@__const.main.array7 = [7 x i32] [i32 88, i32 2, i32 77, i32 73, i32 7, i32 63, i32 67]
@__const.main.array8 = [8 x i32] [i32 99, i32 65, i32 4, i32 28, i32 6, i32 16, i32 70, i32 92]
@__const.main.array9 = [9 x i32] [i32 41, i32 41, i32 26, i32 56, i32 83, i32 40, i32 80, i32 70, i32 33]
@__const.main.array10 = [10 x i32] [i32 41, i32 48, i32 72, i32 33, i32 47, i32 32, i32 37, i32 16, i32 94, i32 29]
@__const.main.array11 = [11 x i32] [i32 53, i32 71, i32 44, i32 65, i32 25, i32 43, i32 91, i32 52, i32 97, i32 51, i32 14]
@__const.main.array12 = [12 x i32] [i32 70, i32 11, i32 33, i32 28, i32 77, i32 73, i32 17, i32 78, i32 39, i32 68, i32 17, i32 57]
@__const.main.array13 = [13 x i32] [i32 91, i32 71, i32 52, i32 38, i32 17, i32 14, i32 91, i32 43, i32 58, i32 50, i32 27, i32 29, i32 48]
@__const.main.array14 = [14 x i32] [i32 63, i32 66, i32 4, i32 68, i32 89, i32 53, i32 67, i32 30, i32 73, i32 16, i32 69, i32 87, i32 40, i32 31]
@__const.main.array15 = [15 x i32] [i32 4, i32 62, i32 98, i32 27, i32 23, i32 9, i32 70, i32 98, i32 73, i32 93, i32 38, i32 53, i32 60, i32 4, i32 23]
@.str.1 = [4 x i8] c"%d\0A\00"
@str = [51 x i8] c"Maximum from top to the bottom of the triangle is:\00"
define i32 @main() {
%1 = alloca [1 x i32]
%2 = alloca i64
%3 = alloca [3 x i32]
%4 = alloca [4 x i32]
%5 = alloca [5 x i32]
%6 = alloca [6 x i32]
%7 = alloca [7 x i32]
%8 = alloca [8 x i32]
%9 = alloca [9 x i32]
%10 = alloca [10 x i32]
%11 = alloca [11 x i32]
%12 = alloca [12 x i32]
%13 = alloca [13 x i32]
%14 = alloca [14 x i32]
%15 = alloca [15 x i32]
%16 = tail call i32** @malloc(i32 60)
%17 = tail call i32** @malloc(i32 4)
%18 = tail call i32** @malloc(i32 4)
%19 = getelementptr inbounds i32*, i32** %16, i64 1
%20 = tail call i32** @malloc(i32 4)
%21 = getelementptr inbounds i32*, i32** %16, i64 2
%22 = tail call i32** @malloc(i32 4)
%23 = getelementptr inbounds i32*, i32** %16, i64 3
%24 = tail call i32** @malloc(i32 4)
%25 = getelementptr inbounds i32*, i32** %16, i64 4
%26 = tail call i32** @malloc(i32 4)
%27 = getelementptr inbounds i32*, i32** %16, i64 5
%28 = tail call i32** @malloc(i32 4)
%29 = getelementptr inbounds i32*, i32** %16, i64 6
%30 = tail call i32** @malloc(i32 4)
%31 = getelementptr inbounds i32*, i32** %16, i64 7
%32 = tail call i32** @malloc(i32 4)
%33 = getelementptr inbounds i32*, i32** %16, i64 8
%34 = tail call i32** @malloc(i32 4)
%35 = getelementptr inbounds i32*, i32** %16, i64 9
%36 = tail call i32** @malloc(i32 4)
%37 = getelementptr inbounds i32*, i32** %16, i64 10
%38 = tail call i32** @malloc(i32 4)
%39 = getelementptr inbounds i32*, i32** %16, i64 11
%40 = tail call i32** @malloc(i32 4)
%41 = getelementptr inbounds i32*, i32** %16, i64 12
%42 = tail call i32** @malloc(i32 4)
%43 = getelementptr inbounds i32*, i32** %16, i64 13
%44 = tail call i32** @malloc(i32 4)
%45 = getelementptr inbounds i32*, i32** %16, i64 14
%46 = bitcast [1 x i32]* %1 to i8*
%47 = getelementptr inbounds [1 x i32], [1 x i32]* %1, i64 0, i64 0
store i32 75, i32* %47
%48 = bitcast i64* %2 to i8*
store i64 274877907039, i64* %2
%49 = bitcast [3 x i32]* %3 to i8*
%50 = bitcast [4 x i32]* %4 to i8*
%51 = bitcast [5 x i32]* %5 to i8*
%52 = bitcast [6 x i32]* %6 to i8*
%53 = bitcast [7 x i32]* %7 to i8*
%54 = bitcast [8 x i32]* %8 to i8*
%55 = bitcast [9 x i32]* %9 to i8*
%56 = bitcast [10 x i32]* %10 to i8*
%57 = bitcast [11 x i32]* %11 to i8*
%58 = bitcast [12 x i32]* %12 to i8*
%59 = bitcast [13 x i32]* %13 to i8*
%60 = bitcast [14 x i32]* %14 to i8*
%61 = bitcast [15 x i32]* %15 to i8*
store i32* %47, i32** %16
%62 = bitcast i32** %19 to i64**
store i64* %2, i64** %62
%63 = getelementptr inbounds [3 x i32], [3 x i32]* %3, i64 0, i64 0
store i32* %63, i32** %21
%64 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 0
store i32* %64, i32** %23
%65 = getelementptr inbounds [5 x i32], [5 x i32]* %5, i64 0, i64 0
store i32* %65, i32** %25
%66 = getelementptr inbounds [6 x i32], [6 x i32]* %6, i64 0, i64 0
store i32* %66, i32** %27
%67 = getelementptr inbounds [7 x i32], [7 x i32]* %7, i64 0, i64 0
store i32* %67, i32** %29
%68 = getelementptr inbounds [8 x i32], [8 x i32]* %8, i64 0, i64 0
store i32* %68, i32** %31
%69 = getelementptr inbounds [9 x i32], [9 x i32]* %9, i64 0, i64 0
store i32* %69, i32** %33
%70 = getelementptr inbounds [10 x i32], [10 x i32]* %10, i64 0, i64 0
store i32* %70, i32** %35
%71 = getelementptr inbounds [11 x i32], [11 x i32]* %11, i64 0, i64 0
store i32* %71, i32** %37
%72 = getelementptr inbounds [12 x i32], [12 x i32]* %12, i64 0, i64 0
store i32* %72, i32** %39
%73 = getelementptr inbounds [13 x i32], [13 x i32]* %13, i64 0, i64 0
store i32* %73, i32** %41
%74 = getelementptr inbounds [14 x i32], [14 x i32]* %14, i64 0, i64 0
store i32* %74, i32** %43
%75 = getelementptr inbounds [15 x i32], [15 x i32]* %15, i64 0, i64 0
store i32* %75, i32** %45
%76 = call i32 @maxSum(i32** %16, i32 0, i32 0)
%77 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @str, i64 0, i64 0))
%78 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %76)
ret i32 0
}