int edge_hash2(const char *cubestr) {
  char positions[] = {1, 3, 4, 6, 8, 9, 10, 11, 13, 15, 16, 18};
  int index = 0;
  int pos, rot, num, i;
  const char *cubie;
  cubie = ((char *)cubestr + (10 << 1));
  num = cubie[0];
  pos = 0;
  while (num != positions[pos])
    ++pos;
  for (i = pos; i < 11; ++i)
    positions[i] = positions[i + 1];
  rot = cubie[1] * 12;
  index += (pos + rot) * 1774080;
  cubie = ((char *)cubestr + (11 << 1));
  num = cubie[0];
  pos = 0;
  while (num != positions[pos])
    ++pos;
  for (i = pos; i < 10; ++i)
    positions[i] = positions[i + 1];
  rot = cubie[1] * 11;
  index += (pos + rot) * 80640;
  cubie = ((char *)cubestr + (13 << 1));
  num = cubie[0];
  pos = 0;
  while (num != positions[pos])
    ++pos;
  for (i = pos; i < 9; ++i)
    positions[i] = positions[i + 1];
  rot = cubie[1] * 10;
  index += (pos + rot) * 4032;
  cubie = ((char *)cubestr + (15 << 1));
  num = cubie[0];
  pos = 0;
  while (num != positions[pos])
    ++pos;
  for (i = pos; i < 8; ++i)
    positions[i] = positions[i + 1];
  rot = cubie[1] * 9;
  index += (pos + rot) * 224;
  cubie = ((char *)cubestr + (16 << 1));
  num = cubie[0];
  pos = 0;
  while (num != positions[pos])
    ++pos;
  for (i = pos; i < 7; ++i)
    positions[i] = positions[i + 1];
  rot = cubie[1] * 8;
  index += (pos + rot) * 14;
  cubie = ((char *)cubestr + (18 << 1));
  num = cubie[0];
  pos = 0;
  while (num != positions[pos])
    ++pos;
  for (i = pos; i < 6; ++i)
    positions[i] = positions[i + 1];
  rot = cubie[1] * 7;
  index += (pos + rot);
  return index;
}


x86 assembly (clang, -O0):
<edge_hash2>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    0xef1(%rip),%rax
mov    %rax,-0x14(%rbp)
mov    0xeef(%rip),%eax
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x14,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
movslq -0x1c(%rbp),%rcx
movsbl -0x14(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
je     1162 <edge_hash2+0x62>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1140 <edge_hash2+0x40>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0xb,-0x28(%rbp)
jge    1194 <edge_hash2+0x94>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x14(%rbp,%rax,1),%cl
movslq -0x28(%rbp),%rax
mov    %cl,-0x14(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1168 <edge_hash2+0x68>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
imul   $0xc,%eax,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
imul   $0x1b1200,%eax,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x16,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
movslq -0x1c(%rbp),%rcx
movsbl -0x14(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
je     11f3 <edge_hash2+0xf3>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11d1 <edge_hash2+0xd1>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0xa,-0x28(%rbp)
jge    1225 <edge_hash2+0x125>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x14(%rbp,%rax,1),%cl
movslq -0x28(%rbp),%rax
mov    %cl,-0x14(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11f9 <edge_hash2+0xf9>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
imul   $0xb,%eax,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
imul   $0x13b00,%eax,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1a,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
movslq -0x1c(%rbp),%rcx
movsbl -0x14(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
je     1284 <edge_hash2+0x184>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1262 <edge_hash2+0x162>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x9,-0x28(%rbp)
jge    12b6 <edge_hash2+0x1b6>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x14(%rbp,%rax,1),%cl
movslq -0x28(%rbp),%rax
mov    %cl,-0x14(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    128a <edge_hash2+0x18a>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
imul   $0xa,%eax,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
imul   $0xfc0,%eax,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1e,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
movslq -0x1c(%rbp),%rcx
movsbl -0x14(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
je     1315 <edge_hash2+0x215>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12f3 <edge_hash2+0x1f3>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x8,-0x28(%rbp)
jge    1347 <edge_hash2+0x247>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x14(%rbp,%rax,1),%cl
movslq -0x28(%rbp),%rax
mov    %cl,-0x14(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    131b <edge_hash2+0x21b>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
imul   $0x9,%eax,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
imul   $0xe0,%eax,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
movslq -0x1c(%rbp),%rcx
movsbl -0x14(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
je     13a6 <edge_hash2+0x2a6>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1384 <edge_hash2+0x284>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x7,-0x28(%rbp)
jge    13d8 <edge_hash2+0x2d8>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x14(%rbp,%rax,1),%cl
movslq -0x28(%rbp),%rax
mov    %cl,-0x14(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13ac <edge_hash2+0x2ac>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
shl    $0x3,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
imul   $0xe,%eax,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x24,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
movslq -0x1c(%rbp),%rcx
movsbl -0x14(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
je     1434 <edge_hash2+0x334>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1412 <edge_hash2+0x312>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x6,-0x28(%rbp)
jge    1466 <edge_hash2+0x366>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x14(%rbp,%rax,1),%cl
movslq -0x28(%rbp),%rax
mov    %cl,-0x14(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    143a <edge_hash2+0x33a>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
imul   $0x7,%eax,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<edge_hash2>:
push   %rbx
movabs $0xb0a090806040301,%rax
09 0a 0b
mov    %rax,-0x10(%rsp)
movl   $0x12100f0d,-0x8(%rsp)
12
mov    0x14(%rdi),%cl
cmp    $0x1,%cl
jne    1124 <edge_hash2+0x24>
xor    %eax,%eax
jmp    113d <edge_hash2+0x3d>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%rdx),%rax
cmp    -0xf(%rsp,%rdx,1),%cl
mov    %rax,%rdx
jne    1130 <edge_hash2+0x30>
cmp    $0xa,%eax
ja     1266 <edge_hash2+0x166>
mov    %eax,%ecx
mov    $0xb,%r9d
sub    %rcx,%r9
cmp    $0x8,%r9
jb     1250 <edge_hash2+0x150>
cmp    $0x20,%r9
jae    1168 <edge_hash2+0x68>
xor    %edx,%edx
jmp    11f8 <edge_hash2+0xf8>
mov    %r9,%rdx
and    $0xffffffffffffffe0,%rdx
lea    -0x20(%rdx),%rsi
mov    %rsi,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1239 <edge_hash2+0x139>
mov    %r8,%r10
and    $0xfffffffffffffffe,%r10
lea    -0x10(%rsp),%rsi
lea    (%rcx,%rsi,1),%rbx
add    $0x31,%rbx
xor    %esi,%esi
nopl   (%rax)
movups -0x30(%rbx,%rsi,1),%xmm0
movups -0x20(%rbx,%rsi,1),%xmm1
movups -0x10(%rbx,%rsi,1),%xmm2
movups (%rbx,%rsi,1),%xmm3
movups %xmm0,-0x31(%rbx,%rsi,1)
movups %xmm1,-0x21(%rbx,%rsi,1)
movups %xmm2,-0x11(%rbx,%rsi,1)
movups %xmm3,-0x1(%rbx,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%r10
jne    11a0 <edge_hash2+0xa0>
test   $0x1,%r8b
je     11ed <edge_hash2+0xed>
add    %rcx,%rsi
movups -0xf(%rsp,%rsi,1),%xmm0
movups 0x1(%rsp,%rsi,1),%xmm1
movups %xmm0,-0x10(%rsp,%rsi,1)
movups %xmm1,(%rsp,%rsi,1)
cmp    %rdx,%r9
je     1266 <edge_hash2+0x166>
test   $0x18,%r9b
je     1243 <edge_hash2+0x143>
mov    $0xb,%r8d
sub    %rcx,%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x10(%rsp),%rbx
add    %rcx,%rbx
add    $0x1,%rbx
add    %r9,%rcx
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rdx,1),%rsi
mov    %rsi,-0x1(%rbx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%r9
jne    1220 <edge_hash2+0x120>
cmp    %r9,%r8
jne    1250 <edge_hash2+0x150>
jmp    1266 <edge_hash2+0x166>
xor    %esi,%esi
test   $0x1,%r8b
jne    11d7 <edge_hash2+0xd7>
jmp    11ed <edge_hash2+0xed>
add    %rdx,%rcx
cs nopw 0x0(%rax,%rax,1)
movzbl -0xf(%rsp,%rcx,1),%edx
mov    %dl,-0x10(%rsp,%rcx,1)
lea    0x1(%rcx),%rdx
mov    %rdx,%rcx
cmp    $0xb,%rdx
jne    1250 <edge_hash2+0x150>
movsbl 0x15(%rdi),%ecx
mov    0x16(%rdi),%bl
imul   $0x144d800,%ecx,%ecx
imul   $0x1b1200,%eax,%eax
add    %eax,%ecx
add    $0xfffeb451,%ecx
mov    $0xffffffffffffffff,%rdx
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rax
add    $0x1,%rdx
add    $0x13b00,%ecx
cmp    -0xf(%rsp,%rax,1),%bl
jne    1290 <edge_hash2+0x190>
cmp    $0x9,%edx
ja     13f6 <edge_hash2+0x2f6>
mov    %edx,%eax
mov    $0xa,%r8d
sub    %rax,%r8
cmp    $0x8,%r8
jb     13e0 <edge_hash2+0x2e0>
cmp    $0x20,%r8
jae    12cf <edge_hash2+0x1cf>
xor    %r10d,%r10d
jmp    1380 <edge_hash2+0x280>
mov    %r8,%r10
and    $0xffffffffffffffe0,%r10
lea    -0x20(%r10),%rsi
mov    %rsi,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     13c9 <edge_hash2+0x2c9>
mov    %edx,%esi
lea    (%rsp,%rsi,1),%r11
add    $0x21,%r11
mov    $0xa,%ebx
sub    %rsi,%rbx
and    $0xffffffffffffffe0,%rbx
add    $0xffffffffffffffe0,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%r11,%rsi,1),%xmm0
movups -0x20(%r11,%rsi,1),%xmm1
movups -0x10(%r11,%rsi,1),%xmm2
movups (%r11,%rsi,1),%xmm3
movups %xmm0,-0x31(%r11,%rsi,1)
movups %xmm1,-0x21(%r11,%rsi,1)
movups %xmm2,-0x11(%r11,%rsi,1)
movups %xmm3,-0x1(%r11,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rbx
jne    1320 <edge_hash2+0x220>
test   $0x1,%r9b
je     1375 <edge_hash2+0x275>
add    %rax,%rsi
movups -0xf(%rsp,%rsi,1),%xmm0
movups 0x1(%rsp,%rsi,1),%xmm1
movups %xmm0,-0x10(%rsp,%rsi,1)
movups %xmm1,(%rsp,%rsi,1)
cmp    %r10,%r8
je     13f6 <edge_hash2+0x2f6>
test   $0x18,%r8b
je     13d3 <edge_hash2+0x2d3>
mov    $0xa,%ebx
mov    $0xa,%r8d
sub    %rax,%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
add    %r9,%rax
mov    %edx,%edx
sub    %rdx,%rbx
and    $0xfffffffffffffff8,%rbx
add    %rsp,%rdx
add    $0xfffffffffffffff1,%rdx
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%r10,1),%rsi
mov    %rsi,-0x1(%rdx,%r10,1)
add    $0x8,%r10
cmp    %r10,%rbx
jne    13b0 <edge_hash2+0x2b0>
cmp    %r9,%r8
jne    13e0 <edge_hash2+0x2e0>
jmp    13f6 <edge_hash2+0x2f6>
xor    %esi,%esi
test   $0x1,%r9b
jne    135f <edge_hash2+0x25f>
jmp    1375 <edge_hash2+0x275>
add    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
movzbl -0xf(%rsp,%rax,1),%edx
mov    %dl,-0x10(%rsp,%rax,1)
lea    0x1(%rax),%rdx
mov    %rdx,%rax
cmp    $0xa,%rdx
jne    13e0 <edge_hash2+0x2e0>
movsbl 0x17(%rdi),%eax
mov    0x1a(%rdi),%bl
imul   $0xd8900,%eax,%eax
add    %ecx,%eax
mov    $0xffffffffffffffff,%rdx
nopl   0x0(%rax)
mov    %rdx,%rcx
add    $0x1,%rdx
add    $0xfc0,%eax
cmp    -0xf(%rsp,%rcx,1),%bl
jne    1410 <edge_hash2+0x310>
cmp    $0x8,%edx
ja     1576 <edge_hash2+0x476>
mov    %edx,%ecx
mov    $0x9,%r8d
sub    %rcx,%r8
cmp    $0x8,%r8
jb     1560 <edge_hash2+0x460>
cmp    $0x20,%r8
jae    144e <edge_hash2+0x34e>
xor    %r10d,%r10d
jmp    1500 <edge_hash2+0x400>
mov    %r8,%r10
and    $0xffffffffffffffe0,%r10
lea    -0x20(%r10),%rsi
mov    %rsi,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1549 <edge_hash2+0x449>
mov    %edx,%esi
lea    (%rsp,%rsi,1),%r11
add    $0x21,%r11
mov    $0x9,%ebx
sub    %rsi,%rbx
and    $0xffffffffffffffe0,%rbx
add    $0xffffffffffffffe0,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%r11,%rsi,1),%xmm0
movups -0x20(%r11,%rsi,1),%xmm1
movups -0x10(%r11,%rsi,1),%xmm2
movups (%r11,%rsi,1),%xmm3
movups %xmm0,-0x31(%r11,%rsi,1)
movups %xmm1,-0x21(%r11,%rsi,1)
movups %xmm2,-0x11(%r11,%rsi,1)
movups %xmm3,-0x1(%r11,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rbx
jne    14a0 <edge_hash2+0x3a0>
test   $0x1,%r9b
je     14f5 <edge_hash2+0x3f5>
add    %rcx,%rsi
movups -0xf(%rsp,%rsi,1),%xmm0
movups 0x1(%rsp,%rsi,1),%xmm1
movups %xmm0,-0x10(%rsp,%rsi,1)
movups %xmm1,(%rsp,%rsi,1)
cmp    %r10,%r8
je     1576 <edge_hash2+0x476>
test   $0x18,%r8b
je     1553 <edge_hash2+0x453>
mov    $0x9,%ebx
mov    $0x9,%r8d
sub    %rcx,%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
add    %r9,%rcx
mov    %edx,%edx
sub    %rdx,%rbx
and    $0xfffffffffffffff8,%rbx
add    %rsp,%rdx
add    $0xfffffffffffffff1,%rdx
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%r10,1),%rsi
mov    %rsi,-0x1(%rdx,%r10,1)
add    $0x8,%r10
cmp    %r10,%rbx
jne    1530 <edge_hash2+0x430>
cmp    %r9,%r8
jne    1560 <edge_hash2+0x460>
jmp    1576 <edge_hash2+0x476>
xor    %esi,%esi
test   $0x1,%r9b
jne    14df <edge_hash2+0x3df>
jmp    14f5 <edge_hash2+0x3f5>
add    %r10,%rcx
cs nopw 0x0(%rax,%rax,1)
movzbl -0xf(%rsp,%rcx,1),%edx
mov    %dl,-0x10(%rsp,%rcx,1)
lea    0x1(%rcx),%rdx
mov    %rdx,%rcx
cmp    $0x9,%rdx
jne    1560 <edge_hash2+0x460>
movsbl 0x1b(%rdi),%ecx
mov    0x1e(%rdi),%bl
imul   $0x9d80,%ecx,%ecx
add    %eax,%ecx
mov    $0xffffffffffffffff,%rdx
nopl   0x0(%rax)
mov    %rdx,%rax
add    $0x1,%rdx
add    $0xe0,%ecx
cmp    -0xf(%rsp,%rax,1),%bl
jne    1590 <edge_hash2+0x490>
cmp    $0x7,%edx
ja     16f6 <edge_hash2+0x5f6>
mov    %edx,%eax
mov    $0x8,%r8d
sub    %rax,%r8
cmp    $0x8,%r8
jb     16e0 <edge_hash2+0x5e0>
cmp    $0x20,%r8
jae    15cf <edge_hash2+0x4cf>
xor    %r10d,%r10d
jmp    1680 <edge_hash2+0x580>
mov    %r8,%r10
and    $0xffffffffffffffe0,%r10
lea    -0x20(%r10),%rsi
mov    %rsi,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     16c9 <edge_hash2+0x5c9>
mov    %edx,%esi
lea    (%rsp,%rsi,1),%r11
add    $0x21,%r11
mov    $0x8,%ebx
sub    %rsi,%rbx
and    $0xffffffffffffffe0,%rbx
add    $0xffffffffffffffe0,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%r11,%rsi,1),%xmm0
movups -0x20(%r11,%rsi,1),%xmm1
movups -0x10(%r11,%rsi,1),%xmm2
movups (%r11,%rsi,1),%xmm3
movups %xmm0,-0x31(%r11,%rsi,1)
movups %xmm1,-0x21(%r11,%rsi,1)
movups %xmm2,-0x11(%r11,%rsi,1)
movups %xmm3,-0x1(%r11,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rbx
jne    1620 <edge_hash2+0x520>
test   $0x1,%r9b
je     1675 <edge_hash2+0x575>
add    %rax,%rsi
movups -0xf(%rsp,%rsi,1),%xmm0
movups 0x1(%rsp,%rsi,1),%xmm1
movups %xmm0,-0x10(%rsp,%rsi,1)
movups %xmm1,(%rsp,%rsi,1)
cmp    %r10,%r8
je     16f6 <edge_hash2+0x5f6>
test   $0x18,%r8b
je     16d3 <edge_hash2+0x5d3>
mov    $0x8,%ebx
mov    $0x8,%r8d
sub    %rax,%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
add    %r9,%rax
mov    %edx,%edx
sub    %rdx,%rbx
and    $0xfffffffffffffff8,%rbx
add    %rsp,%rdx
add    $0xfffffffffffffff1,%rdx
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%r10,1),%rsi
mov    %rsi,-0x1(%rdx,%r10,1)
add    $0x8,%r10
cmp    %r10,%rbx
jne    16b0 <edge_hash2+0x5b0>
cmp    %r9,%r8
jne    16e0 <edge_hash2+0x5e0>
jmp    16f6 <edge_hash2+0x5f6>
xor    %esi,%esi
test   $0x1,%r9b
jne    165f <edge_hash2+0x55f>
jmp    1675 <edge_hash2+0x575>
add    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
movzbl -0xf(%rsp,%rax,1),%edx
mov    %dl,-0x10(%rsp,%rax,1)
lea    0x1(%rax),%rdx
mov    %rdx,%rax
cmp    $0x8,%rdx
jne    16e0 <edge_hash2+0x5e0>
movsbl 0x1f(%rdi),%eax
mov    0x20(%rdi),%bl
imul   $0x7e0,%eax,%eax
add    %ecx,%eax
mov    $0xffffffffffffffff,%rdx
nopl   0x0(%rax)
mov    %rdx,%rcx
add    $0x1,%rdx
add    $0xe,%eax
cmp    -0xf(%rsp,%rcx,1),%bl
jne    1710 <edge_hash2+0x610>
cmp    $0x6,%edx
ja     1876 <edge_hash2+0x776>
mov    %edx,%ecx
mov    $0x7,%r8d
sub    %rcx,%r8
cmp    $0x8,%r8
jb     1860 <edge_hash2+0x760>
cmp    $0x20,%r8
jae    174c <edge_hash2+0x64c>
xor    %r10d,%r10d
jmp    1800 <edge_hash2+0x700>
mov    %r8,%r10
and    $0xffffffffffffffe0,%r10
lea    -0x20(%r10),%rsi
mov    %rsi,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1849 <edge_hash2+0x749>
mov    %edx,%esi
lea    (%rsp,%rsi,1),%r11
add    $0x21,%r11
mov    $0x7,%ebx
sub    %rsi,%rbx
and    $0xffffffffffffffe0,%rbx
add    $0xffffffffffffffe0,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%r11,%rsi,1),%xmm0
movups -0x20(%r11,%rsi,1),%xmm1
movups -0x10(%r11,%rsi,1),%xmm2
movups (%r11,%rsi,1),%xmm3
movups %xmm0,-0x31(%r11,%rsi,1)
movups %xmm1,-0x21(%r11,%rsi,1)
movups %xmm2,-0x11(%r11,%rsi,1)
movups %xmm3,-0x1(%r11,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rbx
jne    17a0 <edge_hash2+0x6a0>
test   $0x1,%r9b
je     17f5 <edge_hash2+0x6f5>
add    %rcx,%rsi
movups -0xf(%rsp,%rsi,1),%xmm0
movups 0x1(%rsp,%rsi,1),%xmm1
movups %xmm0,-0x10(%rsp,%rsi,1)
movups %xmm1,(%rsp,%rsi,1)
cmp    %r10,%r8
je     1876 <edge_hash2+0x776>
test   $0x18,%r8b
je     1853 <edge_hash2+0x753>
mov    $0x7,%ebx
mov    $0x7,%r8d
sub    %rcx,%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
add    %r9,%rcx
mov    %edx,%edx
sub    %rdx,%rbx
and    $0xfffffffffffffff8,%rbx
add    %rsp,%rdx
add    $0xfffffffffffffff1,%rdx
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%r10,1),%rsi
mov    %rsi,-0x1(%rdx,%r10,1)
add    $0x8,%r10
cmp    %r10,%rbx
jne    1830 <edge_hash2+0x730>
cmp    %r9,%r8
jne    1860 <edge_hash2+0x760>
jmp    1876 <edge_hash2+0x776>
xor    %esi,%esi
test   $0x1,%r9b
jne    17df <edge_hash2+0x6df>
jmp    17f5 <edge_hash2+0x6f5>
add    %r10,%rcx
cs nopw 0x0(%rax,%rax,1)
movzbl -0xf(%rsp,%rcx,1),%edx
mov    %dl,-0x10(%rsp,%rcx,1)
lea    0x1(%rcx),%rdx
mov    %rdx,%rcx
cmp    $0x7,%rdx
jne    1860 <edge_hash2+0x760>
movsbl 0x21(%rdi),%ecx
mov    0x24(%rdi),%bl
imul   $0x70,%ecx,%ecx
add    %eax,%ecx
mov    $0xffffffffffffffff,%rdx
nopl   0x0(%rax)
mov    %rdx,%rax
add    $0x1,%rdx
add    $0x1,%ecx
cmp    -0xf(%rsp,%rax,1),%bl
jne    1890 <edge_hash2+0x790>
cmp    $0x5,%edx
ja     19f6 <edge_hash2+0x8f6>
mov    %edx,%eax
mov    $0x6,%r8d
sub    %rax,%r8
cmp    $0x8,%r8
jb     19e0 <edge_hash2+0x8e0>
cmp    $0x20,%r8
jae    18cc <edge_hash2+0x7cc>
xor    %r10d,%r10d
jmp    1980 <edge_hash2+0x880>
mov    %r8,%r10
and    $0xffffffffffffffe0,%r10
lea    -0x20(%r10),%rsi
mov    %rsi,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     19c9 <edge_hash2+0x8c9>
mov    %edx,%esi
lea    (%rsp,%rsi,1),%r11
add    $0x21,%r11
mov    $0x6,%ebx
sub    %rsi,%rbx
and    $0xffffffffffffffe0,%rbx
add    $0xffffffffffffffe0,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%r11,%rsi,1),%xmm0
movups -0x20(%r11,%rsi,1),%xmm1
movups -0x10(%r11,%rsi,1),%xmm2
movups (%r11,%rsi,1),%xmm3
movups %xmm0,-0x31(%r11,%rsi,1)
movups %xmm1,-0x21(%r11,%rsi,1)
movups %xmm2,-0x11(%r11,%rsi,1)
movups %xmm3,-0x1(%r11,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rbx
jne    1920 <edge_hash2+0x820>
test   $0x1,%r9b
je     1975 <edge_hash2+0x875>
add    %rax,%rsi
movups -0xf(%rsp,%rsi,1),%xmm0
movups 0x1(%rsp,%rsi,1),%xmm1
movups %xmm0,-0x10(%rsp,%rsi,1)
movups %xmm1,(%rsp,%rsi,1)
cmp    %r10,%r8
je     19f6 <edge_hash2+0x8f6>
test   $0x18,%r8b
je     19d3 <edge_hash2+0x8d3>
mov    $0x6,%ebx
mov    $0x6,%r8d
sub    %rax,%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
add    %r9,%rax
mov    %edx,%edx
sub    %rdx,%rbx
and    $0xfffffffffffffff8,%rbx
add    %rsp,%rdx
add    $0xfffffffffffffff1,%rdx
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%r10,1),%rsi
mov    %rsi,-0x1(%rdx,%r10,1)
add    $0x8,%r10
cmp    %r10,%rbx
jne    19b0 <edge_hash2+0x8b0>
cmp    %r9,%r8
jne    19e0 <edge_hash2+0x8e0>
jmp    19f6 <edge_hash2+0x8f6>
xor    %esi,%esi
test   $0x1,%r9b
jne    195f <edge_hash2+0x85f>
jmp    1975 <edge_hash2+0x875>
add    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
movzbl -0xf(%rsp,%rax,1),%edx
mov    %dl,-0x10(%rsp,%rax,1)
lea    0x1(%rax),%rdx
mov    %rdx,%rax
cmp    $0x6,%rdx
jne    19e0 <edge_hash2+0x8e0>
movsbl 0x25(%rdi),%edx
lea    0x0(,%rdx,8),%eax
sub    %edx,%eax
add    %ecx,%eax
pop    %rbx
ret

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

LLVM IR (-O2):
@__const.edge_hash2.positions = [12 x i8] c"\01\03\04\06\08\09\0A\0B\0D\0F\10\12"
define i32 @edge_hash2(i8* nocapture %0) {
%2 = alloca [12 x i8]
%3 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 0
%4 = getelementptr inbounds i8, i8* %0, i64 20
%5 = load i8, i8* %4
%6 = icmp eq i8 %5, 1
br i1 %6, label %13, label %7
7: ; preds = %1, %7
%8 = phi i64 [ %12, %7 ], [ 1, %1 ]
%9 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %8
%10 = load i8, i8* %9
%11 = icmp eq i8 %5, %10
%12 = add nuw i64 %8, 1
br i1 %11, label %13, label %7
13: ; preds = %7, %1
%14 = phi i64 [ 0, %1 ], [ %8, %7 ]
%15 = trunc i64 %14 to i32
%16 = icmp ult i32 %15, 11
br i1 %16, label %17, label %112
17: ; preds = %13
%18 = and i64 %14, 4294967295
%19 = sub nsw i64 11, %18
%20 = icmp ult i64 %19, 8
br i1 %20, label %103, label %21
21: ; preds = %17
%22 = icmp ult i64 %19, 32
br i1 %22, label %85, label %23
23: ; preds = %21
%24 = and i64 %19, -32
%25 = add nsw i64 %24, -32
%26 = lshr exact i64 %25, 5
%27 = add nuw nsw i64 %26, 1
%28 = and i64 %27, 1
%29 = icmp eq i64 %25, 0
br i1 %29, label %63, label %30
30: ; preds = %23
%31 = and i64 %27, 1152921504606846974
br label %32
32: ; preds = %32, %30
%33 = phi i64 [ 0, %30 ], [ %60, %32 ]
%34 = phi i64 [ 0, %30 ], [ %61, %32 ]
%35 = add i64 %18, %33
%36 = add nuw nsw i64 %35, 1
%37 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %36
%38 = bitcast i8* %37 to <16 x i8>*
%39 = load <16 x i8>, <16 x i8>* %38
%40 = getelementptr inbounds i8, i8* %37, i64 16
%41 = bitcast i8* %40 to <16 x i8>*
%42 = load <16 x i8>, <16 x i8>* %41
%43 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %35
%44 = bitcast i8* %43 to <16 x i8>*
store <16 x i8> %39, <16 x i8>* %44
%45 = getelementptr inbounds i8, i8* %43, i64 16
%46 = bitcast i8* %45 to <16 x i8>*
store <16 x i8> %42, <16 x i8>* %46
%47 = or i64 %33, 32
%48 = add i64 %18, %47
%49 = add nuw nsw i64 %48, 1
%50 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %49
%51 = bitcast i8* %50 to <16 x i8>*
%52 = load <16 x i8>, <16 x i8>* %51
%53 = getelementptr inbounds i8, i8* %50, i64 16
%54 = bitcast i8* %53 to <16 x i8>*
%55 = load <16 x i8>, <16 x i8>* %54
%56 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %48
%57 = bitcast i8* %56 to <16 x i8>*
store <16 x i8> %52, <16 x i8>* %57
%58 = getelementptr inbounds i8, i8* %56, i64 16
%59 = bitcast i8* %58 to <16 x i8>*
store <16 x i8> %55, <16 x i8>* %59
%60 = add nuw i64 %33, 64
%61 = add i64 %34, 2
%62 = icmp eq i64 %61, %31
br i1 %62, label %63, label %32
63: ; preds = %32, %23
%64 = phi i64 [ 0, %23 ], [ %60, %32 ]
%65 = icmp eq i64 %28, 0
br i1 %65, label %79, label %66
66: ; preds = %63
%67 = add i64 %18, %64
%68 = add nuw nsw i64 %67, 1
%69 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %68
%70 = bitcast i8* %69 to <16 x i8>*
%71 = load <16 x i8>, <16 x i8>* %70
%72 = getelementptr inbounds i8, i8* %69, i64 16
%73 = bitcast i8* %72 to <16 x i8>*
%74 = load <16 x i8>, <16 x i8>* %73
%75 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %67
%76 = bitcast i8* %75 to <16 x i8>*
store <16 x i8> %71, <16 x i8>* %76
%77 = getelementptr inbounds i8, i8* %75, i64 16
%78 = bitcast i8* %77 to <16 x i8>*
store <16 x i8> %74, <16 x i8>* %78
br label %79
79: ; preds = %63, %66
%80 = icmp eq i64 %19, %24
br i1 %80, label %112, label %81
81: ; preds = %79
%82 = add nsw i64 %18, %24
%83 = and i64 %19, 24
%84 = icmp eq i64 %83, 0
br i1 %84, label %103, label %85
85: ; preds = %21, %81
%86 = phi i64 [ %24, %81 ], [ 0, %21 ]
%87 = sub nsw i64 11, %18
%88 = and i64 %87, -8
%89 = add nsw i64 %18, %88
br label %90
90: ; preds = %90, %85
%91 = phi i64 [ %86, %85 ], [ %99, %90 ]
%92 = add i64 %18, %91
%93 = add nuw nsw i64 %92, 1
%94 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %93
%95 = bitcast i8* %94 to <8 x i8>*
%96 = load <8 x i8>, <8 x i8>* %95
%97 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %92
%98 = bitcast i8* %97 to <8 x i8>*
store <8 x i8> %96, <8 x i8>* %98
%99 = add nuw i64 %91, 8
%100 = icmp eq i64 %99, %88
br i1 %100, label %101, label %90
101: ; preds = %90
%102 = icmp eq i64 %87, %88
br i1 %102, label %112, label %103
103: ; preds = %17, %81, %101
%104 = phi i64 [ %18, %17 ], [ %82, %81 ], [ %89, %101 ]
br label %105
105: ; preds = %103, %105
%106 = phi i64 [ %107, %105 ], [ %104, %103 ]
%107 = add nuw nsw i64 %106, 1
%108 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %107
%109 = load i8, i8* %108
%110 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %106
store i8 %109, i8* %110
%111 = icmp eq i64 %107, 11
br i1 %111, label %112, label %105
112: ; preds = %105, %79, %101, %13
%113 = getelementptr inbounds i8, i8* %0, i64 21
%114 = load i8, i8* %113
%115 = getelementptr inbounds i8, i8* %0, i64 22
%116 = load i8, i8* %115
br label %117
117: ; preds = %117, %112
%118 = phi i64 [ %122, %117 ], [ 0, %112 ]
%119 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %118
%120 = load i8, i8* %119
%121 = icmp eq i8 %116, %120
%122 = add nuw i64 %118, 1
br i1 %121, label %123, label %117
123: ; preds = %117
%124 = trunc i64 %118 to i32
%125 = icmp ult i32 %124, 10
br i1 %125, label %126, label %221
126: ; preds = %123
%127 = and i64 %118, 4294967295
%128 = sub nsw i64 10, %127
%129 = icmp ult i64 %128, 8
br i1 %129, label %212, label %130
130: ; preds = %126
%131 = icmp ult i64 %128, 32
br i1 %131, label %194, label %132
132: ; preds = %130
%133 = and i64 %128, -32
%134 = add nsw i64 %133, -32
%135 = lshr exact i64 %134, 5
%136 = add nuw nsw i64 %135, 1
%137 = and i64 %136, 1
%138 = icmp eq i64 %134, 0
br i1 %138, label %172, label %139
139: ; preds = %132
%140 = and i64 %136, 1152921504606846974
br label %141
141: ; preds = %141, %139
%142 = phi i64 [ 0, %139 ], [ %169, %141 ]
%143 = phi i64 [ 0, %139 ], [ %170, %141 ]
%144 = add i64 %127, %142
%145 = add nuw nsw i64 %144, 1
%146 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %145
%147 = bitcast i8* %146 to <16 x i8>*
%148 = load <16 x i8>, <16 x i8>* %147
%149 = getelementptr inbounds i8, i8* %146, i64 16
%150 = bitcast i8* %149 to <16 x i8>*
%151 = load <16 x i8>, <16 x i8>* %150
%152 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %144
%153 = bitcast i8* %152 to <16 x i8>*
store <16 x i8> %148, <16 x i8>* %153
%154 = getelementptr inbounds i8, i8* %152, i64 16
%155 = bitcast i8* %154 to <16 x i8>*
store <16 x i8> %151, <16 x i8>* %155
%156 = or i64 %142, 32
%157 = add i64 %127, %156
%158 = add nuw nsw i64 %157, 1
%159 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %158
%160 = bitcast i8* %159 to <16 x i8>*
%161 = load <16 x i8>, <16 x i8>* %160
%162 = getelementptr inbounds i8, i8* %159, i64 16
%163 = bitcast i8* %162 to <16 x i8>*
%164 = load <16 x i8>, <16 x i8>* %163
%165 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %157
%166 = bitcast i8* %165 to <16 x i8>*
store <16 x i8> %161, <16 x i8>* %166
%167 = getelementptr inbounds i8, i8* %165, i64 16
%168 = bitcast i8* %167 to <16 x i8>*
store <16 x i8> %164, <16 x i8>* %168
%169 = add nuw i64 %142, 64
%170 = add i64 %143, 2
%171 = icmp eq i64 %170, %140
br i1 %171, label %172, label %141
172: ; preds = %141, %132
%173 = phi i64 [ 0, %132 ], [ %169, %141 ]
%174 = icmp eq i64 %137, 0
br i1 %174, label %188, label %175
175: ; preds = %172
%176 = add i64 %127, %173
%177 = add nuw nsw i64 %176, 1
%178 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %177
%179 = bitcast i8* %178 to <16 x i8>*
%180 = load <16 x i8>, <16 x i8>* %179
%181 = getelementptr inbounds i8, i8* %178, i64 16
%182 = bitcast i8* %181 to <16 x i8>*
%183 = load <16 x i8>, <16 x i8>* %182
%184 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %176
%185 = bitcast i8* %184 to <16 x i8>*
store <16 x i8> %180, <16 x i8>* %185
%186 = getelementptr inbounds i8, i8* %184, i64 16
%187 = bitcast i8* %186 to <16 x i8>*
store <16 x i8> %183, <16 x i8>* %187
br label %188
188: ; preds = %172, %175
%189 = icmp eq i64 %128, %133
br i1 %189, label %221, label %190
190: ; preds = %188
%191 = add nsw i64 %127, %133
%192 = and i64 %128, 24
%193 = icmp eq i64 %192, 0
br i1 %193, label %212, label %194
194: ; preds = %130, %190
%195 = phi i64 [ %133, %190 ], [ 0, %130 ]
%196 = sub nsw i64 10, %127
%197 = and i64 %196, -8
%198 = add nsw i64 %127, %197
br label %199
199: ; preds = %199, %194
%200 = phi i64 [ %195, %194 ], [ %208, %199 ]
%201 = add i64 %127, %200
%202 = add nuw nsw i64 %201, 1
%203 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %202
%204 = bitcast i8* %203 to <8 x i8>*
%205 = load <8 x i8>, <8 x i8>* %204
%206 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %201
%207 = bitcast i8* %206 to <8 x i8>*
store <8 x i8> %205, <8 x i8>* %207
%208 = add nuw i64 %200, 8
%209 = icmp eq i64 %208, %197
br i1 %209, label %210, label %199
210: ; preds = %199
%211 = icmp eq i64 %196, %197
br i1 %211, label %221, label %212
212: ; preds = %126, %190, %210
%213 = phi i64 [ %127, %126 ], [ %191, %190 ], [ %198, %210 ]
br label %214
214: ; preds = %212, %214
%215 = phi i64 [ %216, %214 ], [ %213, %212 ]
%216 = add nuw nsw i64 %215, 1
%217 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %216
%218 = load i8, i8* %217
%219 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %215
store i8 %218, i8* %219
%220 = icmp eq i64 %216, 10
br i1 %220, label %221, label %214
221: ; preds = %214, %188, %210, %123
%222 = getelementptr inbounds i8, i8* %0, i64 23
%223 = load i8, i8* %222
%224 = getelementptr inbounds i8, i8* %0, i64 26
%225 = load i8, i8* %224
br label %226
226: ; preds = %226, %221
%227 = phi i64 [ %231, %226 ], [ 0, %221 ]
%228 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %227
%229 = load i8, i8* %228
%230 = icmp eq i8 %225, %229
%231 = add nuw i64 %227, 1
br i1 %230, label %232, label %226
232: ; preds = %226
%233 = trunc i64 %227 to i32
%234 = icmp ult i32 %233, 9
br i1 %234, label %235, label %330
235: ; preds = %232
%236 = and i64 %227, 4294967295
%237 = sub nsw i64 9, %236
%238 = icmp ult i64 %237, 8
br i1 %238, label %321, label %239
239: ; preds = %235
%240 = icmp ult i64 %237, 32
br i1 %240, label %303, label %241
241: ; preds = %239
%242 = and i64 %237, -32
%243 = add nsw i64 %242, -32
%244 = lshr exact i64 %243, 5
%245 = add nuw nsw i64 %244, 1
%246 = and i64 %245, 1
%247 = icmp eq i64 %243, 0
br i1 %247, label %281, label %248
248: ; preds = %241
%249 = and i64 %245, 1152921504606846974
br label %250
250: ; preds = %250, %248
%251 = phi i64 [ 0, %248 ], [ %278, %250 ]
%252 = phi i64 [ 0, %248 ], [ %279, %250 ]
%253 = add i64 %236, %251
%254 = add nuw nsw i64 %253, 1
%255 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %254
%256 = bitcast i8* %255 to <16 x i8>*
%257 = load <16 x i8>, <16 x i8>* %256
%258 = getelementptr inbounds i8, i8* %255, i64 16
%259 = bitcast i8* %258 to <16 x i8>*
%260 = load <16 x i8>, <16 x i8>* %259
%261 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %253
%262 = bitcast i8* %261 to <16 x i8>*
store <16 x i8> %257, <16 x i8>* %262
%263 = getelementptr inbounds i8, i8* %261, i64 16
%264 = bitcast i8* %263 to <16 x i8>*
store <16 x i8> %260, <16 x i8>* %264
%265 = or i64 %251, 32
%266 = add i64 %236, %265
%267 = add nuw nsw i64 %266, 1
%268 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %267
%269 = bitcast i8* %268 to <16 x i8>*
%270 = load <16 x i8>, <16 x i8>* %269
%271 = getelementptr inbounds i8, i8* %268, i64 16
%272 = bitcast i8* %271 to <16 x i8>*
%273 = load <16 x i8>, <16 x i8>* %272
%274 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %266
%275 = bitcast i8* %274 to <16 x i8>*
store <16 x i8> %270, <16 x i8>* %275
%276 = getelementptr inbounds i8, i8* %274, i64 16
%277 = bitcast i8* %276 to <16 x i8>*
store <16 x i8> %273, <16 x i8>* %277
%278 = add nuw i64 %251, 64
%279 = add i64 %252, 2
%280 = icmp eq i64 %279, %249
br i1 %280, label %281, label %250
281: ; preds = %250, %241
%282 = phi i64 [ 0, %241 ], [ %278, %250 ]
%283 = icmp eq i64 %246, 0
br i1 %283, label %297, label %284
284: ; preds = %281
%285 = add i64 %236, %282
%286 = add nuw nsw i64 %285, 1
%287 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %286
%288 = bitcast i8* %287 to <16 x i8>*
%289 = load <16 x i8>, <16 x i8>* %288
%290 = getelementptr inbounds i8, i8* %287, i64 16
%291 = bitcast i8* %290 to <16 x i8>*
%292 = load <16 x i8>, <16 x i8>* %291
%293 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %285
%294 = bitcast i8* %293 to <16 x i8>*
store <16 x i8> %289, <16 x i8>* %294
%295 = getelementptr inbounds i8, i8* %293, i64 16
%296 = bitcast i8* %295 to <16 x i8>*
store <16 x i8> %292, <16 x i8>* %296
br label %297
297: ; preds = %281, %284
%298 = icmp eq i64 %237, %242
br i1 %298, label %330, label %299
299: ; preds = %297
%300 = add nsw i64 %236, %242
%301 = and i64 %237, 24
%302 = icmp eq i64 %301, 0
br i1 %302, label %321, label %303
303: ; preds = %239, %299
%304 = phi i64 [ %242, %299 ], [ 0, %239 ]
%305 = sub nsw i64 9, %236
%306 = and i64 %305, -8
%307 = add nsw i64 %236, %306
br label %308
308: ; preds = %308, %303
%309 = phi i64 [ %304, %303 ], [ %317, %308 ]
%310 = add i64 %236, %309
%311 = add nuw nsw i64 %310, 1
%312 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %311
%313 = bitcast i8* %312 to <8 x i8>*
%314 = load <8 x i8>, <8 x i8>* %313
%315 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %310
%316 = bitcast i8* %315 to <8 x i8>*
store <8 x i8> %314, <8 x i8>* %316
%317 = add nuw i64 %309, 8
%318 = icmp eq i64 %317, %306
br i1 %318, label %319, label %308
319: ; preds = %308
%320 = icmp eq i64 %305, %306
br i1 %320, label %330, label %321
321: ; preds = %235, %299, %319
%322 = phi i64 [ %236, %235 ], [ %300, %299 ], [ %307, %319 ]
br label %323
323: ; preds = %321, %323
%324 = phi i64 [ %325, %323 ], [ %322, %321 ]
%325 = add nuw nsw i64 %324, 1
%326 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %325
%327 = load i8, i8* %326
%328 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %324
store i8 %327, i8* %328
%329 = icmp eq i64 %325, 9
br i1 %329, label %330, label %323
330: ; preds = %323, %297, %319, %232
%331 = getelementptr inbounds i8, i8* %0, i64 27
%332 = load i8, i8* %331
%333 = getelementptr inbounds i8, i8* %0, i64 30
%334 = load i8, i8* %333
br label %335
335: ; preds = %335, %330
%336 = phi i64 [ %340, %335 ], [ 0, %330 ]
%337 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %336
%338 = load i8, i8* %337
%339 = icmp eq i8 %334, %338
%340 = add nuw i64 %336, 1
br i1 %339, label %341, label %335
341: ; preds = %335
%342 = trunc i64 %336 to i32
%343 = icmp ult i32 %342, 8
br i1 %343, label %344, label %439
344: ; preds = %341
%345 = and i64 %336, 4294967295
%346 = sub nsw i64 8, %345
%347 = icmp ult i64 %346, 8
br i1 %347, label %430, label %348
348: ; preds = %344
%349 = icmp ult i64 %346, 32
br i1 %349, label %412, label %350
350: ; preds = %348
%351 = and i64 %346, -32
%352 = add nsw i64 %351, -32
%353 = lshr exact i64 %352, 5
%354 = add nuw nsw i64 %353, 1
%355 = and i64 %354, 1
%356 = icmp eq i64 %352, 0
br i1 %356, label %390, label %357
357: ; preds = %350
%358 = and i64 %354, 1152921504606846974
br label %359
359: ; preds = %359, %357
%360 = phi i64 [ 0, %357 ], [ %387, %359 ]
%361 = phi i64 [ 0, %357 ], [ %388, %359 ]
%362 = add i64 %345, %360
%363 = add nuw nsw i64 %362, 1
%364 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %363
%365 = bitcast i8* %364 to <16 x i8>*
%366 = load <16 x i8>, <16 x i8>* %365
%367 = getelementptr inbounds i8, i8* %364, i64 16
%368 = bitcast i8* %367 to <16 x i8>*
%369 = load <16 x i8>, <16 x i8>* %368
%370 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %362
%371 = bitcast i8* %370 to <16 x i8>*
store <16 x i8> %366, <16 x i8>* %371
%372 = getelementptr inbounds i8, i8* %370, i64 16
%373 = bitcast i8* %372 to <16 x i8>*
store <16 x i8> %369, <16 x i8>* %373
%374 = or i64 %360, 32
%375 = add i64 %345, %374
%376 = add nuw nsw i64 %375, 1
%377 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %376
%378 = bitcast i8* %377 to <16 x i8>*
%379 = load <16 x i8>, <16 x i8>* %378
%380 = getelementptr inbounds i8, i8* %377, i64 16
%381 = bitcast i8* %380 to <16 x i8>*
%382 = load <16 x i8>, <16 x i8>* %381
%383 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %375
%384 = bitcast i8* %383 to <16 x i8>*
store <16 x i8> %379, <16 x i8>* %384
%385 = getelementptr inbounds i8, i8* %383, i64 16
%386 = bitcast i8* %385 to <16 x i8>*
store <16 x i8> %382, <16 x i8>* %386
%387 = add nuw i64 %360, 64
%388 = add i64 %361, 2
%389 = icmp eq i64 %388, %358
br i1 %389, label %390, label %359
390: ; preds = %359, %350
%391 = phi i64 [ 0, %350 ], [ %387, %359 ]
%392 = icmp eq i64 %355, 0
br i1 %392, label %406, label %393
393: ; preds = %390
%394 = add i64 %345, %391
%395 = add nuw nsw i64 %394, 1
%396 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %395
%397 = bitcast i8* %396 to <16 x i8>*
%398 = load <16 x i8>, <16 x i8>* %397
%399 = getelementptr inbounds i8, i8* %396, i64 16
%400 = bitcast i8* %399 to <16 x i8>*
%401 = load <16 x i8>, <16 x i8>* %400
%402 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %394
%403 = bitcast i8* %402 to <16 x i8>*
store <16 x i8> %398, <16 x i8>* %403
%404 = getelementptr inbounds i8, i8* %402, i64 16
%405 = bitcast i8* %404 to <16 x i8>*
store <16 x i8> %401, <16 x i8>* %405
br label %406
406: ; preds = %390, %393
%407 = icmp eq i64 %346, %351
br i1 %407, label %439, label %408
408: ; preds = %406
%409 = add nsw i64 %345, %351
%410 = and i64 %346, 24
%411 = icmp eq i64 %410, 0
br i1 %411, label %430, label %412
412: ; preds = %348, %408
%413 = phi i64 [ %351, %408 ], [ 0, %348 ]
%414 = sub nsw i64 8, %345
%415 = and i64 %414, -8
%416 = add nsw i64 %345, %415
br label %417
417: ; preds = %417, %412
%418 = phi i64 [ %413, %412 ], [ %426, %417 ]
%419 = add i64 %345, %418
%420 = add nuw nsw i64 %419, 1
%421 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %420
%422 = bitcast i8* %421 to <8 x i8>*
%423 = load <8 x i8>, <8 x i8>* %422
%424 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %419
%425 = bitcast i8* %424 to <8 x i8>*
store <8 x i8> %423, <8 x i8>* %425
%426 = add nuw i64 %418, 8
%427 = icmp eq i64 %426, %415
br i1 %427, label %428, label %417
428: ; preds = %417
%429 = icmp eq i64 %414, %415
br i1 %429, label %439, label %430
430: ; preds = %344, %408, %428
%431 = phi i64 [ %345, %344 ], [ %409, %408 ], [ %416, %428 ]
br label %432
432: ; preds = %430, %432
%433 = phi i64 [ %434, %432 ], [ %431, %430 ]
%434 = add nuw nsw i64 %433, 1
%435 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %434
%436 = load i8, i8* %435
%437 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %433
store i8 %436, i8* %437
%438 = icmp eq i64 %434, 8
br i1 %438, label %439, label %432
439: ; preds = %432, %406, %428, %341
%440 = getelementptr inbounds i8, i8* %0, i64 31
%441 = load i8, i8* %440
%442 = getelementptr inbounds i8, i8* %0, i64 32
%443 = load i8, i8* %442
br label %444
444: ; preds = %444, %439
%445 = phi i64 [ %449, %444 ], [ 0, %439 ]
%446 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %445
%447 = load i8, i8* %446
%448 = icmp eq i8 %443, %447
%449 = add nuw i64 %445, 1
br i1 %448, label %450, label %444
450: ; preds = %444
%451 = trunc i64 %445 to i32
%452 = icmp ult i32 %451, 7
br i1 %452, label %453, label %548
453: ; preds = %450
%454 = and i64 %445, 4294967295
%455 = sub nsw i64 7, %454
%456 = icmp ult i64 %455, 8
br i1 %456, label %539, label %457
457: ; preds = %453
%458 = icmp ult i64 %455, 32
br i1 %458, label %521, label %459
459: ; preds = %457
%460 = and i64 %455, -32
%461 = add nsw i64 %460, -32
%462 = lshr exact i64 %461, 5
%463 = add nuw nsw i64 %462, 1
%464 = and i64 %463, 1
%465 = icmp eq i64 %461, 0
br i1 %465, label %499, label %466
466: ; preds = %459
%467 = and i64 %463, 1152921504606846974
br label %468
468: ; preds = %468, %466
%469 = phi i64 [ 0, %466 ], [ %496, %468 ]
%470 = phi i64 [ 0, %466 ], [ %497, %468 ]
%471 = add i64 %454, %469
%472 = add nuw nsw i64 %471, 1
%473 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %472
%474 = bitcast i8* %473 to <16 x i8>*
%475 = load <16 x i8>, <16 x i8>* %474
%476 = getelementptr inbounds i8, i8* %473, i64 16
%477 = bitcast i8* %476 to <16 x i8>*
%478 = load <16 x i8>, <16 x i8>* %477
%479 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %471
%480 = bitcast i8* %479 to <16 x i8>*
store <16 x i8> %475, <16 x i8>* %480
%481 = getelementptr inbounds i8, i8* %479, i64 16
%482 = bitcast i8* %481 to <16 x i8>*
store <16 x i8> %478, <16 x i8>* %482
%483 = or i64 %469, 32
%484 = add i64 %454, %483
%485 = add nuw nsw i64 %484, 1
%486 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %485
%487 = bitcast i8* %486 to <16 x i8>*
%488 = load <16 x i8>, <16 x i8>* %487
%489 = getelementptr inbounds i8, i8* %486, i64 16
%490 = bitcast i8* %489 to <16 x i8>*
%491 = load <16 x i8>, <16 x i8>* %490
%492 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %484
%493 = bitcast i8* %492 to <16 x i8>*
store <16 x i8> %488, <16 x i8>* %493
%494 = getelementptr inbounds i8, i8* %492, i64 16
%495 = bitcast i8* %494 to <16 x i8>*
store <16 x i8> %491, <16 x i8>* %495
%496 = add nuw i64 %469, 64
%497 = add i64 %470, 2
%498 = icmp eq i64 %497, %467
br i1 %498, label %499, label %468
499: ; preds = %468, %459
%500 = phi i64 [ 0, %459 ], [ %496, %468 ]
%501 = icmp eq i64 %464, 0
br i1 %501, label %515, label %502
502: ; preds = %499
%503 = add i64 %454, %500
%504 = add nuw nsw i64 %503, 1
%505 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %504
%506 = bitcast i8* %505 to <16 x i8>*
%507 = load <16 x i8>, <16 x i8>* %506
%508 = getelementptr inbounds i8, i8* %505, i64 16
%509 = bitcast i8* %508 to <16 x i8>*
%510 = load <16 x i8>, <16 x i8>* %509
%511 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %503
%512 = bitcast i8* %511 to <16 x i8>*
store <16 x i8> %507, <16 x i8>* %512
%513 = getelementptr inbounds i8, i8* %511, i64 16
%514 = bitcast i8* %513 to <16 x i8>*
store <16 x i8> %510, <16 x i8>* %514
br label %515
515: ; preds = %499, %502
%516 = icmp eq i64 %455, %460
br i1 %516, label %548, label %517
517: ; preds = %515
%518 = add nsw i64 %454, %460
%519 = and i64 %455, 24
%520 = icmp eq i64 %519, 0
br i1 %520, label %539, label %521
521: ; preds = %457, %517
%522 = phi i64 [ %460, %517 ], [ 0, %457 ]
%523 = sub nsw i64 7, %454
%524 = and i64 %523, -8
%525 = add nsw i64 %454, %524
br label %526
526: ; preds = %526, %521
%527 = phi i64 [ %522, %521 ], [ %535, %526 ]
%528 = add i64 %454, %527
%529 = add nuw nsw i64 %528, 1
%530 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %529
%531 = bitcast i8* %530 to <8 x i8>*
%532 = load <8 x i8>, <8 x i8>* %531
%533 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %528
%534 = bitcast i8* %533 to <8 x i8>*
store <8 x i8> %532, <8 x i8>* %534
%535 = add nuw i64 %527, 8
%536 = icmp eq i64 %535, %524
br i1 %536, label %537, label %526
537: ; preds = %526
%538 = icmp eq i64 %523, %524
br i1 %538, label %548, label %539
539: ; preds = %453, %517, %537
%540 = phi i64 [ %454, %453 ], [ %518, %517 ], [ %525, %537 ]
br label %541
541: ; preds = %539, %541
%542 = phi i64 [ %543, %541 ], [ %540, %539 ]
%543 = add nuw nsw i64 %542, 1
%544 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %543
%545 = load i8, i8* %544
%546 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %542
store i8 %545, i8* %546
%547 = icmp eq i64 %543, 7
br i1 %547, label %548, label %541
548: ; preds = %541, %515, %537, %450
%549 = getelementptr inbounds i8, i8* %0, i64 33
%550 = load i8, i8* %549
%551 = getelementptr inbounds i8, i8* %0, i64 36
%552 = load i8, i8* %551
br label %553
553: ; preds = %553, %548
%554 = phi i64 [ %558, %553 ], [ 0, %548 ]
%555 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %554
%556 = load i8, i8* %555
%557 = icmp eq i8 %552, %556
%558 = add nuw i64 %554, 1
br i1 %557, label %559, label %553
559: ; preds = %553
%560 = trunc i64 %554 to i32
%561 = icmp ult i32 %560, 6
br i1 %561, label %562, label %657
562: ; preds = %559
%563 = and i64 %554, 4294967295
%564 = sub nsw i64 6, %563
%565 = icmp ult i64 %564, 8
br i1 %565, label %648, label %566
566: ; preds = %562
%567 = icmp ult i64 %564, 32
br i1 %567, label %630, label %568
568: ; preds = %566
%569 = and i64 %564, -32
%570 = add nsw i64 %569, -32
%571 = lshr exact i64 %570, 5
%572 = add nuw nsw i64 %571, 1
%573 = and i64 %572, 1
%574 = icmp eq i64 %570, 0
br i1 %574, label %608, label %575
575: ; preds = %568
%576 = and i64 %572, 1152921504606846974
br label %577
577: ; preds = %577, %575
%578 = phi i64 [ 0, %575 ], [ %605, %577 ]
%579 = phi i64 [ 0, %575 ], [ %606, %577 ]
%580 = add i64 %563, %578
%581 = add nuw nsw i64 %580, 1
%582 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %581
%583 = bitcast i8* %582 to <16 x i8>*
%584 = load <16 x i8>, <16 x i8>* %583
%585 = getelementptr inbounds i8, i8* %582, i64 16
%586 = bitcast i8* %585 to <16 x i8>*
%587 = load <16 x i8>, <16 x i8>* %586
%588 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %580
%589 = bitcast i8* %588 to <16 x i8>*
store <16 x i8> %584, <16 x i8>* %589
%590 = getelementptr inbounds i8, i8* %588, i64 16
%591 = bitcast i8* %590 to <16 x i8>*
store <16 x i8> %587, <16 x i8>* %591
%592 = or i64 %578, 32
%593 = add i64 %563, %592
%594 = add nuw nsw i64 %593, 1
%595 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %594
%596 = bitcast i8* %595 to <16 x i8>*
%597 = load <16 x i8>, <16 x i8>* %596
%598 = getelementptr inbounds i8, i8* %595, i64 16
%599 = bitcast i8* %598 to <16 x i8>*
%600 = load <16 x i8>, <16 x i8>* %599
%601 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %593
%602 = bitcast i8* %601 to <16 x i8>*
store <16 x i8> %597, <16 x i8>* %602
%603 = getelementptr inbounds i8, i8* %601, i64 16
%604 = bitcast i8* %603 to <16 x i8>*
store <16 x i8> %600, <16 x i8>* %604
%605 = add nuw i64 %578, 64
%606 = add i64 %579, 2
%607 = icmp eq i64 %606, %576
br i1 %607, label %608, label %577
608: ; preds = %577, %568
%609 = phi i64 [ 0, %568 ], [ %605, %577 ]
%610 = icmp eq i64 %573, 0
br i1 %610, label %624, label %611
611: ; preds = %608
%612 = add i64 %563, %609
%613 = add nuw nsw i64 %612, 1
%614 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %613
%615 = bitcast i8* %614 to <16 x i8>*
%616 = load <16 x i8>, <16 x i8>* %615
%617 = getelementptr inbounds i8, i8* %614, i64 16
%618 = bitcast i8* %617 to <16 x i8>*
%619 = load <16 x i8>, <16 x i8>* %618
%620 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %612
%621 = bitcast i8* %620 to <16 x i8>*
store <16 x i8> %616, <16 x i8>* %621
%622 = getelementptr inbounds i8, i8* %620, i64 16
%623 = bitcast i8* %622 to <16 x i8>*
store <16 x i8> %619, <16 x i8>* %623
br label %624
624: ; preds = %608, %611
%625 = icmp eq i64 %564, %569
br i1 %625, label %657, label %626
626: ; preds = %624
%627 = add nsw i64 %563, %569
%628 = and i64 %564, 24
%629 = icmp eq i64 %628, 0
br i1 %629, label %648, label %630
630: ; preds = %566, %626
%631 = phi i64 [ %569, %626 ], [ 0, %566 ]
%632 = sub nsw i64 6, %563
%633 = and i64 %632, -8
%634 = add nsw i64 %563, %633
br label %635
635: ; preds = %635, %630
%636 = phi i64 [ %631, %630 ], [ %644, %635 ]
%637 = add i64 %563, %636
%638 = add nuw nsw i64 %637, 1
%639 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %638
%640 = bitcast i8* %639 to <8 x i8>*
%641 = load <8 x i8>, <8 x i8>* %640
%642 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %637
%643 = bitcast i8* %642 to <8 x i8>*
store <8 x i8> %641, <8 x i8>* %643
%644 = add nuw i64 %636, 8
%645 = icmp eq i64 %644, %633
br i1 %645, label %646, label %635
646: ; preds = %635
%647 = icmp eq i64 %632, %633
br i1 %647, label %657, label %648
648: ; preds = %562, %626, %646
%649 = phi i64 [ %563, %562 ], [ %627, %626 ], [ %634, %646 ]
br label %650
650: ; preds = %648, %650
%651 = phi i64 [ %652, %650 ], [ %649, %648 ]
%652 = add nuw nsw i64 %651, 1
%653 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %652
%654 = load i8, i8* %653
%655 = getelementptr inbounds [12 x i8], [12 x i8]* %2, i64 0, i64 %651
store i8 %654, i8* %655
%656 = icmp eq i64 %652, 6
br i1 %656, label %657, label %650
657: ; preds = %650, %624, %646, %559
%658 = sext i8 %114 to i32
%659 = mul nsw i32 %658, 12
%660 = add nsw i32 %659, %15
%661 = mul nsw i32 %660, 1774080
%662 = sext i8 %223 to i32
%663 = mul nsw i32 %662, 11
%664 = add nsw i32 %663, %124
%665 = mul nsw i32 %664, 80640
%666 = sext i8 %332 to i32
%667 = mul nsw i32 %666, 10
%668 = add nsw i32 %667, %233
%669 = mul nsw i32 %668, 4032
%670 = sext i8 %441 to i32
%671 = mul nsw i32 %670, 9
%672 = add nsw i32 %671, %342
%673 = mul nsw i32 %672, 224
%674 = sext i8 %550 to i32
%675 = shl nsw i32 %674, 3
%676 = add nsw i32 %675, %451
%677 = mul nsw i32 %676, 14
%678 = getelementptr inbounds i8, i8* %0, i64 37
%679 = load i8, i8* %678
%680 = sext i8 %679 to i32
%681 = mul nsw i32 %680, 7
%682 = add i32 %665, %661
%683 = add i32 %682, %669
%684 = add i32 %683, %673
%685 = add i32 %684, %677
%686 = add i32 %685, %560
%687 = add i32 %686, %681
ret i32 %687
}