index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
4,682 | func0 |
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
| int* func0(int test_tup1[], int test_tup2[], int n) {
int* res = malloc(sizeof(int) * n);
for(int i = 0; i < n; i++) {
res[i] = (int)pow(test_tup1[i], test_tup2[i]);
}
return res;
}
| int main() {
int test1_tup1[] = {10, 4, 5, 6};
int test1_tup2[] = {5, 6, 7, 5};
int expected1[] = {100000, 4096, 78125, 7776};
int* res1 = func0(test1_tup1, test1_tup2, 4);
assert(memcmp(res1, expected1, sizeof(expected1)) == 0);
free(res1);
int test2_tup1[] = {11, 5, 6, 7};
int test2_tup2[] = {6, 7, 8, 6};
int expected2[] = {1771561, 78125, 1679616, 117649};
int* res2 = func0(test2_tup1, test2_tup2, 4);
assert(memcmp(res2, expected2, sizeof(expected2)) == 0);
free(res2);
int test3_tup1[] = {12, 6, 7, 8};
int test3_tup2[] = {7, 8, 9, 7};
int expected3[] = {35831808, 1679616, 40353607, 2097152};
int* res3 = func0(test3_tup1, test3_tup2, 4);
assert(memcmp(res3, expected3, sizeof(expected3)) == 0);
free(res3);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
mov %rsi,%r13
push %r12
push %rbp
mov %rdi,%rbp
movslq %edx,%rdi
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 146e <func0+0x5e>
lea -0x1(%rbx),%r14d
xor %ebx,%ebx
xchg %ax,%ax
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl 0x0(%rbp,%rbx,4),%xmm0
cvtsi2sdl 0x0(%r13,%rbx,4),%xmm1
callq 10a0 <pow@plt>
cvttsd2si %xmm0,%eax
mov %eax,(%r12,%rbx,4)
mov %rbx,%rax
add $0x1,%rbx
cmp %r14,%rax
jne 1440 <func0+0x30>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
movsxd r14, edx
push r13
mov r13, rsi
push r12
push rbp
mov rbp, rdi
lea rdi, ds:0[r14*4]
push rbx
call _malloc
mov r12, rax
test r14d, r14d
jle short loc_146B
xor ebx, ebx
nop dword ptr [rax+00h]
loc_1440:
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, dword ptr [rbp+rbx*4+0]
cvtsi2sd xmm1, dword ptr [r13+rbx*4+0]
call _pow
cvttsd2si eax, xmm0
mov [r12+rbx*4], eax
add rbx, 1
cmp r14, rbx
jnz short loc_1440
loc_146B:
pop rbx
mov rax, r12
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // r14
long long v4; // r12
long long i; // rbx
v3 = a3;
v4 = malloc(4LL * a3);
if ( (int)v3 > 0 )
{
for ( i = 0LL; i != v3; ++i )
*(_DWORD *)(v4 + 4 * i) = (int)pow((double)*(int *)(a1 + 4 * i), (double)*(int *)(a2 + 4 * i));
}
return v4;
} | func0:
ENDBR64
PUSH R14
MOVSXD R14,EDX
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
MOV RBP,RDI
LEA RDI,[R14*0x4]
PUSH RBX
CALL 0x001010d0
MOV R12,RAX
TEST R14D,R14D
JLE 0x0010146b
XOR EBX,EBX
NOP dword ptr [RAX]
LAB_00101440:
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,dword ptr [RBP + RBX*0x4]
CVTSI2SD XMM1,dword ptr [R13 + RBX*0x4]
CALL 0x001010a0
CVTTSD2SI EAX,XMM0
MOV dword ptr [R12 + RBX*0x4],EAX
ADD RBX,0x1
CMP R14,RBX
JNZ 0x00101440
LAB_0010146b:
POP RBX
MOV RAX,R12
POP RBP
POP R12
POP R13
POP R14
RET | void * func0(long param_1,long param_2,int param_3)
{
void *pvVar1;
long lVar2;
double dVar3;
pvVar1 = malloc((long)param_3 * 4);
if (0 < param_3) {
lVar2 = 0;
do {
dVar3 = pow((double)*(int *)(param_1 + lVar2 * 4),(double)*(int *)(param_2 + lVar2 * 4));
*(int *)((long)pvVar1 + lVar2 * 4) = (int)dVar3;
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
return pvVar1;
} |
4,683 | func0 |
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
| int* func0(int test_tup1[], int test_tup2[], int n) {
int* res = malloc(sizeof(int) * n);
for(int i = 0; i < n; i++) {
res[i] = (int)pow(test_tup1[i], test_tup2[i]);
}
return res;
}
| int main() {
int test1_tup1[] = {10, 4, 5, 6};
int test1_tup2[] = {5, 6, 7, 5};
int expected1[] = {100000, 4096, 78125, 7776};
int* res1 = func0(test1_tup1, test1_tup2, 4);
assert(memcmp(res1, expected1, sizeof(expected1)) == 0);
free(res1);
int test2_tup1[] = {11, 5, 6, 7};
int test2_tup2[] = {6, 7, 8, 6};
int expected2[] = {1771561, 78125, 1679616, 117649};
int* res2 = func0(test2_tup1, test2_tup2, 4);
assert(memcmp(res2, expected2, sizeof(expected2)) == 0);
free(res2);
int test3_tup1[] = {12, 6, 7, 8};
int test3_tup2[] = {7, 8, 9, 7};
int expected3[] = {35831808, 1679616, 40353607, 2097152};
int* res3 = func0(test3_tup1, test3_tup2, 4);
assert(memcmp(res3, expected3, sizeof(expected3)) == 0);
free(res3);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
mov %rsi,%r13
push %r12
push %rbp
mov %rdi,%rbp
movslq %edx,%rdi
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 13ee <func0+0x5e>
lea -0x1(%rbx),%r14d
xor %ebx,%ebx
xchg %ax,%ax
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl 0x0(%rbp,%rbx,4),%xmm0
cvtsi2sdl 0x0(%r13,%rbx,4),%xmm1
callq 10a0 <pow@plt>
cvttsd2si %xmm0,%eax
mov %eax,(%r12,%rbx,4)
mov %rbx,%rax
add $0x1,%rbx
cmp %r14,%rax
jne 13c0 <func0+0x30>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
mov r14, rsi
push r13
mov r13, rdi
push r12
movsxd r12, edx
push rbp
push rbx
mov rbx, r12
shl r12, 2
mov rdi, r12; size
call _malloc
mov rbp, rax
test ebx, ebx
jle short loc_13DB
xor ebx, ebx
nop dword ptr [rax]
loc_13B0:
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, dword ptr [r13+rbx+0]; x
cvtsi2sd xmm1, dword ptr [r14+rbx]; y
call _pow
cvttsd2si eax, xmm0
mov [rbp+rbx+0], eax
add rbx, 4
cmp r12, rbx
jnz short loc_13B0
loc_13DB:
pop rbx
mov rax, rbp
pop rbp
pop r12
pop r13
pop r14
retn | char * func0(long long a1, long long a2, int a3)
{
size_t v4; // r12
char *v5; // rbp
long long v6; // rbx
v4 = 4LL * a3;
v5 = (char *)malloc(v4);
if ( a3 > 0 )
{
v6 = 0LL;
do
{
*(_DWORD *)&v5[v6] = (int)pow((double)*(int *)(a1 + v6), (double)*(int *)(a2 + v6));
v6 += 4LL;
}
while ( v4 != v6 );
}
return v5;
} | func0:
ENDBR64
PUSH R14
MOV R14,RSI
PUSH R13
MOV R13,RDI
PUSH R12
MOVSXD R12,EDX
PUSH RBP
PUSH RBX
MOV RBX,R12
SHL R12,0x2
MOV RDI,R12
CALL 0x001010d0
MOV RBP,RAX
TEST EBX,EBX
JLE 0x001013db
XOR EBX,EBX
NOP dword ptr [RAX]
LAB_001013b0:
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,dword ptr [R13 + RBX*0x1]
CVTSI2SD XMM1,dword ptr [R14 + RBX*0x1]
CALL 0x001010a0
CVTTSD2SI EAX,XMM0
MOV dword ptr [RBP + RBX*0x1],EAX
ADD RBX,0x4
CMP R12,RBX
JNZ 0x001013b0
LAB_001013db:
POP RBX
MOV RAX,RBP
POP RBP
POP R12
POP R13
POP R14
RET | void * func0(long param_1,long param_2,int param_3)
{
void *pvVar1;
size_t sVar2;
double dVar3;
pvVar1 = malloc((long)param_3 * 4);
if (0 < param_3) {
sVar2 = 0;
do {
dVar3 = pow((double)*(int *)(param_1 + sVar2),(double)*(int *)(param_2 + sVar2));
*(int *)((long)pvVar1 + sVar2) = (int)dVar3;
sVar2 = sVar2 + 4;
} while ((long)param_3 * 4 != sVar2);
}
return pvVar1;
} |
4,684 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int a, int b) {
if (a < 0 || b < 0) {
return -1;
}
double area = (3 * sqrt(3) * pow(a, 2)) / (4 * b);
return area;
}
| int main() {
assert(func0(4, 2) == 10.392304845413264);
assert(func0(5, 7) == 4.639421805988064);
assert(func0(9, 1) == 105.2220865598093);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
cmpl $0x0,-0x14(%rbp)
js 1187 <func0+0x1e>
cmpl $0x0,-0x18(%rbp)
jns 1191 <func0+0x28>
movsd 0xf31(%rip),%xmm0
jmp 11c7 <func0+0x5e>
cvtsi2sdl -0x14(%rbp),%xmm0
movsd 0xf2a(%rip),%xmm1
callq 1060 <pow@plt>
movsd 0xf25(%rip),%xmm1
mulsd %xmm1,%xmm0
mov -0x18(%rbp),%eax
shl $0x2,%eax
cvtsi2sd %eax,%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
cmp [rbp+var_14], 0
js short loc_1187
cmp [rbp+var_18], 0
jns short loc_1191
loc_1187:
movsd xmm0, cs:qword_20A0
jmp short locret_11DD
loc_1191:
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_14]
movq rax, xmm2
movsd xmm0, cs:y
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movsd xmm1, cs:qword_20B0
mulsd xmm0, xmm1
mov eax, [rbp+var_18]
shl eax, 2
pxor xmm1, xmm1
cvtsi2sd xmm1, eax
divsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
locret_11DD:
leave
retn | double func0(int a1, int a2)
{
if ( a1 >= 0 && a2 >= 0 )
return pow((double)a1, 2.0) * 5.196152422706632 / (double)(4 * a2);
else
return -1.0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
CMP dword ptr [RBP + -0x14],0x0
JS 0x00101187
CMP dword ptr [RBP + -0x18],0x0
JNS 0x00101191
LAB_00101187:
MOVSD XMM0,qword ptr [0x001020a0]
JMP 0x001011dd
LAB_00101191:
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x14]
MOVQ RAX,XMM2
MOVSD XMM0,qword ptr [0x001020a8]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
MOVSD XMM1,qword ptr [0x001020b0]
MULSD XMM0,XMM1
MOV EAX,dword ptr [RBP + -0x18]
SHL EAX,0x2
PXOR XMM1,XMM1
CVTSI2SD XMM1,EAX
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
LAB_001011dd:
LEAVE
RET | void func0(int param_1,int param_2)
{
if ((-1 < param_1) && (-1 < param_2)) {
pow((double)param_1,DAT_001020a8);
}
return;
} |
4,685 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int a, int b) {
if (a < 0 || b < 0) {
return -1;
}
double area = (3 * sqrt(3) * pow(a, 2)) / (4 * b);
return area;
}
| int main() {
assert(func0(4, 2) == 10.392304845413264);
assert(func0(5, 7) == 4.639421805988064);
assert(func0(9, 1) == 105.2220865598093);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
js 1159 <func0+0x30>
test %esi,%esi
js 1159 <func0+0x30>
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd %xmm0,%xmm0
mulsd 0xec7(%rip),%xmm0
shl $0x2,%esi
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
movsd 0xea7(%rip),%xmm0
retq
| func0:
endbr64
movsd xmm0, cs:qword_2008
mov eax, edi
or eax, esi
jns short loc_113C
locret_113B:
retn
loc_113C:
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2010
shl esi, 2
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
jmp short locret_113B | double func0(int a1, int a2)
{
double result; // xmm0_8
result = -1.0;
if ( (a2 | a1) >= 0 )
return (double)a1 * (double)a1 * 5.196152422706632 / (double)(4 * a2);
return result;
} | func0:
ENDBR64
MOVSD XMM0,qword ptr [0x00102008]
MOV EAX,EDI
OR EAX,ESI
JNS 0x0010113c
LAB_0010113b:
RET
LAB_0010113c:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102010]
SHL ESI,0x2
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
JMP 0x0010113b | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(uint param_1,uint param_2)
{
double dVar1;
dVar1 = DAT_00102008;
if (-1 < (int)(param_1 | param_2)) {
dVar1 = ((double)(int)param_1 * (double)(int)param_1 * _DAT_00102010) /
(double)(int)(param_2 << 2);
}
return dVar1;
} |
4,686 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int a, int b) {
if (a < 0 || b < 0) {
return -1;
}
double area = (3 * sqrt(3) * pow(a, 2)) / (4 * b);
return area;
}
| int main() {
assert(func0(4, 2) == 10.392304845413264);
assert(func0(5, 7) == 4.639421805988064);
assert(func0(9, 1) == 105.2220865598093);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
js 1170 <func0+0x30>
test %esi,%esi
js 1170 <func0+0x30>
pxor %xmm0,%xmm0
shl $0x2,%esi
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm0
cvtsi2sd %esi,%xmm1
mulsd %xmm0,%xmm0
mulsd 0xea5(%rip),%xmm0
divsd %xmm1,%xmm0
retq
movsd 0xe90(%rip),%xmm0
retq
nopl 0x0(%rax)
| func0:
endbr64
mov eax, edi
movsd xmm0, cs:qword_2008
or eax, esi
jns short loc_1158
retn
loc_1158:
pxor xmm0, xmm0
shl esi, 2
pxor xmm1, xmm1
cvtsi2sd xmm0, edi
cvtsi2sd xmm1, esi
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2010
divsd xmm0, xmm1
retn | double func0(int a1, int a2)
{
double result; // xmm0_8
result = -1.0;
if ( (a2 | a1) >= 0 )
return (double)a1 * (double)a1 * 5.196152422706632 / (double)(4 * a2);
return result;
} | func0:
ENDBR64
MOV EAX,EDI
MOVSD XMM0,qword ptr [0x00102008]
OR EAX,ESI
JNS 0x00101158
RET
LAB_00101158:
PXOR XMM0,XMM0
SHL ESI,0x2
PXOR XMM1,XMM1
CVTSI2SD XMM0,EDI
CVTSI2SD XMM1,ESI
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102010]
DIVSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(uint param_1,uint param_2)
{
if ((int)(param_1 | param_2) < 0) {
return DAT_00102008;
}
return ((double)(int)param_1 * (double)(int)param_1 * _DAT_00102010) / (double)(int)(param_2 << 2)
;
} |
4,687 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int a, int b) {
if (a < 0 || b < 0) {
return -1;
}
double area = (3 * sqrt(3) * pow(a, 2)) / (4 * b);
return area;
}
| int main() {
assert(func0(4, 2) == 10.392304845413264);
assert(func0(5, 7) == 4.639421805988064);
assert(func0(9, 1) == 105.2220865598093);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
js 1170 <func0+0x30>
test %esi,%esi
js 1170 <func0+0x30>
pxor %xmm0,%xmm0
shl $0x2,%esi
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm0
cvtsi2sd %esi,%xmm1
mulsd %xmm0,%xmm0
mulsd 0xea5(%rip),%xmm0
divsd %xmm1,%xmm0
retq
movsd 0xe90(%rip),%xmm0
retq
nopl 0x0(%rax)
| func0:
endbr64
mov eax, edi
movsd xmm0, cs:qword_2008
or eax, esi
jns short loc_1158
retn
loc_1158:
pxor xmm0, xmm0
shl esi, 2
pxor xmm1, xmm1
cvtsi2sd xmm0, edi
cvtsi2sd xmm1, esi
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2010
divsd xmm0, xmm1
retn | double func0(int a1, int a2)
{
double result; // xmm0_8
result = -1.0;
if ( (a2 | a1) >= 0 )
return (double)a1 * (double)a1 * 5.196152422706632 / (double)(4 * a2);
return result;
} | func0:
ENDBR64
MOV EAX,EDI
MOVSD XMM0,qword ptr [0x00102008]
OR EAX,ESI
JNS 0x00101158
RET
LAB_00101158:
PXOR XMM0,XMM0
SHL ESI,0x2
PXOR XMM1,XMM1
CVTSI2SD XMM0,EDI
CVTSI2SD XMM1,ESI
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102010]
DIVSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(uint param_1,uint param_2)
{
if ((int)(param_1 | param_2) < 0) {
return DAT_00102008;
}
return ((double)(int)param_1 * (double)(int)param_1 * _DAT_00102010) / (double)(int)(param_2 << 2)
;
} |
4,688 | func0 |
#include <assert.h>
| int func0(int n) {
int res = 0;
for (int i = n; i > 0; i--) {
if ((i & (i - 1)) == 0) {
res = i;
break;
}
}
return res;
}
| int main() {
assert(func0(10) == 8);
assert(func0(19) == 16);
assert(func0(32) == 32);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 117c <func0+0x33>
mov -0x4(%rbp),%eax
sub $0x1,%eax
and -0x4(%rbp),%eax
test %eax,%eax
jne 1178 <func0+0x2f>
mov -0x4(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 1182 <func0+0x39>
subl $0x1,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jg 1163 <func0+0x1a>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
jmp short loc_117C
loc_1163:
mov eax, [rbp+var_4]
sub eax, 1
and eax, [rbp+var_4]
test eax, eax
jnz short loc_1178
mov eax, [rbp+var_4]
mov [rbp+var_8], eax
jmp short loc_1182
loc_1178:
sub [rbp+var_4], 1
loc_117C:
cmp [rbp+var_4], 0
jg short loc_1163
loc_1182:
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
v2 = 0;
while ( a1 > 0 )
{
if ( (a1 & (a1 - 1)) == 0 )
return (unsigned int)a1;
--a1;
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0010117c
LAB_00101163:
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
AND EAX,dword ptr [RBP + -0x4]
TEST EAX,EAX
JNZ 0x00101178
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101182
LAB_00101178:
SUB dword ptr [RBP + -0x4],0x1
LAB_0010117c:
CMP dword ptr [RBP + -0x4],0x0
JG 0x00101163
LAB_00101182:
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | uint func0(uint param_1)
{
uint local_c;
local_c = param_1;
while( true ) {
if ((int)local_c < 1) {
return 0;
}
if ((local_c - 1 & local_c) == 0) break;
local_c = local_c - 1;
}
return local_c;
} |
4,689 | func0 |
#include <assert.h>
| int func0(int n) {
int res = 0;
for (int i = n; i > 0; i--) {
if ((i & (i - 1)) == 0) {
res = i;
break;
}
}
return res;
}
| int main() {
assert(func0(10) == 8);
assert(func0(19) == 16);
assert(func0(32) == 32);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 115c <func0+0x13>
lea -0x1(%rdi),%eax
test %edi,%eax
je 1162 <func0+0x19>
mov %eax,%edi
jmp 114d <func0+0x4>
mov $0x0,%eax
retq
mov %edi,%eax
retq
| func0:
endbr64
loc_114D:
test edi, edi
jle short loc_115C
lea eax, [rdi-1]
test eax, edi
jz short loc_1162
mov edi, eax
jmp short loc_114D
loc_115C:
mov eax, 0
retn
loc_1162:
mov eax, edi
retn | long long func0(int a1)
{
while ( 1 )
{
if ( a1 <= 0 )
return 0LL;
if ( (a1 & (a1 - 1)) == 0 )
break;
--a1;
}
return (unsigned int)a1;
} | func0:
ENDBR64
LAB_0010114d:
TEST EDI,EDI
JLE 0x0010115c
LEA EAX,[RDI + -0x1]
TEST EAX,EDI
JZ 0x00101162
MOV EDI,EAX
JMP 0x0010114d
LAB_0010115c:
MOV EAX,0x0
RET
LAB_00101162:
MOV EAX,EDI
RET | uint func0(uint param_1)
{
uint uVar1;
do {
uVar1 = param_1;
if ((int)uVar1 < 1) {
return 0;
}
param_1 = uVar1 - 1;
} while ((uVar1 - 1 & uVar1) != 0);
return uVar1;
} |
4,690 | func0 |
#include <assert.h>
| int func0(int n) {
int res = 0;
for (int i = n; i > 0; i--) {
if ((i & (i - 1)) == 0) {
res = i;
break;
}
}
return res;
}
| int main() {
assert(func0(10) == 8);
assert(func0(19) == 16);
assert(func0(32) == 32);
return 0;
}
| O2 | c | func0:
endbr64
jmp 11e9 <func0+0x19>
nopw %cs:0x0(%rax,%rax,1)
lea -0x1(%rdi),%eax
test %edi,%eax
je 11f0 <func0+0x20>
mov %eax,%edi
test %edi,%edi
jg 11e0 <func0+0x10>
xor %eax,%eax
retq
mov %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
jmp short loc_11E9
loc_11E0:
lea eax, [rdi-1]
test eax, edi
jz short loc_11F0
mov edi, eax
loc_11E9:
test edi, edi
jg short loc_11E0
xor eax, eax
retn
loc_11F0:
mov eax, edi
retn | long long func0(int a1)
{
while ( 1 )
{
if ( a1 <= 0 )
return 0LL;
if ( (a1 & (a1 - 1)) == 0 )
break;
--a1;
}
return (unsigned int)a1;
} | func0:
ENDBR64
JMP 0x001011e9
LAB_001011e0:
LEA EAX,[RDI + -0x1]
TEST EAX,EDI
JZ 0x001011f0
MOV EDI,EAX | void func0(void)
{
FUN_001011e9();
return;
} |
4,691 | func0 |
#include <assert.h>
| int func0(int n) {
int res = 0;
for (int i = n; i > 0; i--) {
if ((i & (i - 1)) == 0) {
res = i;
break;
}
}
return res;
}
| int main() {
assert(func0(10) == 8);
assert(func0(19) == 16);
assert(func0(32) == 32);
return 0;
}
| O3 | c | func0:
endbr64
jmp 11b9 <func0+0x19>
nopw %cs:0x0(%rax,%rax,1)
lea -0x1(%rdi),%eax
test %edi,%eax
je 11c0 <func0+0x20>
mov %eax,%edi
test %edi,%edi
jg 11b0 <func0+0x10>
xor %eax,%eax
retq
mov %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test edi, edi
jle short loc_11C0
nop dword ptr [rax+rax+00000000h]
loc_11B0:
mov eax, edi
sub edi, 1
test edi, eax
jnz short loc_11B0
retn
loc_11C0:
xor eax, eax
retn | long long func0(int a1)
{
long long result; // rax
if ( a1 <= 0 )
return 0LL;
do
result = (unsigned int)a1--;
while ( ((unsigned int)result & a1) != 0 );
return result;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001011c0
NOP dword ptr [RAX + RAX*0x1]
LAB_001011b0:
MOV EAX,EDI
SUB EDI,0x1
TEST EDI,EAX
JNZ 0x001011b0
RET
LAB_001011c0:
XOR EAX,EAX
RET | uint func0(uint param_1)
{
uint uVar1;
uint uVar2;
if ((int)param_1 < 1) {
return 0;
}
do {
uVar2 = param_1;
uVar1 = param_1 - 1 & param_1;
param_1 = param_1 - 1;
} while (uVar1 != 0);
return uVar2;
} |
4,692 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* list1, int size, int* resultSize) {
int max_val = list1[0];
for (int i = 1; i < size; i++) {
if (list1[i] > max_val) {
max_val = list1[i];
}
}
static int max_result[100];
int count = 0;
for (int i = 0; i < size; i++) {
if (list1[i] == max_val) {
max_result[count++] = i;
}
}
*resultSize = count;
return max_result;
}
| int main() {
int resultSize;
int* result;
result = func0((int[]){12,33,23,10,67,89,45,667,23,12,11,10,54}, 13, &resultSize);
int expected1[] = {7};
assert(resultSize == 1 && result[0] == expected1[0]);
result = func0((int[]){1,2,2,2,4,4,4,5,5,5,5}, 11, &resultSize);
int expected2[] = {7, 8, 9, 10};
assert(resultSize == 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected2[i]);
}
result = func0((int[]){2,1,5,6,8,3,4,9,10,11,8,12}, 12, &resultSize);
int expected3[] = {11};
assert(resultSize == 1 && result[0] == expected3[0]);
printf("All tests passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 11e6 <func0+0x5d>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x10(%rbp)
jge 11e2 <func0+0x59>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ae <func0+0x25>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 123d <func0+0xb4>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x10(%rbp)
jne 1239 <func0+0xb0>
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
cltq
lea 0x0(,%rax,4),%rcx
lea 0x2e0d(%rip),%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rcx,%rdx,1)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11fe <func0+0x75>
mov -0x28(%rbp),%rax
mov -0x8(%rbp),%edx
mov %edx,(%rax)
lea 0x2deb(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_10], eax
mov [rbp+var_C], 1
jmp short loc_11E6
loc_11AE:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_10], eax
jge short loc_11E2
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_10], eax
loc_11E2:
add [rbp+var_C], 1
loc_11E6:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_11AE
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_123D
loc_11FE:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_10], eax
jnz short loc_1239
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
cdqe
lea rcx, ds:0[rax*4]
lea rdx, max_result_1
mov eax, [rbp+var_4]
mov [rcx+rdx], eax
loc_1239:
add [rbp+var_4], 1
loc_123D:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11FE
mov rax, [rbp+var_28]
mov edx, [rbp+var_8]
mov [rax], edx
lea rax, max_result_1
pop rbp
retn | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int v3; // eax
int v5; // [rsp+18h] [rbp-10h]
int i; // [rsp+1Ch] [rbp-Ch]
int v7; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
v5 = *a1;
for ( i = 1; i < a2; ++i )
{
if ( v5 < a1[i] )
v5 = a1[i];
}
v7 = 0;
for ( j = 0; j < a2; ++j )
{
if ( v5 == a1[j] )
{
v3 = v7++;
max_result_1[v3] = j;
}
}
*a3 = v7;
return max_result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
MOV dword ptr [RBP + -0xc],0x1
JMP 0x001011e6
LAB_001011ae:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x10],EAX
JGE 0x001011e2
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
LAB_001011e2:
ADD dword ptr [RBP + -0xc],0x1
LAB_001011e6:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ae
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010123d
LAB_001011fe:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x10],EAX
JNZ 0x00101239
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
CDQE
LEA RCX,[RAX*0x4]
LEA RDX,[0x104040]
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RCX + RDX*0x1],EAX
LAB_00101239:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010123d:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011fe
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x8]
MOV dword ptr [RAX],EDX
LEA RAX,[0x104040]
POP RBP
RET | int1 * func0(int *param_1,int param_2,int *param_3)
{
int local_18;
int local_14;
int local_10;
int local_c;
local_18 = *param_1;
for (local_14 = 1; local_14 < param_2; local_14 = local_14 + 1) {
if (local_18 < param_1[local_14]) {
local_18 = param_1[local_14];
}
}
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (local_18 == param_1[local_c]) {
*(int *)(max_result_1 + (long)local_10 * 4) = local_c;
local_10 = local_10 + 1;
}
}
*param_3 = local_10;
return max_result_1;
} |
4,693 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* list1, int size, int* resultSize) {
int max_val = list1[0];
for (int i = 1; i < size; i++) {
if (list1[i] > max_val) {
max_val = list1[i];
}
}
static int max_result[100];
int count = 0;
for (int i = 0; i < size; i++) {
if (list1[i] == max_val) {
max_result[count++] = i;
}
}
*resultSize = count;
return max_result;
}
| int main() {
int resultSize;
int* result;
result = func0((int[]){12,33,23,10,67,89,45,667,23,12,11,10,54}, 13, &resultSize);
int expected1[] = {7};
assert(resultSize == 1 && result[0] == expected1[0]);
result = func0((int[]){1,2,2,2,4,4,4,5,5,5,5}, 11, &resultSize);
int expected2[] = {7, 8, 9, 10};
assert(resultSize == 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected2[i]);
}
result = func0((int[]){2,1,5,6,8,3,4,9,10,11,8,12}, 12, &resultSize);
int expected3[] = {11};
assert(resultSize == 1 && result[0] == expected3[0]);
printf("All tests passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
mov (%rdi),%ecx
cmp $0x1,%esi
jle 11c8 <func0+0x3f>
lea 0x4(%rdi),%rax
lea -0x2(%rsi),%r8d
lea 0x8(%rdi,%r8,4),%r9
mov (%rax),%r8d
cmp %r8d,%ecx
cmovl %r8d,%ecx
add $0x4,%rax
cmp %r9,%rax
jne 11a1 <func0+0x18>
mov $0x0,%eax
mov $0x0,%r8d
lea 0x2e7a(%rip),%r10
jmp 11e3 <func0+0x5a>
je 11b4 <func0+0x2b>
mov $0x0,%r8d
mov %r8d,(%rdx)
lea 0x2e66(%rip),%rax
retq
add $0x1,%rax
cmp %eax,%esi
jle 11d0 <func0+0x47>
cmp %ecx,(%rdi,%rax,4)
jne 11db <func0+0x52>
movslq %r8d,%r9
mov %eax,(%r10,%r9,4)
lea 0x1(%r8),%r8d
jmp 11db <func0+0x52>
| func0:
endbr64
mov r8, rdi
mov ecx, [rdi]
cmp esi, 1
jle short loc_11C6
lea rax, [rdi+4]
lea edi, [rsi-2]
lea r9, [r8+rdi*4+8]
loc_11A3:
mov edi, [rax]
cmp ecx, edi
cmovl ecx, edi
add rax, 4
cmp rax, r9
jnz short loc_11A3
loc_11B3:
mov eax, 0
mov edi, 0
lea r10, max_result_1
jmp short loc_11DF
loc_11C6:
jz short loc_11B3
mov edi, 0
loc_11CD:
mov [rdx], edi
lea rax, max_result_1
retn
loc_11D7:
add rax, 1
cmp esi, eax
jle short loc_11CD
loc_11DF:
cmp [r8+rax*4], ecx
jnz short loc_11D7
movsxd r9, edi
mov [r10+r9*4], eax
lea edi, [rdi+1]
jmp short loc_11D7 | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int v4; // ecx
int *v5; // rax
long long v6; // rax
int v7; // edi
v4 = *a1;
if ( a2 <= 1 )
{
if ( a2 != 1 )
{
v7 = 0;
goto LABEL_9;
}
}
else
{
v5 = a1 + 1;
do
{
if ( v4 < *v5 )
v4 = *v5;
++v5;
}
while ( v5 != &a1[a2 - 2 + 2] );
}
v6 = 0LL;
v7 = 0;
do
{
if ( a1[v6] == v4 )
max_result_1[v7++] = v6;
++v6;
}
while ( a2 > (int)v6 );
LABEL_9:
*a3 = v7;
return max_result_1;
} | func0:
ENDBR64
MOV R8,RDI
MOV ECX,dword ptr [RDI]
CMP ESI,0x1
JLE 0x001011c6
LEA RAX,[RDI + 0x4]
LEA EDI,[RSI + -0x2]
LEA R9,[R8 + RDI*0x4 + 0x8]
LAB_001011a3:
MOV EDI,dword ptr [RAX]
CMP ECX,EDI
CMOVL ECX,EDI
ADD RAX,0x4
CMP RAX,R9
JNZ 0x001011a3
LAB_001011b3:
MOV EAX,0x0
MOV EDI,0x0
LEA R10,[0x104040]
JMP 0x001011df
LAB_001011c6:
JZ 0x001011b3
MOV EDI,0x0
LAB_001011cd:
MOV dword ptr [RDX],EDI
LEA RAX,[0x104040]
RET
LAB_001011d7:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x001011cd
LAB_001011df:
CMP dword ptr [R8 + RAX*0x4],ECX
JNZ 0x001011d7
MOVSXD R9,EDI
MOV dword ptr [R10 + R9*0x4],EAX
LEA EDI,[RDI + 0x1]
JMP 0x001011d7 | int4 * func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
long lVar2;
int iVar3;
int iVar4;
iVar3 = *param_1;
if (param_2 < 2) {
if (param_2 != 1) {
iVar4 = 0;
goto LAB_001011cd;
}
}
else {
piVar1 = param_1 + 1;
do {
if (iVar3 < *piVar1) {
iVar3 = *piVar1;
}
piVar1 = piVar1 + 1;
} while (piVar1 != param_1 + (ulong)(param_2 - 2) + 2);
}
lVar2 = 0;
iVar4 = 0;
do {
if (param_1[lVar2] == iVar3) {
(&max_result_1)[iVar4] = (int)lVar2;
iVar4 = iVar4 + 1;
}
lVar2 = lVar2 + 1;
} while ((int)lVar2 < param_2);
LAB_001011cd:
*param_3 = iVar4;
return &max_result_1;
} |
4,694 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* list1, int size, int* resultSize) {
int max_val = list1[0];
for (int i = 1; i < size; i++) {
if (list1[i] > max_val) {
max_val = list1[i];
}
}
static int max_result[100];
int count = 0;
for (int i = 0; i < size; i++) {
if (list1[i] == max_val) {
max_result[count++] = i;
}
}
*resultSize = count;
return max_result;
}
| int main() {
int resultSize;
int* result;
result = func0((int[]){12,33,23,10,67,89,45,667,23,12,11,10,54}, 13, &resultSize);
int expected1[] = {7};
assert(resultSize == 1 && result[0] == expected1[0]);
result = func0((int[]){1,2,2,2,4,4,4,5,5,5,5}, 11, &resultSize);
int expected2[] = {7, 8, 9, 10};
assert(resultSize == 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected2[i]);
}
result = func0((int[]){2,1,5,6,8,3,4,9,10,11,8,12}, 12, &resultSize);
int expected3[] = {11};
assert(resultSize == 1 && result[0] == expected3[0]);
printf("All tests passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
mov (%rdi),%r9d
cmp $0x1,%esi
jle 1530 <func0+0x70>
lea -0x2(%rsi),%ecx
lea 0x4(%rdi),%rax
lea 0x8(%rdi,%rcx,4),%r10
mov %r9d,%ecx
nopl 0x0(%rax,%rax,1)
mov (%rax),%r8d
cmp %r8d,%ecx
cmovl %r8d,%ecx
add $0x4,%rax
cmp %r10,%rax
jne 14e0 <func0+0x20>
xor %eax,%eax
xor %r8d,%r8d
lea 0x2b41(%rip),%r10
jmp 150c <func0+0x4c>
nopl 0x0(%rax)
mov (%rdi,%rax,4),%r9d
cmp %r9d,%ecx
jne 151c <func0+0x5c>
movslq %r8d,%r9
add $0x1,%r8d
mov %eax,(%r10,%r9,4)
add $0x1,%rax
cmp %eax,%esi
jg 1508 <func0+0x48>
mov %r8d,(%rdx)
lea 0x2b12(%rip),%rax
retq
je 1540 <func0+0x80>
xor %r8d,%r8d
lea 0x2b04(%rip),%rax
mov %r8d,(%rdx)
retq
mov %r9d,%ecx
jmp 14f3 <func0+0x33>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov r8d, [rdi]
mov r9, rdi
cmp esi, 1
jle short loc_1488
lea ecx, [rsi-2]
lea rax, [rdi+4]
lea r10, [rdi+rcx*4+8]
mov ecx, r8d
xchg ax, ax
loc_1440:
mov edi, [rax]
cmp ecx, edi
cmovl ecx, edi
add rax, 4
cmp rax, r10
jnz short loc_1440
loc_1450:
xor eax, eax
xor edi, edi
lea r10, max_result_1
jmp short loc_1464
loc_1460:
mov r8d, [r9+rax*4]
loc_1464:
cmp ecx, r8d
jnz short loc_1473
movsxd r8, edi
add edi, 1
mov [r10+r8*4], eax
loc_1473:
add rax, 1
cmp esi, eax
jg short loc_1460
mov [rdx], edi
mov rax, r10
retn
loc_1488:
jz short loc_1499
xor edi, edi
lea r10, max_result_1
mov [rdx], edi
mov rax, r10
retn
loc_1499:
mov ecx, r8d
jmp short loc_1450 | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int v3; // r8d
int *v5; // rax
int v6; // ecx
long long v7; // rax
int v8; // edi
long long v9; // r8
v3 = *a1;
if ( a2 <= 1 )
{
if ( a2 != 1 )
{
*a3 = 0;
return max_result_1;
}
v6 = *a1;
}
else
{
v5 = a1 + 1;
v6 = *a1;
do
{
if ( v6 < *v5 )
v6 = *v5;
++v5;
}
while ( v5 != &a1[a2 - 2 + 2] );
}
v7 = 0LL;
v8 = 0;
while ( 1 )
{
if ( v6 == v3 )
{
v9 = v8++;
max_result_1[v9] = v7;
}
if ( a2 <= (int)++v7 )
break;
v3 = a1[v7];
}
*a3 = v8;
return max_result_1;
} | func0:
ENDBR64
MOV R8D,dword ptr [RDI]
MOV R9,RDI
CMP ESI,0x1
JLE 0x00101488
LEA ECX,[RSI + -0x2]
LEA RAX,[RDI + 0x4]
LEA R10,[RDI + RCX*0x4 + 0x8]
MOV ECX,R8D
NOP
LAB_00101440:
MOV EDI,dword ptr [RAX]
CMP ECX,EDI
CMOVL ECX,EDI
ADD RAX,0x4
CMP RAX,R10
JNZ 0x00101440
LAB_00101450:
XOR EAX,EAX
XOR EDI,EDI
LEA R10,[0x104040]
JMP 0x00101464
LAB_00101460:
MOV R8D,dword ptr [R9 + RAX*0x4]
LAB_00101464:
CMP ECX,R8D
JNZ 0x00101473
MOVSXD R8,EDI
ADD EDI,0x1
MOV dword ptr [R10 + R8*0x4],EAX
LAB_00101473:
ADD RAX,0x1
CMP ESI,EAX
JG 0x00101460
MOV dword ptr [RDX],EDI
MOV RAX,R10
RET
LAB_00101488:
JZ 0x00101499
XOR EDI,EDI
LEA R10,[0x104040]
MOV dword ptr [RDX],EDI
MOV RAX,R10
RET
LAB_00101499:
MOV ECX,R8D
JMP 0x00101450 | int4 * func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
long lVar6;
iVar5 = *param_1;
iVar3 = iVar5;
if (param_2 < 2) {
if (param_2 != 1) {
*param_3 = 0;
return &max_result_1;
}
}
else {
piVar1 = param_1 + 1;
do {
if (iVar3 < *piVar1) {
iVar3 = *piVar1;
}
piVar1 = piVar1 + 1;
} while (piVar1 != param_1 + (ulong)(param_2 - 2) + 2);
}
lVar2 = 0;
iVar4 = 0;
while( true ) {
if (iVar3 == iVar5) {
lVar6 = (long)iVar4;
iVar4 = iVar4 + 1;
(&max_result_1)[lVar6] = (int)lVar2;
}
lVar2 = lVar2 + 1;
if (param_2 <= (int)lVar2) break;
iVar5 = param_1[lVar2];
}
*param_3 = iVar4;
return &max_result_1;
} |
4,695 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* list1, int size, int* resultSize) {
int max_val = list1[0];
for (int i = 1; i < size; i++) {
if (list1[i] > max_val) {
max_val = list1[i];
}
}
static int max_result[100];
int count = 0;
for (int i = 0; i < size; i++) {
if (list1[i] == max_val) {
max_result[count++] = i;
}
}
*resultSize = count;
return max_result;
}
| int main() {
int resultSize;
int* result;
result = func0((int[]){12,33,23,10,67,89,45,667,23,12,11,10,54}, 13, &resultSize);
int expected1[] = {7};
assert(resultSize == 1 && result[0] == expected1[0]);
result = func0((int[]){1,2,2,2,4,4,4,5,5,5,5}, 11, &resultSize);
int expected2[] = {7, 8, 9, 10};
assert(resultSize == 4);
for (int i = 0; i < 4; i++) {
assert(result[i] == expected2[i]);
}
result = func0((int[]){2,1,5,6,8,3,4,9,10,11,8,12}, 12, &resultSize);
int expected3[] = {11};
assert(resultSize == 1 && result[0] == expected3[0]);
printf("All tests passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
mov (%rdi),%ecx
cmp $0x1,%esi
jle 19d8 <func0+0x128>
lea -0x2(%rsi),%eax
lea -0x1(%rsi),%r8d
cmp $0x2,%eax
jbe 19e8 <func0+0x138>
movd %ecx,%xmm3
mov %r8d,%ecx
mov %rdi,%rax
shr $0x2,%ecx
pshufd $0x0,%xmm3,%xmm2
shl $0x4,%rcx
add %rdi,%rcx
nopl 0x0(%rax,%rax,1)
movdqu 0x4(%rax),%xmm0
add $0x10,%rax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rcx,%rax
jne 18f0 <func0+0x40>
movdqa %xmm2,%xmm0
mov %r8d,%r9d
psrldq $0x8,%xmm0
and $0xfffffffc,%r9d
movdqa %xmm0,%xmm1
lea 0x1(%r9),%eax
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
por %xmm1,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
por %xmm2,%xmm1
movd %xmm1,%ecx
cmp %r8d,%r9d
je 199a <func0+0xea>
movslq %eax,%r8
mov (%rdi,%r8,4),%r8d
cmp %r8d,%ecx
cmovl %r8d,%ecx
lea 0x1(%rax),%r8d
cmp %r8d,%esi
jle 199a <func0+0xea>
movslq %r8d,%r8
mov (%rdi,%r8,4),%r8d
cmp %r8d,%ecx
cmovl %r8d,%ecx
add $0x2,%eax
cmp %eax,%esi
jle 199a <func0+0xea>
cltq
mov (%rdi,%rax,4),%eax
cmp %eax,%ecx
cmovl %eax,%ecx
xor %eax,%eax
lea 0x269d(%rip),%r10
xor %r8d,%r8d
nopw %cs:0x0(%rax,%rax,1)
cmp %ecx,(%rdi,%rax,4)
jne 19c0 <func0+0x110>
movslq %r8d,%r9
add $0x1,%r8d
mov %eax,(%r10,%r9,4)
add $0x1,%rax
cmp %eax,%esi
jg 19b0 <func0+0x100>
mov %r8d,(%rdx)
lea 0x266e(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
je 199a <func0+0xea>
xor %r8d,%r8d
lea 0x265c(%rip),%rax
mov %r8d,(%rdx)
retq
mov $0x1,%eax
jmpq 1964 <func0+0xb4>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
movsxd rcx, esi
mov r8, rdx
mov edx, [rdi]
cmp ecx, 1
jle loc_1290
lea eax, [rcx-2]
lea esi, [rcx-1]
cmp eax, 2
jbe loc_12A2
movd xmm3, edx
mov edx, esi
mov rax, rdi
shr edx, 2
pshufd xmm2, xmm3, 0
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00h]
loc_11C0:
movdqu xmm0, xmmword ptr [rax+4]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rax, rdx
jnz short loc_11C0
movdqa xmm1, xmm2
psrldq xmm1, 8
movdqa xmm0, xmm1
pcmpgtd xmm0, xmm2
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd edx, xmm1
test sil, 3
jz short loc_1265
and esi, 0FFFFFFFCh
add esi, 1
loc_1230:
movsxd rax, esi
lea r9, ds:0[rax*4]
mov eax, [rdi+rax*4]
cmp edx, eax
cmovl edx, eax
lea eax, [rsi+1]
cmp ecx, eax
jle short loc_1265
mov eax, [rdi+r9+4]
cmp edx, eax
cmovl edx, eax
add esi, 2
cmp ecx, esi
jle short loc_1265
mov eax, [rdi+r9+8]
cmp edx, eax
cmovl edx, eax
loc_1265:
xor eax, eax
lea r10, max_result_1
xor esi, esi
loc_1270:
cmp [rdi+rax*4], edx
jnz short loc_127F
movsxd r9, esi
add esi, 1
mov [r10+r9*4], eax
loc_127F:
add rax, 1
cmp rax, rcx
jnz short loc_1270
mov [r8], esi
mov rax, r10
retn
loc_1290:
jz short loc_1265
xor esi, esi
lea r10, max_result_1
mov [r8], esi
mov rax, r10
retn
loc_12A2:
mov esi, 1
jmp short loc_1230 | __int128 * func0(signed int *a1, int a2, _DWORD *a3)
{
long long v3; // rcx
signed int v5; // edx
unsigned int v6; // esi
signed int *v7; // rax
__m128i v8; // xmm2
__m128i v9; // xmm0
__m128i v10; // xmm1
__m128i v11; // xmm1
__m128i v12; // xmm0
__m128i v13; // xmm0
__m128i v14; // xmm2
__m128i v15; // xmm1
signed int v16; // esi
long long v17; // r9
long long v18; // rax
int v19; // esi
long long v20; // r9
v3 = a2;
v5 = *a1;
if ( a2 <= 1 )
{
if ( a2 != 1 )
{
*a3 = 0;
return &max_result_1;
}
}
else
{
v6 = a2 - 1;
if ( (unsigned int)(v3 - 2) <= 2 )
{
v16 = 1;
goto LABEL_7;
}
v7 = a1;
v8 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v5), 0);
do
{
v9 = _mm_loadu_si128((const __m128i *)(v7 + 1));
v7 += 4;
v10 = _mm_cmpgt_epi32(v9, v8);
v8 = _mm_or_si128(_mm_andnot_si128(v10, v8), _mm_and_si128(v9, v10));
}
while ( v7 != &a1[4 * (v6 >> 2)] );
v11 = _mm_srli_si128(v8, 8);
v12 = _mm_cmpgt_epi32(v11, v8);
v13 = _mm_or_si128(_mm_andnot_si128(v12, v8), _mm_and_si128(v11, v12));
v14 = _mm_srli_si128(v13, 4);
v15 = _mm_cmpgt_epi32(v14, v13);
v5 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v15, v13), _mm_and_si128(v14, v15)));
if ( (v6 & 3) != 0 )
{
v16 = (v6 & 0xFFFFFFFC) + 1;
LABEL_7:
v17 = v16;
if ( v5 < a1[v17] )
v5 = a1[v16];
if ( (int)v3 > v16 + 1 )
{
if ( v5 < a1[v17 + 1] )
v5 = a1[v17 + 1];
if ( (int)v3 > v16 + 2 && v5 < a1[v17 + 2] )
v5 = a1[v17 + 2];
}
}
}
v18 = 0LL;
v19 = 0;
do
{
if ( a1[v18] == v5 )
{
v20 = v19++;
*((_DWORD *)&max_result_1 + v20) = v18;
}
++v18;
}
while ( v18 != v3 );
*a3 = v19;
return &max_result_1;
} | func0:
ENDBR64
MOVSXD RCX,ESI
MOV R8,RDX
MOV EDX,dword ptr [RDI]
CMP ECX,0x1
JLE 0x00101290
LEA EAX,[RCX + -0x2]
LEA ESI,[RCX + -0x1]
CMP EAX,0x2
JBE 0x001012a2
MOVD XMM3,EDX
MOV EDX,ESI
MOV RAX,RDI
SHR EDX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_001011c0:
MOVDQU XMM0,xmmword ptr [RAX + 0x4]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RAX,RDX
JNZ 0x001011c0
MOVDQA XMM1,XMM2
PSRLDQ XMM1,0x8
MOVDQA XMM0,XMM1
PCMPGTD XMM0,XMM2
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD EDX,XMM1
TEST SIL,0x3
JZ 0x00101265
AND ESI,0xfffffffc
ADD ESI,0x1
LAB_00101230:
MOVSXD RAX,ESI
LEA R9,[RAX*0x4]
MOV EAX,dword ptr [RDI + RAX*0x4]
CMP EDX,EAX
CMOVL EDX,EAX
LEA EAX,[RSI + 0x1]
CMP ECX,EAX
JLE 0x00101265
MOV EAX,dword ptr [RDI + R9*0x1 + 0x4]
CMP EDX,EAX
CMOVL EDX,EAX
ADD ESI,0x2
CMP ECX,ESI
JLE 0x00101265
MOV EAX,dword ptr [RDI + R9*0x1 + 0x8]
CMP EDX,EAX
CMOVL EDX,EAX
LAB_00101265:
XOR EAX,EAX
LEA R10,[0x104040]
XOR ESI,ESI
LAB_00101270:
CMP dword ptr [RDI + RAX*0x4],EDX
JNZ 0x0010127f
MOVSXD R9,ESI
ADD ESI,0x1
MOV dword ptr [R10 + R9*0x4],EAX
LAB_0010127f:
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101270
MOV dword ptr [R8],ESI
MOV RAX,R10
RET
LAB_00101290:
JZ 0x00101265
XOR ESI,ESI
LEA R10,[0x104040]
MOV dword ptr [R8],ESI
MOV RAX,R10
RET
LAB_001012a2:
MOV ESI,0x1
JMP 0x00101230 | int4 * func0(uint *param_1,int param_2,int *param_3)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
long lVar6;
uint uVar7;
uint uVar8;
int iVar9;
long lVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uint uVar16;
uint uVar17;
uVar7 = *param_1;
if (param_2 < 2) {
if (param_2 != 1) {
*param_3 = 0;
return &max_result_1;
}
}
else {
uVar8 = param_2 - 1;
if (param_2 - 2U < 3) {
iVar9 = 1;
}
else {
puVar5 = param_1;
uVar16 = uVar7;
uVar12 = uVar7;
uVar17 = uVar7;
do {
puVar1 = puVar5 + 1;
puVar2 = puVar5 + 2;
puVar3 = puVar5 + 3;
puVar4 = puVar5 + 4;
puVar5 = puVar5 + 4;
uVar11 = -(uint)((int)uVar7 < (int)*puVar1);
uVar13 = -(uint)((int)uVar16 < (int)*puVar2);
uVar14 = -(uint)((int)uVar12 < (int)*puVar3);
uVar15 = -(uint)((int)uVar17 < (int)*puVar4);
uVar7 = ~uVar11 & uVar7 | *puVar1 & uVar11;
uVar16 = ~uVar13 & uVar16 | *puVar2 & uVar13;
uVar12 = ~uVar14 & uVar12 | *puVar3 & uVar14;
uVar17 = ~uVar15 & uVar17 | *puVar4 & uVar15;
} while (puVar5 != param_1 + (ulong)(uVar8 >> 2) * 4);
uVar7 = ~-(uint)((int)uVar7 < (int)uVar12) & uVar7 |
uVar12 & -(uint)((int)uVar7 < (int)uVar12);
uVar16 = ~-(uint)((int)uVar16 < (int)uVar17) & uVar16 |
uVar17 & -(uint)((int)uVar16 < (int)uVar17);
uVar12 = -(uint)((int)uVar7 < (int)uVar16);
uVar7 = ~uVar12 & uVar7 | uVar16 & uVar12;
if ((uVar8 & 3) == 0) goto LAB_00101265;
iVar9 = (uVar8 & 0xfffffffc) + 1;
}
if ((int)uVar7 < (int)param_1[iVar9]) {
uVar7 = param_1[iVar9];
}
if (iVar9 + 1 < param_2) {
if ((int)uVar7 < (int)param_1[(long)iVar9 + 1]) {
uVar7 = param_1[(long)iVar9 + 1];
}
if ((iVar9 + 2 < param_2) && ((int)uVar7 < (int)param_1[(long)iVar9 + 2])) {
uVar7 = param_1[(long)iVar9 + 2];
}
}
}
LAB_00101265:
lVar6 = 0;
iVar9 = 0;
do {
if (param_1[lVar6] == uVar7) {
lVar10 = (long)iVar9;
iVar9 = iVar9 + 1;
(&max_result_1)[lVar10] = (int)lVar6;
}
lVar6 = lVar6 + 1;
} while (lVar6 != param_2);
*param_3 = iVar9;
return &max_result_1;
} |
4,696 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(char *lst[], int size) {
for (int i = 1; i < size; i++) {
if (strcmp(lst[0], lst[i]) != 0) {
return 0;
}
}
return 1;
}
| int main() {
char *lst1[] = {"one", "one", "one"};
char *lst2[] = {"one", "Two", "Three"};
char *lst3[] = {"bigdata", "python", "Django"};
assert(func0(lst1, 3) == 1);
assert(func0(lst2, 3) == 0);
assert(func0(lst3, 3) == 0);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11fd <func0+0x54>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x18(%rbp),%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 11f9 <func0+0x50>
mov $0x0,%eax
jmp 120a <func0+0x61>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11c5 <func0+0x1c>
mov $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 1
jmp short loc_11FD
loc_11C5:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rdx, [rax]
mov rax, [rbp+var_18]
mov rax, [rax]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz short loc_11F9
mov eax, 0
jmp short locret_120A
loc_11F9:
add [rbp+var_4], 1
loc_11FD:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11C5
mov eax, 1
locret_120A:
leave
retn | long long func0(const char **a1, int a2)
{
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 1; i < a2; ++i )
{
if ( strcmp(*a1, a1[i]) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011fd
LAB_001011c5:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
TEST EAX,EAX
JZ 0x001011f9
MOV EAX,0x0
JMP 0x0010120a
LAB_001011f9:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011fd:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011c5
MOV EAX,0x1
LAB_0010120a:
LEAVE
RET | int8 func0(int8 *param_1,int param_2)
{
int iVar1;
int local_c;
local_c = 1;
while( true ) {
if (param_2 <= local_c) {
return 1;
}
iVar1 = strcmp((char *)*param_1,(char *)param_1[local_c]);
if (iVar1 != 0) break;
local_c = local_c + 1;
}
return 0;
} |
4,697 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(char *lst[], int size) {
for (int i = 1; i < size; i++) {
if (strcmp(lst[0], lst[i]) != 0) {
return 0;
}
}
return 1;
}
| int main() {
char *lst1[] = {"one", "one", "one"};
char *lst2[] = {"one", "Two", "Three"};
char *lst3[] = {"bigdata", "python", "Django"};
assert(func0(lst1, 3) == 1);
assert(func0(lst2, 3) == 0);
assert(func0(lst3, 3) == 0);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11e4 <func0+0x3b>
push %r12
push %rbp
push %rbx
mov (%rdi),%rbp
lea 0x8(%rdi),%rbx
lea -0x2(%rsi),%eax
lea 0x10(%rdi,%rax,8),%r12
mov (%rbx),%rsi
mov %rbp,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 11ea <func0+0x41>
add $0x8,%rbx
cmp %r12,%rbx
jne 11c5 <func0+0x1c>
mov $0x1,%eax
jmp 11ef <func0+0x46>
mov $0x1,%eax
retq
mov $0x0,%eax
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
cmp esi, 1
jle short loc_11E4
push r12
push rbp
push rbx
mov rbp, [rdi]
lea rbx, [rdi+8]
lea eax, [rsi-2]
lea r12, [rdi+rax*8+10h]
loc_11C5:
mov rsi, [rbx]
mov rdi, rbp
call _strcmp
test eax, eax
jnz short loc_11EA
add rbx, 8
cmp rbx, r12
jnz short loc_11C5
mov eax, 1
jmp short loc_11EF
loc_11E4:
mov eax, 1
retn
loc_11EA:
mov eax, 0
loc_11EF:
pop rbx
pop rbp
pop r12
retn | long long func0(long long *a1, int a2)
{
long long v2; // rbp
_QWORD *v3; // rbx
if ( a2 <= 1 )
return 1LL;
v2 = *a1;
v3 = a1 + 1;
while ( !(unsigned int)strcmp(v2, *v3) )
{
if ( ++v3 == &a1[(unsigned int)(a2 - 2) + 2] )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011e4
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,qword ptr [RDI]
LEA RBX,[RDI + 0x8]
LEA EAX,[RSI + -0x2]
LEA R12,[RDI + RAX*0x8 + 0x10]
LAB_001011c5:
MOV RSI,qword ptr [RBX]
MOV RDI,RBP
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x001011ea
ADD RBX,0x8
CMP RBX,R12
JNZ 0x001011c5
MOV EAX,0x1
JMP 0x001011ef
LAB_001011e4:
MOV EAX,0x1
RET
LAB_001011ea:
MOV EAX,0x0
LAB_001011ef:
POP RBX
POP RBP
POP R12
RET | int8 func0(int8 *param_1,int param_2)
{
char *__s1;
int iVar1;
int8 *puVar2;
if (param_2 < 2) {
return 1;
}
__s1 = (char *)*param_1;
puVar2 = param_1 + 1;
do {
iVar1 = strcmp(__s1,(char *)*puVar2);
if (iVar1 != 0) {
return 0;
}
puVar2 = puVar2 + 1;
} while (puVar2 != param_1 + (ulong)(param_2 - 2) + 2);
return 1;
} |
4,698 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(char *lst[], int size) {
for (int i = 1; i < size; i++) {
if (strcmp(lst[0], lst[i]) != 0) {
return 0;
}
}
return 1;
}
| int main() {
char *lst1[] = {"one", "one", "one"};
char *lst2[] = {"one", "Two", "Three"};
char *lst3[] = {"bigdata", "python", "Django"};
assert(func0(lst1, 3) == 1);
assert(func0(lst2, 3) == 0);
assert(func0(lst3, 3) == 0);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 132a <func0+0x4a>
lea -0x2(%rsi),%eax
push %r12
lea 0x10(%rdi,%rax,8),%r12
push %rbp
push %rbx
lea 0x8(%rdi),%rbx
mov (%rdi),%rbp
jmp 1309 <func0+0x29>
xchg %ax,%ax
add $0x8,%rbx
cmp %r12,%rbx
je 1320 <func0+0x40>
mov (%rbx),%rsi
mov %rbp,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 1300 <func0+0x20>
pop %rbx
xor %eax,%eax
pop %rbp
pop %r12
retq
pop %rbx
mov $0x1,%eax
pop %rbp
pop %r12
retq
mov $0x1,%eax
retq
| func0:
endbr64
cmp esi, 1
jle short loc_132A
lea eax, [rsi-2]
push r12
lea r12, [rdi+rax*8+10h]
push rbp
push rbx
lea rbx, [rdi+8]
mov rbp, [rdi]
jmp short loc_1309
loc_1300:
add rbx, 8
cmp rbx, r12
jz short loc_1320
loc_1309:
mov rsi, [rbx]
mov rdi, rbp
call _strcmp
test eax, eax
jz short loc_1300
pop rbx
xor eax, eax
pop rbp
pop r12
retn
loc_1320:
pop rbx
mov eax, 1
pop rbp
pop r12
retn
loc_132A:
mov eax, 1
retn | long long func0(long long *a1, int a2)
{
long long *v2; // rbx
long long v3; // rbp
if ( a2 <= 1 )
return 1LL;
v2 = a1 + 1;
v3 = *a1;
do
{
if ( (unsigned int)strcmp(v3, *v2) )
return 0LL;
++v2;
}
while ( v2 != &a1[(unsigned int)(a2 - 2) + 2] );
return 1LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x0010132a
LEA EAX,[RSI + -0x2]
PUSH R12
LEA R12,[RDI + RAX*0x8 + 0x10]
PUSH RBP
PUSH RBX
LEA RBX,[RDI + 0x8]
MOV RBP,qword ptr [RDI]
JMP 0x00101309
LAB_00101300:
ADD RBX,0x8
CMP RBX,R12
JZ 0x00101320
LAB_00101309:
MOV RSI,qword ptr [RBX]
MOV RDI,RBP
CALL 0x001010b0
TEST EAX,EAX
JZ 0x00101300
POP RBX
XOR EAX,EAX
POP RBP
POP R12
RET
LAB_00101320:
POP RBX
MOV EAX,0x1
POP RBP
POP R12
RET
LAB_0010132a:
MOV EAX,0x1
RET | int8 func0(int8 *param_1,int param_2)
{
char *__s1;
int iVar1;
int8 *puVar2;
if (param_2 < 2) {
return 1;
}
puVar2 = param_1 + 1;
__s1 = (char *)*param_1;
do {
iVar1 = strcmp(__s1,(char *)*puVar2);
if (iVar1 != 0) {
return 0;
}
puVar2 = puVar2 + 1;
} while (puVar2 != param_1 + (ulong)(param_2 - 2) + 2);
return 1;
} |
4,699 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(char *lst[], int size) {
for (int i = 1; i < size; i++) {
if (strcmp(lst[0], lst[i]) != 0) {
return 0;
}
}
return 1;
}
| int main() {
char *lst1[] = {"one", "one", "one"};
char *lst2[] = {"one", "Two", "Three"};
char *lst3[] = {"bigdata", "python", "Django"};
assert(func0(lst1, 3) == 1);
assert(func0(lst2, 3) == 0);
assert(func0(lst3, 3) == 0);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 134a <func0+0x4a>
lea -0x2(%rsi),%eax
push %r12
lea 0x10(%rdi,%rax,8),%r12
push %rbp
push %rbx
lea 0x8(%rdi),%rbx
mov (%rdi),%rbp
jmp 1329 <func0+0x29>
xchg %ax,%ax
add $0x8,%rbx
cmp %r12,%rbx
je 1340 <func0+0x40>
mov (%rbx),%rsi
mov %rbp,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 1320 <func0+0x20>
pop %rbx
xor %eax,%eax
pop %rbp
pop %r12
retq
pop %rbx
mov $0x1,%eax
pop %rbp
pop %r12
retq
mov $0x1,%eax
retq
| func0:
endbr64
cmp esi, 1
jle short loc_133A
lea eax, [rsi-2]
push r12
lea r12, [rdi+rax*8+10h]
push rbp
push rbx
lea rbx, [rdi+8]
mov rbp, [rdi]
jmp short loc_1319
loc_1310:
add rbx, 8
cmp rbx, r12
jz short loc_1330
loc_1319:
mov rsi, [rbx]; s2
mov rdi, rbp; s1
call _strcmp
test eax, eax
jz short loc_1310
pop rbx
xor eax, eax
pop rbp
pop r12
retn
loc_1330:
pop rbx
mov eax, 1
pop rbp
pop r12
retn
loc_133A:
mov eax, 1
retn | long long func0(const char **a1, int a2)
{
const char **v2; // rbx
const char *v3; // rbp
if ( a2 <= 1 )
return 1LL;
v2 = a1 + 1;
v3 = *a1;
do
{
if ( strcmp(v3, *v2) )
return 0LL;
++v2;
}
while ( v2 != &a1[(unsigned int)(a2 - 2) + 2] );
return 1LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x0010133a
LEA EAX,[RSI + -0x2]
PUSH R12
LEA R12,[RDI + RAX*0x8 + 0x10]
PUSH RBP
PUSH RBX
LEA RBX,[RDI + 0x8]
MOV RBP,qword ptr [RDI]
JMP 0x00101319
LAB_00101310:
ADD RBX,0x8
CMP RBX,R12
JZ 0x00101330
LAB_00101319:
MOV RSI,qword ptr [RBX]
MOV RDI,RBP
CALL 0x001010b0
TEST EAX,EAX
JZ 0x00101310
POP RBX
XOR EAX,EAX
POP RBP
POP R12
RET
LAB_00101330:
POP RBX
MOV EAX,0x1
POP RBP
POP R12
RET
LAB_0010133a:
MOV EAX,0x1
RET | int8 func0(int8 *param_1,int param_2)
{
char *__s1;
int iVar1;
int8 *puVar2;
if (param_2 < 2) {
return 1;
}
puVar2 = param_1 + 1;
__s1 = (char *)*param_1;
do {
iVar1 = strcmp(__s1,(char *)*puVar2);
if (iVar1 != 0) {
return 0;
}
puVar2 = puVar2 + 1;
} while (puVar2 != param_1 + (ulong)(param_2 - 2) + 2);
return 1;
} |
4,700 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(const char* str1) {
static char str2[100];
int j = 0;
for (int i = 1; i <= strlen(str1); i++) {
if (i % 2 != 0) {
str2[j++] = str1[i - 1];
}
}
str2[j] = '\0';
return str2;
}
| int main() {
assert(strcmp(func0("python"), "pto") == 0);
assert(strcmp(func0("program"), "porm") == 0);
assert(strcmp(func0("language"), "lnug") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x1,-0x14(%rbp)
jmp 11e1 <func0+0x58>
mov -0x14(%rbp),%eax
and $0x1,%eax
test %eax,%eax
je 11dd <func0+0x54>
mov -0x14(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
movzbl (%rcx),%edx
cltq
lea 0x2e66(%rip),%rcx
mov %dl,(%rax,%rcx,1)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
cmp %rax,%rbx
jbe 11aa <func0+0x21>
mov -0x18(%rbp),%eax
cltq
lea 0x2e3c(%rip),%rdx
movb $0x0,(%rax,%rdx,1)
lea 0x2e31(%rip),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 1
jmp short loc_11E1
loc_11AA:
mov eax, [rbp+var_14]
and eax, 1
test eax, eax
jz short loc_11DD
mov eax, [rbp+var_14]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+s]
lea rcx, [rdx+rax]
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
movzx edx, byte ptr [rcx]
cdqe
lea rcx, str2_1
mov [rax+rcx], dl
loc_11DD:
add [rbp+var_14], 1
loc_11E1:
mov eax, [rbp+var_14]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rax, rbx
jnb short loc_11AA
mov eax, [rbp+var_18]
cdqe
lea rdx, str2_1
mov byte ptr [rax+rdx], 0
lea rax, str2_1
mov rbx, [rbp+var_8]
leave
retn | _BYTE * func0(const char *a1)
{
int v1; // eax
int v3; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v3 = 0;
for ( i = 1; strlen(a1) >= i; ++i )
{
if ( (i & 1) != 0 )
{
v1 = v3++;
str2_1[v1] = a1[i - 1];
}
}
str2_1[v3] = 0;
return str2_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001011e1
LAB_001011aa:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
TEST EAX,EAX
JZ 0x001011dd
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
LEA RCX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_001011dd:
ADD dword ptr [RBP + -0x14],0x1
LAB_001011e1:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101070
CMP RAX,RBX
JNC 0x001011aa
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
LEA RAX,[0x104040]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int1 * func0(char *param_1)
{
size_t sVar1;
int local_20;
uint local_1c;
local_20 = 0;
local_1c = 1;
while( true ) {
sVar1 = strlen(param_1);
if (sVar1 < (ulong)(long)(int)local_1c) break;
if ((local_1c & 1) != 0) {
str2_1[local_20] = param_1[(long)(int)local_1c + -1];
local_20 = local_20 + 1;
}
local_1c = local_1c + 1;
}
str2_1[local_20] = 0;
return str2_1;
} |
4,701 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(const char* str1) {
static char str2[100];
int j = 0;
for (int i = 1; i <= strlen(str1); i++) {
if (i % 2 != 0) {
str2[j++] = str1[i - 1];
}
}
str2[j] = '\0';
return str2;
}
| int main() {
assert(strcmp(func0("python"), "pto") == 0);
assert(strcmp(func0("program"), "porm") == 0);
assert(strcmp(func0("language"), "lnug") == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0x1,%edx
mov $0x0,%esi
mov $0xffffffffffffffff,%r9
mov $0x0,%eax
lea 0x2ed3(%rip),%r10
jmp 1173 <func0+0x2a>
add $0x1,%rdx
mov %r9,%rcx
mov %r8,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp %rdx,%rcx
jb 119e <func0+0x55>
test $0x1,%dl
je 116f <func0+0x26>
movzbl -0x1(%r8,%rdx,1),%edi
movslq %esi,%rcx
mov %dil,(%r10,%rcx,1)
lea 0x1(%rsi),%esi
jmp 116f <func0+0x26>
lea 0x2e9b(%rip),%rax
movslq %esi,%rsi
movb $0x0,(%rax,%rsi,1)
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
mov ebx, 1
mov ebp, 0
lea r13, str2_1
jmp short loc_11B1
loc_11AD:
add rbx, 1
loc_11B1:
mov rdi, r12
call _strlen
cmp rax, rbx
jb short loc_11D6
test bl, 1
jz short loc_11AD
movzx edx, byte ptr [r12+rbx-1]
movsxd rax, ebp
mov [r13+rax+0], dl
lea ebp, [rbp+1]
jmp short loc_11AD
loc_11D6:
lea rax, str2_1
movsxd rbp, ebp
mov byte ptr [rax+rbp], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _BYTE * func0(long long a1)
{
unsigned long long v1; // rbx
int v2; // ebp
_BYTE *result; // rax
v1 = 1LL;
v2 = 0;
while ( strlen(a1) >= v1 )
{
if ( (v1 & 1) != 0 )
str2_1[v2++] = *(_BYTE *)(a1 + v1 - 1);
++v1;
}
result = str2_1;
str2_1[v2] = 0;
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
MOV EBX,0x1
MOV EBP,0x0
LEA R13,[0x104040]
JMP 0x001011b1
LAB_001011ad:
ADD RBX,0x1
LAB_001011b1:
MOV RDI,R12
CALL 0x00101070
CMP RAX,RBX
JC 0x001011d6
TEST BL,0x1
JZ 0x001011ad
MOVZX EDX,byte ptr [R12 + RBX*0x1 + -0x1]
MOVSXD RAX,EBP
MOV byte ptr [R13 + RAX*0x1],DL
LEA EBP,[RBP + 0x1]
JMP 0x001011ad
LAB_001011d6:
LEA RAX,[0x104040]
MOVSXD RBP,EBP
MOV byte ptr [RAX + RBP*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(char *param_1)
{
size_t sVar1;
ulong uVar2;
int iVar3;
uVar2 = 1;
iVar3 = 0;
while( true ) {
sVar1 = strlen(param_1);
if (sVar1 < uVar2) break;
if ((uVar2 & 1) != 0) {
(&str2_1)[iVar3] = param_1[uVar2 - 1];
iVar3 = iVar3 + 1;
}
uVar2 = uVar2 + 1;
}
(&str2_1)[iVar3] = 0;
return;
} |
4,702 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(const char* str1) {
static char str2[100];
int j = 0;
for (int i = 1; i <= strlen(str1); i++) {
if (i % 2 != 0) {
str2[j++] = str1[i - 1];
}
}
str2[j] = '\0';
return str2;
}
| int main() {
assert(strcmp(func0("python"), "pto") == 0);
assert(strcmp(func0("program"), "porm") == 0);
assert(strcmp(func0("language"), "lnug") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %rdi,%r13
push %r12
push %rbp
lea 0x2ddd(%rip),%rbp
push %rbx
mov $0x1,%ebx
sub $0x8,%rsp
callq 1060 <strlen@plt>
xor %edx,%edx
jmp 12a2 <func0+0x52>
nopw %cs:0x0(%rax,%rax,1)
test $0x1,%bl
je 129e <func0+0x4e>
movzbl -0x1(%r13,%rbx,1),%eax
lea 0x1(%rdx),%r12d
mov %r13,%rdi
mov %al,0x0(%rbp,%rdx,1)
callq 1060 <strlen@plt>
movslq %r12d,%rdx
add $0x1,%rbx
cmp %rax,%rbx
jbe 1280 <func0+0x30>
movb $0x0,0x0(%rbp,%rdx,1)
add $0x8,%rsp
lea 0x2d89(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xchg %ax,%ax
| func0:
endbr64
push r13
lea r13, str2_1
push r12
mov r12, rdi
push rbp
xor ebp, ebp
push rbx
mov ebx, 1
sub rsp, 8
jmp short loc_12A2
loc_1288:
test bl, 1
jz short loc_129E
movzx edx, byte ptr [r12+rbx-1]
movsxd rax, ebp
add ebp, 1
mov [r13+rax+0], dl
loc_129E:
add rbx, 1
loc_12A2:
mov rdi, r12
call _strlen
cmp rax, rbx
jnb short loc_1288
movsxd rbp, ebp
mov rax, r13
mov byte ptr [r13+rbp+0], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _BYTE * func0(long long a1)
{
int v1; // ebp
unsigned long long i; // rbx
long long v3; // rax
_BYTE *result; // rax
v1 = 0;
for ( i = 1LL; strlen(a1) >= i; ++i )
{
if ( (i & 1) != 0 )
{
v3 = v1++;
str2_1[v3] = *(_BYTE *)(a1 + i - 1);
}
}
result = str2_1;
str2_1[v1] = 0;
return result;
} | func0:
ENDBR64
PUSH R13
LEA R13,[0x104040]
PUSH R12
MOV R12,RDI
PUSH RBP
XOR EBP,EBP
PUSH RBX
MOV EBX,0x1
SUB RSP,0x8
JMP 0x001012a2
LAB_00101288:
TEST BL,0x1
JZ 0x0010129e
MOVZX EDX,byte ptr [R12 + RBX*0x1 + -0x1]
MOVSXD RAX,EBP
ADD EBP,0x1
MOV byte ptr [R13 + RAX*0x1],DL
LAB_0010129e:
ADD RBX,0x1
LAB_001012a2:
MOV RDI,R12
CALL 0x00101070
CMP RAX,RBX
JNC 0x00101288
MOVSXD RBP,EBP
MOV RAX,R13
MOV byte ptr [R13 + RBP*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | int1 * func0(char *param_1)
{
long lVar1;
size_t sVar2;
ulong uVar3;
int iVar4;
iVar4 = 0;
uVar3 = 1;
while( true ) {
sVar2 = strlen(param_1);
if (sVar2 < uVar3) break;
if ((uVar3 & 1) != 0) {
lVar1 = (long)iVar4;
iVar4 = iVar4 + 1;
(&str2_1)[lVar1] = param_1[uVar3 - 1];
}
uVar3 = uVar3 + 1;
}
(&str2_1)[iVar4] = 0;
return &str2_1;
} |
4,703 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(const char* str1) {
static char str2[100];
int j = 0;
for (int i = 1; i <= strlen(str1); i++) {
if (i % 2 != 0) {
str2[j++] = str1[i - 1];
}
}
str2[j] = '\0';
return str2;
}
| int main() {
assert(strcmp(func0("python"), "pto") == 0);
assert(strcmp(func0("program"), "porm") == 0);
assert(strcmp(func0("language"), "lnug") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %rax,%rax
je 12d8 <func0+0x88>
xor %edx,%edx
mov $0x1,%ebx
lea 0x2dc7(%rip),%rbp
nopl 0x0(%rax)
test $0x1,%bl
je 12ac <func0+0x5c>
movzbl -0x1(%r12,%rbx,1),%eax
mov %r12,%rdi
lea 0x1(%rdx),%r13d
add $0x1,%rbx
mov %al,0x0(%rbp,%rdx,1)
callq 1060 <strlen@plt>
cmp %rax,%rbx
ja 12b8 <func0+0x68>
movslq %r13d,%rdx
test $0x1,%bl
jne 1285 <func0+0x35>
add $0x1,%rbx
cmp %rax,%rbx
jbe 1280 <func0+0x30>
mov %edx,%r13d
movslq %r13d,%r13
lea 0x2d7e(%rip),%rax
movb $0x0,0x0(%rbp,%r13,1)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
xor %r13d,%r13d
lea 0x2d5e(%rip),%rbp
jmp 12b8 <func0+0x68>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r13
lea r13, str2_1
push r12
mov r12, rdi
push rbp
xor ebp, ebp
push rbx
mov ebx, 1
sub rsp, 8
jmp short loc_12A2
loc_1288:
test bl, 1
jz short loc_129E
movzx edx, byte ptr [r12+rbx-1]
movsxd rax, ebp
add ebp, 1
mov [r13+rax+0], dl
loc_129E:
add rbx, 1
loc_12A2:
mov rdi, r12; s
call _strlen
cmp rax, rbx
jnb short loc_1288
movsxd rbp, ebp
mov rax, r13
mov byte ptr [r13+rbp+0], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _BYTE * func0(char *s)
{
int v1; // ebp
size_t i; // rbx
long long v3; // rax
_BYTE *result; // rax
v1 = 0;
for ( i = 1LL; strlen(s) >= i; ++i )
{
if ( (i & 1) != 0 )
{
v3 = v1++;
str2_1[v3] = s[i - 1];
}
}
result = str2_1;
str2_1[v1] = 0;
return result;
} | func0:
ENDBR64
PUSH R13
LEA R13,[0x104040]
PUSH R12
MOV R12,RDI
PUSH RBP
XOR EBP,EBP
PUSH RBX
MOV EBX,0x1
SUB RSP,0x8
JMP 0x001012a2
LAB_00101288:
TEST BL,0x1
JZ 0x0010129e
MOVZX EDX,byte ptr [R12 + RBX*0x1 + -0x1]
MOVSXD RAX,EBP
ADD EBP,0x1
MOV byte ptr [R13 + RAX*0x1],DL
LAB_0010129e:
ADD RBX,0x1
LAB_001012a2:
MOV RDI,R12
CALL 0x00101070
CMP RAX,RBX
JNC 0x00101288
MOVSXD RBP,EBP
MOV RAX,R13
MOV byte ptr [R13 + RBP*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | int1 * func0(char *param_1)
{
long lVar1;
size_t sVar2;
ulong uVar3;
int iVar4;
iVar4 = 0;
uVar3 = 1;
while( true ) {
sVar2 = strlen(param_1);
if (sVar2 < uVar3) break;
if ((uVar3 & 1) != 0) {
lVar1 = (long)iVar4;
iVar4 = iVar4 + 1;
(&str2_1)[lVar1] = param_1[uVar3 - 1];
}
uVar3 = uVar3 + 1;
}
(&str2_1)[iVar4] = 0;
return &str2_1;
} |
4,704 | func0 |
#include <assert.h>
| int func0(int n1, int n2) {
int x = n1 ^ n2;
int setBits = 0;
while (x > 0) {
setBits += x & 1;
x >>= 1;
}
return setBits;
}
| int main() {
assert(func0(4, 8) == 2);
assert(func0(2, 4) == 2);
assert(func0(1, 2) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
xor -0x18(%rbp),%eax
mov %eax,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1175 <func0+0x2c>
mov -0x8(%rbp),%eax
and $0x1,%eax
add %eax,-0x4(%rbp)
sarl -0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jg 1169 <func0+0x20>
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_14]
xor eax, [rbp+var_18]
mov [rbp+var_8], eax
mov [rbp+var_4], 0
jmp short loc_1175
loc_1169:
mov eax, [rbp+var_8]
and eax, 1
add [rbp+var_4], eax
sar [rbp+var_8], 1
loc_1175:
cmp [rbp+var_8], 0
jg short loc_1169
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1, int a2)
{
int v3; // [rsp+10h] [rbp-8h]
unsigned int v4; // [rsp+14h] [rbp-4h]
v3 = a2 ^ a1;
v4 = 0;
while ( v3 > 0 )
{
v4 += v3 & 1;
v3 >>= 1;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x14]
XOR EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101175
LAB_00101169:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0x1
ADD dword ptr [RBP + -0x4],EAX
SAR dword ptr [RBP + -0x8],0x1
LAB_00101175:
CMP dword ptr [RBP + -0x8],0x0
JG 0x00101169
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(uint param_1,uint param_2)
{
int4 local_10;
int4 local_c;
local_c = 0;
for (local_10 = param_1 ^ param_2; 0 < (int)local_10; local_10 = (int)local_10 >> 1) {
local_c = local_c + (local_10 & 1);
}
return local_c;
} |
4,705 | func0 |
#include <assert.h>
| int func0(int n1, int n2) {
int x = n1 ^ n2;
int setBits = 0;
while (x > 0) {
setBits += x & 1;
x >>= 1;
}
return setBits;
}
| int main() {
assert(func0(4, 8) == 2);
assert(func0(2, 4) == 2);
assert(func0(1, 2) == 2);
return 0;
}
| O1 | c | func0:
endbr64
xor %edi,%esi
jle 1164 <func0+0x1b>
mov $0x0,%eax
mov %esi,%edx
and $0x1,%edx
add %edx,%eax
sar %esi
test %esi,%esi
jg 1156 <func0+0xd>
retq
mov $0x0,%eax
retq
| func0:
endbr64
xor edi, esi
jle short loc_1164
mov eax, 0
loc_1156:
mov edx, edi
and edx, 1
add eax, edx
sar edi, 1
test edi, edi
jg short loc_1156
retn
loc_1164:
mov eax, 0
retn | long long func0(int a1, int a2)
{
int v2; // edi
long long result; // rax
v2 = a2 ^ a1;
if ( v2 <= 0 )
return 0LL;
LODWORD(result) = 0;
do
{
result = (v2 & 1) + (unsigned int)result;
v2 >>= 1;
}
while ( v2 > 0 );
return result;
} | func0:
ENDBR64
XOR EDI,ESI
JLE 0x00101164
MOV EAX,0x0
LAB_00101156:
MOV EDX,EDI
AND EDX,0x1
ADD EAX,EDX
SAR EDI,0x1
TEST EDI,EDI
JG 0x00101156
RET
LAB_00101164:
MOV EAX,0x0
RET | int func0(uint param_1,uint param_2)
{
int iVar1;
param_1 = param_1 ^ param_2;
if (0 < (int)param_1) {
iVar1 = 0;
do {
iVar1 = iVar1 + (param_1 & 1);
param_1 = (int)param_1 >> 1;
} while (0 < (int)param_1);
return iVar1;
}
return 0;
} |
4,706 | func0 |
#include <assert.h>
| int func0(int n1, int n2) {
int x = n1 ^ n2;
int setBits = 0;
while (x > 0) {
setBits += x & 1;
x >>= 1;
}
return setBits;
}
| int main() {
assert(func0(4, 8) == 2);
assert(func0(2, 4) == 2);
assert(func0(1, 2) == 2);
return 0;
}
| O2 | c | func0:
endbr64
xor %eax,%eax
xor %edi,%esi
jle 11c0 <func0+0x20>
nopw 0x0(%rax,%rax,1)
mov %esi,%edx
and $0x1,%edx
add %edx,%eax
sar %esi
jne 11b0 <func0+0x10>
retq
nopl 0x0(%rax)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
xor eax, eax
xor edi, esi
jle short locret_11C0
nop word ptr [rax+rax+00h]
loc_11B0:
mov edx, edi
and edx, 1
add eax, edx
sar edi, 1
jnz short loc_11B0
retn
locret_11C0:
retn | long long func0(int a1, int a2)
{
long long result; // rax
int v3; // edi
result = 0LL;
v3 = a2 ^ a1;
if ( v3 > 0 )
{
do
{
result = (v3 & 1) + (unsigned int)result;
v3 >>= 1;
}
while ( v3 );
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
XOR EDI,ESI
JLE 0x001011c0
NOP word ptr [RAX + RAX*0x1]
LAB_001011b0:
MOV EDX,EDI
AND EDX,0x1
ADD EAX,EDX
SAR EDI,0x1
JNZ 0x001011b0
RET
LAB_001011c0:
RET | int func0(uint param_1,uint param_2)
{
int iVar1;
iVar1 = 0;
param_1 = param_1 ^ param_2;
if ((int)param_1 < 1) {
return 0;
}
do {
iVar1 = iVar1 + (param_1 & 1);
param_1 = (int)param_1 >> 1;
} while (param_1 != 0);
return iVar1;
} |
4,707 | func0 |
#include <assert.h>
| int func0(int n1, int n2) {
int x = n1 ^ n2;
int setBits = 0;
while (x > 0) {
setBits += x & 1;
x >>= 1;
}
return setBits;
}
| int main() {
assert(func0(4, 8) == 2);
assert(func0(2, 4) == 2);
assert(func0(1, 2) == 2);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
xor %edi,%esi
jle 1160 <func0+0x20>
nopw 0x0(%rax,%rax,1)
mov %esi,%edx
and $0x1,%edx
add %edx,%eax
sar %esi
jne 1150 <func0+0x10>
retq
nopl 0x0(%rax)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
xor eax, eax
xor edi, esi
jle short locret_1160
nop word ptr [rax+rax+00h]
loc_1150:
mov edx, edi
and edx, 1
add eax, edx
sar edi, 1
jnz short loc_1150
retn
locret_1160:
retn | long long func0(int a1, int a2)
{
long long result; // rax
int v3; // edi
result = 0LL;
v3 = a2 ^ a1;
if ( v3 > 0 )
{
do
{
result = (v3 & 1) + (unsigned int)result;
v3 >>= 1;
}
while ( v3 );
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
XOR EDI,ESI
JLE 0x00101160
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
MOV EDX,EDI
AND EDX,0x1
ADD EAX,EDX
SAR EDI,0x1
JNZ 0x00101150
RET
LAB_00101160:
RET | int func0(uint param_1,uint param_2)
{
int iVar1;
iVar1 = 0;
param_1 = param_1 ^ param_2;
if ((int)param_1 < 1) {
return 0;
}
do {
iVar1 = iVar1 + (param_1 & 1);
param_1 = (int)param_1 >> 1;
} while (param_1 != 0);
return iVar1;
} |
4,708 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char s[], char c) {
int res = 0;
for (int i = 0; i < strlen(s); i++) {
if (s[i] == c) {
res = res + 1;
}
}
return res;
}
| int main() {
assert(func0("abcc", 'c') == 2);
assert(func0("ababca", 'a') == 3);
assert(func0("mnmm0pm", 'm') == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,%eax
mov %al,-0x2c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 11ac <func0+0x43>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp %al,-0x2c(%rbp)
jne 11a8 <func0+0x3f>
addl $0x1,-0x18(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
cmp %rax,%rbx
jb 118f <func0+0x26>
mov -0x18(%rbp),%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov eax, esi
mov [rbp+var_2C], al
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_11AC
loc_118F:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp [rbp+var_2C], al
jnz short loc_11A8
add [rbp+var_18], 1
loc_11A8:
add [rbp+var_14], 1
loc_11AC:
mov eax, [rbp+var_14]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_118F
mov eax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | long long func0(const char *a1, char a2)
{
unsigned int v3; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v3 = 0;
for ( i = 0; i < strlen(a1); ++i )
{
if ( a2 == a1[i] )
++v3;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV EAX,ESI
MOV byte ptr [RBP + -0x2c],AL
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001011ac
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP byte ptr [RBP + -0x2c],AL
JNZ 0x001011a8
ADD dword ptr [RBP + -0x18],0x1
LAB_001011a8:
ADD dword ptr [RBP + -0x14],0x1
LAB_001011ac:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
CMP RBX,RAX
JC 0x0010118f
MOV EAX,dword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int func0(char *param_1,char param_2)
{
size_t sVar1;
int local_20;
int local_1c;
local_20 = 0;
local_1c = 0;
while( true ) {
sVar1 = strlen(param_1);
if (sVar1 <= (ulong)(long)local_1c) break;
if (param_2 == param_1[local_1c]) {
local_20 = local_20 + 1;
}
local_1c = local_1c + 1;
}
return local_20;
} |
4,709 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char s[], char c) {
int res = 0;
for (int i = 0; i < strlen(s); i++) {
if (s[i] == c) {
res = res + 1;
}
}
return res;
}
| int main() {
assert(func0("abcc", 'c') == 2);
assert(func0("ababca", 'a') == 3);
assert(func0("mnmm0pm", 'm') == 4);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %r8,%rdx
lea -0x1(%r8,%rcx,1),%rdi
mov $0x0,%eax
cmp %rdi,%rdx
je 1184 <func0+0x3b>
cmp %sil,(%rdx)
sete %cl
movzbl %cl,%ecx
add %ecx,%eax
add $0x1,%rdx
jmp 116e <func0+0x25>
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov ebp, esi
call _strlen
mov rdi, rax
mov rax, rbx
add rdi, rbx
mov edx, 0
jmp short loc_119C
loc_118D:
cmp [rax], bpl
setz cl
movzx ecx, cl
add edx, ecx
add rax, 1
loc_119C:
cmp rax, rdi
jnz short loc_118D
mov eax, edx
add rsp, 8
pop rbx
pop rbp
retn | long long func0(_BYTE *a1, unsigned __int8 a2)
{
long long v3; // rdi
_BYTE *v4; // rax
_BYTE *v5; // rdi
unsigned int v6; // edx
v3 = strlen();
v4 = a1;
v5 = &a1[v3];
v6 = 0;
while ( v4 != v5 )
v6 += *v4++ == a2;
return v6;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV EBP,ESI
CALL 0x00101060
MOV RDI,RAX
MOV RAX,RBX
ADD RDI,RBX
MOV EDX,0x0
JMP 0x0010119c
LAB_0010118d:
CMP byte ptr [RAX],BPL
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x1
LAB_0010119c:
CMP RAX,RDI
JNZ 0x0010118d
MOV EAX,EDX
ADD RSP,0x8
POP RBX
POP RBP
RET | int func0(char *param_1,char param_2)
{
size_t sVar1;
int iVar2;
char *pcVar3;
sVar1 = strlen(param_1);
pcVar3 = param_1 + sVar1;
iVar2 = 0;
for (; param_1 != pcVar3; param_1 = param_1 + 1) {
iVar2 = iVar2 + (uint)(*param_1 == param_2);
}
return iVar2;
} |
4,710 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char s[], char c) {
int res = 0;
for (int i = 0; i < strlen(s); i++) {
if (s[i] == c) {
res = res + 1;
}
}
return res;
}
| int main() {
assert(func0("abcc", 'c') == 2);
assert(func0("ababca", 'a') == 3);
assert(func0("mnmm0pm", 'm') == 4);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
mov %rbx,%rdi
lea (%rbx,%rax,1),%rcx
xor %eax,%eax
jmp 125e <func0+0x2e>
xor %edx,%edx
cmp %bpl,(%rdi)
sete %dl
add $0x1,%rdi
add %edx,%eax
cmp %rcx,%rdi
jne 1250 <func0+0x20>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
mov rdi, rbx
lea rcx, [rbx+rax]
xor eax, eax
jmp short loc_124E
loc_1240:
xor edx, edx
cmp [rdi], bpl
setz dl
add rdi, 1
add eax, edx
loc_124E:
cmp rdi, rcx
jnz short loc_1240
add rsp, 8
pop rbx
pop rbp
retn | long long func0(_BYTE *a1, unsigned __int8 a2)
{
_BYTE *v2; // rcx
long long result; // rax
BOOL v4; // edx
v2 = &a1[strlen()];
result = 0LL;
while ( a1 != v2 )
{
v4 = *a1++ == a2;
result = (unsigned int)(v4 + result);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
MOV RDI,RBX
LEA RCX,[RBX + RAX*0x1]
XOR EAX,EAX
JMP 0x0010124e
LAB_00101240:
XOR EDX,EDX
CMP byte ptr [RDI],BPL
SETZ DL
ADD RDI,0x1
ADD EAX,EDX
LAB_0010124e:
CMP RDI,RCX
JNZ 0x00101240
ADD RSP,0x8
POP RBX
POP RBP
RET | int func0(char *param_1,char param_2)
{
char *pcVar1;
int iVar2;
size_t sVar3;
sVar3 = strlen(param_1);
pcVar1 = param_1 + sVar3;
iVar2 = 0;
for (; param_1 != pcVar1; param_1 = param_1 + 1) {
iVar2 = iVar2 + (uint)(*param_1 == param_2);
}
return iVar2;
} |
4,711 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char s[], char c) {
int res = 0;
for (int i = 0; i < strlen(s); i++) {
if (s[i] == c) {
res = res + 1;
}
}
return res;
}
| int main() {
assert(func0("abcc", 'c') == 2);
assert(func0("ababca", 'a') == 3);
assert(func0("mnmm0pm", 'm') == 4);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1050 <strlen@plt>
test %rax,%rax
je 13f0 <func0+0x290>
mov %rax,%rcx
lea -0x1(%rax),%rax
cmp $0xe,%rax
jbe 13f9 <func0+0x299>
movd %ebp,%xmm4
mov %rcx,%rax
pxor %xmm1,%xmm1
mov %rbx,%rdx
punpcklbw %xmm4,%xmm4
pxor %xmm6,%xmm6
pxor %xmm5,%xmm5
and $0xfffffffffffffff0,%rax
punpcklwd %xmm4,%xmm4
movdqa 0xe58(%rip),%xmm7
add %rbx,%rax
pshufd $0x0,%xmm4,%xmm4
movdqu (%rdx),%xmm0
movdqa %xmm6,%xmm3
add $0x10,%rdx
pcmpeqb %xmm4,%xmm0
pand %xmm7,%xmm0
pcmpgtb %xmm0,%xmm3
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
punpckhbw %xmm3,%xmm0
movdqa %xmm5,%xmm3
pcmpgtw %xmm2,%xmm3
movdqa %xmm2,%xmm8
punpcklwd %xmm3,%xmm8
punpckhwd %xmm3,%xmm2
movdqa %xmm0,%xmm3
paddd %xmm8,%xmm1
paddd %xmm2,%xmm1
movdqa %xmm5,%xmm2
pcmpgtw %xmm0,%xmm2
punpcklwd %xmm2,%xmm3
punpckhwd %xmm2,%xmm0
paddd %xmm3,%xmm1
paddd %xmm0,%xmm1
cmp %rax,%rdx
jne 11c0 <func0+0x60>
movdqa %xmm1,%xmm0
mov %rcx,%rsi
psrldq $0x8,%xmm0
and $0xfffffffffffffff0,%rsi
paddd %xmm1,%xmm0
mov %esi,%edx
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
cmp %rsi,%rcx
je 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0x1(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0x2(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0x3(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0x4(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0x5(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0x6(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0x7(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0x8(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0x9(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0xa(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0xb(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0xc(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
movzbl %sil,%esi
add %esi,%eax
lea 0xd(%rdx),%esi
movslq %esi,%rsi
cmp %rsi,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rsi,1)
sete %sil
add $0xe,%edx
movzbl %sil,%esi
movslq %edx,%rdx
add %esi,%eax
cmp %rdx,%rcx
jbe 13e2 <func0+0x282>
cmp %bpl,(%rbx,%rdx,1)
sete %dl
movzbl %dl,%edx
add %edx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
xor %edx,%edx
xor %eax,%eax
xor %esi,%esi
jmpq 1254 <func0+0xf4>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test rax, rax
jz loc_13D0
mov rdx, rax
lea rax, [rax-1]
cmp rax, 0Eh
jbe loc_13D9
movd xmm4, ebp
mov rcx, rdx
pxor xmm1, xmm1
mov rax, rbx
punpcklbw xmm4, xmm4
pxor xmm6, xmm6
pxor xmm5, xmm5
and rcx, 0FFFFFFFFFFFFFFF0h
punpcklwd xmm4, xmm4
lea rsi, [rcx+rbx]
pshufd xmm4, xmm4, 0
nop dword ptr [rax+00000000h]
loc_11C0:
movdqu xmm0, xmmword ptr [rax]
movdqa xmm3, xmm6
add rax, 10h
pcmpeqb xmm0, xmm4
pcmpgtb xmm3, xmm0
movdqa xmm2, xmm0
punpcklbw xmm2, xmm3
punpckhbw xmm0, xmm3
movdqa xmm3, xmm5
pcmpgtw xmm3, xmm2
movdqa xmm7, xmm2
punpcklwd xmm7, xmm3
punpckhwd xmm2, xmm3
movdqa xmm3, xmm0
psubd xmm1, xmm7
psubd xmm1, xmm2
movdqa xmm2, xmm5
pcmpgtw xmm2, xmm0
punpcklwd xmm3, xmm2
punpckhwd xmm0, xmm2
psubd xmm1, xmm3
psubd xmm1, xmm0
cmp rsi, rax
jnz short loc_11C0
movdqa xmm0, xmm1
mov esi, ecx
psrldq xmm0, 8
paddd xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
paddd xmm0, xmm2
movd eax, xmm0
movdqa xmm0, xmm1
psrldq xmm1, 8
paddd xmm0, xmm1
cmp rdx, rcx
jz loc_136F
loc_1253:
mov rdi, rdx
sub rdi, rcx
lea r8, [rdi-1]
cmp r8, 6
jbe loc_12FD
movzx eax, bpl
movq xmm1, qword ptr [rbx+rcx]
mov ah, al
movd xmm6, eax
pshuflw xmm2, xmm6, 0
pcmpeqb xmm1, xmm2
pxor xmm2, xmm2
pcmpgtb xmm2, xmm1
movdqa xmm3, xmm1
punpcklbw xmm3, xmm2
punpcklbw xmm1, xmm2
pxor xmm2, xmm2
movdqa xmm4, xmm2
movdqa xmm5, xmm3
pshufd xmm1, xmm1, 4Eh ; 'N'
pcmpgtw xmm4, xmm3
pcmpgtw xmm2, xmm1
punpcklwd xmm5, xmm4
punpcklwd xmm3, xmm4
psubd xmm0, xmm5
pshufd xmm3, xmm3, 4Eh ; 'N'
psubd xmm0, xmm3
movdqa xmm3, xmm1
punpcklwd xmm1, xmm2
punpcklwd xmm3, xmm2
pshufd xmm1, xmm1, 4Eh ; 'N'
psubd xmm0, xmm3
psubd xmm0, xmm1
movd r8d, xmm0
pshufd xmm6, xmm0, 0E5h
movd eax, xmm6
add eax, r8d
mov r8, rdi
and r8, 0FFFFFFFFFFFFFFF8h
add rcx, r8
add esi, r8d
and edi, 7
jz short loc_136F
loc_12FD:
cmp [rbx+rcx], bpl
jz short loc_1380
loc_1303:
lea ecx, [rsi+1]
movsxd rcx, ecx
cmp rcx, rdx
jnb short loc_136F
cmp bpl, [rbx+rcx]
jz short loc_1390
loc_1314:
lea ecx, [rsi+2]
movsxd rcx, ecx
cmp rcx, rdx
jnb short loc_136F
cmp bpl, [rbx+rcx]
jz short loc_13A0
loc_1325:
lea ecx, [rsi+3]
movsxd rcx, ecx
cmp rcx, rdx
jnb short loc_136F
cmp bpl, [rbx+rcx]
jz short loc_13A8
lea ecx, [rsi+4]
movsxd rcx, ecx
cmp rcx, rdx
jnb short loc_136F
loc_1341:
cmp bpl, [rbx+rcx]
jnz short loc_134A
add eax, 1
loc_134A:
lea ecx, [rsi+5]
movsxd rcx, ecx
cmp rcx, rdx
jnb short loc_136F
cmp bpl, [rbx+rcx]
jnz short loc_135E
add eax, 1
loc_135E:
add esi, 6
movsxd rsi, esi
cmp rsi, rdx
jnb short loc_136F
cmp bpl, [rbx+rsi]
jz short loc_13C0
loc_136F:
add rsp, 8
pop rbx
pop rbp
retn
loc_1380:
add eax, 1
jmp loc_1303
loc_1390:
add eax, 1
jmp loc_1314
loc_13A0:
add eax, 1
jmp short loc_1325
loc_13A8:
lea ecx, [rsi+4]
add eax, 1
movsxd rcx, ecx
cmp rcx, rdx
jb short loc_1341
jmp short loc_136F
loc_13C0:
add rsp, 8
add eax, 1
pop rbx
pop rbp
retn
loc_13D0:
add rsp, 8
xor eax, eax
pop rbx
pop rbp
retn
loc_13D9:
pxor xmm0, xmm0
xor esi, esi
xor eax, eax
xor ecx, ecx
jmp loc_1253 | long long func0(const char *a1, unsigned __int8 a2)
{
size_t v4; // rax
size_t v5; // rdx
__m128i v6; // xmm4
__m128i v7; // xmm1
const __m128i *v8; // rax
__m128i v9; // xmm4
unsigned long long v10; // rcx
__m128i v11; // xmm4
__m128i v12; // xmm0
__m128i v13; // xmm0
__m128i v14; // xmm3
__m128i v15; // xmm2
__m128i v16; // xmm0
__m128i v17; // xmm3
__m128i v18; // xmm1
__m128i v19; // xmm2
int v20; // esi
__m128i v21; // xmm0
long long result; // rax
__m128i v23; // xmm0
size_t v24; // rdi
unsigned int v25; // eax
__m128i v26; // xmm1
__m128i v27; // xmm3
__m128i v28; // xmm1
__m128i v29; // xmm2
__m128i v30; // xmm3
__m128i v31; // xmm0
size_t v32; // rcx
size_t v33; // rcx
size_t v34; // rcx
size_t v35; // rcx
size_t v36; // rcx
size_t v37; // rsi
v4 = strlen(a1);
if ( !v4 )
return 0LL;
v5 = v4;
if ( v4 - 1 <= 0xE )
{
v23 = 0LL;
v20 = 0;
result = 0LL;
v10 = 0LL;
}
else
{
v6 = _mm_cvtsi32_si128(a2);
v7 = 0LL;
v8 = (const __m128i *)a1;
v9 = _mm_unpacklo_epi8(v6, v6);
v10 = v5 & 0xFFFFFFFFFFFFFFF0LL;
v11 = _mm_shuffle_epi32(_mm_unpacklo_epi16(v9, v9), 0);
do
{
v12 = _mm_loadu_si128(v8++);
v13 = _mm_cmpeq_epi8(v12, v11);
v14 = _mm_cmpgt_epi8((__m128i)0LL, v13);
v15 = _mm_unpacklo_epi8(v13, v14);
v16 = _mm_unpackhi_epi8(v13, v14);
v17 = _mm_cmpgt_epi16((__m128i)0LL, v15);
v18 = _mm_sub_epi32(_mm_sub_epi32(v7, _mm_unpacklo_epi16(v15, v17)), _mm_unpackhi_epi16(v15, v17));
v19 = _mm_cmpgt_epi16((__m128i)0LL, v16);
v7 = _mm_sub_epi32(_mm_sub_epi32(v18, _mm_unpacklo_epi16(v16, v19)), _mm_unpackhi_epi16(v16, v19));
}
while ( &a1[v5 & 0xFFFFFFFFFFFFFFF0LL] != (const char *)v8 );
v20 = v5 & 0xFFFFFFF0;
v21 = _mm_add_epi32(_mm_srli_si128(v7, 8), v7);
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v21, _mm_srli_si128(v21, 4)));
v23 = _mm_add_epi32(v7, _mm_srli_si128(v7, 8));
if ( v5 == v10 )
return result;
}
v24 = v5 - v10;
if ( v5 - v10 - 1 <= 6 )
goto LABEL_34;
v25 = a2;
BYTE1(v25) = a2;
v26 = _mm_cmpeq_epi8(_mm_loadl_epi64((const __m128i *)&a1[v10]), _mm_shufflelo_epi16(_mm_cvtsi32_si128(v25), 0));
v27 = _mm_unpacklo_epi8(v26, _mm_cmpgt_epi8((__m128i)0LL, v26));
v28 = _mm_shuffle_epi32(v27, 78);
v29 = _mm_cmpgt_epi16((__m128i)0LL, v28);
v30 = _mm_unpacklo_epi16(v27, _mm_cmpgt_epi16((__m128i)0LL, v27));
v31 = _mm_sub_epi32(
_mm_sub_epi32(
_mm_sub_epi32(_mm_sub_epi32(v23, v30), _mm_shuffle_epi32(v30, 78)),
_mm_unpacklo_epi16(v28, v29)),
_mm_shuffle_epi32(_mm_unpacklo_epi16(v28, v29), 78));
result = (unsigned int)(_mm_cvtsi128_si32(v31) + _mm_cvtsi128_si32(_mm_shuffle_epi32(v31, 229)));
v10 += v24 & 0xFFFFFFFFFFFFFFF8LL;
v20 += v24 & 0xFFFFFFF8;
if ( (v24 & 7) != 0 )
{
LABEL_34:
if ( a1[v10] == a2 )
result = (unsigned int)(result + 1);
v32 = v20 + 1;
if ( v32 < v5 )
{
if ( a2 == a1[v32] )
result = (unsigned int)(result + 1);
v33 = v20 + 2;
if ( v33 < v5 )
{
if ( a2 == a1[v33] )
result = (unsigned int)(result + 1);
v34 = v20 + 3;
if ( v34 < v5 )
{
if ( a2 == a1[v34] )
{
result = (unsigned int)(result + 1);
v35 = v20 + 4;
if ( v35 >= v5 )
return result;
}
else
{
v35 = v20 + 4;
if ( v35 >= v5 )
return result;
}
if ( a2 == a1[v35] )
result = (unsigned int)(result + 1);
v36 = v20 + 5;
if ( v36 < v5 )
{
if ( a2 == a1[v36] )
result = (unsigned int)(result + 1);
v37 = v20 + 6;
if ( v37 < v5 && a2 == a1[v37] )
return (unsigned int)(result + 1);
}
}
}
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101050
TEST RAX,RAX
JZ 0x001013d0
MOV RDX,RAX
LEA RAX,[RAX + -0x1]
CMP RAX,0xe
JBE 0x001013d9
MOVD XMM4,EBP
MOV RCX,RDX
PXOR XMM1,XMM1
MOV RAX,RBX
PUNPCKLBW XMM4,XMM4
PXOR XMM6,XMM6
PXOR XMM5,XMM5
AND RCX,-0x10
PUNPCKLWD XMM4,XMM4
LEA RSI,[RCX + RBX*0x1]
PSHUFD XMM4,XMM4,0x0
NOP dword ptr [RAX]
LAB_001011c0:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM3,XMM6
ADD RAX,0x10
PCMPEQB XMM0,XMM4
PCMPGTB XMM3,XMM0
MOVDQA XMM2,XMM0
PUNPCKLBW XMM2,XMM3
PUNPCKHBW XMM0,XMM3
MOVDQA XMM3,XMM5
PCMPGTW XMM3,XMM2
MOVDQA XMM7,XMM2
PUNPCKLWD XMM7,XMM3
PUNPCKHWD XMM2,XMM3
MOVDQA XMM3,XMM0
PSUBD XMM1,XMM7
PSUBD XMM1,XMM2
MOVDQA XMM2,XMM5
PCMPGTW XMM2,XMM0
PUNPCKLWD XMM3,XMM2
PUNPCKHWD XMM0,XMM2
PSUBD XMM1,XMM3
PSUBD XMM1,XMM0
CMP RSI,RAX
JNZ 0x001011c0
MOVDQA XMM0,XMM1
MOV ESI,ECX
PSRLDQ XMM0,0x8
PADDD XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
PADDD XMM0,XMM2
MOVD EAX,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
CMP RDX,RCX
JZ 0x0010136f
LAB_00101253:
MOV RDI,RDX
SUB RDI,RCX
LEA R8,[RDI + -0x1]
CMP R8,0x6
JBE 0x001012fd
MOVZX EAX,BPL
MOVQ XMM1,qword ptr [RBX + RCX*0x1]
MOV AH,AL
MOVD XMM6,EAX
PSHUFLW XMM2,XMM6,0x0
PCMPEQB XMM1,XMM2
PXOR XMM2,XMM2
PCMPGTB XMM2,XMM1
MOVDQA XMM3,XMM1
PUNPCKLBW XMM3,XMM2
PUNPCKLBW XMM1,XMM2
PXOR XMM2,XMM2
MOVDQA XMM4,XMM2
MOVDQA XMM5,XMM3
PSHUFD XMM1,XMM1,0x4e
PCMPGTW XMM4,XMM3
PCMPGTW XMM2,XMM1
PUNPCKLWD XMM5,XMM4
PUNPCKLWD XMM3,XMM4
PSUBD XMM0,XMM5
PSHUFD XMM3,XMM3,0x4e
PSUBD XMM0,XMM3
MOVDQA XMM3,XMM1
PUNPCKLWD XMM1,XMM2
PUNPCKLWD XMM3,XMM2
PSHUFD XMM1,XMM1,0x4e
PSUBD XMM0,XMM3
PSUBD XMM0,XMM1
MOVD R8D,XMM0
PSHUFD XMM6,XMM0,0xe5
MOVD EAX,XMM6
ADD EAX,R8D
MOV R8,RDI
AND R8,-0x8
ADD RCX,R8
ADD ESI,R8D
AND EDI,0x7
JZ 0x0010136f
LAB_001012fd:
CMP byte ptr [RBX + RCX*0x1],BPL
JZ 0x00101380
LAB_00101303:
LEA ECX,[RSI + 0x1]
MOVSXD RCX,ECX
CMP RCX,RDX
JNC 0x0010136f
CMP BPL,byte ptr [RBX + RCX*0x1]
JZ 0x00101390
LAB_00101314:
LEA ECX,[RSI + 0x2]
MOVSXD RCX,ECX
CMP RCX,RDX
JNC 0x0010136f
CMP BPL,byte ptr [RBX + RCX*0x1]
JZ 0x001013a0
LAB_00101325:
LEA ECX,[RSI + 0x3]
MOVSXD RCX,ECX
CMP RCX,RDX
JNC 0x0010136f
CMP BPL,byte ptr [RBX + RCX*0x1]
JZ 0x001013a8
LEA ECX,[RSI + 0x4]
MOVSXD RCX,ECX
CMP RCX,RDX
JNC 0x0010136f
LAB_00101341:
CMP BPL,byte ptr [RBX + RCX*0x1]
JNZ 0x0010134a
ADD EAX,0x1
LAB_0010134a:
LEA ECX,[RSI + 0x5]
MOVSXD RCX,ECX
CMP RCX,RDX
JNC 0x0010136f
CMP BPL,byte ptr [RBX + RCX*0x1]
JNZ 0x0010135e
ADD EAX,0x1
LAB_0010135e:
ADD ESI,0x6
MOVSXD RSI,ESI
CMP RSI,RDX
JNC 0x0010136f
CMP BPL,byte ptr [RBX + RSI*0x1]
JZ 0x001013c0
LAB_0010136f:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00101380:
ADD EAX,0x1
JMP 0x00101303
LAB_00101390:
ADD EAX,0x1
JMP 0x00101314
LAB_001013a0:
ADD EAX,0x1
JMP 0x00101325
LAB_001013a8:
LEA ECX,[RSI + 0x4]
ADD EAX,0x1
MOVSXD RCX,ECX
CMP RCX,RDX
JC 0x00101341
JMP 0x0010136f
LAB_001013c0:
ADD RSP,0x8
ADD EAX,0x1
POP RBX
POP RBP
RET
LAB_001013d0:
ADD RSP,0x8
XOR EAX,EAX
POP RBX
POP RBP
RET
LAB_001013d9:
PXOR XMM0,XMM0
XOR ESI,ESI
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00101253 | int func0(char *param_1,char param_2)
{
bool bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
char *pcVar9;
char *pcVar10;
char *pcVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pcVar16;
char *pcVar17;
char *pcVar18;
char *pcVar19;
char *pcVar20;
char *pcVar21;
char *pcVar22;
char *pcVar23;
int auVar24 [14];
int auVar25 [12];
unkbyte10 Var26;
int auVar27 [12];
int auVar28 [14];
int auVar29 [12];
int auVar30 [16];
int auVar31 [16];
int auVar32 [16];
int auVar33 [12];
unkbyte9 Var34;
int6 uVar35;
int4 uVar36;
int2 uVar37;
size_t sVar38;
char *pcVar39;
ulong uVar40;
uint uVar41;
ulong uVar42;
int4 uVar43;
int iVar44;
char cVar52;
short sVar53;
int auVar48 [12];
int auVar51 [16];
int iVar54;
int auVar55 [12];
char cVar60;
short sVar61;
char cVar64;
int iVar62;
char cVar63;
char cVar65;
int iVar66;
int iVar68;
int auVar56 [16];
int auVar57 [16];
int iVar69;
char cVar74;
char cVar75;
char cVar76;
char cVar77;
char cVar78;
char cVar79;
short sVar80;
short sVar81;
int in_XMM2 [16];
int auVar71 [16];
int auVar73 [16];
int auVar82 [16];
int auVar87 [16];
int auVar88 [16];
int auVar91 [16];
int auVar95 [16];
int auVar98 [16];
int6 uVar45;
int8 uVar46;
int auVar47 [12];
int auVar49 [14];
int auVar50 [16];
int auVar58 [16];
int auVar59 [16];
long lVar67;
int auVar70 [12];
int auVar72 [16];
int auVar83 [16];
int auVar84 [16];
int auVar92 [16];
int auVar85 [16];
int auVar89 [16];
int auVar93 [16];
int auVar86 [16];
int auVar90 [16];
int auVar94 [16];
int auVar96 [16];
int auVar97 [16];
int auVar99 [16];
int auVar100 [16];
sVar38 = strlen(param_1);
if (sVar38 == 0) {
return 0;
}
if (sVar38 - 1 < 0xf) {
iVar54 = 0;
iVar62 = 0;
uVar41 = 0;
iVar44 = 0;
uVar40 = 0;
}
else {
iVar54 = 0;
iVar62 = 0;
iVar66 = 0;
iVar68 = 0;
uVar40 = sVar38 & 0xfffffffffffffff0;
pcVar39 = param_1;
do {
cVar52 = *pcVar39;
pcVar9 = pcVar39 + 1;
pcVar10 = pcVar39 + 2;
pcVar11 = pcVar39 + 3;
pcVar12 = pcVar39 + 4;
pcVar13 = pcVar39 + 5;
pcVar14 = pcVar39 + 6;
pcVar15 = pcVar39 + 7;
pcVar16 = pcVar39 + 8;
pcVar17 = pcVar39 + 9;
pcVar18 = pcVar39 + 10;
pcVar19 = pcVar39 + 0xb;
pcVar20 = pcVar39 + 0xc;
pcVar21 = pcVar39 + 0xd;
pcVar22 = pcVar39 + 0xe;
pcVar23 = pcVar39 + 0xf;
pcVar39 = pcVar39 + 0x10;
bVar1 = cVar52 == param_2;
cVar52 = -(*pcVar15 == param_2);
bVar5 = *pcVar16 == param_2;
bVar6 = *pcVar17 == param_2;
bVar7 = *pcVar18 == param_2;
bVar8 = *pcVar19 == param_2;
uVar37 = CONCAT11(-(*pcVar15 == param_2),cVar52);
uVar36 = CONCAT31(CONCAT21(uVar37,-(*pcVar14 == param_2)),-(*pcVar14 == param_2));
uVar35 = CONCAT51(CONCAT41(uVar36,-(*pcVar13 == param_2)),-(*pcVar13 == param_2));
Var34 = CONCAT72(CONCAT61(uVar35,-(*pcVar12 == param_2)),
CONCAT11(-(*pcVar12 == param_2),cVar52));
lVar67 = (long)((unkuint9)Var34 >> 8);
Var26 = CONCAT91(CONCAT81(lVar67,-(*pcVar11 == param_2)),-(*pcVar11 == param_2));
auVar25._2_10_ = Var26;
auVar25[1] = -(*pcVar10 == param_2);
auVar25[0] = -(*pcVar10 == param_2);
auVar24._2_12_ = auVar25;
auVar24[1] = -(*pcVar9 == param_2);
auVar24[0] = -(*pcVar9 == param_2);
auVar71._0_2_ = CONCAT11(-bVar1,-bVar1);
auVar71._2_14_ = auVar24;
uVar43 = CONCAT13(-bVar6,CONCAT12(-bVar6,CONCAT11(-bVar5,-bVar5)));
uVar45 = CONCAT15(-bVar7,CONCAT14(-bVar7,uVar43));
uVar46 = CONCAT17(-bVar8,CONCAT16(-bVar8,uVar45));
auVar47._0_10_ = CONCAT19(-(*pcVar20 == param_2),CONCAT18(-(*pcVar20 == param_2),uVar46));
auVar47[10] = -(*pcVar21 == param_2);
auVar47[0xb] = -(*pcVar21 == param_2);
auVar49[0xc] = -(*pcVar22 == param_2);
auVar49._0_12_ = auVar47;
auVar49[0xd] = -(*pcVar22 == param_2);
auVar73[0xe] = -(*pcVar23 == param_2);
auVar73._0_14_ = auVar49;
auVar73[0xf] = -(*pcVar23 == param_2);
sVar53 = (short)Var26;
sVar61 = (short)((unkuint9)Var34 >> 8);
sVar80 = (short)uVar35;
sVar81 = (short)uVar36;
auVar100._0_12_ = auVar71._0_12_;
auVar100._12_2_ = sVar53;
auVar100._14_2_ = -(ushort)(sVar53 < 0);
auVar99._12_4_ = auVar100._12_4_;
auVar99._0_10_ = auVar71._0_10_;
auVar99._10_2_ = -(ushort)(auVar25._0_2_ < 0);
auVar98._10_6_ = auVar99._10_6_;
auVar98._0_8_ = auVar71._0_8_;
auVar98._8_2_ = auVar25._0_2_;
auVar27._4_8_ = auVar98._8_8_;
auVar27._2_2_ = -(ushort)(auVar24._0_2_ < 0);
auVar27._0_2_ = auVar24._0_2_;
iVar69 = CONCAT22(-(ushort)(sVar61 < 0),sVar61);
auVar70._0_8_ = CONCAT26(-(ushort)(sVar80 < 0),CONCAT24(sVar80,iVar69));
auVar70._8_2_ = sVar81;
auVar70._10_2_ = -(ushort)(sVar81 < 0);
auVar72._12_2_ = uVar37;
auVar72._0_12_ = auVar70;
auVar72._14_2_ = -(ushort)(lVar67 < 0);
sVar53 = (short)((unkuint10)auVar47._0_10_ >> 0x40);
auVar86._12_2_ = (short)((ulong)uVar46 >> 0x30);
auVar86._0_12_ = auVar47;
auVar86._14_2_ = -(ushort)bVar8;
auVar85._12_4_ = auVar86._12_4_;
auVar85._10_2_ = -(ushort)bVar7;
auVar85._0_10_ = auVar47._0_10_;
auVar84._10_6_ = auVar85._10_6_;
auVar84._8_2_ = (short)((uint6)uVar45 >> 0x20);
auVar84._0_8_ = uVar46;
auVar83._8_8_ = auVar84._8_8_;
auVar83._6_2_ = -(ushort)bVar6;
auVar83._0_6_ = uVar45;
auVar82._6_10_ = auVar83._6_10_;
auVar82._4_2_ = (short)((uint)uVar43 >> 0x10);
auVar82._0_4_ = uVar43;
iVar44 = CONCAT22(-(ushort)(sVar53 < 0),sVar53);
auVar48._0_8_ = CONCAT26(-(ushort)(auVar47._10_2_ < 0),CONCAT24(auVar47._10_2_,iVar44));
auVar48._8_2_ = auVar49._12_2_;
auVar48._10_2_ = -(ushort)(auVar49._12_2_ < 0);
auVar50._12_2_ = auVar73._14_2_;
auVar50._0_12_ = auVar48;
auVar50._14_2_ = -(ushort)(auVar73._14_2_ < 0);
iVar54 = (((iVar54 - CONCAT22(-(ushort)bVar1,auVar71._0_2_)) - iVar69) -
CONCAT22(-(ushort)bVar5,CONCAT11(-bVar5,-bVar5))) - iVar44;
iVar62 = (((iVar62 - auVar27._0_4_) - (int)((ulong)auVar70._0_8_ >> 0x20)) - auVar82._4_4_) -
(int)((ulong)auVar48._0_8_ >> 0x20);
iVar66 = (((iVar66 - auVar98._8_4_) - auVar70._8_4_) - auVar84._8_4_) - auVar48._8_4_;
iVar68 = (((iVar68 - auVar99._12_4_) - auVar72._12_4_) - auVar85._12_4_) - auVar50._12_4_;
} while (param_1 + uVar40 != pcVar39);
uVar41 = (uint)sVar38 & 0xfffffff0;
auVar51._0_4_ = iVar66 + iVar54;
auVar51._4_4_ = iVar68 + iVar62;
auVar51._8_4_ = iVar66;
auVar51._12_4_ = iVar68;
in_XMM2 = auVar51 >> 0x20;
iVar44 = auVar51._0_4_ + auVar51._4_4_;
iVar54 = iVar54 + iVar66;
iVar62 = iVar62 + iVar68;
if (sVar38 == uVar40) {
return iVar44;
}
}
uVar42 = sVar38 - uVar40;
if (6 < uVar42 - 1) {
uVar46 = *(int8 *)(param_1 + uVar40);
auVar73 = pshuflw(in_XMM2,ZEXT216(CONCAT11(param_2,param_2)),0);
bVar1 = (char)uVar46 == auVar73[0];
auVar56[0] = -bVar1;
bVar5 = (char)((ulong)uVar46 >> 8) == auVar73[1];
cVar52 = -bVar5;
bVar6 = (char)((ulong)uVar46 >> 0x10) == auVar73[2];
bVar7 = (char)((ulong)uVar46 >> 0x18) == auVar73[3];
bVar8 = (char)((ulong)uVar46 >> 0x20) == auVar73[4];
cVar60 = -bVar8;
bVar2 = (char)((ulong)uVar46 >> 0x28) == auVar73[5];
cVar63 = -bVar2;
bVar3 = (char)((ulong)uVar46 >> 0x30) == auVar73[6];
cVar64 = -bVar3;
bVar4 = (char)((ulong)uVar46 >> 0x38) == auVar73[7];
cVar65 = -bVar4;
cVar74 = -bVar5;
cVar75 = -bVar7;
cVar76 = -bVar8;
cVar77 = -bVar2;
cVar78 = -bVar3;
cVar79 = -bVar4;
Var26 = CONCAT91(CONCAT81((long)(CONCAT72(CONCAT61(CONCAT51(CONCAT41(CONCAT31(CONCAT21(CONCAT11(
cVar79,cVar65),cVar78),cVar64),cVar77),cVar63),
cVar76),CONCAT11(cVar60,cVar65)) >> 8),cVar75),
-bVar7);
auVar29._2_10_ = Var26;
auVar29[1] = -bVar6;
auVar29[0] = -bVar6;
auVar28._2_12_ = auVar29;
auVar28[1] = cVar74;
auVar28[0] = cVar52;
auVar87._0_2_ = CONCAT11(-bVar1,auVar56[0]);
auVar87._2_14_ = auVar28;
uVar37 = CONCAT11(cVar79,cVar65);
uVar36 = CONCAT31(CONCAT21(uVar37,cVar78),cVar64);
uVar35 = CONCAT51(CONCAT41(uVar36,cVar77),cVar63);
Var34 = CONCAT72(CONCAT61(uVar35,cVar76),CONCAT11(cVar60,cVar65));
lVar67 = (long)((unkuint9)Var34 >> 8);
auVar32._1_8_ = lVar67;
auVar32[0] = cVar75;
auVar32._9_7_ = 0;
auVar31._10_6_ = 0;
auVar31._0_10_ = SUB1610(auVar32 << 0x38,6);
auVar30._11_5_ = 0;
auVar30._0_11_ = SUB1611(auVar31 << 0x30,5);
auVar56._4_12_ = SUB1612(auVar30 << 0x28,4);
auVar56[3] = cVar74;
auVar56[2] = cVar52;
auVar56[1] = -bVar1;
iVar44 = (int)((unkuint9)Var34 >> 8);
auVar55._8_4_ = auVar56._0_4_;
auVar55._0_8_ = lVar67;
sVar80 = auVar29._0_2_;
sVar81 = (short)Var26;
sVar53 = (short)((unkuint9)Var34 >> 8);
sVar61 = (short)uVar36;
auVar97._0_12_ = auVar87._0_12_;
auVar97._12_2_ = sVar81;
auVar97._14_2_ = -(ushort)(sVar81 < 0);
auVar96._12_4_ = auVar97._12_4_;
auVar96._0_10_ = auVar87._0_10_;
auVar96._10_2_ = -(ushort)(sVar80 < 0);
auVar95._10_6_ = auVar96._10_6_;
auVar95._0_8_ = auVar87._0_8_;
auVar95._8_2_ = sVar80;
auVar33._4_8_ = auVar95._8_8_;
auVar33._2_2_ = -(ushort)(auVar28._0_2_ < 0);
auVar33._0_2_ = auVar28._0_2_;
auVar90._12_2_ = sVar81;
auVar90._0_12_ = auVar97._0_12_;
auVar90._14_2_ = -(ushort)(sVar81 < 0);
auVar89._12_4_ = auVar90._12_4_;
auVar89._10_2_ = -(ushort)(sVar80 < 0);
auVar89._0_10_ = auVar96._0_10_;
auVar88._10_6_ = auVar89._10_6_;
auVar88._8_2_ = sVar80;
auVar88._0_8_ = auVar95._0_8_;
auVar59._12_2_ = uVar37;
auVar59._0_12_ = auVar55;
auVar59._14_2_ = -(ushort)(lVar67 < 0);
auVar58._12_4_ = auVar59._12_4_;
auVar58._0_10_ = auVar55._0_10_;
auVar58._10_2_ = -(ushort)(sVar61 < 0);
auVar57._10_6_ = auVar58._10_6_;
auVar57._8_2_ = sVar61;
auVar57._0_8_ = lVar67;
auVar94._12_2_ = uVar37;
auVar94._0_12_ = auVar55;
auVar94._14_2_ = -(ushort)(lVar67 < 0);
auVar93._12_4_ = auVar94._12_4_;
auVar93._10_2_ = -(ushort)(sVar61 < 0);
auVar93._0_10_ = auVar58._0_10_;
auVar92._10_6_ = auVar93._10_6_;
auVar92._8_2_ = sVar61;
auVar92._0_8_ = lVar67;
auVar91._8_8_ = auVar92._8_8_;
auVar91._6_2_ = -(ushort)(iVar44 < 0);
auVar91._4_2_ = (short)uVar35;
auVar91._0_4_ = iVar44;
iVar44 = ((((iVar62 - auVar33._0_4_) - auVar89._12_4_) - auVar91._4_4_) - auVar58._12_4_) +
((((iVar54 - CONCAT22(-(ushort)bVar1,auVar87._0_2_)) - auVar88._8_4_) -
CONCAT22(-(ushort)(sVar53 < 0),sVar53)) - auVar57._8_4_);
uVar40 = uVar40 + (uVar42 & 0xfffffffffffffff8);
uVar41 = uVar41 + (int)(uVar42 & 0xfffffffffffffff8);
if ((uVar42 & 7) == 0) {
return iVar44;
}
}
if (param_1[uVar40] == param_2) {
iVar44 = iVar44 + 1;
}
if ((ulong)(long)(int)(uVar41 + 1) < sVar38) {
if (param_2 == param_1[(int)(uVar41 + 1)]) {
iVar44 = iVar44 + 1;
}
if ((ulong)(long)(int)(uVar41 + 2) < sVar38) {
if (param_2 == param_1[(int)(uVar41 + 2)]) {
iVar44 = iVar44 + 1;
}
if ((ulong)(long)(int)(uVar41 + 3) < sVar38) {
if (param_2 == param_1[(int)(uVar41 + 3)]) {
iVar44 = iVar44 + 1;
}
if ((ulong)(long)(int)(uVar41 + 4) < sVar38) {
if (param_2 == param_1[(int)(uVar41 + 4)]) {
iVar44 = iVar44 + 1;
}
if ((ulong)(long)(int)(uVar41 + 5) < sVar38) {
if (param_2 == param_1[(int)(uVar41 + 5)]) {
iVar44 = iVar44 + 1;
}
if (((ulong)(long)(int)(uVar41 + 6) < sVar38) && (param_2 == param_1[(int)(uVar41 + 6)])
) {
return iVar44 + 1;
}
}
}
}
}
}
return iVar44;
} |
4,712 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(const int test_tup[], int n, int res[]) {
for (int i = 0; i < n; i++) {
res[i] = ~test_tup[i];
}
}
| int main() {
int res[6];
int test1[] = {7, 8, 9, 1, 10, 7};
int expected1[] = {-8, -9, -10, -2, -11, -8};
func0(test1, 6, res);
for (int i = 0; i < 6; i++) assert(res[i] == expected1[i]);
int test2[] = {2, 4, 5, 6, 1, 7};
int expected2[] = {-3, -5, -6, -7, -2, -8};
func0(test2, 6, res);
for (int i = 0; i < 6; i++) assert(res[i] == expected2[i]);
int test3[] = {8, 9, 11, 14, 12, 13};
int expected3[] = {-9, -10, -12, -15, -13, -14};
func0(test3, 6, res);
for (int i = 0; i < 6; i++) assert(res[i] == expected3[i]);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d7 <func0+0x4e>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
not %edx
mov %edx,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11a5 <func0+0x1c>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_4], 0
jmp short loc_11D7
loc_11A5:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
not edx
mov [rax], edx
add [rbp+var_4], 1
loc_11D7:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11A5
nop
nop
pop rbp
retn | long long func0(long long a1, int a2, long long a3)
{
long long result; // rax
unsigned int i; // [rsp+24h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a2 )
break;
*(_DWORD *)(4LL * (int)i + a3) = ~*(_DWORD *)(4LL * (int)i + a1);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d7
LAB_001011a5:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
NOT EDX
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d7:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011a5
NOP
NOP
POP RBP
RET | void func0(long param_1,int param_2,long param_3)
{
int4 local_c;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
*(uint *)(param_3 + (long)local_c * 4) = ~*(uint *)(param_1 + (long)local_c * 4);
}
return;
} |
4,713 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(const int test_tup[], int n, int res[]) {
for (int i = 0; i < n; i++) {
res[i] = ~test_tup[i];
}
}
| int main() {
int res[6];
int test1[] = {7, 8, 9, 1, 10, 7};
int expected1[] = {-8, -9, -10, -2, -11, -8};
func0(test1, 6, res);
for (int i = 0; i < 6; i++) assert(res[i] == expected1[i]);
int test2[] = {2, 4, 5, 6, 1, 7};
int expected2[] = {-3, -5, -6, -7, -2, -8};
func0(test2, 6, res);
for (int i = 0; i < 6; i++) assert(res[i] == expected2[i]);
int test3[] = {8, 9, 11, 14, 12, 13};
int expected3[] = {-9, -10, -12, -15, -13, -14};
func0(test3, 6, res);
for (int i = 0; i < 6; i++) assert(res[i] == expected3[i]);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ad <func0+0x24>
lea -0x1(%rsi),%esi
mov $0x0,%eax
mov (%rdi,%rax,4),%ecx
not %ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %rsi,%rcx
jne 1199 <func0+0x10>
retq
| func0:
endbr64
test esi, esi
jle short locret_11A9
mov esi, esi
mov eax, 0
loc_1198:
mov ecx, [rdi+rax*4]
not ecx
mov [rdx+rax*4], ecx
add rax, 1
cmp rax, rsi
jnz short loc_1198
locret_11A9:
retn | void func0(long long a1, int a2, long long a3)
{
long long i; // rax
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(a3 + 4 * i) = ~*(_DWORD *)(a1 + 4 * i);
}
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a9
MOV ESI,ESI
MOV EAX,0x0
LAB_00101198:
MOV ECX,dword ptr [RDI + RAX*0x4]
NOT ECX
MOV dword ptr [RDX + RAX*0x4],ECX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101198
LAB_001011a9:
RET | void func0(long param_1,uint param_2,long param_3)
{
ulong uVar1;
if (0 < (int)param_2) {
uVar1 = 0;
do {
*(uint *)(param_3 + uVar1 * 4) = ~*(uint *)(param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
}
return;
} |
4,714 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(const int test_tup[], int n, int res[]) {
for (int i = 0; i < n; i++) {
res[i] = ~test_tup[i];
}
}
| int main() {
int res[6];
int test1[] = {7, 8, 9, 1, 10, 7};
int expected1[] = {-8, -9, -10, -2, -11, -8};
func0(test1, 6, res);
for (int i = 0; i < 6; i++) assert(res[i] == expected1[i]);
int test2[] = {2, 4, 5, 6, 1, 7};
int expected2[] = {-3, -5, -6, -7, -2, -8};
func0(test2, 6, res);
for (int i = 0; i < 6; i++) assert(res[i] == expected2[i]);
int test3[] = {8, 9, 11, 14, 12, 13};
int expected3[] = {-9, -10, -12, -15, -13, -14};
func0(test3, 6, res);
for (int i = 0; i < 6; i++) assert(res[i] == expected3[i]);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1434 <func0+0x24>
sub $0x1,%esi
xor %eax,%eax
nopl (%rax)
mov (%rdi,%rax,4),%ecx
not %ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %rcx,%rsi
jne 1420 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short locret_1451
movsxd rsi, esi
xor eax, eax
nop dword ptr [rax]
loc_1440:
mov ecx, [rdi+rax*4]
not ecx
mov [rdx+rax*4], ecx
add rax, 1
cmp rsi, rax
jnz short loc_1440
locret_1451:
retn | void func0(long long a1, int a2, long long a3)
{
long long i; // rax
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(a3 + 4 * i) = ~*(_DWORD *)(a1 + 4 * i);
}
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101451
MOVSXD RSI,ESI
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101440:
MOV ECX,dword ptr [RDI + RAX*0x4]
NOT ECX
MOV dword ptr [RDX + RAX*0x4],ECX
ADD RAX,0x1
CMP RSI,RAX
JNZ 0x00101440
LAB_00101451:
RET | void func0(long param_1,int param_2,long param_3)
{
long lVar1;
if (0 < param_2) {
lVar1 = 0;
do {
*(uint *)(param_3 + lVar1 * 4) = ~*(uint *)(param_1 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (param_2 != lVar1);
}
return;
} |
4,715 | func0 |
#include <stdio.h>
#include <assert.h>
| void func0(const int test_tup[], int n, int res[]) {
for (int i = 0; i < n; i++) {
res[i] = ~test_tup[i];
}
}
| int main() {
int res[6];
int test1[] = {7, 8, 9, 1, 10, 7};
int expected1[] = {-8, -9, -10, -2, -11, -8};
func0(test1, 6, res);
for (int i = 0; i < 6; i++) assert(res[i] == expected1[i]);
int test2[] = {2, 4, 5, 6, 1, 7};
int expected2[] = {-3, -5, -6, -7, -2, -8};
func0(test2, 6, res);
for (int i = 0; i < 6; i++) assert(res[i] == expected2[i]);
int test3[] = {8, 9, 11, 14, 12, 13};
int expected3[] = {-9, -10, -12, -15, -13, -14};
func0(test3, 6, res);
for (int i = 0; i < 6; i++) assert(res[i] == expected3[i]);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1424 <func0+0xa4>
lea 0xf(%rdi),%rcx
lea -0x1(%rsi),%eax
sub %rdx,%rcx
cmp $0x1e,%rcx
jbe 1408 <func0+0x88>
cmp $0x3,%eax
jbe 1408 <func0+0x88>
mov %esi,%ecx
xor %eax,%eax
pcmpeqd %xmm1,%xmm1
shr $0x2,%ecx
shl $0x4,%rcx
movdqu (%rdi,%rax,1),%xmm0
pxor %xmm1,%xmm0
movups %xmm0,(%rdx,%rax,1)
add $0x10,%rax
cmp %rcx,%rax
jne 13b0 <func0+0x30>
mov %esi,%eax
and $0xfffffffc,%eax
test $0x3,%sil
je 1424 <func0+0xa4>
mov %eax,%r8d
mov (%rdi,%r8,4),%ecx
not %ecx
mov %ecx,(%rdx,%r8,4)
lea 0x1(%rax),%ecx
cmp %ecx,%esi
jle 1424 <func0+0xa4>
movslq %ecx,%rcx
add $0x2,%eax
mov (%rdi,%rcx,4),%r8d
not %r8d
mov %r8d,(%rdx,%rcx,4)
cmp %eax,%esi
jle 1424 <func0+0xa4>
cltq
mov (%rdi,%rax,4),%ecx
not %ecx
mov %ecx,(%rdx,%rax,4)
retq
nopl (%rax)
mov %eax,%esi
xor %eax,%eax
nopl 0x0(%rax)
mov (%rdi,%rax,4),%ecx
not %ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %rsi,%rcx
jne 1410 <func0+0x90>
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rax, esi
mov rsi, rdx
test eax, eax
jle short locret_11B1
lea edx, [rax-1]
cmp edx, 2
jbe short loc_1196
lea rcx, [rdi+4]
mov rdx, rsi
sub rdx, rcx
cmp rdx, 8
ja short loc_11B8
loc_1196:
lea rcx, ds:0[rax*4]
xor eax, eax
loc_11A0:
mov edx, [rdi+rax]
not edx
mov [rsi+rax], edx
add rax, 4
cmp rcx, rax
jnz short loc_11A0
locret_11B1:
retn
loc_11B8:
mov ecx, eax
xor edx, edx
pcmpeqd xmm1, xmm1
shr ecx, 2
shl rcx, 4
nop word ptr [rax+rax+00000000h]
loc_11D0:
movdqu xmm0, xmmword ptr [rdi+rdx]
pxor xmm0, xmm1
movups xmmword ptr [rsi+rdx], xmm0
add rdx, 10h
cmp rdx, rcx
jnz short loc_11D0
mov edx, eax
and edx, 0FFFFFFFCh
test al, 3
jz short locret_11B1
mov r8d, edx
mov r9d, [rdi+r8*4]
lea rcx, ds:0[r8*4]
not r9d
mov [rsi+r8*4], r9d
lea r8d, [rdx+1]
cmp eax, r8d
jle short locret_11B1
mov r8d, [rdi+rcx+4]
add edx, 2
not r8d
mov [rsi+rcx+4], r8d
cmp eax, edx
jle short locret_11B1
mov eax, [rdi+rcx+8]
not eax
mov [rsi+rcx+8], eax
retn | long long func0(long long a1, int a2, long long a3)
{
long long result; // rax
long long v5; // rcx
long long v6; // rdx
unsigned int v7; // edx
long long v8; // rcx
result = a2;
if ( (int)result > 0 )
{
if ( (unsigned int)(result - 1) > 2 && (unsigned long long)(a3 - (a1 + 4)) > 8 )
{
v6 = 0LL;
do
{
*(__m128i *)(a3 + v6) = _mm_xor_si128(_mm_loadu_si128((const __m128i *)(a1 + v6)), (__m128i)-1LL);
v6 += 16LL;
}
while ( v6 != 16LL * ((unsigned int)result >> 2) );
v7 = result & 0x7FFFFFFC;
if ( (result & 3) != 0 )
{
v8 = 4LL * v7;
*(_DWORD *)(a3 + v8) = ~*(_DWORD *)(a1 + v8);
if ( (int)result > (int)(v7 + 1) )
{
*(_DWORD *)(a3 + v8 + 4) = ~*(_DWORD *)(a1 + v8 + 4);
if ( (int)result > (int)(v7 + 2) )
{
result = (unsigned int)~*(_DWORD *)(a1 + v8 + 8);
*(_DWORD *)(a3 + v8 + 8) = result;
}
}
}
}
else
{
v5 = 4 * result;
result = 0LL;
do
{
*(_DWORD *)(a3 + result) = ~*(_DWORD *)(a1 + result);
result += 4LL;
}
while ( v5 != result );
}
}
return result;
} | func0:
ENDBR64
MOVSXD RAX,ESI
MOV RSI,RDX
TEST EAX,EAX
JLE 0x001011b1
LEA EDX,[RAX + -0x1]
CMP EDX,0x2
JBE 0x00101196
LEA RCX,[RDI + 0x4]
MOV RDX,RSI
SUB RDX,RCX
CMP RDX,0x8
JA 0x001011b8
LAB_00101196:
LEA RCX,[RAX*0x4]
XOR EAX,EAX
LAB_001011a0:
MOV EDX,dword ptr [RDI + RAX*0x1]
NOT EDX
MOV dword ptr [RSI + RAX*0x1],EDX
ADD RAX,0x4
CMP RCX,RAX
JNZ 0x001011a0
LAB_001011b1:
RET
LAB_001011b8:
MOV ECX,EAX
XOR EDX,EDX
PCMPEQD XMM1,XMM1
SHR ECX,0x2
SHL RCX,0x4
NOP word ptr [RAX + RAX*0x1]
LAB_001011d0:
MOVDQU XMM0,xmmword ptr [RDI + RDX*0x1]
PXOR XMM0,XMM1
MOVUPS xmmword ptr [RSI + RDX*0x1],XMM0
ADD RDX,0x10
CMP RDX,RCX
JNZ 0x001011d0
MOV EDX,EAX
AND EDX,0xfffffffc
TEST AL,0x3
JZ 0x001011b1
MOV R8D,EDX
MOV R9D,dword ptr [RDI + R8*0x4]
LEA RCX,[R8*0x4]
NOT R9D
MOV dword ptr [RSI + R8*0x4],R9D
LEA R8D,[RDX + 0x1]
CMP EAX,R8D
JLE 0x001011b1
MOV R8D,dword ptr [RDI + RCX*0x1 + 0x4]
ADD EDX,0x2
NOT R8D
MOV dword ptr [RSI + RCX*0x1 + 0x4],R8D
CMP EAX,EDX
JLE 0x001011b1
MOV EAX,dword ptr [RDI + RCX*0x1 + 0x8]
NOT EAX
MOV dword ptr [RSI + RCX*0x1 + 0x8],EAX
RET | void func0(long param_1,uint param_2,long param_3)
{
uint *puVar1;
uint *puVar2;
uint uVar3;
uint uVar4;
long lVar5;
uint uVar6;
ulong uVar7;
if (0 < (int)param_2) {
if ((param_2 - 1 < 3) || ((ulong)(param_3 - (param_1 + 4)) < 9)) {
lVar5 = 0;
do {
*(uint *)(param_3 + lVar5) = ~*(uint *)(param_1 + lVar5);
lVar5 = lVar5 + 4;
} while ((long)(int)param_2 * 4 - lVar5 != 0);
}
else {
lVar5 = 0;
do {
puVar1 = (uint *)(param_1 + lVar5);
uVar6 = puVar1[1];
uVar3 = puVar1[2];
uVar4 = puVar1[3];
puVar2 = (uint *)(param_3 + lVar5);
*puVar2 = *puVar1 ^ 0xffffffff;
puVar2[1] = uVar6 ^ 0xffffffff;
puVar2[2] = uVar3 ^ 0xffffffff;
puVar2[3] = uVar4 ^ 0xffffffff;
lVar5 = lVar5 + 0x10;
} while (lVar5 != (ulong)(param_2 >> 2) << 4);
uVar6 = param_2 & 0xfffffffc;
if (((long)(int)param_2 & 3U) != 0) {
uVar7 = (ulong)uVar6;
lVar5 = uVar7 * 4;
*(uint *)(param_3 + uVar7 * 4) = ~*(uint *)(param_1 + uVar7 * 4);
if (((int)(uVar6 + 1) < (int)param_2) &&
(*(uint *)(param_3 + 4 + lVar5) = ~*(uint *)(param_1 + 4 + lVar5),
(int)(uVar6 + 2) < (int)param_2)) {
*(uint *)(param_3 + 8 + lVar5) = ~*(uint *)(param_1 + 8 + lVar5);
return;
}
}
}
}
return;
} |
4,716 | func0 |
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char** func0(char* test_tup[], int size) {
char** res = malloc((size - 1) * sizeof(char*));
for(int i = 0; i < size - 1; i++) {
res[i] = malloc(strlen(test_tup[i]) + strlen(test_tup[i+1]) + 1);
strcpy(res[i], test_tup[i]);
strcat(res[i], test_tup[i+1]);
}
return res;
}
| int main() {
// First test case
char* test1[] = {"DSP ", "IS ", "BEST ", "FOR ", "ALL ", "UTS"};
char* expected1[] = {"DSP IS ", "IS BEST ", "BEST FOR ", "FOR ALL ", "ALL UTS"};
char** result1 = func0(test1, 6);
for(int i = 0; i < 5; i++) {
assert(strcmp(result1[i], expected1[i]) == 0);
free(result1[i]);
}
free(result1);
// Second test case
char* test2[] = {"RES ", "IS ", "BEST ", "FOR ", "ALL ", "QESR"};
char* expected2[] = {"RES IS ", "IS BEST ", "BEST FOR ", "FOR ALL ", "ALL QESR"};
char** result2 = func0(test2, 6);
for(int i = 0; i < 5; i++) {
assert(strcmp(result2[i], expected2[i]) == 0);
free(result2[i]);
}
free(result2);
// Third test case
char* test3[] = {"MSAM", "IS ", "BEST ", "FOR ", "ALL ", "SKD"};
char* expected3[] = {"MSAMIS ", "IS BEST ", "BEST FOR ", "FOR ALL ", "ALL SKD"};
char** result3 = func0(test3, 6);
for(int i = 0; i < 5; i++) {
assert(strcmp(result3[i], expected3[i]) == 0);
free(result3[i]);
}
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1120 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x1c(%rbp)
jmpq 1348 <func0+0x11f>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 10e0 <strlen@plt>
mov %rax,%rbx
mov -0x1c(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 10e0 <strlen@plt>
add %rbx,%rax
add $0x1,%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 1120 <malloc@plt>
mov %rax,(%rbx)
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10d0 <strcpy@plt>
mov -0x1c(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1130 <strcat@plt>
addl $0x1,-0x1c(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x1c(%rbp)
jl 1261 <func0+0x38>
mov -0x18(%rbp),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov eax, [rbp+var_2C]
sub eax, 1
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_1C], 0
jmp loc_1348
loc_1261:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strlen
mov rbx, rax
mov eax, [rbp+var_1C]
cdqe
add rax, 1
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strlen
add rax, rbx
add rax, 1
mov edx, [rbp+var_1C]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
lea rbx, [rcx+rdx]
mov rdi, rax; size
call _malloc
mov [rbx], rax
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_1C]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rcx
mov rax, [rax]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
mov eax, [rbp+var_1C]
cdqe
add rax, 1
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_1C]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rcx
mov rax, [rax]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcat
add [rbp+var_1C], 1
loc_1348:
mov eax, [rbp+var_2C]
sub eax, 1
cmp [rbp+var_1C], eax
jl loc_1261
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(long long a1, int a2)
{
size_t v2; // rbx
size_t v3; // rax
int i; // [rsp+14h] [rbp-1Ch]
_QWORD *v6; // [rsp+18h] [rbp-18h]
v6 = malloc(8LL * (a2 - 1));
for ( i = 0; i < a2 - 1; ++i )
{
v2 = strlen(*(const char **)(8LL * i + a1));
v3 = v2 + strlen(*(const char **)(8 * (i + 1LL) + a1)) + 1;
v6[i] = malloc(v3);
strcpy((char *)v6[i], *(const char **)(8LL * i + a1));
strcat((char *)v6[i], *(const char **)(8 * (i + 1LL) + a1));
}
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101348
LAB_00101261:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x001010e0
MOV RBX,RAX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x001010e0
ADD RAX,RBX
ADD RAX,0x1
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010d0
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101130
ADD dword ptr [RBP + -0x1c],0x1
LAB_00101348:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x1c],EAX
JL 0x00101261
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2)
{
void *pvVar1;
size_t sVar2;
size_t sVar3;
void *pvVar4;
int4 local_24;
pvVar1 = malloc((long)(param_2 + -1) << 3);
for (local_24 = 0; local_24 < param_2 + -1; local_24 = local_24 + 1) {
sVar2 = strlen(*(char **)(param_1 + (long)local_24 * 8));
sVar3 = strlen(*(char **)(param_1 + ((long)local_24 + 1) * 8));
pvVar4 = malloc(sVar3 + sVar2 + 1);
*(void **)((long)local_24 * 8 + (long)pvVar1) = pvVar4;
strcpy(*(char **)((long)pvVar1 + (long)local_24 * 8),*(char **)(param_1 + (long)local_24 * 8));
strcat(*(char **)((long)pvVar1 + (long)local_24 * 8),
*(char **)(param_1 + ((long)local_24 + 1) * 8));
}
return pvVar1;
} |
4,717 | func0 |
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char** func0(char* test_tup[], int size) {
char** res = malloc((size - 1) * sizeof(char*));
for(int i = 0; i < size - 1; i++) {
res[i] = malloc(strlen(test_tup[i]) + strlen(test_tup[i+1]) + 1);
strcpy(res[i], test_tup[i]);
strcat(res[i], test_tup[i+1]);
}
return res;
}
| int main() {
// First test case
char* test1[] = {"DSP ", "IS ", "BEST ", "FOR ", "ALL ", "UTS"};
char* expected1[] = {"DSP IS ", "IS BEST ", "BEST FOR ", "FOR ALL ", "ALL UTS"};
char** result1 = func0(test1, 6);
for(int i = 0; i < 5; i++) {
assert(strcmp(result1[i], expected1[i]) == 0);
free(result1[i]);
}
free(result1);
// Second test case
char* test2[] = {"RES ", "IS ", "BEST ", "FOR ", "ALL ", "QESR"};
char* expected2[] = {"RES IS ", "IS BEST ", "BEST FOR ", "FOR ALL ", "ALL QESR"};
char** result2 = func0(test2, 6);
for(int i = 0; i < 5; i++) {
assert(strcmp(result2[i], expected2[i]) == 0);
free(result2[i]);
}
free(result2);
// Third test case
char* test3[] = {"MSAM", "IS ", "BEST ", "FOR ", "ALL ", "SKD"};
char* expected3[] = {"MSAMIS ", "IS BEST ", "BEST FOR ", "FOR ALL ", "ALL SKD"};
char** result3 = func0(test3, 6);
for(int i = 0; i < 5; i++) {
assert(strcmp(result3[i], expected3[i]) == 0);
free(result3[i]);
}
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %esi,%ebx
lea -0x1(%rsi),%r12d
movslq %r12d,%rdi
shl $0x3,%rdi
callq 1100 <malloc@plt>
mov %rax,0x8(%rsp)
test %r12d,%r12d
jle 12b5 <func0+0xac>
mov %rax,%rsi
mov %rax,%r12
add $0x8,%rbp
lea -0x2(%rbx),%eax
lea 0x8(%rsi,%rax,8),%rax
mov %rax,(%rsp)
mov $0xffffffffffffffff,%r15
mov -0x8(%rbp),%r14
mov $0x0,%eax
mov %r15,%rcx
mov %r14,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rdx
not %rdx
mov 0x0(%rbp),%r13
mov %r15,%rcx
mov %r13,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rdx,%rax,1),%rdi
callq 1100 <malloc@plt>
mov %rax,%rbx
mov %rax,(%r12)
mov %r14,%rsi
mov %rax,%rdi
callq 10c0 <strcpy@plt>
mov %r13,%rsi
mov %rbx,%rdi
callq 1110 <strcat@plt>
add $0x8,%r12
add $0x8,%rbp
cmp (%rsp),%r12
jne 1257 <func0+0x4e>
mov 0x8(%rsp),%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
mov ebx, esi
lea r12d, [rsi-1]
movsxd rdi, r12d
shl rdi, 3
call _malloc
mov [rsp+48h+var_40], rax
test r12d, r12d
jle short loc_12BB
mov rdx, rax
mov r12, rax
add rbp, 8
lea eax, [rbx-2]
lea r15, [rdx+rax*8+8]
loc_126C:
mov r14, [rbp-8]
mov rdi, r14
call _strlen
mov rbx, rax
mov r13, [rbp+0]
mov rdi, r13
call _strlen
lea rdi, [rbx+rax+1]
call _malloc
mov rbx, rax
mov [r12], rax
mov rsi, r14
mov rdi, rax
call _strcpy
mov rsi, r13
mov rdi, rbx
call _strcat
add r12, 8
add rbp, 8
cmp r12, r15
jnz short loc_126C
loc_12BB:
mov rax, [rsp+48h+var_40]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, int a2)
{
long long v2; // rax
_QWORD *v3; // r12
_QWORD *v4; // rbp
long long v5; // r15
long long v6; // r14
long long v7; // rbx
long long v8; // r13
long long v9; // rax
long long v10; // rbx
long long v12; // [rsp+8h] [rbp-40h]
v2 = malloc(8LL * (a2 - 1));
v12 = v2;
if ( a2 - 1 > 0 )
{
v3 = (_QWORD *)v2;
v4 = (_QWORD *)(a1 + 8);
v5 = v2 + 8LL * (unsigned int)(a2 - 2) + 8;
do
{
v6 = *(v4 - 1);
v7 = strlen(v6);
v8 = *v4;
v9 = strlen(*v4);
v10 = malloc(v7 + v9 + 1);
*v3 = v10;
strcpy(v10, v6);
strcat(v10, v8);
++v3;
++v4;
}
while ( v3 != (_QWORD *)v5 );
}
return v12;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
MOV EBX,ESI
LEA R12D,[RSI + -0x1]
MOVSXD RDI,R12D
SHL RDI,0x3
CALL 0x00101120
MOV qword ptr [RSP + 0x8],RAX
TEST R12D,R12D
JLE 0x001012bb
MOV RDX,RAX
MOV R12,RAX
ADD RBP,0x8
LEA EAX,[RBX + -0x2]
LEA R15,[RDX + RAX*0x8 + 0x8]
LAB_0010126c:
MOV R14,qword ptr [RBP + -0x8]
MOV RDI,R14
CALL 0x001010e0
MOV RBX,RAX
MOV R13,qword ptr [RBP]
MOV RDI,R13
CALL 0x001010e0
LEA RDI,[RBX + RAX*0x1 + 0x1]
CALL 0x00101120
MOV RBX,RAX
MOV qword ptr [R12],RAX
MOV RSI,R14
MOV RDI,RAX
CALL 0x001010d0
MOV RSI,R13
MOV RDI,RBX
CALL 0x00101130
ADD R12,0x8
ADD RBP,0x8
CMP R12,R15
JNZ 0x0010126c
LAB_001012bb:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(long param_1,int param_2)
{
char *__s;
char *__s_00;
int8 *puVar1;
size_t sVar2;
size_t sVar3;
char *__dest;
int8 *puVar4;
int8 *puVar5;
puVar1 = (int8 *)malloc((long)(param_2 + -1) << 3);
if (0 < param_2 + -1) {
puVar4 = (int8 *)(param_1 + 8);
puVar5 = puVar1;
do {
__s = (char *)puVar4[-1];
sVar2 = strlen(__s);
__s_00 = (char *)*puVar4;
sVar3 = strlen(__s_00);
__dest = (char *)malloc(sVar2 + 1 + sVar3);
*puVar5 = __dest;
strcpy(__dest,__s);
strcat(__dest,__s_00);
puVar5 = puVar5 + 1;
puVar4 = puVar4 + 1;
} while (puVar5 != puVar1 + (ulong)(param_2 - 2) + 1);
}
return puVar1;
} |
4,718 | func0 |
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char** func0(char* test_tup[], int size) {
char** res = malloc((size - 1) * sizeof(char*));
for(int i = 0; i < size - 1; i++) {
res[i] = malloc(strlen(test_tup[i]) + strlen(test_tup[i+1]) + 1);
strcpy(res[i], test_tup[i]);
strcat(res[i], test_tup[i+1]);
}
return res;
}
| int main() {
// First test case
char* test1[] = {"DSP ", "IS ", "BEST ", "FOR ", "ALL ", "UTS"};
char* expected1[] = {"DSP IS ", "IS BEST ", "BEST FOR ", "FOR ALL ", "ALL UTS"};
char** result1 = func0(test1, 6);
for(int i = 0; i < 5; i++) {
assert(strcmp(result1[i], expected1[i]) == 0);
free(result1[i]);
}
free(result1);
// Second test case
char* test2[] = {"RES ", "IS ", "BEST ", "FOR ", "ALL ", "QESR"};
char* expected2[] = {"RES IS ", "IS BEST ", "BEST FOR ", "FOR ALL ", "ALL QESR"};
char** result2 = func0(test2, 6);
for(int i = 0; i < 5; i++) {
assert(strcmp(result2[i], expected2[i]) == 0);
free(result2[i]);
}
free(result2);
// Third test case
char* test3[] = {"MSAM", "IS ", "BEST ", "FOR ", "ALL ", "SKD"};
char* expected3[] = {"MSAMIS ", "IS BEST ", "BEST FOR ", "FOR ALL ", "ALL SKD"};
char** result3 = func0(test3, 6);
for(int i = 0; i < 5; i++) {
assert(strcmp(result3[i], expected3[i]) == 0);
free(result3[i]);
}
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %esi,%r12d
push %rbp
lea -0x1(%rsi),%ebp
push %rbx
mov %rdi,%rbx
movslq %ebp,%rdi
shl $0x3,%rdi
sub $0x18,%rsp
callq 1130 <malloc@plt>
mov %rax,0x8(%rsp)
test %ebp,%ebp
jle 1604 <func0+0x94>
mov %rax,%rdx
mov %rax,%rbp
lea -0x2(%r12),%eax
add $0x8,%rbx
lea 0x8(%rdx,%rax,8),%r12
nopl 0x0(%rax)
mov -0x8(%rbx),%r13
add $0x8,%rbp
add $0x8,%rbx
mov %r13,%rdi
callq 10f0 <strlen@plt>
mov -0x8(%rbx),%r15
mov %rax,%r14
mov %r15,%rdi
callq 10f0 <strlen@plt>
lea 0x1(%r14,%rax,1),%rdi
callq 1130 <malloc@plt>
mov %r13,%rsi
mov %rax,-0x8(%rbp)
mov %rax,%rdi
callq 10e0 <stpcpy@plt>
mov %r15,%rsi
mov %rax,%rdi
callq 10d0 <strcpy@plt>
cmp %r12,%rbp
jne 15b8 <func0+0x48>
mov 0x8(%rsp),%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
mov r12d, esi
push rbp
lea ebp, [rsi-1]
push rbx
mov rbx, rdi
movsxd rdi, ebp
shl rdi, 3
sub rsp, 18h
call _malloc
mov [rsp+48h+var_40], rax
test ebp, ebp
jle short loc_1604
mov rdx, rax
mov rbp, rax
lea eax, [r12-2]
add rbx, 8
lea r12, [rdx+rax*8+8]
nop dword ptr [rax+00h]
loc_15B8:
mov r13, [rbx-8]
add rbp, 8
add rbx, 8
mov rdi, r13
call _strlen
mov r15, [rbx-8]
mov r14, rax
mov rdi, r15
call _strlen
lea rdi, [r14+rax+1]
call _malloc
mov rsi, r13
mov [rbp-8], rax
mov rdi, rax
call _stpcpy
mov rsi, r15
mov rdi, rax
call _strcpy
cmp rbp, r12
jnz short loc_15B8
loc_1604:
mov rax, [rsp+48h+var_40]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, int a2)
{
long long v2; // rax
long long v3; // rbp
long long v4; // rbx
long long v5; // r12
long long v6; // r13
long long v7; // rax
long long v8; // r15
long long v9; // r14
long long v10; // rax
long long v11; // rax
long long v12; // rax
long long v14; // [rsp+8h] [rbp-40h]
v2 = malloc(8LL * (a2 - 1));
v14 = v2;
if ( a2 - 1 > 0 )
{
v3 = v2;
v4 = a1 + 8;
v5 = v2 + 8LL * (unsigned int)(a2 - 2) + 8;
do
{
v6 = *(_QWORD *)(v4 - 8);
v3 += 8LL;
v4 += 8LL;
v7 = strlen(v6);
v8 = *(_QWORD *)(v4 - 8);
v9 = v7;
v10 = strlen(v8);
v11 = malloc(v9 + v10 + 1);
*(_QWORD *)(v3 - 8) = v11;
v12 = stpcpy(v11, v6);
strcpy(v12, v8);
}
while ( v3 != v5 );
}
return v14;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBP
LEA EBP,[RSI + -0x1]
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,EBP
SHL RDI,0x3
SUB RSP,0x18
CALL 0x00101130
MOV qword ptr [RSP + 0x8],RAX
TEST EBP,EBP
JLE 0x00101604
MOV RDX,RAX
MOV RBP,RAX
LEA EAX,[R12 + -0x2]
ADD RBX,0x8
LEA R12,[RDX + RAX*0x8 + 0x8]
NOP dword ptr [RAX]
LAB_001015b8:
MOV R13,qword ptr [RBX + -0x8]
ADD RBP,0x8
ADD RBX,0x8
MOV RDI,R13
CALL 0x001010f0
MOV R15,qword ptr [RBX + -0x8]
MOV R14,RAX
MOV RDI,R15
CALL 0x001010f0
LEA RDI,[R14 + RAX*0x1 + 0x1]
CALL 0x00101130
MOV RSI,R13
MOV qword ptr [RBP + -0x8],RAX
MOV RDI,RAX
CALL 0x001010e0
MOV RSI,R15
MOV RDI,RAX
CALL 0x001010d0
CMP RBP,R12
JNZ 0x001015b8
LAB_00101604:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(long param_1,int param_2)
{
char *__s;
int8 *puVar1;
size_t sVar2;
size_t sVar3;
char *__dest;
char *pcVar4;
int8 *puVar5;
int8 *puVar6;
int8 *puVar7;
puVar1 = (int8 *)malloc((long)(param_2 + -1) << 3);
if (0 < param_2 + -1) {
puVar5 = (int8 *)(param_1 + 8);
puVar6 = puVar1;
do {
pcVar4 = (char *)puVar5[-1];
puVar7 = puVar6 + 1;
sVar2 = strlen(pcVar4);
__s = (char *)*puVar5;
sVar3 = strlen(__s);
__dest = (char *)malloc(sVar2 + 1 + sVar3);
*puVar6 = __dest;
pcVar4 = stpcpy(__dest,pcVar4);
strcpy(pcVar4,__s);
puVar5 = puVar5 + 1;
puVar6 = puVar7;
} while (puVar7 != puVar1 + (ulong)(param_2 - 2) + 1);
}
return puVar1;
} |
4,719 | func0 |
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
| char** func0(char* test_tup[], int size) {
char** res = malloc((size - 1) * sizeof(char*));
for(int i = 0; i < size - 1; i++) {
res[i] = malloc(strlen(test_tup[i]) + strlen(test_tup[i+1]) + 1);
strcpy(res[i], test_tup[i]);
strcat(res[i], test_tup[i+1]);
}
return res;
}
| int main() {
// First test case
char* test1[] = {"DSP ", "IS ", "BEST ", "FOR ", "ALL ", "UTS"};
char* expected1[] = {"DSP IS ", "IS BEST ", "BEST FOR ", "FOR ALL ", "ALL UTS"};
char** result1 = func0(test1, 6);
for(int i = 0; i < 5; i++) {
assert(strcmp(result1[i], expected1[i]) == 0);
free(result1[i]);
}
free(result1);
// Second test case
char* test2[] = {"RES ", "IS ", "BEST ", "FOR ", "ALL ", "QESR"};
char* expected2[] = {"RES IS ", "IS BEST ", "BEST FOR ", "FOR ALL ", "ALL QESR"};
char** result2 = func0(test2, 6);
for(int i = 0; i < 5; i++) {
assert(strcmp(result2[i], expected2[i]) == 0);
free(result2[i]);
}
free(result2);
// Third test case
char* test3[] = {"MSAM", "IS ", "BEST ", "FOR ", "ALL ", "SKD"};
char* expected3[] = {"MSAMIS ", "IS BEST ", "BEST FOR ", "FOR ALL ", "ALL SKD"};
char** result3 = func0(test3, 6);
for(int i = 0; i < 5; i++) {
assert(strcmp(result3[i], expected3[i]) == 0);
free(result3[i]);
}
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %esi,%r12d
push %rbp
lea -0x1(%rsi),%ebp
push %rbx
mov %rdi,%rbx
movslq %ebp,%rdi
shl $0x3,%rdi
sub $0x18,%rsp
callq 1130 <malloc@plt>
mov %rax,0x8(%rsp)
test %ebp,%ebp
jle 1604 <func0+0x94>
mov %rax,%rdx
mov %rax,%rbp
lea -0x2(%r12),%eax
add $0x8,%rbx
lea 0x8(%rdx,%rax,8),%r12
nopl 0x0(%rax)
mov -0x8(%rbx),%r13
add $0x8,%rbp
add $0x8,%rbx
mov %r13,%rdi
callq 10f0 <strlen@plt>
mov -0x8(%rbx),%r15
mov %rax,%r14
mov %r15,%rdi
callq 10f0 <strlen@plt>
lea 0x1(%r14,%rax,1),%rdi
callq 1130 <malloc@plt>
mov %r13,%rsi
mov %rax,-0x8(%rbp)
mov %rax,%rdi
callq 10e0 <stpcpy@plt>
mov %r15,%rsi
mov %rax,%rdi
callq 10d0 <strcpy@plt>
cmp %rbp,%r12
jne 15b8 <func0+0x48>
mov 0x8(%rsp),%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
lea ebx, [rsi-1]
movsxd rdi, ebx
shl rdi, 3; size
sub rsp, 18h
call _malloc
mov [rsp+48h+var_40], rax
test ebx, ebx
jle short loc_167E
mov ebx, ebx
mov r12, rax
add rbp, 8
lea rax, [rax+rbx*8]
mov [rsp+48h+var_48], rax
xchg ax, ax
loc_1620:
mov r13, [rbp-8]
add r12, 8
add rbp, 8
mov rdi, r13; s
call _strlen
mov r14, [rbp-8]
mov rbx, rax
mov rdi, r14; s
call _strlen
lea r15, [rbx+rax+1]
mov rdi, r15; size
call _malloc
mov rdx, r15
mov rsi, r13
mov [r12-8], rax
mov rdi, rax
mov rbx, rax
call ___stpcpy_chk
mov rsi, r14
sub rbx, rax
mov rdi, rax
lea rdx, [rbx+r15]
call ___strcpy_chk
cmp [rsp+48h+var_48], r12
jnz short loc_1620
loc_167E:
mov rax, [rsp+48h+var_40]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | char * func0(long long a1, int a2)
{
char *v2; // rax
char *v3; // r12
long long v4; // rbp
const char *v5; // r13
size_t v6; // rax
const char *v7; // r14
size_t v8; // r15
char *v9; // rax
char *v10; // rbx
long long v11; // rax
char *v13; // [rsp+0h] [rbp-48h]
char *v14; // [rsp+8h] [rbp-40h]
v2 = (char *)malloc(8LL * (a2 - 1));
v14 = v2;
if ( a2 - 1 > 0 )
{
v3 = v2;
v4 = a1 + 8;
v13 = &v2[8 * (a2 - 1)];
do
{
v5 = *(const char **)(v4 - 8);
v3 += 8;
v4 += 8LL;
v6 = strlen(v5);
v7 = *(const char **)(v4 - 8);
v8 = v6 + strlen(v7) + 1;
v9 = (char *)malloc(v8);
*((_QWORD *)v3 - 1) = v9;
v10 = v9;
v11 = __stpcpy_chk(v9, v5, v8);
__strcpy_chk(v11, v7, &v10[v8 - v11]);
}
while ( v13 != v3 );
}
return v14;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
LEA EBX,[RSI + -0x1]
MOVSXD RDI,EBX
SHL RDI,0x3
SUB RSP,0x18
CALL 0x00101120
MOV qword ptr [RSP + 0x8],RAX
TEST EBX,EBX
JLE 0x0010167e
MOV EBX,EBX
MOV R12,RAX
ADD RBP,0x8
LEA RAX,[RAX + RBX*0x8]
MOV qword ptr [RSP],RAX
NOP
LAB_00101620:
MOV R13,qword ptr [RBP + -0x8]
ADD R12,0x8
ADD RBP,0x8
MOV RDI,R13
CALL 0x001010d0
MOV R14,qword ptr [RBP + -0x8]
MOV RBX,RAX
MOV RDI,R14
CALL 0x001010d0
LEA R15,[RBX + RAX*0x1 + 0x1]
MOV RDI,R15
CALL 0x00101120
MOV RDX,R15
MOV RSI,R13
MOV qword ptr [R12 + -0x8],RAX
MOV RDI,RAX
MOV RBX,RAX
CALL 0x00101110
MOV RSI,R14
SUB RBX,RAX
MOV RDI,RAX
LEA RDX,[RBX + R15*0x1]
CALL 0x00101130
CMP qword ptr [RSP],R12
JNZ 0x00101620
LAB_0010167e:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(long param_1,int param_2)
{
char *__s;
char *__s_00;
int8 *puVar1;
size_t sVar2;
size_t sVar3;
void *pvVar4;
long lVar5;
uint uVar6;
int8 *puVar7;
int8 *puVar8;
int8 *puVar9;
uVar6 = param_2 - 1;
puVar1 = (int8 *)malloc((long)(int)uVar6 << 3);
if (0 < (int)uVar6) {
puVar7 = (int8 *)(param_1 + 8);
puVar8 = puVar1;
do {
__s = (char *)puVar7[-1];
puVar9 = puVar8 + 1;
sVar2 = strlen(__s);
__s_00 = (char *)*puVar7;
sVar3 = strlen(__s_00);
sVar3 = sVar2 + 1 + sVar3;
pvVar4 = malloc(sVar3);
*puVar8 = pvVar4;
lVar5 = __stpcpy_chk(pvVar4,__s,sVar3);
__strcpy_chk(lVar5,__s_00,(long)pvVar4 + (sVar3 - lVar5));
puVar7 = puVar7 + 1;
puVar8 = puVar9;
} while (puVar1 + uVar6 != puVar9);
}
return puVar1;
} |
4,720 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char *str) {
int n = strlen(str);
int dp[n+1][n+1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (str[i-1] == str[j-1] && i != j) {
dp[i][j] = 1 + dp[i-1][j-1];
} else {
dp[i][j] = (dp[i][j-1] > dp[i-1][j]) ? dp[i][j-1] : dp[i-1][j];
}
}
}
return dp[n][n];
}
| int main() {
assert(func0("AABEBCDD") == 3);
assert(func0("aabb") == 2);
assert(func0("aab") == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x88,%rsp
mov %rdi,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rbx
mov -0x78(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x54(%rbp)
mov -0x54(%rbp),%eax
lea 0x1(%rax),%esi
mov -0x54(%rbp),%eax
lea 0x1(%rax),%edi
movslq %esi,%rax
sub $0x1,%rax
mov %rax,-0x50(%rbp)
movslq %esi,%rax
mov %rax,-0xb0(%rbp)
movq $0x0,-0xa8(%rbp)
movslq %esi,%rax
lea 0x0(,%rax,4),%rcx
movslq %edi,%rax
sub $0x1,%rax
mov %rax,-0x48(%rbp)
movslq %esi,%rax
mov %rax,-0xa0(%rbp)
movq $0x0,-0x98(%rbp)
movslq %edi,%rax
mov %rax,-0x90(%rbp)
movq $0x0,-0x88(%rbp)
mov -0xa0(%rbp),%r9
mov -0x98(%rbp),%r10
mov %r10,%rdx
imul -0x90(%rbp),%rdx
mov -0x88(%rbp),%rax
imul %r9,%rax
lea (%rdx,%rax,1),%r8
mov %r9,%rax
mulq -0x90(%rbp)
add %rdx,%r8
mov %r8,%rdx
movslq %esi,%rax
mov %rax,%r14
mov $0x0,%r15d
movslq %edi,%rax
mov %rax,%r12
mov $0x0,%r13d
mov %r15,%rdx
imul %r12,%rdx
mov %r13,%rax
imul %r14,%rax
lea (%rdx,%rax,1),%r8
mov %r14,%rax
mul %r12
add %rdx,%r8
mov %r8,%rdx
movslq %esi,%rdx
movslq %edi,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rdi
sub %rdx,%rdi
mov %rdi,%rdx
cmp %rdx,%rsp
je 12fc <func0+0x173>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 12e5 <func0+0x15c>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1326 <func0+0x19d>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x40(%rbp)
movl $0x0,-0x58(%rbp)
jmp 1380 <func0+0x1f7>
movl $0x0,-0x5c(%rbp)
jmp 1374 <func0+0x1eb>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x40(%rbp),%rax
mov -0x5c(%rbp),%edx
movslq %edx,%rsi
mov -0x58(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rdx
movl $0x0,(%rax,%rdx,4)
addl $0x1,-0x5c(%rbp)
mov -0x5c(%rbp),%eax
cmp -0x54(%rbp),%eax
jle 134b <func0+0x1c2>
addl $0x1,-0x58(%rbp)
mov -0x58(%rbp),%eax
cmp -0x54(%rbp),%eax
jle 1342 <func0+0x1b9>
movl $0x1,-0x60(%rbp)
jmpq 14a2 <func0+0x319>
movl $0x1,-0x64(%rbp)
jmpq 1492 <func0+0x309>
mov -0x60(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x64(%rbp),%eax
cltq
lea -0x1(%rax),%rsi
mov -0x78(%rbp),%rax
add %rsi,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 141f <func0+0x296>
mov -0x60(%rbp),%eax
cmp -0x64(%rbp),%eax
je 141f <func0+0x296>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x60(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x64(%rbp),%eax
lea -0x1(%rax),%esi
mov -0x40(%rbp),%rax
movslq %esi,%rsi
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rdx
mov (%rax,%rdx,4),%eax
mov %rcx,%r8
shr $0x2,%r8
lea 0x1(%rax),%esi
mov -0x40(%rbp),%rax
mov -0x64(%rbp),%edx
movslq %edx,%rdi
mov -0x60(%rbp),%edx
movslq %edx,%rdx
imul %r8,%rdx
add %rdi,%rdx
mov %esi,(%rax,%rdx,4)
jmp 148e <func0+0x305>
mov %rcx,%rdi
shr $0x2,%rdi
mov -0x60(%rbp),%eax
lea -0x1(%rax),%r8d
mov -0x40(%rbp),%rax
mov -0x64(%rbp),%edx
movslq %edx,%rsi
movslq %r8d,%rdx
imul %rdi,%rdx
add %rsi,%rdx
mov (%rax,%rdx,4),%edx
mov %rcx,%r8
shr $0x2,%r8
mov -0x64(%rbp),%eax
lea -0x1(%rax),%esi
mov -0x40(%rbp),%rax
movslq %esi,%rdi
mov -0x60(%rbp),%esi
movslq %esi,%rsi
imul %r8,%rsi
add %rdi,%rsi
mov (%rax,%rsi,4),%eax
mov %rcx,%r8
shr $0x2,%r8
cmp %eax,%edx
cmovl %eax,%edx
mov -0x40(%rbp),%rax
mov -0x64(%rbp),%esi
movslq %esi,%rdi
mov -0x60(%rbp),%esi
movslq %esi,%rsi
imul %r8,%rsi
add %rdi,%rsi
mov %edx,(%rax,%rsi,4)
addl $0x1,-0x64(%rbp)
mov -0x64(%rbp),%eax
cmp -0x54(%rbp),%eax
jle 13a0 <func0+0x217>
addl $0x1,-0x60(%rbp)
mov -0x60(%rbp),%eax
cmp -0x54(%rbp),%eax
jle 1394 <func0+0x20b>
shr $0x2,%rcx
mov %rcx,%rdx
mov -0x40(%rbp),%rax
lea 0x1(%rdx),%rcx
mov -0x54(%rbp),%edx
movslq %edx,%rdx
imul %rcx,%rdx
mov (%rax,%rdx,4),%eax
mov %rbx,%rsp
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
je 14e1 <func0+0x358>
callq 1080 <__stack_chk_fail@plt>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov rbx, rax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
lea r8d, [rax+1]
mov eax, [rbp+var_34]
lea r9d, [rax+1]
movsxd rax, r8d
sub rax, 1
mov [rbp+var_30], rax
movsxd rax, r8d
lea rcx, ds:0[rax*4]
movsxd rax, r9d
sub rax, 1
mov [rbp+var_28], rax
movsxd rax, r8d
mov rsi, rax
mov edi, 0
movsxd rax, r9d
mov rax, rax
mov edx, 0
mov r11, rdi
imul r11, rax
mov r10, rdx
imul r10, rsi
add r10, r11
mul rsi
lea rsi, [r10+rdx]
mov rdx, rsi
movsxd rax, r8d
mov rsi, rax
mov edi, 0
movsxd rax, r9d
mov rax, rax
mov edx, 0
mov r11, rdi
imul r11, rax
mov r10, rdx
imul r10, rsi
add r10, r11
mul rsi
lea rsi, [r10+rdx]
mov rdx, rsi
movsxd rdx, r8d
movsxd rax, r9d
imul rax, rdx
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rsi, rax
and rsi, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rsi
loc_128E:
cmp rsp, rdx
jz short loc_12A5
sub rsp, 1000h
or [rsp+1060h+var_68], 0
jmp short loc_128E
loc_12A5:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_12CF
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_12CF:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov [rbp+var_44], 0
jmp short loc_1329
loc_12EB:
mov [rbp+var_40], 0
jmp short loc_131D
loc_12F4:
mov rdi, rcx
shr rdi, 2
mov rax, [rbp+var_20]
mov edx, [rbp+var_40]
movsxd rsi, edx
mov edx, [rbp+var_44]
movsxd rdx, edx
imul rdx, rdi
add rdx, rsi
mov dword ptr [rax+rdx*4], 0
add [rbp+var_40], 1
loc_131D:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_34]
jle short loc_12F4
add [rbp+var_44], 1
loc_1329:
mov eax, [rbp+var_44]
cmp eax, [rbp+var_34]
jle short loc_12EB
mov [rbp+var_3C], 1
jmp loc_144B
loc_133D:
mov [rbp+var_38], 1
jmp loc_143B
loc_1349:
mov eax, [rbp+var_3C]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_38]
cdqe
lea rsi, [rax-1]
mov rax, [rbp+s]
add rax, rsi
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_13C8
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_38]
jz short loc_13C8
mov rdi, rcx
shr rdi, 2
mov eax, [rbp+var_3C]
lea edx, [rax-1]
mov eax, [rbp+var_38]
lea esi, [rax-1]
mov rax, [rbp+var_20]
movsxd rsi, esi
movsxd rdx, edx
imul rdx, rdi
add rdx, rsi
mov eax, [rax+rdx*4]
mov r8, rcx
shr r8, 2
lea esi, [rax+1]
mov rax, [rbp+var_20]
mov edx, [rbp+var_38]
movsxd rdi, edx
mov edx, [rbp+var_3C]
movsxd rdx, edx
imul rdx, r8
add rdx, rdi
mov [rax+rdx*4], esi
jmp short loc_1437
loc_13C8:
mov rdi, rcx
shr rdi, 2
mov eax, [rbp+var_3C]
lea r8d, [rax-1]
mov rax, [rbp+var_20]
mov edx, [rbp+var_38]
movsxd rsi, edx
movsxd rdx, r8d
imul rdx, rdi
add rdx, rsi
mov edx, [rax+rdx*4]
mov r8, rcx
shr r8, 2
mov eax, [rbp+var_38]
lea esi, [rax-1]
mov rax, [rbp+var_20]
movsxd rdi, esi
mov esi, [rbp+var_3C]
movsxd rsi, esi
imul rsi, r8
add rsi, rdi
mov eax, [rax+rsi*4]
mov r8, rcx
shr r8, 2
cmp edx, eax
cmovl edx, eax
mov rax, [rbp+var_20]
mov esi, [rbp+var_38]
movsxd rdi, esi
mov esi, [rbp+var_3C]
movsxd rsi, esi
imul rsi, r8
add rsi, rdi
mov [rax+rsi*4], edx
loc_1437:
add [rbp+var_38], 1
loc_143B:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_34]
jle loc_1349
add [rbp+var_3C], 1
loc_144B:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_34]
jle loc_133D
shr rcx, 2
mov rdx, rcx
mov rax, [rbp+var_20]
lea rcx, [rdx+1]
mov edx, [rbp+var_34]
movsxd rdx, edx
imul rdx, rcx
mov eax, [rax+rdx*4]
mov rsp, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_148A
call ___stack_chk_fail
loc_148A:
mov rbx, [rbp+var_8]
leave
retn | long long func0(char *a1)
{
unsigned long long v1; // rcx
unsigned long long v2; // rax
void *v3; // rsp
int v4; // edx
_BYTE v6[8]; // [rsp+8h] [rbp-60h] BYREF
char *s; // [rsp+10h] [rbp-58h]
int i; // [rsp+24h] [rbp-44h]
int j; // [rsp+28h] [rbp-40h]
int k; // [rsp+2Ch] [rbp-3Ch]
int m; // [rsp+30h] [rbp-38h]
int v12; // [rsp+34h] [rbp-34h]
long long v13; // [rsp+38h] [rbp-30h]
long long v14; // [rsp+40h] [rbp-28h]
_BYTE *v15; // [rsp+48h] [rbp-20h]
unsigned long long v16; // [rsp+50h] [rbp-18h]
s = a1;
v16 = __readfsqword(0x28u);
v12 = strlen(a1);
v13 = v12 + 1 - 1LL;
v1 = 4LL * (v12 + 1);
v14 = v13;
v2 = 16 * ((4 * (v12 + 1) * (long long)(v12 + 1) + 15) / 0x10uLL);
while ( v6 != &v6[-(v2 & 0xFFFFFFFFFFFFF000LL)] )
;
v3 = alloca(v2 & 0xFFF);
if ( (v2 & 0xFFF) != 0 )
*(_QWORD *)&v6[(v2 & 0xFFF) - 8] = *(_QWORD *)&v6[(v2 & 0xFFF) - 8];
v15 = v6;
for ( i = 0; i <= v12; ++i )
{
for ( j = 0; j <= v12; ++j )
*(_DWORD *)&v15[4 * j + 4 * (v1 >> 2) * i] = 0;
}
for ( k = 1; k <= v12; ++k )
{
for ( m = 1; m <= v12; ++m )
{
if ( s[k - 1] != s[m - 1] || k == m )
{
v4 = *(_DWORD *)&v15[4 * m + 4 * (v1 >> 2) * (k - 1)];
if ( v4 < *(_DWORD *)&v15[4 * m - 4 + 4 * (v1 >> 2) * k] )
v4 = *(_DWORD *)&v15[4 * m - 4 + 4 * (v1 >> 2) * k];
*(_DWORD *)&v15[4 * m + 4 * (v1 >> 2) * k] = v4;
}
else
{
*(_DWORD *)&v15[4 * m + 4 * (v1 >> 2) * k] = *(_DWORD *)&v15[4 * m - 4 + 4 * (v1 >> 2) * (k - 1)] + 1;
}
}
}
return *(unsigned int *)&v15[4 * ((v1 >> 2) + 1) * v12];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
LEA R8D,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x34]
LEA R9D,[RAX + 0x1]
MOVSXD RAX,R8D
SUB RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOVSXD RAX,R8D
LEA RCX,[RAX*0x4]
MOVSXD RAX,R9D
SUB RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOVSXD RAX,R8D
MOV RSI,RAX
MOV EDI,0x0
MOVSXD RAX,R9D
MOV RAX,RAX
MOV EDX,0x0
MOV R11,RDI
IMUL R11,RAX
MOV R10,RDX
IMUL R10,RSI
ADD R10,R11
MUL RSI
LEA RSI,[R10 + RDX*0x1]
MOV RDX,RSI
MOVSXD RAX,R8D
MOV RSI,RAX
MOV EDI,0x0
MOVSXD RAX,R9D
MOV RAX,RAX
MOV EDX,0x0
MOV R11,RDI
IMUL R11,RAX
MOV R10,RDX
IMUL R10,RSI
ADD R10,R11
MUL RSI
LEA RSI,[R10 + RDX*0x1]
MOV RDX,RSI
MOVSXD RDX,R8D
MOVSXD RAX,R9D
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RSI,RAX
AND RSI,-0x1000
MOV RDX,RSP
SUB RDX,RSI
LAB_0010128e:
CMP RSP,RDX
JZ 0x001012a5
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x0010128e
LAB_001012a5:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x001012cf
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_001012cf:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x44],0x0
JMP 0x00101329
LAB_001012eb:
MOV dword ptr [RBP + -0x40],0x0
JMP 0x0010131d
LAB_001012f4:
MOV RDI,RCX
SHR RDI,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x40]
MOVSXD RSI,EDX
MOV EDX,dword ptr [RBP + -0x44]
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RDX,RSI
MOV dword ptr [RAX + RDX*0x4],0x0
ADD dword ptr [RBP + -0x40],0x1
LAB_0010131d:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x001012f4
ADD dword ptr [RBP + -0x44],0x1
LAB_00101329:
MOV EAX,dword ptr [RBP + -0x44]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x001012eb
MOV dword ptr [RBP + -0x3c],0x1
JMP 0x0010144b
LAB_0010133d:
MOV dword ptr [RBP + -0x38],0x1
JMP 0x0010143b
LAB_00101349:
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x38]
CDQE
LEA RSI,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RSI
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x001013c8
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x38]
JZ 0x001013c8
MOV RDI,RCX
SHR RDI,0x2
MOV EAX,dword ptr [RBP + -0x3c]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x38]
LEA ESI,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RSI,ESI
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RDX,RSI
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV R8,RCX
SHR R8,0x2
LEA ESI,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDI,EDX
MOV EDX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EDX
IMUL RDX,R8
ADD RDX,RDI
MOV dword ptr [RAX + RDX*0x4],ESI
JMP 0x00101437
LAB_001013c8:
MOV RDI,RCX
SHR RDI,0x2
MOV EAX,dword ptr [RBP + -0x3c]
LEA R8D,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RSI,EDX
MOVSXD RDX,R8D
IMUL RDX,RDI
ADD RDX,RSI
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV R8,RCX
SHR R8,0x2
MOV EAX,dword ptr [RBP + -0x38]
LEA ESI,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RDI,ESI
MOV ESI,dword ptr [RBP + -0x3c]
MOVSXD RSI,ESI
IMUL RSI,R8
ADD RSI,RDI
MOV EAX,dword ptr [RAX + RSI*0x4]
MOV R8,RCX
SHR R8,0x2
CMP EDX,EAX
CMOVL EDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x38]
MOVSXD RDI,ESI
MOV ESI,dword ptr [RBP + -0x3c]
MOVSXD RSI,ESI
IMUL RSI,R8
ADD RSI,RDI
MOV dword ptr [RAX + RSI*0x4],EDX
LAB_00101437:
ADD dword ptr [RBP + -0x38],0x1
LAB_0010143b:
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x00101349
ADD dword ptr [RBP + -0x3c],0x1
LAB_0010144b:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x0010133d
SHR RCX,0x2
MOV RDX,RCX
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[RDX + 0x1]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RDX,EDX
IMUL RDX,RCX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010148a
CALL 0x00101080
LAB_0010148a:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int4 func0(char *param_1)
{
int iVar1;
long lVar2;
size_t sVar3;
ulong uVar4;
ulong uVar5;
int *puVar6;
long in_FS_OFFSET;
int auStack_68 [8];
char *local_60;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
long local_38;
long local_30;
int *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = param_1;
sVar3 = strlen(param_1);
local_3c = (int)sVar3;
iVar1 = local_3c + 1;
local_38 = (long)iVar1 + -1;
uVar4 = (ulong)iVar1;
local_30 = (long)(local_3c + 1) + -1;
uVar5 = (((long)(local_3c + 1) * (long)iVar1 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar6 = auStack_68; puVar6 != auStack_68 + -(uVar5 & 0xfffffffffffff000);
puVar6 = puVar6 + -0x1000) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
lVar2 = -(ulong)((uint)uVar5 & 0xfff);
if ((uVar5 & 0xfff) != 0) {
*(int8 *)(puVar6 + ((ulong)((uint)uVar5 & 0xfff) - 8) + lVar2) =
*(int8 *)(puVar6 + ((ulong)((uint)uVar5 & 0xfff) - 8) + lVar2);
}
for (local_4c = 0; local_4c <= local_3c; local_4c = local_4c + 1) {
for (local_48 = 0; local_48 <= local_3c; local_48 = local_48 + 1) {
*(int4 *)
(puVar6 + ((long)local_4c * (uVar4 & 0x3fffffffffffffff) + (long)local_48) * 4 + lVar2) = 0;
}
}
for (local_44 = 1; local_44 <= local_3c; local_44 = local_44 + 1) {
for (local_40 = 1; local_40 <= local_3c; local_40 = local_40 + 1) {
if ((local_60[(long)local_44 + -1] == local_60[(long)local_40 + -1]) && (local_44 != local_40)
) {
*(int *)(puVar6 + ((long)local_44 * (uVar4 & 0x3fffffffffffffff) + (long)local_40) * 4 +
lVar2) =
*(int *)(puVar6 + ((long)(local_44 + -1) * (uVar4 & 0x3fffffffffffffff) +
(long)(local_40 + -1)) * 4 + lVar2) + 1;
}
else {
iVar1 = *(int *)(puVar6 + ((long)(local_44 + -1) * (uVar4 & 0x3fffffffffffffff) +
(long)local_40) * 4 + lVar2);
if (*(int *)(puVar6 + ((long)(local_44 + -1) * (uVar4 & 0x3fffffffffffffff) + (long)local_40
) * 4 + lVar2) <
*(int *)(puVar6 + ((long)local_44 * (uVar4 & 0x3fffffffffffffff) + (long)(local_40 + -1)
) * 4 + lVar2)) {
iVar1 = *(int *)(puVar6 + ((long)local_44 * (uVar4 & 0x3fffffffffffffff) +
(long)(local_40 + -1)) * 4 + lVar2);
}
*(int *)(puVar6 + ((long)local_44 * (uVar4 & 0x3fffffffffffffff) + (long)local_40) * 4 +
lVar2) = iVar1;
}
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
local_28 = puVar6 + lVar2;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)(puVar6 + (long)local_3c * ((uVar4 & 0x3fffffffffffffff) + 1) * 4 + lVar2);
} |
4,721 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char *str) {
int n = strlen(str);
int dp[n+1][n+1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (str[i-1] == str[j-1] && i != j) {
dp[i][j] = 1 + dp[i-1][j-1];
} else {
dp[i][j] = (dp[i][j-1] > dp[i-1][j]) ? dp[i][j-1] : dp[i-1][j];
}
}
}
return dp[n][n];
}
| int main() {
assert(func0("AABEBCDD") == 3);
assert(func0("aabb") == 2);
assert(func0("aab") == 1);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r14
push %r13
push %r12
push %rbx
sub $0x10,%rsp
mov %rdi,%r8
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbx
movslq %ecx,%rax
lea 0x0(,%rax,4),%r11
imul %rax,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rdi
sub %rax,%rdi
mov %rdi,%rax
cmp %rax,%rsp
je 11e2 <func0+0x79>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11cb <func0+0x62>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11f8 <func0+0x8f>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%r12
test %ebx,%ebx
js 1236 <func0+0xcd>
mov %ebx,%esi
lea 0x4(%r12,%rsi,4),%rdx
lea 0x1(%rbx),%edi
mov $0x0,%ecx
not %rsi
shl $0x2,%rsi
jmp 1221 <func0+0xb8>
add $0x1,%ecx
add %r11,%rdx
cmp %edi,%ecx
je 1236 <func0+0xcd>
lea (%rsi,%rdx,1),%rax
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1225 <func0+0xbc>
jmp 1217 <func0+0xae>
test %ebx,%ebx
jle 12aa <func0+0x141>
mov %r12,%r14
lea (%r12,%r11,1),%r13
lea -0x1(%rbx),%edi
add $0x2,%rdi
mov %r13,%rsi
mov %r12,%rcx
mov $0x1,%r9d
jmp 129d <func0+0x134>
mov -0x4(%rsi,%rax,4),%edx
cmp %edx,(%rcx,%rax,4)
cmovge (%rcx,%rax,4),%edx
mov %edx,(%rsi,%rax,4)
add $0x1,%rax
cmp %rdi,%rax
je 1288 <func0+0x11f>
cmp %r10b,-0x1(%r8,%rax,1)
jne 1256 <func0+0xed>
cmp %r9d,%eax
je 1256 <func0+0xed>
mov -0x4(%r14,%rax,4),%edx
add $0x1,%edx
mov %edx,0x0(%r13,%rax,4)
jmp 1264 <func0+0xfb>
add $0x1,%r9
add %r11,%r14
add %r11,%r13
add %r11,%rcx
add %r11,%rsi
cmp %rdi,%r9
je 12aa <func0+0x141>
movzbl -0x1(%r8,%r9,1),%r10d
mov $0x1,%eax
jmp 126d <func0+0x104>
shr $0x2,%r11
lea 0x1(%r11),%rax
movslq %ebx,%rbx
imul %rax,%rbx
mov (%r12,%rbx,4),%eax
mov -0x28(%rbp),%rbx
xor %fs:0x28,%rbx
jne 12d9 <func0+0x170>
lea -0x20(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %rbp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
call _strlen
mov r12, rax
lea eax, [rax+1]
cdqe
lea r10, ds:0[rax*4]
imul rax, rax
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11E4:
cmp rsp, rdx
jz short loc_11FB
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11E4
loc_11FB:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_1211
or [rsp+rax+40h+var_48], 0
loc_1211:
mov r13, rsp
test r12d, r12d
js short loc_124F
mov esi, r12d
lea rdx, [r13+rsi*4+4]
lea edi, [r12+1]
mov ecx, 0
not rsi
shl rsi, 2
loc_1232:
lea rax, [rsi+rdx]
loc_1236:
mov dword ptr [rax], 0
add rax, 4
cmp rax, rdx
jnz short loc_1236
add ecx, 1
add rdx, r10
cmp ecx, edi
jnz short loc_1232
loc_124F:
test r12d, r12d
jle short loc_12C9
mov r14, r13
lea r11, [r13+r10+0]
lea esi, [r12-1]
add rsi, 2
mov rcx, r11
mov r9, r13
mov edi, 1
jmp short loc_12BC
loc_1272:
mov edx, [r9+rax*4]
mov r15d, [rcx+rax*4-4]
cmp edx, r15d
cmovl edx, r15d
mov [rcx+rax*4], edx
loc_1285:
add rax, 1
cmp rax, rsi
jz short loc_12A7
loc_128E:
cmp [rbx+rax-1], r8b
jnz short loc_1272
cmp eax, edi
jz short loc_1272
mov edx, [r14+rax*4-4]
add edx, 1
mov [r11+rax*4], edx
jmp short loc_1285
loc_12A7:
add rdi, 1
add r14, r10
add r11, r10
add r9, r10
add rcx, r10
cmp rdi, rsi
jz short loc_12C9
loc_12BC:
movzx r8d, byte ptr [rbx+rdi-1]
mov eax, 1
jmp short loc_128E
loc_12C9:
shr r10, 2
lea rax, [r10+1]
movsxd r12, r12d
imul rax, r12
mov eax, [r13+rax*4+0]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_12FB
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_12FB:
call ___stack_chk_fail | long long func0(long long a1)
{
int v2; // r12d
long long v3; // rax
unsigned long long v4; // r10
long long v5; // rax
__int16 v6; // cx
signed long long v7; // rax
void *v8; // rsp
_BYTE *v9; // rdx
int v10; // ecx
_DWORD *v11; // rax
_BYTE *v12; // r14
_BYTE *v13; // r11
long long v14; // rsi
_BYTE *v15; // rcx
_BYTE *v16; // r9
long long v17; // rdi
int v18; // edx
long long v19; // rax
char v20; // r8
_BYTE v23[8]; // [rsp+8h] [rbp-40h] BYREF
unsigned long long v24; // [rsp+10h] [rbp-38h]
v24 = __readfsqword(0x28u);
v2 = strlen();
v3 = v2 + 1;
v4 = 4 * v3;
v5 = 4 * v3 * v3 + 15;
v6 = v5 & 0xFFF0;
while ( v23 != &v23[-(v5 & 0xFFFFFFFFFFFFF000LL)] )
;
v7 = v5 & 0xFF0;
v8 = alloca(v7);
if ( (v6 & 0xFFF) != 0 )
*(_QWORD *)&v23[v7 - 8] = *(_QWORD *)&v23[v7 - 8];
if ( v2 >= 0 )
{
v9 = &v23[4 * v2 + 4];
v10 = 0;
do
{
v11 = &v9[4 * ~(unsigned long long)(unsigned int)v2];
do
*v11++ = 0;
while ( v11 != (_DWORD *)v9 );
++v10;
v9 += v4;
}
while ( v10 != v2 + 1 );
}
if ( v2 > 0 )
{
v12 = v23;
v13 = &v23[v4];
v14 = (unsigned int)(v2 - 1) + 2LL;
v15 = &v23[v4];
v16 = v23;
v17 = 1LL;
do
{
v20 = *(_BYTE *)(a1 + v17 - 1);
v19 = 1LL;
do
{
if ( *(_BYTE *)(a1 + v19 - 1) != v20 || (_DWORD)v19 == (_DWORD)v17 )
{
v18 = *(_DWORD *)&v16[4 * v19];
if ( v18 < *(_DWORD *)&v15[4 * v19 - 4] )
v18 = *(_DWORD *)&v15[4 * v19 - 4];
*(_DWORD *)&v15[4 * v19] = v18;
}
else
{
*(_DWORD *)&v13[4 * v19] = *(_DWORD *)&v12[4 * v19 - 4] + 1;
}
++v19;
}
while ( v19 != v14 );
++v17;
v12 += v4;
v13 += v4;
v16 += v4;
v15 += v4;
}
while ( v17 != v14 );
}
return *(unsigned int *)&v23[4 * v2 * ((v4 >> 2) + 1)];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
CALL 0x00101070
MOV R12,RAX
LEA EAX,[RAX + 0x1]
CDQE
LEA R10,[RAX*0x4]
IMUL RAX,RAX
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011e4:
CMP RSP,RDX
JZ 0x001011fb
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011e4
LAB_001011fb:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x00101211
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_00101211:
MOV R13,RSP
TEST R12D,R12D
JS 0x0010124f
MOV ESI,R12D
LEA RDX,[R13 + RSI*0x4 + 0x4]
LEA EDI,[R12 + 0x1]
MOV ECX,0x0
NOT RSI
SHL RSI,0x2
LAB_00101232:
LEA RAX,[RSI + RDX*0x1]
LAB_00101236:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101236
ADD ECX,0x1
ADD RDX,R10
CMP ECX,EDI
JNZ 0x00101232
LAB_0010124f:
TEST R12D,R12D
JLE 0x001012c9
MOV R14,R13
LEA R11,[R13 + R10*0x1]
LEA ESI,[R12 + -0x1]
ADD RSI,0x2
MOV RCX,R11
MOV R9,R13
MOV EDI,0x1
JMP 0x001012bc
LAB_00101272:
MOV EDX,dword ptr [R9 + RAX*0x4]
MOV R15D,dword ptr [RCX + RAX*0x4 + -0x4]
CMP EDX,R15D
CMOVL EDX,R15D
MOV dword ptr [RCX + RAX*0x4],EDX
LAB_00101285:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x001012a7
LAB_0010128e:
CMP byte ptr [RBX + RAX*0x1 + -0x1],R8B
JNZ 0x00101272
CMP EAX,EDI
JZ 0x00101272
MOV EDX,dword ptr [R14 + RAX*0x4 + -0x4]
ADD EDX,0x1
MOV dword ptr [R11 + RAX*0x4],EDX
JMP 0x00101285
LAB_001012a7:
ADD RDI,0x1
ADD R14,R10
ADD R11,R10
ADD R9,R10
ADD RCX,R10
CMP RDI,RSI
JZ 0x001012c9
LAB_001012bc:
MOVZX R8D,byte ptr [RBX + RDI*0x1 + -0x1]
MOV EAX,0x1
JMP 0x0010128e
LAB_001012c9:
SHR R10,0x2
LEA RAX,[R10 + 0x1]
MOVSXD R12,R12D
IMUL RAX,R12
MOV EAX,dword ptr [R13 + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012fb
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001012fb:
CALL 0x00101080 | int4 func0(char *param_1)
{
long lVar1;
char cVar2;
int iVar3;
long lVar4;
size_t sVar5;
ulong uVar6;
ulong uVar7;
int4 *puVar8;
long lVar9;
int iVar10;
int1 *puVar11;
int4 *puVar12;
int1 *puVar13;
long lVar14;
long lVar15;
int1 *puVar16;
int1 *puVar17;
int1 *puVar18;
long in_FS_OFFSET;
int1 auStack_48 [8];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar5 = strlen(param_1);
iVar3 = (int)sVar5;
uVar6 = (ulong)(iVar3 + 1);
lVar1 = uVar6 * 4;
uVar7 = uVar6 * uVar6 * 4 + 0xf;
for (puVar13 = auStack_48; puVar13 != auStack_48 + -(uVar7 & 0xfffffffffffff000);
puVar13 = puVar13 + -0x1000) {
*(int8 *)(puVar13 + -8) = *(int8 *)(puVar13 + -8);
}
uVar7 = (ulong)((uint)uVar7 & 0xff0);
lVar4 = -uVar7;
puVar16 = puVar13 + lVar4;
puVar18 = puVar13 + lVar4;
if (uVar7 != 0) {
*(int8 *)(puVar13 + -8) = *(int8 *)(puVar13 + -8);
}
if (-1 < iVar3) {
puVar12 = (int4 *)(puVar13 + (sVar5 & 0xffffffff) * 4 + lVar4 + 4);
iVar10 = 0;
do {
puVar8 = puVar12 + ~(sVar5 & 0xffffffff);
do {
*puVar8 = 0;
puVar8 = puVar8 + 1;
} while (puVar8 != puVar12);
iVar10 = iVar10 + 1;
puVar12 = puVar12 + uVar6;
} while (iVar10 != iVar3 + 1);
}
if (0 < iVar3) {
puVar11 = puVar13 + lVar1 + lVar4;
lVar14 = (ulong)(iVar3 - 1) + 2;
lVar15 = 1;
puVar17 = puVar11;
do {
cVar2 = param_1[lVar15 + -1];
lVar9 = 1;
do {
if ((param_1[lVar9 + -1] == cVar2) && ((int)lVar9 != (int)lVar15)) {
*(int *)(puVar17 + lVar9 * 4) = *(int *)(puVar18 + lVar9 * 4 + -4) + 1;
}
else {
iVar10 = *(int *)(puVar16 + lVar9 * 4);
if (*(int *)(puVar16 + lVar9 * 4) < *(int *)(puVar11 + lVar9 * 4 + -4)) {
iVar10 = *(int *)(puVar11 + lVar9 * 4 + -4);
}
*(int *)(puVar11 + lVar9 * 4) = iVar10;
}
lVar9 = lVar9 + 1;
} while (lVar9 != lVar14);
lVar15 = lVar15 + 1;
puVar18 = puVar18 + lVar1;
puVar17 = puVar17 + lVar1;
puVar16 = puVar16 + lVar1;
puVar11 = puVar11 + lVar1;
} while (lVar15 != lVar14);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar13 + ((uVar6 & 0x3fffffffffffffff) + 1) * (long)iVar3 * 4 + lVar4);
}
/* WARNING: Subroutine does not return */
*(code **)(puVar13 + lVar4 + -8) = main;
__stack_chk_fail();
} |
4,722 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char *str) {
int n = strlen(str);
int dp[n+1][n+1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (str[i-1] == str[j-1] && i != j) {
dp[i][j] = 1 + dp[i-1][j-1];
} else {
dp[i][j] = (dp[i][j-1] > dp[i-1][j]) ? dp[i][j-1] : dp[i-1][j];
}
}
}
return dp[n][n];
}
| int main() {
assert(func0("AABEBCDD") == 3);
assert(func0("aabb") == 2);
assert(func0("aab") == 1);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r14
push %r13
push %r12
push %rbx
mov %rdi,%rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
callq 1070 <strlen@plt>
mov %rsp,%rdi
lea 0x1(%rax),%r8d
movslq %r8d,%rdx
lea 0x0(,%rdx,4),%r10
imul %rdx,%rdx
lea 0xf(,%rdx,4),%rdx
mov %rdx,%rcx
and $0xfffffffffffff000,%rdx
sub %rdx,%rdi
and $0xfffffffffffffff0,%rcx
mov %rdi,%rdx
cmp %rdx,%rsp
je 12a6 <func0+0x76>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rdx,%rsp
jne 1291 <func0+0x61>
and $0xfff,%ecx
sub %rcx,%rsp
test %rcx,%rcx
jne 13ae <func0+0x17e>
mov %r10,%r11
mov %rsp,%r12
shr $0x2,%r11
test %eax,%eax
js 1384 <func0+0x154>
mov %eax,%edi
xor %esi,%esi
lea 0x4(%r12,%rdi,4),%rcx
not %rdi
shl $0x2,%rdi
nopw 0x0(%rax,%rax,1)
lea (%rdi,%rcx,1),%rdx
nopl 0x0(%rax)
movl $0x0,(%rdx)
add $0x4,%rdx
cmp %rcx,%rdx
jne 12e8 <func0+0xb8>
add $0x1,%esi
lea (%rdx,%r10,1),%rcx
cmp %r8d,%esi
jne 12e0 <func0+0xb0>
test %eax,%eax
jle 1384 <func0+0x154>
lea -0x1(%rax),%edi
mov %r12,%r8
lea 0x4(%r10),%r14
mov $0x1,%r9d
add $0x2,%rdi
nopl 0x0(%rax,%rax,1)
movzbl -0x1(%rbx,%r9,1),%r13d
lea (%r14,%r8,1),%rcx
mov $0x1,%edx
jmp 1354 <func0+0x124>
nopl 0x0(%rax)
mov -0x4(%rcx),%esi
cmp %esi,(%r8,%rdx,4)
cmovge (%r8,%rdx,4),%esi
add $0x1,%rdx
add $0x4,%rcx
mov %esi,-0x4(%rcx)
cmp %rdx,%rdi
je 1378 <func0+0x148>
cmp %r13b,-0x1(%rbx,%rdx,1)
jne 1338 <func0+0x108>
cmp %r9d,%edx
je 1338 <func0+0x108>
mov -0x4(%r8,%rdx,4),%esi
add $0x1,%rdx
add $0x4,%rcx
add $0x1,%esi
mov %esi,-0x4(%rcx)
cmp %rdx,%rdi
jne 1354 <func0+0x124>
add $0x1,%r9
add %r10,%r8
cmp %r9,%rdi
jne 1320 <func0+0xf0>
add $0x1,%r11
cltq
imul %r11,%rax
mov -0x28(%rbp),%rbx
xor %fs:0x28,%rbx
mov (%r12,%rax,4),%eax
jne 13b9 <func0+0x189>
lea -0x20(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rcx,1)
jmpq 12b8 <func0+0x88>
callq 1080 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
mov r13, rdi
push r12
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
call _strlen
mov rsi, rsp
lea r14d, [rax+1]
mov [rbp+var_48], rax
movsxd rax, r14d
lea r12, ds:0[rax*4]
imul rax, rax
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rsi, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rsi
jz short loc_12C8
loc_12B3:
sub rsp, 1000h
or [rsp+1060h+var_68], 0
cmp rsp, rsi
jnz short loc_12B3
loc_12C8:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_13CE
loc_12DA:
mov rbx, [rbp+var_48]
mov rdi, rsp
mov [rbp+var_50], rdi
test ebx, ebx
js loc_13D9
mov rax, r12
shr rax, 2
mov [rbp+var_58], rax
mov eax, ebx
xor ebx, ebx
lea r15, ds:4[rax*4]
nop dword ptr [rax+00h]
loc_1308:
mov rdx, r15
xor esi, esi
add ebx, 1
call _memset
mov rdi, rax
add rdi, r12
cmp ebx, r14d
jnz short loc_1308
mov rax, [rbp+var_48]
test eax, eax
jz short loc_1398
mov r9, [rbp+var_50]
lea r10d, [rax-1]
mov r11d, 1
add r10, 2
lea rdi, [r9+r12]
xchg ax, ax
loc_1340:
movzx r14d, byte ptr [r13+r11-1]
mov eax, 1
jmp short loc_1369
loc_1350:
mov edx, [r9+rax*4]
mov esi, [rdi+rax*4-4]
cmp edx, esi
cmovl edx, esi
mov [rdi+rax*4], edx
add rax, 1
cmp rax, r10
jz short loc_1389
loc_1369:
cmp [r13+rax-1], r14b
jnz short loc_1350
cmp eax, r11d
jz short loc_1350
mov ecx, [r9+rax*4-4]
lea edx, [rcx+1]
mov [rdi+rax*4], edx
add rax, 1
cmp rax, r10
jnz short loc_1369
loc_1389:
add r11, 1
add rdi, r12
add r9, r12
cmp r11, r10
jnz short loc_1340
loc_1398:
mov r12, [rbp+var_58]
movsxd rbx, dword ptr [rbp+var_48]
mov rax, [rbp+var_50]
add r12, 1
imul r12, rbx
mov eax, [rax+r12*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_13E3
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_13CE:
or [rsp+rdx+1060h+var_1068], 0
jmp loc_12DA
loc_13D9:
shr r12, 2
mov [rbp+var_58], r12
jmp short loc_1398
loc_13E3:
call ___stack_chk_fail | long long func0(long long a1)
{
long long v2; // rax
int v3; // r14d
unsigned long long v4; // r12
long long v5; // rdx
long long *v6; // rsi
__int16 v7; // dx
signed long long v8; // rdx
void *v9; // rsp
_BYTE *v10; // rdi
int v11; // ebx
long long v12; // r15
_BYTE *v13; // r9
long long v14; // r11
long long v15; // r10
_BYTE *v16; // rdi
char v17; // r14
long long v18; // rax
int v19; // edx
_BYTE v22[4088]; // [rsp+8h] [rbp-1060h] BYREF
long long v23; // [rsp+1008h] [rbp-60h] BYREF
unsigned long long v24; // [rsp+1010h] [rbp-58h]
_BYTE *v25; // [rsp+1018h] [rbp-50h]
long long v26; // [rsp+1020h] [rbp-48h]
unsigned long long v27; // [rsp+1030h] [rbp-38h]
v27 = __readfsqword(0x28u);
v2 = strlen();
v3 = v2 + 1;
v26 = v2;
v4 = 4LL * ((int)v2 + 1);
v5 = 4 * v3 * (long long)v3 + 15;
v6 = (long long *)((char *)&v23 - (v5 & 0xFFFFFFFFFFFFF000LL));
v7 = v5 & 0xFFF0;
if ( &v23 != v6 )
{
while ( v22 != (_BYTE *)v6 )
;
}
v8 = v7 & 0xFFF;
v9 = alloca(v8);
if ( v8 )
*(_QWORD *)&v22[v8 - 8] = *(_QWORD *)&v22[v8 - 8];
v10 = v22;
v25 = v22;
if ( (int)v26 < 0 )
{
v24 = v4 >> 2;
}
else
{
v24 = v4 >> 2;
v11 = 0;
v12 = 4LL * (unsigned int)v26 + 4;
do
{
++v11;
v10 = (_BYTE *)(v4 + memset(v10, 0LL, v12));
}
while ( v11 != v3 );
if ( (_DWORD)v26 )
{
v13 = v25;
v14 = 1LL;
v15 = (unsigned int)(v26 - 1) + 2LL;
v16 = &v25[v4];
do
{
v17 = *(_BYTE *)(a1 + v14 - 1);
v18 = 1LL;
do
{
while ( *(_BYTE *)(a1 + v18 - 1) == v17 && (_DWORD)v18 != (_DWORD)v14 )
{
*(_DWORD *)&v16[4 * v18] = *(_DWORD *)&v13[4 * v18 - 4] + 1;
if ( ++v18 == v15 )
goto LABEL_17;
}
v19 = *(_DWORD *)&v13[4 * v18];
if ( v19 < *(_DWORD *)&v16[4 * v18 - 4] )
v19 = *(_DWORD *)&v16[4 * v18 - 4];
*(_DWORD *)&v16[4 * v18++] = v19;
}
while ( v18 != v15 );
LABEL_17:
++v14;
v16 += v4;
v13 += v4;
}
while ( v14 != v15 );
}
}
return *(unsigned int *)&v25[4 * (int)v26 * (v24 + 1)];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
CALL 0x00101080
MOV RSI,RSP
LEA R14D,[RAX + 0x1]
MOV qword ptr [RBP + -0x48],RAX
MOVSXD RAX,R14D
LEA R12,[RAX*0x4]
IMUL RAX,RAX
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RSI,RAX
AND RDX,-0x10
CMP RSP,RSI
JZ 0x001012c8
LAB_001012b3:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x001012b3
LAB_001012c8:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001013ce
LAB_001012da:
MOV RBX,qword ptr [RBP + -0x48]
MOV RDI,RSP
MOV qword ptr [RBP + -0x50],RDI
TEST EBX,EBX
JS 0x001013d9
MOV RAX,R12
SHR RAX,0x2
MOV qword ptr [RBP + -0x58],RAX
MOV EAX,EBX
XOR EBX,EBX
LEA R15,[0x4 + RAX*0x4]
NOP dword ptr [RAX]
LAB_00101308:
MOV RDX,R15
XOR ESI,ESI
ADD EBX,0x1
CALL 0x001010b0
MOV RDI,RAX
ADD RDI,R12
CMP EBX,R14D
JNZ 0x00101308
MOV RAX,qword ptr [RBP + -0x48]
TEST EAX,EAX
JZ 0x00101398
MOV R9,qword ptr [RBP + -0x50]
LEA R10D,[RAX + -0x1]
MOV R11D,0x1
ADD R10,0x2
LEA RDI,[R9 + R12*0x1]
NOP
LAB_00101340:
MOVZX R14D,byte ptr [R13 + R11*0x1 + -0x1]
MOV EAX,0x1
JMP 0x00101369
LAB_00101350:
MOV EDX,dword ptr [R9 + RAX*0x4]
MOV ESI,dword ptr [RDI + RAX*0x4 + -0x4]
CMP EDX,ESI
CMOVL EDX,ESI
MOV dword ptr [RDI + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,R10
JZ 0x00101389
LAB_00101369:
CMP byte ptr [R13 + RAX*0x1 + -0x1],R14B
JNZ 0x00101350
CMP EAX,R11D
JZ 0x00101350
MOV ECX,dword ptr [R9 + RAX*0x4 + -0x4]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RDI + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,R10
JNZ 0x00101369
LAB_00101389:
ADD R11,0x1
ADD RDI,R12
ADD R9,R12
CMP R11,R10
JNZ 0x00101340
LAB_00101398:
MOV R12,qword ptr [RBP + -0x58]
MOVSXD RBX,dword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x50]
ADD R12,0x1
IMUL R12,RBX
MOV EAX,dword ptr [RAX + R12*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013e3
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001013ce:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012da
LAB_001013d9:
SHR R12,0x2
MOV qword ptr [RBP + -0x58],R12
JMP 0x00101398
LAB_001013e3:
CALL 0x00101090 | int4 func0(char *param_1)
{
long lVar1;
char cVar2;
long lVar3;
ulong uVar4;
void *pvVar5;
long lVar6;
int iVar7;
int1 *puVar8;
int1 *puVar10;
int1 *puVar11;
long lVar12;
long lVar13;
int iVar14;
long in_FS_OFFSET;
int1 auStack_68 [8];
ulong local_60;
int1 *local_58;
size_t local_50;
long local_40;
int1 *puVar9;
puVar8 = auStack_68;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_50 = strlen(param_1);
iVar14 = (int)local_50 + 1;
local_60 = (ulong)iVar14;
lVar1 = local_60 * 4;
uVar4 = local_60 * local_60 * 4 + 0xf;
puVar9 = auStack_68;
puVar10 = auStack_68;
while (puVar9 != auStack_68 + -(uVar4 & 0xfffffffffffff000)) {
puVar8 = puVar10 + -0x1000;
*(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8);
puVar9 = puVar10 + -0x1000;
puVar10 = puVar10 + -0x1000;
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar3 = -uVar4;
local_58 = puVar8 + lVar3;
puVar10 = puVar8 + lVar3;
if (uVar4 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
if ((int)local_50 < 0) {
local_60 = local_60 & 0x3fffffffffffffff;
local_58 = puVar8 + lVar3;
}
else {
local_60 = local_60 & 0x3fffffffffffffff;
uVar4 = local_50 & 0xffffffff;
iVar7 = 0;
do {
iVar7 = iVar7 + 1;
*(int8 *)(puVar8 + lVar3 + -8) = 0x101315;
pvVar5 = memset(puVar10,0,uVar4 * 4 + 4);
puVar10 = (int1 *)((long)pvVar5 + lVar1);
} while (iVar7 != iVar14);
if ((int)local_50 != 0) {
lVar13 = 1;
lVar12 = (ulong)((int)local_50 - 1) + 2;
puVar11 = local_58;
puVar10 = local_58;
do {
puVar10 = puVar10 + lVar1;
cVar2 = param_1[lVar13 + -1];
lVar6 = 1;
do {
while ((param_1[lVar6 + -1] != cVar2 || ((int)lVar6 == (int)lVar13))) {
iVar14 = *(int *)(puVar11 + lVar6 * 4);
if (*(int *)(puVar11 + lVar6 * 4) < *(int *)(puVar10 + lVar6 * 4 + -4)) {
iVar14 = *(int *)(puVar10 + lVar6 * 4 + -4);
}
*(int *)(puVar10 + lVar6 * 4) = iVar14;
lVar6 = lVar6 + 1;
if (lVar6 == lVar12) goto LAB_00101389;
}
*(int *)(puVar10 + lVar6 * 4) = *(int *)(puVar11 + lVar6 * 4 + -4) + 1;
lVar6 = lVar6 + 1;
} while (lVar6 != lVar12);
LAB_00101389:
lVar13 = lVar13 + 1;
puVar11 = puVar11 + lVar1;
} while (lVar13 != lVar12);
}
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar8 + lVar3 + -8) = _fini;
__stack_chk_fail();
}
return *(int4 *)(local_58 + (local_60 + 1) * (long)(int)local_50 * 4);
} |
4,723 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char *str) {
int n = strlen(str);
int dp[n+1][n+1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (str[i-1] == str[j-1] && i != j) {
dp[i][j] = 1 + dp[i-1][j-1];
} else {
dp[i][j] = (dp[i][j-1] > dp[i-1][j]) ? dp[i][j-1] : dp[i-1][j];
}
}
}
return dp[n][n];
}
| int main() {
assert(func0("AABEBCDD") == 3);
assert(func0("aabb") == 2);
assert(func0("aab") == 1);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
mov %rdi,%r15
push %r14
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
callq 1080 <strlen@plt>
mov %rsp,%rdi
lea 0x1(%rax),%r12d
mov %rax,-0x48(%rbp)
movslq %r12d,%rax
lea 0x0(,%rax,4),%rbx
imul %rax,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rdi
and $0xfffffffffffffff0,%rdx
mov %rdi,%rax
cmp %rax,%rsp
je 12cb <func0+0x7b>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 12b6 <func0+0x66>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 13e7 <func0+0x197>
mov %rbx,%rax
mov %rsp,%rdi
shr $0x2,%rax
mov %rdi,-0x50(%rbp)
mov %rax,-0x58(%rbp)
mov -0x48(%rbp),%rax
test %eax,%eax
js 13b1 <func0+0x161>
mov %eax,%eax
xor %r13d,%r13d
lea 0x4(,%rax,4),%r14
nopl 0x0(%rax,%rax,1)
mov %r14,%rdx
xor %esi,%esi
add $0x1,%r13d
callq 10b0 <memset@plt>
mov %rax,%rdi
add %rbx,%rdi
cmp %r12d,%r13d
jne 1310 <func0+0xc0>
mov -0x48(%rbp),%rax
test %eax,%eax
jle 13b1 <func0+0x161>
lea -0x1(%rax),%edi
mov -0x50(%rbp),%rsi
mov $0x1,%r9d
lea 0x4(%rbx),%r11
add $0x2,%rdi
nopw 0x0(%rax,%rax,1)
movzbl -0x1(%r15,%r9,1),%r10d
lea (%r11,%rsi,1),%rdx
mov $0x1,%eax
jmp 1382 <func0+0x132>
nopl 0x0(%rax)
mov -0x4(%rdx),%ecx
cmp %ecx,(%rsi,%rax,4)
cmovge (%rsi,%rax,4),%ecx
add $0x1,%rax
add $0x4,%rdx
mov %ecx,-0x4(%rdx)
cmp %rax,%rdi
je 13a5 <func0+0x155>
cmp %r10b,-0x1(%r15,%rax,1)
jne 1368 <func0+0x118>
cmp %r9d,%eax
je 1368 <func0+0x118>
mov -0x4(%rsi,%rax,4),%ecx
add $0x1,%rax
add $0x4,%rdx
add $0x1,%ecx
mov %ecx,-0x4(%rdx)
cmp %rax,%rdi
jne 1382 <func0+0x132>
add $0x1,%r9
add %rbx,%rsi
cmp %r9,%rdi
jne 1350 <func0+0x100>
mov -0x58(%rbp),%rax
movslq -0x48(%rbp),%r13
add $0x1,%rax
imul %rax,%r13
mov -0x50(%rbp),%rax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
mov (%rax,%r13,4),%eax
jne 13f2 <func0+0x1a2>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 12dd <func0+0x8d>
callq 1090 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
mov r15, rdi
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
call _strlen
mov rsi, rsp
lea r14d, [rax+1]
mov [rbp+var_50], rax
movsxd rax, r14d
lea r12, ds:0[rax*4]
imul rax, rax
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rsi, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rsi
jz short loc_12C8
loc_12B3:
sub rsp, 1000h
or [rsp+1060h+var_68], 0
cmp rsp, rsi
jnz short loc_12B3
loc_12C8:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_13E5
loc_12DA:
mov rax, [rbp+var_50]
mov rdi, rsp; s
mov [rbp+var_58], rdi
test eax, eax
js loc_137D
mov eax, eax
mov r13, rdi
xor ebx, ebx
lea rax, ds:4[rax*4]
mov [rbp+n], rax
loc_1300:
mov rdx, [rbp+n]; n
xor esi, esi; c
add ebx, 1
call _memset
mov rdi, rax
add rdi, r12
cmp ebx, r14d
jnz short loc_1300
mov eax, dword ptr [rbp+var_50]
test eax, eax
jz loc_13F0
mov rax, [rbp+var_58]
mov r9d, ebx
mov r11d, 1
lea rdi, [rax+r12]
nop dword ptr [rax]
loc_1338:
movzx r10d, byte ptr [r15+r11-1]
mov eax, 1
nop dword ptr [rax+rax+00h]
loc_1348:
cmp [r15+rax-1], r10b
jnz short loc_1354
cmp eax, r11d
jnz short loc_13B8
loc_1354:
mov edx, [r13+rax*4+0]
mov esi, [rdi+rax*4-4]
cmp edx, esi
cmovl edx, esi
mov [rdi+rax*4], edx
add rax, 1
cmp rax, r9
jnz short loc_1348
add r11, 1
add rdi, r12
add r13, r12
cmp r11, r9
jnz short loc_1338
loc_137D:
mov r8, r12
shr r8, 2
loc_1384:
movsxd rbx, dword ptr [rbp+var_50]
lea rax, [r8+1]
imul rax, rbx
mov rbx, [rbp+var_58]
mov eax, [rbx+rax*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_13F8
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_13B8:
mov ecx, [r13+rax*4-4]
lea edx, [rcx+1]
mov [rdi+rax*4], edx
add rax, 1
cmp rax, r9
jnz loc_1348
add r11, 1
add rdi, r12
add r13, r12
cmp r11, r9
jnz loc_1338
jmp short loc_137D
loc_13E5:
or [rsp+rdx+1060h+var_1068], 0
jmp loc_12DA
loc_13F0:
mov r8d, 1
jmp short loc_1384
loc_13F8:
call ___stack_chk_fail | long long func0(const char *a1)
{
size_t v2; // rax
int v3; // r14d
unsigned long long v4; // r12
long long v5; // rdx
long long *v6; // rsi
__int16 v7; // dx
signed long long v8; // rdx
void *v9; // rsp
char *v10; // rdi
_BYTE *v11; // r13
int v12; // ebx
long long v13; // r11
_BYTE *v14; // rdi
char v15; // r10
long long v16; // rax
int v17; // edx
long long v18; // r8
_BYTE v21[4088]; // [rsp+8h] [rbp-1060h] BYREF
long long v22; // [rsp+1008h] [rbp-60h] BYREF
_BYTE *v23; // [rsp+1010h] [rbp-58h]
size_t v24; // [rsp+1018h] [rbp-50h]
size_t n; // [rsp+1020h] [rbp-48h]
unsigned long long v26; // [rsp+1030h] [rbp-38h]
v26 = __readfsqword(0x28u);
v2 = strlen(a1);
v3 = v2 + 1;
v24 = v2;
v4 = 4LL * ((int)v2 + 1);
v5 = 4 * v3 * (long long)v3 + 15;
v6 = (long long *)((char *)&v22 - (v5 & 0xFFFFFFFFFFFFF000LL));
v7 = v5 & 0xFFF0;
if ( &v22 != v6 )
{
while ( v21 != (_BYTE *)v6 )
;
}
v8 = v7 & 0xFFF;
v9 = alloca(v8);
if ( v8 )
*(_QWORD *)&v21[v8 - 8] = *(_QWORD *)&v21[v8 - 8];
v10 = v21;
v23 = v21;
if ( (v24 & 0x80000000) == 0LL )
{
v11 = v21;
v12 = 0;
n = 4LL * (unsigned int)v24 + 4;
do
{
++v12;
v10 = (char *)memset(v10, 0, n) + v4;
}
while ( v12 != v3 );
if ( !(_DWORD)v24 )
{
v18 = 1LL;
return *(unsigned int *)&v23[4 * (int)v24 * (v18 + 1)];
}
v13 = 1LL;
v14 = &v23[v4];
LABEL_10:
while ( 2 )
{
v15 = a1[v13 - 1];
v16 = 1LL;
do
{
while ( a1[v16 - 1] != v15 || (_DWORD)v16 == (_DWORD)v13 )
{
v17 = *(_DWORD *)&v11[4 * v16];
if ( v17 < *(_DWORD *)&v14[4 * v16 - 4] )
v17 = *(_DWORD *)&v14[4 * v16 - 4];
*(_DWORD *)&v14[4 * v16++] = v17;
if ( v16 == v12 )
{
++v13;
v14 += v4;
v11 += v4;
if ( v13 != v12 )
goto LABEL_10;
goto LABEL_17;
}
}
*(_DWORD *)&v14[4 * v16] = *(_DWORD *)&v11[4 * v16 - 4] + 1;
++v16;
}
while ( v16 != v12 );
++v13;
v14 += v4;
v11 += v4;
if ( v13 != v12 )
continue;
break;
}
}
LABEL_17:
v18 = v4 >> 2;
return *(unsigned int *)&v23[4 * (int)v24 * (v18 + 1)];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
MOV R15,RDI
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
CALL 0x00101080
MOV RSI,RSP
LEA R14D,[RAX + 0x1]
MOV qword ptr [RBP + -0x50],RAX
MOVSXD RAX,R14D
LEA R12,[RAX*0x4]
IMUL RAX,RAX
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RSI,RAX
AND RDX,-0x10
CMP RSP,RSI
JZ 0x001012c8
LAB_001012b3:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x001012b3
LAB_001012c8:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001013e5
LAB_001012da:
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RSP
MOV qword ptr [RBP + -0x58],RDI
TEST EAX,EAX
JS 0x0010137d
MOV EAX,EAX
MOV R13,RDI
XOR EBX,EBX
LEA RAX,[0x4 + RAX*0x4]
MOV qword ptr [RBP + -0x48],RAX
LAB_00101300:
MOV RDX,qword ptr [RBP + -0x48]
XOR ESI,ESI
ADD EBX,0x1
CALL 0x001010b0
MOV RDI,RAX
ADD RDI,R12
CMP EBX,R14D
JNZ 0x00101300
MOV EAX,dword ptr [RBP + -0x50]
TEST EAX,EAX
JZ 0x001013f0
MOV RAX,qword ptr [RBP + -0x58]
MOV R9D,EBX
MOV R11D,0x1
LEA RDI,[RAX + R12*0x1]
NOP dword ptr [RAX]
LAB_00101338:
MOVZX R10D,byte ptr [R15 + R11*0x1 + -0x1]
MOV EAX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101348:
CMP byte ptr [R15 + RAX*0x1 + -0x1],R10B
JNZ 0x00101354
CMP EAX,R11D
JNZ 0x001013b8
LAB_00101354:
MOV EDX,dword ptr [R13 + RAX*0x4]
MOV ESI,dword ptr [RDI + RAX*0x4 + -0x4]
CMP EDX,ESI
CMOVL EDX,ESI
MOV dword ptr [RDI + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,R9
JNZ 0x00101348
ADD R11,0x1
ADD RDI,R12
ADD R13,R12
CMP R11,R9
JNZ 0x00101338
LAB_0010137d:
MOV R8,R12
SHR R8,0x2
LAB_00101384:
MOVSXD RBX,dword ptr [RBP + -0x50]
LEA RAX,[R8 + 0x1]
IMUL RAX,RBX
MOV RBX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RBX + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013f8
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001013b8:
MOV ECX,dword ptr [R13 + RAX*0x4 + -0x4]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RDI + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,R9
JNZ 0x00101348
ADD R11,0x1
ADD RDI,R12
ADD R13,R12
CMP R11,R9
JNZ 0x00101338
JMP 0x0010137d
LAB_001013e5:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012da
LAB_001013f0:
MOV R8D,0x1
JMP 0x00101384
LAB_001013f8:
CALL 0x00101090 | int4 func0(char *param_1)
{
long lVar1;
char cVar2;
long lVar3;
int *puVar4;
ulong uVar5;
void *pvVar6;
ulong uVar7;
int iVar8;
ulong uVar9;
uint uVar10;
int *puVar11;
int *puVar13;
ulong uVar14;
int *puVar15;
uint uVar16;
long in_FS_OFFSET;
int auStack_68 [8];
int *local_60;
size_t local_58;
size_t local_50;
long local_40;
int *puVar12;
puVar11 = auStack_68;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = strlen(param_1);
uVar16 = (int)local_58 + 1;
uVar5 = (ulong)(int)uVar16;
lVar1 = uVar5 * 4;
uVar9 = uVar5 * uVar5 * 4 + 0xf;
puVar12 = auStack_68;
puVar13 = auStack_68;
while (puVar12 != auStack_68 + -(uVar9 & 0xfffffffffffff000)) {
puVar11 = puVar13 + -0x1000;
*(int8 *)(puVar13 + -8) = *(int8 *)(puVar13 + -8);
puVar12 = puVar13 + -0x1000;
puVar13 = puVar13 + -0x1000;
}
uVar9 = (ulong)((uint)uVar9 & 0xff0);
lVar3 = -uVar9;
local_60 = puVar11 + lVar3;
puVar13 = puVar11 + lVar3;
puVar15 = puVar11 + lVar3;
if (uVar9 != 0) {
*(int8 *)(puVar11 + -8) = *(int8 *)(puVar11 + -8);
}
puVar4 = puVar11 + lVar3;
if (-1 < (int)local_58) {
uVar10 = 0;
local_50 = (local_58 & 0xffffffff) * 4 + 4;
do {
uVar10 = uVar10 + 1;
*(int8 *)(puVar11 + lVar3 + -8) = 0x10130e;
pvVar6 = memset(puVar13,0,local_50);
puVar13 = (int *)((long)pvVar6 + lVar1);
} while (uVar10 != uVar16);
if ((int)local_58 == 0) {
uVar5 = 1;
goto LAB_00101384;
}
uVar9 = (ulong)uVar10;
uVar14 = 1;
puVar13 = local_60 + lVar1;
LAB_00101338:
do {
cVar2 = param_1[uVar14 - 1];
uVar7 = 1;
do {
while ((puVar4 = local_60, param_1[uVar7 - 1] != cVar2 || ((int)uVar7 == (int)uVar14))) {
iVar8 = *(int *)(puVar15 + uVar7 * 4);
if (*(int *)(puVar15 + uVar7 * 4) < *(int *)(puVar13 + uVar7 * 4 + -4)) {
iVar8 = *(int *)(puVar13 + uVar7 * 4 + -4);
}
*(int *)(puVar13 + uVar7 * 4) = iVar8;
uVar7 = uVar7 + 1;
if (uVar7 == uVar9) {
uVar14 = uVar14 + 1;
puVar13 = puVar13 + lVar1;
puVar15 = puVar15 + lVar1;
if (uVar14 == uVar9) goto LAB_0010137d;
goto LAB_00101338;
}
}
*(int *)(puVar13 + uVar7 * 4) = *(int *)(puVar15 + uVar7 * 4 + -4) + 1;
uVar7 = uVar7 + 1;
} while (uVar7 != uVar9);
uVar14 = uVar14 + 1;
puVar13 = puVar13 + lVar1;
puVar15 = puVar15 + lVar1;
} while (uVar14 != uVar9);
}
LAB_0010137d:
local_60 = puVar4;
uVar5 = uVar5 & 0x3fffffffffffffff;
LAB_00101384:
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(local_60 + (uVar5 + 1) * (long)(int)local_58 * 4);
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar11 + lVar3 + -8) = 0x1013fd;
__stack_chk_fail();
} |
4,724 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| int func0(const char *num) {
regex_t reg;
const char *pattern = "^[0-9]+(\\.[0-9]{1,2})?$";
regcomp(®, pattern, REG_EXTENDED);
int result = regexec(®, num, 0, NULL, 0);
regfree(®);
return (result == 0);
}
| int main() {
assert(func0("123.11") == 1);
assert(func0("0.21") == 1);
assert(func0("123.1214") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe19(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10c0 <regcomp@plt>
mov -0x68(%rbp),%rsi
lea -0x50(%rbp),%rax
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 10d0 <regexec@plt>
mov %eax,-0x5c(%rbp)
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 1090 <regfree@plt>
cmpl $0x0,-0x5c(%rbp)
sete %al
movzbl %al,%eax
mov -0x8(%rbp),%rdx
xor %fs:0x28,%rdx
je 1258 <func0+0x8f>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, a090912; "^[0-9]+(\\.[0-9]{1,2})?$"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov rsi, [rbp+string]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov ecx, 0; pmatch
mov edx, 0; nmatch
mov rdi, rax; preg
call _regexec
mov [rbp+var_5C], eax
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
cmp [rbp+var_5C], 0
setz al
movzx eax, al
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1258
call ___stack_chk_fail
locret_1258:
leave
retn | _BOOL8 func0(const char *a1)
{
int v2; // [rsp+14h] [rbp-5Ch]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
regcomp(&preg, "^[0-9]+(\\.[0-9]{1,2})?$", 1);
v2 = regexec(&preg, a1, 0LL, 0LL, 0);
regfree(&preg);
return v2 == 0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102004]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010c0
MOV RSI,qword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x50]
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x5c],EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00101090
CMP dword ptr [RBP + -0x5c],0x0
SETZ AL
MOVZX EAX,AL
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101258
CALL 0x001010a0
LAB_00101258:
LEAVE
RET | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&local_58,"^[0-9]+(\\.[0-9]{1,2})?$",1);
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_58);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar1 == 0;
} |
4,725 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| int func0(const char *num) {
regex_t reg;
const char *pattern = "^[0-9]+(\\.[0-9]{1,2})?$";
regcomp(®, pattern, REG_EXTENDED);
int result = regexec(®, num, 0, NULL, 0);
regfree(®);
return (result == 0);
}
| int main() {
assert(func0("123.11") == 1);
assert(func0("0.21") == 1);
assert(func0("123.1214") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %rdi,%rbx
mov $0x28,%r12d
mov %fs:(%r12),%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov $0x1,%edx
lea 0xe0b(%rip),%rsi
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %eax,%ebx
mov %rbp,%rdi
callq 1090 <regfree@plt>
test %ebx,%ebx
sete %al
mov 0x48(%rsp),%rcx
xor %fs:(%r12),%rcx
jne 1243 <func0+0x7a>
movzbl %al,%eax
add $0x50,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov edx, 1
lea rsi, a090912; "^[0-9]+(\\.[0-9]{1,2})?$"
mov rdi, rbp
call _regcomp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
mov rdi, rbp
call _regexec
mov ebx, eax
mov rdi, rbp
call _regfree
test ebx, ebx
setz al
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_1241
movzx eax, al
add rsp, 58h
pop rbx
pop rbp
retn
loc_1241:
call ___stack_chk_fail | _BOOL8 func0(long long a1)
{
int v1; // ebx
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "^[0-9]+(\\.[0-9]{1,2})?$", 1LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
regfree(_0);
return v1 == 0;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV EDX,0x1
LEA RSI,[0x102004]
MOV RDI,RBP
CALL 0x001010c0
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010d0
MOV EBX,EAX
MOV RDI,RBP
CALL 0x00101090
TEST EBX,EBX
SETZ AL
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101241
MOVZX EAX,AL
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_00101241:
CALL 0x001010a0 | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"^[0-9]+(\\.[0-9]{1,2})?$",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar1 == 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,726 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| int func0(const char *num) {
regex_t reg;
const char *pattern = "^[0-9]+(\\.[0-9]{1,2})?$";
regcomp(®, pattern, REG_EXTENDED);
int result = regexec(®, num, 0, NULL, 0);
regfree(®);
return (result == 0);
}
| int main() {
assert(func0("123.11") == 1);
assert(func0("0.21") == 1);
assert(func0("123.1214") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
mov %rdi,%r12
lea 0xd7f(%rip),%rsi
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
xor %ecx,%ecx
xor %r8d,%r8d
xor %edx,%edx
mov %r12,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %rbp,%rdi
mov %eax,%ebx
callq 1090 <regfree@plt>
test %ebx,%ebx
sete %al
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 12e3 <func0+0x73>
add $0x50,%rsp
movzbl %al,%eax
pop %rbx
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
mov edx, 1
mov r12, rdi
lea rsi, a090912; "^[0-9]+(\\.[0-9]{1,2})?$"
push rbp
push rbx
sub rsp, 50h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp
call _regcomp
xor r8d, r8d
xor ecx, ecx
xor edx, edx
mov rsi, r12
mov rdi, rbp
call _regexec
mov rdi, rbp
mov ebx, eax
call _regfree
test ebx, ebx
setz al
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_12E3
add rsp, 50h
movzx eax, al
pop rbx
pop rbp
pop r12
retn
loc_12E3:
call ___stack_chk_fail | _BOOL8 func0(long long a1)
{
int v1; // ebx
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "^[0-9]+(\\.[0-9]{1,2})?$", 1LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
regfree(_0);
return v1 == 0;
} | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
MOV R12,RDI
LEA RSI,[0x102004]
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010c0
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,R12
MOV RDI,RBP
CALL 0x001010d0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x00101090
TEST EBX,EBX
SETZ AL
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012e3
ADD RSP,0x50
MOVZX EAX,AL
POP RBX
POP RBP
POP R12
RET
LAB_001012e3:
CALL 0x001010a0 | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"^[0-9]+(\\.[0-9]{1,2})?$",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar1 == 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,727 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| int func0(const char *num) {
regex_t reg;
const char *pattern = "^[0-9]+(\\.[0-9]{1,2})?$";
regcomp(®, pattern, REG_EXTENDED);
int result = regexec(®, num, 0, NULL, 0);
regfree(®);
return (result == 0);
}
| int main() {
assert(func0("123.11") == 1);
assert(func0("0.21") == 1);
assert(func0("123.1214") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
mov %rdi,%r12
lea 0xd7f(%rip),%rsi
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
xor %ecx,%ecx
xor %r8d,%r8d
xor %edx,%edx
mov %r12,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %rbp,%rdi
mov %eax,%ebx
callq 1090 <regfree@plt>
test %ebx,%ebx
sete %al
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 12e3 <func0+0x73>
add $0x50,%rsp
movzbl %al,%eax
pop %rbx
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov edx, 1; cflags
lea rsi, pattern; "^[0-9]+(\\.[0-9]{1,2})?$"
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
xor r8d, r8d; eflags
xor ecx, ecx; pmatch
xor edx, edx; nmatch
mov rsi, rbx; string
mov rdi, rbp; preg
call _regexec
mov rdi, rbp; preg
mov ebx, eax
call _regfree
test ebx, ebx
setz al
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_12DF
add rsp, 58h
movzx eax, al
pop rbx
pop rbp
retn
loc_12DF:
call ___stack_chk_fail | _BOOL8 func0(char *string)
{
int v1; // ebx
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
regcomp(&_0, "^[0-9]+(\\.[0-9]{1,2})?$", 1);
v1 = regexec(&_0, string, 0LL, 0LL, 0);
regfree(&_0);
return v1 == 0;
} | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
LEA RSI,[0x102004]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010c0
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010d0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x00101090
TEST EBX,EBX
SETZ AL
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012df
ADD RSP,0x58
MOVZX EAX,AL
POP RBX
POP RBP
RET
LAB_001012df:
CALL 0x001010a0 | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"^[0-9]+(\\.[0-9]{1,2})?$",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar1 == 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,728 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
void heapify(int heap[], int n, int i) {
int smallest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < n && heap[l] < heap[smallest])
smallest = l;
if (r < n && heap[r] < heap[smallest])
smallest = r;
if (smallest != i) {
int temp = heap[i];
heap[i] = heap[smallest];
heap[smallest] = temp;
heapify(heap, n, smallest);
}
}
void buildHeap(int heap[], int n) {
int startIdx = (n / 2) - 1;
for (int i = startIdx; i >= 0; i--) {
heapify(heap, n, i);
}
}
| void func0(int heap[], int n, int a, int* outHeap) {
buildHeap(heap, n);
if (a < heap[0]) return;
heap[0] = a;
heapify(heap, n, 0);
for (int i = 0; i < n; i++) {
outHeap[i] = heap[i];
}
}
| int main() {
int testHeap1[] = {25, 44, 68, 21, 39, 23, 89};
int testHeap2[] = {25, 44, 68, 21, 39, 23, 89};
int testHeap3[] = {25, 44, 68, 21, 39, 23, 89};
int outHeap1[7], outHeap2[7], outHeap3[7];
func0(testHeap1, 7, 21, outHeap1);
func0(testHeap2, 7, 110, outHeap2);
func0(testHeap3, 7, 500, outHeap3);
int expectedHeap1[] = {21, 25, 23, 44, 39, 68, 89};
int expectedHeap2[] = {23, 25, 68, 44, 39, 110, 89};
int expectedHeap3[] = {23, 25, 68, 44, 39, 500, 89};
for (int i = 0; i < 7; i++) {
assert(outHeap1[i] == expectedHeap1[i]);
assert(outHeap2[i] == expectedHeap2[i]);
assert(outHeap3[i] == expectedHeap3[i]);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
mov -0x1c(%rbp),%edx
mov -0x18(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1295 <buildHeap>
mov -0x18(%rbp),%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jl 137d <func0+0x99>
mov -0x18(%rbp),%rax
mov -0x20(%rbp),%edx
mov %edx,(%rax)
mov -0x1c(%rbp),%ecx
mov -0x18(%rbp),%rax
mov $0x0,%edx
mov %ecx,%esi
mov %rax,%rdi
callq 1169 <heapify>
movl $0x0,-0x4(%rbp)
jmp 1373 <func0+0x8f>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1342 <func0+0x5e>
jmp 137e <func0+0x9a>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_28], rcx
mov edx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov esi, edx
mov rdi, rax
call buildHeap
mov rax, [rbp+var_18]
mov eax, [rax]
cmp [rbp+var_20], eax
jl short loc_137D
mov rax, [rbp+var_18]
mov edx, [rbp+var_20]
mov [rax], edx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov edx, 0
mov esi, ecx
mov rdi, rax
call heapify
mov [rbp+var_4], 0
jmp short loc_1373
loc_1342:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_4]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_4], 1
loc_1373:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1342
jmp short locret_137E
loc_137D:
nop
locret_137E:
leave
retn | long long func0(int *a1, unsigned int a2, int a3, long long a4)
{
long long result; // rax
unsigned int i; // [rsp+2Ch] [rbp-4h]
buildHeap(a1, a2);
result = (unsigned int)*a1;
if ( a3 >= (int)result )
{
*a1 = a3;
heapify(a1, a2, 0LL);
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= (int)a2 )
break;
*(_DWORD *)(4LL * (int)i + a4) = a1[i];
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV EDX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101295
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x20],EAX
JL 0x0010137d
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX],EDX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,0x0
MOV ESI,ECX
MOV RDI,RAX
CALL 0x00101169
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101373
LAB_00101342:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101373:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101342
JMP 0x0010137e
LAB_0010137d:
NOP
LAB_0010137e:
LEAVE
RET | void func0(int *param_1,int param_2,int param_3,long param_4)
{
int local_c;
buildHeap(param_1,param_2);
if (*param_1 <= param_3) {
*param_1 = param_3;
heapify(param_1,param_2,0);
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
*(int *)(param_4 + (long)local_c * 4) = param_1[local_c];
}
}
return;
} |
4,729 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
void heapify(int heap[], int n, int i) {
int smallest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < n && heap[l] < heap[smallest])
smallest = l;
if (r < n && heap[r] < heap[smallest])
smallest = r;
if (smallest != i) {
int temp = heap[i];
heap[i] = heap[smallest];
heap[smallest] = temp;
heapify(heap, n, smallest);
}
}
void buildHeap(int heap[], int n) {
int startIdx = (n / 2) - 1;
for (int i = startIdx; i >= 0; i--) {
heapify(heap, n, i);
}
}
| void func0(int heap[], int n, int a, int* outHeap) {
buildHeap(heap, n);
if (a < heap[0]) return;
heap[0] = a;
heapify(heap, n, 0);
for (int i = 0; i < n; i++) {
outHeap[i] = heap[i];
}
}
| int main() {
int testHeap1[] = {25, 44, 68, 21, 39, 23, 89};
int testHeap2[] = {25, 44, 68, 21, 39, 23, 89};
int testHeap3[] = {25, 44, 68, 21, 39, 23, 89};
int outHeap1[7], outHeap2[7], outHeap3[7];
func0(testHeap1, 7, 21, outHeap1);
func0(testHeap2, 7, 110, outHeap2);
func0(testHeap3, 7, 500, outHeap3);
int expectedHeap1[] = {21, 25, 23, 44, 39, 68, 89};
int expectedHeap2[] = {23, 25, 68, 44, 39, 110, 89};
int expectedHeap3[] = {23, 25, 68, 44, 39, 500, 89};
for (int i = 0; i < 7; i++) {
assert(outHeap1[i] == expectedHeap1[i]);
assert(outHeap2[i] == expectedHeap2[i]);
assert(outHeap3[i] == expectedHeap3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%r12d
mov %edx,%r13d
mov %rcx,%rbp
callq 11e5 <buildHeap>
cmp %r13d,(%rbx)
jle 1248 <func0+0x2f>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov %r13d,(%rbx)
mov $0x0,%edx
mov %r12d,%esi
mov %rbx,%rdi
callq 1169 <heapify>
test %r12d,%r12d
jle 123d <func0+0x24>
lea -0x1(%r12),%ecx
mov $0x0,%eax
mov (%rbx,%rax,4),%edx
mov %edx,0x0(%rbp,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rcx,%rdx
jne 126a <func0+0x51>
jmp 123d <func0+0x24>
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov ebp, esi
mov r13d, edx
mov r12, rcx
call buildHeap
cmp [rbx], r13d
jle short loc_1247
loc_123C:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1247:
mov [rbx], r13d
mov edx, 0
mov esi, ebp
mov rdi, rbx
call heapify
test ebp, ebp
jle short loc_123C
mov esi, ebp
mov eax, 0
loc_1264:
mov edx, [rbx+rax*4]
mov [r12+rax*4], edx
add rax, 1
cmp rax, rsi
jnz short loc_1264
jmp short loc_123C | long long func0(_DWORD *a1, int a2, int a3, long long a4)
{
long long result; // rax
result = buildHeap();
if ( *a1 <= a3 )
{
*a1 = a3;
result = heapify(a1, (unsigned int)a2, 0LL);
if ( a2 > 0 )
{
for ( result = 0LL; result != a2; ++result )
*(_DWORD *)(a4 + 4 * result) = a1[result];
}
}
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV EBP,ESI
MOV R13D,EDX
MOV R12,RCX
CALL 0x001011e5
CMP dword ptr [RBX],R13D
JLE 0x00101247
LAB_0010123c:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101247:
MOV dword ptr [RBX],R13D
MOV EDX,0x0
MOV ESI,EBP
MOV RDI,RBX
CALL 0x00101169
TEST EBP,EBP
JLE 0x0010123c
MOV ESI,EBP
MOV EAX,0x0
LAB_00101264:
MOV EDX,dword ptr [RBX + RAX*0x4]
MOV dword ptr [R12 + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101264
JMP 0x0010123c | void func0(int *param_1,uint param_2,int param_3,long param_4)
{
ulong uVar1;
buildHeap();
if (*param_1 <= param_3) {
*param_1 = param_3;
heapify(param_1,param_2,0);
if (0 < (int)param_2) {
uVar1 = 0;
do {
*(int *)(param_4 + uVar1 * 4) = param_1[uVar1];
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
}
}
return;
} |
4,730 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
void heapify(int heap[], int n, int i) {
int smallest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < n && heap[l] < heap[smallest])
smallest = l;
if (r < n && heap[r] < heap[smallest])
smallest = r;
if (smallest != i) {
int temp = heap[i];
heap[i] = heap[smallest];
heap[smallest] = temp;
heapify(heap, n, smallest);
}
}
void buildHeap(int heap[], int n) {
int startIdx = (n / 2) - 1;
for (int i = startIdx; i >= 0; i--) {
heapify(heap, n, i);
}
}
| void func0(int heap[], int n, int a, int* outHeap) {
buildHeap(heap, n);
if (a < heap[0]) return;
heap[0] = a;
heapify(heap, n, 0);
for (int i = 0; i < n; i++) {
outHeap[i] = heap[i];
}
}
| int main() {
int testHeap1[] = {25, 44, 68, 21, 39, 23, 89};
int testHeap2[] = {25, 44, 68, 21, 39, 23, 89};
int testHeap3[] = {25, 44, 68, 21, 39, 23, 89};
int outHeap1[7], outHeap2[7], outHeap3[7];
func0(testHeap1, 7, 21, outHeap1);
func0(testHeap2, 7, 110, outHeap2);
func0(testHeap3, 7, 500, outHeap3);
int expectedHeap1[] = {21, 25, 23, 44, 39, 68, 89};
int expectedHeap2[] = {23, 25, 68, 44, 39, 110, 89};
int expectedHeap3[] = {23, 25, 68, 44, 39, 500, 89};
for (int i = 0; i < 7; i++) {
assert(outHeap1[i] == expectedHeap1[i]);
assert(outHeap2[i] == expectedHeap2[i]);
assert(outHeap3[i] == expectedHeap3[i]);
}
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %edx,%r12d
push %rbp
mov %rcx,%rbp
push %rbx
mov %esi,%ebx
shr $0x1f,%ebx
add %esi,%ebx
sar %ebx
sub $0x1,%ebx
js 14af <func0+0x2f>
nopl 0x0(%rax)
mov %ebx,%edx
sub $0x1,%ebx
callq 13c0 <heapify>
cmp $0xffffffff,%ebx
jne 14a0 <func0+0x20>
cmp %r12d,(%rdi)
jle 14c0 <func0+0x40>
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
mov %r12d,(%rdi)
xor %edx,%edx
callq 13c0 <heapify>
test %esi,%esi
jle 14b4 <func0+0x34>
lea -0x1(%rsi),%ecx
xor %eax,%eax
nopl 0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%edx
mov %edx,0x0(%rbp,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rcx,%rdx
jne 14d8 <func0+0x58>
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r14
mov r14, rdi
push r13
movsxd r13, esi
push r12
mov r12d, edx
push rbp
mov rbp, rcx
push rbx
mov ebx, r13d
shr ebx, 1Fh
add ebx, r13d
sar ebx, 1
sub ebx, 1
js short loc_14C2
nop dword ptr [rax+rax+00000000h]
loc_14B0:
mov edx, ebx
mov esi, r13d
mov rdi, r14
call heapify
sub ebx, 1
jnb short loc_14B0
loc_14C2:
cmp [r14], r12d
jle short loc_14D0
loc_14C7:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_14D0:
mov [r14], r12d
xor edx, edx
mov esi, r13d
mov rdi, r14
call heapify
test r13d, r13d
jle short loc_14C7
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_14F0:
mov edx, [r14+rax*4]
mov [rbp+rax*4+0], edx
add rax, 1
cmp r13, rax
jnz short loc_14F0
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | void func0(_DWORD *a1, int a2, int a3, long long a4)
{
int v6; // ebx
long long i; // rax
v6 = a2 / 2 - 1;
if ( v6 >= 0 )
{
do
heapify(a1, (unsigned int)a2, (unsigned int)v6);
while ( v6-- != 0 );
}
if ( *a1 <= a3 )
{
*a1 = a3;
heapify(a1, (unsigned int)a2, 0LL);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(a4 + 4 * i) = a1[i];
}
}
} | func0:
ENDBR64
PUSH R14
MOV R14,RDI
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOV R12D,EDX
PUSH RBP
MOV RBP,RCX
PUSH RBX
MOV EBX,R13D
SHR EBX,0x1f
ADD EBX,R13D
SAR EBX,0x1
SUB EBX,0x1
JS 0x001014c2
NOP dword ptr [RAX + RAX*0x1]
LAB_001014b0:
MOV EDX,EBX
MOV ESI,R13D
MOV RDI,R14
CALL 0x001013c0
SUB EBX,0x1
JNC 0x001014b0
LAB_001014c2:
CMP dword ptr [R14],R12D
JLE 0x001014d0
LAB_001014c7:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001014d0:
MOV dword ptr [R14],R12D
XOR EDX,EDX
MOV ESI,R13D
MOV RDI,R14
CALL 0x001013c0
TEST R13D,R13D
JLE 0x001014c7
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_001014f0:
MOV EDX,dword ptr [R14 + RAX*0x4]
MOV dword ptr [RBP + RAX*0x4],EDX
ADD RAX,0x1
CMP R13,RAX
JNZ 0x001014f0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | void func0(int *param_1,int param_2,int param_3,long param_4)
{
long lVar1;
int iVar2;
bool bVar3;
iVar2 = param_2 / 2 + -1;
if (-1 < iVar2) {
do {
heapify(param_1,param_2,iVar2);
bVar3 = iVar2 != 0;
iVar2 = iVar2 + -1;
} while (bVar3);
}
if (*param_1 <= param_3) {
*param_1 = param_3;
heapify(param_1,param_2,0);
if (0 < param_2) {
lVar1 = 0;
do {
*(int *)(param_4 + lVar1 * 4) = param_1[lVar1];
lVar1 = lVar1 + 1;
} while (param_2 != lVar1);
return;
}
}
return;
} |
4,731 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
void heapify(int heap[], int n, int i) {
int smallest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < n && heap[l] < heap[smallest])
smallest = l;
if (r < n && heap[r] < heap[smallest])
smallest = r;
if (smallest != i) {
int temp = heap[i];
heap[i] = heap[smallest];
heap[smallest] = temp;
heapify(heap, n, smallest);
}
}
void buildHeap(int heap[], int n) {
int startIdx = (n / 2) - 1;
for (int i = startIdx; i >= 0; i--) {
heapify(heap, n, i);
}
}
| void func0(int heap[], int n, int a, int* outHeap) {
buildHeap(heap, n);
if (a < heap[0]) return;
heap[0] = a;
heapify(heap, n, 0);
for (int i = 0; i < n; i++) {
outHeap[i] = heap[i];
}
}
| int main() {
int testHeap1[] = {25, 44, 68, 21, 39, 23, 89};
int testHeap2[] = {25, 44, 68, 21, 39, 23, 89};
int testHeap3[] = {25, 44, 68, 21, 39, 23, 89};
int outHeap1[7], outHeap2[7], outHeap3[7];
func0(testHeap1, 7, 21, outHeap1);
func0(testHeap2, 7, 110, outHeap2);
func0(testHeap3, 7, 500, outHeap3);
int expectedHeap1[] = {21, 25, 23, 44, 39, 68, 89};
int expectedHeap2[] = {23, 25, 68, 44, 39, 110, 89};
int expectedHeap3[] = {23, 25, 68, 44, 39, 500, 89};
for (int i = 0; i < 7; i++) {
assert(outHeap1[i] == expectedHeap1[i]);
assert(outHeap2[i] == expectedHeap2[i]);
assert(outHeap3[i] == expectedHeap3[i]);
}
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %edx,%r12d
push %rbp
mov %rcx,%rbp
push %rbx
mov %esi,%ebx
shr $0x1f,%ebx
add %esi,%ebx
sar %ebx
sub $0x1,%ebx
js 14ff <func0+0x2f>
nopl 0x0(%rax)
mov %ebx,%edx
sub $0x1,%ebx
callq 1410 <heapify>
cmp $0xffffffff,%ebx
jne 14f0 <func0+0x20>
cmp %r12d,(%rdi)
jle 1510 <func0+0x40>
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
mov %r12d,(%rdi)
xor %edx,%edx
callq 1410 <heapify>
test %esi,%esi
jle 1504 <func0+0x34>
lea 0xf(%rdi),%rdx
lea -0x1(%rsi),%eax
sub %rbp,%rdx
cmp $0x1e,%rdx
jbe 158d <func0+0xbd>
cmp $0x3,%eax
jbe 158d <func0+0xbd>
mov %esi,%edx
xor %eax,%eax
shr $0x2,%edx
shl $0x4,%rdx
xchg %ax,%ax
movdqu (%rdi,%rax,1),%xmm0
movups %xmm0,0x0(%rbp,%rax,1)
add $0x10,%rax
cmp %rdx,%rax
jne 1540 <func0+0x70>
mov %esi,%eax
and $0xfffffffc,%eax
test $0x3,%sil
je 1504 <func0+0x34>
mov %eax,%edx
mov (%rdi,%rdx,4),%ecx
mov %ecx,0x0(%rbp,%rdx,4)
lea 0x1(%rax),%edx
cmp %edx,%esi
jle 1504 <func0+0x34>
movslq %edx,%rdx
add $0x2,%eax
mov (%rdi,%rdx,4),%ecx
mov %ecx,0x0(%rbp,%rdx,4)
cmp %eax,%esi
jle 1504 <func0+0x34>
cltq
pop %rbx
mov (%rdi,%rax,4),%edx
mov %edx,0x0(%rbp,%rax,4)
pop %rbp
pop %r12
retq
mov %eax,%edx
xor %eax,%eax
nopl 0x0(%rax)
mov (%rdi,%rax,4),%ecx
mov %ecx,0x0(%rbp,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %rdx,%rcx
jne 1598 <func0+0xc8>
jmpq 1504 <func0+0x34>
| func0:
endbr64
push r14
mov r14d, edx
push r13
mov r13, rcx
push r12
mov r12, rdi
push rbp
movsxd rbp, esi
push rbx
mov ebx, ebp
shr ebx, 1Fh
add ebx, ebp
sar ebx, 1
sub ebx, 1
js short loc_14C1
nop word ptr [rax+rax+00000000h]
loc_14B0:
mov edx, ebx
mov esi, ebp
mov rdi, r12
call heapify
sub ebx, 1
jnb short loc_14B0
loc_14C1:
cmp [r12], r14d
jle short loc_14D0
loc_14C7:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_14D0:
mov [r12], r14d
xor edx, edx
mov esi, ebp
mov rdi, r12
call heapify
test ebp, ebp
jle short loc_14C7
lea eax, [rbp-1]
cmp eax, 2
jbe short loc_14FD
lea rdx, [r12+4]
mov rax, r13
sub rax, rdx
cmp rax, 8
ja short loc_1528
loc_14FD:
shl rbp, 2
xor eax, eax
nop dword ptr [rax+rax+00h]
loc_1508:
mov edx, [r12+rax]
mov [r13+rax+0], edx
add rax, 4
cmp rbp, rax
jnz short loc_1508
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1528:
mov edx, ebp
xor eax, eax
shr edx, 2
shl rdx, 4
nop dword ptr [rax+rax+00h]
loc_1538:
movdqu xmm0, xmmword ptr [r12+rax]
movups xmmword ptr [r13+rax+0], xmm0
add rax, 10h
cmp rax, rdx
jnz short loc_1538
mov eax, ebp
and eax, 0FFFFFFFCh
test bpl, 3
jz loc_14C7
mov ecx, eax
mov esi, [r12+rcx*4]
lea rdx, ds:0[rcx*4]
mov [r13+rcx*4+0], esi
lea ecx, [rax+1]
cmp ebp, ecx
jle loc_14C7
mov ecx, [r12+rdx+4]
add eax, 2
mov [r13+rdx+4], ecx
cmp ebp, eax
jle loc_14C7
mov eax, [r12+rdx+8]
mov [r13+rdx+8], eax
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | void func0(_DWORD *a1, int a2, int a3, long long a4)
{
int v6; // ebx
long long i; // rax
long long v9; // rax
unsigned int v10; // eax
long long v11; // rdx
v6 = a2 / 2 - 1;
if ( v6 >= 0 )
{
do
heapify(a1, (unsigned int)a2, (unsigned int)v6);
while ( v6-- != 0 );
}
if ( *a1 <= a3 )
{
*a1 = a3;
heapify(a1, (unsigned int)a2, 0LL);
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) > 2 && (unsigned long long)(a4 - (_QWORD)(a1 + 1)) > 8 )
{
v9 = 0LL;
do
{
*(__m128i *)(a4 + v9 * 4) = _mm_loadu_si128((const __m128i *)&a1[v9]);
v9 += 4LL;
}
while ( v9 != 4LL * ((unsigned int)a2 >> 2) );
v10 = a2 & 0xFFFFFFFC;
if ( (a2 & 3) != 0 )
{
v11 = v10;
*(_DWORD *)(a4 + v11 * 4) = a1[v11];
if ( a2 > (int)(v10 + 1) )
{
*(_DWORD *)(a4 + v11 * 4 + 4) = a1[v11 + 1];
if ( a2 > (int)(v10 + 2) )
*(_DWORD *)(a4 + v11 * 4 + 8) = a1[v11 + 2];
}
}
}
else
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(a4 + i * 4) = a1[i];
}
}
}
} | func0:
ENDBR64
PUSH R14
MOV R14D,EDX
PUSH R13
MOV R13,RCX
PUSH R12
MOV R12,RDI
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV EBX,EBP
SHR EBX,0x1f
ADD EBX,EBP
SAR EBX,0x1
SUB EBX,0x1
JS 0x001014c1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001014b0:
MOV EDX,EBX
MOV ESI,EBP
MOV RDI,R12
CALL 0x001013a0
SUB EBX,0x1
JNC 0x001014b0
LAB_001014c1:
CMP dword ptr [R12],R14D
JLE 0x001014d0
LAB_001014c7:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001014d0:
MOV dword ptr [R12],R14D
XOR EDX,EDX
MOV ESI,EBP
MOV RDI,R12
CALL 0x001013a0
TEST EBP,EBP
JLE 0x001014c7
LEA EAX,[RBP + -0x1]
CMP EAX,0x2
JBE 0x001014fd
LEA RDX,[R12 + 0x4]
MOV RAX,R13
SUB RAX,RDX
CMP RAX,0x8
JA 0x00101528
LAB_001014fd:
SHL RBP,0x2
XOR EAX,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101508:
MOV EDX,dword ptr [R12 + RAX*0x1]
MOV dword ptr [R13 + RAX*0x1],EDX
ADD RAX,0x4
CMP RBP,RAX
JNZ 0x00101508
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101528:
MOV EDX,EBP
XOR EAX,EAX
SHR EDX,0x2
SHL RDX,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_00101538:
MOVDQU XMM0,xmmword ptr [R12 + RAX*0x1]
MOVUPS xmmword ptr [R13 + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,RDX
JNZ 0x00101538
MOV EAX,EBP
AND EAX,0xfffffffc
TEST BPL,0x3
JZ 0x001014c7
MOV ECX,EAX
MOV ESI,dword ptr [R12 + RCX*0x4]
LEA RDX,[RCX*0x4]
MOV dword ptr [R13 + RCX*0x4],ESI
LEA ECX,[RAX + 0x1]
CMP EBP,ECX
JLE 0x001014c7
MOV ECX,dword ptr [R12 + RDX*0x1 + 0x4]
ADD EAX,0x2
MOV dword ptr [R13 + RDX*0x1 + 0x4],ECX
CMP EBP,EAX
JLE 0x001014c7
MOV EAX,dword ptr [R12 + RDX*0x1 + 0x8]
MOV dword ptr [R13 + RDX*0x1 + 0x8],EAX
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | void func0(int *param_1,uint param_2,int param_3,long param_4)
{
int8 uVar1;
uint uVar2;
long lVar3;
ulong uVar4;
int iVar5;
bool bVar6;
iVar5 = (int)param_2 / 2 + -1;
if (-1 < iVar5) {
do {
heapify(param_1,param_2,iVar5);
bVar6 = iVar5 != 0;
iVar5 = iVar5 + -1;
} while (bVar6);
}
if (*param_1 <= param_3) {
*param_1 = param_3;
heapify(param_1,param_2,0);
if (0 < (int)param_2) {
if ((param_2 - 1 < 3) || ((ulong)(param_4 - (long)(param_1 + 1)) < 9)) {
lVar3 = 0;
do {
*(int4 *)(param_4 + lVar3) = *(int4 *)((long)param_1 + lVar3);
lVar3 = lVar3 + 4;
} while ((long)(int)param_2 * 4 != lVar3);
return;
}
lVar3 = 0;
do {
uVar1 = ((int8 *)((long)param_1 + lVar3))[1];
*(int8 *)(param_4 + lVar3) = *(int8 *)((long)param_1 + lVar3);
((int8 *)(param_4 + lVar3))[1] = uVar1;
lVar3 = lVar3 + 0x10;
} while (lVar3 != (ulong)(param_2 >> 2) << 4);
uVar2 = param_2 & 0xfffffffc;
if (((long)(int)param_2 & 3U) != 0) {
uVar4 = (ulong)uVar2;
*(int *)(param_4 + uVar4 * 4) = param_1[uVar4];
if (((int)(uVar2 + 1) < (int)param_2) &&
(*(int *)(param_4 + 4 + uVar4 * 4) = param_1[uVar4 + 1], (int)(uVar2 + 2) < (int)param_2)
) {
*(int *)(param_4 + 8 + uVar4 * 4) = param_1[uVar4 + 2];
return;
}
}
}
}
return;
} |
4,732 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
| bool func0(const char* string) {
regex_t regex;
int result;
regcomp(®ex, "[^a-zA-Z0-9.]", REG_EXTENDED);
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
return result == REG_NOMATCH;
}
| int main() {
assert(func0("ABCDEFabcdef123450") == true);
assert(func0("*&%@#!}{") == false);
assert(func0("HELLOhowareyou98765") == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x50(%rbp),%rax
mov $0x1,%edx
lea 0xe10(%rip),%rsi
mov %rax,%rdi
callq 10c0 <regcomp@plt>
mov -0x68(%rbp),%rsi
lea -0x50(%rbp),%rax
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 10d0 <regexec@plt>
mov %eax,-0x54(%rbp)
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 1090 <regfree@plt>
cmpl $0x1,-0x54(%rbp)
sete %al
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 124a <func0+0x81>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+preg]
mov edx, 1; cflags
lea rcx, pattern; "[^a-zA-Z0-9.]"
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov rsi, [rbp+string]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov ecx, 0; pmatch
mov edx, 0; nmatch
mov rdi, rax; preg
call _regexec
mov [rbp+var_54], eax
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
cmp [rbp+var_54], 1
setz al
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_124D
call ___stack_chk_fail
locret_124D:
leave
retn | bool func0(const char *a1)
{
int v2; // [rsp+1Ch] [rbp-54h]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
regcomp(&preg, "[^a-zA-Z0-9.]", 1);
v2 = regexec(&preg, a1, 0LL, 0LL, 0);
regfree(&preg);
return v2 == 1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010c0
MOV RSI,qword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x50]
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x54],EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00101090
CMP dword ptr [RBP + -0x54],0x1
SETZ AL
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010124d
CALL 0x001010a0
LAB_0010124d:
LEAVE
RET | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&local_58,"[^a-zA-Z0-9.]",1);
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_58);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar1 == 1;
} |
4,733 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
| bool func0(const char* string) {
regex_t regex;
int result;
regcomp(®ex, "[^a-zA-Z0-9.]", REG_EXTENDED);
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
return result == REG_NOMATCH;
}
| int main() {
assert(func0("ABCDEFabcdef123450") == true);
assert(func0("*&%@#!}{") == false);
assert(func0("HELLOhowareyou98765") == true);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %rdi,%rbx
mov $0x28,%r12d
mov %fs:(%r12),%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov $0x1,%edx
lea 0xe0b(%rip),%rsi
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %eax,%ebx
mov %rbp,%rdi
callq 1090 <regfree@plt>
cmp $0x1,%ebx
sete %al
mov 0x48(%rsp),%rcx
xor %fs:(%r12),%rcx
jne 1241 <func0+0x78>
add $0x50,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov edx, 1
lea rsi, aAZaZ09; "[^a-zA-Z0-9.]"
mov rdi, rbp
call _regcomp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
mov rdi, rbp
call _regexec
mov ebx, eax
mov rdi, rbp
call _regfree
cmp ebx, 1
setz al
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_123F
add rsp, 58h
pop rbx
pop rbp
retn
loc_123F:
call ___stack_chk_fail | bool func0(long long a1)
{
int v1; // ebx
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "[^a-zA-Z0-9.]", 1LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
regfree(_0);
return v1 == 1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV EDX,0x1
LEA RSI,[0x102004]
MOV RDI,RBP
CALL 0x001010c0
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010d0
MOV EBX,EAX
MOV RDI,RBP
CALL 0x00101090
CMP EBX,0x1
SETZ AL
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010123f
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_0010123f:
CALL 0x001010a0 | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"[^a-zA-Z0-9.]",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar1 == 1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,734 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
| bool func0(const char* string) {
regex_t regex;
int result;
regcomp(®ex, "[^a-zA-Z0-9.]", REG_EXTENDED);
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
return result == REG_NOMATCH;
}
| int main() {
assert(func0("ABCDEFabcdef123450") == true);
assert(func0("*&%@#!}{") == false);
assert(func0("HELLOhowareyou98765") == true);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
mov %rdi,%r12
lea 0xd7f(%rip),%rsi
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
xor %ecx,%ecx
xor %r8d,%r8d
xor %edx,%edx
mov %r12,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %rbp,%rdi
mov %eax,%ebx
callq 1090 <regfree@plt>
cmp $0x1,%ebx
sete %al
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 12e1 <func0+0x71>
add $0x50,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r12
mov edx, 1
mov r12, rdi
lea rsi, aAZaZ09; "[^a-zA-Z0-9.]"
push rbp
push rbx
sub rsp, 50h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp
call _regcomp
xor r8d, r8d
xor ecx, ecx
xor edx, edx
mov rsi, r12
mov rdi, rbp
call _regexec
mov rdi, rbp
mov ebx, eax
call _regfree
cmp ebx, 1
setz al
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_12E1
add rsp, 50h
pop rbx
pop rbp
pop r12
retn
loc_12E1:
call ___stack_chk_fail | bool func0(long long a1)
{
int v1; // ebx
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "[^a-zA-Z0-9.]", 1LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
regfree(_0);
return v1 == 1;
} | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
MOV R12,RDI
LEA RSI,[0x102004]
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010c0
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,R12
MOV RDI,RBP
CALL 0x001010d0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x00101090
CMP EBX,0x1
SETZ AL
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012e1
ADD RSP,0x50
POP RBX
POP RBP
POP R12
RET
LAB_001012e1:
CALL 0x001010a0 | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"[^a-zA-Z0-9.]",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar1 == 1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,735 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
| bool func0(const char* string) {
regex_t regex;
int result;
regcomp(®ex, "[^a-zA-Z0-9.]", REG_EXTENDED);
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
return result == REG_NOMATCH;
}
| int main() {
assert(func0("ABCDEFabcdef123450") == true);
assert(func0("*&%@#!}{") == false);
assert(func0("HELLOhowareyou98765") == true);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
mov %rdi,%r12
lea 0xd7f(%rip),%rsi
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
xor %ecx,%ecx
xor %r8d,%r8d
xor %edx,%edx
mov %r12,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %rbp,%rdi
mov %eax,%ebx
callq 1090 <regfree@plt>
cmp $0x1,%ebx
sete %al
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 12e1 <func0+0x71>
add $0x50,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov edx, 1; cflags
lea rsi, pattern; "[^a-zA-Z0-9.]"
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
xor r8d, r8d; eflags
xor ecx, ecx; pmatch
xor edx, edx; nmatch
mov rsi, rbx; string
mov rdi, rbp; preg
call _regexec
mov rdi, rbp; preg
mov ebx, eax
call _regfree
cmp ebx, 1
setz al
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_12DD
add rsp, 58h
pop rbx
pop rbp
retn
loc_12DD:
call ___stack_chk_fail | bool func0(char *string)
{
int v1; // ebx
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
regcomp(&_0, "[^a-zA-Z0-9.]", 1);
v1 = regexec(&_0, string, 0LL, 0LL, 0);
regfree(&_0);
return v1 == 1;
} | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
LEA RSI,[0x102004]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010c0
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010d0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x00101090
CMP EBX,0x1
SETZ AL
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012dd
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_001012dd:
CALL 0x001010a0 | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"[^a-zA-Z0-9.]",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar1 == 1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,736 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int n) {
if (n == 1) {
return 1;
}
int count = pow(2, n - 2);
return count;
}
| int main() {
assert(func0(2) == 1);
assert(func0(3) == 2);
assert(func0(1) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
cmpl $0x1,-0x14(%rbp)
jne 1185 <func0+0x1c>
mov $0x1,%eax
jmp 11ae <func0+0x45>
mov -0x14(%rbp),%eax
sub $0x2,%eax
cvtsi2sd %eax,%xmm0
mov 0xee2(%rip),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1060 <pow@plt>
cvttsd2si %xmm0,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
cmp [rbp+var_14], 1
jnz short loc_1185
mov eax, 1
jmp short locret_11B2
loc_1185:
mov eax, [rbp+var_14]
sub eax, 2
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mov rax, cs:x
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
cvttsd2si eax, xmm0
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
locret_11B2:
leave
retn | long long func0(int a1)
{
if ( a1 == 1 )
return 1LL;
else
return (unsigned int)(int)pow(2.0, (double)(a1 - 2));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x1
JNZ 0x00101185
MOV EAX,0x1
JMP 0x001011b2
LAB_00101185:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x2
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOV RAX,qword ptr [0x00102058]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
CVTTSD2SI EAX,XMM0
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
LAB_001011b2:
LEAVE
RET | int func0(int param_1)
{
int iVar1;
double dVar2;
if (param_1 == 1) {
iVar1 = 1;
}
else {
dVar2 = pow(DAT_00102058,(double)(param_1 + -2));
iVar1 = (int)dVar2;
}
return iVar1;
} |
4,737 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int n) {
if (n == 1) {
return 1;
}
int count = pow(2, n - 2);
return count;
}
| int main() {
assert(func0(2) == 1);
assert(func0(3) == 2);
assert(func0(1) == 1);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
cmp $0x1,%edi
je 1199 <func0+0x30>
sub $0x8,%rsp
sub $0x2,%edi
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
movsd 0xeed(%rip),%xmm0
callq 1060 <pow@plt>
cvttsd2si %xmm0,%eax
add $0x8,%rsp
retq
retq
| func0:
endbr64
mov eax, edi
cmp edi, 1
jz short locret_1199
sub rsp, 8
sub edi, 2
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
movsd xmm0, cs:qword_2050
call _pow
cvttsd2si eax, xmm0
add rsp, 8
retn
locret_1199:
retn | long long func0(unsigned int a1)
{
long long result; // rax
result = a1;
if ( a1 != 1 )
return (unsigned int)(int)pow(2.0, (double)(int)(a1 - 2));
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,0x1
JZ 0x00101199
SUB RSP,0x8
SUB EDI,0x2
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MOVSD XMM0,qword ptr [0x00102050]
CALL 0x00101060
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
RET
LAB_00101199:
RET | int func0(int param_1)
{
double dVar1;
if (param_1 != 1) {
dVar1 = pow(DAT_00102050,(double)(param_1 + -2));
return (int)dVar1;
}
return param_1;
} |
4,738 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int n) {
if (n == 1) {
return 1;
}
int count = pow(2, n - 2);
return count;
}
| int main() {
assert(func0(2) == 1);
assert(func0(3) == 2);
assert(func0(1) == 1);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%edi
je 1190 <func0+0x30>
sub $0x2,%edi
pxor %xmm1,%xmm1
sub $0x8,%rsp
movsd 0xe8c(%rip),%xmm0
cvtsi2sd %edi,%xmm1
callq 1050 <pow@plt>
add $0x8,%rsp
cvttsd2si %xmm0,%eax
retq
xchg %ax,%ax
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, 1
jz short loc_1190
sub edi, 2
pxor xmm1, xmm1
sub rsp, 8
movsd xmm0, cs:qword_2008
cvtsi2sd xmm1, edi
call _pow
add rsp, 8
cvttsd2si eax, xmm0
retn
loc_1190:
mov eax, 1
retn | long long func0(int a1)
{
if ( a1 == 1 )
return 1LL;
else
return (unsigned int)(int)pow(2.0, (double)(a1 - 2));
} | func0:
ENDBR64
CMP EDI,0x1
JZ 0x00101190
SUB EDI,0x2
PXOR XMM1,XMM1
SUB RSP,0x8
MOVSD XMM0,qword ptr [0x00102008]
CVTSI2SD XMM1,EDI
CALL 0x00101050
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET
LAB_00101190:
MOV EAX,0x1
RET | int func0(int param_1)
{
double dVar1;
if (param_1 != 1) {
dVar1 = pow(DAT_00102008,(double)(param_1 + -2));
return (int)dVar1;
}
return 1;
} |
4,739 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| int func0(int n) {
if (n == 1) {
return 1;
}
int count = pow(2, n - 2);
return count;
}
| int main() {
assert(func0(2) == 1);
assert(func0(3) == 2);
assert(func0(1) == 1);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%edi
je 1190 <func0+0x30>
sub $0x2,%edi
pxor %xmm1,%xmm1
sub $0x8,%rsp
movsd 0xe8c(%rip),%xmm0
cvtsi2sd %edi,%xmm1
callq 1050 <pow@plt>
add $0x8,%rsp
cvttsd2si %xmm0,%eax
retq
xchg %ax,%ax
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, 1
jz short loc_1190
sub edi, 2
pxor xmm1, xmm1
sub rsp, 8
movsd xmm0, cs:x; x
cvtsi2sd xmm1, edi; y
call _pow
add rsp, 8
cvttsd2si eax, xmm0
retn
loc_1190:
mov eax, 1
retn | long long func0(int a1)
{
if ( a1 == 1 )
return 1LL;
else
return (unsigned int)(int)pow(2.0, (double)(a1 - 2));
} | func0:
ENDBR64
CMP EDI,0x1
JZ 0x00101190
SUB EDI,0x2
PXOR XMM1,XMM1
SUB RSP,0x8
MOVSD XMM0,qword ptr [0x00102008]
CVTSI2SD XMM1,EDI
CALL 0x00101050
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET
LAB_00101190:
MOV EAX,0x1
RET | int func0(int param_1)
{
double dVar1;
if (param_1 != 1) {
dVar1 = pow(DAT_00102008,(double)(param_1 + -2));
return (int)dVar1;
}
return 1;
} |
4,740 | func0 | #include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i * i;
}
return sum;
}
| int main() {
assert(func0(2) == 17);
assert(func0(4) == 354);
assert(func0(6) == 2275);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 1179 <func0+0x30>
mov -0x4(%rbp),%eax
imul %eax,%eax
imul -0x4(%rbp),%eax
imul -0x4(%rbp),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 1164 <func0+0x1b>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_1179
loc_1164:
mov eax, [rbp+var_4]
imul eax, eax
imul eax, [rbp+var_4]
imul eax, [rbp+var_4]
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_1179:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_14]
jle short loc_1164
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += i * i * i * i;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101179
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101179:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x00101164
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(int param_1)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 1; local_c <= param_1; local_c = local_c + 1) {
local_10 = local_10 + local_c * local_c * local_c * local_c;
}
return local_10;
} |
4,741 | func0 | #include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i * i;
}
return sum;
}
| int main() {
assert(func0(2) == 17);
assert(func0(4) == 354);
assert(func0(6) == 2275);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1172 <func0+0x29>
add $0x1,%edi
mov $0x1,%eax
mov $0x0,%ecx
mov %eax,%edx
imul %eax,%edx
imul %edx,%edx
add %edx,%ecx
add $0x1,%eax
cmp %edi,%eax
jne 115e <func0+0x15>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 116f <func0+0x26>
| func0:
endbr64
test edi, edi
jle short loc_1172
add edi, 1
mov eax, 1
mov ecx, 0
loc_115E:
mov edx, eax
imul edx, eax
imul edx, edx
add ecx, edx
add eax, 1
cmp eax, edi
jnz short loc_115E
loc_116F:
mov eax, ecx
retn
loc_1172:
mov ecx, 0
jmp short loc_116F | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v3 += v2 * v2 * v2 * v2;
++v2;
}
while ( v2 != v1 );
}
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101172
ADD EDI,0x1
MOV EAX,0x1
MOV ECX,0x0
LAB_0010115e:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EDX
ADD ECX,EDX
ADD EAX,0x1
CMP EAX,EDI
JNZ 0x0010115e
LAB_0010116f:
MOV EAX,ECX
RET
LAB_00101172:
MOV ECX,0x0
JMP 0x0010116f | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1 * iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 1;
} while (iVar1 != param_1 + 1);
}
return iVar2;
} |
4,742 | func0 | #include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i * i;
}
return sum;
}
| int main() {
assert(func0(2) == 17);
assert(func0(4) == 354);
assert(func0(6) == 2275);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
add $0x1,%edi
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
imul %eax,%edx
add $0x1,%eax
imul %edx,%edx
add %edx,%r8d
cmp %edi,%eax
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_1170
add edi, 1
mov eax, 1
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
add eax, 1
imul edx, edx
add r8d, edx
cmp eax, edi
jnz short loc_1158
mov eax, r8d
retn
loc_1170:
xor r8d, r8d
mov eax, r8d
retn | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // r8d
int v4; // edx
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2 * v2;
++v2;
v3 += v4 * v4;
}
while ( v2 != v1 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
ADD EDI,0x1
MOV EAX,0x1
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
ADD EAX,0x1
IMUL EDX,EDX
ADD R8D,EDX
CMP EAX,EDI
JNZ 0x00101158
MOV EAX,R8D
RET
LAB_00101170:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar3 = 0;
do {
iVar2 = iVar1 * iVar1;
iVar1 = iVar1 + 1;
iVar3 = iVar3 + iVar2 * iVar2;
} while (iVar1 != param_1 + 1);
return iVar3;
}
return 0;
} |
4,743 | func0 | #include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i * i;
}
return sum;
}
| int main() {
assert(func0(2) == 17);
assert(func0(4) == 354);
assert(func0(6) == 2275);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
add $0x1,%edi
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
imul %eax,%edx
add $0x1,%eax
imul %edx,%edx
add %edx,%r8d
cmp %eax,%edi
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_1170
add edi, 1
mov eax, 1
xor ecx, ecx
nop word ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
add eax, 1
imul edx, edx
add ecx, edx
cmp eax, edi
jnz short loc_1158
mov eax, ecx
retn
loc_1170:
xor ecx, ecx
mov eax, ecx
retn | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // ecx
int v4; // edx
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2 * v2;
++v2;
v3 += v4 * v4;
}
while ( v2 != v1 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
ADD EDI,0x1
MOV EAX,0x1
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
ADD EAX,0x1
IMUL EDX,EDX
ADD ECX,EDX
CMP EAX,EDI
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101170:
XOR ECX,ECX
MOV EAX,ECX
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
iVar3 = iVar1 * iVar1;
iVar1 = iVar1 + 1;
iVar2 = iVar2 + iVar3 * iVar3;
} while (iVar1 != param_1 + 1);
return iVar2;
}
return 0;
} |
4,744 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| void func0(const char* test_tup1[], const char* test_tup2[], char* res[], int size) {
for (int i = 0; i < size; i++) {
strcpy(res[i], test_tup1[i]);
strcat(res[i], test_tup2[i]);
}
}
| int main() {
// Declare variables
const char* test_tup1_1[] = {"Manjeet", "Nikhil", "Akshat"};
const char* test_tup1_2[] = {" Singh", " Meherwal", " Garg"};
char* res1[3];
char res1_0[20], res1_1[20], res1_2[20];
res1[0] = res1_0; res1[1] = res1_1; res1[2] = res1_2;
const char* test_tup2_1[] = {"Shaik", "Ayesha", "Sanya"};
const char* test_tup2_2[] = {" Dawood", " Begum", " Singh"};
char* res2[3];
char res2_0[20], res2_1[20], res2_2[20];
res2[0] = res2_0; res2[1] = res2_1; res2[2] = res2_2;
const char* test_tup3_1[] = {"Harpreet", "Priyanka", "Muskan"};
const char* test_tup3_2[] = {"Kour", " Agarwal", "Sethi"};
char* res3[3];
char res3_0[20], res3_1[20], res3_2[20];
res3[0] = res3_0; res3[1] = res3_1; res3[2] = res3_2;
// Call the function
func0(test_tup1_1, test_tup1_2, res1, 3);
func0(test_tup2_1, test_tup2_2, res2, 3);
func0(test_tup3_1, test_tup3_2, res3, 3);
// Assertions
assert(strcmp(res1[0], "Manjeet Singh") == 0);
assert(strcmp(res1[1], "Nikhil Meherwal") == 0);
assert(strcmp(res1[2], "Akshat Garg") == 0);
assert(strcmp(res2[0], "Shaik Dawood") == 0);
assert(strcmp(res2[1], "Ayesha Begum") == 0);
assert(strcmp(res2[2], "Sanya Singh") == 0);
assert(strcmp(res3[0], "HarpreetKour") == 0);
assert(strcmp(res3[1], "Priyanka Agarwal") == 0);
assert(strcmp(res3[2], "MuskanSethi") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x2c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1263 <func0+0x9a>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1090 <strcpy@plt>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10d0 <strcat@plt>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11ed <func0+0x24>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_4], 0
jmp short loc_1263
loc_11ED:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rcx
mov rax, [rax]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_20]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rcx
mov rax, [rax]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcat
add [rbp+var_4], 1
loc_1263:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_2C]
jl short loc_11ED
nop
nop
leave
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
unsigned int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a4 )
break;
strcpy(*(char **)(8LL * (int)i + a3), *(const char **)(8LL * (int)i + a1));
strcat(*(char **)(8LL * (int)i + a3), *(const char **)(8LL * (int)i + a2));
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101263
LAB_001011ed:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101090
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010d0
ADD dword ptr [RBP + -0x4],0x1
LAB_00101263:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011ed
NOP
NOP
LEAVE
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
strcpy(*(char **)(param_3 + (long)local_c * 8),*(char **)(param_1 + (long)local_c * 8));
strcat(*(char **)(param_3 + (long)local_c * 8),*(char **)(param_2 + (long)local_c * 8));
}
return;
} |
4,745 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| void func0(const char* test_tup1[], const char* test_tup2[], char* res[], int size) {
for (int i = 0; i < size; i++) {
strcpy(res[i], test_tup1[i]);
strcat(res[i], test_tup2[i]);
}
}
| int main() {
// Declare variables
const char* test_tup1_1[] = {"Manjeet", "Nikhil", "Akshat"};
const char* test_tup1_2[] = {" Singh", " Meherwal", " Garg"};
char* res1[3];
char res1_0[20], res1_1[20], res1_2[20];
res1[0] = res1_0; res1[1] = res1_1; res1[2] = res1_2;
const char* test_tup2_1[] = {"Shaik", "Ayesha", "Sanya"};
const char* test_tup2_2[] = {" Dawood", " Begum", " Singh"};
char* res2[3];
char res2_0[20], res2_1[20], res2_2[20];
res2[0] = res2_0; res2[1] = res2_1; res2[2] = res2_2;
const char* test_tup3_1[] = {"Harpreet", "Priyanka", "Muskan"};
const char* test_tup3_2[] = {"Kour", " Agarwal", "Sethi"};
char* res3[3];
char res3_0[20], res3_1[20], res3_2[20];
res3[0] = res3_0; res3[1] = res3_1; res3[2] = res3_2;
// Call the function
func0(test_tup1_1, test_tup1_2, res1, 3);
func0(test_tup2_1, test_tup2_2, res2, 3);
func0(test_tup3_1, test_tup3_2, res3, 3);
// Assertions
assert(strcmp(res1[0], "Manjeet Singh") == 0);
assert(strcmp(res1[1], "Nikhil Meherwal") == 0);
assert(strcmp(res1[2], "Akshat Garg") == 0);
assert(strcmp(res2[0], "Shaik Dawood") == 0);
assert(strcmp(res2[1], "Ayesha Begum") == 0);
assert(strcmp(res2[2], "Sanya Singh") == 0);
assert(strcmp(res3[0], "HarpreetKour") == 0);
assert(strcmp(res3[1], "Priyanka Agarwal") == 0);
assert(strcmp(res3[2], "MuskanSethi") == 0);
return 0;
}
| O1 | c | func0:
endbr64
test %ecx,%ecx
jle 11fd <func0+0x54>
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %rsi,%r13
mov %rdx,%rbp
lea -0x1(%rcx),%r14d
mov $0x0,%ebx
mov (%r12,%rbx,8),%rsi
mov 0x0(%rbp,%rbx,8),%rdi
callq 1080 <strcpy@plt>
mov 0x0(%r13,%rbx,8),%rsi
mov 0x0(%rbp,%rbx,8),%rdi
callq 10b0 <strcat@plt>
mov %rbx,%rax
add $0x1,%rbx
cmp %r14,%rax
jne 11cb <func0+0x22>
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
retq
| func0:
endbr64
test ecx, ecx
jle short locret_1219
push r14
push r13
push r12
push rbp
push rbx
mov r13, rdi
mov r14, rsi
mov rbp, rdx
mov r12d, ecx
mov ebx, 0
loc_11EA:
mov rsi, [r13+rbx*8+0]
mov rdi, [rbp+rbx*8+0]
call _strcpy
mov rsi, [r14+rbx*8]
mov rdi, [rbp+rbx*8+0]
call _strcat
add rbx, 1
cmp rbx, r12
jnz short loc_11EA
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
locret_1219:
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long v5; // r12
long long i; // rbx
long long result; // rax
if ( a4 > 0 )
{
v5 = (unsigned int)a4;
for ( i = 0LL; i != v5; ++i )
{
strcpy(*(_QWORD *)(a3 + 8 * i), *(_QWORD *)(a1 + 8 * i));
result = strcat(*(_QWORD *)(a3 + 8 * i), *(_QWORD *)(a2 + 8 * i));
}
}
return result;
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x00101219
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R13,RDI
MOV R14,RSI
MOV RBP,RDX
MOV R12D,ECX
MOV EBX,0x0
LAB_001011ea:
MOV RSI,qword ptr [R13 + RBX*0x8]
MOV RDI,qword ptr [RBP + RBX*0x8]
CALL 0x00101090
MOV RSI,qword ptr [R14 + RBX*0x8]
MOV RDI,qword ptr [RBP + RBX*0x8]
CALL 0x001010d0
ADD RBX,0x1
CMP RBX,R12
JNZ 0x001011ea
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101219:
RET | void func0(long param_1,long param_2,long param_3,uint param_4)
{
ulong uVar1;
if (0 < (int)param_4) {
uVar1 = 0;
do {
strcpy(*(char **)(param_3 + uVar1 * 8),*(char **)(param_1 + uVar1 * 8));
strcat(*(char **)(param_3 + uVar1 * 8),*(char **)(param_2 + uVar1 * 8));
uVar1 = uVar1 + 1;
} while (uVar1 != param_4);
return;
}
return;
} |
4,746 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| void func0(const char* test_tup1[], const char* test_tup2[], char* res[], int size) {
for (int i = 0; i < size; i++) {
strcpy(res[i], test_tup1[i]);
strcat(res[i], test_tup2[i]);
}
}
| int main() {
// Declare variables
const char* test_tup1_1[] = {"Manjeet", "Nikhil", "Akshat"};
const char* test_tup1_2[] = {" Singh", " Meherwal", " Garg"};
char* res1[3];
char res1_0[20], res1_1[20], res1_2[20];
res1[0] = res1_0; res1[1] = res1_1; res1[2] = res1_2;
const char* test_tup2_1[] = {"Shaik", "Ayesha", "Sanya"};
const char* test_tup2_2[] = {" Dawood", " Begum", " Singh"};
char* res2[3];
char res2_0[20], res2_1[20], res2_2[20];
res2[0] = res2_0; res2[1] = res2_1; res2[2] = res2_2;
const char* test_tup3_1[] = {"Harpreet", "Priyanka", "Muskan"};
const char* test_tup3_2[] = {"Kour", " Agarwal", "Sethi"};
char* res3[3];
char res3_0[20], res3_1[20], res3_2[20];
res3[0] = res3_0; res3[1] = res3_1; res3[2] = res3_2;
// Call the function
func0(test_tup1_1, test_tup1_2, res1, 3);
func0(test_tup2_1, test_tup2_2, res2, 3);
func0(test_tup3_1, test_tup3_2, res3, 3);
// Assertions
assert(strcmp(res1[0], "Manjeet Singh") == 0);
assert(strcmp(res1[1], "Nikhil Meherwal") == 0);
assert(strcmp(res1[2], "Akshat Garg") == 0);
assert(strcmp(res2[0], "Shaik Dawood") == 0);
assert(strcmp(res2[1], "Ayesha Begum") == 0);
assert(strcmp(res2[2], "Sanya Singh") == 0);
assert(strcmp(res3[0], "HarpreetKour") == 0);
assert(strcmp(res3[1], "Priyanka Agarwal") == 0);
assert(strcmp(res3[2], "MuskanSethi") == 0);
return 0;
}
| O2 | c | func0:
endbr64
test %ecx,%ecx
jle 1658 <func0+0x58>
push %r14
mov %rdi,%r14
push %r13
lea -0x1(%rcx),%r13d
push %r12
mov %rsi,%r12
push %rbp
mov %rdx,%rbp
push %rbx
xor %ebx,%ebx
mov (%r14,%rbx,8),%rsi
mov 0x0(%rbp,%rbx,8),%rdi
callq 1080 <strcpy@plt>
mov (%r12,%rbx,8),%rsi
mov 0x0(%rbp,%rbx,8),%rdi
callq 10b0 <strcat@plt>
mov %rbx,%rax
add $0x1,%rbx
cmp %rax,%r13
jne 1620 <func0+0x20>
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
retq
nopl 0x0(%rax)
| func0:
endbr64
test ecx, ecx
jle short locret_1630
push r14
mov r14, rdi
push r13
movsxd r13, ecx
push r12
mov r12, rsi
push rbp
mov rbp, rdx
push rbx
xor ebx, ebx
xchg ax, ax
loc_1600:
mov rsi, [r14+rbx*8]
mov rdi, [rbp+rbx*8+0]
call _strcpy
mov rsi, [r12+rbx*8]
mov rdi, [rbp+rbx*8+0]
add rbx, 1
call _strcat
cmp rbx, r13
jnz short loc_1600
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
locret_1630:
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long v5; // r13
long long i; // rbx
long long v9; // rsi
long long v10; // rdi
long long result; // rax
if ( a4 > 0 )
{
v5 = a4;
for ( i = 0LL; i != v5; ++i )
{
strcpy(*(_QWORD *)(a3 + 8 * i), *(_QWORD *)(a1 + 8 * i));
v9 = *(_QWORD *)(a2 + 8 * i);
v10 = *(_QWORD *)(a3 + 8 * i);
result = strcat(v10, v9);
}
}
return result;
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x00101630
PUSH R14
MOV R14,RDI
PUSH R13
MOVSXD R13,ECX
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDX
PUSH RBX
XOR EBX,EBX
NOP
LAB_00101600:
MOV RSI,qword ptr [R14 + RBX*0x8]
MOV RDI,qword ptr [RBP + RBX*0x8]
CALL 0x00101090
MOV RSI,qword ptr [R12 + RBX*0x8]
MOV RDI,qword ptr [RBP + RBX*0x8]
ADD RBX,0x1
CALL 0x001010d0
CMP RBX,R13
JNZ 0x00101600
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101630:
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
long lVar2;
long lVar3;
if (0 < param_4) {
lVar3 = 0;
do {
strcpy(*(char **)(param_3 + lVar3 * 8),*(char **)(param_1 + lVar3 * 8));
lVar1 = lVar3 * 8;
lVar2 = lVar3 * 8;
lVar3 = lVar3 + 1;
strcat(*(char **)(param_3 + lVar2),*(char **)(param_2 + lVar1));
} while (lVar3 != param_4);
return;
}
return;
} |
4,747 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| void func0(const char* test_tup1[], const char* test_tup2[], char* res[], int size) {
for (int i = 0; i < size; i++) {
strcpy(res[i], test_tup1[i]);
strcat(res[i], test_tup2[i]);
}
}
| int main() {
// Declare variables
const char* test_tup1_1[] = {"Manjeet", "Nikhil", "Akshat"};
const char* test_tup1_2[] = {" Singh", " Meherwal", " Garg"};
char* res1[3];
char res1_0[20], res1_1[20], res1_2[20];
res1[0] = res1_0; res1[1] = res1_1; res1[2] = res1_2;
const char* test_tup2_1[] = {"Shaik", "Ayesha", "Sanya"};
const char* test_tup2_2[] = {" Dawood", " Begum", " Singh"};
char* res2[3];
char res2_0[20], res2_1[20], res2_2[20];
res2[0] = res2_0; res2[1] = res2_1; res2[2] = res2_2;
const char* test_tup3_1[] = {"Harpreet", "Priyanka", "Muskan"};
const char* test_tup3_2[] = {"Kour", " Agarwal", "Sethi"};
char* res3[3];
char res3_0[20], res3_1[20], res3_2[20];
res3[0] = res3_0; res3[1] = res3_1; res3[2] = res3_2;
// Call the function
func0(test_tup1_1, test_tup1_2, res1, 3);
func0(test_tup2_1, test_tup2_2, res2, 3);
func0(test_tup3_1, test_tup3_2, res3, 3);
// Assertions
assert(strcmp(res1[0], "Manjeet Singh") == 0);
assert(strcmp(res1[1], "Nikhil Meherwal") == 0);
assert(strcmp(res1[2], "Akshat Garg") == 0);
assert(strcmp(res2[0], "Shaik Dawood") == 0);
assert(strcmp(res2[1], "Ayesha Begum") == 0);
assert(strcmp(res2[2], "Sanya Singh") == 0);
assert(strcmp(res3[0], "HarpreetKour") == 0);
assert(strcmp(res3[1], "Priyanka Agarwal") == 0);
assert(strcmp(res3[2], "MuskanSethi") == 0);
return 0;
}
| O3 | c | func0:
endbr64
test %ecx,%ecx
jle 1698 <func0+0x58>
push %r14
mov %rdi,%r14
push %r13
lea -0x1(%rcx),%r13d
push %r12
mov %rsi,%r12
push %rbp
mov %rdx,%rbp
push %rbx
xor %ebx,%ebx
mov (%r14,%rbx,8),%rsi
mov 0x0(%rbp,%rbx,8),%rdi
callq 1080 <strcpy@plt>
mov (%r12,%rbx,8),%rsi
mov 0x0(%rbp,%rbx,8),%rdi
callq 10b0 <strcat@plt>
mov %rbx,%rax
add $0x1,%rbx
cmp %rax,%r13
jne 1660 <func0+0x20>
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
retq
nopl 0x0(%rax)
| func0:
endbr64
test ecx, ecx
jle short locret_16D0
movsxd rcx, ecx
push r14
mov r14, rdi
push r13
mov r13, rsi
push r12
lea r12, ds:0[rcx*8]
push rbp
mov rbp, rdx
push rbx
xor ebx, ebx
nop word ptr [rax+rax+00000000h]
loc_16A0:
mov rsi, [r14+rbx]; src
mov rdi, [rbp+rbx+0]; dest
call _strcpy
mov rsi, [r13+rbx+0]; src
mov rdi, [rbp+rbx+0]; dest
add rbx, 8
call _strcat
cmp r12, rbx
jnz short loc_16A0
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
locret_16D0:
retn | char * func0(long long a1, long long a2, long long a3, int a4)
{
long long v6; // r12
long long v8; // rbx
const char *v9; // rsi
char *v10; // rdi
char *result; // rax
if ( a4 > 0 )
{
v6 = 8LL * a4;
v8 = 0LL;
do
{
strcpy(*(char **)(a3 + v8), *(const char **)(a1 + v8));
v9 = *(const char **)(a2 + v8);
v10 = *(char **)(a3 + v8);
v8 += 8LL;
result = strcat(v10, v9);
}
while ( v6 != v8 );
}
return result;
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x001016d0
MOVSXD RCX,ECX
PUSH R14
MOV R14,RDI
PUSH R13
MOV R13,RSI
PUSH R12
LEA R12,[RCX*0x8]
PUSH RBP
MOV RBP,RDX
PUSH RBX
XOR EBX,EBX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001016a0:
MOV RSI,qword ptr [R14 + RBX*0x1]
MOV RDI,qword ptr [RBP + RBX*0x1]
CALL 0x00101080
MOV RSI,qword ptr [R13 + RBX*0x1]
MOV RDI,qword ptr [RBP + RBX*0x1]
ADD RBX,0x8
CALL 0x001010b0
CMP R12,RBX
JNZ 0x001016a0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001016d0:
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
int8 *puVar1;
int8 *puVar2;
long lVar3;
if (0 < param_4) {
lVar3 = 0;
do {
strcpy(*(char **)(param_3 + lVar3),*(char **)(param_1 + lVar3));
puVar1 = (int8 *)(param_2 + lVar3);
puVar2 = (int8 *)(param_3 + lVar3);
lVar3 = lVar3 + 8;
strcat((char *)*puVar2,(char *)*puVar1);
} while ((long)param_4 * 8 - lVar3 != 0);
return;
}
return;
} |
4,748 | func0 | #include <math.h>
#include <assert.h>
| double func0(double radian) {
double degree = radian * (180 / M_PI);
return degree;
}
| int main() {
assert(func0(90) == 5156.620156177409);
assert(func0(60) == 3437.746770784939);
assert(func0(120) == 6875.493541569878);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf4d(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_2090
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return 57.29577951308232 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102090]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(double param_1)
{
return DAT_00102090 * param_1;
} |
4,749 | func0 | #include <math.h>
#include <assert.h>
| double func0(double radian) {
double degree = radian * (180 / M_PI);
return degree;
}
| int main() {
assert(func0(90) == 5156.620156177409);
assert(func0(60) == 3437.746770784939);
assert(func0(120) == 6875.493541569878);
return 0;
}
| O1 | c | func0:
endbr64
mulsd 0xed3(%rip),%xmm0
retq
| func0:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 57.29577951308232;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
4,750 | func0 | #include <math.h>
#include <assert.h>
| double func0(double radian) {
double degree = radian * (180 / M_PI);
return degree;
}
| int main() {
assert(func0(90) == 5156.620156177409);
assert(func0(60) == 3437.746770784939);
assert(func0(120) == 6875.493541569878);
return 0;
}
| O2 | c | func0:
endbr64
mulsd 0xebc(%rip),%xmm0
retq
nopl (%rax)
| func0:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 57.29577951308232;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
4,751 | func0 | #include <math.h>
#include <assert.h>
| double func0(double radian) {
double degree = radian * (180 / M_PI);
return degree;
}
| int main() {
assert(func0(90) == 5156.620156177409);
assert(func0(60) == 3437.746770784939);
assert(func0(120) == 6875.493541569878);
return 0;
}
| O3 | c | func0:
endbr64
mulsd 0xebc(%rip),%xmm0
retq
nopl (%rax)
| func0:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 57.29577951308232;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
4,752 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
int is_list;
union {
int single;
struct {
int count;
int value;
} list;
} data;
} Element;
typedef struct {
int *array;
int size;
} DecodedList;
DecodedList decode_list(Element *alist, int alist_size) {
// Estimate maximum possible size
int max_size = 0;
for(int i = 0; i < alist_size; i++) {
if(alist[i].is_list)
max_size += alist[i].data.list.count;
else
max_size += 1;
}
int *result = malloc(max_size * sizeof(int));
int index = 0;
for(int i = 0; i < alist_size; i++) {
if(alist[i].is_list) {
for(int j = 0; j < alist[i].data.list.count; j++) {
result[index++] = alist[i].data.list.value;
}
}
else {
result[index++] = alist[i].data.single;
}
}
DecodedList decoded;
decoded.array = result;
decoded.size = index;
return decoded;
}
| int func0(DecodedList a, int *b, int b_size) {
if(a.size != b_size)
return 0;
for(int i = 0; i < a.size; i++) {
if(a.array[i] != b[i])
return 0;
}
return 1;
}
| int main() {
// First test case
Element input1[] = {
{1, .data.list = {2, 1}},
{0, .data.single = 2},
{0, .data.single = 3},
{1, .data.list = {2,4}},
{0, .data.single =5},
{0, .data.single =1}
};
int expected1[] = {1,1,2,3,4,4,5,1};
DecodedList output1 = decode_list(input1, 6);
assert(func0(output1, expected1, 8));
free(output1.array);
// Second test case
Element input2[] = {
{0, .data.single = 'a'},
{0, .data.single = 'u'},
{0, .data.single = 't'},
{0, .data.single = 'o'},
{0, .data.single = 'm'},
{0, .data.single = 'a'},
{0, .data.single = 't'},
{0, .data.single = 'i'},
{0, .data.single = 'c'},
{0, .data.single = 'a'},
{1, .data.list = {2, 'l'}},
{0, .data.single = 'y'}
};
int expected2[] = {'a','u','t','o','m','a','t','i','c','a','l','l','y'};
DecodedList output2 = decode_list(input2, 12);
assert(func0(output2, expected2, 13));
free(output2.array);
// Third test case
Element input3[] = {
{0, .data.single = 'p'},
{0, .data.single = 'y'},
{0, .data.single = 't'},
{0, .data.single = 'h'},
{0, .data.single = 'o'},
{0, .data.single = 'n'}
};
int expected3[] = {'p','y','t','h','o','n'};
DecodedList output3 = decode_list(input3, 6);
assert(func0(output3, expected3, 6));
free(output3.array);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rsi,%rax
mov %rdi,%r8
mov %r8,%rsi
mov %r9,%rdi
mov %rax,%rdi
mov %rsi,-0x20(%rbp)
mov %rdi,-0x18(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x2c(%rbp)
mov -0x18(%rbp),%eax
cmp %eax,-0x2c(%rbp)
je 137a <func0+0x35>
mov $0x0,%eax
jmp 13c8 <func0+0x83>
movl $0x0,-0x4(%rbp)
jmp 13bb <func0+0x76>
mov -0x20(%rbp),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 13b7 <func0+0x72>
mov $0x0,%eax
jmp 13c8 <func0+0x83>
addl $0x1,-0x4(%rbp)
mov -0x18(%rbp),%eax
cmp %eax,-0x4(%rbp)
jl 1383 <func0+0x3e>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov rax, rdi
mov r8, rsi
mov rsi, rax
mov rdi, rdx
mov rdi, r8
mov [rbp+var_20], rsi
mov [rbp+var_18], rdi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov eax, dword ptr [rbp+var_18]
cmp [rbp+var_2C], eax
jz short loc_137A
mov eax, 0
jmp short loc_13C8
loc_137A:
mov [rbp+var_4], 0
jmp short loc_13BB
loc_1383:
mov rax, [rbp+var_20]
mov edx, [rbp+var_4]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_13B7
mov eax, 0
jmp short loc_13C8
loc_13B7:
add [rbp+var_4], 1
loc_13BB:
mov eax, dword ptr [rbp+var_18]
cmp [rbp+var_4], eax
jl short loc_1383
mov eax, 1
loc_13C8:
pop rbp
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+28h] [rbp-4h]
if ( a4 != a2 )
return 0LL;
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) != *(_DWORD *)(4LL * i + a3) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
MOV R8,RSI
MOV RSI,RAX
MOV RDI,RDX
MOV RDI,R8
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV EAX,dword ptr [RBP + -0x18]
CMP dword ptr [RBP + -0x2c],EAX
JZ 0x0010137a
MOV EAX,0x0
JMP 0x001013c8
LAB_0010137a:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001013bb
LAB_00101383:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x001013b7
MOV EAX,0x0
JMP 0x001013c8
LAB_001013b7:
ADD dword ptr [RBP + -0x4],0x1
LAB_001013bb:
MOV EAX,dword ptr [RBP + -0x18]
CMP dword ptr [RBP + -0x4],EAX
JL 0x00101383
MOV EAX,0x1
LAB_001013c8:
POP RBP
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
int8 uVar1;
int local_c;
if (param_4 == param_2) {
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) != *(int *)(param_3 + (long)local_c * 4)) {
return 0;
}
}
uVar1 = 1;
}
else {
uVar1 = 0;
}
return uVar1;
} |
4,753 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
int is_list;
union {
int single;
struct {
int count;
int value;
} list;
} data;
} Element;
typedef struct {
int *array;
int size;
} DecodedList;
DecodedList decode_list(Element *alist, int alist_size) {
// Estimate maximum possible size
int max_size = 0;
for(int i = 0; i < alist_size; i++) {
if(alist[i].is_list)
max_size += alist[i].data.list.count;
else
max_size += 1;
}
int *result = malloc(max_size * sizeof(int));
int index = 0;
for(int i = 0; i < alist_size; i++) {
if(alist[i].is_list) {
for(int j = 0; j < alist[i].data.list.count; j++) {
result[index++] = alist[i].data.list.value;
}
}
else {
result[index++] = alist[i].data.single;
}
}
DecodedList decoded;
decoded.array = result;
decoded.size = index;
return decoded;
}
| int func0(DecodedList a, int *b, int b_size) {
if(a.size != b_size)
return 0;
for(int i = 0; i < a.size; i++) {
if(a.array[i] != b[i])
return 0;
}
return 1;
}
| int main() {
// First test case
Element input1[] = {
{1, .data.list = {2, 1}},
{0, .data.single = 2},
{0, .data.single = 3},
{1, .data.list = {2,4}},
{0, .data.single =5},
{0, .data.single =1}
};
int expected1[] = {1,1,2,3,4,4,5,1};
DecodedList output1 = decode_list(input1, 6);
assert(func0(output1, expected1, 8));
free(output1.array);
// Second test case
Element input2[] = {
{0, .data.single = 'a'},
{0, .data.single = 'u'},
{0, .data.single = 't'},
{0, .data.single = 'o'},
{0, .data.single = 'm'},
{0, .data.single = 'a'},
{0, .data.single = 't'},
{0, .data.single = 'i'},
{0, .data.single = 'c'},
{0, .data.single = 'a'},
{1, .data.list = {2, 'l'}},
{0, .data.single = 'y'}
};
int expected2[] = {'a','u','t','o','m','a','t','i','c','a','l','l','y'};
DecodedList output2 = decode_list(input2, 12);
assert(func0(output2, expected2, 13));
free(output2.array);
// Third test case
Element input3[] = {
{0, .data.single = 'p'},
{0, .data.single = 'y'},
{0, .data.single = 't'},
{0, .data.single = 'h'},
{0, .data.single = 'o'},
{0, .data.single = 'n'}
};
int expected3[] = {'p','y','t','h','o','n'};
DecodedList output3 = decode_list(input3, 6);
assert(func0(output3, expected3, 6));
free(output3.array);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
cmp %esi,%ecx
jne 12a1 <func0+0x40>
test %esi,%esi
jle 1296 <func0+0x35>
lea -0x1(%rsi),%esi
mov $0x0,%eax
jmp 127f <func0+0x1e>
mov %rcx,%rax
mov (%rdx,%rax,4),%ecx
cmp %ecx,(%rdi,%rax,4)
jne 129c <func0+0x3b>
lea 0x1(%rax),%rcx
cmp %rsi,%rax
jne 127c <func0+0x1b>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
mov eax, 0
cmp ecx, esi
jnz short locret_12AA
test esi, esi
jle short loc_129F
lea esi, [rsi-1]
mov eax, 0
jmp short loc_1288
loc_1285:
mov rax, rcx
loc_1288:
mov ecx, [rdx+rax*4]
cmp [rdi+rax*4], ecx
jnz short loc_12A5
lea rcx, [rax+1]
cmp rax, rsi
jnz short loc_1285
mov eax, 1
retn
loc_129F:
mov eax, 1
retn
loc_12A5:
mov eax, 0
locret_12AA:
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
long long v5; // rsi
long long i; // rax
result = 0LL;
if ( a4 == a2 )
{
if ( a2 <= 0 )
{
return 1LL;
}
else
{
v5 = (unsigned int)(a2 - 1);
for ( i = 0LL; *(_DWORD *)(a1 + 4 * i) == *(_DWORD *)(a3 + 4 * i); ++i )
{
if ( i == v5 )
return 1LL;
}
return 0LL;
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x0
CMP ECX,ESI
JNZ 0x001012aa
TEST ESI,ESI
JLE 0x0010129f
LEA ESI,[RSI + -0x1]
MOV EAX,0x0
JMP 0x00101288
LAB_00101285:
MOV RAX,RCX
LAB_00101288:
MOV ECX,dword ptr [RDX + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JNZ 0x001012a5
LEA RCX,[RAX + 0x1]
CMP RAX,RSI
JNZ 0x00101285
MOV EAX,0x1
RET
LAB_0010129f:
MOV EAX,0x1
RET
LAB_001012a5:
MOV EAX,0x0
LAB_001012aa:
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
ulong uVar1;
bool bVar2;
if (param_4 == param_2) {
if (param_2 < 1) {
return 1;
}
uVar1 = 0;
while (*(int *)(param_1 + uVar1 * 4) == *(int *)(param_3 + uVar1 * 4)) {
bVar2 = uVar1 == param_2 - 1;
uVar1 = uVar1 + 1;
if (bVar2) {
return 1;
}
}
}
return 0;
} |
4,754 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
int is_list;
union {
int single;
struct {
int count;
int value;
} list;
} data;
} Element;
typedef struct {
int *array;
int size;
} DecodedList;
DecodedList decode_list(Element *alist, int alist_size) {
// Estimate maximum possible size
int max_size = 0;
for(int i = 0; i < alist_size; i++) {
if(alist[i].is_list)
max_size += alist[i].data.list.count;
else
max_size += 1;
}
int *result = malloc(max_size * sizeof(int));
int index = 0;
for(int i = 0; i < alist_size; i++) {
if(alist[i].is_list) {
for(int j = 0; j < alist[i].data.list.count; j++) {
result[index++] = alist[i].data.list.value;
}
}
else {
result[index++] = alist[i].data.single;
}
}
DecodedList decoded;
decoded.array = result;
decoded.size = index;
return decoded;
}
| int func0(DecodedList a, int *b, int b_size) {
if(a.size != b_size)
return 0;
for(int i = 0; i < a.size; i++) {
if(a.array[i] != b[i])
return 0;
}
return 1;
}
| int main() {
// First test case
Element input1[] = {
{1, .data.list = {2, 1}},
{0, .data.single = 2},
{0, .data.single = 3},
{1, .data.list = {2,4}},
{0, .data.single =5},
{0, .data.single =1}
};
int expected1[] = {1,1,2,3,4,4,5,1};
DecodedList output1 = decode_list(input1, 6);
assert(func0(output1, expected1, 8));
free(output1.array);
// Second test case
Element input2[] = {
{0, .data.single = 'a'},
{0, .data.single = 'u'},
{0, .data.single = 't'},
{0, .data.single = 'o'},
{0, .data.single = 'm'},
{0, .data.single = 'a'},
{0, .data.single = 't'},
{0, .data.single = 'i'},
{0, .data.single = 'c'},
{0, .data.single = 'a'},
{1, .data.list = {2, 'l'}},
{0, .data.single = 'y'}
};
int expected2[] = {'a','u','t','o','m','a','t','i','c','a','l','l','y'};
DecodedList output2 = decode_list(input2, 12);
assert(func0(output2, expected2, 13));
free(output2.array);
// Third test case
Element input3[] = {
{0, .data.single = 'p'},
{0, .data.single = 'y'},
{0, .data.single = 't'},
{0, .data.single = 'h'},
{0, .data.single = 'o'},
{0, .data.single = 'n'}
};
int expected3[] = {'p','y','t','h','o','n'};
DecodedList output3 = decode_list(input3, 6);
assert(func0(output3, expected3, 6));
free(output3.array);
return 0;
}
| O2 | c | func0:
endbr64
xor %eax,%eax
cmp %esi,%ecx
jne 166e <func0+0x2e>
test %ecx,%ecx
jle 1670 <func0+0x30>
lea -0x1(%rcx),%esi
xor %eax,%eax
jmp 1664 <func0+0x24>
nopl (%rax)
lea 0x1(%rax),%rcx
cmp %rsi,%rax
je 1670 <func0+0x30>
mov %rcx,%rax
mov (%rdx,%rax,4),%ecx
cmp %ecx,(%rdi,%rax,4)
je 1658 <func0+0x18>
xor %eax,%eax
retq
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
xor eax, eax
cmp ecx, esi
jnz short locret_165B
test ecx, ecx
jle short loc_1660
movsxd rcx, ecx
xor eax, eax
jmp short loc_1651
loc_1648:
add rax, 1
cmp rax, rcx
jz short loc_1660
loc_1651:
mov esi, [rdx+rax*4]
cmp [rdi+rax*4], esi
jz short loc_1648
xor eax, eax
locret_165B:
retn
loc_1660:
mov eax, 1
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
long long v5; // rax
result = 0LL;
if ( a4 == a2 )
{
if ( a4 <= 0 )
{
return 1LL;
}
else
{
v5 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v5) == *(_DWORD *)(a3 + 4 * v5) )
{
if ( ++v5 == a4 )
return 1LL;
}
return 0LL;
}
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP ECX,ESI
JNZ 0x0010165b
TEST ECX,ECX
JLE 0x00101660
MOVSXD RCX,ECX
XOR EAX,EAX
JMP 0x00101651
LAB_00101648:
ADD RAX,0x1
CMP RAX,RCX
JZ 0x00101660
LAB_00101651:
MOV ESI,dword ptr [RDX + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ESI
JZ 0x00101648
XOR EAX,EAX
LAB_0010165b:
RET
LAB_00101660:
MOV EAX,0x1
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
long lVar1;
if (param_4 != param_2) {
return 0;
}
if (0 < param_4) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1 * 4) != *(int *)(param_3 + lVar1 * 4)) {
return 0;
}
lVar1 = lVar1 + 1;
} while (lVar1 != param_4);
}
return 1;
} |
4,755 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
int is_list;
union {
int single;
struct {
int count;
int value;
} list;
} data;
} Element;
typedef struct {
int *array;
int size;
} DecodedList;
DecodedList decode_list(Element *alist, int alist_size) {
// Estimate maximum possible size
int max_size = 0;
for(int i = 0; i < alist_size; i++) {
if(alist[i].is_list)
max_size += alist[i].data.list.count;
else
max_size += 1;
}
int *result = malloc(max_size * sizeof(int));
int index = 0;
for(int i = 0; i < alist_size; i++) {
if(alist[i].is_list) {
for(int j = 0; j < alist[i].data.list.count; j++) {
result[index++] = alist[i].data.list.value;
}
}
else {
result[index++] = alist[i].data.single;
}
}
DecodedList decoded;
decoded.array = result;
decoded.size = index;
return decoded;
}
| int func0(DecodedList a, int *b, int b_size) {
if(a.size != b_size)
return 0;
for(int i = 0; i < a.size; i++) {
if(a.array[i] != b[i])
return 0;
}
return 1;
}
| int main() {
// First test case
Element input1[] = {
{1, .data.list = {2, 1}},
{0, .data.single = 2},
{0, .data.single = 3},
{1, .data.list = {2,4}},
{0, .data.single =5},
{0, .data.single =1}
};
int expected1[] = {1,1,2,3,4,4,5,1};
DecodedList output1 = decode_list(input1, 6);
assert(func0(output1, expected1, 8));
free(output1.array);
// Second test case
Element input2[] = {
{0, .data.single = 'a'},
{0, .data.single = 'u'},
{0, .data.single = 't'},
{0, .data.single = 'o'},
{0, .data.single = 'm'},
{0, .data.single = 'a'},
{0, .data.single = 't'},
{0, .data.single = 'i'},
{0, .data.single = 'c'},
{0, .data.single = 'a'},
{1, .data.list = {2, 'l'}},
{0, .data.single = 'y'}
};
int expected2[] = {'a','u','t','o','m','a','t','i','c','a','l','l','y'};
DecodedList output2 = decode_list(input2, 12);
assert(func0(output2, expected2, 13));
free(output2.array);
// Third test case
Element input3[] = {
{0, .data.single = 'p'},
{0, .data.single = 'y'},
{0, .data.single = 't'},
{0, .data.single = 'h'},
{0, .data.single = 'o'},
{0, .data.single = 'n'}
};
int expected3[] = {'p','y','t','h','o','n'};
DecodedList output3 = decode_list(input3, 6);
assert(func0(output3, expected3, 6));
free(output3.array);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
cmp %esi,%ecx
jne 170e <func0+0x2e>
test %ecx,%ecx
jle 1710 <func0+0x30>
lea -0x1(%rcx),%esi
xor %eax,%eax
jmp 1704 <func0+0x24>
nopl (%rax)
lea 0x1(%rax),%rcx
cmp %rsi,%rax
je 1710 <func0+0x30>
mov %rcx,%rax
mov (%rdx,%rax,4),%ecx
cmp %ecx,(%rdi,%rax,4)
je 16f8 <func0+0x18>
xor %eax,%eax
retq
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
xor eax, eax
cmp ecx, esi
jnz short locret_1633
test ecx, ecx
jle short loc_1638
movsxd rcx, ecx
xor eax, eax
shl rcx, 2
jmp short loc_1629
loc_1620:
add rax, 4
cmp rcx, rax
jz short loc_1638
loc_1629:
mov esi, [rdx+rax]
cmp [rdi+rax], esi
jz short loc_1620
xor eax, eax
locret_1633:
retn
loc_1638:
mov eax, 1
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
long long v5; // rax
long long v6; // rcx
result = 0LL;
if ( a4 == a2 )
{
if ( a4 <= 0 )
{
return 1LL;
}
else
{
v5 = 0LL;
v6 = 4LL * a4;
while ( *(_DWORD *)(a1 + v5) == *(_DWORD *)(a3 + v5) )
{
v5 += 4LL;
if ( v6 == v5 )
return 1LL;
}
return 0LL;
}
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP ECX,ESI
JNZ 0x00101633
TEST ECX,ECX
JLE 0x00101638
MOVSXD RCX,ECX
XOR EAX,EAX
SHL RCX,0x2
JMP 0x00101629
LAB_00101620:
ADD RAX,0x4
CMP RCX,RAX
JZ 0x00101638
LAB_00101629:
MOV ESI,dword ptr [RDX + RAX*0x1]
CMP dword ptr [RDI + RAX*0x1],ESI
JZ 0x00101620
XOR EAX,EAX
LAB_00101633:
RET
LAB_00101638:
MOV EAX,0x1
RET | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
long lVar1;
if (param_4 != param_2) {
return 0;
}
if (0 < param_4) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1) != *(int *)(param_3 + lVar1)) {
return 0;
}
lVar1 = lVar1 + 4;
} while ((long)param_4 * 4 != lVar1);
}
return 1;
} |
4,756 | func0 | #include <stdbool.h>
#include <assert.h>
| bool func0(int list1[], int size1, int list2[], int size2) {
bool exist = true;
for (int i = 0; i < size2; i++) {
bool found = false;
for (int j = 0; j < size1; j++) {
if (list2[i] == list1[j]) {
found = true;
break;
}
}
if (!found) {
exist = false;
break;
}
}
return exist;
}
| int main() {
int list1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
int list1_sub1[] = {12, 18, 23, 25, 45};
int list1_sub2[] = {7, 11, 19, 24, 28};
int list1_sub3[] = {1, 5, 8, 18, 15, 16};
int list2[] = {2, 3, 1, 4, 5, 6, 8};
int list2_sub1[] = {4, 5};
int list2_sub2[] = {6, 8};
int list3[] = {'a', 'b', 'e', 'c', 'd'};
int list3_sub[] = {'g'};
assert(func0(list1, 14, list1_sub1, 5) == false);
assert(func0(list1, 14, list1_sub2, 5) == false);
assert(func0(list1, 14, list1_sub3, 6) == false);
assert(func0(list2, 7, list2_sub1, 2) == true);
assert(func0(list2, 7, list2_sub2, 2) == true);
assert(func0(list3, 5, list3_sub, 1) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
movb $0x1,-0xa(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11f0 <func0+0x87>
movb $0x0,-0x9(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d3 <func0+0x6a>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11cf <func0+0x66>
movb $0x1,-0x9(%rbp)
jmp 11db <func0+0x72>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1199 <func0+0x30>
movzbl -0x9(%rbp),%eax
xor $0x1,%eax
test %al,%al
je 11ec <func0+0x83>
movb $0x0,-0xa(%rbp)
jmp 11f8 <func0+0x8f>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 118c <func0+0x23>
movzbl -0xa(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_A], 1
mov [rbp+var_8], 0
jmp short loc_11F0
loc_118C:
mov [rbp+var_9], 0
mov [rbp+var_4], 0
jmp short loc_11D3
loc_1199:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11CF
mov [rbp+var_9], 1
jmp short loc_11DB
loc_11CF:
add [rbp+var_4], 1
loc_11D3:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1199
loc_11DB:
movzx eax, [rbp+var_9]
xor eax, 1
test al, al
jz short loc_11EC
mov [rbp+var_A], 0
jmp short loc_11F8
loc_11EC:
add [rbp+var_8], 1
loc_11F0:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_20]
jl short loc_118C
loc_11F8:
movzx eax, [rbp+var_A]
pop rbp
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
unsigned __int8 v5; // [rsp+1Eh] [rbp-Ah]
char v6; // [rsp+1Fh] [rbp-9h]
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
v5 = 1;
for ( i = 0; i < a4; ++i )
{
v6 = 0;
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a3) == *(_DWORD *)(4LL * j + a1) )
{
v6 = 1;
break;
}
}
if ( v6 != 1 )
return 0;
}
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV byte ptr [RBP + -0xa],0x1
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011f0
LAB_0010118c:
MOV byte ptr [RBP + -0x9],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d3
LAB_00101199:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011cf
MOV byte ptr [RBP + -0x9],0x1
JMP 0x001011db
LAB_001011cf:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d3:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101199
LAB_001011db:
MOVZX EAX,byte ptr [RBP + -0x9]
XOR EAX,0x1
TEST AL,AL
JZ 0x001011ec
MOV byte ptr [RBP + -0xa],0x0
JMP 0x001011f8
LAB_001011ec:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011f0:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x0010118c
LAB_001011f8:
MOVZX EAX,byte ptr [RBP + -0xa]
POP RBP
RET | int func0(long param_1,int param_2,long param_3,int param_4)
{
bool bVar1;
int local_10;
int local_c;
local_10 = 0;
do {
if (param_4 <= local_10) {
return 1;
}
bVar1 = false;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_3 + (long)local_10 * 4) == *(int *)(param_1 + (long)local_c * 4)) {
bVar1 = true;
break;
}
}
if (!bVar1) {
return 0;
}
local_10 = local_10 + 1;
} while( true );
} |
4,757 | func0 | #include <stdbool.h>
#include <assert.h>
| bool func0(int list1[], int size1, int list2[], int size2) {
bool exist = true;
for (int i = 0; i < size2; i++) {
bool found = false;
for (int j = 0; j < size1; j++) {
if (list2[i] == list1[j]) {
found = true;
break;
}
}
if (!found) {
exist = false;
break;
}
}
return exist;
}
| int main() {
int list1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
int list1_sub1[] = {12, 18, 23, 25, 45};
int list1_sub2[] = {7, 11, 19, 24, 28};
int list1_sub3[] = {1, 5, 8, 18, 15, 16};
int list2[] = {2, 3, 1, 4, 5, 6, 8};
int list2_sub1[] = {4, 5};
int list2_sub2[] = {6, 8};
int list3[] = {'a', 'b', 'e', 'c', 'd'};
int list3_sub[] = {'g'};
assert(func0(list1, 14, list1_sub1, 5) == false);
assert(func0(list1, 14, list1_sub2, 5) == false);
assert(func0(list1, 14, list1_sub3, 6) == false);
assert(func0(list2, 7, list2_sub1, 2) == true);
assert(func0(list2, 7, list2_sub2, 2) == true);
assert(func0(list3, 5, list3_sub, 1) == false);
return 0;
}
| O1 | c | func0:
endbr64
test %ecx,%ecx
jle 1189 <func0+0x20>
mov %rdx,%r8
lea -0x1(%rcx),%eax
lea 0x4(%rdx,%rax,4),%r10
mov %rdi,%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
jmp 119e <func0+0x35>
mov $0x1,%eax
retq
mov $0x0,%eax
retq
add $0x4,%r8
cmp %r10,%r8
je 11bb <func0+0x52>
test %esi,%esi
jle 118f <func0+0x26>
mov (%r8),%edx
mov %r9,%rax
cmp (%rax),%edx
je 1195 <func0+0x2c>
add $0x4,%rax
cmp %rcx,%rax
jne 11a8 <func0+0x3f>
mov $0x0,%eax
retq
mov $0x1,%eax
retq
| func0:
endbr64
mov r8, rdi
test ecx, ecx
jle short loc_1189
mov rdi, rdx
lea eax, [rcx-1]
lea r9, [rdx+rax*4+4]
lea eax, [rsi-1]
lea rcx, [r8+rax*4+4]
jmp short loc_119E
loc_1189:
mov eax, 1
retn
loc_118F:
mov eax, 0
retn
loc_1195:
add rdi, 4
cmp rdi, r9
jz short loc_11BA
loc_119E:
test esi, esi
jle short loc_118F
mov edx, [rdi]
mov rax, r8
loc_11A7:
cmp edx, [rax]
jz short loc_1195
add rax, 4
cmp rax, rcx
jnz short loc_11A7
mov eax, 0
retn
loc_11BA:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v5; // rdi
_DWORD *v7; // rax
if ( a4 <= 0 )
return 1LL;
v5 = a3;
while ( 2 )
{
if ( a2 <= 0 )
return 0LL;
v7 = a1;
while ( *v5 != *v7 )
{
if ( ++v7 == &a1[a2 - 1 + 1] )
return 0LL;
}
if ( ++v5 != &a3[a4 - 1 + 1] )
continue;
break;
}
return 1LL;
} | func0:
ENDBR64
MOV R8,RDI
TEST ECX,ECX
JLE 0x00101189
MOV RDI,RDX
LEA EAX,[RCX + -0x1]
LEA R9,[RDX + RAX*0x4 + 0x4]
LEA EAX,[RSI + -0x1]
LEA RCX,[R8 + RAX*0x4 + 0x4]
JMP 0x0010119e
LAB_00101189:
MOV EAX,0x1
RET
LAB_0010118f:
MOV EAX,0x0
RET
LAB_00101195:
ADD RDI,0x4
CMP RDI,R9
JZ 0x001011ba
LAB_0010119e:
TEST ESI,ESI
JLE 0x0010118f
MOV EDX,dword ptr [RDI]
MOV RAX,R8
LAB_001011a7:
CMP EDX,dword ptr [RAX]
JZ 0x00101195
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011a7
MOV EAX,0x0
RET
LAB_001011ba:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (param_4 < 1) {
return 1;
}
piVar1 = param_3 + (ulong)(param_4 - 1) + 1;
do {
if (param_2 < 1) {
return 0;
}
piVar2 = param_1;
while (*param_3 != *piVar2) {
piVar2 = piVar2 + 1;
if (piVar2 == param_1 + (ulong)(param_2 - 1) + 1) {
return 0;
}
}
param_3 = param_3 + 1;
if (param_3 == piVar1) {
return 1;
}
} while( true );
} |
4,758 | func0 | #include <stdbool.h>
#include <assert.h>
| bool func0(int list1[], int size1, int list2[], int size2) {
bool exist = true;
for (int i = 0; i < size2; i++) {
bool found = false;
for (int j = 0; j < size1; j++) {
if (list2[i] == list1[j]) {
found = true;
break;
}
}
if (!found) {
exist = false;
break;
}
}
return exist;
}
| int main() {
int list1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
int list1_sub1[] = {12, 18, 23, 25, 45};
int list1_sub2[] = {7, 11, 19, 24, 28};
int list1_sub3[] = {1, 5, 8, 18, 15, 16};
int list2[] = {2, 3, 1, 4, 5, 6, 8};
int list2_sub1[] = {4, 5};
int list2_sub2[] = {6, 8};
int list3[] = {'a', 'b', 'e', 'c', 'd'};
int list3_sub[] = {'g'};
assert(func0(list1, 14, list1_sub1, 5) == false);
assert(func0(list1, 14, list1_sub2, 5) == false);
assert(func0(list1, 14, list1_sub3, 6) == false);
assert(func0(list2, 7, list2_sub1, 2) == true);
assert(func0(list2, 7, list2_sub2, 2) == true);
assert(func0(list3, 5, list3_sub, 1) == false);
return 0;
}
| O2 | c | func0:
endbr64
test %ecx,%ecx
jle 1566 <func0+0x46>
lea -0x1(%rcx),%eax
mov %rdx,%r8
lea 0x4(%rdx,%rax,4),%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
nopl 0x0(%rax,%rax,1)
test %esi,%esi
jle 1570 <func0+0x50>
mov (%r8),%edx
mov %rdi,%rax
jmp 1559 <func0+0x39>
nopl 0x0(%rax)
add $0x4,%rax
cmp %rcx,%rax
je 1570 <func0+0x50>
cmp (%rax),%edx
jne 1550 <func0+0x30>
add $0x4,%r8
cmp %r9,%r8
jne 1540 <func0+0x20>
mov $0x1,%eax
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov r8, rdi
test ecx, ecx
jle short loc_1506
lea eax, [rcx-1]
lea r9, [rdx+rax*4+4]
lea eax, [rsi-1]
lea rdi, [rdi+rax*4+4]
nop dword ptr [rax+rax+00h]
loc_14E0:
test esi, esi
jle short loc_1510
mov ecx, [rdx]
mov rax, r8
jmp short loc_14F9
loc_14F0:
add rax, 4
cmp rax, rdi
jz short loc_1510
loc_14F9:
cmp ecx, [rax]
jnz short loc_14F0
add rdx, 4
cmp rdx, r9
jnz short loc_14E0
loc_1506:
mov eax, 1
retn
loc_1510:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
long long v5; // r9
long long v6; // rdi
_DWORD *v7; // rax
if ( a4 <= 0 )
return 1LL;
v5 = (long long)&a3[a4 - 1 + 1];
v6 = (long long)&a1[a2 - 1 + 1];
while ( a2 > 0 )
{
v7 = a1;
while ( *a3 != *v7 )
{
if ( ++v7 == (_DWORD *)v6 )
return 0LL;
}
if ( ++a3 == (_DWORD *)v5 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV R8,RDI
TEST ECX,ECX
JLE 0x00101506
LEA EAX,[RCX + -0x1]
LEA R9,[RDX + RAX*0x4 + 0x4]
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001014e0:
TEST ESI,ESI
JLE 0x00101510
MOV ECX,dword ptr [RDX]
MOV RAX,R8
JMP 0x001014f9
LAB_001014f0:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x00101510
LAB_001014f9:
CMP ECX,dword ptr [RAX]
JNZ 0x001014f0
ADD RDX,0x4
CMP RDX,R9
JNZ 0x001014e0
LAB_00101506:
MOV EAX,0x1
RET
LAB_00101510:
XOR EAX,EAX
RET | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_4) {
piVar1 = param_3 + (ulong)(param_4 - 1) + 1;
do {
if (param_2 < 1) {
return 0;
}
piVar2 = param_1;
while (*param_3 != *piVar2) {
piVar2 = piVar2 + 1;
if (piVar2 == param_1 + (ulong)(param_2 - 1) + 1) {
return 0;
}
}
param_3 = param_3 + 1;
} while (param_3 != piVar1);
}
return 1;
} |
4,759 | func0 | #include <stdbool.h>
#include <assert.h>
| bool func0(int list1[], int size1, int list2[], int size2) {
bool exist = true;
for (int i = 0; i < size2; i++) {
bool found = false;
for (int j = 0; j < size1; j++) {
if (list2[i] == list1[j]) {
found = true;
break;
}
}
if (!found) {
exist = false;
break;
}
}
return exist;
}
| int main() {
int list1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
int list1_sub1[] = {12, 18, 23, 25, 45};
int list1_sub2[] = {7, 11, 19, 24, 28};
int list1_sub3[] = {1, 5, 8, 18, 15, 16};
int list2[] = {2, 3, 1, 4, 5, 6, 8};
int list2_sub1[] = {4, 5};
int list2_sub2[] = {6, 8};
int list3[] = {'a', 'b', 'e', 'c', 'd'};
int list3_sub[] = {'g'};
assert(func0(list1, 14, list1_sub1, 5) == false);
assert(func0(list1, 14, list1_sub2, 5) == false);
assert(func0(list1, 14, list1_sub3, 6) == false);
assert(func0(list2, 7, list2_sub1, 2) == true);
assert(func0(list2, 7, list2_sub2, 2) == true);
assert(func0(list3, 5, list3_sub, 1) == false);
return 0;
}
| O3 | c | func0:
endbr64
test %ecx,%ecx
jle 1186 <func0+0x46>
lea -0x1(%rcx),%eax
mov %rdx,%r8
lea 0x4(%rdx,%rax,4),%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
nopl 0x0(%rax,%rax,1)
test %esi,%esi
jle 1190 <func0+0x50>
mov (%r8),%edx
mov %rdi,%rax
jmp 1179 <func0+0x39>
nopl 0x0(%rax)
add $0x4,%rax
cmp %rcx,%rax
je 1190 <func0+0x50>
cmp (%rax),%edx
jne 1170 <func0+0x30>
add $0x4,%r8
cmp %r9,%r8
jne 1160 <func0+0x20>
mov $0x1,%eax
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov r8, rdi
test ecx, ecx
jle short loc_1186
movsxd rcx, ecx
movsxd rax, esi
lea r9, [rdx+rcx*4]
lea rdi, [rdi+rax*4]
test esi, esi
jle short loc_1190
nop dword ptr [rax]
loc_1160:
mov ecx, [rdx]
mov rax, r8
jmp short loc_1179
loc_1170:
add rax, 4
cmp rdi, rax
jz short loc_1190
loc_1179:
cmp ecx, [rax]
jnz short loc_1170
add rdx, 4
cmp rdx, r9
jnz short loc_1160
loc_1186:
mov eax, 1
retn
loc_1190:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v5; // r9
_DWORD *v6; // rdi
_DWORD *v7; // rax
if ( a4 <= 0 )
return 1LL;
v5 = &a3[a4];
v6 = &a1[a2];
if ( a2 > 0 )
{
do
{
v7 = a1;
while ( *a3 != *v7 )
{
if ( v6 == ++v7 )
return 0LL;
}
++a3;
}
while ( a3 != v5 );
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV R8,RDI
TEST ECX,ECX
JLE 0x00101186
MOVSXD RCX,ECX
MOVSXD RAX,ESI
LEA R9,[RDX + RCX*0x4]
LEA RDI,[RDI + RAX*0x4]
TEST ESI,ESI
JLE 0x00101190
NOP dword ptr [RAX]
LAB_00101160:
MOV ECX,dword ptr [RDX]
MOV RAX,R8
JMP 0x00101179
LAB_00101170:
ADD RAX,0x4
CMP RDI,RAX
JZ 0x00101190
LAB_00101179:
CMP ECX,dword ptr [RAX]
JNZ 0x00101170
ADD RDX,0x4
CMP RDX,R9
JNZ 0x00101160
LAB_00101186:
MOV EAX,0x1
RET
LAB_00101190:
XOR EAX,EAX
RET | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_4) {
piVar1 = param_3 + param_4;
if (param_2 < 1) {
return 0;
}
do {
piVar2 = param_1;
while (*param_3 != *piVar2) {
piVar2 = piVar2 + 1;
if (param_1 + param_2 == piVar2) {
return 0;
}
}
param_3 = param_3 + 1;
} while (param_3 != piVar1);
}
return 1;
} |
4,760 | func0 |
#include <stdio.h>
#include <assert.h>
| char func0(char* str) {
int h[256] = {0}; // Assuming ASCII character set
for (int i = 0; str[i] != '\0'; i++) {
if (h[(int)str[i]] == 1)
return str[i];
else
h[(int)str[i]]++;
}
return '\0';
}
| int main() {
assert(func0("Google") == 'o');
assert(func0("data") == 'a');
assert(func0("python") == '\0');
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x430,%rsp
mov %rdi,-0x428(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x410(%rbp),%rdx
mov $0x0,%eax
mov $0x80,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0x414(%rbp)
jmp 1226 <func0+0xbd>
mov -0x414(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
cltq
mov -0x410(%rbp,%rax,4),%eax
cmp $0x1,%eax
jne 11f0 <func0+0x87>
mov -0x414(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
jmp 1249 <func0+0xe0>
mov -0x414(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
movslq %eax,%rdx
mov -0x410(%rbp,%rdx,4),%edx
add $0x1,%edx
cltq
mov %edx,-0x410(%rbp,%rax,4)
addl $0x1,-0x414(%rbp)
mov -0x414(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11b1 <func0+0x48>
mov $0x0,%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 125d <func0+0xf4>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 430h
mov [rbp+var_428], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_410]
mov eax, 0
mov ecx, 80h
mov rdi, rdx
rep stosq
mov [rbp+var_414], 0
jmp short loc_1226
loc_11B1:
mov eax, [rbp+var_414]
movsxd rdx, eax
mov rax, [rbp+var_428]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
cdqe
mov eax, [rbp+rax*4+var_410]
cmp eax, 1
jnz short loc_11F0
mov eax, [rbp+var_414]
movsxd rdx, eax
mov rax, [rbp+var_428]
add rax, rdx
movzx eax, byte ptr [rax]
jmp short loc_1249
loc_11F0:
mov eax, [rbp+var_414]
movsxd rdx, eax
mov rax, [rbp+var_428]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
movsxd rdx, eax
mov edx, [rbp+rdx*4+var_410]
add edx, 1
cdqe
mov [rbp+rax*4+var_410], edx
add [rbp+var_414], 1
loc_1226:
mov eax, [rbp+var_414]
movsxd rdx, eax
mov rax, [rbp+var_428]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_11B1
mov eax, 0
loc_1249:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_125D
call ___stack_chk_fail
locret_125D:
leave
retn | long long func0(long long a1)
{
int i; // [rsp+1Ch] [rbp-414h]
_DWORD v3[258]; // [rsp+20h] [rbp-410h] BYREF
unsigned long long v4; // [rsp+428h] [rbp-8h]
v4 = __readfsqword(0x28u);
memset(v3, 0, 0x400uLL);
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( v3[*(char *)(i + a1)] == 1 )
return *(unsigned __int8 *)(i + a1);
++v3[*(char *)(i + a1)];
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x430
MOV qword ptr [RBP + -0x428],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0x410]
MOV EAX,0x0
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x414],0x0
JMP 0x00101226
LAB_001011b1:
MOV EAX,dword ptr [RBP + -0x414]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x410]
CMP EAX,0x1
JNZ 0x001011f0
MOV EAX,dword ptr [RBP + -0x414]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
JMP 0x00101249
LAB_001011f0:
MOV EAX,dword ptr [RBP + -0x414]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
MOVSXD RDX,EAX
MOV EDX,dword ptr [RBP + RDX*0x4 + -0x410]
ADD EDX,0x1
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x410],EDX
ADD dword ptr [RBP + -0x414],0x1
LAB_00101226:
MOV EAX,dword ptr [RBP + -0x414]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011b1
MOV EAX,0x0
LAB_00101249:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010125d
CALL 0x00101060
LAB_0010125d:
LEAVE
RET | int func0(long param_1)
{
int uVar1;
long lVar2;
int *piVar3;
long in_FS_OFFSET;
int local_41c;
int local_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar3 = local_418;
for (lVar2 = 0x80; lVar2 != 0; lVar2 = lVar2 + -1) {
piVar3[0] = 0;
piVar3[1] = 0;
piVar3 = piVar3 + 2;
}
local_41c = 0;
do {
if (*(char *)(param_1 + local_41c) == '\0') {
uVar1 = 0;
LAB_00101249:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar1;
}
if (local_418[(int)*(char *)(param_1 + local_41c)] == 1) {
uVar1 = *(int *)(param_1 + local_41c);
goto LAB_00101249;
}
local_418[(int)*(char *)(param_1 + local_41c)] =
local_418[(int)*(char *)(param_1 + local_41c)] + 1;
local_41c = local_41c + 1;
} while( true );
} |
4,761 | func0 |
#include <stdio.h>
#include <assert.h>
| char func0(char* str) {
int h[256] = {0}; // Assuming ASCII character set
for (int i = 0; str[i] != '\0'; i++) {
if (h[(int)str[i]] == 1)
return str[i];
else
h[(int)str[i]]++;
}
return '\0';
}
| int main() {
assert(func0("Google") == 'o');
assert(func0("data") == 'a');
assert(func0("python") == '\0');
return 0;
}
| O1 | c | func0:
endbr64
sub $0x418,%rsp
mov %rdi,%rsi
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x80,%ecx
rep stos %rax,%es:(%rdi)
movzbl (%rsi),%edx
test %dl,%dl
je 11c4 <func0+0x5b>
lea 0x1(%rsi),%rdi
movsbl %dl,%ecx
movsbq %dl,%rax
mov (%rsp,%rax,4),%eax
cmp $0x1,%eax
je 11c4 <func0+0x5b>
movslq %ecx,%rcx
add $0x1,%eax
mov %eax,(%rsp,%rcx,4)
add $0x1,%rdi
movzbl -0x1(%rdi),%edx
test %dl,%dl
jne 11a0 <func0+0x37>
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 11e1 <func0+0x78>
mov %edx,%eax
add $0x418,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
sub rsp, 418h
mov rsi, rdi
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 80h
rep stosq
movzx edx, byte ptr [rsi]
test dl, dl
jz short loc_11C4
lea rdi, [rsi+1]
loc_11A0:
movsx ecx, dl
movsx rax, dl
mov eax, [rsp+rax*4+418h+var_418]
cmp eax, 1
jz short loc_11C4
movsxd rcx, ecx
add eax, 1
mov [rsp+rcx*4+418h+var_418], eax
add rdi, 1
movzx edx, byte ptr [rdi-1]
test dl, dl
jnz short loc_11A0
loc_11C4:
mov rax, [rsp+418h+var_10]
sub rax, fs:28h
jnz short loc_11E1
mov eax, edx
add rsp, 418h
retn
loc_11E1:
call ___stack_chk_fail | long long func0(unsigned __int8 *a1)
{
unsigned int v1; // edx
unsigned __int8 *v2; // rdi
int v3; // eax
_DWORD v5[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v6; // [rsp+408h] [rbp-10h]
v6 = __readfsqword(0x28u);
memset(v5, 0, 0x400uLL);
v1 = *a1;
if ( (_BYTE)v1 )
{
v2 = a1 + 1;
do
{
v3 = v5[(char)v1];
if ( v3 == 1 )
break;
v5[(char)v1] = v3 + 1;
v1 = *v2++;
}
while ( (_BYTE)v1 );
}
return v1;
} | func0:
ENDBR64
SUB RSP,0x418
MOV RSI,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x80
STOSQ.REP RDI
MOVZX EDX,byte ptr [RSI]
TEST DL,DL
JZ 0x001011c4
LEA RDI,[RSI + 0x1]
LAB_001011a0:
MOVSX ECX,DL
MOVSX RAX,DL
MOV EAX,dword ptr [RSP + RAX*0x4]
CMP EAX,0x1
JZ 0x001011c4
MOVSXD RCX,ECX
ADD EAX,0x1
MOV dword ptr [RSP + RCX*0x4],EAX
ADD RDI,0x1
MOVZX EDX,byte ptr [RDI + -0x1]
TEST DL,DL
JNZ 0x001011a0
LAB_001011c4:
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001011e1
MOV EAX,EDX
ADD RSP,0x418
RET
LAB_001011e1:
CALL 0x00101060 | char func0(char *param_1)
{
long lVar1;
char cVar2;
int *piVar3;
char *pcVar4;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar3 = aiStack_418;
for (lVar1 = 0x80; lVar1 != 0; lVar1 = lVar1 + -1) {
*(int8 *)piVar3 = 0;
piVar3 = (int *)((long)piVar3 + 8);
}
cVar2 = *param_1;
if (cVar2 != '\0') {
pcVar4 = param_1 + 1;
do {
if (aiStack_418[cVar2] == 1) break;
aiStack_418[(int)cVar2] = aiStack_418[cVar2] + 1;
cVar2 = *pcVar4;
pcVar4 = pcVar4 + 1;
} while (cVar2 != '\0');
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return cVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,762 | func0 |
#include <stdio.h>
#include <assert.h>
| char func0(char* str) {
int h[256] = {0}; // Assuming ASCII character set
for (int i = 0; str[i] != '\0'; i++) {
if (h[(int)str[i]] == 1)
return str[i];
else
h[(int)str[i]]++;
}
return '\0';
}
| int main() {
assert(func0("Google") == 'o');
assert(func0("data") == 'a');
assert(func0("python") == '\0');
return 0;
}
| O2 | c | func0:
endbr64
sub $0x418,%rsp
mov %rdi,%rdx
mov $0x80,%ecx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
movzbl (%rdx),%r8d
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
test %r8b,%r8b
je 1290 <func0+0x80>
lea 0x1(%rdx),%rdi
jmp 1263 <func0+0x53>
nopl 0x0(%rax,%rax,1)
movzbl (%rdi),%r8d
add $0x1,%eax
add $0x1,%rdi
mov %eax,(%rsp,%rdx,4)
test %r8b,%r8b
je 1290 <func0+0x80>
movsbq %r8b,%rdx
mov (%rsp,%rdx,4),%eax
cmp $0x1,%eax
jne 1250 <func0+0x40>
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 1295 <func0+0x85>
mov %r8d,%eax
add $0x418,%rsp
retq
nopl (%rax)
xor %r8d,%r8d
jmp 126f <func0+0x5f>
callq 1060 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
sub rsp, 418h
mov rdx, rdi
mov ecx, 80h
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
movzx r8d, byte ptr [rdx]
mov rdi, rsp
rep stosq
test r8b, r8b
jz short loc_1290
lea rdi, [rdx+1]
jmp short loc_1263
loc_1250:
movzx r8d, byte ptr [rdi]
add eax, 1
add rdi, 1
mov [rsp+rdx*4+418h+var_418], eax
test r8b, r8b
jz short loc_1290
loc_1263:
movsx rdx, r8b
mov eax, [rsp+rdx*4+418h+var_418]
cmp eax, 1
jnz short loc_1250
loc_126F:
mov rax, [rsp+418h+var_10]
sub rax, fs:28h
jnz short loc_1295
mov eax, r8d
add rsp, 418h
retn
loc_1290:
xor r8d, r8d
jmp short loc_126F
loc_1295:
call ___stack_chk_fail | long long func0(unsigned __int8 *a1)
{
unsigned int v1; // r8d
unsigned __int8 *v2; // rdi
long long v3; // rdx
int v4; // eax
_DWORD v6[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v7; // [rsp+408h] [rbp-10h]
v7 = __readfsqword(0x28u);
v1 = *a1;
memset(v6, 0, 0x400uLL);
if ( (_BYTE)v1 )
{
v2 = a1 + 1;
while ( 1 )
{
v3 = (char)v1;
v4 = v6[(char)v1];
if ( v4 == 1 )
break;
v1 = *v2++;
v6[v3] = v4 + 1;
if ( !(_BYTE)v1 )
return 0;
}
}
else
{
return 0;
}
return v1;
} | func0:
ENDBR64
SUB RSP,0x418
MOV RDX,RDI
MOV ECX,0x80
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOVZX R8D,byte ptr [RDX]
MOV RDI,RSP
STOSQ.REP RDI
TEST R8B,R8B
JZ 0x00101290
LEA RDI,[RDX + 0x1]
JMP 0x00101263
LAB_00101250:
MOVZX R8D,byte ptr [RDI]
ADD EAX,0x1
ADD RDI,0x1
MOV dword ptr [RSP + RDX*0x4],EAX
TEST R8B,R8B
JZ 0x00101290
LAB_00101263:
MOVSX RDX,R8B
MOV EAX,dword ptr [RSP + RDX*0x4]
CMP EAX,0x1
JNZ 0x00101250
LAB_0010126f:
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101295
MOV EAX,R8D
ADD RSP,0x418
RET
LAB_00101290:
XOR R8D,R8D
JMP 0x0010126f
LAB_00101295:
CALL 0x00101060 | char func0(char *param_1)
{
char cVar1;
long lVar2;
int *piVar3;
char cVar4;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
cVar4 = *param_1;
piVar3 = aiStack_418;
for (lVar2 = 0x80; lVar2 != 0; lVar2 = lVar2 + -1) {
*(int8 *)piVar3 = 0;
piVar3 = (int *)((long)piVar3 + 8);
}
if (cVar4 != '\0') {
param_1 = param_1 + 1;
do {
if (aiStack_418[cVar4] == 1) goto LAB_0010126f;
cVar1 = *param_1;
param_1 = param_1 + 1;
aiStack_418[cVar4] = aiStack_418[cVar4] + 1;
cVar4 = cVar1;
} while (cVar1 != '\0');
}
cVar4 = '\0';
LAB_0010126f:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return cVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,763 | func0 |
#include <stdio.h>
#include <assert.h>
| char func0(char* str) {
int h[256] = {0}; // Assuming ASCII character set
for (int i = 0; str[i] != '\0'; i++) {
if (h[(int)str[i]] == 1)
return str[i];
else
h[(int)str[i]]++;
}
return '\0';
}
| int main() {
assert(func0("Google") == 'o');
assert(func0("data") == 'a');
assert(func0("python") == '\0');
return 0;
}
| O3 | c | func0:
endbr64
sub $0x418,%rsp
mov %rdi,%rdx
mov $0x80,%ecx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
movzbl (%rdx),%r8d
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
test %r8b,%r8b
je 1290 <func0+0x80>
lea 0x1(%rdx),%rdi
jmp 1263 <func0+0x53>
nopl 0x0(%rax,%rax,1)
movzbl (%rdi),%r8d
add $0x1,%eax
add $0x1,%rdi
mov %eax,(%rsp,%rdx,4)
test %r8b,%r8b
je 1290 <func0+0x80>
movsbq %r8b,%rdx
mov (%rsp,%rdx,4),%eax
cmp $0x1,%eax
jne 1250 <func0+0x40>
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 1295 <func0+0x85>
mov %r8d,%eax
add $0x418,%rsp
retq
nopl (%rax)
xor %r8d,%r8d
jmp 126f <func0+0x5f>
callq 1060 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
sub rsp, 418h
mov rdx, rdi
mov ecx, 80h
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
movzx ecx, byte ptr [rdx]
test cl, cl
jz short loc_1290
lea rdi, [rdx+1]
jmp short loc_1261
loc_1250:
movzx ecx, byte ptr [rdi]
add eax, 1
add rdi, 1
mov [rsp+rdx*4+418h+var_418], eax
test cl, cl
jz short loc_1290
loc_1261:
movsx rdx, cl
mov eax, [rsp+rdx*4+418h+var_418]
cmp eax, 1
jnz short loc_1250
loc_126D:
mov rax, [rsp+418h+var_10]
sub rax, fs:28h
jnz short loc_1294
mov eax, ecx
add rsp, 418h
retn
loc_1290:
xor ecx, ecx
jmp short loc_126D
loc_1294:
call ___stack_chk_fail | long long func0(unsigned __int8 *a1)
{
unsigned int v1; // ecx
unsigned __int8 *v2; // rdi
long long v3; // rdx
int v4; // eax
_DWORD v6[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v7; // [rsp+408h] [rbp-10h]
v7 = __readfsqword(0x28u);
memset(v6, 0, 0x400uLL);
v1 = *a1;
if ( (_BYTE)v1 )
{
v2 = a1 + 1;
while ( 1 )
{
v3 = (char)v1;
v4 = v6[(char)v1];
if ( v4 == 1 )
break;
v1 = *v2++;
v6[v3] = v4 + 1;
if ( !(_BYTE)v1 )
return 0;
}
}
else
{
return 0;
}
return v1;
} | func0:
ENDBR64
SUB RSP,0x418
MOV RDX,RDI
MOV ECX,0x80
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOVZX ECX,byte ptr [RDX]
TEST CL,CL
JZ 0x00101290
LEA RDI,[RDX + 0x1]
JMP 0x00101261
LAB_00101250:
MOVZX ECX,byte ptr [RDI]
ADD EAX,0x1
ADD RDI,0x1
MOV dword ptr [RSP + RDX*0x4],EAX
TEST CL,CL
JZ 0x00101290
LAB_00101261:
MOVSX RDX,CL
MOV EAX,dword ptr [RSP + RDX*0x4]
CMP EAX,0x1
JNZ 0x00101250
LAB_0010126d:
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101294
MOV EAX,ECX
ADD RSP,0x418
RET
LAB_00101290:
XOR ECX,ECX
JMP 0x0010126d
LAB_00101294:
CALL 0x00101060 | char func0(char *param_1)
{
char cVar1;
char cVar2;
long lVar3;
int *piVar4;
char *pcVar5;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar4 = aiStack_418;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)piVar4 = 0;
piVar4 = (int *)((long)piVar4 + 8);
}
if (*param_1 != '\0') {
pcVar5 = param_1 + 1;
cVar2 = *param_1;
do {
if (aiStack_418[cVar2] == 1) goto LAB_0010126d;
cVar1 = *pcVar5;
pcVar5 = pcVar5 + 1;
aiStack_418[cVar2] = aiStack_418[cVar2] + 1;
cVar2 = cVar1;
} while (cVar1 != '\0');
}
cVar2 = '\0';
LAB_0010126d:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return cVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,764 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int A, int B) {
int temp;
if (A > B) {
temp = A;
A = B;
B = temp;
}
int gcd(int x, int y) {
int t;
while (y != 0) {
t = y;
y = x % y;
x = t;
}
return x;
}
B = B / gcd(A, B);
return B - 1;
}
| int main() {
assert(func0(2, 4) == 1);
assert(func0(4, 10) == 4);
assert(func0(1, 4) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov %esi,-0x28(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x10(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x24(%rbp),%eax
cmp -0x28(%rbp),%eax
jle 11dd <func0+0x43>
mov -0x24(%rbp),%eax
mov %eax,-0x14(%rbp)
mov -0x28(%rbp),%eax
mov %eax,-0x24(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x28(%rbp)
mov -0x28(%rbp),%edx
mov -0x24(%rbp),%eax
lea -0x10(%rbp),%rcx
mov %rcx,%r10
mov %edx,%esi
mov %eax,%edi
callq 1169 <gcd.2851>
mov %eax,%esi
mov -0x28(%rbp),%eax
cltd
idiv %esi
mov %eax,-0x28(%rbp)
mov -0x28(%rbp),%eax
sub $0x1,%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1218 <func0+0x7e>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_28], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+arg_0]
mov [rbp+var_10], rax
mov eax, [rbp+var_24]
cmp eax, [rbp+var_28]
jle short loc_11DD
mov eax, [rbp+var_24]
mov [rbp+var_14], eax
mov eax, [rbp+var_28]
mov [rbp+var_24], eax
mov eax, [rbp+var_14]
mov [rbp+var_28], eax
loc_11DD:
mov edx, [rbp+var_28]
mov eax, [rbp+var_24]
lea rcx, [rbp+var_10]
mov r10, rcx
mov esi, edx
mov edi, eax
call gcd_0
mov ecx, eax
mov eax, [rbp+var_28]
cdq
idiv ecx
mov [rbp+var_28], eax
mov eax, [rbp+var_28]
sub eax, 1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1218
call ___stack_chk_fail
locret_1218:
leave
retn | long long func0(signed int a1, signed int a2)
{
unsigned int v3; // [rsp+8h] [rbp-28h]
unsigned int v4; // [rsp+Ch] [rbp-24h]
v4 = a1;
v3 = a2;
if ( a1 > a2 )
{
v4 = a2;
v3 = a1;
}
return (unsigned int)((int)v3 / (int)gcd_0(v4, v3) - 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x28],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x28]
JLE 0x001011dd
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x28],EAX
LAB_001011dd:
MOV EDX,dword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x24]
LEA RCX,[RBP + -0x10]
MOV R10,RCX
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101169
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x28]
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x28]
SUB EAX,0x1
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101218
CALL 0x00101060
LAB_00101218:
LEAVE
RET | int func0(int param_1,int param_2)
{
int iVar1;
long in_FS_OFFSET;
int local_30;
int local_2c;
int *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = &stack0x00000008;
local_30 = param_2;
local_2c = param_1;
if (param_2 < param_1) {
local_30 = param_1;
local_2c = param_2;
}
iVar1 = gcd_0(local_2c,local_30,local_30,&local_18);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_30 / iVar1 + -1;
} |
4,765 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int A, int B) {
int temp;
if (A > B) {
temp = A;
A = B;
B = temp;
}
int gcd(int x, int y) {
int t;
while (y != 0) {
t = y;
y = x % y;
x = t;
}
return x;
}
B = B / gcd(A, B);
return B - 1;
}
| int main() {
assert(func0(2, 4) == 1);
assert(func0(4, 10) == 4);
assert(func0(1, 4) == 3);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
cmp %esi,%edi
jle 1157 <func0+0xe>
mov %esi,%eax
mov %edi,%esi
test %esi,%esi
je 1173 <func0+0x2a>
mov %esi,%ecx
mov %ecx,%edi
cltd
idiv %ecx
mov %edx,%ecx
mov %edi,%eax
test %edx,%edx
jne 115d <func0+0x14>
mov %esi,%eax
cltd
idiv %edi
sub $0x1,%eax
retq
mov %eax,%edi
jmp 116a <func0+0x21>
| func0:
endbr64
mov eax, edi
cmp edi, esi
jle short loc_1157
mov eax, esi
mov esi, edi
loc_1157:
test esi, esi
jz short loc_1173
mov ecx, esi
loc_115D:
mov edi, ecx
cdq
idiv ecx
mov ecx, edx
mov eax, edi
test edx, edx
jnz short loc_115D
loc_116A:
mov eax, esi
cdq
idiv edi
sub eax, 1
retn
loc_1173:
mov edi, eax
jmp short loc_116A | long long func0(int a1, int a2)
{
int v2; // eax
int v3; // ecx
int v4; // edi
v2 = a1;
if ( a1 > a2 )
{
v2 = a2;
a2 = a1;
}
if ( a2 )
{
v3 = a2;
do
{
v4 = v3;
v3 = v2 % v3;
v2 = v4;
}
while ( v3 );
}
else
{
v4 = v2;
}
return (unsigned int)(a2 / v4 - 1);
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,ESI
JLE 0x00101157
MOV EAX,ESI
MOV ESI,EDI
LAB_00101157:
TEST ESI,ESI
JZ 0x00101173
MOV ECX,ESI
LAB_0010115d:
MOV EDI,ECX
CDQ
IDIV ECX
MOV ECX,EDX
MOV EAX,EDI
TEST EDX,EDX
JNZ 0x0010115d
LAB_0010116a:
MOV EAX,ESI
CDQ
IDIV EDI
SUB EAX,0x1
RET
LAB_00101173:
MOV EDI,EAX
JMP 0x0010116a | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
iVar1 = param_1;
iVar3 = param_2;
if (param_2 < param_1) {
iVar1 = param_2;
param_2 = param_1;
iVar3 = param_1;
}
while (param_2 != 0) {
iVar2 = iVar1 % param_2;
iVar1 = param_2;
param_2 = iVar2;
}
return iVar3 / iVar1 + -1;
} |
4,766 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int A, int B) {
int temp;
if (A > B) {
temp = A;
A = B;
B = temp;
}
int gcd(int x, int y) {
int t;
while (y != 0) {
t = y;
y = x % y;
x = t;
}
return x;
}
B = B / gcd(A, B);
return B - 1;
}
| int main() {
assert(func0(2, 4) == 1);
assert(func0(4, 10) == 4);
assert(func0(1, 4) == 3);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
cmp %esi,%edi
jle 124e <func0+0xe>
mov %esi,%eax
mov %edi,%esi
test %esi,%esi
je 1270 <func0+0x30>
mov %esi,%edx
nopl 0x0(%rax)
mov %edx,%ecx
cltd
idiv %ecx
mov %ecx,%eax
test %edx,%edx
jne 1258 <func0+0x18>
mov %esi,%eax
cltd
idiv %ecx
sub $0x1,%eax
retq
nopl 0x0(%rax)
mov %eax,%ecx
mov %esi,%eax
cltd
idiv %ecx
sub $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
cmp edi, esi
jle short loc_124E
mov eax, esi
mov esi, edi
loc_124E:
test esi, esi
jz short loc_1270
mov edx, esi
nop dword ptr [rax+00h]
loc_1258:
mov ecx, edx
cdq
idiv ecx
mov eax, ecx
test edx, edx
jnz short loc_1258
mov eax, esi
cdq
idiv ecx
sub eax, 1
retn
loc_1270:
mov ecx, eax
mov eax, esi
cdq
idiv ecx
sub eax, 1
retn | long long func0(int a1, int a2)
{
int v2; // eax
int v3; // edx
int v4; // ecx
v2 = a1;
if ( a1 > a2 )
{
v2 = a2;
a2 = a1;
}
if ( !a2 )
return (unsigned int)(0 / v2 - 1);
v3 = a2;
do
{
v4 = v3;
v3 = v2 % v3;
v2 = v4;
}
while ( v3 );
return (unsigned int)(a2 / v4 - 1);
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,ESI
JLE 0x0010124e
MOV EAX,ESI
MOV ESI,EDI
LAB_0010124e:
TEST ESI,ESI
JZ 0x00101270
MOV EDX,ESI
NOP dword ptr [RAX]
LAB_00101258:
MOV ECX,EDX
CDQ
IDIV ECX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101258
MOV EAX,ESI
CDQ
IDIV ECX
SUB EAX,0x1
RET
LAB_00101270:
MOV ECX,EAX
MOV EAX,ESI
CDQ
IDIV ECX
SUB EAX,0x1
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
iVar2 = param_1;
if (param_2 < param_1) {
iVar2 = param_2;
param_2 = param_1;
}
iVar3 = param_2;
if (param_2 == 0) {
return 0 / iVar2 + -1;
}
do {
iVar1 = iVar3;
iVar3 = iVar2 % iVar1;
iVar2 = iVar1;
} while (iVar3 != 0);
return param_2 / iVar1 + -1;
} |
4,767 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int A, int B) {
int temp;
if (A > B) {
temp = A;
A = B;
B = temp;
}
int gcd(int x, int y) {
int t;
while (y != 0) {
t = y;
y = x % y;
x = t;
}
return x;
}
B = B / gcd(A, B);
return B - 1;
}
| int main() {
assert(func0(2, 4) == 1);
assert(func0(4, 10) == 4);
assert(func0(1, 4) == 3);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
cmp %esi,%edi
jle 124e <func0+0xe>
mov %esi,%eax
mov %edi,%esi
test %esi,%esi
je 1270 <func0+0x30>
mov %esi,%edx
nopl 0x0(%rax)
mov %edx,%ecx
cltd
idiv %ecx
mov %ecx,%eax
test %edx,%edx
jne 1258 <func0+0x18>
mov %esi,%eax
cltd
idiv %ecx
sub $0x1,%eax
retq
nopl 0x0(%rax)
mov %eax,%ecx
mov %esi,%eax
cltd
idiv %ecx
sub $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, esi
cmp edi, esi
jg short loc_125E
mov eax, edi
mov edi, esi
loc_125E:
test edi, edi
jz short loc_1280
mov edx, edi
nop dword ptr [rax+00h]
loc_1268:
mov ecx, edx
cdq
idiv ecx
mov eax, ecx
test edx, edx
jnz short loc_1268
mov eax, edi
cdq
idiv ecx
sub eax, 1
retn
loc_1280:
mov ecx, eax
mov eax, edi
cdq
idiv ecx
sub eax, 1
retn | long long func0(int a1, int a2)
{
int v2; // eax
int v3; // edx
int v4; // ecx
v2 = a2;
if ( a1 <= a2 )
{
v2 = a1;
a1 = a2;
}
if ( !a1 )
return (unsigned int)(0 / v2 - 1);
v3 = a1;
do
{
v4 = v3;
v3 = v2 % v3;
v2 = v4;
}
while ( v3 );
return (unsigned int)(a1 / v4 - 1);
} | func0:
ENDBR64
MOV EAX,ESI
CMP EDI,ESI
JG 0x0010125e
MOV EAX,EDI
MOV EDI,ESI
LAB_0010125e:
TEST EDI,EDI
JZ 0x00101280
MOV EDX,EDI
NOP dword ptr [RAX]
LAB_00101268:
MOV ECX,EDX
CDQ
IDIV ECX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101268
MOV EAX,EDI
CDQ
IDIV ECX
SUB EAX,0x1
RET
LAB_00101280:
MOV ECX,EAX
MOV EAX,EDI
CDQ
IDIV ECX
SUB EAX,0x1
RET | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
iVar2 = param_2;
if (param_1 <= param_2) {
iVar2 = param_1;
param_1 = param_2;
}
iVar3 = param_1;
if (param_1 == 0) {
return 0 / iVar2 + -1;
}
do {
iVar1 = iVar3;
iVar3 = iVar2 % iVar1;
iVar2 = iVar1;
} while (iVar3 != 0);
return param_1 / iVar1 + -1;
} |
4,768 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare two integers for qsort
int compare(const void *a, const void *b) {
int int_a = *((int*) a);
int int_b = *((int*) b);
if (int_a < int_b) return -1;
if (int_a > int_b) return 1;
return 0;
}
| int* func0(int* test_tup, int size, int K, int* res_size) {
// Create a copy of the input array
int* temp = (int*)malloc(size * sizeof(int));
for(int i = 0; i < size; i++) {
temp[i] = test_tup[i];
}
// Sort the copied array
qsort(temp, size, sizeof(int), compare);
// Determine the size of the result
if(2*K > size) {
*res_size = size;
}
else {
*res_size = 2*K;
}
// Allocate memory for the result
int* res = (int*)malloc(*res_size * sizeof(int));
int idx = 0;
// Append the first K elements
for(int i = 0; i < K && i < size; i++) {
res[idx++] = temp[i];
}
// Append the last K elements
for(int i = size - K; i < size; i++) {
if(i >= K) { // Avoid duplicates when 2*K > size
res[idx++] = temp[i];
}
}
free(temp);
return res;
}
| int main() {
// Test 1
int test1[] = {5, 20, 3, 7, 6, 8};
int expected1[] = {3, 5, 8, 20};
int res_size1;
int* res1 = func0(test1, 6, 2, &res_size1);
assert(res_size1 == 4);
for(int i = 0; i < res_size1; i++) {
assert(res1[i] == expected1[i]);
}
free(res1);
// Test 2
int test2[] = {4, 5, 6, 1, 2, 7};
int expected2[] = {1, 2, 4, 5, 6, 7};
int res_size2;
int* res2 = func0(test2, 6, 3, &res_size2);
assert(res_size2 == 6);
for(int i = 0; i < res_size2; i++) {
assert(res2[i] == expected2[i]);
}
free(res2);
// Test 3
int test3[] = {2, 3, 4, 8, 9, 11, 7};
int expected3[] = {2, 3, 4, 7, 8, 9, 11};
int res_size3;
int* res3 = func0(test3, 7, 4, &res_size3);
assert(res_size3 == 7);
for(int i = 0; i < res_size3; i++) {
assert(res3[i] == expected3[i]);
}
free(res3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %rcx,-0x38(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x10(%rbp)
movl $0x0,-0x20(%rbp)
jmp 1279 <func0+0x69>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x10(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1248 <func0+0x38>
mov -0x2c(%rbp),%eax
movslq %eax,%rsi
mov -0x10(%rbp),%rax
lea -0xc9(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
mov -0x30(%rbp),%eax
add %eax,%eax
cmp %eax,-0x2c(%rbp)
jge 12b4 <func0+0xa4>
mov -0x38(%rbp),%rax
mov -0x2c(%rbp),%edx
mov %edx,(%rax)
jmp 12c0 <func0+0xb0>
mov -0x30(%rbp),%eax
lea (%rax,%rax,1),%edx
mov -0x38(%rbp),%rax
mov %edx,(%rax)
mov -0x38(%rbp),%rax
mov (%rax),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
jmp 131f <func0+0x10f>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x10(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x30(%rbp),%eax
jge 132f <func0+0x11f>
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 12e8 <func0+0xd8>
mov -0x2c(%rbp),%eax
sub -0x30(%rbp),%eax
mov %eax,-0x14(%rbp)
jmp 1379 <func0+0x169>
mov -0x14(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 1375 <func0+0x165>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x10(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 133a <func0+0x12a>
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 1090 <free@plt>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov [rbp+var_38], rcx
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+base], rax
mov [rbp+var_20], 0
jmp short loc_1279
loc_1248:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_20]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+base]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_20], 1
loc_1279:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_2C]
jl short loc_1248
mov eax, [rbp+var_2C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
mov eax, [rbp+var_30]
add eax, eax
cmp [rbp+var_2C], eax
jge short loc_12B7
mov rax, [rbp+var_38]
mov edx, [rbp+var_2C]
mov [rax], edx
jmp short loc_12C3
loc_12B7:
mov eax, [rbp+var_30]
lea edx, [rax+rax]
mov rax, [rbp+var_38]
mov [rax], edx
loc_12C3:
mov rax, [rbp+var_38]
mov eax, [rax]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
jmp short loc_1322
loc_12EB:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
lea rcx, [rdx+rax]
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
add [rbp+var_18], 1
loc_1322:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_30]
jge short loc_1332
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl short loc_12EB
loc_1332:
mov eax, [rbp+var_2C]
sub eax, [rbp+var_30]
mov [rbp+var_14], eax
jmp short loc_137C
loc_133D:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_30]
jl short loc_1378
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
lea rcx, [rdx+rax]
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_1378:
add [rbp+var_14], 1
loc_137C:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl short loc_133D
mov rax, [rbp+base]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2, int a3, int *a4)
{
int v4; // eax
int v5; // eax
int i; // [rsp+20h] [rbp-20h]
int v10; // [rsp+24h] [rbp-1Ch]
int j; // [rsp+28h] [rbp-18h]
int k; // [rsp+2Ch] [rbp-14h]
_DWORD *base; // [rsp+30h] [rbp-10h]
_DWORD *v14; // [rsp+38h] [rbp-8h]
base = malloc(4LL * a2);
for ( i = 0; i < a2; ++i )
base[i] = *(_DWORD *)(4LL * i + a1);
qsort(base, a2, 4uLL, compare);
if ( a2 >= 2 * a3 )
*a4 = 2 * a3;
else
*a4 = a2;
v14 = malloc(4LL * *a4);
v10 = 0;
for ( j = 0; j < a3 && j < a2; ++j )
{
v4 = v10++;
v14[v4] = base[j];
}
for ( k = a2 - a3; k < a2; ++k )
{
if ( k >= a3 )
{
v5 = v10++;
v14[v5] = base[k];
}
}
free(base);
return v14;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV qword ptr [RBP + -0x38],RCX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101279
LAB_00101248:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x20],0x1
LAB_00101279:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101248
MOV EAX,dword ptr [RBP + -0x2c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x10]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x001010a0
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,EAX
CMP dword ptr [RBP + -0x2c],EAX
JGE 0x001012b7
MOV RAX,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX],EDX
JMP 0x001012c3
LAB_001012b7:
MOV EAX,dword ptr [RBP + -0x30]
LEA EDX,[RAX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],EDX
LAB_001012c3:
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101322
LAB_001012eb:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x18],0x1
LAB_00101322:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x30]
JGE 0x00101332
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001012eb
LAB_00101332:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0010137c
LAB_0010133d:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x00101378
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_00101378:
ADD dword ptr [RBP + -0x14],0x1
LAB_0010137c:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x0010133d
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x00101090
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int param_3,int *param_4)
{
void *__base;
void *pvVar1;
int local_28;
int local_24;
int local_20;
int local_1c;
__base = malloc((long)param_2 << 2);
for (local_28 = 0; local_28 < param_2; local_28 = local_28 + 1) {
*(int4 *)((long)__base + (long)local_28 * 4) =
*(int4 *)(param_1 + (long)local_28 * 4);
}
qsort(__base,(long)param_2,4,compare);
if (param_2 < param_3 * 2) {
*param_4 = param_2;
}
else {
*param_4 = param_3 * 2;
}
pvVar1 = malloc((long)*param_4 << 2);
local_24 = 0;
for (local_20 = 0; (local_20 < param_3 && (local_20 < param_2)); local_20 = local_20 + 1) {
*(int4 *)((long)local_24 * 4 + (long)pvVar1) =
*(int4 *)((long)local_20 * 4 + (long)__base);
local_24 = local_24 + 1;
}
for (local_1c = param_2 - param_3; local_1c < param_2; local_1c = local_1c + 1) {
if (param_3 <= local_1c) {
*(int4 *)((long)local_24 * 4 + (long)pvVar1) =
*(int4 *)((long)local_1c * 4 + (long)__base);
local_24 = local_24 + 1;
}
}
free(__base);
return pvVar1;
} |
4,769 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare two integers for qsort
int compare(const void *a, const void *b) {
int int_a = *((int*) a);
int int_b = *((int*) b);
if (int_a < int_b) return -1;
if (int_a > int_b) return 1;
return 0;
}
| int* func0(int* test_tup, int size, int K, int* res_size) {
// Create a copy of the input array
int* temp = (int*)malloc(size * sizeof(int));
for(int i = 0; i < size; i++) {
temp[i] = test_tup[i];
}
// Sort the copied array
qsort(temp, size, sizeof(int), compare);
// Determine the size of the result
if(2*K > size) {
*res_size = size;
}
else {
*res_size = 2*K;
}
// Allocate memory for the result
int* res = (int*)malloc(*res_size * sizeof(int));
int idx = 0;
// Append the first K elements
for(int i = 0; i < K && i < size; i++) {
res[idx++] = temp[i];
}
// Append the last K elements
for(int i = size - K; i < size; i++) {
if(i >= K) { // Avoid duplicates when 2*K > size
res[idx++] = temp[i];
}
}
free(temp);
return res;
}
| int main() {
// Test 1
int test1[] = {5, 20, 3, 7, 6, 8};
int expected1[] = {3, 5, 8, 20};
int res_size1;
int* res1 = func0(test1, 6, 2, &res_size1);
assert(res_size1 == 4);
for(int i = 0; i < res_size1; i++) {
assert(res1[i] == expected1[i]);
}
free(res1);
// Test 2
int test2[] = {4, 5, 6, 1, 2, 7};
int expected2[] = {1, 2, 4, 5, 6, 7};
int res_size2;
int* res2 = func0(test2, 6, 3, &res_size2);
assert(res_size2 == 6);
for(int i = 0; i < res_size2; i++) {
assert(res2[i] == expected2[i]);
}
free(res2);
// Test 3
int test3[] = {2, 3, 4, 8, 9, 11, 7};
int expected3[] = {2, 3, 4, 7, 8, 9, 11};
int res_size3;
int* res3 = func0(test3, 7, 4, &res_size3);
assert(res_size3 == 7);
for(int i = 0; i < res_size3; i++) {
assert(res3[i] == expected3[i]);
}
free(res3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%ebp
mov %edx,%r12d
mov %rcx,%r14
movslq %esi,%r15
lea 0x0(,%r15,4),%rdi
callq 10d0 <malloc@plt>
mov %rax,%rbx
test %ebp,%ebp
jle 1231 <func0+0x50>
lea -0x1(%rbp),%ecx
mov $0x0,%eax
mov 0x0(%r13,%rax,4),%edx
mov %edx,(%rbx,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rcx,%rdx
jne 121d <func0+0x3c>
lea -0x6f(%rip),%rcx
mov $0x4,%edx
mov %r15,%rsi
mov %rbx,%rdi
callq 10a0 <qsort@plt>
lea (%r12,%r12,1),%edi
cmp %ebp,%edi
cmovg %ebp,%edi
mov %edi,(%r14)
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r13
cmp %r12d,%ebp
mov %r12d,%ecx
cmovle %ebp,%ecx
test %ecx,%ecx
jle 1299 <func0+0xb8>
lea -0x1(%rcx),%esi
mov $0x0,%eax
mov (%rbx,%rax,4),%edx
mov %edx,0x0(%r13,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rdx,%rsi
jne 1278 <func0+0x97>
mov %ebp,%eax
sub %r12d,%eax
cmp %eax,%ebp
jle 12bd <func0+0xdc>
cltq
jmp 12a8 <func0+0xc7>
mov $0x0,%ecx
jmp 128c <func0+0xab>
add $0x1,%rax
cmp %eax,%ebp
jle 12bd <func0+0xdc>
cmp %eax,%r12d
jg 12a0 <func0+0xbf>
movslq %ecx,%rdx
mov (%rbx,%rax,4),%esi
mov %esi,0x0(%r13,%rdx,4)
lea 0x1(%rcx),%ecx
jmp 12a0 <func0+0xbf>
mov %rbx,%rdi
callq 1090 <free@plt>
mov %r13,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rdi
mov ebp, esi
mov r12d, edx
mov r14, rcx
movsxd r15, esi
lea rdi, ds:0[r15*4]
call _malloc
mov rbx, rax
test ebp, ebp
jle short loc_122D
mov ecx, ebp
mov eax, 0
loc_121C:
mov edx, [r13+rax*4+0]
mov [rbx+rax*4], edx
add rax, 1
cmp rax, rcx
jnz short loc_121C
loc_122D:
lea rcx, compare
mov edx, 4
mov rsi, r15
mov rdi, rbx
call _qsort
lea edi, [r12+r12]
cmp edi, ebp
cmovg edi, ebp
mov [r14], edi
movsxd rdi, edi
shl rdi, 2
call _malloc
mov r13, rax
cmp ebp, r12d
mov ecx, r12d
cmovle ecx, ebp
test ecx, ecx
jle short loc_1291
mov esi, ecx
mov eax, 0
loc_1273:
mov edx, [rbx+rax*4]
mov [r13+rax*4+0], edx
add rax, 1
cmp rsi, rax
jnz short loc_1273
loc_1284:
mov eax, ebp
sub eax, r12d
cmp ebp, eax
jle short loc_12B5
cdqe
jmp short loc_12A0
loc_1291:
mov ecx, 0
jmp short loc_1284
loc_1298:
add rax, 1
cmp ebp, eax
jle short loc_12B5
loc_12A0:
cmp r12d, eax
jg short loc_1298
movsxd rdx, ecx
mov esi, [rbx+rax*4]
mov [r13+rdx*4+0], esi
lea ecx, [rcx+1]
jmp short loc_1298
loc_12B5:
mov rdi, rbx
call _free
mov rax, r13
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, long long a2, int a3, int *a4)
{
int v4; // ebp
long long v7; // rbx
long long v8; // rax
int v9; // edi
long long v10; // rdx
long long v11; // r13
long long v12; // rcx
long long v13; // rax
long long v14; // rax
v4 = a2;
v7 = malloc(4LL * (int)a2);
if ( (int)a2 > 0 )
{
v8 = 0LL;
do
{
*(_DWORD *)(v7 + 4 * v8) = *(_DWORD *)(a1 + 4 * v8);
++v8;
}
while ( v8 != (unsigned int)a2 );
}
a2 = (int)a2;
qsort(v7, (int)a2, 4LL, compare);
v9 = 2 * a3;
if ( 2 * a3 > (int)a2 )
v9 = a2;
*a4 = v9;
v11 = malloc(4LL * v9);
v12 = (unsigned int)a3;
if ( (int)a2 <= a3 )
v12 = (unsigned int)a2;
if ( (int)v12 <= 0 )
{
v12 = 0LL;
}
else
{
a2 = (unsigned int)v12;
v13 = 0LL;
do
{
v10 = *(unsigned int *)(v7 + 4 * v13);
*(_DWORD *)(v11 + 4 * v13++) = v10;
}
while ( (unsigned int)v12 != v13 );
}
LODWORD(v14) = v4 - a3;
if ( v4 > v4 - a3 )
{
v14 = (int)v14;
do
{
if ( a3 <= (int)v14 )
{
v10 = (int)v12;
a2 = *(unsigned int *)(v7 + 4 * v14);
*(_DWORD *)(v11 + 4LL * (int)v12) = a2;
v12 = (unsigned int)(v12 + 1);
}
++v14;
}
while ( v4 > (int)v14 );
}
free(v7, a2, v10, v12);
return v11;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV EBP,ESI
MOV R12D,EDX
MOV R14,RCX
MOVSXD R15,ESI
LEA RDI,[R15*0x4]
CALL 0x001010d0
MOV RBX,RAX
TEST EBP,EBP
JLE 0x0010122d
MOV ECX,EBP
MOV EAX,0x0
LAB_0010121c:
MOV EDX,dword ptr [R13 + RAX*0x4]
MOV dword ptr [RBX + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x0010121c
LAB_0010122d:
LEA RCX,[0x1011c9]
MOV EDX,0x4
MOV RSI,R15
MOV RDI,RBX
CALL 0x001010a0
LEA EDI,[R12 + R12*0x1]
CMP EDI,EBP
CMOVG EDI,EBP
MOV dword ptr [R14],EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV R13,RAX
CMP EBP,R12D
MOV ECX,R12D
CMOVLE ECX,EBP
TEST ECX,ECX
JLE 0x00101291
MOV ESI,ECX
MOV EAX,0x0
LAB_00101273:
MOV EDX,dword ptr [RBX + RAX*0x4]
MOV dword ptr [R13 + RAX*0x4],EDX
ADD RAX,0x1
CMP RSI,RAX
JNZ 0x00101273
LAB_00101284:
MOV EAX,EBP
SUB EAX,R12D
CMP EBP,EAX
JLE 0x001012b5
CDQE
JMP 0x001012a0
LAB_00101291:
MOV ECX,0x0
JMP 0x00101284
LAB_00101298:
ADD RAX,0x1
CMP EBP,EAX
JLE 0x001012b5
LAB_001012a0:
CMP R12D,EAX
JG 0x00101298
MOVSXD RDX,ECX
MOV ESI,dword ptr [RBX + RAX*0x4]
MOV dword ptr [R13 + RDX*0x4],ESI
LEA ECX,[RCX + 0x1]
JMP 0x00101298
LAB_001012b5:
MOV RDI,RBX
CALL 0x00101090
MOV RAX,R13
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(long param_1,uint param_2,uint param_3,uint *param_4)
{
void *__base;
ulong uVar1;
void *pvVar2;
long lVar3;
ulong uVar4;
uint uVar5;
uVar4 = (ulong)param_3;
__base = malloc((long)(int)param_2 * 4);
if (0 < (int)param_2) {
uVar1 = 0;
do {
*(int4 *)((long)__base + uVar1 * 4) = *(int4 *)(param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
}
qsort(__base,(long)(int)param_2,4,compare);
uVar5 = param_3 * 2;
if ((int)param_2 < (int)(param_3 * 2)) {
uVar5 = param_2;
}
*param_4 = uVar5;
pvVar2 = malloc((long)(int)uVar5 << 2);
if ((int)param_2 <= (int)param_3) {
uVar4 = (ulong)param_2;
}
if ((int)uVar4 < 1) {
uVar4 = 0;
}
else {
uVar1 = 0;
do {
*(int4 *)((long)pvVar2 + uVar1 * 4) = *(int4 *)((long)__base + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar4 != uVar1);
}
if ((int)(param_2 - param_3) < (int)param_2) {
lVar3 = (long)(int)(param_2 - param_3);
do {
if ((int)param_3 <= (int)lVar3) {
*(int4 *)((long)pvVar2 + (long)(int)uVar4 * 4) =
*(int4 *)((long)__base + lVar3 * 4);
uVar4 = (ulong)((int)uVar4 + 1);
}
lVar3 = lVar3 + 1;
} while ((int)lVar3 < (int)param_2);
}
free(__base);
return pvVar2;
} |
4,770 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare two integers for qsort
int compare(const void *a, const void *b) {
int int_a = *((int*) a);
int int_b = *((int*) b);
if (int_a < int_b) return -1;
if (int_a > int_b) return 1;
return 0;
}
| int* func0(int* test_tup, int size, int K, int* res_size) {
// Create a copy of the input array
int* temp = (int*)malloc(size * sizeof(int));
for(int i = 0; i < size; i++) {
temp[i] = test_tup[i];
}
// Sort the copied array
qsort(temp, size, sizeof(int), compare);
// Determine the size of the result
if(2*K > size) {
*res_size = size;
}
else {
*res_size = 2*K;
}
// Allocate memory for the result
int* res = (int*)malloc(*res_size * sizeof(int));
int idx = 0;
// Append the first K elements
for(int i = 0; i < K && i < size; i++) {
res[idx++] = temp[i];
}
// Append the last K elements
for(int i = size - K; i < size; i++) {
if(i >= K) { // Avoid duplicates when 2*K > size
res[idx++] = temp[i];
}
}
free(temp);
return res;
}
| int main() {
// Test 1
int test1[] = {5, 20, 3, 7, 6, 8};
int expected1[] = {3, 5, 8, 20};
int res_size1;
int* res1 = func0(test1, 6, 2, &res_size1);
assert(res_size1 == 4);
for(int i = 0; i < res_size1; i++) {
assert(res1[i] == expected1[i]);
}
free(res1);
// Test 2
int test2[] = {4, 5, 6, 1, 2, 7};
int expected2[] = {1, 2, 4, 5, 6, 7};
int res_size2;
int* res2 = func0(test2, 6, 3, &res_size2);
assert(res_size2 == 6);
for(int i = 0; i < res_size2; i++) {
assert(res2[i] == expected2[i]);
}
free(res2);
// Test 3
int test3[] = {2, 3, 4, 8, 9, 11, 7};
int expected3[] = {2, 3, 4, 7, 8, 9, 11};
int res_size3;
int* res3 = func0(test3, 7, 4, &res_size3);
assert(res_size3 == 7);
for(int i = 0; i < res_size3; i++) {
assert(res3[i] == expected3[i]);
}
free(res3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
movslq %esi,%r15
push %r14
mov %rdi,%r14
lea 0x0(,%r15,4),%rdi
push %r13
mov %rcx,%r13
push %r12
mov %edx,%r12d
push %rbp
push %rbx
mov %r15,%rbx
sub $0x8,%rsp
callq 10d0 <malloc@plt>
mov %rax,%rbp
test %r15d,%r15d
jle 1534 <func0+0x54>
lea -0x1(%r15),%ecx
xor %eax,%eax
nopl 0x0(%rax)
mov (%r14,%rax,4),%edx
mov %edx,0x0(%rbp,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rcx,%rdx
jne 1520 <func0+0x40>
lea -0x7b(%rip),%rcx
mov $0x4,%edx
mov %r15,%rsi
mov %rbp,%rdi
callq 10a0 <qsort@plt>
lea (%r12,%r12,1),%edi
cmp %ebx,%edi
cmovg %ebx,%edi
mov %edi,0x0(%r13)
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
cmp %r12d,%ebx
mov %rax,%r13
mov %r12d,%eax
cmovle %ebx,%eax
test %eax,%eax
jle 15e0 <func0+0x100>
lea -0x1(%rax),%esi
xor %edx,%edx
nopl 0x0(%rax)
mov 0x0(%rbp,%rdx,4),%ecx
mov %ecx,0x0(%r13,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rcx,%rsi
jne 1580 <func0+0xa0>
mov %ebx,%edx
sub %r12d,%edx
cmp %edx,%ebx
jle 15c4 <func0+0xe4>
movslq %edx,%rdx
nopl 0x0(%rax)
cmp %edx,%r12d
jg 15bc <func0+0xdc>
mov 0x0(%rbp,%rdx,4),%esi
movslq %eax,%rcx
add $0x1,%eax
mov %esi,0x0(%r13,%rcx,4)
add $0x1,%rdx
cmp %edx,%ebx
jg 15a8 <func0+0xc8>
mov %rbp,%rdi
callq 1090 <free@plt>
add $0x8,%rsp
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xchg %ax,%ax
xor %eax,%eax
jmp 1595 <func0+0xb5>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r15
movsxd r15, esi
push r14
mov r14, rdi
push r13
push r12
mov r12d, edx
lea rdx, ds:0[r15*4]
push rbp
mov rdi, rdx
mov rbp, rcx
push rbx
mov rbx, r15
sub rsp, 18h
mov [rsp+48h+var_40], rdx
call _malloc
mov r13, rax
test r15d, r15d
jle short loc_154E
mov rdx, [rsp+48h+var_40]
mov rsi, r14
mov rdi, rax
call _memcpy
loc_154E:
lea rcx, compare
mov edx, 4
mov rsi, r15
mov rdi, r13
call _qsort
lea edi, [r12+r12]
cmp edi, ebx
cmovg edi, ebx
mov [rbp+0], edi
movsxd rdi, edi
mov ebp, r12d
shl rdi, 2
call _malloc
cmp ebx, r12d
cmovle ebp, ebx
mov r14, rax
test ebp, ebp
jle short loc_15F0
movsxd rdx, ebp
mov rsi, r13
mov rdi, rax
shl rdx, 2
call _memcpy
loc_159F:
mov eax, ebx
sub eax, r12d
cmp ebx, eax
jle short loc_15CC
cdqe
nop word ptr [rax+rax+00h]
loc_15B0:
cmp r12d, eax
jg short loc_15C4
mov ecx, [r13+rax*4+0]
movsxd rdx, ebp
add ebp, 1
mov [r14+rdx*4], ecx
loc_15C4:
add rax, 1
cmp ebx, eax
jg short loc_15B0
loc_15CC:
mov rdi, r13
call _free
add rsp, 18h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15F0:
xor ebp, ebp
jmp short loc_159F | long long func0(long long a1, int a2, int a3, int *a4)
{
long long v6; // rax
long long v7; // r13
int v8; // edi
int v9; // ebp
long long v10; // rax
long long v11; // r14
long long v12; // rax
long long v13; // rdx
v6 = malloc(4LL * a2);
v7 = v6;
if ( a2 > 0 )
memcpy(v6, a1, 4LL * a2);
qsort(v7, a2, 4LL, compare);
v8 = 2 * a3;
if ( 2 * a3 > a2 )
v8 = a2;
*a4 = v8;
v9 = a3;
v10 = malloc(4LL * v8);
if ( a2 <= a3 )
v9 = a2;
v11 = v10;
if ( v9 <= 0 )
v9 = 0;
else
memcpy(v10, v7, 4LL * v9);
LODWORD(v12) = a2 - a3;
if ( a2 > a2 - a3 )
{
v12 = (int)v12;
do
{
if ( a3 <= (int)v12 )
{
v13 = v9++;
*(_DWORD *)(v11 + 4 * v13) = *(_DWORD *)(v7 + 4 * v12);
}
++v12;
}
while ( a2 > (int)v12 );
}
free(v7);
return v11;
} | func0:
ENDBR64
PUSH R15
MOVSXD R15,ESI
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
MOV R12D,EDX
LEA RDX,[R15*0x4]
PUSH RBP
MOV RDI,RDX
MOV RBP,RCX
PUSH RBX
MOV RBX,R15
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDX
CALL 0x001010f0
MOV R13,RAX
TEST R15D,R15D
JLE 0x0010154e
MOV RDX,qword ptr [RSP + 0x8]
MOV RSI,R14
MOV RDI,RAX
CALL 0x001010e0
LAB_0010154e:
LEA RCX,[0x1014e0]
MOV EDX,0x4
MOV RSI,R15
MOV RDI,R13
CALL 0x001010b0
LEA EDI,[R12 + R12*0x1]
CMP EDI,EBX
CMOVG EDI,EBX
MOV dword ptr [RBP],EDI
MOVSXD RDI,EDI
MOV EBP,R12D
SHL RDI,0x2
CALL 0x001010f0
CMP EBX,R12D
CMOVLE EBP,EBX
MOV R14,RAX
TEST EBP,EBP
JLE 0x001015f0
MOVSXD RDX,EBP
MOV RSI,R13
MOV RDI,RAX
SHL RDX,0x2
CALL 0x001010e0
LAB_0010159f:
MOV EAX,EBX
SUB EAX,R12D
CMP EBX,EAX
JLE 0x001015cc
CDQE
NOP word ptr [RAX + RAX*0x1]
LAB_001015b0:
CMP R12D,EAX
JG 0x001015c4
MOV ECX,dword ptr [R13 + RAX*0x4]
MOVSXD RDX,EBP
ADD EBP,0x1
MOV dword ptr [R14 + RDX*0x4],ECX
LAB_001015c4:
ADD RAX,0x1
CMP EBX,EAX
JG 0x001015b0
LAB_001015cc:
MOV RDI,R13
CALL 0x001010a0
ADD RSP,0x18
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015f0:
XOR EBP,EBP
JMP 0x0010159f | void * func0(void *param_1,int param_2,int param_3,int *param_4)
{
size_t __size;
void *__dest;
void *__dest_00;
long lVar1;
long lVar2;
int iVar3;
__size = (long)param_2 * 4;
__dest = malloc(__size);
if (0 < param_2) {
memcpy(__dest,param_1,__size);
}
qsort(__dest,(long)param_2,4,compare);
iVar3 = param_3 * 2;
if (param_2 < param_3 * 2) {
iVar3 = param_2;
}
*param_4 = iVar3;
__dest_00 = malloc((long)iVar3 << 2);
iVar3 = param_3;
if (param_2 <= param_3) {
iVar3 = param_2;
}
if (iVar3 < 1) {
iVar3 = 0;
}
else {
memcpy(__dest_00,__dest,(long)iVar3 << 2);
}
if (param_2 - param_3 < param_2) {
lVar1 = (long)(param_2 - param_3);
do {
if (param_3 <= (int)lVar1) {
lVar2 = (long)iVar3;
iVar3 = iVar3 + 1;
*(int4 *)((long)__dest_00 + lVar2 * 4) = *(int4 *)((long)__dest + lVar1 * 4);
}
lVar1 = lVar1 + 1;
} while ((int)lVar1 < param_2);
}
free(__dest);
return __dest_00;
} |
4,771 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare two integers for qsort
int compare(const void *a, const void *b) {
int int_a = *((int*) a);
int int_b = *((int*) b);
if (int_a < int_b) return -1;
if (int_a > int_b) return 1;
return 0;
}
| int* func0(int* test_tup, int size, int K, int* res_size) {
// Create a copy of the input array
int* temp = (int*)malloc(size * sizeof(int));
for(int i = 0; i < size; i++) {
temp[i] = test_tup[i];
}
// Sort the copied array
qsort(temp, size, sizeof(int), compare);
// Determine the size of the result
if(2*K > size) {
*res_size = size;
}
else {
*res_size = 2*K;
}
// Allocate memory for the result
int* res = (int*)malloc(*res_size * sizeof(int));
int idx = 0;
// Append the first K elements
for(int i = 0; i < K && i < size; i++) {
res[idx++] = temp[i];
}
// Append the last K elements
for(int i = size - K; i < size; i++) {
if(i >= K) { // Avoid duplicates when 2*K > size
res[idx++] = temp[i];
}
}
free(temp);
return res;
}
| int main() {
// Test 1
int test1[] = {5, 20, 3, 7, 6, 8};
int expected1[] = {3, 5, 8, 20};
int res_size1;
int* res1 = func0(test1, 6, 2, &res_size1);
assert(res_size1 == 4);
for(int i = 0; i < res_size1; i++) {
assert(res1[i] == expected1[i]);
}
free(res1);
// Test 2
int test2[] = {4, 5, 6, 1, 2, 7};
int expected2[] = {1, 2, 4, 5, 6, 7};
int res_size2;
int* res2 = func0(test2, 6, 3, &res_size2);
assert(res_size2 == 6);
for(int i = 0; i < res_size2; i++) {
assert(res2[i] == expected2[i]);
}
free(res2);
// Test 3
int test3[] = {2, 3, 4, 8, 9, 11, 7};
int expected3[] = {2, 3, 4, 7, 8, 9, 11};
int res_size3;
int* res3 = func0(test3, 7, 4, &res_size3);
assert(res_size3 == 7);
for(int i = 0; i < res_size3; i++) {
assert(res3[i] == expected3[i]);
}
free(res3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
movslq %esi,%r15
push %r14
push %r13
mov %edx,%r13d
push %r12
mov %rdi,%r12
lea 0x0(,%r15,4),%rdi
push %rbp
mov %rcx,%rbp
push %rbx
mov %r15,%rbx
sub $0x8,%rsp
callq 10f0 <malloc@plt>
mov %rax,%r14
test %r15d,%r15d
jle 150d <func0+0x4d>
lea -0x1(%r15),%eax
mov %r12,%rsi
mov %r14,%rdi
lea 0x4(,%rax,4),%rdx
callq 10e0 <memcpy@plt>
lea -0x74(%rip),%rcx
mov $0x4,%edx
mov %r15,%rsi
mov %r14,%rdi
callq 10b0 <qsort@plt>
lea 0x0(%r13,%r13,1),%edi
cmp %ebx,%edi
cmovg %ebx,%edi
mov %edi,0x0(%rbp)
movslq %edi,%rdi
mov %r13d,%ebp
shl $0x2,%rdi
callq 10f0 <malloc@plt>
cmp %r13d,%ebx
cmovle %ebx,%ebp
mov %rax,%r12
test %ebp,%ebp
jle 1680 <func0+0x1c0>
lea -0x1(%rbp),%eax
mov %r12,%rdi
mov %r14,%rsi
lea 0x4(,%rax,4),%rdx
callq 10e0 <memcpy@plt>
movslq %ebp,%rdi
mov %ebx,%eax
sub %r13d,%eax
cmp %eax,%ebx
jle 165d <func0+0x19d>
cmp %eax,%r13d
jle 1636 <func0+0x176>
mov %ebp,%esi
mov $0x1,%edx
sub %eax,%esi
cmp %ebp,%eax
cmovge %edx,%esi
lea -0x1(%rbp),%edx
sub %eax,%edx
cmp $0x7,%edx
jbe 15ef <func0+0x12f>
cmp %ebp,%eax
jge 15ef <func0+0x12f>
movd %eax,%xmm4
mov %esi,%ecx
movdqa 0xb26(%rip),%xmm3
xor %edx,%edx
pshufd $0x0,%xmm4,%xmm1
movdqa 0xb27(%rip),%xmm2
paddd 0xaff(%rip),%xmm1
shr $0x2,%ecx
nopl 0x0(%rax)
movdqa %xmm1,%xmm0
add $0x1,%edx
paddd %xmm3,%xmm1
paddd %xmm2,%xmm0
cmp %edx,%ecx
jne 15c8 <func0+0x108>
mov %esi,%ecx
pshufd $0xff,%xmm0,%xmm0
and $0xfffffffc,%ecx
movd %xmm0,%edx
add %ecx,%eax
cmp %esi,%ecx
je 1630 <func0+0x170>
lea 0x1(%rax),%edx
cmp %ebp,%edx
jge 1630 <func0+0x170>
lea 0x2(%rax),%edx
cmp %ebp,%edx
jge 1630 <func0+0x170>
lea 0x3(%rax),%edx
cmp %edx,%ebp
jle 1630 <func0+0x170>
lea 0x4(%rax),%edx
cmp %edx,%ebp
jle 1630 <func0+0x170>
lea 0x5(%rax),%edx
cmp %edx,%ebp
jle 1630 <func0+0x170>
lea 0x6(%rax),%edx
cmp %edx,%ebp
jle 1630 <func0+0x170>
lea 0x7(%rax),%edx
add $0x8,%eax
cmp %edx,%ebp
cmovle %edx,%eax
jmp 1632 <func0+0x172>
nopw %cs:0x0(%rax,%rax,1)
mov %edx,%eax
cmp %eax,%ebx
jle 165d <func0+0x19d>
lea -0x1(%rbx),%edx
mov $0x4,%ecx
lea (%r12,%rdi,4),%rdi
sub %eax,%edx
cmp %eax,%ebx
cltq
lea 0x4(,%rdx,4),%rdx
lea (%r14,%rax,4),%rsi
cmovle %rcx,%rdx
callq 10e0 <memcpy@plt>
mov %r14,%rdi
callq 10a0 <free@plt>
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
xor %edi,%edi
jmpq 156a <func0+0xaa>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
movsxd rax, esi
mov r15d, edx
push r14
push r13
mov r13, rcx
push r12
push rbp
push rbx
mov rbx, rax
sub rsp, 18h
mov [rsp+48h+src], rdi
lea rdi, ds:0[rax*4]; size
mov [rsp+48h+nmemb], rax
call _malloc
mov rbp, rax
lea eax, [r15+r15]
cmp eax, ebx
mov r14d, eax
cmovg r14d, ebx
movsxd r12, r14d
shl r12, 2
test ebx, ebx
jle loc_1618
mov rsi, [rsp+48h+src]; src
mov edx, ebx
mov rdi, rbp; dest
shl rdx, 2; n
call _memcpy
mov rsi, [rsp+48h+nmemb]; nmemb
mov edx, 4; size
mov rdi, rbp; base
lea rcx, compare; compar
call _qsort
mov [r13+0], r14d
mov rdi, r12; size
mov r13d, r15d
call _malloc
cmp ebx, r15d
cmovle r13d, ebx
mov r12, rax
test r13d, r13d
jle loc_1675
mov edx, r13d
mov rsi, rbp; src
mov rdi, rax; dest
shl rdx, 2; n
call _memcpy
loc_1522:
mov eax, ebx
sub eax, r15d
cmp ebx, eax
jle loc_15DE
cmp r15d, eax
jle short loc_15B3
cmp ebx, r15d
mov r8d, r15d
mov esi, 1
cmovle r8d, ebx
mov edx, r8d
sub edx, eax
cmp eax, r8d
cmovl esi, edx
sub edx, 1
cmp edx, 2
jbe loc_166E
cmp eax, r8d
jge loc_166E
movd xmm3, eax
mov ecx, esi
movdqa xmm2, cs:xmmword_20B0
xor edx, edx
pshufd xmm0, xmm3, 0
paddd xmm0, cs:xmmword_20A0
shr ecx, 2
nop dword ptr [rax+rax+00h]
loc_1588:
add edx, 1
movdqa xmm1, xmm0
paddd xmm0, xmm2
cmp ecx, edx
jnz short loc_1588
mov edx, esi
and edx, 0FFFFFFFCh
add edx, eax
and esi, 3
jz loc_1650
loc_15A7:
lea eax, [rdx+1]
cmp r8d, eax
jg short loc_1600
cmp ebx, eax
jle short loc_15DE
loc_15B3:
lea edx, [rbx-1]
mov ecx, 4
movsxd r13, r13d
sub edx, eax
cmp ebx, eax
lea rdi, [r12+r13*4]; dest
cdqe
lea rdx, ds:4[rdx*4]
lea rsi, [rbp+rax*4+0]; src
cmovle rdx, rcx; n
call _memcpy
loc_15DE:
mov rdi, rbp; ptr
call _free
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1600:
lea eax, [rdx+2]
add edx, 3
cmp eax, r8d
cmovl eax, edx
cmp ebx, eax
jg short loc_15B3
jmp short loc_15DE
loc_1618:
mov rsi, [rsp+48h+nmemb]; nmemb
lea rcx, compare; compar
mov edx, 4; size
mov rdi, rbp; base
call _qsort
mov [r13+0], r14d
mov rdi, r12; size
xor r13d, r13d
call _malloc
mov r12, rax
jmp loc_1522
loc_1650:
paddd xmm1, cs:xmmword_20C0
pshufd xmm0, xmm1, 0FFh
movd eax, xmm0
cmp ebx, eax
jg loc_15B3
jmp loc_15DE
loc_166E:
mov edx, eax
jmp loc_15A7
loc_1675:
xor r13d, r13d
jmp loc_1522 | char * func0(const void *a1, int a2, signed int a3, int *a4)
{
char *v7; // rbp
int v8; // r14d
int v9; // r13d
char *v10; // rax
char *v11; // r12
signed int v12; // eax
signed int v13; // r8d
unsigned int v14; // esi
__m128i si128; // xmm2
int v16; // edx
__m128i v17; // xmm0
__m128i v18; // xmm1
unsigned int v19; // edx
size_t v20; // rdx
signed int v22; // edx
v7 = (char *)malloc(4LL * a2);
v8 = 2 * a3;
if ( 2 * a3 > a2 )
v8 = a2;
if ( a2 <= 0 )
{
qsort(v7, a2, 4uLL, compare);
*a4 = v8;
v9 = 0;
v11 = (char *)malloc(4LL * v8);
}
else
{
memcpy(v7, a1, 4LL * (unsigned int)a2);
qsort(v7, a2, 4uLL, compare);
*a4 = v8;
v9 = a3;
v10 = (char *)malloc(4LL * v8);
if ( a2 <= a3 )
v9 = a2;
v11 = v10;
if ( v9 <= 0 )
v9 = 0;
else
memcpy(v10, v7, 4LL * (unsigned int)v9);
}
v12 = a2 - a3;
if ( a2 <= a2 - a3 )
goto LABEL_24;
if ( a3 <= v12 )
goto LABEL_21;
v13 = a3;
v14 = 1;
if ( a2 <= a3 )
v13 = a2;
if ( v12 < v13 )
v14 = v13 - v12;
if ( (unsigned int)(v13 - v12 - 1) <= 2 || v12 >= v13 )
{
v19 = a2 - a3;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_20B0);
v16 = 0;
v17 = _mm_add_epi32(_mm_shuffle_epi32(_mm_cvtsi32_si128(v12), 0), (__m128i)xmmword_20A0);
do
{
++v16;
v18 = v17;
v17 = _mm_add_epi32(v17, si128);
}
while ( v14 >> 2 != v16 );
v19 = v12 + (v14 & 0xFFFFFFFC);
if ( (v14 & 3) == 0 )
{
v12 = _mm_cvtsi128_si32(_mm_shuffle_epi32(_mm_add_epi32(v18, (__m128i)xmmword_20C0), 255));
if ( a2 <= v12 )
goto LABEL_24;
goto LABEL_21;
}
}
v12 = v19 + 1;
if ( v13 <= (int)(v19 + 1) )
{
if ( a2 <= v12 )
goto LABEL_24;
goto LABEL_21;
}
v12 = v19 + 2;
v22 = v19 + 3;
if ( v12 < v13 )
v12 = v22;
if ( a2 > v12 )
{
LABEL_21:
v20 = 4LL * (unsigned int)(a2 - 1 - v12) + 4;
if ( a2 <= v12 )
v20 = 4LL;
memcpy(&v11[4 * v9], &v7[4 * v12], v20);
}
LABEL_24:
free(v7);
return v11;
} | func0:
ENDBR64
PUSH R15
MOVSXD RAX,ESI
MOV R15D,EDX
PUSH R14
PUSH R13
MOV R13,RCX
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RAX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
LEA RDI,[RAX*0x4]
MOV qword ptr [RSP],RAX
CALL 0x001010f0
MOV RBP,RAX
LEA EAX,[R15 + R15*0x1]
CMP EAX,EBX
MOV R14D,EAX
CMOVG R14D,EBX
MOVSXD R12,R14D
SHL R12,0x2
TEST EBX,EBX
JLE 0x00101618
MOV RSI,qword ptr [RSP + 0x8]
MOV EDX,EBX
MOV RDI,RBP
SHL RDX,0x2
CALL 0x001010e0
MOV RSI,qword ptr [RSP]
MOV EDX,0x4
MOV RDI,RBP
LEA RCX,[0x101450]
CALL 0x001010b0
MOV dword ptr [R13],R14D
MOV RDI,R12
MOV R13D,R15D
CALL 0x001010f0
CMP EBX,R15D
CMOVLE R13D,EBX
MOV R12,RAX
TEST R13D,R13D
JLE 0x00101675
MOV EDX,R13D
MOV RSI,RBP
MOV RDI,RAX
SHL RDX,0x2
CALL 0x001010e0
LAB_00101522:
MOV EAX,EBX
SUB EAX,R15D
CMP EBX,EAX
JLE 0x001015de
CMP R15D,EAX
JLE 0x001015b3
CMP EBX,R15D
MOV R8D,R15D
MOV ESI,0x1
CMOVLE R8D,EBX
MOV EDX,R8D
SUB EDX,EAX
CMP EAX,R8D
CMOVL ESI,EDX
SUB EDX,0x1
CMP EDX,0x2
JBE 0x0010166e
CMP EAX,R8D
JGE 0x0010166e
MOVD XMM3,EAX
MOV ECX,ESI
MOVDQA XMM2,xmmword ptr [0x001020b0]
XOR EDX,EDX
PSHUFD XMM0,XMM3,0x0
PADDD XMM0,xmmword ptr [0x001020a0]
SHR ECX,0x2
NOP dword ptr [RAX + RAX*0x1]
LAB_00101588:
ADD EDX,0x1
MOVDQA XMM1,XMM0
PADDD XMM0,XMM2
CMP ECX,EDX
JNZ 0x00101588
MOV EDX,ESI
AND EDX,0xfffffffc
ADD EDX,EAX
AND ESI,0x3
JZ 0x00101650
LAB_001015a7:
LEA EAX,[RDX + 0x1]
CMP R8D,EAX
JG 0x00101600
CMP EBX,EAX
JLE 0x001015de
LAB_001015b3:
LEA EDX,[RBX + -0x1]
MOV ECX,0x4
MOVSXD R13,R13D
SUB EDX,EAX
CMP EBX,EAX
LEA RDI,[R12 + R13*0x4]
CDQE
LEA RDX,[0x4 + RDX*0x4]
LEA RSI,[RBP + RAX*0x4]
CMOVLE RDX,RCX
CALL 0x001010e0
LAB_001015de:
MOV RDI,RBP
CALL 0x001010a0
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101600:
LEA EAX,[RDX + 0x2]
ADD EDX,0x3
CMP EAX,R8D
CMOVL EAX,EDX
CMP EBX,EAX
JG 0x001015b3
JMP 0x001015de
LAB_00101618:
MOV RSI,qword ptr [RSP]
LEA RCX,[0x101450]
MOV EDX,0x4
MOV RDI,RBP
CALL 0x001010b0
MOV dword ptr [R13],R14D
MOV RDI,R12
XOR R13D,R13D
CALL 0x001010f0
MOV R12,RAX
JMP 0x00101522
LAB_00101650:
PADDD XMM1,xmmword ptr [0x001020c0]
PSHUFD XMM0,XMM1,0xff
MOVD EAX,XMM0
CMP EBX,EAX
JG 0x001015b3
JMP 0x001015de
LAB_0010166e:
MOV EDX,EAX
JMP 0x001015a7
LAB_00101675:
XOR R13D,R13D
JMP 0x00101522 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void * func0(void *param_1,uint param_2,uint param_3,uint *param_4)
{
int iVar1;
int iVar2;
size_t sVar3;
void *__base;
void *__dest;
uint uVar4;
int iVar5;
ulong uVar6;
uint uVar7;
int iVar8;
sVar3 = (size_t)(int)param_2;
uVar6 = (ulong)param_3;
__base = malloc(sVar3 * 4);
uVar7 = param_3 * 2;
if ((int)param_2 < (int)(param_3 * 2)) {
uVar7 = param_2;
}
if ((int)param_2 < 1) {
qsort(__base,sVar3,4,compare);
*param_4 = uVar7;
iVar5 = 0;
__dest = malloc((long)(int)uVar7 << 2);
}
else {
memcpy(__base,param_1,(ulong)param_2 << 2);
qsort(__base,sVar3,4,compare);
*param_4 = uVar7;
__dest = malloc((long)(int)uVar7 << 2);
if ((int)param_2 <= (int)param_3) {
uVar6 = (ulong)param_2;
}
iVar5 = (int)uVar6;
if (iVar5 < 1) {
iVar5 = 0;
}
else {
memcpy(__dest,__base,uVar6 << 2);
}
}
iVar2 = param_2 - param_3;
if ((int)param_2 <= iVar2) goto LAB_001015de;
if (iVar2 < (int)param_3) {
if ((int)param_2 <= (int)param_3) {
param_3 = param_2;
}
uVar7 = 1;
if (iVar2 < (int)param_3) {
uVar7 = param_3 - iVar2;
}
if (((param_3 - iVar2) - 1 < 3) || ((int)param_3 <= iVar2)) {
LAB_001015a7:
iVar1 = iVar2 + 1;
if (iVar2 + 1 < (int)param_3) {
iVar1 = iVar2 + 2;
if (iVar2 + 2 < (int)param_3) {
iVar1 = iVar2 + 3;
}
}
}
else {
uVar4 = 0;
iVar1 = iVar2 + _UNK_001020ac;
do {
iVar8 = iVar1;
uVar4 = uVar4 + 1;
iVar1 = iVar8 + _UNK_001020bc;
} while (uVar7 >> 2 != uVar4);
iVar2 = (uVar7 & 0xfffffffc) + iVar2;
if ((uVar7 & 3) != 0) goto LAB_001015a7;
iVar1 = iVar8 + _UNK_001020cc;
}
iVar2 = iVar1;
if ((int)param_2 <= iVar2) goto LAB_001015de;
}
sVar3 = (ulong)((param_2 - 1) - iVar2) * 4 + 4;
if ((int)param_2 <= iVar2) {
sVar3 = 4;
}
memcpy((void *)((long)__dest + (long)iVar5 * 4),(void *)((long)__base + (long)iVar2 * 4),sVar3);
LAB_001015de:
free(__base);
return __dest;
} |
4,772 | func0 |
#include <stdio.h>
#include <regex.h>
#include <string.h>
#include <assert.h>
| char *func0(const char *text, int n) {
regex_t regex;
regmatch_t pmatch[1];
static char new_text[256];
strcpy(new_text, text);
const char *pattern = "[ ,.]";
regcomp(®ex, pattern, REG_EXTENDED);
int num_replacements = 0;
while (num_replacements < n && regexec(®ex, new_text, 1, pmatch, 0) == 0) {
int start = pmatch[0].rm_so;
new_text[start] = ':';
num_replacements++;
}
regfree(®ex);
return new_text;
}
| int main() {
assert(strcmp(func0("Python language, Programming language.", 2), "Python:language: Programming language.") == 0);
assert(strcmp(func0("a b c,d e f", 3), "a:b:c:d e f") == 0);
assert(strcmp(func0("ram reshma,ram rahim", 1), "ram:reshma,ram rahim") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %esi,-0x6c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x68(%rbp),%rax
mov %rax,%rsi
lea 0x2e07(%rip),%rdi
callq 10b0 <strcpy@plt>
lea 0xdc3(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10f0 <regcomp@plt>
movl $0x0,-0x60(%rbp)
jmp 1284 <func0+0x7b>
mov -0x10(%rbp),%eax
mov %eax,-0x5c(%rbp)
mov -0x5c(%rbp),%eax
cltq
lea 0x2dc4(%rip),%rdx
movb $0x3a,(%rax,%rdx,1)
addl $0x1,-0x60(%rbp)
mov -0x60(%rbp),%eax
cmp -0x6c(%rbp),%eax
jge 12b5 <func0+0xac>
lea -0x10(%rbp),%rdx
lea -0x50(%rbp),%rax
mov $0x0,%r8d
mov %rdx,%rcx
mov $0x1,%edx
lea 0x2d97(%rip),%rsi
mov %rax,%rdi
callq 1110 <regexec@plt>
test %eax,%eax
je 126a <func0+0x61>
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 10c0 <regfree@plt>
lea 0x2d78(%rip),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 12dc <func0+0xd3>
callq 10d0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+src], rdi
mov [rbp+var_6C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+src]
mov rsi, rax; src
lea rax, new_text_1
mov rdi, rax; dest
call _strcpy
lea rax, asc_2008; "[ ,.]"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov [rbp+var_60], 0
jmp short loc_1287
loc_126D:
mov eax, [rbp+pmatch.rm_so]
mov [rbp+var_5C], eax
mov eax, [rbp+var_5C]
cdqe
lea rdx, new_text_1
mov byte ptr [rax+rdx], 3Ah ; ':'
add [rbp+var_60], 1
loc_1287:
mov eax, [rbp+var_60]
cmp eax, [rbp+var_6C]
jge short loc_12B8
lea rdx, [rbp+pmatch]
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov rcx, rdx; pmatch
mov edx, 1; nmatch
lea rsi, new_text_1; string
mov rdi, rax; preg
call _regexec
test eax, eax
jz short loc_126D
loc_12B8:
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
lea rax, new_text_1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12DF
call ___stack_chk_fail
locret_12DF:
leave
retn | char * func0(const char *a1, int a2)
{
int i; // [rsp+10h] [rbp-60h]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
regmatch_t pmatch; // [rsp+60h] [rbp-10h] BYREF
unsigned long long v6; // [rsp+68h] [rbp-8h]
v6 = __readfsqword(0x28u);
strcpy(new_text_1, a1);
regcomp(&preg, "[ ,.]", 1);
for ( i = 0; i < a2 && !regexec(&preg, new_text_1, 1uLL, &pmatch, 0); ++i )
new_text_1[pmatch.rm_so] = 58;
regfree(&preg);
return new_text_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV dword ptr [RBP + -0x6c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010b0
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010f0
MOV dword ptr [RBP + -0x60],0x0
JMP 0x00101287
LAB_0010126d:
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x5c],EAX
MOV EAX,dword ptr [RBP + -0x5c]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x3a
ADD dword ptr [RBP + -0x60],0x1
LAB_00101287:
MOV EAX,dword ptr [RBP + -0x60]
CMP EAX,dword ptr [RBP + -0x6c]
JGE 0x001012b8
LEA RDX,[RBP + -0x10]
LEA RAX,[RBP + -0x50]
MOV R8D,0x0
MOV RCX,RDX
MOV EDX,0x1
LEA RSI,[0x104040]
MOV RDI,RAX
CALL 0x00101110
TEST EAX,EAX
JZ 0x0010126d
LAB_001012b8:
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x001010c0
LEA RAX,[0x104040]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012df
CALL 0x001010d0
LAB_001012df:
LEAVE
RET | int1 * func0(char *param_1,int param_2)
{
int iVar1;
long in_FS_OFFSET;
int local_68;
regex_t local_58;
regmatch_t local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
strcpy(new_text_1,param_1);
regcomp(&local_58,"[ ,.]",1);
for (local_68 = 0; local_68 < param_2; local_68 = local_68 + 1) {
iVar1 = regexec(&local_58,new_text_1,1,&local_18,0);
if (iVar1 != 0) break;
new_text_1[local_18.rm_so] = 0x3a;
}
regfree(&local_58);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return new_text_1;
} |
4,773 | func0 |
#include <stdio.h>
#include <regex.h>
#include <string.h>
#include <assert.h>
| char *func0(const char *text, int n) {
regex_t regex;
regmatch_t pmatch[1];
static char new_text[256];
strcpy(new_text, text);
const char *pattern = "[ ,.]";
regcomp(®ex, pattern, REG_EXTENDED);
int num_replacements = 0;
while (num_replacements < n && regexec(®ex, new_text, 1, pmatch, 0) == 0) {
int start = pmatch[0].rm_so;
new_text[start] = ':';
num_replacements++;
}
regfree(®ex);
return new_text;
}
| int main() {
assert(strcmp(func0("Python language, Programming language.", 2), "Python:language: Programming language.") == 0);
assert(strcmp(func0("a b c,d e f", 3), "a:b:c:d e f") == 0);
assert(strcmp(func0("ram reshma,ram rahim", 1), "ram:reshma,ram rahim") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %esi,%ebp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov $0x100,%edx
mov %rdi,%rsi
lea 0x2e2a(%rip),%rdi
callq 10f0 <__strcpy_chk@plt>
mov %rsp,%rdi
mov $0x1,%edx
lea 0xdda(%rip),%rsi
callq 10d0 <regcomp@plt>
mov $0x0,%ebx
lea 0x40(%rsp),%r12
test %ebp,%ebp
jle 1275 <func0+0x8c>
mov %rsp,%rdi
mov $0x0,%r8d
mov %r12,%rcx
mov $0x1,%edx
lea 0x2deb(%rip),%rsi
callq 10e0 <regexec@plt>
test %eax,%eax
jne 1275 <func0+0x8c>
movslq 0x40(%rsp),%rax
lea 0x2dd6(%rip),%rdx
movb $0x3a,(%rdx,%rax,1)
add $0x1,%ebx
cmp %ebx,%ebp
jne 123d <func0+0x54>
mov %rsp,%rdi
callq 10a0 <regfree@plt>
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 129d <func0+0xb4>
lea 0x2dac(%rip),%rax
add $0x50,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10b0 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 50h
mov r12d, esi
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov edx, 100h
mov rsi, rdi
lea rdi, new_text_1
call ___strcpy_chk
mov rdi, rsp
mov edx, 1
lea rsi, asc_2004; "[ ,.]"
call _regcomp
mov ebx, 0
lea rbp, new_text_1
test r12d, r12d
jle short loc_1292
loc_1261:
lea rcx, [rsp+68h+var_28]
mov rdi, rsp
mov r8d, 0
mov edx, 1
mov rsi, rbp
call _regexec
test eax, eax
jnz short loc_1292
movsxd rax, [rsp+68h+var_28]
mov byte ptr [rbp+rax+0], 3Ah ; ':'
add ebx, 1
cmp r12d, ebx
jnz short loc_1261
loc_1292:
mov rdi, rsp
call _regfree
mov rax, [rsp+68h+var_20]
sub rax, fs:28h
jnz short loc_12BA
lea rax, new_text_1
add rsp, 50h
pop rbx
pop rbp
pop r12
retn
loc_12BA:
call ___stack_chk_fail | _BYTE * func0(long long a1, int a2)
{
int v2; // ebx
_BYTE v4[64]; // [rsp+0h] [rbp-68h] BYREF
int v5; // [rsp+40h] [rbp-28h] BYREF
unsigned long long v6; // [rsp+48h] [rbp-20h]
v6 = __readfsqword(0x28u);
__strcpy_chk(new_text_1, a1, 256LL);
regcomp(v4, "[ ,.]", 1LL);
v2 = 0;
if ( a2 > 0 )
{
do
{
if ( (unsigned int)regexec(v4, new_text_1, 1LL, &v5, 0LL) )
break;
new_text_1[v5] = 58;
++v2;
}
while ( a2 != v2 );
}
regfree(v4);
return new_text_1;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV R12D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV EDX,0x100
MOV RSI,RDI
LEA RDI,[0x104040]
CALL 0x00101110
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102004]
CALL 0x001010e0
MOV EBX,0x0
LEA RBP,[0x104040]
TEST R12D,R12D
JLE 0x00101292
LAB_00101261:
LEA RCX,[RSP + 0x40]
MOV RDI,RSP
MOV R8D,0x0
MOV EDX,0x1
MOV RSI,RBP
CALL 0x00101100
TEST EAX,EAX
JNZ 0x00101292
MOVSXD RAX,dword ptr [RSP + 0x40]
MOV byte ptr [RBP + RAX*0x1],0x3a
ADD EBX,0x1
CMP R12D,EBX
JNZ 0x00101261
LAB_00101292:
MOV RDI,RSP
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012ba
LEA RAX,[0x104040]
ADD RSP,0x50
POP RBX
POP RBP
POP R12
RET
LAB_001012ba:
CALL 0x001010c0 | int1 * func0(int8 param_1,int param_2)
{
int iVar1;
int iVar2;
long in_FS_OFFSET;
regex_t rStack_68;
regmatch_t local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
__strcpy_chk(new_text_1,param_1,0x100);
regcomp(&rStack_68,"[ ,.]",1);
iVar2 = 0;
if (0 < param_2) {
do {
iVar1 = regexec(&rStack_68,new_text_1,1,&local_28,0);
if (iVar1 != 0) break;
new_text_1[local_28.rm_so] = 0x3a;
iVar2 = iVar2 + 1;
} while (param_2 != iVar2);
}
regfree(&rStack_68);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return new_text_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
4,774 | func0 |
#include <stdio.h>
#include <regex.h>
#include <string.h>
#include <assert.h>
| char *func0(const char *text, int n) {
regex_t regex;
regmatch_t pmatch[1];
static char new_text[256];
strcpy(new_text, text);
const char *pattern = "[ ,.]";
regcomp(®ex, pattern, REG_EXTENDED);
int num_replacements = 0;
while (num_replacements < n && regexec(®ex, new_text, 1, pmatch, 0) == 0) {
int start = pmatch[0].rm_so;
new_text[start] = ':';
num_replacements++;
}
regfree(®ex);
return new_text;
}
| int main() {
assert(strcmp(func0("Python language, Programming language.", 2), "Python:language: Programming language.") == 0);
assert(strcmp(func0("a b c,d e f", 3), "a:b:c:d e f") == 0);
assert(strcmp(func0("ram reshma,ram rahim", 1), "ram:reshma,ram rahim") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
mov $0x100,%edx
push %r14
push %r13
push %r12
push %rbp
mov %esi,%ebp
mov %rdi,%rsi
lea 0x2d42(%rip),%rdi
push %rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r15
callq 10f0 <__strcpy_chk@plt>
mov $0x1,%edx
lea 0xcdd(%rip),%rsi
mov %r15,%rdi
callq 10d0 <regcomp@plt>
test %ebp,%ebp
jle 137b <func0+0x9b>
lea 0x2d06(%rip),%r12
xor %ebx,%ebx
lea 0x40(%rsp),%r14
mov %r12,%r13
jmp 1361 <func0+0x81>
nopw %cs:0x0(%rax,%rax,1)
movslq 0x40(%rsp),%rax
add $0x1,%ebx
movb $0x3a,(%r12,%rax,1)
cmp %ebx,%ebp
je 137b <func0+0x9b>
xor %r8d,%r8d
mov %r14,%rcx
mov $0x1,%edx
mov %r13,%rsi
mov %r15,%rdi
callq 10e0 <regexec@plt>
test %eax,%eax
je 1350 <func0+0x70>
mov %r15,%rdi
callq 10a0 <regfree@plt>
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 13a9 <func0+0xc9>
add $0x58,%rsp
lea 0x2ca2(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10b0 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push r14
mov edx, 100h
push r13
push r12
lea r12, new_text_1
push rbp
mov ebp, esi
mov rsi, rdi
mov rdi, r12
push rbx
xor ebx, ebx
sub rsp, 50h
mov rax, fs:28h
mov [rsp+78h+var_30], rax
xor eax, eax
mov r14, rsp
lea r13, [rsp+78h+var_38]
call ___strcpy_chk
mov edx, 1
lea rsi, asc_2004; "[ ,.]"
mov rdi, r14
call _regcomp
test ebp, ebp
jg short loc_1361
jmp short loc_137B
loc_1350:
movsxd rax, [rsp+78h+var_38]
add ebx, 1
mov byte ptr [r12+rax], 3Ah ; ':'
cmp ebp, ebx
jz short loc_137B
loc_1361:
xor r8d, r8d
mov rcx, r13
mov edx, 1
mov rsi, r12
mov rdi, r14
call _regexec
test eax, eax
jz short loc_1350
loc_137B:
mov rdi, r14
call _regfree
mov rax, [rsp+78h+var_30]
sub rax, fs:28h
jnz short loc_13A3
add rsp, 50h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_13A3:
call ___stack_chk_fail | _BYTE * func0(long long a1, int a2)
{
int v2; // ebx
_BYTE v4[64]; // [rsp+0h] [rbp-78h] BYREF
int v5; // [rsp+40h] [rbp-38h] BYREF
unsigned long long v6; // [rsp+48h] [rbp-30h]
v2 = 0;
v6 = __readfsqword(0x28u);
__strcpy_chk(new_text_1, a1, 256LL);
regcomp(v4, "[ ,.]", 1LL);
if ( a2 > 0 )
{
do
{
if ( (unsigned int)regexec(v4, new_text_1, 1LL, &v5, 0LL) )
break;
++v2;
new_text_1[v5] = 58;
}
while ( a2 != v2 );
}
regfree(v4);
return new_text_1;
} | func0:
ENDBR64
PUSH R14
MOV EDX,0x100
PUSH R13
PUSH R12
LEA R12,[0x104040]
PUSH RBP
MOV EBP,ESI
MOV RSI,RDI
MOV RDI,R12
PUSH RBX
XOR EBX,EBX
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV R14,RSP
LEA R13,[RSP + 0x40]
CALL 0x00101110
MOV EDX,0x1
LEA RSI,[0x102004]
MOV RDI,R14
CALL 0x001010e0
TEST EBP,EBP
JG 0x00101361
JMP 0x0010137b
LAB_00101350:
MOVSXD RAX,dword ptr [RSP + 0x40]
ADD EBX,0x1
MOV byte ptr [R12 + RAX*0x1],0x3a
CMP EBP,EBX
JZ 0x0010137b
LAB_00101361:
XOR R8D,R8D
MOV RCX,R13
MOV EDX,0x1
MOV RSI,R12
MOV RDI,R14
CALL 0x00101100
TEST EAX,EAX
JZ 0x00101350
LAB_0010137b:
MOV RDI,R14
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013a3
ADD RSP,0x50
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001013a3:
CALL 0x001010c0 | int1 * func0(int8 param_1,int param_2)
{
int iVar1;
int iVar2;
long in_FS_OFFSET;
regex_t rStack_78;
regmatch_t local_38;
long local_30;
iVar2 = 0;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__strcpy_chk(new_text_1,param_1,0x100);
regcomp(&rStack_78,"[ ,.]",1);
if (0 < param_2) {
do {
iVar1 = regexec(&rStack_78,new_text_1,1,&local_38,0);
if (iVar1 != 0) break;
iVar2 = iVar2 + 1;
new_text_1[local_38.rm_so] = 0x3a;
} while (param_2 != iVar2);
}
regfree(&rStack_78);
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return new_text_1;
} |
4,775 | func0 |
#include <stdio.h>
#include <regex.h>
#include <string.h>
#include <assert.h>
| char *func0(const char *text, int n) {
regex_t regex;
regmatch_t pmatch[1];
static char new_text[256];
strcpy(new_text, text);
const char *pattern = "[ ,.]";
regcomp(®ex, pattern, REG_EXTENDED);
int num_replacements = 0;
while (num_replacements < n && regexec(®ex, new_text, 1, pmatch, 0) == 0) {
int start = pmatch[0].rm_so;
new_text[start] = ':';
num_replacements++;
}
regfree(®ex);
return new_text;
}
| int main() {
assert(strcmp(func0("Python language, Programming language.", 2), "Python:language: Programming language.") == 0);
assert(strcmp(func0("a b c,d e f", 3), "a:b:c:d e f") == 0);
assert(strcmp(func0("ram reshma,ram rahim", 1), "ram:reshma,ram rahim") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
mov $0x100,%edx
push %r14
push %r13
push %r12
push %rbp
mov %esi,%ebp
mov %rdi,%rsi
lea 0x2d42(%rip),%rdi
push %rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r15
callq 10f0 <__strcpy_chk@plt>
mov $0x1,%edx
lea 0xcdd(%rip),%rsi
mov %r15,%rdi
callq 10d0 <regcomp@plt>
test %ebp,%ebp
jle 137b <func0+0x9b>
lea 0x2d06(%rip),%r12
xor %ebx,%ebx
lea 0x40(%rsp),%r14
mov %r12,%r13
jmp 1361 <func0+0x81>
nopw %cs:0x0(%rax,%rax,1)
movslq 0x40(%rsp),%rax
add $0x1,%ebx
movb $0x3a,(%r12,%rax,1)
cmp %ebx,%ebp
je 137b <func0+0x9b>
xor %r8d,%r8d
mov %r14,%rcx
mov $0x1,%edx
mov %r13,%rsi
mov %r15,%rdi
callq 10e0 <regexec@plt>
test %eax,%eax
je 1350 <func0+0x70>
mov %r15,%rdi
callq 10a0 <regfree@plt>
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 13a9 <func0+0xc9>
add $0x58,%rsp
lea 0x2ca2(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10b0 <__stack_chk_fail@plt>
xchg %ax,%ax
| func0:
endbr64
push r14
mov edx, 100h
push r13
push r12
mov r12d, esi
mov rsi, rdi
push rbp
lea rbp, new_text_1
push rbx
mov rdi, rbp
xor ebx, ebx
sub rsp, 50h
mov rax, fs:28h
mov [rsp+78h+var_30], rax
xor eax, eax
mov r13, rsp
lea r14, [rsp+78h+pmatch]
call ___strcpy_chk
mov edx, 1; cflags
lea rsi, pattern; "[ ,.]"
mov rdi, r13; preg
call _regcomp
test r12d, r12d
jg short loc_1362
jmp short loc_137C
loc_1350:
movsxd rax, [rsp+78h+pmatch.rm_so]
add ebx, 1
mov byte ptr [rbp+rax+0], 3Ah ; ':'
cmp r12d, ebx
jz short loc_137C
loc_1362:
xor r8d, r8d; eflags
mov rcx, r14; pmatch
mov edx, 1; nmatch
mov rsi, rbp; string
mov rdi, r13; preg
call _regexec
test eax, eax
jz short loc_1350
loc_137C:
mov rdi, r13; preg
call _regfree
mov rax, [rsp+78h+var_30]
sub rax, fs:28h
jnz short loc_13A4
add rsp, 50h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_13A4:
call ___stack_chk_fail | char * func0(long long a1, int a2)
{
int v2; // ebx
regex_t v4; // [rsp+0h] [rbp-78h] BYREF
regmatch_t pmatch; // [rsp+40h] [rbp-38h] BYREF
unsigned long long v6; // [rsp+48h] [rbp-30h]
v2 = 0;
v6 = __readfsqword(0x28u);
__strcpy_chk(new_text_1, a1, 256LL);
regcomp(&v4, "[ ,.]", 1);
if ( a2 > 0 )
{
do
{
if ( regexec(&v4, new_text_1, 1uLL, &pmatch, 0) )
break;
++v2;
new_text_1[pmatch.rm_so] = 58;
}
while ( a2 != v2 );
}
regfree(&v4);
return new_text_1;
} | func0:
ENDBR64
PUSH R14
MOV EDX,0x100
PUSH R13
PUSH R12
MOV R12D,ESI
MOV RSI,RDI
PUSH RBP
LEA RBP,[0x104040]
PUSH RBX
MOV RDI,RBP
XOR EBX,EBX
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV R13,RSP
LEA R14,[RSP + 0x40]
CALL 0x00101110
MOV EDX,0x1
LEA RSI,[0x102004]
MOV RDI,R13
CALL 0x001010e0
TEST R12D,R12D
JG 0x00101362
JMP 0x0010137c
LAB_00101350:
MOVSXD RAX,dword ptr [RSP + 0x40]
ADD EBX,0x1
MOV byte ptr [RBP + RAX*0x1],0x3a
CMP R12D,EBX
JZ 0x0010137c
LAB_00101362:
XOR R8D,R8D
MOV RCX,R14
MOV EDX,0x1
MOV RSI,RBP
MOV RDI,R13
CALL 0x00101100
TEST EAX,EAX
JZ 0x00101350
LAB_0010137c:
MOV RDI,R13
CALL 0x001010b0
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013a4
ADD RSP,0x50
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001013a4:
CALL 0x001010c0 | int1 * func0(int8 param_1,int param_2)
{
int iVar1;
int iVar2;
long in_FS_OFFSET;
regex_t rStack_78;
regmatch_t local_38;
long local_30;
iVar2 = 0;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__strcpy_chk(new_text_1,param_1,0x100);
regcomp(&rStack_78,"[ ,.]",1);
if (0 < param_2) {
do {
iVar1 = regexec(&rStack_78,new_text_1,1,&local_38,0);
if (iVar1 != 0) break;
iVar2 = iVar2 + 1;
new_text_1[local_38.rm_so] = 0x3a;
} while (param_2 != iVar2);
}
regfree(&rStack_78);
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return new_text_1;
} |
4,776 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
for (int i = 0; i < size; i++) {
if (nums[i] % 2 == 0) {
return nums[i];
}
}
return -1;
}
| int main() {
int nums1[] = {1, 3, 5, 7, 4, 1, 6, 8};
int nums2[] = {2, 3, 4};
int nums3[] = {5, 6, 7};
assert(func0(nums1, 8) == 4);
assert(func0(nums2, 3) == 2);
assert(func0(nums3, 3) == 6);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ba <func0+0x51>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
jne 11b6 <func0+0x4d>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
jmp 11c7 <func0+0x5e>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
mov $0xffffffff,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_11BA
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jnz short loc_11B6
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
jmp short loc_11C7
loc_11B6:
add [rbp+var_4], 1
loc_11BA:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1181
mov eax, 0FFFFFFFFh
loc_11C7:
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 )
return *(unsigned int *)(4LL * i + a1);
}
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ba
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011b6
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
JMP 0x001011c7
LAB_001011b6:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ba:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
MOV EAX,0xffffffff
LAB_001011c7:
POP RBP
RET | int4 func0(long param_1,int param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 0xffffffff;
}
if ((*(uint *)(param_1 + (long)local_c * 4) & 1) == 0) break;
local_c = local_c + 1;
}
return *(int4 *)(param_1 + (long)local_c * 4);
} |
4,777 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
for (int i = 0; i < size; i++) {
if (nums[i] % 2 == 0) {
return nums[i];
}
}
return -1;
}
| int main() {
int nums1[] = {1, 3, 5, 7, 4, 1, 6, 8};
int nums2[] = {2, 3, 4};
int nums3[] = {5, 6, 7};
assert(func0(nums1, 8) == 4);
assert(func0(nums2, 3) == 2);
assert(func0(nums3, 3) == 6);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1194 <func0+0x2b>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov (%rax),%edx
test $0x1,%dl
je 1191 <func0+0x28>
add $0x4,%rax
cmp %rcx,%rax
jne 117c <func0+0x13>
mov $0xffffffff,%edx
mov %edx,%eax
retq
mov $0xffffffff,%edx
jmp 1191 <func0+0x28>
| func0:
endbr64
test esi, esi
jle short loc_1194
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
loc_117C:
mov edx, [rax]
test dl, 1
jz short loc_1191
add rax, 4
cmp rax, rcx
jnz short loc_117C
mov edx, 0FFFFFFFFh
loc_1191:
mov eax, edx
retn
loc_1194:
mov edx, 0FFFFFFFFh
jmp short loc_1191 | long long func0(unsigned int *a1, int a2)
{
unsigned int *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return (unsigned int)-1;
}
else
{
v2 = a1;
while ( 1 )
{
v3 = *v2;
if ( (*v2 & 1) == 0 )
break;
if ( ++v2 == &a1[a2 - 1 + 1] )
return (unsigned int)-1;
}
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101194
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
LAB_0010117c:
MOV EDX,dword ptr [RAX]
TEST DL,0x1
JZ 0x00101191
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010117c
MOV EDX,0xffffffff
LAB_00101191:
MOV EAX,EDX
RET
LAB_00101194:
MOV EDX,0xffffffff
JMP 0x00101191 | uint func0(uint *param_1,int param_2)
{
uint *puVar1;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if ((*param_1 & 1) == 0) {
return *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return 0xffffffff;
} |
4,778 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
for (int i = 0; i < size; i++) {
if (nums[i] % 2 == 0) {
return nums[i];
}
}
return -1;
}
| int main() {
int nums1[] = {1, 3, 5, 7, 4, 1, 6, 8};
int nums2[] = {2, 3, 4};
int nums3[] = {5, 6, 7};
assert(func0(nums1, 8) == 4);
assert(func0(nums2, 3) == 2);
assert(func0(nums3, 3) == 6);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1260 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
jmp 1251 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rdx,%rdi
je 1260 <func0+0x30>
mov (%rdi),%eax
test $0x1,%al
jne 1248 <func0+0x18>
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1260
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
jmp short loc_1251
loc_1248:
add rdi, 4
cmp rdi, rdx
jz short loc_1260
loc_1251:
mov eax, [rdi]
test al, 1
jnz short loc_1248
retn
loc_1260:
mov eax, 0FFFFFFFFh
retn | long long func0(unsigned int *a1, int a2)
{
long long v2; // rdx
long long result; // rax
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v2 = (long long)&a1[a2 - 1 + 1];
while ( 1 )
{
result = *a1;
if ( (result & 1) == 0 )
break;
if ( ++a1 == (unsigned int *)v2 )
return 0xFFFFFFFFLL;
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101260
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
JMP 0x00101251
LAB_00101248:
ADD RDI,0x4
CMP RDI,RDX
JZ 0x00101260
LAB_00101251:
MOV EAX,dword ptr [RDI]
TEST AL,0x1
JNZ 0x00101248
RET
LAB_00101260:
MOV EAX,0xffffffff
RET | uint func0(uint *param_1,int param_2)
{
uint *puVar1;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if ((*param_1 & 1) == 0) {
return *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return 0xffffffff;
} |
4,779 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
for (int i = 0; i < size; i++) {
if (nums[i] % 2 == 0) {
return nums[i];
}
}
return -1;
}
| int main() {
int nums1[] = {1, 3, 5, 7, 4, 1, 6, 8};
int nums2[] = {2, 3, 4};
int nums3[] = {5, 6, 7};
assert(func0(nums1, 8) == 4);
assert(func0(nums2, 3) == 2);
assert(func0(nums3, 3) == 6);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1250 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
jmp 1241 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rdx,%rdi
je 1250 <func0+0x30>
mov (%rdi),%eax
test $0x1,%al
jne 1238 <func0+0x18>
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
lea rdx, [rdi+rsi*4]
jmp short loc_1161
loc_1158:
add rdi, 4
cmp rdi, rdx
jz short loc_1170
loc_1161:
mov eax, [rdi]
test al, 1
jnz short loc_1158
retn
loc_1170:
mov eax, 0FFFFFFFFh
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int *v2; // rdx
long long result; // rax
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v2 = &a1[a2];
while ( 1 )
{
result = *a1;
if ( (result & 1) == 0 )
break;
if ( ++a1 == v2 )
return 0xFFFFFFFFLL;
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
LEA RDX,[RDI + RSI*0x4]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x4
CMP RDI,RDX
JZ 0x00101170
LAB_00101161:
MOV EAX,dword ptr [RDI]
TEST AL,0x1
JNZ 0x00101158
RET
LAB_00101170:
MOV EAX,0xffffffff
RET | uint func0(uint *param_1,int param_2)
{
uint *puVar1;
if (0 < param_2) {
puVar1 = param_1 + param_2;
do {
if ((*param_1 & 1) == 0) {
return *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return 0xffffffff;
} |
4,780 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int* test_array, int size) {
for (int i = 1; i < size; i++) {
if (sizeof(test_array[i]) != sizeof(test_array[0])) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {5, 6, 7, 3, 5, 6};
int arr2[] = {1, 2}; // Incomplete test, as third element is a string in Python.
int arr3[] = {3, 2, 1, 4, 5};
assert(func0(arr1, sizeof(arr1) / sizeof(arr1[0])) == true);
// assert line for arr2 is omitted as C cannot handle mixed data types like Python tuples.
assert(func0(arr3, sizeof(arr3) / sizeof(arr3[0])) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x1,-0x4(%rbp)
jmp 1185 <func0+0x1c>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 1
jmp short loc_1185
loc_1181:
add [rbp+var_4], 1
loc_1185:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1181
mov eax, 1
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 1; i < a2; ++i )
;
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101185
LAB_00101181:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101185:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
MOV EAX,0x1
POP RBP
RET | int8 func0(int8 param_1,int param_2)
{
int4 local_c;
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
}
return 1;
} |
4,781 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int* test_array, int size) {
for (int i = 1; i < size; i++) {
if (sizeof(test_array[i]) != sizeof(test_array[0])) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {5, 6, 7, 3, 5, 6};
int arr2[] = {1, 2}; // Incomplete test, as third element is a string in Python.
int arr3[] = {3, 2, 1, 4, 5};
assert(func0(arr1, sizeof(arr1) / sizeof(arr1[0])) == true);
// assert line for arr2 is omitted as C cannot handle mixed data types like Python tuples.
assert(func0(arr3, sizeof(arr3) / sizeof(arr3[0])) == true);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 113e <func0+0x15>
mov $0x1,%eax
add $0x1,%eax
cmp %eax,%esi
jne 1137 <func0+0xe>
mov $0x1,%eax
retq
| func0:
endbr64
cmp esi, 1
jle short loc_113E
mov eax, 1
loc_1137:
add eax, 1
cmp esi, eax
jnz short loc_1137
loc_113E:
mov eax, 1
retn | long long func0(long long a1, int a2)
{
int i; // eax
if ( a2 > 1 )
{
for ( i = 1; i != a2; ++i )
;
}
return 1LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x0010113e
MOV EAX,0x1
LAB_00101137:
ADD EAX,0x1
CMP ESI,EAX
JNZ 0x00101137
LAB_0010113e:
MOV EAX,0x1
RET | int8 func0(int8 param_1,int param_2)
{
int iVar1;
if (1 < param_2) {
iVar1 = 1;
do {
iVar1 = iVar1 + 1;
} while (param_2 != iVar1);
}
return 1;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.