int maxProfit(int k, int *prices, int size) {
  int i, j;
  int **date;
  int counter = 0;
  int q = 0, w = 1, e = 0, r = 1;
  int a = 0, s = 1, d = 0, f = 1, g = 0, h = 1;
  date = (int **)malloc(sizeof(int *) * (k));
  for (int i = 0; i <= k; i++) {
    date[i] = (int *)malloc(sizeof(int) * size);
    memset(date[i], 0, sizeof(int) * size);
  }
  if (size < 2) {
    printf("We need more input numbers");
    return 0;
  }
  if (size == 2 || size == 3) {
    k = 1;
  }
  if (size == 4 || size == 5) {
    k = 2;
  }
  if (k > size / 2) {
    k = 3;
  }
  int room = k;
  if (k == size / 2) {
    k--;
  }
  int **t = (int **)malloc(sizeof(int *) * (room + 1));
  for (int i = 0; i <= k; i++) {
    t[i] = (int *)malloc(sizeof(int) * size);
    memset(t[i], 0, sizeof(int) * size);
  }
  int cur = 0;
  for (i = 1; i <= k; i++) {
    cur = -prices[0];
    for (j = 1; j < size; j++) {
      t[i][j] =
          (t[i][j - 1]) > (prices[j] + cur) ? (t[i][j - 1]) : (prices[j] + cur);
      cur = (cur) > (t[i - 1][j - 1] - prices[j])
                ? (cur)
                : (t[i - 1][j - 1] - prices[j]);
      date[i][j] = cur;
    }
    counter++;
  }
  int max = 0;
  if (k == 1) {
    for (i = 0; i < k + 1; i++) {
      for (j = 0; j < size; j++) {
      }
    }
    for (i = 0; i < k + 1; i++) {
      for (j = 0; j < size; j++) {
      }
    }
    int z = 1, x = size;
    for (i = 0; i < size; i++) {
      if (max < t[1][i]) {
        max = t[1][i];
        x = i;
      }
    }
    for (i = 0; i < x; i++) {
      if (date[1][i] != date[1][i + 1]) {
        z = i + 1;
      }
    }
    if (z == 1) {
      z = 0;
    }
    printf("%d\n%d\n", z + 1, x + 1);
    if (t[k][size - 1] == 0)
      printf("there is no result");
  } else if (k == 2) {
    for (i = 0; i < size; i++) {
      if (max < t[2][i]) {
        max = t[2][i];
        q = i;
      }
    }
    for (i = 0; i < q; i++) {
      if (date[2][i] != date[2][i + 1]) {
        w = i + 1;
      }
    }
    max = 0;
    for (i = 0; i < w; i++) {
      if (max < t[1][i]) {
        max = t[1][i];
        e = i;
      }
    }
    for (i = 1; i < w - 1; i++) {
      if (date[1][i] != date[1][i + 1]) {
        r = i + 1;
      }
    }
    if (r == 1) {
      r = 0;
    }
    printf("%d\n%d\n%d\n%d\n", r + 1, e + 1, w + 1, q + 1);
  } else if (k == 3) {
    for (i = 0; i < size; i++) {
      if (max < t[3][i]) {
        max = t[3][i];
        a = i;
      }
    }
    for (i = 0; i < a; i++) {
      if (date[3][i] != date[3][i + 1]) {
        s = i + 1;
      }
    }
    for (i = 0; i < size; i++) {
      if (max < t[3][i]) {
        max = t[3][i];
        a = i;
      }
    }
    for (i = 0; i < a; i++) {
      if (date[3][i] != date[3][i + 1]) {
        s = i + 1;
      }
    }
    max = 0;
    for (i = 0; i < s; i++) {
      if (max < t[2][i]) {
        max = t[2][i];
        d = i;
      }
    }
    for (i = 1; i < d; i++) {
      if (date[2][i] != date[2][i + 1]) {
        f = i + 1;
      }
    }
    max = 0;
    for (i = 0; i < f; i++) {
      if (max < t[1][i]) {
        max = t[1][i];
        g = i;
      }
    }
    for (i = 0; i < g; i++) {
      if (date[1][i] != date[1][i + 1]) {
        h = i + 1;
      }
    }
    if (h == 1) {
      h = 0;
    }
    printf("%d\n%d\n%d\n%d\n%d\n%d\n", h + 1, g + 1, f + 1, d + 1, s + 1,
           a + 1);
  }
  return t[k][size - 1];
}


x86 assembly (clang, -O0):
<maxProfit>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x1,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x1,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x1,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x1,-0x54(%rbp)
movslq -0x8(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     11fb <maxProfit+0xcb>
movslq -0x14(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x14(%rbp),%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    11aa <maxProfit+0x7a>
cmpl   $0x2,-0x14(%rbp)
jge    121f <maxProfit+0xef>
lea    0xdf4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1b3e <maxProfit+0xa0e>
cmpl   $0x2,-0x14(%rbp)
je     1233 <maxProfit+0x103>
cmpl   $0x3,-0x14(%rbp)
jne    123a <maxProfit+0x10a>
movl   $0x1,-0x8(%rbp)
cmpl   $0x4,-0x14(%rbp)
je     124e <maxProfit+0x11e>
cmpl   $0x5,-0x14(%rbp)
jne    1255 <maxProfit+0x125>
movl   $0x2,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x80(%rbp),%eax
cmp    %ecx,%eax
jle    127a <maxProfit+0x14a>
movl   $0x3,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x84(%rbp),%eax
cmp    %ecx,%eax
jne    12ad <maxProfit+0x17d>
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     131b <maxProfit+0x1eb>
movslq -0x14(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x68(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x14(%rbp),%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    12ca <maxProfit+0x19a>
movl   $0x0,-0x70(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1484 <maxProfit+0x354>
mov    -0x10(%rbp),%rcx
xor    %eax,%eax
sub    (%rcx),%eax
mov    %eax,-0x70(%rbp)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    146d <maxProfit+0x33d>
mov    -0x68(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x70(%rbp),%ecx
cmp    %ecx,%eax
jle    13a4 <maxProfit+0x274>
mov    -0x68(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
jmp    13b8 <maxProfit+0x288>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%edx
mov    -0x68(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x70(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
mov    -0x10(%rbp),%rdx
movslq -0x1c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
cmp    %ecx,%eax
jle    1412 <maxProfit+0x2e2>
mov    -0x70(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    1440 <maxProfit+0x310>
mov    -0x68(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1347 <maxProfit+0x217>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1329 <maxProfit+0x1f9>
movl   $0x0,-0x74(%rbp)
cmpl   $0x1,-0x8(%rbp)
jne    164f <maxProfit+0x51f>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    14e6 <maxProfit+0x3b6>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14d3 <maxProfit+0x3a3>
jmp    14c5 <maxProfit+0x395>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14b4 <maxProfit+0x384>
jmp    14d8 <maxProfit+0x3a8>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    149c <maxProfit+0x36c>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1537 <maxProfit+0x407>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1524 <maxProfit+0x3f4>
jmp    1516 <maxProfit+0x3e6>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1505 <maxProfit+0x3d5>
jmp    1529 <maxProfit+0x3f9>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14ed <maxProfit+0x3bd>
movl   $0x1,-0x78(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    159a <maxProfit+0x46a>
mov    -0x74(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    0x8(%rcx),%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1587 <maxProfit+0x457>
mov    -0x68(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    158c <maxProfit+0x45c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    154b <maxProfit+0x41b>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    15f2 <maxProfit+0x4c2>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
mov    0x8(%rcx),%rcx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
je     15df <maxProfit+0x4af>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    15e4 <maxProfit+0x4b4>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    15a1 <maxProfit+0x471>
cmpl   $0x1,-0x78(%rbp)
jne    1603 <maxProfit+0x4d3>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%esi
add    $0x1,%esi
mov    -0x7c(%rbp),%edx
add    $0x1,%edx
lea    0xa24(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x68(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    164a <maxProfit+0x51a>
lea    0x9d8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1b23 <maxProfit+0x9f3>
cmpl   $0x2,-0x8(%rbp)
jne    17ff <maxProfit+0x6cf>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16af <maxProfit+0x57f>
mov    -0x74(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    0x10(%rcx),%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    169c <maxProfit+0x56c>
mov    -0x68(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    16a1 <maxProfit+0x571>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1660 <maxProfit+0x530>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1707 <maxProfit+0x5d7>
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
mov    0x10(%rcx),%rcx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
je     16f4 <maxProfit+0x5c4>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16f9 <maxProfit+0x5c9>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    16b6 <maxProfit+0x586>
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1764 <maxProfit+0x634>
mov    -0x74(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    0x8(%rcx),%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1751 <maxProfit+0x621>
mov    -0x68(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1756 <maxProfit+0x626>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1715 <maxProfit+0x5e5>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    17c1 <maxProfit+0x691>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
mov    0x8(%rcx),%rcx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
je     17ae <maxProfit+0x67e>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17b3 <maxProfit+0x683>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    176b <maxProfit+0x63b>
cmpl   $0x1,-0x3c(%rbp)
jne    17d2 <maxProfit+0x6a2>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%esi
add    $0x1,%esi
mov    -0x38(%rbp),%edx
add    $0x1,%edx
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%r8d
add    $0x1,%r8d
lea    0x841(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1b1e <maxProfit+0x9ee>
cmpl   $0x3,-0x8(%rbp)
jne    1b19 <maxProfit+0x9e9>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    185f <maxProfit+0x72f>
mov    -0x74(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    0x18(%rcx),%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    184c <maxProfit+0x71c>
mov    -0x68(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    1851 <maxProfit+0x721>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1810 <maxProfit+0x6e0>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    18b7 <maxProfit+0x787>
mov    -0x28(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
mov    0x18(%rcx),%rcx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
je     18a4 <maxProfit+0x774>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    18a9 <maxProfit+0x779>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1866 <maxProfit+0x736>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    190d <maxProfit+0x7dd>
mov    -0x74(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    0x18(%rcx),%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    18fa <maxProfit+0x7ca>
mov    -0x68(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    18ff <maxProfit+0x7cf>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    18be <maxProfit+0x78e>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1965 <maxProfit+0x835>
mov    -0x28(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
mov    0x18(%rcx),%rcx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
je     1952 <maxProfit+0x822>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1957 <maxProfit+0x827>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1914 <maxProfit+0x7e4>
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    19c2 <maxProfit+0x892>
mov    -0x74(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    0x10(%rcx),%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    19af <maxProfit+0x87f>
mov    -0x68(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    19b4 <maxProfit+0x884>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1973 <maxProfit+0x843>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1a1a <maxProfit+0x8ea>
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
mov    0x10(%rcx),%rcx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
je     1a07 <maxProfit+0x8d7>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a0c <maxProfit+0x8dc>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    19c9 <maxProfit+0x899>
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1a77 <maxProfit+0x947>
mov    -0x74(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    0x8(%rcx),%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1a64 <maxProfit+0x934>
mov    -0x68(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    1a69 <maxProfit+0x939>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1a28 <maxProfit+0x8f8>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    1acf <maxProfit+0x99f>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
mov    0x8(%rcx),%rcx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
je     1abc <maxProfit+0x98c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1ac1 <maxProfit+0x991>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1a7e <maxProfit+0x94e>
cmpl   $0x1,-0x54(%rbp)
jne    1ae0 <maxProfit+0x9b0>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%esi
add    $0x1,%esi
mov    -0x50(%rbp),%edx
add    $0x1,%edx
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x48(%rbp),%r8d
add    $0x1,%r8d
mov    -0x44(%rbp),%r9d
add    $0x1,%r9d
mov    -0x40(%rbp),%eax
add    $0x1,%eax
lea    0x51f(%rip),%rdi
mov    %eax,(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1b1e <maxProfit+0x9ee>
jmp    1b23 <maxProfit+0x9f3>
mov    -0x68(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<maxProfit>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdx,0x20(%rsp)
mov    %rsi,%r12
mov    %edi,%r15d
movslq %edi,%rbp
lea    0x0(,%rbp,8),%rdi
call   1050 <malloc@plt>
mov    %rax,%rbx
test   %ebp,%ebp
js     118a <maxProfit+0x5a>
movslq 0x20(%rsp),%r13
shl    $0x2,%r13
lea    0x1(%r15),%r14d
xor    %ebp,%ebp
nop
mov    $0x1,%edi
mov    %r13,%rsi
call   1040 <calloc@plt>
mov    %rax,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1170 <maxProfit+0x40>
mov    0x20(%rsp),%r13
cmp    $0x2,%r13d
jge    11aa <maxProfit+0x7a>
lea    0xe64(%rip),%rdi
xor    %ebx,%ebx
xor    %eax,%eax
call   1030 <printf@plt>
jmp    1e7e <maxProfit+0xd4e>
mov    %rbx,0x10(%rsp)
mov    %r13d,%eax
and    $0xfffffffe,%eax
cmp    $0x2,%eax
mov    $0x1,%ecx
cmove  %ecx,%r15d
cmp    $0x4,%eax
mov    $0x2,%eax
cmovne %r15d,%eax
mov    %r13d,%ecx
shr    %ecx
cmp    %ecx,%eax
mov    $0x3,%edx
cmovle %eax,%edx
xor    %ebp,%ebp
cmp    %ecx,%edx
sete   %bpl
movslq %edx,%rbx
lea    0x8(,%rbx,8),%rdi
call   1050 <malloc@plt>
mov    %rbx,%r10
mov    %rax,0x8(%rsp)
sub    %ebp,%r10d
mov    %r10,0x18(%rsp)
js     131f <maxProfit+0x1ef>
mov    %r13d,%r15d
lea    0x0(,%r15,4),%r13
lea    0x1(%r10),%r14d
xor    %ebp,%ebp
mov    0x8(%rsp),%rbx
mov    $0x1,%edi
mov    %r13,%rsi
call   1040 <calloc@plt>
mov    %rax,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1220 <maxProfit+0xf0>
mov    0x18(%rsp),%r10
test   %r10d,%r10d
mov    0x20(%rsp),%r13
jle    131f <maxProfit+0x1ef>
lea    -0x1(%r15),%r9
mov    $0x1,%r8d
jmp    126d <maxProfit+0x13d>
nopl   0x0(%rax)
add    $0x1,%r8
cmp    %r14,%r8
je     131f <maxProfit+0x1ef>
cmp    $0x2,%r13d
jl     1260 <maxProfit+0x130>
xor    %edx,%edx
sub    (%r12),%edx
mov    0x8(%rsp),%rax
mov    -0x8(%rax,%r8,8),%rsi
mov    (%rax,%r8,8),%rdi
mov    0x10(%rsp),%rax
mov    (%rax,%r8,8),%rbp
lea    0x0(,%r15,4),%rax
add    %rbp,%rax
cmp    %rax,%rdi
jae    12e0 <maxProfit+0x1b0>
lea    (%rdi,%r15,4),%rax
lea    0x4(%rbp),%rcx
cmp    %rax,%rcx
jae    12e0 <maxProfit+0x1b0>
xor    %eax,%eax
nop
mov    (%rdi,%rax,4),%ebp
mov    0x4(%r12,%rax,4),%ebx
add    %edx,%ebx
cmp    %ebx,%ebp
cmovg  %ebp,%ebx
mov    %ebx,0x4(%rdi,%rax,4)
mov    (%rsi,%rax,4),%ebp
sub    0x4(%r12,%rax,4),%ebp
cmp    %ebp,%edx
cmovle %ebp,%edx
mov    %edx,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r9
jne    12b0 <maxProfit+0x180>
jmp    1260 <maxProfit+0x130>
xchg   %ax,%ax
mov    (%rdi),%ecx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x4(%r12,%rax,4),%ebx
add    %edx,%ebx
cmp    %ebx,%ecx
cmovle %ebx,%ecx
mov    %ecx,0x4(%rdi,%rax,4)
mov    (%rsi,%rax,4),%ebx
sub    0x4(%r12,%rax,4),%ebx
cmp    %ebx,%edx
cmovle %ebx,%edx
mov    %edx,0x4(%rbp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r9
jne    12f0 <maxProfit+0x1c0>
jmp    1260 <maxProfit+0x130>
cmp    $0x3,%r10d
je     13cd <maxProfit+0x29d>
cmp    $0x2,%r10d
je     1460 <maxProfit+0x330>
cmp    $0x1,%r10d
mov    0x8(%rsp),%rbx
jne    1e6f <maxProfit+0xd3f>
mov    %r13d,%edx
test   %r13d,%r13d
jle    16d5 <maxProfit+0x5a5>
mov    0x8(%rbx),%rax
mov    %r13d,%r8d
lea    -0x1(%r8),%rdx
mov    %r8d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    14b3 <maxProfit+0x383>
xor    %esi,%esi
mov    %r13d,%edx
xor    %edi,%edi
test   %rcx,%rcx
je     1395 <maxProfit+0x265>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rax,%rsi,4),%ebp
cmp    %ebp,%edi
cmovl  %ebp,%edi
cmovl  %esi,%edx
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    1380 <maxProfit+0x250>
test   %edx,%edx
jle    16d5 <maxProfit+0x5a5>
mov    0x10(%rsp),%rax
mov    0x8(%rax),%r10
mov    %edx,%r9d
mov    (%r10),%edi
lea    -0x1(%r9),%rsi
mov    %r9d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rsi
jae    164b <maxProfit+0x51b>
mov    $0x1,%esi
xor    %ebp,%ebp
jmp    169c <maxProfit+0x56c>
xor    %r15d,%r15d
test   %r13d,%r13d
jle    1498 <maxProfit+0x368>
mov    0x8(%rsp),%rax
mov    0x18(%rax),%rbx
mov    %r13d,%r10d
lea    -0x1(%r10),%r8
mov    %r10d,%edx
and    $0x3,%edx
cmp    $0x3,%r8
jae    1510 <maxProfit+0x3e0>
xor    %edi,%edi
xor    %ecx,%ecx
xor    %r14d,%r14d
test   %rdx,%rdx
je     1426 <maxProfit+0x2f6>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rdi,4),%eax
cmp    %eax,%ecx
cmovl  %edi,%r14d
cmovl  %eax,%ecx
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
jne    1410 <maxProfit+0x2e0>
test   %r14d,%r14d
jle    1640 <maxProfit+0x510>
mov    0x10(%rsp),%rax
mov    0x18(%rax),%rbx
mov    %r14d,%r12d
mov    (%rbx),%edi
lea    -0x1(%r12),%rax
mov    %r12d,%r11d
and    $0x3,%r11d
cmp    $0x3,%rax
jae    1715 <maxProfit+0x5e5>
mov    $0x1,%r9d
xor    %ebp,%ebp
jmp    176a <maxProfit+0x63a>
xor    %eax,%eax
mov    $0x1,%ecx
test   %r13d,%r13d
jle    14ab <maxProfit+0x37b>
mov    0x8(%rsp),%rbx
mov    0x10(%rbx),%r10
mov    %r13d,%r9d
lea    -0x1(%r9),%rdx
mov    %r9d,%esi
and    $0x3,%esi
cmp    $0x3,%rdx
jae    1572 <maxProfit+0x442>
xor    %edi,%edi
xor    %ebp,%ebp
xor    %r8d,%r8d
jmp    15e8 <maxProfit+0x4b8>
mov    $0x1,%r9d
xor    %r14d,%r14d
mov    0x8(%rsp),%rbx
jmp    1b15 <maxProfit+0x9e5>
xor    %r8d,%r8d
jmp    188f <maxProfit+0x75f>
and    $0xfffffffc,%r8d
xor    %esi,%esi
mov    %r13d,%edx
xor    %edi,%edi
jmp    14d4 <maxProfit+0x3a4>
mov    %ebx,%edi
mov    0x8(%rsp),%rbx
add    $0x4,%rsi
cmp    %r8,%rsi
je     1370 <maxProfit+0x240>
mov    (%rax,%rsi,4),%ebp
cmp    %ebp,%edi
cmovl  %ebp,%edi
mov    0x4(%rax,%rsi,4),%ebp
cmovl  %esi,%edx
cmp    %ebp,%edi
jl     14f0 <maxProfit+0x3c0>
mov    %edi,%ebp
jmp    14f3 <maxProfit+0x3c3>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rsi),%edx
mov    0x8(%rax,%rsi,4),%ebx
cmp    %ebx,%ebp
jl     1500 <maxProfit+0x3d0>
mov    %ebp,%ebx
jmp    1503 <maxProfit+0x3d3>
nop
lea    0x2(%rsi),%edx
mov    0xc(%rax,%rsi,4),%edi
cmp    %edi,%ebx
jge    14c0 <maxProfit+0x390>
lea    0x3(%rsi),%edx
jmp    14c2 <maxProfit+0x392>
mov    %r10d,%ebp
and    $0xfffffffc,%ebp
xor    %edi,%edi
xor    %ecx,%ecx
xor    %r14d,%r14d
jmp    152f <maxProfit+0x3ff>
nop
mov    %esi,%ecx
add    $0x4,%rdi
cmp    %rbp,%rdi
je     1400 <maxProfit+0x2d0>
mov    (%rbx,%rdi,4),%esi
cmp    %esi,%ecx
cmovl  %edi,%r14d
mov    0x4(%rbx,%rdi,4),%eax
cmovl  %esi,%ecx
cmp    %eax,%ecx
jl     1550 <maxProfit+0x420>
mov    %ecx,%eax
jmp    1554 <maxProfit+0x424>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rdi),%r14d
mov    0x8(%rbx,%rdi,4),%esi
cmp    %esi,%eax
jl     1560 <maxProfit+0x430>
mov    %eax,%esi
jmp    1564 <maxProfit+0x434>
lea    0x2(%rdi),%r14d
mov    0xc(%rbx,%rdi,4),%ecx
cmp    %ecx,%esi
jge    1520 <maxProfit+0x3f0>
lea    0x3(%rdi),%r14d
jmp    1522 <maxProfit+0x3f2>
and    $0xfffffffc,%r9d
xor    %edi,%edi
xor    %ebp,%ebp
xor    %r8d,%r8d
jmp    158b <maxProfit+0x45b>
nop
mov    %ebx,%ebp
add    $0x4,%rdi
cmp    %r9,%rdi
je     15e3 <maxProfit+0x4b3>
mov    (%r10,%rdi,4),%ebx
cmp    %ebx,%ebp
cmovl  %edi,%r8d
mov    0x4(%r10,%rdi,4),%edx
cmovl  %ebx,%ebp
cmp    %edx,%ebp
jl     15b0 <maxProfit+0x480>
mov    %ebp,%edx
jmp    15b4 <maxProfit+0x484>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rdi),%r8d
mov    0x8(%r10,%rdi,4),%ebx
cmp    %ebx,%edx
jl     15d0 <maxProfit+0x4a0>
mov    %edx,%ebx
jmp    15d4 <maxProfit+0x4a4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x2(%rdi),%r8d
mov    0xc(%r10,%rdi,4),%ebp
cmp    %ebp,%ebx
jge    1580 <maxProfit+0x450>
lea    0x3(%rdi),%r8d
jmp    1582 <maxProfit+0x452>
mov    0x8(%rsp),%rbx
test   %rsi,%rsi
je     1607 <maxProfit+0x4d7>
nopl   (%rax)
mov    (%r10,%rdi,4),%edx
cmp    %edx,%ebp
cmovl  %edi,%r8d
cmovl  %edx,%ebp
add    $0x1,%rdi
add    $0xffffffffffffffff,%rsi
jne    15f0 <maxProfit+0x4c0>
test   %r8d,%r8d
jle    1894 <maxProfit+0x764>
mov    0x10(%rsp),%rcx
mov    0x10(%rcx),%r11
mov    %r8d,%r10d
mov    (%r11),%ebx
lea    -0x1(%r10),%rcx
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x3,%rcx
jae    1809 <maxProfit+0x6d9>
mov    $0x1,%ecx
xor    %ebp,%ebp
jmp    185a <maxProfit+0x72a>
mov    $0x1,%r9d
jmp    1797 <maxProfit+0x667>
and    $0xfffffffc,%r9d
mov    $0x1,%esi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%rbp),%ebx
mov    0x4(%r10,%rbp,4),%eax
mov    0x8(%r10,%rbp,4),%r11d
cmp    %eax,%edi
cmove  %esi,%ebx
lea    0x2(%rbp),%ecx
cmp    %r11d,%eax
cmove  %ebx,%ecx
mov    0xc(%r10,%rbp,4),%eax
lea    0x3(%rbp),%esi
cmp    %eax,%r11d
cmove  %ecx,%esi
mov    0x10(%r10,%rbp,4),%edi
add    $0x4,%rbp
cmp    %edi,%eax
cmovne %ebp,%esi
cmp    %rbp,%r9
jne    1660 <maxProfit+0x530>
test   %r8,%r8
je     16c7 <maxProfit+0x597>
lea    0x1(%rbp),%r9d
lea    (%r10,%rbp,4),%rbx
add    $0x4,%rbx
xor    %ebp,%ebp
nop
mov    (%rbx,%rbp,4),%ecx
lea    (%r9,%rbp,1),%eax
cmp    %ecx,%edi
cmovne %eax,%esi
add    $0x1,%rbp
mov    %ecx,%edi
cmp    %rbp,%r8
jne    16b0 <maxProfit+0x580>
cmp    $0x1,%esi
jne    1a20 <maxProfit+0x8f0>
mov    0x8(%rsp),%rbx
mov    $0x1,%esi
add    $0x1,%edx
lea    0x956(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
mov    0x8(%rbx),%rax
lea    -0x1(%r13),%ecx
cmpl   $0x0,(%rax,%rcx,4)
mov    0x18(%rsp),%r10
jne    1e6f <maxProfit+0xd3f>
lea    0x912(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
jmp    1e6a <maxProfit+0xd3a>
and    $0xfffffffc,%r12d
mov    $0x1,%r9d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%rbp),%eax
mov    0x4(%rbx,%rbp,4),%esi
mov    0x8(%rbx,%rbp,4),%edx
cmp    %esi,%edi
cmove  %r9d,%eax
lea    0x2(%rbp),%edi
cmp    %edx,%esi
cmove  %eax,%edi
mov    0xc(%rbx,%rbp,4),%eax
lea    0x3(%rbp),%r9d
cmp    %eax,%edx
cmove  %edi,%r9d
mov    0x10(%rbx,%rbp,4),%edi
add    $0x4,%rbp
cmp    %edi,%eax
cmovne %ebp,%r9d
cmp    %rbp,%r12
jne    1730 <maxProfit+0x600>
test   %r11,%r11
je     1797 <maxProfit+0x667>
lea    0x1(%rbp),%edx
lea    (%rbx,%rbp,4),%rax
add    $0x4,%rax
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    (%rax,%rbx,4),%esi
lea    (%rdx,%rbx,1),%ebp
cmp    %esi,%edi
cmovne %ebp,%r9d
add    $0x1,%rbx
mov    %esi,%edi
cmp    %rbx,%r11
jne    1780 <maxProfit+0x650>
test   %r13d,%r13d
jle    17d6 <maxProfit+0x6a6>
mov    0x8(%rsp),%rax
mov    0x18(%rax),%rdx
mov    %r10d,%edi
and    $0x3,%edi
cmp    $0x3,%r8
jae    1a2d <maxProfit+0x8fd>
xor    %ebx,%ebx
test   %rdi,%rdi
je     17d6 <maxProfit+0x6a6>
nopl   0x0(%rax)
mov    (%rdx,%rbx,4),%eax
cmp    %eax,%ecx
cmovl  %ebx,%r14d
cmovl  %eax,%ecx
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdi
jne    17c0 <maxProfit+0x690>
test   %r14d,%r14d
jle    1b07 <maxProfit+0x9d7>
mov    0x10(%rsp),%rax
mov    0x18(%rax),%rdi
mov    %r14d,%edx
mov    (%rdi),%esi
lea    -0x1(%rdx),%rax
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    1a92 <maxProfit+0x962>
xor    %ebp,%ebp
jmp    1ada <maxProfit+0x9aa>
and    $0xfffffffc,%r10d
mov    $0x1,%ecx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%rbp),%esi
mov    0x4(%r11,%rbp,4),%edx
mov    0x8(%r11,%rbp,4),%edi
cmp    %edx,%ebx
cmove  %ecx,%esi
lea    0x2(%rbp),%ebx
cmp    %edi,%edx
cmove  %esi,%ebx
mov    0xc(%r11,%rbp,4),%edx
lea    0x3(%rbp),%ecx
cmp    %edx,%edi
cmove  %ebx,%ecx
mov    0x10(%r11,%rbp,4),%ebx
add    $0x4,%rbp
cmp    %ebx,%edx
cmovne %ebp,%ecx
cmp    %rbp,%r10
jne    1820 <maxProfit+0x6f0>
test   %r9,%r9
je     1887 <maxProfit+0x757>
lea    0x1(%rbp),%r10d
lea    (%r11,%rbp,4),%rdi
add    $0x4,%rdi
xor    %ebp,%ebp
nopl   (%rax)
mov    (%rdi,%rbp,4),%esi
lea    (%r10,%rbp,1),%edx
cmp    %esi,%ebx
cmovne %edx,%ecx
add    $0x1,%rbp
mov    %esi,%ebx
cmp    %rbp,%r9
jne    1870 <maxProfit+0x740>
test   %ecx,%ecx
jle    1e14 <maxProfit+0xce4>
mov    0x8(%rsp),%rbx
mov    0x8(%rbx),%r10
mov    %ecx,%r9d
lea    -0x1(%r9),%rdx
mov    %r9d,%edi
and    $0x3,%edi
cmp    $0x3,%rdx
jae    1916 <maxProfit+0x7e6>
xor    %ebp,%ebp
xor    %edx,%edx
test   %rdi,%rdi
je     18d6 <maxProfit+0x7a6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r10,%rbp,4),%esi
cmp    %esi,%eax
cmovl  %ebp,%edx
cmovl  %esi,%eax
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdi
jne    18c0 <maxProfit+0x790>
add    $0x1,%edx
cmp    $0x3,%ecx
jl     1e1e <maxProfit+0xcee>
lea    -0x1(%rcx),%esi
mov    0x10(%rsp),%rax
mov    0x8(%rax),%r11
mov    0x4(%r11),%r15d
lea    -0x1(%rsi),%r10
add    $0xfffffffffffffffe,%rsi
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x3,%rsi
jae    1981 <maxProfit+0x851>
mov    $0x1,%esi
mov    $0x1,%ebx
jmp    19d2 <maxProfit+0x8a2>
and    $0xfffffffc,%r9d
xor    %ebp,%ebp
xor    %eax,%eax
xor    %edx,%edx
jmp    1944 <maxProfit+0x814>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebx,%eax
mov    0x8(%rsp),%rbx
add    $0x4,%rbp
cmp    %r9,%rbp
je     18af <maxProfit+0x77f>
mov    (%r10,%rbp,4),%ebx
cmp    %ebx,%eax
cmovl  %ebp,%edx
mov    0x4(%r10,%rbp,4),%esi
cmovl  %ebx,%eax
cmp    %esi,%eax
jl     1960 <maxProfit+0x830>
mov    %eax,%esi
jmp    1963 <maxProfit+0x833>
nopl   (%rax)
lea    0x1(%rbp),%edx
mov    0x8(%r10,%rbp,4),%ebx
cmp    %ebx,%esi
jl     1970 <maxProfit+0x840>
mov    %esi,%ebx
jmp    1973 <maxProfit+0x843>
lea    0x2(%rbp),%edx
mov    0xc(%r10,%rbp,4),%eax
cmp    %eax,%ebx
jge    1930 <maxProfit+0x800>
lea    0x3(%rbp),%edx
jmp    1932 <maxProfit+0x802>
and    $0xfffffffffffffffc,%r10
mov    $0x1,%esi
xor    %ebx,%ebx
nopl   0x0(%rax)
lea    0x2(%rbx),%eax
mov    0x8(%r11,%rbx,4),%ebp
mov    0xc(%r11,%rbx,4),%r14d
cmp    %ebp,%r15d
cmove  %esi,%eax
lea    0x3(%rbx),%edi
cmp    %r14d,%ebp
cmove  %eax,%edi
mov    0x10(%r11,%rbx,4),%eax
mov    0x14(%r11,%rbx,4),%r15d
lea    0x5(%rbx),%esi
add    $0x4,%rbx
cmp    %eax,%r14d
cmovne %ebx,%edi
cmp    %r15d,%eax
cmove  %edi,%esi
cmp    %rbx,%r10
jne    1990 <maxProfit+0x860>
add    $0x1,%rbx
test   %r9,%r9
je     1a0a <maxProfit+0x8da>
lea    0x1(%rbx),%r10d
lea    (%r11,%rbx,4),%rbp
add    $0x4,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%rbp,%rbx,4),%edi
lea    (%r10,%rbx,1),%eax
cmp    %edi,%r15d
cmovne %eax,%esi
add    $0x1,%rbx
mov    %edi,%r15d
cmp    %rbx,%r9
jne    19f0 <maxProfit+0x8c0>
cmp    $0x1,%esi
je     1e19 <maxProfit+0xce9>
add    $0x1,%esi
mov    0x8(%rsp),%rbx
jmp    1e23 <maxProfit+0xcf3>
add    $0x1,%esi
mov    0x8(%rsp),%rbx
jmp    16da <maxProfit+0x5aa>
and    $0xfffffffc,%r10d
xor    %ebx,%ebx
jmp    1a4f <maxProfit+0x91f>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %esi,%ecx
add    $0x4,%rbx
cmp    %r10,%rbx
je     17b7 <maxProfit+0x687>
mov    (%rdx,%rbx,4),%esi
cmp    %esi,%ecx
cmovl  %ebx,%r14d
mov    0x4(%rdx,%rbx,4),%eax
cmovl  %esi,%ecx
cmp    %eax,%ecx
jl     1a70 <maxProfit+0x940>
mov    %ecx,%eax
jmp    1a74 <maxProfit+0x944>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rbx),%r14d
mov    0x8(%rdx,%rbx,4),%esi
cmp    %esi,%eax
jl     1a80 <maxProfit+0x950>
mov    %eax,%esi
jmp    1a84 <maxProfit+0x954>
lea    0x2(%rbx),%r14d
mov    0xc(%rdx,%rbx,4),%ecx
cmp    %ecx,%esi
jge    1a40 <maxProfit+0x910>
lea    0x3(%rbx),%r14d
jmp    1a42 <maxProfit+0x912>
and    $0xfffffffc,%edx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
lea    0x1(%rbp),%eax
mov    0x4(%rdi,%rbp,4),%ecx
mov    0x8(%rdi,%rbp,4),%ebx
cmp    %ecx,%esi
cmove  %r9d,%eax
lea    0x2(%rbp),%esi
cmp    %ebx,%ecx
cmove  %eax,%esi
mov    0xc(%rdi,%rbp,4),%eax
lea    0x3(%rbp),%r9d
cmp    %eax,%ebx
cmove  %esi,%r9d
mov    0x10(%rdi,%rbp,4),%esi
add    $0x4,%rbp
cmp    %esi,%eax
cmovne %ebp,%r9d
cmp    %rbp,%rdx
jne    1aa0 <maxProfit+0x970>
test   %r8,%r8
je     1b07 <maxProfit+0x9d7>
lea    0x1(%rbp),%edx
lea    (%rdi,%rbp,4),%rax
add    $0x4,%rax
xor    %edi,%edi
nopl   0x0(%rax)
mov    (%rax,%rdi,4),%ecx
lea    (%rdx,%rdi,1),%ebp
cmp    %ecx,%esi
cmovne %ebp,%r9d
add    $0x1,%rdi
mov    %ecx,%esi
cmp    %rdi,%r8
jne    1af0 <maxProfit+0x9c0>
test   %r9d,%r9d
mov    0x8(%rsp),%rbx
jle    1c04 <maxProfit+0xad4>
mov    0x10(%rbx),%rdx
mov    %r9d,%ebp
lea    -0x1(%rbp),%rax
mov    %ebp,%esi
and    $0x3,%esi
cmp    $0x3,%rax
jae    1b9f <maxProfit+0xa6f>
xor    %edi,%edi
xor    %r8d,%r8d
test   %rsi,%rsi
je     1b58 <maxProfit+0xa28>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdx,%rdi,4),%eax
cmp    %eax,%r15d
cmovl  %edi,%r8d
cmovl  %eax,%r15d
add    $0x1,%rdi
add    $0xffffffffffffffff,%rsi
jne    1b40 <maxProfit+0xa10>
mov    $0x1,%ecx
cmp    $0x2,%r8d
jl     1c93 <maxProfit+0xb63>
mov    0x10(%rsp),%rax
mov    0x10(%rax),%r15
mov    %r8d,%eax
mov    0x4(%r15),%ebp
lea    -0x1(%rax),%r11
add    $0xfffffffffffffffe,%rax
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x3,%rax
jae    1c11 <maxProfit+0xae1>
mov    $0x1,%ecx
mov    $0x1,%ebx
jmp    1c5e <maxProfit+0xb2e>
and    $0xfffffffc,%ebp
xor    %edi,%edi
xor    %r15d,%r15d
xor    %r8d,%r8d
jmp    1bc0 <maxProfit+0xa90>
nopl   0x0(%rax)
mov    %ecx,%r15d
add    $0x4,%rdi
cmp    %rbp,%rdi
je     1b30 <maxProfit+0xa00>
mov    (%rdx,%rdi,4),%ecx
cmp    %ecx,%r15d
cmovl  %edi,%r8d
mov    0x4(%rdx,%rdi,4),%eax
cmovl  %ecx,%r15d
cmp    %eax,%r15d
jl     1be0 <maxProfit+0xab0>
mov    %r15d,%eax
jmp    1be4 <maxProfit+0xab4>
nopl   0x0(%rax)
lea    0x1(%rdi),%r8d
mov    0x8(%rdx,%rdi,4),%ecx
cmp    %ecx,%eax
jl     1bf0 <maxProfit+0xac0>
mov    %eax,%ecx
jmp    1bf4 <maxProfit+0xac4>
lea    0x2(%rdi),%r8d
mov    0xc(%rdx,%rdi,4),%r15d
cmp    %r15d,%ecx
jge    1bb0 <maxProfit+0xa80>
lea    0x3(%rdi),%r8d
jmp    1bb3 <maxProfit+0xa83>
xor    %r8d,%r8d
mov    $0x1,%ecx
jmp    1c93 <maxProfit+0xb63>
and    $0xfffffffffffffffc,%r11
mov    $0x1,%ecx
xor    %ebx,%ebx
nopl   0x0(%rax)
lea    0x2(%rbx),%eax
mov    0x8(%r15,%rbx,4),%esi
mov    0xc(%r15,%rbx,4),%edx
cmp    %esi,%ebp
cmove  %ecx,%eax
lea    0x3(%rbx),%edi
cmp    %edx,%esi
cmove  %eax,%edi
mov    0x10(%r15,%rbx,4),%eax
mov    0x14(%r15,%rbx,4),%ebp
lea    0x5(%rbx),%ecx
add    $0x4,%rbx
cmp    %eax,%edx
cmovne %ebx,%edi
cmp    %ebp,%eax
cmove  %edi,%ecx
cmp    %rbx,%r11
jne    1c20 <maxProfit+0xaf0>
add    $0x1,%rbx
test   %r10,%r10
je     1c86 <maxProfit+0xb56>
lea    0x1(%rbx),%edx
lea    (%r15,%rbx,4),%rax
add    $0x4,%rax
xor    %edi,%edi
mov    (%rax,%rdi,4),%esi
lea    (%rdx,%rdi,1),%ebx
cmp    %esi,%ebp
cmovne %ebx,%ecx
add    $0x1,%rdi
mov    %esi,%ebp
cmp    %rdi,%r10
jne    1c70 <maxProfit+0xb40>
test   %ecx,%ecx
jle    1e3a <maxProfit+0xd0a>
mov    0x8(%rsp),%rbx
mov    0x8(%rbx),%r11
mov    %ecx,%r10d
lea    -0x1(%r10),%rax
mov    %r10d,%edi
and    $0x3,%edi
cmp    $0x3,%rax
jae    1d0a <maxProfit+0xbda>
xor    %ebp,%ebp
xor    %ebx,%ebx
xor    %edx,%edx
test   %rdi,%rdi
je     1cd6 <maxProfit+0xba6>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r11,%rbp,4),%eax
cmp    %eax,%ebx
cmovl  %ebp,%edx
cmovl  %eax,%ebx
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdi
jne    1cc0 <maxProfit+0xb90>
test   %edx,%edx
jle    1e3c <maxProfit+0xd0c>
mov    0x10(%rsp),%rax
mov    0x8(%rax),%r15
mov    %edx,%r11d
mov    (%r15),%r13d
lea    -0x1(%r11),%rax
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x3,%rax
jae    1d71 <maxProfit+0xc41>
mov    $0x1,%esi
xor    %edi,%edi
jmp    1dbe <maxProfit+0xc8e>
and    $0xfffffffc,%r10d
xor    %ebp,%ebp
xor    %ebx,%ebx
xor    %edx,%edx
jmp    1d2b <maxProfit+0xbfb>
cs nopw 0x0(%rax,%rax,1)
mov    %eax,%ebx
add    $0x4,%rbp
cmp    %r10,%rbp
je     1cb0 <maxProfit+0xb80>
mov    (%r11,%rbp,4),%eax
cmp    %eax,%ebx
cmovl  %ebp,%edx
mov    0x4(%r11,%rbp,4),%esi
cmovl  %eax,%ebx
cmp    %esi,%ebx
jl     1d50 <maxProfit+0xc20>
mov    %ebx,%esi
jmp    1d53 <maxProfit+0xc23>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%rbp),%edx
mov    0x8(%r11,%rbp,4),%eax
cmp    %eax,%esi
jl     1d60 <maxProfit+0xc30>
mov    %esi,%eax
jmp    1d63 <maxProfit+0xc33>
lea    0x2(%rbp),%edx
mov    0xc(%r11,%rbp,4),%ebx
cmp    %ebx,%eax
jge    1d20 <maxProfit+0xbf0>
lea    0x3(%rbp),%edx
jmp    1d22 <maxProfit+0xbf2>
and    $0xfffffffc,%r11d
mov    $0x1,%esi
xor    %edi,%edi
nopl   0x0(%rax)
lea    0x1(%rdi),%eax
mov    0x4(%r15,%rdi,4),%ebx
mov    0x8(%r15,%rdi,4),%r12d
cmp    %ebx,%r13d
cmove  %esi,%eax
lea    0x2(%rdi),%ebp
cmp    %r12d,%ebx
cmove  %eax,%ebp
mov    0xc(%r15,%rdi,4),%eax
lea    0x3(%rdi),%esi
cmp    %eax,%r12d
cmove  %ebp,%esi
mov    0x10(%r15,%rdi,4),%r13d
add    $0x4,%rdi
cmp    %r13d,%eax
cmovne %edi,%esi
cmp    %rdi,%r11
jne    1d80 <maxProfit+0xc50>
test   %r10,%r10
je     1df9 <maxProfit+0xcc9>
lea    0x1(%rdi),%r11d
lea    (%r15,%rdi,4),%rdi
add    $0x4,%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rbx,4),%ebp
lea    (%r11,%rbx,1),%eax
cmp    %ebp,%r13d
cmovne %eax,%esi
add    $0x1,%rbx
mov    %ebp,%r13d
cmp    %rbx,%r10
jne    1de0 <maxProfit+0xcb0>
cmp    $0x1,%esi
jne    1e05 <maxProfit+0xcd5>
mov    0x20(%rsp),%r13
jmp    1e3c <maxProfit+0xd0c>
add    $0x1,%esi
mov    0x20(%rsp),%r13
mov    0x8(%rsp),%rbx
jmp    1e46 <maxProfit+0xd16>
mov    $0x1,%edx
mov    0x8(%rsp),%rbx
mov    $0x1,%esi
add    $0x1,%ecx
add    $0x1,%r8d
lea    0x203(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
jmp    1e6a <maxProfit+0xd3a>
xor    %edx,%edx
mov    0x8(%rsp),%rbx
mov    $0x1,%esi
add    $0x1,%edx
add    $0x1,%ecx
add    $0x1,%r8d
add    $0x1,%r9d
add    $0x1,%r14d
mov    %r14d,(%rsp)
lea    0x1cb(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
mov    0x18(%rsp),%r10
movslq %r10d,%rax
mov    (%rbx,%rax,8),%rax
add    $0xffffffff,%r13d
mov    (%rax,%r13,4),%ebx
mov    %ebx,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [27 x i8] c"We need more input numbers\00"
@.str.1 = [7 x i8] c"%d\0A%d\0A\00"
@.str.2 = [19 x i8] c"there is no result\00"
@.str.3 = [13 x i8] c"%d\0A%d\0A%d\0A%d\0A\00"
@.str.4 = [19 x i8] c"%d\0A%d\0A%d\0A%d\0A%d\0A%d\0A\00"
define i32 @maxProfit(i32 %0, i32* %1, i32 %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32**
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32**
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
store i32 %0, i32* %5
store i32* %1, i32** %6
store i32 %2, i32* %7
store i32 0, i32* %11
store i32 0, i32* %12
store i32 1, i32* %13
store i32 0, i32* %14
store i32 1, i32* %15
store i32 0, i32* %16
store i32 1, i32* %17
store i32 0, i32* %18
store i32 1, i32* %19
store i32 0, i32* %20
store i32 1, i32* %21
%30 = load i32, i32* %5
%31 = sext i32 %30 to i64
%32 = mul i64 8, %31
%33 = call i8* @malloc(i64 %32)
%34 = bitcast i8* %33 to i32**
store i32** %34, i32*** %10
store i32 0, i32* %22
br label %35
35: ; preds = %58, %3
%36 = load i32, i32* %22
%37 = load i32, i32* %5
%38 = icmp sle i32 %36, %37
br i1 %38, label %39, label %61
39: ; preds = %35
%40 = load i32, i32* %7
%41 = sext i32 %40 to i64
%42 = mul i64 4, %41
%43 = call i8* @malloc(i64 %42)
%44 = bitcast i8* %43 to i32*
%45 = load i32**, i32*** %10
%46 = load i32, i32* %22
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32*, i32** %45, i64 %47
store i32* %44, i32** %48
%49 = load i32**, i32*** %10
%50 = load i32, i32* %22
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32*, i32** %49, i64 %51
%53 = load i32*, i32** %52
%54 = bitcast i32* %53 to i8*
%55 = load i32, i32* %7
%56 = sext i32 %55 to i64
%57 = mul i64 4, %56
br label %58
58: ; preds = %39
%59 = load i32, i32* %22
%60 = add nsw i32 %59, 1
store i32 %60, i32* %22
br label %35
61: ; preds = %35
%62 = load i32, i32* %7
%63 = icmp slt i32 %62, 2
br i1 %63, label %64, label %66
64: ; preds = %61
%65 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %4
br label %766
66: ; preds = %61
%67 = load i32, i32* %7
%68 = icmp eq i32 %67, 2
br i1 %68, label %72, label %69
69: ; preds = %66
%70 = load i32, i32* %7
%71 = icmp eq i32 %70, 3
br i1 %71, label %72, label %73
72: ; preds = %69, %66
store i32 1, i32* %5
br label %73
73: ; preds = %72, %69
%74 = load i32, i32* %7
%75 = icmp eq i32 %74, 4
br i1 %75, label %79, label %76
76: ; preds = %73
%77 = load i32, i32* %7
%78 = icmp eq i32 %77, 5
br i1 %78, label %79, label %80
79: ; preds = %76, %73
store i32 2, i32* %5
br label %80
80: ; preds = %79, %76
%81 = load i32, i32* %5
%82 = load i32, i32* %7
%83 = sdiv i32 %82, 2
%84 = icmp sgt i32 %81, %83
br i1 %84, label %85, label %86
85: ; preds = %80
store i32 3, i32* %5
br label %86
86: ; preds = %85, %80
%87 = load i32, i32* %5
store i32 %87, i32* %23
%88 = load i32, i32* %5
%89 = load i32, i32* %7
%90 = sdiv i32 %89, 2
%91 = icmp eq i32 %88, %90
br i1 %91, label %92, label %95
92: ; preds = %86
%93 = load i32, i32* %5
%94 = add nsw i32 %93, -1
store i32 %94, i32* %5
br label %95
95: ; preds = %92, %86
%96 = load i32, i32* %23
%97 = add nsw i32 %96, 1
%98 = sext i32 %97 to i64
%99 = mul i64 8, %98
%100 = call i8* @malloc(i64 %99)
%101 = bitcast i8* %100 to i32**
store i32** %101, i32*** %24
store i32 0, i32* %25
br label %102
102: ; preds = %125, %95
%103 = load i32, i32* %25
%104 = load i32, i32* %5
%105 = icmp sle i32 %103, %104
br i1 %105, label %106, label %128
106: ; preds = %102
%107 = load i32, i32* %7
%108 = sext i32 %107 to i64
%109 = mul i64 4, %108
%110 = call i8* @malloc(i64 %109)
%111 = bitcast i8* %110 to i32*
%112 = load i32**, i32*** %24
%113 = load i32, i32* %25
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i32*, i32** %112, i64 %114
store i32* %111, i32** %115
%116 = load i32**, i32*** %24
%117 = load i32, i32* %25
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i32*, i32** %116, i64 %118
%120 = load i32*, i32** %119
%121 = bitcast i32* %120 to i8*
%122 = load i32, i32* %7
%123 = sext i32 %122 to i64
%124 = mul i64 4, %123
br label %125
125: ; preds = %106
%126 = load i32, i32* %25
%127 = add nsw i32 %126, 1
store i32 %127, i32* %25
br label %102
128: ; preds = %102
store i32 0, i32* %26
store i32 1, i32* %8
br label %129
129: ; preds = %246, %128
%130 = load i32, i32* %8
%131 = load i32, i32* %5
%132 = icmp sle i32 %130, %131
br i1 %132, label %133, label %249
133: ; preds = %129
%134 = load i32*, i32** %6
%135 = getelementptr inbounds i32, i32* %134, i64 0
%136 = load i32, i32* %135
%137 = sub nsw i32 0, %136
store i32 %137, i32* %26
store i32 1, i32* %9
br label %138
138: ; preds = %240, %133
%139 = load i32, i32* %9
%140 = load i32, i32* %7
%141 = icmp slt i32 %139, %140
br i1 %141, label %142, label %243
142: ; preds = %138
%143 = load i32**, i32*** %24
%144 = load i32, i32* %8
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i32*, i32** %143, i64 %145
%147 = load i32*, i32** %146
%148 = load i32, i32* %9
%149 = sub nsw i32 %148, 1
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %147, i64 %150
%152 = load i32, i32* %151
%153 = load i32*, i32** %6
%154 = load i32, i32* %9
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %153, i64 %155
%157 = load i32, i32* %156
%158 = load i32, i32* %26
%159 = add nsw i32 %157, %158
%160 = icmp sgt i32 %152, %159
br i1 %160, label %161, label %172
161: ; preds = %142
%162 = load i32**, i32*** %24
%163 = load i32, i32* %8
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i32*, i32** %162, i64 %164
%166 = load i32*, i32** %165
%167 = load i32, i32* %9
%168 = sub nsw i32 %167, 1
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i32, i32* %166, i64 %169
%171 = load i32, i32* %170
br label %180
172: ; preds = %142
%173 = load i32*, i32** %6
%174 = load i32, i32* %9
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i32, i32* %173, i64 %175
%177 = load i32, i32* %176
%178 = load i32, i32* %26
%179 = add nsw i32 %177, %178
br label %180
180: ; preds = %172, %161
%181 = phi i32 [ %171, %161 ], [ %179, %172 ]
%182 = load i32**, i32*** %24
%183 = load i32, i32* %8
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds i32*, i32** %182, i64 %184
%186 = load i32*, i32** %185
%187 = load i32, i32* %9
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i32, i32* %186, i64 %188
store i32 %181, i32* %189
%190 = load i32, i32* %26
%191 = load i32**, i32*** %24
%192 = load i32, i32* %8
%193 = sub nsw i32 %192, 1
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i32*, i32** %191, i64 %194
%196 = load i32*, i32** %195
%197 = load i32, i32* %9
%198 = sub nsw i32 %197, 1
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i32, i32* %196, i64 %199
%201 = load i32, i32* %200
%202 = load i32*, i32** %6
%203 = load i32, i32* %9
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i32, i32* %202, i64 %204
%206 = load i32, i32* %205
%207 = sub nsw i32 %201, %206
%208 = icmp sgt i32 %190, %207
br i1 %208, label %209, label %211
209: ; preds = %180
%210 = load i32, i32* %26
br label %229
211: ; preds = %180
%212 = load i32**, i32*** %24
%213 = load i32, i32* %8
%214 = sub nsw i32 %213, 1
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds i32*, i32** %212, i64 %215
%217 = load i32*, i32** %216
%218 = load i32, i32* %9
%219 = sub nsw i32 %218, 1
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i32, i32* %217, i64 %220
%222 = load i32, i32* %221
%223 = load i32*, i32** %6
%224 = load i32, i32* %9
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds i32, i32* %223, i64 %225
%227 = load i32, i32* %226
%228 = sub nsw i32 %222, %227
br label %229
229: ; preds = %211, %209
%230 = phi i32 [ %210, %209 ], [ %228, %211 ]
store i32 %230, i32* %26
%231 = load i32, i32* %26
%232 = load i32**, i32*** %10
%233 = load i32, i32* %8
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i32*, i32** %232, i64 %234
%236 = load i32*, i32** %235
%237 = load i32, i32* %9
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i32, i32* %236, i64 %238
store i32 %231, i32* %239
br label %240
240: ; preds = %229
%241 = load i32, i32* %9
%242 = add nsw i32 %241, 1
store i32 %242, i32* %9
br label %138
243: ; preds = %138
%244 = load i32, i32* %11
%245 = add nsw i32 %244, 1
store i32 %245, i32* %11
br label %246
246: ; preds = %243
%247 = load i32, i32* %8
%248 = add nsw i32 %247, 1
store i32 %248, i32* %8
br label %129
249: ; preds = %129
store i32 0, i32* %27
%250 = load i32, i32* %5
%251 = icmp eq i32 %250, 1
br i1 %251, label %252, label %372
252: ; preds = %249
store i32 0, i32* %8
br label %253
253: ; preds = %268, %252
%254 = load i32, i32* %8
%255 = load i32, i32* %5
%256 = add nsw i32 %255, 1
%257 = icmp slt i32 %254, %256
br i1 %257, label %258, label %271
258: ; preds = %253
store i32 0, i32* %9
br label %259
259: ; preds = %264, %258
%260 = load i32, i32* %9
%261 = load i32, i32* %7
%262 = icmp slt i32 %260, %261
br i1 %262, label %263, label %267
263: ; preds = %259
br label %264
264: ; preds = %263
%265 = load i32, i32* %9
%266 = add nsw i32 %265, 1
store i32 %266, i32* %9
br label %259
267: ; preds = %259
br label %268
268: ; preds = %267
%269 = load i32, i32* %8
%270 = add nsw i32 %269, 1
store i32 %270, i32* %8
br label %253
271: ; preds = %253
store i32 0, i32* %8
br label %272
272: ; preds = %287, %271
%273 = load i32, i32* %8
%274 = load i32, i32* %5
%275 = add nsw i32 %274, 1
%276 = icmp slt i32 %273, %275
br i1 %276, label %277, label %290
277: ; preds = %272
store i32 0, i32* %9
br label %278
278: ; preds = %283, %277
%279 = load i32, i32* %9
%280 = load i32, i32* %7
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %286
282: ; preds = %278
br label %283
283: ; preds = %282
%284 = load i32, i32* %9
%285 = add nsw i32 %284, 1
store i32 %285, i32* %9
br label %278
286: ; preds = %278
br label %287
287: ; preds = %286
%288 = load i32, i32* %8
%289 = add nsw i32 %288, 1
store i32 %289, i32* %8
br label %272
290: ; preds = %272
store i32 1, i32* %28
%291 = load i32, i32* %7
store i32 %291, i32* %29
store i32 0, i32* %8
br label %292
292: ; preds = %316, %290
%293 = load i32, i32* %8
%294 = load i32, i32* %7
%295 = icmp slt i32 %293, %294
br i1 %295, label %296, label %319
296: ; preds = %292
%297 = load i32, i32* %27
%298 = load i32**, i32*** %24
%299 = getelementptr inbounds i32*, i32** %298, i64 1
%300 = load i32*, i32** %299
%301 = load i32, i32* %8
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds i32, i32* %300, i64 %302
%304 = load i32, i32* %303
%305 = icmp slt i32 %297, %304
br i1 %305, label %306, label %315
306: ; preds = %296
%307 = load i32**, i32*** %24
%308 = getelementptr inbounds i32*, i32** %307, i64 1
%309 = load i32*, i32** %308
%310 = load i32, i32* %8
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds i32, i32* %309, i64 %311
%313 = load i32, i32* %312
store i32 %313, i32* %27
%314 = load i32, i32* %8
store i32 %314, i32* %29
br label %315
315: ; preds = %306, %296
br label %316
316: ; preds = %315
%317 = load i32, i32* %8
%318 = add nsw i32 %317, 1
store i32 %318, i32* %8
br label %292
319: ; preds = %292
store i32 0, i32* %8
br label %320
320: ; preds = %345, %319
%321 = load i32, i32* %8
%322 = load i32, i32* %29
%323 = icmp slt i32 %321, %322
br i1 %323, label %324, label %348
324: ; preds = %320
%325 = load i32**, i32*** %10
%326 = getelementptr inbounds i32*, i32** %325, i64 1
%327 = load i32*, i32** %326
%328 = load i32, i32* %8
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i32, i32* %327, i64 %329
%331 = load i32, i32* %330
%332 = load i32**, i32*** %10
%333 = getelementptr inbounds i32*, i32** %332, i64 1
%334 = load i32*, i32** %333
%335 = load i32, i32* %8
%336 = add nsw i32 %335, 1
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds i32, i32* %334, i64 %337
%339 = load i32, i32* %338
%340 = icmp ne i32 %331, %339
br i1 %340, label %341, label %344
341: ; preds = %324
%342 = load i32, i32* %8
%343 = add nsw i32 %342, 1
store i32 %343, i32* %28
br label %344
344: ; preds = %341, %324
br label %345
345: ; preds = %344
%346 = load i32, i32* %8
%347 = add nsw i32 %346, 1
store i32 %347, i32* %8
br label %320
348: ; preds = %320
%349 = load i32, i32* %28
%350 = icmp eq i32 %349, 1
br i1 %350, label %351, label %352
351: ; preds = %348
store i32 0, i32* %28
br label %352
352: ; preds = %351, %348
%353 = load i32, i32* %28
%354 = add nsw i32 %353, 1
%355 = load i32, i32* %29
%356 = add nsw i32 %355, 1
%357 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 %354, i32 %356)
%358 = load i32**, i32*** %24
%359 = load i32, i32* %5
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds i32*, i32** %358, i64 %360
%362 = load i32*, i32** %361
%363 = load i32, i32* %7
%364 = sub nsw i32 %363, 1
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds i32, i32* %362, i64 %365
%367 = load i32, i32* %366
%368 = icmp eq i32 %367, 0
br i1 %368, label %369, label %371
369: ; preds = %352
%370 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0))
br label %371
371: ; preds = %369, %352
br label %755
372: ; preds = %249
%373 = load i32, i32* %5
%374 = icmp eq i32 %373, 2
br i1 %374, label %375, label %504
375: ; preds = %372
store i32 0, i32* %8
br label %376
376: ; preds = %400, %375
%377 = load i32, i32* %8
%378 = load i32, i32* %7
%379 = icmp slt i32 %377, %378
br i1 %379, label %380, label %403
380: ; preds = %376
%381 = load i32, i32* %27
%382 = load i32**, i32*** %24
%383 = getelementptr inbounds i32*, i32** %382, i64 2
%384 = load i32*, i32** %383
%385 = load i32, i32* %8
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i32, i32* %384, i64 %386
%388 = load i32, i32* %387
%389 = icmp slt i32 %381, %388
br i1 %389, label %390, label %399
390: ; preds = %380
%391 = load i32**, i32*** %24
%392 = getelementptr inbounds i32*, i32** %391, i64 2
%393 = load i32*, i32** %392
%394 = load i32, i32* %8
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i32, i32* %393, i64 %395
%397 = load i32, i32* %396
store i32 %397, i32* %27
%398 = load i32, i32* %8
store i32 %398, i32* %12
br label %399
399: ; preds = %390, %380
br label %400
400: ; preds = %399
%401 = load i32, i32* %8
%402 = add nsw i32 %401, 1
store i32 %402, i32* %8
br label %376
403: ; preds = %376
store i32 0, i32* %8
br label %404
404: ; preds = %429, %403
%405 = load i32, i32* %8
%406 = load i32, i32* %12
%407 = icmp slt i32 %405, %406
br i1 %407, label %408, label %432
408: ; preds = %404
%409 = load i32**, i32*** %10
%410 = getelementptr inbounds i32*, i32** %409, i64 2
%411 = load i32*, i32** %410
%412 = load i32, i32* %8
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds i32, i32* %411, i64 %413
%415 = load i32, i32* %414
%416 = load i32**, i32*** %10
%417 = getelementptr inbounds i32*, i32** %416, i64 2
%418 = load i32*, i32** %417
%419 = load i32, i32* %8
%420 = add nsw i32 %419, 1
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds i32, i32* %418, i64 %421
%423 = load i32, i32* %422
%424 = icmp ne i32 %415, %423
br i1 %424, label %425, label %428
425: ; preds = %408
%426 = load i32, i32* %8
%427 = add nsw i32 %426, 1
store i32 %427, i32* %13
br label %428
428: ; preds = %425, %408
br label %429
429: ; preds = %428
%430 = load i32, i32* %8
%431 = add nsw i32 %430, 1
store i32 %431, i32* %8
br label %404
432: ; preds = %404
store i32 0, i32* %27
store i32 0, i32* %8
br label %433
433: ; preds = %457, %432
%434 = load i32, i32* %8
%435 = load i32, i32* %13
%436 = icmp slt i32 %434, %435
br i1 %436, label %437, label %460
437: ; preds = %433
%438 = load i32, i32* %27
%439 = load i32**, i32*** %24
%440 = getelementptr inbounds i32*, i32** %439, i64 1
%441 = load i32*, i32** %440
%442 = load i32, i32* %8
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds i32, i32* %441, i64 %443
%445 = load i32, i32* %444
%446 = icmp slt i32 %438, %445
br i1 %446, label %447, label %456
447: ; preds = %437
%448 = load i32**, i32*** %24
%449 = getelementptr inbounds i32*, i32** %448, i64 1
%450 = load i32*, i32** %449
%451 = load i32, i32* %8
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds i32, i32* %450, i64 %452
%454 = load i32, i32* %453
store i32 %454, i32* %27
%455 = load i32, i32* %8
store i32 %455, i32* %14
br label %456
456: ; preds = %447, %437
br label %457
457: ; preds = %456
%458 = load i32, i32* %8
%459 = add nsw i32 %458, 1
store i32 %459, i32* %8
br label %433
460: ; preds = %433
store i32 1, i32* %8
br label %461
461: ; preds = %487, %460
%462 = load i32, i32* %8
%463 = load i32, i32* %13
%464 = sub nsw i32 %463, 1
%465 = icmp slt i32 %462, %464
br i1 %465, label %466, label %490
466: ; preds = %461
%467 = load i32**, i32*** %10
%468 = getelementptr inbounds i32*, i32** %467, i64 1
%469 = load i32*, i32** %468
%470 = load i32, i32* %8
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds i32, i32* %469, i64 %471
%473 = load i32, i32* %472
%474 = load i32**, i32*** %10
%475 = getelementptr inbounds i32*, i32** %474, i64 1
%476 = load i32*, i32** %475
%477 = load i32, i32* %8
%478 = add nsw i32 %477, 1
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds i32, i32* %476, i64 %479
%481 = load i32, i32* %480
%482 = icmp ne i32 %473, %481
br i1 %482, label %483, label %486
483: ; preds = %466
%484 = load i32, i32* %8
%485 = add nsw i32 %484, 1
store i32 %485, i32* %15
br label %486
486: ; preds = %483, %466
br label %487
487: ; preds = %486
%488 = load i32, i32* %8
%489 = add nsw i32 %488, 1
store i32 %489, i32* %8
br label %461
490: ; preds = %461
%491 = load i32, i32* %15
%492 = icmp eq i32 %491, 1
br i1 %492, label %493, label %494
493: ; preds = %490
store i32 0, i32* %15
br label %494
494: ; preds = %493, %490
%495 = load i32, i32* %15
%496 = add nsw i32 %495, 1
%497 = load i32, i32* %14
%498 = add nsw i32 %497, 1
%499 = load i32, i32* %13
%500 = add nsw i32 %499, 1
%501 = load i32, i32* %12
%502 = add nsw i32 %501, 1
%503 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i64 0, i64 0), i32 %496, i32 %498, i32 %500, i32 %502)
br label %754
504: ; preds = %372
%505 = load i32, i32* %5
%506 = icmp eq i32 %505, 3
br i1 %506, label %507, label %753
507: ; preds = %504
store i32 0, i32* %8
br label %508
508: ; preds = %532, %507
%509 = load i32, i32* %8
%510 = load i32, i32* %7
%511 = icmp slt i32 %509, %510
br i1 %511, label %512, label %535
512: ; preds = %508
%513 = load i32, i32* %27
%514 = load i32**, i32*** %24
%515 = getelementptr inbounds i32*, i32** %514, i64 3
%516 = load i32*, i32** %515
%517 = load i32, i32* %8
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds i32, i32* %516, i64 %518
%520 = load i32, i32* %519
%521 = icmp slt i32 %513, %520
br i1 %521, label %522, label %531
522: ; preds = %512
%523 = load i32**, i32*** %24
%524 = getelementptr inbounds i32*, i32** %523, i64 3
%525 = load i32*, i32** %524
%526 = load i32, i32* %8
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds i32, i32* %525, i64 %527
%529 = load i32, i32* %528
store i32 %529, i32* %27
%530 = load i32, i32* %8
store i32 %530, i32* %16
br label %531
531: ; preds = %522, %512
br label %532
532: ; preds = %531
%533 = load i32, i32* %8
%534 = add nsw i32 %533, 1
store i32 %534, i32* %8
br label %508
535: ; preds = %508
store i32 0, i32* %8
br label %536
536: ; preds = %561, %535
%537 = load i32, i32* %8
%538 = load i32, i32* %16
%539 = icmp slt i32 %537, %538
br i1 %539, label %540, label %564
540: ; preds = %536
%541 = load i32**, i32*** %10
%542 = getelementptr inbounds i32*, i32** %541, i64 3
%543 = load i32*, i32** %542
%544 = load i32, i32* %8
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds i32, i32* %543, i64 %545
%547 = load i32, i32* %546
%548 = load i32**, i32*** %10
%549 = getelementptr inbounds i32*, i32** %548, i64 3
%550 = load i32*, i32** %549
%551 = load i32, i32* %8
%552 = add nsw i32 %551, 1
%553 = sext i32 %552 to i64
%554 = getelementptr inbounds i32, i32* %550, i64 %553
%555 = load i32, i32* %554
%556 = icmp ne i32 %547, %555
br i1 %556, label %557, label %560
557: ; preds = %540
%558 = load i32, i32* %8
%559 = add nsw i32 %558, 1
store i32 %559, i32* %17
br label %560
560: ; preds = %557, %540
br label %561
561: ; preds = %560
%562 = load i32, i32* %8
%563 = add nsw i32 %562, 1
store i32 %563, i32* %8
br label %536
564: ; preds = %536
store i32 0, i32* %8
br label %565
565: ; preds = %589, %564
%566 = load i32, i32* %8
%567 = load i32, i32* %7
%568 = icmp slt i32 %566, %567
br i1 %568, label %569, label %592
569: ; preds = %565
%570 = load i32, i32* %27
%571 = load i32**, i32*** %24
%572 = getelementptr inbounds i32*, i32** %571, i64 3
%573 = load i32*, i32** %572
%574 = load i32, i32* %8
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds i32, i32* %573, i64 %575
%577 = load i32, i32* %576
%578 = icmp slt i32 %570, %577
br i1 %578, label %579, label %588
579: ; preds = %569
%580 = load i32**, i32*** %24
%581 = getelementptr inbounds i32*, i32** %580, i64 3
%582 = load i32*, i32** %581
%583 = load i32, i32* %8
%584 = sext i32 %583 to i64
%585 = getelementptr inbounds i32, i32* %582, i64 %584
%586 = load i32, i32* %585
store i32 %586, i32* %27
%587 = load i32, i32* %8
store i32 %587, i32* %16
br label %588
588: ; preds = %579, %569
br label %589
589: ; preds = %588
%590 = load i32, i32* %8
%591 = add nsw i32 %590, 1
store i32 %591, i32* %8
br label %565
592: ; preds = %565
store i32 0, i32* %8
br label %593
593: ; preds = %618, %592
%594 = load i32, i32* %8
%595 = load i32, i32* %16
%596 = icmp slt i32 %594, %595
br i1 %596, label %597, label %621
597: ; preds = %593
%598 = load i32**, i32*** %10
%599 = getelementptr inbounds i32*, i32** %598, i64 3
%600 = load i32*, i32** %599
%601 = load i32, i32* %8
%602 = sext i32 %601 to i64
%603 = getelementptr inbounds i32, i32* %600, i64 %602
%604 = load i32, i32* %603
%605 = load i32**, i32*** %10
%606 = getelementptr inbounds i32*, i32** %605, i64 3
%607 = load i32*, i32** %606
%608 = load i32, i32* %8
%609 = add nsw i32 %608, 1
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds i32, i32* %607, i64 %610
%612 = load i32, i32* %611
%613 = icmp ne i32 %604, %612
br i1 %613, label %614, label %617
614: ; preds = %597
%615 = load i32, i32* %8
%616 = add nsw i32 %615, 1
store i32 %616, i32* %17
br label %617
617: ; preds = %614, %597
br label %618
618: ; preds = %617
%619 = load i32, i32* %8
%620 = add nsw i32 %619, 1
store i32 %620, i32* %8
br label %593
621: ; preds = %593
store i32 0, i32* %27
store i32 0, i32* %8
br label %622
622: ; preds = %646, %621
%623 = load i32, i32* %8
%624 = load i32, i32* %17
%625 = icmp slt i32 %623, %624
br i1 %625, label %626, label %649
626: ; preds = %622
%627 = load i32, i32* %27
%628 = load i32**, i32*** %24
%629 = getelementptr inbounds i32*, i32** %628, i64 2
%630 = load i32*, i32** %629
%631 = load i32, i32* %8
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds i32, i32* %630, i64 %632
%634 = load i32, i32* %633
%635 = icmp slt i32 %627, %634
br i1 %635, label %636, label %645
636: ; preds = %626
%637 = load i32**, i32*** %24
%638 = getelementptr inbounds i32*, i32** %637, i64 2
%639 = load i32*, i32** %638
%640 = load i32, i32* %8
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds i32, i32* %639, i64 %641
%643 = load i32, i32* %642
store i32 %643, i32* %27
%644 = load i32, i32* %8
store i32 %644, i32* %18
br label %645
645: ; preds = %636, %626
br label %646
646: ; preds = %645
%647 = load i32, i32* %8
%648 = add nsw i32 %647, 1
store i32 %648, i32* %8
br label %622
649: ; preds = %622
store i32 1, i32* %8
br label %650
650: ; preds = %675, %649
%651 = load i32, i32* %8
%652 = load i32, i32* %18
%653 = icmp slt i32 %651, %652
br i1 %653, label %654, label %678
654: ; preds = %650
%655 = load i32**, i32*** %10
%656 = getelementptr inbounds i32*, i32** %655, i64 2
%657 = load i32*, i32** %656
%658 = load i32, i32* %8
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds i32, i32* %657, i64 %659
%661 = load i32, i32* %660
%662 = load i32**, i32*** %10
%663 = getelementptr inbounds i32*, i32** %662, i64 2
%664 = load i32*, i32** %663
%665 = load i32, i32* %8
%666 = add nsw i32 %665, 1
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds i32, i32* %664, i64 %667
%669 = load i32, i32* %668
%670 = icmp ne i32 %661, %669
br i1 %670, label %671, label %674
671: ; preds = %654
%672 = load i32, i32* %8
%673 = add nsw i32 %672, 1
store i32 %673, i32* %19
br label %674
674: ; preds = %671, %654
br label %675
675: ; preds = %674
%676 = load i32, i32* %8
%677 = add nsw i32 %676, 1
store i32 %677, i32* %8
br label %650
678: ; preds = %650
store i32 0, i32* %27
store i32 0, i32* %8
br label %679
679: ; preds = %703, %678
%680 = load i32, i32* %8
%681 = load i32, i32* %19
%682 = icmp slt i32 %680, %681
br i1 %682, label %683, label %706
683: ; preds = %679
%684 = load i32, i32* %27
%685 = load i32**, i32*** %24
%686 = getelementptr inbounds i32*, i32** %685, i64 1
%687 = load i32*, i32** %686
%688 = load i32, i32* %8
%689 = sext i32 %688 to i64
%690 = getelementptr inbounds i32, i32* %687, i64 %689
%691 = load i32, i32* %690
%692 = icmp slt i32 %684, %691
br i1 %692, label %693, label %702
693: ; preds = %683
%694 = load i32**, i32*** %24
%695 = getelementptr inbounds i32*, i32** %694, i64 1
%696 = load i32*, i32** %695
%697 = load i32, i32* %8
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds i32, i32* %696, i64 %698
%700 = load i32, i32* %699
store i32 %700, i32* %27
%701 = load i32, i32* %8
store i32 %701, i32* %20
br label %702
702: ; preds = %693, %683
br label %703
703: ; preds = %702
%704 = load i32, i32* %8
%705 = add nsw i32 %704, 1
store i32 %705, i32* %8
br label %679
706: ; preds = %679
store i32 0, i32* %8
br label %707
707: ; preds = %732, %706
%708 = load i32, i32* %8
%709 = load i32, i32* %20
%710 = icmp slt i32 %708, %709
br i1 %710, label %711, label %735
711: ; preds = %707
%712 = load i32**, i32*** %10
%713 = getelementptr inbounds i32*, i32** %712, i64 1
%714 = load i32*, i32** %713
%715 = load i32, i32* %8
%716 = sext i32 %715 to i64
%717 = getelementptr inbounds i32, i32* %714, i64 %716
%718 = load i32, i32* %717
%719 = load i32**, i32*** %10
%720 = getelementptr inbounds i32*, i32** %719, i64 1
%721 = load i32*, i32** %720
%722 = load i32, i32* %8
%723 = add nsw i32 %722, 1
%724 = sext i32 %723 to i64
%725 = getelementptr inbounds i32, i32* %721, i64 %724
%726 = load i32, i32* %725
%727 = icmp ne i32 %718, %726
br i1 %727, label %728, label %731
728: ; preds = %711
%729 = load i32, i32* %8
%730 = add nsw i32 %729, 1
store i32 %730, i32* %21
br label %731
731: ; preds = %728, %711
br label %732
732: ; preds = %731
%733 = load i32, i32* %8
%734 = add nsw i32 %733, 1
store i32 %734, i32* %8
br label %707
735: ; preds = %707
%736 = load i32, i32* %21
%737 = icmp eq i32 %736, 1
br i1 %737, label %738, label %739
738: ; preds = %735
store i32 0, i32* %21
br label %739
739: ; preds = %738, %735
%740 = load i32, i32* %21
%741 = add nsw i32 %740, 1
%742 = load i32, i32* %20
%743 = add nsw i32 %742, 1
%744 = load i32, i32* %19
%745 = add nsw i32 %744, 1
%746 = load i32, i32* %18
%747 = add nsw i32 %746, 1
%748 = load i32, i32* %17
%749 = add nsw i32 %748, 1
%750 = load i32, i32* %16
%751 = add nsw i32 %750, 1
%752 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.4, i64 0, i64 0), i32 %741, i32 %743, i32 %745, i32 %747, i32 %749, i32 %751)
br label %753
753: ; preds = %739, %504
br label %754
754: ; preds = %753, %494
br label %755
755: ; preds = %754, %371
%756 = load i32**, i32*** %24
%757 = load i32, i32* %5
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds i32*, i32** %756, i64 %758
%760 = load i32*, i32** %759
%761 = load i32, i32* %7
%762 = sub nsw i32 %761, 1
%763 = sext i32 %762 to i64
%764 = getelementptr inbounds i32, i32* %760, i64 %763
%765 = load i32, i32* %764
store i32 %765, i32* %4
br label %766
766: ; preds = %755, %64
%767 = load i32, i32* %4
ret i32 %767
}

LLVM IR (-O2):
@.str = [27 x i8] c"We need more input numbers\00"
@.str.1 = [7 x i8] c"%d\0A%d\0A\00"
@.str.2 = [19 x i8] c"there is no result\00"
@.str.3 = [13 x i8] c"%d\0A%d\0A%d\0A%d\0A\00"
@.str.4 = [19 x i8] c"%d\0A%d\0A%d\0A%d\0A%d\0A%d\0A\00"
define i32 @maxProfit(i32 %0, i32* nocapture %1, i32 %2) {
%4 = sext i32 %0 to i64
%5 = shl nsw i64 %4, 3
%6 = tail call i8* @malloc(i64 %5)
%7 = bitcast i8* %6 to i32**
%8 = icmp slt i32 %0, 0
br i1 %8, label %14, label %9
9: ; preds = %3
%10 = sext i32 %2 to i64
%11 = shl nsw i64 %10, 2
%12 = add nuw i32 %0, 1
%13 = zext i32 %12 to i64
br label %16
14: ; preds = %16, %3
%15 = icmp slt i32 %2, 2
br i1 %15, label %23, label %25
16: ; preds = %9, %16
%17 = phi i64 [ 0, %9 ], [ %21, %16 ]
%18 = call i8* @calloc(i64 1, i64 %11)
%19 = getelementptr inbounds i32*, i32** %7, i64 %17
%20 = bitcast i32** %19 to i8**
store i8* %18, i8** %20
%21 = add nuw nsw i64 %17, 1
%22 = icmp eq i64 %21, %13
br i1 %22, label %14, label %16
23: ; preds = %14
%24 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0))
br label %1114
25: ; preds = %14
%26 = and i32 %2, -2
%27 = icmp eq i32 %26, 2
%28 = select i1 %27, i32 1, i32 %0
%29 = icmp eq i32 %26, 4
%30 = select i1 %29, i32 2, i32 %28
%31 = lshr i32 %2, 1
%32 = icmp sgt i32 %30, %31
%33 = select i1 %32, i32 3, i32 %30
%34 = icmp eq i32 %33, %31
%35 = sext i1 %34 to i32
%36 = add i32 %33, %35
%37 = add nsw i32 %33, 1
%38 = sext i32 %37 to i64
%39 = shl nsw i64 %38, 3
%40 = tail call i8* @malloc(i64 %39)
%41 = bitcast i8* %40 to i32**
%42 = icmp slt i32 %36, 0
br i1 %42, label %126, label %43
43: ; preds = %25
%44 = zext i32 %2 to i64
%45 = shl nuw nsw i64 %44, 2
%46 = add nuw i32 %36, 1
%47 = zext i32 %46 to i64
br label %55
48: ; preds = %55
%49 = icmp slt i32 %36, 1
br i1 %49, label %126, label %50
50: ; preds = %48
%51 = icmp sgt i32 %2, 1
%52 = add nuw i32 %36, 1
%53 = zext i32 %52 to i64
%54 = zext i32 %2 to i64
br label %62
55: ; preds = %43, %55
%56 = phi i64 [ 0, %43 ], [ %60, %55 ]
%57 = call i8* @calloc(i64 1, i64 %45)
%58 = getelementptr inbounds i32*, i32** %41, i64 %56
%59 = bitcast i32** %58 to i8**
store i8* %57, i8** %59
%60 = add nuw nsw i64 %56, 1
%61 = icmp eq i64 %60, %47
br i1 %61, label %48, label %55
62: ; preds = %50, %123
%63 = phi i64 [ 1, %50 ], [ %124, %123 ]
br i1 %51, label %64, label %123
64: ; preds = %62
%65 = load i32, i32* %1
%66 = sub nsw i32 0, %65
%67 = getelementptr inbounds i32*, i32** %41, i64 %63
%68 = load i32*, i32** %67
%69 = add nsw i64 %63, -1
%70 = getelementptr inbounds i32*, i32** %41, i64 %69
%71 = load i32*, i32** %70
%72 = getelementptr inbounds i32*, i32** %7, i64 %63
%73 = load i32*, i32** %72
%74 = getelementptr i32, i32* %68, i64 %54
%75 = getelementptr i32, i32* %73, i64 1
%76 = getelementptr i32, i32* %73, i64 %54
%77 = icmp ult i32* %68, %76
%78 = icmp ult i32* %75, %74
%79 = and i1 %77, %78
br i1 %79, label %80, label %101
80: ; preds = %64, %80
%81 = phi i64 [ %99, %80 ], [ 1, %64 ]
%82 = phi i32 [ %97, %80 ], [ %66, %64 ]
%83 = add nsw i64 %81, -1
%84 = getelementptr inbounds i32, i32* %68, i64 %83
%85 = load i32, i32* %84
%86 = getelementptr inbounds i32, i32* %1, i64 %81
%87 = load i32, i32* %86
%88 = add nsw i32 %87, %82
%89 = icmp sgt i32 %85, %88
%90 = select i1 %89, i32 %85, i32 %88
%91 = getelementptr inbounds i32, i32* %68, i64 %81
store i32 %90, i32* %91
%92 = getelementptr inbounds i32, i32* %71, i64 %83
%93 = load i32, i32* %92
%94 = load i32, i32* %86
%95 = sub nsw i32 %93, %94
%96 = icmp sgt i32 %82, %95
%97 = select i1 %96, i32 %82, i32 %95
%98 = getelementptr inbounds i32, i32* %73, i64 %81
store i32 %97, i32* %98
%99 = add nuw nsw i64 %81, 1
%100 = icmp eq i64 %99, %54
br i1 %100, label %123, label %80
101: ; preds = %64
%102 = load i32, i32* %68
br label %103
103: ; preds = %101, %103
%104 = phi i32 [ %102, %101 ], [ %112, %103 ]
%105 = phi i64 [ 1, %101 ], [ %121, %103 ]
%106 = phi i32 [ %66, %101 ], [ %119, %103 ]
%107 = add nsw i64 %105, -1
%108 = getelementptr inbounds i32, i32* %1, i64 %105
%109 = load i32, i32* %108
%110 = add nsw i32 %109, %106
%111 = icmp sgt i32 %104, %110
%112 = select i1 %111, i32 %104, i32 %110
%113 = getelementptr inbounds i32, i32* %68, i64 %105
store i32 %112, i32* %113
%114 = getelementptr inbounds i32, i32* %71, i64 %107
%115 = load i32, i32* %114
%116 = load i32, i32* %108
%117 = sub nsw i32 %115, %116
%118 = icmp sgt i32 %106, %117
%119 = select i1 %118, i32 %106, i32 %117
%120 = getelementptr inbounds i32, i32* %73, i64 %105
store i32 %119, i32* %120
%121 = add nuw nsw i64 %105, 1
%122 = icmp eq i64 %121, %54
br i1 %122, label %123, label %103
123: ; preds = %103, %80, %62
%124 = add nuw nsw i64 %63, 1
%125 = icmp eq i64 %124, %53
br i1 %125, label %126, label %62
126: ; preds = %123, %25, %48
switch i32 %36, label %1106 [
i32 1, label %127
i32 2, label %140
i32 3, label %129
]
127: ; preds = %126
%128 = icmp sgt i32 %2, 0
br i1 %128, label %151, label %282
129: ; preds = %126
%130 = icmp sgt i32 %2, 0
br i1 %130, label %131, label %787
131: ; preds = %129
%132 = getelementptr inbounds i32*, i32** %41, i64 3
%133 = load i32*, i32** %132
%134 = zext i32 %2 to i64
%135 = add nsw i64 %134, -1
%136 = and i64 %134, 3
%137 = icmp ult i64 %135, 3
br i1 %137, label %568, label %138
138: ; preds = %131
%139 = and i64 %134, 4294967292
br label %603
140: ; preds = %126
%141 = icmp sgt i32 %2, 0
br i1 %141, label %142, label %388
142: ; preds = %140
%143 = getelementptr inbounds i32*, i32** %41, i64 2
%144 = load i32*, i32** %143
%145 = zext i32 %2 to i64
%146 = add nsw i64 %145, -1
%147 = and i64 %145, 3
%148 = icmp ult i64 %146, 3
br i1 %148, label %298, label %149
149: ; preds = %142
%150 = and i64 %145, 4294967292
br label %331
151: ; preds = %127
%152 = getelementptr inbounds i32*, i32** %41, i64 1
%153 = load i32*, i32** %152
%154 = zext i32 %2 to i64
%155 = add nsw i64 %154, -1
%156 = and i64 %154, 3
%157 = icmp ult i64 %155, 3
br i1 %157, label %160, label %158
158: ; preds = %151
%159 = and i64 %154, 4294967292
br label %193
160: ; preds = %193, %151
%161 = phi i32 [ undef, %151 ], [ %224, %193 ]
%162 = phi i64 [ 0, %151 ], [ %225, %193 ]
%163 = phi i32 [ %2, %151 ], [ %224, %193 ]
%164 = phi i32 [ 0, %151 ], [ %222, %193 ]
%165 = icmp eq i64 %156, 0
br i1 %165, label %180, label %166
166: ; preds = %160, %166
%167 = phi i64 [ %177, %166 ], [ %162, %160 ]
%168 = phi i32 [ %176, %166 ], [ %163, %160 ]
%169 = phi i32 [ %174, %166 ], [ %164, %160 ]
%170 = phi i64 [ %178, %166 ], [ 0, %160 ]
%171 = getelementptr inbounds i32, i32* %153, i64 %167
%172 = load i32, i32* %171
%173 = icmp slt i32 %169, %172
%174 = select i1 %173, i32 %172, i32 %169
%175 = trunc i64 %167 to i32
%176 = select i1 %173, i32 %175, i32 %168
%177 = add nuw nsw i64 %167, 1
%178 = add i64 %170, 1
%179 = icmp eq i64 %178, %156
br i1 %179, label %180, label %166
180: ; preds = %166, %160
%181 = phi i32 [ %161, %160 ], [ %176, %166 ]
%182 = icmp sgt i32 %181, 0
br i1 %182, label %183, label %282
183: ; preds = %180
%184 = getelementptr inbounds i32*, i32** %7, i64 1
%185 = load i32*, i32** %184
%186 = zext i32 %181 to i64
%187 = load i32, i32* %185
%188 = add nsw i64 %186, -1
%189 = and i64 %186, 3
%190 = icmp ult i64 %188, 3
br i1 %190, label %259, label %191
191: ; preds = %183
%192 = and i64 %186, 4294967292
br label %228
193: ; preds = %193, %158
%194 = phi i64 [ 0, %158 ], [ %225, %193 ]
%195 = phi i32 [ %2, %158 ], [ %224, %193 ]
%196 = phi i32 [ 0, %158 ], [ %222, %193 ]
%197 = phi i64 [ 0, %158 ], [ %226, %193 ]
%198 = getelementptr inbounds i32, i32* %153, i64 %194
%199 = load i32, i32* %198
%200 = icmp slt i32 %196, %199
%201 = select i1 %200, i32 %199, i32 %196
%202 = trunc i64 %194 to i32
%203 = select i1 %200, i32 %202, i32 %195
%204 = or i64 %194, 1
%205 = getelementptr inbounds i32, i32* %153, i64 %204
%206 = load i32, i32* %205
%207 = icmp slt i32 %201, %206
%208 = select i1 %207, i32 %206, i32 %201
%209 = trunc i64 %204 to i32
%210 = select i1 %207, i32 %209, i32 %203
%211 = or i64 %194, 2
%212 = getelementptr inbounds i32, i32* %153, i64 %211
%213 = load i32, i32* %212
%214 = icmp slt i32 %208, %213
%215 = select i1 %214, i32 %213, i32 %208
%216 = trunc i64 %211 to i32
%217 = select i1 %214, i32 %216, i32 %210
%218 = or i64 %194, 3
%219 = getelementptr inbounds i32, i32* %153, i64 %218
%220 = load i32, i32* %219
%221 = icmp slt i32 %215, %220
%222 = select i1 %221, i32 %220, i32 %215
%223 = trunc i64 %218 to i32
%224 = select i1 %221, i32 %223, i32 %217
%225 = add nuw nsw i64 %194, 4
%226 = add i64 %197, 4
%227 = icmp eq i64 %226, %159
br i1 %227, label %160, label %193
228: ; preds = %228, %191
%229 = phi i32 [ %187, %191 ], [ %253, %228 ]
%230 = phi i64 [ 0, %191 ], [ %251, %228 ]
%231 = phi i32 [ 1, %191 ], [ %256, %228 ]
%232 = phi i64 [ 0, %191 ], [ %257, %228 ]
%233 = or i64 %230, 1
%234 = getelementptr inbounds i32, i32* %185, i64 %233
%235 = load i32, i32* %234
%236 = icmp eq i32 %229, %235
%237 = trunc i64 %233 to i32
%238 = select i1 %236, i32 %231, i32 %237
%239 = or i64 %230, 2
%240 = getelementptr inbounds i32, i32* %185, i64 %239
%241 = load i32, i32* %240
%242 = icmp eq i32 %235, %241
%243 = trunc i64 %239 to i32
%244 = select i1 %242, i32 %238, i32 %243
%245 = or i64 %230, 3
%246 = getelementptr inbounds i32, i32* %185, i64 %245
%247 = load i32, i32* %246
%248 = icmp eq i32 %241, %247
%249 = trunc i64 %245 to i32
%250 = select i1 %248, i32 %244, i32 %249
%251 = add nuw nsw i64 %230, 4
%252 = getelementptr inbounds i32, i32* %185, i64 %251
%253 = load i32, i32* %252
%254 = icmp eq i32 %247, %253
%255 = trunc i64 %251 to i32
%256 = select i1 %254, i32 %250, i32 %255
%257 = add i64 %232, 4
%258 = icmp eq i64 %257, %192
br i1 %258, label %259, label %228
259: ; preds = %228, %183
%260 = phi i32 [ undef, %183 ], [ %256, %228 ]
%261 = phi i32 [ %187, %183 ], [ %253, %228 ]
%262 = phi i64 [ 0, %183 ], [ %251, %228 ]
%263 = phi i32 [ 1, %183 ], [ %256, %228 ]
%264 = icmp eq i64 %189, 0
br i1 %264, label %278, label %265
265: ; preds = %259, %265
%266 = phi i32 [ %272, %265 ], [ %261, %259 ]
%267 = phi i64 [ %270, %265 ], [ %262, %259 ]
%268 = phi i32 [ %275, %265 ], [ %263, %259 ]
%269 = phi i64 [ %276, %265 ], [ 0, %259 ]
%270 = add nuw nsw i64 %267, 1
%271 = getelementptr inbounds i32, i32* %185, i64 %270
%272 = load i32, i32* %271
%273 = icmp eq i32 %266, %272
%274 = trunc i64 %270 to i32
%275 = select i1 %273, i32 %268, i32 %274
%276 = add i64 %269, 1
%277 = icmp eq i64 %276, %189
br i1 %277, label %278, label %265
278: ; preds = %265, %259
%279 = phi i32 [ %260, %259 ], [ %275, %265 ]
%280 = icmp eq i32 %279, 1
%281 = add nsw i32 %279, 1
br i1 %280, label %282, label %284
282: ; preds = %127, %180, %278
%283 = phi i32 [ %181, %278 ], [ %181, %180 ], [ %2, %127 ]
br label %284
284: ; preds = %278, %282
%285 = phi i32 [ %283, %282 ], [ %181, %278 ]
%286 = phi i32 [ 1, %282 ], [ %281, %278 ]
%287 = add nsw i32 %285, 1
%288 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 %286, i32 %287)
%289 = getelementptr inbounds i32*, i32** %41, i64 1
%290 = load i32*, i32** %289
%291 = add nsw i32 %2, -1
%292 = zext i32 %291 to i64
%293 = getelementptr inbounds i32, i32* %290, i64 %292
%294 = load i32, i32* %293
%295 = icmp eq i32 %294, 0
br i1 %295, label %296, label %1106
296: ; preds = %284
%297 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0))
br label %1106
298: ; preds = %331, %142
%299 = phi i32 [ undef, %142 ], [ %361, %331 ]
%300 = phi i64 [ 0, %142 ], [ %363, %331 ]
%301 = phi i32 [ 0, %142 ], [ %362, %331 ]
%302 = phi i32 [ 0, %142 ], [ %361, %331 ]
%303 = icmp eq i64 %147, 0
br i1 %303, label %318, label %304
304: ; preds = %298, %304
%305 = phi i64 [ %315, %304 ], [ %300, %298 ]
%306 = phi i32 [ %314, %304 ], [ %301, %298 ]
%307 = phi i32 [ %313, %304 ], [ %302, %298 ]
%308 = phi i64 [ %316, %304 ], [ 0, %298 ]
%309 = getelementptr inbounds i32, i32* %144, i64 %305
%310 = load i32, i32* %309
%311 = icmp slt i32 %306, %310
%312 = trunc i64 %305 to i32
%313 = select i1 %311, i32 %312, i32 %307
%314 = select i1 %311, i32 %310, i32 %306
%315 = add nuw nsw i64 %305, 1
%316 = add i64 %308, 1
%317 = icmp eq i64 %316, %147
br i1 %317, label %318, label %304
318: ; preds = %304, %298
%319 = phi i32 [ %299, %298 ], [ %313, %304 ]
%320 = icmp sgt i32 %319, 0
br i1 %320, label %321, label %388
321: ; preds = %318
%322 = getelementptr inbounds i32*, i32** %7, i64 2
%323 = load i32*, i32** %322
%324 = zext i32 %319 to i64
%325 = load i32, i32* %323
%326 = add nsw i64 %324, -1
%327 = and i64 %324, 3
%328 = icmp ult i64 %326, 3
br i1 %328, label %366, label %329
329: ; preds = %321
%330 = and i64 %324, 4294967292
br label %399
331: ; preds = %331, %149
%332 = phi i64 [ 0, %149 ], [ %363, %331 ]
%333 = phi i32 [ 0, %149 ], [ %362, %331 ]
%334 = phi i32 [ 0, %149 ], [ %361, %331 ]
%335 = phi i64 [ 0, %149 ], [ %364, %331 ]
%336 = getelementptr inbounds i32, i32* %144, i64 %332
%337 = load i32, i32* %336
%338 = icmp slt i32 %333, %337
%339 = trunc i64 %332 to i32
%340 = select i1 %338, i32 %339, i32 %334
%341 = select i1 %338, i32 %337, i32 %333
%342 = or i64 %332, 1
%343 = getelementptr inbounds i32, i32* %144, i64 %342
%344 = load i32, i32* %343
%345 = icmp slt i32 %341, %344
%346 = trunc i64 %342 to i32
%347 = select i1 %345, i32 %346, i32 %340
%348 = select i1 %345, i32 %344, i32 %341
%349 = or i64 %332, 2
%350 = getelementptr inbounds i32, i32* %144, i64 %349
%351 = load i32, i32* %350
%352 = icmp slt i32 %348, %351
%353 = trunc i64 %349 to i32
%354 = select i1 %352, i32 %353, i32 %347
%355 = select i1 %352, i32 %351, i32 %348
%356 = or i64 %332, 3
%357 = getelementptr inbounds i32, i32* %144, i64 %356
%358 = load i32, i32* %357
%359 = icmp slt i32 %355, %358
%360 = trunc i64 %356 to i32
%361 = select i1 %359, i32 %360, i32 %354
%362 = select i1 %359, i32 %358, i32 %355
%363 = add nuw nsw i64 %332, 4
%364 = add i64 %335, 4
%365 = icmp eq i64 %364, %150
br i1 %365, label %298, label %331
366: ; preds = %399, %321
%367 = phi i32 [ undef, %321 ], [ %427, %399 ]
%368 = phi i32 [ %325, %321 ], [ %424, %399 ]
%369 = phi i64 [ 0, %321 ], [ %422, %399 ]
%370 = phi i32 [ 1, %321 ], [ %427, %399 ]
%371 = icmp eq i64 %327, 0
br i1 %371, label %385, label %372
372: ; preds = %366, %372
%373 = phi i32 [ %379, %372 ], [ %368, %366 ]
%374 = phi i64 [ %377, %372 ], [ %369, %366 ]
%375 = phi i32 [ %382, %372 ], [ %370, %366 ]
%376 = phi i64 [ %383, %372 ], [ 0, %366 ]
%377 = add nuw nsw i64 %374, 1
%378 = getelementptr inbounds i32, i32* %323, i64 %377
%379 = load i32, i32* %378
%380 = icmp eq i32 %373, %379
%381 = trunc i64 %377 to i32
%382 = select i1 %380, i32 %375, i32 %381
%383 = add i64 %376, 1
%384 = icmp eq i64 %383, %327
br i1 %384, label %385, label %372
385: ; preds = %372, %366
%386 = phi i32 [ %367, %366 ], [ %382, %372 ]
%387 = icmp sgt i32 %386, 0
br i1 %387, label %388, label %556
388: ; preds = %140, %318, %385
%389 = phi i32 [ %386, %385 ], [ 1, %318 ], [ 1, %140 ]
%390 = phi i32 [ %319, %385 ], [ %319, %318 ], [ 0, %140 ]
%391 = getelementptr inbounds i32*, i32** %41, i64 1
%392 = load i32*, i32** %391
%393 = zext i32 %389 to i64
%394 = add nsw i64 %393, -1
%395 = and i64 %393, 3
%396 = icmp ult i64 %394, 3
br i1 %396, label %430, label %397
397: ; preds = %388
%398 = and i64 %393, 4294967292
br label %467
399: ; preds = %399, %329
%400 = phi i32 [ %325, %329 ], [ %424, %399 ]
%401 = phi i64 [ 0, %329 ], [ %422, %399 ]
%402 = phi i32 [ 1, %329 ], [ %427, %399 ]
%403 = phi i64 [ 0, %329 ], [ %428, %399 ]
%404 = or i64 %401, 1
%405 = getelementptr inbounds i32, i32* %323, i64 %404
%406 = load i32, i32* %405
%407 = icmp eq i32 %400, %406
%408 = trunc i64 %404 to i32
%409 = select i1 %407, i32 %402, i32 %408
%410 = or i64 %401, 2
%411 = getelementptr inbounds i32, i32* %323, i64 %410
%412 = load i32, i32* %411
%413 = icmp eq i32 %406, %412
%414 = trunc i64 %410 to i32
%415 = select i1 %413, i32 %409, i32 %414
%416 = or i64 %401, 3
%417 = getelementptr inbounds i32, i32* %323, i64 %416
%418 = load i32, i32* %417
%419 = icmp eq i32 %412, %418
%420 = trunc i64 %416 to i32
%421 = select i1 %419, i32 %415, i32 %420
%422 = add nuw nsw i64 %401, 4
%423 = getelementptr inbounds i32, i32* %323, i64 %422
%424 = load i32, i32* %423
%425 = icmp eq i32 %418, %424
%426 = trunc i64 %422 to i32
%427 = select i1 %425, i32 %421, i32 %426
%428 = add i64 %403, 4
%429 = icmp eq i64 %428, %330
br i1 %429, label %366, label %399
430: ; preds = %467, %388
%431 = phi i32 [ undef, %388 ], [ %497, %467 ]
%432 = phi i64 [ 0, %388 ], [ %499, %467 ]
%433 = phi i32 [ 0, %388 ], [ %498, %467 ]
%434 = phi i32 [ 0, %388 ], [ %497, %467 ]
%435 = icmp eq i64 %395, 0
br i1 %435, label %450, label %436
436: ; preds = %430, %436
%437 = phi i64 [ %447, %436 ], [ %432, %430 ]
%438 = phi i32 [ %446, %436 ], [ %433, %430 ]
%439 = phi i32 [ %445, %436 ], [ %434, %430 ]
%440 = phi i64 [ %448, %436 ], [ 0, %430 ]
%441 = getelementptr inbounds i32, i32* %392, i64 %437
%442 = load i32, i32* %441
%443 = icmp slt i32 %438, %442
%444 = trunc i64 %437 to i32
%445 = select i1 %443, i32 %444, i32 %439
%446 = select i1 %443, i32 %442, i32 %438
%447 = add nuw nsw i64 %437, 1
%448 = add i64 %440, 1
%449 = icmp eq i64 %448, %395
br i1 %449, label %450, label %436
450: ; preds = %436, %430
%451 = phi i32 [ %431, %430 ], [ %445, %436 ]
%452 = add i32 %451, 1
%453 = icmp sgt i32 %389, 2
br i1 %453, label %454, label %556
454: ; preds = %450
%455 = add nsw i32 %389, -1
%456 = getelementptr inbounds i32*, i32** %7, i64 1
%457 = load i32*, i32** %456
%458 = zext i32 %455 to i64
%459 = getelementptr inbounds i32, i32* %457, i64 1
%460 = load i32, i32* %459
%461 = add nsw i64 %458, -1
%462 = add nsw i64 %458, -2
%463 = and i64 %461, 3
%464 = icmp ult i64 %462, 3
br i1 %464, label %533, label %465
465: ; preds = %454
%466 = and i64 %461, -4
br label %502
467: ; preds = %467, %397
%468 = phi i64 [ 0, %397 ], [ %499, %467 ]
%469 = phi i32 [ 0, %397 ], [ %498, %467 ]
%470 = phi i32 [ 0, %397 ], [ %497, %467 ]
%471 = phi i64 [ 0, %397 ], [ %500, %467 ]
%472 = getelementptr inbounds i32, i32* %392, i64 %468
%473 = load i32, i32* %472
%474 = icmp slt i32 %469, %473
%475 = trunc i64 %468 to i32
%476 = select i1 %474, i32 %475, i32 %470
%477 = select i1 %474, i32 %473, i32 %469
%478 = or i64 %468, 1
%479 = getelementptr inbounds i32, i32* %392, i64 %478
%480 = load i32, i32* %479
%481 = icmp slt i32 %477, %480
%482 = trunc i64 %478 to i32
%483 = select i1 %481, i32 %482, i32 %476
%484 = select i1 %481, i32 %480, i32 %477
%485 = or i64 %468, 2
%486 = getelementptr inbounds i32, i32* %392, i64 %485
%487 = load i32, i32* %486
%488 = icmp slt i32 %484, %487
%489 = trunc i64 %485 to i32
%490 = select i1 %488, i32 %489, i32 %483
%491 = select i1 %488, i32 %487, i32 %484
%492 = or i64 %468, 3
%493 = getelementptr inbounds i32, i32* %392, i64 %492
%494 = load i32, i32* %493
%495 = icmp slt i32 %491, %494
%496 = trunc i64 %492 to i32
%497 = select i1 %495, i32 %496, i32 %490
%498 = select i1 %495, i32 %494, i32 %491
%499 = add nuw nsw i64 %468, 4
%500 = add i64 %471, 4
%501 = icmp eq i64 %500, %398
br i1 %501, label %430, label %467
502: ; preds = %502, %465
%503 = phi i32 [ %460, %465 ], [ %527, %502 ]
%504 = phi i64 [ 1, %465 ], [ %525, %502 ]
%505 = phi i32 [ 1, %465 ], [ %530, %502 ]
%506 = phi i64 [ 0, %465 ], [ %531, %502 ]
%507 = add nuw nsw i64 %504, 1
%508 = getelementptr inbounds i32, i32* %457, i64 %507
%509 = load i32, i32* %508
%510 = icmp eq i32 %503, %509
%511 = trunc i64 %507 to i32
%512 = select i1 %510, i32 %505, i32 %511
%513 = add nuw nsw i64 %504, 2
%514 = getelementptr inbounds i32, i32* %457, i64 %513
%515 = load i32, i32* %514
%516 = icmp eq i32 %509, %515
%517 = trunc i64 %513 to i32
%518 = select i1 %516, i32 %512, i32 %517
%519 = add nuw nsw i64 %504, 3
%520 = getelementptr inbounds i32, i32* %457, i64 %519
%521 = load i32, i32* %520
%522 = icmp eq i32 %515, %521
%523 = trunc i64 %519 to i32
%524 = select i1 %522, i32 %518, i32 %523
%525 = add nuw nsw i64 %504, 4
%526 = getelementptr inbounds i32, i32* %457, i64 %525
%527 = load i32, i32* %526
%528 = icmp eq i32 %521, %527
%529 = trunc i64 %525 to i32
%530 = select i1 %528, i32 %524, i32 %529
%531 = add i64 %506, 4
%532 = icmp eq i64 %531, %466
br i1 %532, label %533, label %502
533: ; preds = %502, %454
%534 = phi i32 [ undef, %454 ], [ %530, %502 ]
%535 = phi i32 [ %460, %454 ], [ %527, %502 ]
%536 = phi i64 [ 1, %454 ], [ %525, %502 ]
%537 = phi i32 [ 1, %454 ], [ %530, %502 ]
%538 = icmp eq i64 %463, 0
br i1 %538, label %552, label %539
539: ; preds = %533, %539
%540 = phi i32 [ %546, %539 ], [ %535, %533 ]
%541 = phi i64 [ %544, %539 ], [ %536, %533 ]
%542 = phi i32 [ %549, %539 ], [ %537, %533 ]
%543 = phi i64 [ %550, %539 ], [ 0, %533 ]
%544 = add nuw nsw i64 %541, 1
%545 = getelementptr inbounds i32, i32* %457, i64 %544
%546 = load i32, i32* %545
%547 = icmp eq i32 %540, %546
%548 = trunc i64 %544 to i32
%549 = select i1 %547, i32 %542, i32 %548
%550 = add i64 %543, 1
%551 = icmp eq i64 %550, %463
br i1 %551, label %552, label %539
552: ; preds = %539, %533
%553 = phi i32 [ %534, %533 ], [ %549, %539 ]
%554 = icmp eq i32 %553, 1
%555 = add nsw i32 %553, 1
br i1 %554, label %556, label %560
556: ; preds = %385, %450, %552
%557 = phi i32 [ %389, %552 ], [ %389, %450 ], [ %386, %385 ]
%558 = phi i32 [ %390, %552 ], [ %390, %450 ], [ %319, %385 ]
%559 = phi i32 [ %452, %552 ], [ %452, %450 ], [ 1, %385 ]
br label %560
560: ; preds = %552, %556
%561 = phi i32 [ %557, %556 ], [ %389, %552 ]
%562 = phi i32 [ %558, %556 ], [ %390, %552 ]
%563 = phi i32 [ %559, %556 ], [ %452, %552 ]
%564 = phi i32 [ 1, %556 ], [ %555, %552 ]
%565 = add nsw i32 %561, 1
%566 = add nsw i32 %562, 1
%567 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i64 0, i64 0), i32 %564, i32 %563, i32 %565, i32 %566)
br label %1106
568: ; preds = %603, %131
%569 = phi i32 [ undef, %131 ], [ %633, %603 ]
%570 = phi i32 [ undef, %131 ], [ %634, %603 ]
%571 = phi i64 [ 0, %131 ], [ %635, %603 ]
%572 = phi i32 [ 0, %131 ], [ %634, %603 ]
%573 = phi i32 [ 0, %131 ], [ %633, %603 ]
%574 = icmp eq i64 %136, 0
br i1 %574, label %589, label %575
575: ; preds = %568, %575
%576 = phi i64 [ %586, %575 ], [ %571, %568 ]
%577 = phi i32 [ %585, %575 ], [ %572, %568 ]
%578 = phi i32 [ %584, %575 ], [ %573, %568 ]
%579 = phi i64 [ %587, %575 ], [ 0, %568 ]
%580 = getelementptr inbounds i32, i32* %133, i64 %576
%581 = load i32, i32* %580
%582 = icmp slt i32 %577, %581
%583 = trunc i64 %576 to i32
%584 = select i1 %582, i32 %583, i32 %578
%585 = select i1 %582, i32 %581, i32 %577
%586 = add nuw nsw i64 %576, 1
%587 = add i64 %579, 1
%588 = icmp eq i64 %587, %136
br i1 %588, label %589, label %575
589: ; preds = %575, %568
%590 = phi i32 [ %569, %568 ], [ %584, %575 ]
%591 = phi i32 [ %570, %568 ], [ %585, %575 ]
%592 = icmp sgt i32 %590, 0
br i1 %592, label %593, label %657
593: ; preds = %589
%594 = getelementptr inbounds i32*, i32** %7, i64 3
%595 = load i32*, i32** %594
%596 = zext i32 %590 to i64
%597 = load i32, i32* %595
%598 = add nsw i64 %596, -1
%599 = and i64 %596, 3
%600 = icmp ult i64 %598, 3
br i1 %600, label %638, label %601
601: ; preds = %593
%602 = and i64 %596, 4294967292
br label %666
603: ; preds = %603, %138
%604 = phi i64 [ 0, %138 ], [ %635, %603 ]
%605 = phi i32 [ 0, %138 ], [ %634, %603 ]
%606 = phi i32 [ 0, %138 ], [ %633, %603 ]
%607 = phi i64 [ 0, %138 ], [ %636, %603 ]
%608 = getelementptr inbounds i32, i32* %133, i64 %604
%609 = load i32, i32* %608
%610 = icmp slt i32 %605, %609
%611 = trunc i64 %604 to i32
%612 = select i1 %610, i32 %611, i32 %606
%613 = select i1 %610, i32 %609, i32 %605
%614 = or i64 %604, 1
%615 = getelementptr inbounds i32, i32* %133, i64 %614
%616 = load i32, i32* %615
%617 = icmp slt i32 %613, %616
%618 = trunc i64 %614 to i32
%619 = select i1 %617, i32 %618, i32 %612
%620 = select i1 %617, i32 %616, i32 %613
%621 = or i64 %604, 2
%622 = getelementptr inbounds i32, i32* %133, i64 %621
%623 = load i32, i32* %622
%624 = icmp slt i32 %620, %623
%625 = trunc i64 %621 to i32
%626 = select i1 %624, i32 %625, i32 %619
%627 = select i1 %624, i32 %623, i32 %620
%628 = or i64 %604, 3
%629 = getelementptr inbounds i32, i32* %133, i64 %628
%630 = load i32, i32* %629
%631 = icmp slt i32 %627, %630
%632 = trunc i64 %628 to i32
%633 = select i1 %631, i32 %632, i32 %626
%634 = select i1 %631, i32 %630, i32 %627
%635 = add nuw nsw i64 %604, 4
%636 = add i64 %607, 4
%637 = icmp eq i64 %636, %139
br i1 %637, label %568, label %603
638: ; preds = %666, %593
%639 = phi i32 [ undef, %593 ], [ %694, %666 ]
%640 = phi i32 [ %597, %593 ], [ %691, %666 ]
%641 = phi i64 [ 0, %593 ], [ %689, %666 ]
%642 = phi i32 [ 1, %593 ], [ %694, %666 ]
%643 = icmp eq i64 %599, 0
br i1 %643, label %657, label %644
644: ; preds = %638, %644
%645 = phi i32 [ %651, %644 ], [ %640, %638 ]
%646 = phi i64 [ %649, %644 ], [ %641, %638 ]
%647 = phi i32 [ %654, %644 ], [ %642, %638 ]
%648 = phi i64 [ %655, %644 ], [ 0, %638 ]
%649 = add nuw nsw i64 %646, 1
%650 = getelementptr inbounds i32, i32* %595, i64 %649
%651 = load i32, i32* %650
%652 = icmp eq i32 %645, %651
%653 = trunc i64 %649 to i32
%654 = select i1 %652, i32 %647, i32 %653
%655 = add i64 %648, 1
%656 = icmp eq i64 %655, %599
br i1 %656, label %657, label %644
657: ; preds = %638, %644, %589
%658 = phi i32 [ 1, %589 ], [ %639, %638 ], [ %654, %644 ]
br i1 %130, label %659, label %717
659: ; preds = %657
%660 = getelementptr inbounds i32*, i32** %41, i64 3
%661 = load i32*, i32** %660
%662 = and i64 %134, 3
%663 = icmp ult i64 %135, 3
br i1 %663, label %697, label %664
664: ; preds = %659
%665 = and i64 %134, 4294967292
br label %730
666: ; preds = %666, %601
%667 = phi i32 [ %597, %601 ], [ %691, %666 ]
%668 = phi i64 [ 0, %601 ], [ %689, %666 ]
%669 = phi i32 [ 1, %601 ], [ %694, %666 ]
%670 = phi i64 [ 0, %601 ], [ %695, %666 ]
%671 = or i64 %668, 1
%672 = getelementptr inbounds i32, i32* %595, i64 %671
%673 = load i32, i32* %672
%674 = icmp eq i32 %667, %673
%675 = trunc i64 %671 to i32
%676 = select i1 %674, i32 %669, i32 %675
%677 = or i64 %668, 2
%678 = getelementptr inbounds i32, i32* %595, i64 %677
%679 = load i32, i32* %678
%680 = icmp eq i32 %673, %679
%681 = trunc i64 %677 to i32
%682 = select i1 %680, i32 %676, i32 %681
%683 = or i64 %668, 3
%684 = getelementptr inbounds i32, i32* %595, i64 %683
%685 = load i32, i32* %684
%686 = icmp eq i32 %679, %685
%687 = trunc i64 %683 to i32
%688 = select i1 %686, i32 %682, i32 %687
%689 = add nuw nsw i64 %668, 4
%690 = getelementptr inbounds i32, i32* %595, i64 %689
%691 = load i32, i32* %690
%692 = icmp eq i32 %685, %691
%693 = trunc i64 %689 to i32
%694 = select i1 %692, i32 %688, i32 %693
%695 = add i64 %670, 4
%696 = icmp eq i64 %695, %602
br i1 %696, label %638, label %666
697: ; preds = %730, %659
%698 = phi i32 [ undef, %659 ], [ %760, %730 ]
%699 = phi i64 [ 0, %659 ], [ %762, %730 ]
%700 = phi i32 [ %591, %659 ], [ %761, %730 ]
%701 = phi i32 [ %590, %659 ], [ %760, %730 ]
%702 = icmp eq i64 %662, 0
br i1 %702, label %717, label %703
703: ; preds = %697, %703
%704 = phi i64 [ %714, %703 ], [ %699, %697 ]
%705 = phi i32 [ %713, %703 ], [ %700, %697 ]
%706 = phi i32 [ %712, %703 ], [ %701, %697 ]
%707 = phi i64 [ %715, %703 ], [ 0, %697 ]
%708 = getelementptr inbounds i32, i32* %661, i64 %704
%709 = load i32, i32* %708
%710 = icmp slt i32 %705, %709
%711 = trunc i64 %704 to i32
%712 = select i1 %710, i32 %711, i32 %706
%713 = select i1 %710, i32 %709, i32 %705
%714 = add nuw nsw i64 %704, 1
%715 = add i64 %707, 1
%716 = icmp eq i64 %715, %662
br i1 %716, label %717, label %703
717: ; preds = %697, %703, %657
%718 = phi i32 [ %590, %657 ], [ %698, %697 ], [ %712, %703 ]
%719 = icmp sgt i32 %718, 0
br i1 %719, label %720, label %784
720: ; preds = %717
%721 = getelementptr inbounds i32*, i32** %7, i64 3
%722 = load i32*, i32** %721
%723 = zext i32 %718 to i64
%724 = load i32, i32* %722
%725 = add nsw i64 %723, -1
%726 = and i64 %723, 3
%727 = icmp ult i64 %725, 3
br i1 %727, label %765, label %728
728: ; preds = %720
%729 = and i64 %723, 4294967292
br label %798
730: ; preds = %730, %664
%731 = phi i64 [ 0, %664 ], [ %762, %730 ]
%732 = phi i32 [ %591, %664 ], [ %761, %730 ]
%733 = phi i32 [ %590, %664 ], [ %760, %730 ]
%734 = phi i64 [ 0, %664 ], [ %763, %730 ]
%735 = getelementptr inbounds i32, i32* %661, i64 %731
%736 = load i32, i32* %735
%737 = icmp slt i32 %732, %736
%738 = trunc i64 %731 to i32
%739 = select i1 %737, i32 %738, i32 %733
%740 = select i1 %737, i32 %736, i32 %732
%741 = or i64 %731, 1
%742 = getelementptr inbounds i32, i32* %661, i64 %741
%743 = load i32, i32* %742
%744 = icmp slt i32 %740, %743
%745 = trunc i64 %741 to i32
%746 = select i1 %744, i32 %745, i32 %739
%747 = select i1 %744, i32 %743, i32 %740
%748 = or i64 %731, 2
%749 = getelementptr inbounds i32, i32* %661, i64 %748
%750 = load i32, i32* %749
%751 = icmp slt i32 %747, %750
%752 = trunc i64 %748 to i32
%753 = select i1 %751, i32 %752, i32 %746
%754 = select i1 %751, i32 %750, i32 %747
%755 = or i64 %731, 3
%756 = getelementptr inbounds i32, i32* %661, i64 %755
%757 = load i32, i32* %756
%758 = icmp slt i32 %754, %757
%759 = trunc i64 %755 to i32
%760 = select i1 %758, i32 %759, i32 %753
%761 = select i1 %758, i32 %757, i32 %754
%762 = add nuw nsw i64 %731, 4
%763 = add i64 %734, 4
%764 = icmp eq i64 %763, %665
br i1 %764, label %697, label %730
765: ; preds = %798, %720
%766 = phi i32 [ undef, %720 ], [ %826, %798 ]
%767 = phi i32 [ %724, %720 ], [ %823, %798 ]
%768 = phi i64 [ 0, %720 ], [ %821, %798 ]
%769 = phi i32 [ %658, %720 ], [ %826, %798 ]
%770 = icmp eq i64 %726, 0
br i1 %770, label %784, label %771
771: ; preds = %765, %771
%772 = phi i32 [ %778, %771 ], [ %767, %765 ]
%773 = phi i64 [ %776, %771 ], [ %768, %765 ]
%774 = phi i32 [ %781, %771 ], [ %769, %765 ]
%775 = phi i64 [ %782, %771 ], [ 0, %765 ]
%776 = add nuw nsw i64 %773, 1
%777 = getelementptr inbounds i32, i32* %722, i64 %776
%778 = load i32, i32* %777
%779 = icmp eq i32 %772, %778
%780 = trunc i64 %776 to i32
%781 = select i1 %779, i32 %774, i32 %780
%782 = add i64 %775, 1
%783 = icmp eq i64 %782, %726
br i1 %783, label %784, label %771
784: ; preds = %765, %771, %717
%785 = phi i32 [ %658, %717 ], [ %766, %765 ], [ %781, %771 ]
%786 = icmp sgt i32 %785, 0
br i1 %786, label %787, label %921
787: ; preds = %129, %784
%788 = phi i32 [ %785, %784 ], [ 1, %129 ]
%789 = phi i32 [ %718, %784 ], [ 0, %129 ]
%790 = getelementptr inbounds i32*, i32** %41, i64 2
%791 = load i32*, i32** %790
%792 = zext i32 %788 to i64
%793 = add nsw i64 %792, -1
%794 = and i64 %792, 3
%795 = icmp ult i64 %793, 3
br i1 %795, label %829, label %796
796: ; preds = %787
%797 = and i64 %792, 4294967292
br label %864
798: ; preds = %798, %728
%799 = phi i32 [ %724, %728 ], [ %823, %798 ]
%800 = phi i64 [ 0, %728 ], [ %821, %798 ]
%801 = phi i32 [ %658, %728 ], [ %826, %798 ]
%802 = phi i64 [ 0, %728 ], [ %827, %798 ]
%803 = or i64 %800, 1
%804 = getelementptr inbounds i32, i32* %722, i64 %803
%805 = load i32, i32* %804
%806 = icmp eq i32 %799, %805
%807 = trunc i64 %803 to i32
%808 = select i1 %806, i32 %801, i32 %807
%809 = or i64 %800, 2
%810 = getelementptr inbounds i32, i32* %722, i64 %809
%811 = load i32, i32* %810
%812 = icmp eq i32 %805, %811
%813 = trunc i64 %809 to i32
%814 = select i1 %812, i32 %808, i32 %813
%815 = or i64 %800, 3
%816 = getelementptr inbounds i32, i32* %722, i64 %815
%817 = load i32, i32* %816
%818 = icmp eq i32 %811, %817
%819 = trunc i64 %815 to i32
%820 = select i1 %818, i32 %814, i32 %819
%821 = add nuw nsw i64 %800, 4
%822 = getelementptr inbounds i32, i32* %722, i64 %821
%823 = load i32, i32* %822
%824 = icmp eq i32 %817, %823
%825 = trunc i64 %821 to i32
%826 = select i1 %824, i32 %820, i32 %825
%827 = add i64 %802, 4
%828 = icmp eq i64 %827, %729
br i1 %828, label %765, label %798
829: ; preds = %864, %787
%830 = phi i32 [ undef, %787 ], [ %894, %864 ]
%831 = phi i64 [ 0, %787 ], [ %896, %864 ]
%832 = phi i32 [ 0, %787 ], [ %895, %864 ]
%833 = phi i32 [ 0, %787 ], [ %894, %864 ]
%834 = icmp eq i64 %794, 0
br i1 %834, label %849, label %835
835: ; preds = %829, %835
%836 = phi i64 [ %846, %835 ], [ %831, %829 ]
%837 = phi i32 [ %845, %835 ], [ %832, %829 ]
%838 = phi i32 [ %844, %835 ], [ %833, %829 ]
%839 = phi i64 [ %847, %835 ], [ 0, %829 ]
%840 = getelementptr inbounds i32, i32* %791, i64 %836
%841 = load i32, i32* %840
%842 = icmp slt i32 %837, %841
%843 = trunc i64 %836 to i32
%844 = select i1 %842, i32 %843, i32 %838
%845 = select i1 %842, i32 %841, i32 %837
%846 = add nuw nsw i64 %836, 1
%847 = add i64 %839, 1
%848 = icmp eq i64 %847, %794
br i1 %848, label %849, label %835
849: ; preds = %835, %829
%850 = phi i32 [ %830, %829 ], [ %844, %835 ]
%851 = icmp sgt i32 %850, 1
br i1 %851, label %852, label %921
852: ; preds = %849
%853 = getelementptr inbounds i32*, i32** %7, i64 2
%854 = load i32*, i32** %853
%855 = zext i32 %850 to i64
%856 = getelementptr inbounds i32, i32* %854, i64 1
%857 = load i32, i32* %856
%858 = add nsw i64 %855, -1
%859 = add nsw i64 %855, -2
%860 = and i64 %858, 3
%861 = icmp ult i64 %859, 3
br i1 %861, label %899, label %862
862: ; preds = %852
%863 = and i64 %858, -4
br label %934
864: ; preds = %864, %796
%865 = phi i64 [ 0, %796 ], [ %896, %864 ]
%866 = phi i32 [ 0, %796 ], [ %895, %864 ]
%867 = phi i32 [ 0, %796 ], [ %894, %864 ]
%868 = phi i64 [ 0, %796 ], [ %897, %864 ]
%869 = getelementptr inbounds i32, i32* %791, i64 %865
%870 = load i32, i32* %869
%871 = icmp slt i32 %866, %870
%872 = trunc i64 %865 to i32
%873 = select i1 %871, i32 %872, i32 %867
%874 = select i1 %871, i32 %870, i32 %866
%875 = or i64 %865, 1
%876 = getelementptr inbounds i32, i32* %791, i64 %875
%877 = load i32, i32* %876
%878 = icmp slt i32 %874, %877
%879 = trunc i64 %875 to i32
%880 = select i1 %878, i32 %879, i32 %873
%881 = select i1 %878, i32 %877, i32 %874
%882 = or i64 %865, 2
%883 = getelementptr inbounds i32, i32* %791, i64 %882
%884 = load i32, i32* %883
%885 = icmp slt i32 %881, %884
%886 = trunc i64 %882 to i32
%887 = select i1 %885, i32 %886, i32 %880
%888 = select i1 %885, i32 %884, i32 %881
%889 = or i64 %865, 3
%890 = getelementptr inbounds i32, i32* %791, i64 %889
%891 = load i32, i32* %890
%892 = icmp slt i32 %888, %891
%893 = trunc i64 %889 to i32
%894 = select i1 %892, i32 %893, i32 %887
%895 = select i1 %892, i32 %891, i32 %888
%896 = add nuw nsw i64 %865, 4
%897 = add i64 %868, 4
%898 = icmp eq i64 %897, %797
br i1 %898, label %829, label %864
899: ; preds = %934, %852
%900 = phi i32 [ undef, %852 ], [ %962, %934 ]
%901 = phi i32 [ %857, %852 ], [ %959, %934 ]
%902 = phi i64 [ 1, %852 ], [ %957, %934 ]
%903 = phi i32 [ 1, %852 ], [ %962, %934 ]
%904 = icmp eq i64 %860, 0
br i1 %904, label %918, label %905
905: ; preds = %899, %905
%906 = phi i32 [ %912, %905 ], [ %901, %899 ]
%907 = phi i64 [ %910, %905 ], [ %902, %899 ]
%908 = phi i32 [ %915, %905 ], [ %903, %899 ]
%909 = phi i64 [ %916, %905 ], [ 0, %899 ]
%910 = add nuw nsw i64 %907, 1
%911 = getelementptr inbounds i32, i32* %854, i64 %910
%912 = load i32, i32* %911
%913 = icmp eq i32 %906, %912
%914 = trunc i64 %910 to i32
%915 = select i1 %913, i32 %908, i32 %914
%916 = add i64 %909, 1
%917 = icmp eq i64 %916, %860
br i1 %917, label %918, label %905
918: ; preds = %905, %899
%919 = phi i32 [ %900, %899 ], [ %915, %905 ]
%920 = icmp sgt i32 %919, 0
br i1 %920, label %921, label %1087
921: ; preds = %784, %849, %918
%922 = phi i32 [ %919, %918 ], [ 1, %849 ], [ 1, %784 ]
%923 = phi i32 [ %788, %918 ], [ %788, %849 ], [ %785, %784 ]
%924 = phi i32 [ %789, %918 ], [ %789, %849 ], [ %718, %784 ]
%925 = phi i32 [ %850, %918 ], [ %850, %849 ], [ 0, %784 ]
%926 = getelementptr inbounds i32*, i32** %41, i64 1
%927 = load i32*, i32** %926
%928 = zext i32 %922 to i64
%929 = add nsw i64 %928, -1
%930 = and i64 %928, 3
%931 = icmp ult i64 %929, 3
br i1 %931, label %965, label %932
932: ; preds = %921
%933 = and i64 %928, 4294967292
br label %998
934: ; preds = %934, %862
%935 = phi i32 [ %857, %862 ], [ %959, %934 ]
%936 = phi i64 [ 1, %862 ], [ %957, %934 ]
%937 = phi i32 [ 1, %862 ], [ %962, %934 ]
%938 = phi i64 [ 0, %862 ], [ %963, %934 ]
%939 = add nuw nsw i64 %936, 1
%940 = getelementptr inbounds i32, i32* %854, i64 %939
%941 = load i32, i32* %940
%942 = icmp eq i32 %935, %941
%943 = trunc i64 %939 to i32
%944 = select i1 %942, i32 %937, i32 %943
%945 = add nuw nsw i64 %936, 2
%946 = getelementptr inbounds i32, i32* %854, i64 %945
%947 = load i32, i32* %946
%948 = icmp eq i32 %941, %947
%949 = trunc i64 %945 to i32
%950 = select i1 %948, i32 %944, i32 %949
%951 = add nuw nsw i64 %936, 3
%952 = getelementptr inbounds i32, i32* %854, i64 %951
%953 = load i32, i32* %952
%954 = icmp eq i32 %947, %953
%955 = trunc i64 %951 to i32
%956 = select i1 %954, i32 %950, i32 %955
%957 = add nuw nsw i64 %936, 4
%958 = getelementptr inbounds i32, i32* %854, i64 %957
%959 = load i32, i32* %958
%960 = icmp eq i32 %953, %959
%961 = trunc i64 %957 to i32
%962 = select i1 %960, i32 %956, i32 %961
%963 = add i64 %938, 4
%964 = icmp eq i64 %963, %863
br i1 %964, label %899, label %934
965: ; preds = %998, %921
%966 = phi i32 [ undef, %921 ], [ %1028, %998 ]
%967 = phi i64 [ 0, %921 ], [ %1030, %998 ]
%968 = phi i32 [ 0, %921 ], [ %1029, %998 ]
%969 = phi i32 [ 0, %921 ], [ %1028, %998 ]
%970 = icmp eq i64 %930, 0
br i1 %970, label %985, label %971
971: ; preds = %965, %971
%972 = phi i64 [ %982, %971 ], [ %967, %965 ]
%973 = phi i32 [ %981, %971 ], [ %968, %965 ]
%974 = phi i32 [ %980, %971 ], [ %969, %965 ]
%975 = phi i64 [ %983, %971 ], [ 0, %965 ]
%976 = getelementptr inbounds i32, i32* %927, i64 %972
%977 = load i32, i32* %976
%978 = icmp slt i32 %973, %977
%979 = trunc i64 %972 to i32
%980 = select i1 %978, i32 %979, i32 %974
%981 = select i1 %978, i32 %977, i32 %973
%982 = add nuw nsw i64 %972, 1
%983 = add i64 %975, 1
%984 = icmp eq i64 %983, %930
br i1 %984, label %985, label %971
985: ; preds = %971, %965
%986 = phi i32 [ %966, %965 ], [ %980, %971 ]
%987 = icmp sgt i32 %986, 0
br i1 %987, label %988, label %1087
988: ; preds = %985
%989 = getelementptr inbounds i32*, i32** %7, i64 1
%990 = load i32*, i32** %989
%991 = zext i32 %986 to i64
%992 = load i32, i32* %990
%993 = add nsw i64 %991, -1
%994 = and i64 %991, 3
%995 = icmp ult i64 %993, 3
br i1 %995, label %1064, label %996
996: ; preds = %988
%997 = and i64 %991, 4294967292
br label %1033
998: ; preds = %998, %932
%999 = phi i64 [ 0, %932 ], [ %1030, %998 ]
%1000 = phi i32 [ 0, %932 ], [ %1029, %998 ]
%1001 = phi i32 [ 0, %932 ], [ %1028, %998 ]
%1002 = phi i64 [ 0, %932 ], [ %1031, %998 ]
%1003 = getelementptr inbounds i32, i32* %927, i64 %999
%1004 = load i32, i32* %1003
%1005 = icmp slt i32 %1000, %1004
%1006 = trunc i64 %999 to i32
%1007 = select i1 %1005, i32 %1006, i32 %1001
%1008 = select i1 %1005, i32 %1004, i32 %1000
%1009 = or i64 %999, 1
%1010 = getelementptr inbounds i32, i32* %927, i64 %1009
%1011 = load i32, i32* %1010
%1012 = icmp slt i32 %1008, %1011
%1013 = trunc i64 %1009 to i32
%1014 = select i1 %1012, i32 %1013, i32 %1007
%1015 = select i1 %1012, i32 %1011, i32 %1008
%1016 = or i64 %999, 2
%1017 = getelementptr inbounds i32, i32* %927, i64 %1016
%1018 = load i32, i32* %1017
%1019 = icmp slt i32 %1015, %1018
%1020 = trunc i64 %1016 to i32
%1021 = select i1 %1019, i32 %1020, i32 %1014
%1022 = select i1 %1019, i32 %1018, i32 %1015
%1023 = or i64 %999, 3
%1024 = getelementptr inbounds i32, i32* %927, i64 %1023
%1025 = load i32, i32* %1024
%1026 = icmp slt i32 %1022, %1025
%1027 = trunc i64 %1023 to i32
%1028 = select i1 %1026, i32 %1027, i32 %1021
%1029 = select i1 %1026, i32 %1025, i32 %1022
%1030 = add nuw nsw i64 %999, 4
%1031 = add i64 %1002, 4
%1032 = icmp eq i64 %1031, %933
br i1 %1032, label %965, label %998
1033: ; preds = %1033, %996
%1034 = phi i32 [ %992, %996 ], [ %1058, %1033 ]
%1035 = phi i64 [ 0, %996 ], [ %1056, %1033 ]
%1036 = phi i32 [ 1, %996 ], [ %1061, %1033 ]
%1037 = phi i64 [ 0, %996 ], [ %1062, %1033 ]
%1038 = or i64 %1035, 1
%1039 = getelementptr inbounds i32, i32* %990, i64 %1038
%1040 = load i32, i32* %1039
%1041 = icmp eq i32 %1034, %1040
%1042 = trunc i64 %1038 to i32
%1043 = select i1 %1041, i32 %1036, i32 %1042
%1044 = or i64 %1035, 2
%1045 = getelementptr inbounds i32, i32* %990, i64 %1044
%1046 = load i32, i32* %1045
%1047 = icmp eq i32 %1040, %1046
%1048 = trunc i64 %1044 to i32
%1049 = select i1 %1047, i32 %1043, i32 %1048
%1050 = or i64 %1035, 3
%1051 = getelementptr inbounds i32, i32* %990, i64 %1050
%1052 = load i32, i32* %1051
%1053 = icmp eq i32 %1046, %1052
%1054 = trunc i64 %1050 to i32
%1055 = select i1 %1053, i32 %1049, i32 %1054
%1056 = add nuw nsw i64 %1035, 4
%1057 = getelementptr inbounds i32, i32* %990, i64 %1056
%1058 = load i32, i32* %1057
%1059 = icmp eq i32 %1052, %1058
%1060 = trunc i64 %1056 to i32
%1061 = select i1 %1059, i32 %1055, i32 %1060
%1062 = add i64 %1037, 4
%1063 = icmp eq i64 %1062, %997
br i1 %1063, label %1064, label %1033
1064: ; preds = %1033, %988
%1065 = phi i32 [ undef, %988 ], [ %1061, %1033 ]
%1066 = phi i32 [ %992, %988 ], [ %1058, %1033 ]
%1067 = phi i64 [ 0, %988 ], [ %1056, %1033 ]
%1068 = phi i32 [ 1, %988 ], [ %1061, %1033 ]
%1069 = icmp eq i64 %994, 0
br i1 %1069, label %1083, label %1070
1070: ; preds = %1064, %1070
%1071 = phi i32 [ %1077, %1070 ], [ %1066, %1064 ]
%1072 = phi i64 [ %1075, %1070 ], [ %1067, %1064 ]
%1073 = phi i32 [ %1080, %1070 ], [ %1068, %1064 ]
%1074 = phi i64 [ %1081, %1070 ], [ 0, %1064 ]
%1075 = add nuw nsw i64 %1072, 1
%1076 = getelementptr inbounds i32, i32* %990, i64 %1075
%1077 = load i32, i32* %1076
%1078 = icmp eq i32 %1071, %1077
%1079 = trunc i64 %1075 to i32
%1080 = select i1 %1078, i32 %1073, i32 %1079
%1081 = add i64 %1074, 1
%1082 = icmp eq i64 %1081, %994
br i1 %1082, label %1083, label %1070
1083: ; preds = %1070, %1064
%1084 = phi i32 [ %1065, %1064 ], [ %1080, %1070 ]
%1085 = icmp eq i32 %1084, 1
%1086 = add nsw i32 %1084, 1
br i1 %1085, label %1087, label %1093
1087: ; preds = %918, %985, %1083
%1088 = phi i32 [ %922, %1083 ], [ %922, %985 ], [ %919, %918 ]
%1089 = phi i32 [ %923, %1083 ], [ %923, %985 ], [ %788, %918 ]
%1090 = phi i32 [ %924, %1083 ], [ %924, %985 ], [ %789, %918 ]
%1091 = phi i32 [ %925, %1083 ], [ %925, %985 ], [ %850, %918 ]
%1092 = phi i32 [ %986, %1083 ], [ %986, %985 ], [ 0, %918 ]
br label %1093
1093: ; preds = %1083, %1087
%1094 = phi i32 [ %1088, %1087 ], [ %922, %1083 ]
%1095 = phi i32 [ %1089, %1087 ], [ %923, %1083 ]
%1096 = phi i32 [ %1090, %1087 ], [ %924, %1083 ]
%1097 = phi i32 [ %1091, %1087 ], [ %925, %1083 ]
%1098 = phi i32 [ %1092, %1087 ], [ %986, %1083 ]
%1099 = phi i32 [ 1, %1087 ], [ %1086, %1083 ]
%1100 = add nsw i32 %1098, 1
%1101 = add nsw i32 %1094, 1
%1102 = add nsw i32 %1097, 1
%1103 = add nsw i32 %1095, 1
%1104 = add nsw i32 %1096, 1
%1105 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.4, i64 0, i64 0), i32 %1099, i32 %1100, i32 %1101, i32 %1102, i32 %1103, i32 %1104)
br label %1106
1106: ; preds = %126, %284, %296, %560, %1093
%1107 = sext i32 %36 to i64
%1108 = getelementptr inbounds i32*, i32** %41, i64 %1107
%1109 = load i32*, i32** %1108
%1110 = add nsw i32 %2, -1
%1111 = zext i32 %1110 to i64
%1112 = getelementptr inbounds i32, i32* %1109, i64 %1111
%1113 = load i32, i32* %1112
br label %1114
1114: ; preds = %1106, %23
%1115 = phi i32 [ 0, %23 ], [ %1113, %1106 ]
ret i32 %1115
}