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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int maxflow_with_scratch(void *scratch, int nv, int source, int sink, int ne,
                         const int *edges, const int *backedges,
                         const int *capacity, int *flow, int *cut) {
  int *todo = (int *)scratch;
  int *prev = todo + nv;
  int *firstedge = todo + 2 * nv;
  int *firstbackedge = todo + 3 * nv;
  int i, j, head, tail, from, to;
  int totalflow;
  j = 0;
  for (i = 0; i < ne; i++)
    while (j <= edges[2 * i])
      firstedge[j++] = i;
  while (j < nv)
    firstedge[j++] = ne;
  assert(j == nv);
  j = 0;
  for (i = 0; i < ne; i++)
    while (j <= edges[2 * backedges[i] + 1])
      firstbackedge[j++] = i;
  while (j < nv)
    firstbackedge[j++] = ne;
  assert(j == nv);
  for (i = 0; i < ne; i++)
    flow[i] = 0;
  totalflow = 0;
  while (1) {
    for (i = 0; i < nv; i++)
      prev[i] = -1;
    head = tail = 0;
    todo[tail++] = source;
    while (head < tail && prev[sink] <= 0) {
      from = todo[head++];
      for (i = firstedge[from]; i < ne && edges[2 * i] == from; i++) {
        to = edges[2 * i + 1];
        if (to == source || prev[to] >= 0)
          continue;
        if (capacity[i] >= 0 && flow[i] >= capacity[i])
          continue;
        prev[to] = 2 * i;
        todo[tail++] = to;
      }
      for (i = firstbackedge[from];
           j = backedges[i], i < ne && edges[2 * j + 1] == from; i++) {
        to = edges[2 * j];
        if (to == source || prev[to] >= 0)
          continue;
        if (flow[j] <= 0)
          continue;
        prev[to] = 2 * j + 1;
        todo[tail++] = to;
      }
    }
    if (prev[sink] >= 0) {
      int max;
      to = sink;
      max = -1;
      while (to != source) {
        int spare;
        i = prev[to];
        from = edges[i];
        assert(from != to);
        if (i & 1)
          spare = flow[i / 2];
        else if (capacity[i / 2] >= 0)
          spare = capacity[i / 2] - flow[i / 2];
        else
          spare = -1;
        assert(spare != 0);
        if (max < 0 || (spare >= 0 && spare < max))
          max = spare;
        to = from;
      }
      assert(max > 0);
      to = sink;
      while (to != source) {
        i = prev[to];
        from = edges[i];
        assert(from != to);
        if (i & 1)
          flow[i / 2] -= max;
        else
          flow[i / 2] += max;
        to = from;
      }
      totalflow += max;
      continue;
    }
    if (cut) {
      for (i = 0; i < nv; i++) {
        if (i == source || prev[i] >= 0)
          cut[i] = 0;
        else
          cut[i] = 1;
      }
    }
    return totalflow;
  }
}


x86 assembly (clang, -O0):
<maxflow_with_scratch>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11f1 <maxflow_with_scratch+0xe1>
jmp    11a8 <maxflow_with_scratch+0x98>
mov    -0x48(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     11de <maxflow_with_scratch+0xce>
mov    -0x44(%rbp),%edx
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x48(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11a8 <maxflow_with_scratch+0x98>
jmp    11e3 <maxflow_with_scratch+0xd3>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1197 <maxflow_with_scratch+0x87>
jmp    11f6 <maxflow_with_scratch+0xe6>
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    121f <maxflow_with_scratch+0x10f>
mov    -0x18(%rbp),%edx
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x48(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11f6 <maxflow_with_scratch+0xe6>
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12a5 <maxflow_with_scratch+0x195>
jmp    1251 <maxflow_with_scratch+0x141>
mov    -0x48(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    0x10(%rbp),%rdx
movslq -0x44(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1292 <maxflow_with_scratch+0x182>
mov    -0x44(%rbp),%edx
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x48(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1251 <maxflow_with_scratch+0x141>
jmp    1297 <maxflow_with_scratch+0x187>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1240 <maxflow_with_scratch+0x130>
jmp    12aa <maxflow_with_scratch+0x19a>
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12d3 <maxflow_with_scratch+0x1c3>
mov    -0x18(%rbp),%edx
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x48(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12aa <maxflow_with_scratch+0x19a>
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1316 <maxflow_with_scratch+0x206>
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12ed <maxflow_with_scratch+0x1dd>
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    134d <maxflow_with_scratch+0x23d>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1324 <maxflow_with_scratch+0x214>
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x10(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x50(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x50(%rbp),%ecx
mov    %al,-0x65(%rbp)
jge    1396 <maxflow_with_scratch+0x286>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
setle  %al
mov    %al,-0x65(%rbp)
mov    -0x65(%rbp),%al
test   $0x1,%al
jne    13a6 <maxflow_with_scratch+0x296>
jmp    158e <maxflow_with_scratch+0x47e>
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%ecx
mov    %al,-0x66(%rbp)
jge    13f6 <maxflow_with_scratch+0x2e6>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
sete   %al
mov    %al,-0x66(%rbp)
mov    -0x66(%rbp),%al
test   $0x1,%al
jne    1406 <maxflow_with_scratch+0x2f6>
jmp    14a9 <maxflow_with_scratch+0x399>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     143a <maxflow_with_scratch+0x32a>
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     143f <maxflow_with_scratch+0x32f>
jmp    149b <maxflow_with_scratch+0x38b>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     1472 <maxflow_with_scratch+0x362>
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x18(%rbp),%rcx
movslq -0x44(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     1472 <maxflow_with_scratch+0x362>
jmp    149b <maxflow_with_scratch+0x38b>
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x50(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13cc <maxflow_with_scratch+0x2bc>
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%ecx
mov    %al,-0x67(%rbp)
jge    14f2 <maxflow_with_scratch+0x3e2>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
sete   %al
mov    %al,-0x67(%rbp)
mov    -0x67(%rbp),%al
test   $0x1,%al
jne    1502 <maxflow_with_scratch+0x3f2>
jmp    1589 <maxflow_with_scratch+0x479>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     1533 <maxflow_with_scratch+0x423>
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     1538 <maxflow_with_scratch+0x428>
jmp    157b <maxflow_with_scratch+0x46b>
mov    0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jg     154f <maxflow_with_scratch+0x43f>
jmp    157b <maxflow_with_scratch+0x46b>
mov    -0x48(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x50(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    14b7 <maxflow_with_scratch+0x3a7>
jmp    1373 <maxflow_with_scratch+0x263>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     17bf <maxflow_with_scratch+0x6af>
mov    -0x14(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0xffffffff,-0x60(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     16dc <maxflow_with_scratch+0x5cc>
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x58(%rbp),%eax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x44(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     161e <maxflow_with_scratch+0x50e>
mov    0x20(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
jmp    169a <maxflow_with_scratch+0x58a>
mov    0x18(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x78(%rbp),%rax
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     168e <maxflow_with_scratch+0x57e>
mov    0x18(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x88(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    0x20(%rbp),%rcx
mov    -0x44(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x7c(%rbp),%eax
movslq %edx,%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x64(%rbp)
jmp    1695 <maxflow_with_scratch+0x585>
movl   $0xffffffff,-0x64(%rbp)
jmp    169a <maxflow_with_scratch+0x58a>
cmpl   $0x0,-0x64(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0x60(%rbp)
jl     16cb <maxflow_with_scratch+0x5bb>
cmpl   $0x0,-0x64(%rbp)
jl     16d1 <maxflow_with_scratch+0x5c1>
mov    -0x64(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    16d1 <maxflow_with_scratch+0x5c1>
mov    -0x64(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    15ad <maxflow_with_scratch+0x49d>
cmpl   $0x0,-0x60(%rbp)
setg   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x14(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     17b1 <maxflow_with_scratch+0x6a1>
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x58(%rbp),%eax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x44(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     176f <maxflow_with_scratch+0x65f>
mov    -0x60(%rbp),%esi
mov    0x20(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x90(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,4)
jmp    17a6 <maxflow_with_scratch+0x696>
mov    -0x60(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x9c(%rbp),%edx
mov    %eax,%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    16f3 <maxflow_with_scratch+0x5e3>
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
jmp    131d <maxflow_with_scratch+0x20d>
cmpq   $0x0,0x28(%rbp)
je     1836 <maxflow_with_scratch+0x726>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1831 <maxflow_with_scratch+0x721>
mov    -0x44(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     17fb <maxflow_with_scratch+0x6eb>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     180f <maxflow_with_scratch+0x6ff>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    181e <maxflow_with_scratch+0x70e>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    1823 <maxflow_with_scratch+0x713>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    17d1 <maxflow_with_scratch+0x6c1>
jmp    1836 <maxflow_with_scratch+0x726>
mov    -0x5c(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<maxflow_with_scratch>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,%r14
mov    %r8d,%r12d
mov    %ecx,0x24(%rsp)
lea    (%rsi,%rsi,1),%eax
movslq %eax,%r9
mov    %rdi,0x8(%rsp)
lea    (%rdi,%r9,4),%r10
lea    (%rsi,%rsi,2),%r8d
mov    %r12d,%r13d
test   %r12d,%r12d
jle    1197 <maxflow_with_scratch+0x77>
xor    %ecx,%ecx
xor    %ebx,%ebx
jmp    1169 <maxflow_with_scratch+0x49>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    %r13,%rcx
je     1199 <maxflow_with_scratch+0x79>
cmp    (%r14,%rcx,8),%ebx
jg     1160 <maxflow_with_scratch+0x40>
lea    (%rcx,%rcx,1),%rax
movslq %ebx,%rdi
add    $0xffffffffffffffff,%rdi
nopw   0x0(%rax,%rax,1)
mov    %ecx,0x4(%r10,%rdi,4)
movslq (%r14,%rax,4),%rbp
add    $0x1,%rdi
add    $0x1,%ebx
cmp    %rbp,%rdi
jl     1180 <maxflow_with_scratch+0x60>
jmp    1160 <maxflow_with_scratch+0x40>
xor    %ebx,%ebx
mov    %edx,0x14(%rsp)
movslq %esi,%rdx
movslq %r8d,%r15
cmp    %esi,%ebx
jge    129f <maxflow_with_scratch+0x17f>
movslq %ebx,%rcx
mov    %rdx,%r11
sub    %rcx,%r11
cmp    $0x8,%r11
jb     1290 <maxflow_with_scratch+0x170>
mov    %r11,%r8
and    $0xfffffffffffffff8,%r8
movd   %r12d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r8),%rax
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0x18,%rax
jae    11ed <maxflow_with_scratch+0xcd>
xor    %eax,%eax
jmp    124a <maxflow_with_scratch+0x12a>
and    $0xfffffffffffffffc,%rdi
lea    0x0(,%r9,4),%rax
lea    (%rax,%rcx,4),%rax
mov    0x8(%rsp),%rbp
add    %rax,%rbp
add    $0x70,%rbp
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x70(%rbp,%rax,4)
movdqu %xmm0,-0x60(%rbp,%rax,4)
movdqu %xmm0,-0x50(%rbp,%rax,4)
movdqu %xmm0,-0x40(%rbp,%rax,4)
movdqu %xmm0,-0x30(%rbp,%rax,4)
movdqu %xmm0,-0x20(%rbp,%rax,4)
movdqu %xmm0,-0x10(%rbp,%rax,4)
movdqu %xmm0,0x0(%rbp,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rdi
jne    1210 <maxflow_with_scratch+0xf0>
test   %rbx,%rbx
je     1284 <maxflow_with_scratch+0x164>
add    %rcx,%rax
shl    $0x2,%r9
lea    (%r9,%rax,4),%rax
mov    0x8(%rsp),%rdi
add    %rdi,%rax
add    $0x10,%rax
shl    $0x5,%rbx
xor    %edi,%edi
nopl   0x0(%rax)
movdqu %xmm0,-0x10(%rax,%rdi,1)
movdqu %xmm0,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rbx
jne    1270 <maxflow_with_scratch+0x150>
mov    %esi,%ebx
cmp    %r8,%r11
je     129f <maxflow_with_scratch+0x17f>
add    %r8,%rcx
xchg   %ax,%ax
mov    %r12d,(%r10,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1290 <maxflow_with_scratch+0x170>
mov    %esi,%ebx
mov    %rdx,0x38(%rsp)
mov    %r10,0x60(%rsp)
mov    0x8(%rsp),%rax
lea    (%rax,%r15,4),%rax
mov    %rax,0x40(%rsp)
xor    %edi,%edi
mov    %rsi,0x18(%rsp)
cmp    %esi,%ebx
sete   %dil
call   1040 <assert@plt>
test   %r12d,%r12d
jle    132b <maxflow_with_scratch+0x20b>
xor    %eax,%eax
xor    %esi,%esi
mov    0x18(%rsp),%r9
mov    0x38(%rsp),%r10
mov    0xa0(%rsp),%rdi
mov    0x40(%rsp),%rbx
jmp    12f9 <maxflow_with_scratch+0x1d9>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r13,%rax
je     133c <maxflow_with_scratch+0x21c>
movslq (%rdi,%rax,4),%rcx
cmp    0x4(%r14,%rcx,8),%esi
jg     12f0 <maxflow_with_scratch+0x1d0>
movslq %esi,%rcx
add    $0xffffffffffffffff,%rcx
nopl   0x0(%rax,%rax,1)
mov    %eax,0x4(%rbx,%rcx,4)
movslq (%rdi,%rax,4),%rdx
movslq 0x4(%r14,%rdx,8),%rdx
add    $0x1,%rcx
add    $0x1,%esi
cmp    %rdx,%rcx
jl     1310 <maxflow_with_scratch+0x1f0>
jmp    12f0 <maxflow_with_scratch+0x1d0>
xor    %esi,%esi
mov    0x18(%rsp),%r9
mov    0x38(%rsp),%r10
mov    0x40(%rsp),%rbx
cmp    %r9d,%esi
jge    135a <maxflow_with_scratch+0x23a>
movslq %esi,%rax
mov    %r10,%rcx
sub    %rax,%rcx
cmp    $0x8,%rcx
jae    1364 <maxflow_with_scratch+0x244>
mov    0x14(%rsp),%r15d
jmp    1450 <maxflow_with_scratch+0x330>
mov    0x14(%rsp),%r15d
jmp    1460 <maxflow_with_scratch+0x340>
mov    %rcx,%r8
and    $0xfffffffffffffff8,%r8
movd   %r12d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r8),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rdx
jae    1393 <maxflow_with_scratch+0x273>
xor    %edx,%edx
jmp    13fa <maxflow_with_scratch+0x2da>
and    $0xfffffffffffffffc,%rdi
lea    0x0(,%r15,4),%rdx
lea    (%rdx,%rax,4),%rdx
mov    0x8(%rsp),%rbp
add    %rdx,%rbp
add    $0x70,%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x70(%rbp,%rdx,4)
movdqu %xmm0,-0x60(%rbp,%rdx,4)
movdqu %xmm0,-0x50(%rbp,%rdx,4)
movdqu %xmm0,-0x40(%rbp,%rdx,4)
movdqu %xmm0,-0x30(%rbp,%rdx,4)
movdqu %xmm0,-0x20(%rbp,%rdx,4)
movdqu %xmm0,-0x10(%rbp,%rdx,4)
movdqu %xmm0,0x0(%rbp,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rdi
jne    13c0 <maxflow_with_scratch+0x2a0>
test   %rsi,%rsi
je     1434 <maxflow_with_scratch+0x314>
add    %rax,%rdx
shl    $0x2,%r15
lea    (%r15,%rdx,4),%rdx
mov    0x8(%rsp),%rdi
add    %rdi,%rdx
add    $0x10,%rdx
shl    $0x5,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movdqu %xmm0,-0x10(%rdx,%rdi,1)
movdqu %xmm0,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1420 <maxflow_with_scratch+0x300>
mov    %r9d,%esi
cmp    %r8,%rcx
mov    0x14(%rsp),%r15d
je     1460 <maxflow_with_scratch+0x340>
add    %r8,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12d,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r10
jne    1450 <maxflow_with_scratch+0x330>
mov    %r9d,%esi
mov    0xb0(%rsp),%rbx
xor    %edi,%edi
cmp    %r9d,%esi
sete   %dil
call   1040 <assert@plt>
test   %r12d,%r12d
jle    148c <maxflow_with_scratch+0x36c>
shl    $0x2,%r13
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1030 <memset@plt>
mov    0x38(%rsp),%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,4),%r13
movslq 0x24(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x18(%rsp),%rax
mov    %eax,%ecx
mov    %rcx,0x48(%rsp)
lea    0x0(,%rcx,4),%rcx
mov    %rcx,0x58(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x28(%rsp)
mov    %rbx,%r8
mov    %r12d,0x34(%rsp)
jmp    14f5 <maxflow_with_scratch+0x3d5>
xchg   %ax,%ax
xor    %edi,%edi
call   1040 <assert@plt>
mov    $0xffffffff,%edx
mov    0x18(%rsp),%rax
mov    0x28(%rsp),%rcx
mov    0xb0(%rsp),%r8
add    %edx,%ecx
mov    %rcx,0x28(%rsp)
test   %eax,%eax
jle    1513 <maxflow_with_scratch+0x3f3>
mov    %r13,%rdi
mov    $0xff,%esi
mov    0x58(%rsp),%rdx
call   1030 <memset@plt>
mov    0xb0(%rsp),%r8
mov    0x8(%rsp),%rax
mov    %r15d,(%rax)
mov    $0x1,%r11d
xor    %r9d,%r9d
jmp    1544 <maxflow_with_scratch+0x424>
cs nopw 0x0(%rax,%rax,1)
mov    0xb0(%rsp),%r8
movslq %r11d,%rax
cmp    %rax,%r9
jge    1680 <maxflow_with_scratch+0x560>
mov    0x50(%rsp),%rax
mov    0x0(%r13,%rax,4),%ecx
test   %ecx,%ecx
jg     1692 <maxflow_with_scratch+0x572>
mov    0x8(%rsp),%rax
movslq (%rax,%r9,4),%rdx
mov    0x60(%rsp),%rax
movslq (%rax,%rdx,4),%rax
cmp    %r12d,%eax
jge    15e0 <maxflow_with_scratch+0x4c0>
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rax,4),%r10
lea    (%r8,%rax,4),%r8
mov    %r12d,%edi
sub    %eax,%edi
lea    (%rax,%rax,1),%ecx
xor    %esi,%esi
jmp    15ab <maxflow_with_scratch+0x48b>
mov    %ecx,0x0(%r13,%rax,4)
movslq %r11d,%rax
add    $0x1,%r11d
mov    0x8(%rsp),%rbx
mov    %ebp,(%rbx,%rax,4)
nopl   (%rax)
add    $0x2,%ecx
add    $0x1,%rsi
cmp    %esi,%edi
je     15e0 <maxflow_with_scratch+0x4c0>
movslq %ecx,%rax
cmp    %edx,(%r14,%rax,4)
jne    15e0 <maxflow_with_scratch+0x4c0>
lea    0x1(%rcx),%eax
cltq
mov    (%r14,%rax,4),%ebp
cmp    %r15d,%ebp
je     15a0 <maxflow_with_scratch+0x480>
movslq %ebp,%rax
cmpl   $0x0,0x0(%r13,%rax,4)
jns    15a0 <maxflow_with_scratch+0x480>
mov    (%r10,%rsi,4),%ebx
test   %ebx,%ebx
js     1589 <maxflow_with_scratch+0x469>
cmp    %ebx,(%r8,%rsi,4)
jl     1589 <maxflow_with_scratch+0x469>
jmp    15a0 <maxflow_with_scratch+0x480>
nopl   (%rax)
add    $0x1,%r9
mov    0x40(%rsp),%rax
movslq (%rax,%rdx,4),%rax
cmp    %r12d,%eax
jge    1530 <maxflow_with_scratch+0x410>
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
mov    %r12d,%esi
sub    %eax,%esi
xor    %edi,%edi
mov    0xb0(%rsp),%r8
jmp    162c <maxflow_with_scratch+0x50c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdi
cmp    %edi,%esi
je     1538 <maxflow_with_scratch+0x418>
movslq (%rcx,%rdi,4),%rbp
mov    %rbp,%rax
add    %rbp,%rax
cmp    %edx,0x4(%r14,%rax,4)
jne    1538 <maxflow_with_scratch+0x418>
cltq
mov    (%r14,%rax,4),%eax
cmp    %r15d,%eax
je     1620 <maxflow_with_scratch+0x500>
movslq %eax,%rbx
cmpl   $0x0,0x0(%r13,%rbx,4)
jns    1620 <maxflow_with_scratch+0x500>
cmpl   $0x0,(%r8,%rbp,4)
jle    1620 <maxflow_with_scratch+0x500>
add    %rbp,%rbp
add    $0x1,%rbp
mov    %ebp,0x0(%r13,%rbx,4)
movslq %r11d,%rbp
add    $0x1,%r11d
mov    0x8(%rsp),%rbx
mov    %eax,(%rbx,%rbp,4)
jmp    1620 <maxflow_with_scratch+0x500>
nopl   0x0(%rax,%rax,1)
mov    0x50(%rsp),%rax
mov    0x0(%r13,%rax,4),%ecx
test   %ecx,%ecx
js     1802 <maxflow_with_scratch+0x6e2>
mov    0x24(%rsp),%eax
cmp    %r15d,%eax
je     14d0 <maxflow_with_scratch+0x3b0>
mov    $0xffffffff,%ebp
mov    %eax,%r12d
nopw   0x0(%rax,%rax,1)
mov    %r12d,%eax
movslq %ecx,%rbx
mov    (%r14,%rbx,4),%r12d
xor    %edi,%edi
cmp    %eax,%r12d
setne  %dil
call   1040 <assert@plt>
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
cltq
test   $0x1,%bl
jne    1700 <maxflow_with_scratch+0x5e0>
mov    0xa8(%rsp),%rcx
mov    (%rcx,%rax,4),%r15d
test   %r15d,%r15d
js     170e <maxflow_with_scratch+0x5ee>
mov    0xb0(%rsp),%rcx
sub    (%rcx,%rax,4),%r15d
jmp    1720 <maxflow_with_scratch+0x600>
nopw   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%rcx
mov    (%rcx,%rax,4),%r15d
jmp    1720 <maxflow_with_scratch+0x600>
mov    $0xffffffff,%r15d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %edi,%edi
test   %r15d,%r15d
setne  %dil
call   1040 <assert@plt>
test   %ebp,%ebp
js     173c <maxflow_with_scratch+0x61c>
test   %r15d,%r15d
js     173f <maxflow_with_scratch+0x61f>
cmp    %ebp,%r15d
jge    173f <maxflow_with_scratch+0x61f>
mov    %r15d,%ebp
mov    0x14(%rsp),%r15d
cmp    %r15d,%r12d
je     1760 <maxflow_with_scratch+0x640>
movslq %r12d,%rax
mov    0x0(%r13,%rax,4),%ecx
jmp    16b0 <maxflow_with_scratch+0x590>
cs nopw 0x0(%rax,%rax,1)
xor    %edi,%edi
test   %ebp,%ebp
setg   %dil
call   1040 <assert@plt>
mov    %ebp,0x10(%rsp)
mov    0x24(%rsp),%ebp
cmp    %r15d,%ebp
jne    1790 <maxflow_with_scratch+0x670>
mov    0x18(%rsp),%rax
jmp    17e7 <maxflow_with_scratch+0x6c7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r15d,%r12d
mov    0x10(%rsp),%r15d
neg    %r15d
nopl   0x0(%rax,%rax,1)
movslq %ebp,%rax
movslq 0x0(%r13,%rax,4),%rbx
mov    (%r14,%rbx,4),%ebp
xor    %edi,%edi
cmp    %eax,%ebp
setne  %dil
call   1040 <assert@plt>
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
test   $0x1,%bl
cltq
mov    %r15d,%ecx
cmove  0x10(%rsp),%ecx
mov    0xb0(%rsp),%rdx
add    %ecx,(%rdx,%rax,4)
cmp    %r12d,%ebp
jne    17a0 <maxflow_with_scratch+0x680>
mov    0x18(%rsp),%rax
mov    %r12d,%r15d
mov    0x34(%rsp),%r12d
mov    0x28(%rsp),%rcx
mov    0xb0(%rsp),%r8
mov    0x10(%rsp),%edx
jmp    14ee <maxflow_with_scratch+0x3ce>
mov    0xb8(%rsp),%rbx
test   %rbx,%rbx
mov    0x18(%rsp),%rcx
je     18b3 <maxflow_with_scratch+0x793>
test   %ecx,%ecx
jle    18b3 <maxflow_with_scratch+0x793>
mov    %r15d,%eax
cmp    $0x1,%ecx
jne    1837 <maxflow_with_scratch+0x717>
xor    %ecx,%ecx
mov    0x48(%rsp),%r8
test   $0x1,%r8b
jne    18a1 <maxflow_with_scratch+0x781>
jmp    18b3 <maxflow_with_scratch+0x793>
mov    0x48(%rsp),%r8
mov    %r8d,%edx
and    $0xfffffffe,%edx
mov    0x38(%rsp),%rcx
mov    0x8(%rsp),%rsi
lea    (%rsi,%rcx,4),%rsi
add    $0x4,%rsi
xor    %edi,%edi
jmp    186d <maxflow_with_scratch+0x74d>
nopl   0x0(%rax,%rax,1)
mov    %ebp,0x4(%rbx,%rcx,4)
add    $0x1,%rdi
cmp    %rdx,%rdi
je     1897 <maxflow_with_scratch+0x777>
mov    %rdi,%rcx
mov    $0x0,%edi
cmp    %rcx,%rax
je     1881 <maxflow_with_scratch+0x761>
mov    -0x4(%rsi,%rcx,4),%edi
shr    $0x1f,%edi
mov    %edi,(%rbx,%rcx,4)
lea    0x1(%rcx),%rdi
xor    %ebp,%ebp
cmp    %rax,%rdi
je     1860 <maxflow_with_scratch+0x740>
mov    (%rsi,%rcx,4),%ebp
shr    $0x1f,%ebp
jmp    1860 <maxflow_with_scratch+0x740>
add    $0x2,%rcx
test   $0x1,%r8b
je     18b3 <maxflow_with_scratch+0x793>
xor    %edx,%edx
cmp    %rax,%rcx
je     18b0 <maxflow_with_scratch+0x790>
mov    0x0(%r13,%rcx,4),%edx
shr    $0x1f,%edx
mov    %edx,(%rbx,%rcx,4)
mov    0x28(%rsp),%rax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @maxflow_with_scratch(i8* %0, i32 %1, i32 %2, i32 %3, i32 %4, i32* %5, i32* %6, i32* %7, i32* %8, i32* %9) {
%11 = alloca i8*
%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
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
store i8* %0, i8** %11
store i32 %1, i32* %12
store i32 %2, i32* %13
store i32 %3, i32* %14
store i32 %4, i32* %15
store i32* %5, i32** %16
store i32* %6, i32** %17
store i32* %7, i32** %18
store i32* %8, i32** %19
store i32* %9, i32** %20
%34 = load i8*, i8** %11
%35 = bitcast i8* %34 to i32*
store i32* %35, i32** %21
%36 = load i32*, i32** %21
%37 = load i32, i32* %12
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i32, i32* %36, i64 %38
store i32* %39, i32** %22
%40 = load i32*, i32** %21
%41 = load i32, i32* %12
%42 = mul nsw i32 2, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i32, i32* %40, i64 %43
store i32* %44, i32** %23
%45 = load i32*, i32** %21
%46 = load i32, i32* %12
%47 = mul nsw i32 3, %46
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i32, i32* %45, i64 %48
store i32* %49, i32** %24
store i32 0, i32* %26
store i32 0, i32* %25
br label %50
50: ; preds = %72, %10
%51 = load i32, i32* %25
%52 = load i32, i32* %15
%53 = icmp slt i32 %51, %52
br i1 %53, label %54, label %75
54: ; preds = %50
br label %55
55: ; preds = %64, %54
%56 = load i32, i32* %26
%57 = load i32*, i32** %16
%58 = load i32, i32* %25
%59 = mul nsw i32 2, %58
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i32, i32* %57, i64 %60
%62 = load i32, i32* %61
%63 = icmp sle i32 %56, %62
br i1 %63, label %64, label %71
64: ; preds = %55
%65 = load i32, i32* %25
%66 = load i32*, i32** %23
%67 = load i32, i32* %26
%68 = add nsw i32 %67, 1
store i32 %68, i32* %26
%69 = sext i32 %67 to i64
%70 = getelementptr inbounds i32, i32* %66, i64 %69
store i32 %65, i32* %70
br label %55
71: ; preds = %55
br label %72
72: ; preds = %71
%73 = load i32, i32* %25
%74 = add nsw i32 %73, 1
store i32 %74, i32* %25
br label %50
75: ; preds = %50
br label %76
76: ; preds = %80, %75
%77 = load i32, i32* %26
%78 = load i32, i32* %12
%79 = icmp slt i32 %77, %78
br i1 %79, label %80, label %87
80: ; preds = %76
%81 = load i32, i32* %15
%82 = load i32*, i32** %23
%83 = load i32, i32* %26
%84 = add nsw i32 %83, 1
store i32 %84, i32* %26
%85 = sext i32 %83 to i64
%86 = getelementptr inbounds i32, i32* %82, i64 %85
store i32 %81, i32* %86
br label %76
87: ; preds = %76
%88 = load i32, i32* %26
%89 = load i32, i32* %12
%90 = icmp eq i32 %88, %89
%91 = zext i1 %90 to i32
%92 = call i32 @assert(i32 %91)
store i32 0, i32* %26
store i32 0, i32* %25
br label %93
93: ; preds = %120, %87
%94 = load i32, i32* %25
%95 = load i32, i32* %15
%96 = icmp slt i32 %94, %95
br i1 %96, label %97, label %123
97: ; preds = %93
br label %98
98: ; preds = %112, %97
%99 = load i32, i32* %26
%100 = load i32*, i32** %16
%101 = load i32*, i32** %17
%102 = load i32, i32* %25
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i32, i32* %101, i64 %103
%105 = load i32, i32* %104
%106 = mul nsw i32 2, %105
%107 = add nsw i32 %106, 1
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32, i32* %100, i64 %108
%110 = load i32, i32* %109
%111 = icmp sle i32 %99, %110
br i1 %111, label %112, label %119
112: ; preds = %98
%113 = load i32, i32* %25
%114 = load i32*, i32** %24
%115 = load i32, i32* %26
%116 = add nsw i32 %115, 1
store i32 %116, i32* %26
%117 = sext i32 %115 to i64
%118 = getelementptr inbounds i32, i32* %114, i64 %117
store i32 %113, i32* %118
br label %98
119: ; preds = %98
br label %120
120: ; preds = %119
%121 = load i32, i32* %25
%122 = add nsw i32 %121, 1
store i32 %122, i32* %25
br label %93
123: ; preds = %93
br label %124
124: ; preds = %128, %123
%125 = load i32, i32* %26
%126 = load i32, i32* %12
%127 = icmp slt i32 %125, %126
br i1 %127, label %128, label %135
128: ; preds = %124
%129 = load i32, i32* %15
%130 = load i32*, i32** %24
%131 = load i32, i32* %26
%132 = add nsw i32 %131, 1
store i32 %132, i32* %26
%133 = sext i32 %131 to i64
%134 = getelementptr inbounds i32, i32* %130, i64 %133
store i32 %129, i32* %134
br label %124
135: ; preds = %124
%136 = load i32, i32* %26
%137 = load i32, i32* %12
%138 = icmp eq i32 %136, %137
%139 = zext i1 %138 to i32
%140 = call i32 @assert(i32 %139)
store i32 0, i32* %25
br label %141
141: ; preds = %150, %135
%142 = load i32, i32* %25
%143 = load i32, i32* %15
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %153
145: ; preds = %141
%146 = load i32*, i32** %19
%147 = load i32, i32* %25
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i32, i32* %146, i64 %148
store i32 0, i32* %149
br label %150
150: ; preds = %145
%151 = load i32, i32* %25
%152 = add nsw i32 %151, 1
store i32 %152, i32* %25
br label %141
153: ; preds = %141
store i32 0, i32* %31
br label %154
154: ; preds = %153, %470
store i32 0, i32* %25
br label %155
155: ; preds = %164, %154
%156 = load i32, i32* %25
%157 = load i32, i32* %12
%158 = icmp slt i32 %156, %157
br i1 %158, label %159, label %167
159: ; preds = %155
%160 = load i32*, i32** %22
%161 = load i32, i32* %25
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i32, i32* %160, i64 %162
store i32 -1, i32* %163
br label %164
164: ; preds = %159
%165 = load i32, i32* %25
%166 = add nsw i32 %165, 1
store i32 %166, i32* %25
br label %155
167: ; preds = %155
store i32 0, i32* %28
store i32 0, i32* %27
%168 = load i32, i32* %13
%169 = load i32*, i32** %21
%170 = load i32, i32* %28
%171 = add nsw i32 %170, 1
store i32 %171, i32* %28
%172 = sext i32 %170 to i64
%173 = getelementptr inbounds i32, i32* %169, i64 %172
store i32 %168, i32* %173
br label %174
174: ; preds = %339, %167
%175 = load i32, i32* %27
%176 = load i32, i32* %28
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %185
178: ; preds = %174
%179 = load i32*, i32** %22
%180 = load i32, i32* %14
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i32, i32* %179, i64 %181
%183 = load i32, i32* %182
%184 = icmp sle i32 %183, 0
br label %185
185: ; preds = %178, %174
%186 = phi i1 [ false, %174 ], [ %184, %178 ]
br i1 %186, label %187, label %340
187: ; preds = %185
%188 = load i32*, i32** %21
%189 = load i32, i32* %27
%190 = add nsw i32 %189, 1
store i32 %190, i32* %27
%191 = sext i32 %189 to i64
%192 = getelementptr inbounds i32, i32* %188, i64 %191
%193 = load i32, i32* %192
store i32 %193, i32* %29
%194 = load i32*, i32** %23
%195 = load i32, i32* %29
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds i32, i32* %194, i64 %196
%198 = load i32, i32* %197
store i32 %198, i32* %25
br label %199
199: ; preds = %266, %187
%200 = load i32, i32* %25
%201 = load i32, i32* %15
%202 = icmp slt i32 %200, %201
br i1 %202, label %203, label %212
203: ; preds = %199
%204 = load i32*, i32** %16
%205 = load i32, i32* %25
%206 = mul nsw i32 2, %205
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i32, i32* %204, i64 %207
%209 = load i32, i32* %208
%210 = load i32, i32* %29
%211 = icmp eq i32 %209, %210
br label %212
212: ; preds = %203, %199
%213 = phi i1 [ false, %199 ], [ %211, %203 ]
br i1 %213, label %214, label %269
214: ; preds = %212
%215 = load i32*, i32** %16
%216 = load i32, i32* %25
%217 = mul nsw i32 2, %216
%218 = add nsw i32 %217, 1
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i32, i32* %215, i64 %219
%221 = load i32, i32* %220
store i32 %221, i32* %30
%222 = load i32, i32* %30
%223 = load i32, i32* %13
%224 = icmp eq i32 %222, %223
br i1 %224, label %232, label %225
225: ; preds = %214
%226 = load i32*, i32** %22
%227 = load i32, i32* %30
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i32, i32* %226, i64 %228
%230 = load i32, i32* %229
%231 = icmp sge i32 %230, 0
br i1 %231, label %232, label %233
232: ; preds = %225, %214
br label %266
233: ; preds = %225
%234 = load i32*, i32** %18
%235 = load i32, i32* %25
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds i32, i32* %234, i64 %236
%238 = load i32, i32* %237
%239 = icmp sge i32 %238, 0
br i1 %239, label %240, label %253
240: ; preds = %233
%241 = load i32*, i32** %19
%242 = load i32, i32* %25
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i32, i32* %241, i64 %243
%245 = load i32, i32* %244
%246 = load i32*, i32** %18
%247 = load i32, i32* %25
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds i32, i32* %246, i64 %248
%250 = load i32, i32* %249
%251 = icmp sge i32 %245, %250
br i1 %251, label %252, label %253
252: ; preds = %240
br label %266
253: ; preds = %240, %233
%254 = load i32, i32* %25
%255 = mul nsw i32 2, %254
%256 = load i32*, i32** %22
%257 = load i32, i32* %30
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i32, i32* %256, i64 %258
store i32 %255, i32* %259
%260 = load i32, i32* %30
%261 = load i32*, i32** %21
%262 = load i32, i32* %28
%263 = add nsw i32 %262, 1
store i32 %263, i32* %28
%264 = sext i32 %262 to i64
%265 = getelementptr inbounds i32, i32* %261, i64 %264
store i32 %260, i32* %265
br label %266
266: ; preds = %253, %252, %232
%267 = load i32, i32* %25
%268 = add nsw i32 %267, 1
store i32 %268, i32* %25
br label %199
269: ; preds = %212
%270 = load i32*, i32** %24
%271 = load i32, i32* %29
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds i32, i32* %270, i64 %272
%274 = load i32, i32* %273
store i32 %274, i32* %25
br label %275
275: ; preds = %336, %269
%276 = load i32*, i32** %17
%277 = load i32, i32* %25
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i32, i32* %276, i64 %278
%280 = load i32, i32* %279
store i32 %280, i32* %26
%281 = load i32, i32* %25
%282 = load i32, i32* %15
%283 = icmp slt i32 %281, %282
br i1 %283, label %284, label %294
284: ; preds = %275
%285 = load i32*, i32** %16
%286 = load i32, i32* %26
%287 = mul nsw i32 2, %286
%288 = add nsw i32 %287, 1
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i32, i32* %285, i64 %289
%291 = load i32, i32* %290
%292 = load i32, i32* %29
%293 = icmp eq i32 %291, %292
br label %294
294: ; preds = %284, %275
%295 = phi i1 [ false, %275 ], [ %293, %284 ]
br i1 %295, label %296, label %339
296: ; preds = %294
%297 = load i32*, i32** %16
%298 = load i32, i32* %26
%299 = mul nsw i32 2, %298
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds i32, i32* %297, i64 %300
%302 = load i32, i32* %301
store i32 %302, i32* %30
%303 = load i32, i32* %30
%304 = load i32, i32* %13
%305 = icmp eq i32 %303, %304
br i1 %305, label %313, label %306
306: ; preds = %296
%307 = load i32*, i32** %22
%308 = load i32, i32* %30
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds i32, i32* %307, i64 %309
%311 = load i32, i32* %310
%312 = icmp sge i32 %311, 0
br i1 %312, label %313, label %314
313: ; preds = %306, %296
br label %336
314: ; preds = %306
%315 = load i32*, i32** %19
%316 = load i32, i32* %26
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds i32, i32* %315, i64 %317
%319 = load i32, i32* %318
%320 = icmp sle i32 %319, 0
br i1 %320, label %321, label %322
321: ; preds = %314
br label %336
322: ; preds = %314
%323 = load i32, i32* %26
%324 = mul nsw i32 2, %323
%325 = add nsw i32 %324, 1
%326 = load i32*, i32** %22
%327 = load i32, i32* %30
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds i32, i32* %326, i64 %328
store i32 %325, i32* %329
%330 = load i32, i32* %30
%331 = load i32*, i32** %21
%332 = load i32, i32* %28
%333 = add nsw i32 %332, 1
store i32 %333, i32* %28
%334 = sext i32 %332 to i64
%335 = getelementptr inbounds i32, i32* %331, i64 %334
store i32 %330, i32* %335
br label %336
336: ; preds = %322, %321, %313
%337 = load i32, i32* %25
%338 = add nsw i32 %337, 1
store i32 %338, i32* %25
br label %275
339: ; preds = %294
br label %174
340: ; preds = %185
%341 = load i32*, i32** %22
%342 = load i32, i32* %14
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds i32, i32* %341, i64 %343
%345 = load i32, i32* %344
%346 = icmp sge i32 %345, 0
br i1 %346, label %347, label %474
347: ; preds = %340
%348 = load i32, i32* %14
store i32 %348, i32* %30
store i32 -1, i32* %32
br label %349
349: ; preds = %419, %347
%350 = load i32, i32* %30
%351 = load i32, i32* %13
%352 = icmp ne i32 %350, %351
br i1 %352, label %353, label %421
353: ; preds = %349
%354 = load i32*, i32** %22
%355 = load i32, i32* %30
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds i32, i32* %354, i64 %356
%358 = load i32, i32* %357
store i32 %358, i32* %25
%359 = load i32*, i32** %16
%360 = load i32, i32* %25
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds i32, i32* %359, i64 %361
%363 = load i32, i32* %362
store i32 %363, i32* %29
%364 = load i32, i32* %29
%365 = load i32, i32* %30
%366 = icmp ne i32 %364, %365
%367 = zext i1 %366 to i32
%368 = call i32 @assert(i32 %367)
%369 = load i32, i32* %25
%370 = and i32 %369, 1
%371 = icmp ne i32 %370, 0
br i1 %371, label %372, label %379
372: ; preds = %353
%373 = load i32*, i32** %19
%374 = load i32, i32* %25
%375 = sdiv i32 %374, 2
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds i32, i32* %373, i64 %376
%378 = load i32, i32* %377
store i32 %378, i32* %33
br label %403
379: ; preds = %353
%380 = load i32*, i32** %18
%381 = load i32, i32* %25
%382 = sdiv i32 %381, 2
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds i32, i32* %380, i64 %383
%385 = load i32, i32* %384
%386 = icmp sge i32 %385, 0
br i1 %386, label %387, label %401
387: ; preds = %379
%388 = load i32*, i32** %18
%389 = load i32, i32* %25
%390 = sdiv i32 %389, 2
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i32, i32* %388, i64 %391
%393 = load i32, i32* %392
%394 = load i32*, i32** %19
%395 = load i32, i32* %25
%396 = sdiv i32 %395, 2
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds i32, i32* %394, i64 %397
%399 = load i32, i32* %398
%400 = sub nsw i32 %393, %399
store i32 %400, i32* %33
br label %402
401: ; preds = %379
store i32 -1, i32* %33
br label %402
402: ; preds = %401, %387
br label %403
403: ; preds = %402, %372
%404 = load i32, i32* %33
%405 = icmp ne i32 %404, 0
%406 = zext i1 %405 to i32
%407 = call i32 @assert(i32 %406)
%408 = load i32, i32* %32
%409 = icmp slt i32 %408, 0
br i1 %409, label %417, label %410
410: ; preds = %403
%411 = load i32, i32* %33
%412 = icmp sge i32 %411, 0
br i1 %412, label %413, label %419
413: ; preds = %410
%414 = load i32, i32* %33
%415 = load i32, i32* %32
%416 = icmp slt i32 %414, %415
br i1 %416, label %417, label %419
417: ; preds = %413, %403
%418 = load i32, i32* %33
store i32 %418, i32* %32
br label %419
419: ; preds = %417, %413, %410
%420 = load i32, i32* %29
store i32 %420, i32* %30
br label %349
421: ; preds = %349
%422 = load i32, i32* %32
%423 = icmp sgt i32 %422, 0
%424 = zext i1 %423 to i32
%425 = call i32 @assert(i32 %424)
%426 = load i32, i32* %14
store i32 %426, i32* %30
br label %427
427: ; preds = %468, %421
%428 = load i32, i32* %30
%429 = load i32, i32* %13
%430 = icmp ne i32 %428, %429
br i1 %430, label %431, label %470
431: ; preds = %427
%432 = load i32*, i32** %22
%433 = load i32, i32* %30
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds i32, i32* %432, i64 %434
%436 = load i32, i32* %435
store i32 %436, i32* %25
%437 = load i32*, i32** %16
%438 = load i32, i32* %25
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds i32, i32* %437, i64 %439
%441 = load i32, i32* %440
store i32 %441, i32* %29
%442 = load i32, i32* %29
%443 = load i32, i32* %30
%444 = icmp ne i32 %442, %443
%445 = zext i1 %444 to i32
%446 = call i32 @assert(i32 %445)
%447 = load i32, i32* %25
%448 = and i32 %447, 1
%449 = icmp ne i32 %448, 0
br i1 %449, label %450, label %459
450: ; preds = %431
%451 = load i32, i32* %32
%452 = load i32*, i32** %19
%453 = load i32, i32* %25
%454 = sdiv i32 %453, 2
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds i32, i32* %452, i64 %455
%457 = load i32, i32* %456
%458 = sub nsw i32 %457, %451
store i32 %458, i32* %456
br label %468
459: ; preds = %431
%460 = load i32, i32* %32
%461 = load i32*, i32** %19
%462 = load i32, i32* %25
%463 = sdiv i32 %462, 2
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds i32, i32* %461, i64 %464
%466 = load i32, i32* %465
%467 = add nsw i32 %466, %460
store i32 %467, i32* %465
br label %468
468: ; preds = %459, %450
%469 = load i32, i32* %29
store i32 %469, i32* %30
br label %427
470: ; preds = %427
%471 = load i32, i32* %32
%472 = load i32, i32* %31
%473 = add nsw i32 %472, %471
store i32 %473, i32* %31
br label %154
474: ; preds = %340
%475 = load i32*, i32** %20
%476 = icmp ne i32* %475, null
br i1 %476, label %477, label %508
477: ; preds = %474
store i32 0, i32* %25
br label %478
478: ; preds = %504, %477
%479 = load i32, i32* %25
%480 = load i32, i32* %12
%481 = icmp slt i32 %479, %480
br i1 %481, label %482, label %507
482: ; preds = %478
%483 = load i32, i32* %25
%484 = load i32, i32* %13
%485 = icmp eq i32 %483, %484
br i1 %485, label %493, label %486
486: ; preds = %482
%487 = load i32*, i32** %22
%488 = load i32, i32* %25
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds i32, i32* %487, i64 %489
%491 = load i32, i32* %490
%492 = icmp sge i32 %491, 0
br i1 %492, label %493, label %498
493: ; preds = %486, %482
%494 = load i32*, i32** %20
%495 = load i32, i32* %25
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds i32, i32* %494, i64 %496
store i32 0, i32* %497
br label %503
498: ; preds = %486
%499 = load i32*, i32** %20
%500 = load i32, i32* %25
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds i32, i32* %499, i64 %501
store i32 1, i32* %502
br label %503
503: ; preds = %498, %493
br label %504
504: ; preds = %503
%505 = load i32, i32* %25
%506 = add nsw i32 %505, 1
store i32 %506, i32* %25
br label %478
507: ; preds = %478
br label %508
508: ; preds = %507, %474
%509 = load i32, i32* %31
ret i32 %509
}

LLVM IR (-O2):
define i32 @maxflow_with_scratch(i8* nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4, i32* nocapture %5, i32* nocapture %6, i32* nocapture %7, i32* nocapture %8, i32* writeonly %9) {
%11 = bitcast i8* %0 to i32*
%12 = bitcast i32* %8 to i8*
%13 = sext i32 %1 to i64
%14 = getelementptr inbounds i32, i32* %11, i64 %13
%15 = shl nsw i32 %1, 1
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds i32, i32* %11, i64 %16
%18 = mul nsw i32 %1, 3
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i32, i32* %11, i64 %19
%21 = icmp sgt i32 %4, 0
br i1 %21, label %22, label %34
22: ; preds = %10
%23 = zext i32 %4 to i64
br label %24
24: ; preds = %22, %111
%25 = phi i64 [ 0, %22 ], [ %113, %111 ]
%26 = phi i32 [ 0, %22 ], [ %112, %111 ]
%27 = shl nuw nsw i64 %25, 1
%28 = getelementptr inbounds i32, i32* %5, i64 %27
%29 = load i32, i32* %28
%30 = icmp sgt i32 %26, %29
br i1 %30, label %111, label %31
31: ; preds = %24
%32 = sext i32 %26 to i64
%33 = trunc i64 %25 to i32
br label %102
34: ; preds = %111, %10
%35 = phi i32 [ 0, %10 ], [ %112, %111 ]
%36 = icmp slt i32 %35, %1
br i1 %36, label %37, label %120
37: ; preds = %34
%38 = sext i32 %35 to i64
%39 = sub nsw i64 %13, %38
%40 = icmp ult i64 %39, 8
br i1 %40, label %100, label %41
41: ; preds = %37
%42 = and i64 %39, -8
%43 = add nsw i64 %42, %38
%44 = insertelement <4 x i32> poison, i32 %4, i64 0
%45 = shufflevector <4 x i32> %44, <4 x i32> poison, <4 x i32> zeroinitializer
%46 = insertelement <4 x i32> poison, i32 %4, i64 0
%47 = shufflevector <4 x i32> %46, <4 x i32> poison, <4 x i32> zeroinitializer
%48 = add nsw i64 %42, -8
%49 = lshr exact i64 %48, 3
%50 = add nuw nsw i64 %49, 1
%51 = and i64 %50, 3
%52 = icmp ult i64 %48, 24
br i1 %52, label %84, label %53
53: ; preds = %41
%54 = and i64 %50, 4611686018427387900
br label %55
55: ; preds = %55, %53
%56 = phi i64 [ 0, %53 ], [ %81, %55 ]
%57 = phi i64 [ 0, %53 ], [ %82, %55 ]
%58 = add i64 %56, %38
%59 = getelementptr inbounds i32, i32* %17, i64 %58
%60 = bitcast i32* %59 to <4 x i32>*
store <4 x i32> %45, <4 x i32>* %60
%61 = getelementptr inbounds i32, i32* %59, i64 4
%62 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> %47, <4 x i32>* %62
%63 = or i64 %56, 8
%64 = add i64 %63, %38
%65 = getelementptr inbounds i32, i32* %17, i64 %64
%66 = bitcast i32* %65 to <4 x i32>*
store <4 x i32> %45, <4 x i32>* %66
%67 = getelementptr inbounds i32, i32* %65, i64 4
%68 = bitcast i32* %67 to <4 x i32>*
store <4 x i32> %47, <4 x i32>* %68
%69 = or i64 %56, 16
%70 = add i64 %69, %38
%71 = getelementptr inbounds i32, i32* %17, i64 %70
%72 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> %45, <4 x i32>* %72
%73 = getelementptr inbounds i32, i32* %71, i64 4
%74 = bitcast i32* %73 to <4 x i32>*
store <4 x i32> %47, <4 x i32>* %74
%75 = or i64 %56, 24
%76 = add i64 %75, %38
%77 = getelementptr inbounds i32, i32* %17, i64 %76
%78 = bitcast i32* %77 to <4 x i32>*
store <4 x i32> %45, <4 x i32>* %78
%79 = getelementptr inbounds i32, i32* %77, i64 4
%80 = bitcast i32* %79 to <4 x i32>*
store <4 x i32> %47, <4 x i32>* %80
%81 = add nuw i64 %56, 32
%82 = add i64 %57, 4
%83 = icmp eq i64 %82, %54
br i1 %83, label %84, label %55
84: ; preds = %55, %41
%85 = phi i64 [ 0, %41 ], [ %81, %55 ]
%86 = icmp eq i64 %51, 0
br i1 %86, label %98, label %87
87: ; preds = %84, %87
%88 = phi i64 [ %95, %87 ], [ %85, %84 ]
%89 = phi i64 [ %96, %87 ], [ 0, %84 ]
%90 = add i64 %88, %38
%91 = getelementptr inbounds i32, i32* %17, i64 %90
%92 = bitcast i32* %91 to <4 x i32>*
store <4 x i32> %45, <4 x i32>* %92
%93 = getelementptr inbounds i32, i32* %91, i64 4
%94 = bitcast i32* %93 to <4 x i32>*
store <4 x i32> %47, <4 x i32>* %94
%95 = add nuw i64 %88, 8
%96 = add i64 %89, 1
%97 = icmp eq i64 %96, %51
br i1 %97, label %98, label %87
98: ; preds = %87, %84
%99 = icmp eq i64 %39, %42
br i1 %99, label %120, label %100
100: ; preds = %37, %98
%101 = phi i64 [ %38, %37 ], [ %43, %98 ]
br label %115
102: ; preds = %31, %102
%103 = phi i64 [ %32, %31 ], [ %104, %102 ]
%104 = add nsw i64 %103, 1
%105 = getelementptr inbounds i32, i32* %17, i64 %103
store i32 %33, i32* %105
%106 = load i32, i32* %28
%107 = sext i32 %106 to i64
%108 = icmp slt i64 %103, %107
br i1 %108, label %102, label %109
109: ; preds = %102
%110 = trunc i64 %104 to i32
br label %111
111: ; preds = %109, %24
%112 = phi i32 [ %26, %24 ], [ %110, %109 ]
%113 = add nuw nsw i64 %25, 1
%114 = icmp eq i64 %113, %23
br i1 %114, label %34, label %24
115: ; preds = %100, %115
%116 = phi i64 [ %117, %115 ], [ %101, %100 ]
%117 = add nsw i64 %116, 1
%118 = getelementptr inbounds i32, i32* %17, i64 %116
store i32 %4, i32* %118
%119 = icmp eq i64 %117, %13
br i1 %119, label %120, label %115
120: ; preds = %115, %98, %34
%121 = phi i32 [ %35, %34 ], [ %1, %98 ], [ %1, %115 ]
%122 = icmp eq i32 %121, %1
%123 = zext i1 %122 to i32
%124 = tail call i32 @assert(i32 %123)
br i1 %21, label %125, label %141
125: ; preds = %120
%126 = zext i32 %4 to i64
br label %127
127: ; preds = %125, %223
%128 = phi i64 [ 0, %125 ], [ %225, %223 ]
%129 = phi i32 [ 0, %125 ], [ %224, %223 ]
%130 = getelementptr inbounds i32, i32* %6, i64 %128
%131 = load i32, i32* %130
%132 = shl nsw i32 %131, 1
%133 = or i32 %132, 1
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i32, i32* %5, i64 %134
%136 = load i32, i32* %135
%137 = icmp sgt i32 %129, %136
br i1 %137, label %223, label %138
138: ; preds = %127
%139 = sext i32 %129 to i64
%140 = trunc i64 %128 to i32
br label %209
141: ; preds = %223, %120
%142 = phi i32 [ 0, %120 ], [ %224, %223 ]
%143 = icmp slt i32 %142, %1
br i1 %143, label %144, label %232
144: ; preds = %141
%145 = sext i32 %142 to i64
%146 = sub nsw i64 %13, %145
%147 = icmp ult i64 %146, 8
br i1 %147, label %207, label %148
148: ; preds = %144
%149 = and i64 %146, -8
%150 = add nsw i64 %149, %145
%151 = insertelement <4 x i32> poison, i32 %4, i64 0
%152 = shufflevector <4 x i32> %151, <4 x i32> poison, <4 x i32> zeroinitializer
%153 = insertelement <4 x i32> poison, i32 %4, i64 0
%154 = shufflevector <4 x i32> %153, <4 x i32> poison, <4 x i32> zeroinitializer
%155 = add nsw i64 %149, -8
%156 = lshr exact i64 %155, 3
%157 = add nuw nsw i64 %156, 1
%158 = and i64 %157, 3
%159 = icmp ult i64 %155, 24
br i1 %159, label %191, label %160
160: ; preds = %148
%161 = and i64 %157, 4611686018427387900
br label %162
162: ; preds = %162, %160
%163 = phi i64 [ 0, %160 ], [ %188, %162 ]
%164 = phi i64 [ 0, %160 ], [ %189, %162 ]
%165 = add i64 %163, %145
%166 = getelementptr inbounds i32, i32* %20, i64 %165
%167 = bitcast i32* %166 to <4 x i32>*
store <4 x i32> %152, <4 x i32>* %167
%168 = getelementptr inbounds i32, i32* %166, i64 4
%169 = bitcast i32* %168 to <4 x i32>*
store <4 x i32> %154, <4 x i32>* %169
%170 = or i64 %163, 8
%171 = add i64 %170, %145
%172 = getelementptr inbounds i32, i32* %20, i64 %171
%173 = bitcast i32* %172 to <4 x i32>*
store <4 x i32> %152, <4 x i32>* %173
%174 = getelementptr inbounds i32, i32* %172, i64 4
%175 = bitcast i32* %174 to <4 x i32>*
store <4 x i32> %154, <4 x i32>* %175
%176 = or i64 %163, 16
%177 = add i64 %176, %145
%178 = getelementptr inbounds i32, i32* %20, i64 %177
%179 = bitcast i32* %178 to <4 x i32>*
store <4 x i32> %152, <4 x i32>* %179
%180 = getelementptr inbounds i32, i32* %178, i64 4
%181 = bitcast i32* %180 to <4 x i32>*
store <4 x i32> %154, <4 x i32>* %181
%182 = or i64 %163, 24
%183 = add i64 %182, %145
%184 = getelementptr inbounds i32, i32* %20, i64 %183
%185 = bitcast i32* %184 to <4 x i32>*
store <4 x i32> %152, <4 x i32>* %185
%186 = getelementptr inbounds i32, i32* %184, i64 4
%187 = bitcast i32* %186 to <4 x i32>*
store <4 x i32> %154, <4 x i32>* %187
%188 = add nuw i64 %163, 32
%189 = add i64 %164, 4
%190 = icmp eq i64 %189, %161
br i1 %190, label %191, label %162
191: ; preds = %162, %148
%192 = phi i64 [ 0, %148 ], [ %188, %162 ]
%193 = icmp eq i64 %158, 0
br i1 %193, label %205, label %194
194: ; preds = %191, %194
%195 = phi i64 [ %202, %194 ], [ %192, %191 ]
%196 = phi i64 [ %203, %194 ], [ 0, %191 ]
%197 = add i64 %195, %145
%198 = getelementptr inbounds i32, i32* %20, i64 %197
%199 = bitcast i32* %198 to <4 x i32>*
store <4 x i32> %152, <4 x i32>* %199
%200 = getelementptr inbounds i32, i32* %198, i64 4
%201 = bitcast i32* %200 to <4 x i32>*
store <4 x i32> %154, <4 x i32>* %201
%202 = add nuw i64 %195, 8
%203 = add i64 %196, 1
%204 = icmp eq i64 %203, %158
br i1 %204, label %205, label %194
205: ; preds = %194, %191
%206 = icmp eq i64 %146, %149
br i1 %206, label %232, label %207
207: ; preds = %144, %205
%208 = phi i64 [ %145, %144 ], [ %150, %205 ]
br label %227
209: ; preds = %138, %209
%210 = phi i64 [ %139, %138 ], [ %211, %209 ]
%211 = add nsw i64 %210, 1
%212 = getelementptr inbounds i32, i32* %20, i64 %210
store i32 %140, i32* %212
%213 = load i32, i32* %130
%214 = shl nsw i32 %213, 1
%215 = or i32 %214, 1
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds i32, i32* %5, i64 %216
%218 = load i32, i32* %217
%219 = sext i32 %218 to i64
%220 = icmp slt i64 %210, %219
br i1 %220, label %209, label %221
221: ; preds = %209
%222 = trunc i64 %211 to i32
br label %223
223: ; preds = %221, %127
%224 = phi i32 [ %129, %127 ], [ %222, %221 ]
%225 = add nuw nsw i64 %128, 1
%226 = icmp eq i64 %225, %126
br i1 %226, label %141, label %127
227: ; preds = %207, %227
%228 = phi i64 [ %229, %227 ], [ %208, %207 ]
%229 = add nsw i64 %228, 1
%230 = getelementptr inbounds i32, i32* %20, i64 %228
store i32 %4, i32* %230
%231 = icmp eq i64 %229, %13
br i1 %231, label %232, label %227
232: ; preds = %227, %205, %141
%233 = phi i32 [ %142, %141 ], [ %1, %205 ], [ %1, %227 ]
%234 = icmp eq i32 %233, %1
%235 = zext i1 %234 to i32
%236 = tail call i32 @assert(i32 %235)
br i1 %21, label %237, label %240
237: ; preds = %232
%238 = zext i32 %4 to i64
%239 = shl nuw nsw i64 %238, 2
br label %240
240: ; preds = %237, %232
%241 = icmp sgt i32 %1, 0
%242 = sext i32 %3 to i64
%243 = getelementptr inbounds i32, i32* %14, i64 %242
%244 = icmp eq i32 %3, %2
%245 = shl nsw i64 %13, 2
%246 = getelementptr i8, i8* %0, i64 %245
%247 = zext i32 %1 to i64
%248 = shl nuw nsw i64 %247, 2
br label %249
249: ; preds = %240, %427
%250 = phi i32 [ %429, %427 ], [ 0, %240 ]
br i1 %241, label %251, label %252
251: ; preds = %249
br label %252
252: ; preds = %251, %249
store i32 %2, i32* %11
br label %253
253: ; preds = %252, %347
%254 = phi i64 [ 0, %252 ], [ %259, %347 ]
%255 = phi i32 [ 1, %252 ], [ %348, %347 ]
%256 = load i32, i32* %243
%257 = icmp slt i32 %256, 1
br i1 %257, label %258, label %354
258: ; preds = %253
%259 = add nuw nsw i64 %254, 1
%260 = getelementptr inbounds i32, i32* %11, i64 %254
%261 = load i32, i32* %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds i32, i32* %17, i64 %262
%264 = load i32, i32* %263
%265 = icmp slt i32 %264, %4
br i1 %265, label %266, label %305
266: ; preds = %258
%267 = sext i32 %264 to i64
br label %268
268: ; preds = %266, %300
%269 = phi i64 [ %267, %266 ], [ %302, %300 ]
%270 = phi i32 [ %255, %266 ], [ %301, %300 ]
%271 = trunc i64 %269 to i32
%272 = shl nsw i32 %271, 1
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds i32, i32* %5, i64 %273
%275 = load i32, i32* %274
%276 = icmp eq i32 %275, %261
br i1 %276, label %277, label %305
277: ; preds = %268
%278 = or i32 %272, 1
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds i32, i32* %5, i64 %279
%281 = load i32, i32* %280
%282 = icmp eq i32 %281, %2
br i1 %282, label %300, label %283
283: ; preds = %277
%284 = sext i32 %281 to i64
%285 = getelementptr inbounds i32, i32* %14, i64 %284
%286 = load i32, i32* %285
%287 = icmp sgt i32 %286, -1
br i1 %287, label %300, label %288
288: ; preds = %283
%289 = getelementptr inbounds i32, i32* %7, i64 %269
%290 = load i32, i32* %289
%291 = icmp sgt i32 %290, -1
br i1 %291, label %292, label %296
292: ; preds = %288
%293 = getelementptr inbounds i32, i32* %8, i64 %269
%294 = load i32, i32* %293
%295 = icmp slt i32 %294, %290
br i1 %295, label %296, label %300
296: ; preds = %292, %288
store i32 %272, i32* %285
%297 = add nsw i32 %270, 1
%298 = sext i32 %270 to i64
%299 = getelementptr inbounds i32, i32* %11, i64 %298
store i32 %281, i32* %299
br label %300
300: ; preds = %292, %277, %283, %296
%301 = phi i32 [ %270, %277 ], [ %270, %283 ], [ %270, %292 ], [ %297, %296 ]
%302 = add nsw i64 %269, 1
%303 = trunc i64 %302 to i32
%304 = icmp eq i32 %303, %4
br i1 %304, label %305, label %268
305: ; preds = %268, %300, %258
%306 = phi i32 [ %255, %258 ], [ %301, %300 ], [ %270, %268 ]
%307 = getelementptr inbounds i32, i32* %20, i64 %262
%308 = load i32, i32* %307
%309 = icmp slt i32 %308, %4
br i1 %309, label %310, label %347
310: ; preds = %305
%311 = sext i32 %308 to i64
br label %312
312: ; preds = %310, %342
%313 = phi i64 [ %311, %310 ], [ %344, %342 ]
%314 = phi i32 [ %306, %310 ], [ %343, %342 ]
%315 = getelementptr inbounds i32, i32* %6, i64 %313
%316 = load i32, i32* %315
%317 = shl nsw i32 %316, 1
%318 = or i32 %317, 1
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds i32, i32* %5, i64 %319
%321 = load i32, i32* %320
%322 = icmp eq i32 %321, %261
br i1 %322, label %323, label %347
323: ; preds = %312
%324 = sext i32 %317 to i64
%325 = getelementptr inbounds i32, i32* %5, i64 %324
%326 = load i32, i32* %325
%327 = icmp eq i32 %326, %2
br i1 %327, label %342, label %328
328: ; preds = %323
%329 = sext i32 %326 to i64
%330 = getelementptr inbounds i32, i32* %14, i64 %329
%331 = load i32, i32* %330
%332 = icmp sgt i32 %331, -1
br i1 %332, label %342, label %333
333: ; preds = %328
%334 = sext i32 %316 to i64
%335 = getelementptr inbounds i32, i32* %8, i64 %334
%336 = load i32, i32* %335
%337 = icmp slt i32 %336, 1
br i1 %337, label %342, label %338
338: ; preds = %333
store i32 %318, i32* %330
%339 = add nsw i32 %314, 1
%340 = sext i32 %314 to i64
%341 = getelementptr inbounds i32, i32* %11, i64 %340
store i32 %326, i32* %341
br label %342
342: ; preds = %333, %323, %328, %338
%343 = phi i32 [ %314, %323 ], [ %314, %328 ], [ %314, %333 ], [ %339, %338 ]
%344 = add nsw i64 %313, 1
%345 = trunc i64 %344 to i32
%346 = icmp eq i32 %345, %4
br i1 %346, label %347, label %312
347: ; preds = %312, %342, %305
%348 = phi i32 [ %306, %305 ], [ %343, %342 ], [ %314, %312 ]
%349 = sext i32 %348 to i64
%350 = icmp slt i64 %259, %349
br i1 %350, label %253, label %351
351: ; preds = %347
%352 = load i32, i32* %243
%353 = icmp sgt i32 %352, -1
br i1 %353, label %354, label %430
354: ; preds = %253, %351
%355 = phi i32 [ %352, %351 ], [ %256, %253 ]
br i1 %244, label %356, label %358
356: ; preds = %354
%357 = tail call i32 @assert(i32 0)
br label %427
358: ; preds = %354, %397
%359 = phi i32 [ %400, %397 ], [ %355, %354 ]
%360 = phi i32 [ %395, %397 ], [ -1, %354 ]
%361 = phi i32 [ %364, %397 ], [ %3, %354 ]
%362 = sext i32 %359 to i64
%363 = getelementptr inbounds i32, i32* %5, i64 %362
%364 = load i32, i32* %363
%365 = icmp ne i32 %364, %361
%366 = zext i1 %365 to i32
%367 = tail call i32 @assert(i32 %366)
%368 = and i32 %359, 1
%369 = icmp eq i32 %368, 0
%370 = sdiv i32 %359, 2
%371 = sext i32 %370 to i64
br i1 %369, label %375, label %372
372: ; preds = %358
%373 = getelementptr inbounds i32, i32* %8, i64 %371
%374 = load i32, i32* %373
br label %383
375: ; preds = %358
%376 = getelementptr inbounds i32, i32* %7, i64 %371
%377 = load i32, i32* %376
%378 = icmp sgt i32 %377, -1
br i1 %378, label %379, label %383
379: ; preds = %375
%380 = getelementptr inbounds i32, i32* %8, i64 %371
%381 = load i32, i32* %380
%382 = sub nsw i32 %377, %381
br label %383
383: ; preds = %375, %379, %372
%384 = phi i32 [ %374, %372 ], [ %382, %379 ], [ -1, %375 ]
%385 = icmp ne i32 %384, 0
%386 = zext i1 %385 to i32
%387 = tail call i32 @assert(i32 %386)
%388 = icmp slt i32 %360, 0
br i1 %388, label %393, label %389
389: ; preds = %383
%390 = icmp sgt i32 %384, -1
%391 = icmp slt i32 %384, %360
%392 = select i1 %390, i1 %391, i1 false
br i1 %392, label %393, label %394
393: ; preds = %389, %383
br label %394
394: ; preds = %393, %389
%395 = phi i32 [ %384, %393 ], [ %360, %389 ]
%396 = icmp eq i32 %364, %2
br i1 %396, label %401, label %397
397: ; preds = %394
%398 = sext i32 %364 to i64
%399 = getelementptr inbounds i32, i32* %14, i64 %398
%400 = load i32, i32* %399
br label %358
401: ; preds = %394
%402 = icmp sgt i32 %395, 0
%403 = zext i1 %402 to i32
%404 = tail call i32 @assert(i32 %403)
br i1 %244, label %427, label %405
405: ; preds = %401
%406 = sub i32 0, %395
br label %407
407: ; preds = %405, %407
%408 = phi i32 [ %414, %407 ], [ %3, %405 ]
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds i32, i32* %14, i64 %409
%411 = load i32, i32* %410
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds i32, i32* %5, i64 %412
%414 = load i32, i32* %413
%415 = icmp ne i32 %414, %408
%416 = zext i1 %415 to i32
%417 = tail call i32 @assert(i32 %416)
%418 = and i32 %411, 1
%419 = icmp eq i32 %418, 0
%420 = sdiv i32 %411, 2
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds i32, i32* %8, i64 %421
%423 = load i32, i32* %422
%424 = select i1 %419, i32 %395, i32 %406
%425 = add i32 %423, %424
store i32 %425, i32* %422
%426 = icmp eq i32 %414, %2
br i1 %426, label %427, label %407
427: ; preds = %407, %356, %401
%428 = phi i32 [ -1, %356 ], [ %395, %401 ], [ %395, %407 ]
%429 = add nsw i32 %428, %250
br label %249
430: ; preds = %351
%431 = icmp ne i32* %9, null
%432 = and i1 %431, %241
br i1 %432, label %433, label %474
433: ; preds = %430
%434 = zext i32 %2 to i64
%435 = and i64 %247, 1
%436 = icmp eq i32 %1, 1
br i1 %436, label %462, label %437
437: ; preds = %433
%438 = and i64 %247, 4294967294
br label %439
439: ; preds = %456, %437
%440 = phi i64 [ 0, %437 ], [ %459, %456 ]
%441 = phi i64 [ 0, %437 ], [ %460, %456 ]
%442 = icmp eq i64 %440, %434
br i1 %442, label %447, label %443
443: ; preds = %439
%444 = getelementptr inbounds i32, i32* %14, i64 %440
%445 = load i32, i32* %444
%446 = lshr i32 %445, 31
br label %447
447: ; preds = %443, %439
%448 = phi i32 [ 0, %439 ], [ %446, %443 ]
%449 = getelementptr inbounds i32, i32* %9, i64 %440
store i32 %448, i32* %449
%450 = or i64 %440, 1
%451 = icmp eq i64 %450, %434
br i1 %451, label %456, label %452
452: ; preds = %447
%453 = getelementptr inbounds i32, i32* %14, i64 %450
%454 = load i32, i32* %453
%455 = lshr i32 %454, 31
br label %456
456: ; preds = %452, %447
%457 = phi i32 [ 0, %447 ], [ %455, %452 ]
%458 = getelementptr inbounds i32, i32* %9, i64 %450
store i32 %457, i32* %458
%459 = add nuw nsw i64 %440, 2
%460 = add i64 %441, 2
%461 = icmp eq i64 %460, %438
br i1 %461, label %462, label %439
462: ; preds = %456, %433
%463 = phi i64 [ 0, %433 ], [ %459, %456 ]
%464 = icmp eq i64 %435, 0
br i1 %464, label %474, label %465
465: ; preds = %462
%466 = icmp eq i64 %463, %434
br i1 %466, label %471, label %467
467: ; preds = %465
%468 = getelementptr inbounds i32, i32* %14, i64 %463
%469 = load i32, i32* %468
%470 = lshr i32 %469, 31
br label %471
471: ; preds = %467, %465
%472 = phi i32 [ 0, %465 ], [ %470, %467 ]
%473 = getelementptr inbounds i32, i32* %9, i64 %463
store i32 %472, i32* %473
br label %474
474: ; preds = %471, %462, %430
ret i32 %250
}