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};
in... | 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
p... | 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
c... | 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));... | 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 ... | 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,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};
in... | 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
p... | 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, x... | 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;
}
... | 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... | 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... |
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 10... | 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+... | 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 pt... | 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... |
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 ... | 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+... | 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 + -0... | 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] ... | 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[... | 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,... | 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, [rb... | _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 )
... | 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 ... | 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 ... |
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] ... | 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[... | 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
jm... | 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 ... | _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;
... | 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
... | 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 = *... |
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] ... | 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[... | 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
... | 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... | _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 ... | 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,[0x1040... | 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;
d... |
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] ... | 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[... | 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)
mov... | 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... | __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
__m128... | 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 +... | 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;
uVar... |
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 ... | 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 ... | 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 + ... | 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,%... | 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 ... | 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 0x0010... | 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 != para... |
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,%rd... | 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 ... | 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 0x0010... | 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 != para... |
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,%rd... | 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... | 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 0x0010... | 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 != para... |
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(%... | 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,... | _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,... | 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 =... |
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... | 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 ... | _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 p... | 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... |
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... | 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... | _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;
r... | 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 RD... | 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];
... |
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 %r... | 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... | _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 RD... | 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];
... |
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 ... | 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... | 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 + -... | 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 %... | 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 ... | 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
MOVZ... | 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 +... |
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... | 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 shor... | 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+0x2... | 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_12... | 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
punpcklb... | 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... | 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
__m1... | 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,[RC... | 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... |
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(test... | 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(,%ra... | 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]
... | 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 EA... | 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(test... | 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(test... | 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(test... | 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
p... | 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, [... | 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 )
{
v... | 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],ED... | 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) ... |
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)... | 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),... | 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+... | _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) + ... | 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 pt... | 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 = s... |
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)... | 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,%r... | 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 ... | 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));
v1... | 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]
L... | 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 {
... |
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)... | 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
... | 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 ... | 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; // [rs... | 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 ... | 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 = puVar... |
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)... | 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
... | 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 ... | 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]... | 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:
MO... | 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) {
puVar... |
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... | 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,... | 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]... | 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+3... | 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,[R... | 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 loca... |
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... | 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),%r... | 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:0F... | 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; // ... | 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,... | 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_O... |
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... | 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 0... | 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[ra... | 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... | 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 +... | 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... |
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... | 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(,... | 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[ra... | 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; //... | 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 +... | 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... |
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>
... | 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; pat... | _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,qwo... | 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_OFFSE... |
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
... | 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 ... | _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... | 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_O... |
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 ... | 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 ... | _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 0x0010... | 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_O... |
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 ... | 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 ... | _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... | 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_O... |
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;
... | 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(test... | 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,-... | 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 ... | 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 ( (in... | 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... | 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[lo... |
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;
... | 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(test... | 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... | 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 ... | 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[resu... | 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... | 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 + ... |
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;
... | 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(test... | 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 ... | 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 ... | 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 ... | 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_001... | 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... |
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;
... | 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(test... | 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 ... | 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 ... | 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 )
... | 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_0010... | 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 (bV... |
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
... | 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+st... | 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,0... | 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)) ... |
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
... | 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
... | 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 ... | 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 + 0x2... |
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 ... | 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... | 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 0x0010... | 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 + 0x2... |
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 ... | 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, ed... | 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 ... | 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 + 0x2... |
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>... | 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, ra... | 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 0x00101... | 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
jl... | 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... | 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 + -... | 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 ... | 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 ... | 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 ... | 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 ... | 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* ... | 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
m... | 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
m... | 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 **)(8... | 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 + -0x1... | 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)... |
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* ... | 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
mo... | 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, ... | 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(*(_QW... | 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 ... | 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;
... |
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* ... | 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 ... | 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]... | 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 *... | 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]... | 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;
strc... |
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* ... | 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 ... | 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... | 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 = *... | 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 [R1... | 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);
... |
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;
} D... | 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};
DecodedL... | 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 1... | 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 ... | 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 0x00... | 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;
}
}
u... |
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;
} D... | 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};
DecodedL... | 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 ... | 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
... | 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) ==... | 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_... | 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 + ... |
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;
} D... | 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};
DecodedL... | 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,... | 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
... | 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 ... | 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 ... | 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 !... |
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;
} D... | 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};
DecodedL... | 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,... | 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 shor... | 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) == *(_DWO... | 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_00... | 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,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;
}
}
... | 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[] = {... | 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... | 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, [... | 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 *)(4L... | 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 0... | 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... |
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;
}
}
... | 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[] = {... | 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>
t... | 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 ... | 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 ( ++v... | 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
J... | 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;
... |
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;
}
}
... | 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[] = {... | 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)
a... | 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 ... | 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 == (_DWO... | 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 0x... | 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;
... |
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;
}
}
... | 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[] = {... | 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)
a... | 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 r... | 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;
... | 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,dwo... | 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 + para... |
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)... | 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... | 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 *(uns... | 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 + -0x41... | 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... |
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 $... | 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+... | 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;
... | 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 0x001011c... | 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... |
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),%... | 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 ... | 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 )
... | 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... | 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;... |
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),%... | 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 ea... | 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 )
... | 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 +... | 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;
... |
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);
... | 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 ... | 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+v... | 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 ... | 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;
loca... |
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);
... | 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 $0x... | 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... | 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)... | 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;
}
retu... |
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);
... | 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 $0x... | 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
cd... | 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 EC... | 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;
... |
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);
... | 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 $0x... | 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
cd... | 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 - ... | 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... | 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;
... |
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);
// Dete... | 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);
/... | 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>
m... | 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... | _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 * a... | 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
JM... | 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... |
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);
// Dete... | 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);
/... | 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),%ec... | 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
lo... | 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... | 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]... | 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,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);
// Dete... | 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);
/... | 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),%... | 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 ... | 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);
q... | 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
CA... | 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)... |
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);
// Dete... | 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);
/... | 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),%... | 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 ... | 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; // x... | 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 R1... | /* 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... |
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... | 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 -0x... | 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 [... | 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... | 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... | 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... |
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... | 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@pl... | 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 ... | _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... | 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
... | 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 {
... |
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... | 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 0xcd... | 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... | _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... | 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
CAL... | 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 {
... |
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... | 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 0xcd... | 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]
cal... | 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 )
{... | 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
CA... | 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 {
... |
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 -... | 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_1... | 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 0x001011b... | 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 ... | 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, ... | 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 ... | 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 $0xffff... | 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;
}
... | 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 $0xffff... | 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 ... | 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 ... | 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
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.