xunge/DecIR huggingface dataset:
/* Type definitions */
struct pico_mqtt_serializer {
  int dummy;
};

/* Variables and functions */
int serialize_acknowledge(struct pico_mqtt_serializer *, int);
int serialize_puback(struct pico_mqtt_serializer *serializer) {
  do {
  } while (0);
  return serialize_acknowledge(serializer, (4 << 4));
}


x86 assembly (clang, -O0):
<serialize_puback>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
jmp    1121 <serialize_puback+0x11>
mov    -0x8(%rbp),%rdi
mov    $0x40,%esi
call   1030 <serialize_acknowledge@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<serialize_puback>:
mov    $0x40,%esi
jmp    1030 <serialize_acknowledge@plt>

LLVM IR (-O0):
%struct.pico_mqtt_serializer = type { i32 }
define i32 @serialize_puback(%struct.pico_mqtt_serializer* %0) {
%2 = alloca %struct.pico_mqtt_serializer*
store %struct.pico_mqtt_serializer* %0, %struct.pico_mqtt_serializer** %2
br label %3
3: ; preds = %1
br label %4
4: ; preds = %3
%5 = load %struct.pico_mqtt_serializer*, %struct.pico_mqtt_serializer** %2
%6 = call i32 @serialize_acknowledge(%struct.pico_mqtt_serializer* %5, i32 64)
ret i32 %6
}

LLVM IR (-O2):
%struct.pico_mqtt_serializer = type { i32 }
define i32 @serialize_puback(%struct.pico_mqtt_serializer* %0) {
%2 = tail call i32 @serialize_acknowledge(%struct.pico_mqtt_serializer* %0, i32 64)
ret i32 %2
}
/* Type definitions */
typedef scalar_t__ uint16_t;

/* Variables and functions */
scalar_t__ _getReg(int);
float getTemp() {
  uint16_t ret;
  ret = _getReg(0x00);
  if (ret < 0)
    return -999.;
  return (float)ret / 65536. * 165. - 40.;
}


x86 assembly (clang, -O0):
<getTemp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
xor    %edi,%edi
call   1030 <_getReg@plt>
mov    %rax,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
jge    1140 <getTemp+0x30>
movss  0xee2(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    1177 <getTemp+0x67>
cvtsi2ssq -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xebe(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0xea2(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe9e(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getTemp>:
push   %rax
xor    %edi,%edi
call   1030 <_getReg@plt>
test   %rax,%rax
js     1144 <getTemp+0x34>
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0xeda(%rip),%xmm0
mulsd  0xeda(%rip),%xmm0
addsd  0xeda(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
pop    %rax
ret
movss  0xeb4(%rip),%xmm0
pop    %rax
ret

LLVM IR (-O0):
define float @getTemp() {
%1 = alloca float
%2 = alloca i64
%3 = call i64 @_getReg(i32 0)
store i64 %3, i64* %2
%4 = load i64, i64* %2
%5 = icmp slt i64 %4, 0
br i1 %5, label %6, label %7
6: ; preds = %0
store float -9.990000e+02, float* %1
br label %14
7: ; preds = %0
%8 = load i64, i64* %2
%9 = sitofp i64 %8 to float
%10 = fpext float %9 to double
%11 = fdiv double %10, 6.553600e+04
%12 = call double @llvm.fmuladd.f64(double %11, double 1.650000e+02, double -4.000000e+01)
%13 = fptrunc double %12 to float
store float %13, float* %1
br label %14
14: ; preds = %7, %6
%15 = load float, float* %1
ret float %15
}

LLVM IR (-O2):
define float @getTemp() {
%1 = tail call i64 @_getReg(i32 0)
%2 = icmp slt i64 %1, 0
br i1 %2, label %9, label %3
3: ; preds = %0
%4 = sitofp i64 %1 to float
%5 = fpext float %4 to double
%6 = fmul double %5, 0x3EF0000000000000
%7 = tail call double @llvm.fmuladd.f64(double %6, double 1.650000e+02, double -4.000000e+01)
%8 = fptrunc double %7 to float
br label %9
9: ; preds = %0, %3
%10 = phi float [ %8, %3 ], [ -9.990000e+02, %0 ]
ret float %10
}
/* Type definitions */
typedef int uint32_t;

/* Variables and functions */
void EMACTxFlush(uint32_t ui32Base) {
  if ((*((volatile uint32_t *)(ui32Base + 0x00000024))) & 0x01000000) {
    (*((volatile uint32_t *)(ui32Base + 0x00000C18))) |= 0x00100000;
    while ((*((volatile uint32_t *)(ui32Base + 0x00000C18))) & 0x00100000) {
    }
  }
}


x86 assembly (clang, -O0):
<EMACTxFlush>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x24,%eax
cltq
mov    (%rax),%eax
and    $0x1000000,%eax
cmp    $0x0,%eax
je     1157 <EMACTxFlush+0x57>
mov    -0x4(%rbp),%eax
add    $0xc18,%eax
cltq
mov    (%rax),%ecx
or     $0x100000,%ecx
mov    %ecx,(%rax)
mov    -0x4(%rbp),%eax
add    $0xc18,%eax
cltq
mov    (%rax),%eax
and    $0x100000,%eax
cmp    $0x0,%eax
je     1152 <EMACTxFlush+0x52>
jmp    1133 <EMACTxFlush+0x33>
jmp    1157 <EMACTxFlush+0x57>
pop    %rbp
ret

x86 assembly (clang, -O2):
<EMACTxFlush>:
movslq %edi,%rax
testl  $0x1000000,0x24(%rax)
je     112c <EMACTxFlush+0x2c>
orl    $0x100000,0xc18(%rax)
cs nopw 0x0(%rax,%rax,1)
testl  $0x100000,0xc18(%rax)
jne    1120 <EMACTxFlush+0x20>
ret

LLVM IR (-O0):
define void @EMACTxFlush(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
%3 = load i32, i32* %2
%4 = add nsw i32 %3, 36
%5 = sext i32 %4 to i64
%6 = inttoptr i64 %5 to i32*
%7 = load volatile i32, i32* %6
%8 = and i32 %7, 16777216
%9 = icmp ne i32 %8, 0
br i1 %9, label %10, label %27
10: ; preds = %1
%11 = load i32, i32* %2
%12 = add nsw i32 %11, 3096
%13 = sext i32 %12 to i64
%14 = inttoptr i64 %13 to i32*
%15 = load volatile i32, i32* %14
%16 = or i32 %15, 1048576
store volatile i32 %16, i32* %14
br label %17
17: ; preds = %25, %10
%18 = load i32, i32* %2
%19 = add nsw i32 %18, 3096
%20 = sext i32 %19 to i64
%21 = inttoptr i64 %20 to i32*
%22 = load volatile i32, i32* %21
%23 = and i32 %22, 1048576
%24 = icmp ne i32 %23, 0
br i1 %24, label %25, label %26
25: ; preds = %17
br label %17
26: ; preds = %17
br label %27
27: ; preds = %26, %1
ret void
}

LLVM IR (-O2):
define void @EMACTxFlush(i32 %0) {
%2 = add nsw i32 %0, 36
%3 = sext i32 %2 to i64
%4 = inttoptr i64 %3 to i32*
%5 = load volatile i32, i32* %4
%6 = and i32 %5, 16777216
%7 = icmp eq i32 %6, 0
br i1 %7, label %18, label %8
8: ; preds = %1
%9 = add nsw i32 %0, 3096
%10 = sext i32 %9 to i64
%11 = inttoptr i64 %10 to i32*
%12 = load volatile i32, i32* %11
%13 = or i32 %12, 1048576
store volatile i32 %13, i32* %11
br label %14
14: ; preds = %14, %8
%15 = load volatile i32, i32* %11
%16 = and i32 %15, 1048576
%17 = icmp eq i32 %16, 0
br i1 %17, label %18, label %14
18: ; preds = %14, %1
ret void
}
void phobos_pwm_ioreuse(void) {
  unsigned int value;
  value = ({
    unsigned int __v = (*(volatile unsigned int *)(0x50018008));
    __v;
  });
  value |= ((0x00000001 | 0x00000002 | 0x00000010 | 0x00000020 | 0x00000040 |
             0x00000200 | 0x00000400 | 0x00000800 | 0x00010000 | 0x00020000 |
             0x00040000 | 0x00400000 | 0x00800000 | 0x04000000 | 0x08000000) |
            0x00000001 | 0x00000002 | 0x00000004 | 0x00001000 | 0x00002000 |
            0x00004000);
  (void)((*(volatile unsigned int *)(0x50018008)) = (value));
  value = ({
    unsigned int __v = (*(volatile unsigned int *)(0x50018100));
    __v;
  });
  value |= ((0x00000000 | 0x00000000 | 0x00000000 | 0x00000000 | 0x00001000 |
             0x00040000 | 0x00000000 | 0x00000000) |
            0x00000001 | 0x00000004 | 0x00000010 | 0x01000000 | 0x04000000 |
            0x10000000);
  (void)((*(volatile unsigned int *)(0x50018100)) = (value));
}


x86 assembly (clang, -O0):
<phobos_pwm_ioreuse>:
push   %rbp
mov    %rsp,%rbp
mov    $0x50018008,%eax
mov    (%rax),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
or     $0xcc77e77,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%ecx
mov    $0x50018008,%eax
mov    %ecx,(%rax)
mov    $0x50018100,%eax
mov    (%rax),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
or     $0x15041015,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%ecx
mov    $0x50018100,%eax
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<phobos_pwm_ioreuse>:
orl    $0xcc77e77,0x50018008
77 7e c7 0c
orl    $0x15041015,0x50018100
15 10 04 15
ret

LLVM IR (-O0):
define void @phobos_pwm_ioreuse() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = load volatile i32, i32* inttoptr (i64 1342275592 to i32*)
store i32 %6, i32* %2
%7 = load i32, i32* %2
store i32 %7, i32* %3
%8 = load i32, i32* %3
store i32 %8, i32* %1
%9 = load i32, i32* %1
%10 = or i32 %9, 214400631
store i32 %10, i32* %1
%11 = load i32, i32* %1
store volatile i32 %11, i32* inttoptr (i64 1342275592 to i32*)
%12 = load volatile i32, i32* inttoptr (i64 1342275840 to i32*)
store i32 %12, i32* %4
%13 = load i32, i32* %4
store i32 %13, i32* %5
%14 = load i32, i32* %5
store i32 %14, i32* %1
%15 = load i32, i32* %1
%16 = or i32 %15, 352587797
store i32 %16, i32* %1
%17 = load i32, i32* %1
store volatile i32 %17, i32* inttoptr (i64 1342275840 to i32*)
ret void
}

LLVM IR (-O2):
define void @phobos_pwm_ioreuse() {
%1 = load volatile i32, i32* inttoptr (i64 1342275592 to i32*)
%2 = or i32 %1, 214400631
store volatile i32 %2, i32* inttoptr (i64 1342275592 to i32*)
%3 = load volatile i32, i32* inttoptr (i64 1342275840 to i32*)
%4 = or i32 %3, 352587797
store volatile i32 %4, i32* inttoptr (i64 1342275840 to i32*)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ wpa_supplicant_cancel_auth_timeout(void *);
void _wpa_supplicant_cancel_auth_timeout(void *wpa_s) {
  wpa_supplicant_cancel_auth_timeout(wpa_s);
}


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

x86 assembly (clang, -O2):
<_wpa_supplicant_cancel_auth_timeout>:
jmp    1030 <wpa_supplicant_cancel_auth_timeout@plt>

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

LLVM IR (-O2):
define void @_wpa_supplicant_cancel_auth_timeout(i8* %0) {
%2 = tail call i32 @wpa_supplicant_cancel_auth_timeout(i8* %0)
ret void
}
/* Variables and functions */
long strtol(char const *, int /*<<< orphan*/ *, unsigned int);
int strict_strtol(const char *str, unsigned int base, long *val) {
  *val = strtol(str, NULL, base);
  return 0;
}


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

x86 assembly (clang, -O2):
<strict_strtol>:
push   %rbx
mov    %rdx,%rbx
mov    %esi,%edx
xor    %esi,%esi
call   1030 <strtol@plt>
mov    %rax,(%rbx)
xor    %eax,%eax
pop    %rbx
ret

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

LLVM IR (-O2):
define i32 @strict_strtol(i8* nocapture %0, i32 %1, i64* nocapture writeonly %2) {
%4 = tail call i64 @strtol(i8* nocapture %0, i32* null, i32 %1)
store i64 %4, i64* %2
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ memcpy(char *, int /*<<< orphan*/, int);
void memcpy11() {
  char a[4] = {0};
  memcpy(a, 0, 4);
}


x86 assembly (clang, -O0):
<memcpy11>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
lea    -0x4(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
lea    -0x4(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1040 <memcpy@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy11>:
push   %rax
movl   $0x0,0x4(%rsp)
lea    0x4(%rsp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memcpy@plt>
pop    %rax
ret

LLVM IR (-O0):
define void @memcpy11() {
%1 = alloca [4 x i8]
%2 = bitcast [4 x i8]* %1 to i8*
%3 = getelementptr inbounds [4 x i8], [4 x i8]* %1, i64 0, i64 0
%4 = call i32 @memcpy(i8* %3, i32 0, i32 4)
ret void
}

LLVM IR (-O2):
define void @memcpy11() {
%1 = alloca i32
%2 = bitcast i32* %1 to i8*
store i32 0, i32* %1
%3 = call i32 @memcpy(i8* %2, i32 0, i32 4)
ret void
}
int extl(unsigned short w) {
  if (w & 0x8000) {
    long v = -65536;
    return (v | w);
  }
  return w;
}


x86 assembly (clang, -O0):
<extl>:
push   %rbp
mov    %rsp,%rbp
mov    %di,%ax
mov    %ax,-0x6(%rbp)
movzwl -0x6(%rbp),%eax
and    $0x8000,%eax
cmp    $0x0,%eax
je     1138 <extl+0x38>
movq   $0xffffffffffff0000,-0x10(%rbp)
ff
mov    -0x10(%rbp),%rax
movzwl -0x6(%rbp),%ecx
or     %rcx,%rax
mov    %eax,-0x4(%rbp)
jmp    113f <extl+0x3f>
movzwl -0x6(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<extl>:
lea    -0x10000(%rdi),%eax
test   $0x8000,%edi
cmove  %edi,%eax
ret

LLVM IR (-O0):
define i32 @extl(i16 zeroext %0) {
%2 = alloca i32
%3 = alloca i16
%4 = alloca i64
store i16 %0, i16* %3
%5 = load i16, i16* %3
%6 = zext i16 %5 to i32
%7 = and i32 %6, 32768
%8 = icmp ne i32 %7, 0
br i1 %8, label %9, label %15
9: ; preds = %1
store i64 -65536, i64* %4
%10 = load i64, i64* %4
%11 = load i16, i16* %3
%12 = zext i16 %11 to i64
%13 = or i64 %10, %12
%14 = trunc i64 %13 to i32
store i32 %14, i32* %2
br label %18
15: ; preds = %1
%16 = load i16, i16* %3
%17 = zext i16 %16 to i32
store i32 %17, i32* %2
br label %18
18: ; preds = %15, %9
%19 = load i32, i32* %2
ret i32 %19
}

LLVM IR (-O2):
define i32 @extl(i16 zeroext %0) {
%2 = zext i16 %0 to i32
%3 = and i32 %2, 32768
%4 = icmp eq i32 %3, 0
%5 = or i32 %2, -65536
%6 = select i1 %4, i32 %2, i32 %5
ret i32 %6
}
/* Variables and functions */
int /*<<< orphan*/ f1(int *);
void i(int c[]) { f1(c); }


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

x86 assembly (clang, -O2):
<i>:
jmp    1030 <f1@plt>

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

LLVM IR (-O2):
define void @i(i32* %0) {
%2 = tail call i32 @f1(i32* %0)
ret void
}
/* Type definitions */
typedef int /*<<< orphan*/ ssize_t;
typedef int /*<<< orphan*/ off_t;

/* Variables and functions */
int /*<<< orphan*/ mfs_get_fi(int);
int /*<<< orphan*/ mfs_pread_int(int /*<<< orphan*/, void *, size_t,
                                 int /*<<< orphan*/);
ssize_t mfs_pread(int fildes, void *buf, size_t nbyte, off_t offset) {
  return mfs_pread_int(mfs_get_fi(fildes), buf, nbyte, offset);
}


x86 assembly (clang, -O0):
<mfs_pread>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x4(%rbp),%edi
call   1030 <mfs_get_fi@plt>
mov    %eax,%edi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
call   1040 <mfs_pread_int@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mfs_pread>:
push   %rbp
push   %r14
push   %rbx
mov    %ecx,%r14d
mov    %rdx,%rbx
mov    %rsi,%rbp
call   1030 <mfs_get_fi@plt>
mov    %eax,%edi
mov    %rbp,%rsi
mov    %rbx,%rdx
mov    %r14d,%ecx
pop    %rbx
pop    %r14
pop    %rbp
jmp    1040 <mfs_pread_int@plt>

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

LLVM IR (-O2):
define i32 @mfs_pread(i32 %0, i8* %1, i64 %2, i32 %3) {
%5 = tail call i32 @mfs_get_fi(i32 %0)
%6 = tail call i32 @mfs_pread_int(i32 %5, i8* %1, i64 %2, i32 %3)
ret i32 %6
}
int isPaired(char openBracket, char closeBracket) {
  if (openBracket == '(' && closeBracket == ')')
    return 1;
  else if (openBracket == '[' && closeBracket == ']')
    return 1;
  else if (openBracket == '{' && closeBracket == '}')
    return 1;
  else
    return 0;
}


x86 assembly (clang, -O0):
<isPaired>:
push   %rbp
mov    %rsp,%rbp
mov    %sil,%al
mov    %dil,%cl
mov    %cl,-0x5(%rbp)
mov    %al,-0x6(%rbp)
movsbl -0x5(%rbp),%eax
cmp    $0x28,%eax
jne    1136 <isPaired+0x36>
movsbl -0x6(%rbp),%eax
cmp    $0x29,%eax
jne    1136 <isPaired+0x36>
movl   $0x1,-0x4(%rbp)
jmp    1189 <isPaired+0x89>
movsbl -0x5(%rbp),%eax
cmp    $0x5b,%eax
jne    115c <isPaired+0x5c>
movsbl -0x6(%rbp),%eax
cmp    $0x5d,%eax
jne    115c <isPaired+0x5c>
movl   $0x1,-0x4(%rbp)
jmp    1189 <isPaired+0x89>
movsbl -0x5(%rbp),%eax
cmp    $0x7b,%eax
jne    1182 <isPaired+0x82>
movsbl -0x6(%rbp),%eax
cmp    $0x7d,%eax
jne    1182 <isPaired+0x82>
movl   $0x1,-0x4(%rbp)
jmp    1189 <isPaired+0x89>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<isPaired>:
mov    $0x1,%eax
cmp    $0x28,%dil
jne    1112 <isPaired+0x12>
cmp    $0x29,%sil
jne    1112 <isPaired+0x12>
ret
cmp    $0x5b,%dil
jne    111e <isPaired+0x1e>
cmp    $0x5d,%sil
je     1111 <isPaired+0x11>
xor    $0x7b,%dil
xor    $0x7d,%sil
xor    %eax,%eax
or     %dil,%sil
sete   %al
ret

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

LLVM IR (-O2):
define i32 @isPaired(i8 signext %0, i8 signext %1) {
%3 = icmp eq i8 %0, 40
%4 = icmp eq i8 %1, 41
%5 = and i1 %3, %4
br i1 %5, label %15, label %6
6: ; preds = %2
%7 = icmp eq i8 %0, 91
%8 = icmp eq i8 %1, 93
%9 = and i1 %7, %8
br i1 %9, label %15, label %10
10: ; preds = %6
%11 = icmp eq i8 %0, 123
%12 = icmp eq i8 %1, 125
%13 = and i1 %11, %12
%14 = zext i1 %13 to i32
br label %15
15: ; preds = %10, %6, %2
%16 = phi i32 [ 1, %2 ], [ 1, %6 ], [ %14, %10 ]
ret i32 %16
}
/* Variables and functions */
int /*<<< orphan*/ assert(int);
int find_or_insert(int);
void *process7(void *arg) {
  int val = 41;
  int found = find_or_insert(val);
  assert(found);
  return NULL;
}


x86 assembly (clang, -O0):
<process7>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x29,-0xc(%rbp)
mov    -0xc(%rbp),%edi
call   1040 <find_or_insert@plt>
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%edi
call   1030 <assert@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<process7>:
push   %rax
mov    $0x29,%edi
call   1040 <find_or_insert@plt>
mov    %eax,%edi
call   1030 <assert@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
define i8* @process7(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
store i8* %0, i8** %2
store i32 41, i32* %3
%5 = load i32, i32* %3
%6 = call i32 @find_or_insert(i32 %5)
store i32 %6, i32* %4
%7 = load i32, i32* %4
%8 = call i32 @assert(i32 %7)
ret i8* null
}

LLVM IR (-O2):
define noalias i8* @process7(i8* nocapture readnone %0) {
%2 = tail call i32 @find_or_insert(i32 41)
%3 = tail call i32 @assert(i32 %2)
ret i8* null
}
void g_value_get_flags() {}


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

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

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

LLVM IR (-O2):
define void @g_value_get_flags() {
ret void
}
long clear_traces_i(long a, long b, long c, long d, long e, long f, long g,
                    long h, long i, long j, long k, long l, long m, long n,
                    long o, long p) {
  return 0;
}


x86 assembly (clang, -O0):
<clear_traces_i>:
push   %rbp
mov    %rsp,%rbp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
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)
xor    %eax,%eax
pop    %rbp
ret

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

LLVM IR (-O0):
define i64 @clear_traces_i(i64 %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5, i64 %6, i64 %7, i64 %8, i64 %9, i64 %10, i64 %11, i64 %12, i64 %13, i64 %14, i64 %15) {
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
%25 = alloca i64
%26 = alloca i64
%27 = alloca i64
%28 = alloca i64
%29 = alloca i64
%30 = alloca i64
%31 = alloca i64
%32 = alloca i64
store i64 %0, i64* %17
store i64 %1, i64* %18
store i64 %2, i64* %19
store i64 %3, i64* %20
store i64 %4, i64* %21
store i64 %5, i64* %22
store i64 %6, i64* %23
store i64 %7, i64* %24
store i64 %8, i64* %25
store i64 %9, i64* %26
store i64 %10, i64* %27
store i64 %11, i64* %28
store i64 %12, i64* %29
store i64 %13, i64* %30
store i64 %14, i64* %31
store i64 %15, i64* %32
ret i64 0
}

LLVM IR (-O2):
define i64 @clear_traces_i(i64 %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5, i64 %6, i64 %7, i64 %8, i64 %9, i64 %10, i64 %11, i64 %12, i64 %13, i64 %14, i64 %15) {
ret i64 0
}
/* Variables and functions */
int /*<<< orphan*/ check_prime(int);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  int N;
  scanf("%d", &N);
  check_prime(N);
  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
call   1040 <scanf@plt>
mov    -0x8(%rbp),%edi
call   1030 <check_prime@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
lea    0xed8(%rip),%rdi
lea    0x4(%rsp),%rsi
call   1040 <scanf@plt>
mov    0x4(%rsp),%edi
call   1030 <check_prime@plt>
xor    %eax,%eax
pop    %rcx
ret

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

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
define i32 @main() {
%1 = alloca i32
%2 = bitcast i32* %1 to i8*
%3 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%4 = load i32, i32* %1
%5 = call i32 @check_prime(i32 %4)
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ permute(char *, int);
int main() {
  int size = 5;
  char *tmp = "outer";
  permute(tmp, size);
  return 0;
}


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

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

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

LLVM IR (-O2):
@.str = [6 x i8] c"outer\00"
define i32 @main() {
%1 = tail call i32 @permute(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32 5)
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ CloseDoscarFilePointer();
int /*<<< orphan*/ free_ArgResources();
int /*<<< orphan*/ free_PartialDosArray();
int /*<<< orphan*/ free_TotalDosArray();
void FreeProgramResources() {
  CloseDoscarFilePointer();
  free_TotalDosArray();
  free_PartialDosArray();
  free_ArgResources();
}


x86 assembly (clang, -O0):
<FreeProgramResources>:
push   %rbp
mov    %rsp,%rbp
mov    $0x0,%al
call   1030 <CloseDoscarFilePointer@plt>
mov    $0x0,%al
call   1060 <free_TotalDosArray@plt>
mov    $0x0,%al
call   1050 <free_PartialDosArray@plt>
mov    $0x0,%al
call   1040 <free_ArgResources@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<FreeProgramResources>:
push   %rax
xor    %eax,%eax
call   1030 <CloseDoscarFilePointer@plt>
xor    %eax,%eax
call   1060 <free_TotalDosArray@plt>
xor    %eax,%eax
call   1050 <free_PartialDosArray@plt>
xor    %eax,%eax
pop    %rcx
jmp    1040 <free_ArgResources@plt>

LLVM IR (-O0):
define void @FreeProgramResources() {
%1 = call i32 (...) @CloseDoscarFilePointer()
%2 = call i32 (...) @free_TotalDosArray()
%3 = call i32 (...) @free_PartialDosArray()
%4 = call i32 (...) @free_ArgResources()
ret void
}

LLVM IR (-O2):
define void @FreeProgramResources() {
%1 = tail call i32 (...) @CloseDoscarFilePointer()
%2 = tail call i32 (...) @free_TotalDosArray()
%3 = tail call i32 (...) @free_PartialDosArray()
%4 = tail call i32 (...) @free_ArgResources()
ret void
}
double x2lon_d(double x) { return x; }


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

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

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

LLVM IR (-O2):
define double @x2lon_d(double returned %0) {
ret double %0
}
void GPIOPortQ1_Handler(void) {
  while (1) {
  }
}


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

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

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

LLVM IR (-O2):
define void @GPIOPortQ1_Handler() {
br label %1
1: ; preds = %0, %1
br label %1
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, int, int);
int main() {
  printf("sizeof(unsigned int) = %u, sizeof(size_t) = %u\n",
         sizeof(unsigned int), sizeof(size_t));
  return 0;
}


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

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

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

LLVM IR (-O2):
@.str = [48 x i8] c"sizeof(unsigned int) = %u, sizeof(size_t) = %u\0A\00"
define i32 @main() {
%1 = tail call i32 @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str, i64 0, i64 0), i32 4, i32 8)
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ lgen(char *, char *, int);
int /*<<< orphan*/ ngen(char *, char *, int);
void cgincstat(char *i, int a, int v) {
  ngen("%s\tcx,%d", "mov", v);
  lgen("%s\t%c%d,cx", i, a);
}


x86 assembly (clang, -O0):
<cgincstat>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%edx
lea    0xec4(%rip),%rdi
lea    0xec6(%rip),%rsi
call   1040 <ngen@plt>
mov    -0x8(%rbp),%rsi
mov    -0xc(%rbp),%edx
lea    0xeb7(%rip),%rdi
call   1030 <lgen@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cgincstat>:
push   %rbp
push   %rbx
push   %rax
mov    %esi,%ebp
mov    %rdi,%rbx
lea    0xed1(%rip),%rdi
lea    0xed3(%rip),%rsi
call   1040 <ngen@plt>
lea    0xecb(%rip),%rdi
mov    %rbx,%rsi
mov    %ebp,%edx
add    $0x8,%rsp
pop    %rbx
pop    %rbp
jmp    1030 <lgen@plt>

LLVM IR (-O0):
@.str = [9 x i8] c"%s\09cx,%d\00"
@.str.1 = [4 x i8] c"mov\00"
@.str.2 = [11 x i8] c"%s\09%c%d,cx\00"
define void @cgincstat(i8* %0, i32 %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%7 = load i32, i32* %6
%8 = call i32 @ngen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %7)
%9 = load i8*, i8** %4
%10 = load i32, i32* %5
%11 = call i32 @lgen(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0), i8* %9, i32 %10)
ret void
}

LLVM IR (-O2):
@.str = [9 x i8] c"%s\09cx,%d\00"
@.str.1 = [4 x i8] c"mov\00"
@.str.2 = [11 x i8] c"%s\09%c%d,cx\00"
define void @cgincstat(i8* %0, i32 %1, i32 %2) {
%4 = tail call i32 @ngen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %2)
%5 = tail call i32 @lgen(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0), i8* %0, i32 %1)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ entab(char *);
int /*<<< orphan*/ settab(int, char **, char *);
main(int argc, char *argv[]) {
  char tab[100 + 1];
  settab(argc, argv, tab);
  entab(tab);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
lea    -0x80(%rbp),%rdx
call   1030 <settab@plt>
lea    -0x80(%rbp),%rdi
call   1040 <entab@plt>
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x70,%rsp
mov    %rsp,%rbx
mov    %rbx,%rdx
call   1030 <settab@plt>
mov    %rbx,%rdi
call   1040 <entab@plt>
xor    %eax,%eax
add    $0x70,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [101 x i8]
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%7 = load i32, i32* %4
%8 = load i8**, i8*** %5
%9 = getelementptr inbounds [101 x i8], [101 x i8]* %6, i64 0, i64 0
%10 = call i32 @settab(i32 %7, i8** %8, i8* %9)
%11 = getelementptr inbounds [101 x i8], [101 x i8]* %6, i64 0, i64 0
%12 = call i32 @entab(i8* %11)
ret i32 0
}

LLVM IR (-O2):
define i32 @main(i32 %0, i8** %1) {
%3 = alloca [101 x i8]
%4 = getelementptr inbounds [101 x i8], [101 x i8]* %3, i64 0, i64 0
%5 = call i32 @settab(i32 %0, i8** %1, i8* %4)
%6 = call i32 @entab(i8* %4)
ret i32 0
}
int ioInitSecurity(void) { return 1; }


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

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

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

LLVM IR (-O2):
define i32 @ioInitSecurity() {
ret i32 1
}
/* Forward declarations */
typedef struct TYPE_4__ TYPE_2__;
typedef struct TYPE_3__ TYPE_1__;

/* Type definitions */
struct TYPE_3__ {
  int /*<<< orphan*/ keycode;
};
struct TYPE_4__ {
  TYPE_1__ xkey;
};
typedef TYPE_2__ XEvent;

/* Variables and functions */
unsigned get_XEvent_xkey_keycode(void *_p) {
  return (unsigned)((XEvent *)_p)->xkey.keycode;
}


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

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

LLVM IR (-O0):
%struct.TYPE_4__ = type { %struct.TYPE_3__ }
%struct.TYPE_3__ = type { i32 }
define i32 @get_XEvent_xkey_keycode(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = bitcast i8* %3 to %struct.TYPE_4__*
%5 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %4, i32 0, i32 0
%6 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %5, i32 0, i32 0
%7 = load i32, i32* %6
ret i32 %7
}

LLVM IR (-O2):
define i32 @get_XEvent_xkey_keycode(i8* nocapture %0) {
%2 = bitcast i8* %0 to i32*
%3 = load i32, i32* %2
ret i32 %3
}
/* Variables and functions */
char *strdup(char *);
char *_longopt(char *longopt_help) {
  char *i, *spaces = strdup(longopt_help);
  for (i = spaces; *i; i++)
    *i = ' ';
  return spaces;
}


x86 assembly (clang, -O0):
<_longopt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strdup@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
je     1156 <_longopt+0x46>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1131 <_longopt+0x21>
mov    -0x18(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_longopt>:
push   %rax
call   1030 <strdup@plt>
cmpb   $0x0,(%rax)
je     113d <_longopt+0x2d>
mov    %rax,%rcx
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movb   $0x20,-0x1(%rcx)
cmpb   $0x0,(%rcx)
lea    0x1(%rcx),%rcx
jne    1130 <_longopt+0x20>
pop    %rcx
ret

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

LLVM IR (-O2):
define noalias i8* @_longopt(i8* nocapture %0) {
%2 = tail call i8* @strdup(i8* %0)
%3 = load i8, i8* %2
%4 = icmp eq i8 %3, 0
br i1 %4, label %10, label %5
5: ; preds = %1, %5
%6 = phi i8* [ %7, %5 ], [ %2, %1 ]
store i8 32, i8* %6
%7 = getelementptr inbounds i8, i8* %6, i64 1
%8 = load i8, i8* %7
%9 = icmp eq i8 %8, 0
br i1 %9, label %10, label %5
10: ; preds = %5, %1
ret i8* %2
}
/* Variables and functions */
int /*<<< orphan*/ exit(int const);
int /*<<< orphan*/ perror(char const *);
void check(const int cmd_return_value, const char *description) {
  if (cmd_return_value < 0) {
    perror(description);
    exit(cmd_return_value);
  }
}


x86 assembly (clang, -O0):
<check>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x0,-0x4(%rbp)
jge    114a <check+0x2a>
mov    -0x10(%rbp),%rdi
call   1030 <perror@plt>
mov    -0x4(%rbp),%edi
call   1040 <exit@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<check>:
test   %edi,%edi
js     1125 <check+0x5>
ret
push   %rbx
mov    %edi,%ebx
mov    %rsi,%rdi
call   1030 <perror@plt>
mov    %ebx,%edi
call   1040 <exit@plt>

LLVM IR (-O0):
define void @check(i32 %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
store i32 %0, i32* %3
store i8* %1, i8** %4
%5 = load i32, i32* %3
%6 = icmp slt i32 %5, 0
br i1 %6, label %7, label %12
7: ; preds = %2
%8 = load i8*, i8** %4
%9 = call i32 @perror(i8* %8)
%10 = load i32, i32* %3
%11 = call i32 @exit(i32 %10)
unreachable
12: ; preds = %2
ret void
}

LLVM IR (-O2):
define void @check(i32 %0, i8* nocapture %1) {
%3 = icmp slt i32 %0, 0
br i1 %3, label %4, label %7
4: ; preds = %2
%5 = tail call i32 @perror(i8* %1)
%6 = tail call i32 @exit(i32 %0)
unreachable
7: ; preds = %2
ret void
}
void gtk_window_set_keep_above() {}


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

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

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

LLVM IR (-O2):
define void @gtk_window_set_keep_above() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ isspace(char const);
int strlen(char const *);
int strlen_chomp(const char *value) {
  int i;
  for (i = strlen(value); i > 0; i--) {
    if (!isspace(value[i - 1]))
      break;
  }
  return i;
}


x86 assembly (clang, -O0):
<strlen_chomp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jle    1179 <strlen_chomp+0x59>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <isspace@plt>
cmp    $0x0,%eax
jne    1166 <strlen_chomp+0x46>
jmp    1179 <strlen_chomp+0x59>
jmp    116b <strlen_chomp+0x4b>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    1138 <strlen_chomp+0x18>
mov    -0xc(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<strlen_chomp>:
push   %rbp
push   %r14
push   %rbx
mov    %rdi,%rbx
call   1030 <strlen@plt>
mov    %eax,%ebp
xor    %r14d,%r14d
test   %eax,%eax
cmovs  %eax,%r14d
nopw   0x0(%rax,%rax,1)
test   %ebp,%ebp
jle    115c <strlen_chomp+0x3c>
movsbl -0x1(%rbx,%rbp,1),%edi
add    $0xffffffffffffffff,%rbp
call   1040 <isspace@plt>
test   %eax,%eax
jne    1140 <strlen_chomp+0x20>
add    $0x1,%ebp
mov    %ebp,%r14d
mov    %r14d,%eax
pop    %rbx
pop    %r14
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @strlen_chomp(i8* %0) {
%2 = tail call i32 @strlen(i8* %0)
%3 = zext i32 %2 to i64
%4 = call i32 @llvm.smin.i32(i32 %2, i32 0)
br label %5
5: ; preds = %9, %1
%6 = phi i64 [ %10, %9 ], [ %3, %1 ]
%7 = trunc i64 %6 to i32
%8 = icmp sgt i32 %7, 0
br i1 %8, label %9, label %17
9: ; preds = %5
%10 = add nsw i64 %6, -1
%11 = getelementptr inbounds i8, i8* %0, i64 %10
%12 = load i8, i8* %11
%13 = tail call i32 @isspace(i8 signext %12)
%14 = icmp eq i32 %13, 0
br i1 %14, label %15, label %5
15: ; preds = %9
%16 = trunc i64 %6 to i32
br label %17
17: ; preds = %5, %15
%18 = phi i32 [ %16, %15 ], [ %4, %5 ]
ret i32 %18
}
int ack(int m, int n) {
  if (m == 0)
    return (n + 1);
  if (n == 0)
    return ack(m - 1, 1);
  return ack(m - 1, ack(m, n - 1));
}


x86 assembly (clang, -O0):
<ack>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cmpl   $0x0,-0x8(%rbp)
jne    1136 <ack+0x26>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    117c <ack+0x6c>
cmpl   $0x0,-0xc(%rbp)
jne    1158 <ack+0x48>
mov    -0x8(%rbp),%edi
sub    $0x1,%edi
mov    $0x1,%esi
call   1030 <ack@plt>
mov    %eax,-0x4(%rbp)
jmp    117c <ack+0x6c>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
sub    $0x1,%esi
call   1030 <ack@plt>
mov    -0x10(%rbp),%edi
mov    %eax,%esi
call   1030 <ack@plt>
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ack>:
push   %rbx
mov    %esi,%eax
test   %edi,%edi
je     113f <ack+0x2f>
mov    %edi,%ebx
jmp    112a <ack+0x1a>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%eax
add    $0xffffffff,%ebx
je     113f <ack+0x2f>
test   %eax,%eax
je     1120 <ack+0x10>
add    $0xffffffff,%eax
mov    %ebx,%edi
mov    %eax,%esi
call   1030 <ack@plt>
add    $0xffffffff,%ebx
jne    112a <ack+0x1a>
add    $0x1,%eax
pop    %rbx
ret

LLVM IR (-O0):
define i32 @ack(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
store i32 %0, i32* %4
store i32 %1, i32* %5
%6 = load i32, i32* %4
%7 = icmp eq i32 %6, 0
br i1 %7, label %8, label %11
8: ; preds = %2
%9 = load i32, i32* %5
%10 = add nsw i32 %9, 1
store i32 %10, i32* %3
br label %26
11: ; preds = %2
%12 = load i32, i32* %5
%13 = icmp eq i32 %12, 0
br i1 %13, label %14, label %18
14: ; preds = %11
%15 = load i32, i32* %4
%16 = sub nsw i32 %15, 1
%17 = call i32 @ack(i32 %16, i32 1)
store i32 %17, i32* %3
br label %26
18: ; preds = %11
%19 = load i32, i32* %4
%20 = sub nsw i32 %19, 1
%21 = load i32, i32* %4
%22 = load i32, i32* %5
%23 = sub nsw i32 %22, 1
%24 = call i32 @ack(i32 %21, i32 %23)
%25 = call i32 @ack(i32 %20, i32 %24)
store i32 %25, i32* %3
br label %26
26: ; preds = %18, %14, %8
%27 = load i32, i32* %3
ret i32 %27
}

LLVM IR (-O2):
define i32 @ack(i32 %0, i32 %1) {
%3 = icmp eq i32 %0, 0
br i1 %3, label %4, label %7
4: ; preds = %11, %2
%5 = phi i32 [ %1, %2 ], [ %12, %11 ]
%6 = add nsw i32 %5, 1
ret i32 %6
7: ; preds = %2, %11
%8 = phi i32 [ %12, %11 ], [ %1, %2 ]
%9 = phi i32 [ %13, %11 ], [ %0, %2 ]
%10 = icmp eq i32 %8, 0
br i1 %10, label %11, label %15
11: ; preds = %7, %15
%12 = phi i32 [ %17, %15 ], [ 1, %7 ]
%13 = add nsw i32 %9, -1
%14 = icmp eq i32 %13, 0
br i1 %14, label %4, label %7
15: ; preds = %7
%16 = add nsw i32 %8, -1
%17 = tail call i32 @ack(i32 %9, i32 %16)
br label %11
}
int fun747() { return 747; }


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

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

LLVM IR (-O0):
define i32 @fun747() {
ret i32 747
}

LLVM IR (-O2):
define i32 @fun747() {
ret i32 747
}
int compare() { return 1; }


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

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

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

LLVM IR (-O2):
define i32 @compare() {
ret i32 1
}
void ble_rsp_hardware_io_port_config_function(
    const struct ble_msg_hardware_io_port_config_function_rsp_t *msg) {}


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

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

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

LLVM IR (-O2):
%struct.ble_msg_hardware_io_port_config_function_rsp_t = type opaque
define void @ble_rsp_hardware_io_port_config_function(%struct.ble_msg_hardware_io_port_config_function_rsp_t* nocapture %0) {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ Assert_real(int, char *, int, char *);
scalar_t__ isupper(int);
void t_isupper_0x34() {
  Assert_real((isupper(52) == 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_isupper.c",
              265, ("isupper should be 0 for 4"));
}


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

x86 assembly (clang, -O2):
<t_isupper_0x34>:
push   %rax
mov    $0x34,%edi
call   1030 <isupper@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
lea    0xec5(%rip),%rsi
lea    0xf66(%rip),%rcx
mov    $0x109,%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_isupper.c\00"
@.str.1 = [26 x i8] c"isupper should be 0 for 4\00"
define void @t_isupper_0x34() {
%1 = call i64 @isupper(i32 52)
%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 265, i8* getelementptr inbounds ([26 x i8], [26 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_isupper.c\00"
@.str.1 = [26 x i8] c"isupper should be 0 for 4\00"
define void @t_isupper_0x34() {
%1 = tail call i64 @isupper(i32 52)
%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 265, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0))
ret void
}
/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ stdout;
void _show_cursor(int enable) {
  if (enable)
    fprintf(stdout, "\x1B[?25h");
  else
    fprintf(stdout, "\x1B[?25l");
}


x86 assembly (clang, -O0):
<_show_cursor>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
cmpl   $0x0,-0x4(%rbp)
je     113f <_show_cursor+0x2f>
mov    0x2eb4(%rip),%rax
mov    (%rax),%edi
lea    0xecb(%rip),%rsi
call   1030 <fprintf@plt>
jmp    1154 <_show_cursor+0x44>
mov    0x2e9a(%rip),%rax
mov    (%rax),%edi
lea    0xeb8(%rip),%rsi
call   1030 <fprintf@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_show_cursor>:
test   %edi,%edi
mov    0x2ec7(%rip),%rax
mov    (%rax),%edi
lea    0xee5(%rip),%rax
lea    0xed7(%rip),%rsi
cmove  %rax,%rsi
jmp    1030 <fprintf@plt>

LLVM IR (-O0):
@stdout = global i32 0
@.str = [7 x i8] c"\1B[?25h\00"
@.str.1 = [7 x i8] c"\1B[?25l\00"
define void @_show_cursor(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
%3 = load i32, i32* %2
%4 = icmp ne i32 %3, 0
br i1 %4, label %5, label %8
5: ; preds = %1
%6 = load i32, i32* @stdout
%7 = call i32 @fprintf(i32 %6, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0))
br label %11
8: ; preds = %1
%9 = load i32, i32* @stdout
%10 = call i32 @fprintf(i32 %9, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
br label %11
11: ; preds = %8, %5
ret void
}

LLVM IR (-O2):
@stdout = global i32 0
@.str = [7 x i8] c"\1B[?25h\00"
@.str.1 = [7 x i8] c"\1B[?25l\00"
define void @_show_cursor(i32 %0) {
%2 = icmp eq i32 %0, 0
%3 = load i32, i32* @stdout
%4 = select i1 %2, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0)
%5 = tail call i32 @fprintf(i32 %3, i8* %4)
ret void
}