xunge/LIRAD-6.7B
Updated
•
22
Dataset Viewer (First 5GB)
-O1_clang
stringlengths 4
2.53M
⌀ | -O1_gcc
stringlengths 11
2.53M
⌀ | -O1_ll
stringlengths 30
3.3M
⌀ | -O2_clang
stringlengths 4
2.53M
⌀ | -O2_gcc
stringlengths 11
2.53M
⌀ | -O2_ll
stringlengths 30
3.3M
⌀ | -O0_clang
stringlengths 36
3.37M
⌀ | -O0_gcc
stringlengths 44
3.83M
⌀ | -O0_ll
stringlengths 30
11.4M
⌀ | -O3_clang
stringlengths 4
2.53M
⌀ | -O3_gcc
stringlengths 11
2.53M
⌀ | -O3_ll
stringlengths 30
3.3M
⌀ | idx
int64 0
450k
| synth_deps
stringlengths 0
33.2k
⌀ | function_def
stringlengths 7
1.2M
| function_name
stringlengths 1
7.56k
| formatted_code
stringlengths 7
1.39M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
<pcg_oneseq_64_xsl_rr_32_boundedrand_r>:
push %rbp
push %r14
push %rbx
mov %esi,%r14d
mov %rdi,%rbx
jmp 1124 <pcg_oneseq_64_xsl_rr_32_boundedrand_r+0x14>
nopl 0x0(%rax)
test %ecx,%ecx
jns 113c <pcg_oneseq_64_xsl_rr_32_boundedrand_r+0x2c>
mov %rbx,%rdi
call 1030 <pcg_oneseq_64_xsl_rr_32_random_r@plt>
mov %eax,%ecx
test %eax,%eax
js 1120 <pcg_oneseq_64_xsl_rr_32_boundedrand_r+0x10>
mov %ecx,%eax
cltd
idiv %r14d
mov %edx,%ebp
jmp 1120 <pcg_oneseq_64_xsl_rr_32_boundedrand_r+0x10>
mov %ebp,%eax
pop %rbx
pop %r14
pop %rbp
ret
| <pcg_oneseq_64_xsl_rr_32_boundedrand_r>:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %esi,%r12d
mov %esi,%eax
neg %eax
cltd
idiv %esi
mov %edx,%ebp
mov %rbx,%rdi
call 1050 <pcg_oneseq_64_xsl_rr_32_random_r@plt>
cmp %eax,%ebp
jg 1130 <pcg_oneseq_64_xsl_rr_32_boundedrand_r+0x17>
cltd
idiv %r12d
mov %edx,%eax
pop %rbx
pop %rbp
pop %r12
ret
| %struct.pcg_state_64 = type { i32 }
define i32 @pcg_oneseq_64_xsl_rr_32_boundedrand_r(%struct.pcg_state_64* %0, i32 %1) {
br label %3
3: ; preds = %9, %2
%4 = phi i32 [ undef, %2 ], [ %10, %9 ]
%5 = call i32 @pcg_oneseq_64_xsl_rr_32_random_r(%struct.pcg_state_64* %0)
%6 = icmp sgt i32 %5, -1
br i1 %6, label %7, label %9
7: ; preds = %3
%8 = srem i32 %5, %1
br label %9
9: ; preds = %3, %7
%10 = phi i32 [ %8, %7 ], [ %4, %3 ]
br i1 %6, label %11, label %3
11: ; preds = %9
ret i32 %10
}
| <pcg_oneseq_64_xsl_rr_32_boundedrand_r>:
push %rbp
push %rbx
push %rax
mov %esi,%ebp
mov %rdi,%rbx
nopl 0x0(%rax,%rax,1)
mov %rbx,%rdi
call 1030 <pcg_oneseq_64_xsl_rr_32_random_r@plt>
test %eax,%eax
js 1120 <pcg_oneseq_64_xsl_rr_32_boundedrand_r+0x10>
cltd
idiv %ebp
mov %edx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
ret
| <pcg_oneseq_64_xsl_rr_32_boundedrand_r>:
endbr64
mov %esi,%eax
push %r12
mov %esi,%r12d
neg %eax
push %rbp
cltd
push %rbx
mov %rdi,%rbx
idiv %esi
mov %edx,%ebp
nopw 0x0(%rax,%rax,1)
mov %rbx,%rdi
call 1050 <pcg_oneseq_64_xsl_rr_32_random_r@plt>
cmp %eax,%ebp
jg 1140 <pcg_oneseq_64_xsl_rr_32_boundedrand_r+0x20>
cltd
pop %rbx
pop %rbp
idiv %r12d
pop %r12
mov %edx,%eax
ret
| %struct.pcg_state_64 = type { i32 }
define i32 @pcg_oneseq_64_xsl_rr_32_boundedrand_r(%struct.pcg_state_64* %0, i32 %1) {
br label %3
3: ; preds = %3, %2
%4 = tail call i32 @pcg_oneseq_64_xsl_rr_32_random_r(%struct.pcg_state_64* %0)
%5 = icmp sgt i32 %4, -1
br i1 %5, label %6, label %3
6: ; preds = %3
%7 = srem i32 %4, %1
ret i32 %7
}
| <pcg_oneseq_64_xsl_rr_32_boundedrand_r>:
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
xor %eax,%eax
sub -0xc(%rbp),%eax
cltd
idivl -0xc(%rbp)
mov %edx,-0x10(%rbp)
mov -0x8(%rbp),%rdi
call 1030 <pcg_oneseq_64_xsl_rr_32_random_r@plt>
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x10(%rbp),%eax
jl 1152 <pcg_oneseq_64_xsl_rr_32_boundedrand_r+0x42>
mov -0x14(%rbp),%eax
cltd
idivl -0xc(%rbp)
mov %edx,%eax
add $0x20,%rsp
pop %rbp
ret
jmp 112b <pcg_oneseq_64_xsl_rr_32_boundedrand_r+0x1b>
| <pcg_oneseq_64_xsl_rr_32_boundedrand_r>:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
neg %eax
cltd
idivl -0x1c(%rbp)
mov %edx,-0x8(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
call 1050 <pcg_oneseq_64_xsl_rr_32_random_r@plt>
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 1138 <pcg_oneseq_64_xsl_rr_32_boundedrand_r+0x1f>
mov -0x4(%rbp),%eax
cltd
idivl -0x1c(%rbp)
mov %edx,%eax
leave
ret
| %struct.pcg_state_64 = type { i32 }
define i32 @pcg_oneseq_64_xsl_rr_32_boundedrand_r(%struct.pcg_state_64* %0, i32 %1) {
%3 = alloca %struct.pcg_state_64*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
store %struct.pcg_state_64* %0, %struct.pcg_state_64** %3
store i32 %1, i32* %4
%7 = load i32, i32* %4
%8 = sub nsw i32 0, %7
%9 = load i32, i32* %4
%10 = srem i32 %8, %9
store i32 %10, i32* %5
br label %11
11: ; preds = %21, %2
%12 = load %struct.pcg_state_64*, %struct.pcg_state_64** %3
%13 = call i32 @pcg_oneseq_64_xsl_rr_32_random_r(%struct.pcg_state_64* %12)
store i32 %13, i32* %6
%14 = load i32, i32* %6
%15 = load i32, i32* %5
%16 = icmp sge i32 %14, %15
br i1 %16, label %17, label %21
17: ; preds = %11
%18 = load i32, i32* %6
%19 = load i32, i32* %4
%20 = srem i32 %18, %19
ret i32 %20
21: ; preds = %11
br label %11
}
| <pcg_oneseq_64_xsl_rr_32_boundedrand_r>:
push %rbp
push %rbx
push %rax
mov %esi,%ebp
mov %rdi,%rbx
nopl 0x0(%rax,%rax,1)
mov %rbx,%rdi
call 1030 <pcg_oneseq_64_xsl_rr_32_random_r@plt>
test %eax,%eax
js 1120 <pcg_oneseq_64_xsl_rr_32_boundedrand_r+0x10>
cltd
idiv %ebp
mov %edx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
ret
| <pcg_oneseq_64_xsl_rr_32_boundedrand_r>:
endbr64
mov %esi,%eax
push %r12
mov %esi,%r12d
neg %eax
push %rbp
cltd
push %rbx
mov %rdi,%rbx
idiv %esi
mov %edx,%ebp
nopw 0x0(%rax,%rax,1)
mov %rbx,%rdi
call 1050 <pcg_oneseq_64_xsl_rr_32_random_r@plt>
cmp %eax,%ebp
jg 1140 <pcg_oneseq_64_xsl_rr_32_boundedrand_r+0x20>
cltd
pop %rbx
pop %rbp
idiv %r12d
pop %r12
mov %edx,%eax
ret
| %struct.pcg_state_64 = type { i32 }
define i32 @pcg_oneseq_64_xsl_rr_32_boundedrand_r(%struct.pcg_state_64* %0, i32 %1) {
br label %3
3: ; preds = %3, %2
%4 = tail call i32 @pcg_oneseq_64_xsl_rr_32_random_r(%struct.pcg_state_64* %0)
%5 = icmp sgt i32 %4, -1
br i1 %5, label %6, label %3
6: ; preds = %3
%7 = srem i32 %4, %1
ret i32 %7
}
| 0 | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
typedef int uint32_t ;
struct pcg_state_64 {int dummy; } ;
/* Variables and functions */
int pcg_oneseq_64_xsl_rr_32_random_r (struct pcg_state_64*) ;
| uint32_t pcg_oneseq_64_xsl_rr_32_boundedrand_r(struct pcg_state_64* rng, uint32_t bound) {
uint32_t threshold = -bound % bound;
for (;;) {
uint32_t r = pcg_oneseq_64_xsl_rr_32_random_r(rng);
if (r >= threshold)
return r % bound;
}
} | pcg_oneseq_64_xsl_rr_32_boundedrand_r | #define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
typedef int uint32_t;
struct pcg_state_64 {
int dummy;
};
/* Variables and functions */
int pcg_oneseq_64_xsl_rr_32_random_r(struct pcg_state_64 *);
uint32_t pcg_oneseq_64_xsl_rr_32_boundedrand_r(struct pcg_state_64 *rng,
uint32_t bound) {
uint32_t threshold = -bound % bound;
for (;;) {
uint32_t r = pcg_oneseq_64_xsl_rr_32_random_r(rng);
if (r >= threshold)
return r % bound;
}
}
|
<loggamma>:
sub $0x18,%rsp
movapd %xmm0,%xmm4
ucomisd 0xee0(%rip),%xmm0
xorpd %xmm0,%xmm0
jne 112c <loggamma+0x1c>
jnp 1232 <loggamma+0x122>
ucomisd 0xed4(%rip),%xmm4
jne 113c <loggamma+0x2c>
jnp 1232 <loggamma+0x122>
movsd 0xebc(%rip),%xmm1
movsd 0xec4(%rip),%xmm2
ucomisd %xmm4,%xmm2
jbe 1170 <loggamma+0x60>
movsd 0xea6(%rip),%xmm3
movapd %xmm3,%xmm0
xchg %ax,%ax
mulsd %xmm4,%xmm0
addsd %xmm3,%xmm4
ucomisd %xmm4,%xmm2
ja 1160 <loggamma+0x50>
jmp 1174 <loggamma+0x64>
movapd %xmm1,%xmm0
movsd %xmm4,0x8(%rsp)
movapd %xmm4,%xmm2
mulsd %xmm4,%xmm2
divsd %xmm2,%xmm1
movsd 0xe8a(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe86(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe82(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe7e(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe7a(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe76(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe72(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe6e(%rip),%xmm2
divsd %xmm4,%xmm2
addsd 0xe6a(%rip),%xmm2
movsd %xmm2,(%rsp)
call 1030 <log@plt>
movsd (%rsp),%xmm1
subsd %xmm0,%xmm1
movsd 0x8(%rsp),%xmm0
subsd %xmm0,%xmm1
movsd %xmm1,(%rsp)
movsd 0xe48(%rip),%xmm1
addsd %xmm0,%xmm1
movsd %xmm1,0x10(%rsp)
call 1030 <log@plt>
mulsd 0x10(%rsp),%xmm0
addsd (%rsp),%xmm0
add $0x18,%rsp
ret
| <loggamma>:
endbr64
push %rbx
sub $0x10,%rsp
movsd %xmm0,(%rsp)
ucomisd 0xed1(%rip),%xmm0
setnp %al
mov $0x0,%edx
cmovne %edx,%eax
test %al,%al
jne 1274 <loggamma+0x15b>
movapd %xmm0,%xmm6
ucomisd 0xeba(%rip),%xmm0
setnp %al
cmovne %edx,%eax
test %al,%al
jne 1274 <loggamma+0x15b>
movsd 0xe9c(%rip),%xmm0
movapd %xmm0,%xmm2
movsd 0xea0(%rip),%xmm1
comisd %xmm6,%xmm1
jbe 1267 <loggamma+0x14e>
movsd (%rsp),%xmm4
mulsd %xmm4,%xmm0
addsd %xmm2,%xmm4
movsd %xmm4,(%rsp)
comisd %xmm4,%xmm1
ja 117a <loggamma+0x61>
movsd (%rsp),%xmm7
movapd %xmm7,%xmm1
mulsd %xmm7,%xmm1
movsd 0xe59(%rip),%xmm2
divsd %xmm1,%xmm2
movsd %xmm2,0x8(%rsp)
call 1050 <log@plt>
movq %xmm0,%rbx
movsd (%rsp),%xmm0
call 1050 <log@plt>
movapd %xmm0,%xmm2
movsd 0x8(%rsp),%xmm5
movapd %xmm5,%xmm6
mulsd 0xe3d(%rip),%xmm6
movapd %xmm6,%xmm0
addsd 0xe39(%rip),%xmm0
mulsd %xmm5,%xmm0
subsd 0xe35(%rip),%xmm0
mulsd %xmm5,%xmm0
addsd 0xe31(%rip),%xmm0
mulsd %xmm5,%xmm0
subsd 0xe2d(%rip),%xmm0
mulsd %xmm5,%xmm0
addsd 0xe29(%rip),%xmm0
mulsd %xmm5,%xmm0
subsd 0xe25(%rip),%xmm0
mulsd %xmm5,%xmm0
addsd 0xe21(%rip),%xmm0
movsd (%rsp),%xmm7
divsd %xmm7,%xmm0
addsd 0xe18(%rip),%xmm0
movq %rbx,%xmm3
subsd %xmm3,%xmm0
subsd %xmm7,%xmm0
subsd 0xe0b(%rip),%xmm7
movapd %xmm7,%xmm1
mulsd %xmm2,%xmm1
addsd %xmm1,%xmm0
add $0x10,%rsp
pop %rbx
ret
movsd 0xd91(%rip),%xmm0
jmp 1192 <loggamma+0x79>
pxor %xmm0,%xmm0
jmp 1261 <loggamma+0x148>
| define double @loggamma(double %0) {
%2 = fcmp oeq double %0, 1.000000e+00
%3 = fcmp oeq double %0, 2.000000e+00
%4 = or i1 %2, %3
br i1 %4, label %33, label %5
5: ; preds = %1
%6 = fcmp olt double %0, 8.000000e+00
br i1 %6, label %7, label %13
7: ; preds = %5, %7
%8 = phi double [ %10, %7 ], [ 1.000000e+00, %5 ]
%9 = phi double [ %11, %7 ], [ %0, %5 ]
%10 = fmul double %9, %8
%11 = fadd double %9, 1.000000e+00
%12 = fcmp olt double %11, 8.000000e+00
br i1 %12, label %7, label %13
13: ; preds = %7, %5
%14 = phi double [ %0, %5 ], [ %11, %7 ]
%15 = phi double [ 1.000000e+00, %5 ], [ %10, %7 ]
%16 = fmul double %14, %14
%17 = fdiv double 1.000000e+00, %16
%18 = call double @llvm.fmuladd.f64(double %17, double 0xBF9E4286CB0F5397, double 0x3F7A41A41A41A41B)
%19 = call double @llvm.fmuladd.f64(double %18, double %17, double 0xBF5F6AB0D9993C7C)
%20 = call double @llvm.fmuladd.f64(double %19, double %17, double 0x3F4B951E2B18FF24)
%21 = call double @llvm.fmuladd.f64(double %20, double %17, double 0xBF43813813813813)
%22 = call double @llvm.fmuladd.f64(double %21, double %17, double 0x3F4A01A01A01A01A)
%23 = call double @llvm.fmuladd.f64(double %22, double %17, double 0xBF66C16C16C16C17)
%24 = call double @llvm.fmuladd.f64(double %23, double %17, double 0x3FB5555555555555)
%25 = fdiv double %24, %14
%26 = fadd double %25, 0x3FED67F1C864BEB5
%27 = call double @log(double %15)
%28 = fsub double %26, %27
%29 = fsub double %28, %14
%30 = fadd double %14, -5.000000e-01
%31 = call double @log(double %14)
%32 = call double @llvm.fmuladd.f64(double %30, double %31, double %29)
br label %33
33: ; preds = %1, %13
%34 = phi double [ %32, %13 ], [ 0.000000e+00, %1 ]
ret double %34
}
| <loggamma>:
sub $0x18,%rsp
ucomisd 0xee4(%rip),%xmm0
jne 1120 <loggamma+0x10>
jnp 1170 <loggamma+0x60>
movapd %xmm0,%xmm4
ucomisd 0xedc(%rip),%xmm0
jne 1130 <loggamma+0x20>
jnp 1170 <loggamma+0x60>
movsd 0xec8(%rip),%xmm1
movsd 0xed0(%rip),%xmm2
ucomisd %xmm4,%xmm2
jbe 1179 <loggamma+0x69>
movsd 0xeb2(%rip),%xmm3
movapd %xmm3,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl 0x0(%rax)
mulsd %xmm4,%xmm0
addsd %xmm3,%xmm4
ucomisd %xmm4,%xmm2
ja 1160 <loggamma+0x50>
jmp 117d <loggamma+0x6d>
xorpd %xmm0,%xmm0
add $0x18,%rsp
ret
movapd %xmm1,%xmm0
movsd %xmm4,0x8(%rsp)
movapd %xmm4,%xmm2
mulsd %xmm4,%xmm2
divsd %xmm2,%xmm1
movsd 0xe81(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe7d(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe79(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe75(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe71(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe6d(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe69(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe65(%rip),%xmm2
divsd %xmm4,%xmm2
addsd 0xe61(%rip),%xmm2
movsd %xmm2,(%rsp)
call 1030 <log@plt>
movsd (%rsp),%xmm1
subsd %xmm0,%xmm1
movsd 0x8(%rsp),%xmm0
subsd %xmm0,%xmm1
movsd %xmm1,(%rsp)
movsd 0xe3f(%rip),%xmm1
addsd %xmm0,%xmm1
movsd %xmm1,0x10(%rsp)
call 1030 <log@plt>
mulsd 0x10(%rsp),%xmm0
addsd (%rsp),%xmm0
add $0x18,%rsp
ret
| <loggamma>:
endbr64
movsd 0xed4(%rip),%xmm3
mov $0x0,%edx
ucomisd %xmm3,%xmm0
setnp %al
cmovne %edx,%eax
test %al,%al
jne 1258 <loggamma+0x138>
ucomisd 0xebd(%rip),%xmm0
movapd %xmm0,%xmm1
setnp %dl
cmove %edx,%eax
test %al,%al
jne 1258 <loggamma+0x138>
sub $0x28,%rsp
movsd 0xea7(%rip),%xmm2
movapd %xmm3,%xmm0
comisd %xmm1,%xmm2
jbe 1186 <loggamma+0x66>
nopl 0x0(%rax,%rax,1)
mulsd %xmm1,%xmm0
addsd %xmm3,%xmm1
comisd %xmm1,%xmm2
ja 1178 <loggamma+0x58>
movapd %xmm1,%xmm2
movsd %xmm1,0x10(%rsp)
mulsd %xmm1,%xmm2
divsd %xmm2,%xmm3
movsd %xmm3,0x18(%rsp)
call 1050 <log@plt>
movsd 0x10(%rsp),%xmm1
movsd %xmm0,0x8(%rsp)
movapd %xmm1,%xmm0
call 1050 <log@plt>
movsd 0x18(%rsp),%xmm3
movsd 0xe52(%rip),%xmm4
movapd %xmm0,%xmm2
movsd 0xe4e(%rip),%xmm0
movsd 0x10(%rsp),%xmm1
mulsd %xmm3,%xmm4
addsd %xmm4,%xmm0
mulsd %xmm3,%xmm0
subsd 0xe3c(%rip),%xmm0
mulsd %xmm3,%xmm0
addsd 0xe38(%rip),%xmm0
mulsd %xmm3,%xmm0
subsd 0xe34(%rip),%xmm0
mulsd %xmm3,%xmm0
addsd 0xe30(%rip),%xmm0
mulsd %xmm3,%xmm0
subsd 0xe2c(%rip),%xmm0
mulsd %xmm3,%xmm0
addsd 0xe28(%rip),%xmm0
divsd %xmm1,%xmm0
addsd 0xe24(%rip),%xmm0
subsd 0x8(%rsp),%xmm0
subsd %xmm1,%xmm0
subsd 0xe1a(%rip),%xmm1
add $0x28,%rsp
mulsd %xmm2,%xmm1
addsd %xmm1,%xmm0
ret
nopl 0x0(%rax,%rax,1)
pxor %xmm0,%xmm0
ret
| define double @loggamma(double %0) {
%2 = fcmp oeq double %0, 1.000000e+00
%3 = fcmp oeq double %0, 2.000000e+00
%4 = or i1 %2, %3
br i1 %4, label %33, label %5
5: ; preds = %1
%6 = fcmp olt double %0, 8.000000e+00
br i1 %6, label %7, label %13
7: ; preds = %5, %7
%8 = phi double [ %10, %7 ], [ 1.000000e+00, %5 ]
%9 = phi double [ %11, %7 ], [ %0, %5 ]
%10 = fmul double %9, %8
%11 = fadd double %9, 1.000000e+00
%12 = fcmp olt double %11, 8.000000e+00
br i1 %12, label %7, label %13
13: ; preds = %7, %5
%14 = phi double [ %0, %5 ], [ %11, %7 ]
%15 = phi double [ 1.000000e+00, %5 ], [ %10, %7 ]
%16 = fmul double %14, %14
%17 = fdiv double 1.000000e+00, %16
%18 = tail call double @llvm.fmuladd.f64(double %17, double 0xBF9E4286CB0F5397, double 0x3F7A41A41A41A41B)
%19 = tail call double @llvm.fmuladd.f64(double %18, double %17, double 0xBF5F6AB0D9993C7C)
%20 = tail call double @llvm.fmuladd.f64(double %19, double %17, double 0x3F4B951E2B18FF24)
%21 = tail call double @llvm.fmuladd.f64(double %20, double %17, double 0xBF43813813813813)
%22 = tail call double @llvm.fmuladd.f64(double %21, double %17, double 0x3F4A01A01A01A01A)
%23 = tail call double @llvm.fmuladd.f64(double %22, double %17, double 0xBF66C16C16C16C17)
%24 = tail call double @llvm.fmuladd.f64(double %23, double %17, double 0x3FB5555555555555)
%25 = fdiv double %24, %14
%26 = fadd double %25, 0x3FED67F1C864BEB5
%27 = tail call double @log(double %15)
%28 = fsub double %26, %27
%29 = fsub double %28, %14
%30 = fadd double %14, -5.000000e-01
%31 = tail call double @log(double %14)
%32 = tail call double @llvm.fmuladd.f64(double %30, double %31, double %29)
br label %33
33: ; preds = %1, %13
%34 = phi double [ %32, %13 ], [ 0.000000e+00, %1 ]
ret double %34
}
| <loggamma>:
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
movsd %xmm0,-0x10(%rbp)
movsd -0x10(%rbp),%xmm0
movsd 0xed6(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne 113f <loggamma+0x2f>
jp 113f <loggamma+0x2f>
jmp 115c <loggamma+0x4c>
movsd -0x10(%rbp),%xmm0
movsd 0xebc(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne 1169 <loggamma+0x59>
jp 1169 <loggamma+0x59>
xorps %xmm0,%xmm0
movsd %xmm0,-0x8(%rbp)
jmp 12d5 <loggamma+0x1c5>
movsd 0xe8f(%rip),%xmm0
movsd %xmm0,-0x18(%rbp)
movsd 0xe92(%rip),%xmm0
ucomisd -0x10(%rbp),%xmm0
jbe 11af <loggamma+0x9f>
movsd -0x10(%rbp),%xmm0
mulsd -0x18(%rbp),%xmm0
movsd %xmm0,-0x18(%rbp)
movsd 0xe60(%rip),%xmm0
addsd -0x10(%rbp),%xmm0
movsd %xmm0,-0x10(%rbp)
jmp 1176 <loggamma+0x66>
movsd -0x10(%rbp),%xmm1
mulsd -0x10(%rbp),%xmm1
movsd 0xe3f(%rip),%xmm0
divsd %xmm1,%xmm0
movsd %xmm0,-0x20(%rbp)
movsd -0x20(%rbp),%xmm0
movsd 0xe81(%rip),%xmm1
mulsd %xmm1,%xmm0
movsd 0xe7d(%rip),%xmm1
addsd %xmm1,%xmm0
movsd -0x20(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd 0xe58(%rip),%xmm1
addsd %xmm1,%xmm0
movsd -0x20(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd 0xe3b(%rip),%xmm1
addsd %xmm1,%xmm0
movsd -0x20(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd 0xe1e(%rip),%xmm1
addsd %xmm1,%xmm0
movsd -0x20(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd 0xe01(%rip),%xmm1
addsd %xmm1,%xmm0
movsd -0x20(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd 0xde4(%rip),%xmm1
addsd %xmm1,%xmm0
movsd -0x20(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd 0xdc7(%rip),%xmm1
addsd %xmm1,%xmm0
divsd -0x10(%rbp),%xmm0
movsd 0xdae(%rip),%xmm1
addsd %xmm1,%xmm0
movsd %xmm0,-0x38(%rbp)
movsd -0x18(%rbp),%xmm0
call 1030 <log@plt>
movaps %xmm0,%xmm1
movsd -0x38(%rbp),%xmm0
subsd %xmm1,%xmm0
subsd -0x10(%rbp),%xmm0
movsd %xmm0,-0x30(%rbp)
movsd -0x10(%rbp),%xmm0
movsd 0xd70(%rip),%xmm1
subsd %xmm1,%xmm0
movsd %xmm0,-0x28(%rbp)
movsd -0x10(%rbp),%xmm0
call 1030 <log@plt>
movsd -0x30(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd -0x28(%rbp),%xmm0
mulsd %xmm2,%xmm0
addsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
add $0x40,%rsp
pop %rbp
ret
| <loggamma>:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
movsd %xmm0,-0x18(%rbp)
movsd 0xece(%rip),%xmm0
ucomisd -0x18(%rbp),%xmm0
jp 1148 <loggamma+0x2f>
movsd 0xebf(%rip),%xmm0
ucomisd -0x18(%rbp),%xmm0
je 1166 <loggamma+0x4d>
movsd -0x18(%rbp),%xmm0
ucomisd 0xeb3(%rip),%xmm0
jp 116f <loggamma+0x56>
movsd -0x18(%rbp),%xmm0
ucomisd 0xea4(%rip),%xmm0
jne 116f <loggamma+0x56>
pxor %xmm0,%xmm0
jmp 12d0 <loggamma+0x1b7>
movsd 0xe89(%rip),%xmm0
movsd %xmm0,-0x10(%rbp)
jmp 11a3 <loggamma+0x8a>
movsd -0x10(%rbp),%xmm0
mulsd -0x18(%rbp),%xmm0
movsd %xmm0,-0x10(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xe66(%rip),%xmm0
addsd %xmm1,%xmm0
movsd %xmm0,-0x18(%rbp)
movsd 0xe65(%rip),%xmm0
comisd -0x18(%rbp),%xmm0
ja 117e <loggamma+0x65>
movsd -0x18(%rbp),%xmm0
movapd %xmm0,%xmm1
mulsd %xmm0,%xmm1
movsd 0xe39(%rip),%xmm0
divsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm1
movsd 0xe3b(%rip),%xmm0
mulsd %xmm0,%xmm1
movsd 0xe37(%rip),%xmm0
addsd %xmm1,%xmm0
mulsd -0x8(%rbp),%xmm0
movsd 0xe2e(%rip),%xmm1
subsd %xmm1,%xmm0
movapd %xmm0,%xmm1
mulsd -0x8(%rbp),%xmm1
movsd 0xe21(%rip),%xmm0
addsd %xmm1,%xmm0
mulsd -0x8(%rbp),%xmm0
movsd 0xe18(%rip),%xmm1
subsd %xmm1,%xmm0
movapd %xmm0,%xmm1
mulsd -0x8(%rbp),%xmm1
movsd 0xe0b(%rip),%xmm0
addsd %xmm1,%xmm0
mulsd -0x8(%rbp),%xmm0
movsd 0xe02(%rip),%xmm1
subsd %xmm1,%xmm0
movapd %xmm0,%xmm1
mulsd -0x8(%rbp),%xmm1
movsd 0xdf5(%rip),%xmm0
addsd %xmm1,%xmm0
movapd %xmm0,%xmm1
divsd -0x18(%rbp),%xmm1
movsd 0xde8(%rip),%xmm0
addsd %xmm0,%xmm1
movsd %xmm1,-0x20(%rbp)
mov -0x10(%rbp),%rax
movq %rax,%xmm0
call 1050 <log@plt>
movapd %xmm0,%xmm1
movsd -0x20(%rbp),%xmm0
subsd %xmm1,%xmm0
subsd -0x18(%rbp),%xmm0
movsd %xmm0,-0x20(%rbp)
movsd -0x18(%rbp),%xmm0
movsd 0xdb5(%rip),%xmm1
movapd %xmm0,%xmm3
subsd %xmm1,%xmm3
movsd %xmm3,-0x28(%rbp)
mov -0x18(%rbp),%rax
movq %rax,%xmm0
call 1050 <log@plt>
mulsd -0x28(%rbp),%xmm0
addsd -0x20(%rbp),%xmm0
movq %xmm0,%rax
movq %rax,%xmm0
leave
ret
| define double @loggamma(double %0) {
%2 = alloca double
%3 = alloca double
%4 = alloca double
%5 = alloca double
store double %0, double* %3
%6 = load double, double* %3
%7 = fcmp oeq double %6, 1.000000e+00
br i1 %7, label %11, label %8
8: ; preds = %1
%9 = load double, double* %3
%10 = fcmp oeq double %9, 2.000000e+00
br i1 %10, label %11, label %12
11: ; preds = %8, %1
store double 0.000000e+00, double* %2
br label %54
12: ; preds = %8
store double 1.000000e+00, double* %4
br label %13
13: ; preds = %16, %12
%14 = load double, double* %3
%15 = fcmp olt double %14, 8.000000e+00
br i1 %15, label %16, label %22
16: ; preds = %13
%17 = load double, double* %3
%18 = load double, double* %4
%19 = fmul double %18, %17
store double %19, double* %4
%20 = load double, double* %3
%21 = fadd double %20, 1.000000e+00
store double %21, double* %3
br label %13
22: ; preds = %13
%23 = load double, double* %3
%24 = load double, double* %3
%25 = fmul double %23, %24
%26 = fdiv double 1.000000e+00, %25
store double %26, double* %5
%27 = load double, double* %5
%28 = call double @llvm.fmuladd.f64(double 0xBF9E4286CB0F5397, double %27, double 0x3F7A41A41A41A41B)
%29 = load double, double* %5
%30 = call double @llvm.fmuladd.f64(double %28, double %29, double 0xBF5F6AB0D9993C7C)
%31 = load double, double* %5
%32 = call double @llvm.fmuladd.f64(double %30, double %31, double 0x3F4B951E2B18FF24)
%33 = load double, double* %5
%34 = call double @llvm.fmuladd.f64(double %32, double %33, double 0xBF43813813813813)
%35 = load double, double* %5
%36 = call double @llvm.fmuladd.f64(double %34, double %35, double 0x3F4A01A01A01A01A)
%37 = load double, double* %5
%38 = call double @llvm.fmuladd.f64(double %36, double %37, double 0xBF66C16C16C16C17)
%39 = load double, double* %5
%40 = call double @llvm.fmuladd.f64(double %38, double %39, double 0x3FB5555555555555)
%41 = load double, double* %3
%42 = fdiv double %40, %41
%43 = fadd double %42, 0x3FED67F1C864BEB5
%44 = load double, double* %4
%45 = call double @log(double %44)
%46 = fsub double %43, %45
%47 = load double, double* %3
%48 = fsub double %46, %47
%49 = load double, double* %3
%50 = fsub double %49, 5.000000e-01
%51 = load double, double* %3
%52 = call double @log(double %51)
%53 = call double @llvm.fmuladd.f64(double %50, double %52, double %48)
store double %53, double* %2
br label %54
54: ; preds = %22, %11
%55 = load double, double* %2
ret double %55
}
| <loggamma>:
sub $0x18,%rsp
ucomisd 0xee4(%rip),%xmm0
jne 1120 <loggamma+0x10>
jnp 1170 <loggamma+0x60>
movapd %xmm0,%xmm4
ucomisd 0xedc(%rip),%xmm0
jne 1130 <loggamma+0x20>
jnp 1170 <loggamma+0x60>
movsd 0xec8(%rip),%xmm1
movsd 0xed0(%rip),%xmm2
ucomisd %xmm4,%xmm2
jbe 1179 <loggamma+0x69>
movsd 0xeb2(%rip),%xmm3
movapd %xmm3,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl 0x0(%rax)
mulsd %xmm4,%xmm0
addsd %xmm3,%xmm4
ucomisd %xmm4,%xmm2
ja 1160 <loggamma+0x50>
jmp 117d <loggamma+0x6d>
xorpd %xmm0,%xmm0
add $0x18,%rsp
ret
movapd %xmm1,%xmm0
movsd %xmm4,0x8(%rsp)
movapd %xmm4,%xmm2
mulsd %xmm4,%xmm2
divsd %xmm2,%xmm1
movsd 0xe81(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe7d(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe79(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe75(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe71(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe6d(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe69(%rip),%xmm2
mulsd %xmm1,%xmm2
addsd 0xe65(%rip),%xmm2
divsd %xmm4,%xmm2
addsd 0xe61(%rip),%xmm2
movsd %xmm2,(%rsp)
call 1030 <log@plt>
movsd (%rsp),%xmm1
subsd %xmm0,%xmm1
movsd 0x8(%rsp),%xmm0
subsd %xmm0,%xmm1
movsd %xmm1,(%rsp)
movsd 0xe3f(%rip),%xmm1
addsd %xmm0,%xmm1
movsd %xmm1,0x10(%rsp)
call 1030 <log@plt>
mulsd 0x10(%rsp),%xmm0
addsd (%rsp),%xmm0
add $0x18,%rsp
ret
| <loggamma>:
endbr64
movsd 0xed4(%rip),%xmm3
mov $0x0,%edx
ucomisd %xmm3,%xmm0
setnp %al
cmovne %edx,%eax
test %al,%al
jne 1258 <loggamma+0x138>
ucomisd 0xebd(%rip),%xmm0
movapd %xmm0,%xmm1
setnp %dl
cmove %edx,%eax
test %al,%al
jne 1258 <loggamma+0x138>
sub $0x28,%rsp
movsd 0xea7(%rip),%xmm2
movapd %xmm3,%xmm0
comisd %xmm1,%xmm2
jbe 1186 <loggamma+0x66>
nopl 0x0(%rax,%rax,1)
mulsd %xmm1,%xmm0
addsd %xmm3,%xmm1
comisd %xmm1,%xmm2
ja 1178 <loggamma+0x58>
movapd %xmm1,%xmm2
movsd %xmm1,0x10(%rsp)
mulsd %xmm1,%xmm2
divsd %xmm2,%xmm3
movsd %xmm3,0x18(%rsp)
call 1050 <log@plt>
movsd 0x10(%rsp),%xmm1
movsd %xmm0,0x8(%rsp)
movapd %xmm1,%xmm0
call 1050 <log@plt>
movsd 0x18(%rsp),%xmm3
movsd 0xe52(%rip),%xmm4
movapd %xmm0,%xmm2
movsd 0xe4e(%rip),%xmm0
movsd 0x10(%rsp),%xmm1
mulsd %xmm3,%xmm4
addsd %xmm4,%xmm0
mulsd %xmm3,%xmm0
subsd 0xe3c(%rip),%xmm0
mulsd %xmm3,%xmm0
addsd 0xe38(%rip),%xmm0
mulsd %xmm3,%xmm0
subsd 0xe34(%rip),%xmm0
mulsd %xmm3,%xmm0
addsd 0xe30(%rip),%xmm0
mulsd %xmm3,%xmm0
subsd 0xe2c(%rip),%xmm0
mulsd %xmm3,%xmm0
addsd 0xe28(%rip),%xmm0
divsd %xmm1,%xmm0
addsd 0xe24(%rip),%xmm0
subsd 0x8(%rsp),%xmm0
subsd %xmm1,%xmm0
subsd 0xe1a(%rip),%xmm1
add $0x28,%rsp
mulsd %xmm2,%xmm1
addsd %xmm1,%xmm0
ret
nopl 0x0(%rax,%rax,1)
pxor %xmm0,%xmm0
ret
| define double @loggamma(double %0) {
%2 = fcmp oeq double %0, 1.000000e+00
%3 = fcmp oeq double %0, 2.000000e+00
%4 = or i1 %2, %3
br i1 %4, label %33, label %5
5: ; preds = %1
%6 = fcmp olt double %0, 8.000000e+00
br i1 %6, label %7, label %13
7: ; preds = %5, %7
%8 = phi double [ %10, %7 ], [ 1.000000e+00, %5 ]
%9 = phi double [ %11, %7 ], [ %0, %5 ]
%10 = fmul double %9, %8
%11 = fadd double %9, 1.000000e+00
%12 = fcmp olt double %11, 8.000000e+00
br i1 %12, label %7, label %13
13: ; preds = %7, %5
%14 = phi double [ %0, %5 ], [ %11, %7 ]
%15 = phi double [ 1.000000e+00, %5 ], [ %10, %7 ]
%16 = fmul double %14, %14
%17 = fdiv double 1.000000e+00, %16
%18 = tail call double @llvm.fmuladd.f64(double %17, double 0xBF9E4286CB0F5397, double 0x3F7A41A41A41A41B)
%19 = tail call double @llvm.fmuladd.f64(double %18, double %17, double 0xBF5F6AB0D9993C7C)
%20 = tail call double @llvm.fmuladd.f64(double %19, double %17, double 0x3F4B951E2B18FF24)
%21 = tail call double @llvm.fmuladd.f64(double %20, double %17, double 0xBF43813813813813)
%22 = tail call double @llvm.fmuladd.f64(double %21, double %17, double 0x3F4A01A01A01A01A)
%23 = tail call double @llvm.fmuladd.f64(double %22, double %17, double 0xBF66C16C16C16C17)
%24 = tail call double @llvm.fmuladd.f64(double %23, double %17, double 0x3FB5555555555555)
%25 = fdiv double %24, %14
%26 = fadd double %25, 0x3FED67F1C864BEB5
%27 = tail call double @log(double %15)
%28 = fsub double %26, %27
%29 = fsub double %28, %14
%30 = fadd double %14, -5.000000e-01
%31 = tail call double @log(double %14)
%32 = tail call double @llvm.fmuladd.f64(double %30, double %31, double %29)
br label %33
33: ; preds = %1, %13
%34 = phi double [ %32, %13 ], [ 0.000000e+00, %1 ]
ret double %34
}
| 1 | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
double log (double) ;
| double loggamma(double x) {
double v, w;
if (x == 1.0 || x == 2.0) return 0.0;
v = 1;
while (x < 8) { v *= x; x++; }
w = 1 / (x * x);
return (((((((((-3617.0 / 510.0) / (16 * 15)) * w + (( 7.0 / 6.0) / (14 * 13))) * w
+ ((-691.0 / 2730.0) / (12 * 11))) * w + (( 5.0 / 66.0) / (10 * 9))) * w
+ ((-1.0 / 30.0) / ( 8 * 7))) * w + (( 1.0 / 42.0) / ( 6 * 5))) * w
+ ((-1.0 / 30.0) / ( 4 * 3))) * w + (( 1.0 / 6.0) / ( 2 * 1))) / x
+ 0.5 * 1.83787706640934548 - log(v) - x + (x - 0.5) * log(x);
} | loggamma | #define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
double log(double);
double loggamma(double x) {
double v, w;
if (x == 1.0 || x == 2.0)
return 0.0;
v = 1;
while (x < 8) {
v *= x;
x++;
}
w = 1 / (x * x);
return (((((((((-3617.0 / 510.0) / (16 * 15)) * w +
((7.0 / 6.0) / (14 * 13))) *
w +
((-691.0 / 2730.0) / (12 * 11))) *
w +
((5.0 / 66.0) / (10 * 9))) *
w +
((-1.0 / 30.0) / (8 * 7))) *
w +
((1.0 / 42.0) / (6 * 5))) *
w +
((-1.0 / 30.0) / (4 * 3))) *
w +
((1.0 / 6.0) / (2 * 1))) /
x +
0.5 * 1.83787706640934548 - log(v) - x + (x - 0.5) * log(x);
}
|
<t_ispunct_0x13>:
push %rax
mov $0x13,%edi
call 1030 <ispunct@plt>
xor %edi,%edi
test %rax,%rax
sete %dil
lea 0xec5(%rip),%rsi
lea 0xf66(%rip),%rcx
mov $0x64,%edx
call 1040 <Assert_real@plt>
pop %rax
ret
| <t_ispunct_0x13>:
endbr64
sub $0x8,%rsp
mov $0x13,%edi
call 1060 <ispunct@plt>
test %rax,%rax
sete %dil
movzbl %dil,%edi
lea 0xea3(%rip),%rcx
mov $0x64,%edx
lea 0xeb7(%rip),%rsi
call 1070 <Assert_real@plt>
add $0x8,%rsp
ret
| @.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_ispunct.c\00"
@.str.1 = [29 x i8] c"ispunct should be 0 for 0x13\00"
define void @t_ispunct_0x13() {
%1 = call i64 @ispunct(i32 19)
%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 100, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0))
ret void
}
| <t_ispunct_0x13>:
push %rax
mov $0x13,%edi
call 1030 <ispunct@plt>
xor %edi,%edi
test %rax,%rax
sete %dil
lea 0xec5(%rip),%rsi
lea 0xf66(%rip),%rcx
mov $0x64,%edx
pop %rax
jmp 1040 <Assert_real@plt>
| <t_ispunct_0x13>:
endbr64
sub $0x8,%rsp
mov $0x13,%edi
call 1060 <ispunct@plt>
xor %edi,%edi
lea 0xea5(%rip),%rcx
mov $0x64,%edx
test %rax,%rax
lea 0xeb6(%rip),%rsi
sete %dil
add $0x8,%rsp
jmp 1070 <Assert_real@plt>
| @.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_ispunct.c\00"
@.str.1 = [29 x i8] c"ispunct should be 0 for 0x13\00"
define void @t_ispunct_0x13() {
%1 = tail call i64 @ispunct(i32 19)
%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 100, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0))
ret void
}
| <t_ispunct_0x13>:
push %rbp
mov %rsp,%rbp
mov $0x13,%edi
call 1030 <ispunct@plt>
cmp $0x0,%rax
sete %al
and $0x1,%al
movzbl %al,%edi
lea 0xebf(%rip),%rsi
mov $0x64,%edx
lea 0xf5b(%rip),%rcx
call 1040 <Assert_real@plt>
pop %rbp
ret
| <t_ispunct_0x13>:
endbr64
push %rbp
mov %rsp,%rbp
mov $0x13,%edi
call 1060 <ispunct@plt>
test %rax,%rax
sete %al
movzbl %al,%eax
lea 0xea5(%rip),%rdx
mov %rdx,%rcx
mov $0x64,%edx
lea 0xeb6(%rip),%rsi
mov %eax,%edi
call 1070 <Assert_real@plt>
nop
pop %rbp
ret
| @.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_ispunct.c\00"
@.str.1 = [29 x i8] c"ispunct should be 0 for 0x13\00"
define void @t_ispunct_0x13() {
%1 = call i64 @ispunct(i32 19)
%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 100, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0))
ret void
}
| <t_ispunct_0x13>:
push %rax
mov $0x13,%edi
call 1030 <ispunct@plt>
xor %edi,%edi
test %rax,%rax
sete %dil
lea 0xec5(%rip),%rsi
lea 0xf66(%rip),%rcx
mov $0x64,%edx
pop %rax
jmp 1040 <Assert_real@plt>
| <t_ispunct_0x13>:
endbr64
sub $0x8,%rsp
mov $0x13,%edi
call 1060 <ispunct@plt>
xor %edi,%edi
lea 0xea5(%rip),%rcx
mov $0x64,%edx
test %rax,%rax
lea 0xeb6(%rip),%rsi
sete %dil
add $0x8,%rsp
jmp 1070 <Assert_real@plt>
| @.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_ispunct.c\00"
@.str.1 = [29 x i8] c"ispunct should be 0 for 0x13\00"
define void @t_ispunct_0x13() {
%1 = tail call i64 @ispunct(i32 19)
%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 100, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0))
ret void
}
| 2 | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
int /*<<< orphan*/ Assert_real (int,char*,int,char*) ;
scalar_t__ ispunct (int) ;
| void t_ispunct_0x13() {
Assert_real((ispunct(19) == 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_ispunct.c", 100, ("ispunct should be 0 for 0x13"));
} | t_ispunct_0x13 | #define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
int /*<<< orphan*/ Assert_real(int, char *, int, char *);
scalar_t__ ispunct(int);
void t_ispunct_0x13() {
Assert_real((ispunct(19) == 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_ispunct.c",
100, ("ispunct should be 0 for 0x13"));
}
|
<main>:
xor %eax,%eax
ret
| <main>:
endbr64
mov $0x0,%eax
ret
| define i32 @main(i32 %0, i8** nocapture readnone %1) {
ret i32 0
}
| <main>:
xor %eax,%eax
ret
| <main>:
endbr64
xor %eax,%eax
ret
nopw 0x0(%rax,%rax,1)
| define i32 @main(i32 %0, i8** nocapture readnone %1) {
ret i32 0
}
| <main>:
push %rbp
mov %rsp,%rbp
movl $0x0,-0x4(%rbp)
mov %edi,-0x8(%rbp)
mov %rsi,-0x10(%rbp)
xor %ecx,%ecx
add $0x0,%ecx
seto %al
mov %ecx,-0x14(%rbp)
test $0x1,%al
jne 112a <main+0x2a>
jmp 1136 <main+0x36>
movl $0xffffffff,-0x4(%rbp)
jmp 126f <main+0x16f>
mov $0x7fffffff,%ecx
add $0x0,%ecx
seto %al
mov %ecx,-0x14(%rbp)
test $0x1,%al
jne 1151 <main+0x51>
jmp 115d <main+0x5d>
movl $0xffffffff,-0x4(%rbp)
jmp 126f <main+0x16f>
xor %ecx,%ecx
add $0x7fffffff,%ecx
seto %al
mov %ecx,-0x14(%rbp)
test $0x1,%al
jne 1178 <main+0x78>
jmp 1184 <main+0x84>
movl $0xffffffff,-0x4(%rbp)
jmp 126f <main+0x16f>
mov $0x80000000,%ecx
add $0x7fffffff,%ecx
seto %al
mov %ecx,-0x14(%rbp)
test $0x1,%al
jne 11a2 <main+0xa2>
jmp 11ae <main+0xae>
movl $0xffffffff,-0x4(%rbp)
jmp 126f <main+0x16f>
mov $0x7fffffff,%ecx
add $0x80000000,%ecx
seto %al
mov %ecx,-0x14(%rbp)
test $0x1,%al
jne 11cc <main+0xcc>
jmp 11d8 <main+0xd8>
movl $0xffffffff,-0x4(%rbp)
jmp 126f <main+0x16f>
mov $0x7fffffff,%ecx
inc %ecx
seto %al
mov %ecx,-0x14(%rbp)
test $0x1,%al
jne 11f9 <main+0xf9>
movl $0xffffffff,-0x4(%rbp)
jmp 126f <main+0x16f>
mov $0x1,%ecx
add $0x7fffffff,%ecx
seto %al
mov %ecx,-0x14(%rbp)
test $0x1,%al
jne 121e <main+0x11e>
movl $0xffffffff,-0x4(%rbp)
jmp 126f <main+0x16f>
mov $0x7fffffff,%ecx
add $0x7fffffff,%ecx
seto %al
mov %ecx,-0x14(%rbp)
test $0x1,%al
jne 1243 <main+0x143>
movl $0xffffffff,-0x4(%rbp)
jmp 126f <main+0x16f>
mov $0x80000000,%ecx
add $0x80000000,%ecx
seto %al
mov %ecx,-0x14(%rbp)
test $0x1,%al
jne 1268 <main+0x168>
movl $0xffffffff,-0x4(%rbp)
jmp 126f <main+0x16f>
movl $0x0,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
ret
| <main>:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %rsi,-0x20(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0xc(%rbp)
movl $0x7fffffff,-0xc(%rbp)
movl $0x7fffffff,-0xc(%rbp)
movl $0xffffffff,-0xc(%rbp)
movl $0xffffffff,-0xc(%rbp)
movl $0x80000000,-0xc(%rbp)
movl $0x80000000,-0xc(%rbp)
movl $0xfffffffe,-0xc(%rbp)
movl $0x0,-0xc(%rbp)
mov $0x0,%eax
mov -0x8(%rbp),%rdx
sub %fs:0x28,%rdx
je 1193 <main+0x7a>
call 1050 <__stack_chk_fail@plt>
leave
ret
| 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, i1 } @llvm.sadd.with.overflow.i32(i32 0, i32 0)
%8 = extractvalue { i32, i1 } %7, 1
%9 = extractvalue { i32, i1 } %7, 0
store i32 %9, i32* %6
br i1 %8, label %10, label %11
10: ; preds = %2
store i32 -1, i32* %3
br label %52
11: ; preds = %2
%12 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 2147483647, i32 0)
%13 = extractvalue { i32, i1 } %12, 1
%14 = extractvalue { i32, i1 } %12, 0
store i32 %14, i32* %6
br i1 %13, label %15, label %16
15: ; preds = %11
store i32 -1, i32* %3
br label %52
16: ; preds = %11
%17 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 0, i32 2147483647)
%18 = extractvalue { i32, i1 } %17, 1
%19 = extractvalue { i32, i1 } %17, 0
store i32 %19, i32* %6
br i1 %18, label %20, label %21
20: ; preds = %16
store i32 -1, i32* %3
br label %52
21: ; preds = %16
%22 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 -2147483648, i32 2147483647)
%23 = extractvalue { i32, i1 } %22, 1
%24 = extractvalue { i32, i1 } %22, 0
store i32 %24, i32* %6
br i1 %23, label %25, label %26
25: ; preds = %21
store i32 -1, i32* %3
br label %52
26: ; preds = %21
%27 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 2147483647, i32 -2147483648)
%28 = extractvalue { i32, i1 } %27, 1
%29 = extractvalue { i32, i1 } %27, 0
store i32 %29, i32* %6
br i1 %28, label %30, label %31
30: ; preds = %26
store i32 -1, i32* %3
br label %52
31: ; preds = %26
%32 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 2147483647, i32 1)
%33 = extractvalue { i32, i1 } %32, 1
%34 = extractvalue { i32, i1 } %32, 0
store i32 %34, i32* %6
br i1 %33, label %36, label %35
35: ; preds = %31
store i32 -1, i32* %3
br label %52
36: ; preds = %31
%37 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 1, i32 2147483647)
%38 = extractvalue { i32, i1 } %37, 1
%39 = extractvalue { i32, i1 } %37, 0
store i32 %39, i32* %6
br i1 %38, label %41, label %40
40: ; preds = %36
store i32 -1, i32* %3
br label %52
41: ; preds = %36
%42 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 2147483647, i32 2147483647)
%43 = extractvalue { i32, i1 } %42, 1
%44 = extractvalue { i32, i1 } %42, 0
store i32 %44, i32* %6
br i1 %43, label %46, label %45
45: ; preds = %41
store i32 -1, i32* %3
br label %52
46: ; preds = %41
%47 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 -2147483648, i32 -2147483648)
%48 = extractvalue { i32, i1 } %47, 1
%49 = extractvalue { i32, i1 } %47, 0
store i32 %49, i32* %6
br i1 %48, label %51, label %50
50: ; preds = %46
store i32 -1, i32* %3
br label %52
51: ; preds = %46
store i32 0, i32* %3
br label %52
52: ; preds = %51, %50, %45, %40, %35, %30, %25, %20, %15, %10
%53 = load i32, i32* %3
ret i32 %53
}
| <main>:
xor %eax,%eax
ret
| <main>:
endbr64
xor %eax,%eax
ret
nopw 0x0(%rax,%rax,1)
| define i32 @main(i32 %0, i8** nocapture readnone %1) {
ret i32 0
}
| 3 | null | int main(int argc, const char **argv) {
signed int res;
if (__builtin_add_overflow((signed int) 0x0, (signed int) 0x0, &res)) {
return -1;
}
if (__builtin_add_overflow((signed int) 0x7FFFFFFF, (signed int) 0x0, &res)) {
return -1;
}
if (__builtin_add_overflow((signed int) 0x0, (signed int) 0x7FFFFFFF, &res)) {
return -1;
}
if (__builtin_add_overflow((signed int) 0x80000000, (signed int) 0x7FFFFFFF, &res)) {
return -1;
}
if (__builtin_add_overflow((signed int) 0x7FFFFFFF, (signed int) 0x80000000, &res)) {
return -1;
}
if (!__builtin_add_overflow((signed int) 0x7FFFFFFF, (signed int) 0x1, &res)) {
return -1;
}
if (!__builtin_add_overflow((signed int) 0x1, (signed int) 0x7FFFFFFF, &res)) {
return -1;
}
if (!__builtin_add_overflow((signed int) 0x7FFFFFFF, (signed int) 0x7FFFFFFF, &res)) {
return -1;
}
if (!__builtin_add_overflow((signed int) 0x80000000, (signed int) 0x80000000, &res)) {
return -1;
}
return 0;
} | main | int main(int argc, const char **argv) {
signed int res;
if (__builtin_add_overflow((signed int)0x0, (signed int)0x0, &res)) {
return -1;
}
if (__builtin_add_overflow((signed int)0x7FFFFFFF, (signed int)0x0, &res)) {
return -1;
}
if (__builtin_add_overflow((signed int)0x0, (signed int)0x7FFFFFFF, &res)) {
return -1;
}
if (__builtin_add_overflow((signed int)0x80000000, (signed int)0x7FFFFFFF,
&res)) {
return -1;
}
if (__builtin_add_overflow((signed int)0x7FFFFFFF, (signed int)0x80000000,
&res)) {
return -1;
}
if (!__builtin_add_overflow((signed int)0x7FFFFFFF, (signed int)0x1, &res)) {
return -1;
}
if (!__builtin_add_overflow((signed int)0x1, (signed int)0x7FFFFFFF, &res)) {
return -1;
}
if (!__builtin_add_overflow((signed int)0x7FFFFFFF, (signed int)0x7FFFFFFF,
&res)) {
return -1;
}
if (!__builtin_add_overflow((signed int)0x80000000, (signed int)0x80000000,
&res)) {
return -1;
}
return 0;
}
|
<attr_load_names>:
xor %eax,%eax
ret
| <attr_load_names>:
endbr64
mov $0x0,%eax
ret
| define i32 @attr_load_names(i8* nocapture readnone %0) {
ret i32 0
}
| <attr_load_names>:
xor %eax,%eax
ret
| <attr_load_names>:
endbr64
xor %eax,%eax
ret
| define i32 @attr_load_names(i8* nocapture readnone %0) {
ret i32 0
}
| <attr_load_names>:
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
xor %eax,%eax
pop %rbp
ret
| <attr_load_names>:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov $0x0,%eax
pop %rbp
ret
| define i32 @attr_load_names(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
ret i32 0
}
| <attr_load_names>:
xor %eax,%eax
ret
| <attr_load_names>:
endbr64
xor %eax,%eax
ret
| define i32 @attr_load_names(i8* nocapture readnone %0) {
ret i32 0
}
| 4 | null | int attr_load_names(name) char *name; {
return 0;
} | attr_load_names | int attr_load_names(name)
char *name;
{ return 0; }
|
<MyAtoI>:
lea -0x61(%rdi),%ecx
lea -0x30(%rdi),%edx
lea -0x57(%rdi),%eax
cmp $0x6,%cl
cmovae %edx,%eax
ret
| <MyAtoI>:
endbr64
lea -0x61(%rdi),%eax
cmp $0x5,%al
ja 110c <MyAtoI+0x13>
movzbl %dil,%edi
lea -0x57(%rdi),%eax
ret
movzbl %dil,%edi
lea -0x30(%rdi),%eax
ret
| define i32 @MyAtoI(i8 zeroext %0) {
%2 = zext i8 %0 to i32
%3 = add i8 %0, -97
%4 = icmp ult i8 %3, 6
%5 = select i1 %4, i32 -87, i32 -48
%6 = add nsw i32 %5, %2
ret i32 %6
}
| <MyAtoI>:
lea -0x61(%rdi),%ecx
lea -0x30(%rdi),%edx
lea -0x57(%rdi),%eax
cmp $0x6,%cl
cmovae %edx,%eax
ret
| <MyAtoI>:
endbr64
movzbl %dil,%eax
sub $0x61,%edi
lea -0x57(%rax),%edx
sub $0x30,%eax
cmp $0x5,%dil
cmovbe %edx,%eax
ret
| define i32 @MyAtoI(i8 zeroext %0) {
%2 = zext i8 %0 to i32
%3 = add i8 %0, -97
%4 = icmp ult i8 %3, 6
%5 = select i1 %4, i32 -87, i32 -48
%6 = add nsw i32 %5, %2
ret i32 %6
}
| <MyAtoI>:
push %rbp
mov %rsp,%rbp
mov %dil,%al
mov %al,-0x5(%rbp)
movzbl -0x5(%rbp),%eax
cmp $0x61,%eax
jl 1136 <MyAtoI+0x36>
movzbl -0x5(%rbp),%eax
cmp $0x66,%eax
jg 1136 <MyAtoI+0x36>
movzbl -0x5(%rbp),%eax
sub $0x61,%eax
add $0xa,%eax
mov %eax,-0x4(%rbp)
jmp 1140 <MyAtoI+0x40>
movzbl -0x5(%rbp),%eax
sub $0x30,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
ret
| <MyAtoI>:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,%eax
mov %al,-0x4(%rbp)
cmpb $0x60,-0x4(%rbp)
jbe 111b <MyAtoI+0x22>
cmpb $0x66,-0x4(%rbp)
ja 111b <MyAtoI+0x22>
movzbl -0x4(%rbp),%eax
sub $0x57,%eax
jmp 1122 <MyAtoI+0x29>
movzbl -0x4(%rbp),%eax
sub $0x30,%eax
pop %rbp
ret
| define i32 @MyAtoI(i8 zeroext %0) {
%2 = alloca i32
%3 = alloca i8
store i8 %0, i8* %3
%4 = load i8, i8* %3
%5 = zext i8 %4 to i32
%6 = icmp sge i32 %5, 97
br i1 %6, label %7, label %16
7: ; preds = %1
%8 = load i8, i8* %3
%9 = zext i8 %8 to i32
%10 = icmp sle i32 %9, 102
br i1 %10, label %11, label %16
11: ; preds = %7
%12 = load i8, i8* %3
%13 = zext i8 %12 to i32
%14 = sub nsw i32 %13, 97
%15 = add nsw i32 %14, 10
store i32 %15, i32* %2
br label %20
16: ; preds = %7, %1
%17 = load i8, i8* %3
%18 = zext i8 %17 to i32
%19 = sub nsw i32 %18, 48
store i32 %19, i32* %2
br label %20
20: ; preds = %16, %11
%21 = load i32, i32* %2
ret i32 %21
}
| <MyAtoI>:
lea -0x61(%rdi),%ecx
lea -0x30(%rdi),%edx
lea -0x57(%rdi),%eax
cmp $0x6,%cl
cmovae %edx,%eax
ret
| <MyAtoI>:
endbr64
movzbl %dil,%eax
sub $0x61,%edi
lea -0x57(%rax),%edx
sub $0x30,%eax
cmp $0x5,%dil
cmovbe %edx,%eax
ret
| define i32 @MyAtoI(i8 zeroext %0) {
%2 = zext i8 %0 to i32
%3 = add i8 %0, -97
%4 = icmp ult i8 %3, 6
%5 = select i1 %4, i32 -87, i32 -48
%6 = add nsw i32 %5, %2
ret i32 %6
}
| 5 | null | int MyAtoI(unsigned char param) {
if(param>='a' && param<='f'){
return (param-'a'+10);
}else{
return (param-'0');
}
} | MyAtoI | int MyAtoI(unsigned char param) {
if (param >= 'a' && param <= 'f') {
return (param - 'a' + 10);
} else {
return (param - '0');
}
}
|
<main>:
push %rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0xd8,%rsp
movups 0xed4(%rip),%xmm0
movups %xmm0,0xbc(%rsp)
movaps 0xeb9(%rip),%xmm0
movaps %xmm0,0xb0(%rsp)
movaps 0xe9a(%rip),%xmm0
movaps %xmm0,0xa0(%rsp)
movaps 0xe7b(%rip),%xmm0
movaps %xmm0,0x90(%rsp)
lea 0x90(%rsp),%rbx
mov %rbx,%rdi
xor %esi,%esi
call 1050 <createList@plt>
mov %rax,%r14
mov %rbx,%rdi
mov $0x1,%esi
call 1050 <createList@plt>
mov %rax,%r15
mov %rbx,%rdi
mov $0x2,%esi
call 1050 <createList@plt>
mov %rax,%rbp
mov %rbx,%rdi
mov $0x3,%esi
call 1050 <createList@plt>
mov %rax,%r12
mov %rbx,%rdi
mov $0x4,%esi
call 1050 <createList@plt>
mov %rax,%r13
mov %rbx,%rdi
mov $0x5,%esi
call 1050 <createList@plt>
mov %rax,0x20(%rsp)
mov %rbx,%rdi
mov $0x6,%esi
call 1050 <createList@plt>
mov %rax,0x18(%rsp)
mov %rbx,%rdi
mov $0x7,%esi
call 1050 <createList@plt>
mov %rax,0x10(%rsp)
mov %rbx,%rdi
mov $0x8,%esi
call 1050 <createList@plt>
mov %rax,0x8(%rsp)
mov %rbx,%rdi
mov $0x9,%esi
call 1050 <createList@plt>
mov %rax,(%rsp)
mov %rbx,%rdi
mov $0xa,%esi
call 1050 <createList@plt>
mov %rax,0x88(%rsp)
mov %rbx,%rdi
mov $0xb,%esi
call 1050 <createList@plt>
mov %rax,0x80(%rsp)
mov %rbx,%rdi
mov $0xc,%esi
call 1050 <createList@plt>
mov %rax,0x78(%rsp)
mov %rbx,%rdi
mov $0xd,%esi
call 1050 <createList@plt>
mov %rax,0x70(%rsp)
mov %rbx,%rdi
mov $0xe,%esi
call 1050 <createList@plt>
mov %rax,0x68(%rsp)
mov %r14,%rdi
call 1040 <swapPairs@plt>
mov %rax,%rbx
mov %rax,0x40(%rsp)
mov %r15,%rdi
call 1040 <swapPairs@plt>
mov %rax,0x60(%rsp)
mov %rbp,%rdi
call 1040 <swapPairs@plt>
mov %rax,%rbp
mov %r12,%rdi
call 1040 <swapPairs@plt>
mov %rax,%r14
mov %r13,%rdi
call 1040 <swapPairs@plt>
mov %rax,%r15
mov %rax,0x38(%rsp)
mov 0x20(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,%r12
mov %rax,0x30(%rsp)
mov 0x18(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x58(%rsp)
mov 0x10(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x50(%rsp)
mov 0x8(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,%r13
mov %rax,0x28(%rsp)
mov (%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x48(%rsp)
mov 0x88(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x20(%rsp)
mov 0x80(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x18(%rsp)
mov 0x78(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x10(%rsp)
mov 0x70(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x8(%rsp)
mov 0x68(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,(%rsp)
mov %rbx,%rdi
call 1060 <printList@plt>
mov 0x60(%rsp),%rbx
mov %rbx,%rdi
call 1060 <printList@plt>
mov %rbp,%rdi
call 1060 <printList@plt>
mov %r14,%rdi
call 1060 <printList@plt>
mov %r15,%rdi
call 1060 <printList@plt>
mov %r12,%rdi
call 1060 <printList@plt>
mov 0x58(%rsp),%r15
mov %r15,%rdi
call 1060 <printList@plt>
mov 0x50(%rsp),%r12
mov %r12,%rdi
call 1060 <printList@plt>
mov %r13,%rdi
call 1060 <printList@plt>
mov 0x48(%rsp),%r13
mov %r13,%rdi
call 1060 <printList@plt>
mov 0x20(%rsp),%rdi
call 1060 <printList@plt>
mov 0x18(%rsp),%rdi
call 1060 <printList@plt>
mov 0x10(%rsp),%rdi
call 1060 <printList@plt>
mov 0x8(%rsp),%rdi
call 1060 <printList@plt>
mov (%rsp),%rdi
call 1060 <printList@plt>
mov 0x40(%rsp),%rdi
call 1030 <freeList@plt>
mov %rbx,%rdi
call 1030 <freeList@plt>
mov %rbp,%rdi
call 1030 <freeList@plt>
mov %r14,%rdi
call 1030 <freeList@plt>
mov 0x38(%rsp),%rdi
call 1030 <freeList@plt>
mov 0x30(%rsp),%rdi
call 1030 <freeList@plt>
mov %r15,%rdi
call 1030 <freeList@plt>
mov %r12,%rdi
call 1030 <freeList@plt>
mov 0x28(%rsp),%rdi
call 1030 <freeList@plt>
mov %r13,%rdi
call 1030 <freeList@plt>
mov 0x20(%rsp),%rdi
call 1030 <freeList@plt>
mov 0x18(%rsp),%rdi
call 1030 <freeList@plt>
mov 0x10(%rsp),%rdi
call 1030 <freeList@plt>
mov 0x8(%rsp),%rdi
call 1030 <freeList@plt>
mov (%rsp),%rdi
call 1030 <freeList@plt>
xor %eax,%eax
add $0xd8,%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
ret
| <main>:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
movl $0x1,0x50(%rsp)
movl $0x2,0x54(%rsp)
movl $0x3,0x58(%rsp)
movl $0x4,0x5c(%rsp)
movl $0x5,0x60(%rsp)
movl $0x6,0x64(%rsp)
movl $0x7,0x68(%rsp)
movl $0x8,0x6c(%rsp)
movl $0x9,0x70(%rsp)
movl $0xa,0x74(%rsp)
movl $0xb,0x78(%rsp)
movl $0xc,0x7c(%rsp)
movl $0xd,0x80(%rsp)
movl $0xe,0x84(%rsp)
movl $0xf,0x88(%rsp)
lea 0x50(%rsp),%rbx
mov $0x0,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,%r15
mov $0x1,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,%r14
mov $0x2,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,%r13
mov $0x3,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,%r12
mov $0x4,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,0x8(%rsp)
mov $0x5,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,0x10(%rsp)
mov $0x6,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,0x18(%rsp)
mov $0x7,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,0x20(%rsp)
mov $0x8,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,0x28(%rsp)
mov $0x9,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,0x30(%rsp)
mov $0xa,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,0x38(%rsp)
mov $0xb,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,0x40(%rsp)
mov $0xc,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,0x48(%rsp)
mov $0xd,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,%rbp
mov $0xe,%esi
mov %rbx,%rdi
call 10c0 <createList@plt>
mov %rax,%rbx
mov %r15,%rdi
call 10b0 <swapPairs@plt>
mov %rax,%r15
mov %r14,%rdi
call 10b0 <swapPairs@plt>
mov %rax,%r14
mov %r13,%rdi
call 10b0 <swapPairs@plt>
mov %rax,%r13
mov %r12,%rdi
call 10b0 <swapPairs@plt>
mov %rax,%r12
mov 0x8(%rsp),%rdi
call 10b0 <swapPairs@plt>
mov %rax,0x8(%rsp)
mov 0x10(%rsp),%rdi
call 10b0 <swapPairs@plt>
mov %rax,0x10(%rsp)
mov 0x18(%rsp),%rdi
call 10b0 <swapPairs@plt>
mov %rax,0x18(%rsp)
mov 0x20(%rsp),%rdi
call 10b0 <swapPairs@plt>
mov %rax,0x20(%rsp)
mov 0x28(%rsp),%rdi
call 10b0 <swapPairs@plt>
mov %rax,0x28(%rsp)
mov 0x30(%rsp),%rdi
call 10b0 <swapPairs@plt>
mov %rax,0x30(%rsp)
mov 0x38(%rsp),%rdi
call 10b0 <swapPairs@plt>
mov %rax,0x38(%rsp)
mov 0x40(%rsp),%rdi
call 10b0 <swapPairs@plt>
mov %rax,0x40(%rsp)
mov 0x48(%rsp),%rdi
call 10b0 <swapPairs@plt>
mov %rax,0x48(%rsp)
mov %rbp,%rdi
call 10b0 <swapPairs@plt>
mov %rax,%rbp
mov %rbx,%rdi
call 10b0 <swapPairs@plt>
mov %rax,%rbx
mov %r15,%rdi
call 10d0 <printList@plt>
mov %r14,%rdi
call 10d0 <printList@plt>
mov %r13,%rdi
call 10d0 <printList@plt>
mov %r12,%rdi
call 10d0 <printList@plt>
mov 0x8(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x10(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x18(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x20(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x28(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x30(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x38(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x40(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x48(%rsp),%rdi
call 10d0 <printList@plt>
mov %rbp,%rdi
call 10d0 <printList@plt>
mov %rbx,%rdi
call 10d0 <printList@plt>
mov %r15,%rdi
call 1090 <freeList@plt>
mov %r14,%rdi
call 1090 <freeList@plt>
mov %r13,%rdi
call 1090 <freeList@plt>
mov %r12,%rdi
call 1090 <freeList@plt>
mov 0x8(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x10(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x18(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x20(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x28(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x30(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x38(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x40(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x48(%rsp),%rdi
call 1090 <freeList@plt>
mov %rbp,%rdi
call 1090 <freeList@plt>
mov %rbx,%rdi
call 1090 <freeList@plt>
mov 0x98(%rsp),%rax
sub %fs:0x28,%rax
jne 1550 <main+0x3b7>
mov $0x0,%eax
add $0xa8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
ret
call 10a0 <__stack_chk_fail@plt>
| %struct.ListNode = type { i32 }
@__const.main.arr = [15 x i32] [i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15]
define i32 @main() {
%1 = alloca [15 x i32]
%2 = bitcast [15 x i32]* %1 to i8*
%3 = getelementptr inbounds [15 x i32], [15 x i32]* %1, i64 0, i64 0
%4 = call %struct.ListNode* @createList(i32* %3, i32 0)
%5 = call %struct.ListNode* @createList(i32* %3, i32 1)
%6 = call %struct.ListNode* @createList(i32* %3, i32 2)
%7 = call %struct.ListNode* @createList(i32* %3, i32 3)
%8 = call %struct.ListNode* @createList(i32* %3, i32 4)
%9 = call %struct.ListNode* @createList(i32* %3, i32 5)
%10 = call %struct.ListNode* @createList(i32* %3, i32 6)
%11 = call %struct.ListNode* @createList(i32* %3, i32 7)
%12 = call %struct.ListNode* @createList(i32* %3, i32 8)
%13 = call %struct.ListNode* @createList(i32* %3, i32 9)
%14 = call %struct.ListNode* @createList(i32* %3, i32 10)
%15 = call %struct.ListNode* @createList(i32* %3, i32 11)
%16 = call %struct.ListNode* @createList(i32* %3, i32 12)
%17 = call %struct.ListNode* @createList(i32* %3, i32 13)
%18 = call %struct.ListNode* @createList(i32* %3, i32 14)
%19 = call %struct.ListNode* @swapPairs(%struct.ListNode* %4)
%20 = call %struct.ListNode* @swapPairs(%struct.ListNode* %5)
%21 = call %struct.ListNode* @swapPairs(%struct.ListNode* %6)
%22 = call %struct.ListNode* @swapPairs(%struct.ListNode* %7)
%23 = call %struct.ListNode* @swapPairs(%struct.ListNode* %8)
%24 = call %struct.ListNode* @swapPairs(%struct.ListNode* %9)
%25 = call %struct.ListNode* @swapPairs(%struct.ListNode* %10)
%26 = call %struct.ListNode* @swapPairs(%struct.ListNode* %11)
%27 = call %struct.ListNode* @swapPairs(%struct.ListNode* %12)
%28 = call %struct.ListNode* @swapPairs(%struct.ListNode* %13)
%29 = call %struct.ListNode* @swapPairs(%struct.ListNode* %14)
%30 = call %struct.ListNode* @swapPairs(%struct.ListNode* %15)
%31 = call %struct.ListNode* @swapPairs(%struct.ListNode* %16)
%32 = call %struct.ListNode* @swapPairs(%struct.ListNode* %17)
%33 = call %struct.ListNode* @swapPairs(%struct.ListNode* %18)
%34 = call i32 @printList(%struct.ListNode* %19)
%35 = call i32 @printList(%struct.ListNode* %20)
%36 = call i32 @printList(%struct.ListNode* %21)
%37 = call i32 @printList(%struct.ListNode* %22)
%38 = call i32 @printList(%struct.ListNode* %23)
%39 = call i32 @printList(%struct.ListNode* %24)
%40 = call i32 @printList(%struct.ListNode* %25)
%41 = call i32 @printList(%struct.ListNode* %26)
%42 = call i32 @printList(%struct.ListNode* %27)
%43 = call i32 @printList(%struct.ListNode* %28)
%44 = call i32 @printList(%struct.ListNode* %29)
%45 = call i32 @printList(%struct.ListNode* %30)
%46 = call i32 @printList(%struct.ListNode* %31)
%47 = call i32 @printList(%struct.ListNode* %32)
%48 = call i32 @printList(%struct.ListNode* %33)
%49 = call i32 @freeList(%struct.ListNode* %19)
%50 = call i32 @freeList(%struct.ListNode* %20)
%51 = call i32 @freeList(%struct.ListNode* %21)
%52 = call i32 @freeList(%struct.ListNode* %22)
%53 = call i32 @freeList(%struct.ListNode* %23)
%54 = call i32 @freeList(%struct.ListNode* %24)
%55 = call i32 @freeList(%struct.ListNode* %25)
%56 = call i32 @freeList(%struct.ListNode* %26)
%57 = call i32 @freeList(%struct.ListNode* %27)
%58 = call i32 @freeList(%struct.ListNode* %28)
%59 = call i32 @freeList(%struct.ListNode* %29)
%60 = call i32 @freeList(%struct.ListNode* %30)
%61 = call i32 @freeList(%struct.ListNode* %31)
%62 = call i32 @freeList(%struct.ListNode* %32)
%63 = call i32 @freeList(%struct.ListNode* %33)
ret i32 0
}
| <main>:
push %rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0xd8,%rsp
movups 0xed4(%rip),%xmm0
movups %xmm0,0xbc(%rsp)
movaps 0xeb9(%rip),%xmm0
movaps %xmm0,0xb0(%rsp)
movaps 0xe9a(%rip),%xmm0
movaps %xmm0,0xa0(%rsp)
movaps 0xe7b(%rip),%xmm0
movaps %xmm0,0x90(%rsp)
lea 0x90(%rsp),%rbx
mov %rbx,%rdi
xor %esi,%esi
call 1050 <createList@plt>
mov %rax,%r14
mov %rbx,%rdi
mov $0x1,%esi
call 1050 <createList@plt>
mov %rax,%r15
mov %rbx,%rdi
mov $0x2,%esi
call 1050 <createList@plt>
mov %rax,%rbp
mov %rbx,%rdi
mov $0x3,%esi
call 1050 <createList@plt>
mov %rax,%r12
mov %rbx,%rdi
mov $0x4,%esi
call 1050 <createList@plt>
mov %rax,%r13
mov %rbx,%rdi
mov $0x5,%esi
call 1050 <createList@plt>
mov %rax,0x20(%rsp)
mov %rbx,%rdi
mov $0x6,%esi
call 1050 <createList@plt>
mov %rax,0x18(%rsp)
mov %rbx,%rdi
mov $0x7,%esi
call 1050 <createList@plt>
mov %rax,0x10(%rsp)
mov %rbx,%rdi
mov $0x8,%esi
call 1050 <createList@plt>
mov %rax,0x8(%rsp)
mov %rbx,%rdi
mov $0x9,%esi
call 1050 <createList@plt>
mov %rax,(%rsp)
mov %rbx,%rdi
mov $0xa,%esi
call 1050 <createList@plt>
mov %rax,0x88(%rsp)
mov %rbx,%rdi
mov $0xb,%esi
call 1050 <createList@plt>
mov %rax,0x80(%rsp)
mov %rbx,%rdi
mov $0xc,%esi
call 1050 <createList@plt>
mov %rax,0x78(%rsp)
mov %rbx,%rdi
mov $0xd,%esi
call 1050 <createList@plt>
mov %rax,0x70(%rsp)
mov %rbx,%rdi
mov $0xe,%esi
call 1050 <createList@plt>
mov %rax,0x68(%rsp)
mov %r14,%rdi
call 1040 <swapPairs@plt>
mov %rax,%rbx
mov %rax,0x40(%rsp)
mov %r15,%rdi
call 1040 <swapPairs@plt>
mov %rax,0x60(%rsp)
mov %rbp,%rdi
call 1040 <swapPairs@plt>
mov %rax,%rbp
mov %r12,%rdi
call 1040 <swapPairs@plt>
mov %rax,%r14
mov %r13,%rdi
call 1040 <swapPairs@plt>
mov %rax,%r15
mov %rax,0x38(%rsp)
mov 0x20(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,%r12
mov %rax,0x30(%rsp)
mov 0x18(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x58(%rsp)
mov 0x10(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x50(%rsp)
mov 0x8(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,%r13
mov %rax,0x28(%rsp)
mov (%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x48(%rsp)
mov 0x88(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x20(%rsp)
mov 0x80(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x18(%rsp)
mov 0x78(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x10(%rsp)
mov 0x70(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x8(%rsp)
mov 0x68(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,(%rsp)
mov %rbx,%rdi
call 1060 <printList@plt>
mov 0x60(%rsp),%rbx
mov %rbx,%rdi
call 1060 <printList@plt>
mov %rbp,%rdi
call 1060 <printList@plt>
mov %r14,%rdi
call 1060 <printList@plt>
mov %r15,%rdi
call 1060 <printList@plt>
mov %r12,%rdi
call 1060 <printList@plt>
mov 0x58(%rsp),%r15
mov %r15,%rdi
call 1060 <printList@plt>
mov 0x50(%rsp),%r12
mov %r12,%rdi
call 1060 <printList@plt>
mov %r13,%rdi
call 1060 <printList@plt>
mov 0x48(%rsp),%r13
mov %r13,%rdi
call 1060 <printList@plt>
mov 0x20(%rsp),%rdi
call 1060 <printList@plt>
mov 0x18(%rsp),%rdi
call 1060 <printList@plt>
mov 0x10(%rsp),%rdi
call 1060 <printList@plt>
mov 0x8(%rsp),%rdi
call 1060 <printList@plt>
mov (%rsp),%rdi
call 1060 <printList@plt>
mov 0x40(%rsp),%rdi
call 1030 <freeList@plt>
mov %rbx,%rdi
call 1030 <freeList@plt>
mov %rbp,%rdi
call 1030 <freeList@plt>
mov %r14,%rdi
call 1030 <freeList@plt>
mov 0x38(%rsp),%rdi
call 1030 <freeList@plt>
mov 0x30(%rsp),%rdi
call 1030 <freeList@plt>
mov %r15,%rdi
call 1030 <freeList@plt>
mov %r12,%rdi
call 1030 <freeList@plt>
mov 0x28(%rsp),%rdi
call 1030 <freeList@plt>
mov %r13,%rdi
call 1030 <freeList@plt>
mov 0x20(%rsp),%rdi
call 1030 <freeList@plt>
mov 0x18(%rsp),%rdi
call 1030 <freeList@plt>
mov 0x10(%rsp),%rdi
call 1030 <freeList@plt>
mov 0x8(%rsp),%rdi
call 1030 <freeList@plt>
mov (%rsp),%rdi
call 1030 <freeList@plt>
xor %eax,%eax
add $0xd8,%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
ret
| <main>:
endbr64
push %r15
xor %esi,%esi
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
movabs $0x200000001,%rax
lea 0x50(%rsp),%rbp
movl $0xf,0x88(%rsp)
mov %rbp,%rdi
mov %rax,0x50(%rsp)
movabs $0x400000003,%rax
mov %rax,0x58(%rsp)
movabs $0x600000005,%rax
mov %rax,0x60(%rsp)
movabs $0x800000007,%rax
mov %rax,0x68(%rsp)
movabs $0xa00000009,%rax
mov %rax,0x70(%rsp)
movabs $0xc0000000b,%rax
mov %rax,0x78(%rsp)
movabs $0xe0000000d,%rax
mov %rax,0x80(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x1,%esi
mov %rax,0x48(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x2,%esi
mov %rax,(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x3,%esi
mov %rax,0x40(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x4,%esi
mov %rax,0x38(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x5,%esi
mov %rax,0x30(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x6,%esi
mov %rax,0x28(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x7,%esi
mov %rax,%rbx
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x8,%esi
mov %rax,%r15
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x9,%esi
mov %rax,%r14
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0xa,%esi
mov %rax,%r13
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0xb,%esi
mov %rax,0x8(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0xc,%esi
mov %rax,0x10(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0xd,%esi
mov %rax,0x18(%rsp)
call 10c0 <createList@plt>
mov $0xe,%esi
mov %rbp,%rdi
mov %rax,%r12
call 10c0 <createList@plt>
mov 0x48(%rsp),%rdi
mov %rax,0x20(%rsp)
call 10b0 <swapPairs@plt>
mov (%rsp),%rdi
mov %rax,%rbp
call 10b0 <swapPairs@plt>
mov 0x40(%rsp),%rdi
mov %rax,(%rsp)
call 10b0 <swapPairs@plt>
mov 0x38(%rsp),%rdi
mov %rax,0x40(%rsp)
call 10b0 <swapPairs@plt>
mov 0x30(%rsp),%rdi
mov %rax,0x38(%rsp)
call 10b0 <swapPairs@plt>
mov 0x28(%rsp),%rdi
mov %rax,0x30(%rsp)
call 10b0 <swapPairs@plt>
mov %rbx,%rdi
mov %rax,0x28(%rsp)
call 10b0 <swapPairs@plt>
mov %r15,%rdi
mov %rax,%rbx
call 10b0 <swapPairs@plt>
mov %r14,%rdi
mov %rax,%r15
call 10b0 <swapPairs@plt>
mov %r13,%rdi
mov %rax,%r14
call 10b0 <swapPairs@plt>
mov 0x8(%rsp),%rdi
mov %rax,%r13
call 10b0 <swapPairs@plt>
mov 0x10(%rsp),%rdi
mov %rax,0x8(%rsp)
call 10b0 <swapPairs@plt>
mov 0x18(%rsp),%rdi
mov %rax,0x10(%rsp)
call 10b0 <swapPairs@plt>
mov %r12,%rdi
mov %rax,0x18(%rsp)
call 10b0 <swapPairs@plt>
mov 0x20(%rsp),%rdi
mov %rax,%r12
call 10b0 <swapPairs@plt>
mov %rbp,%rdi
mov %rax,0x20(%rsp)
call 10d0 <printList@plt>
mov (%rsp),%rdi
call 10d0 <printList@plt>
mov 0x40(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x38(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x30(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x28(%rsp),%rdi
call 10d0 <printList@plt>
mov %rbx,%rdi
call 10d0 <printList@plt>
mov %r15,%rdi
call 10d0 <printList@plt>
mov %r14,%rdi
call 10d0 <printList@plt>
mov %r13,%rdi
call 10d0 <printList@plt>
mov 0x8(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x10(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x18(%rsp),%rdi
call 10d0 <printList@plt>
mov %r12,%rdi
call 10d0 <printList@plt>
mov 0x20(%rsp),%rdi
call 10d0 <printList@plt>
mov %rbp,%rdi
call 1090 <freeList@plt>
mov (%rsp),%rdi
call 1090 <freeList@plt>
mov 0x40(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x38(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x30(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x28(%rsp),%rdi
call 1090 <freeList@plt>
mov %rbx,%rdi
call 1090 <freeList@plt>
mov %r15,%rdi
call 1090 <freeList@plt>
mov %r14,%rdi
call 1090 <freeList@plt>
mov %r13,%rdi
call 1090 <freeList@plt>
mov 0x8(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x10(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x18(%rsp),%rdi
call 1090 <freeList@plt>
mov %r12,%rdi
call 1090 <freeList@plt>
mov 0x20(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x98(%rsp),%rax
sub %fs:0x28,%rax
jne 1484 <main+0x3a4>
add $0xa8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
ret
call 10a0 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| %struct.ListNode = type { i32 }
@__const.main.arr = [15 x i32] [i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15]
define i32 @main() {
%1 = alloca [15 x i32]
%2 = bitcast [15 x i32]* %1 to i8*
%3 = getelementptr inbounds [15 x i32], [15 x i32]* %1, i64 0, i64 0
%4 = call %struct.ListNode* @createList(i32* %3, i32 0)
%5 = call %struct.ListNode* @createList(i32* %3, i32 1)
%6 = call %struct.ListNode* @createList(i32* %3, i32 2)
%7 = call %struct.ListNode* @createList(i32* %3, i32 3)
%8 = call %struct.ListNode* @createList(i32* %3, i32 4)
%9 = call %struct.ListNode* @createList(i32* %3, i32 5)
%10 = call %struct.ListNode* @createList(i32* %3, i32 6)
%11 = call %struct.ListNode* @createList(i32* %3, i32 7)
%12 = call %struct.ListNode* @createList(i32* %3, i32 8)
%13 = call %struct.ListNode* @createList(i32* %3, i32 9)
%14 = call %struct.ListNode* @createList(i32* %3, i32 10)
%15 = call %struct.ListNode* @createList(i32* %3, i32 11)
%16 = call %struct.ListNode* @createList(i32* %3, i32 12)
%17 = call %struct.ListNode* @createList(i32* %3, i32 13)
%18 = call %struct.ListNode* @createList(i32* %3, i32 14)
%19 = call %struct.ListNode* @swapPairs(%struct.ListNode* %4)
%20 = call %struct.ListNode* @swapPairs(%struct.ListNode* %5)
%21 = call %struct.ListNode* @swapPairs(%struct.ListNode* %6)
%22 = call %struct.ListNode* @swapPairs(%struct.ListNode* %7)
%23 = call %struct.ListNode* @swapPairs(%struct.ListNode* %8)
%24 = call %struct.ListNode* @swapPairs(%struct.ListNode* %9)
%25 = call %struct.ListNode* @swapPairs(%struct.ListNode* %10)
%26 = call %struct.ListNode* @swapPairs(%struct.ListNode* %11)
%27 = call %struct.ListNode* @swapPairs(%struct.ListNode* %12)
%28 = call %struct.ListNode* @swapPairs(%struct.ListNode* %13)
%29 = call %struct.ListNode* @swapPairs(%struct.ListNode* %14)
%30 = call %struct.ListNode* @swapPairs(%struct.ListNode* %15)
%31 = call %struct.ListNode* @swapPairs(%struct.ListNode* %16)
%32 = call %struct.ListNode* @swapPairs(%struct.ListNode* %17)
%33 = call %struct.ListNode* @swapPairs(%struct.ListNode* %18)
%34 = call i32 @printList(%struct.ListNode* %19)
%35 = call i32 @printList(%struct.ListNode* %20)
%36 = call i32 @printList(%struct.ListNode* %21)
%37 = call i32 @printList(%struct.ListNode* %22)
%38 = call i32 @printList(%struct.ListNode* %23)
%39 = call i32 @printList(%struct.ListNode* %24)
%40 = call i32 @printList(%struct.ListNode* %25)
%41 = call i32 @printList(%struct.ListNode* %26)
%42 = call i32 @printList(%struct.ListNode* %27)
%43 = call i32 @printList(%struct.ListNode* %28)
%44 = call i32 @printList(%struct.ListNode* %29)
%45 = call i32 @printList(%struct.ListNode* %30)
%46 = call i32 @printList(%struct.ListNode* %31)
%47 = call i32 @printList(%struct.ListNode* %32)
%48 = call i32 @printList(%struct.ListNode* %33)
%49 = call i32 @freeList(%struct.ListNode* %19)
%50 = call i32 @freeList(%struct.ListNode* %20)
%51 = call i32 @freeList(%struct.ListNode* %21)
%52 = call i32 @freeList(%struct.ListNode* %22)
%53 = call i32 @freeList(%struct.ListNode* %23)
%54 = call i32 @freeList(%struct.ListNode* %24)
%55 = call i32 @freeList(%struct.ListNode* %25)
%56 = call i32 @freeList(%struct.ListNode* %26)
%57 = call i32 @freeList(%struct.ListNode* %27)
%58 = call i32 @freeList(%struct.ListNode* %28)
%59 = call i32 @freeList(%struct.ListNode* %29)
%60 = call i32 @freeList(%struct.ListNode* %30)
%61 = call i32 @freeList(%struct.ListNode* %31)
%62 = call i32 @freeList(%struct.ListNode* %32)
%63 = call i32 @freeList(%struct.ListNode* %33)
ret i32 0
}
| <main>:
push %rbp
mov %rsp,%rbp
sub $0xc0,%rsp
movl $0x0,-0x4(%rbp)
lea -0x40(%rbp),%rdi
lea 0xe93(%rip),%rsi
mov $0x3c,%edx
call 1050 <memcpy@plt>
lea -0x40(%rbp),%rdi
xor %esi,%esi
call 1060 <createList@plt>
mov %rax,-0x48(%rbp)
lea -0x40(%rbp),%rdi
mov $0x1,%esi
call 1060 <createList@plt>
mov %rax,-0x50(%rbp)
lea -0x40(%rbp),%rdi
mov $0x2,%esi
call 1060 <createList@plt>
mov %rax,-0x58(%rbp)
lea -0x40(%rbp),%rdi
mov $0x3,%esi
call 1060 <createList@plt>
mov %rax,-0x60(%rbp)
lea -0x40(%rbp),%rdi
mov $0x4,%esi
call 1060 <createList@plt>
mov %rax,-0x68(%rbp)
lea -0x40(%rbp),%rdi
mov $0x5,%esi
call 1060 <createList@plt>
mov %rax,-0x70(%rbp)
lea -0x40(%rbp),%rdi
mov $0x6,%esi
call 1060 <createList@plt>
mov %rax,-0x78(%rbp)
lea -0x40(%rbp),%rdi
mov $0x7,%esi
call 1060 <createList@plt>
mov %rax,-0x80(%rbp)
lea -0x40(%rbp),%rdi
mov $0x8,%esi
call 1060 <createList@plt>
mov %rax,-0x88(%rbp)
lea -0x40(%rbp),%rdi
mov $0x9,%esi
call 1060 <createList@plt>
mov %rax,-0x90(%rbp)
lea -0x40(%rbp),%rdi
mov $0xa,%esi
call 1060 <createList@plt>
mov %rax,-0x98(%rbp)
lea -0x40(%rbp),%rdi
mov $0xb,%esi
call 1060 <createList@plt>
mov %rax,-0xa0(%rbp)
lea -0x40(%rbp),%rdi
mov $0xc,%esi
call 1060 <createList@plt>
mov %rax,-0xa8(%rbp)
lea -0x40(%rbp),%rdi
mov $0xd,%esi
call 1060 <createList@plt>
mov %rax,-0xb0(%rbp)
lea -0x40(%rbp),%rdi
mov $0xe,%esi
call 1060 <createList@plt>
mov %rax,-0xb8(%rbp)
mov -0x48(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0x48(%rbp)
mov -0x50(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0x50(%rbp)
mov -0x58(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0x58(%rbp)
mov -0x60(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0x60(%rbp)
mov -0x68(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0x68(%rbp)
mov -0x70(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0x70(%rbp)
mov -0x78(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0x78(%rbp)
mov -0x80(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0x80(%rbp)
mov -0x88(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0x88(%rbp)
mov -0x90(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0x90(%rbp)
mov -0x98(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0x98(%rbp)
mov -0xa0(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0xa0(%rbp)
mov -0xa8(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0xa8(%rbp)
mov -0xb0(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0xb0(%rbp)
mov -0xb8(%rbp),%rdi
call 1040 <swapPairs@plt>
mov %rax,-0xb8(%rbp)
mov -0x48(%rbp),%rdi
call 1070 <printList@plt>
mov -0x50(%rbp),%rdi
call 1070 <printList@plt>
mov -0x58(%rbp),%rdi
call 1070 <printList@plt>
mov -0x60(%rbp),%rdi
call 1070 <printList@plt>
mov -0x68(%rbp),%rdi
call 1070 <printList@plt>
mov -0x70(%rbp),%rdi
call 1070 <printList@plt>
mov -0x78(%rbp),%rdi
call 1070 <printList@plt>
mov -0x80(%rbp),%rdi
call 1070 <printList@plt>
mov -0x88(%rbp),%rdi
call 1070 <printList@plt>
mov -0x90(%rbp),%rdi
call 1070 <printList@plt>
mov -0x98(%rbp),%rdi
call 1070 <printList@plt>
mov -0xa0(%rbp),%rdi
call 1070 <printList@plt>
mov -0xa8(%rbp),%rdi
call 1070 <printList@plt>
mov -0xb0(%rbp),%rdi
call 1070 <printList@plt>
mov -0xb8(%rbp),%rdi
call 1070 <printList@plt>
mov -0x48(%rbp),%rdi
call 1030 <freeList@plt>
mov -0x50(%rbp),%rdi
call 1030 <freeList@plt>
mov -0x58(%rbp),%rdi
call 1030 <freeList@plt>
mov -0x60(%rbp),%rdi
call 1030 <freeList@plt>
mov -0x68(%rbp),%rdi
call 1030 <freeList@plt>
mov -0x70(%rbp),%rdi
call 1030 <freeList@plt>
mov -0x78(%rbp),%rdi
call 1030 <freeList@plt>
mov -0x80(%rbp),%rdi
call 1030 <freeList@plt>
mov -0x88(%rbp),%rdi
call 1030 <freeList@plt>
mov -0x90(%rbp),%rdi
call 1030 <freeList@plt>
mov -0x98(%rbp),%rdi
call 1030 <freeList@plt>
mov -0xa0(%rbp),%rdi
call 1030 <freeList@plt>
mov -0xa8(%rbp),%rdi
call 1030 <freeList@plt>
mov -0xb0(%rbp),%rdi
call 1030 <freeList@plt>
mov -0xb8(%rbp),%rdi
call 1030 <freeList@plt>
xor %eax,%eax
add $0xc0,%rsp
pop %rbp
ret
| <main>:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xd0,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x1,-0x50(%rbp)
movl $0x2,-0x4c(%rbp)
movl $0x3,-0x48(%rbp)
movl $0x4,-0x44(%rbp)
movl $0x5,-0x40(%rbp)
movl $0x6,-0x3c(%rbp)
movl $0x7,-0x38(%rbp)
movl $0x8,-0x34(%rbp)
movl $0x9,-0x30(%rbp)
movl $0xa,-0x2c(%rbp)
movl $0xb,-0x28(%rbp)
movl $0xc,-0x24(%rbp)
movl $0xd,-0x20(%rbp)
movl $0xe,-0x1c(%rbp)
movl $0xf,-0x18(%rbp)
lea -0x50(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0xc8(%rbp)
lea -0x50(%rbp),%rax
mov $0x1,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0xc0(%rbp)
lea -0x50(%rbp),%rax
mov $0x2,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0xb8(%rbp)
lea -0x50(%rbp),%rax
mov $0x3,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0xb0(%rbp)
lea -0x50(%rbp),%rax
mov $0x4,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0xa8(%rbp)
lea -0x50(%rbp),%rax
mov $0x5,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0xa0(%rbp)
lea -0x50(%rbp),%rax
mov $0x6,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0x98(%rbp)
lea -0x50(%rbp),%rax
mov $0x7,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0x90(%rbp)
lea -0x50(%rbp),%rax
mov $0x8,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0x88(%rbp)
lea -0x50(%rbp),%rax
mov $0x9,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0x80(%rbp)
lea -0x50(%rbp),%rax
mov $0xa,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0x78(%rbp)
lea -0x50(%rbp),%rax
mov $0xb,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0x70(%rbp)
lea -0x50(%rbp),%rax
mov $0xc,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0x68(%rbp)
lea -0x50(%rbp),%rax
mov $0xd,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0x60(%rbp)
lea -0x50(%rbp),%rax
mov $0xe,%esi
mov %rax,%rdi
call 10c0 <createList@plt>
mov %rax,-0x58(%rbp)
mov -0xc8(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0xc8(%rbp)
mov -0xc0(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0xc0(%rbp)
mov -0xb8(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0xb8(%rbp)
mov -0xb0(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0xb0(%rbp)
mov -0xa8(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0xa8(%rbp)
mov -0xa0(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0xa0(%rbp)
mov -0x98(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0x98(%rbp)
mov -0x90(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0x90(%rbp)
mov -0x88(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0x88(%rbp)
mov -0x80(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0x80(%rbp)
mov -0x78(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0x78(%rbp)
mov -0x70(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0x70(%rbp)
mov -0x68(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0x68(%rbp)
mov -0x60(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0x60(%rbp)
mov -0x58(%rbp),%rax
mov %rax,%rdi
call 10b0 <swapPairs@plt>
mov %rax,-0x58(%rbp)
mov -0xc8(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0xc0(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0xb8(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0xb0(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0xa8(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0xa0(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0x98(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0x90(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0x88(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0x80(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0x78(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0x70(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0x68(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0x60(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0x58(%rbp),%rax
mov %rax,%rdi
call 10d0 <printList@plt>
mov -0xc8(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0xc0(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0xb8(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0xb0(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0xa8(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0xa0(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0x98(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0x90(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0x88(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0x80(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0x78(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0x70(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0x68(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0x60(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov -0x58(%rbp),%rax
mov %rax,%rdi
call 1090 <freeList@plt>
mov $0x0,%eax
mov -0x8(%rbp),%rdx
sub %fs:0x28,%rdx
je 1653 <main+0x4ba>
call 10a0 <__stack_chk_fail@plt>
leave
ret
| %struct.ListNode = type { i32 }
@__const.main.arr = [15 x i32] [i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15]
define i32 @main() {
%1 = alloca i32
%2 = alloca [15 x i32]
%3 = alloca %struct.ListNode*
%4 = alloca %struct.ListNode*
%5 = alloca %struct.ListNode*
%6 = alloca %struct.ListNode*
%7 = alloca %struct.ListNode*
%8 = alloca %struct.ListNode*
%9 = alloca %struct.ListNode*
%10 = alloca %struct.ListNode*
%11 = alloca %struct.ListNode*
%12 = alloca %struct.ListNode*
%13 = alloca %struct.ListNode*
%14 = alloca %struct.ListNode*
%15 = alloca %struct.ListNode*
%16 = alloca %struct.ListNode*
%17 = alloca %struct.ListNode*
store i32 0, i32* %1
%18 = bitcast [15 x i32]* %2 to i8*
%19 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%20 = call %struct.ListNode* @createList(i32* %19, i32 0)
store %struct.ListNode* %20, %struct.ListNode** %3
%21 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%22 = call %struct.ListNode* @createList(i32* %21, i32 1)
store %struct.ListNode* %22, %struct.ListNode** %4
%23 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%24 = call %struct.ListNode* @createList(i32* %23, i32 2)
store %struct.ListNode* %24, %struct.ListNode** %5
%25 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%26 = call %struct.ListNode* @createList(i32* %25, i32 3)
store %struct.ListNode* %26, %struct.ListNode** %6
%27 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%28 = call %struct.ListNode* @createList(i32* %27, i32 4)
store %struct.ListNode* %28, %struct.ListNode** %7
%29 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%30 = call %struct.ListNode* @createList(i32* %29, i32 5)
store %struct.ListNode* %30, %struct.ListNode** %8
%31 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%32 = call %struct.ListNode* @createList(i32* %31, i32 6)
store %struct.ListNode* %32, %struct.ListNode** %9
%33 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%34 = call %struct.ListNode* @createList(i32* %33, i32 7)
store %struct.ListNode* %34, %struct.ListNode** %10
%35 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%36 = call %struct.ListNode* @createList(i32* %35, i32 8)
store %struct.ListNode* %36, %struct.ListNode** %11
%37 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%38 = call %struct.ListNode* @createList(i32* %37, i32 9)
store %struct.ListNode* %38, %struct.ListNode** %12
%39 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%40 = call %struct.ListNode* @createList(i32* %39, i32 10)
store %struct.ListNode* %40, %struct.ListNode** %13
%41 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%42 = call %struct.ListNode* @createList(i32* %41, i32 11)
store %struct.ListNode* %42, %struct.ListNode** %14
%43 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%44 = call %struct.ListNode* @createList(i32* %43, i32 12)
store %struct.ListNode* %44, %struct.ListNode** %15
%45 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%46 = call %struct.ListNode* @createList(i32* %45, i32 13)
store %struct.ListNode* %46, %struct.ListNode** %16
%47 = getelementptr inbounds [15 x i32], [15 x i32]* %2, i64 0, i64 0
%48 = call %struct.ListNode* @createList(i32* %47, i32 14)
store %struct.ListNode* %48, %struct.ListNode** %17
%49 = load %struct.ListNode*, %struct.ListNode** %3
%50 = call %struct.ListNode* @swapPairs(%struct.ListNode* %49)
store %struct.ListNode* %50, %struct.ListNode** %3
%51 = load %struct.ListNode*, %struct.ListNode** %4
%52 = call %struct.ListNode* @swapPairs(%struct.ListNode* %51)
store %struct.ListNode* %52, %struct.ListNode** %4
%53 = load %struct.ListNode*, %struct.ListNode** %5
%54 = call %struct.ListNode* @swapPairs(%struct.ListNode* %53)
store %struct.ListNode* %54, %struct.ListNode** %5
%55 = load %struct.ListNode*, %struct.ListNode** %6
%56 = call %struct.ListNode* @swapPairs(%struct.ListNode* %55)
store %struct.ListNode* %56, %struct.ListNode** %6
%57 = load %struct.ListNode*, %struct.ListNode** %7
%58 = call %struct.ListNode* @swapPairs(%struct.ListNode* %57)
store %struct.ListNode* %58, %struct.ListNode** %7
%59 = load %struct.ListNode*, %struct.ListNode** %8
%60 = call %struct.ListNode* @swapPairs(%struct.ListNode* %59)
store %struct.ListNode* %60, %struct.ListNode** %8
%61 = load %struct.ListNode*, %struct.ListNode** %9
%62 = call %struct.ListNode* @swapPairs(%struct.ListNode* %61)
store %struct.ListNode* %62, %struct.ListNode** %9
%63 = load %struct.ListNode*, %struct.ListNode** %10
%64 = call %struct.ListNode* @swapPairs(%struct.ListNode* %63)
store %struct.ListNode* %64, %struct.ListNode** %10
%65 = load %struct.ListNode*, %struct.ListNode** %11
%66 = call %struct.ListNode* @swapPairs(%struct.ListNode* %65)
store %struct.ListNode* %66, %struct.ListNode** %11
%67 = load %struct.ListNode*, %struct.ListNode** %12
%68 = call %struct.ListNode* @swapPairs(%struct.ListNode* %67)
store %struct.ListNode* %68, %struct.ListNode** %12
%69 = load %struct.ListNode*, %struct.ListNode** %13
%70 = call %struct.ListNode* @swapPairs(%struct.ListNode* %69)
store %struct.ListNode* %70, %struct.ListNode** %13
%71 = load %struct.ListNode*, %struct.ListNode** %14
%72 = call %struct.ListNode* @swapPairs(%struct.ListNode* %71)
store %struct.ListNode* %72, %struct.ListNode** %14
%73 = load %struct.ListNode*, %struct.ListNode** %15
%74 = call %struct.ListNode* @swapPairs(%struct.ListNode* %73)
store %struct.ListNode* %74, %struct.ListNode** %15
%75 = load %struct.ListNode*, %struct.ListNode** %16
%76 = call %struct.ListNode* @swapPairs(%struct.ListNode* %75)
store %struct.ListNode* %76, %struct.ListNode** %16
%77 = load %struct.ListNode*, %struct.ListNode** %17
%78 = call %struct.ListNode* @swapPairs(%struct.ListNode* %77)
store %struct.ListNode* %78, %struct.ListNode** %17
%79 = load %struct.ListNode*, %struct.ListNode** %3
%80 = call i32 @printList(%struct.ListNode* %79)
%81 = load %struct.ListNode*, %struct.ListNode** %4
%82 = call i32 @printList(%struct.ListNode* %81)
%83 = load %struct.ListNode*, %struct.ListNode** %5
%84 = call i32 @printList(%struct.ListNode* %83)
%85 = load %struct.ListNode*, %struct.ListNode** %6
%86 = call i32 @printList(%struct.ListNode* %85)
%87 = load %struct.ListNode*, %struct.ListNode** %7
%88 = call i32 @printList(%struct.ListNode* %87)
%89 = load %struct.ListNode*, %struct.ListNode** %8
%90 = call i32 @printList(%struct.ListNode* %89)
%91 = load %struct.ListNode*, %struct.ListNode** %9
%92 = call i32 @printList(%struct.ListNode* %91)
%93 = load %struct.ListNode*, %struct.ListNode** %10
%94 = call i32 @printList(%struct.ListNode* %93)
%95 = load %struct.ListNode*, %struct.ListNode** %11
%96 = call i32 @printList(%struct.ListNode* %95)
%97 = load %struct.ListNode*, %struct.ListNode** %12
%98 = call i32 @printList(%struct.ListNode* %97)
%99 = load %struct.ListNode*, %struct.ListNode** %13
%100 = call i32 @printList(%struct.ListNode* %99)
%101 = load %struct.ListNode*, %struct.ListNode** %14
%102 = call i32 @printList(%struct.ListNode* %101)
%103 = load %struct.ListNode*, %struct.ListNode** %15
%104 = call i32 @printList(%struct.ListNode* %103)
%105 = load %struct.ListNode*, %struct.ListNode** %16
%106 = call i32 @printList(%struct.ListNode* %105)
%107 = load %struct.ListNode*, %struct.ListNode** %17
%108 = call i32 @printList(%struct.ListNode* %107)
%109 = load %struct.ListNode*, %struct.ListNode** %3
%110 = call i32 @freeList(%struct.ListNode* %109)
%111 = load %struct.ListNode*, %struct.ListNode** %4
%112 = call i32 @freeList(%struct.ListNode* %111)
%113 = load %struct.ListNode*, %struct.ListNode** %5
%114 = call i32 @freeList(%struct.ListNode* %113)
%115 = load %struct.ListNode*, %struct.ListNode** %6
%116 = call i32 @freeList(%struct.ListNode* %115)
%117 = load %struct.ListNode*, %struct.ListNode** %7
%118 = call i32 @freeList(%struct.ListNode* %117)
%119 = load %struct.ListNode*, %struct.ListNode** %8
%120 = call i32 @freeList(%struct.ListNode* %119)
%121 = load %struct.ListNode*, %struct.ListNode** %9
%122 = call i32 @freeList(%struct.ListNode* %121)
%123 = load %struct.ListNode*, %struct.ListNode** %10
%124 = call i32 @freeList(%struct.ListNode* %123)
%125 = load %struct.ListNode*, %struct.ListNode** %11
%126 = call i32 @freeList(%struct.ListNode* %125)
%127 = load %struct.ListNode*, %struct.ListNode** %12
%128 = call i32 @freeList(%struct.ListNode* %127)
%129 = load %struct.ListNode*, %struct.ListNode** %13
%130 = call i32 @freeList(%struct.ListNode* %129)
%131 = load %struct.ListNode*, %struct.ListNode** %14
%132 = call i32 @freeList(%struct.ListNode* %131)
%133 = load %struct.ListNode*, %struct.ListNode** %15
%134 = call i32 @freeList(%struct.ListNode* %133)
%135 = load %struct.ListNode*, %struct.ListNode** %16
%136 = call i32 @freeList(%struct.ListNode* %135)
%137 = load %struct.ListNode*, %struct.ListNode** %17
%138 = call i32 @freeList(%struct.ListNode* %137)
ret i32 0
}
| <main>:
push %rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0xd8,%rsp
movups 0xed4(%rip),%xmm0
movups %xmm0,0xbc(%rsp)
movaps 0xeb9(%rip),%xmm0
movaps %xmm0,0xb0(%rsp)
movaps 0xe9a(%rip),%xmm0
movaps %xmm0,0xa0(%rsp)
movaps 0xe7b(%rip),%xmm0
movaps %xmm0,0x90(%rsp)
lea 0x90(%rsp),%rbx
mov %rbx,%rdi
xor %esi,%esi
call 1050 <createList@plt>
mov %rax,%r14
mov %rbx,%rdi
mov $0x1,%esi
call 1050 <createList@plt>
mov %rax,%r15
mov %rbx,%rdi
mov $0x2,%esi
call 1050 <createList@plt>
mov %rax,%rbp
mov %rbx,%rdi
mov $0x3,%esi
call 1050 <createList@plt>
mov %rax,%r12
mov %rbx,%rdi
mov $0x4,%esi
call 1050 <createList@plt>
mov %rax,%r13
mov %rbx,%rdi
mov $0x5,%esi
call 1050 <createList@plt>
mov %rax,0x20(%rsp)
mov %rbx,%rdi
mov $0x6,%esi
call 1050 <createList@plt>
mov %rax,0x18(%rsp)
mov %rbx,%rdi
mov $0x7,%esi
call 1050 <createList@plt>
mov %rax,0x10(%rsp)
mov %rbx,%rdi
mov $0x8,%esi
call 1050 <createList@plt>
mov %rax,0x8(%rsp)
mov %rbx,%rdi
mov $0x9,%esi
call 1050 <createList@plt>
mov %rax,(%rsp)
mov %rbx,%rdi
mov $0xa,%esi
call 1050 <createList@plt>
mov %rax,0x88(%rsp)
mov %rbx,%rdi
mov $0xb,%esi
call 1050 <createList@plt>
mov %rax,0x80(%rsp)
mov %rbx,%rdi
mov $0xc,%esi
call 1050 <createList@plt>
mov %rax,0x78(%rsp)
mov %rbx,%rdi
mov $0xd,%esi
call 1050 <createList@plt>
mov %rax,0x70(%rsp)
mov %rbx,%rdi
mov $0xe,%esi
call 1050 <createList@plt>
mov %rax,0x68(%rsp)
mov %r14,%rdi
call 1040 <swapPairs@plt>
mov %rax,%rbx
mov %rax,0x40(%rsp)
mov %r15,%rdi
call 1040 <swapPairs@plt>
mov %rax,0x60(%rsp)
mov %rbp,%rdi
call 1040 <swapPairs@plt>
mov %rax,%rbp
mov %r12,%rdi
call 1040 <swapPairs@plt>
mov %rax,%r14
mov %r13,%rdi
call 1040 <swapPairs@plt>
mov %rax,%r15
mov %rax,0x38(%rsp)
mov 0x20(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,%r12
mov %rax,0x30(%rsp)
mov 0x18(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x58(%rsp)
mov 0x10(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x50(%rsp)
mov 0x8(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,%r13
mov %rax,0x28(%rsp)
mov (%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x48(%rsp)
mov 0x88(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x20(%rsp)
mov 0x80(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x18(%rsp)
mov 0x78(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x10(%rsp)
mov 0x70(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,0x8(%rsp)
mov 0x68(%rsp),%rdi
call 1040 <swapPairs@plt>
mov %rax,(%rsp)
mov %rbx,%rdi
call 1060 <printList@plt>
mov 0x60(%rsp),%rbx
mov %rbx,%rdi
call 1060 <printList@plt>
mov %rbp,%rdi
call 1060 <printList@plt>
mov %r14,%rdi
call 1060 <printList@plt>
mov %r15,%rdi
call 1060 <printList@plt>
mov %r12,%rdi
call 1060 <printList@plt>
mov 0x58(%rsp),%r15
mov %r15,%rdi
call 1060 <printList@plt>
mov 0x50(%rsp),%r12
mov %r12,%rdi
call 1060 <printList@plt>
mov %r13,%rdi
call 1060 <printList@plt>
mov 0x48(%rsp),%r13
mov %r13,%rdi
call 1060 <printList@plt>
mov 0x20(%rsp),%rdi
call 1060 <printList@plt>
mov 0x18(%rsp),%rdi
call 1060 <printList@plt>
mov 0x10(%rsp),%rdi
call 1060 <printList@plt>
mov 0x8(%rsp),%rdi
call 1060 <printList@plt>
mov (%rsp),%rdi
call 1060 <printList@plt>
mov 0x40(%rsp),%rdi
call 1030 <freeList@plt>
mov %rbx,%rdi
call 1030 <freeList@plt>
mov %rbp,%rdi
call 1030 <freeList@plt>
mov %r14,%rdi
call 1030 <freeList@plt>
mov 0x38(%rsp),%rdi
call 1030 <freeList@plt>
mov 0x30(%rsp),%rdi
call 1030 <freeList@plt>
mov %r15,%rdi
call 1030 <freeList@plt>
mov %r12,%rdi
call 1030 <freeList@plt>
mov 0x28(%rsp),%rdi
call 1030 <freeList@plt>
mov %r13,%rdi
call 1030 <freeList@plt>
mov 0x20(%rsp),%rdi
call 1030 <freeList@plt>
mov 0x18(%rsp),%rdi
call 1030 <freeList@plt>
mov 0x10(%rsp),%rdi
call 1030 <freeList@plt>
mov 0x8(%rsp),%rdi
call 1030 <freeList@plt>
mov (%rsp),%rdi
call 1030 <freeList@plt>
xor %eax,%eax
add $0xd8,%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
ret
| <main>:
endbr64
push %r15
xor %esi,%esi
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
movdqa 0xf01(%rip),%xmm0
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea 0x50(%rsp),%rbp
mov 0xf12(%rip),%rax
movl $0xf,0x88(%rsp)
movaps %xmm0,0x50(%rsp)
movdqa 0xeda(%rip),%xmm0
mov %rbp,%rdi
mov %rax,0x80(%rsp)
movaps %xmm0,0x60(%rsp)
movdqa 0xed2(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x1,%esi
mov %rax,0x48(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x2,%esi
mov %rax,(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x3,%esi
mov %rax,0x40(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x4,%esi
mov %rax,0x38(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x5,%esi
mov %rax,0x30(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x6,%esi
mov %rax,0x28(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x7,%esi
mov %rax,%rbx
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x8,%esi
mov %rax,%r15
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0x9,%esi
mov %rax,%r14
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0xa,%esi
mov %rax,%r13
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0xb,%esi
mov %rax,0x8(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0xc,%esi
mov %rax,0x10(%rsp)
call 10c0 <createList@plt>
mov %rbp,%rdi
mov $0xd,%esi
mov %rax,0x18(%rsp)
call 10c0 <createList@plt>
mov $0xe,%esi
mov %rbp,%rdi
mov %rax,%r12
call 10c0 <createList@plt>
mov 0x48(%rsp),%rdi
mov %rax,0x20(%rsp)
call 10b0 <swapPairs@plt>
mov (%rsp),%rdi
mov %rax,%rbp
call 10b0 <swapPairs@plt>
mov 0x40(%rsp),%rdi
mov %rax,(%rsp)
call 10b0 <swapPairs@plt>
mov 0x38(%rsp),%rdi
mov %rax,0x40(%rsp)
call 10b0 <swapPairs@plt>
mov 0x30(%rsp),%rdi
mov %rax,0x38(%rsp)
call 10b0 <swapPairs@plt>
mov 0x28(%rsp),%rdi
mov %rax,0x30(%rsp)
call 10b0 <swapPairs@plt>
mov %rbx,%rdi
mov %rax,0x28(%rsp)
call 10b0 <swapPairs@plt>
mov %r15,%rdi
mov %rax,%rbx
call 10b0 <swapPairs@plt>
mov %r14,%rdi
mov %rax,%r15
call 10b0 <swapPairs@plt>
mov %r13,%rdi
mov %rax,%r14
call 10b0 <swapPairs@plt>
mov 0x8(%rsp),%rdi
mov %rax,%r13
call 10b0 <swapPairs@plt>
mov 0x10(%rsp),%rdi
mov %rax,0x8(%rsp)
call 10b0 <swapPairs@plt>
mov 0x18(%rsp),%rdi
mov %rax,0x10(%rsp)
call 10b0 <swapPairs@plt>
mov %r12,%rdi
mov %rax,0x18(%rsp)
call 10b0 <swapPairs@plt>
mov 0x20(%rsp),%rdi
mov %rax,%r12
call 10b0 <swapPairs@plt>
mov %rbp,%rdi
mov %rax,0x20(%rsp)
call 10d0 <printList@plt>
mov (%rsp),%rdi
call 10d0 <printList@plt>
mov 0x40(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x38(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x30(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x28(%rsp),%rdi
call 10d0 <printList@plt>
mov %rbx,%rdi
call 10d0 <printList@plt>
mov %r15,%rdi
call 10d0 <printList@plt>
mov %r14,%rdi
call 10d0 <printList@plt>
mov %r13,%rdi
call 10d0 <printList@plt>
mov 0x8(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x10(%rsp),%rdi
call 10d0 <printList@plt>
mov 0x18(%rsp),%rdi
call 10d0 <printList@plt>
mov %r12,%rdi
call 10d0 <printList@plt>
mov 0x20(%rsp),%rdi
call 10d0 <printList@plt>
mov %rbp,%rdi
call 1090 <freeList@plt>
mov (%rsp),%rdi
call 1090 <freeList@plt>
mov 0x40(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x38(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x30(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x28(%rsp),%rdi
call 1090 <freeList@plt>
mov %rbx,%rdi
call 1090 <freeList@plt>
mov %r15,%rdi
call 1090 <freeList@plt>
mov %r14,%rdi
call 1090 <freeList@plt>
mov %r13,%rdi
call 1090 <freeList@plt>
mov 0x8(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x10(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x18(%rsp),%rdi
call 1090 <freeList@plt>
mov %r12,%rdi
call 1090 <freeList@plt>
mov 0x20(%rsp),%rdi
call 1090 <freeList@plt>
mov 0x98(%rsp),%rax
sub %fs:0x28,%rax
jne 1450 <main+0x370>
add $0xa8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
ret
call 10a0 <__stack_chk_fail@plt>
cs nopw 0x0(%rax,%rax,1)
nop
| %struct.ListNode = type { i32 }
@__const.main.arr = [15 x i32] [i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15]
define i32 @main() {
%1 = alloca [15 x i32]
%2 = bitcast [15 x i32]* %1 to i8*
%3 = getelementptr inbounds [15 x i32], [15 x i32]* %1, i64 0, i64 0
%4 = call %struct.ListNode* @createList(i32* %3, i32 0)
%5 = call %struct.ListNode* @createList(i32* %3, i32 1)
%6 = call %struct.ListNode* @createList(i32* %3, i32 2)
%7 = call %struct.ListNode* @createList(i32* %3, i32 3)
%8 = call %struct.ListNode* @createList(i32* %3, i32 4)
%9 = call %struct.ListNode* @createList(i32* %3, i32 5)
%10 = call %struct.ListNode* @createList(i32* %3, i32 6)
%11 = call %struct.ListNode* @createList(i32* %3, i32 7)
%12 = call %struct.ListNode* @createList(i32* %3, i32 8)
%13 = call %struct.ListNode* @createList(i32* %3, i32 9)
%14 = call %struct.ListNode* @createList(i32* %3, i32 10)
%15 = call %struct.ListNode* @createList(i32* %3, i32 11)
%16 = call %struct.ListNode* @createList(i32* %3, i32 12)
%17 = call %struct.ListNode* @createList(i32* %3, i32 13)
%18 = call %struct.ListNode* @createList(i32* %3, i32 14)
%19 = call %struct.ListNode* @swapPairs(%struct.ListNode* %4)
%20 = call %struct.ListNode* @swapPairs(%struct.ListNode* %5)
%21 = call %struct.ListNode* @swapPairs(%struct.ListNode* %6)
%22 = call %struct.ListNode* @swapPairs(%struct.ListNode* %7)
%23 = call %struct.ListNode* @swapPairs(%struct.ListNode* %8)
%24 = call %struct.ListNode* @swapPairs(%struct.ListNode* %9)
%25 = call %struct.ListNode* @swapPairs(%struct.ListNode* %10)
%26 = call %struct.ListNode* @swapPairs(%struct.ListNode* %11)
%27 = call %struct.ListNode* @swapPairs(%struct.ListNode* %12)
%28 = call %struct.ListNode* @swapPairs(%struct.ListNode* %13)
%29 = call %struct.ListNode* @swapPairs(%struct.ListNode* %14)
%30 = call %struct.ListNode* @swapPairs(%struct.ListNode* %15)
%31 = call %struct.ListNode* @swapPairs(%struct.ListNode* %16)
%32 = call %struct.ListNode* @swapPairs(%struct.ListNode* %17)
%33 = call %struct.ListNode* @swapPairs(%struct.ListNode* %18)
%34 = call i32 @printList(%struct.ListNode* %19)
%35 = call i32 @printList(%struct.ListNode* %20)
%36 = call i32 @printList(%struct.ListNode* %21)
%37 = call i32 @printList(%struct.ListNode* %22)
%38 = call i32 @printList(%struct.ListNode* %23)
%39 = call i32 @printList(%struct.ListNode* %24)
%40 = call i32 @printList(%struct.ListNode* %25)
%41 = call i32 @printList(%struct.ListNode* %26)
%42 = call i32 @printList(%struct.ListNode* %27)
%43 = call i32 @printList(%struct.ListNode* %28)
%44 = call i32 @printList(%struct.ListNode* %29)
%45 = call i32 @printList(%struct.ListNode* %30)
%46 = call i32 @printList(%struct.ListNode* %31)
%47 = call i32 @printList(%struct.ListNode* %32)
%48 = call i32 @printList(%struct.ListNode* %33)
%49 = call i32 @freeList(%struct.ListNode* %19)
%50 = call i32 @freeList(%struct.ListNode* %20)
%51 = call i32 @freeList(%struct.ListNode* %21)
%52 = call i32 @freeList(%struct.ListNode* %22)
%53 = call i32 @freeList(%struct.ListNode* %23)
%54 = call i32 @freeList(%struct.ListNode* %24)
%55 = call i32 @freeList(%struct.ListNode* %25)
%56 = call i32 @freeList(%struct.ListNode* %26)
%57 = call i32 @freeList(%struct.ListNode* %27)
%58 = call i32 @freeList(%struct.ListNode* %28)
%59 = call i32 @freeList(%struct.ListNode* %29)
%60 = call i32 @freeList(%struct.ListNode* %30)
%61 = call i32 @freeList(%struct.ListNode* %31)
%62 = call i32 @freeList(%struct.ListNode* %32)
%63 = call i32 @freeList(%struct.ListNode* %33)
ret i32 0
}
| 6 | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
struct ListNode {int dummy; } ;
/* Variables and functions */
struct ListNode* createList (int*,int) ;
int /*<<< orphan*/ freeList (struct ListNode*) ;
int /*<<< orphan*/ printList (struct ListNode*) ;
struct ListNode* swapPairs (struct ListNode*) ;
| int main(void) {
int arr[15] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
struct ListNode *l0 = createList(arr, 0);
struct ListNode *l1 = createList(arr, 1);
struct ListNode *l2 = createList(arr, 2);
struct ListNode *l3 = createList(arr, 3);
struct ListNode *l4 = createList(arr, 4);
struct ListNode *l5 = createList(arr, 5);
struct ListNode *l6 = createList(arr, 6);
struct ListNode *l7 = createList(arr, 7);
struct ListNode *l8 = createList(arr, 8);
struct ListNode *l9 = createList(arr, 9);
struct ListNode *l10 = createList(arr, 10);
struct ListNode *l11 = createList(arr, 11);
struct ListNode *l12 = createList(arr, 12);
struct ListNode *l13 = createList(arr, 13);
struct ListNode *l14 = createList(arr, 14);
l0 = swapPairs(l0);
l1 = swapPairs(l1);
l2 = swapPairs(l2);
l3 = swapPairs(l3);
l4 = swapPairs(l4);
l5 = swapPairs(l5);
l6 = swapPairs(l6);
l7 = swapPairs(l7);
l8 = swapPairs(l8);
l9 = swapPairs(l9);
l10 = swapPairs(l10);
l11 = swapPairs(l11);
l12 = swapPairs(l12);
l13 = swapPairs(l13);
l14 = swapPairs(l14);
printList(l0);
printList(l1);
printList(l2);
printList(l3);
printList(l4);
printList(l5);
printList(l6);
printList(l7);
printList(l8);
printList(l9);
printList(l10);
printList(l11);
printList(l12);
printList(l13);
printList(l14);
freeList(l0);
freeList(l1);
freeList(l2);
freeList(l3);
freeList(l4);
freeList(l5);
freeList(l6);
freeList(l7);
freeList(l8);
freeList(l9);
freeList(l10);
freeList(l11);
freeList(l12);
freeList(l13);
freeList(l14);
return 0;
} | main | #define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
struct ListNode {
int dummy;
};
/* Variables and functions */
struct ListNode *createList(int *, int);
int /*<<< orphan*/ freeList(struct ListNode *);
int /*<<< orphan*/ printList(struct ListNode *);
struct ListNode *swapPairs(struct ListNode *);
int main(void) {
int arr[15] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
struct ListNode *l0 = createList(arr, 0);
struct ListNode *l1 = createList(arr, 1);
struct ListNode *l2 = createList(arr, 2);
struct ListNode *l3 = createList(arr, 3);
struct ListNode *l4 = createList(arr, 4);
struct ListNode *l5 = createList(arr, 5);
struct ListNode *l6 = createList(arr, 6);
struct ListNode *l7 = createList(arr, 7);
struct ListNode *l8 = createList(arr, 8);
struct ListNode *l9 = createList(arr, 9);
struct ListNode *l10 = createList(arr, 10);
struct ListNode *l11 = createList(arr, 11);
struct ListNode *l12 = createList(arr, 12);
struct ListNode *l13 = createList(arr, 13);
struct ListNode *l14 = createList(arr, 14);
l0 = swapPairs(l0);
l1 = swapPairs(l1);
l2 = swapPairs(l2);
l3 = swapPairs(l3);
l4 = swapPairs(l4);
l5 = swapPairs(l5);
l6 = swapPairs(l6);
l7 = swapPairs(l7);
l8 = swapPairs(l8);
l9 = swapPairs(l9);
l10 = swapPairs(l10);
l11 = swapPairs(l11);
l12 = swapPairs(l12);
l13 = swapPairs(l13);
l14 = swapPairs(l14);
printList(l0);
printList(l1);
printList(l2);
printList(l3);
printList(l4);
printList(l5);
printList(l6);
printList(l7);
printList(l8);
printList(l9);
printList(l10);
printList(l11);
printList(l12);
printList(l13);
printList(l14);
freeList(l0);
freeList(l1);
freeList(l2);
freeList(l3);
freeList(l4);
freeList(l5);
freeList(l6);
freeList(l7);
freeList(l8);
freeList(l9);
freeList(l10);
freeList(l11);
freeList(l12);
freeList(l13);
freeList(l14);
return 0;
}
|
<MSIM_OPT_Getopt>:
push %rax
xor %ecx,%ecx
xor %r8d,%r8d
xor %r9d,%r9d
call 1030 <getopt_internal@plt>
pop %rcx
ret
| <MSIM_OPT_Getopt>:
endbr64
sub $0x8,%rsp
mov $0x0,%r9d
mov $0x0,%r8d
mov $0x0,%ecx
call 1050 <getopt_internal@plt>
add $0x8,%rsp
ret
| define i32 @MSIM_OPT_Getopt(i32 %0, i8** %1, i8* %2) {
%4 = call i32 @getopt_internal(i32 %0, i8** %1, i8* %2, i32* null, i32* null, i32 0)
ret i32 %4
}
| <MSIM_OPT_Getopt>:
xor %ecx,%ecx
xor %r8d,%r8d
xor %r9d,%r9d
jmp 1030 <getopt_internal@plt>
| <MSIM_OPT_Getopt>:
endbr64
xor %r9d,%r9d
xor %r8d,%r8d
xor %ecx,%ecx
jmp 1050 <getopt_internal@plt>
| define i32 @MSIM_OPT_Getopt(i32 %0, i8** %1, i8* %2) {
%4 = tail call i32 @getopt_internal(i32 %0, i8** %1, i8* %2, i32* null, i32* null, i32 0)
ret i32 %4
}
| <MSIM_OPT_Getopt>:
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x4(%rbp)
mov %rsi,-0x10(%rbp)
mov %rdx,-0x18(%rbp)
mov -0x4(%rbp),%edi
mov -0x10(%rbp),%rsi
mov -0x18(%rbp),%rdx
xor %eax,%eax
mov %eax,%r8d
xor %r9d,%r9d
mov %r8,%rcx
call 1030 <getopt_internal@plt>
add $0x20,%rsp
pop %rbp
ret
| <MSIM_OPT_Getopt>:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x4(%rbp)
mov %rsi,-0x10(%rbp)
mov %rdx,-0x18(%rbp)
mov -0x18(%rbp),%rdx
mov -0x10(%rbp),%rsi
mov -0x4(%rbp),%eax
mov $0x0,%r9d
mov $0x0,%r8d
mov $0x0,%ecx
mov %eax,%edi
call 1050 <getopt_internal@plt>
leave
ret
| define i32 @MSIM_OPT_Getopt(i32 %0, i8** %1, i8* %2) {
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i8*
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i8* %2, i8** %6
%7 = load i32, i32* %4
%8 = load i8**, i8*** %5
%9 = load i8*, i8** %6
%10 = call i32 @getopt_internal(i32 %7, i8** %8, i8* %9, i32* null, i32* null, i32 0)
ret i32 %10
}
| <MSIM_OPT_Getopt>:
xor %ecx,%ecx
xor %r8d,%r8d
xor %r9d,%r9d
jmp 1030 <getopt_internal@plt>
| <MSIM_OPT_Getopt>:
endbr64
xor %r9d,%r9d
xor %r8d,%r8d
xor %ecx,%ecx
jmp 1050 <getopt_internal@plt>
| define i32 @MSIM_OPT_Getopt(i32 %0, i8** %1, i8* %2) {
%4 = tail call i32 @getopt_internal(i32 %0, i8** %1, i8* %2, i32* null, i32* null, i32 0)
ret i32 %4
}
| 7 | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
int getopt_internal (int,char**,char const*,int /*<<< orphan*/ *,int /*<<< orphan*/ *,int /*<<< orphan*/ ) ;
| int MSIM_OPT_Getopt(int nargc, char **nargv, const char *options) {
return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
} | MSIM_OPT_Getopt | #define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
int getopt_internal(int, char **, char const *, int /*<<< orphan*/ *,
int /*<<< orphan*/ *, int /*<<< orphan*/);
int MSIM_OPT_Getopt(int nargc, char **nargv, const char *options) {
return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
}
|
<main>:
push %rbx
sub $0x20,%rsp
lea 0xebc(%rip),%rdi
xor %eax,%eax
call 1040 <printf@plt>
lea 0xecf(%rip),%rbx
lea 0x18(%rsp),%rsi
mov %rbx,%rdi
call 1070 <scanf@plt>
lea 0xebf(%rip),%rdi
xor %eax,%eax
call 1040 <printf@plt>
lea 0x10(%rsp),%rsi
mov %rbx,%rdi
call 1070 <scanf@plt>
movsd 0x18(%rsp),%xmm0
divsd 0x10(%rsp),%xmm0
movsd %xmm0,0x8(%rsp)
lea 0xf0f(%rip),%rdi
call 1030 <puts@plt>
lea 0xec2(%rip),%rdi
movsd 0x8(%rsp),%xmm0
mov $0x1,%al
call 1040 <printf@plt>
movsd 0x8(%rsp),%xmm0
mulsd 0xe2e(%rip),%xmm0
movsd %xmm0,0x8(%rsp)
lea 0xea9(%rip),%rdi
mov $0x1,%al
call 1040 <printf@plt>
movsd 0x8(%rsp),%xmm1
mulsd 0xe14(%rip),%xmm1
movsd %xmm1,0x8(%rsp)
movsd 0xe0e(%rip),%xmm0
mulsd %xmm1,%xmm0
lea 0xe8b(%rip),%rdi
mov $0x1,%al
call 1040 <printf@plt>
lea 0xe8e(%rip),%rdi
movsd 0x8(%rsp),%xmm0
mov $0x1,%al
call 1040 <printf@plt>
mov 0x2db9(%rip),%rax
mov (%rax),%edi
call 1060 <fflush@plt>
xor %eax,%eax
call 1050 <getchar@plt>
xor %eax,%eax
add $0x20,%rsp
pop %rbx
ret
| <main>:
endbr64
push %rbx
sub $0x30,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
lea 0xe27(%rip),%rdi
call 10c0 <printf@plt>
lea 0x18(%rsp),%rsi
lea 0xea8(%rip),%rbx
mov %rbx,%rdi
call 10f0 <scanf@plt>
lea 0xe2f(%rip),%rdi
mov $0x0,%eax
call 10c0 <printf@plt>
lea 0x20(%rsp),%rsi
mov %rbx,%rdi
call 10f0 <scanf@plt>
movsd 0x18(%rsp),%xmm0
divsd 0x20(%rsp),%xmm0
movsd %xmm0,0x8(%rsp)
lea 0xe3f(%rip),%rdi
call 10a0 <puts@plt>
movsd 0x8(%rsp),%xmm0
lea 0xe5b(%rip),%rdi
mov $0x1,%eax
call 10c0 <printf@plt>
movsd 0x8(%rsp),%xmm3
mulsd 0xe85(%rip),%xmm3
movq %xmm3,%rbx
movapd %xmm3,%xmm0
lea 0xe42(%rip),%rdi
mov $0x1,%eax
call 10c0 <printf@plt>
movq %rbx,%xmm1
mulsd 0xe66(%rip),%xmm1
movsd %xmm1,0x8(%rsp)
movapd %xmm1,%xmm2
mulsd 0xe5c(%rip),%xmm2
movapd %xmm2,%xmm0
lea 0xe1e(%rip),%rdi
mov $0x1,%eax
call 10c0 <printf@plt>
movsd 0x8(%rsp),%xmm0
lea 0xe18(%rip),%rdi
mov $0x1,%eax
call 10c0 <printf@plt>
mov 0x2d29(%rip),%rax
mov (%rax),%edi
call 10e0 <fflush@plt>
mov $0x0,%eax
call 10d0 <getchar@plt>
mov 0x28(%rsp),%rax
sub %fs:0x28,%rax
jne 12eb <main+0x132>
mov $0x0,%eax
add $0x30,%rsp
pop %rbx
ret
call 10b0 <__stack_chk_fail@plt>
| @.str = [33 x i8] c"Gib die Strecke ein (in Meter): \00"
@.str.1 = [4 x i8] c"%lf\00"
@.str.2 = [60 x i8] c"Gib die Zeit ein, die daf\C3\BCr ben\C3\B6tigt wird (in Sekunden): \00"
@.str.4 = [15 x i8] c" %lf m/sec =\0A\00"
@.str.5 = [16 x i8] c" %lf km/h =\0A\00"
@.str.6 = [17 x i8] c" %lf m/d =\0A\00"
@.str.7 = [17 x i8] c" %lf km/d\00"
@stdin = global i32 0
@str = [42 x i8] c"Das entspricht folgender Geschwindigkeit:\00"
define i32 @main() {
%1 = alloca double
%2 = alloca double
%3 = bitcast double* %1 to i8*
%4 = bitcast double* %2 to i8*
%5 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
%6 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %1)
%7 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @.str.2, i64 0, i64 0))
%8 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %2)
%9 = load double, double* %1
%10 = load double, double* %2
%11 = fdiv double %9, %10
%12 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str, i64 0, i64 0))
%13 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), double %11)
%14 = fmul double %11, 3.600000e+00
%15 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.5, i64 0, i64 0), double %14)
%16 = fmul double %14, 2.400000e+01
%17 = fmul double %16, 1.000000e+03
%18 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.6, i64 0, i64 0), double %17)
%19 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.7, i64 0, i64 0), double %16)
%20 = load i32, i32* @stdin
%21 = call i32 @fflush(i32 %20)
%22 = call i32 (...) @getchar()
ret i32 0
}
| <main>:
push %rbx
sub $0x20,%rsp
lea 0xebc(%rip),%rdi
xor %eax,%eax
call 1040 <printf@plt>
lea 0xecf(%rip),%rbx
lea 0x18(%rsp),%rsi
mov %rbx,%rdi
call 1070 <scanf@plt>
lea 0xebf(%rip),%rdi
xor %eax,%eax
call 1040 <printf@plt>
lea 0x10(%rsp),%rsi
mov %rbx,%rdi
call 1070 <scanf@plt>
movsd 0x18(%rsp),%xmm0
divsd 0x10(%rsp),%xmm0
movsd %xmm0,0x8(%rsp)
lea 0xf0f(%rip),%rdi
call 1030 <puts@plt>
lea 0xec2(%rip),%rdi
movsd 0x8(%rsp),%xmm0
mov $0x1,%al
call 1040 <printf@plt>
movsd 0x8(%rsp),%xmm0
mulsd 0xe2e(%rip),%xmm0
movsd %xmm0,0x8(%rsp)
lea 0xea9(%rip),%rdi
mov $0x1,%al
call 1040 <printf@plt>
movsd 0x8(%rsp),%xmm1
mulsd 0xe14(%rip),%xmm1
movsd %xmm1,0x8(%rsp)
movsd 0xe0e(%rip),%xmm0
mulsd %xmm1,%xmm0
lea 0xe8b(%rip),%rdi
mov $0x1,%al
call 1040 <printf@plt>
lea 0xe8e(%rip),%rdi
movsd 0x8(%rsp),%xmm0
mov $0x1,%al
call 1040 <printf@plt>
mov 0x2db9(%rip),%rax
mov (%rax),%edi
call 1060 <fflush@plt>
xor %eax,%eax
call 1050 <getchar@plt>
xor %eax,%eax
add $0x20,%rsp
pop %rbx
ret
| <main>:
endbr64
push %rbp
lea 0xef4(%rip),%rdi
lea 0xf7f(%rip),%rbp
sub $0x30,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
call 10c0 <printf@plt>
lea 0x18(%rsp),%rsi
mov %rbp,%rdi
call 10f0 <scanf@plt>
lea 0xee8(%rip),%rdi
xor %eax,%eax
call 10c0 <printf@plt>
lea 0x20(%rsp),%rsi
mov %rbp,%rdi
call 10f0 <scanf@plt>
lea 0xf0d(%rip),%rdi
movsd 0x18(%rsp),%xmm0
divsd 0x20(%rsp),%xmm0
movsd %xmm0,0x8(%rsp)
call 10a0 <puts@plt>
movsd 0x8(%rsp),%xmm0
mov $0x1,%eax
lea 0xf12(%rip),%rdi
call 10c0 <printf@plt>
movsd 0x8(%rsp),%xmm1
mov $0x1,%eax
lea 0xf0a(%rip),%rdi
mulsd 0xf35(%rip),%xmm1
movapd %xmm1,%xmm0
movsd %xmm1,0x8(%rsp)
call 10c0 <printf@plt>
movsd 0x8(%rsp),%xmm1
mov $0x1,%eax
lea 0xef1(%rip),%rdi
mulsd 0xf14(%rip),%xmm1
movapd %xmm1,%xmm0
movsd %xmm1,0x8(%rsp)
mulsd 0xf0a(%rip),%xmm0
call 10c0 <printf@plt>
movsd 0x8(%rsp),%xmm1
mov $0x1,%eax
lea 0xed1(%rip),%rdi
movapd %xmm1,%xmm0
call 10c0 <printf@plt>
mov 0x2de3(%rip),%rax
mov (%rax),%edi
call 10e0 <fflush@plt>
xor %eax,%eax
call 10d0 <getchar@plt>
mov 0x28(%rsp),%rax
sub %fs:0x28,%rax
jne 122b <main+0x12b>
add $0x30,%rsp
xor %eax,%eax
pop %rbp
ret
call 10b0 <__stack_chk_fail@plt>
| @.str = [33 x i8] c"Gib die Strecke ein (in Meter): \00"
@.str.1 = [4 x i8] c"%lf\00"
@.str.2 = [60 x i8] c"Gib die Zeit ein, die daf\C3\BCr ben\C3\B6tigt wird (in Sekunden): \00"
@.str.4 = [15 x i8] c" %lf m/sec =\0A\00"
@.str.5 = [16 x i8] c" %lf km/h =\0A\00"
@.str.6 = [17 x i8] c" %lf m/d =\0A\00"
@.str.7 = [17 x i8] c" %lf km/d\00"
@stdin = global i32 0
@str = [42 x i8] c"Das entspricht folgender Geschwindigkeit:\00"
define i32 @main() {
%1 = alloca double
%2 = alloca double
%3 = bitcast double* %1 to i8*
%4 = bitcast double* %2 to i8*
%5 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
%6 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %1)
%7 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @.str.2, i64 0, i64 0))
%8 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %2)
%9 = load double, double* %1
%10 = load double, double* %2
%11 = fdiv double %9, %10
%12 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str, i64 0, i64 0))
%13 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), double %11)
%14 = fmul double %11, 3.600000e+00
%15 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.5, i64 0, i64 0), double %14)
%16 = fmul double %14, 2.400000e+01
%17 = fmul double %16, 1.000000e+03
%18 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.6, i64 0, i64 0), double %17)
%19 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.7, i64 0, i64 0), double %16)
%20 = load i32, i32* @stdin
%21 = call i32 @fflush(i32 %20)
%22 = call i32 (...) @getchar()
ret i32 0
}
| <main>:
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
movl $0x0,-0x4(%rbp)
lea 0xec2(%rip),%rdi
mov $0x0,%al
call 1030 <printf@plt>
lea 0xed5(%rip),%rdi
lea -0x10(%rbp),%rsi
call 1060 <scanf@plt>
lea 0xec9(%rip),%rdi
mov $0x0,%al
call 1030 <printf@plt>
lea 0xeb7(%rip),%rdi
lea -0x18(%rbp),%rsi
call 1060 <scanf@plt>
movsd -0x10(%rbp),%xmm0
divsd -0x18(%rbp),%xmm0
movsd %xmm0,-0x20(%rbp)
lea 0xed8(%rip),%rdi
mov $0x0,%al
call 1030 <printf@plt>
movsd -0x20(%rbp),%xmm0
lea 0xef0(%rip),%rdi
mov $0x1,%al
call 1030 <printf@plt>
movsd 0xe45(%rip),%xmm0
mulsd -0x20(%rbp),%xmm0
lea 0xee4(%rip),%rdi
mov $0x1,%al
call 1030 <printf@plt>
movsd 0xe2a(%rip),%xmm0
mulsd -0x20(%rbp),%xmm0
movsd 0xe15(%rip),%xmm1
mulsd %xmm1,%xmm0
movsd 0xe19(%rip),%xmm1
mulsd %xmm1,%xmm0
lea 0xec1(%rip),%rdi
mov $0x1,%al
call 1030 <printf@plt>
movsd 0xdf7(%rip),%xmm0
mulsd -0x20(%rbp),%xmm0
movsd 0xde2(%rip),%xmm1
mulsd %xmm1,%xmm0
lea 0xeab(%rip),%rdi
mov $0x1,%al
call 1030 <printf@plt>
mov 0x2db1(%rip),%rax
mov (%rax),%edi
call 1050 <fflush@plt>
mov $0x0,%al
call 1040 <getchar@plt>
xor %eax,%eax
add $0x20,%rsp
pop %rbp
ret
| <main>:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe25(%rip),%rax
mov %rax,%rdi
mov $0x0,%eax
call 10c0 <printf@plt>
lea -0x20(%rbp),%rax
mov %rax,%rsi
lea 0xe2b(%rip),%rax
mov %rax,%rdi
call 10f0 <scanf@plt>
lea 0xe23(%rip),%rax
mov %rax,%rdi
mov $0x0,%eax
call 10c0 <printf@plt>
lea -0x18(%rbp),%rax
mov %rax,%rsi
lea 0xe01(%rip),%rax
mov %rax,%rdi
call 10f0 <scanf@plt>
movsd -0x20(%rbp),%xmm0
movsd -0x18(%rbp),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x10(%rbp)
lea 0xe26(%rip),%rax
mov %rax,%rdi
call 10a0 <puts@plt>
mov -0x10(%rbp),%rax
movq %rax,%xmm0
lea 0xe38(%rip),%rax
mov %rax,%rdi
mov $0x1,%eax
call 10c0 <printf@plt>
movsd -0x10(%rbp),%xmm1
movsd 0xe64(%rip),%xmm0
mulsd %xmm0,%xmm1
movq %xmm1,%rax
movq %rax,%xmm0
lea 0xe18(%rip),%rax
mov %rax,%rdi
mov $0x1,%eax
call 10c0 <printf@plt>
movsd -0x10(%rbp),%xmm1
movsd 0xe35(%rip),%xmm0
mulsd %xmm0,%xmm1
movsd 0xe31(%rip),%xmm0
mulsd %xmm0,%xmm1
movsd 0xe2d(%rip),%xmm0
mulsd %xmm0,%xmm1
movq %xmm1,%rax
movq %rax,%xmm0
lea 0xde1(%rip),%rax
mov %rax,%rdi
mov $0x1,%eax
call 10c0 <printf@plt>
movsd -0x10(%rbp),%xmm1
movsd 0xdee(%rip),%xmm0
mulsd %xmm0,%xmm1
movsd 0xdea(%rip),%xmm0
mulsd %xmm0,%xmm1
movq %xmm1,%rax
movq %rax,%xmm0
lea 0xdb7(%rip),%rax
mov %rax,%rdi
mov $0x1,%eax
call 10c0 <printf@plt>
mov 0x2cc9(%rip),%rax
mov (%rax),%eax
mov %eax,%edi
call 10e0 <fflush@plt>
mov $0x0,%eax
call 10d0 <getchar@plt>
mov $0x0,%eax
mov -0x8(%rbp),%rdx
sub %fs:0x28,%rdx
je 134b <main+0x192>
call 10b0 <__stack_chk_fail@plt>
leave
ret
| @.str = [33 x i8] c"Gib die Strecke ein (in Meter): \00"
@.str.1 = [4 x i8] c"%lf\00"
@.str.2 = [60 x i8] c"Gib die Zeit ein, die daf\C3\BCr ben\C3\B6tigt wird (in Sekunden): \00"
@.str.3 = [43 x i8] c"Das entspricht folgender Geschwindigkeit:\0A\00"
@.str.4 = [15 x i8] c" %lf m/sec =\0A\00"
@.str.5 = [16 x i8] c" %lf km/h =\0A\00"
@.str.6 = [17 x i8] c" %lf m/d =\0A\00"
@.str.7 = [17 x i8] c" %lf km/d\00"
@stdin = global i32 0
define i32 @main() {
%1 = alloca i32
%2 = alloca double
%3 = alloca double
%4 = alloca double
store i32 0, i32* %1
%5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
%6 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %2)
%7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.2, i64 0, i64 0))
%8 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %3)
%9 = load double, double* %2
%10 = load double, double* %3
%11 = fdiv double %9, %10
store double %11, double* %4
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.3, i64 0, i64 0))
%13 = load double, double* %4
%14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), double %13)
%15 = load double, double* %4
%16 = fmul double %15, 3.600000e+00
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.5, i64 0, i64 0), double %16)
%18 = load double, double* %4
%19 = fmul double %18, 3.600000e+00
%20 = fmul double %19, 2.400000e+01
%21 = fmul double %20, 1.000000e+03
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.6, i64 0, i64 0), double %21)
%23 = load double, double* %4
%24 = fmul double %23, 3.600000e+00
%25 = fmul double %24, 2.400000e+01
%26 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.7, i64 0, i64 0), double %25)
%27 = load i32, i32* @stdin
%28 = call i32 @fflush(i32 %27)
%29 = call i32 (...) @getchar()
ret i32 0
}
| <main>:
push %rbx
sub $0x20,%rsp
lea 0xebc(%rip),%rdi
xor %eax,%eax
call 1040 <printf@plt>
lea 0xecf(%rip),%rbx
lea 0x18(%rsp),%rsi
mov %rbx,%rdi
call 1070 <scanf@plt>
lea 0xebf(%rip),%rdi
xor %eax,%eax
call 1040 <printf@plt>
lea 0x10(%rsp),%rsi
mov %rbx,%rdi
call 1070 <scanf@plt>
movsd 0x18(%rsp),%xmm0
divsd 0x10(%rsp),%xmm0
movsd %xmm0,0x8(%rsp)
lea 0xf0f(%rip),%rdi
call 1030 <puts@plt>
lea 0xec2(%rip),%rdi
movsd 0x8(%rsp),%xmm0
mov $0x1,%al
call 1040 <printf@plt>
movsd 0x8(%rsp),%xmm0
mulsd 0xe2e(%rip),%xmm0
movsd %xmm0,0x8(%rsp)
lea 0xea9(%rip),%rdi
mov $0x1,%al
call 1040 <printf@plt>
movsd 0x8(%rsp),%xmm1
mulsd 0xe14(%rip),%xmm1
movsd %xmm1,0x8(%rsp)
movsd 0xe0e(%rip),%xmm0
mulsd %xmm1,%xmm0
lea 0xe8b(%rip),%rdi
mov $0x1,%al
call 1040 <printf@plt>
lea 0xe8e(%rip),%rdi
movsd 0x8(%rsp),%xmm0
mov $0x1,%al
call 1040 <printf@plt>
mov 0x2db9(%rip),%rax
mov (%rax),%edi
call 1060 <fflush@plt>
xor %eax,%eax
call 1050 <getchar@plt>
xor %eax,%eax
add $0x20,%rsp
pop %rbx
ret
| <main>:
endbr64
push %rbp
lea 0xef4(%rip),%rdi
lea 0xf7f(%rip),%rbp
sub $0x30,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
call 10c0 <printf@plt>
lea 0x18(%rsp),%rsi
mov %rbp,%rdi
call 10f0 <scanf@plt>
lea 0xee8(%rip),%rdi
xor %eax,%eax
call 10c0 <printf@plt>
lea 0x20(%rsp),%rsi
mov %rbp,%rdi
call 10f0 <scanf@plt>
lea 0xf0d(%rip),%rdi
movsd 0x18(%rsp),%xmm0
divsd 0x20(%rsp),%xmm0
movsd %xmm0,0x8(%rsp)
call 10a0 <puts@plt>
movsd 0x8(%rsp),%xmm0
mov $0x1,%eax
lea 0xf12(%rip),%rdi
call 10c0 <printf@plt>
movsd 0x8(%rsp),%xmm1
mov $0x1,%eax
lea 0xf0a(%rip),%rdi
mulsd 0xf35(%rip),%xmm1
movapd %xmm1,%xmm0
movsd %xmm1,0x8(%rsp)
call 10c0 <printf@plt>
movsd 0x8(%rsp),%xmm1
mov $0x1,%eax
lea 0xef1(%rip),%rdi
mulsd 0xf14(%rip),%xmm1
movapd %xmm1,%xmm0
movsd %xmm1,0x8(%rsp)
mulsd 0xf0a(%rip),%xmm0
call 10c0 <printf@plt>
movsd 0x8(%rsp),%xmm1
mov $0x1,%eax
lea 0xed1(%rip),%rdi
movapd %xmm1,%xmm0
call 10c0 <printf@plt>
mov 0x2de3(%rip),%rax
mov (%rax),%edi
call 10e0 <fflush@plt>
xor %eax,%eax
call 10d0 <getchar@plt>
mov 0x28(%rsp),%rax
sub %fs:0x28,%rax
jne 122b <main+0x12b>
add $0x30,%rsp
xor %eax,%eax
pop %rbp
ret
call 10b0 <__stack_chk_fail@plt>
| @.str = [33 x i8] c"Gib die Strecke ein (in Meter): \00"
@.str.1 = [4 x i8] c"%lf\00"
@.str.2 = [60 x i8] c"Gib die Zeit ein, die daf\C3\BCr ben\C3\B6tigt wird (in Sekunden): \00"
@.str.4 = [15 x i8] c" %lf m/sec =\0A\00"
@.str.5 = [16 x i8] c" %lf km/h =\0A\00"
@.str.6 = [17 x i8] c" %lf m/d =\0A\00"
@.str.7 = [17 x i8] c" %lf km/d\00"
@stdin = global i32 0
@str = [42 x i8] c"Das entspricht folgender Geschwindigkeit:\00"
define i32 @main() {
%1 = alloca double
%2 = alloca double
%3 = bitcast double* %1 to i8*
%4 = bitcast double* %2 to i8*
%5 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
%6 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %1)
%7 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @.str.2, i64 0, i64 0))
%8 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), double* %2)
%9 = load double, double* %1
%10 = load double, double* %2
%11 = fdiv double %9, %10
%12 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str, i64 0, i64 0))
%13 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), double %11)
%14 = fmul double %11, 3.600000e+00
%15 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.5, i64 0, i64 0), double %14)
%16 = fmul double %14, 2.400000e+01
%17 = fmul double %16, 1.000000e+03
%18 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.6, i64 0, i64 0), double %17)
%19 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.7, i64 0, i64 0), double %16)
%20 = load i32, i32* @stdin
%21 = call i32 @fflush(i32 %20)
%22 = call i32 (...) @getchar()
ret i32 0
}
| 8 | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
int /*<<< orphan*/ fflush (int /*<<< orphan*/ ) ;
int /*<<< orphan*/ getchar () ;
int /*<<< orphan*/ printf (char*,...) ;
int /*<<< orphan*/ scanf (char*,double*) ;
int /*<<< orphan*/ stdin ;
| int main(void) {
double distance, timeins, mps;
printf("Gib die Strecke ein (in Meter): ");
scanf("%lf", &distance);
printf("Gib die Zeit ein, die dafür benötigt wird (in Sekunden): ");
scanf("%lf", &timeins);
mps = distance / timeins;
printf("Das entspricht folgender Geschwindigkeit:\n");
printf(" %lf m/sec =\n", mps);
printf(" %lf km/h =\n", mps * 3.6);
printf(" %lf m/d =\n", mps * 3.6*24*1000);
printf(" %lf km/d", mps * 3.6*24);
fflush(stdin);
getchar();
return 0;
} | main | #define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
int /*<<< orphan*/ fflush(int /*<<< orphan*/);
int /*<<< orphan*/ getchar();
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, double *);
int /*<<< orphan*/ stdin;
int main(void) {
double distance, timeins, mps;
printf("Gib die Strecke ein (in Meter): ");
scanf("%lf", &distance);
printf("Gib die Zeit ein, die dafür benötigt wird (in Sekunden): ");
scanf("%lf", &timeins);
mps = distance / timeins;
printf("Das entspricht folgender Geschwindigkeit:\n");
printf(" %lf m/sec =\n", mps);
printf(" %lf km/h =\n", mps * 3.6);
printf(" %lf m/d =\n", mps * 3.6 * 24 * 1000);
printf(" %lf km/d", mps * 3.6 * 24);
fflush(stdin);
getchar();
return 0;
}
|
<gtk_toggle_button_set_active>:
ret
| <gtk_toggle_button_set_active>:
endbr64
ret
| define void @gtk_toggle_button_set_active() {
ret void
}
| <gtk_toggle_button_set_active>:
ret
| <gtk_toggle_button_set_active>:
endbr64
ret
| define void @gtk_toggle_button_set_active() {
ret void
}
| <gtk_toggle_button_set_active>:
push %rbp
mov %rsp,%rbp
pop %rbp
ret
| <gtk_toggle_button_set_active>:
endbr64
push %rbp
mov %rsp,%rbp
nop
pop %rbp
ret
| define void @gtk_toggle_button_set_active() {
ret void
}
| <gtk_toggle_button_set_active>:
ret
| <gtk_toggle_button_set_active>:
endbr64
ret
| define void @gtk_toggle_button_set_active() {
ret void
}
| 10 | null | void gtk_toggle_button_set_active() {
} | gtk_toggle_button_set_active | void gtk_toggle_button_set_active() {}
|
<find_rvm_home>:
push %rbp
mov %rsp,%rbp
push %rbx
push %rax
lea 0xeb3(%rip),%rdi
call 1030 <getenv@plt>
mov 0x2e97(%rip),%rcx
mov (%rcx),%ecx
mov %rsp,%rbx
add $0xf,%rcx
and $0xfffffffffffffff0,%rcx
sub %rcx,%rbx
mov %rbx,%rsp
test %rax,%rax
je 1199 <find_rvm_home+0x59>
lea 0xe8d(%rip),%rsi
mov %rbx,%rdi
mov %rax,%rdx
call 1050 <sprintf@plt>
mov 0x2e56(%rip),%rax
mov (%rax),%esi
mov %rbx,%rdi
call 1040 <access@plt>
test %rax,%rax
je 119d <find_rvm_home+0x5d>
xor %eax,%eax
jmp 11a5 <find_rvm_home+0x65>
mov %rbx,%rdi
call 1060 <strdup@plt>
lea -0x8(%rbp),%rsp
pop %rbx
pop %rbp
ret
| <find_rvm_home>:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea 0xe44(%rip),%rdi
call 1090 <getenv@plt>
mov 0x2e28(%rip),%rdx
movslq (%rdx),%rdx
add $0xf,%rdx
mov %rdx,%rsi
and $0xfffffffffffffff0,%rsi
and $0xfffffffffffff000,%rdx
mov %rsp,%rcx
sub %rdx,%rcx
cmp %rcx,%rsp
je 11fa <find_rvm_home+0x61>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11e3 <find_rvm_home+0x4a>
mov %rsi,%rdx
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
je 1211 <find_rvm_home+0x78>
orq $0x0,-0x8(%rsp,%rdx,1)
mov %rsp,%rbx
test %rax,%rax
je 1249 <find_rvm_home+0xb0>
mov %rax,%rdx
lea 0xde2(%rip),%rsi
mov %rbx,%rdi
call 10c0 <sprintf@plt>
mov 0x2dae(%rip),%rax
mov (%rax),%esi
mov %rbx,%rdi
call 10b0 <access@plt>
mov %rax,%rdx
mov $0x0,%eax
test %rdx,%rdx
je 125e <find_rvm_home+0xc5>
mov -0x18(%rbp),%rdx
sub %fs:0x28,%rdx
jne 1268 <find_rvm_home+0xcf>
mov -0x8(%rbp),%rbx
leave
ret
mov %rbx,%rdi
call 10d0 <strdup@plt>
jmp 1249 <find_rvm_home+0xb0>
call 10a0 <__stack_chk_fail@plt>
| @.str = [5 x i8] c"HOME\00"
@PATH_MAX = global i32 0
@.str.1 = [16 x i8] c"%s/.rvm/bin/rvm\00"
@X_OK = global i32 0
define noalias i8* @find_rvm_home() {
%1 = call i8* @getenv(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%2 = load i32, i32* @PATH_MAX
%3 = zext i32 %2 to i64
%4 = alloca i8, i64 %3
%5 = icmp eq i8* %1, null
br i1 %5, label %13, label %6
6: ; preds = %0
%7 = call i32 @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), i8* %1)
%8 = load i32, i32* @X_OK
%9 = call i64 @access(i8* %4, i32 %8)
%10 = icmp eq i64 %9, 0
br i1 %10, label %11, label %13
11: ; preds = %6
%12 = call i8* @strdup(i8* %4)
br label %13
13: ; preds = %6, %0, %11
%14 = phi i8* [ %12, %11 ], [ null, %0 ], [ null, %6 ]
ret i8* %14
}
| <find_rvm_home>:
push %rbp
mov %rsp,%rbp
push %rbx
push %rax
lea 0xeb3(%rip),%rdi
call 1030 <getenv@plt>
mov 0x2e97(%rip),%rcx
mov (%rcx),%ecx
mov %rsp,%rbx
add $0xf,%rcx
and $0xfffffffffffffff0,%rcx
sub %rcx,%rbx
mov %rbx,%rsp
test %rax,%rax
je 1199 <find_rvm_home+0x59>
lea 0xe8d(%rip),%rsi
mov %rbx,%rdi
mov %rax,%rdx
call 1050 <sprintf@plt>
mov 0x2e56(%rip),%rax
mov (%rax),%esi
mov %rbx,%rdi
call 1040 <access@plt>
test %rax,%rax
je 119d <find_rvm_home+0x5d>
xor %eax,%eax
jmp 11a5 <find_rvm_home+0x65>
mov %rbx,%rdi
call 1060 <strdup@plt>
lea -0x8(%rbp),%rsp
pop %rbx
pop %rbp
ret
| <find_rvm_home>:
endbr64
push %rbp
lea 0xe54(%rip),%rdi
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
call 1090 <getenv@plt>
mov %rsp,%rsi
mov %rax,%rdx
mov 0x2e1c(%rip),%rax
movslq (%rax),%rcx
add $0xf,%rcx
mov %rcx,%rax
and $0xfffffffffffff000,%rcx
sub %rcx,%rsi
and $0xfffffffffffffff0,%rax
cmp %rsi,%rsp
je 1206 <find_rvm_home+0x66>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rsi,%rsp
jne 11f1 <find_rvm_home+0x51>
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
jne 1260 <find_rvm_home+0xc0>
test %rdx,%rdx
je 123d <find_rvm_home+0x9d>
lea 0xde6(%rip),%rsi
mov %rsp,%rdi
call 10c0 <sprintf@plt>
mov 0x2db2(%rip),%rax
mov %rsp,%rdi
mov (%rax),%esi
call 10b0 <access@plt>
test %rax,%rax
je 1250 <find_rvm_home+0xb0>
xor %eax,%eax
mov -0x8(%rbp),%rdx
sub %fs:0x28,%rdx
jne 1268 <find_rvm_home+0xc8>
leave
ret
mov %rsp,%rdi
call 10d0 <strdup@plt>
jmp 123f <find_rvm_home+0x9f>
nopw 0x0(%rax,%rax,1)
orq $0x0,-0x8(%rsp,%rax,1)
jmp 1213 <find_rvm_home+0x73>
call 10a0 <__stack_chk_fail@plt>
| @.str = [5 x i8] c"HOME\00"
@PATH_MAX = global i32 0
@.str.1 = [16 x i8] c"%s/.rvm/bin/rvm\00"
@X_OK = global i32 0
define noalias i8* @find_rvm_home() {
%1 = tail call i8* @getenv(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%2 = load i32, i32* @PATH_MAX
%3 = zext i32 %2 to i64
%4 = alloca i8, i64 %3
%5 = icmp eq i8* %1, null
br i1 %5, label %13, label %6
6: ; preds = %0
%7 = call i32 @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), i8* %1)
%8 = load i32, i32* @X_OK
%9 = call i64 @access(i8* %4, i32 %8)
%10 = icmp eq i64 %9, 0
br i1 %10, label %11, label %13
11: ; preds = %6
%12 = call i8* @strdup(i8* %4)
br label %13
13: ; preds = %6, %0, %11
%14 = phi i8* [ %12, %11 ], [ null, %0 ], [ null, %6 ]
ret i8* %14
}
| <find_rvm_home>:
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
lea 0xeb1(%rip),%rdi
call 1030 <getenv@plt>
mov %rax,-0x10(%rbp)
mov 0x2e91(%rip),%rax
mov (%rax),%eax
mov %rsp,%rcx
mov %rcx,-0x18(%rbp)
mov %rax,%rdx
add $0xf,%rdx
and $0xfffffffffffffff0,%rdx
mov %rsp,%rcx
sub %rdx,%rcx
mov %rcx,-0x30(%rbp)
mov %rcx,%rsp
mov %rax,-0x20(%rbp)
cmpq $0x0,-0x10(%rbp)
jne 11a3 <find_rvm_home+0x63>
movq $0x0,-0x8(%rbp)
movl $0x1,-0x24(%rbp)
jmp 11fb <find_rvm_home+0xbb>
mov -0x30(%rbp),%rdi
mov -0x10(%rbp),%rdx
lea 0xe53(%rip),%rsi
call 1050 <sprintf@plt>
mov -0x30(%rbp),%rdi
mov 0x2e1e(%rip),%rax
mov (%rax),%esi
call 1040 <access@plt>
cmp $0x0,%rax
jne 11ec <find_rvm_home+0xac>
mov -0x30(%rbp),%rdi
call 1060 <strdup@plt>
mov %rax,-0x8(%rbp)
movl $0x1,-0x24(%rbp)
jmp 11fb <find_rvm_home+0xbb>
movq $0x0,-0x8(%rbp)
movl $0x1,-0x24(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rsp
mov -0x8(%rbp),%rax
mov %rbp,%rsp
pop %rbp
ret
| <find_rvm_home>:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rbx
lea 0xe36(%rip),%rax
mov %rax,%rdi
call 1090 <getenv@plt>
mov %rax,-0x50(%rbp)
mov 0x2e13(%rip),%rax
mov (%rax),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x48(%rbp)
movslq %eax,%rdx
mov %rdx,%r14
mov $0x0,%r15d
movslq %eax,%rdx
mov %rdx,%r12
mov $0x0,%r13d
cltq
mov $0x10,%edx
sub $0x1,%rdx
add %rdx,%rax
mov $0x10,%esi
mov $0x0,%edx
div %rsi
imul $0x10,%rax,%rax
mov %rax,%rcx
and $0xfffffffffffff000,%rcx
mov %rsp,%rdx
sub %rcx,%rdx
cmp %rdx,%rsp
je 1248 <find_rvm_home+0xaf>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1231 <find_rvm_home+0x98>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1272 <find_rvm_home+0xd9>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x0,%rax
mov %rax,-0x40(%rbp)
cmpq $0x0,-0x50(%rbp)
jne 128b <find_rvm_home+0xf2>
mov $0x0,%eax
jmp 12d4 <find_rvm_home+0x13b>
mov -0x50(%rbp),%rdx
mov -0x40(%rbp),%rax
lea 0xd6b(%rip),%rcx
mov %rcx,%rsi
mov %rax,%rdi
call 10c0 <sprintf@plt>
mov 0x2d34(%rip),%rax
mov (%rax),%edx
mov -0x40(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
call 10b0 <access@plt>
test %rax,%rax
jne 12cf <find_rvm_home+0x136>
mov -0x40(%rbp),%rax
mov %rax,%rdi
call 10d0 <strdup@plt>
jmp 12d4 <find_rvm_home+0x13b>
mov $0x0,%eax
mov %rbx,%rsp
mov -0x38(%rbp),%rdx
sub %fs:0x28,%rdx
je 12eb <find_rvm_home+0x152>
call 10a0 <__stack_chk_fail@plt>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
ret
| @.str = [5 x i8] c"HOME\00"
@PATH_MAX = global i32 0
@.str.1 = [16 x i8] c"%s/.rvm/bin/rvm\00"
@X_OK = global i32 0
define i8* @find_rvm_home() {
%1 = alloca i8*
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i64
%5 = alloca i32
%6 = call i8* @getenv(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
store i8* %6, i8** %2
%7 = load i32, i32* @PATH_MAX
%8 = zext i32 %7 to i64
%9 = call i8* @llvm.stacksave()
store i8* %9, i8** %3
%10 = alloca i8, i64 %8
store i64 %8, i64* %4
%11 = load i8*, i8** %2
%12 = icmp eq i8* %11, null
br i1 %12, label %13, label %14
13: ; preds = %0
store i8* null, i8** %1
store i32 1, i32* %5
br label %23
14: ; preds = %0
%15 = load i8*, i8** %2
%16 = call i32 @sprintf(i8* %10, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), i8* %15)
%17 = load i32, i32* @X_OK
%18 = call i64 @access(i8* %10, i32 %17)
%19 = icmp eq i64 %18, 0
br i1 %19, label %20, label %22
20: ; preds = %14
%21 = call i8* @strdup(i8* %10)
store i8* %21, i8** %1
store i32 1, i32* %5
br label %23
22: ; preds = %14
store i8* null, i8** %1
store i32 1, i32* %5
br label %23
23: ; preds = %22, %20, %13
%24 = load i8*, i8** %3
%25 = load i8*, i8** %1
ret i8* %25
}
| <find_rvm_home>:
push %rbp
mov %rsp,%rbp
push %rbx
push %rax
lea 0xeb3(%rip),%rdi
call 1030 <getenv@plt>
mov 0x2e97(%rip),%rcx
mov (%rcx),%ecx
mov %rsp,%rbx
add $0xf,%rcx
and $0xfffffffffffffff0,%rcx
sub %rcx,%rbx
mov %rbx,%rsp
test %rax,%rax
je 1199 <find_rvm_home+0x59>
lea 0xe8d(%rip),%rsi
mov %rbx,%rdi
mov %rax,%rdx
call 1050 <sprintf@plt>
mov 0x2e56(%rip),%rax
mov (%rax),%esi
mov %rbx,%rdi
call 1040 <access@plt>
test %rax,%rax
je 11a2 <find_rvm_home+0x62>
xor %eax,%eax
lea -0x8(%rbp),%rsp
pop %rbx
pop %rbp
ret
mov %rbx,%rdi
call 1060 <strdup@plt>
lea -0x8(%rbp),%rsp
pop %rbx
pop %rbp
ret
| <find_rvm_home>:
endbr64
push %rbp
lea 0xe54(%rip),%rdi
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
call 1090 <getenv@plt>
mov %rsp,%rsi
mov %rax,%rdx
mov 0x2e1c(%rip),%rax
movslq (%rax),%rcx
add $0xf,%rcx
mov %rcx,%rax
and $0xfffffffffffff000,%rcx
sub %rcx,%rsi
and $0xfffffffffffffff0,%rax
cmp %rsi,%rsp
je 1206 <find_rvm_home+0x66>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rsi,%rsp
jne 11f1 <find_rvm_home+0x51>
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
jne 1260 <find_rvm_home+0xc0>
test %rdx,%rdx
je 123d <find_rvm_home+0x9d>
lea 0xde6(%rip),%rsi
mov %rsp,%rdi
call 10c0 <sprintf@plt>
mov 0x2db2(%rip),%rax
mov %rsp,%rdi
mov (%rax),%esi
call 10b0 <access@plt>
test %rax,%rax
je 1250 <find_rvm_home+0xb0>
xor %eax,%eax
mov -0x8(%rbp),%rdx
sub %fs:0x28,%rdx
jne 1268 <find_rvm_home+0xc8>
leave
ret
mov %rsp,%rdi
call 10d0 <strdup@plt>
jmp 123f <find_rvm_home+0x9f>
nopw 0x0(%rax,%rax,1)
orq $0x0,-0x8(%rsp,%rax,1)
jmp 1213 <find_rvm_home+0x73>
call 10a0 <__stack_chk_fail@plt>
| @.str = [5 x i8] c"HOME\00"
@PATH_MAX = global i32 0
@.str.1 = [16 x i8] c"%s/.rvm/bin/rvm\00"
@X_OK = global i32 0
define noalias i8* @find_rvm_home() {
%1 = tail call i8* @getenv(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%2 = load i32, i32* @PATH_MAX
%3 = zext i32 %2 to i64
%4 = alloca i8, i64 %3
%5 = icmp eq i8* %1, null
br i1 %5, label %13, label %6
6: ; preds = %0
%7 = call i32 @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), i8* %1)
%8 = load i32, i32* @X_OK
%9 = call i64 @access(i8* %4, i32 %8)
%10 = icmp eq i64 %9, 0
br i1 %10, label %11, label %13
11: ; preds = %6
%12 = call i8* @strdup(i8* %4)
br label %13
13: ; preds = %6, %0, %11
%14 = phi i8* [ %12, %11 ], [ null, %0 ], [ null, %6 ]
ret i8* %14
}
| 11 | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
int PATH_MAX ;
int /*<<< orphan*/ X_OK ;
scalar_t__ access (char*,int /*<<< orphan*/ ) ;
char* getenv (char*) ;
int /*<<< orphan*/ sprintf (char*,char*,char*) ;
char* strdup (char*) ;
| char * find_rvm_home(void) {
char * home = getenv("HOME");
char buffer[PATH_MAX];
if ( home == NULL )
return NULL;
sprintf(buffer, "%s/.rvm/bin/rvm", home);
if ( access(buffer, X_OK) == 0 )
return strdup(buffer);
return NULL;
} | find_rvm_home | #define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
int PATH_MAX;
int /*<<< orphan*/ X_OK;
scalar_t__ access(char *, int /*<<< orphan*/);
char *getenv(char *);
int /*<<< orphan*/ sprintf(char *, char *, char *);
char *strdup(char *);
char *find_rvm_home(void) {
char *home = getenv("HOME");
char buffer[PATH_MAX];
if (home == NULL)
return NULL;
sprintf(buffer, "%s/.rvm/bin/rvm", home);
if (access(buffer, X_OK) == 0)
return strdup(buffer);
return NULL;
}
|
<rgph_jenkins2_mix>:
mov (%rdi),%eax
mov 0x4(%rdi),%r8d
sub %r8d,%eax
mov 0x8(%rdi),%r9d
sub %r9d,%eax
mov %r9d,%esi
sar $0xd,%esi
xor %eax,%esi
sub %r9d,%r8d
sub %esi,%r8d
mov %esi,%ecx
shl $0x8,%ecx
xor %r8d,%ecx
sub %esi,%r9d
sub %ecx,%r9d
mov %ecx,%edx
sar $0xd,%edx
xor %r9d,%edx
sub %ecx,%esi
sub %edx,%esi
mov %edx,%eax
sar $0xc,%eax
xor %esi,%eax
sub %edx,%ecx
sub %eax,%ecx
mov %eax,%esi
shl $0x10,%esi
xor %ecx,%esi
sub %eax,%edx
sub %esi,%edx
mov %esi,%ecx
sar $0x5,%ecx
xor %edx,%ecx
sub %esi,%eax
sub %ecx,%eax
mov %ecx,%edx
sar $0x3,%edx
xor %eax,%edx
mov %edx,(%rdi)
sub %ecx,%esi
sub %edx,%esi
mov %edx,%eax
shl $0xa,%eax
xor %esi,%eax
mov %eax,0x4(%rdi)
add %eax,%edx
sub %edx,%ecx
sar $0xf,%eax
xor %ecx,%eax
mov %eax,0x8(%rdi)
ret
| <rgph_jenkins2_mix>:
endbr64
mov %rdi,%rcx
mov 0x4(%rdi),%eax
mov 0x8(%rdi),%edx
mov (%rdi),%esi
sub %eax,%esi
sub %edx,%esi
mov %edx,%edi
sar $0xd,%edi
xor %edi,%esi
sub %edx,%eax
sub %esi,%eax
mov %esi,%edi
shl $0x8,%edi
xor %edi,%eax
sub %esi,%edx
sub %eax,%edx
mov %eax,%edi
sar $0xd,%edi
xor %edi,%edx
sub %eax,%esi
sub %edx,%esi
mov %edx,%edi
sar $0xc,%edi
xor %edi,%esi
sub %edx,%eax
sub %esi,%eax
mov %esi,%edi
shl $0x10,%edi
xor %edi,%eax
sub %esi,%edx
sub %eax,%edx
mov %eax,%edi
sar $0x5,%edi
xor %edi,%edx
sub %eax,%esi
sub %edx,%esi
mov %edx,%edi
sar $0x3,%edi
xor %edi,%esi
mov %esi,(%rcx)
sub %edx,%eax
sub %esi,%eax
mov %esi,%edi
shl $0xa,%edi
xor %edi,%eax
mov %eax,0x4(%rcx)
sub %esi,%edx
sub %eax,%edx
sar $0xf,%eax
xor %eax,%edx
mov %edx,0x8(%rcx)
ret
| define void @rgph_jenkins2_mix(i32* nocapture %0) {
%2 = getelementptr inbounds i32, i32* %0, i64 1
%3 = load i32, i32* %2
%4 = load i32, i32* %0
%5 = sub nsw i32 %4, %3
store i32 %5, i32* %0
%6 = getelementptr inbounds i32, i32* %0, i64 2
%7 = load i32, i32* %6
%8 = sub nsw i32 %5, %7
%9 = ashr i32 %7, 13
%10 = xor i32 %8, %9
store i32 %10, i32* %0
%11 = add i32 %7, %10
%12 = sub i32 %3, %11
%13 = shl i32 %10, 8
%14 = xor i32 %12, %13
store i32 %14, i32* %2
%15 = add i32 %10, %14
%16 = sub i32 %7, %15
%17 = ashr i32 %14, 13
%18 = xor i32 %16, %17
store i32 %18, i32* %6
%19 = add i32 %14, %18
%20 = sub i32 %10, %19
%21 = ashr i32 %18, 12
%22 = xor i32 %20, %21
store i32 %22, i32* %0
%23 = add i32 %18, %22
%24 = sub i32 %14, %23
%25 = shl i32 %22, 16
%26 = xor i32 %24, %25
store i32 %26, i32* %2
%27 = add i32 %22, %26
%28 = sub i32 %18, %27
%29 = ashr i32 %26, 5
%30 = xor i32 %28, %29
store i32 %30, i32* %6
%31 = add i32 %26, %30
%32 = sub i32 %22, %31
%33 = ashr i32 %30, 3
%34 = xor i32 %32, %33
store i32 %34, i32* %0
%35 = add i32 %30, %34
%36 = sub i32 %26, %35
%37 = shl i32 %34, 10
%38 = xor i32 %36, %37
store i32 %38, i32* %2
%39 = add i32 %34, %38
%40 = sub i32 %30, %39
%41 = ashr i32 %38, 15
%42 = xor i32 %40, %41
store i32 %42, i32* %6
ret void
}
| <rgph_jenkins2_mix>:
mov (%rdi),%eax
mov 0x4(%rdi),%r8d
mov 0x8(%rdi),%r9d
sub %r8d,%eax
sub %r9d,%eax
mov %r9d,%esi
sar $0xd,%esi
xor %eax,%esi
sub %r9d,%r8d
sub %esi,%r8d
mov %esi,%ecx
shl $0x8,%ecx
xor %r8d,%ecx
sub %esi,%r9d
sub %ecx,%r9d
mov %ecx,%edx
sar $0xd,%edx
xor %r9d,%edx
sub %ecx,%esi
sub %edx,%esi
mov %edx,%eax
sar $0xc,%eax
xor %esi,%eax
sub %edx,%ecx
sub %eax,%ecx
mov %eax,%esi
shl $0x10,%esi
xor %ecx,%esi
sub %eax,%edx
sub %esi,%edx
mov %esi,%ecx
sar $0x5,%ecx
xor %edx,%ecx
sub %esi,%eax
sub %ecx,%eax
mov %ecx,%edx
sar $0x3,%edx
xor %eax,%edx
mov %edx,(%rdi)
sub %ecx,%esi
sub %edx,%esi
mov %edx,%eax
shl $0xa,%eax
xor %esi,%eax
mov %eax,0x4(%rdi)
add %eax,%edx
sub %edx,%ecx
sar $0xf,%eax
xor %ecx,%eax
mov %eax,0x8(%rdi)
ret
| <rgph_jenkins2_mix>:
endbr64
mov 0x8(%rdi),%edx
mov 0x4(%rdi),%eax
mov %rdi,%rcx
mov (%rdi),%esi
mov %edx,%edi
sub %eax,%esi
sar $0xd,%edi
sub %edx,%eax
sub %edx,%esi
xor %edi,%esi
mov %esi,%edi
sub %esi,%eax
sub %esi,%edx
shl $0x8,%edi
xor %edi,%eax
mov %eax,%edi
sub %eax,%edx
sub %eax,%esi
sar $0xd,%edi
xor %edi,%edx
mov %edx,%edi
sub %edx,%esi
sub %edx,%eax
sar $0xc,%edi
xor %edi,%esi
mov %esi,%edi
sub %esi,%eax
sub %esi,%edx
shl $0x10,%edi
xor %edi,%eax
mov %eax,%edi
sub %eax,%edx
sub %eax,%esi
sar $0x5,%edi
xor %edi,%edx
mov %edx,%edi
sub %edx,%esi
sub %edx,%eax
sar $0x3,%edi
xor %edi,%esi
mov %esi,%edi
sub %esi,%eax
mov %esi,(%rcx)
shl $0xa,%edi
xor %edi,%eax
sub %esi,%edx
sub %eax,%edx
mov %eax,0x4(%rcx)
sar $0xf,%eax
xor %eax,%edx
mov %edx,0x8(%rcx)
ret
| define void @rgph_jenkins2_mix(i32* nocapture %0) {
%2 = getelementptr inbounds i32, i32* %0, i64 1
%3 = load i32, i32* %2
%4 = load i32, i32* %0
%5 = getelementptr inbounds i32, i32* %0, i64 2
%6 = load i32, i32* %5
%7 = add i32 %3, %6
%8 = sub i32 %4, %7
%9 = ashr i32 %6, 13
%10 = xor i32 %8, %9
%11 = add i32 %6, %10
%12 = sub i32 %3, %11
%13 = shl i32 %10, 8
%14 = xor i32 %12, %13
%15 = add i32 %10, %14
%16 = sub i32 %6, %15
%17 = ashr i32 %14, 13
%18 = xor i32 %16, %17
%19 = add i32 %14, %18
%20 = sub i32 %10, %19
%21 = ashr i32 %18, 12
%22 = xor i32 %20, %21
%23 = add i32 %18, %22
%24 = sub i32 %14, %23
%25 = shl i32 %22, 16
%26 = xor i32 %24, %25
%27 = add i32 %22, %26
%28 = sub i32 %18, %27
%29 = ashr i32 %26, 5
%30 = xor i32 %28, %29
%31 = add i32 %26, %30
%32 = sub i32 %22, %31
%33 = ashr i32 %30, 3
%34 = xor i32 %32, %33
store i32 %34, i32* %0
%35 = add i32 %30, %34
%36 = sub i32 %26, %35
%37 = shl i32 %34, 10
%38 = xor i32 %36, %37
store i32 %38, i32* %2
%39 = add i32 %34, %38
%40 = sub i32 %30, %39
%41 = ashr i32 %38, 15
%42 = xor i32 %40, %41
store i32 %42, i32* %5
ret void
}
| <rgph_jenkins2_mix>:
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov -0x8(%rbp),%rax
mov 0x4(%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%ecx
sub %edx,%ecx
mov %ecx,(%rax)
mov -0x8(%rbp),%rax
mov 0x8(%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%ecx
sub %edx,%ecx
mov %ecx,(%rax)
mov -0x8(%rbp),%rax
mov 0x8(%rax),%ecx
sar $0xd,%ecx
mov -0x8(%rbp),%rax
xor (%rax),%ecx
mov %ecx,(%rax)
mov -0x8(%rbp),%rax
mov 0x8(%rax),%edx
mov -0x8(%rbp),%rax
mov 0x4(%rax),%ecx
sub %edx,%ecx
mov %ecx,0x4(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov 0x4(%rax),%ecx
sub %edx,%ecx
mov %ecx,0x4(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%ecx
shl $0x8,%ecx
mov -0x8(%rbp),%rax
xor 0x4(%rax),%ecx
mov %ecx,0x4(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov 0x8(%rax),%ecx
sub %edx,%ecx
mov %ecx,0x8(%rax)
mov -0x8(%rbp),%rax
mov 0x4(%rax),%edx
mov -0x8(%rbp),%rax
mov 0x8(%rax),%ecx
sub %edx,%ecx
mov %ecx,0x8(%rax)
mov -0x8(%rbp),%rax
mov 0x4(%rax),%ecx
sar $0xd,%ecx
mov -0x8(%rbp),%rax
xor 0x8(%rax),%ecx
mov %ecx,0x8(%rax)
mov -0x8(%rbp),%rax
mov 0x4(%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%ecx
sub %edx,%ecx
mov %ecx,(%rax)
mov -0x8(%rbp),%rax
mov 0x8(%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%ecx
sub %edx,%ecx
mov %ecx,(%rax)
mov -0x8(%rbp),%rax
mov 0x8(%rax),%ecx
sar $0xc,%ecx
mov -0x8(%rbp),%rax
xor (%rax),%ecx
mov %ecx,(%rax)
mov -0x8(%rbp),%rax
mov 0x8(%rax),%edx
mov -0x8(%rbp),%rax
mov 0x4(%rax),%ecx
sub %edx,%ecx
mov %ecx,0x4(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov 0x4(%rax),%ecx
sub %edx,%ecx
mov %ecx,0x4(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%ecx
shl $0x10,%ecx
mov -0x8(%rbp),%rax
xor 0x4(%rax),%ecx
mov %ecx,0x4(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov 0x8(%rax),%ecx
sub %edx,%ecx
mov %ecx,0x8(%rax)
mov -0x8(%rbp),%rax
mov 0x4(%rax),%edx
mov -0x8(%rbp),%rax
mov 0x8(%rax),%ecx
sub %edx,%ecx
mov %ecx,0x8(%rax)
mov -0x8(%rbp),%rax
mov 0x4(%rax),%ecx
sar $0x5,%ecx
mov -0x8(%rbp),%rax
xor 0x8(%rax),%ecx
mov %ecx,0x8(%rax)
mov -0x8(%rbp),%rax
mov 0x4(%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%ecx
sub %edx,%ecx
mov %ecx,(%rax)
mov -0x8(%rbp),%rax
mov 0x8(%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%ecx
sub %edx,%ecx
mov %ecx,(%rax)
mov -0x8(%rbp),%rax
mov 0x8(%rax),%ecx
sar $0x3,%ecx
mov -0x8(%rbp),%rax
xor (%rax),%ecx
mov %ecx,(%rax)
mov -0x8(%rbp),%rax
mov 0x8(%rax),%edx
mov -0x8(%rbp),%rax
mov 0x4(%rax),%ecx
sub %edx,%ecx
mov %ecx,0x4(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov 0x4(%rax),%ecx
sub %edx,%ecx
mov %ecx,0x4(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%ecx
shl $0xa,%ecx
mov -0x8(%rbp),%rax
xor 0x4(%rax),%ecx
mov %ecx,0x4(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov 0x8(%rax),%ecx
sub %edx,%ecx
mov %ecx,0x8(%rax)
mov -0x8(%rbp),%rax
mov 0x4(%rax),%edx
mov -0x8(%rbp),%rax
mov 0x8(%rax),%ecx
sub %edx,%ecx
mov %ecx,0x8(%rax)
mov -0x8(%rbp),%rax
mov 0x4(%rax),%ecx
sar $0xf,%ecx
mov -0x8(%rbp),%rax
xor 0x8(%rax),%ecx
mov %ecx,0x8(%rax)
pop %rbp
ret
| <rgph_jenkins2_mix>:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov -0x8(%rbp),%rax
mov (%rax),%eax
mov -0x8(%rbp),%rdx
add $0x4,%rdx
mov (%rdx),%ecx
sub %ecx,%eax
mov %eax,%edx
mov -0x8(%rbp),%rax
mov %edx,(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%eax
mov -0x8(%rbp),%rdx
add $0x8,%rdx
mov (%rdx),%ecx
sub %ecx,%eax
mov %eax,%edx
mov -0x8(%rbp),%rax
mov %edx,(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%eax
sar $0xd,%eax
xor %eax,%edx
mov -0x8(%rbp),%rax
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%ecx
mov -0x8(%rbp),%rax
add $0x4,%rax
sub %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%ecx
mov -0x8(%rbp),%rax
add $0x4,%rax
sub %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%eax
shl $0x8,%eax
mov %eax,%ecx
mov -0x8(%rbp),%rax
add $0x4,%rax
xor %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%ecx
mov -0x8(%rbp),%rax
add $0x8,%rax
sub %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%ecx
mov -0x8(%rbp),%rax
add $0x8,%rax
sub %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%eax
sar $0xd,%eax
mov %eax,%ecx
mov -0x8(%rbp),%rax
add $0x8,%rax
xor %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%eax
mov -0x8(%rbp),%rdx
add $0x4,%rdx
mov (%rdx),%ecx
sub %ecx,%eax
mov %eax,%edx
mov -0x8(%rbp),%rax
mov %edx,(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%eax
mov -0x8(%rbp),%rdx
add $0x8,%rdx
mov (%rdx),%ecx
sub %ecx,%eax
mov %eax,%edx
mov -0x8(%rbp),%rax
mov %edx,(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%eax
sar $0xc,%eax
xor %eax,%edx
mov -0x8(%rbp),%rax
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%ecx
mov -0x8(%rbp),%rax
add $0x4,%rax
sub %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%ecx
mov -0x8(%rbp),%rax
add $0x4,%rax
sub %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%eax
shl $0x10,%eax
mov %eax,%ecx
mov -0x8(%rbp),%rax
add $0x4,%rax
xor %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%ecx
mov -0x8(%rbp),%rax
add $0x8,%rax
sub %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%ecx
mov -0x8(%rbp),%rax
add $0x8,%rax
sub %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%eax
sar $0x5,%eax
mov %eax,%ecx
mov -0x8(%rbp),%rax
add $0x8,%rax
xor %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%eax
mov -0x8(%rbp),%rdx
add $0x4,%rdx
mov (%rdx),%ecx
sub %ecx,%eax
mov %eax,%edx
mov -0x8(%rbp),%rax
mov %edx,(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%eax
mov -0x8(%rbp),%rdx
add $0x8,%rdx
mov (%rdx),%ecx
sub %ecx,%eax
mov %eax,%edx
mov -0x8(%rbp),%rax
mov %edx,(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%eax
sar $0x3,%eax
xor %eax,%edx
mov -0x8(%rbp),%rax
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%ecx
mov -0x8(%rbp),%rax
add $0x4,%rax
sub %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%ecx
mov -0x8(%rbp),%rax
add $0x4,%rax
sub %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%eax
shl $0xa,%eax
mov %eax,%ecx
mov -0x8(%rbp),%rax
add $0x4,%rax
xor %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
mov (%rax),%ecx
mov -0x8(%rbp),%rax
add $0x8,%rax
sub %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%ecx
mov -0x8(%rbp),%rax
add $0x8,%rax
sub %ecx,%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
add $0x8,%rax
mov (%rax),%edx
mov -0x8(%rbp),%rax
add $0x4,%rax
mov (%rax),%eax
sar $0xf,%eax
mov %eax,%ecx
mov -0x8(%rbp),%rax
add $0x8,%rax
xor %ecx,%edx
mov %edx,(%rax)
nop
pop %rbp
ret
| define void @rgph_jenkins2_mix(i32* %0) {
%2 = alloca i32*
store i32* %0, i32** %2
%3 = load i32*, i32** %2
%4 = getelementptr inbounds i32, i32* %3, i64 1
%5 = load i32, i32* %4
%6 = load i32*, i32** %2
%7 = getelementptr inbounds i32, i32* %6, i64 0
%8 = load i32, i32* %7
%9 = sub nsw i32 %8, %5
store i32 %9, i32* %7
%10 = load i32*, i32** %2
%11 = getelementptr inbounds i32, i32* %10, i64 2
%12 = load i32, i32* %11
%13 = load i32*, i32** %2
%14 = getelementptr inbounds i32, i32* %13, i64 0
%15 = load i32, i32* %14
%16 = sub nsw i32 %15, %12
store i32 %16, i32* %14
%17 = load i32*, i32** %2
%18 = getelementptr inbounds i32, i32* %17, i64 2
%19 = load i32, i32* %18
%20 = ashr i32 %19, 13
%21 = load i32*, i32** %2
%22 = getelementptr inbounds i32, i32* %21, i64 0
%23 = load i32, i32* %22
%24 = xor i32 %23, %20
store i32 %24, i32* %22
%25 = load i32*, i32** %2
%26 = getelementptr inbounds i32, i32* %25, i64 2
%27 = load i32, i32* %26
%28 = load i32*, i32** %2
%29 = getelementptr inbounds i32, i32* %28, i64 1
%30 = load i32, i32* %29
%31 = sub nsw i32 %30, %27
store i32 %31, i32* %29
%32 = load i32*, i32** %2
%33 = getelementptr inbounds i32, i32* %32, i64 0
%34 = load i32, i32* %33
%35 = load i32*, i32** %2
%36 = getelementptr inbounds i32, i32* %35, i64 1
%37 = load i32, i32* %36
%38 = sub nsw i32 %37, %34
store i32 %38, i32* %36
%39 = load i32*, i32** %2
%40 = getelementptr inbounds i32, i32* %39, i64 0
%41 = load i32, i32* %40
%42 = shl i32 %41, 8
%43 = load i32*, i32** %2
%44 = getelementptr inbounds i32, i32* %43, i64 1
%45 = load i32, i32* %44
%46 = xor i32 %45, %42
store i32 %46, i32* %44
%47 = load i32*, i32** %2
%48 = getelementptr inbounds i32, i32* %47, i64 0
%49 = load i32, i32* %48
%50 = load i32*, i32** %2
%51 = getelementptr inbounds i32, i32* %50, i64 2
%52 = load i32, i32* %51
%53 = sub nsw i32 %52, %49
store i32 %53, i32* %51
%54 = load i32*, i32** %2
%55 = getelementptr inbounds i32, i32* %54, i64 1
%56 = load i32, i32* %55
%57 = load i32*, i32** %2
%58 = getelementptr inbounds i32, i32* %57, i64 2
%59 = load i32, i32* %58
%60 = sub nsw i32 %59, %56
store i32 %60, i32* %58
%61 = load i32*, i32** %2
%62 = getelementptr inbounds i32, i32* %61, i64 1
%63 = load i32, i32* %62
%64 = ashr i32 %63, 13
%65 = load i32*, i32** %2
%66 = getelementptr inbounds i32, i32* %65, i64 2
%67 = load i32, i32* %66
%68 = xor i32 %67, %64
store i32 %68, i32* %66
%69 = load i32*, i32** %2
%70 = getelementptr inbounds i32, i32* %69, i64 1
%71 = load i32, i32* %70
%72 = load i32*, i32** %2
%73 = getelementptr inbounds i32, i32* %72, i64 0
%74 = load i32, i32* %73
%75 = sub nsw i32 %74, %71
store i32 %75, i32* %73
%76 = load i32*, i32** %2
%77 = getelementptr inbounds i32, i32* %76, i64 2
%78 = load i32, i32* %77
%79 = load i32*, i32** %2
%80 = getelementptr inbounds i32, i32* %79, i64 0
%81 = load i32, i32* %80
%82 = sub nsw i32 %81, %78
store i32 %82, i32* %80
%83 = load i32*, i32** %2
%84 = getelementptr inbounds i32, i32* %83, i64 2
%85 = load i32, i32* %84
%86 = ashr i32 %85, 12
%87 = load i32*, i32** %2
%88 = getelementptr inbounds i32, i32* %87, i64 0
%89 = load i32, i32* %88
%90 = xor i32 %89, %86
store i32 %90, i32* %88
%91 = load i32*, i32** %2
%92 = getelementptr inbounds i32, i32* %91, i64 2
%93 = load i32, i32* %92
%94 = load i32*, i32** %2
%95 = getelementptr inbounds i32, i32* %94, i64 1
%96 = load i32, i32* %95
%97 = sub nsw i32 %96, %93
store i32 %97, i32* %95
%98 = load i32*, i32** %2
%99 = getelementptr inbounds i32, i32* %98, i64 0
%100 = load i32, i32* %99
%101 = load i32*, i32** %2
%102 = getelementptr inbounds i32, i32* %101, i64 1
%103 = load i32, i32* %102
%104 = sub nsw i32 %103, %100
store i32 %104, i32* %102
%105 = load i32*, i32** %2
%106 = getelementptr inbounds i32, i32* %105, i64 0
%107 = load i32, i32* %106
%108 = shl i32 %107, 16
%109 = load i32*, i32** %2
%110 = getelementptr inbounds i32, i32* %109, i64 1
%111 = load i32, i32* %110
%112 = xor i32 %111, %108
store i32 %112, i32* %110
%113 = load i32*, i32** %2
%114 = getelementptr inbounds i32, i32* %113, i64 0
%115 = load i32, i32* %114
%116 = load i32*, i32** %2
%117 = getelementptr inbounds i32, i32* %116, i64 2
%118 = load i32, i32* %117
%119 = sub nsw i32 %118, %115
store i32 %119, i32* %117
%120 = load i32*, i32** %2
%121 = getelementptr inbounds i32, i32* %120, i64 1
%122 = load i32, i32* %121
%123 = load i32*, i32** %2
%124 = getelementptr inbounds i32, i32* %123, i64 2
%125 = load i32, i32* %124
%126 = sub nsw i32 %125, %122
store i32 %126, i32* %124
%127 = load i32*, i32** %2
%128 = getelementptr inbounds i32, i32* %127, i64 1
%129 = load i32, i32* %128
%130 = ashr i32 %129, 5
%131 = load i32*, i32** %2
%132 = getelementptr inbounds i32, i32* %131, i64 2
%133 = load i32, i32* %132
%134 = xor i32 %133, %130
store i32 %134, i32* %132
%135 = load i32*, i32** %2
%136 = getelementptr inbounds i32, i32* %135, i64 1
%137 = load i32, i32* %136
%138 = load i32*, i32** %2
%139 = getelementptr inbounds i32, i32* %138, i64 0
%140 = load i32, i32* %139
%141 = sub nsw i32 %140, %137
store i32 %141, i32* %139
%142 = load i32*, i32** %2
%143 = getelementptr inbounds i32, i32* %142, i64 2
%144 = load i32, i32* %143
%145 = load i32*, i32** %2
%146 = getelementptr inbounds i32, i32* %145, i64 0
%147 = load i32, i32* %146
%148 = sub nsw i32 %147, %144
store i32 %148, i32* %146
%149 = load i32*, i32** %2
%150 = getelementptr inbounds i32, i32* %149, i64 2
%151 = load i32, i32* %150
%152 = ashr i32 %151, 3
%153 = load i32*, i32** %2
%154 = getelementptr inbounds i32, i32* %153, i64 0
%155 = load i32, i32* %154
%156 = xor i32 %155, %152
store i32 %156, i32* %154
%157 = load i32*, i32** %2
%158 = getelementptr inbounds i32, i32* %157, i64 2
%159 = load i32, i32* %158
%160 = load i32*, i32** %2
%161 = getelementptr inbounds i32, i32* %160, i64 1
%162 = load i32, i32* %161
%163 = sub nsw i32 %162, %159
store i32 %163, i32* %161
%164 = load i32*, i32** %2
%165 = getelementptr inbounds i32, i32* %164, i64 0
%166 = load i32, i32* %165
%167 = load i32*, i32** %2
%168 = getelementptr inbounds i32, i32* %167, i64 1
%169 = load i32, i32* %168
%170 = sub nsw i32 %169, %166
store i32 %170, i32* %168
%171 = load i32*, i32** %2
%172 = getelementptr inbounds i32, i32* %171, i64 0
%173 = load i32, i32* %172
%174 = shl i32 %173, 10
%175 = load i32*, i32** %2
%176 = getelementptr inbounds i32, i32* %175, i64 1
%177 = load i32, i32* %176
%178 = xor i32 %177, %174
store i32 %178, i32* %176
%179 = load i32*, i32** %2
%180 = getelementptr inbounds i32, i32* %179, i64 0
%181 = load i32, i32* %180
%182 = load i32*, i32** %2
%183 = getelementptr inbounds i32, i32* %182, i64 2
%184 = load i32, i32* %183
%185 = sub nsw i32 %184, %181
store i32 %185, i32* %183
%186 = load i32*, i32** %2
%187 = getelementptr inbounds i32, i32* %186, i64 1
%188 = load i32, i32* %187
%189 = load i32*, i32** %2
%190 = getelementptr inbounds i32, i32* %189, i64 2
%191 = load i32, i32* %190
%192 = sub nsw i32 %191, %188
store i32 %192, i32* %190
%193 = load i32*, i32** %2
%194 = getelementptr inbounds i32, i32* %193, i64 1
%195 = load i32, i32* %194
%196 = ashr i32 %195, 15
%197 = load i32*, i32** %2
%198 = getelementptr inbounds i32, i32* %197, i64 2
%199 = load i32, i32* %198
%200 = xor i32 %199, %196
store i32 %200, i32* %198
ret void
}
| <rgph_jenkins2_mix>:
mov (%rdi),%eax
mov 0x4(%rdi),%r8d
mov 0x8(%rdi),%r9d
sub %r8d,%eax
sub %r9d,%eax
mov %r9d,%esi
sar $0xd,%esi
xor %eax,%esi
sub %r9d,%r8d
sub %esi,%r8d
mov %esi,%ecx
shl $0x8,%ecx
xor %r8d,%ecx
sub %esi,%r9d
sub %ecx,%r9d
mov %ecx,%edx
sar $0xd,%edx
xor %r9d,%edx
sub %ecx,%esi
sub %edx,%esi
mov %edx,%eax
sar $0xc,%eax
xor %esi,%eax
sub %edx,%ecx
sub %eax,%ecx
mov %eax,%esi
shl $0x10,%esi
xor %ecx,%esi
sub %eax,%edx
sub %esi,%edx
mov %esi,%ecx
sar $0x5,%ecx
xor %edx,%ecx
sub %esi,%eax
sub %ecx,%eax
mov %ecx,%edx
sar $0x3,%edx
xor %eax,%edx
mov %edx,(%rdi)
sub %ecx,%esi
sub %edx,%esi
mov %edx,%eax
shl $0xa,%eax
xor %esi,%eax
mov %eax,0x4(%rdi)
add %eax,%edx
sub %edx,%ecx
sar $0xf,%eax
xor %ecx,%eax
mov %eax,0x8(%rdi)
ret
| <rgph_jenkins2_mix>:
endbr64
mov 0x8(%rdi),%edx
mov 0x4(%rdi),%eax
mov %rdi,%rcx
mov (%rdi),%esi
mov %edx,%edi
sub %eax,%esi
sar $0xd,%edi
sub %edx,%eax
sub %edx,%esi
xor %edi,%esi
mov %esi,%edi
sub %esi,%eax
sub %esi,%edx
shl $0x8,%edi
xor %edi,%eax
mov %eax,%edi
sub %eax,%edx
sub %eax,%esi
sar $0xd,%edi
xor %edi,%edx
mov %edx,%edi
sub %edx,%esi
sub %edx,%eax
sar $0xc,%edi
xor %edi,%esi
mov %esi,%edi
sub %esi,%eax
sub %esi,%edx
shl $0x10,%edi
xor %edi,%eax
mov %eax,%edi
sub %eax,%edx
sub %eax,%esi
sar $0x5,%edi
xor %edi,%edx
mov %edx,%edi
sub %edx,%esi
sub %edx,%eax
sar $0x3,%edi
xor %edi,%esi
mov %esi,%edi
sub %esi,%eax
mov %esi,(%rcx)
shl $0xa,%edi
xor %edi,%eax
sub %esi,%edx
sub %eax,%edx
mov %eax,0x4(%rcx)
sar $0xf,%eax
xor %eax,%edx
mov %edx,0x8(%rcx)
ret
| define void @rgph_jenkins2_mix(i32* nocapture %0) {
%2 = getelementptr inbounds i32, i32* %0, i64 1
%3 = load i32, i32* %2
%4 = load i32, i32* %0
%5 = getelementptr inbounds i32, i32* %0, i64 2
%6 = load i32, i32* %5
%7 = add i32 %3, %6
%8 = sub i32 %4, %7
%9 = ashr i32 %6, 13
%10 = xor i32 %8, %9
%11 = add i32 %6, %10
%12 = sub i32 %3, %11
%13 = shl i32 %10, 8
%14 = xor i32 %12, %13
%15 = add i32 %10, %14
%16 = sub i32 %6, %15
%17 = ashr i32 %14, 13
%18 = xor i32 %16, %17
%19 = add i32 %14, %18
%20 = sub i32 %10, %19
%21 = ashr i32 %18, 12
%22 = xor i32 %20, %21
%23 = add i32 %18, %22
%24 = sub i32 %14, %23
%25 = shl i32 %22, 16
%26 = xor i32 %24, %25
%27 = add i32 %22, %26
%28 = sub i32 %18, %27
%29 = ashr i32 %26, 5
%30 = xor i32 %28, %29
%31 = add i32 %26, %30
%32 = sub i32 %22, %31
%33 = ashr i32 %30, 3
%34 = xor i32 %32, %33
store i32 %34, i32* %0
%35 = add i32 %30, %34
%36 = sub i32 %26, %35
%37 = shl i32 %34, 10
%38 = xor i32 %36, %37
store i32 %38, i32* %2
%39 = add i32 %34, %38
%40 = sub i32 %30, %39
%41 = ashr i32 %38, 15
%42 = xor i32 %40, %41
store i32 %42, i32* %5
ret void
}
| 12 | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
typedef int uint32_t ;
/* Variables and functions */
| void rgph_jenkins2_mix(uint32_t h[ ]) {
h[0] -= h[1]; h[0] -= h[2]; h[0] ^= (h[2] >> 13);
h[1] -= h[2]; h[1] -= h[0]; h[1] ^= (h[0] << 8);
h[2] -= h[0]; h[2] -= h[1]; h[2] ^= (h[1] >> 13);
h[0] -= h[1]; h[0] -= h[2]; h[0] ^= (h[2] >> 12);
h[1] -= h[2]; h[1] -= h[0]; h[1] ^= (h[0] << 16);
h[2] -= h[0]; h[2] -= h[1]; h[2] ^= (h[1] >> 5);
h[0] -= h[1]; h[0] -= h[2]; h[0] ^= (h[2] >> 3);
h[1] -= h[2]; h[1] -= h[0]; h[1] ^= (h[0] << 10);
h[2] -= h[0]; h[2] -= h[1]; h[2] ^= (h[1] >> 15);
} | rgph_jenkins2_mix | #define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
typedef int uint32_t;
/* Variables and functions */
void rgph_jenkins2_mix(uint32_t h[]) {
h[0] -= h[1];
h[0] -= h[2];
h[0] ^= (h[2] >> 13);
h[1] -= h[2];
h[1] -= h[0];
h[1] ^= (h[0] << 8);
h[2] -= h[0];
h[2] -= h[1];
h[2] ^= (h[1] >> 13);
h[0] -= h[1];
h[0] -= h[2];
h[0] ^= (h[2] >> 12);
h[1] -= h[2];
h[1] -= h[0];
h[1] ^= (h[0] << 16);
h[2] -= h[0];
h[2] -= h[1];
h[2] ^= (h[1] >> 5);
h[0] -= h[1];
h[0] -= h[2];
h[0] ^= (h[2] >> 3);
h[1] -= h[2];
h[1] -= h[0];
h[1] ^= (h[0] << 10);
h[2] -= h[0];
h[2] -= h[1];
h[2] ^= (h[1] >> 15);
}
|
<starts_with>:
push %r15
push %r14
push %rbx
mov %rsi,%r14
mov %rdi,%r15
call 1030 <strlen@plt>
lea 0x1(%rax),%edi
call 1050 <malloc@plt>
mov %rax,%rbx
lea 0xe9e(%rip),%rsi
mov %r15,%rdi
mov %rax,%rdx
call 1060 <sscanf@plt>
mov %r14,%rdi
mov %rbx,%rsi
call 1040 <strcmp@plt>
pop %rbx
pop %r14
pop %r15
ret
| <starts_with>:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %rsi,%r12
call 1080 <strlen@plt>
lea 0x1(%rax),%edi
call 10a0 <malloc@plt>
mov %rax,%rbx
mov %rax,%rdx
lea 0xe5f(%rip),%rsi
mov %rbp,%rdi
call 10b0 <sscanf@plt>
mov %rbx,%rsi
mov %r12,%rdi
call 1090 <strcmp@plt>
pop %rbx
pop %rbp
pop %r12
ret
| @.str = [3 x i8] c"%s\00"
define i32 @starts_with(i8* %0, i8* nocapture %1) {
%3 = call i32 @strlen(i8* %0)
%4 = add nsw i32 %3, 1
%5 = call i64 @malloc(i32 %4)
%6 = inttoptr i64 %5 to i8*
%7 = call i32 @sscanf(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %6)
%8 = call i32 @strcmp(i8* dereferenceable(1) %1, i8* dereferenceable(1) %6)
ret i32 %8
}
| <starts_with>:
push %r15
push %r14
push %rbx
mov %rsi,%r14
mov %rdi,%r15
call 1030 <strlen@plt>
lea 0x1(%rax),%edi
call 1050 <malloc@plt>
mov %rax,%rbx
lea 0xe9e(%rip),%rsi
mov %r15,%rdi
mov %rax,%rdx
call 1060 <sscanf@plt>
mov %r14,%rdi
mov %rbx,%rsi
pop %rbx
pop %r14
pop %r15
jmp 1040 <strcmp@plt>
| <starts_with>:
endbr64
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
call 1080 <strlen@plt>
lea 0x1(%rax),%edi
call 10a0 <malloc@plt>
mov %r12,%rdi
lea 0xe5a(%rip),%rsi
mov %rax,%rbp
mov %rax,%rdx
call 10b0 <sscanf@plt>
mov %rbp,%rsi
mov %r13,%rdi
pop %rbp
pop %r12
pop %r13
jmp 1090 <strcmp@plt>
| @.str = [3 x i8] c"%s\00"
define i32 @starts_with(i8* %0, i8* nocapture %1) {
%3 = tail call i32 @strlen(i8* %0)
%4 = add nsw i32 %3, 1
%5 = tail call i64 @malloc(i32 %4)
%6 = inttoptr i64 %5 to i8*
%7 = tail call i32 @sscanf(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %6)
%8 = tail call i32 @strcmp(i8* dereferenceable(1) %1, i8* dereferenceable(1) %6)
ret i32 %8
}
| <starts_with>:
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x8(%rbp)
mov %rsi,-0x10(%rbp)
mov -0x8(%rbp),%rdi
call 1030 <strlen@plt>
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
add $0x1,%eax
cltq
shl $0x0,%rax
mov %eax,%edi
call 1050 <malloc@plt>
mov %rax,-0x20(%rbp)
mov -0x8(%rbp),%rdi
mov -0x20(%rbp),%rdx
lea 0xe7e(%rip),%rsi
call 1060 <sscanf@plt>
mov -0x10(%rbp),%rdi
mov -0x20(%rbp),%rsi
call 1040 <strcmp@plt>
add $0x20,%rsp
pop %rbp
ret
| <starts_with>:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
call 1080 <strlen@plt>
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
add $0x1,%eax
mov %eax,%edi
call 10a0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rdx
mov -0x18(%rbp),%rax
lea 0xe44(%rip),%rcx
mov %rcx,%rsi
mov %rax,%rdi
call 10b0 <sscanf@plt>
mov -0x8(%rbp),%rdx
mov -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
call 1090 <strcmp@plt>
leave
ret
| @.str = [3 x i8] c"%s\00"
define i32 @starts_with(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i8*
store i8* %0, i8** %3
store i8* %1, i8** %4
%7 = load i8*, i8** %3
%8 = call i32 @strlen(i8* %7)
store i32 %8, i32* %5
%9 = load i32, i32* %5
%10 = add nsw i32 %9, 1
%11 = sext i32 %10 to i64
%12 = mul i64 %11, 1
%13 = trunc i64 %12 to i32
%14 = call i64 @malloc(i32 %13)
%15 = inttoptr i64 %14 to i8*
store i8* %15, i8** %6
%16 = load i8*, i8** %3
%17 = load i8*, i8** %6
%18 = call i32 @sscanf(i8* %16, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %17)
%19 = load i8*, i8** %4
%20 = load i8*, i8** %6
%21 = call i32 @strcmp(i8* %19, i8* %20)
ret i32 %21
}
| <starts_with>:
push %r15
push %r14
push %rbx
mov %rsi,%r14
mov %rdi,%r15
call 1030 <strlen@plt>
lea 0x1(%rax),%edi
call 1050 <malloc@plt>
mov %rax,%rbx
lea 0xe9e(%rip),%rsi
mov %r15,%rdi
mov %rax,%rdx
call 1060 <sscanf@plt>
mov %r14,%rdi
mov %rbx,%rsi
pop %rbx
pop %r14
pop %r15
jmp 1040 <strcmp@plt>
| <starts_with>:
endbr64
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
call 1080 <strlen@plt>
lea 0x1(%rax),%edi
call 10a0 <malloc@plt>
mov %r12,%rdi
lea 0xe5a(%rip),%rsi
mov %rax,%rbp
mov %rax,%rdx
call 10b0 <sscanf@plt>
mov %rbp,%rsi
mov %r13,%rdi
pop %rbp
pop %r12
pop %r13
jmp 1090 <strcmp@plt>
| @.str = [3 x i8] c"%s\00"
define i32 @starts_with(i8* %0, i8* nocapture %1) {
%3 = tail call i32 @strlen(i8* %0)
%4 = add nsw i32 %3, 1
%5 = tail call i64 @malloc(i32 %4)
%6 = inttoptr i64 %5 to i8*
%7 = tail call i32 @sscanf(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %6)
%8 = tail call i32 @strcmp(i8* dereferenceable(1) %1, i8* dereferenceable(1) %6)
ret i32 %8
}
| 13 | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
scalar_t__ malloc (int) ;
int /*<<< orphan*/ sscanf (char*,char*,char*) ;
int strcmp (char*,char*) ;
int strlen (char*) ;
| int starts_with(char *str, char *word) {
int len;
char *first_word;
len = strlen(str);
first_word = (char *)malloc((len + 1) * sizeof(char));
sscanf(str, "%s", first_word);
return strcmp(word, first_word);
} | starts_with | #define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
scalar_t__ malloc(int);
int /*<<< orphan*/ sscanf(char *, char *, char *);
int strcmp(char *, char *);
int strlen(char *);
int starts_with(char *str, char *word) {
int len;
char *first_word;
len = strlen(str);
first_word = (char *)malloc((len + 1) * sizeof(char));
sscanf(str, "%s", first_word);
return strcmp(word, first_word);
}
|
<test01_inv>:
xor %eax,%eax
cmp %esi,%edi
setl %al
add $0x7fffffff,%eax
ret
| <test01_inv>:
endbr64
cmp %esi,%edi
setl %al
movzbl %al,%eax
add $0x7fffffff,%eax
ret
| define i32 @test01_inv(i32 %0, i32 %1) {
%3 = icmp slt i32 %0, %1
%4 = select i1 %3, i32 -2147483648, i32 2147483647
ret i32 %4
}
| <test01_inv>:
xor %eax,%eax
cmp %esi,%edi
setl %al
add $0x7fffffff,%eax
ret
| <test01_inv>:
endbr64
xor %eax,%eax
cmp %esi,%edi
setl %al
add $0x7fffffff,%eax
ret
| define i32 @test01_inv(i32 %0, i32 %1) {
%3 = icmp slt i32 %0, %1
%4 = select i1 %3, i32 -2147483648, i32 2147483647
ret i32 %4
}
| <test01_inv>:
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%esi
mov $0x7fffffff,%eax
mov $0x80000000,%ecx
cmp %esi,%edx
cmovl %ecx,%eax
pop %rbp
ret
| <test01_inv>:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jge 1116 <test01_inv+0x1d>
mov $0x80000000,%eax
jmp 111b <test01_inv+0x22>
mov $0x7fffffff,%eax
pop %rbp
ret
| define i32 @test01_inv(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 = load i32, i32* %4
%7 = icmp slt i32 %5, %6
%8 = zext i1 %7 to i64
%9 = select i1 %7, i32 -2147483648, i32 2147483647
ret i32 %9
}
| <test01_inv>:
xor %eax,%eax
cmp %esi,%edi
setl %al
add $0x7fffffff,%eax
ret
| <test01_inv>:
endbr64
xor %eax,%eax
cmp %esi,%edi
setl %al
add $0x7fffffff,%eax
ret
| define i32 @test01_inv(i32 %0, i32 %1) {
%3 = icmp slt i32 %0, %1
%4 = select i1 %3, i32 -2147483648, i32 2147483647
ret i32 %4
}
| 14 | null | int test01_inv (int a, int b) {
return (a < b) ? 0x80000000 : 0x7FFFFFFF;
} | test01_inv | int test01_inv(int a, int b) { return (a < b) ? 0x80000000 : 0x7FFFFFFF; }
|
<led_util_close_file>:
push %rbx
test %rdi,%rdi
je 112d <led_util_close_file+0x1d>
mov %rdi,%rbx
mov (%rdi),%edi
cmp $0xffffffff,%edi
je 112d <led_util_close_file+0x1d>
xor %eax,%eax
call 1030 <close@plt>
movl $0xffffffff,(%rbx)
pop %rbx
ret
| <led_util_close_file>:
endbr64
test %rdi,%rdi
je 1141 <led_util_close_file+0x28>
push %rbx
mov %rdi,%rbx
mov (%rdi),%edi
cmp $0xffffffff,%edi
jne 112f <led_util_close_file+0x16>
pop %rbx
ret
mov $0x0,%eax
call 1050 <close@plt>
movl $0xffffffff,(%rbx)
jmp 112d <led_util_close_file+0x14>
ret
| define void @led_util_close_file(i32* %0) {
%2 = icmp eq i32* %0, null
br i1 %2, label %8, label %3
3: ; preds = %1
%4 = load i32, i32* %0
%5 = icmp eq i32 %4, -1
br i1 %5, label %8, label %6
6: ; preds = %3
%7 = call i32 (i32, ...) bitcast (i32 (...)* @close to i32 (i32, ...)*)(i32 %4)
store i32 -1, i32* %0
br label %8
8: ; preds = %6, %3, %1
ret void
}
| <led_util_close_file>:
push %rbx
test %rdi,%rdi
je 112d <led_util_close_file+0x1d>
mov %rdi,%rbx
mov (%rdi),%edi
cmp $0xffffffff,%edi
je 112d <led_util_close_file+0x1d>
xor %eax,%eax
call 1030 <close@plt>
movl $0xffffffff,(%rbx)
pop %rbx
ret
| <led_util_close_file>:
endbr64
test %rdi,%rdi
je 1150 <led_util_close_file+0x30>
push %rbx
mov %rdi,%rbx
mov (%rdi),%edi
cmp $0xffffffff,%edi
jne 1140 <led_util_close_file+0x20>
pop %rbx
ret
cs nopw 0x0(%rax,%rax,1)
xor %eax,%eax
call 1050 <close@plt>
movl $0xffffffff,(%rbx)
pop %rbx
ret
nop
ret
| define void @led_util_close_file(i32* %0) {
%2 = icmp eq i32* %0, null
br i1 %2, label %8, label %3
3: ; preds = %1
%4 = load i32, i32* %0
%5 = icmp eq i32 %4, -1
br i1 %5, label %8, label %6
6: ; preds = %3
%7 = tail call i32 (i32, ...) bitcast (i32 (...)* @close to i32 (i32, ...)*)(i32 %4)
store i32 -1, i32* %0
br label %8
8: ; preds = %6, %3, %1
ret void
}
| <led_util_close_file>:
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
je 114b <led_util_close_file+0x3b>
mov -0x8(%rbp),%rax
cmpl $0xffffffff,(%rax)
je 114b <led_util_close_file+0x3b>
mov -0x8(%rbp),%rax
mov (%rax),%edi
mov $0x0,%al
call 1030 <close@plt>
mov -0x8(%rbp),%rax
movl $0xffffffff,(%rax)
add $0x10,%rsp
pop %rbp
ret
| <led_util_close_file>:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
je 1157 <led_util_close_file+0x3e>
mov -0x8(%rbp),%rax
mov (%rax),%eax
cmp $0xffffffff,%eax
je 1157 <led_util_close_file+0x3e>
mov -0x8(%rbp),%rax
mov (%rax),%eax
mov %eax,%edi
mov $0x0,%eax
call 1050 <close@plt>
mov -0x8(%rbp),%rax
movl $0xffffffff,(%rax)
nop
leave
ret
| define void @led_util_close_file(i32* %0) {
%2 = alloca i32*
store i32* %0, i32** %2
%3 = load i32*, i32** %2
%4 = icmp ne i32* %3, null
br i1 %4, label %5, label %14
5: ; preds = %1
%6 = load i32*, i32** %2
%7 = load i32, i32* %6
%8 = icmp ne i32 %7, -1
br i1 %8, label %9, label %14
9: ; preds = %5
%10 = load i32*, i32** %2
%11 = load i32, i32* %10
%12 = call i32 (i32, ...) bitcast (i32 (...)* @close to i32 (i32, ...)*)(i32 %11)
%13 = load i32*, i32** %2
store i32 -1, i32* %13
br label %14
14: ; preds = %9, %5, %1
ret void
}
| <led_util_close_file>:
push %rbx
test %rdi,%rdi
je 112d <led_util_close_file+0x1d>
mov %rdi,%rbx
mov (%rdi),%edi
cmp $0xffffffff,%edi
je 112d <led_util_close_file+0x1d>
xor %eax,%eax
call 1030 <close@plt>
movl $0xffffffff,(%rbx)
pop %rbx
ret
| <led_util_close_file>:
endbr64
test %rdi,%rdi
je 1150 <led_util_close_file+0x30>
push %rbx
mov %rdi,%rbx
mov (%rdi),%edi
cmp $0xffffffff,%edi
jne 1140 <led_util_close_file+0x20>
pop %rbx
ret
cs nopw 0x0(%rax,%rax,1)
xor %eax,%eax
call 1050 <close@plt>
movl $0xffffffff,(%rbx)
pop %rbx
ret
nop
ret
| define void @led_util_close_file(i32* %0) {
%2 = icmp eq i32* %0, null
br i1 %2, label %8, label %3
3: ; preds = %1
%4 = load i32, i32* %0
%5 = icmp eq i32 %4, -1
br i1 %5, label %8, label %6
6: ; preds = %3
%7 = tail call i32 (i32, ...) bitcast (i32 (...)* @close to i32 (i32, ...)*)(i32 %4)
store i32 -1, i32* %0
br label %8
8: ; preds = %6, %3, %1
ret void
}
| 15 | void led_util_close_file(int *fd_ptr) {
if( fd_ptr && *fd_ptr != -1 )
{
close(*fd_ptr), *fd_ptr = -1;
}
} | led_util_close_file |
void led_util_close_file(int *fd_ptr) {
if (fd_ptr && *fd_ptr != -1) {
close(*fd_ptr), *fd_ptr = -1;
}
}
|
End of preview. Expand
in Data Studio
We recompiled the train_real_compilable subset of the Exebench dataset for the x86 Linux platform.
There are 885,074 C functions in the dataset, and we successfully compiled 788,262 of them.
Each function includes the assembly code generated by the Clang and GCC compilers, the LLVM-IR generated by the Clang compiler, and the corresponding source code at four optimization levels O0-O3.
Generate the final decompiled dataset through the generate_dataset.py script.
- Downloads last month
- 7
Size of the auto-converted Parquet files (First 5GB):
1.58 GB
Number of rows (First 5GB):
346,396
Estimated number of rows:
523,149
Models trained or fine-tuned on xunge/LIRAD