xunge/DecIR huggingface dataset:
/* Variables and functions */
bool SHAREMIND_SET_KEY_EQUALS_voidptr(void *const k1, void *const k2) {
  return k1 == k2;
}


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

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

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

LLVM IR (-O2):
define i32 @SHAREMIND_SET_KEY_EQUALS_voidptr(i8* readnone %0, i8* readnone %1) {
%3 = icmp eq i8* %0, %1
%4 = zext i1 %3 to i32
ret i32 %4
}
/* Variables and functions */
int /*<<< orphan*/ Assert_real(int, char *, int, char *);
scalar_t__ isodigit(int);
void t_isodigit_0x09() {
  Assert_real((isodigit(9) == 0),
              "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
              "2022-01-22/02-19-57/repos/bitfixer/bitfixer/refs/heads/master/"
              "dg/z88dk/test/suites/ctype/test_isodigit.c",
              50, ("isodigit should be 0 for 0x09"));
}


x86 assembly (clang, -O0):
<t_isodigit_0x09>:
push   %rbp
mov    %rsp,%rbp
mov    $0x9,%edi
call   1040 <isodigit@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
lea    0xebf(%rip),%rsi
mov    $0x32,%edx
lea    0xf5c(%rip),%rcx
call   1030 <Assert_real@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<t_isodigit_0x09>:
push   %rax
mov    $0x9,%edi
call   1040 <isodigit@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
lea    0xec5(%rip),%rsi
lea    0xf67(%rip),%rcx
mov    $0x32,%edx
pop    %rax
jmp    1030 <Assert_real@plt>

LLVM IR (-O0):
@.str = [169 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/bitfixer/bitfixer/refs/heads/master/dg/z88dk/test/suites/ctype/test_isodigit.c\00"
@.str.1 = [30 x i8] c"isodigit should be 0 for 0x09\00"
define void @t_isodigit_0x09() {
%1 = call i64 @isodigit(i32 9)
%2 = icmp eq i64 %1, 0
%3 = zext i1 %2 to i32
%4 = call i32 @Assert_real(i32 %3, i8* getelementptr inbounds ([169 x i8], [169 x i8]* @.str, i64 0, i64 0), i32 50, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.1, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [169 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/bitfixer/bitfixer/refs/heads/master/dg/z88dk/test/suites/ctype/test_isodigit.c\00"
@.str.1 = [30 x i8] c"isodigit should be 0 for 0x09\00"
define void @t_isodigit_0x09() {
%1 = tail call i64 @isodigit(i32 9)
%2 = icmp eq i64 %1, 0
%3 = zext i1 %2 to i32
%4 = tail call i32 @Assert_real(i32 %3, i8* getelementptr inbounds ([169 x i8], [169 x i8]* @.str, i64 0, i64 0), i32 50, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.1, i64 0, i64 0))
ret void
}
/* Type definitions */
struct sock_fprog {
  int dummy;
};

/* Variables and functions */
int __bpf_ipv6_hash(struct sock_fprog *, int);
int bpf_vlan_ipv6_hash(struct sock_fprog *fprog) {
  return __bpf_ipv6_hash(fprog, true);
}


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

x86 assembly (clang, -O2):
<bpf_vlan_ipv6_hash>:
mov    $0x1,%esi
jmp    1030 <__bpf_ipv6_hash@plt>

LLVM IR (-O0):
%struct.sock_fprog = type { i32 }
define i32 @bpf_vlan_ipv6_hash(%struct.sock_fprog* %0) {
%2 = alloca %struct.sock_fprog*
store %struct.sock_fprog* %0, %struct.sock_fprog** %2
%3 = load %struct.sock_fprog*, %struct.sock_fprog** %2
%4 = call i32 @__bpf_ipv6_hash(%struct.sock_fprog* %3, i32 1)
ret i32 %4
}

LLVM IR (-O2):
%struct.sock_fprog = type { i32 }
define i32 @bpf_vlan_ipv6_hash(%struct.sock_fprog* %0) {
%2 = tail call i32 @__bpf_ipv6_hash(%struct.sock_fprog* %0, i32 1)
ret i32 %2
}
/* Type definitions */
struct arg_dbl {
  int dummy;
};

/* Variables and functions */
struct arg_dbl *arg_dbln(char const *, char const *, char const *, int, int,
                         char const *);
struct arg_dbl *arg_dbl1(const char *shortopts, const char *longopts,
                         const char *datatype, const char *glossary) {
  return arg_dbln(shortopts, longopts, datatype, 1, 1, glossary);
}


x86 assembly (clang, -O0):
<arg_dbl1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%r9
mov    $0x1,%r8d
mov    %r8d,%ecx
call   1030 <arg_dbln@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<arg_dbl1>:
mov    %rcx,%r9
mov    $0x1,%ecx
mov    $0x1,%r8d
jmp    1030 <arg_dbln@plt>

LLVM IR (-O0):
%struct.arg_dbl = type { i32 }
define %struct.arg_dbl* @arg_dbl1(i8* %0, i8* %1, i8* %2, i8* %3) {
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
store i8* %0, i8** %5
store i8* %1, i8** %6
store i8* %2, i8** %7
store i8* %3, i8** %8
%9 = load i8*, i8** %5
%10 = load i8*, i8** %6
%11 = load i8*, i8** %7
%12 = load i8*, i8** %8
%13 = call %struct.arg_dbl* @arg_dbln(i8* %9, i8* %10, i8* %11, i32 1, i32 1, i8* %12)
ret %struct.arg_dbl* %13
}

LLVM IR (-O2):
%struct.arg_dbl = type { i32 }
define %struct.arg_dbl* @arg_dbl1(i8* %0, i8* %1, i8* %2, i8* %3) {
%5 = tail call %struct.arg_dbl* @arg_dbln(i8* %0, i8* %1, i8* %2, i32 1, i32 1, i8* %3)
ret %struct.arg_dbl* %5
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *);
void usage(void) {
  printf("reads: read random or stride chunks of a file.\n");
  printf("Usage:\n\n");
  printf("reads -f <filename> -s <filesize> -b <buffersize>"
         "-a <adjacent reads> [-v] [-h] [-C] [-l <stride_length> ] "
         "[ -o <stride_offset> ] [-S <seed>] [-n <iterations>]"
         "[-w <width>] [-t <timelimit>]\n");
}


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

x86 assembly (clang, -O2):
<usage>:
push   %rax
lea    0xee8(%rip),%rdi
call   1030 <puts@plt>
lea    0xf0b(%rip),%rdi
call   1030 <puts@plt>
lea    0xf07(%rip),%rdi
pop    %rax
jmp    1030 <puts@plt>

LLVM IR (-O0):
@.str = [48 x i8] c"reads: read random or stride chunks of a file.\0A\00"
@.str.1 = [9 x i8] c"Usage:\0A\0A\00"
@.str.2 = [189 x i8] c"reads -f <filename> -s <filesize> -b <buffersize>-a <adjacent reads> [-v] [-h] [-C] [-l <stride_length> ] [ -o <stride_offset> ] [-S <seed>] [-n <iterations>][-w <width>] [-t <timelimit>]\0A\00"
define void @usage() {
%1 = call i32 @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str, i64 0, i64 0))
%2 = call i32 @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0))
%3 = call i32 @printf(i8* getelementptr inbounds ([189 x i8], [189 x i8]* @.str.2, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@str = [47 x i8] c"reads: read random or stride chunks of a file.\00"
@str.3 = [8 x i8] c"Usage:\0A\00"
@str.4 = [188 x i8] c"reads -f <filename> -s <filesize> -b <buffersize>-a <adjacent reads> [-v] [-h] [-C] [-l <stride_length> ] [ -o <stride_offset> ] [-S <seed>] [-n <iterations>][-w <width>] [-t <timelimit>]\00"
define void @usage() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str, i64 0, i64 0))
%2 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.3, i64 0, i64 0))
%3 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([188 x i8], [188 x i8]* @str.4, i64 0, i64 0))
ret void
}
char *strcpy(char *restrict dest, const char *restrict src) {
  do {
    *dest++ = *src;
  } while (*src++ != '\0');
  return dest;
}


x86 assembly (clang, -O0):
<strcpy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    110c <strcpy+0xc>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<strcpy>:
mov    %rdi,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rsi),%ecx
mov    %cl,(%rax)
add    $0x1,%rax
add    $0x1,%rsi
test   %cl,%cl
jne    1110 <strcpy+0x10>
ret

LLVM IR (-O0):
define i8* @strcpy(i8* noalias %0, i8* noalias %1) {
%3 = alloca i8*
%4 = alloca i8*
store i8* %0, i8** %3
store i8* %1, i8** %4
br label %5
5: ; preds = %10, %2
%6 = load i8*, i8** %4
%7 = load i8, i8* %6
%8 = load i8*, i8** %3
%9 = getelementptr inbounds i8, i8* %8, i32 1
store i8* %9, i8** %3
store i8 %7, i8* %8
br label %10
10: ; preds = %5
%11 = load i8*, i8** %4
%12 = getelementptr inbounds i8, i8* %11, i32 1
store i8* %12, i8** %4
%13 = load i8, i8* %11
%14 = sext i8 %13 to i32
%15 = icmp ne i32 %14, 0
br i1 %15, label %5, label %16
16: ; preds = %10
%17 = load i8*, i8** %3
ret i8* %17
}

LLVM IR (-O2):
define i8* @strcpy(i8* noalias writeonly %0, i8* noalias nocapture %1) {
br label %3
3: ; preds = %3, %2
%4 = phi i8* [ %0, %2 ], [ %7, %3 ]
%5 = phi i8* [ %1, %2 ], [ %8, %3 ]
%6 = load i8, i8* %5
%7 = getelementptr inbounds i8, i8* %4, i64 1
store i8 %6, i8* %4
%8 = getelementptr inbounds i8, i8* %5, i64 1
%9 = icmp eq i8 %6, 0
br i1 %9, label %10, label %3
10: ; preds = %3
ret i8* %7
}
_Complex float f1(void) {
  float x;
  return x;
}


x86 assembly (clang, -O0):
<f1>:
push   %rbp
mov    %rsp,%rbp
movss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x8(%rbp)
movl   $0x0,-0x4(%rbp)
movsd  -0x8(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<f1>:
xorps  %xmm0,%xmm0
ret

LLVM IR (-O0):
define <2 x float> @f1() {
%1 = alloca { float, float }
%2 = alloca float
%3 = load float, float* %2
%4 = getelementptr inbounds { float, float }, { float, float }* %1, i32 0, i32 0
%5 = getelementptr inbounds { float, float }, { float, float }* %1, i32 0, i32 1
store float %3, float* %4
store float 0.000000e+00, float* %5
%6 = bitcast { float, float }* %1 to <2 x float>*
%7 = load <2 x float>, <2 x float>* %6
ret <2 x float> %7
}

LLVM IR (-O2):
define <2 x float> @f1() {
ret <2 x float> <float undef, float 0.000000e+00>
}
/* Type definitions */
struct termios {
  int dummy;
};

/* Variables and functions */
int ioctl(int, int, long);
int tcgetattr(int fd, struct termios *termios_p) {
  return ioctl(fd, 0x5401, (long)termios_p);
}


x86 assembly (clang, -O0):
<tcgetattr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rdx
mov    $0x5401,%esi
call   1030 <ioctl@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tcgetattr>:
mov    %rsi,%rdx
mov    $0x5401,%esi
jmp    1030 <ioctl@plt>

LLVM IR (-O0):
%struct.termios = type { i32 }
define i32 @tcgetattr(i32 %0, %struct.termios* %1) {
%3 = alloca i32
%4 = alloca %struct.termios*
store i32 %0, i32* %3
store %struct.termios* %1, %struct.termios** %4
%5 = load i32, i32* %3
%6 = load %struct.termios*, %struct.termios** %4
%7 = ptrtoint %struct.termios* %6 to i64
%8 = call i32 @ioctl(i32 %5, i32 21505, i64 %7)
ret i32 %8
}

LLVM IR (-O2):
%struct.termios = type { i32 }
define i32 @tcgetattr(i32 %0, %struct.termios* %1) {
%3 = ptrtoint %struct.termios* %1 to i64
%4 = tail call i32 @ioctl(i32 %0, i32 21505, i64 %3)
ret i32 %4
}
/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *, char *);
int /*<<< orphan*/ stderr;
void print(char *s) { fprintf(stderr, "%p: [%s]\n", s, s); }


x86 assembly (clang, -O0):
<print>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    0x2ebd(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rdx
mov    -0x8(%rbp),%rcx
lea    0xecc(%rip),%rsi
call   1030 <fprintf@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<print>:
mov    %rdi,%rcx
mov    0x2ec6(%rip),%rax
mov    (%rax),%edi
lea    0xedd(%rip),%rsi
mov    %rcx,%rdx
jmp    1030 <fprintf@plt>

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

LLVM IR (-O2):
@stderr = global i32 0
@.str = [10 x i8] c"%p: [%s]\0A\00"
define void @print(i8* %0) {
%2 = load i32, i32* @stderr
%3 = tail call i32 @fprintf(i32 %2, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* %0, i8* %0)
ret void
}
void rt2x00crypto_rx_insert_iv(struct sk_buff *skb, unsigned int header_length,
                               struct rxdone_entry_desc *rxdesc) {}


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

x86 assembly (clang, -O2):
ret

LLVM IR (-O0):
%struct.sk_buff = type opaque
%struct.rxdone_entry_desc = type opaque
define void @rt2x00crypto_rx_insert_iv(%struct.sk_buff* %0, i32 %1, %struct.rxdone_entry_desc* %2) {
%4 = alloca %struct.sk_buff*
%5 = alloca i32
%6 = alloca %struct.rxdone_entry_desc*
store %struct.sk_buff* %0, %struct.sk_buff** %4
store i32 %1, i32* %5
store %struct.rxdone_entry_desc* %2, %struct.rxdone_entry_desc** %6
ret void
}

LLVM IR (-O2):
%struct.sk_buff = type opaque
%struct.rxdone_entry_desc = type opaque
define void @rt2x00crypto_rx_insert_iv(%struct.sk_buff* nocapture %0, i32 %1, %struct.rxdone_entry_desc* nocapture %2) {
ret void
}
int duplex_add_ssh() { return 51; }


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

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

LLVM IR (-O0):
define i32 @duplex_add_ssh() {
ret i32 51
}

LLVM IR (-O2):
define i32 @duplex_add_ssh() {
ret i32 51
}
int open(char *filename, int mode) { return -1; }


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

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

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

LLVM IR (-O2):
define i32 @open(i8* nocapture readnone %0, i32 %1) {
ret i32 -1
}
/* Variables and functions */
int /*<<< orphan*/ geoXyz2Rae(double *, double *);
double geoXyz2A(double x, double y, double z) {
  double rae[3], xyz[3];
  xyz[0] = x;
  xyz[1] = y;
  xyz[2] = z;
  geoXyz2Rae(xyz, rae);
  return (rae[1] * (180.0 / 3.14159265358979323846));
}


x86 assembly (clang, -O0):
<geoXyz2A>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
lea    -0x50(%rbp),%rdi
lea    -0x30(%rbp),%rsi
call   1030 <geoXyz2Rae@plt>
movsd  0xea6(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<geoXyz2A>:
sub    $0x38,%rsp
movsd  %xmm0,(%rsp)
movsd  %xmm1,0x8(%rsp)
movsd  %xmm2,0x10(%rsp)
mov    %rsp,%rdi
lea    0x20(%rsp),%rsi
call   1030 <geoXyz2Rae@plt>
movsd  0x28(%rsp),%xmm0
mulsd  0xec0(%rip),%xmm0
add    $0x38,%rsp
ret

LLVM IR (-O0):
define double @geoXyz2A(double %0, double %1, double %2) {
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca [3 x double]
%8 = alloca [3 x double]
store double %0, double* %4
store double %1, double* %5
store double %2, double* %6
%9 = load double, double* %4
%10 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 0
store double %9, double* %10
%11 = load double, double* %5
%12 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 1
store double %11, double* %12
%13 = load double, double* %6
%14 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 2
store double %13, double* %14
%15 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 0
%16 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 0
%17 = call i32 @geoXyz2Rae(double* %15, double* %16)
%18 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 1
%19 = load double, double* %18
%20 = fmul double %19, 0x404CA5DC1A63C1F8
ret double %20
}

LLVM IR (-O2):
define double @geoXyz2A(double %0, double %1, double %2) {
%4 = alloca [3 x double]
%5 = alloca [3 x double]
%6 = bitcast [3 x double]* %4 to i8*
%7 = bitcast [3 x double]* %5 to i8*
%8 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
store double %0, double* %8
%9 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
store double %1, double* %9
%10 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
store double %2, double* %10
%11 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%12 = call i32 @geoXyz2Rae(double* %8, double* %11)
%13 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%14 = load double, double* %13
%15 = fmul double %14, 0x404CA5DC1A63C1F8
ret double %15
}
/* Type definitions */
struct rtattr {
  int dummy;
};
struct qdisc_util {
  int dummy;
};
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int ingress_print_xstats(struct qdisc_util *qu, FILE *f,
                         struct rtattr *xstats) {
  return 0;
}


x86 assembly (clang, -O0):
<ingress_print_xstats>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
xor    %eax,%eax
pop    %rbp
ret

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

LLVM IR (-O0):
%struct.qdisc_util = type { i32 }
%struct.rtattr = type { i32 }
define i32 @ingress_print_xstats(%struct.qdisc_util* %0, i32* %1, %struct.rtattr* %2) {
%4 = alloca %struct.qdisc_util*
%5 = alloca i32*
%6 = alloca %struct.rtattr*
store %struct.qdisc_util* %0, %struct.qdisc_util** %4
store i32* %1, i32** %5
store %struct.rtattr* %2, %struct.rtattr** %6
ret i32 0
}

LLVM IR (-O2):
%struct.qdisc_util = type { i32 }
%struct.rtattr = type { i32 }
define i32 @ingress_print_xstats(%struct.qdisc_util* nocapture readnone %0, i32* nocapture readnone %1, %struct.rtattr* nocapture readnone %2) {
ret i32 0
}
/* Variables and functions */
unsigned char *cbor_write_type_size_bytes(unsigned char *, unsigned int, int,
                                          unsigned int, unsigned char const *);
unsigned char *cbor_write_bytes(unsigned char *data, unsigned int size,
                                const unsigned char *bytes,
                                unsigned int bytes_size) {
  return cbor_write_type_size_bytes(data, size, 2, bytes_size, bytes);
}


x86 assembly (clang, -O0):
<cbor_write_bytes>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%r8
mov    $0x2,%edx
call   1030 <cbor_write_type_size_bytes@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cbor_write_bytes>:
mov    %rdx,%r8
mov    $0x2,%edx
jmp    1030 <cbor_write_type_size_bytes@plt>

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

LLVM IR (-O2):
define i8* @cbor_write_bytes(i8* %0, i32 %1, i8* %2, i32 %3) {
%5 = tail call i8* @cbor_write_type_size_bytes(i8* %0, i32 %1, i32 2, i32 %3, i8* %2)
ret i8* %5
}
/* Type definitions */
typedef unsigned long long uint64_t;

/* Variables and functions */
int is_block(uint64_t offset, int block_order) {
  return !(((1ULL << block_order) - 1) & offset);
}


x86 assembly (clang, -O0):
<is_block>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
sub    $0x1,%rax
and    -0x8(%rbp),%rax
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<is_block>:
mov    %esi,%ecx
mov    $0xffffffffffffffff,%rdx
shl    %cl,%rdx
not    %rdx
xor    %eax,%eax
test   %rdi,%rdx
sete   %al
ret

LLVM IR (-O0):
define i32 @is_block(i64 %0, i32 %1) {
%3 = alloca i64
%4 = alloca i32
store i64 %0, i64* %3
store i32 %1, i32* %4
%5 = load i32, i32* %4
%6 = zext i32 %5 to i64
%7 = shl i64 1, %6
%8 = sub i64 %7, 1
%9 = load i64, i64* %3
%10 = and i64 %8, %9
%11 = icmp ne i64 %10, 0
%12 = xor i1 %11, true
%13 = zext i1 %12 to i32
ret i32 %13
}

LLVM IR (-O2):
define i32 @is_block(i64 %0, i32 %1) {
%3 = zext i32 %1 to i64
%4 = shl nsw i64 -1, %3
%5 = xor i64 %4, -1
%6 = and i64 %5, %0
%7 = icmp eq i64 %6, 0
%8 = zext i1 %7 to i32
ret i32 %8
}
/* Variables and functions */
double JulianDayFromGregorian(int, int, float);
double ModifiedJulianDayFromGregorian(int year, int month, float day) {
  return (JulianDayFromGregorian(year, month, day) - 2400000.5);
}


x86 assembly (clang, -O0):
<ModifiedJulianDayFromGregorian>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
movss  -0xc(%rbp),%xmm0
call   1030 <JulianDayFromGregorian@plt>
movsd  0xec5(%rip),%xmm1
subsd  %xmm1,%xmm0
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ModifiedJulianDayFromGregorian>:
push   %rax
call   1030 <JulianDayFromGregorian@plt>
addsd  0xee2(%rip),%xmm0
pop    %rax
ret

LLVM IR (-O0):
define double @ModifiedJulianDayFromGregorian(i32 %0, i32 %1, float %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca float
store i32 %0, i32* %4
store i32 %1, i32* %5
store float %2, float* %6
%7 = load i32, i32* %4
%8 = load i32, i32* %5
%9 = load float, float* %6
%10 = call double @JulianDayFromGregorian(i32 %7, i32 %8, float %9)
%11 = fsub double %10, 0x41424F8040000000
ret double %11
}

LLVM IR (-O2):
define double @ModifiedJulianDayFromGregorian(i32 %0, i32 %1, float %2) {
%4 = tail call double @JulianDayFromGregorian(i32 %0, i32 %1, float %2)
%5 = fadd double %4, 0xC1424F8040000000
ret double %5
}
void NextField(ptr) char **ptr;
{
  while (!is_space_char(**ptr) && **ptr != '\0')
    CInc(ptr);
  SkipWhiteSpace(ptr);
}


x86 assembly (clang, -O0):
<NextField>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%edi
mov    $0x0,%al
call   1030 <is_space_char@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x9(%rbp)
jne    1170 <NextField+0x40>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x9(%rbp)
mov    -0x9(%rbp),%al
test   $0x1,%al
jne    1180 <NextField+0x50>
jmp    1190 <NextField+0x60>
mov    -0x8(%rbp),%rdi
mov    $0x0,%al
call   1050 <CInc@plt>
jmp    113c <NextField+0xc>
mov    -0x8(%rbp),%rdi
mov    $0x0,%al
call   1040 <SkipWhiteSpace@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<NextField>:
push   %rbx
mov    %rdi,%rbx
mov    (%rdi),%rax
nopw   0x0(%rax,%rax,1)
movsbl (%rax),%edi
xor    %eax,%eax
call   1030 <is_space_char@plt>
test   %eax,%eax
jne    1165 <NextField+0x35>
mov    (%rbx),%rax
cmpb   $0x0,(%rax)
je     1165 <NextField+0x35>
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <CInc@plt>
mov    (%rbx),%rax
jmp    1140 <NextField+0x10>
mov    %rbx,%rdi
xor    %eax,%eax
pop    %rbx
jmp    1040 <SkipWhiteSpace@plt>

LLVM IR (-O0):
define void @NextField(i8** %0) {
%2 = alloca i8**
store i8** %0, i8*** %2
br label %3
3: ; preds = %18, %1
%4 = load i8**, i8*** %2
%5 = load i8*, i8** %4
%6 = load i8, i8* %5
%7 = sext i8 %6 to i32
%8 = call i32 (i32, ...) bitcast (i32 (...)* @is_space_char to i32 (i32, ...)*)(i32 %7)
%9 = icmp ne i32 %8, 0
br i1 %9, label %16, label %10
10: ; preds = %3
%11 = load i8**, i8*** %2
%12 = load i8*, i8** %11
%13 = load i8, i8* %12
%14 = sext i8 %13 to i32
%15 = icmp ne i32 %14, 0
br label %16
16: ; preds = %10, %3
%17 = phi i1 [ false, %3 ], [ %15, %10 ]
br i1 %17, label %18, label %21
18: ; preds = %16
%19 = load i8**, i8*** %2
%20 = call i32 (i8**, ...) bitcast (i32 (...)* @CInc to i32 (i8**, ...)*)(i8** %19)
br label %3
21: ; preds = %16
%22 = load i8**, i8*** %2
%23 = call i32 (i8**, ...) bitcast (i32 (...)* @SkipWhiteSpace to i32 (i8**, ...)*)(i8** %22)
ret void
}

LLVM IR (-O2):
define void @NextField(i8** %0) {
%2 = load i8*, i8** %0
%3 = load i8, i8* %2
%4 = sext i8 %3 to i32
%5 = tail call i32 (i32, ...) bitcast (i32 (...)* @is_space_char to i32 (i32, ...)*)(i32 %4)
%6 = icmp eq i32 %5, 0
br i1 %6, label %7, label %18
7: ; preds = %1, %11
%8 = load i8*, i8** %0
%9 = load i8, i8* %8
%10 = icmp eq i8 %9, 0
br i1 %10, label %18, label %11
11: ; preds = %7
%12 = tail call i32 (i8**, ...) bitcast (i32 (...)* @CInc to i32 (i8**, ...)*)(i8** %0)
%13 = load i8*, i8** %0
%14 = load i8, i8* %13
%15 = sext i8 %14 to i32
%16 = tail call i32 (i32, ...) bitcast (i32 (...)* @is_space_char to i32 (i32, ...)*)(i32 %15)
%17 = icmp eq i32 %16, 0
br i1 %17, label %7, label %18
18: ; preds = %7, %11, %1
%19 = tail call i32 (i8**, ...) bitcast (i32 (...)* @SkipWhiteSpace to i32 (i8**, ...)*)(i8** %0)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ db(int);
void cbw() {
  db(0x66);
  db(0x98);
}


x86 assembly (clang, -O0):
<cbw>:
push   %rbp
mov    %rsp,%rbp
mov    $0x66,%edi
call   1030 <db@plt>
mov    $0x98,%edi
call   1030 <db@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cbw>:
push   %rax
mov    $0x66,%edi
call   1030 <db@plt>
mov    $0x98,%edi
pop    %rax
jmp    1030 <db@plt>

LLVM IR (-O0):
define void @cbw() {
%1 = call i32 @db(i32 102)
%2 = call i32 @db(i32 152)
ret void
}

LLVM IR (-O2):
define void @cbw() {
%1 = tail call i32 @db(i32 102)
%2 = tail call i32 @db(i32 152)
ret void
}
int main(int argc, char **argv) { return __builtin_ctz(argc); }


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

x86 assembly (clang, -O2):
<main>:
bsf    %edi,%eax
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 = call i32 @llvm.cttz.i32(i32 %6, i1 true)
ret i32 %7
}

LLVM IR (-O2):
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = tail call i32 @llvm.cttz.i32(i32 %0, i1 true)
ret i32 %3
}
/* Variables and functions */
int /*<<< orphan*/ O_WRONLY;
int /*<<< orphan*/ close(int);
int open(char *, int /*<<< orphan*/);
int /*<<< orphan*/ write(int, int *, int);
int ft_int_putchar(int c) {
  int fd;
  fd = open("/dev/tty", O_WRONLY);
  write(fd, &c, 1);
  close(fd);
  return (1);
}


x86 assembly (clang, -O0):
<ft_int_putchar>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    0x2e96(%rip),%rax
mov    (%rax),%esi
lea    0xeb5(%rip),%rdi
call   1050 <open@plt>
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%edi
lea    -0x4(%rbp),%rsi
mov    $0x1,%edx
call   1030 <write@plt>
mov    -0x8(%rbp),%edi
call   1040 <close@plt>
mov    $0x1,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ft_int_putchar>:
push   %rbx
sub    $0x10,%rsp
mov    %edi,0xc(%rsp)
mov    0x2e98(%rip),%rax
mov    (%rax),%esi
lea    0xeb7(%rip),%rdi
call   1050 <open@plt>
mov    %eax,%ebx
lea    0xc(%rsp),%rsi
mov    %eax,%edi
mov    $0x1,%edx
call   1030 <write@plt>
mov    %ebx,%edi
call   1040 <close@plt>
mov    $0x1,%eax
add    $0x10,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@.str = [9 x i8] c"/dev/tty\00"
@O_WRONLY = global i32 0
define i32 @ft_int_putchar(i32 %0) {
%2 = alloca i32
%3 = alloca i32
store i32 %0, i32* %2
%4 = load i32, i32* @O_WRONLY
%5 = call i32 @open(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i32 %4)
store i32 %5, i32* %3
%6 = load i32, i32* %3
%7 = call i32 @write(i32 %6, i32* %2, i32 1)
%8 = load i32, i32* %3
%9 = call i32 @close(i32 %8)
ret i32 1
}

LLVM IR (-O2):
@.str = [9 x i8] c"/dev/tty\00"
@O_WRONLY = global i32 0
define i32 @ft_int_putchar(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
%3 = load i32, i32* @O_WRONLY
%4 = tail call i32 @open(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i32 %3)
%5 = call i32 @write(i32 %4, i32* %2, i32 1)
%6 = tail call i32 @close(i32 %4)
ret i32 1
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, char *);
void print(void *item) {
  char *s = item;
  printf("%s", s);
}


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

x86 assembly (clang, -O2):
<print>:
mov    %rdi,%rsi
lea    0xee6(%rip),%rdi
jmp    1030 <printf@plt>

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

LLVM IR (-O2):
@.str = [3 x i8] c"%s\00"
define void @print(i8* %0) {
%2 = tail call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %0)
ret void
}
int _main(void) { return 0; }


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

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

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

LLVM IR (-O2):
define i32 @_main() {
ret i32 0
}
void I2S0_Handler(void) {
  while (1) {
  }
}


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

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

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

LLVM IR (-O2):
define void @I2S0_Handler() {
br label %1
1: ; preds = %0, %1
br label %1
}
/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
scalar_t__ IsFailure(char *);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, char **);
int /*<<< orphan*/ printf(char *);
void CheckResult(FILE *p_res) {
  char psz_resp[9];
  fscanf(p_res, "%8s", &psz_resp);
  if (IsFailure(psz_resp)) {
    printf(" failed\n");
    exit(-1);
  }
}


x86 assembly (clang, -O0):
<CheckResult>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x11(%rbp),%rdx
lea    0xea5(%rip),%rsi
call   1040 <fscanf@plt>
lea    -0x11(%rbp),%rdi
call   1060 <IsFailure@plt>
cmp    $0x0,%rax
je     1189 <CheckResult+0x49>
lea    0xe8a(%rip),%rdi
call   1030 <printf@plt>
mov    $0xffffffff,%edi
call   1050 <exit@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CheckResult>:
push   %rbx
sub    $0x10,%rsp
lea    0xeb4(%rip),%rsi
lea    0x7(%rsp),%rbx
mov    %rbx,%rdx
call   1040 <fscanf@plt>
mov    %rbx,%rdi
call   1060 <IsFailure@plt>
test   %rax,%rax
jne    116c <CheckResult+0x2c>
add    $0x10,%rsp
pop    %rbx
ret
lea    0xe91(%rip),%rdi
call   1030 <puts@plt>
mov    $0xffffffff,%edi
call   1050 <exit@plt>

LLVM IR (-O0):
@.str = [4 x i8] c"%8s\00"
@.str.1 = [9 x i8] c" failed\0A\00"
define void @CheckResult(i32* %0) {
%2 = alloca i32*
%3 = alloca [9 x i8]
store i32* %0, i32** %2
%4 = load i32*, i32** %2
%5 = bitcast [9 x i8]* %3 to i8**
%6 = call i32 @fscanf(i32* %4, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %5)
%7 = getelementptr inbounds [9 x i8], [9 x i8]* %3, i64 0, i64 0
%8 = call i64 @IsFailure(i8* %7)
%9 = icmp ne i64 %8, 0
br i1 %9, label %10, label %13
10: ; preds = %1
%11 = call i32 @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0))
%12 = call i32 @exit(i32 -1)
unreachable
13: ; preds = %1
ret void
}

LLVM IR (-O2):
@.str = [4 x i8] c"%8s\00"
@str = [8 x i8] c" failed\00"
define void @CheckResult(i32* nocapture %0) {
%2 = alloca [9 x i8]
%3 = getelementptr inbounds [9 x i8], [9 x i8]* %2, i64 0, i64 0
%4 = bitcast [9 x i8]* %2 to i8**
%5 = call i32 @fscanf(i32* %0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8** %4)
%6 = call i64 @IsFailure(i8* %3)
%7 = icmp eq i64 %6, 0
br i1 %7, label %11, label %8
8: ; preds = %1
%9 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str, i64 0, i64 0))
%10 = call i32 @exit(i32 -1)
unreachable
11: ; preds = %1
ret void
}
/* Variables and functions */
int __bitmap_parselist(char const *, unsigned int, int /*<<< orphan*/,
                       unsigned long *, int);
int bitmap_parselist(const char *buf, unsigned int buflen, unsigned long *maskp,
                     int nmaskbits) {
  return __bitmap_parselist(buf, buflen, 0, maskp, nmaskbits);
}


x86 assembly (clang, -O0):
<bitmap_parselist>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x18(%rbp),%rcx
mov    -0x1c(%rbp),%r8d
xor    %edx,%edx
call   1030 <__bitmap_parselist@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitmap_parselist>:
mov    %ecx,%r8d
mov    %rdx,%rcx
xor    %edx,%edx
jmp    1030 <__bitmap_parselist@plt>

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

LLVM IR (-O2):
define i32 @bitmap_parselist(i8* %0, i32 %1, i64* %2, i32 %3) {
%5 = tail call i32 @__bitmap_parselist(i8* %0, i32 %1, i32 0, i64* %2, i32 %3)
ret i32 %5
}
void vvadpRefresh() {}


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

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

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

LLVM IR (-O2):
define void @vvadpRefresh() {
ret void
}
/* Variables and functions */
double sla_eqeqx_(double *);
double slaEqeqx(double date) {
  double DATE;
  double result;
  DATE = date;
  result = sla_eqeqx_(&DATE);
  return result;
}


x86 assembly (clang, -O0):
<slaEqeqx>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
lea    -0x10(%rbp),%rdi
call   1030 <sla_eqeqx_@plt>
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm0
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<slaEqeqx>:
push   %rax
movsd  %xmm0,(%rsp)
mov    %rsp,%rdi
call   1030 <sla_eqeqx_@plt>
pop    %rax
ret

LLVM IR (-O0):
define double @slaEqeqx(double %0) {
%2 = alloca double
%3 = alloca double
%4 = alloca double
store double %0, double* %2
%5 = load double, double* %2
store double %5, double* %3
%6 = call double @sla_eqeqx_(double* %3)
store double %6, double* %4
%7 = load double, double* %4
ret double %7
}

LLVM IR (-O2):
define double @slaEqeqx(double %0) {
%2 = alloca double
%3 = bitcast double* %2 to i8*
store double %0, double* %2
%4 = call double @sla_eqeqx_(double* %2)
ret double %4
}
/* Type definitions */
typedef scalar_t__ wchar_t;

/* Variables and functions */
scalar_t__ bmemdup(scalar_t__ const *, size_t);
wchar_t *bwstrdup_n(const wchar_t *str, size_t n) {
  wchar_t *dup;
  if (!str)
    return NULL;
  dup = (wchar_t *)bmemdup(str, (n + 1) * sizeof(wchar_t));
  dup[n] = 0;
  return dup;
}


x86 assembly (clang, -O0):
<bwstrdup_n>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1138 <bwstrdup_n+0x28>
movq   $0x0,-0x8(%rbp)
jmp    1169 <bwstrdup_n+0x59>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
add    $0x1,%rsi
shl    $0x3,%rsi
call   1030 <bmemdup@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bwstrdup_n>:
test   %rdi,%rdi
je     1130 <bwstrdup_n+0x20>
push   %rbx
mov    %rsi,%rbx
lea    0x8(,%rsi,8),%rsi
call   1030 <bmemdup@plt>
movq   $0x0,(%rax,%rbx,8)
pop    %rbx
ret
xor    %eax,%eax
ret

LLVM IR (-O0):
define i64* @bwstrdup_n(i64* %0, i64 %1) {
%3 = alloca i64*
%4 = alloca i64*
%5 = alloca i64
%6 = alloca i64*
store i64* %0, i64** %4
store i64 %1, i64* %5
%7 = load i64*, i64** %4
%8 = icmp ne i64* %7, null
br i1 %8, label %10, label %9
9: ; preds = %2
store i64* null, i64** %3
br label %21
10: ; preds = %2
%11 = load i64*, i64** %4
%12 = load i64, i64* %5
%13 = add i64 %12, 1
%14 = mul i64 %13, 8
%15 = call i64 @bmemdup(i64* %11, i64 %14)
%16 = inttoptr i64 %15 to i64*
store i64* %16, i64** %6
%17 = load i64*, i64** %6
%18 = load i64, i64* %5
%19 = getelementptr inbounds i64, i64* %17, i64 %18
store i64 0, i64* %19
%20 = load i64*, i64** %6
store i64* %20, i64** %3
br label %21
21: ; preds = %10, %9
%22 = load i64*, i64** %3
ret i64* %22
}

LLVM IR (-O2):
define i64* @bwstrdup_n(i64* %0, i64 %1) {
%3 = icmp eq i64* %0, null
br i1 %3, label %10, label %4
4: ; preds = %2
%5 = shl i64 %1, 3
%6 = add i64 %5, 8
%7 = tail call i64 @bmemdup(i64* %0, i64 %6)
%8 = inttoptr i64 %7 to i64*
%9 = getelementptr inbounds i64, i64* %8, i64 %1
store i64 0, i64* %9
br label %10
10: ; preds = %2, %4
%11 = phi i64* [ %8, %4 ], [ null, %2 ]
ret i64* %11
}
int fn5(int x, int y) {
  int tem1 = ~(x & y);
  int tem2 = x | y;
  return tem1 & tem2;
}


x86 assembly (clang, -O0):
<fn5>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    -0x4(%rbp),%eax
and    -0x8(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
mov    -0x4(%rbp),%eax
or     -0x8(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0xc(%rbp),%eax
and    -0x10(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<fn5>:
mov    %edi,%eax
xor    %esi,%eax
ret

LLVM IR (-O0):
define i32 @fn5(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
store i32 %0, i32* %3
store i32 %1, i32* %4
%7 = load i32, i32* %3
%8 = load i32, i32* %4
%9 = and i32 %7, %8
%10 = xor i32 %9, -1
store i32 %10, i32* %5
%11 = load i32, i32* %3
%12 = load i32, i32* %4
%13 = or i32 %11, %12
store i32 %13, i32* %6
%14 = load i32, i32* %5
%15 = load i32, i32* %6
%16 = and i32 %14, %15
ret i32 %16
}

LLVM IR (-O2):
define i32 @fn5(i32 %0, i32 %1) {
%3 = xor i32 %1, %0
ret i32 %3
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *);
void do_banner() {
  printf(
      "MiniZip 1.01e, demo of zLib + Zip package written by Gilles Vollant\n");
  printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
}


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

x86 assembly (clang, -O2):
<do_banner>:
push   %rax
lea    0xee8(%rip),%rdi
call   1030 <puts@plt>
lea    0xf20(%rip),%rdi
pop    %rax
jmp    1030 <puts@plt>

LLVM IR (-O0):
@.str = [69 x i8] c"MiniZip 1.01e, demo of zLib + Zip package written by Gilles Vollant\0A\00"
@.str.1 = [58 x i8] c"more info at http://www.winimage.com/zLibDll/unzip.html\0A\0A\00"
define void @do_banner() {
%1 = call i32 @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str, i64 0, i64 0))
%2 = call i32 @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.1, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@str = [68 x i8] c"MiniZip 1.01e, demo of zLib + Zip package written by Gilles Vollant\00"
@str.2 = [57 x i8] c"more info at http://www.winimage.com/zLibDll/unzip.html\0A\00"
define void @do_banner() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @str, i64 0, i64 0))
%2 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @str.2, i64 0, i64 0))
ret void
}
unsigned int prince_sbox(unsigned int nibble) {
  const unsigned int sbox[] = {0xb, 0xf, 0x3, 0x2, 0xa, 0xc, 0x9, 0x1,
                               0x6, 0x7, 0x8, 0x0, 0xe, 0x5, 0xd, 0x4};
  return sbox[nibble & 0xF];
}


x86 assembly (clang, -O0):
<prince_sbox>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
lea    -0x50(%rbp),%rdi
lea    0xeda(%rip),%rsi
mov    $0x40,%edx
call   1030 <memcpy@plt>
mov    -0x4(%rbp),%eax
and    $0xf,%eax
mov    %eax,%eax
mov    -0x50(%rbp,%rax,4),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<prince_sbox>:
and    $0xf,%edi
lea    0xef6(%rip),%rax
mov    (%rax,%rdi,4),%eax
ret

LLVM IR (-O0):
@__const.prince_sbox.sbox = [16 x i32] [i32 11, i32 15, i32 3, i32 2, i32 10, i32 12, i32 9, i32 1, i32 6, i32 7, i32 8, i32 0, i32 14, i32 5, i32 13, i32 4]
define i32 @prince_sbox(i32 %0) {
%2 = alloca i32
%3 = alloca [16 x i32]
store i32 %0, i32* %2
%4 = bitcast [16 x i32]* %3 to i8*
%5 = load i32, i32* %2
%6 = and i32 %5, 15
%7 = zext i32 %6 to i64
%8 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 %7
%9 = load i32, i32* %8
ret i32 %9
}

LLVM IR (-O2):
@__const.prince_sbox.sbox = [16 x i32] [i32 11, i32 15, i32 3, i32 2, i32 10, i32 12, i32 9, i32 1, i32 6, i32 7, i32 8, i32 0, i32 14, i32 5, i32 13, i32 4]
define i32 @prince_sbox(i32 %0) {
%2 = and i32 %0, 15
%3 = zext i32 %2 to i64
%4 = getelementptr inbounds [16 x i32], [16 x i32]* @__const.prince_sbox.sbox, i64 0, i64 %3
%5 = load i32, i32* %4
ret i32 %5
}
/* Type definitions */
typedef int /*<<< orphan*/ uint8_t;

/* Variables and functions */
int /*<<< orphan*/ eeprom_update_byte(int /*<<< orphan*/ *, int /*<<< orphan*/);
void eeconfig_update_keymap(uint8_t val) {
  eeprom_update_byte((uint8_t *)4, val);
}


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

x86 assembly (clang, -O2):
<eeconfig_update_keymap>:
mov    %edi,%esi
mov    $0x4,%edi
jmp    1030 <eeprom_update_byte@plt>

LLVM IR (-O0):
define void @eeconfig_update_keymap(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
%3 = load i32, i32* %2
%4 = call i32 @eeprom_update_byte(i32* inttoptr (i64 4 to i32*), i32 %3)
ret void
}

LLVM IR (-O2):
define void @eeconfig_update_keymap(i32 %0) {
%2 = tail call i32 @eeprom_update_byte(i32* inttoptr (i64 4 to i32*), i32 %0)
ret void
}
/* Variables and functions */
double pd_random_double();
double basic_range_random(double lo, double hi) {
  return lo + (hi - lo) * pd_random_double();
}


x86 assembly (clang, -O0):
<basic_range_random>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x10(%rbp),%xmm0
subsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    $0x0,%al
call   1030 <pd_random_double@plt>
movsd  -0x20(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<basic_range_random>:
sub    $0x18,%rsp
movsd  %xmm0,0x10(%rsp)
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %eax,%eax
call   1030 <pd_random_double@plt>
mulsd  0x8(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
add    $0x18,%rsp
ret

LLVM IR (-O0):
define double @basic_range_random(double %0, double %1) {
%3 = alloca double
%4 = alloca double
store double %0, double* %3
store double %1, double* %4
%5 = load double, double* %3
%6 = load double, double* %4
%7 = load double, double* %3
%8 = fsub double %6, %7
%9 = call double (...) @pd_random_double()
%10 = call double @llvm.fmuladd.f64(double %8, double %9, double %5)
ret double %10
}

LLVM IR (-O2):
define double @basic_range_random(double %0, double %1) {
%3 = fsub double %1, %0
%4 = tail call double (...) @pd_random_double()
%5 = tail call double @llvm.fmuladd.f64(double %3, double %4, double %0)
ret double %5
}
/* Type definitions */
typedef int uint8_t;
typedef int uint32_t;

/* Variables and functions */
void ltob(uint32_t l, uint8_t *b) {
  b[0] = l >> 24;
  b[1] = l >> 16;
  b[2] = l >> 8;
  b[3] = l >> 0;
}


x86 assembly (clang, -O0):
<ltob>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x4(%rbp),%ecx
sar    $0x18,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x4(%rbp),%ecx
sar    $0x8,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x4(%rbp),%ecx
sar    $0x0,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0xc(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<ltob>:
mov    %edi,%eax
sar    $0x18,%eax
mov    %eax,(%rsi)
mov    %edi,%eax
sar    $0x10,%eax
mov    %eax,0x4(%rsi)
mov    %edi,%eax
sar    $0x8,%eax
mov    %eax,0x8(%rsi)
mov    %edi,0xc(%rsi)
ret

LLVM IR (-O0):
define void @ltob(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 = ashr i32 %5, 24
%7 = load i32*, i32** %4
%8 = getelementptr inbounds i32, i32* %7, i64 0
store i32 %6, i32* %8
%9 = load i32, i32* %3
%10 = ashr i32 %9, 16
%11 = load i32*, i32** %4
%12 = getelementptr inbounds i32, i32* %11, i64 1
store i32 %10, i32* %12
%13 = load i32, i32* %3
%14 = ashr i32 %13, 8
%15 = load i32*, i32** %4
%16 = getelementptr inbounds i32, i32* %15, i64 2
store i32 %14, i32* %16
%17 = load i32, i32* %3
%18 = ashr i32 %17, 0
%19 = load i32*, i32** %4
%20 = getelementptr inbounds i32, i32* %19, i64 3
store i32 %18, i32* %20
ret void
}

LLVM IR (-O2):
define void @ltob(i32 %0, i32* nocapture writeonly %1) {
%3 = ashr i32 %0, 24
store i32 %3, i32* %1
%4 = ashr i32 %0, 16
%5 = getelementptr inbounds i32, i32* %1, i64 1
store i32 %4, i32* %5
%6 = ashr i32 %0, 8
%7 = getelementptr inbounds i32, i32* %1, i64 2
store i32 %6, i32* %7
%8 = getelementptr inbounds i32, i32* %1, i64 3
store i32 %0, i32* %8
ret void
}
void __attribute__((always_)) x86_restore_flags(unsigned long stored_value) {
  asm volatile("push %0; popf" ::"g"(stored_value));
}


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

x86 assembly (clang, -O2):
<x86_restore_flags>:
mov    %rdi,-0x8(%rsp)
push   -0x8(%rsp)
popf
ret

LLVM IR (-O0):
define void @x86_restore_flags(i64 %0) {
%2 = alloca i64
store i64 %0, i64* %2
%3 = load i64, i64* %2
ret void
}

LLVM IR (-O2):
define void @x86_restore_flags(i64 %0) {
tail call void asm sideeffect "push $0; popf", "imr,~{dirflag},~{fpsr},~{flags}"(i64 %0)
ret void
}