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

/* Variables and functions */
int EOF;
int getc(int /*<<< orphan*/ *);
void skip_to_lf(FILE *stream) {
  register int c;
  while (((c = getc(stream)) != EOF) && (c != '\n')) {
    ;
  }
}


x86 assembly (clang, -O0):
<skip_to_lf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <getc@plt>
mov    %eax,%ecx
mov    %ecx,-0xc(%rbp)
xor    %eax,%eax
mov    0x2eb5(%rip),%rdx
cmp    (%rdx),%ecx
mov    %al,-0xd(%rbp)
je     1148 <skip_to_lf+0x38>
cmpl   $0xa,-0xc(%rbp)
setne  %al
mov    %al,-0xd(%rbp)
mov    -0xd(%rbp),%al
test   $0x1,%al
jne    1158 <skip_to_lf+0x48>
jmp    115d <skip_to_lf+0x4d>
jmp    111c <skip_to_lf+0xc>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<skip_to_lf>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%rbx
mov    0x2eca(%rip),%r14
xchg   %ax,%ax
mov    %rbx,%rdi
call   1030 <getc@plt>
cmp    $0xa,%eax
je     1132 <skip_to_lf+0x22>
cmp    (%r14),%eax
jne    1120 <skip_to_lf+0x10>
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@EOF = global i32 0
define void @skip_to_lf(i32* %0) {
%2 = alloca i32*
%3 = alloca i32
store i32* %0, i32** %2
br label %4
4: ; preds = %14, %1
%5 = load i32*, i32** %2
%6 = call i32 @getc(i32* %5)
store i32 %6, i32* %3
%7 = load i32, i32* @EOF
%8 = icmp ne i32 %6, %7
br i1 %8, label %9, label %12
9: ; preds = %4
%10 = load i32, i32* %3
%11 = icmp ne i32 %10, 10
br label %12
12: ; preds = %9, %4
%13 = phi i1 [ false, %4 ], [ %11, %9 ]
br i1 %13, label %14, label %15
14: ; preds = %12
br label %4
15: ; preds = %12
ret void
}

LLVM IR (-O2):
@EOF = global i32 0
define void @skip_to_lf(i32* nocapture %0) {
br label %2
2: ; preds = %2, %1
%3 = tail call i32 @getc(i32* %0)
%4 = load i32, i32* @EOF
%5 = icmp ne i32 %3, %4
%6 = icmp ne i32 %3, 10
%7 = and i1 %6, %5
br i1 %7, label %2, label %8
8: ; preds = %2
ret void
}
int to_hex(int x) {
  int result;
  __asm__ volatile("andl $0x0f, %%eax			\n"
                   "leal -10(%%eax), %%ebx			\n"
                   "shrl $29, %%ebx			\n"
                   "neg  %%ebx				\n"
                   "leal 55(%%eax, %%ebx), %%eax		\n"
                   : "=a"(result)
                   : "a"(x)
                   : "ebx");
  return result;
}


x86 assembly (clang, -O0):
<to_hex>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
mov    %edi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
and    $0xf,%eax
lea    -0xa(%eax),%ebx
shr    $0x1d,%ebx
neg    %ebx
lea    0x37(%eax,%ebx,1),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<to_hex>:
push   %rbx
mov    %edi,%eax
and    $0xf,%eax
lea    -0xa(%eax),%ebx
shr    $0x1d,%ebx
neg    %ebx
lea    0x37(%eax,%ebx,1),%eax
pop    %rbx
ret

LLVM IR (-O0):
define i32 @to_hex(i32 %0) {
%2 = alloca i32
%3 = alloca i32
store i32 %0, i32* %2
%4 = load i32, i32* %2
%5 = call i32 asm sideeffect "andl $$0x0f, %eax\09\09\09\0Aleal -10(%eax), %ebx\09\09\09\0Ashrl $$29, %ebx\09\09\09\0Aneg %ebx\09\09\09\09\0Aleal 55(%eax, %ebx), %eax\09\09\0A", "={ax},{ax},~{ebx},~{dirflag},~{fpsr},~{flags}"(i32 %4)
store i32 %5, i32* %3
%6 = load i32, i32* %3
ret i32 %6
}

LLVM IR (-O2):
define i32 @to_hex(i32 %0) {
%2 = tail call i32 asm sideeffect "andl $$0x0f, %eax\09\09\09\0Aleal -10(%eax), %ebx\09\09\09\0Ashrl $$29, %ebx\09\09\09\0Aneg %ebx\09\09\09\09\0Aleal 55(%eax, %ebx), %eax\09\09\0A", "={ax},{ax},~{ebx},~{dirflag},~{fpsr},~{flags}"(i32 %0)
ret i32 %2
}
/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
unsigned int read8(int /*<<< orphan*/ *);
unsigned read16(FILE *f) {
  unsigned hi = read8(f);
  unsigned lo = read8(f);
  return (hi << 8) | lo;
}


x86 assembly (clang, -O0):
<read16>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <read8@plt>
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <read8@plt>
mov    %eax,-0x10(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x8,%eax
or     -0x10(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<read16>:
push   %rbp
push   %rbx
push   %rax
mov    %rdi,%rbx
call   1030 <read8@plt>
mov    %eax,%ebp
mov    %rbx,%rdi
call   1030 <read8@plt>
shl    $0x8,%ebp
or     %ebp,%eax
add    $0x8,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define i32 @read16(i32* %0) {
%2 = alloca i32*
%3 = alloca i32
%4 = alloca i32
store i32* %0, i32** %2
%5 = load i32*, i32** %2
%6 = call i32 @read8(i32* %5)
store i32 %6, i32* %3
%7 = load i32*, i32** %2
%8 = call i32 @read8(i32* %7)
store i32 %8, i32* %4
%9 = load i32, i32* %3
%10 = shl i32 %9, 8
%11 = load i32, i32* %4
%12 = or i32 %10, %11
ret i32 %12
}

LLVM IR (-O2):
define i32 @read16(i32* %0) {
%2 = tail call i32 @read8(i32* %0)
%3 = tail call i32 @read8(i32* %0)
%4 = shl i32 %2, 8
%5 = or i32 %4, %3
ret i32 %5
}
/* Variables and functions */
int /*<<< orphan*/ bar1();
int /*<<< orphan*/ foo1();
work() {
  foo1();
  bar1();
}


x86 assembly (clang, -O0):
<work>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    $0x0,%al
call   1040 <foo1@plt>
mov    $0x0,%al
call   1030 <bar1@plt>
mov    -0x4(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<work>:
push   %rax
xor    %eax,%eax
call   1040 <foo1@plt>
xor    %eax,%eax
pop    %rcx
jmp    1030 <bar1@plt>

LLVM IR (-O0):
define i32 @work() {
%1 = alloca i32
%2 = call i32 (...) @foo1()
%3 = call i32 (...) @bar1()
%4 = load i32, i32* %1
ret i32 %4
}

LLVM IR (-O2):
define i32 @work() {
%1 = tail call i32 (...) @foo1()
%2 = tail call i32 (...) @bar1()
ret i32 undef
}
/* Variables and functions */
double cos(double);
double pow(double, double);
double f2(double x) { return cos(x) - pow(x, 3.0); }


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

x86 assembly (clang, -O2):
<f2>:
sub    $0x18,%rsp
movsd  %xmm0,0x8(%rsp)
call   1030 <cos@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0xec3(%rip),%xmm1
movsd  0x8(%rsp),%xmm0
call   1040 <pow@plt>
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
add    $0x18,%rsp
ret

LLVM IR (-O0):
define double @f2(double %0) {
%2 = alloca double
store double %0, double* %2
%3 = load double, double* %2
%4 = call double @cos(double %3)
%5 = load double, double* %2
%6 = call double @pow(double %5, double 3.000000e+00)
%7 = fsub double %4, %6
ret double %7
}

LLVM IR (-O2):
define double @f2(double %0) {
%2 = tail call double @cos(double %0)
%3 = tail call double @pow(double %0, double 3.000000e+00)
%4 = fsub double %2, %3
ret double %4
}
/* Variables and functions */
int /*<<< orphan*/ looser(int *);
int /*<<< orphan*/ winner(int);
void whathappens(int master[], int turn, int win) {
  if (win == 1)
    winner(turn);
  else
    looser(master);
}


x86 assembly (clang, -O0):
<whathappens>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
cmpl   $0x1,-0x10(%rbp)
jne    1149 <whathappens+0x29>
mov    -0xc(%rbp),%edi
call   1030 <winner@plt>
jmp    1152 <whathappens+0x32>
mov    -0x8(%rbp),%rdi
call   1040 <looser@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<whathappens>:
cmp    $0x1,%edx
jne    112c <whathappens+0xc>
mov    %esi,%edi
jmp    1030 <winner@plt>
jmp    1040 <looser@plt>

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

LLVM IR (-O2):
define void @whathappens(i32* %0, i32 %1, i32 %2) {
%4 = icmp eq i32 %2, 1
br i1 %4, label %5, label %7
5: ; preds = %3
%6 = tail call i32 @winner(i32 %1)
br label %9
7: ; preds = %3
%8 = tail call i32 @looser(i32* %0)
br label %9
9: ; preds = %7, %5
ret void
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *);
void error_fichier_inexistant(void) { printf("Erreur : Fichier inexistant\n"); }


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

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

LLVM IR (-O0):
@.str = [29 x i8] c"Erreur : Fichier inexistant\0A\00"
define void @error_fichier_inexistant() {
%1 = call i32 @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@str = [28 x i8] c"Erreur : Fichier inexistant\00"
define void @error_fichier_inexistant() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str, i64 0, i64 0))
ret void
}
char Diss_GetHexDigitAsChar(unsigned char HexDigit) {
  HexDigit &= 0x0f;
  if ((HexDigit >= 0) && (HexDigit <= 9))
    return '0' + HexDigit;
  return 'A' + (HexDigit - 10);
}


x86 assembly (clang, -O0):
<Diss_GetHexDigitAsChar>:
push   %rbp
mov    %rsp,%rbp
mov    %dil,%al
mov    %al,-0x2(%rbp)
movzbl -0x2(%rbp),%eax
and    $0xf,%eax
mov    %al,-0x2(%rbp)
movzbl -0x2(%rbp),%eax
cmp    $0x0,%eax
jl     113d <Diss_GetHexDigitAsChar+0x3d>
movzbl -0x2(%rbp),%eax
cmp    $0x9,%eax
jg     113d <Diss_GetHexDigitAsChar+0x3d>
movzbl -0x2(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x1(%rbp)
jmp    114a <Diss_GetHexDigitAsChar+0x4a>
movzbl -0x2(%rbp),%eax
sub    $0xa,%eax
add    $0x41,%eax
mov    %al,-0x1(%rbp)
movsbl -0x1(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<Diss_GetHexDigitAsChar>:
and    $0xf,%dil
lea    0x30(%rdi),%eax
lea    0x37(%rdi),%ecx
cmp    $0xa,%dil
movzbl %al,%edx
movzbl %cl,%eax
cmovb  %edx,%eax
ret

LLVM IR (-O0):
define signext i8 @Diss_GetHexDigitAsChar(i8 zeroext %0) {
%2 = alloca i8
%3 = alloca i8
store i8 %0, i8* %3
%4 = load i8, i8* %3
%5 = zext i8 %4 to i32
%6 = and i32 %5, 15
%7 = trunc i32 %6 to i8
store i8 %7, i8* %3
%8 = load i8, i8* %3
%9 = zext i8 %8 to i32
%10 = icmp sge i32 %9, 0
br i1 %10, label %11, label %20
11: ; preds = %1
%12 = load i8, i8* %3
%13 = zext i8 %12 to i32
%14 = icmp sle i32 %13, 9
br i1 %14, label %15, label %20
15: ; preds = %11
%16 = load i8, i8* %3
%17 = zext i8 %16 to i32
%18 = add nsw i32 48, %17
%19 = trunc i32 %18 to i8
store i8 %19, i8* %2
br label %26
20: ; preds = %11, %1
%21 = load i8, i8* %3
%22 = zext i8 %21 to i32
%23 = sub nsw i32 %22, 10
%24 = add nsw i32 65, %23
%25 = trunc i32 %24 to i8
store i8 %25, i8* %2
br label %26
26: ; preds = %20, %15
%27 = load i8, i8* %2
ret i8 %27
}

LLVM IR (-O2):
define signext i8 @Diss_GetHexDigitAsChar(i8 zeroext %0) {
%2 = and i8 %0, 15
%3 = icmp ult i8 %2, 10
%4 = or i8 %2, 48
%5 = add nuw nsw i8 %2, 55
%6 = select i1 %3, i8 %4, i8 %5
ret i8 %6
}
/* Variables and functions */
int strcmp(char const *, char const *);
int lexicographic_sort_reverse(const char *a, const char *b) {
  return strcmp(b, a);
}


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

x86 assembly (clang, -O2):
<lexicographic_sort_reverse>:
mov    %rdi,%rax
mov    %rsi,%rdi
mov    %rax,%rsi
jmp    1030 <strcmp@plt>

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

LLVM IR (-O2):
define i32 @lexicographic_sort_reverse(i8* nocapture %0, i8* nocapture %1) {
%3 = tail call i32 @strcmp(i8* dereferenceable(1) %1, i8* dereferenceable(1) %0)
ret i32 %3
}
int larger(int a, int b) {
  if (a >= b)
    return a;
  return b;
}


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

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

LLVM IR (-O0):
define i32 @larger(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 sge 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 @larger(i32 %0, i32 %1) {
%3 = icmp slt i32 %0, %1
%4 = select i1 %3, i32 %1, i32 %0
ret i32 %4
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, char *);
void __print_sw_title(char *sw_name) {
  printf(" ----------- [%s] ----------- \n", sw_name);
  printf(" ::. Usage: %s <password>\n\n", sw_name);
}


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

x86 assembly (clang, -O2):
<__print_sw_title>:
push   %rbx
mov    %rdi,%rbx
lea    0xee5(%rip),%rdi
mov    %rbx,%rsi
call   1030 <printf@plt>
lea    0xef6(%rip),%rdi
mov    %rbx,%rsi
pop    %rbx
jmp    1030 <printf@plt>

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

LLVM IR (-O2):
@.str = [32 x i8] c" ----------- [%s] ----------- \0A\00"
@.str.1 = [28 x i8] c" ::. Usage: %s <password>\0A\0A\00"
define void @__print_sw_title(i8* %0) {
%2 = tail call i32 @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0), i8* %0)
%3 = tail call i32 @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.1, i64 0, i64 0), i8* %0)
ret void
}
unsigned short int
unsignedshortint_ignoring_unsignedlongint(unsigned short int x,
                                          unsigned long int y) {
  return x;
}


x86 assembly (clang, -O0):
<unsignedshortint_ignoring_unsignedlongint>:
push   %rbp
mov    %rsp,%rbp
mov    %di,%ax
mov    %ax,-0x2(%rbp)
mov    %rsi,-0x10(%rbp)
movzwl -0x2(%rbp),%eax
pop    %rbp
ret

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

LLVM IR (-O0):
define zeroext i16 @unsignedshortint_ignoring_unsignedlongint(i16 zeroext %0, i64 %1) {
%3 = alloca i16
%4 = alloca i64
store i16 %0, i16* %3
store i64 %1, i64* %4
%5 = load i16, i16* %3
ret i16 %5
}

LLVM IR (-O2):
define zeroext i16 @unsignedshortint_ignoring_unsignedlongint(i16 returned zeroext %0, i64 %1) {
ret i16 %0
}
/* Variables and functions */
int add_all_ints(int /*<<< orphan*/, int /*<<< orphan*/, int /*<<< orphan*/,
                 int *, int *, int *, int *, int *, int /*<<< orphan*/ *);
void truncated_call(void) {
  int a = 0, b = 1, c = 2, d = 3;
  int *p = NULL;
  int x = add_all_ints(0, 0, 0, &a, p, &b, &c, &d, NULL);
}


x86 assembly (clang, -O0):
<truncated_call>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x8(%rbp)
movl   $0x2,-0xc(%rbp)
movl   $0x3,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%r8
xor    %edx,%edx
lea    -0x4(%rbp),%rcx
lea    -0x8(%rbp),%r9
lea    -0xc(%rbp),%r10
lea    -0x10(%rbp),%rax
xor    %esi,%esi
mov    %edx,%edi
mov    %edx,%esi
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
movq   $0x0,0x10(%rsp)
call   1030 <add_all_ints@plt>
mov    %eax,-0x1c(%rbp)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<truncated_call>:
sub    $0x18,%rsp
movl   $0x0,0x14(%rsp)
movl   $0x1,0x10(%rsp)
movl   $0x2,0xc(%rsp)
movl   $0x3,0x8(%rsp)
sub    $0x8,%rsp
lea    0x10(%rsp),%rax
lea    0x14(%rsp),%r10
lea    0x1c(%rsp),%rcx
lea    0x18(%rsp),%r9
xor    %edi,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %r8d,%r8d
push   $0x0
push   %rax
push   %r10
call   1030 <add_all_ints@plt>
add    $0x38,%rsp
ret

LLVM IR (-O0):
define void @truncated_call() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32*
%6 = alloca i32
store i32 0, i32* %1
store i32 1, i32* %2
store i32 2, i32* %3
store i32 3, i32* %4
store i32* null, i32** %5
%7 = load i32*, i32** %5
%8 = call i32 @add_all_ints(i32 0, i32 0, i32 0, i32* %1, i32* %7, i32* %2, i32* %3, i32* %4, i32* null)
store i32 %8, i32* %6
ret void
}

LLVM IR (-O2):
define void @truncated_call() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = bitcast i32* %1 to i8*
store i32 0, i32* %1
%6 = bitcast i32* %2 to i8*
store i32 1, i32* %2
%7 = bitcast i32* %3 to i8*
store i32 2, i32* %3
%8 = bitcast i32* %4 to i8*
store i32 3, i32* %4
%9 = call i32 @add_all_ints(i32 0, i32 0, i32 0, i32* %1, i32* null, i32* %2, i32* %3, i32* %4, i32* null)
ret void
}
/* Variables and functions */
int syscall(int, char const *);
int swapoff(const char *path) { return syscall(115, path); }


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

x86 assembly (clang, -O2):
<swapoff>:
mov    %rdi,%rsi
mov    $0x73,%edi
jmp    1030 <syscall@plt>

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

LLVM IR (-O2):
define i32 @swapoff(i8* %0) {
%2 = tail call i32 @syscall(i32 115, i8* %0)
ret i32 %2
}
const char *__malidrv_build_info(void) {
  return "malidrv:  CONFIG=ux500 USING_OS_MEMORY=1 API_VERSION=17 "
         "REPO_URL=r3p1-01rel0 REVISION=r3p1-01rel0 "
         "CHANGED_REVISION=r3p1-01rel0 CHANGE_DATE=r3p1-01rel0 BUILD_DATE=Sat "
         "Jul 26 07:27:43 PDT 2014 BUILD=DEBUG CPU=ux500 USING_UMP=1 "
         "USING_HWMEM=1 USING_MALI200=0 USING_MALI400=3 "
         "USING_MALI400_L2_CACHE=1 USING_GP2=0 KDIR= "
         "MALI_PLATFORM_FILE=platform/ux500/mali_platform.c "
         "OS_MEMORY_KERNEL_BUFFER_SIZE_IN_MB=16 USING_PROFILING=0 "
         "USING_INTERNAL_PROFILING=0 USING_GPU_UTILIZATION=y";
}


x86 assembly (clang, -O0):
<__malidrv_build_info>:
push   %rbp
mov    %rsp,%rbp
lea    0xef5(%rip),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<__malidrv_build_info>:
lea    0xef9(%rip),%rax
ret

LLVM IR (-O0):
@.str = [471 x i8] c"malidrv: CONFIG=ux500 USING_OS_MEMORY=1 API_VERSION=17 REPO_URL=r3p1-01rel0 REVISION=r3p1-01rel0 CHANGED_REVISION=r3p1-01rel0 CHANGE_DATE=r3p1-01rel0 BUILD_DATE=Sat Jul 26 07:27:43 PDT 2014 BUILD=DEBUG CPU=ux500 USING_UMP=1 USING_HWMEM=1 USING_MALI200=0 USING_MALI400=3 USING_MALI400_L2_CACHE=1 USING_GP2=0 KDIR= MALI_PLATFORM_FILE=platform/ux500/mali_platform.c OS_MEMORY_KERNEL_BUFFER_SIZE_IN_MB=16 USING_PROFILING=0 USING_INTERNAL_PROFILING=0 USING_GPU_UTILIZATION=y\00"
define i8* @__malidrv_build_info() {
ret i8* getelementptr inbounds ([471 x i8], [471 x i8]* @.str, i64 0, i64 0)
}

LLVM IR (-O2):
@.str = [471 x i8] c"malidrv: CONFIG=ux500 USING_OS_MEMORY=1 API_VERSION=17 REPO_URL=r3p1-01rel0 REVISION=r3p1-01rel0 CHANGED_REVISION=r3p1-01rel0 CHANGE_DATE=r3p1-01rel0 BUILD_DATE=Sat Jul 26 07:27:43 PDT 2014 BUILD=DEBUG CPU=ux500 USING_UMP=1 USING_HWMEM=1 USING_MALI200=0 USING_MALI400=3 USING_MALI400_L2_CACHE=1 USING_GP2=0 KDIR= MALI_PLATFORM_FILE=platform/ux500/mali_platform.c OS_MEMORY_KERNEL_BUFFER_SIZE_IN_MB=16 USING_PROFILING=0 USING_INTERNAL_PROFILING=0 USING_GPU_UTILIZATION=y\00"
define i8* @__malidrv_build_info() {
ret i8* getelementptr inbounds ([471 x i8], [471 x i8]* @.str, i64 0, i64 0)
}
char *file_path(struct file *file, char *buf, int count) {
  char *a;
  return a;
}


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

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

LLVM IR (-O0):
%struct.file = type opaque
define i8* @file_path(%struct.file* %0, i8* %1, i32 %2) {
%4 = alloca %struct.file*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i8*
store %struct.file* %0, %struct.file** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%8 = load i8*, i8** %7
ret i8* %8
}

LLVM IR (-O2):
%struct.file = type opaque
define noalias i8* @file_path(%struct.file* nocapture readnone %0, i8* nocapture readnone %1, i32 %2) {
ret i8* undef
}
/* Variables and functions */
int /*<<< orphan*/ kprintHexByte(unsigned char);
void kprintHexWord(unsigned short wd) {
  kprintHexByte((unsigned char)((wd & 0xFF00) >> 8));
  kprintHexByte((unsigned char)(wd & 0xFF));
}


x86 assembly (clang, -O0):
<kprintHexWord>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %di,%ax
mov    %ax,-0x2(%rbp)
movzwl -0x2(%rbp),%eax
and    $0xff00,%eax
sar    $0x8,%eax
movzbl %al,%edi
call   1030 <kprintHexByte@plt>
movzwl -0x2(%rbp),%eax
and    $0xff,%eax
movzbl %al,%edi
call   1030 <kprintHexByte@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kprintHexWord>:
push   %rbx
mov    %edi,%ebx
shr    $0x8,%edi
call   1030 <kprintHexByte@plt>
movzbl %bl,%edi
pop    %rbx
jmp    1030 <kprintHexByte@plt>

LLVM IR (-O0):
define void @kprintHexWord(i16 zeroext %0) {
%2 = alloca i16
store i16 %0, i16* %2
%3 = load i16, i16* %2
%4 = zext i16 %3 to i32
%5 = and i32 %4, 65280
%6 = ashr i32 %5, 8
%7 = trunc i32 %6 to i8
%8 = call i32 @kprintHexByte(i8 zeroext %7)
%9 = load i16, i16* %2
%10 = zext i16 %9 to i32
%11 = and i32 %10, 255
%12 = trunc i32 %11 to i8
%13 = call i32 @kprintHexByte(i8 zeroext %12)
ret void
}

LLVM IR (-O2):
define void @kprintHexWord(i16 zeroext %0) {
%2 = lshr i16 %0, 8
%3 = trunc i16 %2 to i8
%4 = tail call i32 @kprintHexByte(i8 zeroext %3)
%5 = trunc i16 %0 to i8
%6 = tail call i32 @kprintHexByte(i8 zeroext %5)
ret void
}
void omegle_http_dummy(struct http_request *req) {}


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

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

LLVM IR (-O0):
%struct.http_request = type opaque
define void @omegle_http_dummy(%struct.http_request* %0) {
%2 = alloca %struct.http_request*
store %struct.http_request* %0, %struct.http_request** %2
ret void
}

LLVM IR (-O2):
%struct.http_request = type opaque
define void @omegle_http_dummy(%struct.http_request* nocapture %0) {
ret void
}
int main() {
  int a = 10, b = 20;
  printf("IN MAIN: \n");
  printf("addr of a = %u, addr of b = %u\n\n", &a, &b);
  swap(&a, &b);
  printf("a = %d, b = %d\n", a, b);
  pointer_to_pointer();
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0xa,-0x4(%rbp)
movl   $0x14,-0x8(%rbp)
lea    0xeb3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xeb0(%rip),%rdi
lea    -0x4(%rbp),%rsi
lea    -0x8(%rbp),%rdx
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x4(%rbp),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1050 <swap@plt>
mov    -0x4(%rbp),%esi
mov    -0x8(%rbp),%edx
lea    0xea6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1040 <pointer_to_pointer@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
push   %rax
movl   $0xa,0x4(%rsp)
movl   $0x14,(%rsp)
lea    0xed7(%rip),%rdi
call   1030 <puts@plt>
lea    0xe9a(%rip),%rdi
lea    0x4(%rsp),%rbx
mov    %rsp,%r14
mov    %rbx,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <swap@plt>
mov    0x4(%rsp),%esi
mov    (%rsp),%edx
lea    0xe8b(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %eax,%eax
call   1050 <pointer_to_pointer@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@.str = [11 x i8] c"IN MAIN: \0A\00"
@.str.1 = [33 x i8] c"addr of a = %u, addr of b = %u\0A\0A\00"
@.str.2 = [16 x i8] c"a = %d, b = %d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
store i32 10, i32* %1
store i32 20, i32* %2
%3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0))
%4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0), i32* %1, i32* %2)
%5 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @swap to i32 (i32*, i32*, ...)*)(i32* %1, i32* %2)
%6 = load i32, i32* %1
%7 = load i32, i32* %2
%8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0), i32 %6, i32 %7)
%9 = call i32 (...) @pointer_to_pointer()
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [33 x i8] c"addr of a = %u, addr of b = %u\0A\0A\00"
@.str.2 = [16 x i8] c"a = %d, b = %d\0A\00"
@str = [10 x i8] c"IN MAIN: \00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = bitcast i32* %1 to i8*
store i32 10, i32* %1
%4 = bitcast i32* %2 to i8*
store i32 20, i32* %2
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str, i64 0, i64 0))
%6 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0), i32* %1, i32* %2)
%7 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @swap to i32 (i32*, i32*, ...)*)(i32* %1, i32* %2)
%8 = load i32, i32* %1
%9 = load i32, i32* %2
%10 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0), i32 %8, i32 %9)
%11 = call i32 (...) @pointer_to_pointer()
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ f();
main() {
  const int x = 0;
  if (!!f() != x)
    ;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
mov    $0x0,%al
call   1030 <f@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
cmp    $0x0,%eax
je     114a <main+0x3a>
jmp    114a <main+0x3a>
mov    -0x4(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

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

LLVM IR (-O0):
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %2
%3 = call i32 (...) @f()
%4 = icmp ne i32 %3, 0
%5 = xor i1 %4, true
%6 = xor i1 %5, true
%7 = zext i1 %6 to i32
%8 = icmp ne i32 %7, 0
br i1 %8, label %9, label %10
9: ; preds = %0
br label %10
10: ; preds = %9, %0
%11 = load i32, i32* %1
ret i32 %11
}

LLVM IR (-O2):
define i32 @main() {
%1 = tail call i32 (...) @f()
ret i32 0
}
int fn6(int a, int b) {
  int tem1 = b ^ a;
  int tem2 = a & b;
  return tem1 ^ tem2;
}


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

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

LLVM IR (-O0):
define i32 @fn6(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* %4
%8 = load i32, i32* %3
%9 = xor i32 %7, %8
store i32 %9, i32* %5
%10 = load i32, i32* %3
%11 = load i32, i32* %4
%12 = and i32 %10, %11
store i32 %12, i32* %6
%13 = load i32, i32* %5
%14 = load i32, i32* %6
%15 = xor i32 %13, %14
ret i32 %15
}

LLVM IR (-O2):
define i32 @fn6(i32 %0, i32 %1) {
%3 = or i32 %1, %0
ret i32 %3
}
int __fe_raise_inexact() {
  float f = 1.0f, g = 3.0f;
  __asm__ __volatile__("fdivs %1" : "+t"(f) : "m"(g));
  return 0;
}


x86 assembly (clang, -O0):
<__fe_raise_inexact>:
push   %rbp
mov    %rsp,%rbp
movss  0xef8(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
movss  0xee7(%rip),%xmm0
movss  %xmm0,-0x8(%rbp)
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0xc(%rbp)
flds   -0xc(%rbp)
fdivs  -0x8(%rbp)
fstps  -0x10(%rbp)
movss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<__fe_raise_inexact>:
movl   $0x40400000,-0x4(%rsp)
40
fld1
fdivs  -0x4(%rsp)
fstp   %st(0)
xor    %eax,%eax
ret

LLVM IR (-O0):
define i32 @__fe_raise_inexact() {
%1 = alloca float
%2 = alloca float
store float 1.000000e+00, float* %1
store float 3.000000e+00, float* %2
%3 = load float, float* %1
%4 = call float asm sideeffect "fdivs $1", "={st},*m,0,~{dirflag},~{fpsr},~{flags}"(float* elementtype(float) %2, float %3)
store float %4, float* %1
ret i32 0
}

LLVM IR (-O2):
define i32 @__fe_raise_inexact() {
%1 = alloca float
%2 = bitcast float* %1 to i8*
store float 3.000000e+00, float* %1
%3 = call float asm sideeffect "fdivs $1", "={st},*m,0,~{dirflag},~{fpsr},~{flags}"(float* elementtype(float) %1, float 1.000000e+00)
ret i32 0
}
int isOperatorExpRex(char ch) {
  return (ch == '+') || (ch == '-') || (ch == '*') || (ch == '.') ||
         (ch == '2') || (ch == '?');
}


x86 assembly (clang, -O0):
<isOperatorExpRex>:
push   %rbp
mov    %rsp,%rbp
mov    %dil,%al
mov    %al,-0x1(%rbp)
movsbl -0x1(%rbp),%ecx
mov    $0x1,%al
cmp    $0x2b,%ecx
mov    %al,-0x2(%rbp)
je     1171 <isOperatorExpRex+0x71>
movsbl -0x1(%rbp),%ecx
mov    $0x1,%al
cmp    $0x2d,%ecx
mov    %al,-0x2(%rbp)
je     1171 <isOperatorExpRex+0x71>
movsbl -0x1(%rbp),%ecx
mov    $0x1,%al
cmp    $0x2a,%ecx
mov    %al,-0x2(%rbp)
je     1171 <isOperatorExpRex+0x71>
movsbl -0x1(%rbp),%ecx
mov    $0x1,%al
cmp    $0x2e,%ecx
mov    %al,-0x2(%rbp)
je     1171 <isOperatorExpRex+0x71>
movsbl -0x1(%rbp),%ecx
mov    $0x1,%al
cmp    $0x32,%ecx
mov    %al,-0x2(%rbp)
je     1171 <isOperatorExpRex+0x71>
movsbl -0x1(%rbp),%eax
cmp    $0x3f,%eax
sete   %al
mov    %al,-0x2(%rbp)
mov    -0x2(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<isOperatorExpRex>:
lea    -0x2a(%rdi),%eax
cmp    $0x9,%al
jae    1119 <isOperatorExpRex+0x19>
movzbl %al,%ecx
mov    $0x1,%eax
mov    $0x11b,%edx
bt     %ecx,%edx
jb     1122 <isOperatorExpRex+0x22>
xor    %eax,%eax
cmp    $0x3f,%dil
sete   %al
ret

LLVM IR (-O0):
define i32 @isOperatorExpRex(i8 signext %0) {
%2 = alloca i8
store i8 %0, i8* %2
%3 = load i8, i8* %2
%4 = sext i8 %3 to i32
%5 = icmp eq i32 %4, 43
br i1 %5, label %26, label %6
6: ; preds = %1
%7 = load i8, i8* %2
%8 = sext i8 %7 to i32
%9 = icmp eq i32 %8, 45
br i1 %9, label %26, label %10
10: ; preds = %6
%11 = load i8, i8* %2
%12 = sext i8 %11 to i32
%13 = icmp eq i32 %12, 42
br i1 %13, label %26, label %14
14: ; preds = %10
%15 = load i8, i8* %2
%16 = sext i8 %15 to i32
%17 = icmp eq i32 %16, 46
br i1 %17, label %26, label %18
18: ; preds = %14
%19 = load i8, i8* %2
%20 = sext i8 %19 to i32
%21 = icmp eq i32 %20, 50
br i1 %21, label %26, label %22
22: ; preds = %18
%23 = load i8, i8* %2
%24 = sext i8 %23 to i32
%25 = icmp eq i32 %24, 63
br label %26
26: ; preds = %22, %18, %14, %10, %6, %1
%27 = phi i1 [ true, %18 ], [ true, %14 ], [ true, %10 ], [ true, %6 ], [ true, %1 ], [ %25, %22 ]
%28 = zext i1 %27 to i32
ret i32 %28
}

LLVM IR (-O2):
define i32 @isOperatorExpRex(i8 signext %0) {
%2 = add i8 %0, -42
%3 = icmp ult i8 %2, 9
br i1 %3, label %7, label %4
4: ; preds = %7, %1
%5 = icmp eq i8 %0, 63
%6 = zext i1 %5 to i32
br label %12
7: ; preds = %1
%8 = zext i8 %2 to i16
%9 = lshr i16 283, %8
%10 = and i16 %9, 1
%11 = icmp eq i16 %10, 0
br i1 %11, label %4, label %12
12: ; preds = %7, %4
%13 = phi i32 [ %6, %4 ], [ 1, %7 ]
ret i32 %13
}
/* Type definitions */
struct Barcode_Item {
  int dummy;
};
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ svg_bars(struct Barcode_Item *, int /*<<< orphan*/ *);
int /*<<< orphan*/ svg_end(int /*<<< orphan*/ *);
int /*<<< orphan*/ svg_start(struct Barcode_Item *, int /*<<< orphan*/ *);
int /*<<< orphan*/ svg_text(struct Barcode_Item *, int /*<<< orphan*/ *);
int Barcode_svg_print(struct Barcode_Item *bc, FILE *f) {
  svg_start(bc, f);
  svg_bars(bc, f);
  svg_text(bc, f);
  svg_end(f);
  return 0;
}


x86 assembly (clang, -O0):
<Barcode_svg_print>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <svg_start@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1040 <svg_bars@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1050 <svg_text@plt>
mov    -0x10(%rbp),%rdi
call   1060 <svg_end@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Barcode_svg_print>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%rbx
mov    %rdi,%r14
call   1030 <svg_start@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1040 <svg_bars@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1050 <svg_text@plt>
mov    %rbx,%rdi
call   1060 <svg_end@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
%struct.Barcode_Item = type { i32 }
define i32 @Barcode_svg_print(%struct.Barcode_Item* %0, i32* %1) {
%3 = alloca %struct.Barcode_Item*
%4 = alloca i32*
store %struct.Barcode_Item* %0, %struct.Barcode_Item** %3
store i32* %1, i32** %4
%5 = load %struct.Barcode_Item*, %struct.Barcode_Item** %3
%6 = load i32*, i32** %4
%7 = call i32 @svg_start(%struct.Barcode_Item* %5, i32* %6)
%8 = load %struct.Barcode_Item*, %struct.Barcode_Item** %3
%9 = load i32*, i32** %4
%10 = call i32 @svg_bars(%struct.Barcode_Item* %8, i32* %9)
%11 = load %struct.Barcode_Item*, %struct.Barcode_Item** %3
%12 = load i32*, i32** %4
%13 = call i32 @svg_text(%struct.Barcode_Item* %11, i32* %12)
%14 = load i32*, i32** %4
%15 = call i32 @svg_end(i32* %14)
ret i32 0
}

LLVM IR (-O2):
%struct.Barcode_Item = type { i32 }
define i32 @Barcode_svg_print(%struct.Barcode_Item* %0, i32* %1) {
%3 = tail call i32 @svg_start(%struct.Barcode_Item* %0, i32* %1)
%4 = tail call i32 @svg_bars(%struct.Barcode_Item* %0, i32* %1)
%5 = tail call i32 @svg_text(%struct.Barcode_Item* %0, i32* %1)
%6 = tail call i32 @svg_end(i32* %1)
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, int);
int main(void) {
  int a;
  a = 0 ?: 3;
  printf("a = %i\n", a);
  return 0;
}


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

x86 assembly (clang, -O2):
<main>:
push   %rax
lea    0xee8(%rip),%rdi
mov    $0x3,%esi
call   1030 <printf@plt>
xor    %eax,%eax
pop    %rcx
ret

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

LLVM IR (-O2):
@.str = [8 x i8] c"a = %i\0A\00"
define i32 @main() {
%1 = tail call i32 @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i32 3)
ret i32 0
}
/* Variables and functions */
int EINVAL;
__attribute__((visibility("default"))) int sd_bus_flush(void *bus) {
  return -EINVAL;
}


x86 assembly (clang, -O0):
<sd_bus_flush>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
xor    %eax,%eax
mov    0x2ecf(%rip),%rcx
sub    (%rcx),%eax
pop    %rbp
ret

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

LLVM IR (-O0):
@EINVAL = global i32 0
define i32 @sd_bus_flush(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i32, i32* @EINVAL
%4 = sub nsw i32 0, %3
ret i32 %4
}

LLVM IR (-O2):
@EINVAL = global i32 0
define i32 @sd_bus_flush(i8* nocapture readnone %0) {
%2 = load i32, i32* @EINVAL
%3 = sub nsw i32 0, %2
ret i32 %3
}
void ff_hevc_put_hevc_bi_epel_v64_10_sse4() {}


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

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

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

LLVM IR (-O2):
define void @ff_hevc_put_hevc_bi_epel_v64_10_sse4() {
ret void
}
/* Type definitions */
typedef int uint32_t;
typedef scalar_t__ time_t;
typedef int /*<<< orphan*/ out_msg;

/* Variables and functions */
int /*<<< orphan*/ _xmit(char *);
int /*<<< orphan*/ snprintf(char *, int, char *, int, long);
scalar_t__ time(int /*<<< orphan*/ *);
void _start_job(long my_job_id) {
  time_t now = time(NULL);
  char out_msg[128];
  snprintf(out_msg, sizeof(out_msg),
           "TS=%u AUTH=root DT=CMD=STARTJOB ARG=%ld TASKLIST=", (uint32_t)now,
           my_job_id);
  _xmit(out_msg);
}


x86 assembly (clang, -O0):
<_start_job>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1050 <time@plt>
mov    %rax,-0x10(%rbp)
lea    -0x90(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    %eax,%ecx
mov    -0x8(%rbp),%r8
mov    $0x80,%esi
lea    0xe97(%rip),%rdx
call   1030 <snprintf@plt>
lea    -0x90(%rbp),%rdi
call   1040 <_xmit@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_start_job>:
push   %r14
push   %rbx
sub    $0x88,%rsp
mov    %rdi,%rbx
xor    %edi,%edi
call   1050 <time@plt>
lea    0xeb5(%rip),%rdx
mov    %rsp,%r14
mov    %r14,%rdi
mov    $0x80,%esi
mov    %eax,%ecx
mov    %rbx,%r8
call   1030 <snprintf@plt>
mov    %r14,%rdi
call   1040 <_xmit@plt>
add    $0x88,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@.str = [50 x i8] c"TS=%u AUTH=root DT=CMD=STARTJOB ARG=%ld TASKLIST=\00"
define void @_start_job(i64 %0) {
%2 = alloca i64
%3 = alloca i64
%4 = alloca [128 x i8]
store i64 %0, i64* %2
%5 = call i64 @time(i32* null)
store i64 %5, i64* %3
%6 = getelementptr inbounds [128 x i8], [128 x i8]* %4, i64 0, i64 0
%7 = load i64, i64* %3
%8 = trunc i64 %7 to i32
%9 = load i64, i64* %2
%10 = call i32 @snprintf(i8* %6, i32 128, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str, i64 0, i64 0), i32 %8, i64 %9)
%11 = getelementptr inbounds [128 x i8], [128 x i8]* %4, i64 0, i64 0
%12 = call i32 @_xmit(i8* %11)
ret void
}

LLVM IR (-O2):
@.str = [50 x i8] c"TS=%u AUTH=root DT=CMD=STARTJOB ARG=%ld TASKLIST=\00"
define void @_start_job(i64 %0) {
%2 = alloca [128 x i8]
%3 = tail call i64 @time(i32* null)
%4 = getelementptr inbounds [128 x i8], [128 x i8]* %2, i64 0, i64 0
%5 = trunc i64 %3 to i32
%6 = call i32 @snprintf(i8* %4, i32 128, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str, i64 0, i64 0), i32 %5, i64 %0)
%7 = call i32 @_xmit(i8* %4)
ret void
}
/* Type definitions */
typedef int /*<<< orphan*/ pthread_cond_t;

/* Variables and functions */
int /*<<< orphan*/ abort();
int /*<<< orphan*/ fputs(char *, int /*<<< orphan*/);
scalar_t__ pthread_cond_broadcast(int /*<<< orphan*/ *);
int /*<<< orphan*/ stderr;
void xcond_broadcast(pthread_cond_t *c) {
  if (pthread_cond_broadcast(c)) {
    fputs("xcond_broadcast\n", stderr);
    abort();
  }
}


x86 assembly (clang, -O0):
<xcond_broadcast>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <pthread_cond_broadcast@plt>
cmp    $0x0,%rax
je     116b <xcond_broadcast+0x3b>
mov    0x2e8a(%rip),%rax
mov    (%rax),%esi
lea    0xea1(%rip),%rdi
call   1050 <fputs@plt>
mov    $0x0,%al
call   1030 <abort@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<xcond_broadcast>:
push   %rax
call   1040 <pthread_cond_broadcast@plt>
test   %rax,%rax
jne    113d <xcond_broadcast+0xd>
pop    %rax
ret
mov    0x2e9c(%rip),%rax
mov    (%rax),%esi
lea    0xeb3(%rip),%rdi
call   1050 <fputs@plt>
xor    %eax,%eax
call   1030 <abort@plt>

LLVM IR (-O0):
@.str = [17 x i8] c"xcond_broadcast\0A\00"
@stderr = global i32 0
define void @xcond_broadcast(i32* %0) {
%2 = alloca i32*
store i32* %0, i32** %2
%3 = load i32*, i32** %2
%4 = call i64 @pthread_cond_broadcast(i32* %3)
%5 = icmp ne i64 %4, 0
br i1 %5, label %6, label %10
6: ; preds = %1
%7 = load i32, i32* @stderr
%8 = call i32 @fputs(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), i32 %7)
%9 = call i32 (...) @abort()
unreachable
10: ; preds = %1
ret void
}

LLVM IR (-O2):
@.str = [17 x i8] c"xcond_broadcast\0A\00"
@stderr = global i32 0
define void @xcond_broadcast(i32* %0) {
%2 = tail call i64 @pthread_cond_broadcast(i32* %0)
%3 = icmp eq i64 %2, 0
br i1 %3, label %8, label %4
4: ; preds = %1
%5 = load i32, i32* @stderr
%6 = tail call i32 @fputs(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), i32 %5)
%7 = tail call i32 (...) @abort()
unreachable
8: ; preds = %1
ret void
}
/* Variables and functions */
int /*<<< orphan*/ gtk_main();
int /*<<< orphan*/ window_1_SI();
int showInfoMain() {
  window_1_SI();
  gtk_main();
  return 0;
}


x86 assembly (clang, -O0):
<showInfoMain>:
push   %rbp
mov    %rsp,%rbp
mov    $0x0,%al
call   1040 <window_1_SI@plt>
mov    $0x0,%al
call   1030 <gtk_main@plt>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<showInfoMain>:
push   %rax
xor    %eax,%eax
call   1040 <window_1_SI@plt>
xor    %eax,%eax
call   1030 <gtk_main@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
define i32 @showInfoMain() {
%1 = call i32 (...) @window_1_SI()
%2 = call i32 (...) @gtk_main()
ret i32 0
}

LLVM IR (-O2):
define i32 @showInfoMain() {
%1 = tail call i32 (...) @window_1_SI()
%2 = tail call i32 (...) @gtk_main()
ret i32 0
}
/* Type definitions */
struct passwd {
  int /*<<< orphan*/ pw_dir;
};

/* Variables and functions */
struct passwd *getpwuid(int /*<<< orphan*/);
int /*<<< orphan*/ getuid();
int /*<<< orphan*/ strcat(char *, char *);
int /*<<< orphan*/ strcpy(char *, int /*<<< orphan*/);
void get_home_dir(char *home) {
  struct passwd *pw = getpwuid(getuid());
  strcpy(home, pw->pw_dir);
  strcat(home, "/.tgfs/");
}


x86 assembly (clang, -O0):
<get_home_dir>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    $0x0,%al
call   1050 <getuid@plt>
mov    %eax,%edi
call   1040 <getpwuid@plt>
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%esi
call   1030 <strcpy@plt>
mov    -0x8(%rbp),%rdi
lea    0xe88(%rip),%rsi
call   1060 <strcat@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_home_dir>:
push   %rbx
mov    %rdi,%rbx
xor    %eax,%eax
call   1050 <getuid@plt>
mov    %eax,%edi
call   1040 <getpwuid@plt>
mov    (%rax),%esi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0xe9d(%rip),%rsi
mov    %rbx,%rdi
pop    %rbx
jmp    1060 <strcat@plt>

LLVM IR (-O0):
%struct.passwd = type { i32 }
@.str = [8 x i8] c"/.tgfs/\00"
define void @get_home_dir(i8* %0) {
%2 = alloca i8*
%3 = alloca %struct.passwd*
store i8* %0, i8** %2
%4 = call i32 (...) @getuid()
%5 = call %struct.passwd* @getpwuid(i32 %4)
store %struct.passwd* %5, %struct.passwd** %3
%6 = load i8*, i8** %2
%7 = load %struct.passwd*, %struct.passwd** %3
%8 = getelementptr inbounds %struct.passwd, %struct.passwd* %7, i32 0, i32 0
%9 = load i32, i32* %8
%10 = call i32 @strcpy(i8* %6, i32 %9)
%11 = load i8*, i8** %2
%12 = call i32 @strcat(i8* %11, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
%struct.passwd = type { i32 }
@.str = [8 x i8] c"/.tgfs/\00"
define void @get_home_dir(i8* %0) {
%2 = tail call i32 (...) @getuid()
%3 = tail call %struct.passwd* @getpwuid(i32 %2)
%4 = getelementptr inbounds %struct.passwd, %struct.passwd* %3, i64 0, i32 0
%5 = load i32, i32* %4
%6 = tail call i32 @strcpy(i8* %0, i32 %5)
%7 = tail call i32 @strcat(i8* %0, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
ret void
}
/* Variables and functions */
scalar_t__ __infer_nondet_int();
void FN_loop_once_return_bad() {
  while (__infer_nondet_int()) {
    return;
  }
}


x86 assembly (clang, -O0):
<FN_loop_once_return_bad>:
push   %rbp
mov    %rsp,%rbp
jmp    1119 <FN_loop_once_return_bad+0x9>
mov    $0x0,%al
call   1030 <__infer_nondet_int@plt>
cmp    $0x0,%rax
je     112f <FN_loop_once_return_bad+0x1f>
jmp    112f <FN_loop_once_return_bad+0x1f>
pop    %rbp
ret

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

LLVM IR (-O0):
define void @FN_loop_once_return_bad() {
br label %1
1: ; preds = %0
%2 = call i64 (...) @__infer_nondet_int()
%3 = icmp ne i64 %2, 0
br i1 %3, label %4, label %5
4: ; preds = %1
br label %5
5: ; preds = %4, %1
ret void
}

LLVM IR (-O2):
define void @FN_loop_once_return_bad() {
%1 = tail call i64 (...) @__infer_nondet_int()
ret void
}
/* Variables and functions */
int /*<<< orphan*/ SYS_execveat;
int /*<<< orphan*/ syscall5(int /*<<< orphan*/, int, uintptr_t, uintptr_t,
                            uintptr_t, int);
void sys_execveat(int dirfd, const char *pathname, char *const argv[],
                  char *const envp[], int flags) {
  syscall5(SYS_execveat, dirfd, (uintptr_t)pathname, (uintptr_t)argv,
           (uintptr_t)envp, flags);
}


x86 assembly (clang, -O0):
<sys_execveat>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    0x2eae(%rip),%rax
mov    (%rax),%edi
mov    -0x4(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%r8
mov    -0x24(%rbp),%r9d
call   1030 <syscall5@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sys_execveat>:
mov    %r8d,%r9d
mov    %rcx,%r8
mov    %rdx,%rcx
mov    %rsi,%rdx
mov    %edi,%esi
mov    0x2ebb(%rip),%rax
mov    (%rax),%edi
jmp    1030 <syscall5@plt>

LLVM IR (-O0):
@SYS_execveat = global i32 0
define void @sys_execveat(i32 %0, i8* %1, i8** %2, i8** %3, i32 %4) {
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8**
%9 = alloca i8**
%10 = alloca i32
store i32 %0, i32* %6
store i8* %1, i8** %7
store i8** %2, i8*** %8
store i8** %3, i8*** %9
store i32 %4, i32* %10
%11 = load i32, i32* @SYS_execveat
%12 = load i32, i32* %6
%13 = load i8*, i8** %7
%14 = ptrtoint i8* %13 to i64
%15 = load i8**, i8*** %8
%16 = ptrtoint i8** %15 to i64
%17 = load i8**, i8*** %9
%18 = ptrtoint i8** %17 to i64
%19 = load i32, i32* %10
%20 = call i32 @syscall5(i32 %11, i32 %12, i64 %14, i64 %16, i64 %18, i32 %19)
ret void
}

LLVM IR (-O2):
@SYS_execveat = global i32 0
define void @sys_execveat(i32 %0, i8* %1, i8** %2, i8** %3, i32 %4) {
%6 = load i32, i32* @SYS_execveat
%7 = ptrtoint i8* %1 to i64
%8 = ptrtoint i8** %2 to i64
%9 = ptrtoint i8** %3 to i64
%10 = tail call i32 @syscall5(i32 %6, i32 %0, i64 %7, i64 %8, i64 %9, i32 %4)
ret void
}
void foo783(int p) {}


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

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

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

LLVM IR (-O2):
define void @foo783(i32 %0) {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ memcpy(void *, void *, unsigned int);
void OsaMemCpy(void *d, void *s, unsigned int len) { memcpy(d, s, len); }


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

x86 assembly (clang, -O2):
<OsaMemCpy>:
jmp    1030 <memcpy@plt>

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

LLVM IR (-O2):
define void @OsaMemCpy(i8* %0, i8* %1, i32 %2) {
%4 = tail call i32 @memcpy(i8* %0, i8* %1, i32 %2)
ret void
}