xunge/DecIR huggingface dataset:
int bar(int x, int y) {
  int z = x % y;
  return z;
}


x86 assembly (clang, -O0):
<bar>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    -0x4(%rbp),%eax
cltd
idivl  -0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    -0xc(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<bar>:
mov    %edi,%eax
cltd
idiv   %esi
mov    %edx,%eax
ret

LLVM IR (-O0):
define i32 @bar(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
store i32 %0, i32* %3
store i32 %1, i32* %4
%6 = load i32, i32* %3
%7 = load i32, i32* %4
%8 = srem i32 %6, %7
store i32 %8, i32* %5
%9 = load i32, i32* %5
ret i32 %9
}

LLVM IR (-O2):
define i32 @bar(i32 %0, i32 %1) {
%3 = srem i32 %0, %1
ret i32 %3
}
/* Variables and functions */
int gensymm_main(int, char **);
int main(int argc, char *argv[]) { return (gensymm_main(argc, argv)); }


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1030 <gensymm_main@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
jmp    1030 <gensymm_main@plt>

LLVM IR (-O0):
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%6 = load i32, i32* %4
%7 = load i8**, i8*** %5
%8 = call i32 @gensymm_main(i32 %6, i8** %7)
ret i32 %8
}

LLVM IR (-O2):
define i32 @main(i32 %0, i8** %1) {
%3 = tail call i32 @gensymm_main(i32 %0, i8** %1)
ret i32 %3
}
int main() {
  int *p, a;
  if (a)
    p = &a;
  printf("%u %u", p, &p);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movl   $0x0,-0x4(%rbp)
cmpl   $0x0,-0x14(%rbp)
je     1131 <main+0x21>
lea    -0x14(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rsi
lea    0xec4(%rip),%rdi
lea    -0x10(%rbp),%rdx
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
sub    $0x18,%rsp
lea    0x14(%rsp),%rsi
mov    %rsi,0x8(%rsp)
lea    0xedb(%rip),%rdi
lea    0x8(%rsp),%rdx
xor    %eax,%eax
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x18,%rsp
ret

LLVM IR (-O0):
@.str = [6 x i8] c"%u %u\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32*
%3 = alloca i32
store i32 0, i32* %1
%4 = load i32, i32* %3
%5 = icmp ne i32 %4, 0
br i1 %5, label %6, label %7
6: ; preds = %0
store i32* %3, i32** %2
br label %7
7: ; preds = %6, %0
%8 = load i32*, i32** %2
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32* %8, i32** %2)
ret i32 0
}

LLVM IR (-O2):
@.str = [6 x i8] c"%u %u\00"
define i32 @main() {
%1 = alloca i32*
%2 = alloca i32
%3 = bitcast i32** %1 to i8*
%4 = bitcast i32* %2 to i8*
store i32* %2, i32** %1
%5 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32* %2, i32** %1)
ret i32 0
}
/* Variables and functions */
int ENXIO;
__attribute__((deprecated)) int
snd_tlv_convert_to_dB(unsigned int *tlv, long rangemin, long rangemax,
                      long volume, long *db_gain) {
  return -ENXIO;
}


x86 assembly (clang, -O0):
<snd_tlv_convert_to_dB>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
xor    %eax,%eax
mov    0x2ebf(%rip),%rcx
sub    (%rcx),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<snd_tlv_convert_to_dB>:
mov    0x2ed9(%rip),%rcx
xor    %eax,%eax
sub    (%rcx),%eax
ret

LLVM IR (-O0):
@ENXIO = global i32 0
define i32 @snd_tlv_convert_to_dB(i32* %0, i64 %1, i64 %2, i64 %3, i64* %4) {
%6 = alloca i32*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64*
store i32* %0, i32** %6
store i64 %1, i64* %7
store i64 %2, i64* %8
store i64 %3, i64* %9
store i64* %4, i64** %10
%11 = load i32, i32* @ENXIO
%12 = sub nsw i32 0, %11
ret i32 %12
}

LLVM IR (-O2):
@ENXIO = global i32 0
define i32 @snd_tlv_convert_to_dB(i32* nocapture readnone %0, i64 %1, i64 %2, i64 %3, i64* nocapture readnone %4) {
%6 = load i32, i32* @ENXIO
%7 = sub nsw i32 0, %6
ret i32 %7
}
void foo(void) {
  enum foo_tag { e_foo };
  volatile unsigned char a = e_foo;
}


x86 assembly (clang, -O0):
<foo>:
push   %rbp
mov    %rsp,%rbp
movb   $0x0,-0x1(%rbp)
pop    %rbp
ret

x86 assembly (clang, -O2):
<foo>:
movb   $0x0,-0x1(%rsp)
ret

LLVM IR (-O0):
define void @foo() {
%1 = alloca i8
store volatile i8 0, i8* %1
ret void
}

LLVM IR (-O2):
define void @foo() {
%1 = alloca i8
store volatile i8 0, i8* %1
ret void
}
/* Variables and functions */
int /*<<< orphan*/ whichtable(char **);
void prepare_s(const char *fmt) { whichtable((char **)&fmt); }


x86 assembly (clang, -O0):
<prepare_s>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
lea    -0x8(%rbp),%rdi
call   1030 <whichtable@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<prepare_s>:
push   %rax
mov    %rdi,(%rsp)
mov    %rsp,%rdi
call   1030 <whichtable@plt>
pop    %rax
ret

LLVM IR (-O0):
define void @prepare_s(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = call i32 @whichtable(i8** %2)
ret void
}

LLVM IR (-O2):
define void @prepare_s(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = call i32 @whichtable(i8** %2)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ absolutelong();
int /*<<< orphan*/ readmemw65816(int /*<<< orphan*/);
int /*<<< orphan*/ sbc16(int /*<<< orphan*/);
void sbcLong16(void) { sbc16(readmemw65816(absolutelong())); }


x86 assembly (clang, -O0):
<sbcLong16>:
push   %rbp
mov    %rsp,%rbp
mov    $0x0,%al
call   1030 <absolutelong@plt>
mov    %eax,%edi
call   1040 <readmemw65816@plt>
mov    %eax,%edi
call   1050 <sbc16@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<sbcLong16>:
push   %rax
xor    %eax,%eax
call   1030 <absolutelong@plt>
mov    %eax,%edi
call   1040 <readmemw65816@plt>
mov    %eax,%edi
pop    %rax
jmp    1050 <sbc16@plt>

LLVM IR (-O0):
define void @sbcLong16() {
%1 = call i32 (...) @absolutelong()
%2 = call i32 @readmemw65816(i32 %1)
%3 = call i32 @sbc16(i32 %2)
ret void
}

LLVM IR (-O2):
define void @sbcLong16() {
%1 = tail call i32 (...) @absolutelong()
%2 = tail call i32 @readmemw65816(i32 %1)
%3 = tail call i32 @sbc16(i32 %2)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ fixed_test(int);
int /*<<< orphan*/ null_test();
int /*<<< orphan*/ random_test();
int main(void) {
  fixed_test(15);
  fixed_test(5);
  fixed_test(17);
  fixed_test(6);
  fixed_test(31);
  fixed_test(96);
  random_test();
  null_test();
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0xf,%edi
call   1030 <fixed_test@plt>
mov    $0x5,%edi
call   1030 <fixed_test@plt>
mov    $0x11,%edi
call   1030 <fixed_test@plt>
mov    $0x6,%edi
call   1030 <fixed_test@plt>
mov    $0x1f,%edi
call   1030 <fixed_test@plt>
mov    $0x60,%edi
call   1030 <fixed_test@plt>
mov    $0x0,%al
call   1050 <random_test@plt>
mov    $0x0,%al
call   1040 <null_test@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
mov    $0xf,%edi
call   1030 <fixed_test@plt>
mov    $0x5,%edi
call   1030 <fixed_test@plt>
mov    $0x11,%edi
call   1030 <fixed_test@plt>
mov    $0x6,%edi
call   1030 <fixed_test@plt>
mov    $0x1f,%edi
call   1030 <fixed_test@plt>
mov    $0x60,%edi
call   1030 <fixed_test@plt>
xor    %eax,%eax
call   1050 <random_test@plt>
xor    %eax,%eax
call   1040 <null_test@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
define i32 @main() {
%1 = alloca i32
store i32 0, i32* %1
%2 = call i32 @fixed_test(i32 15)
%3 = call i32 @fixed_test(i32 5)
%4 = call i32 @fixed_test(i32 17)
%5 = call i32 @fixed_test(i32 6)
%6 = call i32 @fixed_test(i32 31)
%7 = call i32 @fixed_test(i32 96)
%8 = call i32 (...) @random_test()
%9 = call i32 (...) @null_test()
ret i32 0
}

LLVM IR (-O2):
define i32 @main() {
%1 = tail call i32 @fixed_test(i32 15)
%2 = tail call i32 @fixed_test(i32 5)
%3 = tail call i32 @fixed_test(i32 17)
%4 = tail call i32 @fixed_test(i32 6)
%5 = tail call i32 @fixed_test(i32 31)
%6 = tail call i32 @fixed_test(i32 96)
%7 = tail call i32 (...) @random_test()
%8 = tail call i32 (...) @null_test()
ret i32 0
}
int vbench_median(int a, int b, int c) {
  int t = (a - b) & ((a - b) >> 31);
  a -= t;
  b += t;
  b -= (b - c) & ((b - c) >> 31);
  b += (a - b) & ((a - b) >> 31);
  return b;
}


x86 assembly (clang, -O0):
<vbench_median>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    -0x4(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    -0x8(%rbp),%ecx
sar    $0x1f,%ecx
and    %ecx,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0x4(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
mov    -0x10(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%ecx
sub    -0xc(%rbp),%ecx
mov    -0x8(%rbp),%eax
sub    -0xc(%rbp),%eax
sar    $0x1f,%eax
and    %eax,%ecx
mov    -0x8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x8(%rbp)
mov    -0x4(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    -0x8(%rbp),%ecx
sar    $0x1f,%ecx
and    %ecx,%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<vbench_median>:
mov    %edi,%eax
sub    %esi,%eax
mov    %eax,%ecx
sar    $0x1f,%ecx
and    %eax,%ecx
add    %ecx,%esi
cmp    %edx,%esi
cmovl  %edx,%esi
add    %esi,%ecx
sub    %ecx,%edi
mov    %edi,%eax
sar    $0x1f,%eax
and    %edi,%eax
add    %esi,%eax
ret

LLVM IR (-O0):
define i32 @vbench_median(i32 %0, i32 %1, i32 %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
store i32 %0, i32* %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%8 = load i32, i32* %4
%9 = load i32, i32* %5
%10 = sub nsw i32 %8, %9
%11 = load i32, i32* %4
%12 = load i32, i32* %5
%13 = sub nsw i32 %11, %12
%14 = ashr i32 %13, 31
%15 = and i32 %10, %14
store i32 %15, i32* %7
%16 = load i32, i32* %7
%17 = load i32, i32* %4
%18 = sub nsw i32 %17, %16
store i32 %18, i32* %4
%19 = load i32, i32* %7
%20 = load i32, i32* %5
%21 = add nsw i32 %20, %19
store i32 %21, i32* %5
%22 = load i32, i32* %5
%23 = load i32, i32* %6
%24 = sub nsw i32 %22, %23
%25 = load i32, i32* %5
%26 = load i32, i32* %6
%27 = sub nsw i32 %25, %26
%28 = ashr i32 %27, 31
%29 = and i32 %24, %28
%30 = load i32, i32* %5
%31 = sub nsw i32 %30, %29
store i32 %31, i32* %5
%32 = load i32, i32* %4
%33 = load i32, i32* %5
%34 = sub nsw i32 %32, %33
%35 = load i32, i32* %4
%36 = load i32, i32* %5
%37 = sub nsw i32 %35, %36
%38 = ashr i32 %37, 31
%39 = and i32 %34, %38
%40 = load i32, i32* %5
%41 = add nsw i32 %40, %39
store i32 %41, i32* %5
%42 = load i32, i32* %5
ret i32 %42
}

LLVM IR (-O2):
define i32 @vbench_median(i32 %0, i32 %1, i32 %2) {
%4 = sub nsw i32 %0, %1
%5 = icmp slt i32 %4, 0
%6 = select i1 %5, i32 %4, i32 0
%7 = add nsw i32 %6, %1
%8 = icmp slt i32 %7, %2
%9 = select i1 %8, i32 %2, i32 %7
%10 = add i32 %6, %9
%11 = sub i32 %0, %10
%12 = icmp slt i32 %11, 0
%13 = select i1 %12, i32 %11, i32 0
%14 = add nsw i32 %13, %9
ret i32 %14
}
/* Variables and functions */
unsigned long strlen(void *);
unsigned long lenValue(void *key, int currentValue) { return (strlen(key)); }


x86 assembly (clang, -O0):
<lenValue>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lenValue>:
jmp    1030 <strlen@plt>

LLVM IR (-O0):
define i64 @lenValue(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
store i8* %0, i8** %3
store i32 %1, i32* %4
%5 = load i8*, i8** %3
%6 = call i64 @strlen(i8* %5)
ret i64 %6
}

LLVM IR (-O2):
define i64 @lenValue(i8* nocapture %0, i32 %1) {
%3 = tail call i64 @strlen(i8* dereferenceable(1) %0)
ret i64 %3
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, int);
void mult_2(int h, int i) { printf("%d\n", h * i); }


x86 assembly (clang, -O0):
<mult_2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    -0x4(%rbp),%esi
imul   -0x8(%rbp),%esi
lea    0xed4(%rip),%rdi
call   1030 <printf@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mult_2>:
imul   %edi,%esi
lea    0xee6(%rip),%rdi
jmp    1030 <printf@plt>

LLVM IR (-O0):
@.str = [4 x i8] c"%d\0A\00"
define void @mult_2(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
store i32 %0, i32* %3
store i32 %1, i32* %4
%5 = load i32, i32* %3
%6 = load i32, i32* %4
%7 = mul nsw i32 %5, %6
%8 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %7)
ret void
}

LLVM IR (-O2):
@.str = [4 x i8] c"%d\0A\00"
define void @mult_2(i32 %0, i32 %1) {
%3 = mul nsw i32 %1, %0
%4 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %3)
ret void
}
void g18(void) { extern int g19; }


x86 assembly (clang, -O0):
<g18>:
push   %rbp
mov    %rsp,%rbp
pop    %rbp
ret

x86 assembly (clang, -O2):
<g18>:
ret

LLVM IR (-O0):
define void @g18() {
ret void
}

LLVM IR (-O2):
define void @g18() {
ret void
}
void RTAvlrFileOffsetGet(void) {}


x86 assembly (clang, -O0):
<RTAvlrFileOffsetGet>:
push   %rbp
mov    %rsp,%rbp
pop    %rbp
ret

x86 assembly (clang, -O2):
<RTAvlrFileOffsetGet>:
ret

LLVM IR (-O0):
define void @RTAvlrFileOffsetGet() {
ret void
}

LLVM IR (-O2):
define void @RTAvlrFileOffsetGet() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ io_set_pgc(int);
int /*<<< orphan*/ io_set_pgd(int);
int /*<<< orphan*/ io_set_pgm(int);
int /*<<< orphan*/ io_set_vpp(int);
void pic24_standby(void) {
  io_set_pgd((0x00));
  io_set_pgc((0x00));
  io_set_vpp((0x00));
  io_set_pgm((0x00));
}


x86 assembly (clang, -O0):
<pic24_standby>:
push   %rbp
mov    %rsp,%rbp
xor    %edi,%edi
call   1050 <io_set_pgd@plt>
xor    %edi,%edi
call   1060 <io_set_pgc@plt>
xor    %edi,%edi
call   1040 <io_set_vpp@plt>
xor    %edi,%edi
call   1030 <io_set_pgm@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<pic24_standby>:
push   %rax
xor    %edi,%edi
call   1050 <io_set_pgd@plt>
xor    %edi,%edi
call   1060 <io_set_pgc@plt>
xor    %edi,%edi
call   1040 <io_set_vpp@plt>
xor    %edi,%edi
pop    %rax
jmp    1030 <io_set_pgm@plt>

LLVM IR (-O0):
define void @pic24_standby() {
%1 = call i32 @io_set_pgd(i32 0)
%2 = call i32 @io_set_pgc(i32 0)
%3 = call i32 @io_set_vpp(i32 0)
%4 = call i32 @io_set_pgm(i32 0)
ret void
}

LLVM IR (-O2):
define void @pic24_standby() {
%1 = tail call i32 @io_set_pgd(i32 0)
%2 = tail call i32 @io_set_pgc(i32 0)
%3 = tail call i32 @io_set_vpp(i32 0)
%4 = tail call i32 @io_set_pgm(i32 0)
ret void
}
void *__attribute__((no)) __attribute__((noclone)) test4a(char *p) {
  void *temp;
  temp = __builtin_return_address(1);
  return temp;
}


x86 assembly (clang, -O0):
<test4a>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rbp,%rax
mov    (%rax),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<test4a>:
push   %rbp
mov    %rsp,%rbp
mov    0x0(%rbp),%rax
mov    0x8(%rax),%rax
pop    %rbp
ret

LLVM IR (-O0):
define i8* @test4a(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
store i8* %0, i8** %2
%4 = call i8* @llvm.returnaddress(i32 1)
store i8* %4, i8** %3
%5 = load i8*, i8** %3
ret i8* %5
}

LLVM IR (-O2):
define i8* @test4a(i8* nocapture readnone %0) {
%2 = tail call i8* @llvm.returnaddress(i32 1)
ret i8* %2
}
/* Type definitions */
typedef int /*<<< orphan*/ SSL;

/* Variables and functions */
int ssl_has_ecc_ciphers(int /*<<< orphan*/ *);
int tlsext_ecpf_clienthello_needs(SSL *s) { return ssl_has_ecc_ciphers(s); }


x86 assembly (clang, -O0):
<tlsext_ecpf_clienthello_needs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <ssl_has_ecc_ciphers@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tlsext_ecpf_clienthello_needs>:
jmp    1030 <ssl_has_ecc_ciphers@plt>

LLVM IR (-O0):
define i32 @tlsext_ecpf_clienthello_needs(i32* %0) {
%2 = alloca i32*
store i32* %0, i32** %2
%3 = load i32*, i32** %2
%4 = call i32 @ssl_has_ecc_ciphers(i32* %3)
ret i32 %4
}

LLVM IR (-O2):
define i32 @tlsext_ecpf_clienthello_needs(i32* %0) {
%2 = tail call i32 @ssl_has_ecc_ciphers(i32* %0)
ret i32 %2
}
/* Variables and functions */
int /*<<< orphan*/ put32(unsigned long);
int /*<<< orphan*/ put8(int);
void imul_m32(void *_m32) {
  unsigned long *m32 = (unsigned long *)_m32;
  put8(0xF7);
  put8(0x2D);
  put32((unsigned long)(m32));
}


x86 assembly (clang, -O0):
<imul_m32>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    $0xf7,%edi
call   1030 <put8@plt>
mov    $0x2d,%edi
call   1030 <put8@plt>
mov    -0x10(%rbp),%rdi
call   1040 <put32@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<imul_m32>:
push   %rbx
mov    %rdi,%rbx
mov    $0xf7,%edi
call   1030 <put8@plt>
mov    $0x2d,%edi
call   1030 <put8@plt>
mov    %rbx,%rdi
pop    %rbx
jmp    1040 <put32@plt>

LLVM IR (-O0):
define void @imul_m32(i8* %0) {
%2 = alloca i8*
%3 = alloca i64*
store i8* %0, i8** %2
%4 = load i8*, i8** %2
%5 = bitcast i8* %4 to i64*
store i64* %5, i64** %3
%6 = call i32 @put8(i32 247)
%7 = call i32 @put8(i32 45)
%8 = load i64*, i64** %3
%9 = ptrtoint i64* %8 to i64
%10 = call i32 @put32(i64 %9)
ret void
}

LLVM IR (-O2):
define void @imul_m32(i8* %0) {
%2 = tail call i32 @put8(i32 247)
%3 = tail call i32 @put8(i32 45)
%4 = ptrtoint i8* %0 to i64
%5 = tail call i32 @put32(i64 %4)
ret void
}
/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *);
void write_footer(FILE *file) {
  fprintf(file, "    {}\n");
  fprintf(file, "};\n");
}


x86 assembly (clang, -O0):
<write_footer>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xed9(%rip),%rsi
call   1030 <fprintf@plt>
mov    -0x8(%rbp),%rdi
lea    0xed1(%rip),%rsi
call   1030 <fprintf@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<write_footer>:
push   %rbx
mov    %rdi,%rbx
lea    0xee5(%rip),%rdi
mov    $0x7,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1030 <fwrite@plt>
lea    0xed4(%rip),%rdi
mov    $0x3,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
pop    %rbx
jmp    1030 <fwrite@plt>

LLVM IR (-O0):
@.str = [8 x i8] c" {}\0A\00"
@.str.1 = [4 x i8] c"};\0A\00"
define void @write_footer(i32* %0) {
%2 = alloca i32*
store i32* %0, i32** %2
%3 = load i32*, i32** %2
%4 = call i32 @fprintf(i32* %3, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%5 = load i32*, i32** %2
%6 = call i32 @fprintf(i32* %5, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [8 x i8] c" {}\0A\00"
@.str.1 = [4 x i8] c"};\0A\00"
define void @write_footer(i32* nocapture %0) {
%2 = tail call i64 @fwrite(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 7, i64 1, i32* %0)
%3 = tail call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i64 3, i64 1, i32* %0)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ EINVAL;
int /*<<< orphan*/ errno;
int _kill(int pid, int sig) {
  (void)pid;
  (void)sig;
  errno = EINVAL;
  return (-1);
}


x86 assembly (clang, -O0):
<_kill>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    0x2ec7(%rip),%rax
mov    (%rax),%ecx
mov    0x2ec6(%rip),%rax
mov    %ecx,(%rax)
mov    $0xffffffff,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<_kill>:
mov    0x2ed1(%rip),%rax
mov    (%rax),%eax
mov    0x2ed0(%rip),%rcx
mov    %eax,(%rcx)
mov    $0xffffffff,%eax
ret

LLVM IR (-O0):
@EINVAL = global i32 0
@errno = global i32 0
define i32 @_kill(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
store i32 %0, i32* %3
store i32 %1, i32* %4
%5 = load i32, i32* %3
%6 = load i32, i32* %4
%7 = load i32, i32* @EINVAL
store i32 %7, i32* @errno
ret i32 -1
}

LLVM IR (-O2):
@EINVAL = global i32 0
@errno = global i32 0
define i32 @_kill(i32 %0, i32 %1) {
%3 = load i32, i32* @EINVAL
store i32 %3, i32* @errno
ret i32 -1
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, char, char);
int /*<<< orphan*/ scanf(char *, char *);
int main() {
  char c = 0;
  scanf("%c", &c);
  if (c >= 'a' && c <= 'z') {
    printf("The uppercase of %c is %c\n", c, 'A' + c - 'a');
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
movb   $0x0,-0x5(%rbp)
lea    0xec6(%rip),%rdi
lea    -0x5(%rbp),%rsi
call   1040 <scanf@plt>
movsbl -0x5(%rbp),%eax
cmp    $0x61,%eax
jl     117c <main+0x5c>
movsbl -0x5(%rbp),%eax
cmp    $0x7a,%eax
jg     117c <main+0x5c>
mov    -0x5(%rbp),%cl
movsbl -0x5(%rbp),%eax
add    $0x41,%eax
sub    $0x61,%eax
lea    0xe92(%rip),%rdi
movsbl %cl,%esi
movsbl %al,%edx
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
movb   $0x0,0x7(%rsp)
lea    0xed3(%rip),%rdi
lea    0x7(%rsp),%rsi
call   1040 <scanf@plt>
mov    0x7(%rsp),%al
lea    -0x61(%rax),%ecx
cmp    $0x19,%cl
ja     1157 <main+0x37>
movsbl %al,%esi
add    $0xe0,%al
movsbl %al,%edx
lea    0xeb1(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%c\00"
@.str.1 = [27 x i8] c"The uppercase of %c is %c\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i8
store i32 0, i32* %1
store i8 0, i8* %2
%3 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %2)
%4 = load i8, i8* %2
%5 = sext i8 %4 to i32
%6 = icmp sge i32 %5, 97
br i1 %6, label %7, label %19
7: ; preds = %0
%8 = load i8, i8* %2
%9 = sext i8 %8 to i32
%10 = icmp sle i32 %9, 122
br i1 %10, label %11, label %19
11: ; preds = %7
%12 = load i8, i8* %2
%13 = load i8, i8* %2
%14 = sext i8 %13 to i32
%15 = add nsw i32 65, %14
%16 = sub nsw i32 %15, 97
%17 = trunc i32 %16 to i8
%18 = call i32 @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.1, i64 0, i64 0), i8 signext %12, i8 signext %17)
br label %19
19: ; preds = %11, %7, %0
ret i32 0
}

LLVM IR (-O2):
@.str = [3 x i8] c"%c\00"
@.str.1 = [27 x i8] c"The uppercase of %c is %c\0A\00"
define i32 @main() {
%1 = alloca i8
store i8 0, i8* %1
%2 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %1)
%3 = load i8, i8* %1
%4 = add i8 %3, -97
%5 = icmp ult i8 %4, 26
br i1 %5, label %6, label %9
6: ; preds = %0
%7 = add nsw i8 %3, -32
%8 = call i32 @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.1, i64 0, i64 0), i8 signext %3, i8 signext %7)
br label %9
9: ; preds = %6, %0
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ add_event_all(int, int /*<<< orphan*/ *);
int /*<<< orphan*/ softmixer_is_active();
int /*<<< orphan*/ softmixer_set_active(int);
void req_toggle_softmixer() {
  softmixer_set_active(!softmixer_is_active());
  add_event_all(0x10, NULL);
}


x86 assembly (clang, -O0):
<req_toggle_softmixer>:
push   %rbp
mov    %rsp,%rbp
mov    $0x0,%al
call   1050 <softmixer_is_active@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1040 <softmixer_set_active@plt>
mov    $0x10,%edi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <add_event_all@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<req_toggle_softmixer>:
push   %rax
xor    %eax,%eax
call   1050 <softmixer_is_active@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   1040 <softmixer_set_active@plt>
mov    $0x10,%edi
xor    %esi,%esi
pop    %rax
jmp    1030 <add_event_all@plt>

LLVM IR (-O0):
define void @req_toggle_softmixer() {
%1 = call i32 (...) @softmixer_is_active()
%2 = icmp ne i32 %1, 0
%3 = xor i1 %2, true
%4 = zext i1 %3 to i32
%5 = call i32 @softmixer_set_active(i32 %4)
%6 = call i32 @add_event_all(i32 16, i32* null)
ret void
}

LLVM IR (-O2):
define void @req_toggle_softmixer() {
%1 = tail call i32 (...) @softmixer_is_active()
%2 = icmp eq i32 %1, 0
%3 = zext i1 %2 to i32
%4 = tail call i32 @softmixer_set_active(i32 %3)
%5 = tail call i32 @add_event_all(i32 16, i32* null)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ CS(int);
int /*<<< orphan*/ DC(int);
int /*<<< orphan*/ LCD_out(unsigned char);
void write_c(unsigned char out_command) {
  DC(0);
  CS(0);
  LCD_out(out_command);
  CS(1);
  DC(1);
}


x86 assembly (clang, -O0):
<write_c>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %dil,%al
mov    %al,-0x1(%rbp)
xor    %edi,%edi
call   1030 <DC@plt>
xor    %edi,%edi
call   1050 <CS@plt>
movzbl -0x1(%rbp),%edi
call   1040 <LCD_out@plt>
mov    $0x1,%edi
call   1050 <CS@plt>
mov    $0x1,%edi
call   1030 <DC@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<write_c>:
push   %rbx
mov    %edi,%ebx
xor    %edi,%edi
call   1030 <DC@plt>
xor    %edi,%edi
call   1050 <CS@plt>
mov    %ebx,%edi
call   1040 <LCD_out@plt>
mov    $0x1,%edi
call   1050 <CS@plt>
mov    $0x1,%edi
pop    %rbx
jmp    1030 <DC@plt>

LLVM IR (-O0):
define void @write_c(i8 zeroext %0) {
%2 = alloca i8
store i8 %0, i8* %2
%3 = call i32 @DC(i32 0)
%4 = call i32 @CS(i32 0)
%5 = load i8, i8* %2
%6 = call i32 @LCD_out(i8 zeroext %5)
%7 = call i32 @CS(i32 1)
%8 = call i32 @DC(i32 1)
ret void
}

LLVM IR (-O2):
define void @write_c(i8 zeroext %0) {
%2 = tail call i32 @DC(i32 0)
%3 = tail call i32 @CS(i32 0)
%4 = tail call i32 @LCD_out(i8 zeroext %0)
%5 = tail call i32 @CS(i32 1)
%6 = tail call i32 @DC(i32 1)
ret void
}
void hander(int signal) { return; }


x86 assembly (clang, -O0):
<hander>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
pop    %rbp
ret

x86 assembly (clang, -O2):
<hander>:
ret

LLVM IR (-O0):
define void @hander(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
ret void
}

LLVM IR (-O2):
define void @hander(i32 %0) {
ret void
}
/* Variables and functions */
int unlink(char *);
int echo_pidfile_delete(char *pathname) { return unlink(pathname); }


x86 assembly (clang, -O0):
<echo_pidfile_delete>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <unlink@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<echo_pidfile_delete>:
jmp    1030 <unlink@plt>

LLVM IR (-O0):
define i32 @echo_pidfile_delete(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = call i32 @unlink(i8* %3)
ret i32 %4
}

LLVM IR (-O2):
define i32 @echo_pidfile_delete(i8* nocapture %0) {
%2 = tail call i32 @unlink(i8* %0)
ret i32 %2
}
/* Variables and functions */
int min2(int, int);
int min4(int a, int b, int c, int d) { return min2(min2(a, b), min2(c, d)); }


x86 assembly (clang, -O0):
<min4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
call   1030 <min2@plt>
mov    %eax,-0x14(%rbp)
mov    -0xc(%rbp),%edi
mov    -0x10(%rbp),%esi
call   1030 <min2@plt>
mov    -0x14(%rbp),%edi
mov    %eax,%esi
call   1030 <min2@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<min4>:
push   %rbp
push   %r14
push   %rbx
mov    %ecx,%r14d
mov    %edx,%ebp
call   1030 <min2@plt>
mov    %eax,%ebx
mov    %ebp,%edi
mov    %r14d,%esi
call   1030 <min2@plt>
mov    %ebx,%edi
mov    %eax,%esi
pop    %rbx
pop    %r14
pop    %rbp
jmp    1030 <min2@plt>

LLVM IR (-O0):
define i32 @min4(i32 %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i32 %0, i32* %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%9 = load i32, i32* %5
%10 = load i32, i32* %6
%11 = call i32 @min2(i32 %9, i32 %10)
%12 = load i32, i32* %7
%13 = load i32, i32* %8
%14 = call i32 @min2(i32 %12, i32 %13)
%15 = call i32 @min2(i32 %11, i32 %14)
ret i32 %15
}

LLVM IR (-O2):
define i32 @min4(i32 %0, i32 %1, i32 %2, i32 %3) {
%5 = tail call i32 @min2(i32 %0, i32 %1)
%6 = tail call i32 @min2(i32 %2, i32 %3)
%7 = tail call i32 @min2(i32 %5, i32 %6)
ret i32 %7
}
char *RCSid() {
  return RCSid("$Id: eval.c,v 1.96.2.5 2013/08/13 23:33:57 sfeam Exp $");
}


x86 assembly (clang, -O0):
<RCSid>:
push   %rbp
mov    %rsp,%rbp
lea    0xee5(%rip),%rdi
mov    $0x0,%al
call   1030 <RCSid@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<RCSid>:
jmp    1100 <RCSid>

LLVM IR (-O0):
@.str = [55 x i8] c"$Id: eval.c,v 1.96.2.5 2013/08/13 23:33:57 sfeam Exp $\00"
define i8* @RCSid() {
%1 = call i8* (i8*, ...) bitcast (i8* ()* @RCSid to i8* (i8*, ...)*)(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str, i64 0, i64 0))
ret i8* %1
}

LLVM IR (-O2):
define noalias i8* @RCSid() {
br label %1
1: ; preds = %1, %0
br label %1
}
void func_loopfb_marker(void) {}


x86 assembly (clang, -O0):
<func_loopfb_marker>:
push   %rbp
mov    %rsp,%rbp
pop    %rbp
ret

x86 assembly (clang, -O2):
<func_loopfb_marker>:
ret

LLVM IR (-O0):
define void @func_loopfb_marker() {
ret void
}

LLVM IR (-O2):
define void @func_loopfb_marker() {
ret void
}
/* Variables and functions */
int global_fd_log();
int write(int, char *, int);
int print_green(int fd_out, char *str, unsigned long size) {
  write(fd_out, "\033[32m", 5);
  write(fd_out, str, size);
  write(global_fd_log(), str, size);
  return (write(fd_out, "\033[0m", 5));
}


x86 assembly (clang, -O0):
<print_green>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x4(%rbp),%edi
lea    0xec3(%rip),%rsi
mov    $0x5,%edx
call   1030 <write@plt>
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rax
mov    %eax,%edx
call   1030 <write@plt>
mov    $0x0,%al
call   1040 <global_fd_log@plt>
mov    %eax,%edi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rax
mov    %eax,%edx
call   1030 <write@plt>
mov    -0x4(%rbp),%edi
lea    0xe8b(%rip),%rsi
mov    $0x5,%edx
call   1030 <write@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_green>:
push   %rbp
push   %r14
push   %rbx
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %edi,%ebp
lea    0xecd(%rip),%rsi
mov    $0x5,%edx
call   1030 <write@plt>
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r14d,%edx
call   1030 <write@plt>
xor    %eax,%eax
call   1040 <global_fd_log@plt>
mov    %eax,%edi
mov    %rbx,%rsi
mov    %r14d,%edx
call   1030 <write@plt>
lea    0xea1(%rip),%rsi
mov    %ebp,%edi
mov    $0x5,%edx
pop    %rbx
pop    %r14
pop    %rbp
jmp    1030 <write@plt>

LLVM IR (-O0):
@.str = [6 x i8] c"\1B[32m\00"
@.str.1 = [5 x i8] c"\1B[0m\00"
define i32 @print_green(i32 %0, i8* %1, i64 %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i64
store i32 %0, i32* %4
store i8* %1, i8** %5
store i64 %2, i64* %6
%7 = load i32, i32* %4
%8 = call i32 @write(i32 %7, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32 5)
%9 = load i32, i32* %4
%10 = load i8*, i8** %5
%11 = load i64, i64* %6
%12 = trunc i64 %11 to i32
%13 = call i32 @write(i32 %9, i8* %10, i32 %12)
%14 = call i32 (...) @global_fd_log()
%15 = load i8*, i8** %5
%16 = load i64, i64* %6
%17 = trunc i64 %16 to i32
%18 = call i32 @write(i32 %14, i8* %15, i32 %17)
%19 = load i32, i32* %4
%20 = call i32 @write(i32 %19, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 5)
ret i32 %20
}

LLVM IR (-O2):
@.str = [6 x i8] c"\1B[32m\00"
@.str.1 = [5 x i8] c"\1B[0m\00"
define i32 @print_green(i32 %0, i8* nocapture %1, i64 %2) {
%4 = tail call i32 @write(i32 %0, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32 5)
%5 = trunc i64 %2 to i32
%6 = tail call i32 @write(i32 %0, i8* %1, i32 %5)
%7 = tail call i32 (...) @global_fd_log()
%8 = tail call i32 @write(i32 %7, i8* %1, i32 %5)
%9 = tail call i32 @write(i32 %0, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 5)
ret i32 %9
}
int Convert_Coordinate(char coordinate) {
  switch (coordinate) {
  case '8':
  case 'A':
    return 0;
  case '7':
  case 'B':
    return 1;
  case '6':
  case 'C':
    return 2;
  case '5':
  case 'D':
    return 3;
  case '4':
  case 'E':
    return 4;
  case '3':
  case 'F':
    return 5;
  case '2':
  case 'G':
    return 6;
  case '1':
  case 'H':
    return 7;
  }
}


x86 assembly (clang, -O0):
<Convert_Coordinate>:
push   %rbp
mov    %rsp,%rbp
mov    %dil,%al
mov    %al,-0x5(%rbp)
movsbl -0x5(%rbp),%eax
add    $0xffffffcf,%eax
mov    %eax,%ecx
mov    %rcx,-0x10(%rbp)
sub    $0x17,%eax
ja     118f <Convert_Coordinate+0x8f>
mov    -0x10(%rbp),%rax
lea    0xed5(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x4(%rbp)
jmp    118f <Convert_Coordinate+0x8f>
movl   $0x1,-0x4(%rbp)
jmp    118f <Convert_Coordinate+0x8f>
movl   $0x2,-0x4(%rbp)
jmp    118f <Convert_Coordinate+0x8f>
movl   $0x3,-0x4(%rbp)
jmp    118f <Convert_Coordinate+0x8f>
movl   $0x4,-0x4(%rbp)
jmp    118f <Convert_Coordinate+0x8f>
movl   $0x5,-0x4(%rbp)
jmp    118f <Convert_Coordinate+0x8f>
movl   $0x6,-0x4(%rbp)
jmp    118f <Convert_Coordinate+0x8f>
movl   $0x7,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<Convert_Coordinate>:
add    $0xffffffcf,%edi
xor    %eax,%eax
cmp    $0x17,%edi
ja     1117 <Convert_Coordinate+0x17>
movslq %edi,%rax
lea    0xeec(%rip),%rcx
mov    (%rcx,%rax,4),%eax
ret

LLVM IR (-O0):
define i32 @Convert_Coordinate(i8 signext %0) {
%2 = alloca i32
%3 = alloca i8
store i8 %0, i8* %3
%4 = load i8, i8* %3
%5 = sext i8 %4 to i32
switch i32 %5, label %14 [
i32 56, label %6
i32 65, label %6
i32 55, label %7
i32 66, label %7
i32 54, label %8
i32 67, label %8
i32 53, label %9
i32 68, label %9
i32 52, label %10
i32 69, label %10
i32 51, label %11
i32 70, label %11
i32 50, label %12
i32 71, label %12
i32 49, label %13
i32 72, label %13
]
6: ; preds = %1, %1
store i32 0, i32* %2
br label %14
7: ; preds = %1, %1
store i32 1, i32* %2
br label %14
8: ; preds = %1, %1
store i32 2, i32* %2
br label %14
9: ; preds = %1, %1
store i32 3, i32* %2
br label %14
10: ; preds = %1, %1
store i32 4, i32* %2
br label %14
11: ; preds = %1, %1
store i32 5, i32* %2
br label %14
12: ; preds = %1, %1
store i32 6, i32* %2
br label %14
13: ; preds = %1, %1
store i32 7, i32* %2
br label %14
14: ; preds = %6, %7, %8, %9, %10, %11, %12, %13, %1
%15 = load i32, i32* %2
ret i32 %15
}

LLVM IR (-O2):
@switch.table.Convert_Coordinate = [24 x i32] [i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7]
define i32 @Convert_Coordinate(i8 signext %0) {
%2 = sext i8 %0 to i32
%3 = add nsw i32 %2, -49
%4 = icmp ult i32 %3, 24
br i1 %4, label %5, label %9
5: ; preds = %1
%6 = sext i32 %3 to i64
%7 = getelementptr inbounds [24 x i32], [24 x i32]* @switch.table.Convert_Coordinate, i64 0, i64 %6
%8 = load i32, i32* %7
br label %9
9: ; preds = %5, %1
%10 = phi i32 [ 0, %1 ], [ %8, %5 ]
ret i32 %10
}
/* Variables and functions */
int /*<<< orphan*/ pierwiastek(float);
int main() {
  float a;
  a = 20;
  pierwiastek(a);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
movss  0xed9(%rip),%xmm0
movss  %xmm0,-0x8(%rbp)
movss  -0x8(%rbp),%xmm0
call   1030 <pierwiastek@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
movss  0xee7(%rip),%xmm0
call   1030 <pierwiastek@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
define i32 @main() {
%1 = alloca i32
%2 = alloca float
store i32 0, i32* %1
store float 2.000000e+01, float* %2
%3 = load float, float* %2
%4 = call i32 @pierwiastek(float %3)
ret i32 0
}

LLVM IR (-O2):
define i32 @main() {
%1 = tail call i32 @pierwiastek(float 2.000000e+01)
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ stderr;
void explain(void) {
  fprintf(stderr, "Usage: ... fw [ classid CLASSID ] [ police POLICE_SPEC ]\n");
  fprintf(stderr, "       POLICE_SPEC := ... look at TBF\n");
  fprintf(stderr, "       CLASSID := X:Y\n");
}


x86 assembly (clang, -O0):
<explain>:
push   %rbp
mov    %rsp,%rbp
mov    0x2ec5(%rip),%rax
mov    (%rax),%edi
lea    0xedc(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2eb0(%rip),%rax
mov    (%rax),%edi
lea    0xf01(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2e9b(%rip),%rax
mov    (%rax),%edi
lea    0xf13(%rip),%rsi
call   1030 <fprintf@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<explain>:
push   %rbx
mov    0x2ec8(%rip),%rbx
mov    (%rbx),%edi
lea    0xedf(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf0b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf24(%rip),%rsi
pop    %rbx
jmp    1030 <fprintf@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [58 x i8] c"Usage: ... fw [ classid CLASSID ] [ police POLICE_SPEC ]\0A\00"
@.str.1 = [39 x i8] c" POLICE_SPEC := ... look at TBF\0A\00"
@.str.2 = [23 x i8] c" CLASSID := X:Y\0A\00"
define void @explain() {
%1 = load i32, i32* @stderr
%2 = call i32 @fprintf(i32 %1, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str, i64 0, i64 0))
%3 = load i32, i32* @stderr
%4 = call i32 @fprintf(i32 %3, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0))
%5 = load i32, i32* @stderr
%6 = call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.2, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [58 x i8] c"Usage: ... fw [ classid CLASSID ] [ police POLICE_SPEC ]\0A\00"
@.str.1 = [39 x i8] c" POLICE_SPEC := ... look at TBF\0A\00"
@.str.2 = [23 x i8] c" CLASSID := X:Y\0A\00"
define void @explain() {
%1 = load i32, i32* @stderr
%2 = tail call i32 @fprintf(i32 %1, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str, i64 0, i64 0))
%3 = load i32, i32* @stderr
%4 = tail call i32 @fprintf(i32 %3, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0))
%5 = load i32, i32* @stderr
%6 = tail call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.2, i64 0, i64 0))
ret void
}
int socket_quit(void) { return 0; }


x86 assembly (clang, -O0):
<socket_quit>:
push   %rbp
mov    %rsp,%rbp
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<socket_quit>:
xor    %eax,%eax
ret

LLVM IR (-O0):
define i32 @socket_quit() {
ret i32 0
}

LLVM IR (-O2):
define i32 @socket_quit() {
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ free(void *);
void MEDAlgo_StandardFree(void *payload) { free(payload); }


x86 assembly (clang, -O0):
<MEDAlgo_StandardFree>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MEDAlgo_StandardFree>:
jmp    1030 <free@plt>

LLVM IR (-O0):
define void @MEDAlgo_StandardFree(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = call i32 @free(i8* %3)
ret void
}

LLVM IR (-O2):
define void @MEDAlgo_StandardFree(i8* nocapture %0) {
%2 = tail call i32 @free(i8* %0)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ my_printf(char *, ...);
int main() {
  int i = 5, j = 9;
  char str[] = "asdfsdf";
  my_printf("Hiii%d", i);
  my_printf("%d, %d", i, j);
  my_printf("%s ", str);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x5,-0x4(%rbp)
movl   $0x9,-0x8(%rbp)
mov    0xed3(%rip),%rax
mov    %rax,-0x10(%rbp)
mov    -0x4(%rbp),%esi
lea    0xecd(%rip),%rdi
mov    $0x0,%al
call   1030 <my_printf@plt>
mov    -0x4(%rbp),%esi
mov    -0x8(%rbp),%edx
lea    0xec0(%rip),%rdi
mov    $0x0,%al
call   1030 <my_printf@plt>
lea    -0x10(%rbp),%rsi
lea    0xeb5(%rip),%rdi
mov    $0x0,%al
call   1030 <my_printf@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
movabs $0x66647366647361,%rax
mov    %rax,(%rsp)
lea    0xeda(%rip),%rdi
mov    $0x5,%esi
xor    %eax,%eax
call   1030 <my_printf@plt>
lea    0xece(%rip),%rdi
mov    $0x5,%esi
mov    $0x9,%edx
xor    %eax,%eax
call   1030 <my_printf@plt>
lea    0xebd(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1030 <my_printf@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@__const.main.str = [8 x i8] c"asdfsdf\00"
@.str = [7 x i8] c"Hiii%d\00"
@.str.1 = [7 x i8] c"%d, %d\00"
@.str.2 = [4 x i8] c"%s \00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca [8 x i8]
store i32 5, i32* %1
store i32 9, i32* %2
%4 = bitcast [8 x i8]* %3 to i8*
%5 = load i32, i32* %1
%6 = call i32 (i8*, ...) @my_printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32 %5)
%7 = load i32, i32* %1
%8 = load i32, i32* %2
%9 = call i32 (i8*, ...) @my_printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 %7, i32 %8)
%10 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 0
%11 = call i32 (i8*, ...) @my_printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i8* %10)
ret i32 0
}

LLVM IR (-O2):
@.str = [7 x i8] c"Hiii%d\00"
@.str.1 = [7 x i8] c"%d, %d\00"
@.str.2 = [4 x i8] c"%s \00"
define i32 @main() {
%1 = alloca i64
%2 = bitcast i64* %1 to i8*
store i64 28820894426362721, i64* %1
%3 = tail call i32 (i8*, ...) @my_printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32 5)
%4 = tail call i32 (i8*, ...) @my_printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 5, i32 9)
%5 = call i32 (i8*, ...) @my_printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i64* %1)
ret i32 0
}
unsigned xrop3_13_1_0(unsigned char s, unsigned char t) {
  unsigned D = 0x00ff;
  unsigned S = ((unsigned)s << 8) | s;
  unsigned T = ((unsigned)t << 8) | t;
  unsigned stk1;
  unsigned stk2;
  unsigned stk3;
  stk3 = ~S;
  stk2 = D & stk3;
  stk1 = T | stk2;
  stk1 = ~stk1;
  return (stk1 & (~S)) | (D & S);
}


x86 assembly (clang, -O0):
<xrop3_13_1_0>:
push   %rbp
mov    %rsp,%rbp
mov    %sil,%al
mov    %dil,%cl
mov    %cl,-0x1(%rbp)
mov    %al,-0x2(%rbp)
movl   $0xff,-0x8(%rbp)
movzbl -0x1(%rbp),%eax
shl    $0x8,%eax
movzbl -0x1(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0xc(%rbp)
movzbl -0x2(%rbp),%eax
shl    $0x8,%eax
movzbl -0x2(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x10(%rbp)
mov    -0xc(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
or     -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0xc(%rbp),%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    -0x8(%rbp),%ecx
and    -0xc(%rbp),%ecx
or     %ecx,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<xrop3_13_1_0>:
mov    %edi,%ecx
shl    $0x8,%ecx
or     %edi,%ecx
mov    %esi,%edx
shl    $0x8,%edx
or     %esi,%edx
mov    %edi,%eax
xor    $0xff,%eax
or     %ecx,%eax
or     %edx,%eax
not    %eax
or     %edi,%eax
ret

LLVM IR (-O0):
define i32 @xrop3_13_1_0(i8 zeroext %0, i8 zeroext %1) {
%3 = alloca i8
%4 = alloca i8
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i8 %0, i8* %3
store i8 %1, i8* %4
store i32 255, i32* %5
%11 = load i8, i8* %3
%12 = zext i8 %11 to i32
%13 = shl i32 %12, 8
%14 = load i8, i8* %3
%15 = zext i8 %14 to i32
%16 = or i32 %13, %15
store i32 %16, i32* %6
%17 = load i8, i8* %4
%18 = zext i8 %17 to i32
%19 = shl i32 %18, 8
%20 = load i8, i8* %4
%21 = zext i8 %20 to i32
%22 = or i32 %19, %21
store i32 %22, i32* %7
%23 = load i32, i32* %6
%24 = xor i32 %23, -1
store i32 %24, i32* %10
%25 = load i32, i32* %5
%26 = load i32, i32* %10
%27 = and i32 %25, %26
store i32 %27, i32* %9
%28 = load i32, i32* %7
%29 = load i32, i32* %9
%30 = or i32 %28, %29
store i32 %30, i32* %8
%31 = load i32, i32* %8
%32 = xor i32 %31, -1
store i32 %32, i32* %8
%33 = load i32, i32* %8
%34 = load i32, i32* %6
%35 = xor i32 %34, -1
%36 = and i32 %33, %35
%37 = load i32, i32* %5
%38 = load i32, i32* %6
%39 = and i32 %37, %38
%40 = or i32 %36, %39
ret i32 %40
}

LLVM IR (-O2):
define i32 @xrop3_13_1_0(i8 zeroext %0, i8 zeroext %1) {
%3 = zext i8 %0 to i32
%4 = mul nuw nsw i32 %3, 257
%5 = zext i8 %1 to i32
%6 = mul nuw nsw i32 %5, 257
%7 = xor i32 %3, 255
%8 = or i32 %4, %7
%9 = or i32 %8, %6
%10 = xor i32 %9, -1
%11 = or i32 %10, %3
ret i32 %11
}
void ExttJobStatusAuxTable(void) {}


x86 assembly (clang, -O0):
<ExttJobStatusAuxTable>:
push   %rbp
mov    %rsp,%rbp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ExttJobStatusAuxTable>:
ret

LLVM IR (-O0):
define void @ExttJobStatusAuxTable() {
ret void
}

LLVM IR (-O2):
define void @ExttJobStatusAuxTable() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ printf2(char *);
void GenStartAsciiString(void) { printf2("\t.ascii\t"); }


x86 assembly (clang, -O0):
<GenStartAsciiString>:
push   %rbp
mov    %rsp,%rbp
lea    0xee5(%rip),%rdi
call   1030 <printf2@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<GenStartAsciiString>:
lea    0xee9(%rip),%rdi
jmp    1030 <printf2@plt>

LLVM IR (-O0):
@.str = [9 x i8] c"\09.ascii\09\00"
define void @GenStartAsciiString() {
%1 = call i32 @printf2(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [9 x i8] c"\09.ascii\09\00"
define void @GenStartAsciiString() {
%1 = tail call i32 @printf2(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
ret void
}
__attribute__((always_, unused)) void
ips___clear_bit(int nr, volatile unsigned long *addr) {
  asm volatile("btrl %1,%0" : "=m"(*addr) : "dIr"(nr));
}


x86 assembly (clang, -O0):
<ips___clear_bit>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
btr    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<ips___clear_bit>:
btr    %edi,(%rsi)
ret

LLVM IR (-O0):
define void @ips___clear_bit(i32 %0, i64* %1) {
%3 = alloca i32
%4 = alloca i64*
store i32 %0, i32* %3
store i64* %1, i64** %4
%5 = load i64*, i64** %4
%6 = load i32, i32* %3
ret void
}

LLVM IR (-O2):
define void @ips___clear_bit(i32 %0, i64* %1) {
tail call void asm sideeffect "btrl $1,$0", "=*m,{dx}Ir,~{dirflag},~{fpsr},~{flags}"(i64* elementtype(i64) %1, i32 %0)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ write(int, char const *, int);
void ft_putnbr_hex(unsigned n, unsigned length) {
  char const *base = "0123456789abcdef";
  if (length > 1)
    ft_putnbr_hex(n >> 4, length - 1);
  write(1, base + (n % 16), 1);
}


x86 assembly (clang, -O0):
<ft_putnbr_hex>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
lea    0xecb(%rip),%rax
mov    %rax,-0x10(%rbp)
cmpl   $0x1,-0x8(%rbp)
jbe    1154 <ft_putnbr_hex+0x34>
mov    -0x4(%rbp),%edi
shr    $0x4,%edi
mov    -0x8(%rbp),%esi
sub    $0x1,%esi
call   1030 <ft_putnbr_hex@plt>
mov    -0x10(%rbp),%rsi
mov    -0x4(%rbp),%eax
and    $0xf,%eax
mov    %eax,%eax
add    %rax,%rsi
mov    $0x1,%edx
mov    %edx,%edi
call   1040 <write@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ft_putnbr_hex>:
push   %rbx
mov    %edi,%ebx
cmp    $0x2,%esi
jb     1135 <ft_putnbr_hex+0x15>
mov    %ebx,%edi
shr    $0x4,%edi
add    $0xffffffff,%esi
call   1030 <ft_putnbr_hex@plt>
and    $0xf,%ebx
lea    0xec1(%rip),%rsi
add    %rbx,%rsi
mov    $0x1,%edi
mov    $0x1,%edx
pop    %rbx
jmp    1040 <write@plt>

LLVM IR (-O0):
@.str = [17 x i8] c"0123456789abcdef\00"
define void @ft_putnbr_hex(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8*
store i32 %0, i32* %3
store i32 %1, i32* %4
store i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), i8** %5
%6 = load i32, i32* %4
%7 = icmp ugt i32 %6, 1
br i1 %7, label %8, label %13
8: ; preds = %2
%9 = load i32, i32* %3
%10 = lshr i32 %9, 4
%11 = load i32, i32* %4
%12 = sub i32 %11, 1
br label %13
13: ; preds = %8, %2
%14 = load i8*, i8** %5
%15 = load i32, i32* %3
%16 = urem i32 %15, 16
%17 = zext i32 %16 to i64
%18 = getelementptr inbounds i8, i8* %14, i64 %17
%19 = call i32 @write(i32 1, i8* %18, i32 1)
ret void
}

LLVM IR (-O2):
@.str = [17 x i8] c"0123456789abcdef\00"
define void @ft_putnbr_hex(i32 %0, i32 %1) {
%3 = icmp ugt i32 %1, 1
br i1 %3, label %4, label %7
4: ; preds = %2
%5 = lshr i32 %0, 4
%6 = add i32 %1, -1
tail call void @ft_putnbr_hex(i32 %5, i32 %6)
br label %7
7: ; preds = %4, %2
%8 = and i32 %0, 15
%9 = zext i32 %8 to i64
%10 = getelementptr inbounds [17 x i8], [17 x i8]* @.str, i64 0, i64 %9
%11 = tail call i32 @write(i32 1, i8* %10, i32 1)
ret void
}