#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*/ memcpy(int *, int *, int);
int /*<<< orphan*/ memset(int *, int /*<<< orphan*/, int);
void min_dom_set(int level, int *n_dom, int num_choice[512], int num_dom[512],
                 int *size, int dom[512 - 1], int *min_size,
                 int min_dom[512 - 1], int vertex_count, int max_deg,
                 int G[512][512]) {
  if (level == 0) {
    int i;
    for (i = 0; i < vertex_count; i++) {
      G[i][i] = 1;
    }
    *n_dom = 0;
    memset(num_choice, 0, vertex_count * sizeof(int));
    max_deg = 0;
    int j, deg_i;
    for (i = 0; i < vertex_count; i++) {
      deg_i = 0;
      for (j = 0; j < vertex_count; j++) {
        deg_i += G[i][j];
      }
      num_choice[i] = deg_i;
      if (deg_i > max_deg) {
        max_deg = deg_i;
      }
    }
    memset(num_dom, 0, vertex_count * sizeof(int));
    *size = 0;
    memset(dom, 0, vertex_count * sizeof(int));
    *min_size = vertex_count;
    memset(min_dom, 0, vertex_count * sizeof(int));
    for (i = 0; i < vertex_count; i++) {
      min_dom[i] = i;
    }
  }
  int i;
  for (i = 0; i < vertex_count; i++) {
    if (!num_choice[i]) {
      return;
    }
  }
  int u = vertex_count - *n_dom;
  int n_extra = u / max_deg + (u % max_deg != 0);
  if (*size + n_extra >= *min_size) {
    return;
  }
  if (level == vertex_count || *n_dom == vertex_count) {
    if (*size < *min_size) {
      memcpy(min_dom, dom, vertex_count * sizeof(int));
      *min_size = *size;
    }
    return;
  }
  for (i = 0; i < vertex_count; i++) {
    if (G[level][i]) {
      num_choice[i]--;
    };
  }
  min_dom_set(level + 1, n_dom, num_choice, num_dom, size, dom, min_size,
              min_dom, vertex_count, max_deg, G);
  for (i = 0; i < vertex_count; i++) {
    if (G[level][i]) {
      num_choice[i]++;
    };
  }
  dom[level] = 1;
  *size += 1;
  for (i = 0; i < vertex_count; i++) {
    if (G[level][i]) {
      num_dom[i]++;
    };
  }
  *n_dom = 0;
  for (i = 0; i < vertex_count; i++) {
    if (num_dom[i]) {
      *n_dom += 1;
    }
  }
  min_dom_set(level + 1, n_dom, num_choice, num_dom, size, dom, min_size,
              min_dom, vertex_count, max_deg, G);
  dom[level] = 0;
  *size -= 1;
  for (i = 0; i < vertex_count; i++) {
    if (G[level][i]) {
      if (num_dom[i]) {
        *n_dom -= 1;
      }
      num_dom[i]--;
    };
  }
  if (level == 0) {
    for (i = 0; i < vertex_count; i++) {
      G[i][i] = 0;
    }
  }
}


x86 assembly (clang, -O0):
<min_dom_set>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x80,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x14(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
cmpl   $0x0,-0x14(%rbp)
jne    12e2 <min_dom_set+0x1b2>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    11ac <min_dom_set+0x7c>
mov    0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1178 <min_dom_set+0x48>
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rdi
movslq 0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x0,0x28(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    125c <min_dom_set+0x12c>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1229 <min_dom_set+0xf9>
mov    0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11f3 <min_dom_set+0xc3>
mov    -0x4c(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
cmp    0x28(%rbp),%eax
jle    1249 <min_dom_set+0x119>
mov    -0x4c(%rbp),%eax
mov    %eax,0x28(%rbp)
jmp    124e <min_dom_set+0x11e>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11d9 <min_dom_set+0xa9>
mov    -0x30(%rbp),%rdi
movslq 0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x38(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x40(%rbp),%rdi
movslq 0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
mov    0x20(%rbp),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    0x18(%rbp),%rdi
movslq 0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    12dd <min_dom_set+0x1ad>
mov    -0x44(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12b5 <min_dom_set+0x185>
jmp    12e2 <min_dom_set+0x1b2>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    131f <min_dom_set+0x1ef>
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    130c <min_dom_set+0x1dc>
jmp    168d <min_dom_set+0x55d>
jmp    1311 <min_dom_set+0x1e1>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12e9 <min_dom_set+0x1b9>
mov    0x20(%rbp),%eax
mov    -0x20(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cltd
idivl  0x28(%rbp)
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
cltd
idivl  0x28(%rbp)
mov    -0x5c(%rbp),%eax
cmp    $0x0,%edx
setne  %cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
add    -0x58(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jl     136a <min_dom_set+0x23a>
jmp    168d <min_dom_set+0x55d>
mov    -0x14(%rbp),%eax
cmp    0x20(%rbp),%eax
je     1385 <min_dom_set+0x255>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
cmp    0x20(%rbp),%eax
jne    13bf <min_dom_set+0x28f>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    13ba <min_dom_set+0x28a>
mov    0x18(%rbp),%rdi
mov    -0x40(%rbp),%rsi
movslq 0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1050 <memcpy@plt>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
jmp    168d <min_dom_set+0x55d>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1413 <min_dom_set+0x2e3>
mov    0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1400 <min_dom_set+0x2d0>
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1405 <min_dom_set+0x2d5>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    13c6 <min_dom_set+0x296>
mov    -0x14(%rbp),%edi
add    $0x1,%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
mov    -0x40(%rbp),%r9
mov    0x10(%rbp),%r14
mov    0x18(%rbp),%rbx
mov    0x20(%rbp),%r11d
mov    0x28(%rbp),%r10d
mov    0x30(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11d,0x10(%rsp)
mov    %r10d,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1030 <min_dom_set@plt>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    14b2 <min_dom_set+0x382>
mov    0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     149f <min_dom_set+0x36f>
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    14a4 <min_dom_set+0x374>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1465 <min_dom_set+0x335>
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1520 <min_dom_set+0x3f0>
mov    0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     150d <min_dom_set+0x3dd>
mov    -0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1512 <min_dom_set+0x3e2>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    14d3 <min_dom_set+0x3a3>
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    156d <min_dom_set+0x43d>
mov    -0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     155a <min_dom_set+0x42a>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    155f <min_dom_set+0x42f>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1531 <min_dom_set+0x401>
mov    -0x14(%rbp),%edi
add    $0x1,%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
mov    -0x40(%rbp),%r9
mov    0x10(%rbp),%r14
mov    0x18(%rbp),%rbx
mov    0x20(%rbp),%r11d
mov    0x28(%rbp),%r10d
mov    0x30(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11d,0x10(%rsp)
mov    %r10d,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1030 <min_dom_set@plt>
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
sub    $0x1,%ecx
mov    %ecx,(%rax)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1643 <min_dom_set+0x513>
mov    0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1630 <min_dom_set+0x500>
mov    -0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     161f <min_dom_set+0x4ef>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
sub    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1635 <min_dom_set+0x505>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    15d9 <min_dom_set+0x4a9>
cmpl   $0x0,-0x14(%rbp)
jne    168d <min_dom_set+0x55d>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1688 <min_dom_set+0x558>
mov    0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x50(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1654 <min_dom_set+0x524>
jmp    168d <min_dom_set+0x55d>
add    $0x80,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<min_dom_set>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rcx,0x20(%rsp)
mov    %rdx,%r14
mov    %rsi,%r11
mov    0xa0(%rsp),%r10
mov    0x90(%rsp),%r13d
mov    0x88(%rsp),%rbp
mov    0x80(%rsp),%r12
test   %edi,%edi
je     117a <min_dom_set+0x4a>
mov    0x98(%rsp),%r15d
jmp    164d <min_dom_set+0x51d>
test   %r13d,%r13d
mov    %rdi,0x30(%rsp)
mov    %r11,0x28(%rsp)
mov    %r8,0x8(%rsp)
mov    %r9,0x10(%rsp)
jle    11b0 <min_dom_set+0x80>
mov    %r13d,%r12d
lea    -0x1(%r12),%rcx
mov    %r12d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    11dd <min_dom_set+0xad>
xor    %ecx,%ecx
mov    0x20(%rsp),%rbx
jmp    1224 <min_dom_set+0xf4>
movl   $0x0,(%r11)
lea    0x0(,%r13,4),%ebx
xor    %r15d,%r15d
mov    %r14,%rdi
xor    %esi,%esi
mov    %ebx,%edx
mov    %r8,%r12
call   1040 <memset@plt>
mov    %ebx,%ecx
mov    0x20(%rsp),%rdi
jmp    143e <min_dom_set+0x30e>
mov    %r12d,%edx
and    $0xfffffffc,%edx
xor    %ecx,%ecx
mov    %r10,%rsi
mov    0x20(%rsp),%rbx
nopl   (%rax)
movl   $0x1,(%rsi)
movl   $0x1,0x804(%rsi)
movl   $0x1,0x1008(%rsi)
movl   $0x1,0x180c(%rsi)
add    $0x4,%rcx
add    $0x2010,%rsi
cmp    %rcx,%rdx
jne    11f0 <min_dom_set+0xc0>
test   %rax,%rax
je     1263 <min_dom_set+0x133>
mov    %rcx,%rdx
shl    $0xb,%rdx
lea    (%rdx,%rcx,4),%rcx
add    %r10,%rcx
mov    %rax,%rdx
shl    $0xb,%rdx
lea    (%rdx,%rax,4),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x1,(%rcx,%rdx,1)
add    $0x804,%rdx
cmp    %rdx,%rax
jne    1250 <min_dom_set+0x120>
movl   $0x0,(%r11)
lea    0x0(,%r13,4),%edx
xor    %r15d,%r15d
mov    %r14,0x18(%rsp)
mov    %r14,%rdi
xor    %esi,%esi
mov    %edx,%r14d
call   1040 <memset@plt>
test   %r13d,%r13d
jle    1426 <min_dom_set+0x2f6>
mov    %rbx,%r11
mov    %r12d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%r9
mov    %r9,%r8
shr    $0x3,%r8
add    $0x1,%r8
mov    %r8d,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%r8
mov    0xa0(%rsp),%rbx
lea    0x70(%rbx),%rdi
mov    %r10,%rsi
shl    $0x5,%rsi
xor    %ebp,%ebp
xor    %r15d,%r15d
jmp    12fa <min_dom_set+0x1ca>
nopl   (%rax)
mov    0x18(%rsp),%rdx
mov    %ecx,(%rdx,%rbp,4)
cmp    %r15d,%ecx
cmovg  %ecx,%r15d
add    $0x1,%rbp
add    $0x800,%rdi
add    $0x800,%rbx
cmp    %r12,%rbp
je     1411 <min_dom_set+0x2e1>
cmp    $0x8,%r13d
jae    1310 <min_dom_set+0x1e0>
xor    %edx,%edx
xor    %ecx,%ecx
jmp    1400 <min_dom_set+0x2d0>
nopl   0x0(%rax)
pxor   %xmm0,%xmm0
cmp    $0x18,%r9
jae    1330 <min_dom_set+0x200>
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
jmp    1399 <min_dom_set+0x269>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8,%rdx
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu -0x70(%rdi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rdi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rdi,%rcx,4),%xmm1
movdqu -0x40(%rdi,%rcx,4),%xmm3
movdqu -0x30(%rdi,%rcx,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rdi,%rcx,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rdi,%rcx,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rdi,%rcx,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdx
jne    1340 <min_dom_set+0x210>
test   %r10,%r10
je     13cc <min_dom_set+0x29c>
lea    (%rbx,%rcx,4),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rcx,%rdx,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rcx,%rdx,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    13b0 <min_dom_set+0x280>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
mov    %rax,%rdx
cmp    %r12,%rax
je     12d0 <min_dom_set+0x1a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    (%rbx,%rdx,4),%ecx
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1400 <min_dom_set+0x2d0>
jmp    12d0 <min_dom_set+0x1a0>
mov    %r14d,%ecx
mov    %r11,%rdi
mov    0x8(%rsp),%r12
mov    0x88(%rsp),%rbp
jmp    1439 <min_dom_set+0x309>
mov    0x8(%rsp),%r12
mov    %rbx,%rdi
mov    0x88(%rsp),%rbp
mov    %r14d,%ecx
mov    0x18(%rsp),%r14
xor    %esi,%esi
mov    %ecx,%ebx
mov    %ecx,%edx
call   1040 <memset@plt>
movl   $0x0,(%r12)
mov    0x10(%rsp),%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1040 <memset@plt>
mov    0x80(%rsp),%r12
mov    %r13d,(%r12)
mov    %rbp,%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1040 <memset@plt>
test   %r13d,%r13d
jle    14a3 <min_dom_set+0x373>
mov    %r13d,%eax
cmp    $0x8,%r13d
jae    14c6 <min_dom_set+0x396>
xor    %ecx,%ecx
mov    0x10(%rsp),%r9
mov    0xa0(%rsp),%r10
mov    0x28(%rsp),%r11
mov    0x8(%rsp),%r8
jmp    162c <min_dom_set+0x4fc>
mov    0x30(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0xa0(%rsp),%r10
mov    0x28(%rsp),%r11
xor    %ebx,%ebx
mov    0x8(%rsp),%r8
jmp    1678 <min_dom_set+0x548>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
mov    0x10(%rsp),%r9
mov    0xa0(%rsp),%r10
mov    0x28(%rsp),%r11
mov    0x8(%rsp),%r8
jae    150b <min_dom_set+0x3db>
movdqa 0xafc(%rip),%xmm0
xor    %edi,%edi
jmp    15d9 <min_dom_set+0x4a9>
and    $0xfffffffffffffffc,%rsi
movdqa 0xae9(%rip),%xmm0
xor    %edi,%edi
movdqa 0xaee(%rip),%xmm8
movdqa 0xaf5(%rip),%xmm9
movdqa 0xafc(%rip),%xmm10
movdqa 0xb04(%rip),%xmm4
movdqa 0xb0c(%rip),%xmm5
movdqa 0xb14(%rip),%xmm6
movdqa 0xb1c(%rip),%xmm7
movdqa 0xb24(%rip),%xmm1
nopl   0x0(%rax)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,0x0(%rbp,%rdi,4)
movdqu %xmm2,0x10(%rbp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbp,%rdi,4)
movdqu %xmm3,0x30(%rbp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbp,%rdi,4)
movdqu %xmm3,0x50(%rbp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbp,%rdi,4)
movdqu %xmm3,0x70(%rbp,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1560 <min_dom_set+0x430>
test   %rdx,%rdx
je     1620 <min_dom_set+0x4f0>
lea    0x10(,%rdi,4),%rsi
add    %rbp,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xa19(%rip),%xmm1
movdqa 0xa21(%rip),%xmm2
nop
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1600 <min_dom_set+0x4d0>
cmp    %rax,%rcx
jne    162c <min_dom_set+0x4fc>
mov    0x30(%rsp),%rdi
jmp    164d <min_dom_set+0x51d>
mov    0x30(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ecx,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1640 <min_dom_set+0x510>
test   %r13d,%r13d
setg   %bl
jle    1676 <min_dom_set+0x546>
mov    %r13d,%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,(%r14,%rcx,4)
je     19f3 <min_dom_set+0x8c3>
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1660 <min_dom_set+0x530>
jmp    1678 <min_dom_set+0x548>
xor    %ebx,%ebx
mov    (%r11),%ecx
mov    %r13d,%eax
sub    %ecx,%eax
cltd
idiv   %r15d
mov    (%r8),%esi
add    %esi,%eax
cmp    $0x1,%edx
sbb    $0xffffffff,%eax
mov    (%r12),%edx
cmp    %edx,%eax
jge    19f3 <min_dom_set+0x8c3>
cmp    %r13d,%edi
je     1717 <min_dom_set+0x5e7>
cmp    %r13d,%ecx
je     1717 <min_dom_set+0x5e7>
test   %bl,%bl
mov    %rdi,0x30(%rsp)
mov    %r8,0x8(%rsp)
mov    %ebx,0x18(%rsp)
je     173f <min_dom_set+0x60f>
movslq %edi,%r12
mov    %r13d,%ebp
mov    %rbp,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x40(%rsp)
mov    0x20(%rsp),%rcx
je     1784 <min_dom_set+0x654>
mov    %ebp,%esi
and    $0xfffffffe,%esi
mov    %r12,%rax
shl    $0xb,%rax
lea    (%r10,%rax,1),%rdx
add    $0x4,%rdx
xor    %eax,%eax
jmp    16fd <min_dom_set+0x5cd>
add    $0x2,%rax
cmp    %rax,%rsi
je     1786 <min_dom_set+0x656>
cmpl   $0x0,-0x4(%rdx,%rax,4)
je     1709 <min_dom_set+0x5d9>
addl   $0xffffffff,(%r14,%rax,4)
cmpl   $0x0,(%rdx,%rax,4)
je     16f0 <min_dom_set+0x5c0>
addl   $0xffffffff,0x4(%r14,%rax,4)
jmp    16f0 <min_dom_set+0x5c0>
cmp    %edx,%esi
jge    19f3 <min_dom_set+0x8c3>
shl    $0x2,%r13d
mov    %rbp,%rdi
mov    %r9,%rsi
mov    %r13d,%edx
mov    %r8,%rbx
call   1050 <memcpy@plt>
mov    (%rbx),%eax
mov    %eax,(%r12)
jmp    19f3 <min_dom_set+0x8c3>
lea    0x1(%rdi),%eax
sub    $0x8,%rsp
mov    %rdi,%r12
mov    %eax,0xc(%rsp)
mov    %eax,%edi
mov    %r11,0x30(%rsp)
mov    %r11,%rsi
mov    %r14,%rdx
mov    0x28(%rsp),%rcx
mov    %rbp,%rax
mov    %r9,%rbp
push   %r10
push   %r15
push   %r13
push   %rax
push   0xa8(%rsp)
mov    %r8,%rbx
call   1030 <min_dom_set@plt>
add    $0x30,%rsp
jmp    186b <min_dom_set+0x73b>
xor    %eax,%eax
mov    %rbp,0x38(%rsp)
test   $0x1,%bpl
je     17a6 <min_dom_set+0x676>
mov    %r12,%rdx
shl    $0xb,%rdx
add    %r10,%rdx
cmpl   $0x0,(%rdx,%rax,4)
je     17a6 <min_dom_set+0x676>
addl   $0xffffffff,(%r14,%rax,4)
add    $0x1,%edi
sub    $0x8,%rsp
mov    %edi,0xc(%rsp)
mov    %r11,%rsi
mov    %r14,%rdx
mov    %r11,%rbp
mov    %rcx,%rbx
mov    0x10(%rsp),%r8
mov    %r9,0x18(%rsp)
push   %r10
push   %r15
push   %r13
push   0xa8(%rsp)
push   0xa8(%rsp)
call   1030 <min_dom_set@plt>
add    $0x30,%rsp
cmpb   $0x0,0x18(%rsp)
je     1857 <min_dom_set+0x727>
mov    %rbp,%rsi
cmpq   $0x0,0x40(%rsp)
je     1a02 <min_dom_set+0x8d2>
mov    0x38(%rsp),%r8
mov    %r8d,%edi
and    $0xfffffffe,%edi
mov    %r12,%rax
shl    $0xb,%rax
mov    0xa0(%rsp),%r10
lea    (%r10,%rax,1),%rdx
add    $0x4,%rdx
xor    %eax,%eax
mov    0x10(%rsp),%r9
mov    0x88(%rsp),%r11
mov    %rbx,%rcx
jmp    183d <min_dom_set+0x70d>
add    $0x2,%rax
cmp    %rax,%rdi
je     1a21 <min_dom_set+0x8f1>
cmpl   $0x0,-0x4(%rdx,%rax,4)
je     1849 <min_dom_set+0x719>
addl   $0x1,(%r14,%rax,4)
cmpl   $0x0,(%rdx,%rax,4)
je     1830 <min_dom_set+0x700>
addl   $0x1,0x4(%r14,%rax,4)
jmp    1830 <min_dom_set+0x700>
mov    %rbp,0x28(%rsp)
mov    0x30(%rsp),%r12
mov    0x8(%rsp),%rbx
mov    0x10(%rsp),%rbp
movslq %r12d,%r12
lea    0x0(,%r12,4),%rax
add    %rbp,%rax
mov    %rax,0x38(%rsp)
movl   $0x1,0x0(%rbp,%r12,4)
addl   $0x1,(%rbx)
mov    0x28(%rsp),%rsi
mov    %rbp,%r9
mov    0x88(%rsp),%r11
mov    0xa0(%rsp),%r10
mov    0x20(%rsp),%rcx
mov    0x4(%rsp),%edi
movl   $0x0,(%rsi)
sub    $0x8,%rsp
mov    %r14,%rdx
mov    0x10(%rsp),%rbx
mov    %rsi,%rbp
mov    %rbx,%r8
push   %r10
push   %r15
push   %r13
push   %r11
push   0xa8(%rsp)
call   1030 <min_dom_set@plt>
mov    0xd0(%rsp),%rdi
add    $0x30,%rsp
mov    0x38(%rsp),%rax
movl   $0x0,(%rax)
addl   $0xffffffff,(%rbx)
mov    0x18(%rsp),%ebx
test   %bl,%bl
mov    0x30(%rsp),%r8
je     19f3 <min_dom_set+0x8c3>
mov    %rbp,%rsi
mov    %r13d,%eax
shl    $0xb,%r12
add    %rdi,%r12
xor    %ecx,%ecx
mov    0x20(%rsp),%rbp
jmp    1937 <min_dom_set+0x807>
nopl   0x0(%rax,%rax,1)
addl   $0xffffffff,(%rsi)
mov    0x0(%rbp,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
je     1949 <min_dom_set+0x819>
cmpl   $0x0,(%r12,%rcx,4)
je     192e <min_dom_set+0x7fe>
cmpl   $0x0,0x0(%rbp,%rcx,4)
jne    1920 <min_dom_set+0x7f0>
xor    %edx,%edx
jmp    1927 <min_dom_set+0x7f7>
test   %r8d,%r8d
setne  %cl
xor    $0x1,%bl
or     %cl,%bl
jne    19f3 <min_dom_set+0x8c3>
lea    -0x1(%rax),%rdx
mov    %eax,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    196d <min_dom_set+0x83d>
xor    %edx,%edx
jmp    19b4 <min_dom_set+0x884>
and    $0xfffffffc,%eax
xor    %edx,%edx
mov    %rdi,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x0,(%rsi)
movl   $0x0,0x804(%rsi)
movl   $0x0,0x1008(%rsi)
movl   $0x0,0x180c(%rsi)
add    $0x4,%rdx
add    $0x2010,%rsi
cmp    %rdx,%rax
jne    1980 <min_dom_set+0x850>
test   %rcx,%rcx
je     19f3 <min_dom_set+0x8c3>
mov    %rdx,%rax
shl    $0xb,%rax
lea    (%rax,%rdx,4),%rax
add    %rax,%rdi
mov    %rcx,%rax
shl    $0xb,%rax
lea    (%rax,%rcx,4),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x0,(%rdi,%rcx,1)
add    $0x804,%rcx
cmp    %rcx,%rax
jne    19e0 <min_dom_set+0x8b0>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
mov    0x10(%rsp),%r9
mov    0x88(%rsp),%r11
mov    0xa0(%rsp),%r10
mov    %rbx,%rcx
mov    0x38(%rsp),%r8
test   $0x1,%r8b
je     1a3c <min_dom_set+0x90c>
mov    %r12,%rdx
shl    $0xb,%rdx
add    %r10,%rdx
cmpl   $0x0,(%rdx,%rax,4)
je     1a3c <min_dom_set+0x90c>
addl   $0x1,(%r14,%rax,4)
lea    (%r9,%r12,4),%rdx
movl   $0x1,(%r9,%r12,4)
mov    0x8(%rsp),%rax
addl   $0x1,(%rax)
cmpb   $0x0,0x18(%rsp)
mov    %rdx,0x38(%rsp)
je     18a7 <min_dom_set+0x777>
cmpq   $0x0,0x40(%rsp)
je     1ab1 <min_dom_set+0x981>
mov    %r8d,%edi
and    $0xfffffffe,%edi
mov    %r12,%rax
shl    $0xb,%rax
lea    (%r10,%rax,1),%rdx
add    $0x4,%rdx
xor    %eax,%eax
jmp    1a99 <min_dom_set+0x969>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%rax
cmp    %rax,%rdi
je     1ab3 <min_dom_set+0x983>
cmpl   $0x0,-0x4(%rdx,%rax,4)
je     1aa4 <min_dom_set+0x974>
addl   $0x1,(%rcx,%rax,4)
cmpl   $0x0,(%rdx,%rax,4)
je     1a90 <min_dom_set+0x960>
addl   $0x1,0x4(%rcx,%rax,4)
jmp    1a90 <min_dom_set+0x960>
xor    %eax,%eax
test   $0x1,%r8b
je     1acd <min_dom_set+0x99d>
mov    %r12,%rdx
shl    $0xb,%rdx
add    %r10,%rdx
cmpl   $0x0,(%rdx,%rax,4)
je     1acd <min_dom_set+0x99d>
addl   $0x1,(%rcx,%rax,4)
movl   $0x0,(%rsi)
cmpb   $0x0,0x18(%rsp)
je     1b27 <min_dom_set+0x9f7>
cmpq   $0x0,0x40(%rsp)
je     1b12 <min_dom_set+0x9e2>
mov    %r8d,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
xor    %edi,%edi
jmp    1af9 <min_dom_set+0x9c9>
xchg   %ax,%ax
add    $0x2,%rdi
cmp    %rdi,%rdx
je     1b16 <min_dom_set+0x9e6>
cmpl   $0x0,(%rcx,%rdi,4)
je     1b04 <min_dom_set+0x9d4>
add    $0x1,%eax
mov    %eax,(%rsi)
cmpl   $0x0,0x4(%rcx,%rdi,4)
je     1af0 <min_dom_set+0x9c0>
add    $0x1,%eax
mov    %eax,(%rsi)
jmp    1af0 <min_dom_set+0x9c0>
xor    %eax,%eax
xor    %edi,%edi
test   $0x1,%r8b
je     1b27 <min_dom_set+0x9f7>
cmpl   $0x0,(%rcx,%rdi,4)
je     1b27 <min_dom_set+0x9f7>
add    $0x1,%eax
mov    %eax,(%rsi)
mov    0x4(%rsp),%edi
jmp    18b1 <min_dom_set+0x781>

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

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