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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ find(int);
int /*<<< orphan*/ insert(int);
int parse(int **);
int /*<<< orphan*/ printf(char *, int);
void funct(int x[4][4]) {
  int state = 0, val;
  int b[4][4];
  int temp, i, j, ii, jj;
  for (i = 0; i < 4; i++)
    for (j = 0; j < 4; j++)
      b[i][j] = x[i][j];
  state = 0;
  printf("%d\n", parse(b));
  for (i = 0; i < 3 && find(123456789) == 0; i++) {
    for (j = 0; j < 3; j++) {
      if (b[i][j] == 9 && state == 0) {
        if (i - 1 >= 0) {
          for (ii = 0; ii < 4; ii++)
            for (jj = 0; jj < 4; jj++)
              b[ii][jj] = x[ii][jj];
          temp = b[i][j];
          b[i][j] = b[i - 1][j];
          b[i - 1][j] = temp;
          val = parse(b);
          if (find(val) == 0) {
            insert(val);
            funct(b);
          }
        }
        if (i + 1 < 3) {
          for (ii = 0; ii < 4; ii++)
            for (jj = 0; jj < 4; jj++)
              b[ii][jj] = x[ii][jj];
          temp = b[i][j];
          b[i][j] = b[i + 1][j];
          b[i + 1][j] = temp;
          val = parse(b);
          if (find(val) == 0) {
            insert(val);
            funct(b);
          }
        }
        if (j + 1 < 3) {
          for (ii = 0; ii < 4; ii++)
            for (jj = 0; jj < 4; jj++)
              b[ii][jj] = x[ii][jj];
          temp = b[i][j];
          b[i][j] = b[i][j + 1];
          b[i][j + 1] = temp;
          val = parse(b);
          if (find(val) == 0) {
            insert(val);
            funct(b);
          }
        }
        if (j - 1 >= 0) {
          for (ii = 0; ii < 4; ii++)
            for (jj = 0; jj < 4; jj++)
              b[ii][jj] = x[ii][jj];
          temp = b[i][j];
          b[i][j] = b[i][j - 1];
          b[i][j - 1] = temp;
          val = parse(b);
          if (find(val) == 0) {
            insert(val);
            funct(b);
          }
        }
        state = 1;
      }
    }
  }
}


x86 assembly (clang, -O0):
<funct>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x58(%rbp)
cmpl   $0x4,-0x58(%rbp)
jge    11d2 <funct+0x82>
movl   $0x0,-0x5c(%rbp)
cmpl   $0x4,-0x5c(%rbp)
jge    11bf <funct+0x6f>
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    117b <funct+0x2b>
jmp    11c4 <funct+0x74>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    116a <funct+0x1a>
movl   $0x0,-0xc(%rbp)
lea    -0x50(%rbp),%rdi
call   1070 <parse@plt>
mov    %eax,%esi
lea    0xe15(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x58(%rbp)
xor    %eax,%eax
cmpl   $0x3,-0x58(%rbp)
mov    %al,-0x65(%rbp)
jge    121a <funct+0xca>
mov    $0x75bcd15,%edi
call   1040 <find@plt>
cmp    $0x0,%rax
sete   %al
mov    %al,-0x65(%rbp)
mov    -0x65(%rbp),%al
test   $0x1,%al
jne    122a <funct+0xda>
jmp    16f7 <funct+0x5a7>
movl   $0x0,-0x5c(%rbp)
cmpl   $0x3,-0x5c(%rbp)
jge    16e4 <funct+0x594>
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
cmpl   $0x9,(%rax,%rcx,4)
jne    16d1 <funct+0x581>
cmpl   $0x0,-0xc(%rbp)
jne    16d1 <funct+0x581>
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jl     137c <funct+0x22c>
movl   $0x0,-0x60(%rbp)
cmpl   $0x4,-0x60(%rbp)
jge    12e0 <funct+0x190>
movl   $0x0,-0x64(%rbp)
cmpl   $0x4,-0x64(%rbp)
jge    12cd <funct+0x17d>
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x60(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1289 <funct+0x139>
jmp    12d2 <funct+0x182>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1278 <funct+0x128>
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%edx
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
lea    -0x50(%rbp),%rdi
call   1070 <parse@plt>
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%edi
call   1040 <find@plt>
cmp    $0x0,%rax
jne    1377 <funct+0x227>
mov    -0x10(%rbp),%edi
call   1060 <insert@plt>
lea    -0x50(%rbp),%rdi
call   1050 <funct@plt>
jmp    137c <funct+0x22c>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cmp    $0x3,%eax
jge    1496 <funct+0x346>
movl   $0x0,-0x60(%rbp)
cmpl   $0x4,-0x60(%rbp)
jge    13fa <funct+0x2aa>
movl   $0x0,-0x64(%rbp)
cmpl   $0x4,-0x64(%rbp)
jge    13e7 <funct+0x297>
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x60(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13a3 <funct+0x253>
jmp    13ec <funct+0x29c>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1392 <funct+0x242>
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%edx
mov    -0x58(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
lea    -0x50(%rbp),%rdi
call   1070 <parse@plt>
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%edi
call   1040 <find@plt>
cmp    $0x0,%rax
jne    1491 <funct+0x341>
mov    -0x10(%rbp),%edi
call   1060 <insert@plt>
lea    -0x50(%rbp),%rdi
call   1050 <funct@plt>
jmp    1496 <funct+0x346>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
cmp    $0x3,%eax
jge    15b0 <funct+0x460>
movl   $0x0,-0x60(%rbp)
cmpl   $0x4,-0x60(%rbp)
jge    1514 <funct+0x3c4>
movl   $0x0,-0x64(%rbp)
cmpl   $0x4,-0x64(%rbp)
jge    1501 <funct+0x3b1>
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x60(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    14bd <funct+0x36d>
jmp    1506 <funct+0x3b6>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    14ac <funct+0x35c>
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%edx
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
lea    -0x50(%rbp),%rdi
call   1070 <parse@plt>
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%edi
call   1040 <find@plt>
cmp    $0x0,%rax
jne    15ab <funct+0x45b>
mov    -0x10(%rbp),%edi
call   1060 <insert@plt>
lea    -0x50(%rbp),%rdi
call   1050 <funct@plt>
jmp    15b0 <funct+0x460>
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jl     16ca <funct+0x57a>
movl   $0x0,-0x60(%rbp)
cmpl   $0x4,-0x60(%rbp)
jge    162e <funct+0x4de>
movl   $0x0,-0x64(%rbp)
cmpl   $0x4,-0x64(%rbp)
jge    161b <funct+0x4cb>
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x60(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    15d7 <funct+0x487>
jmp    1620 <funct+0x4d0>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    15c6 <funct+0x476>
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%edx
movslq -0x58(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
lea    -0x50(%rbp),%rdi
call   1070 <parse@plt>
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%edi
call   1040 <find@plt>
cmp    $0x0,%rax
jne    16c5 <funct+0x575>
mov    -0x10(%rbp),%edi
call   1060 <insert@plt>
lea    -0x50(%rbp),%rdi
call   1050 <funct@plt>
jmp    16ca <funct+0x57a>
movl   $0x1,-0xc(%rbp)
jmp    16d6 <funct+0x586>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1231 <funct+0xe1>
jmp    16e9 <funct+0x599>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    11f7 <funct+0xa7>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<funct>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rdi,%rbx
movups (%rdi),%xmm0
movups 0x10(%rdi),%xmm1
movups 0x20(%rdi),%xmm2
movups 0x30(%rdi),%xmm3
movaps %xmm3,0x40(%rsp)
movaps %xmm2,0x30(%rsp)
movaps %xmm1,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
lea    0x10(%rsp),%rdi
call   1070 <parse@plt>
lea    0xe6b(%rip),%rdi
mov    %eax,%esi
call   1030 <printf@plt>
xor    %eax,%eax
mov    %rax,0x8(%rsp)
xor    %r14d,%r14d
jmp    11c7 <funct+0x77>
nopl   0x0(%rax,%rax,1)
mov    0x58(%rsp),%rcx
mov    %rcx,%rax
mov    %rcx,0x8(%rsp)
cmp    $0x3,%rcx
je     142a <funct+0x2da>
mov    $0x75bcd15,%edi
call   1040 <find@plt>
test   %rax,%rax
jne    142a <funct+0x2da>
mov    0x8(%rsp),%rcx
lea    -0x1(%rcx),%rax
mov    %rax,0x60(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,0x58(%rsp)
xor    %r12d,%r12d
jmp    1210 <funct+0xc0>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r12
mov    %r12,%r15
mov    %r15,%r12
cmp    $0x3,%r15
je     11b0 <funct+0x60>
mov    %rcx,%rax
shl    $0x4,%rax
lea    (%rsp,%rax,1),%r13
add    $0x10,%r13
cmpl   $0x9,0x0(%r13,%r12,4)
jne    1200 <funct+0xb0>
test   %r14d,%r14d
jne    1200 <funct+0xb0>
lea    0x0(,%r12,4),%r14
add    %r13,%r14
test   %rcx,%rcx
je     129a <funct+0x14a>
movups (%rbx),%xmm0
movups 0x10(%rbx),%xmm1
movups 0x20(%rbx),%xmm2
movups 0x30(%rbx),%xmm3
movaps %xmm3,0x40(%rsp)
movaps %xmm2,0x30(%rsp)
movaps %xmm1,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
mov    (%r14),%eax
mov    0x60(%rsp),%rcx
shl    $0x4,%rcx
add    %rsp,%rcx
add    $0x10,%rcx
mov    (%rcx,%r12,4),%edx
mov    %edx,(%r14)
mov    %eax,(%rcx,%r12,4)
lea    0x10(%rsp),%rdi
call   1070 <parse@plt>
mov    %eax,%ebp
mov    %eax,%edi
call   1040 <find@plt>
mov    0x8(%rsp),%rcx
test   %rax,%rax
je     1310 <funct+0x1c0>
cmp    $0x1,%rcx
ja     1330 <funct+0x1e0>
movups (%rbx),%xmm0
movups 0x10(%rbx),%xmm1
movups 0x20(%rbx),%xmm2
movups 0x30(%rbx),%xmm3
movaps %xmm3,0x40(%rsp)
movaps %xmm2,0x30(%rsp)
movaps %xmm1,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
mov    (%r14),%eax
mov    0x58(%rsp),%rcx
shl    $0x4,%rcx
add    %rsp,%rcx
add    $0x10,%rcx
mov    (%rcx,%r12,4),%edx
mov    %edx,(%r14)
mov    %eax,(%rcx,%r12,4)
lea    0x10(%rsp),%rdi
call   1070 <parse@plt>
mov    %eax,%ebp
mov    %eax,%edi
call   1040 <find@plt>
test   %rax,%rax
jne    1330 <funct+0x1e0>
mov    %ebp,%edi
call   1060 <insert@plt>
lea    0x10(%rsp),%rdi
call   1050 <funct@plt>
jmp    1330 <funct+0x1e0>
mov    %ebp,%edi
call   1060 <insert@plt>
lea    0x10(%rsp),%rdi
call   1050 <funct@plt>
mov    0x8(%rsp),%rcx
cmp    $0x1,%rcx
jbe    12a4 <funct+0x154>
lea    0x1(%r12),%r15
cmp    $0x1,%r12
ja     138b <funct+0x23b>
movups (%rbx),%xmm0
movups 0x10(%rbx),%xmm1
movups 0x20(%rbx),%xmm2
movups 0x30(%rbx),%xmm3
movaps %xmm3,0x40(%rsp)
movaps %xmm2,0x30(%rsp)
movaps %xmm1,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
mov    (%r14),%eax
mov    0x0(%r13,%r15,4),%ecx
mov    %ecx,(%r14)
mov    %eax,0x0(%r13,%r15,4)
lea    0x10(%rsp),%rdi
call   1070 <parse@plt>
mov    %eax,%ebp
mov    %eax,%edi
call   1040 <find@plt>
test   %rax,%rax
je     13f0 <funct+0x2a0>
test   %r12,%r12
je     1406 <funct+0x2b6>
movups (%rbx),%xmm0
movups 0x10(%rbx),%xmm1
movups 0x20(%rbx),%xmm2
movups 0x30(%rbx),%xmm3
movaps %xmm3,0x40(%rsp)
movaps %xmm2,0x30(%rsp)
movaps %xmm1,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
mov    (%r14),%eax
mov    -0x4(%r13,%r12,4),%ecx
mov    %ecx,(%r14)
mov    %eax,-0x4(%r13,%r12,4)
lea    0x10(%rsp),%r12
mov    %r12,%rdi
call   1070 <parse@plt>
mov    %eax,%ebp
mov    %eax,%edi
call   1040 <find@plt>
mov    $0x1,%r14d
test   %rax,%rax
jne    1420 <funct+0x2d0>
mov    %ebp,%edi
call   1060 <insert@plt>
mov    %r12,%rdi
call   1050 <funct@plt>
jmp    1420 <funct+0x2d0>
mov    %ebp,%edi
call   1060 <insert@plt>
lea    0x10(%rsp),%rdi
call   1050 <funct@plt>
test   %r12,%r12
jne    138b <funct+0x23b>
mov    $0x1,%r14d
mov    $0x1,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rsp),%rcx
jmp    1207 <funct+0xb7>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [4 x i8] c"%d\0A\00"
define void @funct([4 x i32]* %0) {
%2 = alloca [4 x i32]*
%3 = alloca i32
%4 = alloca i32
%5 = alloca [4 x [4 x i32]]
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store [4 x i32]* %0, [4 x i32]** %2
store i32 0, i32* %3
store i32 0, i32* %7
br label %11
11: ; preds = %37, %1
%12 = load i32, i32* %7
%13 = icmp slt i32 %12, 4
br i1 %13, label %14, label %40
14: ; preds = %11
store i32 0, i32* %8
br label %15
15: ; preds = %33, %14
%16 = load i32, i32* %8
%17 = icmp slt i32 %16, 4
br i1 %17, label %18, label %36
18: ; preds = %15
%19 = load [4 x i32]*, [4 x i32]** %2
%20 = load i32, i32* %7
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds [4 x i32], [4 x i32]* %19, i64 %21
%23 = load i32, i32* %8
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 %24
%26 = load i32, i32* %25
%27 = load i32, i32* %7
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %28
%30 = load i32, i32* %8
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [4 x i32], [4 x i32]* %29, i64 0, i64 %31
store i32 %26, i32* %32
br label %33
33: ; preds = %18
%34 = load i32, i32* %8
%35 = add nsw i32 %34, 1
store i32 %35, i32* %8
br label %15
36: ; preds = %15
br label %37
37: ; preds = %36
%38 = load i32, i32* %7
%39 = add nsw i32 %38, 1
store i32 %39, i32* %7
br label %11
40: ; preds = %11
store i32 0, i32* %3
%41 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 0
%42 = bitcast [4 x i32]* %41 to i32**
%43 = call i32 @parse(i32** %42)
%44 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %43)
store i32 0, i32* %7
br label %45
45: ; preds = %375, %40
%46 = load i32, i32* %7
%47 = icmp slt i32 %46, 3
br i1 %47, label %48, label %51
48: ; preds = %45
%49 = call i64 @find(i32 123456789)
%50 = icmp eq i64 %49, 0
br label %51
51: ; preds = %48, %45
%52 = phi i1 [ false, %45 ], [ %50, %48 ]
br i1 %52, label %53, label %378
53: ; preds = %51
store i32 0, i32* %8
br label %54
54: ; preds = %371, %53
%55 = load i32, i32* %8
%56 = icmp slt i32 %55, 3
br i1 %56, label %57, label %374
57: ; preds = %54
%58 = load i32, i32* %7
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %59
%61 = load i32, i32* %8
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [4 x i32], [4 x i32]* %60, i64 0, i64 %62
%64 = load i32, i32* %63
%65 = icmp eq i32 %64, 9
br i1 %65, label %66, label %370
66: ; preds = %57
%67 = load i32, i32* %3
%68 = icmp eq i32 %67, 0
br i1 %68, label %69, label %370
69: ; preds = %66
%70 = load i32, i32* %7
%71 = sub nsw i32 %70, 1
%72 = icmp sge i32 %71, 0
br i1 %72, label %73, label %144
73: ; preds = %69
store i32 0, i32* %9
br label %74
74: ; preds = %100, %73
%75 = load i32, i32* %9
%76 = icmp slt i32 %75, 4
br i1 %76, label %77, label %103
77: ; preds = %74
store i32 0, i32* %10
br label %78
78: ; preds = %96, %77
%79 = load i32, i32* %10
%80 = icmp slt i32 %79, 4
br i1 %80, label %81, label %99
81: ; preds = %78
%82 = load [4 x i32]*, [4 x i32]** %2
%83 = load i32, i32* %9
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [4 x i32], [4 x i32]* %82, i64 %84
%86 = load i32, i32* %10
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [4 x i32], [4 x i32]* %85, i64 0, i64 %87
%89 = load i32, i32* %88
%90 = load i32, i32* %9
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %91
%93 = load i32, i32* %10
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [4 x i32], [4 x i32]* %92, i64 0, i64 %94
store i32 %89, i32* %95
br label %96
96: ; preds = %81
%97 = load i32, i32* %10
%98 = add nsw i32 %97, 1
store i32 %98, i32* %10
br label %78
99: ; preds = %78
br label %100
100: ; preds = %99
%101 = load i32, i32* %9
%102 = add nsw i32 %101, 1
store i32 %102, i32* %9
br label %74
103: ; preds = %74
%104 = load i32, i32* %7
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %105
%107 = load i32, i32* %8
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [4 x i32], [4 x i32]* %106, i64 0, i64 %108
%110 = load i32, i32* %109
store i32 %110, i32* %6
%111 = load i32, i32* %7
%112 = sub nsw i32 %111, 1
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %113
%115 = load i32, i32* %8
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [4 x i32], [4 x i32]* %114, i64 0, i64 %116
%118 = load i32, i32* %117
%119 = load i32, i32* %7
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %120
%122 = load i32, i32* %8
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds [4 x i32], [4 x i32]* %121, i64 0, i64 %123
store i32 %118, i32* %124
%125 = load i32, i32* %6
%126 = load i32, i32* %7
%127 = sub nsw i32 %126, 1
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %128
%130 = load i32, i32* %8
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [4 x i32], [4 x i32]* %129, i64 0, i64 %131
store i32 %125, i32* %132
%133 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 0
%134 = bitcast [4 x i32]* %133 to i32**
%135 = call i32 @parse(i32** %134)
store i32 %135, i32* %4
%136 = load i32, i32* %4
%137 = call i64 @find(i32 %136)
%138 = icmp eq i64 %137, 0
br i1 %138, label %139, label %143
139: ; preds = %103
%140 = load i32, i32* %4
%141 = call i32 @insert(i32 %140)
%142 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 0
br label %143
143: ; preds = %139, %103
br label %144
144: ; preds = %143, %69
%145 = load i32, i32* %7
%146 = add nsw i32 %145, 1
%147 = icmp slt i32 %146, 3
br i1 %147, label %148, label %219
148: ; preds = %144
store i32 0, i32* %9
br label %149
149: ; preds = %175, %148
%150 = load i32, i32* %9
%151 = icmp slt i32 %150, 4
br i1 %151, label %152, label %178
152: ; preds = %149
store i32 0, i32* %10
br label %153
153: ; preds = %171, %152
%154 = load i32, i32* %10
%155 = icmp slt i32 %154, 4
br i1 %155, label %156, label %174
156: ; preds = %153
%157 = load [4 x i32]*, [4 x i32]** %2
%158 = load i32, i32* %9
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds [4 x i32], [4 x i32]* %157, i64 %159
%161 = load i32, i32* %10
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds [4 x i32], [4 x i32]* %160, i64 0, i64 %162
%164 = load i32, i32* %163
%165 = load i32, i32* %9
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %166
%168 = load i32, i32* %10
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds [4 x i32], [4 x i32]* %167, i64 0, i64 %169
store i32 %164, i32* %170
br label %171
171: ; preds = %156
%172 = load i32, i32* %10
%173 = add nsw i32 %172, 1
store i32 %173, i32* %10
br label %153
174: ; preds = %153
br label %175
175: ; preds = %174
%176 = load i32, i32* %9
%177 = add nsw i32 %176, 1
store i32 %177, i32* %9
br label %149
178: ; preds = %149
%179 = load i32, i32* %7
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %180
%182 = load i32, i32* %8
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds [4 x i32], [4 x i32]* %181, i64 0, i64 %183
%185 = load i32, i32* %184
store i32 %185, i32* %6
%186 = load i32, i32* %7
%187 = add nsw i32 %186, 1
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %188
%190 = load i32, i32* %8
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds [4 x i32], [4 x i32]* %189, i64 0, i64 %191
%193 = load i32, i32* %192
%194 = load i32, i32* %7
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %195
%197 = load i32, i32* %8
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds [4 x i32], [4 x i32]* %196, i64 0, i64 %198
store i32 %193, i32* %199
%200 = load i32, i32* %6
%201 = load i32, i32* %7
%202 = add nsw i32 %201, 1
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %203
%205 = load i32, i32* %8
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds [4 x i32], [4 x i32]* %204, i64 0, i64 %206
store i32 %200, i32* %207
%208 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 0
%209 = bitcast [4 x i32]* %208 to i32**
%210 = call i32 @parse(i32** %209)
store i32 %210, i32* %4
%211 = load i32, i32* %4
%212 = call i64 @find(i32 %211)
%213 = icmp eq i64 %212, 0
br i1 %213, label %214, label %218
214: ; preds = %178
%215 = load i32, i32* %4
%216 = call i32 @insert(i32 %215)
%217 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 0
br label %218
218: ; preds = %214, %178
br label %219
219: ; preds = %218, %144
%220 = load i32, i32* %8
%221 = add nsw i32 %220, 1
%222 = icmp slt i32 %221, 3
br i1 %222, label %223, label %294
223: ; preds = %219
store i32 0, i32* %9
br label %224
224: ; preds = %250, %223
%225 = load i32, i32* %9
%226 = icmp slt i32 %225, 4
br i1 %226, label %227, label %253
227: ; preds = %224
store i32 0, i32* %10
br label %228
228: ; preds = %246, %227
%229 = load i32, i32* %10
%230 = icmp slt i32 %229, 4
br i1 %230, label %231, label %249
231: ; preds = %228
%232 = load [4 x i32]*, [4 x i32]** %2
%233 = load i32, i32* %9
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [4 x i32], [4 x i32]* %232, i64 %234
%236 = load i32, i32* %10
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds [4 x i32], [4 x i32]* %235, i64 0, i64 %237
%239 = load i32, i32* %238
%240 = load i32, i32* %9
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %241
%243 = load i32, i32* %10
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds [4 x i32], [4 x i32]* %242, i64 0, i64 %244
store i32 %239, i32* %245
br label %246
246: ; preds = %231
%247 = load i32, i32* %10
%248 = add nsw i32 %247, 1
store i32 %248, i32* %10
br label %228
249: ; preds = %228
br label %250
250: ; preds = %249
%251 = load i32, i32* %9
%252 = add nsw i32 %251, 1
store i32 %252, i32* %9
br label %224
253: ; preds = %224
%254 = load i32, i32* %7
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %255
%257 = load i32, i32* %8
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds [4 x i32], [4 x i32]* %256, i64 0, i64 %258
%260 = load i32, i32* %259
store i32 %260, i32* %6
%261 = load i32, i32* %7
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %262
%264 = load i32, i32* %8
%265 = add nsw i32 %264, 1
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds [4 x i32], [4 x i32]* %263, i64 0, i64 %266
%268 = load i32, i32* %267
%269 = load i32, i32* %7
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %270
%272 = load i32, i32* %8
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds [4 x i32], [4 x i32]* %271, i64 0, i64 %273
store i32 %268, i32* %274
%275 = load i32, i32* %6
%276 = load i32, i32* %7
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %277
%279 = load i32, i32* %8
%280 = add nsw i32 %279, 1
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds [4 x i32], [4 x i32]* %278, i64 0, i64 %281
store i32 %275, i32* %282
%283 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 0
%284 = bitcast [4 x i32]* %283 to i32**
%285 = call i32 @parse(i32** %284)
store i32 %285, i32* %4
%286 = load i32, i32* %4
%287 = call i64 @find(i32 %286)
%288 = icmp eq i64 %287, 0
br i1 %288, label %289, label %293
289: ; preds = %253
%290 = load i32, i32* %4
%291 = call i32 @insert(i32 %290)
%292 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 0
br label %293
293: ; preds = %289, %253
br label %294
294: ; preds = %293, %219
%295 = load i32, i32* %8
%296 = sub nsw i32 %295, 1
%297 = icmp sge i32 %296, 0
br i1 %297, label %298, label %369
298: ; preds = %294
store i32 0, i32* %9
br label %299
299: ; preds = %325, %298
%300 = load i32, i32* %9
%301 = icmp slt i32 %300, 4
br i1 %301, label %302, label %328
302: ; preds = %299
store i32 0, i32* %10
br label %303
303: ; preds = %321, %302
%304 = load i32, i32* %10
%305 = icmp slt i32 %304, 4
br i1 %305, label %306, label %324
306: ; preds = %303
%307 = load [4 x i32]*, [4 x i32]** %2
%308 = load i32, i32* %9
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds [4 x i32], [4 x i32]* %307, i64 %309
%311 = load i32, i32* %10
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds [4 x i32], [4 x i32]* %310, i64 0, i64 %312
%314 = load i32, i32* %313
%315 = load i32, i32* %9
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %316
%318 = load i32, i32* %10
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds [4 x i32], [4 x i32]* %317, i64 0, i64 %319
store i32 %314, i32* %320
br label %321
321: ; preds = %306
%322 = load i32, i32* %10
%323 = add nsw i32 %322, 1
store i32 %323, i32* %10
br label %303
324: ; preds = %303
br label %325
325: ; preds = %324
%326 = load i32, i32* %9
%327 = add nsw i32 %326, 1
store i32 %327, i32* %9
br label %299
328: ; preds = %299
%329 = load i32, i32* %7
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %330
%332 = load i32, i32* %8
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds [4 x i32], [4 x i32]* %331, i64 0, i64 %333
%335 = load i32, i32* %334
store i32 %335, i32* %6
%336 = load i32, i32* %7
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %337
%339 = load i32, i32* %8
%340 = sub nsw i32 %339, 1
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds [4 x i32], [4 x i32]* %338, i64 0, i64 %341
%343 = load i32, i32* %342
%344 = load i32, i32* %7
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %345
%347 = load i32, i32* %8
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds [4 x i32], [4 x i32]* %346, i64 0, i64 %348
store i32 %343, i32* %349
%350 = load i32, i32* %6
%351 = load i32, i32* %7
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 %352
%354 = load i32, i32* %8
%355 = sub nsw i32 %354, 1
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds [4 x i32], [4 x i32]* %353, i64 0, i64 %356
store i32 %350, i32* %357
%358 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 0
%359 = bitcast [4 x i32]* %358 to i32**
%360 = call i32 @parse(i32** %359)
store i32 %360, i32* %4
%361 = load i32, i32* %4
%362 = call i64 @find(i32 %361)
%363 = icmp eq i64 %362, 0
br i1 %363, label %364, label %368
364: ; preds = %328
%365 = load i32, i32* %4
%366 = call i32 @insert(i32 %365)
%367 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 0
br label %368
368: ; preds = %364, %328
br label %369
369: ; preds = %368, %294
store i32 1, i32* %3
br label %370
370: ; preds = %369, %66, %57
br label %371
371: ; preds = %370
%372 = load i32, i32* %8
%373 = add nsw i32 %372, 1
store i32 %373, i32* %8
br label %54
374: ; preds = %54
br label %375
375: ; preds = %374
%376 = load i32, i32* %7
%377 = add nsw i32 %376, 1
store i32 %377, i32* %7
br label %45
378: ; preds = %51
ret void
}

LLVM IR (-O2):
@.str = [4 x i8] c"%d\0A\00"
define void @funct([4 x i32]* nocapture %0) {
%2 = bitcast [4 x i32]* %0 to i8*
%3 = alloca [4 x [4 x i32]]
%4 = bitcast [4 x [4 x i32]]* %3 to i8*
%5 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %3, i64 0, i64 0
%6 = bitcast [4 x [4 x i32]]* %3 to i32**
%7 = call i32 @parse(i32** %6)
%8 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %7)
br label %9
9: ; preds = %1, %77
%10 = phi i64 [ 0, %1 ], [ %17, %77 ]
%11 = phi i32 [ 0, %1 ], [ %75, %77 ]
%12 = call i64 @find(i32 123456789)
%13 = icmp eq i64 %12, 0
br i1 %13, label %14, label %79
14: ; preds = %9
%15 = add nsw i64 %10, -1
%16 = icmp eq i64 %10, 0
%17 = add nuw nsw i64 %10, 1
%18 = icmp ult i64 %10, 2
br label %19
19: ; preds = %14, %73
%20 = phi i64 [ 0, %14 ], [ %74, %73 ]
%21 = phi i32 [ %11, %14 ], [ %75, %73 ]
%22 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %3, i64 0, i64 %10, i64 %20
%23 = load i32, i32* %22
%24 = icmp eq i32 %23, 9
%25 = icmp eq i32 %21, 0
%26 = select i1 %24, i1 %25, i1 false
br i1 %26, label %29, label %27
27: ; preds = %19
%28 = add nuw nsw i64 %20, 1
br label %73
29: ; preds = %19
br i1 %16, label %39, label %30
30: ; preds = %29
%31 = load i32, i32* %22
%32 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %3, i64 0, i64 %15, i64 %20
%33 = load i32, i32* %32
store i32 %33, i32* %22
store i32 %31, i32* %32
%34 = call i32 @parse(i32** %6)
%35 = call i64 @find(i32 %34)
%36 = icmp eq i64 %35, 0
br i1 %36, label %37, label %39
37: ; preds = %30
%38 = call i32 @insert(i32 %34)
br label %39
39: ; preds = %30, %37, %29
br i1 %18, label %40, label %49
40: ; preds = %39
%41 = load i32, i32* %22
%42 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %3, i64 0, i64 %17, i64 %20
%43 = load i32, i32* %42
store i32 %43, i32* %22
store i32 %41, i32* %42
%44 = call i32 @parse(i32** %6)
%45 = call i64 @find(i32 %44)
%46 = icmp eq i64 %45, 0
br i1 %46, label %47, label %49
47: ; preds = %40
%48 = call i32 @insert(i32 %44)
br label %49
49: ; preds = %40, %47, %39
%50 = add nuw nsw i64 %20, 1
%51 = icmp ult i64 %20, 2
br i1 %51, label %52, label %63
52: ; preds = %49
%53 = load i32, i32* %22
%54 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %3, i64 0, i64 %10, i64 %50
%55 = load i32, i32* %54
store i32 %55, i32* %22
store i32 %53, i32* %54
%56 = call i32 @parse(i32** %6)
%57 = call i64 @find(i32 %56)
%58 = icmp eq i64 %57, 0
br i1 %58, label %59, label %61
59: ; preds = %52
%60 = call i32 @insert(i32 %56)
br label %61
61: ; preds = %52, %59
%62 = icmp eq i64 %20, 0
br i1 %62, label %73, label %63
63: ; preds = %49, %61
%64 = add nsw i64 %20, -1
%65 = load i32, i32* %22
%66 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %3, i64 0, i64 %10, i64 %64
%67 = load i32, i32* %66
store i32 %67, i32* %22
store i32 %65, i32* %66
%68 = call i32 @parse(i32** %6)
%69 = call i64 @find(i32 %68)
%70 = icmp eq i64 %69, 0
br i1 %70, label %71, label %73
71: ; preds = %63
%72 = call i32 @insert(i32 %68)
br label %73
73: ; preds = %27, %61, %71, %63
%74 = phi i64 [ %28, %27 ], [ 1, %61 ], [ %50, %71 ], [ %50, %63 ]
%75 = phi i32 [ %21, %27 ], [ 1, %61 ], [ 1, %71 ], [ 1, %63 ]
%76 = icmp eq i64 %74, 3
br i1 %76, label %77, label %19
77: ; preds = %73
%78 = icmp eq i64 %17, 3
br i1 %78, label %79, label %9
79: ; preds = %77, %9
ret void
}