xunge/DecIR huggingface dataset:
/* Variables and functions */
int /*<<< orphan*/ cng_put_pixel(int, int);
int Affiche5(int x, int y) { cng_put_pixel(-x, -y); }


x86 assembly (clang, -O0):
<Affiche5>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
xor    %edi,%edi
sub    -0x8(%rbp),%edi
xor    %esi,%esi
sub    -0xc(%rbp),%esi
call   1030 <cng_put_pixel@plt>
mov    -0x4(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Affiche5>:
neg    %edi
neg    %esi
jmp    1030 <cng_put_pixel@plt>

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

LLVM IR (-O2):
define i32 @Affiche5(i32 %0, i32 %1) {
%3 = sub nsw i32 0, %0
%4 = sub nsw i32 0, %1
%5 = tail call i32 @cng_put_pixel(i32 %3, i32 %4)
ret i32 undef
}
extern int spell(void) { return 0; }


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

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

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

LLVM IR (-O2):
define i32 @spell() {
ret i32 0
}
int recupererDirectionCasNormal(const unsigned int direction,
                                const unsigned int dimension) {
  static const int baseDirection[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
  return baseDirection[direction][dimension];
}


x86 assembly (clang, -O0):
<recupererDirectionCasNormal>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,%ecx
lea    0xeea(%rip),%rax
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<recupererDirectionCasNormal>:
mov    %edi,%eax
mov    %esi,%ecx
lea    0xef5(%rip),%rdx
lea    (%rdx,%rax,8),%rax
mov    (%rax,%rcx,4),%eax
ret

LLVM IR (-O0):
@recupererDirectionCasNormal.baseDirection = internal constant [4 x [2 x i32]] [[2 x i32] [i32 -1, i32 0], [2 x i32] [i32 1, i32 0], [2 x i32] [i32 0, i32 -1], [2 x i32] [i32 0, i32 1]]
define i32 @recupererDirectionCasNormal(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 = zext i32 %5 to i64
%7 = getelementptr inbounds [4 x [2 x i32]], [4 x [2 x i32]]* @recupererDirectionCasNormal.baseDirection, i64 0, i64 %6
%8 = load i32, i32* %4
%9 = zext i32 %8 to i64
%10 = getelementptr inbounds [2 x i32], [2 x i32]* %7, i64 0, i64 %9
%11 = load i32, i32* %10
ret i32 %11
}

LLVM IR (-O2):
@recupererDirectionCasNormal.baseDirection = internal unnamed_addr constant [4 x [2 x i32]] [[2 x i32] [i32 -1, i32 0], [2 x i32] [i32 1, i32 0], [2 x i32] [i32 0, i32 -1], [2 x i32] [i32 0, i32 1]]
define i32 @recupererDirectionCasNormal(i32 %0, i32 %1) {
%3 = zext i32 %0 to i64
%4 = zext i32 %1 to i64
%5 = getelementptr inbounds [4 x [2 x i32]], [4 x [2 x i32]]* @recupererDirectionCasNormal.baseDirection, i64 0, i64 %3, i64 %4
%6 = load i32, i32* %5
ret i32 %6
}
void swap(void *v[], int i, int j) {
  char *temp;
  temp = v[i];
  v[i] = v[j];
  v[j] = temp;
}


x86 assembly (clang, -O0):
<swap>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
pop    %rbp
ret

x86 assembly (clang, -O2):
<swap>:
movslq %esi,%rax
mov    (%rdi,%rax,8),%rcx
movslq %edx,%rdx
mov    (%rdi,%rdx,8),%rsi
mov    %rsi,(%rdi,%rax,8)
mov    %rcx,(%rdi,%rdx,8)
ret

LLVM IR (-O0):
define void @swap(i8** %0, i32 %1, i32 %2) {
%4 = alloca i8**
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
store i8** %0, i8*** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%8 = load i8**, i8*** %4
%9 = load i32, i32* %5
%10 = sext i32 %9 to i64
%11 = getelementptr inbounds i8*, i8** %8, i64 %10
%12 = load i8*, i8** %11
store i8* %12, i8** %7
%13 = load i8**, i8*** %4
%14 = load i32, i32* %6
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i8*, i8** %13, i64 %15
%17 = load i8*, i8** %16
%18 = load i8**, i8*** %4
%19 = load i32, i32* %5
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds i8*, i8** %18, i64 %20
store i8* %17, i8** %21
%22 = load i8*, i8** %7
%23 = load i8**, i8*** %4
%24 = load i32, i32* %6
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i8*, i8** %23, i64 %25
store i8* %22, i8** %26
ret void
}

LLVM IR (-O2):
define void @swap(i8** nocapture %0, i32 %1, i32 %2) {
%4 = sext i32 %1 to i64
%5 = getelementptr inbounds i8*, i8** %0, i64 %4
%6 = load i8*, i8** %5
%7 = sext i32 %2 to i64
%8 = getelementptr inbounds i8*, i8** %0, i64 %7
%9 = load i8*, i8** %8
store i8* %9, i8** %5
store i8* %6, i8** %8
ret void
}
/* Variables and functions */
unsigned int bar();
void foo0xff(void) {
  unsigned int a = bar();
  if (a <= 0xff)
    bar();
}


x86 assembly (clang, -O0):
<foo0xff>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    $0x0,%al
call   1030 <bar@plt>
mov    %eax,-0x4(%rbp)
cmpl   $0xff,-0x4(%rbp)
ja     1136 <foo0xff+0x26>
mov    $0x0,%al
call   1030 <bar@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<foo0xff>:
push   %rax
xor    %eax,%eax
call   1030 <bar@plt>
cmp    $0xff,%eax
ja     1127 <foo0xff+0x17>
xor    %eax,%eax
pop    %rcx
jmp    1030 <bar@plt>
pop    %rax
ret

LLVM IR (-O0):
define void @foo0xff() {
%1 = alloca i32
%2 = call i32 (...) @bar()
store i32 %2, i32* %1
%3 = load i32, i32* %1
%4 = icmp ule i32 %3, 255
br i1 %4, label %5, label %7
5: ; preds = %0
%6 = call i32 (...) @bar()
br label %7
7: ; preds = %5, %0
ret void
}

LLVM IR (-O2):
define void @foo0xff() {
%1 = tail call i32 (...) @bar()
%2 = icmp ult i32 %1, 256
br i1 %2, label %3, label %5
3: ; preds = %0
%4 = tail call i32 (...) @bar()
br label %5
5: ; preds = %3, %0
ret void
}
/* Variables and functions */
int /*<<< orphan*/ rdc_disable_clock();
int /*<<< orphan*/ rdc_disable_vref();
int /*<<< orphan*/ rdc_enable_pg_v1p2();
int /*<<< orphan*/ rdc_enable_pg_vbat();
int /*<<< orphan*/ rdc_reset2();
void rdc_power_off() {
  rdc_reset2();
  rdc_disable_clock();
  rdc_enable_pg_vbat();
  rdc_enable_pg_v1p2();
  rdc_disable_vref();
}


x86 assembly (clang, -O0):
<rdc_power_off>:
push   %rbp
mov    %rsp,%rbp
mov    $0x0,%al
call   1070 <rdc_reset2@plt>
mov    $0x0,%al
call   1040 <rdc_disable_clock@plt>
mov    $0x0,%al
call   1030 <rdc_enable_pg_vbat@plt>
mov    $0x0,%al
call   1060 <rdc_enable_pg_v1p2@plt>
mov    $0x0,%al
call   1050 <rdc_disable_vref@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<rdc_power_off>:
push   %rax
xor    %eax,%eax
call   1070 <rdc_reset2@plt>
xor    %eax,%eax
call   1040 <rdc_disable_clock@plt>
xor    %eax,%eax
call   1030 <rdc_enable_pg_vbat@plt>
xor    %eax,%eax
call   1060 <rdc_enable_pg_v1p2@plt>
xor    %eax,%eax
pop    %rcx
jmp    1050 <rdc_disable_vref@plt>

LLVM IR (-O0):
define void @rdc_power_off() {
%1 = call i32 (...) @rdc_reset2()
%2 = call i32 (...) @rdc_disable_clock()
%3 = call i32 (...) @rdc_enable_pg_vbat()
%4 = call i32 (...) @rdc_enable_pg_v1p2()
%5 = call i32 (...) @rdc_disable_vref()
ret void
}

LLVM IR (-O2):
define void @rdc_power_off() {
%1 = tail call i32 (...) @rdc_reset2()
%2 = tail call i32 (...) @rdc_disable_clock()
%3 = tail call i32 (...) @rdc_enable_pg_vbat()
%4 = tail call i32 (...) @rdc_enable_pg_v1p2()
%5 = tail call i32 (...) @rdc_disable_vref()
ret void
}
/* Type definitions */
typedef int /*<<< orphan*/ uint8_t;
typedef int /*<<< orphan*/ uint16_t;

/* Variables and functions */
int /*<<< orphan*/ read_be16(int /*<<< orphan*/ const *);
uint16_t read_at_be16(const void *src, size_t offset) {
  const uint8_t *s = src;
  s += offset;
  return read_be16(s);
}


x86 assembly (clang, -O0):
<read_at_be16>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
shl    $0x2,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <read_be16@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<read_at_be16>:
lea    (%rdi,%rsi,4),%rdi
jmp    1030 <read_be16@plt>

LLVM IR (-O0):
define i32 @read_at_be16(i8* %0, i64 %1) {
%3 = alloca i8*
%4 = alloca i64
%5 = alloca i32*
store i8* %0, i8** %3
store i64 %1, i64* %4
%6 = load i8*, i8** %3
%7 = bitcast i8* %6 to i32*
store i32* %7, i32** %5
%8 = load i64, i64* %4
%9 = load i32*, i32** %5
%10 = getelementptr inbounds i32, i32* %9, i64 %8
store i32* %10, i32** %5
%11 = load i32*, i32** %5
%12 = call i32 @read_be16(i32* %11)
ret i32 %12
}

LLVM IR (-O2):
define i32 @read_at_be16(i8* %0, i64 %1) {
%3 = bitcast i8* %0 to i32*
%4 = getelementptr inbounds i32, i32* %3, i64 %1
%5 = tail call i32 @read_be16(i32* %4)
ret i32 %5
}
/* Forward declarations */
typedef struct TYPE_4__ TYPE_2__;
typedef struct TYPE_3__ TYPE_1__;

/* Type definitions */
struct TYPE_3__ {
  char *multi_byte;
};
struct TYPE_4__ {
  TYPE_1__ string;
};
typedef TYPE_2__ XIMText;

/* Variables and functions */
void set_XIMText_string_multi_byte(void *_p, void *_v) {
  ((XIMText *)_p)->string.multi_byte = (char *)_v;
}


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

x86 assembly (clang, -O2):
<set_XIMText_string_multi_byte>:
mov    %rsi,(%rdi)
ret

LLVM IR (-O0):
%struct.TYPE_4__ = type { %struct.TYPE_3__ }
%struct.TYPE_3__ = type { i8* }
define void @set_XIMText_string_multi_byte(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
store i8* %0, i8** %3
store i8* %1, i8** %4
%5 = load i8*, i8** %4
%6 = load i8*, i8** %3
%7 = bitcast i8* %6 to %struct.TYPE_4__*
%8 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %7, i32 0, i32 0
%9 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %8, i32 0, i32 0
store i8* %5, i8** %9
ret void
}

LLVM IR (-O2):
define void @set_XIMText_string_multi_byte(i8* nocapture writeonly %0, i8* %1) {
%3 = bitcast i8* %0 to i8**
store i8* %1, i8** %3
ret void
}
void foo642() {}


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

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

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

LLVM IR (-O2):
define void @foo642() {
ret void
}
int _testfunc_i_bhilfd(signed char b, short h, int i, long l, float f,
                       double d) {
  return (int)(b + h + i + l + f + d);
}


x86 assembly (clang, -O0):
<_testfunc_i_bhilfd>:
push   %rbp
mov    %rsp,%rbp
mov    %si,%ax
mov    %dil,%sil
mov    %sil,-0x1(%rbp)
mov    %ax,-0x4(%rbp)
mov    %edx,-0x8(%rbp)
mov    %rcx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movsd  %xmm1,-0x20(%rbp)
movsbl -0x1(%rbp),%eax
movswl -0x4(%rbp),%ecx
add    %ecx,%eax
add    -0x8(%rbp),%eax
cltq
add    -0x10(%rbp),%rax
cvtsi2ss %rax,%xmm0
addss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x20(%rbp),%xmm0
cvttsd2si %xmm0,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<_testfunc_i_bhilfd>:
add    %esi,%edi
add    %edx,%edi
movslq %edi,%rax
add    %rcx,%rax
cvtsi2ss %rax,%xmm2
addss  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
ret

LLVM IR (-O0):
define i32 @_testfunc_i_bhilfd(i8 signext %0, i16 signext %1, i32 %2, i64 %3, float %4, double %5) {
%7 = alloca i8
%8 = alloca i16
%9 = alloca i32
%10 = alloca i64
%11 = alloca float
%12 = alloca double
store i8 %0, i8* %7
store i16 %1, i16* %8
store i32 %2, i32* %9
store i64 %3, i64* %10
store float %4, float* %11
store double %5, double* %12
%13 = load i8, i8* %7
%14 = sext i8 %13 to i32
%15 = load i16, i16* %8
%16 = sext i16 %15 to i32
%17 = add nsw i32 %14, %16
%18 = load i32, i32* %9
%19 = add nsw i32 %17, %18
%20 = sext i32 %19 to i64
%21 = load i64, i64* %10
%22 = add nsw i64 %20, %21
%23 = sitofp i64 %22 to float
%24 = load float, float* %11
%25 = fadd float %23, %24
%26 = fpext float %25 to double
%27 = load double, double* %12
%28 = fadd double %26, %27
%29 = fptosi double %28 to i32
ret i32 %29
}

LLVM IR (-O2):
define i32 @_testfunc_i_bhilfd(i8 signext %0, i16 signext %1, i32 %2, i64 %3, float %4, double %5) {
%7 = sext i8 %0 to i32
%8 = sext i16 %1 to i32
%9 = add nsw i32 %8, %7
%10 = add nsw i32 %9, %2
%11 = sext i32 %10 to i64
%12 = add nsw i64 %11, %3
%13 = sitofp i64 %12 to float
%14 = fadd float %13, %4
%15 = fpext float %14 to double
%16 = fadd double %15, %5
%17 = fptosi double %16 to i32
ret i32 %17
}
void dummy_pch(void) {}


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

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

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

LLVM IR (-O2):
define void @dummy_pch() {
ret void
}
/* Variables and functions */
int is_prime(int);
int /*<<< orphan*/ printf(char *, int);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  int number;
  int result;
  scanf("%d", &number);
  result = is_prime(number);
  printf("\n%d\n", result);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeba(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1050 <scanf@plt>
mov    -0x8(%rbp),%edi
call   1040 <is_prime@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%esi
lea    0xe9f(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
lea    0xec8(%rip),%rdi
lea    0x4(%rsp),%rsi
call   1050 <scanf@plt>
mov    0x4(%rsp),%edi
call   1040 <is_prime@plt>
lea    0xeb1(%rip),%rdi
mov    %eax,%esi
call   1030 <printf@plt>
xor    %eax,%eax
pop    %rcx
ret

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

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@.str.1 = [5 x i8] c"\0A%d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = bitcast i32* %1 to i8*
%3 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%4 = load i32, i32* %1
%5 = call i32 @is_prime(i32 %4)
%6 = call i32 @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 %5)
ret i32 0
}
int fun274() { return 274; }


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

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

LLVM IR (-O0):
define i32 @fun274() {
ret i32 274
}

LLVM IR (-O2):
define i32 @fun274() {
ret i32 274
}
void cheeky(char *format, ...) {}


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

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

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

LLVM IR (-O2):
define void @cheeky(i8* nocapture %0, ...) {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ SIGALRM;
int /*<<< orphan*/ alarm(int);
int /*<<< orphan*/ signal(int /*<<< orphan*/, void (*)());
void SigAlrmCaught() {
  signal(SIGALRM, SigAlrmCaught);
  alarm(1);
}


x86 assembly (clang, -O0):
<SigAlrmCaught>:
push   %rbp
mov    %rsp,%rbp
mov    0x2ebd(%rip),%rax
mov    (%rax),%edi
mov    0x2eac(%rip),%rsi
call   1040 <signal@plt>
mov    $0x1,%edi
call   1030 <alarm@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<SigAlrmCaught>:
push   %rax
mov    0x2ec0(%rip),%rax
mov    (%rax),%edi
mov    0x2eaf(%rip),%rsi
call   1040 <signal@plt>
mov    $0x1,%edi
pop    %rax
jmp    1030 <alarm@plt>

LLVM IR (-O0):
@SIGALRM = global i32 0
define void @SigAlrmCaught() {
%1 = load i32, i32* @SIGALRM
%2 = call i32 @signal(i32 %1, void (...)* bitcast (void ()* @SigAlrmCaught to void (...)*))
%3 = call i32 @alarm(i32 1)
ret void
}

LLVM IR (-O2):
@SIGALRM = global i32 0
define void @SigAlrmCaught() {
%1 = load i32, i32* @SIGALRM
%2 = tail call i32 @signal(i32 %1, void (...)* bitcast (void ()* @SigAlrmCaught to void (...)*))
%3 = tail call i32 @alarm(i32 1)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ keyboard_send(int);
void resetpc_cad() {
  keyboard_send(29);
  keyboard_send(56);
  keyboard_send(83);
  keyboard_send(157);
  keyboard_send(184);
  keyboard_send(211);
}


x86 assembly (clang, -O0):
<resetpc_cad>:
push   %rbp
mov    %rsp,%rbp
mov    $0x1d,%edi
call   1030 <keyboard_send@plt>
mov    $0x38,%edi
call   1030 <keyboard_send@plt>
mov    $0x53,%edi
call   1030 <keyboard_send@plt>
mov    $0x9d,%edi
call   1030 <keyboard_send@plt>
mov    $0xb8,%edi
call   1030 <keyboard_send@plt>
mov    $0xd3,%edi
call   1030 <keyboard_send@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<resetpc_cad>:
push   %rax
mov    $0x1d,%edi
call   1030 <keyboard_send@plt>
mov    $0x38,%edi
call   1030 <keyboard_send@plt>
mov    $0x53,%edi
call   1030 <keyboard_send@plt>
mov    $0x9d,%edi
call   1030 <keyboard_send@plt>
mov    $0xb8,%edi
call   1030 <keyboard_send@plt>
mov    $0xd3,%edi
pop    %rax
jmp    1030 <keyboard_send@plt>

LLVM IR (-O0):
define void @resetpc_cad() {
%1 = call i32 @keyboard_send(i32 29)
%2 = call i32 @keyboard_send(i32 56)
%3 = call i32 @keyboard_send(i32 83)
%4 = call i32 @keyboard_send(i32 157)
%5 = call i32 @keyboard_send(i32 184)
%6 = call i32 @keyboard_send(i32 211)
ret void
}

LLVM IR (-O2):
define void @resetpc_cad() {
%1 = tail call i32 @keyboard_send(i32 29)
%2 = tail call i32 @keyboard_send(i32 56)
%3 = tail call i32 @keyboard_send(i32 83)
%4 = tail call i32 @keyboard_send(i32 157)
%5 = tail call i32 @keyboard_send(i32 184)
%6 = tail call i32 @keyboard_send(i32 211)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, char *);
scalar_t__ strlen(void *);
void *thread_t1(void *arg) {
  printf("%s\n", (char *)arg);
  return (void *)strlen(arg);
}


x86 assembly (clang, -O0):
<thread_t1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rsi
lea    0xec9(%rip),%rdi
call   1040 <printf@plt>
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<thread_t1>:
push   %rbx
mov    %rdi,%rbx
lea    0xed5(%rip),%rdi
mov    %rbx,%rsi
call   1040 <printf@plt>
mov    %rbx,%rdi
pop    %rbx
jmp    1030 <strlen@plt>

LLVM IR (-O0):
@.str = [4 x i8] c"%s\0A\00"
define i8* @thread_t1(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %3)
%5 = load i8*, i8** %2
%6 = call i64 @strlen(i8* %5)
%7 = inttoptr i64 %6 to i8*
ret i8* %7
}

LLVM IR (-O2):
@.str = [4 x i8] c"%s\0A\00"
define i8* @thread_t1(i8* %0) {
%2 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %0)
%3 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%4 = inttoptr i64 %3 to i8*
ret i8* %4
}
__attribute__((always_)) void _uatomic_link_error(void) { __builtin_trap(); }


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

x86 assembly (clang, -O2):
<_uatomic_link_error>:
ud2

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

LLVM IR (-O2):
define void @_uatomic_link_error() {
tail call void @llvm.trap()
unreachable
}
/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
long ftell(int /*<<< orphan*/ *);
int /*<<< orphan*/ stderr;
long fgGetCurFilePlace(FILE *fp) {
  if (fp == NULL) {
    fprintf(stderr, "fgGetCurFilePlace, param is null\n");
    return -1;
  }
  return ftell(fp);
}


x86 assembly (clang, -O0):
<fgGetCurFilePlace>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1159 <fgGetCurFilePlace+0x39>
mov    0x2ea2(%rip),%rax
mov    (%rax),%edi
lea    0xeb9(%rip),%rsi
call   1030 <fprintf@plt>
movq   $0xffffffffffffffff,-0x8(%rbp)
ff
jmp    1166 <fgGetCurFilePlace+0x46>
mov    -0x10(%rbp),%rdi
call   1040 <ftell@plt>
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fgGetCurFilePlace>:
test   %rdi,%rdi
je     112a <fgGetCurFilePlace+0xa>
jmp    1040 <ftell@plt>
push   %rax
mov    0x2eae(%rip),%rax
mov    (%rax),%edi
lea    0xec5(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0xffffffffffffffff,%rax
pop    %rcx
ret

LLVM IR (-O0):
@stderr = global i32 0
@.str = [34 x i8] c"fgGetCurFilePlace, param is null\0A\00"
define i64 @fgGetCurFilePlace(i32* %0) {
%2 = alloca i64
%3 = alloca i32*
store i32* %0, i32** %3
%4 = load i32*, i32** %3
%5 = icmp eq i32* %4, null
br i1 %5, label %6, label %9
6: ; preds = %1
%7 = load i32, i32* @stderr
%8 = call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0))
store i64 -1, i64* %2
br label %12
9: ; preds = %1
%10 = load i32*, i32** %3
%11 = call i64 @ftell(i32* %10)
store i64 %11, i64* %2
br label %12
12: ; preds = %9, %6
%13 = load i64, i64* %2
ret i64 %13
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [34 x i8] c"fgGetCurFilePlace, param is null\0A\00"
define i64 @fgGetCurFilePlace(i32* %0) {
%2 = icmp eq i32* %0, null
br i1 %2, label %3, label %6
3: ; preds = %1
%4 = load i32, i32* @stderr
%5 = tail call i32 @fprintf(i32 %4, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0))
br label %8
6: ; preds = %1
%7 = tail call i64 @ftell(i32* %0)
br label %8
8: ; preds = %6, %3
%9 = phi i64 [ -1, %3 ], [ %7, %6 ]
ret i64 %9
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *);
void printHelp() {
  printf("Mine Miner Help\n"
         "Note: This game is not yet completed.\n"
         "Note: Some arguments listed do not work at the moment.\n"
         "start a new game\n"
         "\t$ mm --newgame\n"
         "\tor\n"
         "\t$ mm --newgame x y \n"
         "\tor\n"
         "\t$ mm --newgame x y mines\n"
         "\tor\n"
         "\t$ mm --newgame x y --diff 0,1,2,3-10\n"
         "print game grid\n"
         "\t$ mm -p \n"
         "\tor\n"
         "\t$ mm -p --noflags\n"
         "set flag tiles\n"
         "\t$ mm -f x y\tset or remove flag\n"
         "\tor\n"
         "\t$ mm -f x y 'c'\tset flag charactor\n"
         "uncover tiles\n"
         "\t$ mm -u x y \n");
}


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

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

LLVM IR (-O0):
@.str = [404 x i8] c"Mine Miner Help\0ANote: This game is not yet completed.\0ANote: Some arguments listed do not work at the moment.\0Astart a new game\0A\09$ mm --newgame\0A\09or\0A\09$ mm --newgame x y \0A\09or\0A\09$ mm --newgame x y mines\0A\09or\0A\09$ mm --newgame x y --diff 0,1,2,3-10\0Aprint game grid\0A\09$ mm -p \0A\09or\0A\09$ mm -p --noflags\0Aset flag tiles\0A\09$ mm -f x y\09set or remove flag\0A\09or\0A\09$ mm -f x y 'c'\09set flag charactor\0Auncover tiles\0A\09$ mm -u x y \0A\00"
define void @printHelp() {
%1 = call i32 @printf(i8* getelementptr inbounds ([404 x i8], [404 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@str = [403 x i8] c"Mine Miner Help\0ANote: This game is not yet completed.\0ANote: Some arguments listed do not work at the moment.\0Astart a new game\0A\09$ mm --newgame\0A\09or\0A\09$ mm --newgame x y \0A\09or\0A\09$ mm --newgame x y mines\0A\09or\0A\09$ mm --newgame x y --diff 0,1,2,3-10\0Aprint game grid\0A\09$ mm -p \0A\09or\0A\09$ mm -p --noflags\0Aset flag tiles\0A\09$ mm -f x y\09set or remove flag\0A\09or\0A\09$ mm -f x y 'c'\09set flag charactor\0Auncover tiles\0A\09$ mm -u x y \00"
define void @printHelp() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([403 x i8], [403 x i8]* @str, i64 0, i64 0))
ret void
}
void _Parse_lsda(void) {}


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

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

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

LLVM IR (-O2):
define void @_Parse_lsda() {
ret void
}
/* Variables and functions */
char *iso_dirid(char const *, int, int /*<<< orphan*/);
char *iso_2_dirid(const char *src) { return iso_dirid(src, 31, 0); }


x86 assembly (clang, -O0):
<iso_2_dirid>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
mov    $0x1f,%esi
xor    %edx,%edx
call   1030 <iso_dirid@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<iso_2_dirid>:
mov    $0x1f,%esi
xor    %edx,%edx
jmp    1030 <iso_dirid@plt>

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

LLVM IR (-O2):
define i8* @iso_2_dirid(i8* %0) {
%2 = tail call i8* @iso_dirid(i8* %0, i32 31, i32 0)
ret i8* %2
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, ...);
void display(int arr[], int size) {
  int i;
  for (i = 0; i < size; i++)
    printf("%4d", arr[i]);
  printf("\n");
}


x86 assembly (clang, -O0):
<display>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1159 <display+0x49>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xebc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1126 <display+0x16>
lea    0xea4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<display>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
test   %esi,%esi
jle    1157 <display+0x37>
mov    %rdi,%r15
mov    %esi,%r12d
lea    0xec7(%rip),%r14
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1140 <display+0x20>
mov    $0xa,%edi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1030 <putchar@plt>

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

LLVM IR (-O2):
@.str = [4 x i8] c"%4d\00"
define void @display(i32* nocapture %0, i32 %1) {
%3 = icmp sgt i32 %1, 0
br i1 %3, label %4, label %13
4: ; preds = %2
%5 = zext i32 %1 to i64
br label %6
6: ; preds = %4, %6
%7 = phi i64 [ 0, %4 ], [ %11, %6 ]
%8 = getelementptr inbounds i32, i32* %0, i64 %7
%9 = load i32, i32* %8
%10 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %9)
%11 = add nuw nsw i64 %7, 1
%12 = icmp eq i64 %11, %5
br i1 %12, label %13, label %6
13: ; preds = %6, %2
%14 = tail call i32 @putchar(i32 10)
ret void
}
int SteamAPI_ISteamFriends_GetFriendsGroupCount(void *self) {
  xlogf("%s(self = %p)\n", __func__, self);
  return 0;
}


x86 assembly (clang, -O0):
<SteamAPI_ISteamFriends_GetFriendsGroupCount>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdx
lea    0xed9(%rip),%rdi
lea    0xee1(%rip),%rsi
mov    $0x0,%al
call   1030 <xlogf@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SteamAPI_ISteamFriends_GetFriendsGroupCount>:
push   %rax
mov    %rdi,%rdx
lea    0xee5(%rip),%rdi
lea    0xeed(%rip),%rsi
xor    %eax,%eax
call   1030 <xlogf@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [15 x i8] c"%s(self = %p)\0A\00"
@__func__.SteamAPI_ISteamFriends_GetFriendsGroupCount = [44 x i8] c"SteamAPI_ISteamFriends_GetFriendsGroupCount\00"
define i32 @SteamAPI_ISteamFriends_GetFriendsGroupCount(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = call i32 (i8*, i8*, i8*, ...) bitcast (i32 (...)* @xlogf to i32 (i8*, i8*, i8*, ...)*)(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([44 x i8], [44 x i8]* @__func__.SteamAPI_ISteamFriends_GetFriendsGroupCount, i64 0, i64 0), i8* %3)
ret i32 0
}

LLVM IR (-O2):
@.str = [15 x i8] c"%s(self = %p)\0A\00"
@__func__.SteamAPI_ISteamFriends_GetFriendsGroupCount = [44 x i8] c"SteamAPI_ISteamFriends_GetFriendsGroupCount\00"
define i32 @SteamAPI_ISteamFriends_GetFriendsGroupCount(i8* %0) {
%2 = tail call i32 (i8*, i8*, i8*, ...) bitcast (i32 (...)* @xlogf to i32 (i8*, i8*, i8*, ...)*)(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([44 x i8], [44 x i8]* @__func__.SteamAPI_ISteamFriends_GetFriendsGroupCount, i64 0, i64 0), i8* %0)
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ board_from_fen(char *);
int /*<<< orphan*/ printf(char *);
void board_init() {
  if (!board_from_fen(
          "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"))
    printf("Illegal position (FEN) !\n");
}


x86 assembly (clang, -O0):
<board_init>:
push   %rbp
mov    %rsp,%rbp
lea    0xed5(%rip),%rdi
call   1040 <board_from_fen@plt>
cmp    $0x0,%eax
jne    1145 <board_init+0x25>
lea    0xef9(%rip),%rdi
call   1030 <printf@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<board_init>:
push   %rax
lea    0xed8(%rip),%rdi
call   1040 <board_from_fen@plt>
test   %eax,%eax
je     1133 <board_init+0x13>
pop    %rax
ret
lea    0xeff(%rip),%rdi
pop    %rax
jmp    1030 <puts@plt>

LLVM IR (-O0):
@.str = [57 x i8] c"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1\00"
@.str.1 = [26 x i8] c"Illegal position (FEN) !\0A\00"
define void @board_init() {
%1 = call i32 @board_from_fen(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str, i64 0, i64 0))
%2 = icmp ne i32 %1, 0
br i1 %2, label %5, label %3
3: ; preds = %0
%4 = call i32 @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0))
br label %5
5: ; preds = %3, %0
ret void
}

LLVM IR (-O2):
@.str = [57 x i8] c"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1\00"
@str = [25 x i8] c"Illegal position (FEN) !\00"
define void @board_init() {
%1 = tail call i32 @board_from_fen(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str, i64 0, i64 0))
%2 = icmp eq i32 %1, 0
br i1 %2, label %3, label %5
3: ; preds = %0
%4 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str, i64 0, i64 0))
br label %5
5: ; preds = %3, %0
ret void
}
/* Variables and functions */
int /*<<< orphan*/ dispatch(long);
int male_indirect_jump(long offset) {
  dispatch(offset);
  return 0;
}


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

x86 assembly (clang, -O2):
<male_indirect_jump>:
push   %rax
call   1030 <dispatch@plt>
xor    %eax,%eax
pop    %rcx
ret

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

LLVM IR (-O2):
define i32 @male_indirect_jump(i64 %0) {
%2 = tail call i32 @dispatch(i64 %0)
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ printf(char *, char *);
void shauth_client_usage(char *program_name) {
  printf(" usage: %s mode url ckey tkey csec tsec\n", program_name);
  exit(1);
}


x86 assembly (clang, -O0):
<shauth_client_usage>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rsi
lea    0xec9(%rip),%rdi
call   1030 <printf@plt>
mov    $0x1,%edi
call   1040 <exit@plt>

x86 assembly (clang, -O2):
<shauth_client_usage>:
push   %rax
mov    %rdi,%rsi
lea    0xed5(%rip),%rdi
call   1030 <printf@plt>
mov    $0x1,%edi
call   1040 <exit@plt>

LLVM IR (-O0):
@.str = [41 x i8] c" usage: %s mode url ckey tkey csec tsec\0A\00"
define void @shauth_client_usage(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i8* %3)
%5 = call i32 @exit(i32 1)
unreachable
}

LLVM IR (-O2):
@.str = [41 x i8] c" usage: %s mode url ckey tkey csec tsec\0A\00"
define void @shauth_client_usage(i8* %0) {
%2 = tail call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i8* %0)
%3 = tail call i32 @exit(i32 1)
unreachable
}
/* Variables and functions */
int /*<<< orphan*/ trap_SendConsoleCommand(char *);
void CG_TauntDeathInsult_f(void) {
  trap_SendConsoleCommand("cmd vsay death_insult\n");
}


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

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

LLVM IR (-O0):
@.str = [23 x i8] c"cmd vsay death_insult\0A\00"
define void @CG_TauntDeathInsult_f() {
%1 = call i32 @trap_SendConsoleCommand(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [23 x i8] c"cmd vsay death_insult\0A\00"
define void @CG_TauntDeathInsult_f() {
%1 = tail call i32 @trap_SendConsoleCommand(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0))
ret void
}
/* Variables and functions */
int O_CREAT;
int O_NDELAY;
int O_TRUNC;
int O_WRONLY;
int open(char *, int, int);
int open_trunc(char *fn) {
  return open(fn, O_WRONLY | O_NDELAY | O_TRUNC | O_CREAT, 0644);
}


x86 assembly (clang, -O0):
<open_trunc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
mov    0x2e99(%rip),%rax
mov    (%rax),%esi
mov    0x2ea0(%rip),%rax
or     (%rax),%esi
mov    0x2eb7(%rip),%rax
or     (%rax),%esi
mov    0x2eb6(%rip),%rax
or     (%rax),%esi
mov    $0x1a4,%edx
call   1030 <open@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<open_trunc>:
mov    0x2ea9(%rip),%rax
mov    0x2eb2(%rip),%rcx
mov    (%rcx),%esi
or     (%rax),%esi
mov    0x2ec7(%rip),%rax
or     (%rax),%esi
mov    0x2ec6(%rip),%rax
or     (%rax),%esi
mov    $0x1a4,%edx
jmp    1030 <open@plt>

LLVM IR (-O0):
@O_WRONLY = global i32 0
@O_NDELAY = global i32 0
@O_TRUNC = global i32 0
@O_CREAT = global i32 0
define i32 @open_trunc(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = load i32, i32* @O_WRONLY
%5 = load i32, i32* @O_NDELAY
%6 = or i32 %4, %5
%7 = load i32, i32* @O_TRUNC
%8 = or i32 %6, %7
%9 = load i32, i32* @O_CREAT
%10 = or i32 %8, %9
%11 = call i32 @open(i8* %3, i32 %10, i32 420)
ret i32 %11
}

LLVM IR (-O2):
@O_WRONLY = global i32 0
@O_NDELAY = global i32 0
@O_TRUNC = global i32 0
@O_CREAT = global i32 0
define i32 @open_trunc(i8* nocapture %0) {
%2 = load i32, i32* @O_WRONLY
%3 = load i32, i32* @O_NDELAY
%4 = or i32 %3, %2
%5 = load i32, i32* @O_TRUNC
%6 = or i32 %4, %5
%7 = load i32, i32* @O_CREAT
%8 = or i32 %6, %7
%9 = tail call i32 @open(i8* %0, i32 %8, i32 420)
ret i32 %9
}
/* Variables and functions */
double __floatunsidf(unsigned long);
float __floatunsisf(unsigned long l) {
  double foo = __floatunsidf(l);
  return foo;
}


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

x86 assembly (clang, -O2):
<__floatunsisf>:
push   %rax
call   1030 <__floatunsidf@plt>
cvtsd2ss %xmm0,%xmm0
pop    %rax
ret

LLVM IR (-O0):
define float @__floatunsisf(i64 %0) {
%2 = alloca i64
%3 = alloca double
store i64 %0, i64* %2
%4 = load i64, i64* %2
%5 = call double @__floatunsidf(i64 %4)
store double %5, double* %3
%6 = load double, double* %3
%7 = fptrunc double %6 to float
ret float %7
}

LLVM IR (-O2):
define float @__floatunsisf(i64 %0) {
%2 = tail call double @__floatunsidf(i64 %0)
%3 = fptrunc double %2 to float
ret float %3
}
/* Variables and functions */
int /*<<< orphan*/ usock_cleanup();
void cl_cleanup(void) { usock_cleanup(); }


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

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

LLVM IR (-O0):
define void @cl_cleanup() {
%1 = call i32 (...) @usock_cleanup()
ret void
}

LLVM IR (-O2):
define void @cl_cleanup() {
%1 = tail call i32 (...) @usock_cleanup()
ret void
}
int ands_si_test2(int a, int b, int c) {
  int d = a & 0x99999999;
  if (d <= 0)
    return a + c;
  else
    return b + d + c;
}


x86 assembly (clang, -O0):
<ands_si_test2>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x8(%rbp),%eax
and    $0x99999999,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jg     1130 <ands_si_test2+0x30>
mov    -0x8(%rbp),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    113c <ands_si_test2+0x3c>
mov    -0xc(%rbp),%eax
add    -0x14(%rbp),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<ands_si_test2>:
mov    %edi,%ecx
and    $0x99999999,%ecx
lea    (%rsi,%rcx,1),%eax
test   %ecx,%ecx
cmovle %edi,%eax
add    %edx,%eax
ret

LLVM IR (-O0):
define i32 @ands_si_test2(i32 %0, i32 %1, i32 %2) {
%4 = alloca i32
%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
%9 = load i32, i32* %5
%10 = and i32 %9, -1717986919
store i32 %10, i32* %8
%11 = load i32, i32* %8
%12 = icmp sle i32 %11, 0
br i1 %12, label %13, label %17
13: ; preds = %3
%14 = load i32, i32* %5
%15 = load i32, i32* %7
%16 = add nsw i32 %14, %15
store i32 %16, i32* %4
br label %23
17: ; preds = %3
%18 = load i32, i32* %6
%19 = load i32, i32* %8
%20 = add nsw i32 %18, %19
%21 = load i32, i32* %7
%22 = add nsw i32 %20, %21
store i32 %22, i32* %4
br label %23
23: ; preds = %17, %13
%24 = load i32, i32* %4
ret i32 %24
}

LLVM IR (-O2):
define i32 @ands_si_test2(i32 %0, i32 %1, i32 %2) {
%4 = and i32 %0, -1717986919
%5 = icmp slt i32 %4, 1
%6 = add nsw i32 %4, %1
%7 = select i1 %5, i32 %0, i32 %6
%8 = add nsw i32 %7, %2
ret i32 %8
}
/* Variables and functions */
float fgamma_sf(int, float);
float fgamma_steedf(int, float);
float fgammaf(int m, float x) {
  if (x < (m + 0.5))
    return fgamma_sf(m, x);
  else
    return fgamma_steedf(m, x);
}


x86 assembly (clang, -O0):
<fgammaf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
cvtsi2sdl -0x8(%rbp),%xmm0
movsd  0xeba(%rip),%xmm2
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    116b <fgammaf+0x4b>
mov    -0x8(%rbp),%edi
movss  -0xc(%rbp),%xmm0
call   1040 <fgamma_sf@plt>
movss  %xmm0,-0x4(%rbp)
jmp    117d <fgammaf+0x5d>
mov    -0x8(%rbp),%edi
movss  -0xc(%rbp),%xmm0
call   1030 <fgamma_steedf@plt>
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fgammaf>:
cvtss2sd %xmm0,%xmm1
cvtsi2sd %edi,%xmm2
addsd  0xed0(%rip),%xmm2
ucomisd %xmm1,%xmm2
jbe    113b <fgammaf+0x1b>
jmp    1040 <fgamma_sf@plt>
jmp    1030 <fgamma_steedf@plt>

LLVM IR (-O0):
define float @fgammaf(i32 %0, float %1) {
%3 = alloca float
%4 = alloca i32
%5 = alloca float
store i32 %0, i32* %4
store float %1, float* %5
%6 = load float, float* %5
%7 = fpext float %6 to double
%8 = load i32, i32* %4
%9 = sitofp i32 %8 to double
%10 = fadd double %9, 5.000000e-01
%11 = fcmp olt double %7, %10
br i1 %11, label %12, label %16
12: ; preds = %2
%13 = load i32, i32* %4
%14 = load float, float* %5
%15 = call float @fgamma_sf(i32 %13, float %14)
store float %15, float* %3
br label %20
16: ; preds = %2
%17 = load i32, i32* %4
%18 = load float, float* %5
%19 = call float @fgamma_steedf(i32 %17, float %18)
store float %19, float* %3
br label %20
20: ; preds = %16, %12
%21 = load float, float* %3
ret float %21
}

LLVM IR (-O2):
define float @fgammaf(i32 %0, float %1) {
%3 = fpext float %1 to double
%4 = sitofp i32 %0 to double
%5 = fadd double %4, 5.000000e-01
%6 = fcmp ogt double %5, %3
br i1 %6, label %7, label %9
7: ; preds = %2
%8 = tail call float @fgamma_sf(i32 %0, float %1)
br label %11
9: ; preds = %2
%10 = tail call float @fgamma_steedf(i32 %0, float %1)
br label %11
11: ; preds = %9, %7
%12 = phi float [ %8, %7 ], [ %10, %9 ]
ret float %12
}
void X509_signature_print(void) {}


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

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

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

LLVM IR (-O2):
define void @X509_signature_print() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ gmx_analyze(int, char **);
int main(int argc, char *argv[]) {
  gmx_analyze(argc, argv);
  return 0;
}


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 <gmx_analyze@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
call   1030 <gmx_analyze@plt>
xor    %eax,%eax
pop    %rcx
ret

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 @gmx_analyze(i32 %6, i8** %7)
ret i32 0
}

LLVM IR (-O2):
define i32 @main(i32 %0, i8** %1) {
%3 = tail call i32 @gmx_analyze(i32 %0, i8** %1)
ret i32 0
}
/* Forward declarations */
typedef struct TYPE_2__ TYPE_1__;

/* Type definitions */
struct TYPE_2__ {
  scalar_t__ root;
};
typedef TYPE_1__ XButtonPressedEvent;

/* Variables and functions */
unsigned long get_XButtonPressedEvent_root(void *_p) {
  return (unsigned long)((XButtonPressedEvent *)_p)->root;
}


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

x86 assembly (clang, -O2):
<get_XButtonPressedEvent_root>:
mov    (%rdi),%rax
ret

LLVM IR (-O0):
%struct.TYPE_2__ = type { i64 }
define i64 @get_XButtonPressedEvent_root(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = bitcast i8* %3 to %struct.TYPE_2__*
%5 = getelementptr inbounds %struct.TYPE_2__, %struct.TYPE_2__* %4, i32 0, i32 0
%6 = load i64, i64* %5
ret i64 %6
}

LLVM IR (-O2):
define i64 @get_XButtonPressedEvent_root(i8* nocapture %0) {
%2 = bitcast i8* %0 to i64*
%3 = load i64, i64* %2
ret i64 %3
}
/* Variables and functions */
void *malloc_func(size_t);
void *default_malloc_ex(size_t num, const char *file, int line) {
  return malloc_func(num);
}


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

x86 assembly (clang, -O2):
<default_malloc_ex>:
jmp    1030 <malloc_func@plt>

LLVM IR (-O0):
define i8* @default_malloc_ex(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 = call i8* @malloc_func(i64 %7)
ret i8* %8
}

LLVM IR (-O2):
define i8* @default_malloc_ex(i64 %0, i8* nocapture readnone %1, i32 %2) {
%4 = tail call i8* @malloc_func(i64 %0)
ret i8* %4
}
/* Variables and functions */
short math___Float_is_nan___impl(double);
short int core__math___Float___is_nan(double self) {
  short int var;
  short int var1;
  var1 = math___Float_is_nan___impl(self);
  var = var1;
  goto RET_LABEL;
RET_LABEL:;
  return var;
}


x86 assembly (clang, -O0):
<core__math___Float___is_nan>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
call   1030 <math___Float_is_nan___impl@plt>
mov    %ax,-0xc(%rbp)
mov    -0xc(%rbp),%ax
mov    %ax,-0xa(%rbp)
movswl -0xa(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<core__math___Float___is_nan>:
jmp    1030 <math___Float_is_nan___impl@plt>

LLVM IR (-O0):
define signext i16 @core__math___Float___is_nan(double %0) {
%2 = alloca double
%3 = alloca i16
%4 = alloca i16
store double %0, double* %2
%5 = load double, double* %2
%6 = call signext i16 @math___Float_is_nan___impl(double %5)
store i16 %6, i16* %4
%7 = load i16, i16* %4
store i16 %7, i16* %3
br label %8
8: ; preds = %1
%9 = load i16, i16* %3
ret i16 %9
}

LLVM IR (-O2):
define signext i16 @core__math___Float___is_nan(double %0) {
%2 = tail call signext i16 @math___Float_is_nan___impl(double %0)
ret i16 %2
}
/* Type definitions */
typedef int /*<<< orphan*/ uint32_t;

/* Variables and functions */
void set_keypair_addr(uint32_t addr[8], uint32_t keypair) { addr[5] = keypair; }


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

x86 assembly (clang, -O2):
<set_keypair_addr>:
mov    %esi,0x14(%rdi)
ret

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

LLVM IR (-O2):
define void @set_keypair_addr(i32* nocapture writeonly %0, i32 %1) {
%3 = getelementptr inbounds i32, i32* %0, i64 5
store i32 %1, i32* %3
ret void
}
/* Type definitions */
typedef int off_t;

/* Variables and functions */
bool is_mmc_device(off_t device_size) {
  if (device_size == 0)
    return false;
  if (device_size > (32 * (1024 * (1024 * (1024LL)))))
    return false;
  return true;
}


x86 assembly (clang, -O0):
<is_mmc_device>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x8(%rbp)
cmpl   $0x0,-0x8(%rbp)
jne    111d <is_mmc_device+0x1d>
movl   $0x0,-0x4(%rbp)
jmp    1147 <is_mmc_device+0x47>
movslq -0x8(%rbp),%rax
movabs $0x800000000,%rcx
cmp    %rcx,%rax
jle    1140 <is_mmc_device+0x40>
movl   $0x0,-0x4(%rbp)
jmp    1147 <is_mmc_device+0x47>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<is_mmc_device>:
xor    %eax,%eax
test   %edi,%edi
setne  %al
ret

LLVM IR (-O0):
define i32 @is_mmc_device(i32 %0) {
%2 = alloca i32
%3 = alloca i32
store i32 %0, i32* %3
%4 = load i32, i32* %3
%5 = icmp eq i32 %4, 0
br i1 %5, label %6, label %7
6: ; preds = %1
store i32 0, i32* %2
br label %13
7: ; preds = %1
%8 = load i32, i32* %3
%9 = sext i32 %8 to i64
%10 = icmp sgt i64 %9, 34359738368
br i1 %10, label %11, label %12
11: ; preds = %7
store i32 0, i32* %2
br label %13
12: ; preds = %7
store i32 1, i32* %2
br label %13
13: ; preds = %12, %11, %6
%14 = load i32, i32* %2
ret i32 %14
}

LLVM IR (-O2):
define i32 @is_mmc_device(i32 %0) {
%2 = icmp ne i32 %0, 0
%3 = zext i1 %2 to i32
ret i32 %3
}