int push_relabel_max_flow(int n, int *xadj, int *adj, int *wgt, int s, int t,
                          int *flow, int *aux) {
  int *oxadj = xadj;
  int *oadj = adj;
  int *owgt = wgt;
  int *auxptr;
  int nnz = xadj[n];
  int *ixadj = u_alloc(n + 2, &auxptr);
  int *iadj = u_alloc(nnz, &auxptr);
  int *imap = u_alloc(nnz, &auxptr);
  int *H = u_alloc(n, &auxptr);
  int *E = u_alloc(n, &auxptr);
  int *next = u_alloc(n, &auxptr);
  int *L = u_alloc(n, &auxptr);
  int *iv = u_alloc(n, &auxptr);
  int *ie = u_alloc(n, &auxptr);
  int *ov = u_alloc(n, &auxptr);
  int *oe = u_alloc(n, &auxptr);
  graph_reverse_map(n, xadj, adj, ixadj, iadj, imap);
  for (int v = 0; v < n; v++) {
    flow[v] = 0;
    H[v] = 0;
    E[v] = 0;
    iv[v] = -1;
    ov[v] = -1;
  }
  H[s] = n;
  for (int j = oxadj[s]; j < oxadj[s + 1]; j++) {
    int w = oadj[j];
    flow[j] += wgt[j];
    E[w] += wgt[j];
    E[s] -= wgt[j];
  }
  for (int rj = ixadj[s]; rj < ixadj[s + 1]; rj++) {
    int w = iadj[rj];
    int j = imap[rj];
    flow[j] -= E[w];
  }
  int lptr = 0;
  for (int v = 0; v < n; v++) {
    if (v != s && v != t) {
      L[lptr++] = v;
    }
  }
  L[lptr] = -1;
  lptr = 0;
  int u = L[lptr];
  while (u >= 0) {
    int height = H[u];
    int v = u;
    for (int j = oxadj[u]; j < oxadj[u + 1]; j++) {
      int w = oadj[j];
      iv[w] = u;
      ie[w] = j;
      next[v] = w;
      v = w;
    }
    for (int rj = ixadj[u]; rj < ixadj[u + 1]; rj++) {
      int w = iadj[rj];
      int j = imap[rj];
      ov[w] = u;
      oe[w] = j;
      if (iv[w] != u) {
        next[v] = w;
        v = w;
      }
    }
    next[v] = u;
    v = next[u];
    while (E[u] > 0) {
      if (v == u) {
        relabel(iv, ie, oe, wgt, flow, H, u, n, next);
        v = next[u];
      } else {
        if (H[u] == H[v] + 1) {
          if (ie[v] == u) {
            int j = ie[v];
            if (wgt[j] > flow[j]) {
              int df = u_min(E[u], wgt[j] - flow[j]);
              push(E, df, u, flow, iv, ie, ov, oe, v);
              v = next[v];
            }
            continue;
          }
          if (oe[v] == u) {
            int j = oe[v];
            if (flow[j] > 0) {
              int df = u_min(E[u], flow[j]);
              push(E, df, u, flow, iv, ie, ov, oe, v);
            }
            continue;
          }
        }
      }
    }
    if (H[u] > height) {
      move_to_front(L, &lptr, u);
    }
    lptr++;
    u = L[lptr];
  }
  for (int j = 0; j < nnz; j++) {
    if (flow[j] < 0) {
      flow[j] = 0;
    }
  }
  return compute_max_flow(oxadj, oadj, ixadj, iadj, imap, flow, s);
}


x86 assembly (clang, -O0):
<push_relabel_max_flow>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4(%rbp),%edi
add    $0x2,%edi
lea    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1040 <u_alloc@plt>
cltq
mov    %rax,-0x58(%rbp)
mov    -0x4c(%rbp),%edi
lea    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1040 <u_alloc@plt>
cltq
mov    %rax,-0x60(%rbp)
mov    -0x4c(%rbp),%edi
lea    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1040 <u_alloc@plt>
cltq
mov    %rax,-0x68(%rbp)
mov    -0x4(%rbp),%edi
lea    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1040 <u_alloc@plt>
cltq
mov    %rax,-0x70(%rbp)
mov    -0x4(%rbp),%edi
lea    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1040 <u_alloc@plt>
cltq
mov    %rax,-0x78(%rbp)
mov    -0x4(%rbp),%edi
lea    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1040 <u_alloc@plt>
cltq
mov    %rax,-0x80(%rbp)
mov    -0x4(%rbp),%edi
lea    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1040 <u_alloc@plt>
cltq
mov    %rax,-0x88(%rbp)
mov    -0x4(%rbp),%edi
lea    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1040 <u_alloc@plt>
cltq
mov    %rax,-0x90(%rbp)
mov    -0x4(%rbp),%edi
lea    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1040 <u_alloc@plt>
cltq
mov    %rax,-0x98(%rbp)
mov    -0x4(%rbp),%edi
lea    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1040 <u_alloc@plt>
cltq
mov    %rax,-0xa0(%rbp)
mov    -0x4(%rbp),%edi
lea    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1040 <u_alloc@plt>
cltq
mov    %rax,-0xa8(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0x68(%rbp),%r9
mov    $0x0,%al
call   1090 <graph_reverse_map@plt>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1359 <push_relabel_max_flow+0x1e9>
mov    0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
movslq -0xac(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
movslq -0xac(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x90(%rbp),%rax
movslq -0xac(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
movslq -0xac(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    12d6 <push_relabel_max_flow+0x166>
mov    -0x4(%rbp),%edx
mov    -0x70(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1418 <push_relabel_max_flow+0x2a8>
mov    -0x38(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x20(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x10(%rbp),%rax
movslq -0xb0(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x78(%rbp),%rax
movslq -0xb4(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x78(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1378 <push_relabel_max_flow+0x208>
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
mov    -0x58(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    14a2 <push_relabel_max_flow+0x332>
mov    -0x60(%rbp),%rax
movslq -0xb8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xbc(%rbp)
mov    -0x68(%rbp),%rax
movslq -0xb8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc0(%rbp)
mov    -0x78(%rbp),%rax
movslq -0xbc(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    0x10(%rbp),%rax
movslq -0xc0(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1429 <push_relabel_max_flow+0x2b9>
movl   $0x0,-0xc4(%rbp)
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1520 <push_relabel_max_flow+0x3b0>
mov    -0xc8(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     1507 <push_relabel_max_flow+0x397>
mov    -0xc8(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     1507 <push_relabel_max_flow+0x397>
mov    -0xc8(%rbp),%edx
mov    -0x88(%rbp),%rax
mov    -0xc4(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0xc4(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    150c <push_relabel_max_flow+0x39c>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    14b6 <push_relabel_max_flow+0x346>
mov    -0x88(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
movl   $0x0,-0xc4(%rbp)
mov    -0x88(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xcc(%rbp)
cmpl   $0x0,-0xcc(%rbp)
jl     19ff <push_relabel_max_flow+0x88f>
mov    -0x70(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0x30(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    -0xcc(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    162c <push_relabel_max_flow+0x4bc>
mov    -0x38(%rbp),%rax
movslq -0xd8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xdc(%rbp)
mov    -0xcc(%rbp),%edx
mov    -0x90(%rbp),%rax
movslq -0xdc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xd8(%rbp),%edx
mov    -0x98(%rbp),%rax
movslq -0xdc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xdc(%rbp),%edx
mov    -0x80(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xdc(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1597 <push_relabel_max_flow+0x427>
mov    -0x58(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
mov    -0x58(%rbp),%rcx
mov    -0xcc(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    170b <push_relabel_max_flow+0x59b>
mov    -0x60(%rbp),%rax
movslq -0xe0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xe4(%rbp)
mov    -0x68(%rbp),%rax
movslq -0xe0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xcc(%rbp),%edx
mov    -0xa0(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xe8(%rbp),%edx
mov    -0xa8(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x90(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0xcc(%rbp),%eax
je     16f2 <push_relabel_max_flow+0x582>
mov    -0xe4(%rbp),%edx
mov    -0x80(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xe4(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    16f7 <push_relabel_max_flow+0x587>
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    1640 <push_relabel_max_flow+0x4d0>
mov    -0xcc(%rbp),%edx
mov    -0x80(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd4(%rbp)
mov    -0x78(%rbp),%rax
movslq -0xcc(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    199f <push_relabel_max_flow+0x82f>
mov    -0xd4(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jne    17b8 <push_relabel_max_flow+0x648>
mov    -0x90(%rbp),%rdi
mov    -0x98(%rbp),%rsi
mov    -0xa8(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    0x10(%rbp),%r8
mov    -0x70(%rbp),%r9
mov    -0xcc(%rbp),%r11d
mov    -0x4(%rbp),%r10d
mov    -0x80(%rbp),%rax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1060 <relabel@plt>
mov    -0x80(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd4(%rbp)
jmp    199a <push_relabel_max_flow+0x82a>
mov    -0x70(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x70(%rbp),%rcx
movslq -0xd4(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1995 <push_relabel_max_flow+0x825>
mov    -0x98(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0xcc(%rbp),%eax
jne    18cf <push_relabel_max_flow+0x75f>
mov    -0x98(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xec(%rbp)
mov    -0x20(%rbp),%rax
movslq -0xec(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x10(%rbp),%rcx
movslq -0xec(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    18ca <push_relabel_max_flow+0x75a>
mov    -0x78(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x20(%rbp),%rax
movslq -0xec(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    0x10(%rbp),%rax
movslq -0xec(%rbp),%rcx
sub    (%rax,%rcx,4),%esi
mov    $0x0,%al
call   1070 <u_min@plt>
mov    %eax,-0xf0(%rbp)
mov    -0x78(%rbp),%rdi
mov    -0xf0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    0x10(%rbp),%rcx
mov    -0x90(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0xa0(%rbp),%r11
mov    -0xa8(%rbp),%r10
mov    -0xd4(%rbp),%eax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1080 <push@plt>
mov    -0x80(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd4(%rbp)
jmp    1733 <push_relabel_max_flow+0x5c3>
mov    -0xa8(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0xcc(%rbp),%eax
jne    1990 <push_relabel_max_flow+0x820>
mov    -0xa8(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xf4(%rbp)
mov    0x10(%rbp),%rax
movslq -0xf4(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    198b <push_relabel_max_flow+0x81b>
mov    -0x78(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    0x10(%rbp),%rax
movslq -0xf4(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    $0x0,%al
call   1070 <u_min@plt>
mov    %eax,-0xf8(%rbp)
mov    -0x78(%rbp),%rdi
mov    -0xf8(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    0x10(%rbp),%rcx
mov    -0x90(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0xa0(%rbp),%r11
mov    -0xa8(%rbp),%r10
mov    -0xd4(%rbp),%eax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1080 <push@plt>
jmp    1733 <push_relabel_max_flow+0x5c3>
jmp    1995 <push_relabel_max_flow+0x825>
jmp    199a <push_relabel_max_flow+0x82a>
jmp    1733 <push_relabel_max_flow+0x5c3>
mov    -0x70(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0xd0(%rbp),%eax
jle    19d4 <push_relabel_max_flow+0x864>
mov    -0x88(%rbp),%rdi
mov    -0xcc(%rbp),%edx
lea    -0xc4(%rbp),%rsi
mov    $0x0,%al
call   1030 <move_to_front@plt>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
mov    -0x88(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xcc(%rbp)
jmp    1556 <push_relabel_max_flow+0x3e6>
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1a58 <push_relabel_max_flow+0x8e8>
mov    0x10(%rbp),%rax
movslq -0xfc(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    1a3f <push_relabel_max_flow+0x8cf>
mov    0x10(%rbp),%rax
movslq -0xfc(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    1a44 <push_relabel_max_flow+0x8d4>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    1a09 <push_relabel_max_flow+0x899>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%r8
mov    0x10(%rbp),%r9
mov    -0x24(%rbp),%eax
mov    %eax,(%rsp)
mov    $0x0,%al
call   1050 <compute_max_flow@plt>
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<push_relabel_max_flow>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9d,0xc(%rsp)
mov    %r8,0x80(%rsp)
mov    %rcx,0x78(%rsp)
mov    %rdx,0x68(%rsp)
mov    %rsi,%r13
mov    %edi,%r15d
movslq %edi,%r12
mov    (%rsi,%r12,4),%ebp
lea    0x2(%r12),%edi
lea    0xa0(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <u_alloc@plt>
cltq
mov    %rax,0x30(%rsp)
mov    %ebp,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <u_alloc@plt>
cltq
mov    %rax,0x50(%rsp)
mov    %rbp,0x90(%rsp)
mov    %ebp,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <u_alloc@plt>
movslq %eax,%rbp
mov    %r12d,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <u_alloc@plt>
cltq
mov    %rax,0x20(%rsp)
mov    %r12d,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <u_alloc@plt>
movslq %eax,%r14
mov    %r12d,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <u_alloc@plt>
mov    %eax,0x38(%rsp)
mov    %r12d,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <u_alloc@plt>
mov    %eax,0x48(%rsp)
mov    %r12d,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <u_alloc@plt>
cltq
mov    %rax,0x10(%rsp)
mov    %r12d,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <u_alloc@plt>
mov    %eax,0x60(%rsp)
mov    %r12d,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <u_alloc@plt>
cltq
mov    %rax,0x40(%rsp)
mov    %r12d,%edi
mov    %rbx,%rsi
mov    0x50(%rsp),%rbx
xor    %eax,%eax
call   1040 <u_alloc@plt>
mov    %eax,0x70(%rsp)
mov    %r12d,%edi
mov    %r13,0x88(%rsp)
mov    %r13,%rsi
mov    0x68(%rsp),%rdx
mov    0x30(%rsp),%rcx
mov    %rbx,%r8
mov    %rbp,0x28(%rsp)
mov    %rbp,%r9
xor    %eax,%eax
call   1090 <graph_reverse_map@plt>
mov    0x20(%rsp),%r11
test   %r12d,%r12d
jle    137c <push_relabel_max_flow+0x20c>
mov    %r15d,%eax
cmp    $0x1,%r15d
jne    12c7 <push_relabel_max_flow+0x157>
xor    %ecx,%ecx
jmp    1341 <push_relabel_max_flow+0x1d1>
mov    %eax,%edx
and    $0xfffffffe,%edx
xor    %ecx,%ecx
mov    0x10(%rsp),%rsi
mov    0x40(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
mov    0xe0(%rsp),%rbp
movl   $0x0,0x0(%rbp,%rcx,4)
movl   $0x0,(%r11,%rcx,4)
movl   $0x0,(%r14,%rcx,4)
movl   $0xffffffff,(%rsi,%rcx,4)
movl   $0xffffffff,(%rdi,%rcx,4)
movl   $0x0,0x4(%rbp,%rcx,4)
movl   $0x0,0x4(%r11,%rcx,4)
movl   $0x0,0x4(%r14,%rcx,4)
movl   $0xffffffff,0x4(%rsi,%rcx,4)
ff
movl   $0xffffffff,0x4(%rdi,%rcx,4)
ff
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    12e0 <push_relabel_max_flow+0x170>
test   $0x1,%al
je     137c <push_relabel_max_flow+0x20c>
mov    0xe0(%rsp),%rax
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,(%r11,%rcx,4)
movl   $0x0,(%r14,%rcx,4)
mov    0x10(%rsp),%rax
movl   $0xffffffff,(%rax,%rcx,4)
mov    0x40(%rsp),%rax
movl   $0xffffffff,(%rax,%rcx,4)
mov    0x80(%rsp),%r10
movslq %r10d,%r8
mov    %r15d,(%r11,%r8,4)
mov    0x88(%rsp),%rdi
movslq (%rdi,%r8,4),%rdx
lea    0x1(%r8),%rax
cmp    0x4(%rdi,%r8,4),%edx
mov    0x68(%rsp),%r13
mov    0x78(%rsp),%rbp
jge    13e1 <push_relabel_max_flow+0x271>
nopl   0x0(%rax)
movslq 0x0(%r13,%rdx,4),%rsi
mov    0x0(%rbp,%rdx,4),%ebx
mov    0xe0(%rsp),%rcx
add    %ebx,(%rcx,%rdx,4)
mov    0x0(%rbp,%rdx,4),%ebx
add    %ebx,(%r14,%rsi,4)
mov    0x0(%rbp,%rdx,4),%esi
sub    %esi,(%r14,%r8,4)
add    $0x1,%rdx
movslq (%rdi,%rax,4),%rsi
cmp    %rsi,%rdx
jl     13b0 <push_relabel_max_flow+0x240>
mov    0x30(%rsp),%rbp
movslq 0x0(%rbp,%r8,4),%rcx
cmp    0x0(%rbp,%rax,4),%ecx
mov    0x50(%rsp),%r9
mov    0x28(%rsp),%r8
jge    1425 <push_relabel_max_flow+0x2b5>
nopl   0x0(%rax,%rax,1)
movslq (%r9,%rcx,4),%rdx
movslq (%r8,%rcx,4),%rsi
mov    (%r14,%rdx,4),%edx
mov    0xe0(%rsp),%rbx
sub    %edx,(%rbx,%rsi,4)
add    $0x1,%rcx
movslq 0x0(%rbp,%rax,4),%rdx
cmp    %rdx,%rcx
jl     1400 <push_relabel_max_flow+0x290>
movslq 0x48(%rsp),%rax
mov    %rax,0x18(%rsp)
xor    %eax,%eax
movl   $0x0,0x8(%rsp)
test   %r15d,%r15d
mov    %r14,0x58(%rsp)
mov    %r15,0x98(%rsp)
jle    150f <push_relabel_max_flow+0x39f>
cmp    $0x1,%r15d
je     14e5 <push_relabel_max_flow+0x375>
mov    %r10d,%ecx
neg    %ecx
mov    0xc(%rsp),%eax
mov    %eax,%r8d
neg    %r8d
mov    %r15d,%r11d
and    $0xfffffffe,%r11d
neg    %r11d
mov    $0x1,%eax
jmp    1490 <push_relabel_max_flow+0x320>
nopl   0x0(%rax)
mov    %eax,%edx
add    $0x2,%eax
add    %r11d,%edx
add    $0x2,%edx
cmp    $0x1,%edx
je     14d8 <push_relabel_max_flow+0x368>
lea    (%rcx,%rax,1),%ebp
lea    (%r8,%rax,1),%esi
cmp    $0x1,%ebp
je     14b8 <push_relabel_max_flow+0x348>
cmp    $0x1,%esi
je     14b8 <push_relabel_max_flow+0x348>
lea    -0x1(%rax),%ebp
movslq 0x8(%rsp),%rbx
lea    0x1(%rbx),%edx
mov    %edx,0x8(%rsp)
mov    0x18(%rsp),%rdx
mov    %ebp,(%rdx,%rbx,4)
mov    %ecx,%edx
add    %eax,%edx
je     1480 <push_relabel_max_flow+0x310>
test   %esi,%esi
je     1480 <push_relabel_max_flow+0x310>
movslq 0x8(%rsp),%rdx
lea    0x1(%rdx),%esi
mov    %esi,0x8(%rsp)
mov    0x18(%rsp),%rsi
mov    %eax,(%rsi,%rdx,4)
jmp    1480 <push_relabel_max_flow+0x310>
add    $0xffffffff,%eax
mov    0x28(%rsp),%r8
mov    0x20(%rsp),%r11
test   $0x1,%r15b
je     150a <push_relabel_max_flow+0x39a>
cmp    %r10d,%eax
je     150a <push_relabel_max_flow+0x39a>
cmp    0xc(%rsp),%eax
je     150a <push_relabel_max_flow+0x39a>
movslq 0x8(%rsp),%rcx
lea    0x1(%rcx),%edx
mov    %edx,0x8(%rsp)
mov    0x18(%rsp),%rdx
mov    %eax,(%rdx,%rcx,4)
movslq 0x8(%rsp),%rax
mov    0x18(%rsp),%rcx
movl   $0xffffffff,(%rcx,%rax,4)
movl   $0x0,0x8(%rsp)
mov    (%rcx),%ebp
test   %ebp,%ebp
js     1810 <push_relabel_max_flow+0x6a0>
movslq 0x38(%rsp),%rbx
movslq 0x60(%rsp),%r12
movslq 0x70(%rsp),%r14
mov    %rbx,0x48(%rsp)
jmp    157b <push_relabel_max_flow+0x40b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq 0x8(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %ecx,0x8(%rsp)
mov    0x18(%rsp),%rcx
mov    0x4(%rcx,%rax,4),%ebp
test   %ebp,%ebp
mov    0x68(%rsp),%r13
mov    0x88(%rsp),%rdi
js     1810 <push_relabel_max_flow+0x6a0>
mov    %ebp,%r15d
mov    (%r11,%r15,4),%eax
mov    %eax,0xc(%rsp)
movslq (%rdi,%r15,4),%rdx
lea    0x1(%r15),%rax
mov    %ebp,%ecx
cmp    0x4(%rdi,%r15,4),%edx
mov    0x10(%rsp),%r10
mov    %r13,%r9
mov    %rbx,%r13
jge    15d3 <push_relabel_max_flow+0x463>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %ecx,%rcx
movslq (%r9,%rdx,4),%rsi
mov    %ebp,(%r10,%rsi,4)
mov    %edx,(%r12,%rsi,4)
mov    %esi,0x0(%r13,%rcx,4)
add    $0x1,%rdx
movslq (%rdi,%rax,4),%rbx
mov    %esi,%ecx
cmp    %rbx,%rdx
jl     15b0 <push_relabel_max_flow+0x440>
mov    0x30(%rsp),%rdi
movslq (%rdi,%r15,4),%rdx
cmp    (%rdi,%rax,4),%edx
mov    0x50(%rsp),%r13
mov    0x40(%rsp),%rbx
jl     1642 <push_relabel_max_flow+0x4d2>
movslq %ecx,%rax
mov    0x48(%rsp),%rbx
mov    %ebp,(%rbx,%rax,4)
mov    0x58(%rsp),%rax
mov    (%rax,%r15,4),%edi
test   %edi,%edi
jle    17e0 <push_relabel_max_flow+0x670>
lea    (%rbx,%r15,4),%rax
mov    %rax,0x70(%rsp)
mov    (%rax),%eax
mov    %rax,0x38(%rsp)
movslq %ebp,%rax
mov    %rax,0x60(%rsp)
jmp    16d0 <push_relabel_max_flow+0x560>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x30(%rsp),%rdi
add    $0x1,%rdx
movslq (%rdi,%rax,4),%rsi
cmp    %rsi,%rdx
jge    15eb <push_relabel_max_flow+0x47b>
movslq 0x0(%r13,%rdx,4),%rsi
mov    (%r8,%rdx,4),%edi
mov    %ebp,(%rbx,%rsi,4)
mov    %edi,(%r14,%rsi,4)
cmp    %ebp,(%r10,%rsi,4)
je     1630 <push_relabel_max_flow+0x4c0>
movslq %ecx,%rcx
mov    0x48(%rsp),%rdi
mov    %esi,(%rdi,%rcx,4)
mov    %esi,%ecx
jmp    1630 <push_relabel_max_flow+0x4c0>
nopw   0x0(%rax,%rax,1)
sub    $0x8,%rsp
mov    %r10,%rdi
mov    %r12,%rsi
mov    %r14,%rdx
mov    0x80(%rsp),%rcx
mov    0xe8(%rsp),%r8
mov    %r11,%r9
xor    %eax,%eax
push   %rbx
push   0xa8(%rsp)
push   %rbp
call   1060 <relabel@plt>
mov    0x30(%rsp),%r10
mov    0x40(%rsp),%r11
mov    0x48(%rsp),%r8
add    $0x20,%rsp
mov    0x70(%rsp),%rax
mov    (%rax),%eax
mov    %rax,0x38(%rsp)
mov    0x58(%rsp),%rax
mov    (%rax,%r15,4),%edi
test   %edi,%edi
jle    17e0 <push_relabel_max_flow+0x670>
mov    0x38(%rsp),%rax
cmp    %ebp,%eax
je     1670 <push_relabel_max_flow+0x500>
movslq %eax,%r13
jmp    16e8 <push_relabel_max_flow+0x578>
xchg   %ax,%ax
test   %edi,%edi
jle    17e0 <push_relabel_max_flow+0x670>
mov    (%r11,%r13,4),%eax
add    $0x1,%eax
cmp    %eax,(%r11,%r15,4)
jne    16bf <push_relabel_max_flow+0x54f>
cmp    %ebp,(%r12,%r13,4)
je     176e <push_relabel_max_flow+0x5fe>
cmp    %ebp,(%r14,%r13,4)
jne    16bf <push_relabel_max_flow+0x54f>
mov    0xe0(%rsp),%rax
mov    0x60(%rsp),%rcx
mov    (%rax,%rcx,4),%esi
test   %esi,%esi
jle    16e0 <push_relabel_max_flow+0x570>
xor    %eax,%eax
call   1070 <u_min@plt>
sub    $0x8,%rsp
mov    0x60(%rsp),%rbx
mov    %rbx,%rdi
mov    %eax,%esi
mov    %ebp,%edx
mov    0xe8(%rsp),%rcx
mov    0x18(%rsp),%r8
mov    %r12,%r9
xor    %eax,%eax
push   0x40(%rsp)
push   %r14
push   0x58(%rsp)
call   1080 <push@plt>
mov    0x30(%rsp),%r10
mov    0x40(%rsp),%r11
mov    0x48(%rsp),%r8
add    $0x20,%rsp
mov    (%rbx,%r15,4),%edi
mov    0x48(%rsp),%rbx
jmp    16e0 <push_relabel_max_flow+0x570>
mov    0x78(%rsp),%rax
mov    0x60(%rsp),%rcx
mov    (%rax,%rcx,4),%esi
mov    0xe0(%rsp),%rax
sub    (%rax,%rcx,4),%esi
jle    16bf <push_relabel_max_flow+0x54f>
xor    %eax,%eax
call   1070 <u_min@plt>
sub    $0x8,%rsp
mov    0x60(%rsp),%rdi
mov    %eax,%esi
mov    %ebp,%edx
mov    0xe8(%rsp),%rcx
mov    0x18(%rsp),%r8
mov    %r12,%r9
xor    %eax,%eax
push   0x40(%rsp)
push   %r14
push   0x58(%rsp)
call   1080 <push@plt>
mov    0x30(%rsp),%r10
mov    0x40(%rsp),%r11
mov    0x48(%rsp),%r8
add    $0x20,%rsp
lea    (%rbx,%r13,4),%rax
jmp    16b8 <push_relabel_max_flow+0x548>
nopl   (%rax)
mov    0xc(%rsp),%eax
cmp    %eax,(%r11,%r15,4)
jle    1550 <push_relabel_max_flow+0x3e0>
mov    0x18(%rsp),%rdi
lea    0x8(%rsp),%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1030 <move_to_front@plt>
mov    0x20(%rsp),%r11
mov    0x28(%rsp),%r8
jmp    1550 <push_relabel_max_flow+0x3e0>
mov    0x90(%rsp),%rbx
test   %ebx,%ebx
mov    0x80(%rsp),%rbp
jle    196b <push_relabel_max_flow+0x7fb>
cmp    $0x8,%ebx
jae    1834 <push_relabel_max_flow+0x6c4>
xor    %eax,%eax
jmp    19a9 <push_relabel_max_flow+0x839>
mov    %ebx,%eax
and    $0xfffffff8,%eax
lea    0x0(,%rbx,4),%rcx
and    $0xffffffffffffffe0,%rcx
xor    %edx,%edx
jmp    185d <push_relabel_max_flow+0x6ed>
nopl   0x0(%rax)
add    $0x20,%rdx
cmp    %rdx,%rcx
je     1966 <push_relabel_max_flow+0x7f6>
mov    0xe0(%rsp),%rsi
movdqu (%rsi,%rdx,1),%xmm1
pxor   %xmm0,%xmm0
pcmpgtd %xmm1,%xmm0
movd   %xmm0,%esi
test   $0x1,%sil
je     188b <push_relabel_max_flow+0x71b>
mov    0xe0(%rsp),%rsi
movl   $0x0,(%rsi,%rdx,1)
pextrw $0x2,%xmm0,%esi
test   $0x1,%sil
je     18a6 <push_relabel_max_flow+0x736>
mov    0xe0(%rsp),%rsi
movl   $0x0,0x4(%rsi,%rdx,1)
pextrw $0x4,%xmm0,%esi
test   $0x1,%sil
je     18c1 <push_relabel_max_flow+0x751>
mov    0xe0(%rsp),%rsi
movl   $0x0,0x8(%rsi,%rdx,1)
pextrw $0x6,%xmm0,%esi
test   $0x1,%sil
je     18dc <push_relabel_max_flow+0x76c>
mov    0xe0(%rsp),%rsi
movl   $0x0,0xc(%rsi,%rdx,1)
mov    0xe0(%rsp),%rsi
movdqu 0x10(%rsi,%rdx,1),%xmm1
pxor   %xmm0,%xmm0
pcmpgtd %xmm1,%xmm0
movd   %xmm0,%esi
test   $0x1,%sil
je     190c <push_relabel_max_flow+0x79c>
mov    0xe0(%rsp),%rsi
movl   $0x0,0x10(%rsi,%rdx,1)
pextrw $0x2,%xmm0,%esi
test   $0x1,%sil
je     1927 <push_relabel_max_flow+0x7b7>
mov    0xe0(%rsp),%rsi
movl   $0x0,0x14(%rsi,%rdx,1)
pextrw $0x4,%xmm0,%esi
test   $0x1,%sil
je     1942 <push_relabel_max_flow+0x7d2>
mov    0xe0(%rsp),%rsi
movl   $0x0,0x18(%rsi,%rdx,1)
pextrw $0x6,%xmm0,%esi
test   $0x1,%sil
je     1850 <push_relabel_max_flow+0x6e0>
mov    0xe0(%rsp),%rsi
movl   $0x0,0x1c(%rsi,%rdx,1)
jmp    1850 <push_relabel_max_flow+0x6e0>
cmp    %rbx,%rax
jne    19a9 <push_relabel_max_flow+0x839>
sub    $0x8,%rsp
mov    %r13,%rsi
mov    0x38(%rsp),%rdx
mov    0x58(%rsp),%rcx
mov    0xe8(%rsp),%r9
xor    %eax,%eax
push   %rbp
call   1050 <compute_max_flow@plt>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xchg   %ax,%ax
add    $0x1,%rax
cmp    %rax,%rbx
je     196b <push_relabel_max_flow+0x7fb>
mov    0xe0(%rsp),%rcx
cmpl   $0x0,(%rcx,%rax,4)
jns    19a0 <push_relabel_max_flow+0x830>
mov    0xe0(%rsp),%rcx
movl   $0x0,(%rcx,%rax,4)
jmp    19a0 <push_relabel_max_flow+0x830>

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

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