xunge/DecIR huggingface dataset:
/* Variables and functions */
int /*<<< orphan*/ read_input_file();
int /*<<< orphan*/ tokenize_string();
void get_replacement_strings() {
  read_input_file();
  tokenize_string();
}


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

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

LLVM IR (-O0):
define void @get_replacement_strings() {
%1 = call i32 (...) @read_input_file()
%2 = call i32 (...) @tokenize_string()
ret void
}

LLVM IR (-O2):
define void @get_replacement_strings() {
%1 = tail call i32 (...) @read_input_file()
%2 = tail call i32 (...) @tokenize_string()
ret void
}
/* Variables and functions */
void *realloc(void *, size_t);
void *mm_realloc(void *ptr, size_t size) { return realloc(ptr, size); }


x86 assembly (clang, -O0):
<mm_realloc>:
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 <realloc@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mm_realloc>:
jmp    1030 <realloc@plt>

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

LLVM IR (-O2):
define noalias i8* @mm_realloc(i8* nocapture %0, i64 %1) {
%3 = tail call i8* @realloc(i8* %0, i64 %1)
ret i8* %3
}
/* Variables and functions */
int /*<<< orphan*/ derivHald(int, double, int, int, double *, double *,
                             double *);
void derivHald_R_wrapper(int *gen, double *mu, int *n, int *N0, double *prob,
                         double *prob1, double *prob2) {
  derivHald(*gen, *mu, *n, *N0, prob, prob1, prob2);
}


x86 assembly (clang, -O0):
<derivHald_R_wrapper>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    (%rax),%esi
mov    -0x20(%rbp),%rax
mov    (%rax),%edx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    0x10(%rbp),%r9
call   1030 <derivHald@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<derivHald_R_wrapper>:
mov    %r9,%rax
mov    0x8(%rsp),%r9
mov    (%rdi),%edi
movsd  (%rsi),%xmm0
mov    (%rdx),%esi
mov    (%rcx),%edx
mov    %r8,%rcx
mov    %rax,%r8
jmp    1030 <derivHald@plt>

LLVM IR (-O0):
define void @derivHald_R_wrapper(i32* %0, double* %1, i32* %2, i32* %3, double* %4, double* %5, double* %6) {
%8 = alloca i32*
%9 = alloca double*
%10 = alloca i32*
%11 = alloca i32*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
store i32* %0, i32** %8
store double* %1, double** %9
store i32* %2, i32** %10
store i32* %3, i32** %11
store double* %4, double** %12
store double* %5, double** %13
store double* %6, double** %14
%15 = load i32*, i32** %8
%16 = load i32, i32* %15
%17 = load double*, double** %9
%18 = load double, double* %17
%19 = load i32*, i32** %10
%20 = load i32, i32* %19
%21 = load i32*, i32** %11
%22 = load i32, i32* %21
%23 = load double*, double** %12
%24 = load double*, double** %13
%25 = load double*, double** %14
%26 = call i32 @derivHald(i32 %16, double %18, i32 %20, i32 %22, double* %23, double* %24, double* %25)
ret void
}

LLVM IR (-O2):
define void @derivHald_R_wrapper(i32* nocapture %0, double* nocapture %1, i32* nocapture %2, i32* nocapture %3, double* %4, double* %5, double* %6) {
%8 = load i32, i32* %0
%9 = load double, double* %1
%10 = load i32, i32* %2
%11 = load i32, i32* %3
%12 = tail call i32 @derivHald(i32 %8, double %9, i32 %10, i32 %11, double* %4, double* %5, double* %6)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *);
void main() {
  printf("Jessica Cristina Cacau Patricio\n"
         "Jessica\tCristina\tCacau\tPatricio\n");
}


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

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

LLVM IR (-O0):
@.str = [65 x i8] c"Jessica Cristina Cacau Patricio\0AJessica\09Cristina\09Cacau\09Patricio\0A\00"
define void @main() {
%1 = call i32 @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@str = [64 x i8] c"Jessica Cristina Cacau Patricio\0AJessica\09Cristina\09Cacau\09Patricio\00"
define void @main() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @str, i64 0, i64 0))
ret void
}
/* Type definitions */
typedef int /*<<< orphan*/ uint8_t;
typedef int uint32_t;

/* Variables and functions */
int /*<<< orphan*/ SLIP_send_frame_data(int /*<<< orphan*/ const);
void SLIP_send_frame_data_buf(const void *buf, uint32_t size) {
  const uint8_t *buf_c = (const uint8_t *)buf;
  for (int i = 0; i < size; i++) {
    SLIP_send_frame_data(buf_c[i]);
  }
}


x86 assembly (clang, -O0):
<SLIP_send_frame_data_buf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1158 <SLIP_send_frame_data_buf+0x48>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1030 <SLIP_send_frame_data@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112e <SLIP_send_frame_data_buf+0x1e>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SLIP_send_frame_data_buf>:
push   %r15
push   %r14
push   %rbx
test   %esi,%esi
jle    1142 <SLIP_send_frame_data_buf+0x32>
mov    %rdi,%r14
mov    %esi,%r15d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rbx,4),%edi
call   1030 <SLIP_send_frame_data@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1130 <SLIP_send_frame_data_buf+0x20>
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @SLIP_send_frame_data_buf(i8* nocapture %0, i32 %1) {
%3 = bitcast i8* %0 to i32*
%4 = icmp sgt i32 %1, 0
br i1 %4, label %5, label %7
5: ; preds = %2
%6 = zext i32 %1 to i64
br label %8
7: ; preds = %8, %2
ret void
8: ; preds = %5, %8
%9 = phi i64 [ 0, %5 ], [ %13, %8 ]
%10 = getelementptr inbounds i32, i32* %3, i64 %9
%11 = load i32, i32* %10
%12 = tail call i32 @SLIP_send_frame_data(i32 %11)
%13 = add nuw nsw i64 %9, 1
%14 = icmp eq i64 %13, %6
br i1 %14, label %7, label %8
}
void ex3() {}


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

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

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

LLVM IR (-O2):
define void @ex3() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ sol_network_shutdown();
void sol_comms_shutdown(void) { sol_network_shutdown(); }


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

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

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

LLVM IR (-O2):
define void @sol_comms_shutdown() {
%1 = tail call i32 (...) @sol_network_shutdown()
ret void
}
int typedef2() {
  typedef int **ptr2;
  {
    typedef int ***ptr3;
    ptr3 ptr2;
    ptr3 ptr1;
  }
}


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

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

LLVM IR (-O0):
define i32 @typedef2() {
%1 = alloca i32
%2 = alloca i32***
%3 = alloca i32***
%4 = load i32, i32* %1
ret i32 %4
}

LLVM IR (-O2):
define i32 @typedef2() {
ret i32 undef
}
/* Variables and functions */
int setpgid(int /*<<< orphan*/, int /*<<< orphan*/);
int setpgrp() { return setpgid(0, 0); }


x86 assembly (clang, -O0):
<setpgrp>:
push   %rbp
mov    %rsp,%rbp
xor    %esi,%esi
mov    %esi,%edi
call   1030 <setpgid@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<setpgrp>:
xor    %edi,%edi
xor    %esi,%esi
jmp    1030 <setpgid@plt>

LLVM IR (-O0):
define i32 @setpgrp() {
%1 = call i32 @setpgid(i32 0, i32 0)
ret i32 %1
}

LLVM IR (-O2):
define i32 @setpgrp() {
%1 = tail call i32 @setpgid(i32 0, i32 0)
ret i32 %1
}
int NoSoundDrv_PCM_BeginPlayback(char *BufferStart, int BufferSize,
                                 int NumDivisions, void (*CallBackFunc)(void)) {
  return 0;
}


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

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

LLVM IR (-O0):
define i32 @NoSoundDrv_PCM_BeginPlayback(i8* %0, i32 %1, i32 %2, void ()* %3) {
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca void ()*
store i8* %0, i8** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store void ()* %3, void ()** %8
ret i32 0
}

LLVM IR (-O2):
define i32 @NoSoundDrv_PCM_BeginPlayback(i8* nocapture readnone %0, i32 %1, i32 %2, void ()* nocapture readnone %3) {
ret i32 0
}
/* Type definitions */
typedef int /*<<< orphan*/ POLICYINFO;

/* Variables and functions */
scalar_t__ ASN1_item_new(int /*<<< orphan*/ *);
int /*<<< orphan*/ POLICYINFO_it;
POLICYINFO *POLICYINFO_new(void) {
  return (POLICYINFO *)ASN1_item_new(&POLICYINFO_it);
}


x86 assembly (clang, -O0):
<POLICYINFO_new>:
push   %rbp
mov    %rsp,%rbp
mov    0x2ecd(%rip),%rdi
call   1030 <ASN1_item_new@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<POLICYINFO_new>:
mov    0x2ed1(%rip),%rdi
jmp    1030 <ASN1_item_new@plt>

LLVM IR (-O0):
@POLICYINFO_it = global i32 0
define i32* @POLICYINFO_new() {
%1 = call i64 @ASN1_item_new(i32* @POLICYINFO_it)
%2 = inttoptr i64 %1 to i32*
ret i32* %2
}

LLVM IR (-O2):
@POLICYINFO_it = global i32 0
define i32* @POLICYINFO_new() {
%1 = tail call i64 @ASN1_item_new(i32* @POLICYINFO_it)
%2 = inttoptr i64 %1 to i32*
ret i32* %2
}
/* Variables and functions */
int /*<<< orphan*/ g(int);
void f(int one) {
  (void)one;
  g(2);
}


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

x86 assembly (clang, -O2):
<f>:
mov    $0x2,%edi
jmp    1030 <g@plt>

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

LLVM IR (-O2):
define void @f(i32 %0) {
%2 = tail call i32 @g(i32 2)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ sprintf(char *, char *);
char *get_system_name(void) {
  static char name[32];
  sprintf(name, "SSDS SYSTEM");
  return name;
}


x86 assembly (clang, -O0):
<get_system_name>:
push   %rbp
mov    %rsp,%rbp
lea    0x2f25(%rip),%rdi
lea    0xede(%rip),%rsi
call   1030 <sprintf@plt>
lea    0x2f12(%rip),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_system_name>:
movabs $0x5359532053445353,%rax
53 59 53
mov    %rax,0x2f1f(%rip)
movl   $0x4d4554,0x2f1d(%rip)
lea    0x2f0e(%rip),%rax
ret

LLVM IR (-O0):
@get_system_name.name = internal global [32 x i8] zeroinitializer
@.str = [12 x i8] c"SSDS SYSTEM\00"
define i8* @get_system_name() {
%1 = call i32 @sprintf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @get_system_name.name, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0))
ret i8* getelementptr inbounds ([32 x i8], [32 x i8]* @get_system_name.name, i64 0, i64 0)
}

LLVM IR (-O2):
@get_system_name.name = internal global [32 x i8] zeroinitializer
@.str = [12 x i8] c"SSDS SYSTEM\00"
define i8* @get_system_name() {
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 dereferenceable(12) getelementptr inbounds ([32 x i8], [32 x i8]* @get_system_name.name, i64 0, i64 0), i8* align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0), i64 12, i1 false)
ret i8* getelementptr inbounds ([32 x i8], [32 x i8]* @get_system_name.name, i64 0, i64 0)
}
/* Variables and functions */
int /*<<< orphan*/ ASRT_Mark(char *, int, char *);
scalar_t__ ASRT_Ptr(int *, int *);
int test_PtrFail() {
  int x, y;
  do {
    ASRT_Mark("/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
              "2022-01-22/02-19-57/repos/cohadar/c-learning/refs/heads/master/"
              "src/asrt_tests.c",
              103,
              "&x"
              " == "
              "&y");
    if (ASRT_Ptr(&x, &y)) {
      return 1;
    };
  } while (0);
  return 0;
}


x86 assembly (clang, -O0):
<test_PtrFail>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
lea    0xed1(%rip),%rdi
mov    $0x67,%esi
lea    0xf55(%rip),%rdx
call   1040 <ASRT_Mark@plt>
lea    -0x8(%rbp),%rdi
lea    -0xc(%rbp),%rsi
call   1030 <ASRT_Ptr@plt>
cmp    $0x0,%rax
je     1163 <test_PtrFail+0x43>
movl   $0x1,-0x4(%rbp)
jmp    116f <test_PtrFail+0x4f>
jmp    1168 <test_PtrFail+0x48>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_PtrFail>:
push   %rax
lea    0xed8(%rip),%rdi
lea    0xf61(%rip),%rdx
mov    $0x67,%esi
call   1040 <ASRT_Mark@plt>
lea    0x4(%rsp),%rdi
mov    %rsp,%rsi
call   1030 <ASRT_Ptr@plt>
xor    %ecx,%ecx
test   %rax,%rax
setne  %cl
mov    %ecx,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [144 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/cohadar/c-learning/refs/heads/master/src/asrt_tests.c\00"
@.str.1 = [9 x i8] c"&x == &y\00"
define i32 @test_PtrFail() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
br label %4
4: ; preds = %0
%5 = call i32 @ASRT_Mark(i8* getelementptr inbounds ([144 x i8], [144 x i8]* @.str, i64 0, i64 0), i32 103, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0))
%6 = call i64 @ASRT_Ptr(i32* %2, i32* %3)
%7 = icmp ne i64 %6, 0
br i1 %7, label %8, label %9
8: ; preds = %4
store i32 1, i32* %1
br label %11
9: ; preds = %4
br label %10
10: ; preds = %9
store i32 0, i32* %1
br label %11
11: ; preds = %10, %8
%12 = load i32, i32* %1
ret i32 %12
}

LLVM IR (-O2):
@.str = [144 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/cohadar/c-learning/refs/heads/master/src/asrt_tests.c\00"
@.str.1 = [9 x i8] c"&x == &y\00"
define i32 @test_PtrFail() {
%1 = alloca i32
%2 = alloca i32
%3 = bitcast i32* %1 to i8*
%4 = bitcast i32* %2 to i8*
%5 = tail call i32 @ASRT_Mark(i8* getelementptr inbounds ([144 x i8], [144 x i8]* @.str, i64 0, i64 0), i32 103, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0))
%6 = call i64 @ASRT_Ptr(i32* %1, i32* %2)
%7 = icmp ne i64 %6, 0
%8 = zext i1 %7 to i32
ret i32 %8
}
/* Variables and functions */
int strnatcmp(char const *, char const *);
int verscmp(char const *v1, char const *v2) { return strnatcmp(v1, v2); }


x86 assembly (clang, -O0):
<verscmp>:
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 <strnatcmp@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<verscmp>:
jmp    1030 <strnatcmp@plt>

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

LLVM IR (-O2):
define i32 @verscmp(i8* %0, i8* %1) {
%3 = tail call i32 @strnatcmp(i8* %0, i8* %1)
ret i32 %3
}
void timeR_finish(void) {}


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

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

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

LLVM IR (-O2):
define void @timeR_finish() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ Atm128AlarmC__0__HplAtm128Timer__overflow();
int /*<<< orphan*/ Atm128CounterC__0__Timer__overflow();
int /*<<< orphan*/ Atm128TimerInitC__0__Timer__overflow();
void HplAtm128Timer1P__Timer__overflow(void) {
  Atm128CounterC__0__Timer__overflow();
  Atm128TimerInitC__0__Timer__overflow();
  Atm128AlarmC__0__HplAtm128Timer__overflow();
}


x86 assembly (clang, -O0):
<HplAtm128Timer1P__Timer__overflow>:
push   %rbp
mov    %rsp,%rbp
mov    $0x0,%al
call   1050 <Atm128CounterC__0__Timer__overflow@plt>
mov    $0x0,%al
call   1040 <Atm128TimerInitC__0__Timer__overflow@plt>
mov    $0x0,%al
call   1030 <Atm128AlarmC__0__HplAtm128Timer__overflow@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<HplAtm128Timer1P__Timer__overflow>:
push   %rax
xor    %eax,%eax
call   1050 <Atm128CounterC__0__Timer__overflow@plt>
xor    %eax,%eax
call   1040 <Atm128TimerInitC__0__Timer__overflow@plt>
xor    %eax,%eax
pop    %rcx
jmp    1030 <Atm128AlarmC__0__HplAtm128Timer__overflow@plt>

LLVM IR (-O0):
define void @HplAtm128Timer1P__Timer__overflow() {
%1 = call i32 (...) @Atm128CounterC__0__Timer__overflow()
%2 = call i32 (...) @Atm128TimerInitC__0__Timer__overflow()
%3 = call i32 (...) @Atm128AlarmC__0__HplAtm128Timer__overflow()
ret void
}

LLVM IR (-O2):
define void @HplAtm128Timer1P__Timer__overflow() {
%1 = tail call i32 (...) @Atm128CounterC__0__Timer__overflow()
%2 = tail call i32 (...) @Atm128TimerInitC__0__Timer__overflow()
%3 = tail call i32 (...) @Atm128AlarmC__0__HplAtm128Timer__overflow()
ret void
}
/* Variables and functions */
int equal(char *, char *, char *);
int stops(char *p, char *a) {
  char *s = "int loop(char* x) { while (1) {++x;} }";
  int e = equal(s, p, a);
  if (e == 2) {
    return 2;
  } else {
    return 1 - e;
  }
}


x86 assembly (clang, -O0):
<stops>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
lea    0xed9(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
call   1030 <equal@plt>
mov    %eax,-0x24(%rbp)
cmpl   $0x2,-0x24(%rbp)
jne    1155 <stops+0x45>
movl   $0x2,-0x4(%rbp)
jmp    1160 <stops+0x50>
mov    $0x1,%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stops>:
push   %rax
mov    %rsi,%rdx
mov    %rdi,%rsi
lea    0xee2(%rip),%rdi
call   1030 <equal@plt>
mov    $0x1,%ecx
sub    %eax,%ecx
cmp    $0x2,%eax
cmovne %ecx,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [39 x i8] c"int loop(char* x) { while (1) {++x;} }\00"
define i32 @stops(i8* %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), i8** %6
%8 = load i8*, i8** %6
%9 = load i8*, i8** %4
%10 = load i8*, i8** %5
%11 = call i32 @equal(i8* %8, i8* %9, i8* %10)
store i32 %11, i32* %7
%12 = load i32, i32* %7
%13 = icmp eq i32 %12, 2
br i1 %13, label %14, label %15
14: ; preds = %2
store i32 2, i32* %3
br label %18
15: ; preds = %2
%16 = load i32, i32* %7
%17 = sub nsw i32 1, %16
store i32 %17, i32* %3
br label %18
18: ; preds = %15, %14
%19 = load i32, i32* %3
ret i32 %19
}

LLVM IR (-O2):
@.str = [39 x i8] c"int loop(char* x) { while (1) {++x;} }\00"
define i32 @stops(i8* %0, i8* %1) {
%3 = tail call i32 @equal(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), i8* %0, i8* %1)
%4 = icmp eq i32 %3, 2
%5 = sub nsw i32 1, %3
%6 = select i1 %4, i32 2, i32 %5
ret i32 %6
}
int test_imm_67int16_mem(short *val) {
  return ((*val) & (0x67 << 0)) ? -20 : -40;
}


x86 assembly (clang, -O0):
<test_imm_67int16_mem>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movswl (%rax),%edx
and    $0x67,%edx
mov    $0xffffffd8,%eax
mov    $0xffffffec,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_imm_67int16_mem>:
testb  $0x67,(%rdi)
mov    $0xffffffd8,%ecx
mov    $0xffffffec,%eax
cmove  %ecx,%eax
ret

LLVM IR (-O0):
define i32 @test_imm_67int16_mem(i16* %0) {
%2 = alloca i16*
store i16* %0, i16** %2
%3 = load i16*, i16** %2
%4 = load i16, i16* %3
%5 = sext i16 %4 to i32
%6 = and i32 %5, 103
%7 = icmp ne i32 %6, 0
%8 = zext i1 %7 to i64
%9 = select i1 %7, i32 -20, i32 -40
ret i32 %9
}

LLVM IR (-O2):
define i32 @test_imm_67int16_mem(i16* nocapture %0) {
%2 = load i16, i16* %0
%3 = and i16 %2, 103
%4 = icmp eq i16 %3, 0
%5 = select i1 %4, i32 -40, i32 -20
ret i32 %5
}
/* Variables and functions */
int imax(int, int /*<<< orphan*/);
int imin(int, int);
int iClip1(int high, int x) {
  x = imax(x, 0);
  x = imin(x, high);
  return x;
}


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

x86 assembly (clang, -O2):
<iClip1>:
push   %rbx
mov    %edi,%ebx
mov    %esi,%edi
xor    %esi,%esi
call   1040 <imax@plt>
mov    %eax,%edi
mov    %ebx,%esi
pop    %rbx
jmp    1030 <imin@plt>

LLVM IR (-O0):
define i32 @iClip1(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
store i32 %0, i32* %3
store i32 %1, i32* %4
%5 = load i32, i32* %4
%6 = call i32 @imax(i32 %5, i32 0)
store i32 %6, i32* %4
%7 = load i32, i32* %4
%8 = load i32, i32* %3
%9 = call i32 @imin(i32 %7, i32 %8)
store i32 %9, i32* %4
%10 = load i32, i32* %4
ret i32 %10
}

LLVM IR (-O2):
define i32 @iClip1(i32 %0, i32 %1) {
%3 = tail call i32 @imax(i32 %1, i32 0)
%4 = tail call i32 @imin(i32 %3, i32 %0)
ret i32 %4
}
/* Variables and functions */
int /*<<< orphan*/ default_isr();
__attribute__((weak)) void I2C2_Handler() { default_isr(); }


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

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

LLVM IR (-O0):
define weak void @I2C2_Handler() {
%1 = call i32 (...) @default_isr()
ret void
}

LLVM IR (-O2):
define weak void @I2C2_Handler() {
%1 = tail call i32 (...) @default_isr()
ret void
}
/* Variables and functions */
int /*<<< orphan*/ cryptopals_set1_challenge1();
int /*<<< orphan*/ cryptopals_set1_challenge2();
void cryptopals(void) {
  cryptopals_set1_challenge1();
  cryptopals_set1_challenge2();
}


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

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

LLVM IR (-O0):
define void @cryptopals() {
%1 = call i32 (...) @cryptopals_set1_challenge1()
%2 = call i32 (...) @cryptopals_set1_challenge2()
ret void
}

LLVM IR (-O2):
define void @cryptopals() {
%1 = tail call i32 (...) @cryptopals_set1_challenge1()
%2 = tail call i32 (...) @cryptopals_set1_challenge2()
ret void
}
/* Variables and functions */
int /*<<< orphan*/ abort();
int cal(int, int);
int main(int argc, char **argv) {
  int ret = cal(2, 1);
  if (ret != 11)
    abort();
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    $0x2,%edi
mov    $0x1,%esi
call   1040 <cal@plt>
mov    %eax,-0x14(%rbp)
cmpl   $0xb,-0x14(%rbp)
je     1159 <main+0x39>
mov    $0x0,%al
call   1030 <abort@plt>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
mov    $0x2,%edi
mov    $0x1,%esi
call   1040 <cal@plt>
cmp    $0xb,%eax
jne    1139 <main+0x19>
xor    %eax,%eax
pop    %rcx
ret
xor    %eax,%eax
call   1030 <abort@plt>

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 = call i32 @cal(i32 2, i32 1)
store i32 %7, i32* %6
%8 = load i32, i32* %6
%9 = icmp ne i32 %8, 11
br i1 %9, label %10, label %12
10: ; preds = %2
%11 = call i32 (...) @abort()
unreachable
12: ; preds = %2
ret i32 0
}

LLVM IR (-O2):
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = tail call i32 @cal(i32 2, i32 1)
%4 = icmp eq i32 %3, 11
br i1 %4, label %7, label %5
5: ; preds = %2
%6 = tail call i32 (...) @abort()
unreachable
7: ; preds = %2
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ assume(int);
int /*<<< orphan*/ static_assert(int);
void main() {
  int i, k, n, l;
  assume(l > 0);
  for (k = 1; k < n; k++) {
    for (i = l; i < n; i++) {
    }
    for (i = l; i < n; i++) {
      static_assert(1 <= k);
    }
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
cmpl   $0x0,-0x10(%rbp)
setg   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assume@plt>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11b9 <main+0x99>
mov    -0x10(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1171 <main+0x51>
jmp    1163 <main+0x43>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    1152 <main+0x32>
mov    -0x10(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11a6 <main+0x86>
mov    $0x1,%eax
cmp    -0x8(%rbp),%eax
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <static_assert@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    1177 <main+0x57>
jmp    11ab <main+0x8b>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1140 <main+0x20>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
xor    %edi,%edi
jmp    1030 <assume@plt>

LLVM IR (-O0):
define void @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = load i32, i32* %4
%6 = icmp sgt i32 %5, 0
%7 = zext i1 %6 to i32
%8 = call i32 @assume(i32 %7)
store i32 1, i32* %2
br label %9
9: ; preds = %38, %0
%10 = load i32, i32* %2
%11 = load i32, i32* %3
%12 = icmp slt i32 %10, %11
br i1 %12, label %13, label %41
13: ; preds = %9
%14 = load i32, i32* %4
store i32 %14, i32* %1
br label %15
15: ; preds = %20, %13
%16 = load i32, i32* %1
%17 = load i32, i32* %3
%18 = icmp slt i32 %16, %17
br i1 %18, label %19, label %23
19: ; preds = %15
br label %20
20: ; preds = %19
%21 = load i32, i32* %1
%22 = add nsw i32 %21, 1
store i32 %22, i32* %1
br label %15
23: ; preds = %15
%24 = load i32, i32* %4
store i32 %24, i32* %1
br label %25
25: ; preds = %34, %23
%26 = load i32, i32* %1
%27 = load i32, i32* %3
%28 = icmp slt i32 %26, %27
br i1 %28, label %29, label %37
29: ; preds = %25
%30 = load i32, i32* %2
%31 = icmp sle i32 1, %30
%32 = zext i1 %31 to i32
%33 = call i32 @static_assert(i32 %32)
br label %34
34: ; preds = %29
%35 = load i32, i32* %1
%36 = add nsw i32 %35, 1
store i32 %36, i32* %1
br label %25
37: ; preds = %25
br label %38
38: ; preds = %37
%39 = load i32, i32* %2
%40 = add nsw i32 %39, 1
store i32 %40, i32* %2
br label %9
41: ; preds = %9
ret void
}

LLVM IR (-O2):
define void @main() {
%1 = tail call i32 @assume(i32 0)
ret void
}
void Net_Shutdown(void) {}


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

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

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

LLVM IR (-O2):
define void @Net_Shutdown() {
ret void
}
void caller_2_1_2_2_2_2_2() {}


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

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

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

LLVM IR (-O2):
define void @caller_2_1_2_2_2_2_2() {
ret void
}
/* Variables and functions */
unsigned char abs(char n) { return n < 0 ? -n : n; }


x86 assembly (clang, -O0):
<abs>:
push   %rbp
mov    %rsp,%rbp
mov    %dil,%al
mov    %al,-0x1(%rbp)
movsbl -0x1(%rbp),%eax
cmp    $0x0,%eax
jge    1127 <abs+0x27>
movsbl -0x1(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x8(%rbp)
jmp    112e <abs+0x2e>
movsbl -0x1(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
movzbl %al,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<abs>:
mov    %edi,%ecx
sar    $0x7,%cl
lea    (%rdi,%rcx,1),%eax
xor    %cl,%al
ret

LLVM IR (-O0):
define zeroext i8 @abs(i8 signext %0) {
%2 = alloca i8
store i8 %0, i8* %2
%3 = load i8, i8* %2
%4 = sext i8 %3 to i32
%5 = icmp slt i32 %4, 0
br i1 %5, label %6, label %10
6: ; preds = %1
%7 = load i8, i8* %2
%8 = sext i8 %7 to i32
%9 = sub nsw i32 0, %8
br label %13
10: ; preds = %1
%11 = load i8, i8* %2
%12 = sext i8 %11 to i32
br label %13
13: ; preds = %10, %6
%14 = phi i32 [ %9, %6 ], [ %12, %10 ]
%15 = trunc i32 %14 to i8
ret i8 %15
}

LLVM IR (-O2):
define zeroext i8 @abs(i8 signext %0) {
%2 = tail call i8 @llvm.abs.i8(i8 %0, i1 false)
ret i8 %2
}
void waitpause(int x) { return; }


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

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

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

LLVM IR (-O2):
define void @waitpause(i32 %0) {
ret void
}
/* Variables and functions */
scalar_t__ size_to_objp(size_t);
void *compare_strnr_context(size_t n) { return (void *)size_to_objp(n); }


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

x86 assembly (clang, -O2):
<compare_strnr_context>:
jmp    1030 <size_to_objp@plt>

LLVM IR (-O0):
define i8* @compare_strnr_context(i64 %0) {
%2 = alloca i64
store i64 %0, i64* %2
%3 = load i64, i64* %2
%4 = call i64 @size_to_objp(i64 %3)
%5 = inttoptr i64 %4 to i8*
ret i8* %5
}

LLVM IR (-O2):
define i8* @compare_strnr_context(i64 %0) {
%2 = tail call i64 @size_to_objp(i64 %0)
%3 = inttoptr i64 %2 to i8*
ret i8* %3
}
/* Variables and functions */
int ccnl_lrpc_fieldlen(unsigned int);
int ccnl_lrpc_TLlen(unsigned int type, unsigned int len) {
  return ccnl_lrpc_fieldlen(type) + ccnl_lrpc_fieldlen(len);
}


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

x86 assembly (clang, -O2):
<ccnl_lrpc_TLlen>:
push   %rbp
push   %rbx
push   %rax
mov    %esi,%ebx
call   1030 <ccnl_lrpc_fieldlen@plt>
mov    %eax,%ebp
mov    %ebx,%edi
call   1030 <ccnl_lrpc_fieldlen@plt>
add    %ebp,%eax
add    $0x8,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define i32 @ccnl_lrpc_TLlen(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 = call i32 @ccnl_lrpc_fieldlen(i32 %5)
%7 = load i32, i32* %4
%8 = call i32 @ccnl_lrpc_fieldlen(i32 %7)
%9 = add nsw i32 %6, %8
ret i32 %9
}

LLVM IR (-O2):
define i32 @ccnl_lrpc_TLlen(i32 %0, i32 %1) {
%3 = tail call i32 @ccnl_lrpc_fieldlen(i32 %0)
%4 = tail call i32 @ccnl_lrpc_fieldlen(i32 %1)
%5 = add nsw i32 %4, %3
ret i32 %5
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *);
int usage() {
  printf("Usage:\n"
         "\t shdump [options] <filename>\n"
         "Supported Options:\n"
         "\t -j N  \t skip N bytes\n"
         "\t -n N  \t dump up to N bytes\n");
  return -1;
}


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

x86 assembly (clang, -O2):
<usage>:
push   %rax
lea    0xee8(%rip),%rdi
call   1030 <puts@plt>
mov    $0xffffffff,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [109 x i8] c"Usage:\0A\09 shdump [options] <filename>\0ASupported Options:\0A\09 -j N \09 skip N bytes\0A\09 -n N \09 dump up to N bytes\0A\00"
define i32 @usage() {
%1 = call i32 @printf(i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str, i64 0, i64 0))
ret i32 -1
}

LLVM IR (-O2):
@str = [108 x i8] c"Usage:\0A\09 shdump [options] <filename>\0ASupported Options:\0A\09 -j N \09 skip N bytes\0A\09 -n N \09 dump up to N bytes\00"
define i32 @usage() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([108 x i8], [108 x i8]* @str, i64 0, i64 0))
ret i32 -1
}
void neural_layer_softmax_rand(struct Layer *l) { (void)l; }


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

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

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

LLVM IR (-O2):
%struct.Layer = type opaque
define void @neural_layer_softmax_rand(%struct.Layer* nocapture %0) {
ret void
}
double Tween_BackInEasing(double k) {
  double s = 1.70158;
  return k * k * ((s + 1) * k - s);
}


x86 assembly (clang, -O0):
<Tween_BackInEasing>:
push   %rbp
mov    %rsp,%rbp
movsd  %xmm0,-0x8(%rbp)
movsd  0xef7(%rip),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  -0x8(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
movsd  0xed8(%rip),%xmm1
addsd  -0x10(%rbp),%xmm1
movsd  -0x8(%rbp),%xmm3
movsd  -0x10(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<Tween_BackInEasing>:
movapd %xmm0,%xmm1
mulsd  0xef4(%rip),%xmm0
mulsd  %xmm1,%xmm1
addsd  0xef0(%rip),%xmm0
mulsd  %xmm1,%xmm0
ret

LLVM IR (-O0):
define double @Tween_BackInEasing(double %0) {
%2 = alloca double
%3 = alloca double
store double %0, double* %2
store double 1.701580e+00, double* %3
%4 = load double, double* %2
%5 = load double, double* %2
%6 = fmul double %4, %5
%7 = load double, double* %3
%8 = fadd double %7, 1.000000e+00
%9 = load double, double* %2
%10 = load double, double* %3
%11 = fneg double %10
%12 = call double @llvm.fmuladd.f64(double %8, double %9, double %11)
%13 = fmul double %6, %12
ret double %13
}

LLVM IR (-O2):
define double @Tween_BackInEasing(double %0) {
%2 = fmul double %0, %0
%3 = tail call double @llvm.fmuladd.f64(double %0, double 2.701580e+00, double -1.701580e+00)
%4 = fmul double %2, %3
ret double %4
}
int open_pp(const char *devicename) {
  if (devicename)
    return -1;
  return -1;
}


x86 assembly (clang, -O0):
<open_pp>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     111f <open_pp+0x1f>
movl   $0xffffffff,-0x4(%rbp)
jmp    1126 <open_pp+0x26>
movl   $0xffffffff,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

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

LLVM IR (-O0):
define i32 @open_pp(i8* %0) {
%2 = alloca i32
%3 = alloca i8*
store i8* %0, i8** %3
%4 = load i8*, i8** %3
%5 = icmp ne i8* %4, null
br i1 %5, label %6, label %7
6: ; preds = %1
store i32 -1, i32* %2
br label %8
7: ; preds = %1
store i32 -1, i32* %2
br label %8
8: ; preds = %7, %6
%9 = load i32, i32* %2
ret i32 %9
}

LLVM IR (-O2):
define i32 @open_pp(i8* nocapture readnone %0) {
ret i32 -1
}
/* Variables and functions */
int /*<<< orphan*/ e_bit();
int /*<<< orphan*/ e_zp();
void e_bit_zp() {
  e_zp();
  e_bit();
}


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

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

LLVM IR (-O0):
define void @e_bit_zp() {
%1 = call i32 (...) @e_zp()
%2 = call i32 (...) @e_bit()
ret void
}

LLVM IR (-O2):
define void @e_bit_zp() {
%1 = tail call i32 (...) @e_zp()
%2 = tail call i32 (...) @e_bit()
ret void
}
/* Variables and functions */
int rand();
int coap_prng_impl(unsigned char *buf, size_t len) {
  while (len--)
    *buf++ = rand() & 0xFF;
  return 1;
}


x86 assembly (clang, -O0):
<coap_prng_impl>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x10(%rbp)
cmp    $0x0,%rax
je     115d <coap_prng_impl+0x4d>
mov    $0x0,%al
call   1030 <rand@plt>
and    $0xff,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
jmp    1120 <coap_prng_impl+0x10>
mov    $0x1,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<coap_prng_impl>:
push   %r15
push   %r14
push   %rbx
test   %rsi,%rsi
je     1144 <coap_prng_impl+0x34>
mov    %rsi,%r15
mov    %rdi,%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
call   1030 <rand@plt>
mov    %al,(%r14,%rbx,1)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1130 <coap_prng_impl+0x20>
mov    $0x1,%eax
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define i32 @coap_prng_impl(i8* %0, i64 %1) {
%3 = alloca i8*
%4 = alloca i64
store i8* %0, i8** %3
store i64 %1, i64* %4
br label %5
5: ; preds = %9, %2
%6 = load i64, i64* %4
%7 = add i64 %6, -1
store i64 %7, i64* %4
%8 = icmp ne i64 %6, 0
br i1 %8, label %9, label %15
9: ; preds = %5
%10 = call i32 (...) @rand()
%11 = and i32 %10, 255
%12 = trunc i32 %11 to i8
%13 = load i8*, i8** %3
%14 = getelementptr inbounds i8, i8* %13, i32 1
store i8* %14, i8** %3
store i8 %12, i8* %13
br label %5
15: ; preds = %5
ret i32 1
}

LLVM IR (-O2):
define i32 @coap_prng_impl(i8* nocapture writeonly %0, i64 %1) {
%3 = icmp eq i64 %1, 0
br i1 %3, label %12, label %4
4: ; preds = %2, %4
%5 = phi i64 [ %7, %4 ], [ %1, %2 ]
%6 = phi i8* [ %10, %4 ], [ %0, %2 ]
%7 = add i64 %5, -1
%8 = tail call i32 (...) @rand()
%9 = trunc i32 %8 to i8
%10 = getelementptr inbounds i8, i8* %6, i64 1
store i8 %9, i8* %6
%11 = icmp eq i64 %7, 0
br i1 %11, label %12, label %4
12: ; preds = %4, %2
ret i32 1
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, float, float);
int /*<<< orphan*/ scanf(char *, float *, float *, float *);
int main() {
  float N, H, S_H;
  scanf(" %f %f %f", &N, &H, &S_H);
  printf("NUMBER = %0.0f\nSALARY = U$ %0.2f\n", N, H * S_H);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeca(%rip),%rdi
lea    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdx
lea    -0x10(%rbp),%rcx
call   1040 <scanf@plt>
movss  -0x8(%rbp),%xmm0
movss  -0xc(%rbp),%xmm1
mulss  -0x10(%rbp),%xmm1
lea    0xead(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
sub    $0x18,%rsp
lea    0xed5(%rip),%rdi
lea    0x14(%rsp),%rsi
lea    0x10(%rsp),%rdx
lea    0xc(%rsp),%rcx
call   1040 <scanf@plt>
movss  0x14(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
mulss  0xc(%rsp),%xmm1
lea    0xeb2(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x18,%rsp
ret

LLVM IR (-O0):
@.str = [10 x i8] c" %f %f %f\00"
@.str.1 = [34 x i8] c"NUMBER = %0.0f\0ASALARY = U$ %0.2f\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca float
%3 = alloca float
%4 = alloca float
store i32 0, i32* %1
%5 = call i32 @scanf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), float* %2, float* %3, float* %4)
%6 = load float, float* %2
%7 = load float, float* %3
%8 = load float, float* %4
%9 = fmul float %7, %8
%10 = call i32 @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), float %6, float %9)
ret i32 0
}

LLVM IR (-O2):
@.str = [10 x i8] c" %f %f %f\00"
@.str.1 = [34 x i8] c"NUMBER = %0.0f\0ASALARY = U$ %0.2f\0A\00"
define i32 @main() {
%1 = alloca float
%2 = alloca float
%3 = alloca float
%4 = bitcast float* %1 to i8*
%5 = bitcast float* %2 to i8*
%6 = bitcast float* %3 to i8*
%7 = call i32 @scanf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), float* %1, float* %2, float* %3)
%8 = load float, float* %1
%9 = load float, float* %2
%10 = load float, float* %3
%11 = fmul float %9, %10
%12 = call i32 @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), float %8, float %11)
ret i32 0
}
void print_matrix(char *name, void *B, int rows, int cols) {}


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

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

LLVM IR (-O0):
define void @print_matrix(i8* %0, i8* %1, i32 %2, i32 %3) {
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
store i8* %0, i8** %5
store i8* %1, i8** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
ret void
}

LLVM IR (-O2):
define void @print_matrix(i8* nocapture %0, i8* nocapture %1, i32 %2, i32 %3) {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ emit_adcimm(int, int /*<<< orphan*/, int);
int /*<<< orphan*/ emit_andimm(int, int, int);
int /*<<< orphan*/ emit_cmp(int, int);
void emit_cmphs(int s1, int s2, int sr, int temp) {
  emit_andimm(sr, ~1, sr);
  emit_cmp(s2, s1);
  emit_adcimm(sr, 0, sr);
}


x86 assembly (clang, -O0):
<emit_cmphs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    -0xc(%rbp),%edi
mov    -0xc(%rbp),%edx
mov    $0xfffffffe,%esi
call   1050 <emit_andimm@plt>
mov    -0x8(%rbp),%edi
mov    -0x4(%rbp),%esi
call   1040 <emit_cmp@plt>
mov    -0xc(%rbp),%edi
mov    -0xc(%rbp),%edx
xor    %esi,%esi
call   1030 <emit_adcimm@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<emit_cmphs>:
push   %rbp
push   %r14
push   %rbx
mov    %edx,%ebx
mov    %esi,%ebp
mov    %edi,%r14d
mov    %edx,%edi
mov    $0xfffffffe,%esi
call   1050 <emit_andimm@plt>
mov    %ebp,%edi
mov    %r14d,%esi
call   1040 <emit_cmp@plt>
mov    %ebx,%edi
xor    %esi,%esi
mov    %ebx,%edx
pop    %rbx
pop    %r14
pop    %rbp
jmp    1030 <emit_adcimm@plt>

LLVM IR (-O0):
define void @emit_cmphs(i32 %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i32 %0, i32* %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%9 = load i32, i32* %7
%10 = load i32, i32* %7
%11 = call i32 @emit_andimm(i32 %9, i32 -2, i32 %10)
%12 = load i32, i32* %6
%13 = load i32, i32* %5
%14 = call i32 @emit_cmp(i32 %12, i32 %13)
%15 = load i32, i32* %7
%16 = load i32, i32* %7
%17 = call i32 @emit_adcimm(i32 %15, i32 0, i32 %16)
ret void
}

LLVM IR (-O2):
define void @emit_cmphs(i32 %0, i32 %1, i32 %2, i32 %3) {
%5 = tail call i32 @emit_andimm(i32 %2, i32 -2, i32 %2)
%6 = tail call i32 @emit_cmp(i32 %1, i32 %0)
%7 = tail call i32 @emit_adcimm(i32 %2, i32 0, i32 %2)
ret void
}
void gdk_x11_image_get_xdisplay() {}


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

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

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

LLVM IR (-O2):
define void @gdk_x11_image_get_xdisplay() {
ret void
}
int calculateSingleAmount(int *remainder, int sizeBill) {
  int tempRemainder = *remainder / sizeBill;
  *remainder = *remainder % sizeBill;
  return tempRemainder;
}


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

x86 assembly (clang, -O2):
<calculateSingleAmount>:
mov    (%rdi),%eax
cltd
idiv   %esi
mov    %edx,(%rdi)
ret

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

LLVM IR (-O2):
define i32 @calculateSingleAmount(i32* nocapture %0, i32 %1) {
%3 = load i32, i32* %0
%4 = sdiv i32 %3, %1
%5 = srem i32 %3, %1
store i32 %5, i32* %0
ret i32 %4
}
int xtensa_const16(v)
int v;
{ return 1; }


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

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

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

LLVM IR (-O2):
define i32 @xtensa_const16(i32 %0) {
ret i32 1
}
/* Type definitions */
typedef int /*<<< orphan*/ va_list;

/* Variables and functions */
int /*<<< orphan*/ print_tap_result(char *, unsigned long, char const *,
                                    int /*<<< orphan*/);
int /*<<< orphan*/ safe_printf(char *);
void tap_not_ok_skip_va(unsigned long testnum, const char *msg, va_list ap) {
  print_tap_result("not ok", testnum, msg, ap);
  safe_printf(" # SKIP \n");
}


x86 assembly (clang, -O0):
<tap_not_ok_skip_va>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x14(%rbp),%ecx
lea    0xebb(%rip),%rdi
call   1040 <print_tap_result@plt>
lea    0xeb6(%rip),%rdi
call   1030 <safe_printf@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tap_not_ok_skip_va>:
push   %rax
mov    %edx,%ecx
mov    %rsi,%rdx
mov    %rdi,%rsi
lea    0xed0(%rip),%rdi
call   1040 <print_tap_result@plt>
lea    0xecb(%rip),%rdi
pop    %rax
jmp    1030 <safe_printf@plt>

LLVM IR (-O0):
@.str = [7 x i8] c"not ok\00"
@.str.1 = [10 x i8] c" # SKIP \0A\00"
define void @tap_not_ok_skip_va(i64 %0, i8* %1, i32 %2) {
%4 = alloca i64
%5 = alloca i8*
%6 = alloca i32
store i64 %0, i64* %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%7 = load i64, i64* %4
%8 = load i8*, i8** %5
%9 = load i32, i32* %6
%10 = call i32 @print_tap_result(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i64 %7, i8* %8, i32 %9)
%11 = call i32 @safe_printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [7 x i8] c"not ok\00"
@.str.1 = [10 x i8] c" # SKIP \0A\00"
define void @tap_not_ok_skip_va(i64 %0, i8* %1, i32 %2) {
%4 = tail call i32 @print_tap_result(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i64 %0, i8* %1, i32 %2)
%5 = tail call i32 @safe_printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
ret void
}