#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ arr3;
typedef int /*<<< orphan*/ arr202;
typedef int /*<<< orphan*/ arr201;
typedef int /*<<< orphan*/ arr20;
typedef int /*<<< orphan*/ arr2;
typedef int /*<<< orphan*/ arr1;
typedef int /*<<< orphan*/ arr0;

/* Variables and functions */
int /*<<< orphan*/ isSorted(int *, int);
int /*<<< orphan*/ mergeSort(int *, int /*<<< orphan*/, int);
int /*<<< orphan*/ printf(char *, ...);
int main(int argc, const char *argv[]) {
  int arr0[] = {};
  int arr1[1] = {1};
  int arr2[2] = {2, 1};
  int arr20[20] = {20, 17, 19, 18, 16, 11, 13, 15, 14, 12,
                   10, 8,  5,  6,  9,  7,  4,  1,  3,  2};
  int arr201[20] = {1,  2,  3,  4,  5,  6,  7,  8,  9,  10,
                    11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
  int arr202[20] = {20, 19, 18, 17, 16, 15, 14, 13, 12, 11,
                    10, 9,  8,  7,  6,  5,  4,  3,  2,  1};
  int arr3[10] = {3, 3, 3, 3, 3, 3, 3, 3, 3, 3};
  mergeSort(arr0, NULL, NULL);
  mergeSort(arr1, 0, 0);
  mergeSort(arr2, 0, 1);
  mergeSort(arr20, 0, 19);
  mergeSort(arr201, 0, 19);
  mergeSort(arr202, 0, 19);
  mergeSort(arr3, 0, 9);
  isSorted(arr0, sizeof(arr0) / sizeof(int));
  isSorted(arr1, sizeof(arr1) / sizeof(int));
  isSorted(arr2, sizeof(arr2) / sizeof(int));
  isSorted(arr20, sizeof(arr20) / sizeof(int));
  isSorted(arr201, sizeof(arr201) / sizeof(int));
  isSorted(arr202, sizeof(arr202) / sizeof(int));
  isSorted(arr3, sizeof(arr3) / sizeof(int));
  printf("\n");
  for (int i = 0; i < 1; i++)
    printf("%d ", arr0[i]);
  printf("\n");
  for (int i = 0; i < 1; i++)
    printf("%d ", arr1[i]);
  printf("\n");
  for (int i = 0; i < 2; i++)
    printf("%d ", arr2[i]);
  printf("\n");
  for (int i = 0; i < 20; i++)
    printf("%d ", arr20[i]);
  printf("\n");
  for (int i = 0; i < 20; i++)
    printf("%d ", arr201[i]);
  printf("\n");
  for (int i = 0; i < 20; i++)
    printf("%d ", arr202[i]);
  printf("\n");
  for (int i = 0; i < 10; i++)
    printf("%d ", arr3[i]);
  printf("\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    0xea1(%rip),%eax
mov    %eax,-0x18(%rbp)
mov    0xe9b(%rip),%rax
mov    %rax,-0x20(%rbp)
lea    -0x70(%rbp),%rdi
lea    0xe98(%rip),%rsi
mov    $0x50,%edx
call   1040 <memcpy@plt>
lea    -0xc0(%rbp),%rdi
lea    0xed0(%rip),%rsi
mov    $0x50,%edx
call   1040 <memcpy@plt>
lea    -0x110(%rbp),%rdi
lea    0xf08(%rip),%rsi
mov    $0x50,%edx
call   1040 <memcpy@plt>
lea    -0x140(%rbp),%rdi
lea    0xf40(%rip),%rsi
mov    $0x28,%edx
call   1040 <memcpy@plt>
lea    -0x14(%rbp),%rdi
xor    %edx,%edx
mov    %edx,%esi
call   1050 <mergeSort@plt>
lea    -0x18(%rbp),%rdi
xor    %edx,%edx
mov    %edx,%esi
call   1050 <mergeSort@plt>
lea    -0x20(%rbp),%rdi
xor    %esi,%esi
mov    $0x1,%edx
call   1050 <mergeSort@plt>
lea    -0x70(%rbp),%rdi
xor    %esi,%esi
mov    $0x13,%edx
call   1050 <mergeSort@plt>
lea    -0xc0(%rbp),%rdi
xor    %esi,%esi
mov    $0x13,%edx
call   1050 <mergeSort@plt>
lea    -0x110(%rbp),%rdi
xor    %esi,%esi
mov    $0x13,%edx
call   1050 <mergeSort@plt>
lea    -0x140(%rbp),%rdi
xor    %esi,%esi
mov    $0x9,%edx
call   1050 <mergeSort@plt>
lea    -0x14(%rbp),%rdi
xor    %esi,%esi
call   1060 <isSorted@plt>
lea    -0x18(%rbp),%rdi
mov    $0x1,%esi
call   1060 <isSorted@plt>
lea    -0x20(%rbp),%rdi
mov    $0x2,%esi
call   1060 <isSorted@plt>
lea    -0x70(%rbp),%rdi
mov    $0x14,%esi
call   1060 <isSorted@plt>
lea    -0xc0(%rbp),%rdi
mov    $0x14,%esi
call   1060 <isSorted@plt>
lea    -0x110(%rbp),%rdi
mov    $0x14,%esi
call   1060 <isSorted@plt>
lea    -0x140(%rbp),%rdi
mov    $0xa,%esi
call   1060 <isSorted@plt>
lea    0xe7c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x144(%rbp)
cmpl   $0x1,-0x144(%rbp)
jge    12f7 <main+0x1b7>
movslq -0x144(%rbp),%rax
mov    -0x14(%rbp,%rax,4),%esi
lea    0xe4e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
jmp    12bd <main+0x17d>
lea    0xe2a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x148(%rbp)
cmpl   $0x1,-0x148(%rbp)
jge    1349 <main+0x209>
movslq -0x148(%rbp),%rax
mov    -0x18(%rbp,%rax,4),%esi
lea    0xdfc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x148(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x148(%rbp)
jmp    130f <main+0x1cf>
lea    0xdd8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x14c(%rbp)
cmpl   $0x2,-0x14c(%rbp)
jge    139b <main+0x25b>
movslq -0x14c(%rbp),%rax
mov    -0x20(%rbp,%rax,4),%esi
lea    0xdaa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x14c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14c(%rbp)
jmp    1361 <main+0x221>
lea    0xd86(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x150(%rbp)
cmpl   $0x14,-0x150(%rbp)
jge    13ed <main+0x2ad>
movslq -0x150(%rbp),%rax
mov    -0x70(%rbp,%rax,4),%esi
lea    0xd58(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x150(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x150(%rbp)
jmp    13b3 <main+0x273>
lea    0xd34(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x154(%rbp)
cmpl   $0x14,-0x154(%rbp)
jge    1442 <main+0x302>
movslq -0x154(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%esi
lea    0xd03(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1405 <main+0x2c5>
lea    0xcdf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x158(%rbp)
cmpl   $0x14,-0x158(%rbp)
jge    1497 <main+0x357>
movslq -0x158(%rbp),%rax
mov    -0x110(%rbp,%rax,4),%esi
lea    0xcae(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    145a <main+0x31a>
lea    0xc8a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x15c(%rbp)
cmpl   $0xa,-0x15c(%rbp)
jge    14ec <main+0x3ac>
movslq -0x15c(%rbp),%rax
mov    -0x140(%rbp,%rax,4),%esi
lea    0xc59(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x15c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x15c(%rbp)
jmp    14af <main+0x36f>
lea    0xc35(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
movl   $0x1,0x4(%rsp)
movabs $0x100000002,%rax
mov    %rax,0x8(%rsp)
movaps 0xed1(%rip),%xmm0
movaps %xmm0,0x120(%rsp)
movaps 0xeb2(%rip),%xmm0
movaps %xmm0,0x110(%rsp)
movaps 0xe93(%rip),%xmm0
movaps %xmm0,0x100(%rsp)
movaps 0xe74(%rip),%xmm0
movaps %xmm0,0xf0(%rsp)
movaps 0xe55(%rip),%xmm0
movaps %xmm0,0xe0(%rsp)
movaps 0xed6(%rip),%xmm0
movaps %xmm0,0xd0(%rsp)
movaps 0xeb7(%rip),%xmm0
movaps %xmm0,0xc0(%rsp)
movaps 0xe98(%rip),%xmm0
movaps %xmm0,0xb0(%rsp)
movaps 0xe79(%rip),%xmm0
movaps %xmm0,0xa0(%rsp)
movaps 0xe5a(%rip),%xmm0
movaps %xmm0,0x90(%rsp)
movaps 0xedb(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
movaps 0xebc(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0xea0(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0xe84(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xe68(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
mov    0xecc(%rip),%rax
mov    %rax,0x30(%rsp)
movaps 0xeb0(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xe94(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
mov    %rsp,%rdi
xor    %esi,%esi
xor    %edx,%edx
call   1050 <mergeSort@plt>
lea    0x4(%rsp),%r15
mov    %r15,%rdi
xor    %esi,%esi
xor    %edx,%edx
call   1050 <mergeSort@plt>
lea    0x8(%rsp),%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    $0x1,%edx
call   1050 <mergeSort@plt>
lea    0xe0(%rsp),%r13
mov    %r13,%rdi
xor    %esi,%esi
mov    $0x13,%edx
call   1050 <mergeSort@plt>
lea    0x90(%rsp),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x13,%edx
call   1050 <mergeSort@plt>
lea    0x40(%rsp),%rbp
mov    %rbp,%rdi
xor    %esi,%esi
mov    $0x13,%edx
call   1050 <mergeSort@plt>
lea    0x10(%rsp),%r14
mov    %r14,%rdi
xor    %esi,%esi
mov    $0x9,%edx
call   1050 <mergeSort@plt>
mov    %rsp,%rdi
xor    %esi,%esi
call   1060 <isSorted@plt>
mov    %r15,%rdi
mov    $0x1,%esi
call   1060 <isSorted@plt>
mov    %r12,%rdi
mov    $0x2,%esi
call   1060 <isSorted@plt>
mov    %r13,%rdi
mov    $0x14,%esi
call   1060 <isSorted@plt>
mov    %rbx,%rdi
mov    $0x14,%esi
call   1060 <isSorted@plt>
mov    %rbp,%rdi
mov    $0x14,%esi
call   1060 <isSorted@plt>
mov    %r14,%rdi
mov    $0xa,%esi
call   1060 <isSorted@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    (%rsp),%esi
lea    0xdc4(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0xe0(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xe4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xe8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xec(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xf0(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xf4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xf8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xfc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x100(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x104(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x108(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x110(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x114(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x118(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x11c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x120(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x124(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x128(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x12c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x90(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x94(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x98(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x9c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xa0(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xa4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xa8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xac(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xb0(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xb4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xb8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xbc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc0(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xcc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xd0(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xd4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xd8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xdc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x40(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x44(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x48(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x50(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x54(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x58(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x5c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x60(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x64(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x68(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x6c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x70(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x74(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x78(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x7c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x80(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x84(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x88(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x14(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x34(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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