#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 printf(char *, int);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  int i, j, row, R, A[6000];
  scanf("%d", &R);
  for (i = 0; i < R * (R + 1) / 2; scanf("%d", A + (++i)))
    ;
  for (row = R - 1; row > 0; row--) {
    j = row * (row - 1) / 2 + 1;
    for (i = j; i < j + row; i++)
      A[i] += (A[i + row] > A[i + row + 1] ? A[i + row] : A[i + row + 1]);
  }
  return printf("%d\n", A[1]);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x5df0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xec7(%rip),%rdi
lea    -0x14(%rbp),%rsi
call   1040 <scanf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x5de4(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x5de4(%rbp),%eax
cmp    %ecx,%eax
jge    11a5 <main+0x85>
jmp    117b <main+0x5b>
lea    -0x5de0(%rbp),%rsi
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
cltq
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe65(%rip),%rdi
call   1040 <scanf@plt>
jmp    1149 <main+0x29>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jle    127c <main+0x15c>
mov    -0x10(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1269 <main+0x149>
mov    -0x8(%rbp),%eax
add    -0x10(%rbp),%eax
cltq
mov    -0x5de0(%rbp,%rax,4),%eax
mov    -0x8(%rbp),%ecx
add    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    -0x5de0(%rbp,%rcx,4),%eax
jle    122b <main+0x10b>
mov    -0x8(%rbp),%eax
add    -0x10(%rbp),%eax
cltq
mov    -0x5de0(%rbp,%rax,4),%eax
mov    %eax,-0x5de8(%rbp)
jmp    1243 <main+0x123>
mov    -0x8(%rbp),%eax
add    -0x10(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x5de0(%rbp,%rax,4),%eax
mov    %eax,-0x5de8(%rbp)
mov    -0x5de8(%rbp),%ecx
movslq -0x8(%rbp),%rax
add    -0x5de0(%rbp,%rax,4),%ecx
mov    %ecx,-0x5de0(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11d8 <main+0xb8>
jmp    126e <main+0x14e>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    11ae <main+0x8e>
mov    -0x5ddc(%rbp),%esi
lea    0xd7a(%rip),%rdi
call   1030 <printf@plt>
add    $0x5df0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x5dd8,%rsp
lea    0xec8(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1040 <scanf@plt>
mov    0xc(%rsp),%r8d
lea    0x1(%r8),%ecx
imul   %r8d,%ecx
cmp    $0x2,%ecx
jl     11a1 <main+0x81>
lea    0x14(%rsp),%r15
xor    %ebx,%ebx
lea    0xe9e(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbx
mov    %r14,%rdi
mov    %r15,%rsi
call   1040 <scanf@plt>
mov    0xc(%rsp),%r8d
lea    0x1(%r8),%ecx
imul   %r8d,%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
add    %ecx,%edx
sar    %edx
movslq %edx,%rcx
add    $0x4,%r15
cmp    %rcx,%rbx
jl     1170 <main+0x50>
cmp    $0x2,%r8d
jl     1371 <main+0x251>
lea    0x1(%r8),%r9d
xor    %r14d,%r14d
jmp    11ce <main+0xae>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r14d
cmp    $0x3,%r15d
jl     1371 <main+0x251>
mov    %r8d,%r15d
lea    -0x1(%r15),%r8d
lea    -0x2(%r15),%ecx
imul   %r8d,%ecx
mov    %ecx,%ebx
shr    $0x1f,%ebx
add    %ecx,%ebx
sar    %ebx
lea    (%rbx,%r15,1),%edx
lea    0x1(%rbx),%ecx
cmp    %edx,%ecx
jge    11c0 <main+0xa0>
movslq %ebx,%rsi
lea    0x1(%rsi),%r10
movslq %edx,%r12
mov    %rsi,%r11
not    %r11
add    %r12,%r11
cmp    $0x8,%r11
jae    1260 <main+0x140>
mov    %rsi,%rcx
add    %r15d,%ecx
lea    (%r10,%r15,1),%edx
lea    (%rsp,%r10,4),%rsi
add    $0x10,%rsi
add    %r15d,%ebx
movslq %ebx,%rdi
sub    %r10,%rdi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
lea    (%rcx,%rbx,1),%ebp
movslq %ebp,%rbp
mov    0x10(%rsp,%rbp,4),%ebp
lea    (%rdx,%rbx,1),%eax
cltq
mov    0x10(%rsp,%rax,4),%eax
cmp    %eax,%ebp
cmovg  %ebp,%eax
add    %eax,(%rsi,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    1230 <main+0x110>
jmp    11c0 <main+0xa0>
nopl   0x0(%rax)
mov    %r12,%rdi
sub    %rsi,%rdi
add    $0xfffffffffffffffe,%rdi
lea    (%rdx,%rdi,1),%ecx
cmp    %edx,%ecx
jl     120a <main+0xea>
mov    %rdi,%r13
shr    $0x20,%r13
jne    120a <main+0xea>
mov    %r9d,%ecx
sub    %r14d,%ecx
add    %ebx,%ecx
add    %ecx,%edi
cmp    %ecx,%edi
jl     120a <main+0xea>
test   %r13,%r13
jne    120a <main+0xea>
lea    0x14(%rsp),%rax
lea    (%rax,%rsi,4),%r13
movslq %ecx,%rcx
lea    (%r12,%rcx,1),%rdi
sub    %rsi,%rdi
lea    (%rax,%rdi,4),%rdi
add    $0xfffffffffffffff8,%rdi
cmp    %rdi,%r13
jae    12ce <main+0x1ae>
lea    (%rsp,%r12,4),%rdi
add    $0x10,%rdi
lea    (%rsp,%rcx,4),%rcx
add    $0x10,%rcx
cmp    %rdi,%rcx
jb     120a <main+0xea>
mov    %r11,%r12
and    $0xfffffffffffffff8,%r12
lea    (%r12,%rsi,1),%rcx
add    %r12,%r10
lea    0x14(%rsp),%rax
lea    (%rax,%rsi,4),%rsi
add    $0x10,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movslq %edx,%rdx
movdqu 0x10(%rsp,%rdx,4),%xmm0
movdqu 0x20(%rsp,%rdx,4),%xmm1
lea    0x1(%rdx),%ebp
movslq %ebp,%rbp
movdqu 0x10(%rsp,%rbp,4),%xmm2
movdqu 0x20(%rsp,%rbp,4),%xmm3
movdqa %xmm0,%xmm4
pcmpgtd %xmm2,%xmm4
pand   %xmm4,%xmm0
pandn  %xmm2,%xmm4
por    %xmm0,%xmm4
movdqa %xmm1,%xmm0
pcmpgtd %xmm3,%xmm0
pand   %xmm0,%xmm1
pandn  %xmm3,%xmm0
por    %xmm1,%xmm0
movdqu -0x10(%rsi,%rdi,4),%xmm1
paddd  %xmm4,%xmm1
movdqu (%rsi,%rdi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu %xmm1,-0x10(%rsi,%rdi,4)
movdqu %xmm2,(%rsi,%rdi,4)
add    $0x8,%rdi
add    $0x8,%edx
cmp    %rdi,%r12
jne    12f0 <main+0x1d0>
cmp    %r12,%r11
je     11c0 <main+0xa0>
jmp    120d <main+0xed>
mov    0x14(%rsp),%esi
lea    0xc87(%rip),%rdi
call   1030 <printf@plt>
add    $0x5dd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@.str.1 = [4 x i8] c"%d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [6000 x i32]
%3 = bitcast i32* %1 to i8*
%4 = bitcast [6000 x i32]* %2 to i8*
%5 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%6 = load i32, i32* %1
%7 = add nsw i32 %6, 1
%8 = mul nsw i32 %7, %6
%9 = icmp sgt i32 %8, 1
br i1 %9, label %17, label %10
10: ; preds = %17, %0
%11 = phi i32 [ %6, %0 ], [ %22, %17 ]
%12 = icmp sgt i32 %11, 1
br i1 %12, label %13, label %146
13: ; preds = %10
%14 = add i32 %11, 1
%15 = getelementptr inbounds [6000 x i32], [6000 x i32]* %2, i64 0, i64 1
%16 = getelementptr [6000 x i32], [6000 x i32]* %2, i64 0, i64 -1
br label %31
17: ; preds = %0, %17
%18 = phi i64 [ %19, %17 ], [ 0, %0 ]
%19 = add nuw nsw i64 %18, 1
%20 = getelementptr inbounds [6000 x i32], [6000 x i32]* %2, i64 0, i64 %19
%21 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %20)
%22 = load i32, i32* %1
%23 = add nsw i32 %22, 1
%24 = mul nsw i32 %23, %22
%25 = sdiv i32 %24, 2
%26 = sext i32 %25 to i64
%27 = icmp slt i64 %19, %26
br i1 %27, label %17, label %10
28: ; preds = %125, %120, %31
%29 = icmp sgt i32 %33, 2
%30 = add i32 %32, 1
br i1 %29, label %31, label %146
31: ; preds = %13, %28
%32 = phi i32 [ 0, %13 ], [ %30, %28 ]
%33 = phi i32 [ %11, %13 ], [ %36, %28 ]
%34 = sub i32 %14, %32
%35 = sub i32 %14, %32
%36 = add nsw i32 %33, -1
%37 = add nsw i32 %33, -2
%38 = mul nsw i32 %36, %37
%39 = sdiv i32 %38, 2
%40 = add i32 %39, %33
%41 = add nsw i32 %39, 1
%42 = icmp slt i32 %41, %40
br i1 %42, label %43, label %28
43: ; preds = %31
%44 = sext i32 %39 to i64
%45 = add nsw i64 %44, 1
%46 = sext i32 %40 to i64
%47 = xor i64 %44, -1
%48 = add nsw i64 %47, %46
%49 = icmp ult i64 %48, 8
br i1 %49, label %122, label %50
50: ; preds = %43
%51 = add nsw i64 %46, -2
%52 = sub nsw i64 %51, %44
%53 = trunc i64 %52 to i32
%54 = add i32 %40, %53
%55 = icmp slt i32 %54, %40
%56 = icmp ugt i64 %52, 4294967295
%57 = or i1 %55, %56
%58 = add i32 %39, %35
%59 = trunc i64 %52 to i32
%60 = add i32 %58, %59
%61 = icmp slt i32 %60, %58
%62 = icmp ugt i64 %52, 4294967295
%63 = or i1 %61, %62
%64 = or i1 %57, %63
br i1 %64, label %122, label %65
65: ; preds = %50
%66 = getelementptr i32, i32* %15, i64 %44
%67 = getelementptr [6000 x i32], [6000 x i32]* %2, i64 0, i64 %46
%68 = add i32 %39, %34
%69 = sext i32 %68 to i64
%70 = getelementptr [6000 x i32], [6000 x i32]* %2, i64 0, i64 %69
%71 = add nsw i64 %46, %69
%72 = sub nsw i64 %71, %44
%73 = getelementptr i32, i32* %16, i64 %72
%74 = icmp ult i32* %66, %73
%75 = icmp ult i32* %70, %67
%76 = and i1 %74, %75
br i1 %76, label %122, label %77
77: ; preds = %65
%78 = and i64 %48, -8
%79 = add nsw i64 %78, %44
%80 = add nsw i64 %45, %78
br label %81
81: ; preds = %81, %77
%82 = phi i64 [ 0, %77 ], [ %118, %81 ]
%83 = add i64 %45, %82
%84 = trunc i64 %82 to i32
%85 = add i32 %39, %84
%86 = add i64 %45, %82
%87 = trunc i64 %86 to i32
%88 = add i32 %33, %85
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [6000 x i32], [6000 x i32]* %2, i64 0, i64 %89
%91 = bitcast i32* %90 to <4 x i32>*
%92 = load <4 x i32>, <4 x i32>* %91
%93 = getelementptr inbounds i32, i32* %90, i64 4
%94 = bitcast i32* %93 to <4 x i32>*
%95 = load <4 x i32>, <4 x i32>* %94
%96 = add i32 %33, %87
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [6000 x i32], [6000 x i32]* %2, i64 0, i64 %97
%99 = bitcast i32* %98 to <4 x i32>*
%100 = load <4 x i32>, <4 x i32>* %99
%101 = getelementptr inbounds i32, i32* %98, i64 4
%102 = bitcast i32* %101 to <4 x i32>*
%103 = load <4 x i32>, <4 x i32>* %102
%104 = icmp sgt <4 x i32> %92, %100
%105 = icmp sgt <4 x i32> %95, %103
%106 = select <4 x i1> %104, <4 x i32> %92, <4 x i32> %100
%107 = select <4 x i1> %105, <4 x i32> %95, <4 x i32> %103
%108 = getelementptr inbounds [6000 x i32], [6000 x i32]* %2, i64 0, i64 %83
%109 = bitcast i32* %108 to <4 x i32>*
%110 = load <4 x i32>, <4 x i32>* %109
%111 = getelementptr inbounds i32, i32* %108, i64 4
%112 = bitcast i32* %111 to <4 x i32>*
%113 = load <4 x i32>, <4 x i32>* %112
%114 = add nsw <4 x i32> %106, %110
%115 = add nsw <4 x i32> %107, %113
%116 = bitcast i32* %108 to <4 x i32>*
store <4 x i32> %114, <4 x i32>* %116
%117 = bitcast i32* %111 to <4 x i32>*
store <4 x i32> %115, <4 x i32>* %117
%118 = add nuw i64 %82, 8
%119 = icmp eq i64 %118, %78
br i1 %119, label %120, label %81
120: ; preds = %81
%121 = icmp eq i64 %48, %78
br i1 %121, label %28, label %122
122: ; preds = %65, %50, %43, %120
%123 = phi i64 [ %44, %65 ], [ %44, %50 ], [ %44, %43 ], [ %79, %120 ]
%124 = phi i64 [ %45, %65 ], [ %45, %50 ], [ %45, %43 ], [ %80, %120 ]
br label %125
125: ; preds = %122, %125
%126 = phi i64 [ %128, %125 ], [ %123, %122 ]
%127 = phi i64 [ %144, %125 ], [ %124, %122 ]
%128 = add nsw i64 %126, 1
%129 = trunc i64 %126 to i32
%130 = add i32 %33, %129
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [6000 x i32], [6000 x i32]* %2, i64 0, i64 %131
%133 = load i32, i32* %132
%134 = trunc i64 %127 to i32
%135 = add i32 %33, %134
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [6000 x i32], [6000 x i32]* %2, i64 0, i64 %136
%138 = load i32, i32* %137
%139 = icmp sgt i32 %133, %138
%140 = select i1 %139, i32 %133, i32 %138
%141 = getelementptr inbounds [6000 x i32], [6000 x i32]* %2, i64 0, i64 %127
%142 = load i32, i32* %141
%143 = add nsw i32 %140, %142
store i32 %143, i32* %141
%144 = add nsw i64 %127, 1
%145 = icmp eq i64 %144, %46
br i1 %145, label %28, label %125
146: ; preds = %28, %10
%147 = getelementptr inbounds [6000 x i32], [6000 x i32]* %2, i64 0, i64 1
%148 = load i32, i32* %147
%149 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %148)
ret i32 %149
}