#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ hash(int);
void test(int M, int N) {
  int p1, p3, p5, p7;
  int i, j, k, l;
  { hash(1); };
  { hash(2); };
  for (p1 = 0; p1 <= N - 1; p1++) {
    for (p3 = 0; p3 <= N - 1; p3++) {
      {
        hash(4);
        hash(p1);
        hash(p3);
      };
      {
        hash(5);
        hash(p1);
        hash(p3);
      };
    }
  }
  for (p1 = 0; p1 <= N - 1; p1++) {
    for (p3 = 0; p3 <= N - 1; p3++) {
      for (p5 = 0; p5 <= (((N - 1) < 0) ? -((-(N - 1) + (32) - 1) / (32))
                                        : (N - 1) / (32));
           p5++) {
        if (p5 >= 0) {
          p7 = 32 * p5;
          l = 32 * p5;
          {
            hash(7);
            hash(p1);
            hash(p3);
            hash(p5);
            hash(32 * p5);
          };
        }
        if (p5 <= -1) {
          {
            hash(7);
            hash(p1);
            hash(p3);
            hash(p5);
            hash(0);
          };
        }
        for (p7 = ((32 * p5 + 1) > (1) ? (32 * p5 + 1) : (1));
             p7 <= ((N - 1) < (32 * p5 + 31) ? (N - 1) : (32 * p5 + 31));
             p7++) {
          l = p7 - 1;
          {
            hash(6);
            hash(p1);
            hash(p3);
            hash(p5);
            hash(p7 - 1);
          };
          {
            hash(7);
            hash(p1);
            hash(p3);
            hash(p5);
            hash(p7);
          };
        }
        if (p5 >= (((N - 32) < 0) ? -((-(N - 32)) / (32))
                                  : ((N - 32) + (32) - 1) / (32))) {
          l = N - 1;
          {
            hash(6);
            hash(p1);
            hash(p3);
            hash(p5);
            hash(N - 1);
          };
        }
        if (p5 <= (((N - 33) < 0) ? -((-(N - 33) + (32) - 1) / (32))
                                  : (N - 33) / (32))) {
          p7 = 32 * p5 + 32;
          l = 32 * p5 + 31;
          {
            hash(6);
            hash(p1);
            hash(p3);
            hash(p5);
            hash(32 * p5 + 31);
          };
        }
      }
    }
  }
  { hash(8); };
}


x86 assembly (clang, -O0):
<test>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    $0x1,%edi
call   1030 <hash@plt>
mov    $0x2,%edi
call   1030 <hash@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     11b7 <test+0xa7>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     11a4 <test+0x94>
mov    $0x4,%edi
call   1030 <hash@plt>
mov    -0xc(%rbp),%edi
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
call   1030 <hash@plt>
mov    $0x5,%edi
call   1030 <hash@plt>
mov    -0xc(%rbp),%edi
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
call   1030 <hash@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1151 <test+0x41>
jmp    11a9 <test+0x99>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1139 <test+0x29>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1518 <test+0x408>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1505 <test+0x3f5>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    1229 <test+0x119>
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
add    $0x20,%eax
sub    $0x1,%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
jmp    123a <test+0x12a>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%ecx
cmp    %ecx,%eax
jg     14f2 <test+0x3e2>
cmpl   $0x0,-0x14(%rbp)
jl     1291 <test+0x181>
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    %eax,-0x28(%rbp)
mov    $0x7,%edi
call   1030 <hash@plt>
mov    -0xc(%rbp),%edi
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
call   1030 <hash@plt>
mov    -0x14(%rbp),%edi
call   1030 <hash@plt>
mov    -0x14(%rbp),%edi
shl    $0x5,%edi
call   1030 <hash@plt>
cmpl   $0xffffffff,-0x14(%rbp)
jg     12c4 <test+0x1b4>
mov    $0x7,%edi
call   1030 <hash@plt>
mov    -0xc(%rbp),%edi
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
call   1030 <hash@plt>
mov    -0x14(%rbp),%edi
call   1030 <hash@plt>
xor    %edi,%edi
call   1030 <hash@plt>
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
add    $0x1,%eax
cmp    $0x1,%eax
jle    12e7 <test+0x1d7>
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12f4 <test+0x1e4>
mov    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12f4 <test+0x1e4>
mov    -0x34(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
add    $0x1f,%ecx
cmp    %ecx,%eax
jge    1325 <test+0x215>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1331 <test+0x221>
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
add    $0x1f,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x3c(%rbp),%ecx
cmp    %ecx,%eax
jg     13ad <test+0x29d>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    $0x6,%edi
call   1030 <hash@plt>
mov    -0xc(%rbp),%edi
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
call   1030 <hash@plt>
mov    -0x14(%rbp),%edi
call   1030 <hash@plt>
mov    -0x18(%rbp),%edi
sub    $0x1,%edi
call   1030 <hash@plt>
mov    $0x7,%edi
call   1030 <hash@plt>
mov    -0xc(%rbp),%edi
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
call   1030 <hash@plt>
mov    -0x14(%rbp),%edi
call   1030 <hash@plt>
mov    -0x18(%rbp),%edi
call   1030 <hash@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12fa <test+0x1ea>
mov    -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x20,%eax
cmp    $0x0,%eax
jge    13e2 <test+0x2d2>
mov    -0x8(%rbp),%ecx
sub    $0x20,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
jmp    13f9 <test+0x2e9>
mov    -0x8(%rbp),%eax
sub    $0x20,%eax
add    $0x20,%eax
sub    $0x1,%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jl     143d <test+0x32d>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    $0x6,%edi
call   1030 <hash@plt>
mov    -0xc(%rbp),%edi
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
call   1030 <hash@plt>
mov    -0x14(%rbp),%edi
call   1030 <hash@plt>
mov    -0x8(%rbp),%edi
sub    $0x1,%edi
call   1030 <hash@plt>
mov    -0x14(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x21,%eax
cmp    $0x0,%eax
jge    1478 <test+0x368>
mov    -0x8(%rbp),%ecx
sub    $0x21,%ecx
xor    %eax,%eax
sub    %ecx,%eax
add    $0x20,%eax
sub    $0x1,%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
jmp    1489 <test+0x379>
mov    -0x8(%rbp),%eax
sub    $0x21,%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x4c(%rbp),%ecx
cmp    %ecx,%eax
jg     14df <test+0x3cf>
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
add    $0x20,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
add    $0x1f,%eax
mov    %eax,-0x28(%rbp)
mov    $0x6,%edi
call   1030 <hash@plt>
mov    -0xc(%rbp),%edi
call   1030 <hash@plt>
mov    -0x10(%rbp),%edi
call   1030 <hash@plt>
mov    -0x14(%rbp),%edi
call   1030 <hash@plt>
mov    -0x14(%rbp),%edi
shl    $0x5,%edi
add    $0x1f,%edi
call   1030 <hash@plt>
jmp    14e4 <test+0x3d4>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11ee <test+0xde>
jmp    14f7 <test+0x3e7>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11d6 <test+0xc6>
jmp    150a <test+0x3fa>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11be <test+0xae>
mov    $0x8,%edi
call   1030 <hash@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %esi,%r13d
mov    $0x1,%edi
call   1030 <hash@plt>
mov    $0x2,%edi
call   1030 <hash@plt>
test   %r13d,%r13d
jle    1374 <test+0x264>
xor    %ebx,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0x4,%edi
call   1030 <hash@plt>
mov    %ebx,%edi
call   1030 <hash@plt>
mov    %ebp,%edi
call   1030 <hash@plt>
mov    $0x5,%edi
call   1030 <hash@plt>
mov    %ebx,%edi
call   1030 <hash@plt>
mov    %ebp,%edi
call   1030 <hash@plt>
add    $0x1,%ebp
cmp    %ebp,%r13d
jne    1150 <test+0x40>
add    $0x1,%ebx
cmp    %r13d,%ebx
jne    1140 <test+0x30>
test   %r13d,%r13d
jle    1374 <test+0x264>
lea    -0x1(%r13),%eax
mov    %eax,0x10(%rsp)
mov    %eax,%esi
shr    $0x5,%esi
mov    %r13d,%ecx
sub    $0x21,%ecx
setb   %al
shr    $0x5,%ecx
mov    %ecx,0x8(%rsp)
mov    $0x40,%edx
sub    %r13d,%edx
mov    $0x5f,%ecx
sub    %r13d,%ecx
test   %edx,%edx
cmovns %edx,%ecx
sar    $0x5,%ecx
neg    %ecx
mov    %esi,0x14(%rsp)
mov    %esi,0xc(%rsp)
cmp    $0x1f,%r13d
ja     11f7 <test+0xe7>
mov    $0x20,%edx
sub    %r13d,%edx
lea    0x1f(%rdx),%esi
test   %edx,%edx
cmovns %edx,%esi
sar    $0x5,%esi
neg    %esi
mov    %esi,0xc(%rsp)
test   %al,%al
mov    0x8(%rsp),%eax
cmovne %ecx,%eax
mov    %eax,0x8(%rsp)
xor    %r12d,%r12d
mov    %r13,0x18(%rsp)
jmp    121d <test+0x10d>
xchg   %ax,%ax
add    $0x1,%r12d
cmp    %r13d,%r12d
je     1374 <test+0x264>
xor    %ebp,%ebp
jmp    1238 <test+0x128>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%ebp
cmp    %r13d,%ebp
je     1210 <test+0x100>
xor    %ebx,%ebx
jmp    1250 <test+0x140>
nopl   0x0(%rax)
lea    0x1(%rbx),%eax
cmp    0x14(%rsp),%ebx
mov    %eax,%ebx
mov    0x18(%rsp),%r13
je     1230 <test+0x120>
mov    $0x7,%edi
call   1030 <hash@plt>
mov    %r12d,%edi
call   1030 <hash@plt>
mov    %ebp,%edi
call   1030 <hash@plt>
mov    %ebx,%edi
call   1030 <hash@plt>
mov    %ebx,%r14d
shl    $0x5,%r14d
mov    %r14d,%edi
call   1030 <hash@plt>
lea    0x1(%r14),%r15d
test   %ebx,%ebx
mov    $0x1,%eax
cmove  %eax,%r15d
or     $0x1f,%r14d
cmp    %r13d,%r14d
mov    0x10(%rsp),%r13d
mov    %r14,0x20(%rsp)
cmovl  %r14d,%r13d
cmp    %r13d,%r15d
jg     130c <test+0x1fc>
add    $0xffffffff,%r15d
nopl   0x0(%rax)
lea    0x1(%r15),%r14d
mov    $0x6,%edi
call   1030 <hash@plt>
mov    %r12d,%edi
call   1030 <hash@plt>
mov    %ebp,%edi
call   1030 <hash@plt>
mov    %ebx,%edi
call   1030 <hash@plt>
mov    %r15d,%edi
call   1030 <hash@plt>
mov    $0x7,%edi
call   1030 <hash@plt>
mov    %r12d,%edi
call   1030 <hash@plt>
mov    %ebp,%edi
call   1030 <hash@plt>
mov    %ebx,%edi
call   1030 <hash@plt>
mov    %r14d,%edi
call   1030 <hash@plt>
mov    %r14d,%r15d
cmp    %r14d,%r13d
jne    12b0 <test+0x1a0>
cmp    0xc(%rsp),%ebx
jl     133b <test+0x22b>
mov    $0x6,%edi
call   1030 <hash@plt>
mov    %r12d,%edi
call   1030 <hash@plt>
mov    %ebp,%edi
call   1030 <hash@plt>
mov    %ebx,%edi
call   1030 <hash@plt>
mov    0x10(%rsp),%edi
call   1030 <hash@plt>
cmp    0x8(%rsp),%ebx
jg     1240 <test+0x130>
mov    $0x6,%edi
call   1030 <hash@plt>
mov    %r12d,%edi
call   1030 <hash@plt>
mov    %ebp,%edi
call   1030 <hash@plt>
mov    %ebx,%edi
call   1030 <hash@plt>
mov    0x20(%rsp),%rdi
call   1030 <hash@plt>
jmp    1240 <test+0x130>
mov    $0x8,%edi
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <hash@plt>

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

LLVM IR (-O2):
define void @test(i32 %0, i32 %1) {
%3 = tail call i32 @hash(i32 1)
%4 = tail call i32 @hash(i32 2)
%5 = icmp sgt i32 %1, 0
br i1 %5, label %6, label %94
6: ; preds = %2, %32
%7 = phi i32 [ %33, %32 ], [ 0, %2 ]
br label %22
8: ; preds = %32
%9 = add nsw i32 %1, -1
br i1 %5, label %10, label %94
10: ; preds = %8
%11 = lshr i32 %9, 5
%12 = icmp ult i32 %1, 32
%13 = sub nsw i32 32, %1
%14 = sdiv i32 %13, -32
%15 = icmp ult i32 %1, 33
%16 = add nsw i32 %1, -33
%17 = lshr i32 %16, 5
%18 = sub nsw i32 64, %1
%19 = sdiv i32 %18, -32
%20 = select i1 %12, i32 %14, i32 %11
%21 = select i1 %15, i32 %19, i32 %17
br label %35
22: ; preds = %6, %22
%23 = phi i32 [ %30, %22 ], [ 0, %6 ]
%24 = tail call i32 @hash(i32 4)
%25 = tail call i32 @hash(i32 %7)
%26 = tail call i32 @hash(i32 %23)
%27 = tail call i32 @hash(i32 5)
%28 = tail call i32 @hash(i32 %7)
%29 = tail call i32 @hash(i32 %23)
%30 = add nuw nsw i32 %23, 1
%31 = icmp eq i32 %30, %1
br i1 %31, label %32, label %22
32: ; preds = %22
%33 = add nuw nsw i32 %7, 1
%34 = icmp eq i32 %33, %1
br i1 %34, label %8, label %6
35: ; preds = %91, %10
%36 = phi i32 [ 0, %10 ], [ %92, %91 ]
br label %37
37: ; preds = %35, %88
%38 = phi i32 [ %89, %88 ], [ 0, %35 ]
br label %39
39: ; preds = %37, %85
%40 = phi i32 [ 0, %37 ], [ %86, %85 ]
%41 = tail call i32 @hash(i32 7)
%42 = tail call i32 @hash(i32 %36)
%43 = tail call i32 @hash(i32 %38)
%44 = tail call i32 @hash(i32 %40)
%45 = shl nsw i32 %40, 5
%46 = tail call i32 @hash(i32 %45)
%47 = or i32 %45, 1
%48 = icmp eq i32 %40, 0
%49 = select i1 %48, i32 1, i32 %47
%50 = or i32 %45, 31
%51 = icmp slt i32 %50, %1
%52 = select i1 %51, i32 %50, i32 %9
%53 = icmp sgt i32 %49, %52
br i1 %53, label %69, label %54
54: ; preds = %39, %54
%55 = phi i32 [ %67, %54 ], [ %49, %39 ]
%56 = tail call i32 @hash(i32 6)
%57 = tail call i32 @hash(i32 %36)
%58 = tail call i32 @hash(i32 %38)
%59 = tail call i32 @hash(i32 %40)
%60 = add nsw i32 %55, -1
%61 = tail call i32 @hash(i32 %60)
%62 = tail call i32 @hash(i32 7)
%63 = tail call i32 @hash(i32 %36)
%64 = tail call i32 @hash(i32 %38)
%65 = tail call i32 @hash(i32 %40)
%66 = tail call i32 @hash(i32 %55)
%67 = add nuw i32 %55, 1
%68 = icmp eq i32 %55, %52
br i1 %68, label %69, label %54
69: ; preds = %54, %39
%70 = icmp slt i32 %40, %20
br i1 %70, label %77, label %71
71: ; preds = %69
%72 = tail call i32 @hash(i32 6)
%73 = tail call i32 @hash(i32 %36)
%74 = tail call i32 @hash(i32 %38)
%75 = tail call i32 @hash(i32 %40)
%76 = tail call i32 @hash(i32 %9)
br label %77
77: ; preds = %71, %69
%78 = icmp sgt i32 %40, %21
br i1 %78, label %85, label %79
79: ; preds = %77
%80 = tail call i32 @hash(i32 6)
%81 = tail call i32 @hash(i32 %36)
%82 = tail call i32 @hash(i32 %38)
%83 = tail call i32 @hash(i32 %40)
%84 = tail call i32 @hash(i32 %50)
br label %85
85: ; preds = %77, %79
%86 = add nuw nsw i32 %40, 1
%87 = icmp eq i32 %40, %11
br i1 %87, label %88, label %39
88: ; preds = %85
%89 = add nuw nsw i32 %38, 1
%90 = icmp eq i32 %89, %1
br i1 %90, label %91, label %37
91: ; preds = %88
%92 = add nuw nsw i32 %36, 1
%93 = icmp eq i32 %92, %1
br i1 %93, label %94, label %35
94: ; preds = %91, %2, %8
%95 = tail call i32 @hash(i32 8)
ret void
}