xunge/DecIR huggingface dataset:
/* Variables and functions */
int /*<<< orphan*/ printf(char *, int);
int main(void) {
  unsigned char i = 1;
  for (int numero = 20; i <= 6; numero += -6) {
    printf("%d\n", numero);
    i++;
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
movb   $0x1,-0x5(%rbp)
movl   $0x14,-0xc(%rbp)
movzbl -0x5(%rbp),%eax
cmp    $0x6,%eax
jg     115c <main+0x4c>
mov    -0xc(%rbp),%esi
lea    0xebf(%rip),%rdi
call   1030 <printf@plt>
mov    -0x5(%rbp),%al
add    $0x1,%al
mov    %al,-0x5(%rbp)
mov    -0xc(%rbp),%eax
add    $0xfffffffa,%eax
mov    %eax,-0xc(%rbp)
jmp    112a <main+0x1a>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
lea    0xee8(%rip),%rbx
mov    %rbx,%rdi
mov    $0x14,%esi
call   1030 <printf@plt>
mov    %rbx,%rdi
mov    $0xe,%esi
call   1030 <printf@plt>
mov    %rbx,%rdi
mov    $0x8,%esi
call   1030 <printf@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
call   1030 <printf@plt>
mov    %rbx,%rdi
mov    $0xfffffffc,%esi
call   1030 <printf@plt>
mov    %rbx,%rdi
mov    $0xfffffff6,%esi
call   1030 <printf@plt>
xor    %eax,%eax
pop    %rbx
ret

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

LLVM IR (-O2):
@.str = [4 x i8] c"%d\0A\00"
define i32 @main() {
%1 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 20)
%2 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 14)
%3 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 8)
%4 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 2)
%5 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 -4)
%6 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 -10)
ret i32 0
}
void gselect_(params, actno, maxno, list, return_code) double *params;
int *actno, *maxno;
float *list;
int *return_code;
{
  *actno = 0;
  *return_code = 1;
}


x86 assembly (clang, -O0):
<gselect_>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<gselect_>:
movl   $0x0,(%rsi)
movl   $0x1,(%r8)
ret

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

LLVM IR (-O2):
define void @gselect_(double* nocapture readnone %0, i32* nocapture writeonly %1, i32* nocapture readnone %2, float* nocapture readnone %3, i32* nocapture writeonly %4) {
store i32 0, i32* %1
store i32 1, i32* %4
ret void
}
/* Variables and functions */
int /*<<< orphan*/ setLastError(char *);
int /*<<< orphan*/ setLastRC(int /*<<< orphan*/);
int numeroteInit() {
  setLastRC(0);
  setLastError("OK");
  return 0;
}


x86 assembly (clang, -O0):
<numeroteInit>:
push   %rbp
mov    %rsp,%rbp
xor    %edi,%edi
call   1040 <setLastRC@plt>
lea    0xece(%rip),%rdi
call   1030 <setLastError@plt>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<numeroteInit>:
push   %rax
xor    %edi,%edi
call   1040 <setLastRC@plt>
lea    0xed1(%rip),%rdi
call   1030 <setLastError@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [3 x i8] c"OK\00"
define i32 @numeroteInit() {
%1 = call i32 @setLastRC(i32 0)
%2 = call i32 @setLastError(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
ret i32 0
}

LLVM IR (-O2):
@.str = [3 x i8] c"OK\00"
define i32 @numeroteInit() {
%1 = tail call i32 @setLastRC(i32 0)
%2 = tail call i32 @setLastError(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
ret i32 0
}
/* Variables and functions */
scalar_t__ isspace(int);
int is_delim(int ch) {
  return isspace(ch) || ch == 0 || ch == '(' || ch == ')' || ch == '"' ||
         ch == ';';
}


x86 assembly (clang, -O0):
<is_delim>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%edi
call   1030 <isspace@plt>
mov    %rax,%rcx
mov    $0x1,%al
cmp    $0x0,%rcx
mov    %al,-0x5(%rbp)
jne    117b <is_delim+0x6b>
mov    $0x1,%al
cmpl   $0x0,-0x4(%rbp)
mov    %al,-0x5(%rbp)
je     117b <is_delim+0x6b>
mov    $0x1,%al
cmpl   $0x28,-0x4(%rbp)
mov    %al,-0x5(%rbp)
je     117b <is_delim+0x6b>
mov    $0x1,%al
cmpl   $0x29,-0x4(%rbp)
mov    %al,-0x5(%rbp)
je     117b <is_delim+0x6b>
mov    $0x1,%al
cmpl   $0x22,-0x4(%rbp)
mov    %al,-0x5(%rbp)
je     117b <is_delim+0x6b>
cmpl   $0x3b,-0x4(%rbp)
sete   %al
mov    %al,-0x5(%rbp)
mov    -0x5(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<is_delim>:
push   %rbx
mov    %edi,%ebx
call   1030 <isspace@plt>
mov    %rax,%rcx
mov    $0x1,%eax
test   %rcx,%rcx
je     1127 <is_delim+0x17>
pop    %rbx
ret
cmp    $0x29,%ebx
ja     113e <is_delim+0x2e>
mov    %ebx,%ecx
movabs $0x30400000001,%rdx
bt     %rcx,%rdx
jb     1125 <is_delim+0x15>
xor    %eax,%eax
cmp    $0x3b,%ebx
sete   %al
pop    %rbx
ret

LLVM IR (-O0):
define i32 @is_delim(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
%3 = load i32, i32* %2
%4 = call i64 @isspace(i32 %3)
%5 = icmp ne i64 %4, 0
br i1 %5, label %21, label %6
6: ; preds = %1
%7 = load i32, i32* %2
%8 = icmp eq i32 %7, 0
br i1 %8, label %21, label %9
9: ; preds = %6
%10 = load i32, i32* %2
%11 = icmp eq i32 %10, 40
br i1 %11, label %21, label %12
12: ; preds = %9
%13 = load i32, i32* %2
%14 = icmp eq i32 %13, 41
br i1 %14, label %21, label %15
15: ; preds = %12
%16 = load i32, i32* %2
%17 = icmp eq i32 %16, 34
br i1 %17, label %21, label %18
18: ; preds = %15
%19 = load i32, i32* %2
%20 = icmp eq i32 %19, 59
br label %21
21: ; preds = %18, %15, %12, %9, %6, %1
%22 = phi i1 [ true, %15 ], [ true, %12 ], [ true, %9 ], [ true, %6 ], [ true, %1 ], [ %20, %18 ]
%23 = zext i1 %22 to i32
ret i32 %23
}

LLVM IR (-O2):
define i32 @is_delim(i32 %0) {
%2 = tail call i64 @isspace(i32 %0)
%3 = freeze i64 %2
%4 = icmp eq i64 %3, 0
br i1 %4, label %5, label %9
5: ; preds = %1
switch i32 %0, label %6 [
i32 41, label %9
i32 40, label %9
i32 34, label %9
i32 0, label %9
]
6: ; preds = %5
%7 = icmp eq i32 %0, 59
%8 = zext i1 %7 to i32
br label %9
9: ; preds = %5, %5, %5, %5, %1, %6
%10 = phi i32 [ 1, %5 ], [ %8, %6 ], [ 1, %1 ], [ 1, %5 ], [ 1, %5 ], [ 1, %5 ]
ret i32 %10
}
void otp(double T, double *Y, double *YP) { Y[6] = -Y[0]; }


x86 assembly (clang, -O0):
<otp>:
push   %rbp
mov    %rsp,%rbp
movsd  %xmm0,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x30(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<otp>:
movsd  (%rdi),%xmm0
xorps  0xef5(%rip),%xmm0
movlps %xmm0,0x30(%rdi)
ret

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

LLVM IR (-O2):
define void @otp(double %0, double* nocapture %1, double* nocapture readnone %2) {
%4 = load double, double* %1
%5 = fneg double %4
%6 = getelementptr inbounds double, double* %1, i64 6
store double %5, double* %6
ret void
}
int gotoStatementFunction() {
  goto done;
done:
  return 0;
}


x86 assembly (clang, -O0):
<gotoStatementFunction>:
push   %rbp
mov    %rsp,%rbp
jmp    1109 <gotoStatementFunction+0x9>
xor    %eax,%eax
pop    %rbp
ret

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

LLVM IR (-O0):
define i32 @gotoStatementFunction() {
br label %1
1: ; preds = %0
ret i32 0
}

LLVM IR (-O2):
define i32 @gotoStatementFunction() {
ret i32 0
}
void check_stack() {}


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

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

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

LLVM IR (-O2):
define void @check_stack() {
ret void
}
void backlight_enable(void) {
  (*((volatile unsigned long *)0x7F0080A4)) |= (1 << 14);
}


x86 assembly (clang, -O0):
<backlight_enable>:
push   %rbp
mov    %rsp,%rbp
mov    $0x7f0080a4,%eax
mov    (%rax),%rcx
or     $0x4000,%rcx
mov    $0x7f0080a4,%eax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<backlight_enable>:
orq    $0x4000,0x7f0080a4
ret

LLVM IR (-O0):
define void @backlight_enable() {
%1 = load volatile i64, i64* inttoptr (i64 2130739364 to i64*)
%2 = or i64 %1, 16384
store volatile i64 %2, i64* inttoptr (i64 2130739364 to i64*)
ret void
}

LLVM IR (-O2):
define void @backlight_enable() {
%1 = load volatile i64, i64* inttoptr (i64 2130739364 to i64*)
%2 = or i64 %1, 16384
store volatile i64 %2, i64* inttoptr (i64 2130739364 to i64*)
ret void
}
/* Type definitions */
typedef int __u32;

/* Variables and functions */
__u32 ceph_frag_make(__u32 b, __u32 v) {
  return (b << 24) | (v & (0xffffffu << (24 - b)) & 0xffffffu);
}


x86 assembly (clang, -O0):
<ceph_frag_make>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x18,%eax
mov    -0x8(%rbp),%ecx
mov    %ecx,-0xc(%rbp)
mov    $0x18,%ecx
sub    -0x4(%rbp),%ecx
mov    $0xffffff,%edx
shl    %cl,%edx
mov    -0xc(%rbp),%ecx
and    %edx,%ecx
and    $0xffffff,%ecx
or     %ecx,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<ceph_frag_make>:
mov    $0x18,%cl
sub    %dil,%cl
mov    $0xffffff,%eax
shl    %cl,%eax
shl    $0x18,%edi
and    %esi,%eax
and    $0xffffff,%eax
or     %edi,%eax
ret

LLVM IR (-O0):
define i32 @ceph_frag_make(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 = shl i32 %5, 24
%7 = load i32, i32* %4
%8 = load i32, i32* %3
%9 = sub nsw i32 24, %8
%10 = shl i32 16777215, %9
%11 = and i32 %7, %10
%12 = and i32 %11, 16777215
%13 = or i32 %6, %12
ret i32 %13
}

LLVM IR (-O2):
define i32 @ceph_frag_make(i32 %0, i32 %1) {
%3 = shl i32 %0, 24
%4 = sub nsw i32 24, %0
%5 = shl i32 16777215, %4
%6 = and i32 %1, 16777215
%7 = and i32 %6, %5
%8 = or i32 %7, %3
ret i32 %8
}
/* Variables and functions */
int /*<<< orphan*/ screen_toggle_fullscreen();
__attribute__((visibility("default"))) void ChangeWindow(void) {
  screen_toggle_fullscreen();
}


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

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

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

LLVM IR (-O2):
define void @ChangeWindow() {
%1 = tail call i32 (...) @screen_toggle_fullscreen()
ret void
}
int fun494() { return 494; }


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

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

LLVM IR (-O0):
define i32 @fun494() {
ret i32 494
}

LLVM IR (-O2):
define i32 @fun494() {
ret i32 494
}
/* Variables and functions */
int /*<<< orphan*/ close(int);
int /*<<< orphan*/ wprintf(char *, int);
extern void *net_fail(int fd) {
  close(fd);
  wprintf(L"net_fail(): closing fd %d due to errors\n", fd);
  return NULL;
}


x86 assembly (clang, -O0):
<net_fail>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%edi
call   1030 <close@plt>
mov    -0x4(%rbp),%esi
lea    0xec3(%rip),%rdi
call   1040 <wprintf@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<net_fail>:
push   %rbx
mov    %edi,%ebx
call   1030 <close@plt>
lea    0xed1(%rip),%rdi
mov    %ebx,%esi
call   1040 <wprintf@plt>
xor    %eax,%eax
pop    %rbx
ret

LLVM IR (-O0):
@.str = [41 x i32] [i32 110, i32 101, i32 116, i32 95, i32 102, i32 97, i32 105, i32 108, i32 40, i32 41, i32 58, i32 32, i32 99, i32 108, i32 111, i32 115, i32 105, i32 110, i32 103, i32 32, i32 102, i32 100, i32 32, i32 37, i32 100, i32 32, i32 100, i32 117, i32 101, i32 32, i32 116, i32 111, i32 32, i32 101, i32 114, i32 114, i32 111, i32 114, i32 115, i32 10, i32 0]
define i8* @net_fail(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
%3 = load i32, i32* %2
%4 = call i32 @close(i32 %3)
%5 = load i32, i32* %2
%6 = call i32 @wprintf(i8* bitcast ([41 x i32]* @.str to i8*), i32 %5)
ret i8* null
}

LLVM IR (-O2):
@.str = [41 x i32] [i32 110, i32 101, i32 116, i32 95, i32 102, i32 97, i32 105, i32 108, i32 40, i32 41, i32 58, i32 32, i32 99, i32 108, i32 111, i32 115, i32 105, i32 110, i32 103, i32 32, i32 102, i32 100, i32 32, i32 37, i32 100, i32 32, i32 100, i32 117, i32 101, i32 32, i32 116, i32 111, i32 32, i32 101, i32 114, i32 114, i32 111, i32 114, i32 115, i32 10, i32 0]
define noalias i8* @net_fail(i32 %0) {
%2 = tail call i32 @close(i32 %0)
%3 = tail call i32 @wprintf(i8* bitcast ([41 x i32]* @.str to i8*), i32 %0)
ret i8* null
}
/* Type definitions */
struct string {
  int dummy;
};

/* Variables and functions */
struct string *string_char_insert(struct string *, int /*<<< orphan*/, char,
                                  unsigned int);
struct string *string_char_prepend(struct string *string, char c,
                                   unsigned int num) {
  return string_char_insert(string, 0, c, num);
}


x86 assembly (clang, -O0):
<string_char_prepend>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %sil,%al
mov    %rdi,-0x8(%rbp)
mov    %al,-0x9(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x9(%rbp),%al
mov    -0x10(%rbp),%ecx
xor    %esi,%esi
movsbl %al,%edx
call   1030 <string_char_insert@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<string_char_prepend>:
mov    %edx,%ecx
mov    %esi,%edx
xor    %esi,%esi
jmp    1030 <string_char_insert@plt>

LLVM IR (-O0):
%struct.string = type { i32 }
define %struct.string* @string_char_prepend(%struct.string* %0, i8 signext %1, i32 %2) {
%4 = alloca %struct.string*
%5 = alloca i8
%6 = alloca i32
store %struct.string* %0, %struct.string** %4
store i8 %1, i8* %5
store i32 %2, i32* %6
%7 = load %struct.string*, %struct.string** %4
%8 = load i8, i8* %5
%9 = load i32, i32* %6
%10 = call %struct.string* @string_char_insert(%struct.string* %7, i32 0, i8 signext %8, i32 %9)
ret %struct.string* %10
}

LLVM IR (-O2):
%struct.string = type { i32 }
define %struct.string* @string_char_prepend(%struct.string* %0, i8 signext %1, i32 %2) {
%4 = tail call %struct.string* @string_char_insert(%struct.string* %0, i32 0, i8 signext %1, i32 %2)
ret %struct.string* %4
}
/* Variables and functions */
int main_downsa(int, char **);
int main(int c, char *v[]) { return main_downsa(c, v); }


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1030 <main_downsa@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
jmp    1030 <main_downsa@plt>

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

LLVM IR (-O2):
define i32 @main(i32 %0, i8** %1) {
%3 = tail call i32 @main_downsa(i32 %0, i8** %1)
ret i32 %3
}
int fun795() { return 795; }


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

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

LLVM IR (-O0):
define i32 @fun795() {
ret i32 795
}

LLVM IR (-O2):
define i32 @fun795() {
ret i32 795
}
/* Variables and functions */
int /*<<< orphan*/ Assert_real(int, char *, int, char *);
scalar_t__ isdigit(int);
void t_isdigit_0xd2() {
  Assert_real((isdigit(210) == 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_isdigit.c",
              1055, ("isdigit should be 0 for 0xd2"));
}


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

x86 assembly (clang, -O2):
<t_isdigit_0xd2>:
push   %rax
mov    $0xd2,%edi
call   1030 <isdigit@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
lea    0xec5(%rip),%rsi
lea    0xf66(%rip),%rcx
mov    $0x41f,%edx
pop    %rax
jmp    1040 <Assert_real@plt>

LLVM IR (-O0):
@.str = [168 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_isdigit.c\00"
@.str.1 = [29 x i8] c"isdigit should be 0 for 0xd2\00"
define void @t_isdigit_0xd2() {
%1 = call i64 @isdigit(i32 210)
%2 = icmp eq i64 %1, 0
%3 = zext i1 %2 to i32
%4 = call i32 @Assert_real(i32 %3, i8* getelementptr inbounds ([168 x i8], [168 x i8]* @.str, i64 0, i64 0), i32 1055, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [168 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_isdigit.c\00"
@.str.1 = [29 x i8] c"isdigit should be 0 for 0xd2\00"
define void @t_isdigit_0xd2() {
%1 = tail call i64 @isdigit(i32 210)
%2 = icmp eq i64 %1, 0
%3 = zext i1 %2 to i32
%4 = tail call i32 @Assert_real(i32 %3, i8* getelementptr inbounds ([168 x i8], [168 x i8]* @.str, i64 0, i64 0), i32 1055, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0))
ret void
}
float svecnorm(float *x, int n) {
  extern float snrm2_(int *n, float *dx, int *incx);
  int one = 1;
  return snrm2_(&n, x, &one);
}


x86 assembly (clang, -O0):
<svecnorm>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x1,-0x10(%rbp)
mov    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdi
lea    -0x10(%rbp),%rdx
call   1030 <snrm2_@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svecnorm>:
push   %rax
mov    %rdi,%rax
mov    %esi,0x4(%rsp)
movl   $0x1,(%rsp)
lea    0x4(%rsp),%rdi
mov    %rsp,%rdx
mov    %rax,%rsi
call   1030 <snrm2_@plt>
pop    %rax
ret

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

LLVM IR (-O2):
define float @svecnorm(float* %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
store i32 %1, i32* %3
%5 = bitcast i32* %4 to i8*
store i32 1, i32* %4
%6 = call float @snrm2_(i32* %3, float* %0, i32* %4)
ret float %6
}
/* Type definitions */
typedef int /*<<< orphan*/ buf;

/* Variables and functions */
char *prchar(int);
int /*<<< orphan*/ snprintf(char *, int, char *, char *);
char *propt(int c) {
  static char buf[8];
  (void)snprintf(buf, sizeof(buf), "-%s", prchar(c));
  return (buf);
}


x86 assembly (clang, -O0):
<propt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%edi
call   1040 <prchar@plt>
mov    %rax,%rcx
lea    0x2ef4(%rip),%rdi
mov    $0x8,%esi
lea    0xeb7(%rip),%rdx
call   1030 <snprintf@plt>
lea    0x2edc(%rip),%rax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<propt>:
push   %rbx
call   1040 <prchar@plt>
lea    0x2f04(%rip),%rbx
lea    0xecc(%rip),%rdx
mov    %rbx,%rdi
mov    $0x8,%esi
mov    %rax,%rcx
call   1030 <snprintf@plt>
mov    %rbx,%rax
pop    %rbx
ret

LLVM IR (-O0):
@propt.buf = internal global [8 x i8] zeroinitializer
@.str = [4 x i8] c"-%s\00"
define i8* @propt(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
%3 = load i32, i32* %2
%4 = call i8* @prchar(i32 %3)
%5 = call i32 @snprintf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @propt.buf, i64 0, i64 0), i32 8, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %4)
ret i8* getelementptr inbounds ([8 x i8], [8 x i8]* @propt.buf, i64 0, i64 0)
}

LLVM IR (-O2):
@propt.buf = internal global [8 x i8] zeroinitializer
@.str = [4 x i8] c"-%s\00"
define i8* @propt(i32 %0) {
%2 = tail call i8* @prchar(i32 %0)
%3 = tail call i32 @snprintf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @propt.buf, i64 0, i64 0), i32 8, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %2)
ret i8* getelementptr inbounds ([8 x i8], [8 x i8]* @propt.buf, i64 0, i64 0)
}
/* Type definitions */
typedef int /*<<< orphan*/ uint32_t;

/* Variables and functions */
int /*<<< orphan*/ _mesa_hash_string(char const *);
uint32_t _mesa_key_hash_string(const void *key) {
  return _mesa_hash_string((const char *)key);
}


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

x86 assembly (clang, -O2):
<_mesa_key_hash_string>:
jmp    1030 <_mesa_hash_string@plt>

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

LLVM IR (-O2):
define i32 @_mesa_key_hash_string(i8* %0) {
%2 = tail call i32 @_mesa_hash_string(i8* %0)
ret i32 %2
}
const char *BZ2_bzlibVersion(void) { return "1.0.2, 30-Dec-2001"; }


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

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

LLVM IR (-O0):
@.str = [19 x i8] c"1.0.2, 30-Dec-2001\00"
define i8* @BZ2_bzlibVersion() {
ret i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0)
}

LLVM IR (-O2):
@.str = [19 x i8] c"1.0.2, 30-Dec-2001\00"
define i8* @BZ2_bzlibVersion() {
ret i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0)
}
void RTPathReal(void) {}


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

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

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

LLVM IR (-O2):
define void @RTPathReal() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ do_test_api1(char const *, int *);
int /*<<< orphan*/ do_test_api2(char const *, int *);
void test_api(const char *zPattern, int *pRc) {
  do_test_api1(zPattern, pRc);
  do_test_api2(zPattern, pRc);
}


x86 assembly (clang, -O0):
<test_api>:
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 <do_test_api1@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1040 <do_test_api2@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_api>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
call   1030 <do_test_api1@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
add    $0x8,%rsp
pop    %rbx
pop    %r14
jmp    1040 <do_test_api2@plt>

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

LLVM IR (-O2):
define void @test_api(i8* %0, i32* %1) {
%3 = tail call i32 @do_test_api1(i8* %0, i32* %1)
%4 = tail call i32 @do_test_api2(i8* %0, i32* %1)
ret void
}
/* Variables and functions */
int GetInt();
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  printf("Give me an integer: ");
  int x = GetInt();
  printf("Give me another integer: ");
  int y = GetInt();
  printf("The sum of %i and %i is %i!\n", x, y, x + y);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
lea    0xed1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1040 <GetInt@plt>
mov    %eax,-0x4(%rbp)
lea    0xece(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1040 <GetInt@plt>
mov    %eax,-0x8(%rbp)
mov    -0x4(%rbp),%esi
mov    -0x8(%rbp),%edx
mov    -0x4(%rbp),%ecx
add    -0x8(%rbp),%ecx
lea    0xec4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
lea    0xed8(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
xor    %eax,%eax
call   1040 <GetInt@plt>
mov    %eax,%ebx
lea    0xed6(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
xor    %eax,%eax
call   1040 <GetInt@plt>
lea    (%rax,%rbx,1),%ecx
lea    0xed8(%rip),%rdi
mov    %ebx,%esi
mov    %eax,%edx
xor    %eax,%eax
call   1030 <printf@plt>
xor    %eax,%eax
pop    %rbx
ret

LLVM IR (-O0):
@.str = [21 x i8] c"Give me an integer: \00"
@.str.1 = [26 x i8] c"Give me another integer: \00"
@.str.2 = [29 x i8] c"The sum of %i and %i is %i!\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0))
%4 = call i32 (...) @GetInt()
store i32 %4, i32* %1
%5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0))
%6 = call i32 (...) @GetInt()
store i32 %6, i32* %2
%7 = load i32, i32* %1
%8 = load i32, i32* %2
%9 = load i32, i32* %1
%10 = load i32, i32* %2
%11 = add nsw i32 %9, %10
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i32 %7, i32 %8, i32 %11)
ret i32 0
}

LLVM IR (-O2):
@.str = [21 x i8] c"Give me an integer: \00"
@.str.1 = [26 x i8] c"Give me another integer: \00"
@.str.2 = [29 x i8] c"The sum of %i and %i is %i!\0A\00"
define i32 @main() {
%1 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0))
%2 = tail call i32 (...) @GetInt()
%3 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0))
%4 = tail call i32 (...) @GetInt()
%5 = add nsw i32 %4, %2
%6 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i32 %2, i32 %4, i32 %5)
ret i32 0
}
/* Variables and functions */
scalar_t__ ascii_numeric_cmp(char const *, char const *);
int num_le(const char *pat, const char *text) {
  return (ascii_numeric_cmp(text, pat) <= 0);
}


x86 assembly (clang, -O0):
<num_le>:
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 <ascii_numeric_cmp@plt>
cmp    $0x0,%rax
setle  %al
and    $0x1,%al
movzbl %al,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<num_le>:
push   %rax
mov    %rdi,%rax
mov    %rsi,%rdi
mov    %rax,%rsi
call   1030 <ascii_numeric_cmp@plt>
xor    %ecx,%ecx
test   %rax,%rax
setle  %cl
mov    %ecx,%eax
pop    %rcx
ret

LLVM IR (-O0):
define i32 @num_le(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 i64 @ascii_numeric_cmp(i8* %5, i8* %6)
%8 = icmp sle i64 %7, 0
%9 = zext i1 %8 to i32
ret i32 %9
}

LLVM IR (-O2):
define i32 @num_le(i8* %0, i8* %1) {
%3 = tail call i64 @ascii_numeric_cmp(i8* %1, i8* %0)
%4 = icmp slt i64 %3, 1
%5 = zext i1 %4 to i32
ret i32 %5
}
int countSegments(char *s) {
  int count = 0;
  while (*s != '\0') {
    if (*s != ' ' && (*(s + 1) == ' ' || *(s + 1) == '\0'))
      count++;
    s++;
  }
  return count;
}


x86 assembly (clang, -O0):
<countSegments>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     116b <countSegments+0x6b>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
je     115a <countSegments+0x5a>
mov    -0x8(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x20,%eax
je     1151 <countSegments+0x51>
mov    -0x8(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x0,%eax
jne    115a <countSegments+0x5a>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    110f <countSegments+0xf>
mov    -0xc(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<countSegments>:
add    $0x1,%rdi
xor    %eax,%eax
jmp    1114 <countSegments+0x14>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
movzbl -0x1(%rdi),%ecx
cmp    $0x20,%cl
je     1110 <countSegments+0x10>
test   %cl,%cl
je     112b <countSegments+0x2b>
testb  $0xdf,(%rdi)
jne    1110 <countSegments+0x10>
add    $0x1,%eax
jmp    1110 <countSegments+0x10>
ret

LLVM IR (-O0):
define i32 @countSegments(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
store i8* %0, i8** %2
store i32 0, i32* %3
br label %4
4: ; preds = %29, %1
%5 = load i8*, i8** %2
%6 = load i8, i8* %5
%7 = sext i8 %6 to i32
%8 = icmp ne i32 %7, 0
br i1 %8, label %9, label %32
9: ; preds = %4
%10 = load i8*, i8** %2
%11 = load i8, i8* %10
%12 = sext i8 %11 to i32
%13 = icmp ne i32 %12, 32
br i1 %13, label %14, label %29
14: ; preds = %9
%15 = load i8*, i8** %2
%16 = getelementptr inbounds i8, i8* %15, i64 1
%17 = load i8, i8* %16
%18 = sext i8 %17 to i32
%19 = icmp eq i32 %18, 32
br i1 %19, label %26, label %20
20: ; preds = %14
%21 = load i8*, i8** %2
%22 = getelementptr inbounds i8, i8* %21, i64 1
%23 = load i8, i8* %22
%24 = sext i8 %23 to i32
%25 = icmp eq i32 %24, 0
br i1 %25, label %26, label %29
26: ; preds = %20, %14
%27 = load i32, i32* %3
%28 = add nsw i32 %27, 1
store i32 %28, i32* %3
br label %29
29: ; preds = %26, %20, %9
%30 = load i8*, i8** %2
%31 = getelementptr inbounds i8, i8* %30, i32 1
store i8* %31, i8** %2
br label %4
32: ; preds = %4
%33 = load i32, i32* %3
ret i32 %33
}

LLVM IR (-O2):
define i32 @countSegments(i8* nocapture %0) {
br label %2
2: ; preds = %11, %1
%3 = phi i8* [ %0, %1 ], [ %13, %11 ]
%4 = phi i32 [ 0, %1 ], [ %12, %11 ]
%5 = load i8, i8* %3
switch i8 %5, label %6 [
i8 0, label %14
i8 32, label %11
]
6: ; preds = %2
%7 = getelementptr inbounds i8, i8* %3, i64 1
%8 = load i8, i8* %7
switch i8 %8, label %11 [
i8 32, label %9
i8 0, label %9
]
9: ; preds = %6, %6
%10 = add nsw i32 %4, 1
br label %11
11: ; preds = %6, %2, %9
%12 = phi i32 [ %10, %9 ], [ %4, %2 ], [ %4, %6 ]
%13 = getelementptr inbounds i8, i8* %3, i64 1
br label %2
14: ; preds = %2
ret i32 %4
}
/* Type definitions */
struct fdi {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ track_atari_st(struct fdi *, int);
void track_atari_st_9(struct fdi *fdi) { track_atari_st(fdi, 9); }


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

x86 assembly (clang, -O2):
<track_atari_st_9>:
mov    $0x9,%esi
jmp    1030 <track_atari_st@plt>

LLVM IR (-O0):
%struct.fdi = type { i32 }
define void @track_atari_st_9(%struct.fdi* %0) {
%2 = alloca %struct.fdi*
store %struct.fdi* %0, %struct.fdi** %2
%3 = load %struct.fdi*, %struct.fdi** %2
%4 = call i32 @track_atari_st(%struct.fdi* %3, i32 9)
ret void
}

LLVM IR (-O2):
%struct.fdi = type { i32 }
define void @track_atari_st_9(%struct.fdi* %0) {
%2 = tail call i32 @track_atari_st(%struct.fdi* %0, i32 9)
ret void
}
int relay_config_check_network_ssl_priorities(void *data,
                                              struct t_config_option *option,
                                              const char *value) {
  (void)data;
  (void)option;
  (void)value;
  return 1;
}


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

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

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

LLVM IR (-O2):
%struct.t_config_option = type opaque
define i32 @relay_config_check_network_ssl_priorities(i8* nocapture readnone %0, %struct.t_config_option* nocapture readnone %1, i8* nocapture readnone %2) {
ret i32 1
}
/* Variables and functions */
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int fork();
void daemonize(void) {
  int ret = fork();
  if (ret == 0) {
    exit(0);
  }
}


x86 assembly (clang, -O0):
<daemonize>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    $0x0,%al
call   1040 <fork@plt>
mov    %eax,-0x4(%rbp)
cmpl   $0x0,-0x4(%rbp)
jne    1143 <daemonize+0x23>
xor    %edi,%edi
call   1030 <exit@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<daemonize>:
push   %rax
xor    %eax,%eax
call   1040 <fork@plt>
test   %eax,%eax
je     112e <daemonize+0xe>
pop    %rax
ret
xor    %edi,%edi
call   1030 <exit@plt>

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

LLVM IR (-O2):
define void @daemonize() {
%1 = tail call i32 (...) @fork()
%2 = icmp eq i32 %1, 0
br i1 %2, label %3, label %5
3: ; preds = %0
%4 = tail call i32 @exit(i32 0)
unreachable
5: ; preds = %0
ret void
}
void I422ToARGBRow_C() {}


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

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

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

LLVM IR (-O2):
define void @I422ToARGBRow_C() {
ret void
}
void gtk_tree_view_column_set_attributes() {}


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

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

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

LLVM IR (-O2):
define void @gtk_tree_view_column_set_attributes() {
ret void
}
/* Variables and functions */
int atoi(char *);
int main(int argc, char *argv[]) {
  int player;
  if (argc == 2) {
    player = atoi(argv[1]);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x2,-0x8(%rbp)
jne    1140 <main+0x30>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1030 <atoi@plt>
mov    %eax,-0x14(%rbp)
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbp
ret

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

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

LLVM IR (-O2):
define i32 @main(i32 %0, i8** nocapture readnone %1) {
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ output_line(char *);
gen_convert_primary_reg_value_to_bool() {
  output_line("sltu\t$t1, $v0, $zero");
  output_line("sltu\t$t2, $zero, $v0");
  output_line("or\t$v0, $t1, $t2");
}


x86 assembly (clang, -O0):
<gen_convert_primary_reg_value_to_bool>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
lea    0xee1(%rip),%rdi
call   1030 <output_line@plt>
lea    0xeea(%rip),%rdi
call   1030 <output_line@plt>
lea    0xef3(%rip),%rdi
call   1030 <output_line@plt>
mov    -0x4(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gen_convert_primary_reg_value_to_bool>:
push   %rax
lea    0xee8(%rip),%rdi
call   1030 <output_line@plt>
lea    0xef1(%rip),%rdi
call   1030 <output_line@plt>
lea    0xefa(%rip),%rdi
pop    %rax
jmp    1030 <output_line@plt>

LLVM IR (-O0):
@.str = [21 x i8] c"sltu\09$t1, $v0, $zero\00"
@.str.1 = [21 x i8] c"sltu\09$t2, $zero, $v0\00"
@.str.2 = [17 x i8] c"or\09$v0, $t1, $t2\00"
define i32 @gen_convert_primary_reg_value_to_bool() {
%1 = alloca i32
%2 = call i32 @output_line(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0))
%3 = call i32 @output_line(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0))
%4 = call i32 @output_line(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0))
%5 = load i32, i32* %1
ret i32 %5
}

LLVM IR (-O2):
@.str = [21 x i8] c"sltu\09$t1, $v0, $zero\00"
@.str.1 = [21 x i8] c"sltu\09$t2, $zero, $v0\00"
@.str.2 = [17 x i8] c"or\09$v0, $t1, $t2\00"
define i32 @gen_convert_primary_reg_value_to_bool() {
%1 = tail call i32 @output_line(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0))
%2 = tail call i32 @output_line(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0))
%3 = tail call i32 @output_line(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0))
ret i32 undef
}
/* Variables and functions */
int /*<<< orphan*/ die(char *, unsigned long, void *);
int /*<<< orphan*/ munmap(void *, unsigned long);
void blob_free(void *addr, unsigned long size) {
  if (!size || (size & ~32768) || ((unsigned long)addr & 512))
    die("internal error: bad blob free (%lu bytes at %p)", size, addr);
  munmap(addr, size);
}


x86 assembly (clang, -O0):
<blob_free>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1163 <blob_free+0x43>
mov    -0x10(%rbp),%rax
and    $0xffffffffffff7fff,%rax
cmp    $0x0,%rax
jne    1163 <blob_free+0x43>
mov    -0x8(%rbp),%rax
and    $0x200,%rax
cmp    $0x0,%rax
je     1177 <blob_free+0x57>
mov    -0x10(%rbp),%rsi
mov    -0x8(%rbp),%rdx
lea    0xe8e(%rip),%rdi
call   1040 <die@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <munmap@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<blob_free>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%rbx
mov    %rdi,%r14
cmp    $0x8000,%rsi
jne    1140 <blob_free+0x20>
mov    %r14d,%eax
and    $0x200,%eax
test   %rax,%rax
je     1152 <blob_free+0x32>
lea    0xeb9(%rip),%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
call   1040 <die@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
add    $0x8,%rsp
pop    %rbx
pop    %r14
jmp    1030 <munmap@plt>

LLVM IR (-O0):
@.str = [48 x i8] c"internal error: bad blob free (%lu bytes at %p)\00"
define void @blob_free(i8* %0, i64 %1) {
%3 = alloca i8*
%4 = alloca i64
store i8* %0, i8** %3
store i64 %1, i64* %4
%5 = load i64, i64* %4
%6 = icmp ne i64 %5, 0
br i1 %6, label %7, label %16
7: ; preds = %2
%8 = load i64, i64* %4
%9 = and i64 %8, -32769
%10 = icmp ne i64 %9, 0
br i1 %10, label %16, label %11
11: ; preds = %7
%12 = load i8*, i8** %3
%13 = ptrtoint i8* %12 to i64
%14 = and i64 %13, 512
%15 = icmp ne i64 %14, 0
br i1 %15, label %16, label %20
16: ; preds = %11, %7, %2
%17 = load i64, i64* %4
%18 = load i8*, i8** %3
%19 = call i32 @die(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str, i64 0, i64 0), i64 %17, i8* %18)
br label %20
20: ; preds = %16, %11
%21 = load i8*, i8** %3
%22 = load i64, i64* %4
%23 = call i32 @munmap(i8* %21, i64 %22)
ret void
}

LLVM IR (-O2):
@.str = [48 x i8] c"internal error: bad blob free (%lu bytes at %p)\00"
define void @blob_free(i8* %0, i64 %1) {
%3 = icmp eq i64 %1, 32768
%4 = ptrtoint i8* %0 to i64
%5 = and i64 %4, 512
%6 = icmp eq i64 %5, 0
%7 = and i1 %3, %6
br i1 %7, label %10, label %8
8: ; preds = %2
%9 = tail call i32 @die(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str, i64 0, i64 0), i64 %1, i8* %0)
br label %10
10: ; preds = %2, %8
%11 = tail call i32 @munmap(i8* %0, i64 %1)
ret void
}
int sprintf(char *str, const char *format, ...) {
  char s = *format;
  str[0] = s;
  return 0;
}


x86 assembly (clang, -O0):
<sprintf>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x11(%rbp)
mov    -0x11(%rbp),%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<sprintf>:
mov    (%rsi),%al
mov    %al,(%rdi)
xor    %eax,%eax
ret

LLVM IR (-O0):
define i32 @sprintf(i8* %0, i8* %1, ...) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8
store i8* %0, i8** %3
store i8* %1, i8** %4
%6 = load i8*, i8** %4
%7 = load i8, i8* %6
store i8 %7, i8* %5
%8 = load i8, i8* %5
%9 = load i8*, i8** %3
%10 = getelementptr inbounds i8, i8* %9, i64 0
store i8 %8, i8* %10
ret i32 0
}

LLVM IR (-O2):
define i32 @sprintf(i8* nocapture writeonly %0, i8* nocapture %1, ...) {
%3 = load i8, i8* %1
store i8 %3, i8* %0
ret i32 0
}
/* Type definitions */
typedef int /*<<< orphan*/ _iface;

/* Variables and functions */
int /*<<< orphan*/ strncpy(char *, char *, int);
void *strtok(char *, char *);
int _iface_has(char *iface, char *delims) {
  char _iface[80];
  strncpy(_iface, iface, sizeof(_iface));
  _iface[sizeof(_iface) - 1] = 0;
  strtok(_iface, delims);
  void *token = strtok(NULL, delims);
  return (token != NULL);
}


x86 assembly (clang, -O0):
<_iface_has>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x60(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    $0x50,%edx
call   1030 <strncpy@plt>
movb   $0x0,-0x11(%rbp)
lea    -0x60(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1040 <strtok@plt>
mov    -0x10(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
call   1040 <strtok@plt>
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x68(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_iface_has>:
push   %r14
push   %rbx
sub    $0x58,%rsp
mov    %rsi,%rbx
mov    %rdi,%rsi
mov    %rsp,%r14
mov    %r14,%rdi
mov    $0x50,%edx
call   1030 <strncpy@plt>
movb   $0x0,0x4f(%rsp)
mov    %r14,%rdi
mov    %rbx,%rsi
call   1040 <strtok@plt>
xor    %edi,%edi
mov    %rbx,%rsi
call   1040 <strtok@plt>
xor    %ecx,%ecx
test   %rax,%rax
setne  %cl
mov    %ecx,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define i32 @_iface_has(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca [80 x i8]
%6 = alloca i8*
store i8* %0, i8** %3
store i8* %1, i8** %4
%7 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 0
%8 = load i8*, i8** %3
%9 = call i32 @strncpy(i8* %7, i8* %8, i32 80)
%10 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 79
store i8 0, i8* %10
%11 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 0
%12 = load i8*, i8** %4
%13 = call i8* @strtok(i8* %11, i8* %12)
%14 = load i8*, i8** %4
%15 = call i8* @strtok(i8* null, i8* %14)
store i8* %15, i8** %6
%16 = load i8*, i8** %6
%17 = icmp ne i8* %16, null
%18 = zext i1 %17 to i32
ret i32 %18
}

LLVM IR (-O2):
define i32 @_iface_has(i8* %0, i8* nocapture %1) {
%3 = alloca [80 x i8]
%4 = getelementptr inbounds [80 x i8], [80 x i8]* %3, i64 0, i64 0
%5 = call i32 @strncpy(i8* %4, i8* %0, i32 80)
%6 = getelementptr inbounds [80 x i8], [80 x i8]* %3, i64 0, i64 79
store i8 0, i8* %6
%7 = call i8* @strtok(i8* %4, i8* %1)
%8 = call i8* @strtok(i8* null, i8* %1)
%9 = icmp ne i8* %8, null
%10 = zext i1 %9 to i32
ret i32 %10
}
/* Variables and functions */
double erf(double);
double testfn_I_A(double x, double sig, double xc) {
  return erf((x - xc) / sig);
}


x86 assembly (clang, -O0):
<testfn_I_A>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
movsd  -0x8(%rbp),%xmm0
subsd  -0x18(%rbp),%xmm0
divsd  -0x10(%rbp),%xmm0
call   1030 <erf@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<testfn_I_A>:
subsd  %xmm2,%xmm0
divsd  %xmm1,%xmm0
jmp    1030 <erf@plt>

LLVM IR (-O0):
define double @testfn_I_A(double %0, double %1, double %2) {
%4 = alloca double
%5 = alloca double
%6 = alloca double
store double %0, double* %4
store double %1, double* %5
store double %2, double* %6
%7 = load double, double* %4
%8 = load double, double* %6
%9 = fsub double %7, %8
%10 = load double, double* %5
%11 = fdiv double %9, %10
%12 = call double @erf(double %11)
ret double %12
}

LLVM IR (-O2):
define double @testfn_I_A(double %0, double %1, double %2) {
%4 = fsub double %0, %2
%5 = fdiv double %4, %1
%6 = tail call double @erf(double %5)
ret double %6
}
void gtk_file_chooser_button_new() {}


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

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

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

LLVM IR (-O2):
define void @gtk_file_chooser_button_new() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ say(char *, int);
void hit(void) {
  say("I'm dreaming!  You aren't really here, mystical island of legend!", 1);
}


x86 assembly (clang, -O0):
<hit>:
push   %rbp
mov    %rsp,%rbp
lea    0xee5(%rip),%rdi
mov    $0x1,%esi
call   1030 <say@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<hit>:
lea    0xee9(%rip),%rdi
mov    $0x1,%esi
jmp    1030 <say@plt>

LLVM IR (-O0):
@.str = [66 x i8] c"I'm dreaming! You aren't really here, mystical island of legend!\00"
define void @hit() {
%1 = call i32 @say(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str, i64 0, i64 0), i32 1)
ret void
}

LLVM IR (-O2):
@.str = [66 x i8] c"I'm dreaming! You aren't really here, mystical island of legend!\00"
define void @hit() {
%1 = tail call i32 @say(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str, i64 0, i64 0), i32 1)
ret void
}