void test(int M, int N) {
  int c2, c4;
  int i, j;
  if ((M >= 0) && (N >= 0)) {
    for (c2 = -4; c2 <= ((-1) < (3 * M + N - 4) ? (-1) : (3 * M + N - 4));
         c2++) {
      for (c4 = ((0) > (c2 - 3 * M + 4) ? (0) : (c2 - 3 * M + 4));
           c4 <= ((c2 + 4) < (N) ? (c2 + 4) : (N)); c4++) {
        if ((c2 + 2 * c4 + 1) % 3 == 0) {
          i = (c2 - c4 + 4) / 3;
          {
            hash(1);
            hash((c2 - c4 + 4) / 3);
            hash(c4);
          };
        }
      }
    }
  }
  if ((M <= 1) && (M >= 0)) {
    for (c2 = 0; c2 <= 3 * M + N - 4; c2++) {
      for (c4 = ((c2 - 3 * M) > (0) ? (c2 - 3 * M) : (0)); c4 <= c2; c4++) {
        if ((c2 + 2 * c4) % 3 == 0) {
          i = (c2 - c4) / 3;
          {
            hash(2);
            hash((c2 - c4) / 3);
            hash(c4);
          };
        }
      }
      for (c4 = c2 - 3 * M + 4; c4 <= ((c2 + 4) < (N) ? (c2 + 4) : (N)); c4++) {
        if ((c2 + 2 * c4 + 1) % 3 == 0) {
          i = (c2 - c4 + 4) / 3;
          {
            hash(1);
            hash((c2 - c4 + 4) / 3);
            hash(c4);
          };
        }
      }
      for (c4 = ((0) > (c2 - 3 * M) ? (0) : (c2 - 3 * M)); c4 <= c2; c4++) {
        if ((c2 + 2 * c4) % 3 == 0) {
          i = (c2 - c4) / 3;
          {
            hash(3);
            hash((c2 - c4) / 3);
            hash(c4);
          };
        }
      }
    }
  }
  for (c2 = 0; c2 <= ((3 * M - 4) < (N - 1) ? (3 * M - 4) : (N - 1)); c2++) {
    for (c4 = 0; c4 <= c2; c4++) {
      if ((c2 + 2 * c4) % 3 == 0) {
        i = (c2 - c4) / 3;
        {
          hash(2);
          hash((c2 - c4) / 3);
          hash(c4);
        };
      }
      if ((c2 + 2 * c4 + 1) % 3 == 0) {
        i = (c2 - c4 + 4) / 3;
        {
          hash(1);
          hash((c2 - c4 + 4) / 3);
          hash(c4);
        };
      }
    }
    for (c4 = c2 + 1; c4 <= ((c2 + 4) < (N) ? (c2 + 4) : (N)); c4++) {
      if ((c2 + 2 * c4 + 1) % 3 == 0) {
        i = (c2 - c4 + 4) / 3;
        {
          hash(1);
          hash((c2 - c4 + 4) / 3);
          hash(c4);
        };
      }
    }
    for (c4 = 0; c4 <= c2; c4++) {
      if ((c2 + 2 * c4) % 3 == 0) {
        i = (c2 - c4) / 3;
        {
          hash(3);
          hash((c2 - c4) / 3);
          hash(c4);
        };
      }
    }
  }
  if (M >= 2) {
    for (c2 = 3 * M - 3; c2 <= N - 1; c2++) {
      for (c4 = ((c2 - 3 * M) > (0) ? (c2 - 3 * M) : (0)); c4 <= c2 - 3 * M + 3;
           c4++) {
        if ((c2 + 2 * c4) % 3 == 0) {
          i = (c2 - c4) / 3;
          {
            hash(2);
            hash((c2 - c4) / 3);
            hash(c4);
          };
        }
      }
      for (c4 = c2 - 3 * M + 4; c4 <= c2; c4++) {
        if ((c2 + 2 * c4) % 3 == 0) {
          i = (c2 - c4) / 3;
          {
            hash(2);
            hash((c2 - c4) / 3);
            hash(c4);
          };
        }
        if ((c2 + 2 * c4 + 1) % 3 == 0) {
          i = (c2 - c4 + 4) / 3;
          {
            hash(1);
            hash((c2 - c4 + 4) / 3);
            hash(c4);
          };
        }
      }
      for (c4 = c2 + 1; c4 <= ((c2 + 4) < (N) ? (c2 + 4) : (N)); c4++) {
        if ((c2 + 2 * c4 + 1) % 3 == 0) {
          i = (c2 - c4 + 4) / 3;
          {
            hash(1);
            hash((c2 - c4 + 4) / 3);
            hash(c4);
          };
        }
      }
      for (c4 = ((0) > (c2 - 3 * M) ? (0) : (c2 - 3 * M)); c4 <= c2; c4++) {
        if ((c2 + 2 * c4) % 3 == 0) {
          i = (c2 - c4) / 3;
          {
            hash(3);
            hash((c2 - c4) / 3);
            hash(c4);
          };
        }
      }
    }
  }
  if (N >= 0) {
    for (c2 = N; c2 <= 3 * M - 4; c2++) {
      for (c4 = 0; c4 <= N; c4++) {
        if ((c2 + 2 * c4) % 3 == 0) {
          i = (c2 - c4) / 3;
          {
            hash(2);
            hash((c2 - c4) / 3);
            hash(c4);
          };
        }
        if ((c2 + 2 * c4 + 1) % 3 == 0) {
          i = (c2 - c4 + 4) / 3;
          {
            hash(1);
            hash((c2 - c4 + 4) / 3);
            hash(c4);
          };
        }
      }
      for (c4 = 0; c4 <= N; c4++) {
        if ((c2 + 2 * c4) % 3 == 0) {
          i = (c2 - c4) / 3;
          {
            hash(3);
            hash((c2 - c4) / 3);
            hash(c4);
          };
        }
      }
    }
  }
  for (c2 = ((3 * M - 3) > (N) ? (3 * M - 3) : (N)); c2 <= 3 * M + N - 4;
       c2++) {
    for (c4 = ((c2 - 3 * M) > (0) ? (c2 - 3 * M) : (0)); c4 <= c2 - 3 * M + 3;
         c4++) {
      if ((c2 + 2 * c4) % 3 == 0) {
        i = (c2 - c4) / 3;
        {
          hash(2);
          hash((c2 - c4) / 3);
          hash(c4);
        };
      }
    }
    for (c4 = c2 - 3 * M + 4; c4 <= N; c4++) {
      if ((c2 + 2 * c4) % 3 == 0) {
        i = (c2 - c4) / 3;
        {
          hash(2);
          hash((c2 - c4) / 3);
          hash(c4);
        };
      }
      if ((c2 + 2 * c4 + 1) % 3 == 0) {
        i = (c2 - c4 + 4) / 3;
        {
          hash(1);
          hash((c2 - c4 + 4) / 3);
          hash(c4);
        };
      }
    }
    for (c4 = ((0) > (c2 - 3 * M) ? (0) : (c2 - 3 * M)); c4 <= N; c4++) {
      if ((c2 + 2 * c4) % 3 == 0) {
        i = (c2 - c4) / 3;
        {
          hash(3);
          hash((c2 - c4) / 3);
          hash(c4);
        };
      }
    }
  }
  if ((M >= 0) && (N >= 0)) {
    for (c2 = ((3 * M + N - 3) > (0) ? (3 * M + N - 3) : (0)); c2 <= 3 * M + N;
         c2++) {
      for (c4 = ((0) > (c2 - 3 * M) ? (0) : (c2 - 3 * M));
           c4 <= ((c2) < (N) ? (c2) : (N)); c4++) {
        if ((c2 + 2 * c4) % 3 == 0) {
          i = (c2 - c4) / 3;
          {
            hash(2);
            hash((c2 - c4) / 3);
            hash(c4);
          };
        }
      }
      for (c4 = ((0) > (c2 - 3 * M) ? (0) : (c2 - 3 * M));
           c4 <= ((c2) < (N) ? (c2) : (N)); c4++) {
        if ((c2 + 2 * c4) % 3 == 0) {
          i = (c2 - c4) / 3;
          {
            hash(3);
            hash((c2 - c4) / 3);
            hash(c4);
          };
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<test>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
cmpl   $0x0,-0x4(%rbp)
jl     127b <test+0x16b>
cmpl   $0x0,-0x8(%rbp)
jl     127b <test+0x16b>
movl   $0xfffffffc,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x1c(%rbp)
imul   $0x3,-0x4(%rbp),%ecx
add    -0x8(%rbp),%ecx
sub    $0x4,%ecx
mov    $0xffffffff,%eax
cmp    %ecx,%eax
jge    1166 <test+0x56>
mov    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1173 <test+0x63>
imul   $0x3,-0x4(%rbp),%eax
add    -0x8(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jg     1276 <test+0x166>
mov    -0xc(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%eax
sub    %eax,%ecx
add    $0x4,%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    11a1 <test+0x91>
xor    %eax,%eax
mov    %eax,-0x24(%rbp)
jmp    11b0 <test+0xa0>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
cmp    -0x8(%rbp),%eax
jge    11d9 <test+0xc9>
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
jmp    11df <test+0xcf>
mov    -0x8(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x2c(%rbp),%ecx
cmp    %ecx,%eax
jg     1263 <test+0x153>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1250 <test+0x140>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x1,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1255 <test+0x145>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11b6 <test+0xa6>
jmp    1268 <test+0x158>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    113c <test+0x2c>
jmp    127b <test+0x16b>
cmpl   $0x1,-0x4(%rbp)
jg     14d3 <test+0x3c3>
cmpl   $0x0,-0x4(%rbp)
jl     14d3 <test+0x3c3>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
add    -0x8(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jg     14ce <test+0x3be>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jle    12ce <test+0x1be>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
jmp    12d8 <test+0x1c8>
xor    %eax,%eax
mov    %eax,-0x30(%rbp)
jmp    12d8 <test+0x1c8>
mov    -0x30(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1357 <test+0x247>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1344 <test+0x234>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x2,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1349 <test+0x239>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12de <test+0x1ce>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
add    $0x4,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
cmp    -0x8(%rbp),%eax
jge    1389 <test+0x279>
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x38(%rbp)
jmp    138f <test+0x27f>
mov    -0x8(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jg     1413 <test+0x303>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1400 <test+0x2f0>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x1,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1405 <test+0x2f5>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1366 <test+0x256>
mov    -0xc(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    1430 <test+0x320>
xor    %eax,%eax
mov    %eax,-0x3c(%rbp)
jmp    143c <test+0x32c>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14bb <test+0x3ab>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    14a8 <test+0x398>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x3,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    14ad <test+0x39d>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1442 <test+0x332>
jmp    14c0 <test+0x3b0>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1296 <test+0x186>
jmp    14d3 <test+0x3c3>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
imul   $0x3,-0x4(%rbp),%eax
sub    $0x4,%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1504 <test+0x3f4>
imul   $0x3,-0x4(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x44(%rbp)
jmp    150d <test+0x3fd>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jg     1747 <test+0x637>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     15fe <test+0x4ee>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1588 <test+0x478>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x2,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    15eb <test+0x4db>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x1,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    15f0 <test+0x4e0>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1522 <test+0x412>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
cmp    -0x8(%rbp),%eax
jge    162a <test+0x51a>
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x4c(%rbp)
jmp    1630 <test+0x520>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x4c(%rbp),%ecx
cmp    %ecx,%eax
jg     16b4 <test+0x5a4>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    16a1 <test+0x591>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x1,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    16a6 <test+0x596>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1607 <test+0x4f7>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1734 <test+0x624>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1721 <test+0x611>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x3,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1726 <test+0x616>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    16bb <test+0x5ab>
jmp    1739 <test+0x629>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    14da <test+0x3ca>
cmpl   $0x2,-0x4(%rbp)
jl     1a84 <test+0x974>
imul   $0x3,-0x4(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1a7f <test+0x96f>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jle    178f <test+0x67f>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
jmp    1799 <test+0x689>
xor    %eax,%eax
mov    %eax,-0x50(%rbp)
jmp    1799 <test+0x689>
mov    -0x50(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%edx
sub    %edx,%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jg     1823 <test+0x713>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1810 <test+0x700>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x2,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1815 <test+0x705>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    179f <test+0x68f>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
add    $0x4,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     190e <test+0x7fe>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1898 <test+0x788>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x2,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    18fb <test+0x7eb>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x1,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1900 <test+0x7f0>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1832 <test+0x722>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
cmp    -0x8(%rbp),%eax
jge    193a <test+0x82a>
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x58(%rbp)
jmp    1940 <test+0x830>
mov    -0x8(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x58(%rbp),%ecx
cmp    %ecx,%eax
jg     19c4 <test+0x8b4>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    19b1 <test+0x8a1>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x1,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    19b6 <test+0x8a6>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1917 <test+0x807>
mov    -0xc(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    19e1 <test+0x8d1>
xor    %eax,%eax
mov    %eax,-0x5c(%rbp)
jmp    19ed <test+0x8dd>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1a6c <test+0x95c>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1a59 <test+0x949>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x3,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1a5e <test+0x94e>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    19f3 <test+0x8e3>
jmp    1a71 <test+0x961>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    175b <test+0x64b>
jmp    1a84 <test+0x974>
cmpl   $0x0,-0x8(%rbp)
jl     1c21 <test+0xb11>
mov    -0x8(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jg     1c1c <test+0xb0c>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1b89 <test+0xa79>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1b13 <test+0xa03>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x2,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1b76 <test+0xa66>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x1,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1b7b <test+0xa6b>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1aad <test+0x99d>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1c09 <test+0xaf9>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1bf6 <test+0xae6>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x3,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1bfb <test+0xaeb>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1b90 <test+0xa80>
jmp    1c0e <test+0xafe>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1a94 <test+0x984>
jmp    1c21 <test+0xb11>
imul   $0x3,-0x4(%rbp),%eax
sub    $0x3,%eax
cmp    -0x8(%rbp),%eax
jle    1c40 <test+0xb30>
imul   $0x3,-0x4(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x60(%rbp)
jmp    1c46 <test+0xb36>
mov    -0x8(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
add    -0x8(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jg     1ebe <test+0xdae>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jle    1c84 <test+0xb74>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x64(%rbp)
jmp    1c8e <test+0xb7e>
xor    %eax,%eax
mov    %eax,-0x64(%rbp)
jmp    1c8e <test+0xb7e>
mov    -0x64(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%edx
sub    %edx,%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jg     1d18 <test+0xc08>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1d05 <test+0xbf5>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x2,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1d0a <test+0xbfa>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1c94 <test+0xb84>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
add    $0x4,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1e03 <test+0xcf3>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1d8d <test+0xc7d>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x2,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1df0 <test+0xce0>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x1,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
add    $0x4,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1df5 <test+0xce5>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1d27 <test+0xc17>
mov    -0xc(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    1e20 <test+0xd10>
xor    %eax,%eax
mov    %eax,-0x68(%rbp)
jmp    1e2c <test+0xd1c>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1eab <test+0xd9b>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1e98 <test+0xd88>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x3,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1e9d <test+0xd8d>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1e32 <test+0xd22>
jmp    1eb0 <test+0xda0>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1c4c <test+0xb3c>
cmpl   $0x0,-0x4(%rbp)
jl     20d4 <test+0xfc4>
cmpl   $0x0,-0x8(%rbp)
jl     20d4 <test+0xfc4>
imul   $0x3,-0x4(%rbp),%eax
add    -0x8(%rbp),%eax
sub    $0x3,%eax
cmp    $0x0,%eax
jle    1ef7 <test+0xde7>
imul   $0x3,-0x4(%rbp),%eax
add    -0x8(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x6c(%rbp)
jmp    1f01 <test+0xdf1>
xor    %eax,%eax
mov    %eax,-0x6c(%rbp)
jmp    1f01 <test+0xdf1>
mov    -0x6c(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
add    -0x8(%rbp),%ecx
cmp    %ecx,%eax
jg     20cf <test+0xfbf>
mov    -0xc(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    1f36 <test+0xe26>
xor    %eax,%eax
mov    %eax,-0x70(%rbp)
jmp    1f42 <test+0xe32>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1f65 <test+0xe55>
mov    -0xc(%rbp),%eax
mov    %eax,-0x78(%rbp)
jmp    1f6b <test+0xe5b>
mov    -0x8(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x78(%rbp),%ecx
cmp    %ecx,%eax
jg     1fe6 <test+0xed6>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1fd3 <test+0xec3>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x2,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    1fd8 <test+0xec8>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1f48 <test+0xe38>
mov    -0xc(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    2003 <test+0xef3>
xor    %eax,%eax
mov    %eax,-0x7c(%rbp)
jmp    200f <test+0xeff>
mov    -0xc(%rbp),%eax
imul   $0x3,-0x4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2035 <test+0xf25>
mov    -0xc(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    203e <test+0xf2e>
mov    -0x8(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x80(%rbp),%eax
mov    -0x84(%rbp),%ecx
cmp    %ecx,%eax
jg     20bc <test+0xfac>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    20a9 <test+0xf99>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    $0x3,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    $0x0,%al
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <hash@plt>
jmp    20ae <test+0xf9e>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    2015 <test+0xf05>
jmp    20c1 <test+0xfb1>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1f07 <test+0xdf7>
jmp    20d4 <test+0xfc4>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rsi,%rax
mov    %rsi,0x8(%rsp)
mov    %rdi,%rcx
mov    %rdi,0x50(%rsp)
or     %edi,%eax
mov    %eax,0x60(%rsp)
js     1167 <test+0x57>
mov    0x50(%rsp),%rax
lea    (%rax,%rax,2),%edx
mov    0x8(%rsp),%rcx
lea    (%rdx,%rcx,1),%eax
cmp    $0x4,%eax
mov    %rdx,0x20(%rsp)
lea    -0x4(%rcx,%rdx,1),%eax
mov    $0xffffffff,%ecx
cmovl  %eax,%ecx
mov    %ecx,0x18(%rsp)
cmp    $0xfffffffc,%ecx
jae    1e1b <test+0xd0b>
mov    0x50(%rsp),%rcx
lea    (%rcx,%rcx,2),%eax
mov    %rax,0x18(%rsp)
cmp    $0x1,%ecx
ja     13fa <test+0x2ea>
mov    0x8(%rsp),%rax
mov    0x18(%rsp),%rcx
add    %ecx,%eax
add    $0xfffffffc,%eax
js     13fa <test+0x2ea>
mov    0x8(%rsp),%rax
mov    0x18(%rsp),%rcx
add    %ecx,%eax
add    $0xfffffffd,%eax
mov    %eax,0x40(%rsp)
mov    0x50(%rsp),%rax
lea    (%rax,%rax,2),%r14d
neg    %r14d
mov    $0x3,%r12d
sub    %ecx,%r12d
add    %eax,%eax
lea    (%rax,%rax,2),%eax
mov    $0x9,%ebp
sub    %eax,%ebp
xor    %r13d,%r13d
xor    %edx,%edx
jmp    11f5 <test+0xe5>
nopl   (%rax)
add    $0x1,%edx
mov    0x34(%rsp),%r13d
add    $0xffffffff,%r13d
add    $0x1,%r14d
add    $0x1,%r12d
mov    0x10(%rsp),%ebp
add    $0x3,%ebp
cmp    0x40(%rsp),%edx
je     13fa <test+0x2ea>
mov    %r12d,0x48(%rsp)
test   %r14d,%r14d
mov    $0x0,%eax
mov    %r14d,0x14(%rsp)
cmovg  %r14d,%eax
mov    %r13d,0x34(%rsp)
sub    %eax,%r13d
sub    %eax,%r13d
lea    (%rdx,%rax,2),%ecx
mov    %ecx,0x20(%rsp)
mov    %edx,%ecx
sub    %eax,%ecx
mov    %ecx,0x28(%rsp)
mov    %edx,%ecx
sub    0x18(%rsp),%ecx
mov    $0x0,%eax
mov    %ecx,0x10(%rsp)
cmovns %ecx,%eax
mov    %rax,0x38(%rsp)
cmp    %eax,%edx
mov    %rdx,(%rsp)
jae    1370 <test+0x260>
mov    0x10(%rsp),%ecx
add    $0x4,%ecx
lea    0x4(%rdx),%r14d
mov    0x8(%rsp),%rax
cmp    %eax,%r14d
cmovge %eax,%r14d
mov    %ebp,0x10(%rsp)
mov    0x48(%rsp),%r12d
mov    %r12d,%r15d
mov    0x18(%rsp),%rax
mov    %eax,%ebx
cmp    %r14d,%ecx
jle    12ab <test+0x19b>
mov    0x38(%rsp),%r15
cmp    %r15d,%edx
mov    0x14(%rsp),%r14d
mov    0x20(%rsp),%ebp
mov    0x28(%rsp),%ebx
jae    131a <test+0x20a>
jmp    11d0 <test+0xc0>
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%ebx
add    $0x2,%ebp
cmp    %r14d,%r15d
jge    1277 <test+0x167>
add    $0x1,%r15d
imul   $0xaaaaaaab,%ebp,%eax
add    $0x2aaaaaaa,%eax
cmp    $0x55555554,%eax
ja     12a0 <test+0x190>
mov    $0x1,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %ebx,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %r15d,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    (%rsp),%rdx
jmp    12a0 <test+0x190>
nopl   0x0(%rax,%rax,1)
lea    0x1(%r15),%eax
add    $0xfffffffe,%r13d
add    $0x2,%ebp
add    $0xffffffff,%ebx
cmp    %r15d,%edx
mov    %eax,%r15d
jbe    11d0 <test+0xc0>
mov    %ebp,%eax
mov    $0xaaaaaaab,%ecx
imul   %rcx,%rax
shr    $0x21,%rax
lea    (%rax,%rax,2),%eax
add    %r13d,%eax
jne    1300 <test+0x1f0>
mov    $0x3,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %ebx,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %r15d,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    (%rsp),%rdx
jmp    1300 <test+0x1f0>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%r14d
mov    0x20(%rsp),%r15d
mov    %r13d,%r12d
mov    0x38(%rsp),%rbx
jmp    13a9 <test+0x299>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%rbx),%eax
add    $0xfffffffe,%r12d
add    $0x2,%r15d
add    $0xffffffff,%r14d
cmp    %ebx,%edx
mov    %eax,%ebx
jbe    1248 <test+0x138>
mov    %r15d,%eax
mov    $0xaaaaaaab,%ecx
imul   %rcx,%rax
shr    $0x21,%rax
lea    (%rax,%rax,2),%eax
add    %r12d,%eax
jne    1390 <test+0x280>
mov    $0x2,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %r14d,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    (%rsp),%rdx
jmp    1390 <test+0x280>
mov    0x18(%rsp),%rax
lea    -0x4(%rax),%ecx
mov    0x8(%rsp),%rax
add    $0xffffffff,%eax
cmp    %eax,%ecx
mov    %ecx,0x58(%rsp)
cmovl  %ecx,%eax
mov    %eax,0x64(%rsp)
test   %eax,%eax
js     16f3 <test+0x5e3>
mov    $0x1,%r12d
mov    $0x4,%ecx
mov    $0xffffffff,%r13d
movl   $0xfffffffd,0x40(%rsp)
ff
movl   $0x3,0x5c(%rsp)
xor    %r15d,%r15d
movl   $0x0,(%rsp)
jmp    1481 <test+0x371>
nopl   0x0(%rax)
add    $0x1,%r12d
mov    0x48(%rsp),%ecx
add    $0x1,%ecx
mov    0x38(%rsp),%r15d
add    $0xffffffff,%r15d
add    $0xffffffff,%r13d
addl   $0xfffffffd,0x40(%rsp)
addl   $0x3,0x5c(%rsp)
mov    0x28(%rsp),%rax
cmp    0x64(%rsp),%eax
je     16f3 <test+0x5e3>
mov    0x8(%rsp),%rax
cmp    %ecx,%eax
mov    %ecx,0x48(%rsp)
mov    %ecx,%edx
cmovl  %eax,%edx
mov    (%rsp),%eax
mov    %eax,%ecx
neg    %edx
mov    %rdx,0x20(%rsp)
lea    0x4(%rcx),%eax
mov    %eax,0x34(%rsp)
mov    %r12d,0x14(%rsp)
mov    %r12d,%ebp
mov    %r13d,0x10(%rsp)
mov    %ecx,%r12d
mov    %r15d,0x38(%rsp)
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
mov    %ecx,%esi
xor    %ebx,%ebx
jmp    14eb <test+0x3db>
nopw   0x0(%rax,%rax,1)
add    $0x1,%ebx
add    $0xfffffffe,%r15d
add    $0x2,%r12d
add    $0xfffffffe,%r13d
add    $0x2,%ebp
add    $0xffffffff,%esi
jae    15b0 <test+0x4a0>
mov    %r12d,%eax
mov    $0xaaaaaaab,%edx
imul   %rdx,%rax
shr    $0x21,%rax
lea    (%rax,%rax,2),%eax
mov    %ebp,%ecx
imul   %rdx,%rcx
shr    $0x21,%rcx
lea    (%rcx,%rcx,2),%r14d
add    %r13d,%r14d
add    %r15d,%eax
je     1520 <test+0x410>
test   %r14d,%r14d
jne    14d0 <test+0x3c0>
jmp    1565 <test+0x455>
nopl   0x0(%rax,%rax,1)
mov    $0x2,%edi
xor    %eax,%eax
mov    %rsi,(%rsp)
call   1030 <hash@plt>
movslq (%rsp),%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    (%rsp),%rsi
test   %r14d,%r14d
jne    14d0 <test+0x3c0>
lea    0x4(%rsi),%r14d
mov    $0x1,%edi
xor    %eax,%eax
mov    %rsi,(%rsp)
call   1030 <hash@plt>
movslq %r14d,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    (%rsp),%rsi
jmp    14d0 <test+0x3c0>
nopl   0x0(%rax)
mov    0x28(%rsp),%rcx
lea    0x1(%rcx),%eax
mov    %eax,(%rsp)
mov    0x8(%rsp),%rax
mov    0x34(%rsp),%edx
cmp    %eax,%edx
cmovge %eax,%edx
cmp    %edx,%ecx
mov    0x14(%rsp),%r12d
mov    0x10(%rsp),%r13d
jge    1670 <test+0x560>
mov    $0x3,%r14d
mov    0x5c(%rsp),%ebp
mov    0x40(%rsp),%ebx
mov    (%rsp),%eax
mov    %eax,%r15d
jmp    1623 <test+0x513>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
add    %r15d,%eax
add    $0x1,%eax
mov    %r15d,%ecx
add    $0x1,%ecx
add    $0xffffffff,%r14d
add    $0xfffffffe,%ebx
add    $0x2,%ebp
mov    %ecx,%r15d
cmp    $0x1,%eax
je     1670 <test+0x560>
mov    %ebp,%eax
mov    $0xaaaaaaab,%ecx
imul   %rcx,%rax
shr    $0x21,%rax
lea    (%rax,%rax,2),%eax
add    %ebx,%eax
jne    1600 <test+0x4f0>
mov    $0x1,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %r14d,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %r15d,%edi
xor    %eax,%eax
call   1030 <hash@plt>
jmp    1600 <test+0x4f0>
nop
xor    %ebx,%ebx
mov    0x28(%rsp),%rax
mov    %eax,%r14d
mov    %eax,%r15d
mov    0x38(%rsp),%ebp
jmp    16a7 <test+0x597>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%ebx
add    $0xfffffffe,%ebp
add    $0x2,%r15d
add    $0xffffffff,%r14d
cmp    %ebx,%r12d
je     1450 <test+0x340>
mov    %r15d,%eax
mov    $0xaaaaaaab,%ecx
imul   %rcx,%rax
shr    $0x21,%rax
lea    (%rax,%rax,2),%eax
add    %ebp,%eax
jne    1690 <test+0x580>
mov    $0x3,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %r14d,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <hash@plt>
jmp    1690 <test+0x580>
mov    0x18(%rsp),%rax
add    $0xfffffffd,%eax
mov    %rax,0x28(%rsp)
cmpl   $0x2,0x50(%rsp)
jl     1a03 <test+0x8f3>
mov    0x28(%rsp),%rax
cmp    0x8(%rsp),%eax
jge    1a03 <test+0x8f3>
mov    0x50(%rsp),%rax
lea    (%rax,%rax,8),%ecx
add    $0xfffffffa,%ecx
mov    $0xfffffffd,%ebp
mov    0x18(%rsp),%rax
mov    %eax,%r15d
mov    0x28(%rsp),%rax
mov    %eax,%r13d
jmp    1759 <test+0x649>
nopl   0x0(%rax)
add    $0x1,%ebp
add    $0x3,%r15d
mov    0x14(%rsp),%ecx
add    $0x3,%ecx
cmp    0x8(%rsp),%r13d
je     1a03 <test+0x8f3>
mov    %r15d,0x34(%rsp)
mov    %ecx,0x14(%rsp)
mov    %r13d,%r12d
test   %ebp,%ebp
mov    $0x0,%eax
mov    %ebp,0x10(%rsp)
cmovg  %ebp,%eax
lea    (%r12,%rax,2),%ecx
mov    %ecx,0x48(%rsp)
mov    %r13d,%ecx
sub    %eax,%ecx
mov    %ecx,0x20(%rsp)
mov    %r12,0x38(%rsp)
sub    0x18(%rsp),%r12d
mov    $0x0,%eax
cmovns %r12d,%eax
lea    0x3(%r12),%r13d
mov    %rax,(%rsp)
cmp    %r13d,%eax
jle    18e0 <test+0x7d0>
add    $0x4,%r12d
mov    0x38(%rsp),%rax
lea    0x4(%rax),%ecx
mov    %ecx,0x40(%rsp)
cmp    %r12d,%eax
mov    0x34(%rsp),%r15d
jge    1950 <test+0x840>
mov    0x8(%rsp),%rax
mov    0x40(%rsp),%ecx
cmp    %eax,%ecx
cmovge %eax,%ecx
mov    0x38(%rsp),%r12
cmp    %ecx,%r12d
jge    1850 <test+0x740>
mov    %ecx,%r14d
mov    $0x3,%ebp
mov    0x14(%rsp),%ebx
mov    %r12d,%r13d
jmp    17fb <test+0x6eb>
add    $0xffffffff,%ebp
add    $0x2,%ebx
cmp    %r14d,%r13d
jge    1850 <test+0x740>
add    $0x1,%r13d
imul   $0xaaaaaaab,%ebx,%eax
add    $0x2aaaaaaa,%eax
cmp    $0x55555554,%eax
ja     17f0 <test+0x6e0>
mov    $0x1,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %ebp,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %r13d,%edi
xor    %eax,%eax
call   1030 <hash@plt>
jmp    17f0 <test+0x6e0>
nopw   0x0(%rax,%rax,1)
lea    0x1(%r12),%r13d
cmp    (%rsp),%r12d
mov    0x10(%rsp),%ebp
mov    0x48(%rsp),%ebx
jge    188c <test+0x77c>
jmp    1740 <test+0x630>
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%rcx
lea    0x1(%rcx),%eax
add    $0x2,%ebx
addl   $0xffffffff,0x20(%rsp)
cmp    %ecx,%r12d
mov    %rax,(%rsp)
jle    1740 <test+0x630>
imul   $0xaaaaaaab,%ebx,%eax
add    $0x2aaaaaaa,%eax
cmp    $0x55555554,%eax
ja     1870 <test+0x760>
mov    $0x3,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq 0x20(%rsp),%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    (%rsp),%rdi
xor    %eax,%eax
call   1030 <hash@plt>
jmp    1870 <test+0x760>
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%r15d
mov    0x48(%rsp),%r14d
mov    (%rsp),%rbp
jmp    1906 <test+0x7f6>
lea    0x1(%rbp),%eax
add    $0x2,%r14d
add    $0xffffffff,%r15d
cmp    %r13d,%ebp
mov    %eax,%ebp
jge    17a9 <test+0x699>
imul   $0xaaaaaaab,%r14d,%eax
add    $0x2aaaaaaa,%eax
cmp    $0x55555554,%eax
ja     18f0 <test+0x7e0>
mov    $0x2,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %r15d,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebp,%edi
xor    %eax,%eax
call   1030 <hash@plt>
jmp    18f0 <test+0x7e0>
xchg   %ax,%ax
mov    %r15d,%r13d
mov    0x58(%rsp),%eax
mov    %eax,%ebp
jmp    1971 <test+0x861>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12d
add    $0x2,%r13d
add    $0xffffffff,%ebp
jae    17c7 <test+0x6b7>
imul   $0xaaaaaaab,%r13d,%ebx
lea    0x7fffffff(%rbx),%eax
cmp    $0x55555554,%eax
ja     19b9 <test+0x8a9>
mov    $0x2,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %ebp,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %r12d,%edi
xor    %eax,%eax
call   1030 <hash@plt>
add    $0x2aaaaaaa,%ebx
cmp    $0x55555554,%ebx
ja     1960 <test+0x850>
lea    0x4(%rbp),%ebx
mov    $0x1,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %ebx,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %r12d,%edi
xor    %eax,%eax
call   1030 <hash@plt>
jmp    1960 <test+0x850>
cmpl   $0x0,0x8(%rsp)
js     1b6c <test+0xa5c>
mov    0x58(%rsp),%eax
cmp    0x8(%rsp),%eax
jl     1b6c <test+0xa5c>
mov    0x8(%rsp),%rax
mov    %eax,%r15d
not    %r15d
mov    %eax,%r14d
jmp    1a3f <test+0x92f>
nopl   0x0(%rax)
add    $0x1,%r14d
cmp    0x28(%rsp),%r14d
je     1b6c <test+0xa5c>
mov    %r14d,%r13d
mov    %r14d,%r12d
xor    %ebx,%ebx
jmp    1a66 <test+0x956>
nopl   0x0(%rax)
add    $0x1,%ebx
add    $0xffffffff,%r12d
add    $0x2,%r13d
mov    %r15d,%eax
add    %ebx,%eax
je     1b00 <test+0x9f0>
imul   $0xaaaaaaab,%r13d,%ebp
lea    0x2aaaaaaa(%rbp),%eax
cmp    $0x55555554,%eax
ja     1aad <test+0x99d>
mov    $0x2,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %r12d,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <hash@plt>
add    $0xd5555555,%ebp
cmp    $0x55555554,%ebp
ja     1a50 <test+0x940>
lea    0x4(%r12),%ebp
mov    $0x1,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %ebp,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <hash@plt>
jmp    1a50 <test+0x940>
nopl   0x0(%rax,%rax,1)
xor    %ebx,%ebx
mov    %r14d,%r12d
mov    %r14d,%ebp
jmp    1b25 <test+0xa15>
nopw   0x0(%rax,%rax,1)
add    $0x1,%ebx
add    $0x2,%ebp
add    $0xffffffff,%r12d
mov    %r15d,%eax
add    %ebx,%eax
je     1a30 <test+0x920>
imul   $0xaaaaaaab,%ebp,%eax
add    $0x2aaaaaaa,%eax
cmp    $0x55555554,%eax
ja     1b10 <test+0xa00>
mov    $0x3,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %r12d,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <hash@plt>
jmp    1b10 <test+0xa00>
mov    0x8(%rsp),%rax
mov    0x28(%rsp),%rbx
cmp    %eax,%ebx
cmovle %eax,%ebx
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,1),%edx
mov    %rdx,0x40(%rsp)
add    %ecx,%eax
add    $0xfffffffc,%eax
cmp    %eax,%ebx
jle    1bc3 <test+0xab3>
cmpl   $0x0,0x60(%rsp)
js     1bb4 <test+0xaa4>
mov    0x40(%rsp),%rax
lea    -0x3(%rax),%r12d
xor    %r14d,%r14d
cmp    $0x4,%eax
cmovl  %r14d,%r12d
cmp    %eax,%r12d
jle    1f08 <test+0xdf8>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x40(%rsp),%rax
add    $0xfffffffd,%eax
mov    %eax,0x34(%rsp)
mov    %ebx,%ecx
sub    0x18(%rsp),%ecx
lea    0x3(%rcx),%eax
mov    %eax,0x38(%rsp)
lea    (%rbx,%rbx,2),%edx
mov    0x50(%rsp),%rax
add    %eax,%eax
lea    (%rax,%rax,2),%eax
sub    %eax,%edx
add    $0x9,%edx
mov    %edx,0x14(%rsp)
jmp    1c1f <test+0xb0f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%ebx
mov    0x48(%rsp),%rcx
add    $0x1,%ecx
addl   $0x1,0x38(%rsp)
addl   $0x3,0x14(%rsp)
cmp    0x34(%rsp),%ebx
je     1b91 <test+0xa81>
test   %ecx,%ecx
mov    $0x0,%eax
mov    %rcx,0x48(%rsp)
cmovg  %ecx,%eax
lea    -0x1(%rax),%ecx
mov    %ecx,0x20(%rsp)
lea    (%rbx,%rax,2),%r14d
mov    %ebx,%r13d
sub    %eax,%r13d
mov    %rbx,0x28(%rsp)
sub    0x18(%rsp),%ebx
mov    $0x0,%eax
cmovns %ebx,%eax
mov    %rbx,(%rsp)
lea    0x3(%rbx),%r15d
mov    %eax,0x10(%rsp)
cmp    %r15d,%eax
jle    1db0 <test+0xca0>
mov    (%rsp),%rax
add    $0x4,%eax
mov    0x14(%rsp),%r12d
mov    0x38(%rsp),%ebp
mov    0x18(%rsp),%r15
cmp    0x8(%rsp),%eax
jle    1cae <test+0xb9e>
mov    0x10(%rsp),%eax
cmp    0x8(%rsp),%eax
mov    0x28(%rsp),%rbx
mov    0x20(%rsp),%ebp
jle    1d62 <test+0xc52>
jmp    1c00 <test+0xaf0>
nopl   0x0(%rax)
add    $0xffffffff,%r15d
add    $0x2,%r12d
cmp    0x8(%rsp),%ebp
jge    1c80 <test+0xb70>
add    $0x1,%ebp
imul   $0xaaaaaaab,%r12d,%ebx
lea    0x7fffffff(%rbx),%eax
cmp    $0x55555554,%eax
ja     1d00 <test+0xbf0>
lea    -0x4(%r15),%eax
mov    %eax,(%rsp)
mov    $0x2,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq (%rsp),%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebp,%edi
xor    %eax,%eax
call   1030 <hash@plt>
add    $0x2aaaaaaa,%ebx
cmp    $0x55555554,%ebx
ja     1ca0 <test+0xb90>
mov    $0x1,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %r15d,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebp,%edi
xor    %eax,%eax
call   1030 <hash@plt>
jmp    1ca0 <test+0xb90>
cs nopw 0x0(%rax,%rax,1)
add    $0x2,%r14d
add    $0xffffffff,%r13d
cmp    0x8(%rsp),%ebp
jge    1c00 <test+0xaf0>
add    $0x1,%ebp
imul   $0xaaaaaaab,%r14d,%eax
add    $0x2aaaaaaa,%eax
cmp    $0x55555554,%eax
ja     1d50 <test+0xc40>
mov    $0x3,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %r13d,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebp,%edi
xor    %eax,%eax
call   1030 <hash@plt>
jmp    1d50 <test+0xc40>
nopl   (%rax)
mov    %r13d,%ebx
mov    %r14d,%ebp
mov    0x20(%rsp),%r12d
jmp    1dcf <test+0xcbf>
nopl   (%rax)
add    $0x2,%ebp
add    $0xffffffff,%ebx
cmp    %r15d,%r12d
jge    1c65 <test+0xb55>
add    $0x1,%r12d
imul   $0xaaaaaaab,%ebp,%eax
add    $0x2aaaaaaa,%eax
cmp    $0x55555554,%eax
ja     1dc0 <test+0xcb0>
mov    $0x2,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %ebx,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %r12d,%edi
xor    %eax,%eax
call   1030 <hash@plt>
jmp    1dc0 <test+0xcb0>
mov    $0xfffffffc,%r13d
mov    $0xfffffffc,%ebp
sub    0x20(%rsp),%ebp
mov    $0x5,%eax
mov    %rax,(%rsp)
jmp    1e60 <test+0xd50>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%r13),%eax
add    $0x1,%ebp
mov    (%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,(%rsp)
cmp    0x18(%rsp),%r13d
mov    %eax,%r13d
je     1167 <test+0x57>
cmp    $0xfffffffd,%ebp
mov    $0xfffffffc,%eax
cmovge %ebp,%eax
mov    %r13d,%ecx
sub    0x20(%rsp),%ecx
lea    0x4(%rcx),%edx
cmp    $0xfffffffc,%ecx
mov    $0x0,%ecx
cmovl  %ecx,%edx
lea    0x4(%r13),%r14d
mov    0x8(%rsp),%rcx
cmp    %ecx,%r14d
cmovge %ecx,%r14d
cmp    %r14d,%edx
jg     1e40 <test+0xd30>
mov    %r13d,%r15d
sub    %eax,%r15d
mov    %eax,%ebx
add    $0x3,%ebx
mov    (%rsp),%rcx
lea    (%rcx,%rax,2),%r12d
jmp    1ebd <test+0xdad>
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%r15d
add    $0x2,%r12d
cmp    %r14d,%ebx
jge    1e40 <test+0xd30>
add    $0x1,%ebx
imul   $0xaaaaaaab,%r12d,%eax
add    $0x2aaaaaaa,%eax
cmp    $0x55555554,%eax
ja     1eb0 <test+0xda0>
mov    $0x1,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %r15d,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <hash@plt>
jmp    1eb0 <test+0xda0>
mov    %r12d,%ebp
sub    0x18(%rsp),%ebp
jmp    1f36 <test+0xe26>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%r12),%eax
add    $0x1,%ebp
cmp    0x40(%rsp),%r12d
mov    %eax,%r12d
je     1bb4 <test+0xaa4>
test   %ebp,%ebp
mov    $0x0,%eax
cmovg  %ebp,%eax
mov    %r12d,%edx
sub    0x18(%rsp),%edx
cmovs  %r14d,%edx
mov    0x8(%rsp),%rcx
cmp    %ecx,%r12d
cmovl  %r12d,%ecx
cmp    %ecx,%edx
jg     1f20 <test+0xe10>
mov    %edx,0x38(%rsp)
mov    %ebp,0x28(%rsp)
lea    -0x1(%rax),%ebx
lea    (%r12,%rax,2),%r13d
mov    %r12,0x20(%rsp)
mov    %r12d,%r15d
sub    %eax,%r15d
mov    %r15d,%r12d
mov    %r13d,%r14d
mov    %ebx,%ebp
mov    %ecx,(%rsp)
jmp    1f9c <test+0xe8c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%r14d
add    $0xffffffff,%r12d
cmp    %ecx,%ebp
jge    1ff0 <test+0xee0>
add    $0x1,%ebp
imul   $0xaaaaaaab,%r14d,%eax
add    $0x2aaaaaaa,%eax
cmp    $0x55555554,%eax
ja     1f90 <test+0xe80>
mov    $0x2,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %r12d,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebp,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    (%rsp),%ecx
jmp    1f90 <test+0xe80>
nopw   0x0(%rax,%rax,1)
cmp    %ecx,0x38(%rsp)
mov    $0x0,%r14d
mov    0x20(%rsp),%r12
mov    0x28(%rsp),%ebp
jle    2020 <test+0xf10>
jmp    1f20 <test+0xe10>
nopw   0x0(%rax,%rax,1)
add    $0x2,%r13d
add    $0xffffffff,%r15d
cmp    %ecx,%ebx
jge    1f20 <test+0xe10>
add    $0x1,%ebx
imul   $0xaaaaaaab,%r13d,%eax
add    $0x2aaaaaaa,%eax
cmp    $0x55555554,%eax
ja     2010 <test+0xf00>
mov    $0x3,%edi
xor    %eax,%eax
call   1030 <hash@plt>
movslq %r15d,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <hash@plt>
mov    (%rsp),%ecx
jmp    2010 <test+0xf00>

LLVM IR (-O0):
define void @test(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i32 %0, i32* %3
store i32 %1, i32* %4
%9 = load i32, i32* %3
%10 = icmp sge i32 %9, 0
br i1 %10, label %11, label %95
11: ; preds = %2
%12 = load i32, i32* %4
%13 = icmp sge i32 %12, 0
br i1 %13, label %14, label %95
14: ; preds = %11
store i32 -4, i32* %5
br label %15
15: ; preds = %91, %14
%16 = load i32, i32* %5
%17 = load i32, i32* %3
%18 = mul nsw i32 3, %17
%19 = load i32, i32* %4
%20 = add nsw i32 %18, %19
%21 = sub nsw i32 %20, 4
%22 = icmp slt i32 -1, %21
br i1 %22, label %23, label %24
23: ; preds = %15
br label %30
24: ; preds = %15
%25 = load i32, i32* %3
%26 = mul nsw i32 3, %25
%27 = load i32, i32* %4
%28 = add nsw i32 %26, %27
%29 = sub nsw i32 %28, 4
br label %30
30: ; preds = %24, %23
%31 = phi i32 [ -1, %23 ], [ %29, %24 ]
%32 = icmp sle i32 %16, %31
br i1 %32, label %33, label %94
33: ; preds = %30
%34 = load i32, i32* %5
%35 = load i32, i32* %3
%36 = mul nsw i32 3, %35
%37 = sub nsw i32 %34, %36
%38 = add nsw i32 %37, 4
%39 = icmp sgt i32 0, %38
br i1 %39, label %40, label %41
40: ; preds = %33
br label %47
41: ; preds = %33
%42 = load i32, i32* %5
%43 = load i32, i32* %3
%44 = mul nsw i32 3, %43
%45 = sub nsw i32 %42, %44
%46 = add nsw i32 %45, 4
br label %47
47: ; preds = %41, %40
%48 = phi i32 [ 0, %40 ], [ %46, %41 ]
store i32 %48, i32* %6
br label %49
49: ; preds = %87, %47
%50 = load i32, i32* %6
%51 = load i32, i32* %5
%52 = add nsw i32 %51, 4
%53 = load i32, i32* %4
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %58
55: ; preds = %49
%56 = load i32, i32* %5
%57 = add nsw i32 %56, 4
br label %60
58: ; preds = %49
%59 = load i32, i32* %4
br label %60
60: ; preds = %58, %55
%61 = phi i32 [ %57, %55 ], [ %59, %58 ]
%62 = icmp sle i32 %50, %61
br i1 %62, label %63, label %90
63: ; preds = %60
%64 = load i32, i32* %5
%65 = load i32, i32* %6
%66 = mul nsw i32 2, %65
%67 = add nsw i32 %64, %66
%68 = add nsw i32 %67, 1
%69 = srem i32 %68, 3
%70 = icmp eq i32 %69, 0
br i1 %70, label %71, label %86
71: ; preds = %63
%72 = load i32, i32* %5
%73 = load i32, i32* %6
%74 = sub nsw i32 %72, %73
%75 = add nsw i32 %74, 4
%76 = sdiv i32 %75, 3
store i32 %76, i32* %7
%77 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 1)
%78 = load i32, i32* %5
%79 = load i32, i32* %6
%80 = sub nsw i32 %78, %79
%81 = add nsw i32 %80, 4
%82 = sdiv i32 %81, 3
%83 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %82)
%84 = load i32, i32* %6
%85 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %84)
br label %86
86: ; preds = %71, %63
br label %87
87: ; preds = %86
%88 = load i32, i32* %6
%89 = add nsw i32 %88, 1
store i32 %89, i32* %6
br label %49
90: ; preds = %60
br label %91
91: ; preds = %90
%92 = load i32, i32* %5
%93 = add nsw i32 %92, 1
store i32 %93, i32* %5
br label %15
94: ; preds = %30
br label %95
95: ; preds = %94, %11, %2
%96 = load i32, i32* %3
%97 = icmp sle i32 %96, 1
br i1 %97, label %98, label %246
98: ; preds = %95
%99 = load i32, i32* %3
%100 = icmp sge i32 %99, 0
br i1 %100, label %101, label %246
101: ; preds = %98
store i32 0, i32* %5
br label %102
102: ; preds = %242, %101
%103 = load i32, i32* %5
%104 = load i32, i32* %3
%105 = mul nsw i32 3, %104
%106 = load i32, i32* %4
%107 = add nsw i32 %105, %106
%108 = sub nsw i32 %107, 4
%109 = icmp sle i32 %103, %108
br i1 %109, label %110, label %245
110: ; preds = %102
%111 = load i32, i32* %5
%112 = load i32, i32* %3
%113 = mul nsw i32 3, %112
%114 = sub nsw i32 %111, %113
%115 = icmp sgt i32 %114, 0
br i1 %115, label %116, label %121
116: ; preds = %110
%117 = load i32, i32* %5
%118 = load i32, i32* %3
%119 = mul nsw i32 3, %118
%120 = sub nsw i32 %117, %119
br label %122
121: ; preds = %110
br label %122
122: ; preds = %121, %116
%123 = phi i32 [ %120, %116 ], [ 0, %121 ]
store i32 %123, i32* %6
br label %124
124: ; preds = %149, %122
%125 = load i32, i32* %6
%126 = load i32, i32* %5
%127 = icmp sle i32 %125, %126
br i1 %127, label %128, label %152
128: ; preds = %124
%129 = load i32, i32* %5
%130 = load i32, i32* %6
%131 = mul nsw i32 2, %130
%132 = add nsw i32 %129, %131
%133 = srem i32 %132, 3
%134 = icmp eq i32 %133, 0
br i1 %134, label %135, label %148
135: ; preds = %128
%136 = load i32, i32* %5
%137 = load i32, i32* %6
%138 = sub nsw i32 %136, %137
%139 = sdiv i32 %138, 3
store i32 %139, i32* %7
%140 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 2)
%141 = load i32, i32* %5
%142 = load i32, i32* %6
%143 = sub nsw i32 %141, %142
%144 = sdiv i32 %143, 3
%145 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %144)
%146 = load i32, i32* %6
%147 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %146)
br label %148
148: ; preds = %135, %128
br label %149
149: ; preds = %148
%150 = load i32, i32* %6
%151 = add nsw i32 %150, 1
store i32 %151, i32* %6
br label %124
152: ; preds = %124
%153 = load i32, i32* %5
%154 = load i32, i32* %3
%155 = mul nsw i32 3, %154
%156 = sub nsw i32 %153, %155
%157 = add nsw i32 %156, 4
store i32 %157, i32* %6
br label %158
158: ; preds = %196, %152
%159 = load i32, i32* %6
%160 = load i32, i32* %5
%161 = add nsw i32 %160, 4
%162 = load i32, i32* %4
%163 = icmp slt i32 %161, %162
br i1 %163, label %164, label %167
164: ; preds = %158
%165 = load i32, i32* %5
%166 = add nsw i32 %165, 4
br label %169
167: ; preds = %158
%168 = load i32, i32* %4
br label %169
169: ; preds = %167, %164
%170 = phi i32 [ %166, %164 ], [ %168, %167 ]
%171 = icmp sle i32 %159, %170
br i1 %171, label %172, label %199
172: ; preds = %169
%173 = load i32, i32* %5
%174 = load i32, i32* %6
%175 = mul nsw i32 2, %174
%176 = add nsw i32 %173, %175
%177 = add nsw i32 %176, 1
%178 = srem i32 %177, 3
%179 = icmp eq i32 %178, 0
br i1 %179, label %180, label %195
180: ; preds = %172
%181 = load i32, i32* %5
%182 = load i32, i32* %6
%183 = sub nsw i32 %181, %182
%184 = add nsw i32 %183, 4
%185 = sdiv i32 %184, 3
store i32 %185, i32* %7
%186 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 1)
%187 = load i32, i32* %5
%188 = load i32, i32* %6
%189 = sub nsw i32 %187, %188
%190 = add nsw i32 %189, 4
%191 = sdiv i32 %190, 3
%192 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %191)
%193 = load i32, i32* %6
%194 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %193)
br label %195
195: ; preds = %180, %172
br label %196
196: ; preds = %195
%197 = load i32, i32* %6
%198 = add nsw i32 %197, 1
store i32 %198, i32* %6
br label %158
199: ; preds = %169
%200 = load i32, i32* %5
%201 = load i32, i32* %3
%202 = mul nsw i32 3, %201
%203 = sub nsw i32 %200, %202
%204 = icmp sgt i32 0, %203
br i1 %204, label %205, label %206
205: ; preds = %199
br label %211
206: ; preds = %199
%207 = load i32, i32* %5
%208 = load i32, i32* %3
%209 = mul nsw i32 3, %208
%210 = sub nsw i32 %207, %209
br label %211
211: ; preds = %206, %205
%212 = phi i32 [ 0, %205 ], [ %210, %206 ]
store i32 %212, i32* %6
br label %213
213: ; preds = %238, %211
%214 = load i32, i32* %6
%215 = load i32, i32* %5
%216 = icmp sle i32 %214, %215
br i1 %216, label %217, label %241
217: ; preds = %213
%218 = load i32, i32* %5
%219 = load i32, i32* %6
%220 = mul nsw i32 2, %219
%221 = add nsw i32 %218, %220
%222 = srem i32 %221, 3
%223 = icmp eq i32 %222, 0
br i1 %223, label %224, label %237
224: ; preds = %217
%225 = load i32, i32* %5
%226 = load i32, i32* %6
%227 = sub nsw i32 %225, %226
%228 = sdiv i32 %227, 3
store i32 %228, i32* %7
%229 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 3)
%230 = load i32, i32* %5
%231 = load i32, i32* %6
%232 = sub nsw i32 %230, %231
%233 = sdiv i32 %232, 3
%234 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %233)
%235 = load i32, i32* %6
%236 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %235)
br label %237
237: ; preds = %224, %217
br label %238
238: ; preds = %237
%239 = load i32, i32* %6
%240 = add nsw i32 %239, 1
store i32 %240, i32* %6
br label %213
241: ; preds = %213
br label %242
242: ; preds = %241
%243 = load i32, i32* %5
%244 = add nsw i32 %243, 1
store i32 %244, i32* %5
br label %102
245: ; preds = %102
br label %246
246: ; preds = %245, %98, %95
store i32 0, i32* %5
br label %247
247: ; preds = %391, %246
%248 = load i32, i32* %5
%249 = load i32, i32* %3
%250 = mul nsw i32 3, %249
%251 = sub nsw i32 %250, 4
%252 = load i32, i32* %4
%253 = sub nsw i32 %252, 1
%254 = icmp slt i32 %251, %253
br i1 %254, label %255, label %259
255: ; preds = %247
%256 = load i32, i32* %3
%257 = mul nsw i32 3, %256
%258 = sub nsw i32 %257, 4
br label %262
259: ; preds = %247
%260 = load i32, i32* %4
%261 = sub nsw i32 %260, 1
br label %262
262: ; preds = %259, %255
%263 = phi i32 [ %258, %255 ], [ %261, %259 ]
%264 = icmp sle i32 %248, %263
br i1 %264, label %265, label %394
265: ; preds = %262
store i32 0, i32* %6
br label %266
266: ; preds = %314, %265
%267 = load i32, i32* %6
%268 = load i32, i32* %5
%269 = icmp sle i32 %267, %268
br i1 %269, label %270, label %317
270: ; preds = %266
%271 = load i32, i32* %5
%272 = load i32, i32* %6
%273 = mul nsw i32 2, %272
%274 = add nsw i32 %271, %273
%275 = srem i32 %274, 3
%276 = icmp eq i32 %275, 0
br i1 %276, label %277, label %290
277: ; preds = %270
%278 = load i32, i32* %5
%279 = load i32, i32* %6
%280 = sub nsw i32 %278, %279
%281 = sdiv i32 %280, 3
store i32 %281, i32* %7
%282 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 2)
%283 = load i32, i32* %5
%284 = load i32, i32* %6
%285 = sub nsw i32 %283, %284
%286 = sdiv i32 %285, 3
%287 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %286)
%288 = load i32, i32* %6
%289 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %288)
br label %290
290: ; preds = %277, %270
%291 = load i32, i32* %5
%292 = load i32, i32* %6
%293 = mul nsw i32 2, %292
%294 = add nsw i32 %291, %293
%295 = add nsw i32 %294, 1
%296 = srem i32 %295, 3
%297 = icmp eq i32 %296, 0
br i1 %297, label %298, label %313
298: ; preds = %290
%299 = load i32, i32* %5
%300 = load i32, i32* %6
%301 = sub nsw i32 %299, %300
%302 = add nsw i32 %301, 4
%303 = sdiv i32 %302, 3
store i32 %303, i32* %7
%304 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 1)
%305 = load i32, i32* %5
%306 = load i32, i32* %6
%307 = sub nsw i32 %305, %306
%308 = add nsw i32 %307, 4
%309 = sdiv i32 %308, 3
%310 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %309)
%311 = load i32, i32* %6
%312 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %311)
br label %313
313: ; preds = %298, %290
br label %314
314: ; preds = %313
%315 = load i32, i32* %6
%316 = add nsw i32 %315, 1
store i32 %316, i32* %6
br label %266
317: ; preds = %266
%318 = load i32, i32* %5
%319 = add nsw i32 %318, 1
store i32 %319, i32* %6
br label %320
320: ; preds = %358, %317
%321 = load i32, i32* %6
%322 = load i32, i32* %5
%323 = add nsw i32 %322, 4
%324 = load i32, i32* %4
%325 = icmp slt i32 %323, %324
br i1 %325, label %326, label %329
326: ; preds = %320
%327 = load i32, i32* %5
%328 = add nsw i32 %327, 4
br label %331
329: ; preds = %320
%330 = load i32, i32* %4
br label %331
331: ; preds = %329, %326
%332 = phi i32 [ %328, %326 ], [ %330, %329 ]
%333 = icmp sle i32 %321, %332
br i1 %333, label %334, label %361
334: ; preds = %331
%335 = load i32, i32* %5
%336 = load i32, i32* %6
%337 = mul nsw i32 2, %336
%338 = add nsw i32 %335, %337
%339 = add nsw i32 %338, 1
%340 = srem i32 %339, 3
%341 = icmp eq i32 %340, 0
br i1 %341, label %342, label %357
342: ; preds = %334
%343 = load i32, i32* %5
%344 = load i32, i32* %6
%345 = sub nsw i32 %343, %344
%346 = add nsw i32 %345, 4
%347 = sdiv i32 %346, 3
store i32 %347, i32* %7
%348 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 1)
%349 = load i32, i32* %5
%350 = load i32, i32* %6
%351 = sub nsw i32 %349, %350
%352 = add nsw i32 %351, 4
%353 = sdiv i32 %352, 3
%354 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %353)
%355 = load i32, i32* %6
%356 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %355)
br label %357
357: ; preds = %342, %334
br label %358
358: ; preds = %357
%359 = load i32, i32* %6
%360 = add nsw i32 %359, 1
store i32 %360, i32* %6
br label %320
361: ; preds = %331
store i32 0, i32* %6
br label %362
362: ; preds = %387, %361
%363 = load i32, i32* %6
%364 = load i32, i32* %5
%365 = icmp sle i32 %363, %364
br i1 %365, label %366, label %390
366: ; preds = %362
%367 = load i32, i32* %5
%368 = load i32, i32* %6
%369 = mul nsw i32 2, %368
%370 = add nsw i32 %367, %369
%371 = srem i32 %370, 3
%372 = icmp eq i32 %371, 0
br i1 %372, label %373, label %386
373: ; preds = %366
%374 = load i32, i32* %5
%375 = load i32, i32* %6
%376 = sub nsw i32 %374, %375
%377 = sdiv i32 %376, 3
store i32 %377, i32* %7
%378 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 3)
%379 = load i32, i32* %5
%380 = load i32, i32* %6
%381 = sub nsw i32 %379, %380
%382 = sdiv i32 %381, 3
%383 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %382)
%384 = load i32, i32* %6
%385 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %384)
br label %386
386: ; preds = %373, %366
br label %387
387: ; preds = %386
%388 = load i32, i32* %6
%389 = add nsw i32 %388, 1
store i32 %389, i32* %6
br label %362
390: ; preds = %362
br label %391
391: ; preds = %390
%392 = load i32, i32* %5
%393 = add nsw i32 %392, 1
store i32 %393, i32* %5
br label %247
394: ; preds = %262
%395 = load i32, i32* %3
%396 = icmp sge i32 %395, 2
br i1 %396, label %397, label %600
397: ; preds = %394
%398 = load i32, i32* %3
%399 = mul nsw i32 3, %398
%400 = sub nsw i32 %399, 3
store i32 %400, i32* %5
br label %401
401: ; preds = %596, %397
%402 = load i32, i32* %5
%403 = load i32, i32* %4
%404 = sub nsw i32 %403, 1
%405 = icmp sle i32 %402, %404
br i1 %405, label %406, label %599
406: ; preds = %401
%407 = load i32, i32* %5
%408 = load i32, i32* %3
%409 = mul nsw i32 3, %408
%410 = sub nsw i32 %407, %409
%411 = icmp sgt i32 %410, 0
br i1 %411, label %412, label %417
412: ; preds = %406
%413 = load i32, i32* %5
%414 = load i32, i32* %3
%415 = mul nsw i32 3, %414
%416 = sub nsw i32 %413, %415
br label %418
417: ; preds = %406
br label %418
418: ; preds = %417, %412
%419 = phi i32 [ %416, %412 ], [ 0, %417 ]
store i32 %419, i32* %6
br label %420
420: ; preds = %449, %418
%421 = load i32, i32* %6
%422 = load i32, i32* %5
%423 = load i32, i32* %3
%424 = mul nsw i32 3, %423
%425 = sub nsw i32 %422, %424
%426 = add nsw i32 %425, 3
%427 = icmp sle i32 %421, %426
br i1 %427, label %428, label %452
428: ; preds = %420
%429 = load i32, i32* %5
%430 = load i32, i32* %6
%431 = mul nsw i32 2, %430
%432 = add nsw i32 %429, %431
%433 = srem i32 %432, 3
%434 = icmp eq i32 %433, 0
br i1 %434, label %435, label %448
435: ; preds = %428
%436 = load i32, i32* %5
%437 = load i32, i32* %6
%438 = sub nsw i32 %436, %437
%439 = sdiv i32 %438, 3
store i32 %439, i32* %7
%440 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 2)
%441 = load i32, i32* %5
%442 = load i32, i32* %6
%443 = sub nsw i32 %441, %442
%444 = sdiv i32 %443, 3
%445 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %444)
%446 = load i32, i32* %6
%447 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %446)
br label %448
448: ; preds = %435, %428
br label %449
449: ; preds = %448
%450 = load i32, i32* %6
%451 = add nsw i32 %450, 1
store i32 %451, i32* %6
br label %420
452: ; preds = %420
%453 = load i32, i32* %5
%454 = load i32, i32* %3
%455 = mul nsw i32 3, %454
%456 = sub nsw i32 %453, %455
%457 = add nsw i32 %456, 4
store i32 %457, i32* %6
br label %458
458: ; preds = %506, %452
%459 = load i32, i32* %6
%460 = load i32, i32* %5
%461 = icmp sle i32 %459, %460
br i1 %461, label %462, label %509
462: ; preds = %458
%463 = load i32, i32* %5
%464 = load i32, i32* %6
%465 = mul nsw i32 2, %464
%466 = add nsw i32 %463, %465
%467 = srem i32 %466, 3
%468 = icmp eq i32 %467, 0
br i1 %468, label %469, label %482
469: ; preds = %462
%470 = load i32, i32* %5
%471 = load i32, i32* %6
%472 = sub nsw i32 %470, %471
%473 = sdiv i32 %472, 3
store i32 %473, i32* %7
%474 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 2)
%475 = load i32, i32* %5
%476 = load i32, i32* %6
%477 = sub nsw i32 %475, %476
%478 = sdiv i32 %477, 3
%479 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %478)
%480 = load i32, i32* %6
%481 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %480)
br label %482
482: ; preds = %469, %462
%483 = load i32, i32* %5
%484 = load i32, i32* %6
%485 = mul nsw i32 2, %484
%486 = add nsw i32 %483, %485
%487 = add nsw i32 %486, 1
%488 = srem i32 %487, 3
%489 = icmp eq i32 %488, 0
br i1 %489, label %490, label %505
490: ; preds = %482
%491 = load i32, i32* %5
%492 = load i32, i32* %6
%493 = sub nsw i32 %491, %492
%494 = add nsw i32 %493, 4
%495 = sdiv i32 %494, 3
store i32 %495, i32* %7
%496 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 1)
%497 = load i32, i32* %5
%498 = load i32, i32* %6
%499 = sub nsw i32 %497, %498
%500 = add nsw i32 %499, 4
%501 = sdiv i32 %500, 3
%502 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %501)
%503 = load i32, i32* %6
%504 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %503)
br label %505
505: ; preds = %490, %482
br label %506
506: ; preds = %505
%507 = load i32, i32* %6
%508 = add nsw i32 %507, 1
store i32 %508, i32* %6
br label %458
509: ; preds = %458
%510 = load i32, i32* %5
%511 = add nsw i32 %510, 1
store i32 %511, i32* %6
br label %512
512: ; preds = %550, %509
%513 = load i32, i32* %6
%514 = load i32, i32* %5
%515 = add nsw i32 %514, 4
%516 = load i32, i32* %4
%517 = icmp slt i32 %515, %516
br i1 %517, label %518, label %521
518: ; preds = %512
%519 = load i32, i32* %5
%520 = add nsw i32 %519, 4
br label %523
521: ; preds = %512
%522 = load i32, i32* %4
br label %523
523: ; preds = %521, %518
%524 = phi i32 [ %520, %518 ], [ %522, %521 ]
%525 = icmp sle i32 %513, %524
br i1 %525, label %526, label %553
526: ; preds = %523
%527 = load i32, i32* %5
%528 = load i32, i32* %6
%529 = mul nsw i32 2, %528
%530 = add nsw i32 %527, %529
%531 = add nsw i32 %530, 1
%532 = srem i32 %531, 3
%533 = icmp eq i32 %532, 0
br i1 %533, label %534, label %549
534: ; preds = %526
%535 = load i32, i32* %5
%536 = load i32, i32* %6
%537 = sub nsw i32 %535, %536
%538 = add nsw i32 %537, 4
%539 = sdiv i32 %538, 3
store i32 %539, i32* %7
%540 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 1)
%541 = load i32, i32* %5
%542 = load i32, i32* %6
%543 = sub nsw i32 %541, %542
%544 = add nsw i32 %543, 4
%545 = sdiv i32 %544, 3
%546 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %545)
%547 = load i32, i32* %6
%548 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %547)
br label %549
549: ; preds = %534, %526
br label %550
550: ; preds = %549
%551 = load i32, i32* %6
%552 = add nsw i32 %551, 1
store i32 %552, i32* %6
br label %512
553: ; preds = %523
%554 = load i32, i32* %5
%555 = load i32, i32* %3
%556 = mul nsw i32 3, %555
%557 = sub nsw i32 %554, %556
%558 = icmp sgt i32 0, %557
br i1 %558, label %559, label %560
559: ; preds = %553
br label %565
560: ; preds = %553
%561 = load i32, i32* %5
%562 = load i32, i32* %3
%563 = mul nsw i32 3, %562
%564 = sub nsw i32 %561, %563
br label %565
565: ; preds = %560, %559
%566 = phi i32 [ 0, %559 ], [ %564, %560 ]
store i32 %566, i32* %6
br label %567
567: ; preds = %592, %565
%568 = load i32, i32* %6
%569 = load i32, i32* %5
%570 = icmp sle i32 %568, %569
br i1 %570, label %571, label %595
571: ; preds = %567
%572 = load i32, i32* %5
%573 = load i32, i32* %6
%574 = mul nsw i32 2, %573
%575 = add nsw i32 %572, %574
%576 = srem i32 %575, 3
%577 = icmp eq i32 %576, 0
br i1 %577, label %578, label %591
578: ; preds = %571
%579 = load i32, i32* %5
%580 = load i32, i32* %6
%581 = sub nsw i32 %579, %580
%582 = sdiv i32 %581, 3
store i32 %582, i32* %7
%583 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 3)
%584 = load i32, i32* %5
%585 = load i32, i32* %6
%586 = sub nsw i32 %584, %585
%587 = sdiv i32 %586, 3
%588 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %587)
%589 = load i32, i32* %6
%590 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %589)
br label %591
591: ; preds = %578, %571
br label %592
592: ; preds = %591
%593 = load i32, i32* %6
%594 = add nsw i32 %593, 1
store i32 %594, i32* %6
br label %567
595: ; preds = %567
br label %596
596: ; preds = %595
%597 = load i32, i32* %5
%598 = add nsw i32 %597, 1
store i32 %598, i32* %5
br label %401
599: ; preds = %401
br label %600
600: ; preds = %599, %394
%601 = load i32, i32* %4
%602 = icmp sge i32 %601, 0
br i1 %602, label %603, label %697
603: ; preds = %600
%604 = load i32, i32* %4
store i32 %604, i32* %5
br label %605
605: ; preds = %693, %603
%606 = load i32, i32* %5
%607 = load i32, i32* %3
%608 = mul nsw i32 3, %607
%609 = sub nsw i32 %608, 4
%610 = icmp sle i32 %606, %609
br i1 %610, label %611, label %696
611: ; preds = %605
store i32 0, i32* %6
br label %612
612: ; preds = %660, %611
%613 = load i32, i32* %6
%614 = load i32, i32* %4
%615 = icmp sle i32 %613, %614
br i1 %615, label %616, label %663
616: ; preds = %612
%617 = load i32, i32* %5
%618 = load i32, i32* %6
%619 = mul nsw i32 2, %618
%620 = add nsw i32 %617, %619
%621 = srem i32 %620, 3
%622 = icmp eq i32 %621, 0
br i1 %622, label %623, label %636
623: ; preds = %616
%624 = load i32, i32* %5
%625 = load i32, i32* %6
%626 = sub nsw i32 %624, %625
%627 = sdiv i32 %626, 3
store i32 %627, i32* %7
%628 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 2)
%629 = load i32, i32* %5
%630 = load i32, i32* %6
%631 = sub nsw i32 %629, %630
%632 = sdiv i32 %631, 3
%633 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %632)
%634 = load i32, i32* %6
%635 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %634)
br label %636
636: ; preds = %623, %616
%637 = load i32, i32* %5
%638 = load i32, i32* %6
%639 = mul nsw i32 2, %638
%640 = add nsw i32 %637, %639
%641 = add nsw i32 %640, 1
%642 = srem i32 %641, 3
%643 = icmp eq i32 %642, 0
br i1 %643, label %644, label %659
644: ; preds = %636
%645 = load i32, i32* %5
%646 = load i32, i32* %6
%647 = sub nsw i32 %645, %646
%648 = add nsw i32 %647, 4
%649 = sdiv i32 %648, 3
store i32 %649, i32* %7
%650 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 1)
%651 = load i32, i32* %5
%652 = load i32, i32* %6
%653 = sub nsw i32 %651, %652
%654 = add nsw i32 %653, 4
%655 = sdiv i32 %654, 3
%656 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %655)
%657 = load i32, i32* %6
%658 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %657)
br label %659
659: ; preds = %644, %636
br label %660
660: ; preds = %659
%661 = load i32, i32* %6
%662 = add nsw i32 %661, 1
store i32 %662, i32* %6
br label %612
663: ; preds = %612
store i32 0, i32* %6
br label %664
664: ; preds = %689, %663
%665 = load i32, i32* %6
%666 = load i32, i32* %4
%667 = icmp sle i32 %665, %666
br i1 %667, label %668, label %692
668: ; preds = %664
%669 = load i32, i32* %5
%670 = load i32, i32* %6
%671 = mul nsw i32 2, %670
%672 = add nsw i32 %669, %671
%673 = srem i32 %672, 3
%674 = icmp eq i32 %673, 0
br i1 %674, label %675, label %688
675: ; preds = %668
%676 = load i32, i32* %5
%677 = load i32, i32* %6
%678 = sub nsw i32 %676, %677
%679 = sdiv i32 %678, 3
store i32 %679, i32* %7
%680 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 3)
%681 = load i32, i32* %5
%682 = load i32, i32* %6
%683 = sub nsw i32 %681, %682
%684 = sdiv i32 %683, 3
%685 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %684)
%686 = load i32, i32* %6
%687 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %686)
br label %688
688: ; preds = %675, %668
br label %689
689: ; preds = %688
%690 = load i32, i32* %6
%691 = add nsw i32 %690, 1
store i32 %691, i32* %6
br label %664
692: ; preds = %664
br label %693
693: ; preds = %692
%694 = load i32, i32* %5
%695 = add nsw i32 %694, 1
store i32 %695, i32* %5
br label %605
696: ; preds = %605
br label %697
697: ; preds = %696, %600
%698 = load i32, i32* %3
%699 = mul nsw i32 3, %698
%700 = sub nsw i32 %699, 3
%701 = load i32, i32* %4
%702 = icmp sgt i32 %700, %701
br i1 %702, label %703, label %707
703: ; preds = %697
%704 = load i32, i32* %3
%705 = mul nsw i32 3, %704
%706 = sub nsw i32 %705, 3
br label %709
707: ; preds = %697
%708 = load i32, i32* %4
br label %709
709: ; preds = %707, %703
%710 = phi i32 [ %706, %703 ], [ %708, %707 ]
store i32 %710, i32* %5
br label %711
711: ; preds = %865, %709
%712 = load i32, i32* %5
%713 = load i32, i32* %3
%714 = mul nsw i32 3, %713
%715 = load i32, i32* %4
%716 = add nsw i32 %714, %715
%717 = sub nsw i32 %716, 4
%718 = icmp sle i32 %712, %717
br i1 %718, label %719, label %868
719: ; preds = %711
%720 = load i32, i32* %5
%721 = load i32, i32* %3
%722 = mul nsw i32 3, %721
%723 = sub nsw i32 %720, %722
%724 = icmp sgt i32 %723, 0
br i1 %724, label %725, label %730
725: ; preds = %719
%726 = load i32, i32* %5
%727 = load i32, i32* %3
%728 = mul nsw i32 3, %727
%729 = sub nsw i32 %726, %728
br label %731
730: ; preds = %719
br label %731
731: ; preds = %730, %725
%732 = phi i32 [ %729, %725 ], [ 0, %730 ]
store i32 %732, i32* %6
br label %733
733: ; preds = %762, %731
%734 = load i32, i32* %6
%735 = load i32, i32* %5
%736 = load i32, i32* %3
%737 = mul nsw i32 3, %736
%738 = sub nsw i32 %735, %737
%739 = add nsw i32 %738, 3
%740 = icmp sle i32 %734, %739
br i1 %740, label %741, label %765
741: ; preds = %733
%742 = load i32, i32* %5
%743 = load i32, i32* %6
%744 = mul nsw i32 2, %743
%745 = add nsw i32 %742, %744
%746 = srem i32 %745, 3
%747 = icmp eq i32 %746, 0
br i1 %747, label %748, label %761
748: ; preds = %741
%749 = load i32, i32* %5
%750 = load i32, i32* %6
%751 = sub nsw i32 %749, %750
%752 = sdiv i32 %751, 3
store i32 %752, i32* %7
%753 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 2)
%754 = load i32, i32* %5
%755 = load i32, i32* %6
%756 = sub nsw i32 %754, %755
%757 = sdiv i32 %756, 3
%758 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %757)
%759 = load i32, i32* %6
%760 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %759)
br label %761
761: ; preds = %748, %741
br label %762
762: ; preds = %761
%763 = load i32, i32* %6
%764 = add nsw i32 %763, 1
store i32 %764, i32* %6
br label %733
765: ; preds = %733
%766 = load i32, i32* %5
%767 = load i32, i32* %3
%768 = mul nsw i32 3, %767
%769 = sub nsw i32 %766, %768
%770 = add nsw i32 %769, 4
store i32 %770, i32* %6
br label %771
771: ; preds = %819, %765
%772 = load i32, i32* %6
%773 = load i32, i32* %4
%774 = icmp sle i32 %772, %773
br i1 %774, label %775, label %822
775: ; preds = %771
%776 = load i32, i32* %5
%777 = load i32, i32* %6
%778 = mul nsw i32 2, %777
%779 = add nsw i32 %776, %778
%780 = srem i32 %779, 3
%781 = icmp eq i32 %780, 0
br i1 %781, label %782, label %795
782: ; preds = %775
%783 = load i32, i32* %5
%784 = load i32, i32* %6
%785 = sub nsw i32 %783, %784
%786 = sdiv i32 %785, 3
store i32 %786, i32* %7
%787 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 2)
%788 = load i32, i32* %5
%789 = load i32, i32* %6
%790 = sub nsw i32 %788, %789
%791 = sdiv i32 %790, 3
%792 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %791)
%793 = load i32, i32* %6
%794 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %793)
br label %795
795: ; preds = %782, %775
%796 = load i32, i32* %5
%797 = load i32, i32* %6
%798 = mul nsw i32 2, %797
%799 = add nsw i32 %796, %798
%800 = add nsw i32 %799, 1
%801 = srem i32 %800, 3
%802 = icmp eq i32 %801, 0
br i1 %802, label %803, label %818
803: ; preds = %795
%804 = load i32, i32* %5
%805 = load i32, i32* %6
%806 = sub nsw i32 %804, %805
%807 = add nsw i32 %806, 4
%808 = sdiv i32 %807, 3
store i32 %808, i32* %7
%809 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 1)
%810 = load i32, i32* %5
%811 = load i32, i32* %6
%812 = sub nsw i32 %810, %811
%813 = add nsw i32 %812, 4
%814 = sdiv i32 %813, 3
%815 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %814)
%816 = load i32, i32* %6
%817 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %816)
br label %818
818: ; preds = %803, %795
br label %819
819: ; preds = %818
%820 = load i32, i32* %6
%821 = add nsw i32 %820, 1
store i32 %821, i32* %6
br label %771
822: ; preds = %771
%823 = load i32, i32* %5
%824 = load i32, i32* %3
%825 = mul nsw i32 3, %824
%826 = sub nsw i32 %823, %825
%827 = icmp sgt i32 0, %826
br i1 %827, label %828, label %829
828: ; preds = %822
br label %834
829: ; preds = %822
%830 = load i32, i32* %5
%831 = load i32, i32* %3
%832 = mul nsw i32 3, %831
%833 = sub nsw i32 %830, %832
br label %834
834: ; preds = %829, %828
%835 = phi i32 [ 0, %828 ], [ %833, %829 ]
store i32 %835, i32* %6
br label %836
836: ; preds = %861, %834
%837 = load i32, i32* %6
%838 = load i32, i32* %4
%839 = icmp sle i32 %837, %838
br i1 %839, label %840, label %864
840: ; preds = %836
%841 = load i32, i32* %5
%842 = load i32, i32* %6
%843 = mul nsw i32 2, %842
%844 = add nsw i32 %841, %843
%845 = srem i32 %844, 3
%846 = icmp eq i32 %845, 0
br i1 %846, label %847, label %860
847: ; preds = %840
%848 = load i32, i32* %5
%849 = load i32, i32* %6
%850 = sub nsw i32 %848, %849
%851 = sdiv i32 %850, 3
store i32 %851, i32* %7
%852 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 3)
%853 = load i32, i32* %5
%854 = load i32, i32* %6
%855 = sub nsw i32 %853, %854
%856 = sdiv i32 %855, 3
%857 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %856)
%858 = load i32, i32* %6
%859 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %858)
br label %860
860: ; preds = %847, %840
br label %861
861: ; preds = %860
%862 = load i32, i32* %6
%863 = add nsw i32 %862, 1
store i32 %863, i32* %6
br label %836
864: ; preds = %836
br label %865
865: ; preds = %864
%866 = load i32, i32* %5
%867 = add nsw i32 %866, 1
store i32 %867, i32* %5
br label %711
868: ; preds = %711
%869 = load i32, i32* %3
%870 = icmp sge i32 %869, 0
br i1 %870, label %871, label %1002
871: ; preds = %868
%872 = load i32, i32* %4
%873 = icmp sge i32 %872, 0
br i1 %873, label %874, label %1002
874: ; preds = %871
%875 = load i32, i32* %3
%876 = mul nsw i32 3, %875
%877 = load i32, i32* %4
%878 = add nsw i32 %876, %877
%879 = sub nsw i32 %878, 3
%880 = icmp sgt i32 %879, 0
br i1 %880, label %881, label %887
881: ; preds = %874
%882 = load i32, i32* %3
%883 = mul nsw i32 3, %882
%884 = load i32, i32* %4
%885 = add nsw i32 %883, %884
%886 = sub nsw i32 %885, 3
br label %888
887: ; preds = %874
br label %888
888: ; preds = %887, %881
%889 = phi i32 [ %886, %881 ], [ 0, %887 ]
store i32 %889, i32* %5
br label %890
890: ; preds = %998, %888
%891 = load i32, i32* %5
%892 = load i32, i32* %3
%893 = mul nsw i32 3, %892
%894 = load i32, i32* %4
%895 = add nsw i32 %893, %894
%896 = icmp sle i32 %891, %895
br i1 %896, label %897, label %1001
897: ; preds = %890
%898 = load i32, i32* %5
%899 = load i32, i32* %3
%900 = mul nsw i32 3, %899
%901 = sub nsw i32 %898, %900
%902 = icmp sgt i32 0, %901
br i1 %902, label %903, label %904
903: ; preds = %897
br label %909
904: ; preds = %897
%905 = load i32, i32* %5
%906 = load i32, i32* %3
%907 = mul nsw i32 3, %906
%908 = sub nsw i32 %905, %907
br label %909
909: ; preds = %904, %903
%910 = phi i32 [ 0, %903 ], [ %908, %904 ]
store i32 %910, i32* %6
br label %911
911: ; preds = %944, %909
%912 = load i32, i32* %6
%913 = load i32, i32* %5
%914 = load i32, i32* %4
%915 = icmp slt i32 %913, %914
br i1 %915, label %916, label %918
916: ; preds = %911
%917 = load i32, i32* %5
br label %920
918: ; preds = %911
%919 = load i32, i32* %4
br label %920
920: ; preds = %918, %916
%921 = phi i32 [ %917, %916 ], [ %919, %918 ]
%922 = icmp sle i32 %912, %921
br i1 %922, label %923, label %947
923: ; preds = %920
%924 = load i32, i32* %5
%925 = load i32, i32* %6
%926 = mul nsw i32 2, %925
%927 = add nsw i32 %924, %926
%928 = srem i32 %927, 3
%929 = icmp eq i32 %928, 0
br i1 %929, label %930, label %943
930: ; preds = %923
%931 = load i32, i32* %5
%932 = load i32, i32* %6
%933 = sub nsw i32 %931, %932
%934 = sdiv i32 %933, 3
store i32 %934, i32* %7
%935 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 2)
%936 = load i32, i32* %5
%937 = load i32, i32* %6
%938 = sub nsw i32 %936, %937
%939 = sdiv i32 %938, 3
%940 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %939)
%941 = load i32, i32* %6
%942 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %941)
br label %943
943: ; preds = %930, %923
br label %944
944: ; preds = %943
%945 = load i32, i32* %6
%946 = add nsw i32 %945, 1
store i32 %946, i32* %6
br label %911
947: ; preds = %920
%948 = load i32, i32* %5
%949 = load i32, i32* %3
%950 = mul nsw i32 3, %949
%951 = sub nsw i32 %948, %950
%952 = icmp sgt i32 0, %951
br i1 %952, label %953, label %954
953: ; preds = %947
br label %959
954: ; preds = %947
%955 = load i32, i32* %5
%956 = load i32, i32* %3
%957 = mul nsw i32 3, %956
%958 = sub nsw i32 %955, %957
br label %959
959: ; preds = %954, %953
%960 = phi i32 [ 0, %953 ], [ %958, %954 ]
store i32 %960, i32* %6
br label %961
961: ; preds = %994, %959
%962 = load i32, i32* %6
%963 = load i32, i32* %5
%964 = load i32, i32* %4
%965 = icmp slt i32 %963, %964
br i1 %965, label %966, label %968
966: ; preds = %961
%967 = load i32, i32* %5
br label %970
968: ; preds = %961
%969 = load i32, i32* %4
br label %970
970: ; preds = %968, %966
%971 = phi i32 [ %967, %966 ], [ %969, %968 ]
%972 = icmp sle i32 %962, %971
br i1 %972, label %973, label %997
973: ; preds = %970
%974 = load i32, i32* %5
%975 = load i32, i32* %6
%976 = mul nsw i32 2, %975
%977 = add nsw i32 %974, %976
%978 = srem i32 %977, 3
%979 = icmp eq i32 %978, 0
br i1 %979, label %980, label %993
980: ; preds = %973
%981 = load i32, i32* %5
%982 = load i32, i32* %6
%983 = sub nsw i32 %981, %982
%984 = sdiv i32 %983, 3
store i32 %984, i32* %7
%985 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 3)
%986 = load i32, i32* %5
%987 = load i32, i32* %6
%988 = sub nsw i32 %986, %987
%989 = sdiv i32 %988, 3
%990 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %989)
%991 = load i32, i32* %6
%992 = call i32 (i32, ...) bitcast (i32 (...)* @hash to i32 (i32, ...)*)(i32 %991)
br label %993
993: ; preds = %980, %973
br label %994
994: ; preds = %993
%995 = load i32, i32* %6
%996 = add nsw i32 %995, 1
store i32 %996, i32* %6
br label %961
997: ; preds = %970
br label %998
998: ; preds = %997
%999 = load i32, i32* %5
%1000 = add nsw i32 %999, 1
store i32 %1000, i32* %5
br label %890
1001: ; preds = %890
br label %1002
1002: ; preds = %1001, %871, %868
ret void
}

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