#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 */
typedef int /*<<< orphan*/ err;

/* Variables and functions */
int /*<<< orphan*/ memset(int *, int /*<<< orphan*/, int);
unsigned int match_colors_block(const unsigned char *block,
                                unsigned char color[4][3], int dither) {
  unsigned int mask = 0;
  int dirb = color[0][0] - color[1][0];
  int dirg = color[0][1] - color[1][1];
  int dirr = color[0][2] - color[1][2];
  int dots[16], stops[4];
  int c0pt, halfpt, c3pt, dot;
  int i;
  for (i = 0; i < 16; ++i)
    dots[i] =
        block[4 * i] * dirb + block[4 * i + 1] * dirg + block[4 * i + 2] * dirr;
  for (i = 0; i < 4; ++i)
    stops[i] = color[i][0] * dirb + color[i][1] * dirg + color[i][2] * dirr;
  c0pt = (stops[1] + stops[3]) >> 1;
  halfpt = (stops[3] + stops[2]) >> 1;
  c3pt = (stops[2] + stops[0]) >> 1;
  if (!dither) {
    for (i = 15; i >= 0; --i) {
      mask <<= 2;
      dot = dots[i];
      if (dot < halfpt)
        mask |= (dot < c0pt) ? 1 : 3;
      else
        mask |= (dot < c3pt) ? 2 : 0;
    }
  } else {
    int err[8], *ep1 = err, *ep2 = err + 4, *tmp;
    int *dp = dots, y, lmask, step;
    c0pt <<= 4;
    halfpt <<= 4;
    c3pt <<= 4;
    memset(err, 0, sizeof(err));
    for (y = 0; y < 4; ++y) {
      dot = (dp[0] << 4) + (3 * ep2[1] + 5 * ep2[0]);
      if (dot < halfpt)
        step = (dot < c0pt) ? 1 : 3;
      else
        step = (dot < c3pt) ? 2 : 0;
      ep1[0] = dp[0] - stops[step];
      lmask = step;
      dot = (dp[1] << 4) + (7 * ep1[0] + 3 * ep2[2] + 5 * ep2[1] + ep2[0]);
      if (dot < halfpt)
        step = (dot < c0pt) ? 1 : 3;
      else
        step = (dot < c3pt) ? 2 : 0;
      ep1[1] = dp[1] - stops[step];
      lmask |= step << 2;
      dot = (dp[2] << 4) + (7 * ep1[1] + 3 * ep2[3] + 5 * ep2[2] + ep2[1]);
      if (dot < halfpt)
        step = (dot < c0pt) ? 1 : 3;
      else
        step = (dot < c3pt) ? 2 : 0;
      ep1[2] = dp[2] - stops[step];
      lmask |= step << 4;
      dot = (dp[3] << 4) + (7 * ep1[2] + 5 * ep2[3] + ep2[2]);
      if (dot < halfpt)
        step = (dot < c0pt) ? 1 : 3;
      else
        step = (dot < c3pt) ? 2 : 0;
      ep1[3] = dp[3] - stops[step];
      lmask |= step << 6;
      tmp = ep1;
      ep1 = ep2;
      ep2 = tmp;
      dp += 4;
      mask |= lmask << (y * 8);
    }
  }
  return (mask);
}


x86 assembly (clang, -O0):
<match_colors_block>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x4(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x94(%rbp)
cmpl   $0x10,-0x94(%rbp)
jge    11f3 <match_colors_block+0xe3>
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
imul   -0x1c(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%edx
shl    $0x2,%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rax,%rdx,1),%eax
imul   -0x20(%rbp),%eax
add    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%edx
shl    $0x2,%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rax,%rdx,1),%eax
imul   -0x24(%rbp),%eax
add    %eax,%ecx
movslq -0x94(%rbp),%rax
mov    %ecx,-0x70(%rbp,%rax,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1175 <match_colors_block+0x65>
movl   $0x0,-0x94(%rbp)
cmpl   $0x4,-0x94(%rbp)
jge    127a <match_colors_block+0x16a>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl (%rax),%ecx
imul   -0x1c(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rdx
imul   $0x3,%rdx,%rdx
add    %rdx,%rax
movzbl 0x1(%rax),%eax
imul   -0x20(%rbp),%eax
add    %eax,%ecx
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rdx
imul   $0x3,%rdx,%rdx
add    %rdx,%rax
movzbl 0x2(%rax),%eax
imul   -0x24(%rbp),%eax
add    %eax,%ecx
movslq -0x94(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    11fd <match_colors_block+0xed>
mov    -0x7c(%rbp),%eax
add    -0x74(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x74(%rbp),%eax
add    -0x78(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x78(%rbp),%eax
add    -0x80(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x8c(%rbp)
cmpl   $0x0,-0x14(%rbp)
jne    1356 <match_colors_block+0x246>
movl   $0xf,-0x94(%rbp)
cmpl   $0x0,-0x94(%rbp)
jl     1351 <match_colors_block+0x241>
mov    -0x18(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x18(%rbp)
movslq -0x94(%rbp),%rax
mov    -0x70(%rbp,%rax,4),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    131a <match_colors_block+0x20a>
mov    -0x90(%rbp),%edx
mov    -0x84(%rbp),%esi
mov    $0x3,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
or     -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1338 <match_colors_block+0x228>
mov    -0x90(%rbp),%edx
mov    -0x8c(%rbp),%esi
xor    %eax,%eax
mov    $0x2,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
or     -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    133d <match_colors_block+0x22d>
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
jmp    12bb <match_colors_block+0x1ab>
jmp    1749 <match_colors_block+0x639>
lea    -0xc0(%rbp),%rax
mov    %rax,-0xc8(%rbp)
lea    -0xc0(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0xd0(%rbp)
lea    -0x70(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x84(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x84(%rbp)
mov    -0x88(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x88(%rbp)
mov    -0x8c(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x8c(%rbp)
lea    -0xc0(%rbp),%rdi
xor    %esi,%esi
mov    $0x20,%edx
call   1030 <memset@plt>
movl   $0x0,-0xe4(%rbp)
cmpl   $0x4,-0xe4(%rbp)
jge    1744 <match_colors_block+0x634>
mov    -0xe0(%rbp),%rax
mov    (%rax),%eax
shl    $0x4,%eax
mov    -0xd0(%rbp),%rcx
imul   $0x3,0x4(%rcx),%ecx
mov    -0xd0(%rbp),%rdx
imul   $0x5,(%rdx),%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    143b <match_colors_block+0x32b>
mov    -0x90(%rbp),%edx
mov    -0x84(%rbp),%esi
mov    $0x3,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0xec(%rbp)
jmp    1459 <match_colors_block+0x349>
mov    -0x90(%rbp),%edx
mov    -0x8c(%rbp),%esi
xor    %eax,%eax
mov    $0x2,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xe0(%rbp),%rax
mov    (%rax),%ecx
movslq -0xec(%rbp),%rax
sub    -0x80(%rbp,%rax,4),%ecx
mov    -0xc8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xec(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe0(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x4,%eax
mov    -0xc8(%rbp),%rcx
imul   $0x7,(%rcx),%ecx
mov    -0xd0(%rbp),%rdx
imul   $0x3,0x8(%rdx),%edx
add    %edx,%ecx
mov    -0xd0(%rbp),%rdx
imul   $0x5,0x4(%rdx),%edx
add    %edx,%ecx
mov    -0xd0(%rbp),%rdx
add    (%rdx),%ecx
add    %ecx,%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    14fc <match_colors_block+0x3ec>
mov    -0x90(%rbp),%edx
mov    -0x84(%rbp),%esi
mov    $0x3,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0xec(%rbp)
jmp    151a <match_colors_block+0x40a>
mov    -0x90(%rbp),%edx
mov    -0x8c(%rbp),%esi
xor    %eax,%eax
mov    $0x2,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xe0(%rbp),%rax
mov    0x4(%rax),%ecx
movslq -0xec(%rbp),%rax
sub    -0x80(%rbp,%rax,4),%ecx
mov    -0xc8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0xec(%rbp),%eax
shl    $0x2,%eax
or     -0xe8(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe0(%rbp),%rax
mov    0x8(%rax),%eax
shl    $0x4,%eax
mov    -0xc8(%rbp),%rcx
imul   $0x7,0x4(%rcx),%ecx
mov    -0xd0(%rbp),%rdx
imul   $0x3,0xc(%rdx),%edx
add    %edx,%ecx
mov    -0xd0(%rbp),%rdx
imul   $0x5,0x8(%rdx),%edx
add    %edx,%ecx
mov    -0xd0(%rbp),%rdx
add    0x4(%rdx),%ecx
add    %ecx,%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    15ca <match_colors_block+0x4ba>
mov    -0x90(%rbp),%edx
mov    -0x84(%rbp),%esi
mov    $0x3,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0xec(%rbp)
jmp    15e8 <match_colors_block+0x4d8>
mov    -0x90(%rbp),%edx
mov    -0x8c(%rbp),%esi
xor    %eax,%eax
mov    $0x2,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xe0(%rbp),%rax
mov    0x8(%rax),%ecx
movslq -0xec(%rbp),%rax
sub    -0x80(%rbp,%rax,4),%ecx
mov    -0xc8(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0xec(%rbp),%eax
shl    $0x4,%eax
or     -0xe8(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe0(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x4,%eax
mov    -0xc8(%rbp),%rcx
imul   $0x7,0x8(%rcx),%ecx
mov    -0xd0(%rbp),%rdx
imul   $0x5,0xc(%rdx),%edx
add    %edx,%ecx
mov    -0xd0(%rbp),%rdx
add    0x8(%rdx),%ecx
add    %ecx,%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    168b <match_colors_block+0x57b>
mov    -0x90(%rbp),%edx
mov    -0x84(%rbp),%esi
mov    $0x3,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0xec(%rbp)
jmp    16a9 <match_colors_block+0x599>
mov    -0x90(%rbp),%edx
mov    -0x8c(%rbp),%esi
xor    %eax,%eax
mov    $0x2,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xe0(%rbp),%rax
mov    0xc(%rax),%ecx
movslq -0xec(%rbp),%rax
sub    -0x80(%rbp,%rax,4),%ecx
mov    -0xc8(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0xec(%rbp),%eax
shl    $0x6,%eax
or     -0xe8(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xc8(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0xd8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xe0(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe8(%rbp),%eax
mov    -0xe4(%rbp),%ecx
shl    $0x3,%ecx
shl    %cl,%eax
or     -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    13cb <match_colors_block+0x2bb>
jmp    1749 <match_colors_block+0x639>
mov    -0x18(%rbp),%eax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<match_colors_block>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
movzbl (%rsi),%r10d
movzbl 0x3(%rsi),%r8d
mov    %r10d,%r13d
sub    %r8d,%r13d
movzbl 0x1(%rsi),%r14d
movzbl 0x4(%rsi),%r11d
mov    %r14d,%ebp
sub    %r11d,%ebp
movzbl 0x2(%rsi),%r9d
movzbl 0x5(%rsi),%r12d
mov    %r9d,%r15d
sub    %r12d,%r15d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rdi,%rbx,4),%eax
imul   %r13d,%eax
movzbl 0x1(%rdi,%rbx,4),%ecx
imul   %ebp,%ecx
add    %eax,%ecx
movzbl 0x2(%rdi,%rbx,4),%eax
imul   %r15d,%eax
add    %ecx,%eax
mov    %eax,0x40(%rsp,%rbx,4)
add    $0x1,%rbx
cmp    $0x10,%rbx
jne    1160 <match_colors_block+0x50>
imul   %r13d,%r10d
imul   %ebp,%r14d
add    %r10d,%r14d
imul   %r15d,%r9d
add    %r14d,%r9d
mov    %r9d,0x10(%rsp)
imul   %r13d,%r8d
imul   %ebp,%r11d
add    %r8d,%r11d
imul   %r15d,%r12d
add    %r11d,%r12d
mov    %r12d,0x14(%rsp)
movzbl 0x6(%rsi),%eax
imul   %r13d,%eax
movzbl 0x7(%rsi),%ecx
imul   %ebp,%ecx
add    %eax,%ecx
movzbl 0x8(%rsi),%r8d
imul   %r15d,%r8d
add    %ecx,%r8d
mov    %r8d,0x18(%rsp)
movzbl 0x9(%rsi),%eax
imul   %r13d,%eax
movzbl 0xa(%rsi),%ecx
imul   %ebp,%ecx
add    %eax,%ecx
movzbl 0xb(%rsi),%r10d
imul   %r15d,%r10d
add    %ecx,%r10d
mov    %r10d,0x1c(%rsp)
add    %r10d,%r12d
sar    %r12d
add    %r8d,%r10d
sar    %r10d
add    %r9d,%r8d
sar    %r8d
test   %edx,%edx
je     1401 <match_colors_block+0x2f1>
lea    0x20(%rsp),%r14
lea    0x30(%rsp),%rbx
shl    $0x4,%r12d
mov    %r12d,0x4(%rsp)
shl    $0x4,%r10d
mov    %r10d,(%rsp)
shl    $0x4,%r8d
mov    %r8d,0x8(%rsp)
xor    %r15d,%r15d
mov    %r14,%rdi
xor    %esi,%esi
mov    $0x20,%edx
call   1030 <memset@plt>
mov    (%rsp),%r10d
mov    0x30(%rsp),%ecx
mov    0x34(%rsp),%r12d
xor    %eax,%eax
mov    0x4(%rsp),%r11d
mov    0x8(%rsp),%r13d
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%r9
mov    0x40(%rsp,%r15,2),%r8d
mov    %r8d,%esi
shl    $0x4,%esi
lea    (%r12,%r12,2),%edx
add    %esi,%edx
lea    (%rcx,%rcx,4),%esi
add    %edx,%esi
xor    %edx,%edx
cmp    %r11d,%esi
setge  %dl
xor    %ebx,%ebx
cmp    %r13d,%esi
setl   %bl
add    %ebx,%ebx
cmp    %r10d,%esi
lea    0x1(%rdx,%rdx,1),%ebp
cmovge %ebx,%ebp
lea    0x0(,%rbp,4),%rdx
lea    0x10(%rsp),%rsi
or     %rsi,%rdx
sub    (%rdx),%r8d
mov    %r8d,(%r14)
mov    0x44(%rsp,%r15,2),%r12d
mov    %r12d,%esi
shl    $0x4,%esi
lea    0x0(,%r8,8),%ebx
sub    %r8d,%ebx
mov    0x4(%r9),%r10d
mov    0x8(%r9),%edi
lea    (%rdi,%rdi,2),%edi
add    %ecx,%ebx
lea    (%r10,%r10,4),%ecx
add    %esi,%ebx
add    %edi,%ebx
add    %ecx,%ebx
xor    %ecx,%ecx
cmp    %r11d,%ebx
setge  %cl
xor    %esi,%esi
cmp    %r13d,%ebx
setl   %sil
add    %esi,%esi
cmp    (%rsp),%ebx
lea    0x1(%rcx,%rcx,1),%ecx
cmovge %esi,%ecx
lea    0x0(,%rcx,4),%rsi
lea    0x10(%rsp),%rdx
or     %rdx,%rsi
sub    (%rsi),%r12d
mov    %r12d,0x4(%r14)
lea    0x0(%rbp,%rcx,4),%ecx
mov    %ecx,0xc(%rsp)
mov    0x48(%rsp,%r15,2),%ebp
mov    %ebp,%ecx
shl    $0x4,%ecx
lea    0x0(,%r12,8),%edi
sub    %r12d,%edi
mov    0x8(%r9),%esi
add    %r10d,%edi
mov    (%rsp),%r10d
mov    0xc(%r9),%ebx
lea    (%rbx,%rbx,2),%ebx
add    %ecx,%edi
lea    (%rsi,%rsi,4),%ecx
add    %ebx,%edi
add    %ecx,%edi
xor    %ecx,%ecx
cmp    %r11d,%edi
setge  %cl
xor    %ebx,%ebx
cmp    %r13d,%edi
setl   %bl
add    %ebx,%ebx
cmp    %r10d,%edi
lea    0x1(%rcx,%rcx,1),%ecx
cmovge %ebx,%ecx
lea    0x0(,%rcx,4),%rdi
or     %rdx,%rdi
sub    (%rdi),%ebp
mov    %ebp,0x8(%r14)
shl    $0x4,%ecx
or     0xc(%rsp),%ecx
mov    0x4c(%rsp,%r15,2),%edx
lea    0x0(,%rbp,8),%edi
sub    %ebp,%edi
mov    %edx,%ebx
shl    $0x4,%ebx
add    %esi,%edi
mov    0xc(%r9),%esi
lea    (%rsi,%rsi,4),%esi
add    %ebx,%edi
add    %esi,%edi
xor    %esi,%esi
cmp    %r11d,%edi
setge  %sil
xor    %ebp,%ebp
cmp    %r13d,%edi
setl   %bpl
add    %ebp,%ebp
cmp    %r10d,%edi
lea    0x1(%rsi,%rsi,1),%esi
cmovge %ebp,%esi
lea    0x0(,%rsi,4),%rdi
lea    0x10(%rsp),%rbp
or     %rbp,%rdi
sub    (%rdi),%edx
shl    $0x6,%esi
or     %ecx,%esi
mov    %r15d,%ecx
shl    %cl,%esi
mov    %edx,0xc(%r14)
or     %esi,%eax
add    $0x8,%r15
mov    %r8d,%ecx
mov    %r14,%rbx
mov    %r9,%r14
cmp    $0x20,%r15d
jne    1270 <match_colors_block+0x160>
jmp    1468 <match_colors_block+0x358>
xor    %eax,%eax
mov    $0xe,%ecx
nopl   0x0(%rax,%rax,1)
shl    $0x4,%eax
mov    0x40(%rsp,%rcx,4),%edx
mov    0x44(%rsp,%rcx,4),%esi
xor    %edi,%edi
cmp    %r12d,%esi
setge  %dil
xor    %ebp,%ebp
cmp    %r8d,%esi
setl   %bpl
shl    $0x3,%ebp
cmp    %r10d,%esi
lea    0x4(,%rdi,8),%esi
cmovge %ebp,%esi
or     %eax,%esi
xor    %eax,%eax
cmp    %r12d,%edx
setge  %al
xor    %edi,%edi
cmp    %r8d,%edx
setl   %dil
add    %edi,%edi
cmp    %r10d,%edx
lea    0x1(%rax,%rax,1),%eax
cmovge %edi,%eax
or     %esi,%eax
add    $0xfffffffffffffffe,%rcx
cmp    $0xfffffffffffffffe,%rcx
jne    1410 <match_colors_block+0x300>
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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