#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*/ assert(int);
int /*<<< orphan*/ assume_abort_if_not(int);
int main() {
  short k;
  long long y, x, c;
  assume_abort_if_not(k >= 0 && k <= 5);
  assume_abort_if_not(k <= 256);
  y = 0;
  x = 0;
  c = 0;
  while (1) {
    assert(-2 * y * y * y * y * y * y - 6 * y * y * y * y * y -
               5 * y * y * y * y + y * y + 12 * x ==
           0);
    if (!(c < k))
      break;
    c = c + 1;
    y = y + 1;
    x = y * y * y * y * y + x;
  }
  assert(-2 * y * y * y * y * y * y - 6 * y * y * y * y * y -
             5 * y * y * y * y + y * y + 12 * x ==
         0);
  assert(k * y == y * y);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
movswl -0x6(%rbp),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x21(%rbp)
jl     114e <main+0x2e>
movswl -0x6(%rbp),%eax
cmp    $0x5,%eax
setle  %al
mov    %al,-0x21(%rbp)
mov    -0x21(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assume_abort_if_not@plt>
movswl -0x6(%rbp),%eax
cmp    $0x100,%eax
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assume_abort_if_not@plt>
movq   $0x0,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
imul   $0xfffffffffffffffe,-0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   $0x6,-0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
sub    %rcx,%rax
imul   $0x5,-0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
sub    %rcx,%rax
mov    -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    %rcx,%rax
imul   $0xc,-0x18(%rbp),%rcx
add    %rcx,%rax
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x20(%rbp),%rax
movswq -0x6(%rbp),%rcx
cmp    %rcx,%rax
jl     1216 <main+0xf6>
jmp    1253 <main+0x133>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1189 <main+0x69>
imul   $0xfffffffffffffffe,-0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
imul   $0x6,-0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
sub    %rcx,%rax
imul   $0x5,-0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
sub    %rcx,%rax
mov    -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    %rcx,%rax
imul   $0xc,-0x18(%rbp),%rcx
add    %rcx,%rax
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movswq -0x6(%rbp),%rax
imul   -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
mov    $0x1,%edi
call   1040 <assume_abort_if_not@plt>
mov    $0x1,%edi
call   1040 <assume_abort_if_not@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
xor    %eax,%eax
pop    %rcx
ret

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

LLVM IR (-O2):
define i32 @main() {
%1 = tail call i32 @assume_abort_if_not(i32 1)
%2 = tail call i32 @assume_abort_if_not(i32 1)
%3 = tail call i32 @assert(i32 1)
%4 = tail call i32 @assert(i32 1)
%5 = tail call i32 @assert(i32 1)
ret i32 0
}