xunge/DecIR huggingface dataset:
int c039(void) { return 0; }


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

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

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

LLVM IR (-O2):
define i32 @c039() {
ret i32 0
}
void display_blink_slow(void) {}


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

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

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

LLVM IR (-O2):
define void @display_blink_slow() {
ret void
}
void function_empty_est_time() {}


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

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

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

LLVM IR (-O2):
define void @function_empty_est_time() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ closeKey();
void stopPowerPackUserOperation(void) { closeKey(); }


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

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

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

LLVM IR (-O2):
define void @stopPowerPackUserOperation() {
%1 = tail call i32 (...) @closeKey()
ret void
}
/* Variables and functions */
int /*<<< orphan*/ write(int, char *, int);
void wipe_line(void) { write(1, "                                ", 31); }


x86 assembly (clang, -O0):
<wipe_line>:
push   %rbp
mov    %rsp,%rbp
mov    $0x1,%edi
lea    0xee0(%rip),%rsi
mov    $0x1f,%edx
call   1030 <write@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<wipe_line>:
lea    0xee9(%rip),%rsi
mov    $0x1,%edi
mov    $0x1f,%edx
jmp    1030 <write@plt>

LLVM IR (-O0):
@.str = [33 x i8] c" \00"
define void @wipe_line() {
%1 = call i32 @write(i32 1, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0), i32 31)
ret void
}

LLVM IR (-O2):
@.str = [33 x i8] c" \00"
define void @wipe_line() {
%1 = tail call i32 @write(i32 1, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0), i32 31)
ret void
}
void __attribute__((always_))
bss_init(unsigned int *section_begin, unsigned int *section_end) {
  unsigned int *p = section_begin;
  while (p < section_end)
    *p++ = 0;
}


x86 assembly (clang, -O0):
<bss_init>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    113c <bss_init+0x3c>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movl   $0x0,(%rax)
jmp    1114 <bss_init+0x14>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bss_init>:
cmp    %rsi,%rdi
jae    113e <bss_init+0x2e>
push   %rax
lea    0x4(%rdi),%rax
cmp    %rax,%rsi
cmova  %rsi,%rax
mov    %rdi,%rcx
not    %rcx
lea    (%rax,%rcx,1),%rdx
add    $0x4,%rdx
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
add    $0x8,%rsp
ret

LLVM IR (-O0):
define void @bss_init(i32* %0, i32* %1) {
%3 = alloca i32*
%4 = alloca i32*
%5 = alloca i32*
store i32* %0, i32** %3
store i32* %1, i32** %4
%6 = load i32*, i32** %3
store i32* %6, i32** %5
br label %7
7: ; preds = %11, %2
%8 = load i32*, i32** %5
%9 = load i32*, i32** %4
%10 = icmp ult i32* %8, %9
br i1 %10, label %11, label %14
11: ; preds = %7
%12 = load i32*, i32** %5
%13 = getelementptr inbounds i32, i32* %12, i32 1
store i32* %13, i32** %5
store i32 0, i32* %12
br label %7
14: ; preds = %7
ret void
}

LLVM IR (-O2):
define void @bss_init(i32* writeonly %0, i32* readnone %1) {
%3 = ptrtoint i32* %0 to i64
%4 = icmp ult i32* %0, %1
br i1 %4, label %5, label %14
5: ; preds = %2
%6 = ptrtoint i32* %1 to i64
%7 = bitcast i32* %0 to i8*
%8 = add i64 %3, 4
%9 = call i64 @llvm.umax.i64(i64 %6, i64 %8)
%10 = xor i64 %3, -1
%11 = add i64 %9, %10
%12 = add i64 %11, 4
%13 = and i64 %12, -4
br label %14
14: ; preds = %5, %2
ret void
}
/* Variables and functions */
int i2c_smbus_write_byte(int, int);
int raspberrypiI2CWrite(int fd, int data) {
  return i2c_smbus_write_byte(fd, data);
}


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

x86 assembly (clang, -O2):
<raspberrypiI2CWrite>:
jmp    1030 <i2c_smbus_write_byte@plt>

LLVM IR (-O0):
define i32 @raspberrypiI2CWrite(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 = call i32 @i2c_smbus_write_byte(i32 %5, i32 %6)
ret i32 %7
}

LLVM IR (-O2):
define i32 @raspberrypiI2CWrite(i32 %0, i32 %1) {
%3 = tail call i32 @i2c_smbus_write_byte(i32 %0, i32 %1)
ret i32 %3
}
void yy_1_ClosingTagHeader(char *yytext, int yyleng) {
  ;
  ;
}


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

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

LLVM IR (-O0):
define void @yy_1_ClosingTagHeader(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
store i8* %0, i8** %3
store i32 %1, i32* %4
ret void
}

LLVM IR (-O2):
define void @yy_1_ClosingTagHeader(i8* nocapture %0, i32 %1) {
ret void
}
/* Variables and functions */
bool nrf52_errata_190(void) { return false; }


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

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

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

LLVM IR (-O2):
define i32 @nrf52_errata_190() {
ret i32 0
}
int squashfs_xattr_lookup(struct super_block *sb, unsigned int index,
                          int *count, int *size, unsigned long long *xattr) {
  return 0;
}


x86 assembly (clang, -O0):
<squashfs_xattr_lookup>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
xor    %eax,%eax
pop    %rbp
ret

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

LLVM IR (-O0):
%struct.super_block = type opaque
define i32 @squashfs_xattr_lookup(%struct.super_block* %0, i32 %1, i32* %2, i32* %3, i64* %4) {
%6 = alloca %struct.super_block*
%7 = alloca i32
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca i64*
store %struct.super_block* %0, %struct.super_block** %6
store i32 %1, i32* %7
store i32* %2, i32** %8
store i32* %3, i32** %9
store i64* %4, i64** %10
ret i32 0
}

LLVM IR (-O2):
%struct.super_block = type opaque
define i32 @squashfs_xattr_lookup(%struct.super_block* nocapture readnone %0, i32 %1, i32* nocapture readnone %2, i32* nocapture readnone %3, i64* nocapture readnone %4) {
ret i32 0
}
/* Variables and functions */
int strlen(char *);
int is_ascii(char *contents) {
  int i;
  for (i = 0; i < strlen(contents); i++) {
    if (contents[i] > 127) {
      return -1;
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<is_ascii>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%eax
cmp    %ecx,%eax
jge    1173 <is_ascii+0x63>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7f,%eax
jle    1160 <is_ascii+0x50>
movl   $0xffffffff,-0x4(%rbp)
jmp    117a <is_ascii+0x6a>
jmp    1165 <is_ascii+0x55>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1123 <is_ascii+0x13>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<is_ascii>:
push   %rbp
push   %rbx
push   %rax
mov    %rdi,%rbx
mov    $0xffffffff,%ebp
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
call   1030 <strlen@plt>
add    $0x1,%ebp
cmp    %eax,%ebp
jl     1120 <is_ascii+0x10>
mov    $0x1,%eax
add    $0x8,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define i32 @is_ascii(i8* %0) {
%2 = alloca i32
%3 = alloca i8*
%4 = alloca i32
store i8* %0, i8** %3
store i32 0, i32* %4
br label %5
5: ; preds = %20, %1
%6 = load i32, i32* %4
%7 = load i8*, i8** %3
%8 = call i32 @strlen(i8* %7)
%9 = icmp slt i32 %6, %8
br i1 %9, label %10, label %23
10: ; preds = %5
%11 = load i8*, i8** %3
%12 = load i32, i32* %4
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds i8, i8* %11, i64 %13
%15 = load i8, i8* %14
%16 = sext i8 %15 to i32
%17 = icmp sgt i32 %16, 127
br i1 %17, label %18, label %19
18: ; preds = %10
store i32 -1, i32* %2
br label %24
19: ; preds = %10
br label %20
20: ; preds = %19
%21 = load i32, i32* %4
%22 = add nsw i32 %21, 1
store i32 %22, i32* %4
br label %5
23: ; preds = %5
store i32 1, i32* %2
br label %24
24: ; preds = %23, %18
%25 = load i32, i32* %2
ret i32 %25
}

LLVM IR (-O2):
define i32 @is_ascii(i8* %0) {
br label %2
2: ; preds = %2, %1
%3 = phi i32 [ 0, %1 ], [ %6, %2 ]
%4 = tail call i32 @strlen(i8* %0)
%5 = icmp slt i32 %3, %4
%6 = add nuw nsw i32 %3, 1
br i1 %5, label %2, label %7
7: ; preds = %2
ret i32 1
}
/* Variables and functions */
int /*<<< orphan*/ umfpack_dl_defaults(double *);
void umf4def(double Control[20]) { umfpack_dl_defaults(Control); }


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

x86 assembly (clang, -O2):
<umf4def>:
jmp    1030 <umfpack_dl_defaults@plt>

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

LLVM IR (-O2):
define void @umf4def(double* %0) {
%2 = tail call i32 @umfpack_dl_defaults(double* %0)
ret void
}
int assign_user_entity_token() { return 1; }


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

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

LLVM IR (-O0):
define i32 @assign_user_entity_token() {
ret i32 1
}

LLVM IR (-O2):
define i32 @assign_user_entity_token() {
ret i32 1
}
/* Variables and functions */
unsigned char *cbor_write_nlong(unsigned char *, unsigned int,
                                unsigned long long);
unsigned char *cbor_write_plong(unsigned char *, unsigned int,
                                unsigned long long);
unsigned char *cbor_write_long(unsigned char *data, unsigned int size,
                               long long value) {
  if (value < 0) {
    return cbor_write_nlong(data, size, (unsigned long long)(-value));
  } else {
    return cbor_write_plong(data, size, (unsigned long long)(value));
  }
}


x86 assembly (clang, -O0):
<cbor_write_long>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jge    115b <cbor_write_long+0x3b>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
xor    %eax,%eax
mov    %eax,%edx
sub    -0x20(%rbp),%rdx
call   1030 <cbor_write_nlong@plt>
mov    %rax,-0x8(%rbp)
jmp    116f <cbor_write_long+0x4f>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x20(%rbp),%rdx
call   1040 <cbor_write_plong@plt>
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cbor_write_long>:
test   %rdx,%rdx
js     112a <cbor_write_long+0xa>
jmp    1040 <cbor_write_plong@plt>
neg    %rdx
jmp    1030 <cbor_write_nlong@plt>

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

LLVM IR (-O2):
define i8* @cbor_write_long(i8* %0, i32 %1, i64 %2) {
%4 = icmp slt i64 %2, 0
br i1 %4, label %5, label %8
5: ; preds = %3
%6 = sub nsw i64 0, %2
%7 = tail call i8* @cbor_write_nlong(i8* %0, i32 %1, i64 %6)
br label %10
8: ; preds = %3
%9 = tail call i8* @cbor_write_plong(i8* %0, i32 %1, i64 %2)
br label %10
10: ; preds = %8, %5
%11 = phi i8* [ %7, %5 ], [ %9, %8 ]
ret i8* %11
}
void guruplug_dt_init(void) {}


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

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

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

LLVM IR (-O2):
define void @guruplug_dt_init() {
ret void
}
void BusFault_Handler(void) {
  ;
  while (1) {
  }
}


x86 assembly (clang, -O0):
<BusFault_Handler>:
push   %rbp
mov    %rsp,%rbp
jmp    1109 <BusFault_Handler+0x9>
jmp    1109 <BusFault_Handler+0x9>

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

LLVM IR (-O0):
define void @BusFault_Handler() {
br label %1
1: ; preds = %0, %1
br label %1
}

LLVM IR (-O2):
define void @BusFault_Handler() {
br label %1
1: ; preds = %0, %1
br label %1
}
__attribute__((always_)) int ddebug_remove_module(char *mod) { return 0; }


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

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

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

LLVM IR (-O2):
define i32 @ddebug_remove_module(i8* nocapture readnone %0) {
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ closelog();
void xyz_log_close(void) {
  closelog();
  return;
}


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

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

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

LLVM IR (-O2):
define void @xyz_log_close() {
%1 = tail call i32 (...) @closelog()
ret void
}
/* Variables and functions */
int /*<<< orphan*/ U000000e9();
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int main(void) {
  \U000000e9();
  exit(0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1040 <é@plt>
xor    %edi,%edi
call   1030 <exit@plt>

x86 assembly (clang, -O2):
<main>:
push   %rax
xor    %eax,%eax
call   1040 <é@plt>
xor    %edi,%edi
call   1030 <exit@plt>

LLVM IR (-O0):
define i32 @main() {
%1 = alloca i32
store i32 0, i32* %1
%2 = call i32 (...) @"\C3\A9"()
%3 = call i32 @exit(i32 0)
unreachable
}

LLVM IR (-O2):
define i32 @main() {
%1 = tail call i32 (...) @"\C3\A9"()
%2 = tail call i32 @exit(i32 0)
unreachable
}
/* Variables and functions */
int /*<<< orphan*/ sscanf(char *, char *, int *);
int build_year() {
  int year;
  sscanf("Mar 17 2022", "%*s %*d %d", &year);
  return year;
}


x86 assembly (clang, -O0):
<build_year>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
lea    0xee1(%rip),%rdi
lea    0xee6(%rip),%rsi
lea    -0x4(%rbp),%rdx
call   1030 <sscanf@plt>
mov    -0x4(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<build_year>:
push   %rax
lea    0xee8(%rip),%rdi
lea    0xeed(%rip),%rsi
lea    0x4(%rsp),%rdx
call   1030 <sscanf@plt>
mov    0x4(%rsp),%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [12 x i8] c"Mar 17 2022\00"
@.str.1 = [11 x i8] c"%*s %*d %d\00"
define i32 @build_year() {
%1 = alloca i32
%2 = call i32 @sscanf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0), i32* %1)
%3 = load i32, i32* %1
ret i32 %3
}

LLVM IR (-O2):
@.str = [12 x i8] c"Mar 17 2022\00"
@.str.1 = [11 x i8] c"%*s %*d %d\00"
define i32 @build_year() {
%1 = alloca i32
%2 = bitcast i32* %1 to i8*
%3 = call i32 @sscanf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0), i32* %1)
%4 = load i32, i32* %1
ret i32 %4
}
void gf8mul_00010001(void) {
  __asm__ __volatile__("\tpxor    %xmm7, %xmm5\n"
                       "\tpxor    %xmm7, %xmm4\n"
                       "\tpxor    %xmm7, %xmm3\n"
                       "\tpxor    %xmm7, %xmm2\n"
                       "\tpxor    %xmm7, %xmm1\n"
                       "\tpxor    %xmm7, %xmm0\n"
                       "\tpxor    %xmm6, %xmm7\n"
                       "\tpxor    %xmm6, %xmm5\n"
                       "\tpxor    %xmm6, %xmm3\n"
                       "\tpxor    %xmm6, %xmm2\n"
                       "\tpxor    %xmm6, %xmm1\n"
                       "\tpxor    %xmm5, %xmm6\n"
                       "\tpxor    %xmm5, %xmm4\n"
                       "\tpxor    %xmm5, %xmm2\n"
                       "\tpxor    %xmm5, %xmm1\n"
                       "\tpxor    %xmm5, %xmm0\n"
                       "\tpxor    %xmm4, %xmm7\n"
                       "\tpxor    %xmm4, %xmm6\n"
                       "\tpxor    %xmm4, %xmm3\n"
                       "\tpxor    %xmm4, %xmm2\n"
                       "\tpxor    %xmm4, %xmm0\n"
                       "\tpxor    %xmm3, %xmm7\n"
                       "\tpxor    %xmm2, %xmm6\n"
                       "\tpxor    %xmm1, %xmm5\n"
                       "\tpxor    %xmm0, %xmm4\n");
}


x86 assembly (clang, -O0):
push   %rbp
mov    %rsp,%rbp
pxor   %xmm7,%xmm5
pxor   %xmm7,%xmm4
pxor   %xmm7,%xmm3
pxor   %xmm7,%xmm2
pxor   %xmm7,%xmm1
pxor   %xmm7,%xmm0
pxor   %xmm6,%xmm7
pxor   %xmm6,%xmm5
pxor   %xmm6,%xmm3
pxor   %xmm6,%xmm2
pxor   %xmm6,%xmm1
pxor   %xmm5,%xmm6
pxor   %xmm5,%xmm4
pxor   %xmm5,%xmm2
pxor   %xmm5,%xmm1
pxor   %xmm5,%xmm0
pxor   %xmm4,%xmm7
pxor   %xmm4,%xmm6
pxor   %xmm4,%xmm3
pxor   %xmm4,%xmm2
pxor   %xmm4,%xmm0
pxor   %xmm3,%xmm7
pxor   %xmm2,%xmm6
pxor   %xmm1,%xmm5
pxor   %xmm0,%xmm4
pop    %rbp
ret

x86 assembly (clang, -O2):
pxor   %xmm7,%xmm5
pxor   %xmm7,%xmm4
pxor   %xmm7,%xmm3
pxor   %xmm7,%xmm2
pxor   %xmm7,%xmm1
pxor   %xmm7,%xmm0
pxor   %xmm6,%xmm7
pxor   %xmm6,%xmm5
pxor   %xmm6,%xmm3
pxor   %xmm6,%xmm2
pxor   %xmm6,%xmm1
pxor   %xmm5,%xmm6
pxor   %xmm5,%xmm4
pxor   %xmm5,%xmm2
pxor   %xmm5,%xmm1
pxor   %xmm5,%xmm0
pxor   %xmm4,%xmm7
pxor   %xmm4,%xmm6
pxor   %xmm4,%xmm3
pxor   %xmm4,%xmm2
pxor   %xmm4,%xmm0
pxor   %xmm3,%xmm7
pxor   %xmm2,%xmm6
pxor   %xmm1,%xmm5
pxor   %xmm0,%xmm4
ret

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

LLVM IR (-O2):
define void @gf8mul_00010001() {
tail call void asm sideeffect "\09pxor %xmm7, %xmm5\0A\09pxor %xmm7, %xmm4\0A\09pxor %xmm7, %xmm3\0A\09pxor %xmm7, %xmm2\0A\09pxor %xmm7, %xmm1\0A\09pxor %xmm7, %xmm0\0A\09pxor %xmm6, %xmm7\0A\09pxor %xmm6, %xmm5\0A\09pxor %xmm6, %xmm3\0A\09pxor %xmm6, %xmm2\0A\09pxor %xmm6, %xmm1\0A\09pxor %xmm5, %xmm6\0A\09pxor %xmm5, %xmm4\0A\09pxor %xmm5, %xmm2\0A\09pxor %xmm5, %xmm1\0A\09pxor %xmm5, %xmm0\0A\09pxor %xmm4, %xmm7\0A\09pxor %xmm4, %xmm6\0A\09pxor %xmm4, %xmm3\0A\09pxor %xmm4, %xmm2\0A\09pxor %xmm4, %xmm0\0A\09pxor %xmm3, %xmm7\0A\09pxor %xmm2, %xmm6\0A\09pxor %xmm1, %xmm5\0A\09pxor %xmm0, %xmm4\0A", "~{dirflag},~{fpsr},~{flags}"()
ret void
}
/* Type definitions */
typedef int uint8_t;
typedef int /*<<< orphan*/ uint16_t;

/* Variables and functions */
int /*<<< orphan*/ chr1setBank0(int);
void m32setParamsBXX0(uint16_t addr, uint8_t val) {
  (void)addr;
  chr1setBank0(val << 10);
}


x86 assembly (clang, -O0):
<m32setParamsBXX0>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    -0x8(%rbp),%edi
shl    $0xa,%edi
call   1030 <chr1setBank0@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<m32setParamsBXX0>:
mov    %esi,%edi
shl    $0xa,%edi
jmp    1030 <chr1setBank0@plt>

LLVM IR (-O0):
define void @m32setParamsBXX0(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 = shl i32 %6, 10
%8 = call i32 @chr1setBank0(i32 %7)
ret void
}

LLVM IR (-O2):
define void @m32setParamsBXX0(i32 %0, i32 %1) {
%3 = shl i32 %1, 10
%4 = tail call i32 @chr1setBank0(i32 %3)
ret void
}
void wait_write_lock(int *lk) {
  int acquired = 0;
  do {
    ;
    ;
    if (*lk == 0) {
      *lk = -1;
      acquired = 1;
    };
    ;
  } while (!acquired);
}


x86 assembly (clang, -O0):
<wait_write_lock>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
cmpl   $0x0,(%rax)
jne    112d <wait_write_lock+0x2d>
mov    -0x8(%rbp),%rax
movl   $0xffffffff,(%rax)
movl   $0x1,-0xc(%rbp)
jmp    1132 <wait_write_lock+0x32>
cmpl   $0x0,-0xc(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    110f <wait_write_lock+0xf>
pop    %rbp
ret

x86 assembly (clang, -O2):
<wait_write_lock>:
cmpl   $0x0,(%rdi)
je     1112 <wait_write_lock+0x12>
cs nopw 0x0(%rax,%rax,1)
nop
jmp    1110 <wait_write_lock+0x10>
movl   $0xffffffff,(%rdi)
ret

LLVM IR (-O0):
define void @wait_write_lock(i32* %0) {
%2 = alloca i32*
%3 = alloca i32
store i32* %0, i32** %2
store i32 0, i32* %3
br label %4
4: ; preds = %11, %1
%5 = load i32*, i32** %2
%6 = load i32, i32* %5
%7 = icmp eq i32 %6, 0
br i1 %7, label %8, label %10
8: ; preds = %4
%9 = load i32*, i32** %2
store i32 -1, i32* %9
store i32 1, i32* %3
br label %10
10: ; preds = %8, %4
br label %11
11: ; preds = %10
%12 = load i32, i32* %3
%13 = icmp ne i32 %12, 0
%14 = xor i1 %13, true
br i1 %14, label %4, label %15
15: ; preds = %11
ret void
}

LLVM IR (-O2):
define void @wait_write_lock(i32* nocapture %0) {
%2 = load i32, i32* %0
%3 = icmp eq i32 %2, 0
br i1 %3, label %5, label %4
4: ; preds = %1, %4
br label %4
5: ; preds = %1
store i32 -1, i32* %0
ret void
}
int SoundDev_WriteStereoSamples2(short *buffer, int cnt, int ovcnt) {
  return (0);
}


x86 assembly (clang, -O0):
<SoundDev_WriteStereoSamples2>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
xor    %eax,%eax
pop    %rbp
ret

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

LLVM IR (-O0):
define i32 @SoundDev_WriteStereoSamples2(i16* %0, i32 %1, i32 %2) {
%4 = alloca i16*
%5 = alloca i32
%6 = alloca i32
store i16* %0, i16** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
ret i32 0
}

LLVM IR (-O2):
define i32 @SoundDev_WriteStereoSamples2(i16* nocapture readnone %0, i32 %1, i32 %2) {
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ system(char *);
void clr() { system("clear"); }


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

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

LLVM IR (-O0):
@.str = [6 x i8] c"clear\00"
define void @clr() {
%1 = call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [6 x i8] c"clear\00"
define void @clr() {
%1 = tail call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
ret void
}
void audioRefresh() {}


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

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

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

LLVM IR (-O2):
define void @audioRefresh() {
ret void
}
void ff_hevc_put_hevc_qpel_hv32_8_sse4() {}


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

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

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

LLVM IR (-O2):
define void @ff_hevc_put_hevc_qpel_hv32_8_sse4() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ memset(void *, int /*<<< orphan*/, unsigned long);
unsigned long __xtensa_clear_user(void *addr, unsigned long size) {
  if (!memset(addr, 0, size))
    return size;
  return 0;
}


x86 assembly (clang, -O0):
<__xtensa_clear_user>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rdx
xor    %esi,%esi
call   1030 <memset@plt>
cmp    $0x0,%eax
jne    1145 <__xtensa_clear_user+0x35>
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    114d <__xtensa_clear_user+0x3d>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<__xtensa_clear_user>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
xor    %ebx,%ebx
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
test   %eax,%eax
cmove  %r14,%rbx
mov    %rbx,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define i64 @__xtensa_clear_user(i8* %0, i64 %1) {
%3 = tail call i32 @memset(i8* %0, i32 0, i64 %1)
%4 = icmp eq i32 %3, 0
%5 = select i1 %4, i64 %1, i64 0
ret i64 %5
}
/* Variables and functions */
int /*<<< orphan*/ exit(unsigned long);
int /*<<< orphan*/ printf(char *, int, unsigned long);
__attribute__((__noreturn__)) void exitfunc10(int status, void *arg) {
  printf("Executing exitfunc"
         "10"
         " (status=%d, arg=%lu)\n",
         status, (unsigned long)arg);
  exit((unsigned long)arg);
}


x86 assembly (clang, -O0):
<exitfunc10>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x4(%rbp),%esi
mov    -0x10(%rbp),%rdx
lea    0xec3(%rip),%rdi
call   1030 <printf@plt>
mov    -0x10(%rbp),%rdi
call   1040 <exit@plt>

x86 assembly (clang, -O2):
<exitfunc10>:
push   %rbx
mov    %rsi,%rbx
mov    %edi,%esi
lea    0xed3(%rip),%rdi
mov    %rbx,%rdx
call   1030 <printf@plt>
mov    %rbx,%rdi
call   1040 <exit@plt>

LLVM IR (-O0):
@.str = [43 x i8] c"Executing exitfunc10 (status=%d, arg=%lu)\0A\00"
define void @exitfunc10(i32 %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
store i32 %0, i32* %3
store i8* %1, i8** %4
%5 = load i32, i32* %3
%6 = load i8*, i8** %4
%7 = ptrtoint i8* %6 to i64
%8 = call i32 @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str, i64 0, i64 0), i32 %5, i64 %7)
%9 = load i8*, i8** %4
%10 = ptrtoint i8* %9 to i64
%11 = call i32 @exit(i64 %10)
unreachable
}

LLVM IR (-O2):
@.str = [43 x i8] c"Executing exitfunc10 (status=%d, arg=%lu)\0A\00"
define void @exitfunc10(i32 %0, i8* %1) {
%3 = ptrtoint i8* %1 to i64
%4 = tail call i32 @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str, i64 0, i64 0), i32 %0, i64 %3)
%5 = tail call i32 @exit(i64 %3)
unreachable
}
/* Variables and functions */
scalar_t__ get_create_battery_capacity();
scalar_t__ get_create_battery_charge();
float create_get_charge() {
  return (float)get_create_battery_charge() /
         (float)get_create_battery_capacity() * 100.0;
}


x86 assembly (clang, -O0):
<create_get_charge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    $0x0,%al
call   1030 <get_create_battery_charge@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x4(%rbp)
mov    $0x0,%al
call   1040 <get_create_battery_capacity@plt>
movss  -0x4(%rbp),%xmm0
cvtsi2ss %rax,%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xea6(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<create_get_charge>:
push   %rax
xor    %eax,%eax
call   1030 <get_create_battery_charge@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x4(%rsp)
xor    %eax,%eax
call   1040 <get_create_battery_capacity@plt>
cvtsi2ss %rax,%xmm1
movss  0x4(%rsp),%xmm0
divss  %xmm1,%xmm0
mulss  0xeaf(%rip),%xmm0
pop    %rax
ret

LLVM IR (-O0):
define float @create_get_charge() {
%1 = call i64 (...) @get_create_battery_charge()
%2 = sitofp i64 %1 to float
%3 = call i64 (...) @get_create_battery_capacity()
%4 = sitofp i64 %3 to float
%5 = fdiv float %2, %4
%6 = fpext float %5 to double
%7 = fmul double %6, 1.000000e+02
%8 = fptrunc double %7 to float
ret float %8
}

LLVM IR (-O2):
define float @create_get_charge() {
%1 = tail call i64 (...) @get_create_battery_charge()
%2 = sitofp i64 %1 to float
%3 = tail call i64 (...) @get_create_battery_capacity()
%4 = sitofp i64 %3 to float
%5 = fdiv float %2, %4
%6 = fmul float %5, 1.000000e+02
ret float %6
}
/* Variables and functions */
unsigned int executeHandleMessage(void *, char *, int);
unsigned int retractEvent(void *handle, char *message) {
  return executeHandleMessage(handle, message, 8);
}


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

x86 assembly (clang, -O2):
<retractEvent>:
mov    $0x8,%edx
jmp    1030 <executeHandleMessage@plt>

LLVM IR (-O0):
define i32 @retractEvent(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 = call i32 @executeHandleMessage(i8* %5, i8* %6, i32 8)
ret i32 %7
}

LLVM IR (-O2):
define i32 @retractEvent(i8* %0, i8* %1) {
%3 = tail call i32 @executeHandleMessage(i8* %0, i8* %1, i32 8)
ret i32 %3
}
void flush_signals_thread(void) {}


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

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

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

LLVM IR (-O2):
define void @flush_signals_thread() {
ret void
}
void foo063(int p) {}


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

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

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

LLVM IR (-O2):
define void @foo063(i32 %0) {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ INSStateHandle();
int /*<<< orphan*/ UAVObjRequestUpdate(int /*<<< orphan*/);
void INSStateRequestUpdate() { UAVObjRequestUpdate(INSStateHandle()); }


x86 assembly (clang, -O0):
<INSStateRequestUpdate>:
push   %rbp
mov    %rsp,%rbp
mov    $0x0,%al
call   1030 <INSStateHandle@plt>
mov    %eax,%edi
call   1040 <UAVObjRequestUpdate@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<INSStateRequestUpdate>:
push   %rax
xor    %eax,%eax
call   1030 <INSStateHandle@plt>
mov    %eax,%edi
pop    %rax
jmp    1040 <UAVObjRequestUpdate@plt>

LLVM IR (-O0):
define void @INSStateRequestUpdate() {
%1 = call i32 (...) @INSStateHandle()
%2 = call i32 @UAVObjRequestUpdate(i32 %1)
ret void
}

LLVM IR (-O2):
define void @INSStateRequestUpdate() {
%1 = tail call i32 (...) @INSStateHandle()
%2 = tail call i32 @UAVObjRequestUpdate(i32 %1)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ test_cosup_poly_system();
int main(void) {
  printf("\nTesting Coefficient Support Polynomial Representations\n");
  test_cosup_poly_system();
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeca(%rip),%rdi
call   1040 <printf@plt>
mov    $0x0,%al
call   1030 <test_cosup_poly_system@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

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

LLVM IR (-O0):
@.str = [57 x i8] c"\0ATesting Coefficient Support Polynomial Representations\0A\00"
define i32 @main() {
%1 = alloca i32
store i32 0, i32* %1
%2 = call i32 @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str, i64 0, i64 0))
%3 = call i32 (...) @test_cosup_poly_system()
ret i32 0
}

LLVM IR (-O2):
@str = [56 x i8] c"\0ATesting Coefficient Support Polynomial Representations\00"
define i32 @main() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @str, i64 0, i64 0))
%2 = tail call i32 (...) @test_cosup_poly_system()
ret i32 0
}
unsigned int Max(unsigned int a, unsigned int b) {
  if (a > b) {
    return a;
  } else {
    return b;
  }
  __builtin_unreachable();
}


x86 assembly (clang, -O0):
<Max>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jbe    1121 <Max+0x21>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1127 <Max+0x27>
mov    -0xc(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<Max>:
mov    %esi,%eax
cmp    %esi,%edi
cmova  %edi,%eax
ret

LLVM IR (-O0):
define i32 @Max(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 = load i32, i32* %5
%8 = icmp ugt i32 %6, %7
br i1 %8, label %9, label %11
9: ; preds = %2
%10 = load i32, i32* %4
store i32 %10, i32* %3
br label %13
11: ; preds = %2
%12 = load i32, i32* %5
store i32 %12, i32* %3
br label %13
13: ; preds = %11, %9
%14 = load i32, i32* %3
ret i32 %14
}

LLVM IR (-O2):
define i32 @Max(i32 %0, i32 %1) {
%3 = icmp ugt i32 %0, %1
%4 = select i1 %3, i32 %0, i32 %1
ret i32 %4
}
/* Variables and functions */
char getchar();
void bf_input(char *c) { *c = getchar(); }


x86 assembly (clang, -O0):
<bf_input>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    $0x0,%al
call   1030 <getchar@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bf_input>:
push   %rbx
mov    %rdi,%rbx
xor    %eax,%eax
call   1030 <getchar@plt>
mov    %al,(%rbx)
pop    %rbx
ret

LLVM IR (-O0):
define void @bf_input(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = call signext i8 (...) @getchar()
%4 = load i8*, i8** %2
store i8 %3, i8* %4
ret void
}

LLVM IR (-O2):
define void @bf_input(i8* nocapture writeonly %0) {
%2 = tail call signext i8 (...) @getchar()
store i8 %2, i8* %0
ret void
}
void gtk_window_get_icon() {}


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

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

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

LLVM IR (-O2):
define void @gtk_window_get_icon() {
ret void
}
void BN_MONT_CTX_free(void) {}


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

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

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

LLVM IR (-O2):
define void @BN_MONT_CTX_free() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *);
int is_prime(int n) {
  if (n < 2)
    printf("-1");
  else if (n % 2 == 0)
    printf("0");
  else
    printf("1");
  return 0;
}


x86 assembly (clang, -O0):
<is_prime>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
cmpl   $0x2,-0x4(%rbp)
jge    1136 <is_prime+0x26>
lea    0xed4(%rip),%rdi
call   1030 <printf@plt>
jmp    116c <is_prime+0x5c>
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    115b <is_prime+0x4b>
lea    0xeb2(%rip),%rdi
call   1030 <printf@plt>
jmp    1167 <is_prime+0x57>
lea    0xe9f(%rip),%rdi
call   1030 <printf@plt>
jmp    116c <is_prime+0x5c>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<is_prime>:
push   %rax
cmp    $0x1,%edi
jg     1134 <is_prime+0x14>
lea    0xed3(%rip),%rdi
call   1040 <printf@plt>
jmp    114b <is_prime+0x2b>
test   $0x1,%dil
jne    1141 <is_prime+0x21>
mov    $0x30,%edi
jmp    1146 <is_prime+0x26>
mov    $0x31,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
pop    %rcx
ret

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

LLVM IR (-O2):
@.str = [3 x i8] c"-1\00"
define i32 @is_prime(i32 %0) {
%2 = icmp slt i32 %0, 2
br i1 %2, label %3, label %5
3: ; preds = %1
%4 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
br label %12
5: ; preds = %1
%6 = and i32 %0, 1
%7 = icmp eq i32 %6, 0
br i1 %7, label %8, label %10
8: ; preds = %5
%9 = tail call i32 @putchar(i32 48)
br label %12
10: ; preds = %5
%11 = tail call i32 @putchar(i32 49)
br label %12
12: ; preds = %8, %10, %3
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ free(double *);
void free_vector(double *v, long nl, long nh) { free(v + nl - 1); }


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

x86 assembly (clang, -O2):
<free_vector>:
lea    (%rdi,%rsi,8),%rdi
add    $0xfffffffffffffff8,%rdi
jmp    1030 <free@plt>

LLVM IR (-O0):
define void @free_vector(double* %0, i64 %1, i64 %2) {
%4 = alloca double*
%5 = alloca i64
%6 = alloca i64
store double* %0, double** %4
store i64 %1, i64* %5
store i64 %2, i64* %6
%7 = load double*, double** %4
%8 = load i64, i64* %5
%9 = getelementptr inbounds double, double* %7, i64 %8
%10 = getelementptr inbounds double, double* %9, i64 -1
%11 = call i32 @free(double* %10)
ret void
}

LLVM IR (-O2):
define void @free_vector(double* nocapture %0, i64 %1, i64 %2) {
%4 = getelementptr inbounds double, double* %0, i64 %1
%5 = getelementptr inbounds double, double* %4, i64 -1
%6 = tail call i32 @free(double* %5)
ret void
}
/* Variables and functions */
int spec_endianness_is_big();
int arch_spec_endianness_is_big(void) { return spec_endianness_is_big(); }


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

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

LLVM IR (-O0):
define i32 @arch_spec_endianness_is_big() {
%1 = call i32 (...) @spec_endianness_is_big()
ret i32 %1
}

LLVM IR (-O2):
define i32 @arch_spec_endianness_is_big() {
%1 = tail call i32 (...) @spec_endianness_is_big()
ret i32 %1
}
/* Variables and functions */
scalar_t__ replace_string(char **, char const *);
scalar_t__ strcmp(char *, char const *);
int replace_if_changed(char **current, const char new[]) {
  if (strcmp(*current, new) == 0) {
    return 0;
  }
  return (replace_string(current, new) == 0) ? 1 : 0;
}


x86 assembly (clang, -O0):
<replace_if_changed>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x18(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1156 <replace_if_changed+0x36>
movl   $0x0,-0x4(%rbp)
jmp    1177 <replace_if_changed+0x57>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1030 <replace_string@plt>
mov    %rax,%rdx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%rdx
cmove  %ecx,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<replace_if_changed>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
mov    (%rdi),%rdi
call   1040 <strcmp@plt>
test   %rax,%rax
je     114f <replace_if_changed+0x2f>
mov    %rbx,%rdi
mov    %r14,%rsi
call   1030 <replace_string@plt>
mov    %rax,%rcx
xor    %eax,%eax
test   %rcx,%rcx
sete   %al
jmp    1151 <replace_if_changed+0x31>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define i32 @replace_if_changed(i8** %0, i8* %1) {
%3 = load i8*, i8** %0
%4 = tail call i64 @strcmp(i8* %3, i8* %1)
%5 = icmp eq i64 %4, 0
br i1 %5, label %10, label %6
6: ; preds = %2
%7 = tail call i64 @replace_string(i8** %0, i8* %1)
%8 = icmp eq i64 %7, 0
%9 = zext i1 %8 to i32
br label %10
10: ; preds = %2, %6
%11 = phi i32 [ %9, %6 ], [ 0, %2 ]
ret i32 %11
}
void swap(int *p1, int *p2) {
  int temp;
  temp = *p2;
  *p2 = *p1;
  *p1 = temp;
}


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

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

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

LLVM IR (-O2):
define void @swap(i32* nocapture %0, i32* nocapture %1) {
%3 = load i32, i32* %1
%4 = load i32, i32* %0
store i32 %4, i32* %1
store i32 %3, i32* %0
ret void
}
/* Variables and functions */
double generate_exp(double, int);
double get_t();
double generate_next_time(double lambda, int stream) {
  return generate_exp(lambda, stream) + get_t();
}


x86 assembly (clang, -O0):
<generate_next_time>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movsd  %xmm0,-0x8(%rbp)
mov    %edi,-0xc(%rbp)
movsd  -0x8(%rbp),%xmm0
mov    -0xc(%rbp),%edi
call   1030 <generate_exp@plt>
movsd  %xmm0,-0x18(%rbp)
mov    $0x0,%al
call   1040 <get_t@plt>
movaps %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
addsd  %xmm1,%xmm0
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<generate_next_time>:
push   %rax
call   1030 <generate_exp@plt>
movsd  %xmm0,(%rsp)
xor    %eax,%eax
call   1040 <get_t@plt>
addsd  (%rsp),%xmm0
pop    %rax
ret

LLVM IR (-O0):
define double @generate_next_time(double %0, i32 %1) {
%3 = alloca double
%4 = alloca i32
store double %0, double* %3
store i32 %1, i32* %4
%5 = load double, double* %3
%6 = load i32, i32* %4
%7 = call double @generate_exp(double %5, i32 %6)
%8 = call double (...) @get_t()
%9 = fadd double %7, %8
ret double %9
}

LLVM IR (-O2):
define double @generate_next_time(double %0, i32 %1) {
%3 = tail call double @generate_exp(double %0, i32 %1)
%4 = tail call double (...) @get_t()
%5 = fadd double %3, %4
ret double %5
}
void bootLoaderInit() {}


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

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

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

LLVM IR (-O2):
define void @bootLoaderInit() {
ret void
}
void gtk_message_dialog_format_secondary_markup() {}


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

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

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

LLVM IR (-O2):
define void @gtk_message_dialog_format_secondary_markup() {
ret void
}
/* Variables and functions */
double pow(double, double);
double sqrt(double x) { return pow(x, 0.5); }


x86 assembly (clang, -O0):
<sqrt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
movsd  0xed6(%rip),%xmm1
call   1030 <pow@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sqrt>:
movsd  0xee8(%rip),%xmm1
jmp    1030 <pow@plt>

LLVM IR (-O0):
define double @sqrt(double %0) {
%2 = alloca double
store double %0, double* %2
%3 = load double, double* %2
%4 = call double @pow(double %3, double 5.000000e-01)
ret double %4
}

LLVM IR (-O2):
define double @sqrt(double %0) {
%2 = tail call double @pow(double %0, double 5.000000e-01)
ret double %2
}
/* Variables and functions */
int /*<<< orphan*/ _SC_PAGESIZE;
char *_uitoa(int);
int strlen(char const *);
scalar_t__ sysconf(int /*<<< orphan*/);
int /*<<< orphan*/ write(int, char const *, int);
int main(int argc, char *argv[]) {
  const char *p = _uitoa((int)sysconf(_SC_PAGESIZE));
  write(1, p, strlen(p));
  write(1, "\n", 1);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    0x2e8b(%rip),%rax
mov    (%rax),%edi
call   1050 <sysconf@plt>
mov    %eax,%edi
call   1060 <_uitoa@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0x20(%rbp),%rsi
mov    %eax,%edx
mov    $0x1,%edi
call   1030 <write@plt>
mov    $0x1,%edx
lea    0xe64(%rip),%rsi
mov    %edx,%edi
call   1030 <write@plt>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
mov    0x2ea0(%rip),%rax
mov    (%rax),%edi
call   1050 <sysconf@plt>
mov    %eax,%edi
call   1060 <_uitoa@plt>
mov    %rax,%rbx
mov    %rax,%rdi
call   1040 <strlen@plt>
mov    $0x1,%edi
mov    %rbx,%rsi
mov    %eax,%edx
call   1030 <write@plt>
lea    0xe89(%rip),%rsi
mov    $0x1,%edi
mov    $0x1,%edx
call   1030 <write@plt>
xor    %eax,%eax
pop    %rbx
ret

LLVM IR (-O0):
@_SC_PAGESIZE = global i32 0
@.str = [2 x i8] c"\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i8*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%7 = load i32, i32* @_SC_PAGESIZE
%8 = call i64 @sysconf(i32 %7)
%9 = trunc i64 %8 to i32
%10 = call i8* @_uitoa(i32 %9)
store i8* %10, i8** %6
%11 = load i8*, i8** %6
%12 = load i8*, i8** %6
%13 = call i32 @strlen(i8* %12)
%14 = call i32 @write(i32 1, i8* %11, i32 %13)
%15 = call i32 @write(i32 1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 1)
ret i32 0
}

LLVM IR (-O2):
@_SC_PAGESIZE = global i32 0
@.str = [2 x i8] c"\0A\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = load i32, i32* @_SC_PAGESIZE
%4 = tail call i64 @sysconf(i32 %3)
%5 = trunc i64 %4 to i32
%6 = tail call i8* @_uitoa(i32 %5)
%7 = tail call i32 @strlen(i8* %6)
%8 = tail call i32 @write(i32 1, i8* %6, i32 %7)
%9 = tail call i32 @write(i32 1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 1)
ret i32 0
}