int maxProfit(int *prices, int pricesSize) {
  if (pricesSize <= 1)
    return (0);
  int i, max_to_i[pricesSize], max_from_i[pricesSize];
  int min_max, t;
  min_max = max_to_i[0] = 0;
  for (i = 1; i < pricesSize; i++) {
    if (prices[i] < prices[min_max])
      min_max = i;
    t = prices[i] - prices[min_max];
    max_to_i[i] = (max_to_i[i - 1] > t ? max_to_i[i - 1] : t);
  }
  max_from_i[pricesSize - 1] = 0;
  min_max = pricesSize - 1;
  for (i = pricesSize - 2; i >= 0; i--) {
    if (prices[i] > prices[min_max])
      min_max = i;
    t = prices[min_max] - prices[i];
    max_from_i[i] = (max_from_i[i + 1] > t ? max_from_i[i + 1] : t);
  }
  min_max = 0;
  for (i = 0; i < pricesSize; i++) {
    t = max_to_i[i] + max_from_i[i];
    if (t > min_max)
      min_max = t;
  }
  return (min_max);
}


x86 assembly (clang, -O0):
<maxProfit>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
cmpl   $0x1,-0x14(%rbp)
jg     1125 <maxProfit+0x25>
movl   $0x0,-0x4(%rbp)
jmp    133f <maxProfit+0x23f>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
mov    %rsp,%rax
mov    %rax,-0x20(%rbp)
lea    0xf(,%rcx,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rax
sub    %rdx,%rax
mov    %rax,-0x48(%rbp)
mov    %rax,%rsp
mov    %rcx,-0x28(%rbp)
mov    -0x14(%rbp),%ecx
lea    0xf(,%rcx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x40(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x30(%rbp)
movl   $0x0,(%rax)
movl   $0x0,-0x34(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    121c <maxProfit+0x11c>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    11b0 <maxProfit+0xb0>
mov    -0x18(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x18(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    -0x10(%rbp),%rdx
movslq -0x34(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
mov    %ecx,-0x38(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x38(%rbp),%eax
jle    11fa <maxProfit+0xfa>
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
jmp    1200 <maxProfit+0x100>
mov    -0x38(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x4c(%rbp),%edx
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1182 <maxProfit+0x82>
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jl     12da <maxProfit+0x1da>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    126e <maxProfit+0x16e>
mov    -0x18(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    -0x10(%rbp),%rdx
movslq -0x18(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
mov    %ecx,-0x38(%rbp)
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x38(%rbp),%eax
jle    12b8 <maxProfit+0x1b8>
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
jmp    12be <maxProfit+0x1be>
mov    -0x38(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%edx
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    1242 <maxProfit+0x142>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1332 <maxProfit+0x232>
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
movslq -0x18(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jle    131f <maxProfit+0x21f>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1324 <maxProfit+0x224>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12e8 <maxProfit+0x1e8>
mov    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<maxProfit>:
xor    %eax,%eax
cmp    $0x2,%esi
jl     14b7 <maxProfit+0x3b7>
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsp,-0x38(%rbp)
mov    %esi,%r9d
mov    %rsp,%r14
lea    0xf(,%r9,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r14
mov    %r14,%rsp
mov    %rsp,%r11
sub    %rax,%r11
mov    %r11,%rsp
movl   $0x0,(%r14)
mov    (%rdi),%r13d
lea    -0x1(%r9),%r15
cmp    $0x2,%esi
mov    %r15,-0x30(%rbp)
jne    116d <maxProfit+0x6d>
mov    $0x1,%eax
xor    %edx,%edx
xor    %r10d,%r10d
test   $0x1,%r15b
jne    11da <maxProfit+0xda>
jmp    11f3 <maxProfit+0xf3>
and    $0xfffffffffffffffe,%r15
mov    $0x1,%eax
xor    %edx,%edx
xor    %r10d,%r10d
jmp    119d <maxProfit+0x9d>
nopl   (%rax)
movslq %r10d,%rbx
mov    (%rdi,%rbx,4),%r13d
sub    %r13d,%edx
cmp    %edx,%ecx
cmovg  %ecx,%edx
mov    %edx,0x4(%r14,%rax,4)
add    $0x2,%rax
cmp    %r15,%r8
je     11d0 <maxProfit+0xd0>
mov    (%rdi,%rax,4),%ecx
mov    %eax,%r12d
cmp    %r13d,%ecx
jl     11ab <maxProfit+0xab>
mov    %r10d,%r12d
movslq %r12d,%rbx
mov    (%rdi,%rbx,4),%ebx
sub    %ebx,%ecx
cmp    %ecx,%edx
cmovg  %edx,%ecx
mov    %ecx,(%r14,%rax,4)
mov    0x4(%rdi,%rax,4),%edx
lea    0x1(%rax),%r8
mov    %r8d,%r10d
cmp    %ebx,%edx
jl     1180 <maxProfit+0x80>
mov    %r12d,%r10d
jmp    1180 <maxProfit+0x80>
mov    -0x30(%rbp),%r15
test   $0x1,%r15b
je     11f3 <maxProfit+0xf3>
mov    (%rdi,%rax,4),%ecx
cmp    %r13d,%ecx
cmovl  %eax,%r10d
movslq %r10d,%rbx
sub    (%rdi,%rbx,4),%ecx
cmp    %ecx,%edx
cmovg  %edx,%ecx
mov    %ecx,(%r14,%rax,4)
lea    -0x1(%rsi),%r15d
movl   $0x0,(%r11,%r15,4)
cmp    $0x2,%esi
jl     1252 <maxProfit+0x152>
lea    -0x2(%rsi),%ecx
mov    %r15d,%eax
mov    (%rdi,%rax,4),%r8d
test   $0x1,%cl
jne    1246 <maxProfit+0x146>
mov    (%rdi,%rcx,4),%eax
cmp    %r8d,%eax
cmovg  %ecx,%r15d
movslq %r15d,%rdx
mov    (%rdi,%rdx,4),%r8d
mov    %r8d,%edx
sub    %eax,%edx
mov    0x4(%r11,%rcx,4),%eax
cmp    %edx,%eax
cmovg  %eax,%edx
mov    %edx,(%r11,%rcx,4)
lea    -0x1(%rcx),%rdx
test   %rcx,%rcx
jne    1464 <maxProfit+0x364>
jmp    1252 <maxProfit+0x152>
mov    %rcx,%rdx
test   %rcx,%rcx
jne    1464 <maxProfit+0x364>
test   %esi,%esi
jle    14a3 <maxProfit+0x3a3>
mov    (%r11),%ecx
xor    %eax,%eax
test   %ecx,%ecx
cmovns %ecx,%eax
cmp    $0x1,%esi
je     14a5 <maxProfit+0x3a5>
mov    $0x1,%esi
mov    -0x30(%rbp),%rcx
cmp    $0x8,%rcx
jb     1420 <maxProfit+0x320>
mov    %rcx,%rsi
and    $0xfffffffffffffff8,%rsi
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rsi),%rax
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
test   %rax,%rax
je     14b8 <maxProfit+0x3b8>
mov    %rdi,%rdx
and    $0xfffffffffffffffe,%rdx
mov    $0x1,%eax
movdqa %xmm0,%xmm1
nopl   0x0(%rax,%rax,1)
movdqu (%r14,%rax,4),%xmm2
movdqu 0x10(%r14,%rax,4),%xmm3
movdqu 0x20(%r14,%rax,4),%xmm4
movdqu 0x30(%r14,%rax,4),%xmm5
movdqu (%r11,%rax,4),%xmm6
paddd  %xmm2,%xmm6
movdqu 0x10(%r11,%rax,4),%xmm7
paddd  %xmm3,%xmm7
movdqu 0x20(%r11,%rax,4),%xmm3
paddd  %xmm4,%xmm3
movdqu 0x30(%r11,%rax,4),%xmm2
paddd  %xmm5,%xmm2
movdqa %xmm6,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm6
pandn  %xmm0,%xmm4
por    %xmm6,%xmm4
movdqa %xmm7,%xmm5
pcmpgtd %xmm1,%xmm5
pand   %xmm5,%xmm7
pandn  %xmm1,%xmm5
por    %xmm7,%xmm5
movdqa %xmm3,%xmm0
pcmpgtd %xmm4,%xmm0
pand   %xmm0,%xmm3
pandn  %xmm4,%xmm0
por    %xmm3,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm5,%xmm1
por    %xmm2,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdx
jne    12c0 <maxProfit+0x1c0>
test   $0x1,%dil
je     13bc <maxProfit+0x2bc>
movdqu (%r14,%rax,4),%xmm2
movdqu 0x10(%r14,%rax,4),%xmm3
movdqu (%r11,%rax,4),%xmm4
paddd  %xmm2,%xmm4
movdqu 0x10(%r11,%rax,4),%xmm2
paddd  %xmm3,%xmm2
movdqa %xmm4,%xmm3
pcmpgtd %xmm0,%xmm3
pand   %xmm3,%xmm4
pandn  %xmm0,%xmm3
por    %xmm4,%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm1,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm1,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm0
movdqa %xmm4,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%eax
cmp    %rsi,%rcx
je     14a5 <maxProfit+0x3a5>
or     $0x1,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r11,%rsi,4),%ecx
add    (%r14,%rsi,4),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
add    $0x1,%rsi
cmp    %rsi,%r9
jne    1420 <maxProfit+0x320>
jmp    14a5 <maxProfit+0x3a5>
nopl   0x0(%rax,%rax,1)
movslq %r15d,%rbx
mov    (%rdi,%rbx,4),%r8d
mov    %r8d,%ebx
sub    %r10d,%ebx
cmp    %ebx,%eax
cmovg  %eax,%ebx
mov    %ebx,-0x4(%r11,%rdx,4)
sub    $0x1,%rcx
mov    %rcx,%rdx
jb     1252 <maxProfit+0x152>
mov    (%rdi,%rdx,4),%eax
mov    %edx,%r12d
cmp    %r8d,%eax
jg     1472 <maxProfit+0x372>
mov    %r15d,%r12d
movslq %r12d,%rcx
mov    (%rdi,%rcx,4),%r8d
mov    %r8d,%ecx
sub    %eax,%ecx
mov    0x4(%r11,%rdx,4),%eax
cmp    %ecx,%eax
jg     1489 <maxProfit+0x389>
mov    %ecx,%eax
mov    %eax,(%r11,%rdx,4)
mov    -0x4(%rdi,%rdx,4),%r10d
lea    -0x1(%rdx),%rcx
mov    %ecx,%r15d
cmp    %r8d,%r10d
jg     1440 <maxProfit+0x340>
mov    %r12d,%r15d
jmp    1440 <maxProfit+0x340>
xor    %eax,%eax
mov    -0x38(%rbp),%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%eax
movdqa %xmm0,%xmm1
test   $0x1,%dil
jne    136a <maxProfit+0x26a>
jmp    13bc <maxProfit+0x2bc>

LLVM IR (-O0):
define i32 @maxProfit(i32* %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i64
%9 = alloca i64
%10 = alloca i32
%11 = alloca i32
store i32* %0, i32** %4
store i32 %1, i32* %5
%12 = load i32, i32* %5
%13 = icmp sle i32 %12, 1
br i1 %13, label %14, label %15
14: ; preds = %2
store i32 0, i32* %3
br label %165
15: ; preds = %2
%16 = load i32, i32* %5
%17 = zext i32 %16 to i64
%18 = call i8* @llvm.stacksave()
store i8* %18, i8** %7
%19 = alloca i32, i64 %17
store i64 %17, i64* %8
%20 = load i32, i32* %5
%21 = zext i32 %20 to i64
%22 = alloca i32, i64 %21
store i64 %21, i64* %9
%23 = getelementptr inbounds i32, i32* %19, i64 0
store i32 0, i32* %23
store i32 0, i32* %10
store i32 1, i32* %6
br label %24
24: ; preds = %74, %15
%25 = load i32, i32* %6
%26 = load i32, i32* %5
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %77
28: ; preds = %24
%29 = load i32*, i32** %4
%30 = load i32, i32* %6
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i32, i32* %29, i64 %31
%33 = load i32, i32* %32
%34 = load i32*, i32** %4
%35 = load i32, i32* %10
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds i32, i32* %34, i64 %36
%38 = load i32, i32* %37
%39 = icmp slt i32 %33, %38
br i1 %39, label %40, label %42
40: ; preds = %28
%41 = load i32, i32* %6
store i32 %41, i32* %10
br label %42
42: ; preds = %40, %28
%43 = load i32*, i32** %4
%44 = load i32, i32* %6
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %43, i64 %45
%47 = load i32, i32* %46
%48 = load i32*, i32** %4
%49 = load i32, i32* %10
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i32, i32* %48, i64 %50
%52 = load i32, i32* %51
%53 = sub nsw i32 %47, %52
store i32 %53, i32* %11
%54 = load i32, i32* %6
%55 = sub nsw i32 %54, 1
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i32, i32* %19, i64 %56
%58 = load i32, i32* %57
%59 = load i32, i32* %11
%60 = icmp sgt i32 %58, %59
br i1 %60, label %61, label %67
61: ; preds = %42
%62 = load i32, i32* %6
%63 = sub nsw i32 %62, 1
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i32, i32* %19, i64 %64
%66 = load i32, i32* %65
br label %69
67: ; preds = %42
%68 = load i32, i32* %11
br label %69
69: ; preds = %67, %61
%70 = phi i32 [ %66, %61 ], [ %68, %67 ]
%71 = load i32, i32* %6
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i32, i32* %19, i64 %72
store i32 %70, i32* %73
br label %74
74: ; preds = %69
%75 = load i32, i32* %6
%76 = add nsw i32 %75, 1
store i32 %76, i32* %6
br label %24
77: ; preds = %24
%78 = load i32, i32* %5
%79 = sub nsw i32 %78, 1
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %22, i64 %80
store i32 0, i32* %81
%82 = load i32, i32* %5
%83 = sub nsw i32 %82, 1
store i32 %83, i32* %10
%84 = load i32, i32* %5
%85 = sub nsw i32 %84, 2
store i32 %85, i32* %6
br label %86
86: ; preds = %135, %77
%87 = load i32, i32* %6
%88 = icmp sge i32 %87, 0
br i1 %88, label %89, label %138
89: ; preds = %86
%90 = load i32*, i32** %4
%91 = load i32, i32* %6
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i32, i32* %90, i64 %92
%94 = load i32, i32* %93
%95 = load i32*, i32** %4
%96 = load i32, i32* %10
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i32, i32* %95, i64 %97
%99 = load i32, i32* %98
%100 = icmp sgt i32 %94, %99
br i1 %100, label %101, label %103
101: ; preds = %89
%102 = load i32, i32* %6
store i32 %102, i32* %10
br label %103
103: ; preds = %101, %89
%104 = load i32*, i32** %4
%105 = load i32, i32* %10
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i32, i32* %104, i64 %106
%108 = load i32, i32* %107
%109 = load i32*, i32** %4
%110 = load i32, i32* %6
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i32, i32* %109, i64 %111
%113 = load i32, i32* %112
%114 = sub nsw i32 %108, %113
store i32 %114, i32* %11
%115 = load i32, i32* %6
%116 = add nsw i32 %115, 1
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i32, i32* %22, i64 %117
%119 = load i32, i32* %118
%120 = load i32, i32* %11
%121 = icmp sgt i32 %119, %120
br i1 %121, label %122, label %128
122: ; preds = %103
%123 = load i32, i32* %6
%124 = add nsw i32 %123, 1
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i32, i32* %22, i64 %125
%127 = load i32, i32* %126
br label %130
128: ; preds = %103
%129 = load i32, i32* %11
br label %130
130: ; preds = %128, %122
%131 = phi i32 [ %127, %122 ], [ %129, %128 ]
%132 = load i32, i32* %6
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i32, i32* %22, i64 %133
store i32 %131, i32* %134
br label %135
135: ; preds = %130
%136 = load i32, i32* %6
%137 = add nsw i32 %136, -1
store i32 %137, i32* %6
br label %86
138: ; preds = %86
store i32 0, i32* %10
store i32 0, i32* %6
br label %139
139: ; preds = %159, %138
%140 = load i32, i32* %6
%141 = load i32, i32* %5
%142 = icmp slt i32 %140, %141
br i1 %142, label %143, label %162
143: ; preds = %139
%144 = load i32, i32* %6
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i32, i32* %19, i64 %145
%147 = load i32, i32* %146
%148 = load i32, i32* %6
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds i32, i32* %22, i64 %149
%151 = load i32, i32* %150
%152 = add nsw i32 %147, %151
store i32 %152, i32* %11
%153 = load i32, i32* %11
%154 = load i32, i32* %10
%155 = icmp sgt i32 %153, %154
br i1 %155, label %156, label %158
156: ; preds = %143
%157 = load i32, i32* %11
store i32 %157, i32* %10
br label %158
158: ; preds = %156, %143
br label %159
159: ; preds = %158
%160 = load i32, i32* %6
%161 = add nsw i32 %160, 1
store i32 %161, i32* %6
br label %139
162: ; preds = %139
%163 = load i32, i32* %10
store i32 %163, i32* %3
%164 = load i8*, i8** %7
br label %165
165: ; preds = %162, %14
%166 = load i32, i32* %3
ret i32 %166
}

LLVM IR (-O2):
define i32 @maxProfit(i32* nocapture %0, i32 %1) {
%3 = icmp slt i32 %1, 2
br i1 %3, label %258, label %4
4: ; preds = %2
%5 = zext i32 %1 to i64
%6 = tail call i8* @llvm.stacksave()
%7 = alloca i32, i64 %5
%8 = alloca i32, i64 %5
store i32 0, i32* %7
%9 = load i32, i32* %0
%10 = add nsw i64 %5, -1
%11 = and i64 %10, 1
%12 = icmp eq i32 %1, 2
br i1 %12, label %49, label %13
13: ; preds = %4
%14 = and i64 %10, -2
br label %15
15: ; preds = %15, %13
%16 = phi i32 [ 0, %13 ], [ %44, %15 ]
%17 = phi i32 [ %9, %13 ], [ %41, %15 ]
%18 = phi i64 [ 1, %13 ], [ %46, %15 ]
%19 = phi i32 [ 0, %13 ], [ %38, %15 ]
%20 = phi i64 [ 0, %13 ], [ %47, %15 ]
%21 = getelementptr inbounds i32, i32* %0, i64 %18
%22 = load i32, i32* %21
%23 = icmp slt i32 %22, %17
%24 = trunc i64 %18 to i32
%25 = select i1 %23, i32 %24, i32 %19
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i32, i32* %0, i64 %26
%28 = load i32, i32* %27
%29 = sub nsw i32 %22, %28
%30 = icmp sgt i32 %16, %29
%31 = select i1 %30, i32 %16, i32 %29
%32 = getelementptr inbounds i32, i32* %7, i64 %18
store i32 %31, i32* %32
%33 = add nuw nsw i64 %18, 1
%34 = getelementptr inbounds i32, i32* %0, i64 %33
%35 = load i32, i32* %34
%36 = icmp slt i32 %35, %28
%37 = trunc i64 %33 to i32
%38 = select i1 %36, i32 %37, i32 %25
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i32, i32* %0, i64 %39
%41 = load i32, i32* %40
%42 = sub nsw i32 %35, %41
%43 = icmp sgt i32 %31, %42
%44 = select i1 %43, i32 %31, i32 %42
%45 = getelementptr inbounds i32, i32* %7, i64 %33
store i32 %44, i32* %45
%46 = add nuw nsw i64 %18, 2
%47 = add i64 %20, 2
%48 = icmp eq i64 %47, %14
br i1 %48, label %49, label %15
49: ; preds = %15, %4
%50 = phi i32 [ 0, %4 ], [ %44, %15 ]
%51 = phi i32 [ %9, %4 ], [ %41, %15 ]
%52 = phi i64 [ 1, %4 ], [ %46, %15 ]
%53 = phi i32 [ 0, %4 ], [ %38, %15 ]
%54 = icmp eq i64 %11, 0
br i1 %54, label %68, label %55
55: ; preds = %49
%56 = getelementptr inbounds i32, i32* %0, i64 %52
%57 = load i32, i32* %56
%58 = icmp slt i32 %57, %51
%59 = trunc i64 %52 to i32
%60 = select i1 %58, i32 %59, i32 %53
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i32, i32* %0, i64 %61
%63 = load i32, i32* %62
%64 = sub nsw i32 %57, %63
%65 = icmp sgt i32 %50, %64
%66 = select i1 %65, i32 %50, i32 %64
%67 = getelementptr inbounds i32, i32* %7, i64 %52
store i32 %66, i32* %67
br label %68
68: ; preds = %49, %55
%69 = add nsw i32 %1, -1
%70 = zext i32 %69 to i64
%71 = getelementptr inbounds i32, i32* %8, i64 %70
store i32 0, i32* %71
%72 = icmp sgt i32 %1, 1
br i1 %72, label %73, label %102
73: ; preds = %68
%74 = add nsw i32 %1, -2
%75 = zext i32 %74 to i64
%76 = zext i32 %69 to i64
%77 = getelementptr inbounds i32, i32* %0, i64 %76
%78 = load i32, i32* %77
%79 = and i64 %75, 1
%80 = icmp eq i64 %79, 0
br i1 %80, label %81, label %97
81: ; preds = %73
%82 = getelementptr inbounds i32, i32* %0, i64 %75
%83 = load i32, i32* %82
%84 = icmp sgt i32 %83, %78
%85 = select i1 %84, i32 %74, i32 %69
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i32, i32* %0, i64 %86
%88 = load i32, i32* %87
%89 = sub nsw i32 %88, %83
%90 = add nuw nsw i64 %75, 1
%91 = getelementptr inbounds i32, i32* %8, i64 %90
%92 = load i32, i32* %91
%93 = icmp sgt i32 %92, %89
%94 = select i1 %93, i32 %92, i32 %89
%95 = getelementptr inbounds i32, i32* %8, i64 %75
store i32 %94, i32* %95
%96 = add nsw i64 %75, -1
br label %97
97: ; preds = %81, %73
%98 = phi i32 [ %78, %73 ], [ %88, %81 ]
%99 = phi i64 [ %75, %73 ], [ %96, %81 ]
%100 = phi i32 [ %69, %73 ], [ %85, %81 ]
%101 = icmp eq i32 %74, 0
br i1 %101, label %102, label %208
102: ; preds = %97, %208, %68
%103 = icmp sgt i32 %1, 0
br i1 %103, label %104, label %256
104: ; preds = %102
%105 = load i32, i32* %8
%106 = icmp sgt i32 %105, 0
%107 = select i1 %106, i32 %105, i32 0
%108 = icmp eq i32 %1, 1
br i1 %108, label %256, label %109
109: ; preds = %104
%110 = add nsw i64 %5, -1
%111 = icmp ult i64 %110, 8
br i1 %111, label %205, label %112
112: ; preds = %109
%113 = and i64 %110, -8
%114 = or i64 %113, 1
%115 = insertelement <4 x i32> poison, i32 %107, i64 0
%116 = shufflevector <4 x i32> %115, <4 x i32> poison, <4 x i32> zeroinitializer
%117 = add nsw i64 %113, -8
%118 = lshr exact i64 %117, 3
%119 = add nuw nsw i64 %118, 1
%120 = and i64 %119, 1
%121 = icmp eq i64 %117, 0
br i1 %121, label %172, label %122
122: ; preds = %112
%123 = and i64 %119, 4611686018427387902
br label %124
124: ; preds = %124, %122
%125 = phi i64 [ 0, %122 ], [ %167, %124 ]
%126 = phi <4 x i32> [ %116, %122 ], [ %165, %124 ]
%127 = phi <4 x i32> [ %116, %122 ], [ %166, %124 ]
%128 = phi i64 [ 0, %122 ], [ %168, %124 ]
%129 = or i64 %125, 1
%130 = getelementptr inbounds i32, i32* %7, i64 %129
%131 = bitcast i32* %130 to <4 x i32>*
%132 = load <4 x i32>, <4 x i32>* %131
%133 = getelementptr inbounds i32, i32* %130, i64 4
%134 = bitcast i32* %133 to <4 x i32>*
%135 = load <4 x i32>, <4 x i32>* %134
%136 = getelementptr inbounds i32, i32* %8, i64 %129
%137 = bitcast i32* %136 to <4 x i32>*
%138 = load <4 x i32>, <4 x i32>* %137
%139 = getelementptr inbounds i32, i32* %136, i64 4
%140 = bitcast i32* %139 to <4 x i32>*
%141 = load <4 x i32>, <4 x i32>* %140
%142 = add nsw <4 x i32> %138, %132
%143 = add nsw <4 x i32> %141, %135
%144 = icmp sgt <4 x i32> %142, %126
%145 = icmp sgt <4 x i32> %143, %127
%146 = select <4 x i1> %144, <4 x i32> %142, <4 x i32> %126
%147 = select <4 x i1> %145, <4 x i32> %143, <4 x i32> %127
%148 = or i64 %125, 9
%149 = getelementptr inbounds i32, i32* %7, i64 %148
%150 = bitcast i32* %149 to <4 x i32>*
%151 = load <4 x i32>, <4 x i32>* %150
%152 = getelementptr inbounds i32, i32* %149, i64 4
%153 = bitcast i32* %152 to <4 x i32>*
%154 = load <4 x i32>, <4 x i32>* %153
%155 = getelementptr inbounds i32, i32* %8, i64 %148
%156 = bitcast i32* %155 to <4 x i32>*
%157 = load <4 x i32>, <4 x i32>* %156
%158 = getelementptr inbounds i32, i32* %155, i64 4
%159 = bitcast i32* %158 to <4 x i32>*
%160 = load <4 x i32>, <4 x i32>* %159
%161 = add nsw <4 x i32> %157, %151
%162 = add nsw <4 x i32> %160, %154
%163 = icmp sgt <4 x i32> %161, %146
%164 = icmp sgt <4 x i32> %162, %147
%165 = select <4 x i1> %163, <4 x i32> %161, <4 x i32> %146
%166 = select <4 x i1> %164, <4 x i32> %162, <4 x i32> %147
%167 = add nuw i64 %125, 16
%168 = add i64 %128, 2
%169 = icmp eq i64 %168, %123
br i1 %169, label %170, label %124
170: ; preds = %124
%171 = or i64 %167, 1
br label %172
172: ; preds = %170, %112
%173 = phi <4 x i32> [ undef, %112 ], [ %165, %170 ]
%174 = phi <4 x i32> [ undef, %112 ], [ %166, %170 ]
%175 = phi i64 [ 1, %112 ], [ %171, %170 ]
%176 = phi <4 x i32> [ %116, %112 ], [ %165, %170 ]
%177 = phi <4 x i32> [ %116, %112 ], [ %166, %170 ]
%178 = icmp eq i64 %120, 0
br i1 %178, label %198, label %179
179: ; preds = %172
%180 = getelementptr inbounds i32, i32* %7, i64 %175
%181 = bitcast i32* %180 to <4 x i32>*
%182 = load <4 x i32>, <4 x i32>* %181
%183 = getelementptr inbounds i32, i32* %180, i64 4
%184 = bitcast i32* %183 to <4 x i32>*
%185 = load <4 x i32>, <4 x i32>* %184
%186 = getelementptr inbounds i32, i32* %8, i64 %175
%187 = bitcast i32* %186 to <4 x i32>*
%188 = load <4 x i32>, <4 x i32>* %187
%189 = getelementptr inbounds i32, i32* %186, i64 4
%190 = bitcast i32* %189 to <4 x i32>*
%191 = load <4 x i32>, <4 x i32>* %190
%192 = add nsw <4 x i32> %188, %182
%193 = add nsw <4 x i32> %191, %185
%194 = icmp sgt <4 x i32> %192, %176
%195 = icmp sgt <4 x i32> %193, %177
%196 = select <4 x i1> %194, <4 x i32> %192, <4 x i32> %176
%197 = select <4 x i1> %195, <4 x i32> %193, <4 x i32> %177
br label %198
198: ; preds = %172, %179
%199 = phi <4 x i32> [ %173, %172 ], [ %196, %179 ]
%200 = phi <4 x i32> [ %174, %172 ], [ %197, %179 ]
%201 = icmp sgt <4 x i32> %199, %200
%202 = select <4 x i1> %201, <4 x i32> %199, <4 x i32> %200
%203 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %202)
%204 = icmp eq i64 %110, %113
br i1 %204, label %256, label %205
205: ; preds = %109, %198
%206 = phi i64 [ 1, %109 ], [ %114, %198 ]
%207 = phi i32 [ %107, %109 ], [ %203, %198 ]
br label %244
208: ; preds = %97, %208
%209 = phi i32 [ %235, %208 ], [ %98, %97 ]
%210 = phi i64 [ %242, %208 ], [ %99, %97 ]
%211 = phi i32 [ %232, %208 ], [ %100, %97 ]
%212 = getelementptr inbounds i32, i32* %0, i64 %210
%213 = load i32, i32* %212
%214 = icmp sgt i32 %213, %209
%215 = trunc i64 %210 to i32
%216 = select i1 %214, i32 %215, i32 %211
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i32, i32* %0, i64 %217
%219 = load i32, i32* %218
%220 = sub nsw i32 %219, %213
%221 = add nuw nsw i64 %210, 1
%222 = getelementptr inbounds i32, i32* %8, i64 %221
%223 = load i32, i32* %222
%224 = icmp sgt i32 %223, %220
%225 = select i1 %224, i32 %223, i32 %220
%226 = getelementptr inbounds i32, i32* %8, i64 %210
store i32 %225, i32* %226
%227 = add nsw i64 %210, -1
%228 = getelementptr inbounds i32, i32* %0, i64 %227
%229 = load i32, i32* %228
%230 = icmp sgt i32 %229, %219
%231 = trunc i64 %227 to i32
%232 = select i1 %230, i32 %231, i32 %216
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds i32, i32* %0, i64 %233
%235 = load i32, i32* %234
%236 = sub nsw i32 %235, %229
%237 = getelementptr inbounds i32, i32* %8, i64 %210
%238 = load i32, i32* %237
%239 = icmp sgt i32 %238, %236
%240 = select i1 %239, i32 %238, i32 %236
%241 = getelementptr inbounds i32, i32* %8, i64 %227
store i32 %240, i32* %241
%242 = add nsw i64 %210, -2
%243 = icmp eq i64 %227, 0
br i1 %243, label %102, label %208
244: ; preds = %205, %244
%245 = phi i64 [ %254, %244 ], [ %206, %205 ]
%246 = phi i32 [ %253, %244 ], [ %207, %205 ]
%247 = getelementptr inbounds i32, i32* %7, i64 %245
%248 = load i32, i32* %247
%249 = getelementptr inbounds i32, i32* %8, i64 %245
%250 = load i32, i32* %249
%251 = add nsw i32 %250, %248
%252 = icmp sgt i32 %251, %246
%253 = select i1 %252, i32 %251, i32 %246
%254 = add nuw nsw i64 %245, 1
%255 = icmp eq i64 %254, %5
br i1 %255, label %256, label %244
256: ; preds = %244, %104, %198, %102
%257 = phi i32 [ 0, %102 ], [ %107, %104 ], [ %203, %198 ], [ %253, %244 ]
tail call void @llvm.stackrestore(i8* %6)
br label %258
258: ; preds = %2, %256
%259 = phi i32 [ %257, %256 ], [ 0, %2 ]
ret i32 %259
}