#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 n) {
  int c1, c2;
  int i, j;
  for (c1 = 0; c1 <= 5 * n; c1++) {
    for (c2 = ((c1 - n) > ((((2 * c1) < 0) ? -((-(2 * c1)) / (3))
                                           : ((2 * c1) + (3) - 1) / (3)))
                   ? (c1 - n)
                   : ((((2 * c1) < 0) ? -((-(2 * c1)) / (3))
                                      : ((2 * c1) + (3) - 1) / (3))));
         c2 <= ((c1) < ((((2 * c1 + 2 * n) < 0)
                             ? -((-(2 * c1 + 2 * n) + (3) - 1) / (3))
                             : (2 * c1 + 2 * n) / (3)))
                    ? (c1)
                    : ((((2 * c1 + 2 * n) < 0)
                            ? -((-(2 * c1 + 2 * n) + (3) - 1) / (3))
                            : (2 * c1 + 2 * n) / (3))));
         c2++) {
      if (c2 % 2 == 0) {
        i = (-2 * c1 + 3 * c2) / 2;
        j = c1 - c2;
        {
          hash(1);
          hash((-2 * c1 + 3 * c2) / 2);
          hash(c1 - c2);
        };
      }
    }
  }
}


x86 assembly (clang, -O0):
<test>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
imul   $0x5,-0x4(%rbp),%ecx
cmp    %ecx,%eax
jg     136f <test+0x25f>
mov    -0x8(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
cmp    $0x0,%eax
jge    1169 <test+0x59>
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    1180 <test+0x70>
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
add    $0x3,%eax
sub    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jle    119c <test+0x8c>
mov    -0x8(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    11e8 <test+0xd8>
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
cmp    $0x0,%eax
jge    11cb <test+0xbb>
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
jmp    11e2 <test+0xd2>
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
add    $0x3,%eax
sub    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
cmp    $0x0,%eax
jge    123f <test+0x12f>
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
add    $0x3,%eax
sub    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
jmp    1258 <test+0x148>
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x30(%rbp),%ecx
cmp    %ecx,%eax
jge    1271 <test+0x161>
mov    -0x8(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    12d5 <test+0x1c5>
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
cmp    $0x0,%eax
jge    12b6 <test+0x1a6>
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
add    $0x3,%eax
sub    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
jmp    12cf <test+0x1bf>
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jg     135c <test+0x24c>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1349 <test+0x239>
imul   $0xfffffffe,-0x8(%rbp),%eax
imul   $0x3,-0xc(%rbp),%ecx
add    %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    $0x1,%edi
call   1030 <hash@plt>
imul   $0xfffffffe,-0x8(%rbp),%eax
imul   $0x3,-0xc(%rbp),%ecx
add    %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
call   1030 <hash@plt>
mov    -0x8(%rbp),%edi
sub    -0xc(%rbp),%edi
call   1030 <hash@plt>
jmp    134e <test+0x23e>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11ee <test+0xde>
jmp    1361 <test+0x251>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1122 <test+0x12>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,0x10(%rsp)
test   %edi,%edi
js     1270 <test+0x160>
mov    0x10(%rsp),%rax
lea    (%rax,%rax,4),%ecx
xor    %edx,%edx
test   %ecx,%ecx
movl   $0x0,0x4(%rsp)
cmovle %edx,%ecx
mov    %ecx,0x8(%rsp)
mov    %eax,%ebx
neg    %ebx
mov    $0x2,%ecx
xor    %r15d,%r15d
jmp    1181 <test+0x71>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%r15),%eax
add    $0x1,%ebx
mov    0xc(%rsp),%ecx
add    $0x2,%ecx
addl   $0xfffffffe,0x4(%rsp)
cmp    0x8(%rsp),%r15d
mov    %eax,%r15d
je     1270 <test+0x160>
mov    %ecx,0xc(%rsp)
mov    %ecx,%eax
mov    $0xaaaaaaab,%esi
imul   %rsi,%rax
shr    $0x21,%rax
cmp    %eax,%ebx
cmovg  %ebx,%eax
mov    %r15d,%r14d
mov    0x10(%rsp),%rdx
sub    %edx,%r14d
lea    (%r15,%r15,1),%ecx
add    $0x2,%ecx
imul   %rsi,%rcx
shr    $0x21,%rcx
cmp    %ecx,%r14d
cmovle %ecx,%r14d
lea    (%r15,%rdx,1),%ecx
lea    (%rcx,%rcx,1),%edx
movslq %edx,%rdx
imul   $0x55555556,%rdx,%r12
mov    %r12,%rsi
shr    $0x3f,%rsi
shr    $0x20,%r12
add    %esi,%r12d
mov    $0x2,%esi
sub    %edx,%esi
movslq %esi,%rdx
imul   $0x55555555,%rdx,%rsi
shr    $0x20,%rsi
sub    %edx,%esi
mov    %esi,%edx
shr    $0x1f,%edx
sar    %esi
add    %edx,%esi
cmp    %esi,%r15d
cmovl  %r15d,%esi
cmp    %r12d,%r15d
cmovl  %r15d,%r12d
test   %ecx,%ecx
cmovs  %esi,%r12d
cmp    %r12d,%r14d
jg     1160 <test+0x50>
mov    %r15d,%ebp
sub    %eax,%ebp
lea    (%rax,%rax,2),%r13d
add    0x4(%rsp),%r13d
jmp    1247 <test+0x137>
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%r14),%eax
add    $0xffffffff,%ebp
add    $0x3,%r13d
cmp    %r12d,%r14d
mov    %eax,%r14d
jge    1160 <test+0x50>
test   $0x1,%r14b
jne    1230 <test+0x120>
mov    $0x1,%edi
call   1030 <hash@plt>
mov    %r13d,%edi
shr    $0x1f,%edi
add    %r13d,%edi
sar    %edi
call   1030 <hash@plt>
mov    %ebp,%edi
call   1030 <hash@plt>
jmp    1230 <test+0x120>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @test(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
store i32 %0, i32* %2
store i32 0, i32* %3
br label %7
7: ; preds = %151, %1
%8 = load i32, i32* %3
%9 = load i32, i32* %2
%10 = mul nsw i32 5, %9
%11 = icmp sle i32 %8, %10
br i1 %11, label %12, label %154
12: ; preds = %7
%13 = load i32, i32* %3
%14 = load i32, i32* %2
%15 = sub nsw i32 %13, %14
%16 = load i32, i32* %3
%17 = mul nsw i32 2, %16
%18 = icmp slt i32 %17, 0
br i1 %18, label %19, label %25
19: ; preds = %12
%20 = load i32, i32* %3
%21 = mul nsw i32 2, %20
%22 = sub nsw i32 0, %21
%23 = sdiv i32 %22, 3
%24 = sub nsw i32 0, %23
br label %31
25: ; preds = %12
%26 = load i32, i32* %3
%27 = mul nsw i32 2, %26
%28 = add nsw i32 %27, 3
%29 = sub nsw i32 %28, 1
%30 = sdiv i32 %29, 3
br label %31
31: ; preds = %25, %19
%32 = phi i32 [ %24, %19 ], [ %30, %25 ]
%33 = icmp sgt i32 %15, %32
br i1 %33, label %34, label %38
34: ; preds = %31
%35 = load i32, i32* %3
%36 = load i32, i32* %2
%37 = sub nsw i32 %35, %36
br label %56
38: ; preds = %31
%39 = load i32, i32* %3
%40 = mul nsw i32 2, %39
%41 = icmp slt i32 %40, 0
br i1 %41, label %42, label %48
42: ; preds = %38
%43 = load i32, i32* %3
%44 = mul nsw i32 2, %43
%45 = sub nsw i32 0, %44
%46 = sdiv i32 %45, 3
%47 = sub nsw i32 0, %46
br label %54
48: ; preds = %38
%49 = load i32, i32* %3
%50 = mul nsw i32 2, %49
%51 = add nsw i32 %50, 3
%52 = sub nsw i32 %51, 1
%53 = sdiv i32 %52, 3
br label %54
54: ; preds = %48, %42
%55 = phi i32 [ %47, %42 ], [ %53, %48 ]
br label %56
56: ; preds = %54, %34
%57 = phi i32 [ %37, %34 ], [ %55, %54 ]
store i32 %57, i32* %4
br label %58
58: ; preds = %147, %56
%59 = load i32, i32* %4
%60 = load i32, i32* %3
%61 = load i32, i32* %3
%62 = mul nsw i32 2, %61
%63 = load i32, i32* %2
%64 = mul nsw i32 2, %63
%65 = add nsw i32 %62, %64
%66 = icmp slt i32 %65, 0
br i1 %66, label %67, label %78
67: ; preds = %58
%68 = load i32, i32* %3
%69 = mul nsw i32 2, %68
%70 = load i32, i32* %2
%71 = mul nsw i32 2, %70
%72 = add nsw i32 %69, %71
%73 = sub nsw i32 0, %72
%74 = add nsw i32 %73, 3
%75 = sub nsw i32 %74, 1
%76 = sdiv i32 %75, 3
%77 = sub nsw i32 0, %76
br label %85
78: ; preds = %58
%79 = load i32, i32* %3
%80 = mul nsw i32 2, %79
%81 = load i32, i32* %2
%82 = mul nsw i32 2, %81
%83 = add nsw i32 %80, %82
%84 = sdiv i32 %83, 3
br label %85
85: ; preds = %78, %67
%86 = phi i32 [ %77, %67 ], [ %84, %78 ]
%87 = icmp slt i32 %60, %86
br i1 %87, label %88, label %90
88: ; preds = %85
%89 = load i32, i32* %3
br label %117
90: ; preds = %85
%91 = load i32, i32* %3
%92 = mul nsw i32 2, %91
%93 = load i32, i32* %2
%94 = mul nsw i32 2, %93
%95 = add nsw i32 %92, %94
%96 = icmp slt i32 %95, 0
br i1 %96, label %97, label %108
97: ; preds = %90
%98 = load i32, i32* %3
%99 = mul nsw i32 2, %98
%100 = load i32, i32* %2
%101 = mul nsw i32 2, %100
%102 = add nsw i32 %99, %101
%103 = sub nsw i32 0, %102
%104 = add nsw i32 %103, 3
%105 = sub nsw i32 %104, 1
%106 = sdiv i32 %105, 3
%107 = sub nsw i32 0, %106
br label %115
108: ; preds = %90
%109 = load i32, i32* %3
%110 = mul nsw i32 2, %109
%111 = load i32, i32* %2
%112 = mul nsw i32 2, %111
%113 = add nsw i32 %110, %112
%114 = sdiv i32 %113, 3
br label %115
115: ; preds = %108, %97
%116 = phi i32 [ %107, %97 ], [ %114, %108 ]
br label %117
117: ; preds = %115, %88
%118 = phi i32 [ %89, %88 ], [ %116, %115 ]
%119 = icmp sle i32 %59, %118
br i1 %119, label %120, label %150
120: ; preds = %117
%121 = load i32, i32* %4
%122 = srem i32 %121, 2
%123 = icmp eq i32 %122, 0
br i1 %123, label %124, label %146
124: ; preds = %120
%125 = load i32, i32* %3
%126 = mul nsw i32 -2, %125
%127 = load i32, i32* %4
%128 = mul nsw i32 3, %127
%129 = add nsw i32 %126, %128
%130 = sdiv i32 %129, 2
store i32 %130, i32* %5
%131 = load i32, i32* %3
%132 = load i32, i32* %4
%133 = sub nsw i32 %131, %132
store i32 %133, i32* %6
%134 = call i32 @hash(i32 1)
%135 = load i32, i32* %3
%136 = mul nsw i32 -2, %135
%137 = load i32, i32* %4
%138 = mul nsw i32 3, %137
%139 = add nsw i32 %136, %138
%140 = sdiv i32 %139, 2
%141 = call i32 @hash(i32 %140)
%142 = load i32, i32* %3
%143 = load i32, i32* %4
%144 = sub nsw i32 %142, %143
%145 = call i32 @hash(i32 %144)
br label %146
146: ; preds = %124, %120
br label %147
147: ; preds = %146
%148 = load i32, i32* %4
%149 = add nsw i32 %148, 1
store i32 %149, i32* %4
br label %58
150: ; preds = %117
br label %151
151: ; preds = %150
%152 = load i32, i32* %3
%153 = add nsw i32 %152, 1
store i32 %153, i32* %3
br label %7
154: ; preds = %7
ret void
}

LLVM IR (-O2):
define void @test(i32 %0) {
%2 = icmp slt i32 %0, 0
br i1 %2, label %45, label %3
3: ; preds = %1
%4 = mul i32 %0, 5
%5 = call i32 @llvm.smax.i32(i32 %4, i32 0)
br label %6
6: ; preds = %3, %42
%7 = phi i32 [ %43, %42 ], [ 0, %3 ]
%8 = sub nsw i32 %7, %0
%9 = shl nuw nsw i32 %7, 1
%10 = add nuw nsw i32 %9, 2
%11 = udiv i32 %10, 3
%12 = icmp sgt i32 %8, %11
%13 = select i1 %12, i32 %8, i32 %11
%14 = add nsw i32 %7, %0
%15 = shl nsw i32 %14, 1
%16 = icmp slt i32 %14, 0
%17 = sdiv i32 %15, 3
%18 = icmp slt i32 %7, %17
%19 = sub i32 2, %15
%20 = sdiv i32 %19, -3
%21 = icmp slt i32 %7, %20
%22 = mul nsw i32 %7, -2
%23 = select i1 %21, i32 %7, i32 %20
%24 = select i1 %18, i32 %7, i32 %17
%25 = select i1 %16, i32 %23, i32 %24
%26 = icmp sgt i32 %13, %25
br i1 %26, label %42, label %27
27: ; preds = %6, %39
%28 = phi i32 [ %40, %39 ], [ %13, %6 ]
%29 = and i32 %28, 1
%30 = icmp eq i32 %29, 0
br i1 %30, label %31, label %39
31: ; preds = %27
%32 = mul nsw i32 %28, 3
%33 = add nsw i32 %32, %22
%34 = tail call i32 @hash(i32 1)
%35 = sdiv i32 %33, 2
%36 = tail call i32 @hash(i32 %35)
%37 = sub nsw i32 %7, %28
%38 = tail call i32 @hash(i32 %37)
br label %39
39: ; preds = %27, %31
%40 = add nuw nsw i32 %28, 1
%41 = icmp slt i32 %28, %25
br i1 %41, label %27, label %42
42: ; preds = %39, %6
%43 = add nuw i32 %7, 1
%44 = icmp eq i32 %7, %5
br i1 %44, label %45, label %6
45: ; preds = %42, %1
ret void
}