xunge/DecIR huggingface dataset:
/* Type definitions */
typedef int /*<<< orphan*/ buf0;

/* Variables and functions */
int /*<<< orphan*/ fflush(int /*<<< orphan*/);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ puts(char *);
int /*<<< orphan*/ stdin;
int /*<<< orphan*/ stdout;
void fun0() {
  puts("Oh I almost forgot to mention, due to budget cuts we decided to get "
       "rud if tge exit. Just think of all of the security research we can do "
       "now!. And by we, I mean you.\n");
  char buf0[100];
  fgets(buf0, sizeof(buf0), stdin);
  printf(buf0);
  fflush(stdout);
}


x86 assembly (clang, -O0):
<fun0>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
lea    0xeb1(%rip),%rdi
call   1030 <puts@plt>
lea    -0x70(%rbp),%rdi
mov    0x2e89(%rip),%rax
mov    (%rax),%edx
mov    $0x64,%esi
call   1050 <fgets@plt>
lea    -0x70(%rbp),%rdi
call   1040 <printf@plt>
mov    0x2e5d(%rip),%rax
mov    (%rax),%edi
call   1060 <fflush@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fun0>:
push   %rbx
sub    $0x70,%rsp
lea    0xeb4(%rip),%rdi
call   1030 <puts@plt>
mov    0x2e90(%rip),%rax
mov    (%rax),%edx
mov    %rsp,%rbx
mov    %rbx,%rdi
mov    $0x64,%esi
call   1050 <fgets@plt>
mov    %rbx,%rdi
call   1040 <printf@plt>
mov    0x2e5f(%rip),%rax
mov    (%rax),%edi
call   1060 <fflush@plt>
add    $0x70,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@.str = [168 x i8] c"Oh I almost forgot to mention, due to budget cuts we decided to get rud if tge exit. Just think of all of the security research we can do now!. And by we, I mean you.\0A\00"
@stdin = global i32 0
@stdout = global i32 0
define void @fun0() {
%1 = alloca [100 x i8]
%2 = call i32 @puts(i8* getelementptr inbounds ([168 x i8], [168 x i8]* @.str, i64 0, i64 0))
%3 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 0
%4 = load i32, i32* @stdin
%5 = call i32 @fgets(i8* %3, i32 100, i32 %4)
%6 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 0
%7 = call i32 @printf(i8* %6)
%8 = load i32, i32* @stdout
%9 = call i32 @fflush(i32 %8)
ret void
}

LLVM IR (-O2):
@.str = [168 x i8] c"Oh I almost forgot to mention, due to budget cuts we decided to get rud if tge exit. Just think of all of the security research we can do now!. And by we, I mean you.\0A\00"
@stdin = global i32 0
@stdout = global i32 0
define void @fun0() {
%1 = alloca [100 x i8]
%2 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([168 x i8], [168 x i8]* @.str, i64 0, i64 0))
%3 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 0
%4 = load i32, i32* @stdin
%5 = call i32 @fgets(i8* %3, i32 100, i32 %4)
%6 = call i32 @printf(i8* %3)
%7 = load i32, i32* @stdout
%8 = call i32 @fflush(i32 %7)
ret void
}
/* Type definitions */
struct node {
  int dummy;
};

/* Variables and functions */
void createGraph(struct node *adjList[], int num) {
  int i;
  for (i = 0; i < num; i++) {
    adjList[i] = NULL;
  }
}


x86 assembly (clang, -O0):
<createGraph>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    113c <createGraph+0x3c>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1112 <createGraph+0x12>
pop    %rbp
ret

x86 assembly (clang, -O2):
<createGraph>:
test   %esi,%esi
jle    1126 <createGraph+0x16>
push   %rax
mov    %esi,%edx
shl    $0x3,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
add    $0x8,%rsp
ret

LLVM IR (-O0):
%struct.node = type { i32 }
define void @createGraph(%struct.node** %0, i32 %1) {
%3 = alloca %struct.node**
%4 = alloca i32
%5 = alloca i32
store %struct.node** %0, %struct.node*** %3
store i32 %1, i32* %4
store i32 0, i32* %5
br label %6
6: ; preds = %15, %2
%7 = load i32, i32* %5
%8 = load i32, i32* %4
%9 = icmp slt i32 %7, %8
br i1 %9, label %10, label %18
10: ; preds = %6
%11 = load %struct.node**, %struct.node*** %3
%12 = load i32, i32* %5
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds %struct.node*, %struct.node** %11, i64 %13
store %struct.node* null, %struct.node** %14
br label %15
15: ; preds = %10
%16 = load i32, i32* %5
%17 = add nsw i32 %16, 1
store i32 %17, i32* %5
br label %6
18: ; preds = %6
ret void
}

LLVM IR (-O2):
%struct.node = type { i32 }
define void @createGraph(%struct.node** nocapture writeonly %0, i32 %1) {
%3 = icmp sgt i32 %1, 0
br i1 %3, label %4, label %8
4: ; preds = %2
%5 = bitcast %struct.node** %0 to i8*
%6 = zext i32 %1 to i64
%7 = shl nuw nsw i64 %6, 3
br label %8
8: ; preds = %4, %2
ret void
}
/* Variables and functions */
int _ada_use_c2phc4c(int, int *, int *, double *, int /*<<< orphan*/);
int write_doubles_to_defined_output_file(int n, double *a) {
  int i, *b, fail;
  fail = _ada_use_c2phc4c(160, &n, b, a, 0);
  return fail;
}


x86 assembly (clang, -O0):
<write_doubles_to_defined_output_file>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x20(%rbp),%rdx
mov    -0x10(%rbp),%rcx
mov    $0xa0,%edi
lea    -0x4(%rbp),%rsi
xor    %r8d,%r8d
call   1030 <_ada_use_c2phc4c@plt>
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<write_doubles_to_defined_output_file>:
push   %rax
mov    %rsi,%rcx
mov    %edi,0x4(%rsp)
lea    0x4(%rsp),%rsi
mov    $0xa0,%edi
xor    %r8d,%r8d
call   1030 <_ada_use_c2phc4c@plt>
pop    %rcx
ret

LLVM IR (-O0):
define i32 @write_doubles_to_defined_output_file(i32 %0, double* %1) {
%3 = alloca i32
%4 = alloca double*
%5 = alloca i32
%6 = alloca i32*
%7 = alloca i32
store i32 %0, i32* %3
store double* %1, double** %4
%8 = load i32*, i32** %6
%9 = load double*, double** %4
%10 = call i32 @_ada_use_c2phc4c(i32 160, i32* %3, i32* %8, double* %9, i32 0)
store i32 %10, i32* %7
%11 = load i32, i32* %7
ret i32 %11
}

LLVM IR (-O2):
define i32 @write_doubles_to_defined_output_file(i32 %0, double* %1) {
%3 = alloca i32
store i32 %0, i32* %3
%4 = call i32 @_ada_use_c2phc4c(i32 160, i32* %3, i32* undef, double* %1, i32 0)
ret i32 %4
}
/* Variables and functions */
int strlen(char const *);
int strnlen(const char *c, int n) { return strlen(c); }


x86 assembly (clang, -O0):
<strnlen>:
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):
<strnlen>:
jmp    1030 <strlen@plt>

LLVM IR (-O0):
define i32 @strnlen(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 i32 @strlen(i8* %5)
ret i32 %6
}

LLVM IR (-O2):
define i32 @strnlen(i8* %0, i32 %1) {
%3 = tail call i32 @strlen(i8* %0)
ret i32 %3
}
void foo526() {}


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

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

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

LLVM IR (-O2):
define void @foo526() {
ret void
}
void rb_f_chop() {}


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

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

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

LLVM IR (-O2):
define void @rb_f_chop() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ _buffer_check_size(char **, size_t *, char **);
int _buffer_set_byte(char **buffer, size_t *allocated, char **cursor,
                     char byte) {
  if (!_buffer_check_size(buffer, allocated, cursor)) {
    return 0;
  }
  **cursor = byte;
  return 1;
}


x86 assembly (clang, -O0):
<_buffer_set_byte>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %cl,%al
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %al,-0x21(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
call   1030 <_buffer_check_size@plt>
cmp    $0x0,%eax
jne    114f <_buffer_set_byte+0x3f>
movl   $0x0,-0x4(%rbp)
jmp    1162 <_buffer_set_byte+0x52>
mov    -0x21(%rbp),%cl
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    %cl,(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_buffer_set_byte>:
push   %rbp
push   %rbx
push   %rax
mov    %ecx,%ebp
mov    %rdx,%rbx
call   1030 <_buffer_check_size@plt>
test   %eax,%eax
je     112e <_buffer_set_byte+0x1e>
mov    (%rbx),%rax
mov    %bpl,(%rax)
mov    $0x1,%eax
jmp    1130 <_buffer_set_byte+0x20>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define i32 @_buffer_set_byte(i8** %0, i64* %1, i8** %2, i8 signext %3) {
%5 = alloca i32
%6 = alloca i8**
%7 = alloca i64*
%8 = alloca i8**
%9 = alloca i8
store i8** %0, i8*** %6
store i64* %1, i64** %7
store i8** %2, i8*** %8
store i8 %3, i8* %9
%10 = load i8**, i8*** %6
%11 = load i64*, i64** %7
%12 = load i8**, i8*** %8
%13 = call i32 @_buffer_check_size(i8** %10, i64* %11, i8** %12)
%14 = icmp ne i32 %13, 0
br i1 %14, label %16, label %15
15: ; preds = %4
store i32 0, i32* %5
br label %20
16: ; preds = %4
%17 = load i8, i8* %9
%18 = load i8**, i8*** %8
%19 = load i8*, i8** %18
store i8 %17, i8* %19
store i32 1, i32* %5
br label %20
20: ; preds = %16, %15
%21 = load i32, i32* %5
ret i32 %21
}

LLVM IR (-O2):
define i32 @_buffer_set_byte(i8** %0, i64* %1, i8** %2, i8 signext %3) {
%5 = tail call i32 @_buffer_check_size(i8** %0, i64* %1, i8** %2)
%6 = icmp eq i32 %5, 0
br i1 %6, label %9, label %7
7: ; preds = %4
%8 = load i8*, i8** %2
store i8 %3, i8* %8
br label %9
9: ; preds = %4, %7
%10 = phi i32 [ 1, %7 ], [ 0, %4 ]
ret i32 %10
}
/* Variables and functions */
int putchar(char);
int p(char c) { return putchar(c); }


x86 assembly (clang, -O0):
<p>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %dil,%al
mov    %al,-0x1(%rbp)
movsbl -0x1(%rbp),%edi
call   1030 <putchar@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<p>:
jmp    1030 <putchar@plt>

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

LLVM IR (-O2):
define i32 @p(i8 signext %0) {
%2 = tail call i32 @putchar(i8 signext %0)
ret i32 %2
}
struct s3c24x0_timers *s3c24x0_get_base_timers(void) {
  return (struct s3c24x0_timers *)0x51000000;
}


x86 assembly (clang, -O0):
<s3c24x0_get_base_timers>:
push   %rbp
mov    %rsp,%rbp
mov    $0x51000000,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<s3c24x0_get_base_timers>:
mov    $0x51000000,%eax
ret

LLVM IR (-O0):
%struct.s3c24x0_timers = type opaque
define %struct.s3c24x0_timers* @s3c24x0_get_base_timers() {
ret %struct.s3c24x0_timers* inttoptr (i64 1358954496 to %struct.s3c24x0_timers*)
}

LLVM IR (-O2):
%struct.s3c24x0_timers = type opaque
define %struct.s3c24x0_timers* @s3c24x0_get_base_timers() {
ret %struct.s3c24x0_timers* inttoptr (i64 1358954496 to %struct.s3c24x0_timers*)
}
int Cyc_List_ptrequal(void *x, void *y) { return !(x == y); }


x86 assembly (clang, -O0):
<Cyc_List_ptrequal>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
sete   %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<Cyc_List_ptrequal>:
xor    %eax,%eax
cmp    %rsi,%rdi
setne  %al
ret

LLVM IR (-O0):
define i32 @Cyc_List_ptrequal(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
store i8* %0, i8** %3
store i8* %1, i8** %4
%5 = load i8*, i8** %3
%6 = load i8*, i8** %4
%7 = icmp eq i8* %5, %6
%8 = xor i1 %7, true
%9 = zext i1 %8 to i32
ret i32 %9
}

LLVM IR (-O2):
define i32 @Cyc_List_ptrequal(i8* readnone %0, i8* readnone %1) {
%3 = icmp ne i8* %0, %1
%4 = zext i1 %3 to i32
ret i32 %4
}
/* Type definitions */
typedef int uint64_t;
typedef int /*<<< orphan*/ uint32_t;
typedef int /*<<< orphan*/ memory;

/* Variables and functions */
int sysctlbyname(char *, int *, size_t *, int /*<<< orphan*/ *,
                 int /*<<< orphan*/);
uint32_t get_memory(void) {
  size_t len;
  uint64_t memory;
  int retcode;
  len = sizeof(memory);
  retcode = sysctlbyname("hw.memsize", &memory, &len, NULL, 0);
  if (retcode == -1) {
    return 0;
  }
  memory >>= 20;
  return (uint32_t)memory;
}


x86 assembly (clang, -O0):
<get_memory>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movq   $0x4,-0x10(%rbp)
lea    0xed9(%rip),%rdi
lea    -0x14(%rbp),%rsi
lea    -0x10(%rbp),%rdx
xor    %eax,%eax
mov    %eax,%ecx
xor    %r8d,%r8d
call   1030 <sysctlbyname@plt>
mov    %eax,-0x18(%rbp)
cmpl   $0xffffffff,-0x18(%rbp)
jne    1154 <get_memory+0x44>
movl   $0x0,-0x4(%rbp)
jmp    1163 <get_memory+0x53>
mov    -0x14(%rbp),%eax
sar    $0x14,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_memory>:
push   %rbx
sub    $0x10,%rsp
movq   $0x4,0x8(%rsp)
lea    0xedb(%rip),%rdi
xor    %ebx,%ebx
lea    0x4(%rsp),%rsi
lea    0x8(%rsp),%rdx
xor    %ecx,%ecx
xor    %r8d,%r8d
call   1030 <sysctlbyname@plt>
mov    0x4(%rsp),%ecx
sar    $0x14,%ecx
cmp    $0xffffffff,%eax
cmove  %ebx,%ecx
mov    %ecx,%eax
add    $0x10,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@.str = [11 x i8] c"hw.memsize\00"
define i32 @get_memory() {
%1 = alloca i32
%2 = alloca i64
%3 = alloca i32
%4 = alloca i32
store i64 4, i64* %2
%5 = call i32 @sysctlbyname(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0), i32* %3, i64* %2, i32* null, i32 0)
store i32 %5, i32* %4
%6 = load i32, i32* %4
%7 = icmp eq i32 %6, -1
br i1 %7, label %8, label %9
8: ; preds = %0
store i32 0, i32* %1
br label %13
9: ; preds = %0
%10 = load i32, i32* %3
%11 = ashr i32 %10, 20
store i32 %11, i32* %3
%12 = load i32, i32* %3
store i32 %12, i32* %1
br label %13
13: ; preds = %9, %8
%14 = load i32, i32* %1
ret i32 %14
}

LLVM IR (-O2):
@.str = [11 x i8] c"hw.memsize\00"
define i32 @get_memory() {
%1 = alloca i64
%2 = alloca i32
%3 = bitcast i64* %1 to i8*
%4 = bitcast i32* %2 to i8*
store i64 4, i64* %1
%5 = call i32 @sysctlbyname(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0), i32* %2, i64* %1, i32* null, i32 0)
%6 = icmp eq i32 %5, -1
%7 = load i32, i32* %2
%8 = ashr i32 %7, 20
%9 = select i1 %6, i32 0, i32 %8
ret i32 %9
}
/* Variables and functions */
int /*<<< orphan*/ memcpy(float *, float const *, int);
void floats_xytcov_copy(const float xyta[3], const float Ca[9], float xytr[3],
                        float Cr[9]) {
  memcpy(xytr, xyta, 3 * sizeof(float));
  memcpy(Cr, Ca, 9 * sizeof(float));
}


x86 assembly (clang, -O0):
<floats_xytcov_copy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    $0xc,%edx
call   1030 <memcpy@plt>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    $0x24,%edx
call   1030 <memcpy@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<floats_xytcov_copy>:
push   %r14
push   %rbx
push   %rax
mov    %rcx,%r14
mov    %rsi,%rbx
mov    %rdi,%rsi
mov    %rdx,%rdi
mov    $0xc,%edx
call   1030 <memcpy@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0x24,%edx
add    $0x8,%rsp
pop    %rbx
pop    %r14
jmp    1030 <memcpy@plt>

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

LLVM IR (-O2):
define void @floats_xytcov_copy(float* %0, float* %1, float* %2, float* %3) {
%5 = tail call i32 @memcpy(float* %2, float* %0, i32 12)
%6 = tail call i32 @memcpy(float* %3, float* %1, i32 36)
ret void
}
int test_imm_C1int16_reg(short val) {
  return ((val) & (0xC1 << 0)) ? -20 : -40;
}


x86 assembly (clang, -O0):
<test_imm_C1int16_reg>:
push   %rbp
mov    %rsp,%rbp
mov    %di,%ax
mov    %ax,-0x2(%rbp)
movswl -0x2(%rbp),%edx
and    $0xc1,%edx
mov    $0xffffffd8,%eax
mov    $0xffffffec,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_imm_C1int16_reg>:
test   $0xc1,%dil
mov    $0xffffffd8,%ecx
mov    $0xffffffec,%eax
cmove  %ecx,%eax
ret

LLVM IR (-O0):
define i32 @test_imm_C1int16_reg(i16 signext %0) {
%2 = alloca i16
store i16 %0, i16* %2
%3 = load i16, i16* %2
%4 = sext i16 %3 to i32
%5 = and i32 %4, 193
%6 = icmp ne i32 %5, 0
%7 = zext i1 %6 to i64
%8 = select i1 %6, i32 -20, i32 -40
ret i32 %8
}

LLVM IR (-O2):
define i32 @test_imm_C1int16_reg(i16 signext %0) {
%2 = and i16 %0, 193
%3 = icmp eq i16 %2, 0
%4 = select i1 %3, i32 -40, i32 -20
ret i32 %4
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *);
int XSetNormalHints() {
  printf("XSetNormalHints called\n");
  return 0;
}


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

x86 assembly (clang, -O2):
<XSetNormalHints>:
push   %rax
lea    0xee8(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [24 x i8] c"XSetNormalHints called\0A\00"
define i32 @XSetNormalHints() {
%1 = call i32 @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str, i64 0, i64 0))
ret i32 0
}

LLVM IR (-O2):
@str = [23 x i8] c"XSetNormalHints called\00"
define i32 @XSetNormalHints() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @str, i64 0, i64 0))
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ print_statements_Calling();
int /*<<< orphan*/ printf(char *);
void print_Mucke_Calling(void) {
  printf("bool Calling(Module m, PrCount p)\n");
  printf("(false\n");
  print_statements_Calling();
  printf(");\n");
}


x86 assembly (clang, -O0):
<print_Mucke_Calling>:
push   %rbp
mov    %rsp,%rbp
lea    0xed5(%rip),%rdi
call   1030 <printf@plt>
lea    0xeec(%rip),%rdi
call   1030 <printf@plt>
mov    $0x0,%al
call   1040 <print_statements_Calling@plt>
lea    0xee1(%rip),%rdi
call   1030 <printf@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_Mucke_Calling>:
push   %rax
lea    0xed8(%rip),%rdi
call   1030 <puts@plt>
lea    0xeee(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
call   1040 <print_statements_Calling@plt>
lea    0xee2(%rip),%rdi
pop    %rax
jmp    1030 <puts@plt>

LLVM IR (-O0):
@.str = [35 x i8] c"bool Calling(Module m, PrCount p)\0A\00"
@.str.1 = [8 x i8] c"(false\0A\00"
@.str.2 = [4 x i8] c");\0A\00"
define void @print_Mucke_Calling() {
%1 = call i32 @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str, i64 0, i64 0))
%2 = call i32 @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%3 = call i32 (...) @print_statements_Calling()
%4 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@str = [34 x i8] c"bool Calling(Module m, PrCount p)\00"
@str.3 = [7 x i8] c"(false\00"
@str.4 = [3 x i8] c");\00"
define void @print_Mucke_Calling() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str, i64 0, i64 0))
%2 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @str.3, i64 0, i64 0))
%3 = tail call i32 (...) @print_statements_Calling()
%4 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.4, i64 0, i64 0))
ret void
}
/* Variables and functions */
int /*<<< orphan*/ w5100_writeSn_byte(unsigned int, int, unsigned int);
void w5100_writeSnTX_FSR(unsigned sock, unsigned data) {
  w5100_writeSn_byte(sock, 0x0020, data >> 8);
  w5100_writeSn_byte(sock, 0x0020 + 1, data & 0xFF);
}


x86 assembly (clang, -O0):
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%edx
shr    $0x8,%edx
mov    $0x20,%esi
call   1030 <w5100_writeSn_byte@plt>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%edx
and    $0xff,%edx
mov    $0x21,%esi
call   1030 <w5100_writeSn_byte@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
push   %rbp
push   %rbx
push   %rax
mov    %esi,%ebx
mov    %edi,%ebp
mov    %esi,%edx
shr    $0x8,%edx
mov    $0x20,%esi
call   1030 <w5100_writeSn_byte@plt>
movzbl %bl,%edx
mov    %ebp,%edi
mov    $0x21,%esi
add    $0x8,%rsp
pop    %rbx
pop    %rbp
jmp    1030 <w5100_writeSn_byte@plt>

LLVM IR (-O0):
define void @w5100_writeSnTX_FSR(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 = lshr i32 %6, 8
%8 = call i32 @w5100_writeSn_byte(i32 %5, i32 32, i32 %7)
%9 = load i32, i32* %3
%10 = load i32, i32* %4
%11 = and i32 %10, 255
%12 = call i32 @w5100_writeSn_byte(i32 %9, i32 33, i32 %11)
ret void
}

LLVM IR (-O2):
define void @w5100_writeSnTX_FSR(i32 %0, i32 %1) {
%3 = lshr i32 %1, 8
%4 = tail call i32 @w5100_writeSn_byte(i32 %0, i32 32, i32 %3)
%5 = and i32 %1, 255
%6 = tail call i32 @w5100_writeSn_byte(i32 %0, i32 33, i32 %5)
ret void
}
/* Type definitions */
typedef int /*<<< orphan*/ buf;

/* Variables and functions */
int /*<<< orphan*/ strerror_r(int, char *, int);
int /*<<< orphan*/ tap_error(char *, char const *, unsigned long, char const *,
                             int, int /*<<< orphan*/);
void tap_error_errno_at(const char *function, int errnum, const char *filename,
                        unsigned long line) {
  char buf[100];
  tap_error("%s:%lu: %s failed: %d (%s)", filename, line, function, errnum,
            strerror_r(errnum, buf, sizeof(buf)));
}


x86 assembly (clang, -O0):
<tap_error_errno_at>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0xc(%rbp),%edi
lea    -0x90(%rbp),%rsi
mov    $0x64,%edx
call   1030 <strerror_r@plt>
mov    -0xb0(%rbp),%rsi
mov    -0xa8(%rbp),%rdx
mov    -0xa0(%rbp),%rcx
mov    -0x94(%rbp),%r8d
mov    %eax,%r9d
lea    0xe62(%rip),%rdi
call   1040 <tap_error@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tap_error_errno_at>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%r14
mov    %rdx,%rbx
mov    %esi,%ebp
mov    %rdi,%r15
mov    %rsp,%rsi
mov    %ebp,%edi
mov    $0x64,%edx
call   1030 <strerror_r@plt>
lea    0xeb5(%rip),%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    %r15,%rcx
mov    %ebp,%r8d
mov    %eax,%r9d
call   1040 <tap_error@plt>
add    $0x68,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [27 x i8] c"%s:%lu: %s failed: %d (%s)\00"
define void @tap_error_errno_at(i8* %0, i32 %1, i8* %2, i64 %3) {
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i64
%9 = alloca [100 x i8]
store i8* %0, i8** %5
store i32 %1, i32* %6
store i8* %2, i8** %7
store i64 %3, i64* %8
%10 = load i8*, i8** %7
%11 = load i64, i64* %8
%12 = load i8*, i8** %5
%13 = load i32, i32* %6
%14 = load i32, i32* %6
%15 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%16 = call i32 @strerror_r(i32 %14, i8* %15, i32 100)
%17 = call i32 @tap_error(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), i8* %10, i64 %11, i8* %12, i32 %13, i32 %16)
ret void
}

LLVM IR (-O2):
@.str = [27 x i8] c"%s:%lu: %s failed: %d (%s)\00"
define void @tap_error_errno_at(i8* %0, i32 %1, i8* %2, i64 %3) {
%5 = alloca [100 x i8]
%6 = getelementptr inbounds [100 x i8], [100 x i8]* %5, i64 0, i64 0
%7 = call i32 @strerror_r(i32 %1, i8* %6, i32 100)
%8 = call i32 @tap_error(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), i8* %2, i64 %3, i8* %0, i32 %1, i32 %7)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *);
void clearscr(void) { printf("\e[1;1H\e[2J"); }


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

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

LLVM IR (-O0):
@.str = [11 x i8] c"\1B[1;1H\1B[2J\00"
define void @clearscr() {
%1 = call i32 @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [11 x i8] c"\1B[1;1H\1B[2J\00"
define void @clearscr() {
%1 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0))
ret void
}
int main(void) {
  int *p = 0;
  p;
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
movl   $0x0,-0x4(%rbp)
movq   $0x0,-0x10(%rbp)
xor    %eax,%eax
pop    %rbp
ret

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

LLVM IR (-O0):
define i32 @main() {
%1 = alloca i32
%2 = alloca i32*
store i32 0, i32* %1
store i32* null, i32** %2
%3 = load i32*, i32** %2
ret i32 0
}

LLVM IR (-O2):
define i32 @main() {
ret i32 0
}
const char *get_shortmsg_from_status_code(int status_code) {
  if (status_code == 200) {
    return "OK";
  }
  if (status_code == 304) {
    return "Not Modified";
  }
  if (status_code == 404) {
    return "Not Found";
  }
  return "Unknown";
}


x86 assembly (clang, -O0):
<get_shortmsg_from_status_code>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0xc(%rbp)
cmpl   $0xc8,-0xc(%rbp)
jne    1124 <get_shortmsg_from_status_code+0x24>
lea    0xee5(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    1169 <get_shortmsg_from_status_code+0x69>
cmpl   $0x130,-0xc(%rbp)
jne    1141 <get_shortmsg_from_status_code+0x41>
lea    0xecb(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    1169 <get_shortmsg_from_status_code+0x69>
cmpl   $0x194,-0xc(%rbp)
jne    115e <get_shortmsg_from_status_code+0x5e>
lea    0xebb(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    1169 <get_shortmsg_from_status_code+0x69>
lea    0xeb5(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_shortmsg_from_status_code>:
cmp    $0xc8,%edi
je     1120 <get_shortmsg_from_status_code+0x20>
cmp    $0x194,%edi
je     1128 <get_shortmsg_from_status_code+0x28>
cmp    $0x130,%edi
jne    1130 <get_shortmsg_from_status_code+0x30>
lea    0xee4(%rip),%rax
ret
lea    0xed9(%rip),%rax
ret
lea    0xee1(%rip),%rax
ret
lea    0xee3(%rip),%rax
ret

LLVM IR (-O0):
@.str = [3 x i8] c"OK\00"
@.str.1 = [13 x i8] c"Not Modified\00"
@.str.2 = [10 x i8] c"Not Found\00"
@.str.3 = [8 x i8] c"Unknown\00"
define i8* @get_shortmsg_from_status_code(i32 %0) {
%2 = alloca i8*
%3 = alloca i32
store i32 %0, i32* %3
%4 = load i32, i32* %3
%5 = icmp eq i32 %4, 200
br i1 %5, label %6, label %7
6: ; preds = %1
store i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8** %2
br label %16
7: ; preds = %1
%8 = load i32, i32* %3
%9 = icmp eq i32 %8, 304
br i1 %9, label %10, label %11
10: ; preds = %7
store i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i8** %2
br label %16
11: ; preds = %7
%12 = load i32, i32* %3
%13 = icmp eq i32 %12, 404
br i1 %13, label %14, label %15
14: ; preds = %11
store i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0), i8** %2
br label %16
15: ; preds = %11
store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i8** %2
br label %16
16: ; preds = %15, %14, %10, %6
%17 = load i8*, i8** %2
ret i8* %17
}

LLVM IR (-O2):
@.str = [3 x i8] c"OK\00"
@.str.1 = [13 x i8] c"Not Modified\00"
@.str.2 = [10 x i8] c"Not Found\00"
@.str.3 = [8 x i8] c"Unknown\00"
define i8* @get_shortmsg_from_status_code(i32 %0) {
switch i32 %0, label %4 [
i32 200, label %5
i32 304, label %2
i32 404, label %3
]
2: ; preds = %1
br label %5
3: ; preds = %1
br label %5
4: ; preds = %1
br label %5
5: ; preds = %1, %4, %3, %2
%6 = phi i8* [ getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), %2 ], [ getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0), %3 ], [ getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), %4 ], [ getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), %1 ]
ret i8* %6
}
/* Variables and functions */
scalar_t__ write_com_4bit(int);
void cursor_shift_L() {
  write_com_4bit(0x0010);
  while (write_com_4bit(0x0100) != 0)
    ;
}


x86 assembly (clang, -O0):
<cursor_shift_L>:
push   %rbp
mov    %rsp,%rbp
mov    $0x10,%edi
call   1030 <write_com_4bit@plt>
mov    $0x100,%edi
call   1030 <write_com_4bit@plt>
cmp    $0x0,%rax
je     1137 <cursor_shift_L+0x27>
jmp    111e <cursor_shift_L+0xe>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cursor_shift_L>:
push   %rax
mov    $0x10,%edi
call   1030 <write_com_4bit@plt>
nopl   0x0(%rax,%rax,1)
mov    $0x100,%edi
call   1030 <write_com_4bit@plt>
test   %rax,%rax
jne    1120 <cursor_shift_L+0x10>
pop    %rax
ret

LLVM IR (-O0):
define void @cursor_shift_L() {
%1 = call i64 @write_com_4bit(i32 16)
br label %2
2: ; preds = %5, %0
%3 = call i64 @write_com_4bit(i32 256)
%4 = icmp ne i64 %3, 0
br i1 %4, label %5, label %6
5: ; preds = %2
br label %2
6: ; preds = %2
ret void
}

LLVM IR (-O2):
define void @cursor_shift_L() {
%1 = tail call i64 @write_com_4bit(i32 16)
br label %2
2: ; preds = %2, %0
%3 = tail call i64 @write_com_4bit(i32 256)
%4 = icmp eq i64 %3, 0
br i1 %4, label %5, label %2
5: ; preds = %2
ret void
}
/* Type definitions */
struct stack_st_OPENSSL_STRING {
  int dummy;
};

/* Variables and functions */
scalar_t__ OPENSSL_sk_new_null();
struct stack_st_OPENSSL_STRING *sk_OPENSSL_STRING_new_null(void) {
  return (struct stack_st_OPENSSL_STRING *)OPENSSL_sk_new_null();
}


x86 assembly (clang, -O0):
<sk_OPENSSL_STRING_new_null>:
push   %rbp
mov    %rsp,%rbp
mov    $0x0,%al
call   1030 <OPENSSL_sk_new_null@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<sk_OPENSSL_STRING_new_null>:
xor    %eax,%eax
jmp    1030 <OPENSSL_sk_new_null@plt>

LLVM IR (-O0):
%struct.stack_st_OPENSSL_STRING = type { i32 }
define %struct.stack_st_OPENSSL_STRING* @sk_OPENSSL_STRING_new_null() {
%1 = call i64 (...) @OPENSSL_sk_new_null()
%2 = inttoptr i64 %1 to %struct.stack_st_OPENSSL_STRING*
ret %struct.stack_st_OPENSSL_STRING* %2
}

LLVM IR (-O2):
%struct.stack_st_OPENSSL_STRING = type { i32 }
define %struct.stack_st_OPENSSL_STRING* @sk_OPENSSL_STRING_new_null() {
%1 = tail call i64 (...) @OPENSSL_sk_new_null()
%2 = inttoptr i64 %1 to %struct.stack_st_OPENSSL_STRING*
ret %struct.stack_st_OPENSSL_STRING* %2
}
/* Variables and functions */
char *ulltoa_wp(unsigned long long, char *, unsigned int, int /*<<< orphan*/,
                char);
char *ulltoa(unsigned long long val, char *buffer, unsigned int base) {
  return ulltoa_wp(val, buffer, base, 0, ' ');
}


x86 assembly (clang, -O0):
<ulltoa>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
xor    %ecx,%ecx
mov    $0x20,%r8d
call   1030 <ulltoa_wp@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ulltoa>:
xor    %ecx,%ecx
mov    $0x20,%r8d
jmp    1030 <ulltoa_wp@plt>

LLVM IR (-O0):
define i8* @ulltoa(i64 %0, i8* %1, i32 %2) {
%4 = alloca i64
%5 = alloca i8*
%6 = alloca i32
store i64 %0, i64* %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%7 = load i64, i64* %4
%8 = load i8*, i8** %5
%9 = load i32, i32* %6
%10 = call i8* @ulltoa_wp(i64 %7, i8* %8, i32 %9, i32 0, i8 signext 32)
ret i8* %10
}

LLVM IR (-O2):
define i8* @ulltoa(i64 %0, i8* %1, i32 %2) {
%4 = tail call i8* @ulltoa_wp(i64 %0, i8* %1, i32 %2, i32 0, i8 signext 32)
ret i8* %4
}
/* Type definitions */
typedef int /*<<< orphan*/ int32_t;

/* Variables and functions */
int32_t ev3_lcd_fill_rect(int32_t x, int32_t y, int32_t w, int32_t h,
                          int32_t color) {
  return 0;
}


x86 assembly (clang, -O0):
<ev3_lcd_fill_rect>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
xor    %eax,%eax
pop    %rbp
ret

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

LLVM IR (-O0):
define i32 @ev3_lcd_fill_rect(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i32 %0, i32* %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
ret i32 0
}

LLVM IR (-O2):
define i32 @ev3_lcd_fill_rect(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4) {
ret i32 0
}
void gtk_tree_view_column_set_clickable() {}


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

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

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

LLVM IR (-O2):
define void @gtk_tree_view_column_set_clickable() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ bckH_display();
int /*<<< orphan*/ gen_display();
int /*<<< orphan*/ part_display();
void sim_display(void) {
  part_display();
  gen_display();
  bckH_display();
}


x86 assembly (clang, -O0):
<sim_display>:
push   %rbp
mov    %rsp,%rbp
mov    $0x0,%al
call   1050 <part_display@plt>
mov    $0x0,%al
call   1040 <gen_display@plt>
mov    $0x0,%al
call   1030 <bckH_display@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<sim_display>:
push   %rax
xor    %eax,%eax
call   1050 <part_display@plt>
xor    %eax,%eax
call   1040 <gen_display@plt>
xor    %eax,%eax
pop    %rcx
jmp    1030 <bckH_display@plt>

LLVM IR (-O0):
define void @sim_display() {
%1 = call i32 (...) @part_display()
%2 = call i32 (...) @gen_display()
%3 = call i32 (...) @bckH_display()
ret void
}

LLVM IR (-O2):
define void @sim_display() {
%1 = tail call i32 (...) @part_display()
%2 = tail call i32 (...) @gen_display()
%3 = tail call i32 (...) @bckH_display()
ret void
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, char *);
void print_lines(char **lines, size_t count) {
  for (size_t i = 0; i < count; i++)
    printf("%s\n", lines[i]);
}


x86 assembly (clang, -O0):
<print_lines>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    115f <print_lines+0x4f>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0xeb7(%rip),%rdi
call   1030 <printf@plt>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1128 <print_lines+0x18>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_lines>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
test   %rsi,%rsi
je     1145 <print_lines+0x35>
mov    %rsi,%r12
mov    %rdi,%r14
xor    %ebx,%ebx
lea    0xed4(%rip),%r15
nopl   0x0(%rax)
mov    (%r14,%rbx,8),%rsi
mov    %r15,%rdi
call   1030 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1130 <print_lines+0x20>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [4 x i8] c"%s\0A\00"
define void @print_lines(i8** %0, i64 %1) {
%3 = alloca i8**
%4 = alloca i64
%5 = alloca i64
store i8** %0, i8*** %3
store i64 %1, i64* %4
store i64 0, i64* %5
br label %6
6: ; preds = %16, %2
%7 = load i64, i64* %5
%8 = load i64, i64* %4
%9 = icmp ult i64 %7, %8
br i1 %9, label %10, label %19
10: ; preds = %6
%11 = load i8**, i8*** %3
%12 = load i64, i64* %5
%13 = getelementptr inbounds i8*, i8** %11, i64 %12
%14 = load i8*, i8** %13
%15 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %14)
br label %16
16: ; preds = %10
%17 = load i64, i64* %5
%18 = add i64 %17, 1
store i64 %18, i64* %5
br label %6
19: ; preds = %6
ret void
}

LLVM IR (-O2):
@.str = [4 x i8] c"%s\0A\00"
define void @print_lines(i8** nocapture %0, i64 %1) {
%3 = icmp eq i64 %1, 0
br i1 %3, label %4, label %5
4: ; preds = %5, %2
ret void
5: ; preds = %2, %5
%6 = phi i64 [ %10, %5 ], [ 0, %2 ]
%7 = getelementptr inbounds i8*, i8** %0, i64 %6
%8 = load i8*, i8** %7
%9 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %8)
%10 = add nuw i64 %6, 1
%11 = icmp eq i64 %10, %1
br i1 %11, label %4, label %5
}
void msm_pm_set_platform_data(struct msm_pm_platform_data *data, int count) {}


x86 assembly (clang, -O0):
<msm_pm_set_platform_data>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
pop    %rbp
ret

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

LLVM IR (-O0):
%struct.msm_pm_platform_data = type opaque
define void @msm_pm_set_platform_data(%struct.msm_pm_platform_data* %0, i32 %1) {
%3 = alloca %struct.msm_pm_platform_data*
%4 = alloca i32
store %struct.msm_pm_platform_data* %0, %struct.msm_pm_platform_data** %3
store i32 %1, i32* %4
ret void
}

LLVM IR (-O2):
%struct.msm_pm_platform_data = type opaque
define void @msm_pm_set_platform_data(%struct.msm_pm_platform_data* nocapture %0, i32 %1) {
ret void
}
double AACGM_v2_Sgn(double a, double b) {
  double x = 0;
  x = (a >= 0) ? a : -a;
  return (b >= 0) ? x : -x;
}


x86 assembly (clang, -O0):
<AACGM_v2_Sgn>:
push   %rbp
mov    %rsp,%rbp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x8(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1137 <AACGM_v2_Sgn+0x37>
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
jmp    1158 <AACGM_v2_Sgn+0x58>
movsd  -0x8(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x10(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1183 <AACGM_v2_Sgn+0x83>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    11a4 <AACGM_v2_Sgn+0xa4>
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<AACGM_v2_Sgn>:
movapd 0xef8(%rip),%xmm2
movapd %xmm0,%xmm3
xorpd  %xmm2,%xmm3
xorpd  %xmm4,%xmm4
xorpd  %xmm5,%xmm5
cmplesd %xmm0,%xmm5
andpd  %xmm5,%xmm0
andnpd %xmm3,%xmm5
orpd   %xmm5,%xmm0
xorpd  %xmm0,%xmm2
cmplesd %xmm1,%xmm4
andpd  %xmm4,%xmm0
andnpd %xmm2,%xmm4
orpd   %xmm4,%xmm0
ret

LLVM IR (-O0):
define double @AACGM_v2_Sgn(double %0, double %1) {
%3 = alloca double
%4 = alloca double
%5 = alloca double
store double %0, double* %3
store double %1, double* %4
store double 0.000000e+00, double* %5
%6 = load double, double* %3
%7 = fcmp oge double %6, 0.000000e+00
br i1 %7, label %8, label %10
8: ; preds = %2
%9 = load double, double* %3
br label %13
10: ; preds = %2
%11 = load double, double* %3
%12 = fneg double %11
br label %13
13: ; preds = %10, %8
%14 = phi double [ %9, %8 ], [ %12, %10 ]
store double %14, double* %5
%15 = load double, double* %4
%16 = fcmp oge double %15, 0.000000e+00
br i1 %16, label %17, label %19
17: ; preds = %13
%18 = load double, double* %5
br label %22
19: ; preds = %13
%20 = load double, double* %5
%21 = fneg double %20
br label %22
22: ; preds = %19, %17
%23 = phi double [ %18, %17 ], [ %21, %19 ]
ret double %23
}

LLVM IR (-O2):
define double @AACGM_v2_Sgn(double %0, double %1) {
%3 = fcmp oge double %0, 0.000000e+00
%4 = fneg double %0
%5 = select i1 %3, double %0, double %4
%6 = fcmp oge double %1, 0.000000e+00
%7 = fneg double %5
%8 = select i1 %6, double %5, double %7
ret double %8
}
/* Type definitions */
typedef int /*<<< orphan*/ int32_t;

/* Variables and functions */
int INT32_MAX;
int32_t Qtos32(float q) { return (int32_t)(q * (float)(INT32_MAX - 1)); }


x86 assembly (clang, -O0):
<Qtos32>:
push   %rbp
mov    %rsp,%rbp
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
mov    0x2ecb(%rip),%rax
mov    (%rax),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<Qtos32>:
mov    0x2ed9(%rip),%rax
mov    (%rax),%eax
add    $0xffffffff,%eax
cvtsi2ss %eax,%xmm1
mulss  %xmm0,%xmm1
cvttss2si %xmm1,%eax
ret

LLVM IR (-O0):
@INT32_MAX = global i32 0
define i32 @Qtos32(float %0) {
%2 = alloca float
store float %0, float* %2
%3 = load float, float* %2
%4 = load i32, i32* @INT32_MAX
%5 = sub nsw i32 %4, 1
%6 = sitofp i32 %5 to float
%7 = fmul float %3, %6
%8 = fptosi float %7 to i32
ret i32 %8
}

LLVM IR (-O2):
@INT32_MAX = global i32 0
define i32 @Qtos32(float %0) {
%2 = load i32, i32* @INT32_MAX
%3 = add nsw i32 %2, -1
%4 = sitofp i32 %3 to float
%5 = fmul float %4, %0
%6 = fptosi float %5 to i32
ret i32 %6
}
void moveleft(int frame[][4]) { return; }


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

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

LLVM IR (-O0):
define void @moveleft([4 x i32]* %0) {
%2 = alloca [4 x i32]*
store [4 x i32]* %0, [4 x i32]** %2
ret void
}

LLVM IR (-O2):
define void @moveleft([4 x i32]* nocapture %0) {
ret void
}
double mkelvin_to_C(int mkelvin) { return (mkelvin - 273150) / 1000.0; }


x86 assembly (clang, -O0):
<mkelvin_to_C>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x42afe,%eax
cvtsi2sd %eax,%xmm0
movsd  0xee5(%rip),%xmm1
divsd  %xmm1,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<mkelvin_to_C>:
add    $0xfffbd502,%edi
cvtsi2sd %edi,%xmm0
divsd  0xeee(%rip),%xmm0
ret

LLVM IR (-O0):
define double @mkelvin_to_C(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
%3 = load i32, i32* %2
%4 = sub nsw i32 %3, 273150
%5 = sitofp i32 %4 to double
%6 = fdiv double %5, 1.000000e+03
ret double %6
}

LLVM IR (-O2):
define double @mkelvin_to_C(i32 %0) {
%2 = add nsw i32 %0, -273150
%3 = sitofp i32 %2 to double
%4 = fdiv double %3, 1.000000e+03
ret double %4
}
int f(int a) {
  if (a > 0) {
    return a * f(a - 1);
  } else {
    return 0;
  }
}


x86 assembly (clang, -O0):
<f>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x8(%rbp)
cmpl   $0x0,-0x8(%rbp)
jle    1146 <f+0x36>
mov    -0x8(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%edi
sub    $0x1,%edi
call   1030 <f@plt>
mov    %eax,%ecx
mov    -0xc(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    114d <f+0x3d>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

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

LLVM IR (-O0):
define i32 @f(i32 %0) {
%2 = alloca i32
%3 = alloca i32
store i32 %0, i32* %3
%4 = load i32, i32* %3
%5 = icmp sgt i32 %4, 0
br i1 %5, label %6, label %12
6: ; preds = %1
%7 = load i32, i32* %3
%8 = load i32, i32* %3
%9 = sub nsw i32 %8, 1
%10 = call i32 @f(i32 %9)
%11 = mul nsw i32 %7, %10
store i32 %11, i32* %2
br label %13
12: ; preds = %1
store i32 0, i32* %2
br label %13
13: ; preds = %12, %6
%14 = load i32, i32* %2
ret i32 %14
}

LLVM IR (-O2):
define i32 @f(i32 %0) {
ret i32 0
}
/* Variables and functions */
int f25(int *);
int f26(int *p) { return f25(p); }


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

x86 assembly (clang, -O2):
<f26>:
jmp    1030 <f25@plt>

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

LLVM IR (-O2):
define i32 @f26(i32* %0) {
%2 = tail call i32 @f25(i32* %0)
ret i32 %2
}
/* Type definitions */
typedef int key_t;

/* Variables and functions */
int IPC_CREAT;
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int);
int msgget(int, int);
int /*<<< orphan*/ stderr;
int createOrGetQueueIdWithKey(key_t key) {
  int queue_id;
  if ((queue_id = msgget(key, IPC_CREAT | 0666)) == -1) {
    fprintf(stderr, "Impossivel criar a fila de mensagens com a chave: %d\n",
            key);
    exit(1);
  }
  return queue_id;
}


x86 assembly (clang, -O0):
<createOrGetQueueIdWithKey>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%edi
mov    0x2e93(%rip),%rax
mov    (%rax),%esi
or     $0x1b6,%esi
call   1030 <msgget@plt>
mov    %eax,-0x8(%rbp)
cmp    $0xffffffff,%eax
jne    1180 <createOrGetQueueIdWithKey+0x50>
mov    0x2e7b(%rip),%rax
mov    (%rax),%edi
mov    -0x4(%rbp),%edx
lea    0xe8f(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1050 <exit@plt>
mov    -0x8(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<createOrGetQueueIdWithKey>:
push   %rbx
mov    %edi,%ebx
mov    0x2e9e(%rip),%rax
mov    $0x1b6,%esi
or     (%rax),%esi
call   1030 <msgget@plt>
cmp    $0xffffffff,%eax
je     114d <createOrGetQueueIdWithKey+0x1d>
pop    %rbx
ret
mov    0x2e8c(%rip),%rax
mov    (%rax),%edi
lea    0xea3(%rip),%rsi
mov    %ebx,%edx
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1050 <exit@plt>

LLVM IR (-O0):
@IPC_CREAT = global i32 0
@stderr = global i32 0
@.str = [54 x i8] c"Impossivel criar a fila de mensagens com a chave: %d\0A\00"
define i32 @createOrGetQueueIdWithKey(i32 %0) {
%2 = alloca i32
%3 = alloca i32
store i32 %0, i32* %2
%4 = load i32, i32* %2
%5 = load i32, i32* @IPC_CREAT
%6 = or i32 %5, 438
%7 = call i32 @msgget(i32 %4, i32 %6)
store i32 %7, i32* %3
%8 = icmp eq i32 %7, -1
br i1 %8, label %9, label %14
9: ; preds = %1
%10 = load i32, i32* @stderr
%11 = load i32, i32* %2
%12 = call i32 @fprintf(i32 %10, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str, i64 0, i64 0), i32 %11)
%13 = call i32 @exit(i32 1)
unreachable
14: ; preds = %1
%15 = load i32, i32* %3
ret i32 %15
}

LLVM IR (-O2):
@IPC_CREAT = global i32 0
@stderr = global i32 0
@.str = [54 x i8] c"Impossivel criar a fila de mensagens com a chave: %d\0A\00"
define i32 @createOrGetQueueIdWithKey(i32 %0) {
%2 = load i32, i32* @IPC_CREAT
%3 = or i32 %2, 438
%4 = tail call i32 @msgget(i32 %0, i32 %3)
%5 = icmp eq i32 %4, -1
br i1 %5, label %6, label %10
6: ; preds = %1
%7 = load i32, i32* @stderr
%8 = tail call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str, i64 0, i64 0), i32 %0)
%9 = tail call i32 @exit(i32 1)
unreachable
10: ; preds = %1
ret i32 %4
}
double Log10(x)
double x;
{ return errcheck(log10(x), "log10"); }


x86 assembly (clang, -O0):
<Log10>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
call   1040 <log10@plt>
lea    0xec2(%rip),%rdi
mov    $0x1,%al
call   1030 <errcheck@plt>
cvtsi2sd %eax,%xmm0
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Log10>:
push   %rax
call   1040 <log10@plt>
lea    0xed3(%rip),%rdi
mov    $0x1,%al
call   1030 <errcheck@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
pop    %rax
ret

LLVM IR (-O0):
@.str = [6 x i8] c"log10\00"
define double @Log10(double %0) {
%2 = alloca double
store double %0, double* %2
%3 = load double, double* %2
%4 = call double @log10(double %3)
%5 = call i32 (double, i8*, ...) bitcast (i32 (...)* @errcheck to i32 (double, i8*, ...)*)(double %4, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%6 = sitofp i32 %5 to double
ret double %6
}

LLVM IR (-O2):
@.str = [6 x i8] c"log10\00"
define double @Log10(double %0) {
%2 = tail call double @log10(double %0)
%3 = tail call i32 (double, i8*, ...) bitcast (i32 (...)* @errcheck to i32 (double, i8*, ...)*)(double %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%4 = sitofp i32 %3 to double
ret double %4
}