#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*/ changebit(int *, int, int);
scalar_t__ isboundary(int);
scalar_t__ isempty(int);
scalar_t__ isfluid(int);
void init_cell(int ***Flag, int i, int j, int k) {
  int *flag = 0, *flagc = 0;
  flagc = &Flag[i][j][k];
  flag = &Flag[i + 1][j][k];
  if (isempty(*flag)) {
    changebit(flagc, 10, 0);
    changebit(flagc, 11, 1);
  } else if (isfluid(*flag)) {
    changebit(flagc, 10, 1);
    changebit(flagc, 11, 0);
  } else if (isboundary(*flag)) {
    changebit(flagc, 10, 1);
    changebit(flagc, 11, 1);
  }
  flag = &Flag[i - 1][j][k];
  if (isempty(*flag)) {
    changebit(flagc, 8, 0);
    changebit(flagc, 9, 1);
  } else if (isfluid(*flag)) {
    changebit(flagc, 8, 1);
    changebit(flagc, 9, 0);
  } else if (isboundary(*flag)) {
    changebit(flagc, 8, 1);
    changebit(flagc, 9, 1);
  }
  flag = &Flag[i][j + 1][k];
  if (isempty(*flag)) {
    changebit(flagc, 6, 0);
    changebit(flagc, 7, 1);
  } else if (isfluid(*flag)) {
    changebit(flagc, 6, 1);
    changebit(flagc, 7, 0);
  } else if (isboundary(*flag)) {
    changebit(flagc, 6, 1);
    changebit(flagc, 7, 1);
  }
  flag = &Flag[i][j - 1][k];
  if (isempty(*flag)) {
    changebit(flagc, 4, 0);
    changebit(flagc, 5, 1);
  } else if (isfluid(*flag)) {
    changebit(flagc, 4, 1);
    changebit(flagc, 5, 0);
  } else if (isboundary(*flag)) {
    changebit(flagc, 4, 1);
    changebit(flagc, 5, 1);
  }
  flag = &Flag[i][j][k - 1];
  if (isempty(*flag)) {
    changebit(flagc, 2, 0);
    changebit(flagc, 3, 1);
  } else if (isfluid(*flag)) {
    changebit(flagc, 2, 1);
    changebit(flagc, 3, 0);
  } else if (isboundary(*flag)) {
    changebit(flagc, 2, 1);
    changebit(flagc, 3, 1);
  }
  flag = &Flag[i][j][k + 1];
  if (isempty(*flag)) {
    changebit(flagc, 0, 0);
    changebit(flagc, 1, 1);
  } else if (isfluid(*flag)) {
    changebit(flagc, 0, 1);
    changebit(flagc, 1, 0);
  } else if (isboundary(*flag)) {
    changebit(flagc, 0, 1);
    changebit(flagc, 1, 1);
  }
}


x86 assembly (clang, -O0):
<init_cell>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1060 <isempty@plt>
cmp    $0x0,%rax
je     11ed <init_cell+0xad>
mov    -0x28(%rbp),%rdi
mov    $0xa,%esi
xor    %edx,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0xb,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
jmp    126f <init_cell+0x12f>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     122a <init_cell+0xea>
mov    -0x28(%rbp),%rdi
mov    $0xa,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0xb,%esi
xor    %edx,%edx
call   1050 <changebit@plt>
jmp    126a <init_cell+0x12a>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1040 <isboundary@plt>
cmp    $0x0,%rax
je     1265 <init_cell+0x125>
mov    -0x28(%rbp),%rdi
mov    $0xa,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0xb,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
jmp    126a <init_cell+0x12a>
jmp    126f <init_cell+0x12f>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1060 <isempty@plt>
cmp    $0x0,%rax
je     12d4 <init_cell+0x194>
mov    -0x28(%rbp),%rdi
mov    $0x8,%esi
xor    %edx,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x9,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
jmp    1356 <init_cell+0x216>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     1311 <init_cell+0x1d1>
mov    -0x28(%rbp),%rdi
mov    $0x8,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x9,%esi
xor    %edx,%edx
call   1050 <changebit@plt>
jmp    1351 <init_cell+0x211>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1040 <isboundary@plt>
cmp    $0x0,%rax
je     134c <init_cell+0x20c>
mov    -0x28(%rbp),%rdi
mov    $0x8,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x9,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
jmp    1351 <init_cell+0x211>
jmp    1356 <init_cell+0x216>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1060 <isempty@plt>
cmp    $0x0,%rax
je     13bb <init_cell+0x27b>
mov    -0x28(%rbp),%rdi
mov    $0x6,%esi
xor    %edx,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x7,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
jmp    143d <init_cell+0x2fd>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     13f8 <init_cell+0x2b8>
mov    -0x28(%rbp),%rdi
mov    $0x6,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x7,%esi
xor    %edx,%edx
call   1050 <changebit@plt>
jmp    1438 <init_cell+0x2f8>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1040 <isboundary@plt>
cmp    $0x0,%rax
je     1433 <init_cell+0x2f3>
mov    -0x28(%rbp),%rdi
mov    $0x6,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x7,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
jmp    1438 <init_cell+0x2f8>
jmp    143d <init_cell+0x2fd>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1060 <isempty@plt>
cmp    $0x0,%rax
je     14a2 <init_cell+0x362>
mov    -0x28(%rbp),%rdi
mov    $0x4,%esi
xor    %edx,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x5,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
jmp    1524 <init_cell+0x3e4>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     14df <init_cell+0x39f>
mov    -0x28(%rbp),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x5,%esi
xor    %edx,%edx
call   1050 <changebit@plt>
jmp    151f <init_cell+0x3df>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1040 <isboundary@plt>
cmp    $0x0,%rax
je     151a <init_cell+0x3da>
mov    -0x28(%rbp),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x5,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
jmp    151f <init_cell+0x3df>
jmp    1524 <init_cell+0x3e4>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1060 <isempty@plt>
cmp    $0x0,%rax
je     1589 <init_cell+0x449>
mov    -0x28(%rbp),%rdi
mov    $0x2,%esi
xor    %edx,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x3,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
jmp    160b <init_cell+0x4cb>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     15c6 <init_cell+0x486>
mov    -0x28(%rbp),%rdi
mov    $0x2,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x3,%esi
xor    %edx,%edx
call   1050 <changebit@plt>
jmp    1606 <init_cell+0x4c6>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1040 <isboundary@plt>
cmp    $0x0,%rax
je     1601 <init_cell+0x4c1>
mov    -0x28(%rbp),%rdi
mov    $0x2,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x3,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
jmp    1606 <init_cell+0x4c6>
jmp    160b <init_cell+0x4cb>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1060 <isempty@plt>
cmp    $0x0,%rax
je     166a <init_cell+0x52a>
mov    -0x28(%rbp),%rdi
xor    %edx,%edx
mov    %edx,%esi
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%edx
mov    %edx,%esi
call   1050 <changebit@plt>
jmp    16e3 <init_cell+0x5a3>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1030 <isfluid@plt>
cmp    $0x0,%rax
je     16a4 <init_cell+0x564>
mov    -0x28(%rbp),%rdi
xor    %esi,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%esi
xor    %edx,%edx
call   1050 <changebit@plt>
jmp    16de <init_cell+0x59e>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1040 <isboundary@plt>
cmp    $0x0,%rax
je     16d9 <init_cell+0x599>
mov    -0x28(%rbp),%rdi
xor    %esi,%esi
mov    $0x1,%edx
call   1050 <changebit@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%edx
mov    %edx,%esi
call   1050 <changebit@plt>
jmp    16de <init_cell+0x59e>
jmp    16e3 <init_cell+0x5a3>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<init_cell>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r14
movslq %esi,%r12
movslq %edx,%r13
movslq %ecx,%r15
lea    0x0(,%r15,4),%rbx
mov    (%rdi,%r12,8),%rax
mov    0x8(%rdi,%r12,8),%rcx
add    (%rax,%r13,8),%rbx
mov    (%rcx,%r13,8),%rbp
mov    0x0(%rbp,%r15,4),%edi
call   1060 <isempty@plt>
test   %rax,%rax
je     1188 <init_cell+0x48>
mov    $0x1,%ebp
xor    %edx,%edx
jmp    11b9 <init_cell+0x79>
mov    0x0(%rbp,%r15,4),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
je     11a0 <init_cell+0x60>
xor    %ebp,%ebp
mov    $0x1,%edx
jmp    11b9 <init_cell+0x79>
mov    0x0(%rbp,%r15,4),%edi
call   1040 <isboundary@plt>
mov    $0x1,%edx
mov    $0x1,%ebp
test   %rax,%rax
je     11d5 <init_cell+0x95>
mov    %rbx,%rdi
mov    $0xa,%esi
call   1050 <changebit@plt>
mov    %rbx,%rdi
mov    $0xb,%esi
mov    %ebp,%edx
call   1050 <changebit@plt>
mov    -0x8(%r14,%r12,8),%rax
mov    (%rax,%r13,8),%rbp
mov    0x0(%rbp,%r15,4),%edi
call   1060 <isempty@plt>
test   %rax,%rax
je     11f6 <init_cell+0xb6>
mov    $0x1,%ebp
xor    %edx,%edx
jmp    1227 <init_cell+0xe7>
mov    0x0(%rbp,%r15,4),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
je     120e <init_cell+0xce>
xor    %ebp,%ebp
mov    $0x1,%edx
jmp    1227 <init_cell+0xe7>
mov    0x0(%rbp,%r15,4),%edi
call   1040 <isboundary@plt>
mov    $0x1,%edx
mov    $0x1,%ebp
test   %rax,%rax
je     1243 <init_cell+0x103>
mov    %rbx,%rdi
mov    $0x8,%esi
call   1050 <changebit@plt>
mov    %rbx,%rdi
mov    $0x9,%esi
mov    %ebp,%edx
call   1050 <changebit@plt>
mov    (%r14,%r12,8),%rax
mov    0x8(%rax,%r13,8),%rbp
mov    0x0(%rbp,%r15,4),%edi
call   1060 <isempty@plt>
test   %rax,%rax
je     1264 <init_cell+0x124>
mov    $0x1,%ebp
xor    %edx,%edx
jmp    1295 <init_cell+0x155>
mov    0x0(%rbp,%r15,4),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
je     127c <init_cell+0x13c>
xor    %ebp,%ebp
mov    $0x1,%edx
jmp    1295 <init_cell+0x155>
mov    0x0(%rbp,%r15,4),%edi
call   1040 <isboundary@plt>
mov    $0x1,%edx
mov    $0x1,%ebp
test   %rax,%rax
je     12b1 <init_cell+0x171>
mov    %rbx,%rdi
mov    $0x6,%esi
call   1050 <changebit@plt>
mov    %rbx,%rdi
mov    $0x7,%esi
mov    %ebp,%edx
call   1050 <changebit@plt>
mov    (%r14,%r12,8),%rax
mov    -0x8(%rax,%r13,8),%rbp
mov    0x0(%rbp,%r15,4),%edi
call   1060 <isempty@plt>
test   %rax,%rax
je     12d2 <init_cell+0x192>
mov    $0x1,%ebp
xor    %edx,%edx
jmp    1303 <init_cell+0x1c3>
mov    0x0(%rbp,%r15,4),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
je     12ea <init_cell+0x1aa>
xor    %ebp,%ebp
mov    $0x1,%edx
jmp    1303 <init_cell+0x1c3>
mov    0x0(%rbp,%r15,4),%edi
call   1040 <isboundary@plt>
mov    $0x1,%edx
mov    $0x1,%ebp
test   %rax,%rax
je     131f <init_cell+0x1df>
mov    %rbx,%rdi
mov    $0x4,%esi
call   1050 <changebit@plt>
mov    %rbx,%rdi
mov    $0x5,%esi
mov    %ebp,%edx
call   1050 <changebit@plt>
mov    (%r14,%r12,8),%rax
mov    (%rax,%r13,8),%rbp
mov    -0x4(%rbp,%r15,4),%edi
call   1060 <isempty@plt>
test   %rax,%rax
je     133f <init_cell+0x1ff>
mov    $0x1,%ebp
xor    %edx,%edx
jmp    1380 <init_cell+0x240>
mov    %r12,(%rsp)
lea    -0x1(%r15),%r12
mov    0x0(%rbp,%r12,4),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
je     1363 <init_cell+0x223>
xor    %ebp,%ebp
mov    $0x1,%edx
mov    (%rsp),%r12
jmp    1380 <init_cell+0x240>
mov    0x0(%rbp,%r12,4),%edi
call   1040 <isboundary@plt>
mov    $0x1,%edx
mov    $0x1,%ebp
test   %rax,%rax
mov    (%rsp),%r12
je     139c <init_cell+0x25c>
mov    %rbx,%rdi
mov    $0x2,%esi
call   1050 <changebit@plt>
mov    %rbx,%rdi
mov    $0x3,%esi
mov    %ebp,%edx
call   1050 <changebit@plt>
mov    (%r14,%r12,8),%rax
mov    (%rax,%r13,8),%rbp
mov    0x4(%rbp,%r15,4),%edi
call   1060 <isempty@plt>
test   %rax,%rax
je     13bc <init_cell+0x27c>
mov    $0x1,%ebp
xor    %edx,%edx
jmp    13f1 <init_cell+0x2b1>
add    $0x1,%r15
mov    0x0(%rbp,%r15,4),%edi
call   1030 <isfluid@plt>
test   %rax,%rax
je     13d8 <init_cell+0x298>
xor    %ebp,%ebp
mov    $0x1,%edx
jmp    13f1 <init_cell+0x2b1>
mov    0x0(%rbp,%r15,4),%edi
call   1040 <isboundary@plt>
mov    $0x1,%edx
mov    $0x1,%ebp
test   %rax,%rax
je     1418 <init_cell+0x2d8>
mov    %rbx,%rdi
xor    %esi,%esi
call   1050 <changebit@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %ebp,%edx
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <changebit@plt>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @init_cell(i32*** %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i32***
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i32*
store i32*** %0, i32**** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
store i32* null, i32** %9
store i32* null, i32** %10
%11 = load i32***, i32**** %5
%12 = load i32, i32* %6
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds i32**, i32*** %11, i64 %13
%15 = load i32**, i32*** %14
%16 = load i32, i32* %7
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i32*, i32** %15, i64 %17
%19 = load i32*, i32** %18
%20 = load i32, i32* %8
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i32, i32* %19, i64 %21
store i32* %22, i32** %10
%23 = load i32***, i32**** %5
%24 = load i32, i32* %6
%25 = add nsw i32 %24, 1
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i32**, i32*** %23, i64 %26
%28 = load i32**, i32*** %27
%29 = load i32, i32* %7
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i32*, i32** %28, i64 %30
%32 = load i32*, i32** %31
%33 = load i32, i32* %8
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %32, i64 %34
store i32* %35, i32** %9
%36 = load i32*, i32** %9
%37 = load i32, i32* %36
%38 = call i64 @isempty(i32 %37)
%39 = icmp ne i64 %38, 0
br i1 %39, label %40, label %45
40: ; preds = %4
%41 = load i32*, i32** %10
%42 = call i32 @changebit(i32* %41, i32 10, i32 0)
%43 = load i32*, i32** %10
%44 = call i32 @changebit(i32* %43, i32 11, i32 1)
br label %67
45: ; preds = %4
%46 = load i32*, i32** %9
%47 = load i32, i32* %46
%48 = call i64 @isfluid(i32 %47)
%49 = icmp ne i64 %48, 0
br i1 %49, label %50, label %55
50: ; preds = %45
%51 = load i32*, i32** %10
%52 = call i32 @changebit(i32* %51, i32 10, i32 1)
%53 = load i32*, i32** %10
%54 = call i32 @changebit(i32* %53, i32 11, i32 0)
br label %66
55: ; preds = %45
%56 = load i32*, i32** %9
%57 = load i32, i32* %56
%58 = call i64 @isboundary(i32 %57)
%59 = icmp ne i64 %58, 0
br i1 %59, label %60, label %65
60: ; preds = %55
%61 = load i32*, i32** %10
%62 = call i32 @changebit(i32* %61, i32 10, i32 1)
%63 = load i32*, i32** %10
%64 = call i32 @changebit(i32* %63, i32 11, i32 1)
br label %65
65: ; preds = %60, %55
br label %66
66: ; preds = %65, %50
br label %67
67: ; preds = %66, %40
%68 = load i32***, i32**** %5
%69 = load i32, i32* %6
%70 = sub nsw i32 %69, 1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i32**, i32*** %68, i64 %71
%73 = load i32**, i32*** %72
%74 = load i32, i32* %7
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i32*, i32** %73, i64 %75
%77 = load i32*, i32** %76
%78 = load i32, i32* %8
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %77, i64 %79
store i32* %80, i32** %9
%81 = load i32*, i32** %9
%82 = load i32, i32* %81
%83 = call i64 @isempty(i32 %82)
%84 = icmp ne i64 %83, 0
br i1 %84, label %85, label %90
85: ; preds = %67
%86 = load i32*, i32** %10
%87 = call i32 @changebit(i32* %86, i32 8, i32 0)
%88 = load i32*, i32** %10
%89 = call i32 @changebit(i32* %88, i32 9, i32 1)
br label %112
90: ; preds = %67
%91 = load i32*, i32** %9
%92 = load i32, i32* %91
%93 = call i64 @isfluid(i32 %92)
%94 = icmp ne i64 %93, 0
br i1 %94, label %95, label %100
95: ; preds = %90
%96 = load i32*, i32** %10
%97 = call i32 @changebit(i32* %96, i32 8, i32 1)
%98 = load i32*, i32** %10
%99 = call i32 @changebit(i32* %98, i32 9, i32 0)
br label %111
100: ; preds = %90
%101 = load i32*, i32** %9
%102 = load i32, i32* %101
%103 = call i64 @isboundary(i32 %102)
%104 = icmp ne i64 %103, 0
br i1 %104, label %105, label %110
105: ; preds = %100
%106 = load i32*, i32** %10
%107 = call i32 @changebit(i32* %106, i32 8, i32 1)
%108 = load i32*, i32** %10
%109 = call i32 @changebit(i32* %108, i32 9, i32 1)
br label %110
110: ; preds = %105, %100
br label %111
111: ; preds = %110, %95
br label %112
112: ; preds = %111, %85
%113 = load i32***, i32**** %5
%114 = load i32, i32* %6
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i32**, i32*** %113, i64 %115
%117 = load i32**, i32*** %116
%118 = load i32, i32* %7
%119 = add nsw i32 %118, 1
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i32*, i32** %117, i64 %120
%122 = load i32*, i32** %121
%123 = load i32, i32* %8
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i32, i32* %122, i64 %124
store i32* %125, i32** %9
%126 = load i32*, i32** %9
%127 = load i32, i32* %126
%128 = call i64 @isempty(i32 %127)
%129 = icmp ne i64 %128, 0
br i1 %129, label %130, label %135
130: ; preds = %112
%131 = load i32*, i32** %10
%132 = call i32 @changebit(i32* %131, i32 6, i32 0)
%133 = load i32*, i32** %10
%134 = call i32 @changebit(i32* %133, i32 7, i32 1)
br label %157
135: ; preds = %112
%136 = load i32*, i32** %9
%137 = load i32, i32* %136
%138 = call i64 @isfluid(i32 %137)
%139 = icmp ne i64 %138, 0
br i1 %139, label %140, label %145
140: ; preds = %135
%141 = load i32*, i32** %10
%142 = call i32 @changebit(i32* %141, i32 6, i32 1)
%143 = load i32*, i32** %10
%144 = call i32 @changebit(i32* %143, i32 7, i32 0)
br label %156
145: ; preds = %135
%146 = load i32*, i32** %9
%147 = load i32, i32* %146
%148 = call i64 @isboundary(i32 %147)
%149 = icmp ne i64 %148, 0
br i1 %149, label %150, label %155
150: ; preds = %145
%151 = load i32*, i32** %10
%152 = call i32 @changebit(i32* %151, i32 6, i32 1)
%153 = load i32*, i32** %10
%154 = call i32 @changebit(i32* %153, i32 7, i32 1)
br label %155
155: ; preds = %150, %145
br label %156
156: ; preds = %155, %140
br label %157
157: ; preds = %156, %130
%158 = load i32***, i32**** %5
%159 = load i32, i32* %6
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i32**, i32*** %158, i64 %160
%162 = load i32**, i32*** %161
%163 = load i32, i32* %7
%164 = sub nsw i32 %163, 1
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds i32*, i32** %162, i64 %165
%167 = load i32*, i32** %166
%168 = load i32, i32* %8
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i32, i32* %167, i64 %169
store i32* %170, i32** %9
%171 = load i32*, i32** %9
%172 = load i32, i32* %171
%173 = call i64 @isempty(i32 %172)
%174 = icmp ne i64 %173, 0
br i1 %174, label %175, label %180
175: ; preds = %157
%176 = load i32*, i32** %10
%177 = call i32 @changebit(i32* %176, i32 4, i32 0)
%178 = load i32*, i32** %10
%179 = call i32 @changebit(i32* %178, i32 5, i32 1)
br label %202
180: ; preds = %157
%181 = load i32*, i32** %9
%182 = load i32, i32* %181
%183 = call i64 @isfluid(i32 %182)
%184 = icmp ne i64 %183, 0
br i1 %184, label %185, label %190
185: ; preds = %180
%186 = load i32*, i32** %10
%187 = call i32 @changebit(i32* %186, i32 4, i32 1)
%188 = load i32*, i32** %10
%189 = call i32 @changebit(i32* %188, i32 5, i32 0)
br label %201
190: ; preds = %180
%191 = load i32*, i32** %9
%192 = load i32, i32* %191
%193 = call i64 @isboundary(i32 %192)
%194 = icmp ne i64 %193, 0
br i1 %194, label %195, label %200
195: ; preds = %190
%196 = load i32*, i32** %10
%197 = call i32 @changebit(i32* %196, i32 4, i32 1)
%198 = load i32*, i32** %10
%199 = call i32 @changebit(i32* %198, i32 5, i32 1)
br label %200
200: ; preds = %195, %190
br label %201
201: ; preds = %200, %185
br label %202
202: ; preds = %201, %175
%203 = load i32***, i32**** %5
%204 = load i32, i32* %6
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i32**, i32*** %203, i64 %205
%207 = load i32**, i32*** %206
%208 = load i32, i32* %7
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds i32*, i32** %207, i64 %209
%211 = load i32*, i32** %210
%212 = load i32, i32* %8
%213 = sub nsw i32 %212, 1
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds i32, i32* %211, i64 %214
store i32* %215, i32** %9
%216 = load i32*, i32** %9
%217 = load i32, i32* %216
%218 = call i64 @isempty(i32 %217)
%219 = icmp ne i64 %218, 0
br i1 %219, label %220, label %225
220: ; preds = %202
%221 = load i32*, i32** %10
%222 = call i32 @changebit(i32* %221, i32 2, i32 0)
%223 = load i32*, i32** %10
%224 = call i32 @changebit(i32* %223, i32 3, i32 1)
br label %247
225: ; preds = %202
%226 = load i32*, i32** %9
%227 = load i32, i32* %226
%228 = call i64 @isfluid(i32 %227)
%229 = icmp ne i64 %228, 0
br i1 %229, label %230, label %235
230: ; preds = %225
%231 = load i32*, i32** %10
%232 = call i32 @changebit(i32* %231, i32 2, i32 1)
%233 = load i32*, i32** %10
%234 = call i32 @changebit(i32* %233, i32 3, i32 0)
br label %246
235: ; preds = %225
%236 = load i32*, i32** %9
%237 = load i32, i32* %236
%238 = call i64 @isboundary(i32 %237)
%239 = icmp ne i64 %238, 0
br i1 %239, label %240, label %245
240: ; preds = %235
%241 = load i32*, i32** %10
%242 = call i32 @changebit(i32* %241, i32 2, i32 1)
%243 = load i32*, i32** %10
%244 = call i32 @changebit(i32* %243, i32 3, i32 1)
br label %245
245: ; preds = %240, %235
br label %246
246: ; preds = %245, %230
br label %247
247: ; preds = %246, %220
%248 = load i32***, i32**** %5
%249 = load i32, i32* %6
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds i32**, i32*** %248, i64 %250
%252 = load i32**, i32*** %251
%253 = load i32, i32* %7
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i32*, i32** %252, i64 %254
%256 = load i32*, i32** %255
%257 = load i32, i32* %8
%258 = add nsw i32 %257, 1
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds i32, i32* %256, i64 %259
store i32* %260, i32** %9
%261 = load i32*, i32** %9
%262 = load i32, i32* %261
%263 = call i64 @isempty(i32 %262)
%264 = icmp ne i64 %263, 0
br i1 %264, label %265, label %270
265: ; preds = %247
%266 = load i32*, i32** %10
%267 = call i32 @changebit(i32* %266, i32 0, i32 0)
%268 = load i32*, i32** %10
%269 = call i32 @changebit(i32* %268, i32 1, i32 1)
br label %292
270: ; preds = %247
%271 = load i32*, i32** %9
%272 = load i32, i32* %271
%273 = call i64 @isfluid(i32 %272)
%274 = icmp ne i64 %273, 0
br i1 %274, label %275, label %280
275: ; preds = %270
%276 = load i32*, i32** %10
%277 = call i32 @changebit(i32* %276, i32 0, i32 1)
%278 = load i32*, i32** %10
%279 = call i32 @changebit(i32* %278, i32 1, i32 0)
br label %291
280: ; preds = %270
%281 = load i32*, i32** %9
%282 = load i32, i32* %281
%283 = call i64 @isboundary(i32 %282)
%284 = icmp ne i64 %283, 0
br i1 %284, label %285, label %290
285: ; preds = %280
%286 = load i32*, i32** %10
%287 = call i32 @changebit(i32* %286, i32 0, i32 1)
%288 = load i32*, i32** %10
%289 = call i32 @changebit(i32* %288, i32 1, i32 1)
br label %290
290: ; preds = %285, %280
br label %291
291: ; preds = %290, %275
br label %292
292: ; preds = %291, %265
ret void
}

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