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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
7,082 | func0 |
#include <assert.h>
int sum_Odd(int n) {
int terms = (n + 1) / 2;
int sum1 = terms * terms;
return sum1;
}
| int func0(int l, int r) {
return sum_Odd(r) - sum_Odd(l - 1);
}
| int main() {
assert(func0(2, 5) == 8);
assert(func0(5, 7) == 12);
assert(func0(7, 13) == 40);
return 0;
}
| O2 | c | func0:
endbr64
add $0x1,%esi
mov %edi,%edx
mov %esi,%eax
shr $0x1f,%edx
shr $0x1f,%eax
add %edi,%edx
add %esi,%eax
sar %edx
sar %eax
imul %edx,%edx
imul %eax,%eax
sub %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
add esi, 1
mov edx, edi
mov eax, esi
shr edx, 1Fh
shr eax, 1Fh
add edx, edi
add eax, esi
sar edx, 1
sar eax, 1
imul edx, edx
imul eax, eax
sub eax, edx
retn | long long func0(int a1, int a2)
{
return (unsigned int)((a2 + 1) / 2 * ((a2 + 1) / 2) - a1 / 2 * (a1 / 2));
} | func0:
ENDBR64
ADD ESI,0x1
MOV EDX,EDI
MOV EAX,ESI
SHR EDX,0x1f
SHR EAX,0x1f
ADD EDX,EDI
ADD EAX,ESI
SAR EDX,0x1
SAR EAX,0x1
IMUL EDX,EDX
IMUL EAX,EAX
SUB EAX,EDX
RET | int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = (param_2 + 1) / 2;
return iVar1 * iVar1 - (param_1 / 2) * (param_1 / 2);
} |
7,083 | func0 |
#include <assert.h>
int sum_Odd(int n) {
int terms = (n + 1) / 2;
int sum1 = terms * terms;
return sum1;
}
| int func0(int l, int r) {
return sum_Odd(r) - sum_Odd(l - 1);
}
| int main() {
assert(func0(2, 5) == 8);
assert(func0(5, 7) == 12);
assert(func0(7, 13) == 40);
return 0;
}
| O3 | c | func0:
endbr64
add $0x1,%esi
mov %edi,%edx
mov %esi,%eax
shr $0x1f,%edx
shr $0x1f,%eax
add %edi,%edx
add %esi,%eax
sar %edx
sar %eax
imul %edx,%edx
imul %eax,%eax
sub %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
add esi, 1
mov edx, edi
mov eax, esi
shr edx, 1Fh
shr eax, 1Fh
add edx, edi
add eax, esi
sar edx, 1
sar eax, 1
imul edx, edx
imul eax, eax
sub eax, edx
retn | long long func0(int a1, int a2)
{
return (unsigned int)((a2 + 1) / 2 * ((a2 + 1) / 2) - a1 / 2 * (a1 / 2));
} | func0:
ENDBR64
ADD ESI,0x1
MOV EDX,EDI
MOV EAX,ESI
SHR EDX,0x1f
SHR EAX,0x1f
ADD EDX,EDI
ADD EAX,ESI
SAR EDX,0x1
SAR EAX,0x1
IMUL EDX,EDX
IMUL EAX,EAX
SUB EAX,EDX
RET | int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = (param_2 + 1) / 2;
return iVar1 * iVar1 - (param_1 / 2) * (param_1 / 2);
} |
7,084 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for(int i = 0; i < n; i++) {
sum += arr[i];
}
return sum;
}
| int main() {
int arr1[] = {1, 2, 3};
assert(func0(arr1, 3) == 6);
int arr2[] = {15, 12, 13, 10};
assert(func0(arr2, 4) == 50);
int arr3[] = {0, 1, 2};
assert(func0(arr3, 3) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a5 <func0+0x3c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11A5
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
add... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 += *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a5
LAB_00101188:
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]
ADD dwo... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
return local_10;
} |
7,085 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for(int i = 0; i < n; i++) {
sum += arr[i];
}
return sum;
}
| int main() {
int arr1[] = {1, 2, 3};
assert(func0(arr1, 3) == 6);
int arr2[] = {15, 12, 13, 10};
assert(func0(arr2, 4) == 50);
int arr3[] = {0, 1, 2};
assert(func0(arr3, 3) == 3);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 118f <func0+0x26>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 118c <func0+0x23>
| func0:
endbr64
test esi, esi
jle short loc_118F
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1181
loc_118C:
mov eax, edx
retn
loc_118F:
mov edx, 0
jmp short loc_118C | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 += *v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010118f
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101181
LAB_0010118c:
MOV EAX,EDX
RET
LAB_0010118f:
MOV EDX,0x0
JMP 0x0010118c | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
7,086 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for(int i = 0; i < n; i++) {
sum += arr[i];
}
return sum;
}
| int main() {
int arr1[] = {1, 2, 3};
assert(func0(arr1, 3) == 6);
int arr2[] = {15, 12, 13, 10};
assert(func0(arr2, 4) == 50);
int arr3[] = {0, 1, 2};
assert(func0(arr3, 3) == 3);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1168 <func0+0x28>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
add (%rdi),%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 1158 <func0+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1168
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1158:
add eax, [rdi]
add rdi, 4
cmp rdi, rdx
jnz short loc_1158
retn
loc_1168:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rdx
long long result; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
result = (unsigned int)(*a1++ + result);
while ( a1 != (_DWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101168
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
ADD EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x00101158
RET
LAB_00101168:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
}
return 0;
} |
7,087 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for(int i = 0; i < n; i++) {
sum += arr[i];
}
return sum;
}
| int main() {
int arr1[] = {1, 2, 3};
assert(func0(arr1, 3) == 6);
int arr2[] = {15, 12, 13, 10};
assert(func0(arr2, 4) == 50);
int arr3[] = {0, 1, 2};
assert(func0(arr3, 3) == 3);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 11e0 <func0+0xa0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 11e9 <func0+0xa9>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm0,%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rdx,%... | func0:
endbr64
mov rcx, rdi
test esi, esi
jle loc_11D8
lea eax, [rsi-1]
cmp eax, 2
jbe loc_11E1
mov edx, esi
mov rax, rdi
pxor xmm0, xmm0
shr edx, 2
shl rdx, 4
add rdx, rdi
xchg ax, ax
loc_1170:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
cmp ... | long long func0(const __m128i *a1, int a2)
{
const __m128i *v2; // rax
__m128i v3; // xmm0
__m128i v4; // xmm2
int v5; // edx
__m128i v6; // xmm0
long long result; // rax
long long v8; // r8
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v5 = 0;
LODWORD(result) = 0;
... | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x001011d8
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001011e1
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM0,XMM0
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP
LAB_00101170:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
CMP RAX,RDX
JNZ 0x00101170
MOVDQA XMM1,XMM0
MOV EDX,ESI
PSRLDQ XM... | int func0(int *param_1,uint param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
if ((int)param_2 < 1) {
iVar7 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar6 = 0;
iVar7 = 0;
}
else {
... |
7,088 | func0 |
#include <assert.h>
#define INT_BITS 32
| int func0(int n, int d) {
return (n << d)|(n >> (INT_BITS - d));
}
| int main() {
assert(func0(16, 2) == 64);
assert(func0(10, 2) == 40);
assert(func0(99, 3) == 792);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x8(%rbp),%eax
mov -0x4(%rbp),%edx
mov %edx,%esi
mov %eax,%ecx
shl %cl,%esi
mov $0x20,%eax
sub -0x8(%rbp),%eax
mov -0x4(%rbp),%edx
mov %eax,%ecx
sar %cl,%edx
mov %edx,%eax
or %esi,%eax
pop... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_8]
mov edx, [rbp+var_4]
mov esi, edx
mov ecx, eax
shl esi, cl
mov eax, 20h ; ' '
sub eax, [rbp+var_8]
mov edx, [rbp+var_4]
mov ecx, eax
sar edx, cl
mov eax, edx
or ... | long long func0(int a1, char a2)
{
return (a1 << a2) | (unsigned int)(a1 >> (32 - a2));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x8]
MOV EDX,dword ptr [RBP + -0x4]
MOV ESI,EDX
MOV ECX,EAX
SHL ESI,CL
MOV EAX,0x20
SUB EAX,dword ptr [RBP + -0x8]
MOV EDX,dword ptr [RBP + -0x4]
MOV ECX,EAX
SAR EDX,CL
MOV EAX,EDX
OR EAX,ESI
POP ... | uint func0(int param_1,byte param_2)
{
return param_1 >> (0x20 - param_2 & 0x1f) | param_1 << (param_2 & 0x1f);
} |
7,089 | func0 |
#include <assert.h>
#define INT_BITS 32
| int func0(int n, int d) {
return (n << d)|(n >> (INT_BITS - d));
}
| int main() {
assert(func0(16, 2) == 64);
assert(func0(10, 2) == 40);
assert(func0(99, 3) == 792);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x20,%ecx
sub %esi,%ecx
mov %edi,%eax
sar %cl,%eax
mov %esi,%ecx
shl %cl,%edi
or %edi,%eax
retq
| func0:
endbr64
mov ecx, 20h ; ' '
sub ecx, esi
mov eax, edi
sar eax, cl
mov ecx, esi
shl edi, cl
or eax, edi
retn | long long func0(int a1, char a2)
{
return (a1 << a2) | (unsigned int)(a1 >> (32 - a2));
} | ||
7,090 | func0 |
#include <assert.h>
#define INT_BITS 32
| int func0(int n, int d) {
return (n << d)|(n >> (INT_BITS - d));
}
| int main() {
assert(func0(16, 2) == 64);
assert(func0(10, 2) == 40);
assert(func0(99, 3) == 792);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x20,%ecx
mov %edi,%eax
sub %esi,%ecx
sar %cl,%eax
mov %esi,%ecx
shl %cl,%edi
or %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov ecx, 20h ; ' '
mov eax, edi
sub ecx, esi
sar eax, cl
mov ecx, esi
shl edi, cl
or eax, edi
retn | long long func0(int a1, char a2)
{
return (a1 << a2) | (unsigned int)(a1 >> (32 - a2));
} | func0:
ENDBR64
MOV ECX,0x20
MOV EAX,EDI
SUB ECX,ESI
SAR EAX,CL
MOV ECX,ESI
SHL EDI,CL
OR EAX,EDI
RET | uint func0(int param_1,byte param_2)
{
return param_1 >> (0x20 - param_2 & 0x1f) | param_1 << (param_2 & 0x1f);
} |
7,091 | func0 |
#include <assert.h>
#define INT_BITS 32
| int func0(int n, int d) {
return (n << d)|(n >> (INT_BITS - d));
}
| int main() {
assert(func0(16, 2) == 64);
assert(func0(10, 2) == 40);
assert(func0(99, 3) == 792);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x20,%ecx
mov %edi,%eax
sub %esi,%ecx
sar %cl,%eax
mov %esi,%ecx
shl %cl,%edi
or %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov ecx, 20h ; ' '
mov eax, edi
sub ecx, esi
sar eax, cl
mov ecx, esi
shl edi, cl
or eax, edi
retn | long long func0(int a1, char a2)
{
return (a1 << a2) | (unsigned int)(a1 >> (32 - a2));
} | func0:
ENDBR64
MOV ECX,0x20
MOV EAX,EDI
SUB ECX,ESI
SAR EAX,CL
MOV ECX,ESI
SHL EDI,CL
OR EAX,EDI
RET | uint func0(int param_1,byte param_2)
{
return param_1 >> (0x20 - param_2 & 0x1f) | param_1 << (param_2 & 0x1f);
} |
7,092 | func0 |
#include <assert.h>
#include <string.h>
#include <ctype.h>
| void func0(char* text, char* result) {
int i = 0, j = 0;
while (text[i]) {
if (!isspace((unsigned char) text[i])) {
result[j++] = text[i];
}
i++;
}
result[j] = '\0';
}
| int main() {
char result[100];
func0("python program", result);
assert(strcmp(result, "pythonprogram") == 0);
func0("python programming language", result);
assert(strcmp(result, "pythonprogramminglanguage") == 0);
func0("python program", result);
assert... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1227 <func0+0x7e>
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_1227
loc_11CD:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rcx, edx
mov rdx, [rbp+var_18]
add rdx, rcx
m... | _BYTE * func0(long long a1, long long a2)
{
int v2; // eax
_BYTE *result; // rax
int v4; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v4 = 0;
v5 = 0;
while ( *(_BYTE *)(v4 + a1) )
{
if ( ((*__ctype_b_loc())[*(unsigned __int8 *)(v4 + a1)] & 0x2000) == 0 )
{
v2 = v5++;
*(_BYTE ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101227
LAB_001011cd:
CALL 0x001010b0
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18... | void func0(long param_1,long param_2)
{
ushort **ppuVar1;
int local_10;
int local_c;
local_c = 0;
for (local_10 = 0; *(char *)(param_1 + local_10) != '\0'; local_10 = local_10 + 1) {
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[*(byte *)(param_1 + local_10)] & 0x2000) == 0) {
*(int *)(local_c ... |
7,093 | func0 |
#include <assert.h>
#include <string.h>
#include <ctype.h>
| void func0(char* text, char* result) {
int i = 0, j = 0;
while (text[i]) {
if (!isspace((unsigned char) text[i])) {
result[j++] = text[i];
}
i++;
}
result[j] = '\0';
}
| int main() {
char result[100];
func0("python program", result);
assert(strcmp(result, "pythonprogram") == 0);
func0("python programming language", result);
assert(strcmp(result, "pythonprogramminglanguage") == 0);
func0("python program", result);
assert... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rsi,%r12
movzbl (%rdi),%ebx
test %bl,%bl
je 11d3 <func0+0x4a>
mov %rdi,%rbp
callq 1090 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
mov $0x0,%esi
jmp 11ba <func0+0x31>
add $0x1,%rdi
movzbl -0x1(%rdi),%ebx
test %bl,%bl
je 11d8 <func0+0x4f>
... | func0:
endbr64
push r12
push rbp
push rbx
mov r12, rsi
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_11F3
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
mov esi, 0
jmp short loc_11DA
loc_11CE:
add rdi, 1
movzx ebx, byte ptr [rdi-1]
test bl, bl
jz short loc... | void func0(unsigned __int8 *a1, long long a2)
{
unsigned __int8 v3; // bl
_QWORD *v4; // rax
unsigned __int8 *v5; // rdi
int v6; // esi
v3 = *a1;
if ( *a1 )
{
v4 = (_QWORD *)__ctype_b_loc();
v5 = a1 + 1;
v6 = 0;
do
{
if ( (*(_BYTE *)(*v4 + 2LL * v3 + 1) & 0x20) == 0 )
*... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RSI
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001011f3
MOV RBP,RDI
CALL 0x001010b0
LEA RDI,[RBP + 0x1]
MOV ESI,0x0
JMP 0x001011da
LAB_001011ce:
ADD RDI,0x1
MOVZX EBX,byte ptr [RDI + -0x1]
TEST BL,BL
JZ 0x001011f8
LAB_001011da:
MOVZX EDX,BL
MOV RCX,qword ptr [RAX]
TEST by... | void func0(byte *param_1,long param_2)
{
ushort **ppuVar1;
byte bVar2;
int iVar3;
byte *pbVar4;
bVar2 = *param_1;
if (bVar2 == 0) {
iVar3 = 0;
}
else {
ppuVar1 = __ctype_b_loc();
iVar3 = 0;
pbVar4 = param_1 + 1;
do {
if ((*(byte *)((long)*ppuVar1 + (ulong)bVar2 * 2 + 1) & 0... |
7,094 | func0 |
#include <assert.h>
#include <string.h>
#include <ctype.h>
| void func0(char* text, char* result) {
int i = 0, j = 0;
while (text[i]) {
if (!isspace((unsigned char) text[i])) {
result[j++] = text[i];
}
i++;
}
result[j] = '\0';
}
| int main() {
char result[100];
func0("python program", result);
assert(strcmp(result, "pythonprogram") == 0);
func0("python programming language", result);
assert(strcmp(result, "pythonprogramminglanguage") == 0);
func0("python program", result);
assert... | O2 | c | func0:
endbr64
push %r12
mov %rsi,%r12
push %rbp
push %rbx
movzbl (%rdi),%ebx
test %bl,%bl
je 1330 <func0+0x60>
mov %rdi,%rbp
callq 1090 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %esi,%esi
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov (%rax),%r9
movzbl %bl,%edx
lea (%r12,%r8,1),%rcx
testb... | func0:
endbr64
push r12
mov r12, rsi
push rbp
push rbx
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_1321
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor r8d, r8d
nop dword ptr [rax+00000000h]
loc_12F8:
mov rcx, [rax]
movzx edx, bl
test byte ptr [rcx+rdx*2+1... | void func0(unsigned __int8 *a1, _BYTE *a2)
{
_BYTE *v2; // r12
unsigned __int8 v3; // bl
_QWORD *v4; // rax
unsigned __int8 *v5; // rdi
int v6; // r8d
long long v7; // rdx
v2 = a2;
v3 = *a1;
if ( *a1 )
{
v4 = (_QWORD *)__ctype_b_loc();
v5 = a1 + 1;
v6 = 0;
do
{
if ( (*(_B... | func0:
ENDBR64
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101321
MOV RBP,RDI
CALL 0x00101090
LEA RDI,[RBP + 0x1]
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_001012f8:
MOV RCX,qword ptr [RAX]
MOVZX EDX,BL
TEST byte ptr [RCX + RDX*0x2 + 0x1],0x20
JNZ 0x00101310
MOVSXD RDX,R8D
ADD R8D,0x1
MO... | void func0(byte *param_1,int1 *param_2)
{
ushort **ppuVar1;
long lVar2;
byte bVar3;
int iVar4;
bVar3 = *param_1;
if (bVar3 != 0) {
ppuVar1 = __ctype_b_loc();
param_1 = param_1 + 1;
iVar4 = 0;
do {
if ((*(byte *)((long)*ppuVar1 + (ulong)bVar3 * 2 + 1) & 0x20) == 0) {
lVar2 =... |
7,095 | func0 |
#include <assert.h>
#include <string.h>
#include <ctype.h>
| void func0(char* text, char* result) {
int i = 0, j = 0;
while (text[i]) {
if (!isspace((unsigned char) text[i])) {
result[j++] = text[i];
}
i++;
}
result[j] = '\0';
}
| int main() {
char result[100];
func0("python program", result);
assert(strcmp(result, "pythonprogram") == 0);
func0("python programming language", result);
assert(strcmp(result, "pythonprogramminglanguage") == 0);
func0("python program", result);
assert... | O3 | c | func0:
endbr64
push %r12
mov %rsi,%r12
push %rbp
push %rbx
movzbl (%rdi),%ebx
test %bl,%bl
je 1340 <func0+0x70>
mov %rdi,%rbp
callq 1090 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %esi,%esi
xor %ecx,%ecx
jmp 1310 <func0+0x40>
nopl 0x0(%rax)
add $0x1,%rdi
mov %bl,(%rdx)
add $0x1... | func0:
endbr64
push r12
mov r12, rsi
push rbp
push rbx
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_132A
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor edx, edx
jmp short loc_130E
loc_12F8:
add rdi, 1
mov [r12+rdx], bl
lea ecx, [rdx+1]
movzx ebx, byte... | void func0(unsigned __int8 *a1, _BYTE *a2)
{
_BYTE *v2; // r12
unsigned __int8 v3; // bl
const unsigned __int16 **v4; // rax
unsigned __int8 *v5; // rdi
long long v6; // rdx
v2 = a2;
v3 = *a1;
if ( *a1 )
{
v4 = __ctype_b_loc();
v5 = a1 + 1;
v6 = 0LL;
do
{
while ( ((*v4)[v3]... | func0:
ENDBR64
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x0010132a
MOV RBP,RDI
CALL 0x00101090
LEA RDI,[RBP + 0x1]
XOR EDX,EDX
JMP 0x0010130e
LAB_001012f8:
ADD RDI,0x1
MOV byte ptr [R12 + RDX*0x1],BL
LEA ECX,[RDX + 0x1]
MOVZX EBX,byte ptr [RDI + -0x1]
MOVSXD RDX,ECX
TEST BL,BL
JZ 0x... | void func0(byte *param_1,int *param_2)
{
ushort **ppuVar1;
long lVar2;
byte bVar3;
byte *pbVar4;
bVar3 = *param_1;
if (bVar3 != 0) {
ppuVar1 = __ctype_b_loc();
lVar2 = 0;
pbVar4 = param_1 + 1;
do {
while ((*(byte *)((long)*ppuVar1 + (ulong)bVar3 * 2 + 1) & 0x20) != 0) {
bVa... |
7,096 | func0 |
#include <assert.h>
| int func0(int x, int y, int z) {
int result[3] = {x, y, z};
int unique_values = 0;
int counts[3] = {0, 0, 0};
for (int i = 0; i < 3; i++) {
int found = 0;
for (int j = 0; j < i; j++) {
if (result[j] == result[i]) {
found = 1;
break;
... | int main() {
assert(func0(1, 1, 1) == 3);
assert(func0(-1, -2, -3) == 0);
assert(func0(1, 2, 2) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %edi,-0x34(%rbp)
mov %esi,-0x38(%rbp)
mov %edx,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x34(%rbp),%eax
mov %eax,-0x20(%rbp)
mov -0x38(%rbp),%eax
mov %eax,-0x1c(%rbp)
mov -0x3c(%rbp),%eax
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov [rbp+var_38], esi
mov [rbp+var_3C], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_34]
mov [rbp+var_20], eax
mov eax, [rbp+var_38]
mov [rbp+var_1C], eax
mov eax, [r... | long long func0(int a1, int a2, int a3)
{
int v4; // [rsp+10h] [rbp-30h]
int i; // [rsp+14h] [rbp-2Ch]
int v6; // [rsp+18h] [rbp-28h]
int j; // [rsp+1Ch] [rbp-24h]
_DWORD v8[6]; // [rsp+20h] [rbp-20h]
unsigned long long v9; // [rsp+38h] [rbp-8h]
v9 = __readfsqword(0x28u);
v8[0] = a1;
v8[1] = a2;
v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV dword ptr [RBP + -0x38],ESI
MOV dword ptr [RBP + -0x3c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x38]
MOV dwor... | int func0(int param_1,int4 param_2,int4 param_3)
{
bool bVar1;
long in_FS_OFFSET;
int local_38;
int local_34;
int local_2c;
int local_28 [6];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_28[0] = param_1;
local_28[1] = param_2;
local_28[2] = param_3;
local_38 = 0;
local_2... |
7,097 | func0 |
#include <assert.h>
| int func0(int x, int y, int z) {
int result[3] = {x, y, z};
int unique_values = 0;
int counts[3] = {0, 0, 0};
for (int i = 0; i < 3; i++) {
int found = 0;
for (int j = 0; j < i; j++) {
if (result[j] == result[i]) {
found = 1;
break;
... | int main() {
assert(func0(1, 1, 1) == 3);
assert(func0(-1, -2, -3) == 0);
assert(func0(1, 2, 2) == 2);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov %edi,0xc(%rsp)
mov %esi,0x10(%rsp)
mov %edx,0x14(%rsp)
mov $0x0,%edi
mov $0x0,%r8d
jmp 11d1 <func0+0x68>
mov $0x4,%eax
sub %r8d,%eax
cmp $0x3,%r8d
mov $0x0,%edx
cmove %edx,%eax
mov 0x18(%r... | func0:
endbr64
sub rsp, 28h
mov rax, fs:28h
mov [rsp+28h+var_10], rax
xor eax, eax
mov [rsp+28h+var_1C], edi
mov [rsp+28h+var_18], esi
mov [rsp+28h+var_14], edx
mov edi, 0
mov r8d, 0
jmp short loc_11D1
loc_119A:
mov eax, 4
sub eax, r8d
cmp r8d, 3
mov edx, 0
cmovz ... | long long func0(int a1, int a2, int a3)
{
long long v3; // rdi
int v4; // r8d
long long result; // rax
long long v6; // rax
_DWORD v7[3]; // [rsp+Ch] [rbp-1Ch]
unsigned long long v8; // [rsp+18h] [rbp-10h]
v8 = __readfsqword(0x28u);
v7[0] = a1;
v7[1] = a2;
v7[2] = a3;
v3 = 0LL;
v4 = 0;
do
... | func0:
ENDBR64
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0xc],EDI
MOV dword ptr [RSP + 0x10],ESI
MOV dword ptr [RSP + 0x14],EDX
MOV EDI,0x0
MOV R8D,0x0
JMP 0x001011d1
LAB_0010119a:
MOV EAX,0x4
SUB EAX,R8D
CMP R8D,0x3
MOV EDX,0x0
CMOVZ EAX,EDX
MOV RDX,qword ... | int func0(int param_1,int4 param_2,int4 param_3)
{
int iVar1;
long lVar2;
long lVar3;
int iVar4;
long in_FS_OFFSET;
int local_1c [3];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1c[0] = param_1;
local_1c[1] = param_2;
local_1c[2] = param_3;
lVar3 = 0;
iVar4 = 0;
do {
... |
7,098 | func0 |
#include <assert.h>
| int func0(int x, int y, int z) {
int result[3] = {x, y, z};
int unique_values = 0;
int counts[3] = {0, 0, 0};
for (int i = 0; i < 3; i++) {
int found = 0;
for (int j = 0; j < i; j++) {
if (result[j] == result[i]) {
found = 1;
break;
... | int main() {
assert(func0(1, 1, 1) == 3);
assert(func0(-1, -2, -3) == 0);
assert(func0(1, 2, 2) == 2);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x28,%rsp
xor %r8d,%r8d
xor %r10d,%r10d
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov %edi,0xc(%rsp)
lea 0xc(%rsp),%r9
mov %esi,0x10(%rsp)
mov %edx,0x14(%rsp)
test %r8,%r8
je 1458 <func0+0x98>
lea -0x1(%r8),%edx
mov (%r9,%r8,4),%ecx
mov %r9,%rax... | func0:
endbr64
sub rsp, 28h
xor r8d, r8d
xor r10d, r10d
mov rax, fs:28h
mov [rsp+28h+var_10], rax
xor eax, eax
mov [rsp+28h+var_1C], edi
lea r9, [rsp+28h+var_1C]
mov [rsp+28h+var_18], esi
mov [rsp+28h+var_14], edx
loc_125F:
test r8, r8
jz short loc_12C0
lea edx, [r8-1... | long long func0(int a1, int a2, int a3)
{
long long v3; // r8
int v4; // r10d
_DWORD *v5; // rax
int v6; // edx
long long result; // rax
_DWORD v8[3]; // [rsp+Ch] [rbp-1Ch] BYREF
unsigned long long v9; // [rsp+18h] [rbp-10h]
v3 = 0LL;
v4 = 0;
v9 = __readfsqword(0x28u);
v8[0] = a1;
v8[1] = a2;
... | func0:
ENDBR64
SUB RSP,0x28
XOR R8D,R8D
XOR R10D,R10D
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0xc],EDI
LEA R9,[RSP + 0xc]
MOV dword ptr [RSP + 0x10],ESI
MOV dword ptr [RSP + 0x14],EDX
LAB_0010125f:
TEST R8,R8
JZ 0x001012c0
LEA EDX,[R8 + -0x1]
MOV ECX,dword ptr [R9 + R... | int func0(int param_1,int4 param_2,int4 param_3)
{
int *piVar1;
int *piVar2;
int iVar3;
long lVar4;
int iVar5;
long in_FS_OFFSET;
int local_1c [3];
long local_10;
lVar4 = 0;
iVar5 = 0;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1c[1] = param_2;
local_1c[2] = param_3;
do {
while... |
7,099 | func0 |
#include <assert.h>
| int func0(int x, int y, int z) {
int result[3] = {x, y, z};
int unique_values = 0;
int counts[3] = {0, 0, 0};
for (int i = 0; i < 3; i++) {
int found = 0;
for (int j = 0; j < i; j++) {
if (result[j] == result[i]) {
found = 1;
break;
... | int main() {
assert(func0(1, 1, 1) == 3);
assert(func0(-1, -2, -3) == 0);
assert(func0(1, 2, 2) == 2);
return 0;
}
| O3 | c | func0:
endbr64
xor %ecx,%ecx
cmp %esi,%edi
setne %cl
add $0x1,%ecx
cmp %edx,%edi
je 1162 <func0+0x22>
cmp %edx,%esi
je 1162 <func0+0x22>
xor %eax,%eax
cmp $0x2,%ecx
je 1170 <func0+0x30>
mov $0x2,%ecx
mov $0x4,%eax
sub %ecx,%eax
retq
nopw 0x0(%rax,%rax,1)
retq
nopw %cs:0x0(... | func0:
endbr64
cmp edi, esi
jz short loc_1230
cmp edi, edx
jz short loc_1223
xor eax, eax
cmp esi, edx
jz short loc_1223
retn
loc_1223:
mov edx, 2
loc_1228:
mov eax, 4
sub eax, edx
retn
loc_1230:
cmp edi, edx
setnz dl
movzx edx, dl
add edx, 1
jmp short loc_1228 | long long func0(int a1, int a2, int a3)
{
long long result; // rax
int v4; // edx
if ( a1 == a2 )
{
v4 = (a1 != a3) + 1;
return (unsigned int)(4 - v4);
}
if ( a1 == a3 || (result = 0LL, a2 == a3) )
{
v4 = 2;
return (unsigned int)(4 - v4);
}
return result;
} | func0:
ENDBR64
CMP EDI,ESI
JZ 0x00101230
CMP EDI,EDX
JZ 0x00101223
XOR EAX,EAX
CMP ESI,EDX
JZ 0x00101223
RET
LAB_00101223:
MOV EDX,0x2
LAB_00101228:
MOV EAX,0x4
SUB EAX,EDX
RET
LAB_00101230:
CMP EDI,EDX
SETNZ DL
MOVZX EDX,DL
ADD EDX,0x1
JMP 0x00101228 | int func0(int param_1,int param_2,int param_3)
{
int iVar1;
if (param_1 == param_2) {
iVar1 = (param_1 != param_3) + 1;
}
else {
if ((param_1 != param_3) && (param_2 != param_3)) {
return 0;
}
iVar1 = 2;
}
return 4 - iVar1;
} |
7,100 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
for (int i = 1; i < n; i++) {
if (arr[i] < arr[i - 1]) {
return i;
}
}
return 0;
}
| int main() {
int arr1[] = {3, 2, 1};
int arr2[] = {4, 5, 1, 2, 3};
int arr3[] = {7, 8, 9, 1, 2, 3};
assert(func0(arr1, 3) == 1);
assert(func0(arr2, 5) == 2);
assert(func0(arr3, 6) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x1,-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),%edx
mov -0x4(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rcx... | 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_11BA
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
shl rax, 2
lea ... | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 1; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) < *(_DWORD *)(4LL * i - 4 + a1) )
return (unsigned int)i;
}
return 0LL;
} | 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 0x001011ba
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SH... | int func0(long param_1,int param_2)
{
int local_c;
local_c = 1;
while( true ) {
if (param_2 <= local_c) {
return 0;
}
if (*(int *)(param_1 + (long)local_c * 4) < *(int *)(param_1 + (long)local_c * 4 + -4)) break;
local_c = local_c + 1;
}
return local_c;
} |
7,101 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
for (int i = 1; i < n; i++) {
if (arr[i] < arr[i - 1]) {
return i;
}
}
return 0;
}
| int main() {
int arr1[] = {3, 2, 1};
int arr2[] = {4, 5, 1, 2, 3};
int arr3[] = {7, 8, 9, 1, 2, 3};
assert(func0(arr1, 3) == 1);
assert(func0(arr2, 5) == 2);
assert(func0(arr3, 6) == 3);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 119a <func0+0x31>
lea -0x2(%rsi),%edx
add $0x2,%rdx
mov $0x1,%eax
mov %eax,%ecx
mov -0x4(%rdi,%rax,4),%esi
cmp %esi,(%rdi,%rax,4)
jl 1197 <func0+0x2e>
add $0x1,%rax
cmp %rdx,%rax
jne 117e <func0+0x15>
mov $0x0,%ecx
mov %ecx,%eax
retq
mov $0x... | func0:
endbr64
cmp esi, 1
jle short loc_1195
mov esi, esi
mov eax, 1
loc_1179:
mov edx, eax
mov ecx, [rdi+rax*4-4]
cmp [rdi+rax*4], ecx
jl short loc_1192
add rax, 1
cmp rax, rsi
jnz short loc_1179
mov edx, 0
loc_1192:
mov eax, edx
retn
loc_1195:
mov edx, 0
jmp ... | long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int v3; // edx
if ( a2 <= 1 )
{
return 0;
}
else
{
v2 = 1LL;
while ( 1 )
{
v3 = v2;
if ( *(_DWORD *)(a1 + 4 * v2) < *(_DWORD *)(a1 + 4 * v2 - 4) )
break;
if ( ++v2 == a2 )
return 0;
... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101195
MOV ESI,ESI
MOV EAX,0x1
LAB_00101179:
MOV EDX,EAX
MOV ECX,dword ptr [RDI + RAX*0x4 + -0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JL 0x00101192
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101179
MOV EDX,0x0
LAB_00101192:
MOV EAX,EDX
RET
LAB_00101195:
MOV EDX,0x0
JMP 0x00101192 | ulong func0(long param_1,uint param_2)
{
ulong uVar1;
if (1 < (int)param_2) {
uVar1 = 1;
do {
if (*(int *)(param_1 + uVar1 * 4) < *(int *)(param_1 + -4 + uVar1 * 4)) {
return uVar1 & 0xffffffff;
}
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
}
return 0;
} |
7,102 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
for (int i = 1; i < n; i++) {
if (arr[i] < arr[i - 1]) {
return i;
}
}
return 0;
}
| int main() {
int arr1[] = {3, 2, 1};
int arr2[] = {4, 5, 1, 2, 3};
int arr3[] = {7, 8, 9, 1, 2, 3};
assert(func0(arr1, 3) == 1);
assert(func0(arr2, 5) == 2);
assert(func0(arr3, 6) == 3);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 1180 <func0+0x40>
lea -0x2(%rsi),%edx
mov $0x1,%eax
add $0x2,%rdx
jmp 1169 <func0+0x29>
nopw 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %rdx,%rax
je 1180 <func0+0x40>
mov -0x4(%rdi,%rax,4),%ecx
mov %eax,%r8d
cmp %ecx,(%rdi,%rax,4)
jge 1160 <func0+0x20>
... | func0:
endbr64
cmp esi, 1
jle short loc_12E8
movsxd rsi, esi
mov eax, 1
jmp short loc_12D1
loc_12C8:
add rax, 1
cmp rax, rsi
jz short loc_12E8
loc_12D1:
mov edx, [rdi+rax*4-4]
mov r8d, eax
cmp [rdi+rax*4], edx
jge short loc_12C8
mov eax, r8d
retn
loc_12E8:
xor r8d, ... | long long func0(long long a1, int a2)
{
long long result; // rax
if ( a2 <= 1 )
return 0LL;
result = 1LL;
while ( *(_DWORD *)(a1 + 4 * result) >= *(_DWORD *)(a1 + 4 * result - 4) )
{
if ( ++result == a2 )
return 0LL;
}
return (unsigned int)result;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001012e8
MOVSXD RSI,ESI
MOV EAX,0x1
JMP 0x001012d1
LAB_001012c8:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x001012e8
LAB_001012d1:
MOV EDX,dword ptr [RDI + RAX*0x4 + -0x4]
MOV R8D,EAX
CMP dword ptr [RDI + RAX*0x4],EDX
JGE 0x001012c8
MOV EAX,R8D
RET
LAB_001012e8:
XOR R8D,R8D
MOV EAX,R8D
RET | ulong func0(long param_1,int param_2)
{
ulong uVar1;
if (1 < param_2) {
uVar1 = 1;
do {
if (*(int *)(param_1 + uVar1 * 4) < *(int *)(param_1 + -4 + uVar1 * 4)) {
return uVar1 & 0xffffffff;
}
uVar1 = uVar1 + 1;
} while (uVar1 != (long)param_2);
}
return 0;
} |
7,103 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
for (int i = 1; i < n; i++) {
if (arr[i] < arr[i - 1]) {
return i;
}
}
return 0;
}
| int main() {
int arr1[] = {3, 2, 1};
int arr2[] = {4, 5, 1, 2, 3};
int arr3[] = {7, 8, 9, 1, 2, 3};
assert(func0(arr1, 3) == 1);
assert(func0(arr2, 5) == 2);
assert(func0(arr3, 6) == 3);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 1240 <func0+0x40>
sub $0x2,%esi
mov (%rdi),%edx
mov $0x1,%eax
add $0x2,%rsi
jmp 1229 <func0+0x29>
nopl 0x0(%rax)
add $0x1,%rax
cmp %rsi,%rax
je 1240 <func0+0x40>
mov %edx,%ecx
mov (%rdi,%rax,4),%edx
mov %eax,%r8d
cmp %ecx,%edx
jge 1220 <fu... | func0:
endbr64
cmp esi, 1
jle short loc_1170
mov edx, [rdi]
mov esi, esi
mov eax, 1
jmp short loc_1161
loc_1158:
add rax, 1
cmp rax, rsi
jz short loc_1170
loc_1161:
mov ecx, edx
mov edx, [rdi+rax*4]
cmp edx, ecx
jge short loc_1158
retn
loc_1170:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
int v2; // edx
long long result; // rax
int v4; // ecx
if ( a2 <= 1 )
return 0LL;
v2 = *a1;
result = 1LL;
while ( 1 )
{
v4 = v2;
v2 = a1[result];
if ( v2 < v4 )
break;
if ( ++result == a2 )
return 0LL;
}
return result;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101170
MOV EDX,dword ptr [RDI]
MOV ESI,ESI
MOV EAX,0x1
JMP 0x00101161
LAB_00101158:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x00101170
LAB_00101161:
MOV ECX,EDX
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,ECX
JGE 0x00101158
RET
LAB_00101170:
XOR EAX,EAX
RET | ulong func0(int *param_1,uint param_2)
{
int *piVar1;
ulong uVar2;
int iVar3;
if (1 < (int)param_2) {
uVar2 = 1;
iVar3 = *param_1;
do {
piVar1 = param_1 + uVar2;
if (*piVar1 < iVar3) {
return uVar2;
}
uVar2 = uVar2 + 1;
iVar3 = *piVar1;
} while (uVar2 !=... |
7,104 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
if ((n % i == 0) && (n / i == i)) {
return true;
}
i = i + 1;
}
return false;
}
| int main() {
assert(func0(10) == false);
assert(func0(36) == true);
assert(func0(14) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x1,-0x4(%rbp)
jmp 1181 <func0+0x38>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 117d <func0+0x34>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
cmp %eax,-0x4(%rbp)
jne 117d <func0+0x34>
mov... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 1
jmp short loc_1181
loc_115D:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_117D
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
cmp [rbp+var_4], eax
jnz shor... | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
for ( i = 1; a1 >= i * i; ++i )
{
if ( !(a1 % i) && i == a1 / i )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101181
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x0010117d
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
CMP dword ptr [RBP + -0x... | int [16] func0(int param_1,int8 param_2,ulong param_3)
{
int8 uVar1;
int auVar2 [16];
int4 local_c;
local_c = 1;
do {
if (param_1 < local_c * local_c) {
uVar1 = 0;
LAB_00101191:
auVar2._8_8_ = param_3;
auVar2._0_8_ = uVar1;
return auVar2;
}
param_3 = (long)param_1 % (l... |
7,105 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
if ((n % i == 0) && (n / i == i)) {
return true;
}
i = i + 1;
}
return false;
}
| int main() {
assert(func0(10) == false);
assert(func0(36) == true);
assert(func0(14) == false);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1182 <func0+0x39>
mov $0x1,%ecx
jmp 1164 <func0+0x1b>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg 117c <func0+0x33>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1158 <func0+0xf>
mov %edi,%eax
cltd
idiv %ecx
cmp %ecx,%eax
jn... | func0:
endbr64
test edi, edi
jle short loc_1182
mov ecx, 1
jmp short loc_1164
loc_1158:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jg short loc_117C
loc_1164:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_1158
mov eax, edi
cdq
idiv ecx
cmp eax,... | long long func0(int a1)
{
int v1; // ecx
if ( a1 <= 0 )
return 0LL;
v1 = 1;
do
{
if ( !(a1 % v1) && a1 / v1 == v1 )
return 1LL;
++v1;
}
while ( v1 * v1 <= a1 );
return 0LL;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101182
MOV ECX,0x1
JMP 0x00101164
LAB_00101158:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x0010117c
LAB_00101164:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101158
MOV EAX,EDI
CDQ
IDIV ECX
CMP EAX,ECX
JNZ 0x00101158
MOV EAX,0x1
RET
LAB_0010117c:
MOV EAX,0x0
RET
LAB_0010... | int1 [16] func0(int param_1,int8 param_2,ulong param_3)
{
int1 auVar1 [16];
int1 auVar2 [16];
int iVar3;
int1 auVar4 [16];
if (param_1 < 1) {
auVar2._8_8_ = 0;
auVar2._0_8_ = param_3;
return auVar2 << 0x40;
}
iVar3 = 1;
while ((auVar4._8_8_ = (long)param_1 % (long)iVar3 & 0xffffffff,
... |
7,106 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
if ((n % i == 0) && (n / i == i)) {
return true;
}
i = i + 1;
}
return false;
}
| int main() {
assert(func0(10) == false);
assert(func0(36) == true);
assert(func0(14) == false);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1269 <func0+0x29>
mov $0x1,%ecx
nopl (%rax)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 125d <func0+0x1d>
cmp %ecx,%eax
je 1270 <func0+0x30>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle 1250 <func0+0x10>
xor %eax,%eax
retq... | func0:
endbr64
test edi, edi
jle short loc_1219
mov ecx, 1
nop dword ptr [rax]
loc_1200:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_120D
cmp eax, ecx
jz short loc_1220
loc_120D:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short loc_1200
loc_... | long long func0(int a1)
{
int v1; // ecx
if ( a1 <= 0 )
return 0LL;
v1 = 1;
while ( a1 % v1 || a1 / v1 != v1 )
{
++v1;
if ( v1 * v1 > a1 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101219
MOV ECX,0x1
NOP dword ptr [RAX]
LAB_00101200:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010120d
CMP EAX,ECX
JZ 0x00101220
LAB_0010120d:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JLE 0x00101200
LAB_00101219:
XOR EAX,EAX
RET
LAB_00101220:
MOV EAX,0x1
RET | int8 func0(int param_1)
{
int iVar1;
if (0 < param_1) {
iVar1 = 1;
do {
if ((param_1 % iVar1 == 0) && (param_1 / iVar1 == iVar1)) {
return 1;
}
iVar1 = iVar1 + 1;
} while (iVar1 * iVar1 <= param_1);
}
return 0;
} |
7,107 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
if ((n % i == 0) && (n / i == i)) {
return true;
}
i = i + 1;
}
return false;
}
| int main() {
assert(func0(10) == false);
assert(func0(36) == true);
assert(func0(14) == false);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1269 <func0+0x29>
mov $0x1,%ecx
nopl (%rax)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 125d <func0+0x1d>
cmp %ecx,%eax
je 1270 <func0+0x30>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle 1250 <func0+0x10>
xor %eax,%eax
retq... | func0:
endbr64
test edi, edi
jle short loc_1269
mov ecx, 1
nop dword ptr [rax]
loc_1250:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_125D
cmp eax, ecx
jz short loc_1270
loc_125D:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle short loc_1250
loc_... | long long func0(int a1)
{
int v1; // ecx
if ( a1 <= 0 )
return 0LL;
v1 = 1;
while ( a1 % v1 || a1 / v1 != v1 )
{
++v1;
if ( v1 * v1 > a1 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101269
MOV ECX,0x1
NOP dword ptr [RAX]
LAB_00101250:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010125d
CMP EAX,ECX
JZ 0x00101270
LAB_0010125d:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JLE 0x00101250
LAB_00101269:
XOR EAX,EAX
RET
LAB_00101270:
MOV EAX,0x1
RET | int8 func0(int param_1)
{
int iVar1;
if (0 < param_1) {
iVar1 = 1;
do {
if ((param_1 % iVar1 == 0) && (param_1 / iVar1 == iVar1)) {
return 1;
}
iVar1 = iVar1 + 1;
} while (iVar1 * iVar1 <= param_1);
}
return 0;
} |
7,108 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int arr[], int n) {
for (int i = 0; i < n; i++) {
if ((arr[i] & 1) == 0) {
return true;
}
}
return false;
}
| int main() {
int arr1[] = {1, 2, 3};
assert(func0(arr1, 3) == true);
int arr2[] = {1, 2, 1, 4};
assert(func0(arr2, 4) == true);
int arr3[] = {1, 1};
assert(func0(arr3, 2) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a9 <func0+0x40>
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 11a5 <func0+0x3c>
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_11A9
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 1LL;
}
return 0LL;
} | 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 0x001011a9
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 0x001011a... | int8 func0(long param_1,int param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 0;
}
if ((*(uint *)(param_1 + (long)local_c * 4) & 1) == 0) break;
local_c = local_c + 1;
}
return 1;
} |
7,109 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int arr[], int n) {
for (int i = 0; i < n; i++) {
if ((arr[i] & 1) == 0) {
return true;
}
}
return false;
}
| int main() {
int arr1[] = {1, 2, 3};
assert(func0(arr1, 3) == true);
int arr2[] = {1, 2, 1, 4};
assert(func0(arr2, 4) == true);
int arr3[] = {1, 1};
assert(func0(arr3, 2) == false);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1190 <func0+0x27>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdx
testb $0x1,(%rax)
je 1196 <func0+0x2d>
add $0x4,%rax
cmp %rdx,%rax
jne 117c <func0+0x13>
mov $0x0,%eax
retq
mov $0x0,%eax
retq
mov $0x1,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_1190
mov rax, rdi
lea edx, [rsi-1]
lea rdx, [rdi+rdx*4+4]
loc_117C:
test byte ptr [rax], 1
jz short loc_1196
add rax, 4
cmp rax, rdx
jnz short loc_117C
mov eax, 0
retn
loc_1190:
mov eax, 0
retn
loc_1196:
mov eax, 1
retn | long long func0(_BYTE *a1, int a2)
{
_BYTE *v2; // rax
if ( a2 <= 0 )
return 0LL;
v2 = a1;
while ( (*v2 & 1) != 0 )
{
v2 += 4;
if ( v2 == &a1[4 * (a2 - 1) + 4] )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101190
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RDX,[RDI + RDX*0x4 + 0x4]
LAB_0010117c:
TEST byte ptr [RAX],0x1
JZ 0x00101196
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x0010117c
MOV EAX,0x0
RET
LAB_00101190:
MOV EAX,0x0
RET
LAB_00101196:
MOV EAX,0x1
RET | int8 func0(byte *param_1,int param_2)
{
byte *pbVar1;
if (param_2 < 1) {
return 0;
}
pbVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
do {
if ((*param_1 & 1) == 0) {
return 1;
}
param_1 = param_1 + 4;
} while (param_1 != pbVar1);
return 0;
} |
7,110 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int arr[], int n) {
for (int i = 0; i < n; i++) {
if ((arr[i] & 1) == 0) {
return true;
}
}
return false;
}
| int main() {
int arr1[] = {1, 2, 3};
assert(func0(arr1, 3) == true);
int arr2[] = {1, 2, 1, 4};
assert(func0(arr2, 4) == true);
int arr3[] = {1, 1};
assert(func0(arr3, 2) == false);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1170 <func0+0x30>
testb $0x1,(%rdi)
jne 1158 <func0+0x18>
mov $0x1,%eax
retq
nopl 0x0(%rax)
xor %eax,%eax
ret... | func0:
endbr64
test esi, esi
jle short loc_1170
lea eax, [rsi-1]
lea rax, [rdi+rax*4+4]
jmp short loc_1161
loc_1158:
add rdi, 4
cmp rdi, rax
jz short loc_1170
loc_1161:
test byte ptr [rdi], 1
jnz short loc_1158
mov eax, 1
retn
loc_1170:
xor eax, eax
retn | long long func0(_BYTE *a1, int a2)
{
long long v2; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[4 * (a2 - 1) + 4];
while ( (*a1 & 1) != 0 )
{
a1 += 4;
if ( a1 == (_BYTE *)v2 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
LEA EAX,[RSI + -0x1]
LEA RAX,[RDI + RAX*0x4 + 0x4]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101170
LAB_00101161:
TEST byte ptr [RDI],0x1
JNZ 0x00101158
MOV EAX,0x1
RET
LAB_00101170:
XOR EAX,EAX
RET | int8 func0(byte *param_1,int param_2)
{
byte *pbVar1;
if (0 < param_2) {
pbVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
do {
if ((*param_1 & 1) == 0) {
return 1;
}
param_1 = param_1 + 4;
} while (param_1 != pbVar1);
}
return 0;
} |
7,111 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int arr[], int n) {
for (int i = 0; i < n; i++) {
if ((arr[i] & 1) == 0) {
return true;
}
}
return false;
}
| int main() {
int arr1[] = {1, 2, 3};
assert(func0(arr1, 3) == true);
int arr2[] = {1, 2, 1, 4};
assert(func0(arr2, 4) == true);
int arr3[] = {1, 1};
assert(func0(arr3, 2) == false);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1170 <func0+0x30>
testb $0x1,(%rdi)
jne 1158 <func0+0x18>
mov $0x1,%eax
retq
nopl 0x0(%rax)
xor %eax,%eax
ret... | func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
lea rax, [rdi+rsi*4]
jmp short loc_1161
loc_1158:
add rdi, 4
cmp rdi, rax
jz short loc_1170
loc_1161:
test byte ptr [rdi], 1
jnz short loc_1158
mov eax, 1
retn
loc_1170:
xor eax, eax
retn | long long func0(_BYTE *a1, int a2)
{
_BYTE *v2; // rax
if ( a2 <= 0 )
return 0LL;
v2 = &a1[4 * a2];
while ( (*a1 & 1) != 0 )
{
a1 += 4;
if ( a1 == v2 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
LEA RAX,[RDI + RSI*0x4]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101170
LAB_00101161:
TEST byte ptr [RDI],0x1
JNZ 0x00101158
MOV EAX,0x1
RET
LAB_00101170:
XOR EAX,EAX
RET | int8 func0(byte *param_1,int param_2)
{
byte *pbVar1;
if (0 < param_2) {
pbVar1 = param_1 + (long)param_2 * 4;
do {
if ((*param_1 & 1) == 0) {
return 1;
}
param_1 = param_1 + 4;
} while (param_1 != pbVar1);
}
return 0;
} |
7,112 | func0 |
#include <assert.h>
#include <stdio.h>
#include <string.h>
| int* func0(int lists[][3], int num_lists, int* length) {
int max_sum = -1;
int* max_list = NULL;
for (int i = 0; i < num_lists; i++) {
int current_sum = 0;
for (int j = 0; j < 3; j++) {
current_sum += lists[i][j];
}
if (current_sum > max_sum) {
... | int main() {
int length;
int list1[4][3] = {{1,2,3}, {4,5,6}, {10,11,12}, {7,8,9}};
int* max_list1 = func0(list1, 4, &length);
int expected1[3] = {10, 11, 12};
assert(memcmp(max_list1, expected1, sizeof(expected1)) == 0);
int list2[3][3] = {{3,2,1}, {6,5,4}, {12,11,10}};
i... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
movl $0xffffffff,-0x18(%rbp)
movq $0x0,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
jmp 1253 <func0+0xaa>
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1210 <func0+0x67>
mov -0x14(%rbp),%eax
movsl... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov [rbp+var_18], 0FFFFFFFFh
mov [rbp+var_8], 0
mov [rbp+var_14], 0
jmp short loc_1253
loc_11D4:
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp short loc_1210
loc_11E4:
mov ... | long long func0(long long a1, int a2, _DWORD *a3)
{
int v4; // [rsp+20h] [rbp-18h]
int i; // [rsp+24h] [rbp-14h]
int v6; // [rsp+28h] [rbp-10h]
int j; // [rsp+2Ch] [rbp-Ch]
long long v8; // [rsp+30h] [rbp-8h]
v4 = -1;
v8 = 0LL;
for ( i = 0; i < a2; ++i )
{
v6 = 0;
for ( j = 0; j <= 2; ++j )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV dword ptr [RBP + -0x18],0xffffffff
MOV qword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101253
LAB_001011d4:
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc... | long func0(long param_1,int param_2,int4 *param_3)
{
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
int8 local_10;
local_20 = -1;
local_10 = 0;
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
local_18 = 0;
for (local_14 = 0; local_14 < 3; local_14 = local_14 + ... |
7,113 | func0 |
#include <assert.h>
#include <stdio.h>
#include <string.h>
| int* func0(int lists[][3], int num_lists, int* length) {
int max_sum = -1;
int* max_list = NULL;
for (int i = 0; i < num_lists; i++) {
int current_sum = 0;
for (int j = 0; j < 3; j++) {
current_sum += lists[i][j];
}
if (current_sum > max_sum) {
... | int main() {
int length;
int list1[4][3] = {{1,2,3}, {4,5,6}, {10,11,12}, {7,8,9}};
int* max_list1 = func0(list1, 4, &length);
int expected1[3] = {10, 11, 12};
assert(memcmp(max_list1, expected1, sizeof(expected1)) == 0);
int list2[3][3] = {{3,2,1}, {6,5,4}, {12,11,10}};
i... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11ef <func0+0x46>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea (%rcx,%rcx,2),%rcx
lea 0xc(%rdi,%rcx,4),%rdi
mov $0x0,%r8d
mov $0xffffffff,%esi
jmp 11d6 <func0+0x2d>
add $0xc,%rax
cmp %rdi,%rax
je 11f5 <func0+0x4c>
mov 0x4(%rax),%ecx
add (%rax),%ecx
ad... | func0:
endbr64
test esi, esi
jle short loc_11EF
mov rax, rdi
lea ecx, [rsi-1]
lea rcx, [rcx+rcx*2]
lea rdi, [rdi+rcx*4+0Ch]
mov r8d, 0
mov esi, 0FFFFFFFFh
jmp short loc_11D6
loc_11CD:
add rax, 0Ch
cmp rax, rdi
jz short loc_11F5
loc_11D6:
mov ecx, [rax+4]
add ecx, ... | _DWORD * func0(_DWORD *a1, int a2, _DWORD *a3)
{
_DWORD *v3; // rax
long long v4; // rdi
_DWORD *v5; // r8
int v6; // esi
int v7; // ecx
if ( a2 <= 0 )
return 0LL;
v3 = a1;
v4 = (long long)&a1[3 * (a2 - 1) + 3];
v5 = 0LL;
v6 = -1;
do
{
v7 = v3[2] + *v3 + v3[1];
if ( v7 > v6 )
{
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011ef
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA RCX,[RCX + RCX*0x2]
LEA RDI,[RDI + RCX*0x4 + 0xc]
MOV R8D,0x0
MOV ESI,0xffffffff
JMP 0x001011d6
LAB_001011cd:
ADD RAX,0xc
CMP RAX,RDI
JZ 0x001011f5
LAB_001011d6:
MOV ECX,dword ptr [RAX + 0x4]
ADD ECX,dword ptr [RAX]
ADD ECX,dword ptr [RAX +... | int * func0(int *param_1,int param_2,int4 *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int *piVar4;
if (param_2 < 1) {
piVar4 = (int *)0x0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) * 3 + 3;
piVar4 = (int *)0x0;
iVar3 = -1;
do {
iVar2 = param_1[1] + *param_1 + param_... |
7,114 | func0 |
#include <assert.h>
#include <stdio.h>
#include <string.h>
| int* func0(int lists[][3], int num_lists, int* length) {
int max_sum = -1;
int* max_list = NULL;
for (int i = 0; i < num_lists; i++) {
int current_sum = 0;
for (int j = 0; j < 3; j++) {
current_sum += lists[i][j];
}
if (current_sum > max_sum) {
... | int main() {
int length;
int list1[4][3] = {{1,2,3}, {4,5,6}, {10,11,12}, {7,8,9}};
int* max_list1 = func0(list1, 4, &length);
int expected1[3] = {10, 11, 12};
assert(memcmp(max_list1, expected1, sizeof(expected1)) == 0);
int list2[3][3] = {{3,2,1}, {6,5,4}, {12,11,10}};
i... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1374 <func0+0x44>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
mov $0xffffffff,%ecx
lea (%rax,%rax,2),%rax
lea 0xc(%rdi,%rax,4),%rsi
nopl 0x0(%rax)
mov 0x4(%rdi),%eax
add (%rdi),%eax
add 0x8(%rdi),%eax
cmp %eax,%ecx
jge 1367 <func0+0x37>
movl $0x3,(%rdx)
mov... | func0:
endbr64
test esi, esi
jle short loc_13B4
lea eax, [rsi-1]
xor r8d, r8d
mov ecx, 0FFFFFFFFh
lea rax, [rax+rax*2]
lea rsi, [rdi+rax*4+0Ch]
nop dword ptr [rax+00h]
loc_1390:
mov eax, [rdi+4]
add eax, [rdi]
add eax, [rdi+8]
cmp ecx, eax
jge short loc_13A7
mov dw... | _DWORD * func0(_DWORD *a1, int a2, _DWORD *a3)
{
_DWORD *v3; // r8
int v4; // ecx
long long v5; // rsi
int v6; // eax
if ( a2 <= 0 )
return 0LL;
v3 = 0LL;
v4 = -1;
v5 = (long long)&a1[3 * (a2 - 1) + 3];
do
{
v6 = a1[2] + *a1 + a1[1];
if ( v4 < v6 )
{
*a3 = 3;
v3 = a1;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013b4
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
MOV ECX,0xffffffff
LEA RAX,[RAX + RAX*0x2]
LEA RSI,[RDI + RAX*0x4 + 0xc]
NOP dword ptr [RAX]
LAB_00101390:
MOV EAX,dword ptr [RDI + 0x4]
ADD EAX,dword ptr [RDI]
ADD EAX,dword ptr [RDI + 0x8]
CMP ECX,EAX
JGE 0x001013a7
MOV dword ptr [RDX],0x3
MO... | int * func0(int *param_1,int param_2,int4 *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int *piVar4;
if (0 < param_2) {
piVar4 = (int *)0x0;
iVar3 = -1;
piVar1 = param_1 + (ulong)(param_2 - 1) * 3 + 3;
do {
iVar2 = param_1[1] + *param_1 + param_1[2];
if (iVar3 < iVar2) {
... |
7,115 | func0 |
#include <assert.h>
#include <stdio.h>
#include <string.h>
| int* func0(int lists[][3], int num_lists, int* length) {
int max_sum = -1;
int* max_list = NULL;
for (int i = 0; i < num_lists; i++) {
int current_sum = 0;
for (int j = 0; j < 3; j++) {
current_sum += lists[i][j];
}
if (current_sum > max_sum) {
... | int main() {
int length;
int list1[4][3] = {{1,2,3}, {4,5,6}, {10,11,12}, {7,8,9}};
int* max_list1 = func0(list1, 4, &length);
int expected1[3] = {10, 11, 12};
assert(memcmp(max_list1, expected1, sizeof(expected1)) == 0);
int list2[3][3] = {{3,2,1}, {6,5,4}, {12,11,10}};
i... | O3 | c | func0:
endbr64
test %esi,%esi
jle 13a4 <func0+0x44>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
mov $0xffffffff,%ecx
lea (%rax,%rax,2),%rax
lea 0xc(%rdi,%rax,4),%rsi
nopl 0x0(%rax)
mov 0x4(%rdi),%eax
add (%rdi),%eax
add 0x8(%rdi),%eax
cmp %eax,%ecx
jge 1397 <func0+0x37>
movl $0x3,(%rdx)
mov... | func0:
endbr64
test esi, esi
jle short loc_1274
movsxd rsi, esi
xor r8d, r8d
mov ecx, 0FFFFFFFFh
lea rax, [rsi+rsi*2]
lea rsi, [rdi+rax*4]
nop dword ptr [rax+rax+00h]
loc_1250:
mov eax, [rdi+4]
add eax, [rdi]
add eax, [rdi+8]
cmp ecx, eax
jge short loc_1267
mov dword ... | _DWORD * func0(_DWORD *a1, int a2, _DWORD *a3)
{
_DWORD *v3; // r8
int v4; // ecx
_DWORD *v5; // rsi
int v6; // eax
if ( a2 <= 0 )
return 0LL;
v3 = 0LL;
v4 = -1;
v5 = &a1[3 * a2];
do
{
v6 = a1[2] + *a1 + a1[1];
if ( v4 < v6 )
{
*a3 = 3;
v3 = a1;
v4 = v6;
}
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101274
MOVSXD RSI,ESI
XOR R8D,R8D
MOV ECX,0xffffffff
LEA RAX,[RSI + RSI*0x2]
LEA RSI,[RDI + RAX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101250:
MOV EAX,dword ptr [RDI + 0x4]
ADD EAX,dword ptr [RDI]
ADD EAX,dword ptr [RDI + 0x8]
CMP ECX,EAX
JGE 0x00101267
MOV dword ptr [RDX],0x3
MOV ... | int * func0(int *param_1,int param_2,int4 *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int *piVar4;
if (0 < param_2) {
piVar4 = (int *)0x0;
iVar3 = -1;
piVar1 = param_1 + (long)param_2 * 3;
do {
iVar2 = param_1[1] + *param_1 + param_1[2];
if (iVar3 < iVar2) {
*param_3... |
7,116 | func0 |
#include <assert.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *test_str) {
int cnt = 0;
int res = 0;
int length = strlen(test_str);
for (int idx = 0; idx < length; idx++) {
if (isupper(test_str[idx])) {
cnt++;
} else {
if (cnt > res) {
res = cnt;
}
cnt =... | int main() {
assert(func0("GeMKSForGERksISBESt") == 5);
assert(func0("PrECIOusMOVemENTSYT") == 6);
assert(func0("GooGLEFluTTER") == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 120f <func0+0x86>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_8], 0
jmp short loc_120F
loc_11BF:
call ___ctype_b_loc
mov rax, [rax]
mov edx... | long long func0(const char *a1)
{
signed int v2; // [rsp+10h] [rbp-10h]
signed int v3; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v2 = 0;
v3 = 0;
v5 = strlen(a1);
for ( i = 0; i < v5; ++i )
{
if ( ((*__ctype_b_loc())[a1[i]] & 0x100) != 0 )
{
++v2;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x0010120f
LAB_001011bf:
CALL 0x00101090
MOV RAX,q... | int func0(char *param_1)
{
size_t sVar1;
ushort **ppuVar2;
int local_18;
int local_14;
int local_10;
local_18 = 0;
local_14 = 0;
sVar1 = strlen(param_1);
for (local_10 = 0; local_10 < (int)sVar1; local_10 = local_10 + 1) {
ppuVar2 = __ctype_b_loc();
if (((*ppuVar2)[param_1[local_10]] & 0x1... |
7,117 | func0 |
#include <assert.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *test_str) {
int cnt = 0;
int res = 0;
int length = strlen(test_str);
for (int idx = 0; idx < length; idx++) {
if (isupper(test_str[idx])) {
cnt++;
} else {
if (cnt > res) {
res = cnt;
}
cnt =... | int main() {
assert(func0("GeMKSForGERksISBESt") == 5);
assert(func0("PrECIOusMOVemENTSYT") == 6);
assert(func0("GooGLEFluTTER") == 4);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r12
test %r12d,%r12d
jle 11d8 <func0+0x6f>
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rsi
mov %r13,%rax
l... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rdi
call _strlen
mov r12, rax
test eax, eax
jle short loc_11EA
call ___ctype_b_loc
mov rsi, [rax]
mov rax, r13
lea edx, [r12-1]
lea rcx, [r13+rdx+1]
mov ebp, 0
mov ebx, 0
jmp short loc... | long long func0(char *a1)
{
int v1; // r12d
long long v2; // rsi
char *v3; // rax
signed int v4; // ebp
signed int v5; // ebx
long long v6; // rax
v1 = strlen();
if ( v1 <= 0 )
{
v4 = 0;
v5 = 0;
}
else
{
v2 = *(_QWORD *)__ctype_b_loc();
v3 = a1;
v4 = 0;
v5 = 0;
do
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
CALL 0x00101070
MOV R12,RAX
TEST EAX,EAX
JLE 0x001011ea
CALL 0x00101090
MOV RSI,qword ptr [RAX]
MOV RAX,R13
LEA EDX,[R12 + -0x1]
LEA RCX,[R13 + RDX*0x1 + 0x1]
MOV EBP,0x0
MOV EBX,0x0
JMP 0x001011da
LAB_001011c7:
CMP EBP,EBX
CMOVL EBP,EBX
MOV EBX... | int func0(char *param_1)
{
int iVar1;
size_t sVar2;
ushort **ppuVar3;
char *pcVar4;
int iVar5;
int iVar6;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (iVar1 < 1) {
iVar6 = 0;
iVar5 = 0;
}
else {
ppuVar3 = __ctype_b_loc();
iVar6 = 0;
iVar5 = 0;
pcVar4 = param_1;
... |
7,118 | func0 |
#include <assert.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *test_str) {
int cnt = 0;
int res = 0;
int length = strlen(test_str);
for (int idx = 0; idx < length; idx++) {
if (isupper(test_str[idx])) {
cnt++;
} else {
if (cnt > res) {
res = cnt;
}
cnt =... | int main() {
assert(func0("GeMKSForGERksISBESt") == 5);
assert(func0("PrECIOusMOVemENTSYT") == 6);
assert(func0("GooGLEFluTTER") == 4);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %rax,%rbx
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rsi
test %ebx,%ebx
jle 12b8 <func0+0x88>
lea -0x1(%rbx),%edx
mov %rbp,%rax
xor %r8d,%r8d
lea 0x1(%rbp,%rdx,1),%r9
xor %edx,%edx
jmp 127... | func0:
endbr64
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
call _strlen
mov rbx, rax
call ___ctype_b_loc
mov rsi, [rax]
test ebx, ebx
jle short loc_12B8
lea edx, [rbx-1]
mov rax, rbp
xor r8d, r8d
lea r9, [rbp+rdx+1]
xor edx, edx
jmp short loc_1274
loc_1268:
add ... | long long func0(char *a1)
{
int v1; // ebx
long long v2; // rsi
char *v3; // rax
signed int v4; // r8d
long long v5; // r9
signed int v6; // edx
v1 = strlen();
v2 = *(_QWORD *)__ctype_b_loc();
if ( v1 <= 0 )
{
v4 = 0;
v6 = 0;
}
else
{
v3 = a1;
v4 = 0;
v5 = (long long)&a1[... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
MOV RBX,RAX
CALL 0x00101090
MOV RSI,qword ptr [RAX]
TEST EBX,EBX
JLE 0x001012b8
LEA EDX,[RBX + -0x1]
MOV RAX,RBP
XOR R8D,R8D
LEA R9,[RBP + RDX*0x1 + 0x1]
XOR EDX,EDX
JMP 0x00101274
LAB_00101268:
ADD RAX,0x1
ADD EDX,0x1
CMP R9,RAX
JZ 0x00101291
LAB... | int func0(char *param_1)
{
size_t sVar1;
ushort **ppuVar2;
char *pcVar3;
int iVar4;
int iVar5;
int iVar6;
sVar1 = strlen(param_1);
ppuVar2 = __ctype_b_loc();
iVar5 = (int)sVar1;
if (iVar5 < 1) {
iVar6 = 0;
iVar4 = 0;
}
else {
iVar6 = 0;
iVar4 = 0;
pcVar3 = param_1;
do... |
7,119 | func0 |
#include <assert.h>
#include <string.h>
#include <ctype.h>
| int func0(const char *test_str) {
int cnt = 0;
int res = 0;
int length = strlen(test_str);
for (int idx = 0; idx < length; idx++) {
if (isupper(test_str[idx])) {
cnt++;
} else {
if (cnt > res) {
res = cnt;
}
cnt =... | int main() {
assert(func0("GeMKSForGERksISBESt") == 5);
assert(func0("PrECIOusMOVemENTSYT") == 6);
assert(func0("GooGLEFluTTER") == 4);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %rax,%rbx
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rsi
test %ebx,%ebx
jle 12b8 <func0+0x88>
lea -0x1(%rbx),%edx
mov %rbp,%rax
xor %r8d,%r8d
lea 0x1(%rbp,%rdx,1),%r9
xor %edx,%edx
jmp 127... | func0:
endbr64
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
call _strlen
mov rbx, rax
call ___ctype_b_loc
mov r8, [rax]
test ebx, ebx
jle short loc_12B0
lea edx, [rbx-1]
mov rax, rbp
xor ecx, ecx
lea r9, [rbp+rdx+1]
xor edx, edx
jmp short loc_1274
loc_1268:
add ... | long long func0(const char *a1)
{
int v1; // ebx
const unsigned __int16 *v2; // r8
const char *v3; // rax
signed int v4; // ecx
long long v5; // r9
signed int v6; // edx
v1 = strlen(a1);
v2 = *__ctype_b_loc();
if ( v1 <= 0 )
{
v4 = 0;
v6 = 0;
}
else
{
v3 = a1;
v4 = 0;
v5 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
MOV RBX,RAX
CALL 0x00101090
MOV R8,qword ptr [RAX]
TEST EBX,EBX
JLE 0x001012b0
LEA EDX,[RBX + -0x1]
MOV RAX,RBP
XOR ECX,ECX
LEA R9,[RBP + RDX*0x1 + 0x1]
XOR EDX,EDX
JMP 0x00101274
LAB_00101268:
ADD RAX,0x1
ADD EDX,0x1
CMP R9,RAX
JZ 0x00101290
LAB_... | int func0(char *param_1)
{
size_t sVar1;
ushort **ppuVar2;
char *pcVar3;
int iVar4;
int iVar5;
int iVar6;
sVar1 = strlen(param_1);
ppuVar2 = __ctype_b_loc();
iVar6 = (int)sVar1;
if (iVar6 < 1) {
iVar4 = 0;
iVar5 = 0;
}
else {
iVar4 = 0;
iVar5 = 0;
pcVar3 = param_1;
do... |
7,120 | func0 |
#include <assert.h>
| int func0(int nums[], int length) {
for (int i = 0; i < length; i++) {
if (nums[i] % 2 != 0) {
return nums[i];
}
}
return -1;
}
| int main() {
int nums1[] = {1, 3, 5};
int nums2[] = {2, 4, 1, 3};
int nums3[] = {8, 9, 1};
assert(func0(nums1, 3) == 1);
assert(func0(nums2, 4) == 1);
assert(func0(nums3, 3) == 9);
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
je 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
jz 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
JZ 0x001011b6... | 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);
} |
7,121 | func0 |
#include <assert.h>
| int func0(int nums[], int length) {
for (int i = 0; i < length; i++) {
if (nums[i] % 2 != 0) {
return nums[i];
}
}
return -1;
}
| int main() {
int nums1[] = {1, 3, 5};
int nums2[] = {2, 4, 1, 3};
int nums3[] = {8, 9, 1};
assert(func0(nums1, 3) == 1);
assert(func0(nums2, 4) == 1);
assert(func0(nums3, 3) == 9);
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
jne 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
jnz 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
JNZ 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;
} |
7,122 | func0 |
#include <assert.h>
| int func0(int nums[], int length) {
for (int i = 0; i < length; i++) {
if (nums[i] % 2 != 0) {
return nums[i];
}
}
return -1;
}
| int main() {
int nums1[] = {1, 3, 5};
int nums2[] = {2, 4, 1, 3};
int nums3[] = {8, 9, 1};
assert(func0(nums1, 3) == 1);
assert(func0(nums2, 4) == 1);
assert(func0(nums3, 3) == 9);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rdx,%rdi
je 1170 <func0+0x30>
mov (%rdi),%eax
test $0x1,%al
je 1158 <func0+0x18>
retq
nopl 0x0(%rax,%rax,1)
mov $0xffff... | func0:
endbr64
test esi, esi
jle short loc_1170
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+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
jz short loc_1158
retn
loc_1170:
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 0x00101170
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x4
CMP RDI,RDX
JZ 0x00101170
LAB_00101161:
MOV EAX,dword ptr [RDI]
TEST AL,0x1
JZ 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 + (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;
} |
7,123 | func0 |
#include <assert.h>
| int func0(int nums[], int length) {
for (int i = 0; i < length; i++) {
if (nums[i] % 2 != 0) {
return nums[i];
}
}
return -1;
}
| int main() {
int nums1[] = {1, 3, 5};
int nums2[] = {2, 4, 1, 3};
int nums3[] = {8, 9, 1};
assert(func0(nums1, 3) == 1);
assert(func0(nums2, 4) == 1);
assert(func0(nums3, 3) == 9);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rdx,%rdi
je 1170 <func0+0x30>
mov (%rdi),%eax
test $0x1,%al
je 1158 <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
jz 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
JZ 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;
} |
7,124 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup[], int n, int K) {
bool res = false;
for(int i = 0; i < n; i++) {
if(test_tup[i] == K) {
res = true;
break;
}
}
return res;
}
| int main() {
int arr1[] = {10, 4, 5, 6, 8};
assert(func0(arr1, 5, 6) == true);
int arr2[] = {1, 2, 3, 4, 5, 6};
assert(func0(arr2, 6, 7) == false);
int arr3[] = {7, 8, 9, 44, 11, 12};
assert(func0(arr3, 6, 11) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movb $0x0,-0x5(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ad <func0+0x44>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%r... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_5], 0
mov [rbp+var_4], 0
jmp short loc_11AD
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cm... | long long func0(long long a1, int a2, int a3)
{
unsigned __int8 v4; // [rsp+1Bh] [rbp-5h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
if ( a3 == *(_DWORD *)(4LL * i + a1) )
return 1;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV byte ptr [RBP + -0x5],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ad
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
... | int func0(long param_1,int param_2,int param_3)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 0;
}
if (param_3 == *(int *)(param_1 + (long)local_c * 4)) break;
local_c = local_c + 1;
}
return 1;
} |
7,125 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup[], int n, int K) {
bool res = false;
for(int i = 0; i < n; i++) {
if(test_tup[i] == K) {
res = true;
break;
}
}
return res;
}
| int main() {
int arr1[] = {10, 4, 5, 6, 8};
assert(func0(arr1, 5, 6) == true);
int arr2[] = {1, 2, 3, 4, 5, 6};
assert(func0(arr2, 6, 7) == false);
int arr3[] = {7, 8, 9, 44, 11, 12};
assert(func0(arr3, 6, 11) == true);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 118f <func0+0x26>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%rcx
cmp %edx,(%rax)
je 1195 <func0+0x2c>
add $0x4,%rax
cmp %rcx,%rax
jne 117c <func0+0x13>
mov $0x0,%eax
retq
mov $0x0,%eax
retq
mov $0x1,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_118F
mov rax, rdi
lea ecx, [rsi-1]
lea rcx, [rdi+rcx*4+4]
loc_117C:
cmp [rax], edx
jz short loc_1195
add rax, 4
cmp rax, rcx
jnz short loc_117C
mov eax, 0
retn
loc_118F:
mov eax, 0
retn
loc_1195:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
if ( a2 <= 0 )
return 0LL;
v3 = a1;
while ( *v3 != a3 )
{
if ( ++v3 == &a1[a2 - 1 + 1] )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010118f
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA RCX,[RDI + RCX*0x4 + 0x4]
LAB_0010117c:
CMP dword ptr [RAX],EDX
JZ 0x00101195
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010117c
MOV EAX,0x0
RET
LAB_0010118f:
MOV EAX,0x0
RET
LAB_00101195:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
if (param_2 < 1) {
return 0;
}
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (*param_1 == param_3) {
return 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return 0;
} |
7,126 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup[], int n, int K) {
bool res = false;
for(int i = 0; i < n; i++) {
if(test_tup[i] == K) {
res = true;
break;
}
}
return res;
}
| int main() {
int arr1[] = {10, 4, 5, 6, 8};
assert(func0(arr1, 5, 6) == true);
int arr2[] = {1, 2, 3, 4, 5, 6};
assert(func0(arr2, 6, 7) == false);
int arr3[] = {7, 8, 9, 44, 11, 12};
assert(func0(arr3, 6, 11) == true);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1170 <func0+0x30>
cmp %edx,(%rdi)
jne 1158 <func0+0x18>
mov $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%... | func0:
endbr64
test esi, esi
jle short loc_1320
lea eax, [rsi-1]
lea rax, [rdi+rax*4+4]
jmp short loc_1311
loc_1308:
add rdi, 4
cmp rdi, rax
jz short loc_1320
loc_1311:
cmp [rdi], edx
jnz short loc_1308
mov eax, 1
retn
loc_1320:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2, int a3)
{
long long v3; // rax
if ( a2 <= 0 )
return 0LL;
v3 = (long long)&a1[a2 - 1 + 1];
while ( *a1 != a3 )
{
if ( ++a1 == (_DWORD *)v3 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101320
LEA EAX,[RSI + -0x1]
LEA RAX,[RDI + RAX*0x4 + 0x4]
JMP 0x00101311
LAB_00101308:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101320
LAB_00101311:
CMP dword ptr [RDI],EDX
JNZ 0x00101308
MOV EAX,0x1
RET
LAB_00101320:
XOR EAX,EAX
RET | int8 func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (*param_1 == param_3) {
return 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 0;
} |
7,127 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup[], int n, int K) {
bool res = false;
for(int i = 0; i < n; i++) {
if(test_tup[i] == K) {
res = true;
break;
}
}
return res;
}
| int main() {
int arr1[] = {10, 4, 5, 6, 8};
assert(func0(arr1, 5, 6) == true);
int arr2[] = {1, 2, 3, 4, 5, 6};
assert(func0(arr2, 6, 7) == false);
int arr3[] = {7, 8, 9, 44, 11, 12};
assert(func0(arr3, 6, 11) == true);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1270 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1261 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1270 <func0+0x30>
cmp %edx,(%rdi)
jne 1258 <func0+0x18>
mov $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%... | func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
lea rax, [rdi+rsi*4]
jmp short loc_1161
loc_1158:
add rdi, 4
cmp rdi, rax
jz short loc_1170
loc_1161:
cmp [rdi], edx
jnz short loc_1158
mov eax, 1
retn
loc_1170:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
if ( a2 <= 0 )
return 0LL;
v3 = &a1[a2];
while ( *a1 != a3 )
{
if ( ++a1 == v3 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
LEA RAX,[RDI + RSI*0x4]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101170
LAB_00101161:
CMP dword ptr [RDI],EDX
JNZ 0x00101158
MOV EAX,0x1
RET
LAB_00101170:
XOR EAX,EAX
RET | int8 func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + param_2;
do {
if (*param_1 == param_3) {
return 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 0;
} |
7,128 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int test_tup2[], int size) {
bool res = true;
for (int i = 0; i < size; i++) {
if (!(test_tup1[i] > test_tup2[i])) {
res = false;
break;
}
}
return res;
}
| int main() {
int tup1_1[] = {1, 2, 3};
int tup2_1[] = {2, 3, 4};
assert(func0(tup1_1, tup2_1, 3) == false);
int tup1_2[] = {4, 5, 6};
int tup2_2[] = {3, 4, 5};
assert(func0(tup1_2, tup2_2, 3) == true);
int tup1_3[] = {11, 12, 13};
int tup2_3[] = {10, 11, 12};
assert(func... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
movb $0x1,-0x5(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c3 <func0+0x5a>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%e... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_5], 1
mov [rbp+var_4], 0
jmp short loc_11C3
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mo... | long long func0(long long a1, long long a2, int a3)
{
unsigned __int8 v4; // [rsp+1Fh] [rbp-5h]
int i; // [rsp+20h] [rbp-4h]
v4 = 1;
for ( i = 0; i < a3; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) <= *(_DWORD *)(4LL * i + a2) )
return 0;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV byte ptr [RBP + -0x5],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c3
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
... | int func0(long param_1,long param_2,int param_3)
{
int local_c;
local_c = 0;
while( true ) {
if (param_3 <= local_c) {
return 1;
}
if (*(int *)(param_1 + (long)local_c * 4) <= *(int *)(param_2 + (long)local_c * 4)) break;
local_c = local_c + 1;
}
return 0;
} |
7,129 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int test_tup2[], int size) {
bool res = true;
for (int i = 0; i < size; i++) {
if (!(test_tup1[i] > test_tup2[i])) {
res = false;
break;
}
}
return res;
}
| int main() {
int tup1_1[] = {1, 2, 3};
int tup2_1[] = {2, 3, 4};
assert(func0(tup1_1, tup2_1, 3) == false);
int tup1_2[] = {4, 5, 6};
int tup2_2[] = {3, 4, 5};
assert(func0(tup1_2, tup2_2, 3) == true);
int tup1_3[] = {11, 12, 13};
int tup2_3[] = {10, 11, 12};
assert(func... | O1 | c | func0:
endbr64
test %edx,%edx
jle 1195 <func0+0x2c>
lea -0x1(%rdx),%ecx
mov $0x0,%eax
jmp 117e <func0+0x15>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
jle 119b <func0+0x32>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
jne 117b <func0+0x12>
mov $0x1,%eax
retq
mov $0x1,%eax
r... | func0:
endbr64
test edx, edx
jle short loc_118F
mov edx, edx
mov eax, 0
loc_1178:
mov ecx, [rsi+rax*4]
cmp [rdi+rax*4], ecx
jle short loc_1195
add rax, 1
cmp rax, rdx
jnz short loc_1178
mov eax, 1
retn
loc_118F:
mov eax, 1
retn
loc_1195:
mov eax, 0
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
if ( a3 <= 0 )
return 1LL;
v3 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v3) > *(_DWORD *)(a2 + 4 * v3) )
{
if ( ++v3 == a3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x0010118f
MOV EDX,EDX
MOV EAX,0x0
LAB_00101178:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JLE 0x00101195
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x00101178
MOV EAX,0x1
RET
LAB_0010118f:
MOV EAX,0x1
RET
LAB_00101195:
MOV EAX,0x0
RET | int8 func0(long param_1,long param_2,uint param_3)
{
ulong uVar1;
if ((int)param_3 < 1) {
return 1;
}
uVar1 = 0;
do {
if (*(int *)(param_1 + uVar1 * 4) <= *(int *)(param_2 + uVar1 * 4)) {
return 0;
}
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
return 1;
} |
7,130 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int test_tup2[], int size) {
bool res = true;
for (int i = 0; i < size; i++) {
if (!(test_tup1[i] > test_tup2[i])) {
res = false;
break;
}
}
return res;
}
| int main() {
int tup1_1[] = {1, 2, 3};
int tup2_1[] = {2, 3, 4};
assert(func0(tup1_1, tup2_1, 3) == false);
int tup1_2[] = {4, 5, 6};
int tup2_2[] = {3, 4, 5};
assert(func0(tup1_2, tup2_2, 3) == true);
int tup1_3[] = {11, 12, 13};
int tup2_3[] = {10, 11, 12};
assert(func... | O2 | c | func0:
endbr64
test %edx,%edx
jle 1170 <func0+0x30>
lea -0x1(%rdx),%ecx
xor %eax,%eax
jmp 115c <func0+0x1c>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1170 <func0+0x30>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
jg 1150 <func0+0x10>
xor %eax,%eax
retq
nopw 0x0(%rax,%r... | func0:
endbr64
test edx, edx
jle short loc_1168
movsxd rdx, edx
xor eax, eax
jmp short loc_1159
loc_1150:
add rax, 1
cmp rax, rdx
jz short loc_1168
loc_1159:
mov ecx, [rsi+rax*4]
cmp [rdi+rax*4], ecx
jg short loc_1150
xor eax, eax
retn
loc_1168:
mov eax, 1
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
if ( a3 <= 0 )
return 1LL;
v3 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v3) > *(_DWORD *)(a2 + 4 * v3) )
{
if ( ++v3 == a3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x00101168
MOVSXD RDX,EDX
XOR EAX,EAX
JMP 0x00101159
LAB_00101150:
ADD RAX,0x1
CMP RAX,RDX
JZ 0x00101168
LAB_00101159:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JG 0x00101150
XOR EAX,EAX
RET
LAB_00101168:
MOV EAX,0x1
RET | int8 func0(long param_1,long param_2,int param_3)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1 * 4) <= *(int *)(param_2 + lVar1 * 4)) {
return 0;
}
lVar1 = lVar1 + 1;
} while (lVar1 != param_3);
}
return 1;
} |
7,131 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int test_tup2[], int size) {
bool res = true;
for (int i = 0; i < size; i++) {
if (!(test_tup1[i] > test_tup2[i])) {
res = false;
break;
}
}
return res;
}
| int main() {
int tup1_1[] = {1, 2, 3};
int tup2_1[] = {2, 3, 4};
assert(func0(tup1_1, tup2_1, 3) == false);
int tup1_2[] = {4, 5, 6};
int tup2_2[] = {3, 4, 5};
assert(func0(tup1_2, tup2_2, 3) == true);
int tup1_3[] = {11, 12, 13};
int tup2_3[] = {10, 11, 12};
assert(func... | O3 | c | func0:
endbr64
test %edx,%edx
jle 1170 <func0+0x30>
lea -0x1(%rdx),%ecx
xor %eax,%eax
jmp 115c <func0+0x1c>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1170 <func0+0x30>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
jg 1150 <func0+0x10>
xor %eax,%eax
retq
nopw 0x0(%rax,%r... | func0:
endbr64
test edx, edx
jle short loc_1170
movsxd rdx, edx
xor eax, eax
shl rdx, 2
jmp short loc_1161
loc_1158:
add rax, 4
cmp rdx, rax
jz short loc_1170
loc_1161:
mov ecx, [rsi+rax]
cmp [rdi+rax], ecx
jg short loc_1158
xor eax, eax
retn
loc_1170:
mov eax, 1
re... | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
long long v4; // rdx
if ( a3 <= 0 )
return 1LL;
v3 = 0LL;
v4 = 4LL * a3;
while ( *(_DWORD *)(a1 + v3) > *(_DWORD *)(a2 + v3) )
{
v3 += 4LL;
if ( v4 == v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x00101170
MOVSXD RDX,EDX
XOR EAX,EAX
SHL RDX,0x2
JMP 0x00101161
LAB_00101158:
ADD RAX,0x4
CMP RDX,RAX
JZ 0x00101170
LAB_00101161:
MOV ECX,dword ptr [RSI + RAX*0x1]
CMP dword ptr [RDI + RAX*0x1],ECX
JG 0x00101158
XOR EAX,EAX
RET
LAB_00101170:
MOV EAX,0x1
RET | int8 func0(long param_1,long param_2,int param_3)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1) <= *(int *)(param_2 + lVar1)) {
return 0;
}
lVar1 = lVar1 + 4;
} while ((long)param_3 * 4 != lVar1);
}
return 1;
} |
7,132 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(int a, int b, int c, int d) {
int total = 0;
if (a > 0) total += a;
if (b > 0) total += b;
if (c > 0) total += c;
if (d > 0) total += d;
char* result = malloc((total + 1) * sizeof(char));
if (!result) {
perror("Failed to allocate memory");
exit(EXIT_FAI... | int main() {
char* res1 = func0(4, 2, 0, -2);
assert(strcmp(res1, "ppppqq") == 0);
free(res1);
char* res2 = func0(0, 1, 2, 3);
assert(strcmp(res2, "qrrsss") == 0);
free(res2);
char* res3 = func0(11, 15, 12, 23);
char expected3[11 + 15 + 12 + 23 + 1];
int idx = 0;
fo... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov %esi,-0x28(%rbp)
mov %edx,-0x2c(%rbp)
mov %ecx,-0x30(%rbp)
movl $0x0,-0x20(%rbp)
cmpl $0x0,-0x24(%rbp)
jle 1234 <func0+0x2b>
mov -0x24(%rbp),%eax
add %eax,-0x20(%rbp)
cmpl $0x0,-0x28(%rbp)
jle 1240 <func... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_28], esi
mov [rbp+var_2C], edx
mov [rbp+var_30], ecx
mov [rbp+var_20], 0
cmp [rbp+var_24], 0
jle short loc_1234
mov eax, [rbp+var_24]
add [rbp+var_20], eax
loc_1234:
cmp [rbp+var_28], ... | _BYTE * func0(int a1, int a2, int a3, int a4)
{
int v4; // eax
int v5; // eax
int v6; // eax
int v7; // eax
int v11; // [rsp+10h] [rbp-20h]
int v12; // [rsp+14h] [rbp-1Ch]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
int k; // [rsp+20h] [rbp-10h]
int m; // [rsp+24h] [rbp-Ch]
_BYTE *... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x28],ESI
MOV dword ptr [RBP + -0x2c],EDX
MOV dword ptr [RBP + -0x30],ECX
MOV dword ptr [RBP + -0x20],0x0
CMP dword ptr [RBP + -0x24],0x0
JLE 0x00101234
MOV EAX,dword ptr [RBP + -0x24]
ADD dword ptr [RBP + -0x20],EAX
... | void * func0(int param_1,int param_2,int param_3,int param_4)
{
void *pvVar1;
int local_28;
int local_24;
int local_20;
int local_1c;
int local_18;
int local_14;
local_28 = 0;
if (0 < param_1) {
local_28 = param_1;
}
if (0 < param_2) {
local_28 = local_28 + param_2;
}
if (0 < param... |
7,133 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(int a, int b, int c, int d) {
int total = 0;
if (a > 0) total += a;
if (b > 0) total += b;
if (c > 0) total += c;
if (d > 0) total += d;
char* result = malloc((total + 1) * sizeof(char));
if (!result) {
perror("Failed to allocate memory");
exit(EXIT_FAI... | int main() {
char* res1 = func0(4, 2, 0, -2);
assert(strcmp(res1, "ppppqq") == 0);
free(res1);
char* res2 = func0(0, 1, 2, 3);
assert(strcmp(res2, "qrrsss") == 0);
free(res2);
char* res3 = func0(11, 15, 12, 23);
char expected3[11 + 15 + 12 + 23 + 1];
int idx = 0;
fo... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebx
mov %esi,%r13d
mov %edx,%r12d
mov %ecx,%ebp
test %edi,%edi
mov $0x0,%edi
cmovns %ebx,%edi
lea (%rdi,%rsi,1),%eax
test %esi,%esi
cmovg %eax,%edi
lea (%rdi,%rdx,1),%eax
test %edx,%edx
cmovg %eax,%edi... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebx, edi
mov r13d, esi
mov r12d, edx
mov ebp, ecx
test edi, edi
mov edi, 0
cmovns edi, ebx
lea eax, [rdi+rsi]
test esi, esi
cmovg edi, eax
lea eax, [rdi+rdx]
test edx, edx
cmovg edi, eax
lea e... | _BYTE * func0(int a1, int a2, int a3, int a4)
{
int v4; // ebx
bool v7; // sf
int v8; // edi
_BYTE *v9; // rax
_BYTE *v10; // rdx
_BYTE *v11; // rcx
_BYTE *v12; // rax
_BYTE *v13; // rax
_BYTE *v14; // rax
v4 = a1;
v7 = a1 < 0;
v8 = 0;
if ( !v7 )
v8 = v4;
if ( a2 > 0 )
v8 += a2;
i... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
MOV R13D,ESI
MOV R12D,EDX
MOV EBP,ECX
TEST EDI,EDI
MOV EDI,0x0
CMOVNS EDI,EBX
LEA EAX,[RDI + RSI*0x1]
TEST ESI,ESI
CMOVG EDI,EAX
LEA EAX,[RDI + RDX*0x1]
TEST EDX,EDX
CMOVG EDI,EAX
LEA EAX,[RDI + RCX*0x1]
TEST ECX,ECX
CMOVG EDI,EAX
ADD EDI,0x1
MO... | int1 * func0(uint param_1,uint param_2,uint param_3,uint param_4)
{
int1 *puVar1;
int1 *puVar2;
uint uVar3;
uVar3 = 0;
if (-1 < (int)param_1) {
uVar3 = param_1;
}
if (0 < (int)param_2) {
uVar3 = uVar3 + param_2;
}
if (0 < (int)param_3) {
uVar3 = uVar3 + param_3;
}
if (0 < (int)para... |
7,134 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(int a, int b, int c, int d) {
int total = 0;
if (a > 0) total += a;
if (b > 0) total += b;
if (c > 0) total += c;
if (d > 0) total += d;
char* result = malloc((total + 1) * sizeof(char));
if (!result) {
perror("Failed to allocate memory");
exit(EXIT_FAI... | int main() {
char* res1 = func0(4, 2, 0, -2);
assert(strcmp(res1, "ppppqq") == 0);
free(res1);
char* res2 = func0(0, 1, 2, 3);
assert(strcmp(res2, "qrrsss") == 0);
free(res2);
char* res3 = func0(11, 15, 12, 23);
char expected3[11 + 15 + 12 + 23 + 1];
int idx = 0;
fo... | O2 | c | func0:
endbr64
push %r13
mov %esi,%r13d
push %r12
mov %edx,%r12d
push %rbp
mov %ecx,%ebp
push %rbx
mov %edi,%ebx
sub $0x8,%rsp
test %edi,%edi
mov $0x0,%edi
cmovns %ebx,%edi
test %esi,%esi
lea (%rdi,%rsi,1),%eax
cmovg %eax,%edi
test %edx,%edx
lea (%rdi,%rdx,1),%eax
cmovg %eax,%edi... | func0:
endbr64
push r15
push r14
push r13
mov r13d, edi
push r12
mov r12d, esi
push rbp
mov ebp, edx
push rbx
mov ebx, ecx
sub rsp, 8
test edi, edi
mov edi, 0
cmovns edi, r13d
test esi, esi
lea eax, [rdi+rsi]
cmovg edi, eax
test edx, edx
lea eax, [rdi+rdx]
c... | _BYTE * func0(int a1, int a2, int a3, int a4)
{
int v4; // r13d
bool v7; // sf
int v8; // edi
_BYTE *v9; // rax
_BYTE *v10; // r14
long long v11; // rdi
long long v12; // rdi
v4 = a1;
v7 = a1 < 0;
v8 = 0;
if ( !v7 )
v8 = v4;
if ( a2 > 0 )
v8 += a2;
if ( a3 > 0 )
v8 += a3;
if ( a... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13D,EDI
PUSH R12
MOV R12D,ESI
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV EBX,ECX
SUB RSP,0x8
TEST EDI,EDI
MOV EDI,0x0
CMOVNS EDI,R13D
TEST ESI,ESI
LEA EAX,[RDI + RSI*0x1]
CMOVG EDI,EAX
TEST EDX,EDX
LEA EAX,[RDI + RDX*0x1]
CMOVG EDI,EAX
TEST ECX,ECX
LEA EAX,[RDI + RCX*0x1]
CMOVG EDI... | int1 * func0(int param_1,int param_2,int param_3,int param_4)
{
int1 *__s;
int1 *puVar1;
int iVar2;
long lVar3;
iVar2 = 0;
if (-1 < param_1) {
iVar2 = param_1;
}
if (0 < param_2) {
iVar2 = iVar2 + param_2;
}
if (0 < param_3) {
iVar2 = iVar2 + param_3;
}
if (0 < param_4) {
iVa... |
7,135 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char* func0(int a, int b, int c, int d) {
int total = 0;
if (a > 0) total += a;
if (b > 0) total += b;
if (c > 0) total += c;
if (d > 0) total += d;
char* result = malloc((total + 1) * sizeof(char));
if (!result) {
perror("Failed to allocate memory");
exit(EXIT_FAI... | int main() {
char* res1 = func0(4, 2, 0, -2);
assert(strcmp(res1, "ppppqq") == 0);
free(res1);
char* res2 = func0(0, 1, 2, 3);
assert(strcmp(res2, "qrrsss") == 0);
free(res2);
char* res3 = func0(11, 15, 12, 23);
char expected3[11 + 15 + 12 + 23 + 1];
int idx = 0;
fo... | O3 | c | func0:
endbr64
push %r14
test %edi,%edi
mov %esi,%r14d
push %r13
push %r12
mov %edx,%r12d
push %rbp
mov %ecx,%ebp
push %rbx
mov %edi,%ebx
mov $0x0,%edi
cmovns %ebx,%edi
test %esi,%esi
lea (%rdi,%rsi,1),%eax
cmovg %eax,%edi
test %edx,%edx
lea (%rdi,%rdx,1),%eax
cmovg %eax,%edi
test... | func0:
endbr64
push r14
test edi, edi
push r13
mov r13d, esi
push r12
mov r12d, edx
push rbp
mov ebp, ecx
push rbx
mov ebx, edi
mov edi, 0
cmovns edi, ebx
test esi, esi
lea eax, [rdi+rsi]
cmovg edi, eax
test edx, edx
lea eax, [rdi+rdx]
cmovg edi, eax
test ecx,... | _BYTE * func0(size_t n, int a2, int a3, int a4)
{
bool v4; // sf
int v7; // ebx
int v8; // edi
_BYTE *v9; // rax
_BYTE *v10; // r14
long long v11; // rdi
long long v12; // rdi
v4 = (n & 0x80000000) != 0LL;
v7 = n;
v8 = 0;
if ( !v4 )
v8 = v7;
if ( a2 > 0 )
v8 += a2;
if ( a3 > 0 )
v... | func0:
ENDBR64
PUSH R14
TEST EDI,EDI
PUSH R13
MOV R13D,ESI
PUSH R12
MOV R12D,EDX
PUSH RBP
MOV EBP,ECX
PUSH RBX
MOV EBX,EDI
MOV EDI,0x0
CMOVNS EDI,EBX
TEST ESI,ESI
LEA EAX,[RDI + RSI*0x1]
CMOVG EDI,EAX
TEST EDX,EDX
LEA EAX,[RDI + RDX*0x1]
CMOVG EDI,EAX
TEST ECX,ECX
LEA EAX,[RDI + RCX*0x1]
CMOVG EDI,EAX
ADD EDI,0x1
MOVSX... | int * func0(uint param_1,uint param_2,uint param_3,uint param_4)
{
int *__s;
int *puVar1;
uint uVar2;
long lVar3;
uVar2 = 0;
if (-1 < (int)param_1) {
uVar2 = param_1;
}
if (0 < (int)param_2) {
uVar2 = uVar2 + param_2;
}
if (0 < (int)param_3) {
uVar2 = uVar2 + param_3;
}
if (0 < (... |
7,136 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_list1[][2], int size1, int test_list2[][2], int size2) {
if(size1 != size2) {
return false;
}
for(int i = 0; i < size1; i++) {
if(test_list1[i][0] != test_list2[i][0] || test_list1[i][1] != test_list2[i][1]) {
return false;
}
}
return ... | int main() {
int list1[][2] = {{10, 4}, {2, 5}};
int list2[][2] = {{10, 4}, {2, 5}};
int list3[][2] = {{1, 2}, {3, 7}};
int list4[][2] = {{12, 14}, {12, 45}};
int list5[][2] = {{2, 14}, {12, 25}};
int list6[][2] = {{2, 14}, {12, 25}};
assert(func0(list1, 2, list2, 2) == true);
... | 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)
mov -0x1c(%rbp),%eax
cmp -0x20(%rbp),%eax
je 1191 <func0+0x28>
mov $0x0,%eax
jmpq 1214 <func0+0xab>
movl $0x0,-0x4(%rbp)
jmp 1207 <func0+0x9e>
mov -0x4(%rbp)... | 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 eax, [rbp+var_1C]
cmp eax, [rbp+var_20]
jz short loc_1191
mov eax, 0
jmp loc_1214
loc_1191:
mov [rbp+var_4], 0
jmp short loc_1207
loc_119A:... | long long func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+24h] [rbp-4h]
if ( a2 != a4 )
return 0LL;
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(8LL * i + a1) != *(_DWORD *)(8LL * i + a3)
|| *(_DWORD *)(8LL * i + a1 + 4) != *(_DWORD *)(8LL * i + a3 + 4) )
{
return 0... | 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 EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x20]
JZ 0x00101191
MOV EAX,0x0
JMP 0x00101214
LAB_00101191:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x... | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
int8 uVar1;
int local_c;
if (param_2 == param_4) {
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((*(int *)(param_1 + (long)local_c * 8) != *(int *)(param_3 + (long)local_c * 8)) ||
(*(int *)(param_1 + (long)... |
7,137 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_list1[][2], int size1, int test_list2[][2], int size2) {
if(size1 != size2) {
return false;
}
for(int i = 0; i < size1; i++) {
if(test_list1[i][0] != test_list2[i][0] || test_list1[i][1] != test_list2[i][1]) {
return false;
}
}
return ... | int main() {
int list1[][2] = {{10, 4}, {2, 5}};
int list2[][2] = {{10, 4}, {2, 5}};
int list3[][2] = {{1, 2}, {3, 7}};
int list4[][2] = {{12, 14}, {12, 45}};
int list5[][2] = {{2, 14}, {12, 25}};
int list6[][2] = {{2, 14}, {12, 25}};
assert(func0(list1, 2, list2, 2) == true);
... | O1 | c | func0:
endbr64
mov $0x0,%eax
cmp %ecx,%esi
jne 11b9 <func0+0x50>
test %esi,%esi
jle 11a8 <func0+0x3f>
lea -0x1(%rsi),%esi
mov $0x0,%eax
jmp 1187 <func0+0x1e>
mov %rcx,%rax
mov (%rdx,%rax,8),%ecx
cmp %ecx,(%rdi,%rax,8)
jne 11ae <func0+0x45>
mov 0x4(%rdx,%rax,8),%ecx
cmp %ecx,0x4(... | func0:
endbr64
mov eax, 0
cmp esi, ecx
jnz short locret_11B9
test esi, esi
jle short loc_11A8
lea esi, [rsi-1]
mov eax, 0
jmp short loc_1187
loc_1184:
mov rax, rcx
loc_1187:
mov ecx, [rdx+rax*8]
cmp [rdi+rax*8], ecx
jnz short loc_11AE
mov ecx, [rdx+rax*8+4]
cmp [rd... | 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 ( a2 == a4 )
{
if ( a2 <= 0 )
{
return 1LL;
}
else
{
v5 = (unsigned int)(a2 - 1);
for ( i = 0LL; ; ++i )
{
if... | func0:
ENDBR64
MOV EAX,0x0
CMP ESI,ECX
JNZ 0x001011b9
TEST ESI,ESI
JLE 0x001011a8
LEA ESI,[RSI + -0x1]
MOV EAX,0x0
JMP 0x00101187
LAB_00101184:
MOV RAX,RCX
LAB_00101187:
MOV ECX,dword ptr [RDX + RAX*0x8]
CMP dword ptr [RDI + RAX*0x8],ECX
JNZ 0x001011ae
MOV ECX,dword ptr [RDX + RAX*0x8 + 0x4]
CMP dword ptr [RDI + RAX*0x... | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
ulong uVar1;
bool bVar2;
if (param_2 == param_4) {
if (param_2 < 1) {
return 1;
}
uVar1 = 0;
while( true ) {
if (*(int *)(param_1 + uVar1 * 8) != *(int *)(param_3 + uVar1 * 8)) {
return 0;
}
if (*(i... |
7,138 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_list1[][2], int size1, int test_list2[][2], int size2) {
if(size1 != size2) {
return false;
}
for(int i = 0; i < size1; i++) {
if(test_list1[i][0] != test_list2[i][0] || test_list1[i][1] != test_list2[i][1]) {
return false;
}
}
return ... | int main() {
int list1[][2] = {{10, 4}, {2, 5}};
int list2[][2] = {{10, 4}, {2, 5}};
int list3[][2] = {{1, 2}, {3, 7}};
int list4[][2] = {{12, 14}, {12, 45}};
int list5[][2] = {{2, 14}, {12, 25}};
int list6[][2] = {{2, 14}, {12, 25}};
assert(func0(list1, 2, list2, 2) == true);
... | O2 | c | func0:
endbr64
cmp %ecx,%esi
jne 1330 <func0+0x10>
jmp 12e0 <func0.part.0>
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
test esi, esi
jle short loc_1320
movsxd rsi, esi
xor eax, eax
jmp short loc_1313
loc_1300:
mov ecx, [rdx+rax*8+4]
cmp [rdi+rax*8+4], ecx
jnz short loc_131B
add rax, 1
cmp rax, rsi
jz short loc_1320
loc_1313:
mov ecx, [rdx+rax*8]
cmp [rdi+rax*8], ecx
jz ... | long long func0_part_0(long long a1, int a2, long long a3)
{
long long v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = 0LL;
while ( *(_DWORD *)(a1 + 8 * v3) == *(_DWORD *)(a3 + 8 * v3)
&& *(_DWORD *)(a1 + 8 * v3 + 4) == *(_DWORD *)(a3 + 8 * v3 + 4) )
{
if ( ++v3 == a2 )
return 1LL;
}
ret... | func0.part.0:
TEST ESI,ESI
JLE 0x00101320
MOVSXD RSI,ESI
XOR EAX,EAX
JMP 0x00101313
LAB_00101300:
MOV ECX,dword ptr [RDX + RAX*0x8 + 0x4]
CMP dword ptr [RDI + RAX*0x8 + 0x4],ECX
JNZ 0x0010131b
ADD RAX,0x1
CMP RAX,RSI
JZ 0x00101320
LAB_00101313:
MOV ECX,dword ptr [RDX + RAX*0x8]
CMP dword ptr [RDI + RAX*0x8],ECX
JZ 0x00... | int8 func0_part_0(long param_1,int param_2,long param_3)
{
long lVar1;
if (0 < param_2) {
lVar1 = 0;
do {
if ((*(int *)(param_1 + lVar1 * 8) != *(int *)(param_3 + lVar1 * 8)) ||
(*(int *)(param_1 + 4 + lVar1 * 8) != *(int *)(param_3 + 4 + lVar1 * 8))) {
return 0;
}
lVa... |
7,139 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_list1[][2], int size1, int test_list2[][2], int size2) {
if(size1 != size2) {
return false;
}
for(int i = 0; i < size1; i++) {
if(test_list1[i][0] != test_list2[i][0] || test_list1[i][1] != test_list2[i][1]) {
return false;
}
}
return ... | int main() {
int list1[][2] = {{10, 4}, {2, 5}};
int list2[][2] = {{10, 4}, {2, 5}};
int list3[][2] = {{1, 2}, {3, 7}};
int list4[][2] = {{12, 14}, {12, 45}};
int list5[][2] = {{2, 14}, {12, 25}};
int list6[][2] = {{2, 14}, {12, 25}};
assert(func0(list1, 2, list2, 2) == true);
... | O3 | c | func0:
endbr64
xor %eax,%eax
cmp %ecx,%esi
jne 1308 <func0+0x38>
test %esi,%esi
jle 1310 <func0+0x40>
sub $0x1,%esi
xor %eax,%eax
jmp 12fe <func0+0x2e>
nopl (%rax)
mov 0x4(%rdx,%rax,8),%ecx
cmp %ecx,0x4(%rdi,%rax,8)
jne 1306 <func0+0x36>
lea 0x1(%rax),%rcx
cmp %rsi,%rax
je 13... | func0_part_0:
test esi, esi
jle short loc_12D0
movsxd rsi, esi
xor eax, eax
lea rcx, ds:0[rsi*8]
jmp short loc_12BB
loc_12A8:
mov esi, [rdx+rax+4]
cmp [rdi+rax+4], esi
jnz short loc_12C3
add rax, 8
cmp rcx, rax
jz short loc_12D0
loc_12BB:
mov esi, [rdx+rax]
cmp [rdi+... | long long func0_part_0(long long a1, int a2, long long a3)
{
long long v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = 0LL;
while ( *(_DWORD *)(a1 + v3) == *(_DWORD *)(a3 + v3) && *(_DWORD *)(a1 + v3 + 4) == *(_DWORD *)(a3 + v3 + 4) )
{
v3 += 8LL;
if ( 8LL * a2 == v3 )
return 1LL;
}
return ... | func0.part.0:
TEST ESI,ESI
JLE 0x001012d0
MOVSXD RSI,ESI
XOR EAX,EAX
LEA RCX,[RSI*0x8]
JMP 0x001012bb
LAB_001012a8:
MOV ESI,dword ptr [RDX + RAX*0x1 + 0x4]
CMP dword ptr [RDI + RAX*0x1 + 0x4],ESI
JNZ 0x001012c3
ADD RAX,0x8
CMP RCX,RAX
JZ 0x001012d0
LAB_001012bb:
MOV ESI,dword ptr [RDX + RAX*0x1]
CMP dword ptr [RDI + RA... | int8 func0_part_0(long param_1,int param_2,long param_3)
{
long lVar1;
if (0 < param_2) {
lVar1 = 0;
do {
if ((*(int *)(param_1 + lVar1) != *(int *)(param_3 + lVar1)) ||
(*(int *)(param_1 + 4 + lVar1) != *(int *)(param_3 + 4 + lVar1))) {
return 0;
}
lVar1 = lVar1 + 8;
... |
7,140 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* street) {
int length = strlen(street);
if (length > 4 && strcmp(&street[length - 4], "Road") == 0) {
street[length - 4] = '\0';
strcat(street, "Rd.");
}
return street;
}
| int main() {
char street1[] = "ravipadu Road";
char street2[] = "palnadu Road";
char street3[] = "eshwar enclave Road";
assert(strcmp(func0(street1), "ravipadu Rd.") == 0);
assert(strcmp(func0(street2), "palnadu Rd.") == 0);
assert(strcmp(func0(street3), "eshwar enclave Rd.") == 0);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x4(%rbp)
cmpl $0x4,-0x4(%rbp)
jle 1233 <func0+0x8a>
mov -0x4(%rbp),%eax
cltq
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
lea ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
cmp [rbp+var_4], 4
jle short loc_1223
mov eax, [rbp+var_4]
cdqe
lea rdx, [rax-4]
mov rax, [rbp+s]
add rax, rdx
lea rdx, s2; "Roa... | const char * func0(const char *a1)
{
int v2; // [rsp+1Ch] [rbp-4h]
v2 = strlen(a1);
if ( v2 > 4 && !strcmp(&a1[v2 - 4], "Road") )
{
a1[v2 - 4] = 0;
*(_DWORD *)&a1[strlen(a1)] = 3040338;
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0x4
JLE 0x00101223
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
L... | char * func0(char *param_1)
{
int iVar1;
int iVar2;
size_t sVar3;
sVar3 = strlen(param_1);
iVar1 = (int)sVar3;
if (4 < iVar1) {
iVar2 = strcmp(param_1 + (long)iVar1 + -4,"Road");
if (iVar2 == 0) {
param_1[(long)iVar1 + -4] = '\0';
sVar3 = strlen(param_1);
builtin_strncpy(param_... |
7,141 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* street) {
int length = strlen(street);
if (length > 4 && strcmp(&street[length - 4], "Road") == 0) {
street[length - 4] = '\0';
strcat(street, "Rd.");
}
return street;
}
| int main() {
char street1[] = "ravipadu Road";
char street2[] = "palnadu Road";
char street3[] = "eshwar enclave Road";
assert(strcmp(func0(street1), "ravipadu Rd.") == 0);
assert(strcmp(func0(street2), "palnadu Rd.") == 0);
assert(strcmp(func0(street3), "eshwar enclave Rd.") == 0);
... | O1 | c | func0:
endbr64
mov %rdi,%rdx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp $0x4,%ecx
jle 11ac <func0+0x43>
movslq %ecx,%rcx
lea -0x4(%rdx,%rcx,1),%r8
mov $0x5,%ecx
lea 0xe66(%rip),%rdi
mov %r8,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta ... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
call _strlen
cmp eax, 4
jle short loc_11DA
cdqe
lea rbp, [rbx+rax-4]
lea rsi, aRoad; "Road"
mov rdi, rbp
call _strcmp
test eax, eax
jz short loc_11E4
loc_11DA:
mov rax, rbx
add rsp, 8
pop rbx
pop rbp... | long long func0(long long a1)
{
int v1; // eax
_BYTE *v2; // rbp
v1 = ((long long (*)(void))strlen)();
if ( v1 > 4 )
{
v2 = (_BYTE *)(a1 + v1 - 4);
if ( !(unsigned int)strcmp(v2, "Road") )
{
*v2 = 0;
*(_DWORD *)(a1 + strlen(a1)) = 3040338;
}
}
return a1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
CALL 0x00101080
CMP EAX,0x4
JLE 0x001011da
CDQE
LEA RBP,[RBX + RAX*0x1 + -0x4]
LEA RSI,[0x102004]
MOV RDI,RBP
CALL 0x001010b0
TEST EAX,EAX
JZ 0x001011e4
LAB_001011da:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011e4:
MOV byte ptr [RBP],0x0
MOV RDI,RBX
CAL... | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
sVar2 = strlen(param_1);
if (4 < (int)sVar2) {
iVar1 = strcmp(param_1 + (long)(int)sVar2 + -4,"Road");
if (iVar1 == 0) {
param_1[(long)(int)sVar2 + -4] = '\0';
sVar2 = strlen(param_1);
builtin_strncpy(param_1 + sVar2,"Rd.",4);
... |
7,142 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* street) {
int length = strlen(street);
if (length > 4 && strcmp(&street[length - 4], "Road") == 0) {
street[length - 4] = '\0';
strcat(street, "Rd.");
}
return street;
}
| int main() {
char street1[] = "ravipadu Road";
char street2[] = "palnadu Road";
char street3[] = "eshwar enclave Road";
assert(strcmp(func0(street1), "ravipadu Rd.") == 0);
assert(strcmp(func0(street2), "palnadu Rd.") == 0);
assert(strcmp(func0(street3), "eshwar enclave Rd.") == 0);
... | O2 | c | func0:
endbr64
push %r12
mov %rdi,%r12
callq 1070 <strlen@plt>
cmp $0x4,%eax
jle 1314 <func0+0x34>
cltq
mov $0x5,%ecx
lea 0xd03(%rip),%rdi
lea -0x4(%r12,%rax,1),%rdx
mov %rdx,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %al
sbb $0x0,%al
test %al,%al
je 1320 <func0+0x40>
mov %r12,%rax... | func0:
endbr64
push r12
mov r12, rdi
push rbx
sub rsp, 8
call _strlen
cmp eax, 4
jle short loc_1322
cdqe
lea rsi, aRoad; "Road"
lea rbx, [r12+rax-4]
mov rdi, rbx
call _strcmp
test eax, eax
jz short loc_1330
loc_1322:
add rsp, 8
mov rax, r12
pop rbx
pop r12... | long long func0(long long a1)
{
int v1; // eax
_BYTE *v2; // rbx
v1 = ((long long (*)(void))strlen)();
if ( v1 <= 4 )
return a1;
v2 = (_BYTE *)(a1 + v1 - 4);
if ( (unsigned int)strcmp(v2, "Road") )
return a1;
*v2 = 0;
*(_DWORD *)(a1 + strlen(a1)) = 3040338;
return a1;
} | func0:
ENDBR64
PUSH R12
MOV R12,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x00101080
CMP EAX,0x4
JLE 0x00101322
CDQE
LEA RSI,[0x102004]
LEA RBX,[R12 + RAX*0x1 + -0x4]
MOV RDI,RBX
CALL 0x001010b0
TEST EAX,EAX
JZ 0x00101330
LAB_00101322:
ADD RSP,0x8
MOV RAX,R12
POP RBX
POP R12
RET
LAB_00101330:
MOV byte ptr [RBX],0x0
MOV RDI,R12
CAL... | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
sVar2 = strlen(param_1);
if (4 < (int)sVar2) {
iVar1 = strcmp(param_1 + (long)(int)sVar2 + -4,"Road");
if (iVar1 == 0) {
param_1[(long)(int)sVar2 + -4] = '\0';
sVar2 = strlen(param_1);
builtin_strncpy(param_1 + sVar2,"Rd.",4);
... |
7,143 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* street) {
int length = strlen(street);
if (length > 4 && strcmp(&street[length - 4], "Road") == 0) {
street[length - 4] = '\0';
strcat(street, "Rd.");
}
return street;
}
| int main() {
char street1[] = "ravipadu Road";
char street2[] = "palnadu Road";
char street3[] = "eshwar enclave Road";
assert(strcmp(func0(street1), "ravipadu Rd.") == 0);
assert(strcmp(func0(street2), "palnadu Rd.") == 0);
assert(strcmp(func0(street3), "eshwar enclave Rd.") == 0);
... | O3 | c | func0:
endbr64
push %r12
mov %rdi,%r12
callq 1070 <strlen@plt>
cmp $0x4,%eax
jle 1314 <func0+0x34>
cltq
mov $0x5,%ecx
lea 0xd03(%rip),%rdi
lea -0x4(%r12,%rax,1),%rdx
mov %rdx,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %al
sbb $0x0,%al
test %al,%al
je 1320 <func0+0x40>
mov %r12,%rax... | func0:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
cmp eax, 4
jle short loc_1311
cdqe
lea rsi, aRoad; "Road"
lea rbp, [rbx+rax-4]
mov rdi, rbp; s1
call _strcmp
test eax, eax
jz short loc_1320
loc_1311:
add rsp, 8
mov rax, rbx
pop rbx
pop ... | char * func0(char *s)
{
int v1; // eax
const char *v2; // rbp
v1 = strlen(s);
if ( v1 <= 4 )
return s;
v2 = &s[v1 - 4];
if ( strcmp(v2, "Road") )
return s;
*v2 = 0;
*(_DWORD *)&s[strlen(s)] = 3040338;
return s;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101080
CMP EAX,0x4
JLE 0x00101311
CDQE
LEA RSI,[0x102004]
LEA RBP,[RBX + RAX*0x1 + -0x4]
MOV RDI,RBP
CALL 0x001010b0
TEST EAX,EAX
JZ 0x00101320
LAB_00101311:
ADD RSP,0x8
MOV RAX,RBX
POP RBX
POP RBP
RET
LAB_00101320:
MOV byte ptr [RBP],0x0
MOV RDI,RBX
CAL... | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
sVar2 = strlen(param_1);
if (4 < (int)sVar2) {
iVar1 = strcmp(param_1 + (long)(int)sVar2 + -4,"Road");
if (iVar1 == 0) {
param_1[(long)(int)sVar2 + -4] = '\0';
sVar2 = strlen(param_1);
builtin_strncpy(param_1 + sVar2,"Rd.",4);
... |
7,144 | func0 |
#include <assert.h>
| int func0(const char *str1) {
int count = 0;
while (*str1 != '\0') {
count++;
str1++;
}
return count;
}
| int main() {
assert(func0("python") == 6);
assert(func0("program") == 7);
assert(func0("language") == 8);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1167 <func0+0x1e>
addl $0x1,-0x4(%rbp)
addq $0x1,-0x18(%rbp)
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
jne 115e <func0+0x15>
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_4], 0
jmp short loc_1167
loc_115E:
add [rbp+var_4], 1
add [rbp+var_18], 1
loc_1167:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
test al, al
jnz short loc_115E
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(_BYTE *a1)
{
unsigned int v3; // [rsp+14h] [rbp-4h]
v3 = 0;
while ( *a1 )
{
++v3;
++a1;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101167
LAB_0010115e:
ADD dword ptr [RBP + -0x4],0x1
ADD qword ptr [RBP + -0x18],0x1
LAB_00101167:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010115e
MOV EAX,dword ptr [RBP + -0x4]
P... | int func0(char *param_1)
{
char *local_20;
int local_c;
local_c = 0;
for (local_20 = param_1; *local_20 != '\0'; local_20 = local_20 + 1) {
local_c = local_c + 1;
}
return local_c;
} |
7,145 | func0 |
#include <assert.h>
| int func0(const char *str1) {
int count = 0;
while (*str1 != '\0') {
count++;
str1++;
}
return count;
}
| int main() {
assert(func0("python") == 6);
assert(func0("program") == 7);
assert(func0("language") == 8);
return 0;
}
| O1 | c | func0:
endbr64
cmpb $0x0,(%rdi)
je 116b <func0+0x22>
mov %rdi,%rax
mov $0x1,%edx
sub %edi,%edx
lea (%rdx,%rax,1),%ecx
add $0x1,%rax
cmpb $0x0,(%rax)
jne 115c <func0+0x13>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1168 <func0+0x1f>
| func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_116B
mov rax, rdi
mov edx, 1
sub edx, edi
loc_115C:
lea ecx, [rdx+rax]
add rax, 1
cmp byte ptr [rax], 0
jnz short loc_115C
loc_1168:
mov eax, ecx
retn
loc_116B:
mov ecx, 0
jmp short loc_1168 | long long func0(_BYTE *a1)
{
_BYTE *v1; // rax
unsigned int v2; // ecx
if ( *a1 )
{
v1 = a1;
do
v2 = 1 - (_DWORD)a1 + (_DWORD)v1++;
while ( *v1 );
}
else
{
return 0;
}
return v2;
} | func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x0010116b
MOV RAX,RDI
MOV EDX,0x1
SUB EDX,EDI
LAB_0010115c:
LEA ECX,[RDX + RAX*0x1]
ADD RAX,0x1
CMP byte ptr [RAX],0x0
JNZ 0x0010115c
LAB_00101168:
MOV EAX,ECX
RET
LAB_0010116b:
MOV ECX,0x0
JMP 0x00101168 | int func0(char *param_1)
{
int iVar1;
int iVar2;
iVar2 = (int)param_1;
if (*param_1 == '\0') {
iVar1 = 0;
}
else {
do {
iVar1 = (1 - iVar2) + (int)param_1;
param_1 = param_1 + 1;
} while (*param_1 != '\0');
}
return iVar1;
} |
7,146 | func0 |
#include <assert.h>
| int func0(const char *str1) {
int count = 0;
while (*str1 != '\0') {
count++;
str1++;
}
return count;
}
| int main() {
assert(func0("python") == 6);
assert(func0("program") == 7);
assert(func0("language") == 8);
return 0;
}
| O2 | c | func0:
endbr64
cmpb $0x0,(%rdi)
je 1278 <func0+0x28>
mov $0x1,%eax
sub %edi,%eax
lea (%rax,%rdi,1),%r8d
add $0x1,%rdi
cmpb $0x0,(%rdi)
jne 1260 <func0+0x10>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_1278
mov eax, 1
sub eax, edi
loc_1260:
lea r8d, [rax+rdi]
add rdi, 1
cmp byte ptr [rdi], 0
jnz short loc_1260
mov eax, r8d
retn
loc_1278:
xor r8d, r8d
mov eax, r8d
retn | long long func0(_BYTE *a1)
{
int v1; // eax
unsigned int v2; // r8d
if ( !*a1 )
return 0LL;
v1 = 1 - (_DWORD)a1;
do
v2 = v1 + (_DWORD)a1++;
while ( *a1 );
return v2;
} | func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x00101278
MOV EAX,0x1
SUB EAX,EDI
LAB_00101260:
LEA R8D,[RAX + RDI*0x1]
ADD RDI,0x1
CMP byte ptr [RDI],0x0
JNZ 0x00101260
MOV EAX,R8D
RET
LAB_00101278:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(char *param_1)
{
int iVar1;
int iVar2;
if (*param_1 != '\0') {
iVar2 = (int)param_1;
do {
iVar1 = (int)param_1;
param_1 = param_1 + 1;
} while (*param_1 != '\0');
return (1 - iVar2) + iVar1;
}
return 0;
} |
7,147 | func0 |
#include <assert.h>
| int func0(const char *str1) {
int count = 0;
while (*str1 != '\0') {
count++;
str1++;
}
return count;
}
| int main() {
assert(func0("python") == 6);
assert(func0("program") == 7);
assert(func0("language") == 8);
return 0;
}
| O3 | c | func0:
endbr64
cmpb $0x0,(%rdi)
je 1258 <func0+0x28>
mov $0x1,%eax
sub %edi,%eax
lea (%rax,%rdi,1),%r8d
add $0x1,%rdi
cmpb $0x0,(%rdi)
jne 1240 <func0+0x10>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_1180
sub rsp, 8
add rdi, 1; s
call _strlen
add rsp, 8
add eax, 1
retn
loc_1180:
xor eax, eax
retn | long long func0(long long a1)
{
if ( *(_BYTE *)a1 )
return (unsigned int)strlen((const char *)(a1 + 1)) + 1;
else
return 0LL;
} | func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x00101180
SUB RSP,0x8
ADD RDI,0x1
CALL 0x00101050
ADD RSP,0x8
ADD EAX,0x1
RET
LAB_00101180:
XOR EAX,EAX
RET | int func0(char *param_1)
{
size_t sVar1;
if (*param_1 != '\0') {
sVar1 = strlen(param_1 + 1);
return (int)sVar1 + 1;
}
return 0;
} |
7,148 | func0 |
#include <assert.h>
| double func0(double p, double q) {
double area = (p * q) / 2;
return area;
}
| int main() {
assert(func0(10, 20) == 100);
assert(func0(10, 5) == 25);
assert(func0(4, 2) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd %xmm1,-0x20(%rbp)
movsd -0x18(%rbp),%xmm0
mulsd -0x20(%rbp),%xmm0
movsd 0xf1b(%rip),%xmm1
divsd %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 [rbp+var_20], xmm1
movsd xmm0, [rbp+var_18]
mulsd xmm0, [rbp+var_20]
movsd xmm1, cs:qword_2068
divsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1, double a2)
{
return a1 * a2 / 2.0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOVSD XMM0,qword ptr [RBP + -0x18]
MULSD XMM0,qword ptr [RBP + -0x20]
MOVSD XMM1,qword ptr [0x00102068]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(double param_1,double param_2)
{
return (param_1 * param_2) / DAT_00102068;
} |
7,149 | func0 |
#include <assert.h>
| double func0(double p, double q) {
double area = (p * q) / 2;
return area;
}
| int main() {
assert(func0(10, 20) == 100);
assert(func0(10, 5) == 25);
assert(func0(4, 2) == 4);
return 0;
}
| O1 | c | func0:
endbr64
mulsd %xmm1,%xmm0
mulsd 0xecf(%rip),%xmm0
retq
| func0:
endbr64
mulsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
retn | double func0(double a1, double a2)
{
return a1 * a2 * 0.5;
} | func0:
ENDBR64
MULSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
return param_1 * param_2 * _DAT_00102008;
} |
7,150 | func0 |
#include <assert.h>
| double func0(double p, double q) {
double area = (p * q) / 2;
return area;
}
| int main() {
assert(func0(10, 20) == 100);
assert(func0(10, 5) == 25);
assert(func0(4, 2) == 4);
return 0;
}
| O2 | c | func0:
endbr64
mulsd %xmm1,%xmm0
mulsd 0xeb8(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mulsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
retn | double func0(double a1, double a2)
{
return a1 * a2 * 0.5;
} | func0:
ENDBR64
MULSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
return param_1 * param_2 * _DAT_00102008;
} |
7,151 | func0 |
#include <assert.h>
| double func0(double p, double q) {
double area = (p * q) / 2;
return area;
}
| int main() {
assert(func0(10, 20) == 100);
assert(func0(10, 5) == 25);
assert(func0(4, 2) == 4);
return 0;
}
| O3 | c | func0:
endbr64
mulsd %xmm1,%xmm0
mulsd 0xeb8(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mulsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
retn | double func0(double a1, double a2)
{
return a1 * a2 * 0.5;
} | func0:
ENDBR64
MULSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
return param_1 * param_2 * _DAT_00102008;
} |
7,152 | func0 |
#include <assert.h>
| void func0(int arr[], int n) {
int low = 0;
int mid = 0;
int high = n - 1;
while (mid <= high) {
if (arr[mid] == 0) {
int temp = arr[low];
arr[low] = arr[mid];
arr[mid] = temp;
low++;
mid++;
} else if (arr[mid] ... | int main() {
int arr1[9] = {1,2,0,1,0,1,2,1,1};
func0(arr1, 9);
int expected_arr1[9] = {0, 0, 1, 1, 1, 1, 1, 2, 2};
for (int i = 0; i < 9; i++)
assert(arr1[i] == expected_arr1[i]);
int arr2[10] = {1,0,0,1,2,1,2,2,1,0};
func0(arr2, 10);
int expected_arr2[10] = {0, 0, 0, 1, 1... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
jmpq 129e <func0+0x135>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov eax, [rbp+var_2C]
sub eax, 1
mov [rbp+var_C], eax
jmp loc_129E
loc_1194:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
a... | long long func0(long long a1, int a2)
{
long long result; // rax
int v3; // [rsp+18h] [rbp-14h]
unsigned int v4; // [rsp+1Ch] [rbp-10h]
int v5; // [rsp+20h] [rbp-Ch]
int v6; // [rsp+24h] [rbp-8h]
int v7; // [rsp+28h] [rbp-4h]
v3 = 0;
v4 = 0;
v5 = a2 - 1;
while ( 1 )
{
result = v4;
if ( (... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x0010129e
LAB_00101194:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x... | void func0(long param_1,int param_2)
{
int4 uVar1;
int4 local_1c;
int4 local_18;
int4 local_14;
local_1c = 0;
local_18 = 0;
local_14 = param_2 + -1;
while (local_18 <= local_14) {
if (*(int *)(param_1 + (long)local_18 * 4) == 0) {
uVar1 = *(int4 *)(param_1 + (long)local_1c * 4);
*(in... |
7,153 | func0 |
#include <assert.h>
| void func0(int arr[], int n) {
int low = 0;
int mid = 0;
int high = n - 1;
while (mid <= high) {
if (arr[mid] == 0) {
int temp = arr[low];
arr[low] = arr[mid];
arr[mid] = temp;
low++;
mid++;
} else if (arr[mid] ... | int main() {
int arr1[9] = {1,2,0,1,0,1,2,1,1};
func0(arr1, 9);
int expected_arr1[9] = {0, 0, 1, 1, 1, 1, 1, 2, 2};
for (int i = 0; i < 9; i++)
assert(arr1[i] == expected_arr1[i]);
int arr2[10] = {1,0,0,1,2,1,2,2,1,0};
func0(arr2, 10);
int expected_arr2[10] = {0, 0, 0, 1, 1... | O1 | c | func0:
endbr64
sub $0x1,%esi
js 11c9 <func0+0x60>
mov $0x0,%eax
mov $0x0,%r8d
jmp 119b <func0+0x32>
cmp $0x1,%edx
je 11c4 <func0+0x5b>
movslq %esi,%r9
lea (%rdi,%r9,4),%r9
mov (%r9),%r10d
mov %r10d,(%rcx)
mov %edx,(%r9)
sub $0x1,%esi
cmp %esi,%eax
jg 11c9 <func0+0x60>
movslq... | func0:
endbr64
sub esi, 1
js short locret_11C9
mov eax, 0
mov r8d, 0
jmp short loc_119B
loc_117F:
cmp edx, 1
jz short loc_11C4
movsxd r9, esi
lea r9, [rdi+r9*4]
mov r10d, [r9]
mov [rcx], r10d
mov [r9], edx
sub esi, 1
loc_1197:
cmp eax, esi
jg short locret_11C9... | void func0(long long a1, int a2)
{
int v2; // esi
int v3; // eax
int v4; // r8d
int *v5; // r9
int *v6; // rcx
int v7; // edx
int *v8; // rdx
int v9; // r9d
v2 = a2 - 1;
if ( v2 >= 0 )
{
v3 = 0;
v4 = 0;
do
{
v6 = (int *)(a1 + 4LL * v3);
v7 = *v6;
if ( *v6 )
... | func0:
ENDBR64
SUB ESI,0x1
JS 0x001011c9
MOV EAX,0x0
MOV R8D,0x0
JMP 0x0010119b
LAB_0010117f:
CMP EDX,0x1
JZ 0x001011c4
MOVSXD R9,ESI
LEA R9,[RDI + R9*0x4]
MOV R10D,dword ptr [R9]
MOV dword ptr [RCX],R10D
MOV dword ptr [R9],EDX
SUB ESI,0x1
LAB_00101197:
CMP EAX,ESI
JG 0x001011c9
LAB_0010119b:
MOVSXD RDX,EAX
LEA RCX,[RD... | void func0(long param_1,int param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
int iVar5;
param_2 = param_2 + -1;
if (-1 < param_2) {
iVar4 = 0;
iVar5 = 0;
do {
piVar1 = (int *)(param_1 + (long)iVar4 * 4);
iVar3 = *piVar1;
if (iVar3 == 0) {
piVar2 = (int *... |
7,154 | func0 |
#include <assert.h>
| void func0(int arr[], int n) {
int low = 0;
int mid = 0;
int high = n - 1;
while (mid <= high) {
if (arr[mid] == 0) {
int temp = arr[low];
arr[low] = arr[mid];
arr[mid] = temp;
low++;
mid++;
} else if (arr[mid] ... | int main() {
int arr1[9] = {1,2,0,1,0,1,2,1,1};
func0(arr1, 9);
int expected_arr1[9] = {0, 0, 1, 1, 1, 1, 1, 2, 2};
for (int i = 0; i < 9; i++)
assert(arr1[i] == expected_arr1[i]);
int arr2[10] = {1,0,0,1,2,1,2,2,1,0};
func0(arr2, 10);
int expected_arr2[10] = {0, 0, 0, 1, 1... | O2 | c | func0:
endbr64
sub $0x1,%esi
js 1477 <func0+0x57>
xor %eax,%eax
xor %r8d,%r8d
jmp 144e <func0+0x2e>
movslq %r8d,%rdx
add $0x1,%eax
add $0x1,%r8d
lea (%rdi,%rdx,4),%rdx
mov (%rdx),%r9d
movl $0x0,(%rdx)
mov %r9d,(%rcx)
cmp %eax,%esi
jl 1477 <func0+0x57>
movslq %eax,%rdx
lea (%rd... | func0:
endbr64
sub esi, 1
js short locret_1477
xor eax, eax
xor r8d, r8d
jmp short loc_144E
loc_1430:
movsxd rdx, r8d
add eax, 1
add r8d, 1
lea rdx, [rdi+rdx*4]
mov r9d, [rdx]
mov dword ptr [rdx], 0
mov [rcx], r9d
loc_144A:
cmp esi, eax
jl short locret_1477
loc_144... | void func0(long long a1, int a2)
{
int v2; // esi
int v3; // eax
int v4; // r8d
long long v5; // rdx
int *v6; // rdx
int v7; // r9d
int *v8; // rcx
int v9; // edx
long long v10; // r9
int *v11; // r9
v2 = a2 - 1;
if ( v2 >= 0 )
{
v3 = 0;
v4 = 0;
do
{
while ( 1 )
{... | func0:
ENDBR64
SUB ESI,0x1
JS 0x00101477
XOR EAX,EAX
XOR R8D,R8D
JMP 0x0010144e
LAB_00101430:
MOVSXD RDX,R8D
ADD EAX,0x1
ADD R8D,0x1
LEA RDX,[RDI + RDX*0x4]
MOV R9D,dword ptr [RDX]
MOV dword ptr [RDX],0x0
MOV dword ptr [RCX],R9D
LAB_0010144a:
CMP ESI,EAX
JL 0x00101477
LAB_0010144e:
MOVSXD RDX,EAX
LEA RCX,[RDI + RDX*0x4... | void func0(long param_1,int param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
int iVar5;
long lVar6;
param_2 = param_2 + -1;
if (-1 < param_2) {
iVar4 = 0;
iVar5 = 0;
do {
while( true ) {
piVar1 = (int *)(param_1 + (long)iVar4 * 4);
iVar3 = *piVar1;
... |
7,155 | func0 |
#include <assert.h>
| void func0(int arr[], int n) {
int low = 0;
int mid = 0;
int high = n - 1;
while (mid <= high) {
if (arr[mid] == 0) {
int temp = arr[low];
arr[low] = arr[mid];
arr[mid] = temp;
low++;
mid++;
} else if (arr[mid] ... | int main() {
int arr1[9] = {1,2,0,1,0,1,2,1,1};
func0(arr1, 9);
int expected_arr1[9] = {0, 0, 1, 1, 1, 1, 1, 2, 2};
for (int i = 0; i < 9; i++)
assert(arr1[i] == expected_arr1[i]);
int arr2[10] = {1,0,0,1,2,1,2,2,1,0};
func0(arr2, 10);
int expected_arr2[10] = {0, 0, 0, 1, 1... | O3 | c | func0:
endbr64
sub $0x1,%esi
js 1537 <func0+0x57>
xor %eax,%eax
xor %r8d,%r8d
jmp 150e <func0+0x2e>
movslq %r8d,%rdx
add $0x1,%eax
add $0x1,%r8d
lea (%rdi,%rdx,4),%rdx
mov (%rdx),%r9d
movl $0x0,(%rdx)
mov %r9d,(%rcx)
cmp %eax,%esi
jl 1537 <func0+0x57>
movslq %eax,%rdx
lea (%rd... | func0:
endbr64
sub esi, 1
js short locret_1407
xor eax, eax
xor r8d, r8d
jmp short loc_13DE
loc_13C0:
movsxd rdx, r8d
add eax, 1
add r8d, 1
lea rdx, [rdi+rdx*4]
mov r9d, [rdx]
mov dword ptr [rdx], 0
mov [rcx], r9d
loc_13DA:
cmp esi, eax
jl short locret_1407
loc_13D... | void func0(long long a1, int a2)
{
int v2; // esi
int v3; // eax
int v4; // r8d
long long v5; // rdx
int *v6; // rdx
int v7; // r9d
int *v8; // rcx
int v9; // edx
long long v10; // r9
int *v11; // r9
v2 = a2 - 1;
if ( v2 >= 0 )
{
v3 = 0;
v4 = 0;
do
{
while ( 1 )
{... | func0:
ENDBR64
SUB ESI,0x1
JS 0x00101407
XOR EAX,EAX
XOR R8D,R8D
JMP 0x001013de
LAB_001013c0:
MOVSXD RDX,R8D
ADD EAX,0x1
ADD R8D,0x1
LEA RDX,[RDI + RDX*0x4]
MOV R9D,dword ptr [RDX]
MOV dword ptr [RDX],0x0
MOV dword ptr [RCX],R9D
LAB_001013da:
CMP ESI,EAX
JL 0x00101407
LAB_001013de:
MOVSXD RDX,EAX
LEA RCX,[RDI + RDX*0x4... | void func0(long param_1,int param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
int iVar5;
long lVar6;
param_2 = param_2 + -1;
if (-1 < param_2) {
iVar4 = 0;
iVar5 = 0;
do {
while( true ) {
piVar1 = (int *)(param_1 + (long)iVar4 * 4);
iVar3 = *piVar1;
... |
7,156 | func0 |
#include <assert.h>
#include <stdlib.h>
typedef struct {
int *elements;
size_t size;
} tuple;
| tuple func0(tuple test_tup) {
tuple new_tup;
new_tup.elements = NULL;
new_tup.size = 0;
return new_tup;
}
| int main() {
tuple result;
result = func0((tuple){ (int[]){1, 5, 3, 6, 8}, 5 });
assert(result.size == 0);
result = func0((tuple){ (int[]){2, 1, 4, 5, 6}, 5 });
assert(result.size == 0);
result = func0((tuple){ (int[]){3, 2, 5, 6, 8}, 5 });
assert(result.size == 0);
retur... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,%rax
mov %rsi,%rcx
mov %rcx,%rdx
mov %rax,-0x20(%rbp)
mov %rdx,-0x18(%rbp)
movq $0x0,-0x10(%rbp)
movq $0x0,-0x8(%rbp)
mov -0x10(%rbp),%rax
mov -0x8(%rbp),%rdx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov rax, rdi
mov rcx, rsi
mov rdx, rcx
mov [rbp+var_20], rax
mov [rbp+var_18], rdx
mov [rbp+var_10], 0
mov [rbp+var_8], 0
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
pop rbp
retn | long long func0()
{
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
MOV RCX,RSI
MOV RDX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x10],0x0
MOV qword ptr [RBP + -0x8],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
POP RBP
RET | int [16] func0(void)
{
return ZEXT816(0);
} |
7,157 | func0 |
#include <assert.h>
#include <stdlib.h>
typedef struct {
int *elements;
size_t size;
} tuple;
| tuple func0(tuple test_tup) {
tuple new_tup;
new_tup.elements = NULL;
new_tup.size = 0;
return new_tup;
}
| int main() {
tuple result;
result = func0((tuple){ (int[]){1, 5, 3, 6, 8}, 5 });
assert(result.size == 0);
result = func0((tuple){ (int[]){2, 1, 4, 5, 6}, 5 });
assert(result.size == 0);
result = func0((tuple){ (int[]){3, 2, 5, 6, 8}, 5 });
assert(result.size == 0);
retur... | O1 | c | func0:
endbr64
mov $0x0,%eax
mov $0x0,%edx
retq
| func0:
endbr64
mov eax, 0
mov edx, 0
retn | long long func0()
{
return 0LL;
} | func0:
ENDBR64
MOV EAX,0x0
MOV EDX,0x0
RET | int1 [16] func0(void)
{
return ZEXT816(0);
} |
7,158 | func0 |
#include <assert.h>
#include <stdlib.h>
typedef struct {
int *elements;
size_t size;
} tuple;
| tuple func0(tuple test_tup) {
tuple new_tup;
new_tup.elements = NULL;
new_tup.size = 0;
return new_tup;
}
| int main() {
tuple result;
result = func0((tuple){ (int[]){1, 5, 3, 6, 8}, 5 });
assert(result.size == 0);
result = func0((tuple){ (int[]){2, 1, 4, 5, 6}, 5 });
assert(result.size == 0);
result = func0((tuple){ (int[]){3, 2, 5, 6, 8}, 5 });
assert(result.size == 0);
retur... | O2 | c | func0:
endbr64
xor %eax,%eax
xor %edx,%edx
retq
nopl 0x0(%rax)
| func0:
endbr64
xor eax, eax
xor edx, edx
retn | long long func0()
{
return 0LL;
} | func0:
ENDBR64
XOR EAX,EAX
XOR EDX,EDX
RET | int1 [16] func0(void)
{
return ZEXT816(0);
} |
7,159 | func0 |
#include <assert.h>
#include <stdlib.h>
typedef struct {
int *elements;
size_t size;
} tuple;
| tuple func0(tuple test_tup) {
tuple new_tup;
new_tup.elements = NULL;
new_tup.size = 0;
return new_tup;
}
| int main() {
tuple result;
result = func0((tuple){ (int[]){1, 5, 3, 6, 8}, 5 });
assert(result.size == 0);
result = func0((tuple){ (int[]){2, 1, 4, 5, 6}, 5 });
assert(result.size == 0);
result = func0((tuple){ (int[]){3, 2, 5, 6, 8}, 5 });
assert(result.size == 0);
retur... | O3 | c | func0:
endbr64
xor %eax,%eax
xor %edx,%edx
retq
nopl 0x0(%rax)
| func0:
endbr64
xor eax, eax
xor edx, edx
retn | long long func0()
{
return 0LL;
} | func0:
ENDBR64
XOR EAX,EAX
XOR EDX,EDX
RET | int [16] func0(void)
{
return ZEXT816(0);
} |
7,160 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int nums[], int size, int m, int n, int* result_size) {
int* result = (int*)malloc(size * sizeof(int));
int count = 0;
for (int i = 0; i < size; i++) {
if (nums[i] % m == 0 || nums[i] % n == 0) {
result[count++] = nums[i];
}
}
*result_size = count;
... | int main() {
int nums1[] = {19, 65, 57, 39, 152, 639, 121, 44, 90, 190};
int nums2[] = {1, 2, 3, 5, 7, 8, 10};
int nums3[] = {10, 15, 14, 13, 18, 12, 20};
int expected1[] = {19, 65, 57, 39, 152, 190};
int expected2[] = {2, 5, 8, 10};
int expected3[] = {10, 15, 20};
int result_size1, r... | 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 %ecx,-0x24(%rbp)
mov %r8,-0x30(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
movl... | 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_24], ecx
mov [rbp+var_30], r8
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_10]... | _DWORD * func0(long long a1, int a2, int a3, int a4, _DWORD *a5)
{
int v5; // eax
int v10; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
_DWORD *v12; // [rsp+28h] [rbp-8h]
v12 = malloc(4LL * a2);
v10 = 0;
for ( i = 0; i < a2; ++i )
{
if ( !(*(_DWORD *)(4LL * i + a1) % a3) || !(*(_DWORD *)(4LL... | 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 dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV ... | void * func0(long param_1,int param_2,int param_3,int param_4,int *param_5)
{
void *pvVar1;
int4 local_18;
int4 local_14;
pvVar1 = malloc((long)param_2 << 2);
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if ((*(int *)(param_1 + (long)local_14 * 4) % param_3 == 0) |... |
7,161 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int nums[], int size, int m, int n, int* result_size) {
int* result = (int*)malloc(size * sizeof(int));
int count = 0;
for (int i = 0; i < size; i++) {
if (nums[i] % m == 0 || nums[i] % n == 0) {
result[count++] = nums[i];
}
}
*result_size = count;
... | int main() {
int nums1[] = {19, 65, 57, 39, 152, 639, 121, 44, 90, 190};
int nums2[] = {1, 2, 3, 5, 7, 8, 10};
int nums3[] = {10, 15, 14, 13, 18, 12, 20};
int expected1[] = {19, 65, 57, 39, 152, 190};
int expected2[] = {2, 5, 8, 10};
int expected3[] = {10, 15, 20};
int result_size1, r... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r14
mov %esi,%r13d
mov %edx,%ebx
mov %ecx,%ebp
mov %r8,%r12
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r8
test %r13d,%r13d
jle 1212 <func0+0x69>
mov %r14,%rsi
lea -0x1(%r13),%eax
l... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov r13d, esi
mov ebx, edx
mov ebp, ecx
mov r12, r8
movsxd rdi, esi
shl rdi, 2
call _malloc
mov r8, rax
test r13d, r13d
jle short loc_1212
mov rsi, r14
lea eax, [r13-1]
lea r9, [r14... | long long func0(int *a1, int a2, int a3, int a4, _DWORD *a5)
{
long long v9; // r8
int *v10; // rsi
long long v11; // r9
int v12; // edi
int v13; // ecx
v9 = malloc(4LL * a2);
if ( a2 <= 0 )
{
v12 = 0;
}
else
{
v10 = a1;
v11 = (long long)&a1[a2 - 1 + 1];
v12 = 0;
do
{
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV R13D,ESI
MOV EBX,EDX
MOV EBP,ECX
MOV R12,R8
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
MOV R8,RAX
TEST R13D,R13D
JLE 0x00101212
MOV RSI,R14
LEA EAX,[R13 + -0x1]
LEA R9,[R14 + RAX*0x4 + 0x4]
MOV EDI,0x0
JMP 0x001011fc
LAB_001011e9:
MOVSXD RAX,ED... | void * func0(int *param_1,int param_2,int param_3,int param_4,int *param_5)
{
int *piVar1;
int iVar2;
void *pvVar3;
int iVar4;
pvVar3 = malloc((long)param_2 << 2);
if (param_2 < 1) {
iVar4 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar4 = 0;
do {
iVar2 = *param... |
7,162 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int nums[], int size, int m, int n, int* result_size) {
int* result = (int*)malloc(size * sizeof(int));
int count = 0;
for (int i = 0; i < size; i++) {
if (nums[i] % m == 0 || nums[i] % n == 0) {
result[count++] = nums[i];
}
}
*result_size = count;
... | int main() {
int nums1[] = {19, 65, 57, 39, 152, 639, 121, 44, 90, 190};
int nums2[] = {1, 2, 3, 5, 7, 8, 10};
int nums3[] = {10, 15, 14, 13, 18, 12, 20};
int expected1[] = {19, 65, 57, 39, 152, 190};
int expected2[] = {2, 5, 8, 10};
int expected3[] = {10, 15, 20};
int result_size1, r... | O2 | c | func0:
endbr64
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
mov %rdi,%r13
shl $0x2,%rdi
push %r12
mov %r8,%r12
push %rbp
mov %ecx,%ebp
push %rbx
mov %edx,%ebx
callq 10b0 <malloc@plt>
mov %rax,%r10
test %r13d,%r13d
jle 1530 <func0+0x80>
lea -0x1(%r13),%eax
mov %r14,%rdi
x... | func0:
endbr64
push r14
mov r14, rdi
movsxd rdi, esi
push r13
mov r13, rdi
shl rdi, 2
push r12
mov r12, r8
push rbp
mov ebp, ecx
push rbx
mov ebx, edx
call _malloc
mov r9, rax
test r13d, r13d
jle short loc_1530
lea eax, [r13-1]
mov rsi, r14
xor edi, edi
... | long long func0(int *a1, int a2, int a3, int a4, _DWORD *a5)
{
long long result; // rax
long long v11; // r9
int *v12; // rsi
int v13; // edi
int v14; // ecx
long long v15; // rax
result = malloc(4LL * a2);
v11 = result;
if ( a2 <= 0 )
{
*a5 = 0;
}
else
{
v12 = a1;
v13 = 0;
d... | func0:
ENDBR64
PUSH R14
MOV R14,RDI
MOVSXD RDI,ESI
PUSH R13
MOV R13,RDI
SHL RDI,0x2
PUSH R12
MOV R12,R8
PUSH RBP
MOV EBP,ECX
PUSH RBX
MOV EBX,EDX
CALL 0x001010b0
MOV R9,RAX
TEST R13D,R13D
JLE 0x00101530
LEA EAX,[R13 + -0x1]
MOV RSI,R14
XOR EDI,EDI
LEA R10,[R14 + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001014f0... | void * func0(int *param_1,int param_2,int param_3,int param_4,int *param_5)
{
int *piVar1;
int iVar2;
void *pvVar3;
long lVar4;
int iVar5;
pvVar3 = malloc((long)param_2 << 2);
if (0 < param_2) {
iVar5 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
iVar2 = *param_1;
if (... |
7,163 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int nums[], int size, int m, int n, int* result_size) {
int* result = (int*)malloc(size * sizeof(int));
int count = 0;
for (int i = 0; i < size; i++) {
if (nums[i] % m == 0 || nums[i] % n == 0) {
result[count++] = nums[i];
}
}
*result_size = count;
... | int main() {
int nums1[] = {19, 65, 57, 39, 152, 639, 121, 44, 90, 190};
int nums2[] = {1, 2, 3, 5, 7, 8, 10};
int nums3[] = {10, 15, 14, 13, 18, 12, 20};
int expected1[] = {19, 65, 57, 39, 152, 190};
int expected2[] = {2, 5, 8, 10};
int expected3[] = {10, 15, 20};
int result_size1, r... | O3 | c | func0:
endbr64
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
mov %rdi,%r13
shl $0x2,%rdi
push %r12
mov %r8,%r12
push %rbp
mov %ecx,%ebp
push %rbx
mov %edx,%ebx
callq 10b0 <malloc@plt>
mov %rax,%r10
test %r13d,%r13d
jle 14f0 <func0+0x80>
lea -0x1(%r13),%eax
mov %r14,%rdi
x... | func0:
endbr64
push r15
movsxd r9, esi
push r14
mov r15, r9
mov r14, r8
push r13
mov r13d, ecx
push r12
lea r12, ds:0[r9*4]
push rbp
mov ebp, edx
push rbx
mov rbx, rdi
mov rdi, r12; size
sub rsp, 8
call _malloc
mov r8, rax
test r15d, r15d
jle short loc_14... | _DWORD * func0(int *a1, int a2, int a3, int a4, _DWORD *a5)
{
size_t v7; // r12
_DWORD *v10; // r8
int *v11; // rsi
int v12; // edi
int v13; // ecx
long long v14; // rax
v7 = a2;
v10 = malloc(v7 * 4);
if ( a2 <= 0 )
{
v12 = 0;
}
else
{
v11 = a1;
v12 = 0;
do
{
v13 = *... | func0:
ENDBR64
PUSH R15
MOVSXD R9,ESI
PUSH R14
MOV R15,R9
MOV R14,R8
PUSH R13
MOV R13D,ECX
PUSH R12
LEA R12,[R9*0x4]
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x8
CALL 0x001010b0
MOV R8,RAX
TEST R15D,R15D
JLE 0x001014b8
MOV RSI,RBX
LEA R9,[RBX + R12*0x1]
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_00101478:... | void * func0(int *param_1,int param_2,int param_3,int param_4,int *param_5)
{
int *piVar1;
int iVar2;
void *pvVar3;
long lVar4;
int iVar5;
pvVar3 = malloc((long)param_2 * 4);
if (param_2 < 1) {
iVar5 = 0;
}
else {
piVar1 = param_1 + param_2;
iVar5 = 0;
do {
iVar2 = *param_1;
... |
7,164 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str) {
int lower_ctr = 0;
for (int i = 0; i < strlen(str); i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
lower_ctr++;
}
}
return lower_ctr;
}
| int main() {
assert(func0("abc") == 3);
assert(func0("string") == 6);
assert(func0("Python") == 5);
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 $0x0,-0x14(%rbp)
jmp 11ba <func0+0x51>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x60,%al
jle 11b6 <func0+0x4d>
mov ... | 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], 0
jmp short loc_11BA
loc_118A:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 60h ; '`'
jle short ... | long long func0(const char *a1)
{
unsigned int v2; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v2 = 0;
for ( i = 0; i < strlen(a1); ++i )
{
if ( a1[i] > 96 && a1[i] <= 122 )
++v2;
}
return v2;
} | 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],0x0
JMP 0x001011ba
LAB_0010118a:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x60
JLE 0x001... | int func0(char *param_1)
{
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_1[local_1c]) && (param_1[local_1c] < '{')) {
local_20 = local_20 + 1;
}
local_1c... |
7,165 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str) {
int lower_ctr = 0;
for (int i = 0; i < strlen(str); i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
lower_ctr++;
}
}
return lower_ctr;
}
| int main() {
assert(func0("abc") == 3);
assert(func0("string") == 6);
assert(func0("Python") == 5);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rsi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %rsi,%rdx
lea -0x1(%rsi,%rcx,1),%rsi
mov $0x0,%ecx
cmp %rsi,%rdx
je 1184 <func0+0x3b>
movzbl (%rdx),%eax
sub $0x61,%eax
cmp $0x1a,%al
adc $0x0,%ecx
add $0x1,%rdx
jmp ... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdi, rax
mov rax, rbx
add rdi, rbx
mov ecx, 0
jmp short loc_1196
loc_1186:
movzx esi, byte ptr [rax]
lea edx, [rsi-61h]
cmp dl, 1Ah
adc ecx, 0
add rax, 1
loc_1196:
cmp rax, rdi
jnz short loc_1186
mov eax, e... | long long func0(_BYTE *a1)
{
long long v2; // rdi
_BYTE *v3; // rax
_BYTE *v4; // rdi
unsigned int v5; // ecx
v2 = strlen();
v3 = a1;
v4 = &a1[v2];
v5 = 0;
while ( v3 != v4 )
v5 += (unsigned __int8)(*v3++ - 97) < 0x1Au;
return v5;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV RDI,RAX
MOV RAX,RBX
ADD RDI,RBX
MOV ECX,0x0
JMP 0x00101196
LAB_00101186:
MOVZX ESI,byte ptr [RAX]
LEA EDX,[RSI + -0x61]
CMP DL,0x1a
ADC ECX,0x0
ADD RAX,0x1
LAB_00101196:
CMP RAX,RDI
JNZ 0x00101186
MOV EAX,ECX
POP RBX
RET | int func0(char *param_1)
{
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)((byte)(*param_1 + 0x9fU) < 0x1a);
}
return iVar2;
} |
7,166 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str) {
int lower_ctr = 0;
for (int i = 0; i < strlen(str); i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
lower_ctr++;
}
}
return lower_ctr;
}
| int main() {
assert(func0("abc") == 3);
assert(func0("string") == 6);
assert(func0("Python") == 5);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %rbx,%rdi
lea (%rbx,%rax,1),%rcx
xor %eax,%eax
jmp 1240 <func0+0x30>
nopl 0x0(%rax,%rax,1)
movzbl (%rdi),%esi
lea -0x61(%rsi),%edx
cmp $0x1a,%dl
adc $0x0,%eax
add $0x1,%rdi
cmp %rcx,%rdi
jne 1230 <func0+0x20>
pop ... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdi, rbx
lea rcx, [rbx+rax]
xor eax, eax
jmp short loc_1240
loc_1230:
movzx esi, byte ptr [rdi]
lea edx, [rsi-61h]
cmp dl, 1Ah
adc eax, 0
add rdi, 1
loc_1240:
cmp rdi, rcx
jnz short loc_1230
pop rbx
retn | long long func0(_BYTE *a1)
{
_BYTE *v1; // rcx
long long result; // rax
v1 = &a1[strlen()];
result = 0LL;
while ( a1 != v1 )
result = ((unsigned __int8)(*a1++ - 97) < 0x1Au) + (unsigned int)result;
return result;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV RDI,RBX
LEA RCX,[RBX + RAX*0x1]
XOR EAX,EAX
JMP 0x00101240
LAB_00101230:
MOVZX ESI,byte ptr [RDI]
LEA EDX,[RSI + -0x61]
CMP DL,0x1a
ADC EAX,0x0
ADD RDI,0x1
LAB_00101240:
CMP RDI,RCX
JNZ 0x00101230
POP RBX
RET | int func0(char *param_1)
{
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)((byte)(*param_1 + 0x9fU) < 0x1a);
}
return iVar2;
} |
7,167 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str) {
int lower_ctr = 0;
for (int i = 0; i < strlen(str); i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
lower_ctr++;
}
}
return lower_ctr;
}
| int main() {
assert(func0("abc") == 3);
assert(func0("string") == 6);
assert(func0("Python") == 5);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
test %rax,%rax
je 14b0 <func0+0x2a0>
mov %rax,%rcx
lea -0x1(%rax),%rax
cmp $0xe,%rax
jbe 14b4 <func0+0x2a4>
mov %rcx,%rax
mov %rbx,%rdx
pxor %xmm1,%xmm1
movdqa 0xe57(%rip),%xmm7
and $0xfffffffffffffff0,%rax
movdqa 0xe5b(%r... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test rax, rax
jz loc_1470
mov rdx, rax
lea rax, [rax-1]
cmp rax, 0Eh
jbe loc_1474
mov rcx, rdx
pxor xmm1, xmm1
pxor xmm3, xmm3
mov rax, rbx
and rcx, 0FFFFFFFFFFFFFFF0h
movdqa xmm6, cs:xmmword_2080
movdqa xmm5, cs:xmm... | long long func0(const char *a1)
{
size_t v2; // rax
size_t v3; // rdx
__m128i v4; // xmm1
const __m128i *v5; // rax
unsigned long long v6; // rcx
__m128i si128; // xmm6
__m128i v8; // xmm5
__m128i v9; // xmm2
__m128i v10; // xmm0
__m128i v11; // xmm7
__m128i v12; // xmm2
__m128i v13; // xmm0
... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
TEST RAX,RAX
JZ 0x00101470
MOV RDX,RAX
LEA RAX,[RAX + -0x1]
CMP RAX,0xe
JBE 0x00101474
MOV RCX,RDX
PXOR XMM1,XMM1
PXOR XMM3,XMM3
MOV RAX,RBX
AND RCX,-0x10
MOVDQA XMM6,xmmword ptr [0x00102080]
MOVDQA XMM5,xmmword ptr [0x00102090]
PXOR XMM4,XMM4
LEA RSI,[RCX + RBX*0x1]
... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(char *param_1)
{
bool bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
bool bVar11;
bool bVar12;
bool bVar13;
bool bVar14;
boo... |
7,168 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int* lists, int list_size, int** elements, int** frequencies, int* return_size) {
*elements = (int*)malloc(sizeof(int) * list_size);
*frequencies = (int*)malloc(sizeof(int) * list_size);
int element_count = 0;
if (list_size == 0) {
*return_size = 0;
return;
}
... | int main() {
int list1[] = {1,2,2,2,4,4,4,5,5,5,5};
int list2[] = {2,2,3,1,2,6,7,9};
int list3[] = {2,1,5,6,8,3,4,9,10,11,8,12};
int *elements, *frequencies, size;
func0(list1, sizeof(list1)/sizeof(list1[0]), &elements, &frequencies, &size);
assert(size == 4);
assert(elements[0] =... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
mov %r8,-0x38(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rdx
mov -0x28(%rbp),%rax
mov %rd... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_38], r8
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_28]
mo... | _DWORD * func0(long long a1, int a2, void **a3, void **a4, _DWORD *a5)
{
_DWORD *result; // rax
int v9; // [rsp+34h] [rbp-Ch]
int v10; // [rsp+38h] [rbp-8h]
int i; // [rsp+3Ch] [rbp-4h]
*a3 = malloc(4LL * a2);
*a4 = malloc(4LL * a2);
v9 = 0;
if ( a2 )
{
v10 = 1;
for ( i = 0; i < a2 - 1; ++i )... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x38],R8
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV RDX,RAX
MOV RAX,qword ptr [RBP ... | void func0(long param_1,int param_2,long *param_3,long *param_4,int *param_5)
{
void *pvVar1;
int4 local_14;
int4 local_10;
int4 local_c;
pvVar1 = malloc((long)param_2 << 2);
*param_3 = (long)pvVar1;
pvVar1 = malloc((long)param_2 << 2);
*param_4 = (long)pvVar1;
local_14 = 0;
if (param_2 == 0) {
... |
7,169 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int* lists, int list_size, int** elements, int** frequencies, int* return_size) {
*elements = (int*)malloc(sizeof(int) * list_size);
*frequencies = (int*)malloc(sizeof(int) * list_size);
int element_count = 0;
if (list_size == 0) {
*return_size = 0;
return;
}
... | int main() {
int list1[] = {1,2,2,2,4,4,4,5,5,5,5};
int list2[] = {2,2,3,1,2,6,7,9};
int list3[] = {2,1,5,6,8,3,4,9,10,11,8,12};
int *elements, *frequencies, size;
func0(list1, sizeof(list1)/sizeof(list1[0]), &elements, &frequencies, &size);
assert(size == 4);
assert(elements[0] =... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%ebx
mov %rdx,%rbp
mov %rcx,%r12
mov %r8,%r14
movslq %esi,%r15
shl $0x2,%r15
mov %r15,%rdi
callq 10b0 <malloc@plt>
mov %rax,0x0(%rbp)
mov %r15,%rdi
callq 10b0 <mall... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
mov r14d, esi
mov rbx, rdx
mov rbp, rcx
mov r13, r8
movsxd r15, esi
shl r15, 2
mov rdi, r15
call _malloc
mov [rbx], rax
mov rdi, r15
call _malloc
mov [rbp+0],... | long long func0(_DWORD *a1, int a2, long long *a3, long long *a4, int *a5)
{
int v5; // r14d
long long result; // rax
_DWORD *v10; // rax
int v11; // ecx
int v12; // edx
int v13; // eax
int v14; // ecx
v5 = a2;
*a3 = malloc(4LL * a2);
result = malloc(4LL * a2);
*a4 = result;
if ( a2 )
{
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
MOV R14D,ESI
MOV RBX,RDX
MOV RBP,RCX
MOV R13,R8
MOVSXD R15,ESI
SHL R15,0x2
MOV RDI,R15
CALL 0x001010b0
MOV qword ptr [RBX],RAX
MOV RDI,R15
CALL 0x001010b0
MOV qword ptr [RBP],RAX
TEST R14D,R14D
JZ 0x0010125b
CMP R14D,0x1
JLE 0x... | void func0(int *param_1,int param_2,long *param_3,long *param_4,int *param_5)
{
void *pvVar1;
int *piVar2;
int iVar3;
int iVar4;
pvVar1 = malloc((long)param_2 << 2);
*param_3 = (long)pvVar1;
pvVar1 = malloc((long)param_2 << 2);
*param_4 = (long)pvVar1;
if (param_2 != 0) {
if (param_2 < 2) {
... |
7,170 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int* lists, int list_size, int** elements, int** frequencies, int* return_size) {
*elements = (int*)malloc(sizeof(int) * list_size);
*frequencies = (int*)malloc(sizeof(int) * list_size);
int element_count = 0;
if (list_size == 0) {
*return_size = 0;
return;
}
... | int main() {
int list1[] = {1,2,2,2,4,4,4,5,5,5,5};
int list2[] = {2,2,3,1,2,6,7,9};
int list3[] = {2,1,5,6,8,3,4,9,10,11,8,12};
int *elements, *frequencies, size;
func0(list1, sizeof(list1)/sizeof(list1[0]), &elements, &frequencies, &size);
assert(size == 4);
assert(elements[0] =... | O2 | c | func0:
endbr64
push %r15
mov %rcx,%r15
push %r14
mov %rdx,%r14
push %r13
movslq %esi,%r13
push %r12
mov %r8,%r12
push %rbp
mov %r13,%rbp
shl $0x2,%r13
push %rbx
mov %rdi,%rbx
mov %r13,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %r13,%rdi
mov %rax,(%r14)
callq 10b0 <malloc@... | func0:
endbr64
push r15
mov r15, rcx
push r14
mov r14, r8
push r13
mov r13, rdx
push r12
movsxd r12, esi
push rbp
mov rbp, rdi
push rbx
mov rbx, r12
shl r12, 2
mov rdi, r12
sub rsp, 8
call _malloc
mov rdi, r12
mov [r13+0], rax
call _malloc
mov [r15], ... | long long func0(unsigned int *a1, int a2, _QWORD *a3, long long *a4, int *a5)
{
unsigned int *v8; // rbp
int v9; // ebx
long long result; // rax
int v11; // r8d
_DWORD *v12; // r10
_DWORD *v13; // r9
unsigned int *v14; // rax
int v15; // esi
int v16; // ecx
long long v17; // r11
long long v18; //... | func0:
ENDBR64
PUSH R15
MOV R15,RCX
PUSH R14
MOV R14,R8
PUSH R13
MOV R13,RDX
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,R12
SHL R12,0x2
MOV RDI,R12
SUB RSP,0x8
CALL 0x001010b0
MOV RDI,R12
MOV qword ptr [R13],RAX
CALL 0x001010b0
MOV qword ptr [R15],RAX
TEST EBX,EBX
JZ 0x00101630
LEA R8D,[RBX + -0x1]
M... | void func0(int *param_1,int param_2,int8 *param_3,int8 *param_4,int *param_5)
{
int iVar1;
void *pvVar2;
int *piVar3;
int *piVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int *piVar9;
pvVar2 = malloc((long)param_2 << 2);
*param_3 = pvVar2;
piVar3 = (int *)malloc((long)param_2 << 2);
*p... |
7,171 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int* lists, int list_size, int** elements, int** frequencies, int* return_size) {
*elements = (int*)malloc(sizeof(int) * list_size);
*frequencies = (int*)malloc(sizeof(int) * list_size);
int element_count = 0;
if (list_size == 0) {
*return_size = 0;
return;
}
... | int main() {
int list1[] = {1,2,2,2,4,4,4,5,5,5,5};
int list2[] = {2,2,3,1,2,6,7,9};
int list3[] = {2,1,5,6,8,3,4,9,10,11,8,12};
int *elements, *frequencies, size;
func0(list1, sizeof(list1)/sizeof(list1[0]), &elements, &frequencies, &size);
assert(size == 4);
assert(elements[0] =... | O3 | c | func0:
endbr64
push %r15
mov %rcx,%r15
push %r14
mov %rdx,%r14
push %r13
movslq %esi,%r13
push %r12
mov %r8,%r12
push %rbp
mov %r13,%rbp
shl $0x2,%r13
push %rbx
mov %rdi,%rbx
mov %r13,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %r13,%rdi
mov %rax,(%r14)
callq 10b0 <malloc@... | func0:
endbr64
push r15
mov r15, rcx
push r14
mov r14, r8
push r13
mov r13, rdx
push r12
movsxd r12, esi
push rbp
mov rbp, rdi
push rbx
mov rbx, r12
shl r12, 2
mov rdi, r12; size
sub rsp, 8
call _malloc
mov rdi, r12; size
mov [r13+0], rax
call _malloc
mov... | int * func0(unsigned int *a1, int a2, void **a3, int **a4, int *a5)
{
unsigned int *v8; // rbp
int v9; // ebx
int *result; // rax
_DWORD *v11; // r10
int *v12; // r9
unsigned int *v13; // rax
int v14; // esi
int v15; // ecx
long long v16; // r11
long long v17; // rdi
unsigned int v18; // edx
lon... | func0:
ENDBR64
PUSH R15
MOV R15,RCX
PUSH R14
MOV R14,R8
PUSH R13
MOV R13,RDX
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,R12
SHL R12,0x2
MOV RDI,R12
SUB RSP,0x8
CALL 0x001010b0
MOV RDI,R12
MOV qword ptr [R13],RAX
CALL 0x001010b0
MOV qword ptr [R15],RAX
TEST EBX,EBX
JZ 0x001015f0
MOV R10,qword ptr [R13... | void func0(int *param_1,int param_2,int8 *param_3,int8 *param_4,int *param_5)
{
int iVar1;
void *pvVar2;
int *piVar3;
int *piVar4;
int iVar5;
int iVar6;
uint uVar7;
int iVar8;
int *piVar9;
pvVar2 = malloc((long)param_2 << 2);
*param_3 = pvVar2;
piVar3 = (int *)malloc((long)param_2 << 2);
*... |
7,172 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int monthnum1) {
if (monthnum1 == 2) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(2) == true);
assert(func0(1) == false);
assert(func0(3) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
cmpl $0x2,-0x4(%rbp)
jne 1161 <func0+0x18>
mov $0x1,%eax
jmp 1166 <func0+0x1d>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
cmp [rbp+var_4], 2
jnz short loc_1161
mov eax, 1
jmp short loc_1166
loc_1161:
mov eax, 0
loc_1166:
pop rbp
retn | _BOOL8 func0(int a1)
{
return a1 == 2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x2
JNZ 0x00101161
MOV EAX,0x1
JMP 0x00101166
LAB_00101161:
MOV EAX,0x0
LAB_00101166:
POP RBP
RET | bool func0(int param_1)
{
return param_1 == 2;
} |
7,173 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int monthnum1) {
if (monthnum1 == 2) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(2) == true);
assert(func0(1) == false);
assert(func0(3) == false);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x2,%edi
sete %al
retq
| func0:
endbr64
cmp edi, 2
setz al
retn | bool func0(int a1)
{
return a1 == 2;
} | func0:
ENDBR64
CMP EDI,0x2
SETZ AL
RET | bool func0(int param_1)
{
return param_1 == 2;
} |
7,174 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int monthnum1) {
if (monthnum1 == 2) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(2) == true);
assert(func0(1) == false);
assert(func0(3) == false);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x2,%edi
sete %al
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, 2
setz al
retn | bool func0(int a1)
{
return a1 == 2;
} | func0:
ENDBR64
CMP EDI,0x2
SETZ AL
RET | bool func0(int param_1)
{
return param_1 == 2;
} |
7,175 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int monthnum1) {
if (monthnum1 == 2) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(2) == true);
assert(func0(1) == false);
assert(func0(3) == false);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x2,%edi
sete %al
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, 2
setz al
retn | bool func0(int a1)
{
return a1 == 2;
} | func0:
ENDBR64
CMP EDI,0x2
SETZ AL
RET | bool func0(int param_1)
{
return param_1 == 2;
} |
7,176 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char key;
char value[10];
} DictItem;
typedef struct {
DictItem *items;
int size;
} Dictionary;
| Dictionary func0(Dictionary dict1, Dictionary dict2) {
Dictionary merged_dict;
merged_dict.size = dict1.size + dict2.size;
merged_dict.items = malloc(merged_dict.size * sizeof(DictItem));
int k = 0;
for (int i = 0; i < dict1.size; i++) {
int found = 0;
for (int j =... | int main() {
DictItem items1[] = {{'R', "Red"}, {'B', "Black"}, {'P', "Pink"}};
Dictionary dict1 = { items1, 3 };
DictItem items2[] = {{'G', "Green"}, {'W', "White"}};
Dictionary dict2 = { items2, 2 };
Dictionary result1 = func0(dict1, dict2);
assert(result1.size == 5);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rsi,%rax
mov %rdi,%r8
mov %r8,%rsi
mov %r9,%rdi
mov %rax,%rdi
mov %rsi,-0x40(%rbp)
mov %rdi,-0x38(%rbp)
mov %rdx,-0x50(%rbp)
mov %rcx,-0x48(%rbp)
mov -0x38(%rbp),%edx
mov -0x48(%rbp),%eax
add %edx,%eax
mov %eax,-0x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, rdi
mov r8, rsi
mov rsi, rax
mov rdi, rdx
mov rdi, r8
mov [rbp+var_40], rsi
mov [rbp+var_38], rdi
mov [rbp+var_50], rdx
mov [rbp+var_48], rcx
mov edx, dword ptr [rbp+var_38]
mov eax, dword ptr [rbp+var_48]
... | char * func0(long long a1, int a2, long long a3, int a4)
{
long long v4; // rcx
int v5; // eax
char *v6; // rax
long long v7; // rcx
int v8; // eax
char *v9; // rax
int v13; // [rsp+2Ch] [rbp-24h]
int i; // [rsp+30h] [rbp-20h]
int v15; // [rsp+34h] [rbp-1Ch]
int j; // [rsp+38h] [rbp-18h]
int k; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,RDI
MOV R8,RSI
MOV RSI,RAX
MOV RDI,RDX
MOV RDI,R8
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x50],RDX
MOV qword ptr [RBP + -0x48],RCX
MOV EDX,dword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x48]
ADD EAX,EDX
MOV dword... | int [16] func0(long param_1,int param_2,long param_3,int param_4)
{
int auVar1 [16];
bool bVar2;
void *pvVar3;
int8 *puVar4;
int8 *puVar5;
int4 local_2c;
int4 local_28;
int4 local_20;
int4 local_1c;
int4 uStack_c;
pvVar3 = malloc((long)(param_4 + param_2) * 0xb);
local_2c = 0;
local_28 = ... |
7,177 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char key;
char value[10];
} DictItem;
typedef struct {
DictItem *items;
int size;
} Dictionary;
| Dictionary func0(Dictionary dict1, Dictionary dict2) {
Dictionary merged_dict;
merged_dict.size = dict1.size + dict2.size;
merged_dict.items = malloc(merged_dict.size * sizeof(DictItem));
int k = 0;
for (int i = 0; i < dict1.size; i++) {
int found = 0;
for (int j =... | int main() {
DictItem items1[] = {{'R', "Red"}, {'B', "Black"}, {'P', "Pink"}};
Dictionary dict1 = { items1, 3 };
DictItem items2[] = {{'G', "Green"}, {'W', "White"}};
Dictionary dict2 = { items2, 2 };
Dictionary result1 = func0(dict1, dict2);
assert(result1.size == 5);
... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r15
mov %rsi,%r13
mov %rdx,%r14
mov %rcx,%rbp
mov %rdx,%rbx
mov %ecx,%r12d
lea (%rcx,%rsi,1),%eax
cltq
lea (%rax,%rax,4),%rdx
lea (%rax,%rdx,2),%rdi
callq 10b0 <malloc@plt>
test ... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov r13, rsi
mov rbx, rdx
mov rbp, rcx
mov r12d, ecx
lea eax, [rcx+rsi]
cdqe
lea rdx, [rax+rax*4]
lea rdi, [rax+rdx*2]
call _malloc
mov rdi, rax
test r13d, r13d
jle short loc_120D
mov ... | long long func0(long long a1, int a2, _BYTE *a3, int a4)
{
long long v9; // rdi
long long v10; // rsi
int v11; // r8d
long long v12; // rdx
long long v13; // rax
long long v15; // rax
_BYTE *v16; // rax
v9 = malloc(11LL * (a4 + a2));
if ( a2 <= 0 )
{
v11 = 0;
}
else
{
v10 = a1;
v... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV R13,RSI
MOV RBX,RDX
MOV RBP,RCX
MOV R12D,ECX
LEA EAX,[RCX + RSI*0x1]
CDQE
LEA RDX,[RAX + RAX*0x4]
LEA RDI,[RAX + RDX*0x2]
CALL 0x001010b0
MOV RDI,RAX
TEST R13D,R13D
JLE 0x0010120d
MOV RSI,R14
LEA EAX,[R13 + -0x1]
LEA RDX,[RAX + RAX*0x4]
LEA RAX... | int1 [16] func0(char *param_1,int param_2,char *param_3,uint param_4)
{
char *pcVar1;
long lVar2;
int8 *puVar3;
char *pcVar4;
int iVar5;
int1 auVar6 [16];
auVar6._0_8_ = malloc((long)(int)(param_4 + param_2) * 0xb);
if (param_2 < 1) {
iVar5 = 0;
}
else {
pcVar1 = param_1 + (ulong)(param... |
7,178 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char key;
char value[10];
} DictItem;
typedef struct {
DictItem *items;
int size;
} Dictionary;
| Dictionary func0(Dictionary dict1, Dictionary dict2) {
Dictionary merged_dict;
merged_dict.size = dict1.size + dict2.size;
merged_dict.items = malloc(merged_dict.size * sizeof(DictItem));
int k = 0;
for (int i = 0; i < dict1.size; i++) {
int found = 0;
for (int j =... | int main() {
DictItem items1[] = {{'R', "Red"}, {'B', "Black"}, {'P', "Pink"}};
Dictionary dict1 = { items1, 3 };
DictItem items2[] = {{'G', "Green"}, {'W', "White"}};
Dictionary dict2 = { items2, 2 };
Dictionary result1 = func0(dict1, dict2);
assert(result1.size == 5);
... | O2 | c | func0:
endbr64
lea (%rcx,%rsi,1),%eax
push %r14
mov %rsi,%r14
push %r13
cltq
mov %rdi,%r13
push %r12
mov %ecx,%r12d
push %rbp
mov %rcx,%rbp
push %rbx
mov %rdx,%rbx
lea (%rax,%rax,4),%rdx
lea (%rax,%rdx,2),%rdi
callq 10b0 <malloc@plt>
test %r14d,%r14d
jle 14ed <func0+0x12d>
lea ... | func0:
endbr64
push r15
lea eax, [rcx+rsi]
mov r15, rsi
push r14
cdqe
mov r14d, ecx
push r13
mov r13, rcx
push r12
push rbp
mov rbp, rdx
lea rdx, [rax+rax*4]
push rbx
mov rbx, rdi
lea rdi, [rax+rdx*2]
sub rsp, 8
call _malloc
mov r12, rax
test r15d, r15d
jl... | long long func0(_BYTE *a1, int a2, _BYTE *a3, int a4)
{
long long v8; // rcx
long long v9; // r12
_BYTE *v10; // rsi
long long v11; // rdi
int v12; // ebx
_BYTE *v13; // rax
long long v15; // rax
long long v16; // rax
v9 = malloc(11LL * (a4 + a2));
if ( a2 <= 0 )
{
v12 = 0;
}
else
{
... | func0:
ENDBR64
PUSH R15
LEA EAX,[RCX + RSI*0x1]
MOV R15,RSI
PUSH R14
CDQE
MOV R14D,ECX
PUSH R13
MOV R13,RCX
PUSH R12
PUSH RBP
MOV RBP,RDX
LEA RDX,[RAX + RAX*0x4]
PUSH RBX
MOV RBX,RDI
LEA RDI,[RAX + RDX*0x2]
SUB RSP,0x8
CALL 0x001010d0
MOV R12,RAX
TEST R15D,R15D
JLE 0x0010148e
LEA EAX,[R15 + -0x1]
MOV RSI,RBX
LEA RDX,[R... | int1 [16] func0(char *param_1,int param_2,char *param_3,int param_4)
{
char *pcVar1;
char *pcVar2;
long lVar3;
int8 *puVar4;
int iVar5;
int1 auVar6 [16];
auVar6._0_8_ = malloc((long)(param_4 + param_2) * 0xb);
if (param_2 < 1) {
iVar5 = 0;
}
else {
pcVar1 = param_1 + (ulong)(param_2 - 1... |
7,179 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char key;
char value[10];
} DictItem;
typedef struct {
DictItem *items;
int size;
} Dictionary;
| Dictionary func0(Dictionary dict1, Dictionary dict2) {
Dictionary merged_dict;
merged_dict.size = dict1.size + dict2.size;
merged_dict.items = malloc(merged_dict.size * sizeof(DictItem));
int k = 0;
for (int i = 0; i < dict1.size; i++) {
int found = 0;
for (int j =... | int main() {
DictItem items1[] = {{'R', "Red"}, {'B', "Black"}, {'P', "Pink"}};
Dictionary dict1 = { items1, 3 };
DictItem items2[] = {{'G', "Green"}, {'W', "White"}};
Dictionary dict2 = { items2, 2 };
Dictionary result1 = func0(dict1, dict2);
assert(result1.size == 5);
... | O3 | c | func0:
endbr64
push %r15
lea (%rcx,%rsi,1),%eax
mov %rsi,%r15
push %r14
cltq
mov %ecx,%r14d
push %r13
mov %rcx,%r13
push %r12
push %rbp
mov %rdx,%rbp
lea (%rax,%rax,4),%rdx
push %rbx
mov %rdi,%rbx
lea (%rax,%rdx,2),%rdi
sub $0x8,%rsp
callq 10d0 <malloc@plt>
mov %rax,%r12
test ... | func0:
endbr64
push r15
lea eax, [rsi+rcx]
mov r15, rdi
push r14
cdqe
mov r14d, ecx
push r13
mov r13, rsi
push r12
mov r12, rcx
push rbp
push rbx
mov rbx, rdx
lea rdx, [rax+rax*4]
lea rdi, [rax+rdx*2]; size
sub rsp, 8
call _malloc
mov rbp, rax
test r13d, r... | char * func0(_BYTE *a1, int a2, _BYTE *a3, int a4)
{
char *v8; // rbp
_BYTE *v10; // rsi
int v11; // edi
_BYTE *v12; // r8
_BYTE *v13; // rax
int v14; // r13d
char *v16; // rax
v8 = (char *)malloc(11LL * (a2 + a4));
if ( a2 <= 0 )
{
v14 = 0;
}
else
{
v10 = a1;
v11 = 0;
v12 = &... | func0:
ENDBR64
PUSH R15
LEA EAX,[RSI + RCX*0x1]
MOV R15,RDI
PUSH R14
CDQE
MOV R14D,ECX
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RCX
PUSH RBP
PUSH RBX
MOV RBX,RDX
LEA RDX,[RAX + RAX*0x4]
LEA RDI,[RAX + RDX*0x2]
SUB RSP,0x8
CALL 0x001010d0
MOV RBP,RAX
TEST R13D,R13D
JLE 0x00101470
MOVSXD R13,R13D
MOV RSI,R15
XOR EDI,EDI
LEA... | int [16] func0(char *param_1,int param_2,char *param_3,uint param_4)
{
char *pcVar1;
long lVar2;
int8 *puVar3;
char *pcVar4;
int iVar5;
int auVar6 [16];
auVar6._0_8_ = malloc((long)(int)(param_2 + param_4) * 0xb);
if (param_2 < 1) {
iVar5 = 0;
}
else {
iVar5 = 0;
pcVar4 = param_1;
... |
7,180 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
| bool func0(const char *p) {
int len = strlen(p);
bool hasLower = false;
bool hasUpper = false;
bool hasDigit = false;
bool hasSpecial = false;
if (len < 6 || len > 12) {
return false;
}
for (int i = 0; i < len; i++) {
if (islower(p[i])) {
hasLow... | int main() {
assert(func0("password") == false);
assert(func0("Password@10") == true);
assert(func0("password@10") == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x4(%rbp)
movb $0x0,-0xc(%rbp)
movb $0x0,-0xb(%rbp)
movb $0x0,-0xa(%rbp)
movb $0x0,-0x9(%rbp)
cmpl $0x5,-0x4(%rbp)
jle 11c4 <func0+0x3b>
cmpl ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_C], 0
mov [rbp+var_B], 0
mov [rbp+var_A], 0
mov [rbp+var_9], 0
cmp [rbp+var_4], 5
jle short loc_11C4
cmp [rbp+var_4... | _BOOL8 func0(const char *a1)
{
char v3; // [rsp+14h] [rbp-Ch]
char v4; // [rsp+15h] [rbp-Bh]
char v5; // [rsp+16h] [rbp-Ah]
char v6; // [rsp+17h] [rbp-9h]
int i; // [rsp+18h] [rbp-8h]
int v8; // [rsp+1Ch] [rbp-4h]
v8 = strlen(a1);
v3 = 0;
v4 = 0;
v5 = 0;
v6 = 0;
if ( v8 <= 5 || v8 > 12 )
r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x4],EAX
MOV byte ptr [RBP + -0xc],0x0
MOV byte ptr [RBP + -0xb],0x0
MOV byte ptr [RBP + -0xa],0x0
MOV byte ptr [RBP + -0x9],0x0
CMP dword ptr [RBP + -0x4],0... | int4 func0(char *param_1)
{
bool bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
int iVar5;
int4 uVar6;
size_t sVar7;
ushort **ppuVar8;
int local_10;
sVar7 = strlen(param_1);
iVar5 = (int)sVar7;
bVar1 = false;
bVar2 = false;
bVar3 = false;
bVar4 = false;
if ((iVar5 < 6) || (0xc < iVar5)) ... |
7,181 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
| bool func0(const char *p) {
int len = strlen(p);
bool hasLower = false;
bool hasUpper = false;
bool hasDigit = false;
bool hasSpecial = false;
if (len < 6 || len > 12) {
return false;
}
for (int i = 0; i < len; i++) {
if (islower(p[i])) {
hasLow... | int main() {
assert(func0("password") == false);
assert(func0("Password@10") == true);
assert(func0("password@10") == false);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x7(%rcx),%edx
cmp $0x6,%edx
ja 1235 <func0+0xcc>
lea -0x1(%rcx),%rbp
test %ebp,%ebp
jle 123a <func0+0xd1>
callq 1070 <__ctype_b_loc@plt>
mov... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
call _strlen
mov rbx, rax
lea edx, [rax-6]
mov eax, 0
cmp edx, 6
ja loc_124A
test ebx, ebx
jle loc_1251
call ___ctype_b_loc
mov rdi, [rax]
mov rdx, rbp
lea eax, [rbx-1]
lea r8, [rbp+rax+1]
mov eb... | long long func0(unsigned __int8 *a1)
{
int v2; // ebx
long long result; // rax
long long v4; // rdi
unsigned __int8 *v5; // rdx
long long v6; // r8
bool v7; // bp
char v8; // bl
char v9; // r11
char v10; // r10
int v11; // esi
__int16 v12; // cx
char v13; // al
v2 = strlen();
result = 0LL;... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
CALL 0x00101070
MOV RBX,RAX
LEA EDX,[RAX + -0x6]
MOV EAX,0x0
CMP EDX,0x6
JA 0x0010124a
TEST EBX,EBX
JLE 0x00101251
CALL 0x00101090
MOV RDI,qword ptr [RAX]
MOV RDX,RBP
LEA EAX,[RBX + -0x1]
LEA R8,[RBP + RAX*0x1 + 0x1]
MOV EBP,0x0
MOV EBX,0x0
MOV R11D,0x0
MOV R10D,... | uint func0(byte *param_1)
{
byte *pbVar1;
byte bVar2;
ushort uVar3;
bool bVar4;
int iVar5;
uint uVar6;
bool bVar7;
bool bVar8;
size_t sVar9;
ushort **ppuVar10;
uint uVar11;
uint uVar12;
uint uVar13;
sVar9 = strlen((char *)param_1);
iVar5 = (int)sVar9;
uVar11 = 0;
if (iVar5 - 6U < 7... |
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.