#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 evaluate(unsigned char *, int, int);
int apply_bitmask(unsigned char *grid, int size) {
  int x, y;
  unsigned char p;
  int pattern, penalty[8];
  int best_val, best_pattern;
  int bit;
  unsigned char mask[size * size];
  unsigned char eval[size * size];
  for (x = 0; x < size; x++) {
    for (y = 0; y < size; y++) {
      mask[(y * size) + x] = 0x00;
      if (!(grid[(y * size) + x] & 0xf0)) {
        if (((y + x) & 1) == 0) {
          mask[(y * size) + x] += 0x01;
        }
        if ((y & 1) == 0) {
          mask[(y * size) + x] += 0x02;
        }
        if ((x % 3) == 0) {
          mask[(y * size) + x] += 0x04;
        }
        if (((y + x) % 3) == 0) {
          mask[(y * size) + x] += 0x08;
        }
        if ((((y / 2) + (x / 3)) & 1) == 0) {
          mask[(y * size) + x] += 0x10;
        }
        if ((((y * x) & 1) + ((y * x) % 3)) == 0) {
          mask[(y * size) + x] += 0x20;
        }
        if (((((y * x) & 1) + ((y * x) % 3)) & 1) == 0) {
          mask[(y * size) + x] += 0x40;
        }
        if (((((y + x) & 1) + ((y * x) % 3)) & 1) == 0) {
          mask[(y * size) + x] += 0x80;
        }
      }
    }
  }
  for (x = 0; x < size; x++) {
    for (y = 0; y < size; y++) {
      if (grid[(y * size) + x] & 0x01) {
        p = 0xff;
      } else {
        p = 0x00;
      }
      eval[(y * size) + x] = mask[(y * size) + x] ^ p;
    }
  }
  for (pattern = 0; pattern < 8; pattern++) {
    penalty[pattern] = evaluate(eval, size, pattern);
  }
  best_pattern = 0;
  best_val = penalty[0];
  for (pattern = 1; pattern < 8; pattern++) {
    if (penalty[pattern] < best_val) {
      best_pattern = pattern;
      best_val = penalty[pattern];
    }
  }
  for (x = 0; x < size; x++) {
    for (y = 0; y < size; y++) {
      bit = 0;
      switch (best_pattern) {
      case 0:
        if (mask[(y * size) + x] & 0x01) {
          bit = 1;
        }
        break;
      case 1:
        if (mask[(y * size) + x] & 0x02) {
          bit = 1;
        }
        break;
      case 2:
        if (mask[(y * size) + x] & 0x04) {
          bit = 1;
        }
        break;
      case 3:
        if (mask[(y * size) + x] & 0x08) {
          bit = 1;
        }
        break;
      case 4:
        if (mask[(y * size) + x] & 0x10) {
          bit = 1;
        }
        break;
      case 5:
        if (mask[(y * size) + x] & 0x20) {
          bit = 1;
        }
        break;
      case 6:
        if (mask[(y * size) + x] & 0x40) {
          bit = 1;
        }
        break;
      case 7:
        if (mask[(y * size) + x] & 0x80) {
          bit = 1;
        }
        break;
      }
      if (bit == 1) {
        if (grid[(y * size) + x] & 0x01) {
          grid[(y * size) + x] = 0x00;
        } else {
          grid[(y * size) + x] = 0x01;
        }
      }
    }
  }
  return best_pattern;
}


x86 assembly (clang, -O0):
<apply_bitmask>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
imul   %eax,%eax
mov    %rsp,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x78(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
mov    -0xc(%rbp),%eax
imul   %eax,%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x70(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13d8 <apply_bitmask+0x2c8>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13c5 <apply_bitmask+0x2b5>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xf0,%eax
cmp    $0x0,%eax
jne    13b2 <apply_bitmask+0x2a2>
mov    -0x14(%rbp),%eax
add    -0x10(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    11f8 <apply_bitmask+0xe8>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
add    $0x1,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    1222 <apply_bitmask+0x112>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
add    $0x2,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1251 <apply_bitmask+0x141>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
add    $0x4,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1283 <apply_bitmask+0x173>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
add    $0x8,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x7c(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x7c(%rbp),%eax
add    %ecx,%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    12ca <apply_bitmask+0x1ba>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
add    $0x10,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
imul   -0x10(%rbp),%eax
and    $0x1,%eax
mov    %eax,-0x80(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0x80(%rbp),%eax
add    %edx,%eax
cmp    $0x0,%eax
jne    130f <apply_bitmask+0x1ff>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
add    $0x20,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
imul   -0x10(%rbp),%eax
and    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0x84(%rbp),%eax
add    %edx,%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    135d <apply_bitmask+0x24d>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
add    $0x40,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    -0x10(%rbp),%eax
and    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0x88(%rbp),%eax
add    %edx,%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    13ad <apply_bitmask+0x29d>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
add    $0x80,%edx
mov    %dl,(%rax,%rcx,1)
jmp    13b2 <apply_bitmask+0x2a2>
jmp    13b7 <apply_bitmask+0x2a7>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1187 <apply_bitmask+0x77>
jmp    13ca <apply_bitmask+0x2ba>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1174 <apply_bitmask+0x64>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    147e <apply_bitmask+0x36e>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    146b <apply_bitmask+0x35b>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1428 <apply_bitmask+0x318>
movb   $0xff,-0x15(%rbp)
jmp    142c <apply_bitmask+0x31c>
movb   $0x0,-0x15(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    -0x10(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
movzbl -0x15(%rbp),%edx
xor    %edx,%ecx
mov    %cl,%dl
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13f2 <apply_bitmask+0x2e2>
jmp    1470 <apply_bitmask+0x360>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13df <apply_bitmask+0x2cf>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x8,-0x1c(%rbp)
jge    14b6 <apply_bitmask+0x3a6>
mov    -0x70(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x1c(%rbp),%edx
call   1030 <evaluate@plt>
mov    %eax,%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1485 <apply_bitmask+0x375>
movl   $0x0,-0x48(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x1c(%rbp)
cmpl   $0x8,-0x1c(%rbp)
jge    1509 <apply_bitmask+0x3f9>
movslq -0x1c(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
cmp    -0x44(%rbp),%eax
jge    14f6 <apply_bitmask+0x3e6>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x48(%rbp)
movslq -0x1c(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
mov    %eax,-0x44(%rbp)
jmp    14fb <apply_bitmask+0x3eb>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14ca <apply_bitmask+0x3ba>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1750 <apply_bitmask+0x640>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    173d <apply_bitmask+0x62d>
movl   $0x0,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %rax,-0x90(%rbp)
sub    $0x7,%rax
ja     16cb <apply_bitmask+0x5bb>
mov    -0x90(%rbp),%rax
lea    0xaa8(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1589 <apply_bitmask+0x479>
movl   $0x1,-0x4c(%rbp)
jmp    16cb <apply_bitmask+0x5bb>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     15b6 <apply_bitmask+0x4a6>
movl   $0x1,-0x4c(%rbp)
jmp    16cb <apply_bitmask+0x5bb>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     15e3 <apply_bitmask+0x4d3>
movl   $0x1,-0x4c(%rbp)
jmp    16cb <apply_bitmask+0x5bb>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     1610 <apply_bitmask+0x500>
movl   $0x1,-0x4c(%rbp)
jmp    16cb <apply_bitmask+0x5bb>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     163d <apply_bitmask+0x52d>
movl   $0x1,-0x4c(%rbp)
jmp    16cb <apply_bitmask+0x5bb>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x20,%eax
cmp    $0x0,%eax
je     166a <apply_bitmask+0x55a>
movl   $0x1,-0x4c(%rbp)
jmp    16cb <apply_bitmask+0x5bb>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     1697 <apply_bitmask+0x587>
movl   $0x1,-0x4c(%rbp)
jmp    16cb <apply_bitmask+0x5bb>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     16c6 <apply_bitmask+0x5b6>
movl   $0x1,-0x4c(%rbp)
jmp    16cb <apply_bitmask+0x5bb>
cmpl   $0x1,-0x4c(%rbp)
jne    172a <apply_bitmask+0x61a>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1710 <apply_bitmask+0x600>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1725 <apply_bitmask+0x615>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x1,(%rax,%rcx,1)
jmp    172a <apply_bitmask+0x61a>
jmp    172f <apply_bitmask+0x61f>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1523 <apply_bitmask+0x413>
jmp    1742 <apply_bitmask+0x632>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1510 <apply_bitmask+0x400>
mov    -0x48(%rbp),%eax
mov    -0x58(%rbp),%rcx
mov    %rcx,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<apply_bitmask>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %esi,%r13d
mov    %rdi,%r14
mov    %esi,%eax
imul   %eax,%eax
mov    %rsp,%r11
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r11
mov    %r11,%rsp
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
mov    %esi,%esi
test   %r13d,%r13d
mov    %r11,-0x68(%rbp)
mov    %rsi,-0x50(%rbp)
jle    13a0 <apply_bitmask+0x290>
mov    %r12,-0x48(%rbp)
mov    %r13d,-0x5c(%rbp)
mov    $0x1,%ebx
xor    %eax,%eax
mov    %r14,-0x70(%rbp)
jmp    1188 <apply_bitmask+0x78>
xchg   %ax,%ax
add    $0x1,%rax
add    $0x1,%ebx
cmp    %rsi,%rax
mov    -0x70(%rbp),%r14
mov    -0x68(%rbp),%r11
je     12f1 <apply_bitmask+0x1e1>
mov    %rax,-0x38(%rbp)
mov    %eax,%ecx
mov    $0xaaaaaaab,%eax
imul   %rax,%rcx
shr    $0x21,%rcx
mov    %rcx,-0x58(%rbp)
lea    (%rcx,%rcx,2),%eax
mov    -0x38(%rbp),%rcx
sub    %eax,%ecx
mov    %ecx,-0x30(%rbp)
mov    -0x38(%rbp),%rax
mov    %r14,%r10
mov    %r11,%rdx
mov    %eax,%r14d
mov    %eax,%r13d
xor    %edi,%edi
xor    %r15d,%r15d
mov    %ebx,-0x2c(%rbp)
jmp    11e8 <apply_bitmask+0xd8>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r15
add    %eax,%edi
add    %ebx,%r13d
add    $0x1,%r14d
add    %rsi,%rdx
add    %rsi,%r10
cmp    %r15,%rsi
je     1170 <apply_bitmask+0x60>
movb   $0x0,(%rdx,%rax,1)
cmpb   $0xf,(%r10,%rax,1)
ja     11d0 <apply_bitmask+0xc0>
mov    %edi,%r12d
and    $0x1,%r12d
add    %edi,%r12d
mov    %edi,%ecx
mov    $0xaaaaaaab,%esi
imul   %rsi,%rcx
shr    $0x21,%rcx
lea    (%rcx,%rcx,2),%ecx
mov    %ecx,-0x3c(%rbp)
sub    %ecx,%r12d
mov    %r14d,%ecx
imul   %rsi,%rcx
shr    $0x21,%rcx
lea    (%rcx,%rcx,2),%r8d
neg    %r8d
lea    (%rax,%r15,1),%r9
mov    %r9d,%ecx
not    %cl
and    $0x1,%cl
lea    0x2(%rcx),%esi
test   $0x1,%r15b
movzbl %cl,%ecx
movzbl %sil,%esi
cmovne %ecx,%esi
mov    %r9d,%ecx
and    %r15d,%ecx
lea    0x4(%rsi),%r11d
cmpl   $0x0,-0x30(%rbp)
movzbl %r11b,%eax
cmovne %esi,%eax
mov    %eax,%ebx
or     $0x8,%bl
add    %r9d,%r8d
movzbl %bl,%esi
cmovne %eax,%esi
mov    %r15d,%r11d
shr    %r11d
add    -0x58(%rbp),%r11d
lea    0x10(%rsi),%eax
and    $0x1,%r11d
movzbl %al,%r9d
cmovne %esi,%r9d
test   $0x1,%cl
je     1295 <apply_bitmask+0x185>
cmpl   $0x0,-0x30(%rbp)
je     1295 <apply_bitmask+0x185>
test   %r8d,%r8d
je     1295 <apply_bitmask+0x185>
test   %r11d,%r11d
jne    129d <apply_bitmask+0x18d>
mov    -0x38(%rbp),%rax
mov    %r9b,(%rdx,%rax,1)
mov    %r13d,%ecx
sub    -0x3c(%rbp),%ecx
test   %r12d,%r12d
je     12c4 <apply_bitmask+0x1b4>
test   $0x1,%r12b
mov    -0x50(%rbp),%rsi
mov    -0x2c(%rbp),%ebx
mov    -0x38(%rbp),%rax
je     12d3 <apply_bitmask+0x1c3>
test   $0x1,%cl
jne    11d0 <apply_bitmask+0xc0>
jmp    12e4 <apply_bitmask+0x1d4>
add    $0x20,%r9b
mov    -0x50(%rbp),%rsi
mov    -0x2c(%rbp),%ebx
mov    -0x38(%rbp),%rax
add    $0x40,%r9b
mov    %r9b,(%rdx,%rax,1)
test   $0x1,%cl
jne    11d0 <apply_bitmask+0xc0>
xor    $0x80,%r9b
mov    %r9b,(%rdx,%rax,1)
jmp    11d0 <apply_bitmask+0xc0>
mov    -0x5c(%rbp),%r13d
test   %r13d,%r13d
mov    -0x48(%rbp),%r12
jle    13a0 <apply_bitmask+0x290>
mov    %esi,%r9d
and    $0xfffffffe,%r9d
lea    (%r12,%rsi,1),%r10
lea    (%rsi,%rsi,1),%r15
lea    (%r11,%rsi,1),%rdx
lea    (%r14,%rsi,1),%rdi
xor    %r8d,%r8d
jmp    132d <apply_bitmask+0x21d>
xchg   %ax,%ax
add    $0x1,%r8
cmp    %rsi,%r8
mov    -0x48(%rbp),%r12
je     13a0 <apply_bitmask+0x290>
cmp    $0x1,%esi
jne    1340 <apply_bitmask+0x230>
xor    %ebx,%ebx
jmp    137e <apply_bitmask+0x26e>
cs nopw 0x0(%rax,%rax,1)
mov    %r8,%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%r14,%rax,1),%ecx
and    $0x1,%cl
neg    %cl
xor    (%r11,%rax,1),%cl
mov    %cl,(%r12,%rax,1)
movzbl (%rdi,%rax,1),%ecx
and    $0x1,%cl
neg    %cl
xor    (%rdx,%rax,1),%cl
mov    %cl,(%r10,%rax,1)
add    $0x2,%rbx
add    %r15,%rax
cmp    %rbx,%r9
jne    1350 <apply_bitmask+0x240>
test   $0x1,%sil
je     1320 <apply_bitmask+0x210>
imul   %rsi,%rbx
add    %r8,%rbx
mov    (%r14,%rbx,1),%al
and    $0x1,%al
neg    %al
xor    (%r11,%rbx,1),%al
mov    -0x48(%rbp),%rcx
mov    %al,(%rcx,%rbx,1)
jmp    1320 <apply_bitmask+0x210>
mov    %r12,%rdi
mov    %r13d,%esi
xor    %edx,%edx
call   1030 <evaluate@plt>
mov    %eax,%ebx
mov    %r12,%rdi
mov    %r13d,%esi
mov    $0x1,%edx
call   1030 <evaluate@plt>
mov    %eax,%r15d
mov    %r12,%rdi
mov    %r13d,%esi
mov    $0x2,%edx
call   1030 <evaluate@plt>
mov    %eax,-0x3c(%rbp)
mov    %r12,%rdi
mov    %r13d,%esi
mov    $0x3,%edx
call   1030 <evaluate@plt>
mov    %eax,-0x30(%rbp)
mov    %r12,%rdi
mov    %r13d,%esi
mov    $0x4,%edx
call   1030 <evaluate@plt>
mov    %eax,-0x38(%rbp)
mov    %r12,%rdi
mov    %r13d,%esi
mov    $0x5,%edx
call   1030 <evaluate@plt>
mov    %eax,-0x58(%rbp)
mov    %r12,%rdi
mov    %r13d,%esi
mov    $0x6,%edx
call   1030 <evaluate@plt>
mov    %eax,-0x2c(%rbp)
mov    %r12,%rdi
mov    %r13d,%esi
mov    $0x7,%edx
call   1030 <evaluate@plt>
xor    %ecx,%ecx
cmp    %ebx,%r15d
cmovl  %r15d,%ebx
setl   %cl
mov    -0x3c(%rbp),%edx
cmp    %ebx,%edx
cmovl  %edx,%ebx
mov    $0x2,%edx
cmovl  %edx,%ecx
mov    -0x30(%rbp),%edx
cmp    %ebx,%edx
cmovl  %edx,%ebx
mov    $0x3,%edx
cmovl  %edx,%ecx
mov    -0x38(%rbp),%edx
cmp    %ebx,%edx
cmovl  %edx,%ebx
mov    $0x4,%edx
cmovl  %edx,%ecx
mov    -0x58(%rbp),%edx
cmp    %ebx,%edx
cmovl  %edx,%ebx
mov    $0x5,%edx
cmovl  %edx,%ecx
mov    -0x68(%rbp),%r10
mov    -0x2c(%rbp),%edx
cmp    %ebx,%edx
cmovl  %edx,%ebx
mov    $0x6,%edx
cmovl  %edx,%ecx
mov    -0x50(%rbp),%r11
cmp    %ebx,%eax
mov    $0x7,%eax
cmovl  %eax,%ecx
test   %r13d,%r13d
jle    1560 <apply_bitmask+0x450>
xor    %r8d,%r8d
lea    0xb4e(%rip),%r9
jmp    14cd <apply_bitmask+0x3bd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8
cmp    %r11,%r8
je     1560 <apply_bitmask+0x450>
mov    %r11,%rsi
mov    %r8,%rdi
xor    %ebx,%ebx
jmp    1505 <apply_bitmask+0x3f5>
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rax
imul   %r11,%rax
add    %r8,%rax
movzbl (%r14,%rax,1),%edx
not    %dl
and    $0x1,%dl
mov    %dl,(%r14,%rax,1)
add    $0x1,%rbx
add    %r11,%rdi
add    $0xffffffffffffffff,%rsi
je     14c0 <apply_bitmask+0x3b0>
cmp    $0x7,%ecx
ja     14f8 <apply_bitmask+0x3e8>
mov    %ecx,%eax
movslq (%r9,%rax,4),%rax
add    %r9,%rax
jmp    *%rax
testb  $0x1,(%r10,%rdi,1)
jne    14e0 <apply_bitmask+0x3d0>
jmp    14f8 <apply_bitmask+0x3e8>
testb  $0x2,(%r10,%rdi,1)
jne    14e0 <apply_bitmask+0x3d0>
jmp    14f8 <apply_bitmask+0x3e8>
testb  $0x4,(%r10,%rdi,1)
jne    14e0 <apply_bitmask+0x3d0>
jmp    14f8 <apply_bitmask+0x3e8>
testb  $0x8,(%r10,%rdi,1)
jne    14e0 <apply_bitmask+0x3d0>
jmp    14f8 <apply_bitmask+0x3e8>
testb  $0x10,(%r10,%rdi,1)
jne    14e0 <apply_bitmask+0x3d0>
jmp    14f8 <apply_bitmask+0x3e8>
testb  $0x20,(%r10,%rdi,1)
jne    14e0 <apply_bitmask+0x3d0>
jmp    14f8 <apply_bitmask+0x3e8>
testb  $0x40,(%r10,%rdi,1)
jne    14e0 <apply_bitmask+0x3d0>
jmp    14f8 <apply_bitmask+0x3e8>
cmpb   $0x0,(%r10,%rdi,1)
mov    %rdi,%rax
jns    14f8 <apply_bitmask+0x3e8>
jmp    14ea <apply_bitmask+0x3da>
mov    %ecx,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @apply_bitmask(i8* nocapture %0, i32 %1) {
%3 = mul nsw i32 %1, %1
%4 = zext i32 %3 to i64
%5 = alloca i8, i64 %4
%6 = alloca i8, i64 %4
%7 = icmp sgt i32 %1, 0
br i1 %7, label %8, label %93
8: ; preds = %2
%9 = zext i32 %1 to i64
%10 = zext i32 %1 to i64
br label %11
11: ; preds = %88, %8
%12 = phi i64 [ 0, %8 ], [ %89, %88 ]
%13 = trunc i64 %12 to i32
%14 = urem i32 %13, 3
%15 = icmp eq i32 %14, 0
%16 = udiv i32 %13, 3
br label %25
17: ; preds = %88
br i1 %7, label %18, label %93
18: ; preds = %17
%19 = zext i32 %1 to i64
%20 = zext i32 %1 to i64
%21 = and i64 %10, 1
%22 = icmp eq i32 %1, 1
%23 = and i64 %10, 4294967294
%24 = icmp eq i64 %21, 0
br label %91
25: ; preds = %11, %85
%26 = phi i64 [ 0, %11 ], [ %86, %85 ]
%27 = mul nsw i64 %26, %9
%28 = add nuw nsw i64 %27, %12
%29 = getelementptr inbounds i8, i8* %5, i64 %28
store i8 0, i8* %29
%30 = getelementptr inbounds i8, i8* %0, i64 %28
%31 = load i8, i8* %30
%32 = icmp ult i8 %31, 16
br i1 %32, label %33, label %85
33: ; preds = %25
%34 = add nuw nsw i64 %26, %12
%35 = trunc i64 %34 to i32
%36 = trunc i64 %34 to i8
%37 = and i8 %36, 1
%38 = xor i8 %37, 1
%39 = trunc i64 %26 to i32
%40 = and i32 %39, 1
%41 = icmp eq i32 %40, 0
%42 = or i8 %38, 2
%43 = select i1 %41, i8 %42, i8 %38
%44 = and i64 %34, %26
%45 = and i64 %44, 1
%46 = icmp eq i64 %45, 0
%47 = or i8 %43, 4
%48 = select i1 %15, i8 %47, i8 %43
%49 = or i1 %46, %15
%50 = urem i32 %35, 3
%51 = icmp eq i32 %50, 0
%52 = or i8 %48, 8
%53 = select i1 %51, i8 %52, i8 %48
%54 = or i1 %49, %51
%55 = lshr i32 %39, 1
%56 = add nuw nsw i32 %55, %16
%57 = and i32 %56, 1
%58 = icmp eq i32 %57, 0
%59 = add i8 %53, 16
%60 = select i1 %58, i8 %59, i8 %53
%61 = or i1 %54, %58
br i1 %61, label %62, label %63
62: ; preds = %33
store i8 %60, i8* %29
br label %63
63: ; preds = %33, %62
%64 = mul nuw nsw i64 %26, %12
%65 = trunc i64 %64 to i32
%66 = and i32 %65, 1
%67 = urem i32 %65, 3
%68 = add nuw nsw i32 %66, %67
%69 = icmp eq i32 %68, 0
br i1 %69, label %70, label %72
70: ; preds = %63
%71 = add i8 %60, 32
br label %75
72: ; preds = %63
%73 = and i32 %68, 1
%74 = icmp eq i32 %73, 0
br i1 %74, label %75, label %78
75: ; preds = %70, %72
%76 = phi i8 [ %71, %70 ], [ %60, %72 ]
%77 = add i8 %76, 64
store i8 %77, i8* %29
br label %78
78: ; preds = %75, %72
%79 = phi i8 [ %77, %75 ], [ %60, %72 ]
%80 = add nuw i32 %67, %35
%81 = and i32 %80, 1
%82 = icmp eq i32 %81, 0
br i1 %82, label %83, label %85
83: ; preds = %78
%84 = xor i8 %79, -128
store i8 %84, i8* %29
br label %85
85: ; preds = %25, %83, %78
%86 = add nuw nsw i64 %26, 1
%87 = icmp eq i64 %86, %10
br i1 %87, label %88, label %25
88: ; preds = %85
%89 = add nuw nsw i64 %12, 1
%90 = icmp eq i64 %89, %10
br i1 %90, label %17, label %11
91: ; preds = %162, %18
%92 = phi i64 [ 0, %18 ], [ %163, %162 ]
br i1 %22, label %149, label %122
93: ; preds = %162, %2, %17
%94 = call i32 @evaluate(i8* %6, i32 %1, i32 0)
%95 = call i32 @evaluate(i8* %6, i32 %1, i32 1)
%96 = call i32 @evaluate(i8* %6, i32 %1, i32 2)
%97 = call i32 @evaluate(i8* %6, i32 %1, i32 3)
%98 = call i32 @evaluate(i8* %6, i32 %1, i32 4)
%99 = call i32 @evaluate(i8* %6, i32 %1, i32 5)
%100 = call i32 @evaluate(i8* %6, i32 %1, i32 6)
%101 = call i32 @evaluate(i8* %6, i32 %1, i32 7)
%102 = icmp slt i32 %95, %94
%103 = select i1 %102, i32 %95, i32 %94
%104 = zext i1 %102 to i32
%105 = icmp slt i32 %96, %103
%106 = select i1 %105, i32 %96, i32 %103
%107 = select i1 %105, i32 2, i32 %104
%108 = icmp slt i32 %97, %106
%109 = select i1 %108, i32 %97, i32 %106
%110 = select i1 %108, i32 3, i32 %107
%111 = icmp slt i32 %98, %109
%112 = select i1 %111, i32 %98, i32 %109
%113 = select i1 %111, i32 4, i32 %110
%114 = icmp slt i32 %99, %112
%115 = select i1 %114, i32 %99, i32 %112
%116 = select i1 %114, i32 5, i32 %113
%117 = icmp slt i32 %100, %115
%118 = select i1 %117, i32 %100, i32 %115
%119 = select i1 %117, i32 6, i32 %116
%120 = icmp slt i32 %101, %118
%121 = select i1 %120, i32 7, i32 %119
br i1 %7, label %165, label %239
122: ; preds = %91, %122
%123 = phi i64 [ %146, %122 ], [ 0, %91 ]
%124 = phi i64 [ %147, %122 ], [ 0, %91 ]
%125 = mul nsw i64 %123, %19
%126 = add nuw nsw i64 %125, %92
%127 = getelementptr inbounds i8, i8* %0, i64 %126
%128 = load i8, i8* %127
%129 = and i8 %128, 1
%130 = sub nsw i8 0, %129
%131 = getelementptr inbounds i8, i8* %5, i64 %126
%132 = load i8, i8* %131
%133 = xor i8 %132, %130
%134 = getelementptr inbounds i8, i8* %6, i64 %126
store i8 %133, i8* %134
%135 = or i64 %123, 1
%136 = mul nsw i64 %135, %19
%137 = add nuw nsw i64 %136, %92
%138 = getelementptr inbounds i8, i8* %0, i64 %137
%139 = load i8, i8* %138
%140 = and i8 %139, 1
%141 = sub nsw i8 0, %140
%142 = getelementptr inbounds i8, i8* %5, i64 %137
%143 = load i8, i8* %142
%144 = xor i8 %143, %141
%145 = getelementptr inbounds i8, i8* %6, i64 %137
store i8 %144, i8* %145
%146 = add nuw nsw i64 %123, 2
%147 = add i64 %124, 2
%148 = icmp eq i64 %147, %23
br i1 %148, label %149, label %122
149: ; preds = %122, %91
%150 = phi i64 [ 0, %91 ], [ %146, %122 ]
br i1 %24, label %162, label %151
151: ; preds = %149
%152 = mul nsw i64 %150, %19
%153 = add nuw nsw i64 %152, %92
%154 = getelementptr inbounds i8, i8* %0, i64 %153
%155 = load i8, i8* %154
%156 = and i8 %155, 1
%157 = sub nsw i8 0, %156
%158 = getelementptr inbounds i8, i8* %5, i64 %153
%159 = load i8, i8* %158
%160 = xor i8 %159, %157
%161 = getelementptr inbounds i8, i8* %6, i64 %153
store i8 %160, i8* %161
br label %162
162: ; preds = %149, %151
%163 = add nuw nsw i64 %92, 1
%164 = icmp eq i64 %163, %20
br i1 %164, label %93, label %91
165: ; preds = %93
%166 = zext i32 %1 to i64
%167 = zext i32 %1 to i64
br label %168
168: ; preds = %236, %165
%169 = phi i64 [ 0, %165 ], [ %237, %236 ]
br label %170
170: ; preds = %168, %233
%171 = phi i64 [ 0, %168 ], [ %234, %233 ]
switch i32 %121, label %233 [
i32 0, label %172
i32 1, label %179
i32 2, label %186
i32 3, label %193
i32 4, label %200
i32 5, label %207
i32 6, label %214
i32 7, label %221
]
172: ; preds = %170
%173 = mul nsw i64 %171, %166
%174 = add nuw nsw i64 %173, %169
%175 = getelementptr inbounds i8, i8* %5, i64 %174
%176 = load i8, i8* %175
%177 = and i8 %176, 1
%178 = icmp eq i8 %177, 0
br i1 %178, label %233, label %227
179: ; preds = %170
%180 = mul nsw i64 %171, %166
%181 = add nuw nsw i64 %180, %169
%182 = getelementptr inbounds i8, i8* %5, i64 %181
%183 = load i8, i8* %182
%184 = and i8 %183, 2
%185 = icmp eq i8 %184, 0
br i1 %185, label %233, label %227
186: ; preds = %170
%187 = mul nsw i64 %171, %166
%188 = add nuw nsw i64 %187, %169
%189 = getelementptr inbounds i8, i8* %5, i64 %188
%190 = load i8, i8* %189
%191 = and i8 %190, 4
%192 = icmp eq i8 %191, 0
br i1 %192, label %233, label %227
193: ; preds = %170
%194 = mul nsw i64 %171, %166
%195 = add nuw nsw i64 %194, %169
%196 = getelementptr inbounds i8, i8* %5, i64 %195
%197 = load i8, i8* %196
%198 = and i8 %197, 8
%199 = icmp eq i8 %198, 0
br i1 %199, label %233, label %227
200: ; preds = %170
%201 = mul nsw i64 %171, %166
%202 = add nuw nsw i64 %201, %169
%203 = getelementptr inbounds i8, i8* %5, i64 %202
%204 = load i8, i8* %203
%205 = and i8 %204, 16
%206 = icmp eq i8 %205, 0
br i1 %206, label %233, label %227
207: ; preds = %170
%208 = mul nsw i64 %171, %166
%209 = add nuw nsw i64 %208, %169
%210 = getelementptr inbounds i8, i8* %5, i64 %209
%211 = load i8, i8* %210
%212 = and i8 %211, 32
%213 = icmp eq i8 %212, 0
br i1 %213, label %233, label %227
214: ; preds = %170
%215 = mul nsw i64 %171, %166
%216 = add nuw nsw i64 %215, %169
%217 = getelementptr inbounds i8, i8* %5, i64 %216
%218 = load i8, i8* %217
%219 = and i8 %218, 64
%220 = icmp eq i8 %219, 0
br i1 %220, label %233, label %227
221: ; preds = %170
%222 = mul nsw i64 %171, %166
%223 = add nuw nsw i64 %222, %169
%224 = getelementptr inbounds i8, i8* %5, i64 %223
%225 = load i8, i8* %224
%226 = icmp slt i8 %225, 0
br i1 %226, label %227, label %233
227: ; preds = %214, %207, %200, %193, %186, %179, %172, %221
%228 = phi i64 [ %216, %214 ], [ %209, %207 ], [ %202, %200 ], [ %195, %193 ], [ %188, %186 ], [ %181, %179 ], [ %174, %172 ], [ %223, %221 ]
%229 = getelementptr inbounds i8, i8* %0, i64 %228
%230 = load i8, i8* %229
%231 = and i8 %230, 1
%232 = xor i8 %231, 1
store i8 %232, i8* %229
br label %233
233: ; preds = %227, %214, %207, %200, %193, %186, %179, %172, %170, %221
%234 = add nuw nsw i64 %171, 1
%235 = icmp eq i64 %234, %167
br i1 %235, label %236, label %170
236: ; preds = %233
%237 = add nuw nsw i64 %169, 1
%238 = icmp eq i64 %237, %167
br i1 %238, label %239, label %168
239: ; preds = %236, %93
ret i32 %121
}