#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 Kit_TruthWordNum(int);
void Kit_TruthAndPhase(unsigned *pOut, unsigned *pIn0, unsigned *pIn1,
                       int nVars, int fCompl0, int fCompl1) {
  int w;
  if (fCompl0 && fCompl1) {
    for (w = Kit_TruthWordNum(nVars) - 1; w >= 0; w--)
      pOut[w] = ~(pIn0[w] | pIn1[w]);
  } else if (fCompl0 && !fCompl1) {
    for (w = Kit_TruthWordNum(nVars) - 1; w >= 0; w--)
      pOut[w] = ~pIn0[w] & pIn1[w];
  } else if (!fCompl0 && fCompl1) {
    for (w = Kit_TruthWordNum(nVars) - 1; w >= 0; w--)
      pOut[w] = pIn0[w] & ~pIn1[w];
  } else {
    for (w = Kit_TruthWordNum(nVars) - 1; w >= 0; w--)
      pOut[w] = pIn0[w] & pIn1[w];
  }
}


x86 assembly (clang, -O0):
<Kit_TruthAndPhase>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
cmpl   $0x0,-0x20(%rbp)
je     1192 <Kit_TruthAndPhase+0x82>
cmpl   $0x0,-0x24(%rbp)
je     1192 <Kit_TruthAndPhase+0x82>
mov    -0x1c(%rbp),%edi
call   1030 <Kit_TruthWordNum@plt>
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     118d <Kit_TruthAndPhase+0x7d>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
or     (%rax,%rcx,4),%edx
xor    $0xffffffff,%edx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1151 <Kit_TruthAndPhase+0x41>
jmp    12b0 <Kit_TruthAndPhase+0x1a0>
cmpl   $0x0,-0x20(%rbp)
je     11f5 <Kit_TruthAndPhase+0xe5>
cmpl   $0x0,-0x24(%rbp)
jne    11f5 <Kit_TruthAndPhase+0xe5>
mov    -0x1c(%rbp),%edi
call   1030 <Kit_TruthWordNum@plt>
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     11f0 <Kit_TruthAndPhase+0xe0>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
xor    $0xffffffff,%edx
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
and    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    11b4 <Kit_TruthAndPhase+0xa4>
jmp    12ab <Kit_TruthAndPhase+0x19b>
cmpl   $0x0,-0x20(%rbp)
jne    125a <Kit_TruthAndPhase+0x14a>
cmpl   $0x0,-0x24(%rbp)
je     125a <Kit_TruthAndPhase+0x14a>
mov    -0x1c(%rbp),%edi
call   1030 <Kit_TruthWordNum@plt>
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1255 <Kit_TruthAndPhase+0x145>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
xor    $0xffffffff,%eax
and    %eax,%edx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1217 <Kit_TruthAndPhase+0x107>
jmp    12a6 <Kit_TruthAndPhase+0x196>
mov    -0x1c(%rbp),%edi
call   1030 <Kit_TruthWordNum@plt>
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     12a1 <Kit_TruthAndPhase+0x191>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
and    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1268 <Kit_TruthAndPhase+0x158>
jmp    12a6 <Kit_TruthAndPhase+0x196>
jmp    12ab <Kit_TruthAndPhase+0x19b>
jmp    12b0 <Kit_TruthAndPhase+0x1a0>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Kit_TruthAndPhase>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %r9d,%ebp
mov    %r8d,%ebx
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%r12
test   %r8d,%r8d
je     1180 <Kit_TruthAndPhase+0x70>
test   %ebp,%ebp
je     1180 <Kit_TruthAndPhase+0x70>
mov    %ecx,%edi
call   1030 <Kit_TruthWordNum@plt>
test   %eax,%eax
jle    1349 <Kit_TruthAndPhase+0x239>
mov    %eax,%ecx
cmp    $0x8,%eax
jae    1230 <Kit_TruthAndPhase+0x120>
mov    %rcx,%rax
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0x2(%rax),%ecx
mov    (%r14,%rcx,4),%edx
or     (%r15,%rcx,4),%edx
not    %edx
mov    %edx,(%r12,%rcx,4)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     1160 <Kit_TruthAndPhase+0x50>
jmp    1349 <Kit_TruthAndPhase+0x239>
test   %ebx,%ebx
je     11d0 <Kit_TruthAndPhase+0xc0>
test   %ebp,%ebp
jne    11d0 <Kit_TruthAndPhase+0xc0>
mov    %ecx,%edi
call   1030 <Kit_TruthWordNum@plt>
test   %eax,%eax
jle    1349 <Kit_TruthAndPhase+0x239>
mov    %eax,%ecx
cmp    $0x8,%eax
jae    1352 <Kit_TruthAndPhase+0x242>
mov    %rcx,%rax
add    $0x1,%rax
nopl   0x0(%rax)
lea    -0x2(%rax),%ecx
mov    (%r15,%rcx,4),%edx
not    %edx
and    (%r14,%rcx,4),%edx
mov    %edx,(%r12,%rcx,4)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     11b0 <Kit_TruthAndPhase+0xa0>
jmp    1349 <Kit_TruthAndPhase+0x239>
mov    %ecx,%edi
call   1030 <Kit_TruthWordNum@plt>
test   %ebx,%ebx
jne    1315 <Kit_TruthAndPhase+0x205>
test   %ebp,%ebp
je     1315 <Kit_TruthAndPhase+0x205>
test   %eax,%eax
jle    1349 <Kit_TruthAndPhase+0x239>
mov    %eax,%ecx
cmp    $0x8,%eax
jae    1430 <Kit_TruthAndPhase+0x320>
mov    %rcx,%rax
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0x2(%rax),%ecx
mov    (%r14,%rcx,4),%edx
not    %edx
and    (%r15,%rcx,4),%edx
mov    %edx,(%r12,%rcx,4)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     1210 <Kit_TruthAndPhase+0x100>
jmp    1349 <Kit_TruthAndPhase+0x239>
lea    -0x1(%rcx),%rdx
add    $0xffffffff,%eax
cmp    %edx,%eax
jb     114a <Kit_TruthAndPhase+0x3a>
mov    %rdx,%rsi
shr    $0x20,%rsi
jne    114a <Kit_TruthAndPhase+0x3a>
mov    %rcx,%rsi
neg    %rsi
add    %rax,%rsi
add    $0x1,%rsi
lea    (%r12,%rsi,4),%rdi
lea    0x4(%r12,%rax,4),%rbp
lea    (%r15,%rsi,4),%r8
lea    (%r15,%rax,4),%rbx
add    $0x4,%rbx
lea    (%r14,%rsi,4),%rsi
lea    (%r14,%rax,4),%rax
add    $0x4,%rax
cmp    %rbx,%rdi
setb   %r9b
cmp    %rbp,%r8
setb   %bl
cmp    %rax,%rdi
setb   %al
cmp    %rbp,%rsi
setb   %sil
test   %bl,%r9b
jne    114a <Kit_TruthAndPhase+0x3a>
and    %sil,%al
jne    114a <Kit_TruthAndPhase+0x3a>
mov    %ecx,%esi
and    $0xfffffff8,%esi
mov    %ecx,%eax
and    $0x7,%eax
pcmpeqd %xmm0,%xmm0
mov    %rsi,%rdi
nopw   0x0(%rax,%rax,1)
mov    %edx,%ebp
shl    $0x2,%rbp
movdqu -0x1c(%r15,%rbp,1),%xmm1
movdqu -0xc(%r15,%rbp,1),%xmm2
movdqu -0x1c(%r14,%rbp,1),%xmm3
por    %xmm1,%xmm3
movdqu -0xc(%r14,%rbp,1),%xmm1
por    %xmm2,%xmm1
pxor   %xmm0,%xmm1
pxor   %xmm0,%xmm3
movdqu %xmm1,-0xc(%r12,%rbp,1)
movdqu %xmm3,-0x1c(%r12,%rbp,1)
add    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffff8,%rdi
jne    12c0 <Kit_TruthAndPhase+0x1b0>
cmp    %rcx,%rsi
jne    114d <Kit_TruthAndPhase+0x3d>
jmp    1349 <Kit_TruthAndPhase+0x239>
test   %eax,%eax
jle    1349 <Kit_TruthAndPhase+0x239>
mov    %eax,%ecx
cmp    $0x8,%eax
jae    1510 <Kit_TruthAndPhase+0x400>
add    $0x1,%rcx
nopl   0x0(%rax,%rax,1)
lea    -0x2(%rcx),%eax
mov    (%r14,%rax,4),%edx
and    (%r15,%rax,4),%edx
mov    %edx,(%r12,%rax,4)
add    $0xffffffffffffffff,%rcx
cmp    $0x1,%rcx
ja     1330 <Kit_TruthAndPhase+0x220>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%rcx),%rdx
add    $0xffffffff,%eax
cmp    %edx,%eax
jb     11a2 <Kit_TruthAndPhase+0x92>
mov    %rdx,%rsi
shr    $0x20,%rsi
jne    11a2 <Kit_TruthAndPhase+0x92>
mov    %rcx,%rsi
neg    %rsi
add    %rax,%rsi
add    $0x1,%rsi
lea    (%r12,%rsi,4),%rdi
lea    0x4(%r12,%rax,4),%rbp
lea    (%r15,%rsi,4),%r8
lea    (%r15,%rax,4),%rbx
add    $0x4,%rbx
lea    (%r14,%rsi,4),%rsi
lea    (%r14,%rax,4),%rax
add    $0x4,%rax
cmp    %rbx,%rdi
setb   %r9b
cmp    %rbp,%r8
setb   %bl
cmp    %rax,%rdi
setb   %al
cmp    %rbp,%rsi
setb   %sil
test   %bl,%r9b
jne    11a2 <Kit_TruthAndPhase+0x92>
and    %sil,%al
jne    11a2 <Kit_TruthAndPhase+0x92>
mov    %ecx,%esi
and    $0xfffffff8,%esi
mov    %ecx,%eax
and    $0x7,%eax
mov    %rsi,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %edx,%ebp
shl    $0x2,%rbp
movdqu -0x1c(%r15,%rbp,1),%xmm0
movdqu -0xc(%r15,%rbp,1),%xmm1
movdqu -0x1c(%r14,%rbp,1),%xmm2
pandn  %xmm2,%xmm0
movdqu -0xc(%r14,%rbp,1),%xmm2
pandn  %xmm2,%xmm1
movdqu %xmm1,-0xc(%r12,%rbp,1)
movdqu %xmm0,-0x1c(%r12,%rbp,1)
add    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffff8,%rdi
jne    13e0 <Kit_TruthAndPhase+0x2d0>
cmp    %rcx,%rsi
jne    11a5 <Kit_TruthAndPhase+0x95>
jmp    1349 <Kit_TruthAndPhase+0x239>
lea    -0x1(%rcx),%rdx
add    $0xffffffff,%eax
cmp    %edx,%eax
jb     11fa <Kit_TruthAndPhase+0xea>
mov    %rdx,%rsi
shr    $0x20,%rsi
jne    11fa <Kit_TruthAndPhase+0xea>
mov    %rcx,%rsi
neg    %rsi
add    %rax,%rsi
add    $0x1,%rsi
lea    (%r12,%rsi,4),%rdi
lea    0x4(%r12,%rax,4),%rbp
lea    (%r15,%rsi,4),%r8
lea    (%r15,%rax,4),%rbx
add    $0x4,%rbx
lea    (%r14,%rsi,4),%rsi
lea    (%r14,%rax,4),%rax
add    $0x4,%rax
cmp    %rbx,%rdi
setb   %r9b
cmp    %rbp,%r8
setb   %bl
cmp    %rax,%rdi
setb   %al
cmp    %rbp,%rsi
setb   %sil
test   %bl,%r9b
jne    11fa <Kit_TruthAndPhase+0xea>
and    %sil,%al
jne    11fa <Kit_TruthAndPhase+0xea>
mov    %ecx,%esi
and    $0xfffffff8,%esi
mov    %ecx,%eax
and    $0x7,%eax
mov    %rsi,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %edx,%ebp
shl    $0x2,%rbp
movdqu -0x1c(%r15,%rbp,1),%xmm0
movdqu -0xc(%r15,%rbp,1),%xmm1
movdqu -0x1c(%r14,%rbp,1),%xmm2
pandn  %xmm0,%xmm2
movdqu -0xc(%r14,%rbp,1),%xmm0
pandn  %xmm1,%xmm0
movdqu %xmm0,-0xc(%r12,%rbp,1)
movdqu %xmm2,-0x1c(%r12,%rbp,1)
add    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffff8,%rdi
jne    14c0 <Kit_TruthAndPhase+0x3b0>
cmp    %rcx,%rsi
jne    11fd <Kit_TruthAndPhase+0xed>
jmp    1349 <Kit_TruthAndPhase+0x239>
lea    -0x1(%rcx),%rdx
add    $0xffffffff,%eax
cmp    %edx,%eax
jb     1324 <Kit_TruthAndPhase+0x214>
mov    %rdx,%rsi
shr    $0x20,%rsi
jne    1324 <Kit_TruthAndPhase+0x214>
mov    %rcx,%rsi
neg    %rsi
add    %rax,%rsi
add    $0x1,%rsi
lea    (%r12,%rsi,4),%rdi
lea    0x4(%r12,%rax,4),%rbp
lea    (%r15,%rsi,4),%r8
lea    (%r15,%rax,4),%rbx
add    $0x4,%rbx
lea    (%r14,%rsi,4),%rsi
lea    (%r14,%rax,4),%rax
add    $0x4,%rax
cmp    %rbx,%rdi
setb   %r9b
cmp    %rbp,%r8
setb   %bl
cmp    %rax,%rdi
setb   %al
cmp    %rbp,%rsi
setb   %sil
test   %bl,%r9b
jne    1324 <Kit_TruthAndPhase+0x214>
and    %sil,%al
jne    1324 <Kit_TruthAndPhase+0x214>
mov    %ecx,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     1638 <Kit_TruthAndPhase+0x528>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0xfffffff7,%ebx
add    %rcx,%rbx
mov    $0x1,%esi
mov    %edx,%eax
shl    $0x2,%rax
movups -0x1c(%r15,%rax,1),%xmm0
movups -0xc(%r15,%rax,1),%xmm1
movups -0x1c(%r14,%rax,1),%xmm2
andps  %xmm0,%xmm2
movups -0xc(%r14,%rax,1),%xmm0
andps  %xmm1,%xmm0
movups %xmm0,-0xc(%r12,%rax,1)
movups %xmm2,-0x1c(%r12,%rax,1)
mov    %ebx,%eax
shl    $0x2,%rax
movdqu -0x1c(%r15,%rax,1),%xmm0
movdqu -0xc(%r15,%rax,1),%xmm1
movdqu -0x1c(%r14,%rax,1),%xmm2
pand   %xmm0,%xmm2
movdqu -0xc(%r14,%rax,1),%xmm0
pand   %xmm1,%xmm0
movdqu %xmm0,-0xc(%r12,%rax,1)
movdqu %xmm2,-0x1c(%r12,%rax,1)
add    $0x10,%rsi
add    $0xfffffffffffffff0,%rbx
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffffe,%rdi
jne    15b9 <Kit_TruthAndPhase+0x4a9>
neg    %rsi
jmp    163f <Kit_TruthAndPhase+0x52f>
mov    $0xffffffffffffffff,%rsi
test   $0x1,%bpl
je     1679 <Kit_TruthAndPhase+0x569>
add    %ecx,%esi
movdqu -0x1c(%r15,%rsi,4),%xmm0
movdqu -0xc(%r15,%rsi,4),%xmm1
movdqu -0x1c(%r14,%rsi,4),%xmm2
pand   %xmm0,%xmm2
movdqu -0xc(%r14,%rsi,4),%xmm0
pand   %xmm1,%xmm0
movdqu %xmm0,-0xc(%r12,%rsi,4)
movdqu %xmm2,-0x1c(%r12,%rsi,4)
cmp    %rcx,%r8
je     1349 <Kit_TruthAndPhase+0x239>
and    $0x7,%ecx
jmp    1324 <Kit_TruthAndPhase+0x214>

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

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