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)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_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 [rbp+var_4], 1
loc_11A5:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | 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 dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a5:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | 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,%rax
jne 1170 <func0+0x30>
movdqa %xmm0,%xmm1
mov %esi,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
test $0x3,%sil
je 11e8 <func0+0xa8>
movslq %edx,%rcx
add (%rdi,%rcx,4),%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 11e2 <func0+0xa2>
movslq %ecx,%rcx
add (%rdi,%rcx,4),%eax
lea 0x2(%rdx),%ecx
cmp %ecx,%esi
jle 11e2 <func0+0xa2>
movslq %ecx,%rcx
add $0x3,%edx
add (%rdi,%rcx,4),%eax
cmp %edx,%esi
jle 11e2 <func0+0xa2>
movslq %edx,%rdx
add (%rdi,%rdx,4),%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %edx,%edx
xor %eax,%eax
jmp 11aa <func0+0x6a>
| 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 rax, rdx
jnz short loc_1170
movdqa xmm1, xmm0
mov edx, esi
psrldq xmm1, 8
and edx, 0FFFFFFFCh
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test sil, 3
jz short locret_11E0
loc_11AA:
movsxd rdi, edx
lea r8, ds:0[rdi*4]
add eax, [rcx+rdi*4]
lea edi, [rdx+1]
cmp esi, edi
jle short locret_11DA
add edx, 2
add eax, [rcx+r8+4]
cmp esi, edx
jle short locret_11DA
add eax, [rcx+r8+8]
retn
loc_11D8:
xor eax, eax
locret_11DA:
retn
locret_11E0:
retn
loc_11E1:
xor edx, edx
xor eax, eax
jmp short loc_11AA | 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;
}
else
{
v2 = a1;
v3 = 0LL;
do
{
v4 = _mm_loadu_si128(v2++);
v3 = _mm_add_epi32(v3, v4);
}
while ( v2 != &a1[(unsigned int)a2 >> 2] );
v5 = a2 & 0x7FFFFFFC;
v6 = _mm_add_epi32(v3, _mm_srli_si128(v3, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v6, _mm_srli_si128(v6, 4)));
if ( (a2 & 3) == 0 )
return result;
}
v8 = v5;
result = (unsigned int)(a1->m128i_i32[v8] + result);
if ( a2 > v5 + 1 )
{
result = (unsigned int)(a1->m128i_i32[v8 + 1] + result);
if ( a2 > v5 + 2 )
return (unsigned int)(a1->m128i_i32[v8 + 2] + result);
}
return result;
} | 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 XMM1,0x8
AND EDX,0xfffffffc
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST SIL,0x3
JZ 0x001011e0
LAB_001011aa:
MOVSXD RDI,EDX
LEA R8,[RDI*0x4]
ADD EAX,dword ptr [RCX + RDI*0x4]
LEA EDI,[RDX + 0x1]
CMP ESI,EDI
JLE 0x001011da
ADD EDX,0x2
ADD EAX,dword ptr [RCX + R8*0x1 + 0x4]
CMP ESI,EDX
JLE 0x001011da
ADD EAX,dword ptr [RCX + R8*0x1 + 0x8]
RET
LAB_001011d8:
XOR EAX,EAX
LAB_001011da:
RET
LAB_001011e0:
RET
LAB_001011e1:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011aa | 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 {
iVar7 = 0;
iVar8 = 0;
iVar9 = 0;
iVar10 = 0;
piVar5 = param_1;
do {
iVar1 = *piVar5;
piVar2 = piVar5 + 1;
piVar3 = piVar5 + 2;
piVar4 = piVar5 + 3;
piVar5 = piVar5 + 4;
iVar7 = iVar7 + iVar1;
iVar8 = iVar8 + *piVar2;
iVar9 = iVar9 + *piVar3;
iVar10 = iVar10 + *piVar4;
} while (piVar5 != param_1 + (ulong)(param_2 >> 2) * 4);
uVar6 = param_2 & 0xfffffffc;
iVar7 = iVar7 + iVar9 + iVar8 + iVar10;
if ((param_2 & 3) == 0) {
return iVar7;
}
}
iVar7 = iVar7 + param_1[(int)uVar6];
if ((int)(uVar6 + 1) < (int)param_2) {
iVar7 = iVar7 + param_1[(long)(int)uVar6 + 1];
if ((int)(uVar6 + 2) < (int)param_2) {
return iVar7 + param_1[(long)(int)uVar6 + 2];
}
}
}
return iVar7;
} |
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 %rbp
retq
| 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 eax, esi
pop rbp
retn | 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 RBP
RET | 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(strcmp(result, "pythonprogram") == 0);
return 0;
}
| 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 (%rdx),%edx
movzbl %dl,%edx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x2000,%eax
test %eax,%eax
jne 1223 <func0+0x7a>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x4(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x4(%rbp)
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
movzbl (%rcx),%eax
mov %al,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11cd <func0+0x24>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
leaveq
retq
| 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
movzx edx, byte ptr [rdx]
movzx edx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 2000h
test eax, eax
jnz short loc_1223
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_4]
lea edx, [rax+1]
mov [rbp+var_4], edx
movsxd rdx, eax
mov rax, [rbp+var_20]
add rdx, rax
movzx eax, byte ptr [rcx]
mov [rdx], al
loc_1223:
add [rbp+var_8], 1
loc_1227:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_11CD
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_20]
add rax, rdx
mov byte ptr [rax], 0
nop
leave
retn | _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 *)(a2 + v2) = *(_BYTE *)(v4 + a1);
}
++v4;
}
result = (_BYTE *)(v5 + a2);
*result = 0;
return result;
} | 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]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVZX EDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x2000
TEST EAX,EAX
JNZ 0x00101223
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x4]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x4],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOVZX EAX,byte ptr [RCX]
MOV byte ptr [RDX],AL
LAB_00101223:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101227:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011cd
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
NOP
LEAVE
RET | 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 + param_2) = *(int *)(local_10 + param_1);
local_c = local_c + 1;
}
}
*(int *)(param_2 + local_c) = 0;
return;
} |
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(strcmp(result, "pythonprogram") == 0);
return 0;
}
| 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>
movzbl %bl,%edx
mov (%rax),%rcx
testb $0x20,0x1(%rcx,%rdx,2)
jne 11ae <func0+0x25>
movslq %esi,%rdx
mov %bl,(%r12,%rdx,1)
lea 0x1(%rsi),%esi
jmp 11ae <func0+0x25>
mov $0x0,%esi
movslq %esi,%rsi
movb $0x0,(%r12,%rsi,1)
pop %rbx
pop %rbp
pop %r12
retq
| 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_11F8
loc_11DA:
movzx edx, bl
mov rcx, [rax]
test byte ptr [rcx+rdx*2+1], 20h
jnz short loc_11CE
movsxd rdx, esi
mov [r12+rdx], bl
lea esi, [rsi+1]
jmp short loc_11CE
loc_11F3:
mov esi, 0
loc_11F8:
movsxd rsi, esi
mov byte ptr [r12+rsi], 0
pop rbx
pop rbp
pop r12
retn | 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 )
*(_BYTE *)(a2 + v6++) = v3;
v3 = *v5++;
}
while ( v3 );
}
else
{
v6 = 0;
}
*(_BYTE *)(a2 + v6) = 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 byte ptr [RCX + RDX*0x2 + 0x1],0x20
JNZ 0x001011ce
MOVSXD RDX,ESI
MOV byte ptr [R12 + RDX*0x1],BL
LEA ESI,[RSI + 0x1]
JMP 0x001011ce
LAB_001011f3:
MOV ESI,0x0
LAB_001011f8:
MOVSXD RSI,ESI
MOV byte ptr [R12 + RSI*0x1],0x0
POP RBX
POP RBP
POP R12
RET | 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) & 0x20) == 0) {
*(byte *)(param_2 + iVar3) = bVar2;
iVar3 = iVar3 + 1;
}
bVar2 = *pbVar4;
pbVar4 = pbVar4 + 1;
} while (bVar2 != 0);
}
*(int1 *)(param_2 + iVar3) = 0;
return;
} |
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(strcmp(result, "pythonprogram") == 0);
return 0;
}
| 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 $0x20,0x1(%r9,%rdx,2)
jne 1316 <func0+0x46>
add $0x1,%esi
mov %bl,(%rcx)
movslq %esi,%r8
lea (%r12,%r8,1),%rcx
movzbl (%rdi),%ebx
add $0x1,%rdi
test %bl,%bl
jne 12f8 <func0+0x28>
movb $0x0,(%rcx)
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
mov %rsi,%rcx
movb $0x0,(%rcx)
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
| 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], 20h
jnz short loc_1310
movsxd rdx, r8d
add r8d, 1
mov [r12+rdx], bl
loc_1310:
movzx ebx, byte ptr [rdi]
add rdi, 1
test bl, bl
jnz short loc_12F8
movsxd r8, r8d
add r12, r8
loc_1321:
pop rbx
pop rbp
mov byte ptr [r12], 0
pop r12
retn | 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 ( (*(_BYTE *)(*v4 + 2LL * v3 + 1) & 0x20) == 0 )
{
v7 = v6++;
a2[v7] = v3;
}
v3 = *v5++;
}
while ( v3 );
v2 = &a2[v6];
}
*v2 = 0;
} | 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
MOV byte ptr [R12 + RDX*0x1],BL
LAB_00101310:
MOVZX EBX,byte ptr [RDI]
ADD RDI,0x1
TEST BL,BL
JNZ 0x001012f8
MOVSXD R8,R8D
ADD R12,R8
LAB_00101321:
POP RBX
POP RBP
MOV byte ptr [R12],0x0
POP R12
RET | 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 = (long)iVar4;
iVar4 = iVar4 + 1;
param_2[lVar2] = bVar3;
}
bVar3 = *param_1;
param_1 = param_1 + 1;
} while (bVar3 != 0);
param_2 = param_2 + iVar4;
}
*param_2 = 0;
return;
} |
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(strcmp(result, "pythonprogram") == 0);
return 0;
}
| 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,%esi
movzbl -0x1(%rdi),%ebx
movslq %esi,%rcx
lea (%r12,%rcx,1),%rdx
test %bl,%bl
je 132e <func0+0x5e>
mov (%rax),%r9
movzbl %bl,%r8d
lea (%r12,%rcx,1),%rdx
testb $0x20,0x1(%r9,%r8,2)
je 12f8 <func0+0x28>
movzbl (%rdi),%ebx
add $0x1,%rdi
test %bl,%bl
jne 1313 <func0+0x43>
movb $0x0,(%rdx)
pop %rbx
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
mov %rsi,%rdx
movb $0x0,(%rdx)
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
| 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 ptr [rdi-1]
movsxd rdx, ecx
test bl, bl
jz short loc_1327
loc_130E:
mov r8, [rax]
loc_1311:
movzx ecx, bl
test byte ptr [r8+rcx*2+1], 20h
jz short loc_12F8
movzx ebx, byte ptr [rdi]
add rdi, 1
test bl, bl
jnz short loc_1311
loc_1327:
add r12, rdx
loc_132A:
mov byte ptr [r12], 0
pop rbx
pop rbp
pop r12
retn | 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] & 0x2000) == 0 )
{
++v5;
a2[v6] = v3;
v3 = *(v5 - 1);
v6 = (int)v6 + 1;
if ( !v3 )
goto LABEL_6;
}
v3 = *v5++;
}
while ( v3 );
LABEL_6:
v2 = &a2[v6];
}
*v2 = 0;
} | 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 0x00101327
LAB_0010130e:
MOV R8,qword ptr [RAX]
LAB_00101311:
MOVZX ECX,BL
TEST byte ptr [R8 + RCX*0x2 + 0x1],0x20
JZ 0x001012f8
MOVZX EBX,byte ptr [RDI]
ADD RDI,0x1
TEST BL,BL
JNZ 0x00101311
LAB_00101327:
ADD R12,RDX
LAB_0010132a:
MOV byte ptr [R12],0x0
POP RBX
POP RBP
POP R12
RET | 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) {
bVar3 = *pbVar4;
pbVar4 = pbVar4 + 1;
if (bVar3 == 0) goto LAB_00101327;
}
param_2[lVar2] = bVar3;
bVar3 = *pbVar4;
lVar2 = (long)((int)lVar2 + 1);
pbVar4 = pbVar4 + 1;
} while (bVar3 != 0);
LAB_00101327:
param_2 = param_2 + lVar2;
}
*param_2 = 0;
return;
} |
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;
}
}
if (!found) {
unique_values++;
}
}
if (unique_values == 3) {
return 0;
} else {
return (4 - unique_values);
}
}
| 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 %eax,-0x18(%rbp)
movl $0x0,-0x30(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x2c(%rbp)
jmp 120d <func0+0xa4>
movl $0x0,-0x28(%rbp)
movl $0x0,-0x24(%rbp)
jmp 11f7 <func0+0x8e>
mov -0x24(%rbp),%eax
cltq
mov -0x20(%rbp,%rax,4),%edx
mov -0x2c(%rbp),%eax
cltq
mov -0x20(%rbp,%rax,4),%eax
cmp %eax,%edx
jne 11f3 <func0+0x8a>
movl $0x1,-0x28(%rbp)
jmp 11ff <func0+0x96>
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11d4 <func0+0x6b>
cmpl $0x0,-0x28(%rbp)
jne 1209 <func0+0xa0>
addl $0x1,-0x30(%rbp)
addl $0x1,-0x2c(%rbp)
cmpl $0x2,-0x2c(%rbp)
jle 11c4 <func0+0x5b>
cmpl $0x3,-0x30(%rbp)
jne 1220 <func0+0xb7>
mov $0x0,%eax
jmp 1228 <func0+0xbf>
mov $0x4,%eax
sub -0x30(%rbp),%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 123c <func0+0xd3>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
| 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, [rbp+var_3C]
mov [rbp+var_18], eax
mov [rbp+var_30], 0
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov [rbp+var_2C], 0
jmp short loc_120D
loc_11C4:
mov [rbp+var_28], 0
mov [rbp+var_24], 0
jmp short loc_11F7
loc_11D4:
mov eax, [rbp+var_24]
cdqe
mov edx, [rbp+rax*4+var_20]
mov eax, [rbp+var_2C]
cdqe
mov eax, [rbp+rax*4+var_20]
cmp edx, eax
jnz short loc_11F3
mov [rbp+var_28], 1
jmp short loc_11FF
loc_11F3:
add [rbp+var_24], 1
loc_11F7:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_2C]
jl short loc_11D4
loc_11FF:
cmp [rbp+var_28], 0
jnz short loc_1209
add [rbp+var_30], 1
loc_1209:
add [rbp+var_2C], 1
loc_120D:
cmp [rbp+var_2C], 2
jle short loc_11C4
cmp [rbp+var_30], 3
jnz short loc_1220
mov eax, 0
jmp short loc_1228
loc_1220:
mov eax, 4
sub eax, [rbp+var_30]
loc_1228:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_123C
call ___stack_chk_fail
locret_123C:
leave
retn | 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;
v8[2] = a3;
v4 = 0;
v8[3] = 0;
v8[4] = 0;
v8[5] = 0;
for ( i = 0; i <= 2; ++i )
{
v6 = 0;
for ( j = 0; j < i; ++j )
{
if ( v8[j] == v8[i] )
{
v6 = 1;
break;
}
}
if ( !v6 )
++v4;
}
if ( v4 == 3 )
return 0LL;
else
return (unsigned int)(4 - v4);
} | 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 dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x18],EAX
MOV dword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x0010120d
LAB_001011c4:
MOV dword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x24],0x0
JMP 0x001011f7
LAB_001011d4:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
MOV EDX,dword ptr [RBP + RAX*0x4 + -0x20]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x20]
CMP EDX,EAX
JNZ 0x001011f3
MOV dword ptr [RBP + -0x28],0x1
JMP 0x001011ff
LAB_001011f3:
ADD dword ptr [RBP + -0x24],0x1
LAB_001011f7:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011d4
LAB_001011ff:
CMP dword ptr [RBP + -0x28],0x0
JNZ 0x00101209
ADD dword ptr [RBP + -0x30],0x1
LAB_00101209:
ADD dword ptr [RBP + -0x2c],0x1
LAB_0010120d:
CMP dword ptr [RBP + -0x2c],0x2
JLE 0x001011c4
CMP dword ptr [RBP + -0x30],0x3
JNZ 0x00101220
MOV EAX,0x0
JMP 0x00101228
LAB_00101220:
MOV EAX,0x4
SUB EAX,dword ptr [RBP + -0x30]
LAB_00101228:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010123c
CALL 0x00101060
LAB_0010123c:
LEAVE
RET | 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_28[3] = 0;
local_28[4] = 0;
local_28[5] = 0;
local_34 = 0;
do {
if (2 < local_34) {
if (local_38 == 3) {
local_38 = 0;
}
else {
local_38 = 4 - local_38;
}
if (*(long *)(in_FS_OFFSET + 0x28) != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_38;
}
bVar1 = false;
for (local_2c = 0; local_2c < local_34; local_2c = local_2c + 1) {
if (local_28[local_2c] == local_28[local_34]) {
bVar1 = true;
break;
}
}
if (!bVar1) {
local_38 = local_38 + 1;
}
local_34 = local_34 + 1;
} while( true );
} |
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;
}
}
if (!found) {
unique_values++;
}
}
if (unique_values == 3) {
return 0;
} else {
return (4 - unique_values);
}
}
| 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(%rsp),%rdi
xor %fs:0x28,%rdi
jne 11f4 <func0+0x8b>
add $0x28,%rsp
retq
add $0x1,%r8d
add $0x1,%rdi
cmp $0x3,%rdi
je 119a <func0+0x31>
mov %edi,%esi
test %edi,%edi
jle 11c3 <func0+0x5a>
mov 0xc(%rsp,%rdi,4),%ecx
mov $0x0,%eax
lea 0xc(%rsp),%rdx
cmp %ecx,(%rdx,%rax,4)
je 11c7 <func0+0x5e>
add $0x1,%rax
cmp %eax,%esi
jg 11e5 <func0+0x7c>
jmp 11c3 <func0+0x5a>
callq 1060 <__stack_chk_fail@plt>
| 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 eax, edx
mov rdx, [rsp+28h+var_10]
sub rdx, fs:28h
jnz short loc_11F4
add rsp, 28h
retn
loc_11C3:
add r8d, 1
loc_11C7:
add rdi, 1
cmp rdi, 3
jz short loc_119A
loc_11D1:
mov esi, edi
test edi, edi
jle short loc_11C3
mov ecx, [rsp+rdi*4+28h+var_1C]
mov eax, 0
lea rdx, [rsp+28h+var_1C]
loc_11E5:
cmp [rdx+rax*4], ecx
jz short loc_11C7
add rax, 1
cmp esi, eax
jg short loc_11E5
jmp short loc_11C3
loc_11F4:
call ___stack_chk_fail | 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
{
if ( (int)v3 <= 0 )
{
LABEL_5:
++v4;
}
else
{
v6 = 0LL;
while ( v7[v6] != v7[v3] )
{
if ( (int)v3 <= (int)++v6 )
goto LABEL_5;
}
}
++v3;
}
while ( v3 != 3 );
result = (unsigned int)(4 - v4);
if ( v4 == 3 )
return 0LL;
return result;
} | 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 ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001011f4
ADD RSP,0x28
RET
LAB_001011c3:
ADD R8D,0x1
LAB_001011c7:
ADD RDI,0x1
CMP RDI,0x3
JZ 0x0010119a
LAB_001011d1:
MOV ESI,EDI
TEST EDI,EDI
JLE 0x001011c3
MOV ECX,dword ptr [RSP + RDI*0x4 + 0xc]
MOV EAX,0x0
LEA RDX,[RSP + 0xc]
LAB_001011e5:
CMP dword ptr [RDX + RAX*0x4],ECX
JZ 0x001011c7
ADD RAX,0x1
CMP ESI,EAX
JG 0x001011e5
JMP 0x001011c3
LAB_001011f4:
CALL 0x00101060 | 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 {
if (0 < (int)lVar3) {
lVar2 = 0;
do {
if (local_1c[lVar2] == local_1c[lVar3]) goto LAB_001011c7;
lVar2 = lVar2 + 1;
} while ((int)lVar2 < (int)lVar3);
}
iVar4 = iVar4 + 1;
LAB_001011c7:
lVar3 = lVar3 + 1;
if (lVar3 == 3) {
iVar1 = 4 - iVar4;
if (iVar4 == 3) {
iVar1 = 0;
}
if (*(long *)(in_FS_OFFSET + 0x28) != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar1;
}
} while( true );
} |
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;
}
}
if (!found) {
unique_values++;
}
}
if (unique_values == 3) {
return 0;
} else {
return (4 - unique_values);
}
}
| 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
lea (%r9,%rdx,4),%rsi
mov %edi,%edx
jmp 141c <func0+0x5c>
nopw 0x0(%rax,%rax,1)
cmp %rsi,%rax
je 1458 <func0+0x98>
mov 0x4(%rax),%edx
add $0x4,%rax
cmp %edx,%ecx
jne 1410 <func0+0x50>
add $0x1,%r8
cmp $0x3,%r8
jne 13ef <func0+0x2f>
mov $0x4,%eax
mov $0x0,%edx
sub %r10d,%eax
cmp $0x3,%r10d
cmove %edx,%eax
mov 0x18(%rsp),%rdi
xor %fs:0x28,%rdi
jne 1468 <func0+0xa8>
add $0x28,%rsp
retq
nopl 0x0(%rax,%rax,1)
add $0x1,%r8
add $0x1,%r10d
cmp $0x3,%r8
jne 13ef <func0+0x2f>
jmp 142a <func0+0x6a>
callq 1060 <__stack_chk_fail@plt>
nopl (%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]
mov ecx, [r9+r8*4]
mov rax, r9
lea rsi, [r9+rdx*4]
mov edx, edi
jmp short loc_128C
loc_1280:
cmp rax, rsi
jz short loc_12C0
mov edx, [rax+4]
add rax, 4
loc_128C:
cmp ecx, edx
jnz short loc_1280
add r8, 1
cmp r8, 3
jnz short loc_125F
loc_129A:
mov eax, 4
xor edx, edx
sub eax, r10d
cmp r10d, 3
cmovz eax, edx
mov rdx, [rsp+28h+var_10]
sub rdx, fs:28h
jnz short loc_12D0
add rsp, 28h
retn
loc_12C0:
add r8, 1
add r10d, 1
cmp r8, 3
jnz short loc_125F
jmp short loc_129A
loc_12D0:
call ___stack_chk_fail | 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;
v8[2] = a3;
do
{
while ( !v3 )
{
LABEL_11:
++v3;
++v4;
if ( v3 == 3 )
goto LABEL_8;
}
v5 = v8;
v6 = a1;
while ( v8[v3] != v6 )
{
if ( v5 == &v8[(unsigned int)(v3 - 1)] )
goto LABEL_11;
v6 = v5[1];
++v5;
}
++v3;
}
while ( v3 != 3 );
LABEL_8:
result = (unsigned int)(4 - v4);
if ( v4 == 3 )
return 0LL;
return result;
} | 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 + R8*0x4]
MOV RAX,R9
LEA RSI,[R9 + RDX*0x4]
MOV EDX,EDI
JMP 0x0010128c
LAB_00101280:
CMP RAX,RSI
JZ 0x001012c0
MOV EDX,dword ptr [RAX + 0x4]
ADD RAX,0x4
LAB_0010128c:
CMP ECX,EDX
JNZ 0x00101280
ADD R8,0x1
CMP R8,0x3
JNZ 0x0010125f
LAB_0010129a:
MOV EAX,0x4
XOR EDX,EDX
SUB EAX,R10D
CMP R10D,0x3
CMOVZ EAX,EDX
MOV RDX,qword ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012d0
ADD RSP,0x28
RET
LAB_001012c0:
ADD R8,0x1
ADD R10D,0x1
CMP R8,0x3
JNZ 0x0010125f
JMP 0x0010129a
LAB_001012d0:
CALL 0x00101060 | 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 (lVar4 == 0) {
LAB_001012c0:
lVar4 = lVar4 + 1;
iVar5 = iVar5 + 1;
if (lVar4 == 3) goto LAB_0010129a;
}
piVar2 = local_1c;
iVar3 = param_1;
while (local_1c[lVar4] != iVar3) {
if (piVar2 == local_1c + ((int)lVar4 - 1)) goto LAB_001012c0;
piVar1 = piVar2 + 1;
piVar2 = piVar2 + 1;
iVar3 = *piVar1;
}
lVar4 = lVar4 + 1;
} while (lVar4 != 3);
LAB_0010129a:
iVar3 = 4 - iVar5;
if (iVar5 == 3) {
iVar3 = 0;
}
if (*(long *)(in_FS_OFFSET + 0x28) != *(long *)(in_FS_OFFSET + 0x28)) {
local_1c[0] = param_1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar3;
} |
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;
}
}
if (!found) {
unique_values++;
}
}
if (unique_values == 3) {
return 0;
} else {
return (4 - unique_values);
}
}
| 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(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| 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
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 11b6 <func0+0x4d>
mov -0x4(%rbp),%eax
jmp 11c7 <func0+0x5e>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 1
jmp short loc_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 rcx, [rax-4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_11B6
mov eax, [rbp+var_4]
jmp short loc_11C7
loc_11B6:
add [rbp+var_4], 1
loc_11BA:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1181
mov eax, 0
loc_11C7:
pop rbp
retn | 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
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x001011b6
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x001011c7
LAB_001011b6:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ba:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
MOV EAX,0x0
LAB_001011c7:
POP RBP
RET | 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 $0x0,%ecx
jmp 1197 <func0+0x2e>
| 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 short loc_1192 | 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;
}
}
return v3;
} | 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>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| 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, r8d
mov eax, r8d
retn | 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 <func0+0x20>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| 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 != param_2);
}
return 0;
} |
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 $0x1,%eax
jmp 1191 <func0+0x48>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jge 115d <func0+0x14>
mov $0x0,%eax
pop %rbp
retq
| 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 short loc_117D
mov eax, 1
jmp short loc_1191
loc_117D:
add [rbp+var_4], 1
loc_1181:
mov eax, [rbp+var_4]
imul eax, eax
cmp [rbp+var_14], eax
jge short loc_115D
mov eax, 0
loc_1191:
pop rbp
retn | 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 + -0x4],EAX
JNZ 0x0010117d
MOV EAX,0x1
JMP 0x00101191
LAB_0010117d:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JGE 0x0010115d
MOV EAX,0x0
LAB_00101191:
POP RBP
RET | 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 % (long)local_c & 0xffffffff;
if (((int)((long)param_1 % (long)local_c) == 0) &&
(param_3 = (long)param_1 % (long)local_c & 0xffffffff, local_c == param_1 / local_c)) {
uVar1 = 1;
goto LAB_00101191;
}
local_c = local_c + 1;
} while( true );
} |
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
jne 1158 <func0+0xf>
mov $0x1,%eax
retq
mov $0x0,%eax
retq
mov $0x0,%eax
retq
| 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, ecx
jnz short loc_1158
mov eax, 1
retn
loc_117C:
mov eax, 0
retn
loc_1182:
mov eax, 0
retn | 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_00101182:
MOV EAX,0x0
RET | 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,
(int)((long)param_1 % (long)iVar3) != 0 ||
(auVar4._8_8_ = (long)param_1 % (long)iVar3 & 0xffffffff, param_1 / iVar3 != iVar3))) {
iVar3 = iVar3 + 1;
if (param_1 < iVar3 * iVar3) {
auVar1._8_8_ = 0;
auVar1._0_8_ = auVar4._8_8_;
return auVar1 << 0x40;
}
}
auVar4._0_8_ = 1;
return auVar4;
} |
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
nopl 0x0(%rax)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| 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_1219:
xor eax, eax
retn
loc_1220:
mov eax, 1
retn | 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
nopl 0x0(%rax)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| 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_1269:
xor eax, eax
retn
loc_1270:
mov eax, 1
retn | 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 $0x1,%eax
jmp 11b6 <func0+0x4d>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_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_11A5
mov eax, 1
jmp short loc_11B6
loc_11A5:
add [rbp+var_4], 1
loc_11A9:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1181
mov eax, 0
loc_11B6:
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 )
return 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 0x001011a5
MOV EAX,0x1
JMP 0x001011b6
LAB_001011a5:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a9:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
MOV EAX,0x0
LAB_001011b6:
POP RBP
RET | 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
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| 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
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| 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) {
max_sum = current_sum;
max_list = lists[i];
*length = 3;
}
}
return max_list;
}
| 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}};
int* max_list2 = func0(list2, 3, &length);
int expected2[3] = {12, 11, 10};
assert(memcmp(max_list2, expected2, sizeof(expected2)) == 0);
int list3[1][3] = {{2,3,1}};
int* max_list3 = func0(list3, 1, &length);
int expected3[3] = {2, 3, 1};
assert(memcmp(max_list3, expected3, sizeof(expected3)) == 0);
printf("All test cases passed.\n");
return 0;
}
| 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
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
add %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
cmpl $0x2,-0xc(%rbp)
jle 11e4 <func0+0x3b>
mov -0x10(%rbp),%eax
cmp -0x18(%rbp),%eax
jle 124f <func0+0xa6>
mov -0x10(%rbp),%eax
mov %eax,-0x18(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov %rax,-0x8(%rbp)
mov -0x38(%rbp),%rax
movl $0x3,(%rax)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11d4 <func0+0x2b>
mov -0x8(%rbp),%rax
pop %rbp
retq
| 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 eax, [rbp+var_14]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_C]
cdqe
mov eax, [rdx+rax*4]
add [rbp+var_10], eax
add [rbp+var_C], 1
loc_1210:
cmp [rbp+var_C], 2
jle short loc_11E4
mov eax, [rbp+var_10]
cmp eax, [rbp+var_18]
jle short loc_124F
mov eax, [rbp+var_10]
mov [rbp+var_18], eax
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdx, rax
mov rax, [rbp+var_28]
add rax, rdx
mov [rbp+var_8], rax
mov rax, [rbp+var_38]
mov dword ptr [rax], 3
loc_124F:
add [rbp+var_14], 1
loc_1253:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl loc_11D4
mov rax, [rbp+var_8]
pop rbp
retn | 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 )
v6 += *(_DWORD *)(a1 + 12LL * i + 4LL * j);
if ( v6 > v4 )
{
v4 = v6;
v8 = 12LL * i + a1;
*a3 = 3;
}
}
return v8;
} | 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],0x0
JMP 0x00101210
LAB_001011e4:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
ADD dword ptr [RBP + -0x10],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_00101210:
CMP dword ptr [RBP + -0xc],0x2
JLE 0x001011e4
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x18]
JLE 0x0010124f
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x3
LAB_0010124f:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101253:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011d4
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET | 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 + 1) {
local_18 = local_18 + *(int *)((long)local_1c * 0xc + param_1 + (long)local_14 * 4);
}
if (local_20 < local_18) {
local_20 = local_18;
local_10 = param_1 + (long)local_1c * 0xc;
*param_3 = 3;
}
}
return local_10;
} |
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) {
max_sum = current_sum;
max_list = lists[i];
*length = 3;
}
}
return max_list;
}
| 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}};
int* max_list2 = func0(list2, 3, &length);
int expected2[3] = {12, 11, 10};
assert(memcmp(max_list2, expected2, sizeof(expected2)) == 0);
int list3[1][3] = {{2,3,1}};
int* max_list3 = func0(list3, 1, &length);
int expected3[3] = {2, 3, 1};
assert(memcmp(max_list3, expected3, sizeof(expected3)) == 0);
printf("All test cases passed.\n");
return 0;
}
| 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
add 0x8(%rax),%ecx
cmp %esi,%ecx
jle 11cd <func0+0x24>
movl $0x3,(%rdx)
mov %rax,%r8
mov %ecx,%esi
jmp 11cd <func0+0x24>
mov $0x0,%r8d
mov %r8,%rax
retq
| 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, [rax]
add ecx, [rax+8]
cmp ecx, esi
jle short loc_11CD
mov dword ptr [rdx], 3
mov r8, rax
mov esi, ecx
jmp short loc_11CD
loc_11EF:
mov r8d, 0
loc_11F5:
mov rax, r8
retn | _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 )
{
*a3 = 3;
v5 = v3;
v6 = v7;
}
v3 += 3;
}
while ( v3 != (_DWORD *)v4 );
return v5;
} | 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 + 0x8]
CMP ECX,ESI
JLE 0x001011cd
MOV dword ptr [RDX],0x3
MOV R8,RAX
MOV ESI,ECX
JMP 0x001011cd
LAB_001011ef:
MOV R8D,0x0
LAB_001011f5:
MOV RAX,R8
RET | 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_1[2];
if (iVar3 < iVar2) {
*param_3 = 3;
piVar4 = param_1;
iVar3 = iVar2;
}
param_1 = param_1 + 3;
} while (param_1 != piVar1);
}
return piVar4;
} |
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) {
max_sum = current_sum;
max_list = lists[i];
*length = 3;
}
}
return max_list;
}
| 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}};
int* max_list2 = func0(list2, 3, &length);
int expected2[3] = {12, 11, 10};
assert(memcmp(max_list2, expected2, sizeof(expected2)) == 0);
int list3[1][3] = {{2,3,1}};
int* max_list3 = func0(list3, 1, &length);
int expected3[3] = {2, 3, 1};
assert(memcmp(max_list3, expected3, sizeof(expected3)) == 0);
printf("All test cases passed.\n");
return 0;
}
| 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 %rdi,%r8
mov %eax,%ecx
add $0xc,%rdi
cmp %rsi,%rdi
jne 1350 <func0+0x20>
mov %r8,%rax
retq
xor %r8d,%r8d
mov %r8,%rax
retq
nopl 0x0(%rax,%rax,1)
| 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 dword ptr [rdx], 3
mov r8, rdi
mov ecx, eax
loc_13A7:
add rdi, 0Ch
cmp rdi, rsi
jnz short loc_1390
mov rax, r8
retn
loc_13B4:
xor r8d, r8d
mov rax, r8
retn | _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;
v4 = v6;
}
a1 += 3;
}
while ( a1 != (_DWORD *)v5 );
return v3;
} | 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
MOV R8,RDI
MOV ECX,EAX
LAB_001013a7:
ADD RDI,0xc
CMP RDI,RSI
JNZ 0x00101390
MOV RAX,R8
RET
LAB_001013b4:
XOR R8D,R8D
MOV RAX,R8
RET | 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) {
*param_3 = 3;
piVar4 = param_1;
iVar3 = iVar2;
}
param_1 = param_1 + 3;
} while (param_1 != piVar1);
return piVar4;
}
return (int *)0x0;
} |
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) {
max_sum = current_sum;
max_list = lists[i];
*length = 3;
}
}
return max_list;
}
| 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}};
int* max_list2 = func0(list2, 3, &length);
int expected2[3] = {12, 11, 10};
assert(memcmp(max_list2, expected2, sizeof(expected2)) == 0);
int list3[1][3] = {{2,3,1}};
int* max_list3 = func0(list3, 1, &length);
int expected3[3] = {2, 3, 1};
assert(memcmp(max_list3, expected3, sizeof(expected3)) == 0);
printf("All test cases passed.\n");
return 0;
}
| 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 %rdi,%r8
mov %eax,%ecx
add $0xc,%rdi
cmp %rdi,%rsi
jne 1380 <func0+0x20>
mov %r8,%rax
retq
xor %r8d,%r8d
mov %r8,%rax
retq
nopl 0x0(%rax,%rax,1)
| 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 ptr [rdx], 3
mov r8, rdi
mov ecx, eax
loc_1267:
add rdi, 0Ch
cmp rsi, rdi
jnz short loc_1250
mov rax, r8
retn
loc_1274:
xor r8d, r8d
mov rax, r8
retn | _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;
}
a1 += 3;
}
while ( v5 != a1 );
return v3;
} | 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 R8,RDI
MOV ECX,EAX
LAB_00101267:
ADD RDI,0xc
CMP RSI,RDI
JNZ 0x00101250
MOV RAX,R8
RET
LAB_00101274:
XOR R8D,R8D
MOV RAX,R8
RET | 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 = 3;
piVar4 = param_1;
iVar3 = iVar2;
}
param_1 = param_1 + 3;
} while (piVar1 != param_1);
return piVar4;
}
return (int *)0x0;
} |
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 = 0;
}
}
if (isupper(test_str[length - 1])) {
if (cnt > res) {
res = cnt;
}
}
return res;
}
| 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
mov -0x8(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 11f6 <func0+0x6d>
addl $0x1,-0x10(%rbp)
jmp 120b <func0+0x82>
mov -0x10(%rbp),%eax
cmp -0xc(%rbp),%eax
jle 1204 <func0+0x7b>
mov -0x10(%rbp),%eax
mov %eax,-0xc(%rbp)
movl $0x0,-0x10(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 11bf <func0+0x36>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea -0x1(%rdx),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 125a <func0+0xd1>
mov -0x10(%rbp),%eax
cmp -0xc(%rbp),%eax
jle 125a <func0+0xd1>
mov -0x10(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
leaveq
retq
| 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, [rbp+var_8]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz short loc_11F6
add [rbp+var_10], 1
jmp short loc_120B
loc_11F6:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_C]
jle short loc_1204
mov eax, [rbp+var_10]
mov [rbp+var_C], eax
loc_1204:
mov [rbp+var_10], 0
loc_120B:
add [rbp+var_8], 1
loc_120F:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jl short loc_11BF
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_4]
movsxd rdx, edx
lea rcx, [rdx-1]
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz short loc_125A
mov eax, [rbp+var_10]
cmp eax, [rbp+var_C]
jle short loc_125A
mov eax, [rbp+var_10]
mov [rbp+var_C], eax
loc_125A:
mov eax, [rbp+var_C]
leave
retn | 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;
}
else
{
if ( v2 > v3 )
v3 = v2;
v2 = 0;
}
}
if ( ((*__ctype_b_loc())[a1[v5 - 1]] & 0x100) != 0 && v2 > v3 )
return (unsigned int)v2;
return (unsigned int)v3;
} | 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,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x001011f6
ADD dword ptr [RBP + -0x10],0x1
JMP 0x0010120b
LAB_001011f6:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0xc]
JLE 0x00101204
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0xc],EAX
LAB_00101204:
MOV dword ptr [RBP + -0x10],0x0
LAB_0010120b:
ADD dword ptr [RBP + -0x8],0x1
LAB_0010120f:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x001011bf
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
LEA RCX,[RDX + -0x1]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x0010125a
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0xc]
JLE 0x0010125a
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0xc],EAX
LAB_0010125a:
MOV EAX,dword ptr [RBP + -0xc]
LEAVE
RET | 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]] & 0x100) == 0) {
if (local_14 < local_18) {
local_14 = local_18;
}
local_18 = 0;
}
else {
local_18 = local_18 + 1;
}
}
ppuVar2 = __ctype_b_loc();
if ((((*ppuVar2)[param_1[(long)(int)sVar1 + -1]] & 0x100) != 0) && (local_14 < local_18)) {
local_14 = local_18;
}
return local_14;
} |
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 = 0;
}
}
if (isupper(test_str[length - 1])) {
if (cnt > res) {
res = cnt;
}
}
return res;
}
| 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
lea -0x1(%r12),%edx
lea 0x1(%r13,%rdx,1),%rcx
mov $0x0,%ebp
mov $0x0,%ebx
jmp 11c8 <func0+0x5f>
cmp %ebx,%ebp
cmovl %ebx,%ebp
mov $0x0,%ebx
add $0x1,%rax
cmp %rcx,%rax
je 11e2 <func0+0x79>
movsbq (%rax),%rdx
testb $0x1,0x1(%rsi,%rdx,2)
je 11b5 <func0+0x4c>
add $0x1,%ebx
jmp 11bf <func0+0x56>
mov $0x0,%ebp
mov $0x0,%ebx
callq 1070 <__ctype_b_loc@plt>
movslq %r12d,%r12
movsbq -0x1(%r13,%r12,1),%rdx
mov (%rax),%rax
testb $0x1,0x1(%rax,%rdx,2)
je 11ff <func0+0x96>
cmp %ebx,%ebp
cmovl %ebx,%ebp
mov %ebp,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
| 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_11DA
loc_11C7:
cmp ebp, ebx
cmovl ebp, ebx
mov ebx, 0
loc_11D1:
add rax, 1
cmp rax, rcx
jz short loc_11F4
loc_11DA:
movsx rdx, byte ptr [rax]
test byte ptr [rsi+rdx*2+1], 1
jz short loc_11C7
add ebx, 1
jmp short loc_11D1
loc_11EA:
mov ebp, 0
mov ebx, 0
loc_11F4:
call ___ctype_b_loc
movsxd r12, r12d
movsx rdx, byte ptr [r13+r12-1]
mov rax, [rax]
cmp ebp, ebx
cmovge ebx, ebp
test byte ptr [rax+rdx*2+1], 1
cmovnz ebp, ebx
mov eax, ebp
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | 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
{
if ( (*(_BYTE *)(v2 + 2LL * *v3 + 1) & 1) != 0 )
{
++v5;
}
else
{
if ( v4 < v5 )
v4 = v5;
v5 = 0;
}
++v3;
}
while ( v3 != &a1[v1 - 1 + 1] );
}
v6 = *(_QWORD *)__ctype_b_loc();
if ( v4 >= v5 )
v5 = v4;
if ( (*(_BYTE *)(v6 + 2LL * a1[v1 - 1] + 1) & 1) != 0 )
return (unsigned int)v5;
return (unsigned int)v4;
} | 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,0x0
LAB_001011d1:
ADD RAX,0x1
CMP RAX,RCX
JZ 0x001011f4
LAB_001011da:
MOVSX RDX,byte ptr [RAX]
TEST byte ptr [RSI + RDX*0x2 + 0x1],0x1
JZ 0x001011c7
ADD EBX,0x1
JMP 0x001011d1
LAB_001011ea:
MOV EBP,0x0
MOV EBX,0x0
LAB_001011f4:
CALL 0x00101090
MOVSXD R12,R12D
MOVSX RDX,byte ptr [R13 + R12*0x1 + -0x1]
MOV RAX,qword ptr [RAX]
CMP EBP,EBX
CMOVGE EBX,EBP
TEST byte ptr [RAX + RDX*0x2 + 0x1],0x1
CMOVNZ EBP,EBX
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | 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;
do {
if ((*(byte *)((long)*ppuVar3 + (long)*pcVar4 * 2 + 1) & 1) == 0) {
if (iVar6 < iVar5) {
iVar6 = iVar5;
}
iVar5 = 0;
}
else {
iVar5 = iVar5 + 1;
}
pcVar4 = pcVar4 + 1;
} while (pcVar4 != param_1 + (ulong)(iVar1 - 1) + 1);
}
ppuVar3 = __ctype_b_loc();
if (iVar5 <= iVar6) {
iVar5 = iVar6;
}
if ((*(byte *)((long)*ppuVar3 + (long)param_1[(long)iVar1 + -1] * 2 + 1) & 1) != 0) {
iVar6 = iVar5;
}
return iVar6;
} |
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 = 0;
}
}
if (isupper(test_str[length - 1])) {
if (cnt > res) {
res = cnt;
}
}
return res;
}
| 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 1274 <func0+0x44>
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
add $0x1,%edx
cmp %rax,%r9
je 1291 <func0+0x61>
movsbq (%rax),%rcx
testb $0x1,0x1(%rsi,%rcx,2)
jne 1268 <func0+0x38>
cmp %edx,%r8d
cmovl %edx,%r8d
add $0x1,%rax
xor %edx,%edx
cmp %rax,%r9
jne 1274 <func0+0x44>
movslq %ebx,%rbx
movsbq -0x1(%rbp,%rbx,1),%rax
testb $0x1,0x1(%rsi,%rax,2)
je 12a8 <func0+0x78>
cmp %edx,%r8d
cmovl %edx,%r8d
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
xor %edx,%edx
jmp 1291 <func0+0x61>
| 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 rax, 1
add edx, 1
cmp r9, rax
jz short loc_1291
loc_1274:
movsx rcx, byte ptr [rax]
test byte ptr [rsi+rcx*2+1], 1
jnz short loc_1268
cmp r8d, edx
cmovl r8d, edx
add rax, 1
xor edx, edx
cmp r9, rax
jnz short loc_1274
loc_1291:
movsxd rbx, ebx
cmp r8d, edx
movsx rax, byte ptr [rbp+rbx-1]
cmovge edx, r8d
test byte ptr [rsi+rax*2+1], 1
cmovnz r8d, edx
add rsp, 8
pop rbx
pop rbp
mov eax, r8d
retn
loc_12B8:
xor r8d, r8d
xor edx, edx
jmp short loc_1291 | 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[v1 - 1 + 1];
v6 = 0;
do
{
while ( (*(_BYTE *)(v2 + 2LL * *v3 + 1) & 1) != 0 )
{
++v3;
++v6;
if ( (char *)v5 == v3 )
goto LABEL_8;
}
if ( v4 < v6 )
v4 = v6;
++v3;
v6 = 0;
}
while ( (char *)v5 != v3 );
}
LABEL_8:
if ( v4 >= v6 )
v6 = v4;
if ( (*(_BYTE *)(v2 + 2LL * a1[v1 - 1] + 1) & 1) != 0 )
return (unsigned int)v6;
return (unsigned int)v4;
} | 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_00101274:
MOVSX RCX,byte ptr [RAX]
TEST byte ptr [RSI + RCX*0x2 + 0x1],0x1
JNZ 0x00101268
CMP R8D,EDX
CMOVL R8D,EDX
ADD RAX,0x1
XOR EDX,EDX
CMP R9,RAX
JNZ 0x00101274
LAB_00101291:
MOVSXD RBX,EBX
CMP R8D,EDX
MOVSX RAX,byte ptr [RBP + RBX*0x1 + -0x1]
CMOVGE EDX,R8D
TEST byte ptr [RSI + RAX*0x2 + 0x1],0x1
CMOVNZ R8D,EDX
ADD RSP,0x8
POP RBX
POP RBP
MOV EAX,R8D
RET
LAB_001012b8:
XOR R8D,R8D
XOR EDX,EDX
JMP 0x00101291 | 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 {
while ((*(byte *)((long)*ppuVar2 + (long)*pcVar3 * 2 + 1) & 1) == 0) {
if (iVar6 < iVar4) {
iVar6 = iVar4;
}
pcVar3 = pcVar3 + 1;
iVar4 = 0;
if (param_1 + (ulong)(iVar5 - 1) + 1 == pcVar3) goto LAB_00101291;
}
pcVar3 = pcVar3 + 1;
iVar4 = iVar4 + 1;
} while (param_1 + (ulong)(iVar5 - 1) + 1 != pcVar3);
}
LAB_00101291:
if (iVar4 <= iVar6) {
iVar4 = iVar6;
}
if ((*(byte *)((long)*ppuVar2 + (long)param_1[(long)iVar5 + -1] * 2 + 1) & 1) != 0) {
iVar6 = iVar4;
}
return iVar6;
} |
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 = 0;
}
}
if (isupper(test_str[length - 1])) {
if (cnt > res) {
res = cnt;
}
}
return res;
}
| 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 1274 <func0+0x44>
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
add $0x1,%edx
cmp %rax,%r9
je 1291 <func0+0x61>
movsbq (%rax),%rcx
testb $0x1,0x1(%rsi,%rcx,2)
jne 1268 <func0+0x38>
cmp %edx,%r8d
cmovl %edx,%r8d
add $0x1,%rax
xor %edx,%edx
cmp %rax,%r9
jne 1274 <func0+0x44>
movslq %ebx,%rbx
movsbq -0x1(%rbp,%rbx,1),%rax
testb $0x1,0x1(%rsi,%rax,2)
je 12a8 <func0+0x78>
cmp %edx,%r8d
cmovl %edx,%r8d
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
xor %edx,%edx
jmp 1291 <func0+0x61>
| 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 rax, 1
add edx, 1
cmp r9, rax
jz short loc_1290
loc_1274:
movsx rsi, byte ptr [rax]
test byte ptr [r8+rsi*2+1], 1
jnz short loc_1268
cmp ecx, edx
cmovl ecx, edx
add rax, 1
xor edx, edx
cmp r9, rax
jnz short loc_1274
loc_1290:
movsxd rbx, ebx
cmp ecx, edx
movsx rax, byte ptr [rbp+rbx-1]
cmovge edx, ecx
test byte ptr [r8+rax*2+1], 1
cmovnz ecx, edx
add rsp, 8
pop rbx
pop rbp
mov eax, ecx
retn
loc_12B0:
xor ecx, ecx
xor edx, edx
jmp short loc_1290 | 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 = (long long)&a1[v1 - 1 + 1];
v6 = 0;
do
{
while ( (v2[*v3] & 0x100) != 0 )
{
++v3;
++v6;
if ( (const char *)v5 == v3 )
goto LABEL_8;
}
if ( v4 < v6 )
v4 = v6;
++v3;
v6 = 0;
}
while ( (const char *)v5 != v3 );
}
LABEL_8:
if ( v4 >= v6 )
v6 = v4;
if ( (v2[a1[v1 - 1]] & 0x100) != 0 )
return (unsigned int)v6;
return (unsigned int)v4;
} | 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_00101274:
MOVSX RSI,byte ptr [RAX]
TEST byte ptr [R8 + RSI*0x2 + 0x1],0x1
JNZ 0x00101268
CMP ECX,EDX
CMOVL ECX,EDX
ADD RAX,0x1
XOR EDX,EDX
CMP R9,RAX
JNZ 0x00101274
LAB_00101290:
MOVSXD RBX,EBX
CMP ECX,EDX
MOVSX RAX,byte ptr [RBP + RBX*0x1 + -0x1]
CMOVGE EDX,ECX
TEST byte ptr [R8 + RAX*0x2 + 0x1],0x1
CMOVNZ ECX,EDX
ADD RSP,0x8
POP RBX
POP RBP
MOV EAX,ECX
RET
LAB_001012b0:
XOR ECX,ECX
XOR EDX,EDX
JMP 0x00101290 | 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 {
while ((*(byte *)((long)*ppuVar2 + (long)*pcVar3 * 2 + 1) & 1) == 0) {
if (iVar4 < iVar5) {
iVar4 = iVar5;
}
pcVar3 = pcVar3 + 1;
iVar5 = 0;
if (param_1 + (ulong)(iVar6 - 1) + 1 == pcVar3) goto LAB_00101290;
}
pcVar3 = pcVar3 + 1;
iVar5 = iVar5 + 1;
} while (param_1 + (ulong)(iVar6 - 1) + 1 != pcVar3);
}
LAB_00101290:
if (iVar5 <= iVar4) {
iVar5 = iVar4;
}
if ((*(byte *)((long)*ppuVar2 + (long)param_1[(long)iVar6 + -1] * 2 + 1) & 1) != 0) {
iVar4 = iVar5;
}
return iVar4;
} |
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 -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
jmp 11c7 <func0+0x5e>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
mov $0xffffffff,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_11BA
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jz short loc_11B6
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
jmp short loc_11C7
loc_11B6:
add [rbp+var_4], 1
loc_11BA:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1181
mov eax, 0FFFFFFFFh
loc_11C7:
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) != 0 )
return *(unsigned int *)(4LL * i + a1);
}
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ba
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX,0x1
TEST EAX,EAX
JZ 0x001011b6
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
JMP 0x001011c7
LAB_001011b6:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ba:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
MOV EAX,0xffffffff
LAB_001011c7:
POP RBP
RET | int4 func0(long param_1,int param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 0xffffffff;
}
if ((*(uint *)(param_1 + (long)local_c * 4) & 1) != 0) break;
local_c = local_c + 1;
}
return *(int4 *)(param_1 + (long)local_c * 4);
} |
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 1191 <func0+0x28>
| func0:
endbr64
test esi, esi
jle short loc_1194
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
loc_117C:
mov edx, [rax]
test dl, 1
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, 0FFFFFFFFh
jmp short loc_1191 | long long func0(unsigned int *a1, int a2)
{
unsigned int *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return (unsigned int)-1;
}
else
{
v2 = a1;
while ( 1 )
{
v3 = *v2;
if ( (*v2 & 1) != 0 )
break;
if ( ++v2 == &a1[a2 - 1 + 1] )
return (unsigned int)-1;
}
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101194
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
LAB_0010117c:
MOV EDX,dword ptr [RAX]
TEST DL,0x1
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 $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| 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;
}
return result;
} | 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 $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
lea rdx, [rdi+rsi*4]
jmp short loc_1161
loc_1158:
add rdi, 4
cmp rdi, rdx
jz short loc_1170
loc_1161:
mov eax, [rdi]
test al, 1
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(%rbp)
jne 11a9 <func0+0x40>
movb $0x1,-0x5(%rbp)
jmp 11b5 <func0+0x4c>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
movzbl -0x5(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_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]
cmp [rbp+var_20], eax
jnz short loc_11A9
mov [rbp+var_5], 1
jmp short loc_11B5
loc_11A9:
add [rbp+var_4], 1
loc_11AD:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
loc_11B5:
movzx eax, [rbp+var_5]
pop rbp
retn | 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
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x20],EAX
JNZ 0x001011a9
MOV byte ptr [RBP + -0x5],0x1
JMP 0x001011b5
LAB_001011a9:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ad:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
LAB_001011b5:
MOVZX EAX,byte ptr [RBP + -0x5]
POP RBP
RET | 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,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| 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,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| 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(func0(tup1_3, tup2_3, 3) == true);
return 0;
}
| 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),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jg 11bf <func0+0x56>
movb $0x0,-0x5(%rbp)
jmp 11cb <func0+0x62>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 1189 <func0+0x20>
movzbl -0x5(%rbp),%eax
pop %rbp
retq
| 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]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jg short loc_11BF
mov [rbp+var_5], 0
jmp short loc_11CB
loc_11BF:
add [rbp+var_4], 1
loc_11C3:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_24]
jl short loc_1189
loc_11CB:
movzx eax, [rbp+var_5]
pop rbp
retn | 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
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JG 0x001011bf
MOV byte ptr [RBP + -0x5],0x0
JMP 0x001011cb
LAB_001011bf:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c3:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00101189
LAB_001011cb:
MOVZX EAX,byte ptr [RBP + -0x5]
POP RBP
RET | 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(func0(tup1_3, tup2_3, 3) == true);
return 0;
}
| 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
retq
mov $0x0,%eax
retq
| 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(func0(tup1_3, tup2_3, 3) == true);
return 0;
}
| 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,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| 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(func0(tup1_3, tup2_3, 3) == true);
return 0;
}
| 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,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| 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
retn | 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_FAILURE);
}
int index = 0;
for(int i = 0; i < a; i++) {
result[index++] = 'p';
}
for(int i = 0; i < b; i++) {
result[index++] = 'q';
}
for(int i = 0; i < c; i++) {
result[index++] = 'r';
}
for(int i = 0; i < d; i++) {
result[index++] = 's';
}
result[index] = '\0';
return result;
}
| 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;
for(int i = 0; i < 11; i++) expected3[idx++] = 'p';
for(int i = 0; i < 15; i++) expected3[idx++] = 'q';
for(int i = 0; i < 12; i++) expected3[idx++] = 'r';
for(int i = 0; i < 23; i++) expected3[idx++] = 's';
expected3[idx] = '\0';
assert(strcmp(res3, expected3) == 0);
free(res3);
return 0;
}
| 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 <func0+0x37>
mov -0x28(%rbp),%eax
add %eax,-0x20(%rbp)
cmpl $0x0,-0x2c(%rbp)
jle 124c <func0+0x43>
mov -0x2c(%rbp),%eax
add %eax,-0x20(%rbp)
cmpl $0x0,-0x30(%rbp)
jle 1258 <func0+0x4f>
mov -0x30(%rbp),%eax
add %eax,-0x20(%rbp)
mov -0x20(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 1289 <func0+0x80>
lea 0xd8e(%rip),%rdi
callq 1100 <perror@plt>
mov $0x1,%edi
callq 1110 <exit@plt>
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
jmp 12b3 <func0+0xaa>
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x70,(%rax)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 1299 <func0+0x90>
movl $0x0,-0x14(%rbp)
jmp 12de <func0+0xd5>
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x71,(%rax)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x28(%rbp),%eax
jl 12c4 <func0+0xbb>
movl $0x0,-0x10(%rbp)
jmp 1309 <func0+0x100>
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x72,(%rax)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 12ef <func0+0xe6>
movl $0x0,-0xc(%rbp)
jmp 1334 <func0+0x12b>
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x73,(%rax)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 131a <func0+0x111>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| 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], 0
jle short loc_1240
mov eax, [rbp+var_28]
add [rbp+var_20], eax
loc_1240:
cmp [rbp+var_2C], 0
jle short loc_124C
mov eax, [rbp+var_2C]
add [rbp+var_20], eax
loc_124C:
cmp [rbp+var_30], 0
jle short loc_1258
mov eax, [rbp+var_30]
add [rbp+var_20], eax
loc_1258:
mov eax, [rbp+var_20]
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jnz short loc_128C
lea rax, s; "Failed to allocate memory"
mov rdi, rax; s
call _perror
mov edi, 1; status
call _exit
loc_128C:
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
jmp short loc_12B6
loc_129C:
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov byte ptr [rax], 70h ; 'p'
add [rbp+var_18], 1
loc_12B6:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_24]
jl short loc_129C
mov [rbp+var_14], 0
jmp short loc_12E1
loc_12C7:
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov byte ptr [rax], 71h ; 'q'
add [rbp+var_14], 1
loc_12E1:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_28]
jl short loc_12C7
mov [rbp+var_10], 0
jmp short loc_130C
loc_12F2:
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov byte ptr [rax], 72h ; 'r'
add [rbp+var_10], 1
loc_130C:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_2C]
jl short loc_12F2
mov [rbp+var_C], 0
jmp short loc_1337
loc_131D:
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov byte ptr [rax], 73h ; 's'
add [rbp+var_C], 1
loc_1337:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_30]
jl short loc_131D
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
leave
retn | _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 *v17; // [rsp+28h] [rbp-8h]
v11 = 0;
if ( a1 > 0 )
v11 = a1;
if ( a2 > 0 )
v11 += a2;
if ( a3 > 0 )
v11 += a3;
if ( a4 > 0 )
v11 += a4;
v17 = malloc(v11 + 1);
if ( !v17 )
{
perror("Failed to allocate memory");
exit(1);
}
v12 = 0;
for ( i = 0; i < a1; ++i )
{
v4 = v12++;
v17[v4] = 112;
}
for ( j = 0; j < a2; ++j )
{
v5 = v12++;
v17[v5] = 113;
}
for ( k = 0; k < a3; ++k )
{
v6 = v12++;
v17[v6] = 114;
}
for ( m = 0; m < a4; ++m )
{
v7 = v12++;
v17[v7] = 115;
}
v17[v12] = 0;
return v17;
} | 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
LAB_00101234:
CMP dword ptr [RBP + -0x28],0x0
JLE 0x00101240
MOV EAX,dword ptr [RBP + -0x28]
ADD dword ptr [RBP + -0x20],EAX
LAB_00101240:
CMP dword ptr [RBP + -0x2c],0x0
JLE 0x0010124c
MOV EAX,dword ptr [RBP + -0x2c]
ADD dword ptr [RBP + -0x20],EAX
LAB_0010124c:
CMP dword ptr [RBP + -0x30],0x0
JLE 0x00101258
MOV EAX,dword ptr [RBP + -0x30]
ADD dword ptr [RBP + -0x20],EAX
LAB_00101258:
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0010128c
LEA RAX,[0x102004]
MOV RDI,RAX
CALL 0x00101100
MOV EDI,0x1
CALL 0x00101110
LAB_0010128c:
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001012b6
LAB_0010129c:
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x70
ADD dword ptr [RBP + -0x18],0x1
LAB_001012b6:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x0010129c
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012e1
LAB_001012c7:
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x71
ADD dword ptr [RBP + -0x14],0x1
LAB_001012e1:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x28]
JL 0x001012c7
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0010130c
LAB_001012f2:
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x72
ADD dword ptr [RBP + -0x10],0x1
LAB_0010130c:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001012f2
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101337
LAB_0010131d:
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x73
ADD dword ptr [RBP + -0xc],0x1
LAB_00101337:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x0010131d
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | 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_3) {
local_28 = local_28 + param_3;
}
if (0 < param_4) {
local_28 = local_28 + param_4;
}
pvVar1 = malloc((long)(local_28 + 1));
if (pvVar1 == (void *)0x0) {
perror("Failed to allocate memory");
/* WARNING: Subroutine does not return */
exit(1);
}
local_24 = 0;
for (local_20 = 0; local_20 < param_1; local_20 = local_20 + 1) {
*(int *)((long)pvVar1 + (long)local_24) = 0x70;
local_24 = local_24 + 1;
}
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
*(int *)((long)pvVar1 + (long)local_24) = 0x71;
local_24 = local_24 + 1;
}
for (local_18 = 0; local_18 < param_3; local_18 = local_18 + 1) {
*(int *)((long)pvVar1 + (long)local_24) = 0x72;
local_24 = local_24 + 1;
}
for (local_14 = 0; local_14 < param_4; local_14 = local_14 + 1) {
*(int *)((long)pvVar1 + (long)local_24) = 0x73;
local_24 = local_24 + 1;
}
*(int *)((long)pvVar1 + (long)local_24) = 0;
return pvVar1;
} |
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_FAILURE);
}
int index = 0;
for(int i = 0; i < a; i++) {
result[index++] = 'p';
}
for(int i = 0; i < b; i++) {
result[index++] = 'q';
}
for(int i = 0; i < c; i++) {
result[index++] = 'r';
}
for(int i = 0; i < d; i++) {
result[index++] = 's';
}
result[index] = '\0';
return result;
}
| 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;
for(int i = 0; i < 11; i++) expected3[idx++] = 'p';
for(int i = 0; i < 15; i++) expected3[idx++] = 'q';
for(int i = 0; i < 12; i++) expected3[idx++] = 'r';
for(int i = 0; i < 23; i++) expected3[idx++] = 's';
expected3[idx] = '\0';
assert(strcmp(res3, expected3) == 0);
free(res3);
return 0;
}
| 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
lea (%rdi,%rcx,1),%eax
test %ecx,%ecx
cmovg %eax,%edi
add $0x1,%edi
movslq %edi,%rdi
callq 10f0 <malloc@plt>
test %rax,%rax
je 1305 <func0+0xfc>
test %ebx,%ebx
jle 12fb <func0+0xf2>
mov %rax,%rdx
lea -0x1(%rbx),%ecx
lea 0x1(%rax,%rcx,1),%rcx
movb $0x70,(%rdx)
add $0x1,%rdx
cmp %rcx,%rdx
jne 126a <func0+0x61>
test %r13d,%r13d
jle 129d <func0+0x94>
movslq %ebx,%rsi
lea (%rax,%rsi,1),%rdx
lea -0x1(%r13),%ecx
lea 0x1(%rax,%rcx,1),%rcx
add %rsi,%rcx
movb $0x71,(%rdx)
add $0x1,%rdx
cmp %rcx,%rdx
jne 128e <func0+0x85>
add %r13d,%ebx
test %r12d,%r12d
jle 12c5 <func0+0xbc>
movslq %ebx,%rsi
lea (%rax,%rsi,1),%rdx
lea -0x1(%r12),%ecx
lea 0x1(%rax,%rcx,1),%rcx
add %rsi,%rcx
movb $0x72,(%rdx)
add $0x1,%rdx
cmp %rcx,%rdx
jne 12b6 <func0+0xad>
add %r12d,%ebx
test %ebp,%ebp
jle 12e9 <func0+0xe0>
movslq %ebx,%rsi
lea (%rax,%rsi,1),%rdx
lea -0x1(%rbp),%ecx
lea 0x1(%rax,%rcx,1),%rcx
add %rsi,%rcx
movb $0x73,(%rdx)
add $0x1,%rdx
cmp %rcx,%rdx
jne 12db <func0+0xd2>
add %ebp,%ebx
movslq %ebx,%rbx
movb $0x0,(%rax,%rbx,1)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x0,%ebx
jmpq 1276 <func0+0x6d>
lea 0xcf8(%rip),%rdi
callq 1100 <perror@plt>
mov $0x1,%edi
callq 1110 <exit@plt>
| 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 eax, [rdi+rcx]
test ecx, ecx
cmovg edi, eax
add edi, 1
movsxd rdi, edi
call _malloc
test rax, rax
jz loc_12FB
mov rdx, rax
mov ecx, ebx
add rcx, rax
test ebx, ebx
jle loc_12F1
loc_1267:
mov byte ptr [rax], 70h ; 'p'
add rax, 1
cmp rax, rcx
jnz short loc_1267
loc_1273:
test r13d, r13d
jle short loc_1297
movsxd rsi, ebx
lea rax, [rdx+rsi]
mov ecx, r13d
add rcx, rdx
add rcx, rsi
loc_1288:
mov byte ptr [rax], 71h ; 'q'
add rax, 1
cmp rax, rcx
jnz short loc_1288
add ebx, r13d
loc_1297:
test r12d, r12d
jle short loc_12BB
movsxd rsi, ebx
lea rax, [rdx+rsi]
mov ecx, r12d
add rcx, rdx
add rcx, rsi
loc_12AC:
mov byte ptr [rax], 72h ; 'r'
add rax, 1
cmp rax, rcx
jnz short loc_12AC
add ebx, r12d
loc_12BB:
test ebp, ebp
jle short loc_12DC
movsxd rsi, ebx
lea rax, [rdx+rsi]
mov ecx, ebp
add rcx, rdx
add rcx, rsi
loc_12CE:
mov byte ptr [rax], 73h ; 's'
add rax, 1
cmp rax, rcx
jnz short loc_12CE
add ebx, ebp
loc_12DC:
movsxd rbx, ebx
mov byte ptr [rdx+rbx], 0
mov rax, rdx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_12F1:
mov ebx, 0
jmp loc_1273
loc_12FB:
lea rdi, aFailedToAlloca; "Failed to allocate memory"
call _perror
mov edi, 1
call _exit | _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;
if ( a3 > 0 )
v8 += a3;
if ( a4 > 0 )
v8 += a4;
v9 = (_BYTE *)malloc(v8 + 1);
if ( !v9 )
{
perror("Failed to allocate memory");
exit(1LL);
}
v10 = v9;
v11 = &v9[v4];
if ( v4 <= 0 )
{
v4 = 0;
}
else
{
do
*v9++ = 112;
while ( v9 != v11 );
}
if ( a2 > 0 )
{
v12 = &v10[v4];
do
*v12++ = 113;
while ( v12 != &v10[a2 + v4] );
v4 += a2;
}
if ( a3 > 0 )
{
v13 = &v10[v4];
do
*v13++ = 114;
while ( v13 != &v10[a3 + v4] );
v4 += a3;
}
if ( a4 > 0 )
{
v14 = &v10[v4];
do
*v14++ = 115;
while ( v14 != &v10[a4 + v4] );
v4 += a4;
}
v10[v4] = 0;
return v10;
} | 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
MOVSXD RDI,EDI
CALL 0x001010f0
TEST RAX,RAX
JZ 0x001012fb
MOV RDX,RAX
MOV ECX,EBX
ADD RCX,RAX
TEST EBX,EBX
JLE 0x001012f1
LAB_00101267:
MOV byte ptr [RAX],0x70
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101267
LAB_00101273:
TEST R13D,R13D
JLE 0x00101297
MOVSXD RSI,EBX
LEA RAX,[RDX + RSI*0x1]
MOV ECX,R13D
ADD RCX,RDX
ADD RCX,RSI
LAB_00101288:
MOV byte ptr [RAX],0x71
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101288
ADD EBX,R13D
LAB_00101297:
TEST R12D,R12D
JLE 0x001012bb
MOVSXD RSI,EBX
LEA RAX,[RDX + RSI*0x1]
MOV ECX,R12D
ADD RCX,RDX
ADD RCX,RSI
LAB_001012ac:
MOV byte ptr [RAX],0x72
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x001012ac
ADD EBX,R12D
LAB_001012bb:
TEST EBP,EBP
JLE 0x001012dc
MOVSXD RSI,EBX
LEA RAX,[RDX + RSI*0x1]
MOV ECX,EBP
ADD RCX,RDX
ADD RCX,RSI
LAB_001012ce:
MOV byte ptr [RAX],0x73
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x001012ce
ADD EBX,EBP
LAB_001012dc:
MOVSXD RBX,EBX
MOV byte ptr [RDX + RBX*0x1],0x0
MOV RAX,RDX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001012f1:
MOV EBX,0x0
JMP 0x00101273
LAB_001012fb:
LEA RDI,[0x102004]
CALL 0x00101100
MOV EDI,0x1
CALL 0x00101110 | 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)param_4) {
uVar3 = uVar3 + param_4;
}
puVar1 = (int1 *)malloc((long)(int)(uVar3 + 1));
if (puVar1 != (int1 *)0x0) {
puVar2 = puVar1;
if ((int)param_1 < 1) {
param_1 = 0;
}
else {
do {
*puVar2 = 0x70;
puVar2 = puVar2 + 1;
} while (puVar2 != puVar1 + param_1);
}
if (0 < (int)param_2) {
puVar2 = puVar1 + (int)param_1;
do {
*puVar2 = 0x71;
puVar2 = puVar2 + 1;
} while (puVar2 != puVar1 + (long)(int)param_1 + (ulong)param_2);
param_1 = param_1 + param_2;
}
if (0 < (int)param_3) {
puVar2 = puVar1 + (int)param_1;
do {
*puVar2 = 0x72;
puVar2 = puVar2 + 1;
} while (puVar2 != puVar1 + (long)(int)param_1 + (ulong)param_3);
param_1 = param_1 + param_3;
}
if (0 < (int)param_4) {
puVar2 = puVar1 + (int)param_1;
do {
*puVar2 = 0x73;
puVar2 = puVar2 + 1;
} while (puVar2 != puVar1 + (long)(int)param_1 + (ulong)param_4);
param_1 = param_1 + param_4;
}
puVar1[(int)param_1] = 0;
return puVar1;
}
perror("Failed to allocate memory");
/* WARNING: Subroutine does not return */
exit(1);
} |
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_FAILURE);
}
int index = 0;
for(int i = 0; i < a; i++) {
result[index++] = 'p';
}
for(int i = 0; i < b; i++) {
result[index++] = 'q';
}
for(int i = 0; i < c; i++) {
result[index++] = 'r';
}
for(int i = 0; i < d; i++) {
result[index++] = 's';
}
result[index] = '\0';
return result;
}
| 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;
for(int i = 0; i < 11; i++) expected3[idx++] = 'p';
for(int i = 0; i < 15; i++) expected3[idx++] = 'q';
for(int i = 0; i < 12; i++) expected3[idx++] = 'r';
for(int i = 0; i < 23; i++) expected3[idx++] = 's';
expected3[idx] = '\0';
assert(strcmp(res3, expected3) == 0);
free(res3);
return 0;
}
| 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
test %ecx,%ecx
lea (%rdi,%rcx,1),%eax
cmovg %eax,%edi
add $0x1,%edi
movslq %edi,%rdi
callq 10f0 <malloc@plt>
test %rax,%rax
je 14e2 <func0+0x132>
test %ebx,%ebx
jle 14d8 <func0+0x128>
lea -0x1(%rbx),%edx
mov %rax,%rdi
lea 0x1(%rax,%rdx,1),%rdx
nopl 0x0(%rax)
movb $0x70,(%rdi)
add $0x1,%rdi
cmp %rdx,%rdi
jne 1418 <func0+0x68>
movslq %ebx,%rdx
add %rax,%rdx
test %r13d,%r13d
jle 145d <func0+0xad>
lea -0x1(%r13),%edx
movslq %ebx,%rcx
lea 0x1(%rax,%rdx,1),%rdx
lea (%rax,%rcx,1),%rdi
add %rcx,%rdx
nopw 0x0(%rax,%rax,1)
movb $0x71,(%rdi)
add $0x1,%rdi
cmp %rdx,%rdi
jne 1448 <func0+0x98>
add %r13d,%ebx
movslq %ebx,%rdx
add %rax,%rdx
test %r12d,%r12d
jle 1495 <func0+0xe5>
lea -0x1(%r12),%ecx
movslq %ebx,%rdx
lea 0x1(%rax,%rcx,1),%rcx
lea (%rax,%rdx,1),%rsi
add %rdx,%rcx
nopw %cs:0x0(%rax,%rax,1)
movb $0x72,(%rsi)
add $0x1,%rsi
cmp %rsi,%rcx
jne 1480 <func0+0xd0>
add %r12d,%ebx
movslq %ebx,%rdx
add %rax,%rdx
test %ebp,%ebp
jle 14c5 <func0+0x115>
lea -0x1(%rbp),%esi
movslq %ebx,%rcx
lea 0x1(%rax,%rsi,1),%rsi
lea (%rax,%rcx,1),%rdx
add %rcx,%rsi
nopl 0x0(%rax,%rax,1)
movb $0x73,(%rdx)
add $0x1,%rdx
cmp %rsi,%rdx
jne 14b0 <func0+0x100>
add %ebp,%ebx
movslq %ebx,%rbx
lea (%rax,%rbx,1),%rdx
movb $0x0,(%rdx)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
mov %rax,%rdx
xor %ebx,%ebx
jmpq 142a <func0+0x7a>
lea 0xb1b(%rip),%rdi
callq 1100 <perror@plt>
mov $0x1,%edi
callq 1110 <exit@plt>
nopl 0x0(%rax,%rax,1)
| 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]
cmovg edi, eax
test ecx, ecx
lea eax, [rdi+rcx]
cmovg edi, eax
add edi, 1
movsxd rdi, edi
call _malloc
test rax, rax
jz loc_14E5
mov r14, rax
test r13d, r13d
jle loc_14E0
movsxd r15, r13d
mov esi, 70h ; 'p'
mov rdi, rax
mov rdx, r15
call _memset
lea rax, [r14+r15]
loc_1466:
test r12d, r12d
jle short loc_1487
movsxd rdi, r13d
movsxd rdx, r12d
mov esi, 71h ; 'q'
add r13d, r12d
add rdi, r14
call _memset
movsxd rax, r13d
add rax, r14
loc_1487:
test ebp, ebp
jle short loc_14A7
movsxd rdi, r13d
movsxd rdx, ebp
mov esi, 72h ; 'r'
add r13d, ebp
add rdi, r14
call _memset
movsxd rax, r13d
add rax, r14
loc_14A7:
test ebx, ebx
jle short loc_14C8
movsxd rdx, ebx
movsxd rdi, r13d
add ebx, r13d
mov esi, 73h ; 's'
add rdi, r14
movsxd rbx, ebx
call _memset
lea rax, [r14+rbx]
loc_14C8:
mov byte ptr [rax], 0
add rsp, 8
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_14E0:
xor r13d, r13d
jmp short loc_1466
loc_14E5:
lea rdi, aFailedToAlloca; "Failed to allocate memory"
call _perror
mov edi, 1
call _exit | _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 ( a4 > 0 )
v8 += a4;
v9 = (_BYTE *)malloc(v8 + 1);
if ( !v9 )
{
perror("Failed to allocate memory");
exit(1LL);
}
v10 = v9;
if ( v4 <= 0 )
{
v4 = 0;
}
else
{
memset(v9, 112LL, v4);
v9 = &v10[v4];
}
if ( a2 > 0 )
{
v11 = v4;
v4 += a2;
memset(&v10[v11], 113LL, a2);
v9 = &v10[v4];
}
if ( a3 > 0 )
{
v12 = v4;
v4 += a3;
memset(&v10[v12], 114LL, a3);
v9 = &v10[v4];
}
if ( a4 > 0 )
{
memset(&v10[v4], 115LL, a4);
v9 = &v10[v4 + a4];
}
*v9 = 0;
return v10;
} | 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,EAX
ADD EDI,0x1
MOVSXD RDI,EDI
CALL 0x00101110
TEST RAX,RAX
JZ 0x001014e5
MOV R14,RAX
TEST R13D,R13D
JLE 0x001014e0
MOVSXD R15,R13D
MOV ESI,0x70
MOV RDI,RAX
MOV RDX,R15
CALL 0x001010f0
LEA RAX,[R14 + R15*0x1]
LAB_00101466:
TEST R12D,R12D
JLE 0x00101487
MOVSXD RDI,R13D
MOVSXD RDX,R12D
MOV ESI,0x71
ADD R13D,R12D
ADD RDI,R14
CALL 0x001010f0
MOVSXD RAX,R13D
ADD RAX,R14
LAB_00101487:
TEST EBP,EBP
JLE 0x001014a7
MOVSXD RDI,R13D
MOVSXD RDX,EBP
MOV ESI,0x72
ADD R13D,EBP
ADD RDI,R14
CALL 0x001010f0
MOVSXD RAX,R13D
ADD RAX,R14
LAB_001014a7:
TEST EBX,EBX
JLE 0x001014c8
MOVSXD RDX,EBX
MOVSXD RDI,R13D
ADD EBX,R13D
MOV ESI,0x73
ADD RDI,R14
MOVSXD RBX,EBX
CALL 0x001010f0
LEA RAX,[R14 + RBX*0x1]
LAB_001014c8:
MOV byte ptr [RAX],0x0
ADD RSP,0x8
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001014e0:
XOR R13D,R13D
JMP 0x00101466
LAB_001014e5:
LEA RDI,[0x102004]
CALL 0x00101120
MOV EDI,0x1
CALL 0x00101130 | 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) {
iVar2 = iVar2 + param_4;
}
__s = (int1 *)malloc((long)(iVar2 + 1));
if (__s != (int1 *)0x0) {
if (param_1 < 1) {
param_1 = 0;
puVar1 = __s;
}
else {
memset(__s,0x70,(long)param_1);
puVar1 = __s + param_1;
}
if (0 < param_2) {
lVar3 = (long)param_1;
param_1 = param_1 + param_2;
memset(__s + lVar3,0x71,(long)param_2);
puVar1 = __s + param_1;
}
if (0 < param_3) {
lVar3 = (long)param_1;
param_1 = param_1 + param_3;
memset(__s + lVar3,0x72,(long)param_3);
puVar1 = __s + param_1;
}
if (0 < param_4) {
memset(__s + param_1,0x73,(long)param_4);
puVar1 = __s + (param_4 + param_1);
}
*puVar1 = 0;
return __s;
}
perror("Failed to allocate memory");
/* WARNING: Subroutine does not return */
exit(1);
} |
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_FAILURE);
}
int index = 0;
for(int i = 0; i < a; i++) {
result[index++] = 'p';
}
for(int i = 0; i < b; i++) {
result[index++] = 'q';
}
for(int i = 0; i < c; i++) {
result[index++] = 'r';
}
for(int i = 0; i < d; i++) {
result[index++] = 's';
}
result[index] = '\0';
return result;
}
| 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;
for(int i = 0; i < 11; i++) expected3[idx++] = 'p';
for(int i = 0; i < 15; i++) expected3[idx++] = 'q';
for(int i = 0; i < 12; i++) expected3[idx++] = 'r';
for(int i = 0; i < 23; i++) expected3[idx++] = 's';
expected3[idx] = '\0';
assert(strcmp(res3, expected3) == 0);
free(res3);
return 0;
}
| 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 %ecx,%ecx
lea (%rdi,%rcx,1),%eax
cmovg %eax,%edi
add $0x1,%edi
movslq %edi,%rdi
callq 1110 <malloc@plt>
test %rax,%rax
je 14ff <func0+0xff>
mov %rax,%r13
test %ebx,%ebx
jle 14f8 <func0+0xf8>
lea -0x1(%rbx),%edx
mov $0x70,%esi
mov %rax,%rdi
add $0x1,%rdx
callq 10f0 <memset@plt>
movslq %ebx,%rax
add %r13,%rax
test %r14d,%r14d
jle 1497 <func0+0x97>
movslq %ebx,%rdi
lea -0x1(%r14),%edx
mov $0x71,%esi
add %r14d,%ebx
add $0x1,%rdx
add %r13,%rdi
callq 10f0 <memset@plt>
movslq %ebx,%rax
add %r13,%rax
test %r12d,%r12d
jle 14be <func0+0xbe>
movslq %ebx,%rdi
lea -0x1(%r12),%edx
mov $0x72,%esi
add %r12d,%ebx
add $0x1,%rdx
add %r13,%rdi
callq 10f0 <memset@plt>
movslq %ebx,%rax
add %r13,%rax
test %ebp,%ebp
jle 14e3 <func0+0xe3>
movslq %ebx,%rdi
lea -0x1(%rbp),%edx
add %ebp,%ebx
mov $0x73,%esi
add $0x1,%rdx
add %r13,%rdi
movslq %ebx,%rbx
callq 10f0 <memset@plt>
lea 0x0(%r13,%rbx,1),%rax
movb $0x0,(%rax)
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
xor %ebx,%ebx
jmpq 1471 <func0+0x71>
lea 0xafe(%rip),%rdi
callq 1120 <perror@plt>
mov $0x1,%edi
callq 1130 <exit@plt>
nopw %cs:0x0(%rax,%rax,1)
| 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, ecx
lea eax, [rdi+rcx]
cmovg edi, eax
add edi, 1
movsxd rdi, edi; size
call _malloc
test rax, rax
jz func0_cold
mov r14, rax
test ebx, ebx
jle loc_14D0
mov edx, ebx; n
mov esi, 70h ; 'p'; c
mov rdi, rax; s
call _memset
movsxd rax, ebx
add rax, r14
loc_145C:
test r13d, r13d
jle short loc_147D
movsxd rdi, ebx
mov edx, r13d; n
mov esi, 71h ; 'q'; c
add ebx, r13d
add rdi, r14; s
call _memset
movsxd rax, ebx
add rax, r14
loc_147D:
test r12d, r12d
jle short loc_149E
movsxd rdi, ebx
mov edx, r12d; n
mov esi, 72h ; 'r'; c
add ebx, r12d
add rdi, r14; s
call _memset
movsxd rax, ebx
add rax, r14
loc_149E:
test ebp, ebp
jle short loc_14BD
movsxd rdi, ebx
add ebx, ebp
mov edx, ebp; n
mov esi, 73h ; 's'; c
add rdi, r14; s
movsxd rbx, ebx
call _memset
lea rax, [r14+rbx]
loc_14BD:
mov byte ptr [rax], 0
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_14D0:
xor ebx, ebx
jmp short loc_145C | _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 )
v8 += a3;
if ( a4 > 0 )
v8 += a4;
v9 = malloc(v8 + 1);
if ( !v9 )
func0_cold();
v10 = v9;
if ( v7 <= 0 )
{
v7 = 0;
}
else
{
memset(v9, 112, (unsigned int)v7);
v9 = &v10[v7];
}
if ( a2 > 0 )
{
v11 = v7;
v7 += a2;
memset(&v10[v11], 113, (unsigned int)a2);
v9 = &v10[v7];
}
if ( a3 > 0 )
{
v12 = v7;
v7 += a3;
memset(&v10[v12], 114, (unsigned int)a3);
v9 = &v10[v7];
}
if ( a4 > 0 )
{
memset(&v10[v7], 115, (unsigned int)a4);
v9 = &v10[a4 + v7];
}
*v9 = 0;
return v10;
} | 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
MOVSXD RDI,EDI
CALL 0x00101110
TEST RAX,RAX
JZ 0x00101140
MOV R14,RAX
TEST EBX,EBX
JLE 0x001014d0
MOV EDX,EBX
MOV ESI,0x70
MOV RDI,RAX
CALL 0x001010f0
MOVSXD RAX,EBX
ADD RAX,R14
LAB_0010145c:
TEST R13D,R13D
JLE 0x0010147d
MOVSXD RDI,EBX
MOV EDX,R13D
MOV ESI,0x71
ADD EBX,R13D
ADD RDI,R14
CALL 0x001010f0
MOVSXD RAX,EBX
ADD RAX,R14
LAB_0010147d:
TEST R12D,R12D
JLE 0x0010149e
MOVSXD RDI,EBX
MOV EDX,R12D
MOV ESI,0x72
ADD EBX,R12D
ADD RDI,R14
CALL 0x001010f0
MOVSXD RAX,EBX
ADD RAX,R14
LAB_0010149e:
TEST EBP,EBP
JLE 0x001014bd
MOVSXD RDI,EBX
ADD EBX,EBP
MOV EDX,EBP
MOV ESI,0x73
ADD RDI,R14
MOVSXD RBX,EBX
CALL 0x001010f0
LEA RAX,[R14 + RBX*0x1]
LAB_001014bd:
MOV byte ptr [RAX],0x0
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001014d0:
XOR EBX,EBX
JMP 0x0010145c | 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 < (int)param_4) {
uVar2 = uVar2 + param_4;
}
__s = (int *)malloc((long)(int)(uVar2 + 1));
if (__s != (int *)0x0) {
if ((int)param_1 < 1) {
param_1 = 0;
puVar1 = __s;
}
else {
memset(__s,0x70,(ulong)param_1);
puVar1 = __s + (int)param_1;
}
if (0 < (int)param_2) {
lVar3 = (long)(int)param_1;
param_1 = param_1 + param_2;
memset(__s + lVar3,0x71,(ulong)param_2);
puVar1 = __s + (int)param_1;
}
if (0 < (int)param_3) {
lVar3 = (long)(int)param_1;
param_1 = param_1 + param_3;
memset(__s + lVar3,0x72,(ulong)param_3);
puVar1 = __s + (int)param_1;
}
if (0 < (int)param_4) {
memset(__s + (int)param_1,0x73,(ulong)param_4);
puVar1 = __s + (int)(param_1 + param_4);
}
*puVar1 = 0;
return __s;
}
perror("Failed to allocate memory");
/* WARNING: Subroutine does not return */
exit(1);
} |
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 true;
}
| 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);
assert(func0(list3, 2, list4, 2) == false);
assert(func0(list5, 2, list6, 2) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
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),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11fc <func0+0x93>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov 0x4(%rax),%eax
cmp %eax,%edx
je 1203 <func0+0x9a>
mov $0x0,%eax
jmp 1214 <func0+0xab>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 119a <func0+0x31>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_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:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11FC
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax+4]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax+4]
cmp edx, eax
jz short loc_1203
loc_11FC:
mov eax, 0
jmp short loc_1214
loc_1203:
add [rbp+var_4], 1
loc_1207:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_119A
mov eax, 1
loc_1214:
pop rbp
retn | 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 0LL;
}
}
return 1LL;
} | 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 0x00101207
LAB_0010119a:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011fc
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0x4]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
CMP EDX,EAX
JZ 0x00101203
LAB_001011fc:
MOV EAX,0x0
JMP 0x00101214
LAB_00101203:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101207:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010119a
MOV EAX,0x1
LAB_00101214:
POP RBP
RET | 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)local_c * 8 + 4) != *(int *)(param_3 + (long)local_c * 8 + 4))) {
return 0;
}
}
uVar1 = 1;
}
else {
uVar1 = 0;
}
return uVar1;
} |
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 true;
}
| 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);
assert(func0(list3, 2, list4, 2) == false);
assert(func0(list5, 2, list6, 2) == true);
return 0;
}
| 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(%rdi,%rax,8)
jne 11b4 <func0+0x4b>
lea 0x1(%rax),%rcx
cmp %rsi,%rax
jne 1184 <func0+0x1b>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
mov $0x0,%eax
retq
| 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 [rdi+rax*8+4], ecx
jnz short loc_11B4
lea rcx, [rax+1]
cmp rax, rsi
jnz short loc_1184
mov eax, 1
retn
loc_11A8:
mov eax, 1
retn
loc_11AE:
mov eax, 0
retn
loc_11B4:
mov eax, 0
locret_11B9:
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
long long v5; // rsi
long long i; // rax
result = 0LL;
if ( a2 == a4 )
{
if ( a2 <= 0 )
{
return 1LL;
}
else
{
v5 = (unsigned int)(a2 - 1);
for ( i = 0LL; ; ++i )
{
if ( *(_DWORD *)(a1 + 8 * i) != *(_DWORD *)(a3 + 8 * i) )
return 0LL;
if ( *(_DWORD *)(a1 + 8 * i + 4) != *(_DWORD *)(a3 + 8 * i + 4) )
break;
if ( i == v5 )
return 1LL;
}
return 0LL;
}
}
return result;
} | 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*0x8 + 0x4],ECX
JNZ 0x001011b4
LEA RCX,[RAX + 0x1]
CMP RAX,RSI
JNZ 0x00101184
MOV EAX,0x1
RET
LAB_001011a8:
MOV EAX,0x1
RET
LAB_001011ae:
MOV EAX,0x0
RET
LAB_001011b4:
MOV EAX,0x0
LAB_001011b9:
RET | 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 (*(int *)(param_1 + 4 + uVar1 * 8) != *(int *)(param_3 + 4 + uVar1 * 8)) break;
bVar2 = uVar1 == param_2 - 1;
uVar1 = uVar1 + 1;
if (bVar2) {
return 1;
}
}
}
return 0;
} |
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 true;
}
| 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);
assert(func0(list3, 2, list4, 2) == false);
assert(func0(list5, 2, list6, 2) == true);
return 0;
}
| 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 short loc_1300
loc_131B:
xor eax, eax
retn
loc_1320:
mov eax, 1
retn | 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;
}
return 0LL;
} | 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 0x00101300
LAB_0010131b:
XOR EAX,EAX
RET
LAB_00101320:
MOV EAX,0x1
RET | 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;
}
lVar1 = lVar1 + 1;
} while (lVar1 != param_2);
}
return 1;
} |
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 true;
}
| 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);
assert(func0(list3, 2, list4, 2) == false);
assert(func0(list5, 2, list6, 2) == true);
return 0;
}
| 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 1310 <func0+0x40>
mov %rcx,%rax
mov (%rdx,%rax,8),%ecx
cmp %ecx,(%rdi,%rax,8)
je 12e8 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| 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+rax], esi
jz short loc_12A8
loc_12C3:
xor eax, eax
retn
loc_12D0:
mov eax, 1
retn | 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 0LL;
} | 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 + RAX*0x1],ESI
JZ 0x001012a8
LAB_001012c3:
XOR EAX,EAX
RET
LAB_001012d0:
MOV EAX,0x1
RET | 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;
} while ((long)param_2 * 8 - lVar1 != 0);
}
return 1;
} |
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);
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 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 0xe23(%rip),%rsi
mov %rax,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 1233 <func0+0x8a>
mov -0x4(%rbp),%eax
cltq
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x18(%rbp),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movl $0x2e6452,(%rax)
mov -0x18(%rbp),%rax
leaveq
retq
| 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; "Road"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_1223
mov eax, [rbp+var_4]
cdqe
lea rdx, [rax-4]
mov rax, [rbp+s]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+s]
add rax, rdx
mov dword ptr [rax], 2E6452h
loc_1223:
mov rax, [rbp+s]
leave
retn | 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
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x00101223
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV dword ptr [RAX],0x2e6452
LAB_00101223:
MOV RAX,qword ptr [RBP + -0x18]
LEAVE
RET | 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_1 + sVar3,"Rd.",4);
}
}
return param_1;
} |
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);
return 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 %al
sbb $0x0,%al
test %al,%al
je 11b0 <func0+0x47>
mov %rdx,%rax
retq
movb $0x0,(%r8)
mov $0xffffffffffffffff,%rcx
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
not %rcx
movl $0x2e6452,-0x1(%rdx,%rcx,1)
jmp 11ac <func0+0x43>
| 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
retn
loc_11E4:
mov byte ptr [rbp+0], 0
mov rdi, rbx
call _strlen
mov dword ptr [rbx+rax], 2E6452h
jmp short loc_11DA | 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
CALL 0x00101080
MOV dword ptr [RBX + RAX*0x1],0x2e6452
JMP 0x001011da | 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);
}
}
return param_1;
} |
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);
return 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
pop %r12
retq
nopw 0x0(%rax,%rax,1)
movb $0x0,(%rdx)
mov %r12,%rdi
callq 1070 <strlen@plt>
movl $0x2e6452,(%r12,%rax,1)
mov %r12,%rax
pop %r12
retq
nopl 0x0(%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
retn
loc_1330:
mov byte ptr [rbx], 0
mov rdi, r12
call _strlen
mov dword ptr [r12+rax], 2E6452h
add rsp, 8
mov rax, r12
pop rbx
pop r12
retn | 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
CALL 0x00101080
MOV dword ptr [R12 + RAX*0x1],0x2e6452
ADD RSP,0x8
MOV RAX,R12
POP RBX
POP R12
RET | 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);
return param_1;
}
}
return param_1;
} |
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);
return 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
pop %r12
retq
nopw 0x0(%rax,%rax,1)
movb $0x0,(%rdx)
mov %r12,%rdi
callq 1070 <strlen@plt>
movl $0x2e6452,(%r12,%rax,1)
mov %r12,%rax
pop %r12
retq
nopl 0x0(%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 rbp
retn
loc_1320:
mov byte ptr [rbp+0], 0
mov rdi, rbx; s
call _strlen
mov dword ptr [rbx+rax], 2E6452h
add rsp, 8
mov rax, rbx
pop rbx
pop rbp
retn | 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
CALL 0x00101080
MOV dword ptr [RBX + RAX*0x1],0x2e6452
ADD RSP,0x8
MOV RAX,RBX
POP RBX
POP RBP
RET | 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);
return param_1;
}
}
return param_1;
} |
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]
POP RBP
RET | 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] == 1) {
mid++;
} else {
int temp = arr[mid];
arr[mid] = arr[high];
arr[high] = temp;
high--;
}
}
}
| 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, 1, 1, 2, 2, 2};
for (int i = 0; i < 10; i++)
assert(arr2[i] == expected_arr2[i]);
int arr3[10] = {2,2,1,0,0,0,1,1,2,1};
func0(arr3, 10);
int expected_arr3[10] = {0, 0, 0, 1, 1, 1, 1, 2, 2, 2};
for (int i = 0; i < 10; i++)
assert(arr3[i] == expected_arr3[i]);
return 0;
}
| 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,%rax
mov (%rax),%eax
test %eax,%eax
jne 121a <func0+0xb1>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x14(%rbp)
addl $0x1,-0x10(%rbp)
jmpq 129e <func0+0x135>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp $0x1,%eax
jne 123b <func0+0xd2>
addl $0x1,-0x10(%rbp)
jmp 129e <func0+0x135>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0x8(%rbp),%eax
mov %eax,(%rdx)
subl $0x1,-0xc(%rbp)
mov -0x10(%rbp),%eax
cmp -0xc(%rbp),%eax
jle 1194 <func0+0x2b>
pop %rbp
retq
| 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]
add rax, rdx
mov eax, [rax]
test eax, eax
jnz short loc_121A
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_14]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
add [rbp+var_14], 1
add [rbp+var_10], 1
jmp loc_129E
loc_121A:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
cmp eax, 1
jnz short loc_123B
add [rbp+var_10], 1
jmp short loc_129E
loc_123B:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_8], eax
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_10]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_8]
mov [rdx], eax
sub [rbp+var_C], 1
loc_129E:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_C]
jle loc_1194
nop
nop
pop rbp
retn | 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 ( (int)v4 > v5 )
break;
if ( *(_DWORD *)(4LL * (int)v4 + a1) )
{
if ( *(_DWORD *)(4LL * (int)v4 + a1) == 1 )
{
++v4;
}
else
{
v6 = *(_DWORD *)(4LL * (int)v4 + a1);
*(_DWORD *)(4LL * (int)v4 + a1) = *(_DWORD *)(4LL * v5 + a1);
*(_DWORD *)(a1 + 4LL * v5--) = v6;
}
}
else
{
v7 = *(_DWORD *)(4LL * v3 + a1);
*(_DWORD *)(4LL * v3 + a1) = *(_DWORD *)(4LL * (int)v4 + a1);
*(_DWORD *)(a1 + 4LL * (int)v4) = v7;
++v3;
++v4;
}
}
return result;
} | 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*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNZ 0x0010121a
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x14],0x1
ADD dword ptr [RBP + -0x10],0x1
JMP 0x0010129e
LAB_0010121a:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP EAX,0x1
JNZ 0x0010123b
ADD dword ptr [RBP + -0x10],0x1
JMP 0x0010129e
LAB_0010123b:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RDX],EAX
SUB dword ptr [RBP + -0xc],0x1
LAB_0010129e:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0xc]
JLE 0x00101194
NOP
NOP
POP RBP
RET | 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);
*(int4 *)(param_1 + (long)local_1c * 4) = *(int4 *)(param_1 + (long)local_18 * 4);
*(int4 *)((long)local_18 * 4 + param_1) = uVar1;
local_1c = local_1c + 1;
local_18 = local_18 + 1;
}
else if (*(int *)(param_1 + (long)local_18 * 4) == 1) {
local_18 = local_18 + 1;
}
else {
uVar1 = *(int4 *)(param_1 + (long)local_18 * 4);
*(int4 *)(param_1 + (long)local_18 * 4) = *(int4 *)(param_1 + (long)local_14 * 4);
*(int4 *)((long)local_14 * 4 + param_1) = uVar1;
local_14 = local_14 + -1;
}
}
return;
} |
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] == 1) {
mid++;
} else {
int temp = arr[mid];
arr[mid] = arr[high];
arr[high] = temp;
high--;
}
}
}
| 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, 1, 1, 2, 2, 2};
for (int i = 0; i < 10; i++)
assert(arr2[i] == expected_arr2[i]);
int arr3[10] = {2,2,1,0,0,0,1,1,2,1};
func0(arr3, 10);
int expected_arr3[10] = {0, 0, 0, 1, 1, 1, 1, 2, 2, 2};
for (int i = 0; i < 10; i++)
assert(arr3[i] == expected_arr3[i]);
return 0;
}
| 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 %eax,%rdx
lea (%rdi,%rdx,4),%rcx
mov (%rcx),%edx
test %edx,%edx
jne 117f <func0+0x16>
movslq %r8d,%rdx
lea (%rdi,%rdx,4),%rdx
mov (%rdx),%r9d
movl $0x0,(%rdx)
mov %r9d,(%rcx)
add $0x1,%r8d
add $0x1,%eax
jmp 1197 <func0+0x2e>
add $0x1,%eax
jmp 1197 <func0+0x2e>
retq
| 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
loc_119B:
movsxd rdx, eax
lea rcx, [rdi+rdx*4]
mov edx, [rcx]
test edx, edx
jnz short loc_117F
movsxd rdx, r8d
lea rdx, [rdi+rdx*4]
mov r9d, [rdx]
mov dword ptr [rdx], 0
mov [rcx], r9d
add r8d, 1
add eax, 1
jmp short loc_1197
loc_11C4:
add eax, 1
jmp short loc_1197
locret_11C9:
retn | 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 )
{
if ( v7 == 1 )
{
++v3;
}
else
{
v5 = (int *)(a1 + 4LL * v2);
*v6 = *v5;
*v5 = v7;
--v2;
}
}
else
{
v8 = (int *)(a1 + 4LL * v4);
v9 = *v8;
*v8 = 0;
*v6 = v9;
++v4;
++v3;
}
}
while ( v3 <= v2 );
}
} | 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,[RDI + RDX*0x4]
MOV EDX,dword ptr [RCX]
TEST EDX,EDX
JNZ 0x0010117f
MOVSXD RDX,R8D
LEA RDX,[RDI + RDX*0x4]
MOV R9D,dword ptr [RDX]
MOV dword ptr [RDX],0x0
MOV dword ptr [RCX],R9D
ADD R8D,0x1
ADD EAX,0x1
JMP 0x00101197
LAB_001011c4:
ADD EAX,0x1
JMP 0x00101197
LAB_001011c9:
RET | 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 *)(param_1 + (long)iVar5 * 4);
iVar3 = *piVar2;
*piVar2 = 0;
*piVar1 = iVar3;
iVar5 = iVar5 + 1;
iVar4 = iVar4 + 1;
}
else if (iVar3 == 1) {
iVar4 = iVar4 + 1;
}
else {
piVar2 = (int *)(param_1 + (long)param_2 * 4);
*piVar1 = *piVar2;
*piVar2 = iVar3;
param_2 = param_2 + -1;
}
} while (iVar4 <= param_2);
}
return;
} |
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] == 1) {
mid++;
} else {
int temp = arr[mid];
arr[mid] = arr[high];
arr[high] = temp;
high--;
}
}
}
| 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, 1, 1, 2, 2, 2};
for (int i = 0; i < 10; i++)
assert(arr2[i] == expected_arr2[i]);
int arr3[10] = {2,2,1,0,0,0,1,1,2,1};
func0(arr3, 10);
int expected_arr3[10] = {0, 0, 0, 1, 1, 1, 1, 2, 2, 2};
for (int i = 0; i < 10; i++)
assert(arr3[i] == expected_arr3[i]);
return 0;
}
| 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 (%rdi,%rdx,4),%rcx
mov (%rcx),%edx
test %edx,%edx
je 1430 <func0+0x10>
cmp $0x1,%edx
je 1480 <func0+0x60>
movslq %esi,%r9
sub $0x1,%esi
lea (%rdi,%r9,4),%r9
mov (%r9),%r10d
mov %r10d,(%rcx)
mov %edx,(%r9)
cmp %eax,%esi
jge 144e <func0+0x2e>
retq
nopl 0x0(%rax,%rax,1)
add $0x1,%eax
jmp 144a <func0+0x2a>
nopw %cs:0x0(%rax,%rax,1)
| 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_144E:
movsxd rdx, eax
lea rcx, [rdi+rdx*4]
mov edx, [rcx]
test edx, edx
jz short loc_1430
cmp edx, 1
jz short loc_1480
movsxd r9, esi
sub esi, 1
lea r9, [rdi+r9*4]
mov r10d, [r9]
mov [rcx], r10d
mov [r9], edx
cmp esi, eax
jge short loc_144E
locret_1477:
retn
loc_1480:
add eax, 1
jmp short loc_144A | 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 )
{
v8 = (int *)(a1 + 4LL * v3);
v9 = *v8;
if ( *v8 )
break;
v5 = v4;
++v3;
++v4;
v6 = (int *)(a1 + 4 * v5);
v7 = *v6;
*v6 = 0;
*v8 = v7;
LABEL_4:
if ( v2 < v3 )
return;
}
if ( v9 == 1 )
{
++v3;
goto LABEL_4;
}
v10 = v2--;
v11 = (int *)(a1 + 4 * v10);
*v8 = *v11;
*v11 = v9;
}
while ( v2 >= v3 );
}
} | 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]
MOV EDX,dword ptr [RCX]
TEST EDX,EDX
JZ 0x00101430
CMP EDX,0x1
JZ 0x00101480
MOVSXD R9,ESI
SUB ESI,0x1
LEA R9,[RDI + R9*0x4]
MOV R10D,dword ptr [R9]
MOV dword ptr [RCX],R10D
MOV dword ptr [R9],EDX
CMP ESI,EAX
JGE 0x0010144e
LAB_00101477:
RET
LAB_00101480:
ADD EAX,0x1
JMP 0x0010144a | 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;
if (iVar3 != 0) break;
lVar6 = (long)iVar5;
iVar5 = iVar5 + 1;
piVar2 = (int *)(param_1 + lVar6 * 4);
iVar3 = *piVar2;
*piVar2 = 0;
*piVar1 = iVar3;
LAB_0010144a:
iVar4 = iVar4 + 1;
if (param_2 < iVar4) {
return;
}
}
if (iVar3 == 1) goto LAB_0010144a;
lVar6 = (long)param_2;
param_2 = param_2 + -1;
piVar2 = (int *)(param_1 + lVar6 * 4);
*piVar1 = *piVar2;
*piVar2 = iVar3;
} while (iVar4 <= param_2);
}
return;
} |
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] == 1) {
mid++;
} else {
int temp = arr[mid];
arr[mid] = arr[high];
arr[high] = temp;
high--;
}
}
}
| 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, 1, 1, 2, 2, 2};
for (int i = 0; i < 10; i++)
assert(arr2[i] == expected_arr2[i]);
int arr3[10] = {2,2,1,0,0,0,1,1,2,1};
func0(arr3, 10);
int expected_arr3[10] = {0, 0, 0, 1, 1, 1, 1, 2, 2, 2};
for (int i = 0; i < 10; i++)
assert(arr3[i] == expected_arr3[i]);
return 0;
}
| 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 (%rdi,%rdx,4),%rcx
mov (%rcx),%edx
test %edx,%edx
je 14f0 <func0+0x10>
cmp $0x1,%edx
je 1540 <func0+0x60>
movslq %esi,%r9
sub $0x1,%esi
lea (%rdi,%r9,4),%r9
mov (%r9),%r10d
mov %r10d,(%rcx)
mov %edx,(%r9)
cmp %eax,%esi
jge 150e <func0+0x2e>
retq
nopl 0x0(%rax,%rax,1)
add $0x1,%eax
jmp 150a <func0+0x2a>
nopw %cs:0x0(%rax,%rax,1)
| 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_13DE:
movsxd rdx, eax
lea rcx, [rdi+rdx*4]
mov edx, [rcx]
test edx, edx
jz short loc_13C0
cmp edx, 1
jz short loc_1410
movsxd r9, esi
sub esi, 1
lea r9, [rdi+r9*4]
mov r10d, [r9]
mov [rcx], r10d
mov [r9], edx
cmp esi, eax
jge short loc_13DE
locret_1407:
retn
loc_1410:
add eax, 1
jmp short loc_13DA | 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 )
{
v8 = (int *)(a1 + 4LL * v3);
v9 = *v8;
if ( *v8 )
break;
v5 = v4;
++v3;
++v4;
v6 = (int *)(a1 + 4 * v5);
v7 = *v6;
*v6 = 0;
*v8 = v7;
LABEL_4:
if ( v2 < v3 )
return;
}
if ( v9 == 1 )
{
++v3;
goto LABEL_4;
}
v10 = v2--;
v11 = (int *)(a1 + 4 * v10);
*v8 = *v11;
*v11 = v9;
}
while ( v2 >= v3 );
}
} | 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]
MOV EDX,dword ptr [RCX]
TEST EDX,EDX
JZ 0x001013c0
CMP EDX,0x1
JZ 0x00101410
MOVSXD R9,ESI
SUB ESI,0x1
LEA R9,[RDI + R9*0x4]
MOV R10D,dword ptr [R9]
MOV dword ptr [RCX],R10D
MOV dword ptr [R9],EDX
CMP ESI,EAX
JGE 0x001013de
LAB_00101407:
RET
LAB_00101410:
ADD EAX,0x1
JMP 0x001013da | 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;
if (iVar3 != 0) break;
lVar6 = (long)iVar5;
iVar5 = iVar5 + 1;
piVar2 = (int *)(param_1 + lVar6 * 4);
iVar3 = *piVar2;
*piVar2 = 0;
*piVar1 = iVar3;
LAB_001013da:
iVar4 = iVar4 + 1;
if (param_2 < iVar4) {
return;
}
}
if (iVar3 == 1) goto LAB_001013da;
lVar6 = (long)param_2;
param_2 = param_2 + -1;
piVar2 = (int *)(param_1 + lVar6 * 4);
*piVar1 = *piVar2;
*piVar2 = iVar3;
} while (iVar4 <= param_2);
}
return;
} |
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);
return 0;
}
| 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);
return 0;
}
| 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);
return 0;
}
| 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);
return 0;
}
| 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;
return result;
}
| 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, result_size2, result_size3;
int* result1 = func0(nums1, 10, 19, 13, &result_size1);
int* result2 = func0(nums2, 7, 2, 5, &result_size2);
int* result3 = func0(nums3, 7, 10, 5, &result_size3);
assert(result_size1 == 6);
for (int i = 0; i < result_size1; i++) {
assert(result1[i] == expected1[i]);
}
assert(result_size2 == 4);
for (int i = 0; i < result_size2; i++) {
assert(result2[i] == expected2[i]);
}
assert(result_size3 == 3);
for (int i = 0; i < result_size3; i++) {
assert(result3[i] == expected3[i]);
}
free(result1);
free(result2);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %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 $0x0,-0xc(%rbp)
jmp 1262 <func0+0xb9>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltd
idivl -0x20(%rbp)
mov %edx,%eax
test %eax,%eax
je 122b <func0+0x82>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltd
idivl -0x24(%rbp)
mov %edx,%eax
test %eax,%eax
jne 125e <func0+0xb5>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11eb <func0+0x42>
mov -0x30(%rbp),%rax
mov -0x10(%rbp),%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_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], 0
mov [rbp+var_C], 0
jmp short loc_1262
loc_11EB:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cdq
idiv [rbp+var_20]
mov eax, edx
test eax, eax
jz short loc_122B
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cdq
idiv [rbp+var_24]
mov eax, edx
test eax, eax
jnz short loc_125E
loc_122B:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_125E:
add [rbp+var_C], 1
loc_1262:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_11EB
mov rax, [rbp+var_30]
mov edx, [rbp+var_10]
mov [rax], edx
mov rax, [rbp+var_8]
leave
retn | _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 * i + a1) % a4) )
{
v5 = v10++;
v12[v5] = *(_DWORD *)(4LL * i + a1);
}
}
*a5 = v10;
return v12;
} | 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 dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101262
LAB_001011eb:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQ
IDIV dword ptr [RBP + -0x20]
MOV EAX,EDX
TEST EAX,EAX
JZ 0x0010122b
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQ
IDIV dword ptr [RBP + -0x24]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x0010125e
LAB_0010122b:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_0010125e:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101262:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011eb
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x10]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | 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) ||
(*(int *)(param_1 + (long)local_14 * 4) % param_4 == 0)) {
*(int4 *)((long)local_18 * 4 + (long)pvVar1) =
*(int4 *)((long)local_14 * 4 + param_1);
local_18 = local_18 + 1;
}
}
*param_5 = local_18;
return pvVar1;
} |
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;
return result;
}
| 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, result_size2, result_size3;
int* result1 = func0(nums1, 10, 19, 13, &result_size1);
int* result2 = func0(nums2, 7, 2, 5, &result_size2);
int* result3 = func0(nums3, 7, 10, 5, &result_size3);
assert(result_size1 == 6);
for (int i = 0; i < result_size1; i++) {
assert(result1[i] == expected1[i]);
}
assert(result_size2 == 4);
for (int i = 0; i < result_size2; i++) {
assert(result2[i] == expected2[i]);
}
assert(result_size3 == 3);
for (int i = 0; i < result_size3; i++) {
assert(result3[i] == expected3[i]);
}
free(result1);
free(result2);
free(result3);
return 0;
}
| 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
lea 0x4(%r14,%rax,4),%r9
mov $0x0,%edi
jmp 11fc <func0+0x53>
movslq %edi,%rax
mov %ecx,(%r8,%rax,4)
lea 0x1(%rdi),%edi
add $0x4,%rsi
cmp %r9,%rsi
je 1217 <func0+0x6e>
mov (%rsi),%ecx
mov %ecx,%eax
cltd
idiv %ebx
test %edx,%edx
je 11e9 <func0+0x40>
mov %ecx,%eax
cltd
idiv %ebp
test %edx,%edx
jne 11f3 <func0+0x4a>
jmp 11e9 <func0+0x40>
mov $0x0,%edi
mov %edi,(%r12)
mov %r8,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
| 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+rax*4+4]
mov edi, 0
jmp short loc_11FC
loc_11E9:
movsxd rax, edi
mov [r8+rax*4], ecx
lea edi, [rdi+1]
loc_11F3:
add rsi, 4
cmp rsi, r9
jz short loc_1217
loc_11FC:
mov ecx, [rsi]
mov eax, ecx
cdq
idiv ebx
test edx, edx
jz short loc_11E9
mov eax, ecx
cdq
idiv ebp
test edx, edx
jnz short loc_11F3
jmp short loc_11E9
loc_1212:
mov edi, 0
loc_1217:
mov [r12], edi
mov rax, r8
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | 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
{
v13 = *v10;
if ( !(*v10 % a3) || !(v13 % a4) )
*(_DWORD *)(v9 + 4LL * v12++) = v13;
++v10;
}
while ( v10 != (int *)v11 );
}
*a5 = v12;
return v9;
} | 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,EDI
MOV dword ptr [R8 + RAX*0x4],ECX
LEA EDI,[RDI + 0x1]
LAB_001011f3:
ADD RSI,0x4
CMP RSI,R9
JZ 0x00101217
LAB_001011fc:
MOV ECX,dword ptr [RSI]
MOV EAX,ECX
CDQ
IDIV EBX
TEST EDX,EDX
JZ 0x001011e9
MOV EAX,ECX
CDQ
IDIV EBP
TEST EDX,EDX
JNZ 0x001011f3
JMP 0x001011e9
LAB_00101212:
MOV EDI,0x0
LAB_00101217:
MOV dword ptr [R12],EDI
MOV RAX,R8
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | 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_1;
if ((iVar2 % param_3 == 0) || (iVar2 % param_4 == 0)) {
*(int *)((long)pvVar3 + (long)iVar4 * 4) = iVar2;
iVar4 = iVar4 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
*param_5 = iVar4;
return pvVar3;
} |
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;
return result;
}
| 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, result_size2, result_size3;
int* result1 = func0(nums1, 10, 19, 13, &result_size1);
int* result2 = func0(nums2, 7, 2, 5, &result_size2);
int* result3 = func0(nums3, 7, 10, 5, &result_size3);
assert(result_size1 == 6);
for (int i = 0; i < result_size1; i++) {
assert(result1[i] == expected1[i]);
}
assert(result_size2 == 4);
for (int i = 0; i < result_size2; i++) {
assert(result2[i] == expected2[i]);
}
assert(result_size3 == 3);
for (int i = 0; i < result_size3; i++) {
assert(result3[i] == expected3[i]);
}
free(result1);
free(result2);
free(result3);
return 0;
}
| 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
xor %r9d,%r9d
lea 0x4(%r14,%rax,4),%rcx
nopl 0x0(%rax)
mov (%rdi),%esi
mov %esi,%eax
cltd
idiv %ebx
test %edx,%edx
je 1504 <func0+0x54>
mov %esi,%eax
cltd
idiv %ebp
test %edx,%edx
jne 150f <func0+0x5f>
movslq %r9d,%rax
add $0x1,%r9d
mov %esi,(%r10,%rax,4)
add $0x4,%rdi
cmp %rcx,%rdi
jne 14f0 <func0+0x40>
pop %rbx
mov %r10,%rax
pop %rbp
mov %r9d,(%r12)
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
xor %r9d,%r9d
pop %rbx
mov %r10,%rax
pop %rbp
mov %r9d,(%r12)
pop %r12
pop %r13
pop %r14
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| 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
lea r10, [r14+rax*4+4]
nop dword ptr [rax+rax+00h]
loc_14F0:
mov ecx, [rsi]
mov eax, ecx
cdq
idiv ebx
test edx, edx
jz short loc_1504
mov eax, ecx
cdq
idiv ebp
test edx, edx
jnz short loc_150E
loc_1504:
movsxd rax, edi
add edi, 1
mov [r9+rax*4], ecx
loc_150E:
add rsi, 4
cmp rsi, r10
jnz short loc_14F0
pop rbx
mov rax, r9
pop rbp
mov [r12], edi
pop r12
pop r13
pop r14
retn
loc_1530:
xor edi, edi
pop rbx
mov rax, r9
pop rbp
mov [r12], edi
pop r12
pop r13
pop r14
retn | 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;
do
{
v14 = *v12;
if ( !(*v12 % a3) || !(v14 % a4) )
{
v15 = v13++;
*(_DWORD *)(v11 + 4 * v15) = v14;
}
++v12;
}
while ( v12 != &a1[a2 - 1 + 1] );
result = v11;
*a5 = v13;
}
return result;
} | 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:
MOV ECX,dword ptr [RSI]
MOV EAX,ECX
CDQ
IDIV EBX
TEST EDX,EDX
JZ 0x00101504
MOV EAX,ECX
CDQ
IDIV EBP
TEST EDX,EDX
JNZ 0x0010150e
LAB_00101504:
MOVSXD RAX,EDI
ADD EDI,0x1
MOV dword ptr [R9 + RAX*0x4],ECX
LAB_0010150e:
ADD RSI,0x4
CMP RSI,R10
JNZ 0x001014f0
POP RBX
MOV RAX,R9
POP RBP
MOV dword ptr [R12],EDI
POP R12
POP R13
POP R14
RET
LAB_00101530:
XOR EDI,EDI
POP RBX
MOV RAX,R9
POP RBP
MOV dword ptr [R12],EDI
POP R12
POP R13
POP R14
RET | 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 ((iVar2 % param_3 == 0) || (iVar2 % param_4 == 0)) {
lVar4 = (long)iVar5;
iVar5 = iVar5 + 1;
*(int *)((long)pvVar3 + lVar4 * 4) = iVar2;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
*param_5 = iVar5;
return pvVar3;
}
*param_5 = 0;
return pvVar3;
} |
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;
return result;
}
| 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, result_size2, result_size3;
int* result1 = func0(nums1, 10, 19, 13, &result_size1);
int* result2 = func0(nums2, 7, 2, 5, &result_size2);
int* result3 = func0(nums3, 7, 10, 5, &result_size3);
assert(result_size1 == 6);
for (int i = 0; i < result_size1; i++) {
assert(result1[i] == expected1[i]);
}
assert(result_size2 == 4);
for (int i = 0; i < result_size2; i++) {
assert(result2[i] == expected2[i]);
}
assert(result_size3 == 3);
for (int i = 0; i < result_size3; i++) {
assert(result3[i] == expected3[i]);
}
free(result1);
free(result2);
free(result3);
return 0;
}
| 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
xor %r9d,%r9d
lea 0x4(%r14,%rax,4),%rcx
nopl 0x0(%rax)
mov (%rdi),%esi
mov %esi,%eax
cltd
idiv %ebx
test %edx,%edx
je 14c4 <func0+0x54>
mov %esi,%eax
cltd
idiv %ebp
test %edx,%edx
jne 14cf <func0+0x5f>
movslq %r9d,%rax
add $0x1,%r9d
mov %esi,(%r10,%rax,4)
add $0x4,%rdi
cmp %rcx,%rdi
jne 14b0 <func0+0x40>
pop %rbx
mov %r10,%rax
pop %rbp
mov %r9d,(%r12)
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
xor %r9d,%r9d
pop %rbx
mov %r10,%rax
pop %rbp
mov %r9d,(%r12)
pop %r12
pop %r13
pop %r14
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| 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_14B8
mov rsi, rbx
lea r9, [rbx+r12]
xor edi, edi
nop dword ptr [rax+00h]
loc_1478:
mov ecx, [rsi]
mov eax, ecx
cdq
idiv ebp
test edx, edx
jz short loc_148D
mov eax, ecx
cdq
idiv r13d
test edx, edx
jnz short loc_1497
loc_148D:
movsxd rax, edi
add edi, 1
mov [r8+rax*4], ecx
loc_1497:
add rsi, 4
cmp r9, rsi
jnz short loc_1478
loc_14A0:
mov [r14], edi
add rsp, 8
mov rax, r8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_14B8:
xor edi, edi
jmp short loc_14A0 | _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 = *v11;
if ( !(*v11 % a3) || !(v13 % a4) )
{
v14 = v12++;
v10[v14] = v13;
}
++v11;
}
while ( &a1[v7] != v11 );
}
*a5 = v12;
return v10;
} | 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:
MOV ECX,dword ptr [RSI]
MOV EAX,ECX
CDQ
IDIV EBP
TEST EDX,EDX
JZ 0x0010148d
MOV EAX,ECX
CDQ
IDIV R13D
TEST EDX,EDX
JNZ 0x00101497
LAB_0010148d:
MOVSXD RAX,EDI
ADD EDI,0x1
MOV dword ptr [R8 + RAX*0x4],ECX
LAB_00101497:
ADD RSI,0x4
CMP R9,RSI
JNZ 0x00101478
LAB_001014a0:
MOV dword ptr [R14],EDI
ADD RSP,0x8
MOV RAX,R8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001014b8:
XOR EDI,EDI
JMP 0x001014a0 | 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;
if ((iVar2 % param_3 == 0) || (iVar2 % param_4 == 0)) {
lVar4 = (long)iVar5;
iVar5 = iVar5 + 1;
*(int *)((long)pvVar3 + lVar4 * 4) = iVar2;
}
param_1 = param_1 + 1;
} while (piVar1 != param_1);
}
*param_5 = iVar5;
return pvVar3;
} |
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 -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x7a,%al
jg 11b6 <func0+0x4d>
addl $0x1,-0x18(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
cmp %rax,%rbx
jb 118a <func0+0x21>
mov -0x18(%rbp),%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov [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 loc_11B6
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 7Ah ; 'z'
jg short loc_11B6
add [rbp+var_18], 1
loc_11B6:
add [rbp+var_14], 1
loc_11BA:
mov eax, [rbp+var_14]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_118A
mov eax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | 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 0x001011b6
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,0x7a
JG 0x001011b6
ADD dword ptr [RBP + -0x18],0x1
LAB_001011b6:
ADD dword ptr [RBP + -0x14],0x1
LAB_001011ba:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
CMP RBX,RAX
JC 0x0010118a
MOV EAX,dword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | 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 = local_1c + 1;
}
return local_20;
} |
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 116e <func0+0x25>
mov %ecx,%eax
retq
| 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, ecx
pop rbx
retn | 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 %rbx
retq
nopw 0x0(%rax,%rax,1)
| 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(%rip),%xmm6
pxor %xmm4,%xmm4
pxor %xmm3,%xmm3
movdqa 0xe5b(%rip),%xmm5
add %rbx,%rax
nopl 0x0(%rax,%rax,1)
movdqu (%rdx),%xmm0
movdqa %xmm4,%xmm8
add $0x10,%rdx
paddb %xmm7,%xmm0
psubusb %xmm6,%xmm0
pcmpeqb %xmm4,%xmm0
pand %xmm5,%xmm0
pcmpgtb %xmm0,%xmm8
movdqa %xmm0,%xmm2
punpcklbw %xmm8,%xmm2
punpckhbw %xmm8,%xmm0
movdqa %xmm3,%xmm8
pcmpgtw %xmm2,%xmm8
movdqa %xmm2,%xmm9
punpcklwd %xmm8,%xmm9
punpckhwd %xmm8,%xmm2
movdqa %xmm0,%xmm8
paddd %xmm9,%xmm1
paddd %xmm2,%xmm1
movdqa %xmm3,%xmm2
pcmpgtw %xmm0,%xmm2
punpcklwd %xmm2,%xmm8
punpckhwd %xmm2,%xmm0
paddd %xmm8,%xmm1
paddd %xmm0,%xmm1
cmp %rax,%rdx
jne 1270 <func0+0x60>
movdqa %xmm1,%xmm0
mov %rcx,%rsi
psrldq $0x8,%xmm0
and $0xfffffffffffffff0,%rsi
paddd %xmm1,%xmm0
mov %esi,%edx
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
cmp %rsi,%rcx
je 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0x1(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0x2(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0x3(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0x4(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0x5(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0x6(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0x7(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0x8(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0x9(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0xa(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0xb(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0xc(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
lea 0xd(%rdx),%esi
movslq %esi,%rsi
adc $0x0,%eax
cmp %rsi,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rsi,1),%esi
sub $0x61,%esi
cmp $0x1a,%sil
adc $0x0,%eax
add $0xe,%edx
movslq %edx,%rdx
cmp %rdx,%rcx
jbe 14a5 <func0+0x295>
movzbl (%rbx,%rdx,1),%edx
sub $0x61,%edx
cmp $0x1a,%dl
adc $0x0,%eax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
pop %rbx
retq
xor %edx,%edx
xor %eax,%eax
xor %esi,%esi
jmpq 1316 <func0+0x106>
| 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:xmmword_2090
pxor xmm4, xmm4
lea rsi, [rcx+rbx]
nop dword ptr [rax+00000000h]
loc_1268:
movdqu xmm2, xmmword ptr [rax]
movdqa xmm0, xmm5
movdqa xmm7, xmm3
add rax, 10h
paddb xmm2, xmm6
psubusb xmm0, xmm2
pcmpeqb xmm0, xmm3
pcmpeqb xmm0, xmm3
pcmpgtb xmm7, xmm0
movdqa xmm2, xmm0
punpcklbw xmm2, xmm7
punpckhbw xmm0, xmm7
movdqa xmm7, xmm4
pcmpgtw xmm7, xmm2
movdqa xmm8, xmm2
punpcklwd xmm8, xmm7
punpckhwd xmm2, xmm7
movdqa xmm7, xmm0
psubd xmm1, xmm8
psubd xmm1, xmm2
movdqa xmm2, xmm4
pcmpgtw xmm2, xmm0
punpcklwd xmm7, xmm2
punpckhwd xmm0, xmm2
psubd xmm1, xmm7
psubd xmm1, xmm0
cmp rsi, rax
jnz short loc_1268
movdqa xmm0, xmm1
mov esi, ecx
psrldq xmm0, 8
paddd xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
paddd xmm0, xmm2
movd eax, xmm0
movdqa xmm0, xmm1
psrldq xmm1, 8
paddd xmm1, xmm0
cmp rdx, rcx
jz loc_1466
loc_130E:
mov rdi, rdx
sub rdi, rcx
lea r8, [rdi-1]
cmp r8, 6
jbe loc_13C5
movq xmm2, qword ptr cs:xmmword_2080
movq xmm0, qword ptr [rbx+rcx]
paddb xmm0, xmm2
movq xmm2, cs:qword_20A0
pminub xmm2, xmm0
pcmpeqb xmm0, xmm2
pxor xmm2, xmm2
pcmpgtb xmm2, xmm0
movdqa xmm3, xmm0
punpcklbw xmm3, xmm2
punpcklbw xmm0, xmm2
pxor xmm2, xmm2
movdqa xmm4, xmm2
movdqa xmm5, xmm3
pshufd xmm0, xmm0, 4Eh ; 'N'
pcmpgtw xmm4, xmm3
pcmpgtw xmm2, xmm0
punpcklwd xmm5, xmm4
punpcklwd xmm3, xmm4
psubd xmm1, xmm5
pshufd xmm3, xmm3, 4Eh ; 'N'
psubd xmm1, xmm3
movdqa xmm3, xmm0
punpcklwd xmm0, xmm2
punpcklwd xmm3, xmm2
pshufd xmm0, xmm0, 4Eh ; 'N'
psubd xmm1, xmm3
psubd xmm1, xmm0
movd r8d, xmm1
pshufd xmm6, xmm1, 0E5h
movd eax, xmm6
add eax, r8d
mov r8, rdi
and r8, 0FFFFFFFFFFFFFFF8h
add rcx, r8
add esi, r8d
and edi, 7
jz loc_1466
loc_13C5:
movzx ecx, byte ptr [rbx+rcx]
sub ecx, 61h ; 'a'
cmp cl, 1Ah
lea ecx, [rsi+1]
movsxd rcx, ecx
adc eax, 0
cmp rcx, rdx
jnb loc_1466
movzx ecx, byte ptr [rbx+rcx]
sub ecx, 61h ; 'a'
cmp cl, 1Ah
lea ecx, [rsi+2]
movsxd rcx, ecx
adc eax, 0
cmp rcx, rdx
jnb short loc_1466
movzx ecx, byte ptr [rbx+rcx]
sub ecx, 61h ; 'a'
cmp cl, 1Ah
lea ecx, [rsi+3]
movsxd rcx, ecx
adc eax, 0
cmp rcx, rdx
jnb short loc_1466
movzx ecx, byte ptr [rbx+rcx]
sub ecx, 61h ; 'a'
cmp cl, 1Ah
lea ecx, [rsi+4]
movsxd rcx, ecx
adc eax, 0
cmp rcx, rdx
jnb short loc_1466
movzx ecx, byte ptr [rbx+rcx]
sub ecx, 61h ; 'a'
cmp cl, 1Ah
lea ecx, [rsi+5]
movsxd rcx, ecx
adc eax, 0
cmp rcx, rdx
jnb short loc_1466
movzx ecx, byte ptr [rbx+rcx]
sub ecx, 61h ; 'a'
cmp cl, 1Ah
adc eax, 0
add esi, 6
movsxd rsi, esi
cmp rsi, rdx
jnb short loc_1466
movzx edx, byte ptr [rbx+rsi]
sub edx, 61h ; 'a'
cmp dl, 1Ah
adc eax, 0
loc_1466:
pop rbx
retn
loc_1470:
xor eax, eax
pop rbx
retn
loc_1474:
pxor xmm1, xmm1
xor esi, esi
xor eax, eax
xor ecx, ecx
jmp loc_130E | 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
__m128i v14; // xmm7
__m128i v15; // xmm1
__m128i v16; // xmm2
int v17; // esi
__m128i v18; // xmm0
long long result; // rax
__m128i v20; // xmm1
size_t v21; // rdi
__m128i v22; // xmm0
__m128i v23; // xmm0
__m128i v24; // xmm3
__m128i v25; // xmm0
__m128i v26; // xmm2
__m128i v27; // xmm3
__m128i v28; // xmm1
bool v29; // cf
size_t v30; // rcx
size_t v31; // rcx
size_t v32; // rcx
size_t v33; // rcx
size_t v34; // rcx
size_t v35; // rsi
v2 = strlen(a1);
if ( !v2 )
return 0LL;
v3 = v2;
if ( v2 - 1 <= 0xE )
{
v20 = 0LL;
v17 = 0;
LODWORD(result) = 0;
v6 = 0LL;
}
else
{
v4 = 0LL;
v5 = (const __m128i *)a1;
v6 = v3 & 0xFFFFFFFFFFFFFFF0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_2080);
v8 = _mm_load_si128((const __m128i *)&xmmword_2090);
do
{
v9 = _mm_loadu_si128(v5++);
v10 = _mm_cmpeq_epi8(_mm_cmpeq_epi8(_mm_subs_epu8(v8, _mm_add_epi8(v9, si128)), (__m128i)0LL), (__m128i)0LL);
v11 = _mm_cmpgt_epi8((__m128i)0LL, v10);
v12 = _mm_unpacklo_epi8(v10, v11);
v13 = _mm_unpackhi_epi8(v10, v11);
v14 = _mm_cmpgt_epi16((__m128i)0LL, v12);
v15 = _mm_sub_epi32(_mm_sub_epi32(v4, _mm_unpacklo_epi16(v12, v14)), _mm_unpackhi_epi16(v12, v14));
v16 = _mm_cmpgt_epi16((__m128i)0LL, v13);
v4 = _mm_sub_epi32(_mm_sub_epi32(v15, _mm_unpacklo_epi16(v13, v16)), _mm_unpackhi_epi16(v13, v16));
}
while ( &a1[v3 & 0xFFFFFFFFFFFFFFF0LL] != (const char *)v5 );
v17 = v3 & 0xFFFFFFF0;
v18 = _mm_add_epi32(_mm_srli_si128(v4, 8), v4);
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v18, _mm_srli_si128(v18, 4)));
v20 = v18;
if ( v3 == v6 )
return result;
}
v21 = v3 - v6;
if ( v3 - v6 - 1 <= 6 )
goto LABEL_8;
v22 = _mm_add_epi8(_mm_loadl_epi64((const __m128i *)&a1[v6]), _mm_loadl_epi64((const __m128i *)&xmmword_2080));
v23 = _mm_cmpeq_epi8(v22, _mm_min_epu8(_mm_loadl_epi64((const __m128i *)&qword_20A0), v22));
v24 = _mm_unpacklo_epi8(v23, _mm_cmpgt_epi8((__m128i)0LL, v23));
v25 = _mm_shuffle_epi32(v24, 78);
v26 = _mm_cmpgt_epi16((__m128i)0LL, v25);
v27 = _mm_unpacklo_epi16(v24, _mm_cmpgt_epi16((__m128i)0LL, v24));
v28 = _mm_sub_epi32(
_mm_sub_epi32(
_mm_sub_epi32(_mm_sub_epi32(v20, v27), _mm_shuffle_epi32(v27, 78)),
_mm_unpacklo_epi16(v25, v26)),
_mm_shuffle_epi32(_mm_unpacklo_epi16(v25, v26), 78));
result = (unsigned int)(_mm_cvtsi128_si32(v28) + _mm_cvtsi128_si32(_mm_shuffle_epi32(v28, 229)));
v6 += v21 & 0xFFFFFFFFFFFFFFF8LL;
v17 += v21 & 0xFFFFFFF8;
if ( (v21 & 7) != 0 )
{
LABEL_8:
v29 = (unsigned __int8)(a1[v6] - 97) < 0x1Au;
v30 = v17 + 1;
result = v29 + (unsigned int)result;
if ( v30 < v3 )
{
v29 = (unsigned __int8)(a1[v30] - 97) < 0x1Au;
v31 = v17 + 2;
result = v29 + (unsigned int)result;
if ( v31 < v3 )
{
v29 = (unsigned __int8)(a1[v31] - 97) < 0x1Au;
v32 = v17 + 3;
result = v29 + (unsigned int)result;
if ( v32 < v3 )
{
v29 = (unsigned __int8)(a1[v32] - 97) < 0x1Au;
v33 = v17 + 4;
result = v29 + (unsigned int)result;
if ( v33 < v3 )
{
v29 = (unsigned __int8)(a1[v33] - 97) < 0x1Au;
v34 = v17 + 5;
result = v29 + (unsigned int)result;
if ( v34 < v3 )
{
result = ((unsigned __int8)(a1[v34] - 97) < 0x1Au) + (unsigned int)result;
v35 = v17 + 6;
if ( v35 < v3 )
return ((unsigned __int8)(a1[v35] - 97) < 0x1Au) + (unsigned int)result;
}
}
}
}
}
}
return result;
} | 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]
NOP dword ptr [RAX]
LAB_00101268:
MOVDQU XMM2,xmmword ptr [RAX]
MOVDQA XMM0,XMM5
MOVDQA XMM7,XMM3
ADD RAX,0x10
PADDB XMM2,XMM6
PSUBUSB XMM0,XMM2
PCMPEQB XMM0,XMM3
PCMPEQB XMM0,XMM3
PCMPGTB XMM7,XMM0
MOVDQA XMM2,XMM0
PUNPCKLBW XMM2,XMM7
PUNPCKHBW XMM0,XMM7
MOVDQA XMM7,XMM4
PCMPGTW XMM7,XMM2
MOVDQA XMM8,XMM2
PUNPCKLWD XMM8,XMM7
PUNPCKHWD XMM2,XMM7
MOVDQA XMM7,XMM0
PSUBD XMM1,XMM8
PSUBD XMM1,XMM2
MOVDQA XMM2,XMM4
PCMPGTW XMM2,XMM0
PUNPCKLWD XMM7,XMM2
PUNPCKHWD XMM0,XMM2
PSUBD XMM1,XMM7
PSUBD XMM1,XMM0
CMP RSI,RAX
JNZ 0x00101268
MOVDQA XMM0,XMM1
MOV ESI,ECX
PSRLDQ XMM0,0x8
PADDD XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
PADDD XMM0,XMM2
MOVD EAX,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM1,0x8
PADDD XMM1,XMM0
CMP RDX,RCX
JZ 0x00101466
LAB_0010130e:
MOV RDI,RDX
SUB RDI,RCX
LEA R8,[RDI + -0x1]
CMP R8,0x6
JBE 0x001013c5
MOVQ XMM2,qword ptr [0x00102080]
MOVQ XMM0,qword ptr [RBX + RCX*0x1]
PADDB XMM0,XMM2
MOVQ XMM2,qword ptr [0x001020a0]
PMINUB XMM2,XMM0
PCMPEQB XMM0,XMM2
PXOR XMM2,XMM2
PCMPGTB XMM2,XMM0
MOVDQA XMM3,XMM0
PUNPCKLBW XMM3,XMM2
PUNPCKLBW XMM0,XMM2
PXOR XMM2,XMM2
MOVDQA XMM4,XMM2
MOVDQA XMM5,XMM3
PSHUFD XMM0,XMM0,0x4e
PCMPGTW XMM4,XMM3
PCMPGTW XMM2,XMM0
PUNPCKLWD XMM5,XMM4
PUNPCKLWD XMM3,XMM4
PSUBD XMM1,XMM5
PSHUFD XMM3,XMM3,0x4e
PSUBD XMM1,XMM3
MOVDQA XMM3,XMM0
PUNPCKLWD XMM0,XMM2
PUNPCKLWD XMM3,XMM2
PSHUFD XMM0,XMM0,0x4e
PSUBD XMM1,XMM3
PSUBD XMM1,XMM0
MOVD R8D,XMM1
PSHUFD XMM6,XMM1,0xe5
MOVD EAX,XMM6
ADD EAX,R8D
MOV R8,RDI
AND R8,-0x8
ADD RCX,R8
ADD ESI,R8D
AND EDI,0x7
JZ 0x00101466
LAB_001013c5:
MOVZX ECX,byte ptr [RBX + RCX*0x1]
SUB ECX,0x61
CMP CL,0x1a
LEA ECX,[RSI + 0x1]
MOVSXD RCX,ECX
ADC EAX,0x0
CMP RCX,RDX
JNC 0x00101466
MOVZX ECX,byte ptr [RBX + RCX*0x1]
SUB ECX,0x61
CMP CL,0x1a
LEA ECX,[RSI + 0x2]
MOVSXD RCX,ECX
ADC EAX,0x0
CMP RCX,RDX
JNC 0x00101466
MOVZX ECX,byte ptr [RBX + RCX*0x1]
SUB ECX,0x61
CMP CL,0x1a
LEA ECX,[RSI + 0x3]
MOVSXD RCX,ECX
ADC EAX,0x0
CMP RCX,RDX
JNC 0x00101466
MOVZX ECX,byte ptr [RBX + RCX*0x1]
SUB ECX,0x61
CMP CL,0x1a
LEA ECX,[RSI + 0x4]
MOVSXD RCX,ECX
ADC EAX,0x0
CMP RCX,RDX
JNC 0x00101466
MOVZX ECX,byte ptr [RBX + RCX*0x1]
SUB ECX,0x61
CMP CL,0x1a
LEA ECX,[RSI + 0x5]
MOVSXD RCX,ECX
ADC EAX,0x0
CMP RCX,RDX
JNC 0x00101466
MOVZX ECX,byte ptr [RBX + RCX*0x1]
SUB ECX,0x61
CMP CL,0x1a
ADC EAX,0x0
ADD ESI,0x6
MOVSXD RSI,ESI
CMP RSI,RDX
JNC 0x00101466
MOVZX EDX,byte ptr [RBX + RSI*0x1]
SUB EDX,0x61
CMP DL,0x1a
ADC EAX,0x0
LAB_00101466:
POP RBX
RET
LAB_00101470:
XOR EAX,EAX
POP RBX
RET
LAB_00101474:
PXOR XMM1,XMM1
XOR ESI,ESI
XOR EAX,EAX
XOR ECX,ECX
JMP 0x0010130e | /* 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;
bool bVar15;
bool bVar16;
char *pcVar17;
char *pcVar18;
char *pcVar19;
char *pcVar20;
char *pcVar21;
char *pcVar22;
char *pcVar23;
char *pcVar24;
char *pcVar25;
char *pcVar26;
char *pcVar27;
char *pcVar28;
char *pcVar29;
char *pcVar30;
char *pcVar31;
int auVar32 [14];
int auVar33 [12];
unkbyte10 Var34;
int auVar35 [12];
int auVar36 [14];
int auVar37 [12];
int auVar38 [16];
int auVar39 [16];
int auVar40 [16];
int auVar41 [12];
unkbyte9 Var42;
int6 uVar43;
int4 uVar44;
int2 uVar45;
size_t sVar46;
char *pcVar47;
ulong uVar48;
uint uVar49;
ulong uVar50;
byte bVar51;
short sVar52;
int4 uVar53;
int iVar54;
byte bVar77;
byte bVar79;
byte bVar83;
byte bVar88;
int auVar57 [11];
int auVar59 [12];
int auVar61 [12];
byte bVar78;
byte bVar80;
short sVar82;
byte bVar85;
char cVar87;
int auVar65 [16];
int auVar67 [16];
int auVar74 [16];
int iVar90;
int iVar91;
int iVar92;
int iVar93;
int iVar94;
char cVar99;
char cVar100;
char cVar101;
char cVar102;
char cVar103;
char cVar104;
short sVar105;
short sVar106;
int auVar96 [16];
int auVar97 [16];
int auVar107 [16];
int auVar114 [16];
int auVar117 [16];
int auVar121 [16];
int auVar124 [16];
int auVar129 [16];
int6 uVar55;
int8 uVar56;
int auVar68 [16];
int auVar58 [12];
int auVar69 [16];
int auVar75 [16];
int auVar60 [12];
int auVar70 [16];
int auVar63 [14];
int auVar66 [16];
int auVar62 [13];
int auVar71 [16];
int auVar76 [16];
int auVar64 [14];
int auVar72 [16];
int auVar73 [16];
char cVar81;
char cVar84;
char cVar86;
long lVar89;
int auVar95 [12];
int auVar98 [16];
int auVar118 [16];
int auVar108 [16];
int auVar109 [16];
int auVar115 [16];
int auVar119 [16];
int auVar110 [16];
int auVar111 [16];
int auVar116 [16];
int auVar120 [16];
int auVar112 [16];
int auVar113 [16];
int auVar122 [16];
int auVar123 [16];
int auVar125 [16];
int auVar126 [16];
int auVar127 [16];
int auVar128 [16];
int auVar130 [16];
int auVar131 [16];
sVar46 = strlen(param_1);
if (sVar46 == 0) {
return 0;
}
if (sVar46 - 1 < 0xf) {
iVar92 = 0;
iVar93 = 0;
uVar49 = 0;
iVar54 = 0;
uVar48 = 0;
}
else {
iVar90 = 0;
iVar91 = 0;
iVar92 = 0;
iVar93 = 0;
uVar48 = sVar46 & 0xfffffffffffffff0;
pcVar47 = param_1;
do {
cVar87 = *pcVar47;
pcVar17 = pcVar47 + 1;
pcVar18 = pcVar47 + 2;
pcVar19 = pcVar47 + 3;
pcVar20 = pcVar47 + 4;
pcVar21 = pcVar47 + 5;
pcVar22 = pcVar47 + 6;
pcVar23 = pcVar47 + 7;
pcVar24 = pcVar47 + 8;
pcVar25 = pcVar47 + 9;
pcVar26 = pcVar47 + 10;
pcVar27 = pcVar47 + 0xb;
pcVar28 = pcVar47 + 0xc;
pcVar29 = pcVar47 + 0xd;
pcVar30 = pcVar47 + 0xe;
pcVar31 = pcVar47 + 0xf;
pcVar47 = pcVar47 + 0x10;
auVar96[0] = cVar87 + (char)DAT_00102080;
auVar96[1] = *pcVar17 + DAT_00102080._1_1_;
auVar96[2] = *pcVar18 + DAT_00102080._2_1_;
auVar96[3] = *pcVar19 + DAT_00102080._3_1_;
auVar96[4] = *pcVar20 + DAT_00102080._4_1_;
auVar96[5] = *pcVar21 + DAT_00102080._5_1_;
auVar96[6] = *pcVar22 + DAT_00102080._6_1_;
auVar96[7] = *pcVar23 + DAT_00102080._7_1_;
auVar96[8] = *pcVar24 + UNK_00102088;
auVar96[9] = *pcVar25 + UNK_00102089;
auVar96[10] = *pcVar26 + UNK_0010208a;
auVar96[0xb] = *pcVar27 + UNK_0010208b;
auVar96[0xc] = *pcVar28 + UNK_0010208c;
auVar96[0xd] = *pcVar29 + UNK_0010208d;
auVar96[0xe] = *pcVar30 + UNK_0010208e;
auVar96[0xf] = *pcVar31 + UNK_0010208f;
auVar65 = psubusb(_DAT_00102090,auVar96);
bVar1 = auVar65[0] != '\0';
bVar2 = auVar65[1] != '\0';
bVar3 = auVar65[2] != '\0';
bVar4 = auVar65[3] != '\0';
bVar5 = auVar65[4] != '\0';
bVar6 = auVar65[5] != '\0';
bVar7 = auVar65[6] != '\0';
bVar8 = auVar65[7] != '\0';
bVar9 = auVar65[8] != '\0';
bVar10 = auVar65[9] != '\0';
bVar11 = auVar65[10] != '\0';
bVar12 = auVar65[0xb] != '\0';
bVar13 = auVar65[0xc] != '\0';
bVar14 = auVar65[0xd] != '\0';
bVar15 = auVar65[0xe] != '\0';
bVar16 = auVar65[0xf] != '\0';
cVar87 = -bVar8;
uVar45 = CONCAT11(-bVar8,cVar87);
uVar44 = CONCAT31(CONCAT21(uVar45,-bVar7),-bVar7);
uVar43 = CONCAT51(CONCAT41(uVar44,-bVar6),-bVar6);
Var42 = CONCAT72(CONCAT61(uVar43,-bVar5),CONCAT11(-bVar5,cVar87));
lVar89 = (long)((unkuint9)Var42 >> 8);
Var34 = CONCAT91(CONCAT81(lVar89,-bVar4),-bVar4);
auVar33._2_10_ = Var34;
auVar33[1] = -bVar3;
auVar33[0] = -bVar3;
auVar32._2_12_ = auVar33;
auVar32[1] = -bVar2;
auVar32[0] = -bVar2;
auVar97._0_2_ = CONCAT11(-bVar1,-bVar1);
auVar97._2_14_ = auVar32;
uVar53 = CONCAT13(-bVar10,CONCAT12(-bVar10,CONCAT11(-bVar9,-bVar9)));
uVar55 = CONCAT15(-bVar11,CONCAT14(-bVar11,uVar53));
uVar56 = CONCAT17(-bVar12,CONCAT16(-bVar12,uVar55));
auVar58._0_10_ = CONCAT19(-bVar13,CONCAT18(-bVar13,uVar56));
auVar58[10] = -bVar14;
auVar58[0xb] = -bVar14;
auVar63[0xc] = -bVar15;
auVar63._0_12_ = auVar58;
auVar63[0xd] = -bVar15;
auVar65[0xe] = -bVar16;
auVar65._0_14_ = auVar63;
auVar65[0xf] = -bVar16;
sVar52 = (short)Var34;
sVar82 = (short)((unkuint9)Var42 >> 8);
sVar105 = (short)uVar43;
sVar106 = (short)uVar44;
auVar131._0_12_ = auVar97._0_12_;
auVar131._12_2_ = sVar52;
auVar131._14_2_ = -(ushort)(sVar52 < 0);
auVar130._12_4_ = auVar131._12_4_;
auVar130._0_10_ = auVar97._0_10_;
auVar130._10_2_ = -(ushort)(auVar33._0_2_ < 0);
auVar129._10_6_ = auVar130._10_6_;
auVar129._0_8_ = auVar97._0_8_;
auVar129._8_2_ = auVar33._0_2_;
auVar35._4_8_ = auVar129._8_8_;
auVar35._2_2_ = -(ushort)(auVar32._0_2_ < 0);
auVar35._0_2_ = auVar32._0_2_;
iVar94 = CONCAT22(-(ushort)(sVar82 < 0),sVar82);
auVar95._0_8_ = CONCAT26(-(ushort)(sVar105 < 0),CONCAT24(sVar105,iVar94));
auVar95._8_2_ = sVar106;
auVar95._10_2_ = -(ushort)(sVar106 < 0);
auVar98._12_2_ = uVar45;
auVar98._0_12_ = auVar95;
auVar98._14_2_ = -(ushort)(lVar89 < 0);
sVar52 = (short)((unkuint10)auVar58._0_10_ >> 0x40);
auVar128._12_2_ = (short)((ulong)uVar56 >> 0x30);
auVar128._0_12_ = auVar58;
auVar128._14_2_ = -(ushort)bVar12;
auVar127._12_4_ = auVar128._12_4_;
auVar127._10_2_ = -(ushort)bVar11;
auVar127._0_10_ = auVar58._0_10_;
auVar126._10_6_ = auVar127._10_6_;
auVar126._8_2_ = (short)((uint6)uVar55 >> 0x20);
auVar126._0_8_ = uVar56;
auVar125._8_8_ = auVar126._8_8_;
auVar125._6_2_ = -(ushort)bVar10;
auVar125._0_6_ = uVar55;
auVar124._6_10_ = auVar125._6_10_;
auVar124._4_2_ = (short)((uint)uVar53 >> 0x10);
auVar124._0_4_ = uVar53;
iVar54 = CONCAT22(-(ushort)(sVar52 < 0),sVar52);
auVar59._0_8_ = CONCAT26(-(ushort)(auVar58._10_2_ < 0),CONCAT24(auVar58._10_2_,iVar54));
auVar59._8_2_ = auVar63._12_2_;
auVar59._10_2_ = -(ushort)(auVar63._12_2_ < 0);
auVar66._12_2_ = auVar65._14_2_;
auVar66._0_12_ = auVar59;
auVar66._14_2_ = -(ushort)(auVar65._14_2_ < 0);
iVar90 = (((iVar90 - CONCAT22(-(ushort)bVar1,auVar97._0_2_)) - iVar94) -
CONCAT22(-(ushort)bVar9,CONCAT11(-bVar9,-bVar9))) - iVar54;
iVar91 = (((iVar91 - auVar35._0_4_) - (int)((ulong)auVar95._0_8_ >> 0x20)) - auVar124._4_4_) -
(int)((ulong)auVar59._0_8_ >> 0x20);
iVar92 = (((iVar92 - auVar129._8_4_) - auVar95._8_4_) - auVar126._8_4_) - auVar59._8_4_;
iVar93 = (((iVar93 - auVar130._12_4_) - auVar98._12_4_) - auVar127._12_4_) - auVar66._12_4_;
} while (param_1 + uVar48 != pcVar47);
uVar49 = (uint)sVar46 & 0xfffffff0;
iVar54 = iVar92 + iVar90 + iVar93 + iVar91;
iVar92 = iVar92 + iVar90;
iVar93 = iVar93 + iVar91;
if (sVar46 == uVar48) {
return iVar54;
}
}
uVar50 = sVar46 - uVar48;
if (6 < uVar50 - 1) {
uVar56 = *(int8 *)(param_1 + uVar48);
bVar51 = (char)uVar56 + (char)DAT_00102080;
bVar77 = (char)((ulong)uVar56 >> 8) + DAT_00102080._1_1_;
bVar78 = (char)((ulong)uVar56 >> 0x10) + DAT_00102080._2_1_;
bVar79 = (char)((ulong)uVar56 >> 0x18) + DAT_00102080._3_1_;
bVar80 = (char)((ulong)uVar56 >> 0x20) + DAT_00102080._4_1_;
bVar83 = (char)((ulong)uVar56 >> 0x28) + DAT_00102080._5_1_;
bVar85 = (char)((ulong)uVar56 >> 0x30) + DAT_00102080._6_1_;
bVar88 = (char)((ulong)uVar56 >> 0x38) + DAT_00102080._7_1_;
bVar1 = bVar51 == (byte)((bVar51 < (byte)DAT_001020a0) * bVar51 |
(bVar51 >= (byte)DAT_001020a0) * (byte)DAT_001020a0);
auVar67[0] = -bVar1;
bVar2 = bVar77 == (byte)((bVar77 < DAT_001020a0._1_1_) * bVar77 |
(bVar77 >= DAT_001020a0._1_1_) * DAT_001020a0._1_1_);
cVar87 = -bVar2;
bVar3 = bVar78 == (byte)((bVar78 < DAT_001020a0._2_1_) * bVar78 |
(bVar78 >= DAT_001020a0._2_1_) * DAT_001020a0._2_1_);
bVar4 = bVar79 == (byte)((bVar79 < DAT_001020a0._3_1_) * bVar79 |
(bVar79 >= DAT_001020a0._3_1_) * DAT_001020a0._3_1_);
bVar5 = bVar80 == (byte)((bVar80 < DAT_001020a0._4_1_) * bVar80 |
(bVar80 >= DAT_001020a0._4_1_) * DAT_001020a0._4_1_);
cVar81 = -bVar5;
bVar6 = bVar83 == (byte)((bVar83 < DAT_001020a0._5_1_) * bVar83 |
(bVar83 >= DAT_001020a0._5_1_) * DAT_001020a0._5_1_);
cVar84 = -bVar6;
bVar7 = bVar85 == (byte)((bVar85 < DAT_001020a0._6_1_) * bVar85 |
(bVar85 >= DAT_001020a0._6_1_) * DAT_001020a0._6_1_);
cVar86 = -bVar7;
bVar8 = bVar88 == (byte)((bVar88 < DAT_001020a0._7_1_) * bVar88 |
(bVar88 >= DAT_001020a0._7_1_) * DAT_001020a0._7_1_);
bVar51 = -bVar8;
auVar68._0_9_ = CONCAT18(0xff,(ulong)bVar51 << 0x38);
auVar57._0_10_ = CONCAT19(0xff,auVar68._0_9_);
auVar57[10] = 0xff;
auVar60[0xb] = 0xff;
auVar60._0_11_ = auVar57;
auVar62[0xc] = 0xff;
auVar62._0_12_ = auVar60;
auVar64[0xd] = 0xff;
auVar64._0_13_ = auVar62;
cVar99 = -bVar2;
cVar100 = -bVar4;
cVar101 = -bVar5;
cVar102 = -bVar6;
cVar103 = -bVar7;
cVar104 = -bVar8;
auVar113[0xe] = bVar51;
auVar113._0_14_ = auVar64;
auVar113[0xf] = cVar104;
auVar112._14_2_ = auVar113._14_2_;
auVar112[0xd] = cVar103;
auVar112._0_13_ = auVar62;
auVar111._13_3_ = auVar112._13_3_;
auVar111[0xc] = cVar86;
auVar111._0_12_ = auVar60;
auVar110._12_4_ = auVar111._12_4_;
auVar110[0xb] = cVar102;
auVar110._0_11_ = auVar57;
auVar109._11_5_ = auVar110._11_5_;
auVar109[10] = cVar84;
auVar109._0_10_ = auVar57._0_10_;
auVar108._10_6_ = auVar109._10_6_;
auVar108[9] = cVar101;
auVar108._0_9_ = auVar68._0_9_;
Var34 = CONCAT91(CONCAT81((long)(CONCAT72(auVar108._9_7_,CONCAT11(cVar81,bVar51)) >> 8),cVar100)
,-bVar4);
auVar37._2_10_ = Var34;
auVar37[1] = -bVar3;
auVar37[0] = -bVar3;
auVar36._2_12_ = auVar37;
auVar36[1] = cVar99;
auVar36[0] = cVar87;
auVar107._0_2_ = CONCAT11(-bVar1,auVar67[0]);
auVar107._2_14_ = auVar36;
auVar73[0xe] = bVar51;
auVar73._0_14_ = auVar64;
auVar73[0xf] = cVar104;
auVar72._14_2_ = auVar73._14_2_;
auVar72[0xd] = cVar103;
auVar72._0_13_ = auVar62;
auVar71._13_3_ = auVar72._13_3_;
auVar71[0xc] = cVar86;
auVar71._0_12_ = auVar60;
auVar70._12_4_ = auVar71._12_4_;
auVar70[0xb] = cVar102;
auVar70._0_11_ = auVar57;
auVar69._11_5_ = auVar70._11_5_;
auVar69[10] = cVar84;
auVar69._0_10_ = auVar57._0_10_;
auVar68._10_6_ = auVar69._10_6_;
auVar68[9] = cVar101;
Var42 = CONCAT72(auVar68._9_7_,CONCAT11(cVar81,bVar51));
lVar89 = (long)((unkuint9)Var42 >> 8);
auVar40._1_8_ = lVar89;
auVar40[0] = cVar100;
auVar40._9_7_ = 0;
auVar39._10_6_ = 0;
auVar39._0_10_ = SUB1610(auVar40 << 0x38,6);
auVar38._11_5_ = 0;
auVar38._0_11_ = SUB1611(auVar39 << 0x30,5);
auVar67._4_12_ = SUB1612(auVar38 << 0x28,4);
auVar67[3] = cVar99;
auVar67[2] = cVar87;
auVar67[1] = -bVar1;
iVar54 = (int)((unkuint9)Var42 >> 8);
auVar61._8_4_ = auVar67._0_4_;
auVar61._0_8_ = lVar89;
sVar105 = auVar37._0_2_;
sVar106 = (short)Var34;
sVar52 = (short)((unkuint9)Var42 >> 8);
sVar82 = auVar71._12_2_;
auVar123._0_12_ = auVar107._0_12_;
auVar123._12_2_ = sVar106;
auVar123._14_2_ = -(ushort)(sVar106 < 0);
auVar122._12_4_ = auVar123._12_4_;
auVar122._0_10_ = auVar107._0_10_;
auVar122._10_2_ = -(ushort)(sVar105 < 0);
auVar121._10_6_ = auVar122._10_6_;
auVar121._0_8_ = auVar107._0_8_;
auVar121._8_2_ = sVar105;
auVar41._4_8_ = auVar121._8_8_;
auVar41._2_2_ = -(ushort)(auVar36._0_2_ < 0);
auVar41._0_2_ = auVar36._0_2_;
auVar116._12_2_ = sVar106;
auVar116._0_12_ = auVar123._0_12_;
auVar116._14_2_ = -(ushort)(sVar106 < 0);
auVar115._12_4_ = auVar116._12_4_;
auVar115._10_2_ = -(ushort)(sVar105 < 0);
auVar115._0_10_ = auVar122._0_10_;
auVar114._10_6_ = auVar115._10_6_;
auVar114._8_2_ = sVar105;
auVar114._0_8_ = auVar121._0_8_;
auVar76._12_2_ = auVar72._14_2_;
auVar76._0_12_ = auVar61;
auVar76._14_2_ = -(ushort)(lVar89 < 0);
auVar75._12_4_ = auVar76._12_4_;
auVar75._0_10_ = auVar61._0_10_;
auVar75._10_2_ = -(ushort)(sVar82 < 0);
auVar74._10_6_ = auVar75._10_6_;
auVar74._8_2_ = sVar82;
auVar74._0_8_ = lVar89;
auVar120._12_2_ = auVar72._14_2_;
auVar120._0_12_ = auVar61;
auVar120._14_2_ = -(ushort)(lVar89 < 0);
auVar119._12_4_ = auVar120._12_4_;
auVar119._10_2_ = -(ushort)(sVar82 < 0);
auVar119._0_10_ = auVar75._0_10_;
auVar118._10_6_ = auVar119._10_6_;
auVar118._8_2_ = sVar82;
auVar118._0_8_ = lVar89;
auVar117._8_8_ = auVar118._8_8_;
auVar117._6_2_ = -(ushort)(iVar54 < 0);
auVar117._4_2_ = auVar69._10_2_;
auVar117._0_4_ = iVar54;
iVar54 = ((((iVar93 - auVar41._0_4_) - auVar115._12_4_) - auVar117._4_4_) - auVar75._12_4_) +
((((iVar92 - CONCAT22(-(ushort)bVar1,auVar107._0_2_)) - auVar114._8_4_) -
CONCAT22(-(ushort)(sVar52 < 0),sVar52)) - auVar74._8_4_);
uVar48 = uVar48 + (uVar50 & 0xfffffffffffffff8);
uVar49 = uVar49 + (int)(uVar50 & 0xfffffffffffffff8);
if ((uVar50 & 7) == 0) {
return iVar54;
}
}
iVar54 = iVar54 + (uint)((byte)(param_1[uVar48] + 0x9fU) < 0x1a);
if ((ulong)(long)(int)(uVar49 + 1) < sVar46) {
iVar54 = iVar54 + (uint)((byte)(param_1[(int)(uVar49 + 1)] + 0x9fU) < 0x1a);
if ((ulong)(long)(int)(uVar49 + 2) < sVar46) {
iVar54 = iVar54 + (uint)((byte)(param_1[(int)(uVar49 + 2)] + 0x9fU) < 0x1a);
if ((ulong)(long)(int)(uVar49 + 3) < sVar46) {
iVar54 = iVar54 + (uint)((byte)(param_1[(int)(uVar49 + 3)] + 0x9fU) < 0x1a);
if ((ulong)(long)(int)(uVar49 + 4) < sVar46) {
iVar54 = iVar54 + (uint)((byte)(param_1[(int)(uVar49 + 4)] + 0x9fU) < 0x1a);
if ((ulong)(long)(int)(uVar49 + 5) < sVar46) {
iVar54 = iVar54 + (uint)((byte)(param_1[(int)(uVar49 + 5)] + 0x9fU) < 0x1a);
if ((ulong)(long)(int)(uVar49 + 6) < sVar46) {
iVar54 = iVar54 + (uint)((byte)(param_1[(int)(uVar49 + 6)] + 0x9fU) < 0x1a);
}
}
}
}
}
}
return iVar54;
} |
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 running_count = 1;
int i;
for (i = 0; i < list_size - 1; ++i) {
if (lists[i] == lists[i + 1]) {
running_count++;
} else {
(*frequencies)[element_count] = running_count;
(*elements)[element_count] = lists[i];
element_count++;
running_count = 1;
}
}
(*frequencies)[element_count] = running_count;
(*elements)[element_count] = lists[i];
element_count++;
*return_size = element_count;
}
| 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] == 1 && frequencies[0] == 1);
assert(elements[1] == 2 && frequencies[1] == 3);
assert(elements[2] == 4 && frequencies[2] == 3);
assert(elements[3] == 5 && frequencies[3] == 4);
free(elements);
free(frequencies);
func0(list2, sizeof(list2)/sizeof(list2[0]), &elements, &frequencies, &size);
assert(size == 7);
assert(elements[0] == 2 && frequencies[0] == 2);
assert(elements[1] == 3 && frequencies[1] == 1);
free(elements);
free(frequencies);
func0(list3, sizeof(list3)/sizeof(list3[0]), &elements, &frequencies, &size);
assert(size == 12);
for (int i = 0; i < size; i++) {
assert(frequencies[i] == 1);
}
free(elements);
free(frequencies);
return 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 %rdx,(%rax)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rdx
mov -0x30(%rbp),%rax
mov %rdx,(%rax)
movl $0x0,-0xc(%rbp)
cmpl $0x0,-0x1c(%rbp)
jne 121a <func0+0x71>
mov -0x38(%rbp),%rax
movl $0x0,(%rax)
jmpq 131e <func0+0x175>
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 12bc <func0+0x113>
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
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 1267 <func0+0xbe>
addl $0x1,-0x8(%rbp)
jmp 12b8 <func0+0x10f>
mov -0x30(%rbp),%rax
mov (%rax),%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rax,%rdx
mov -0x8(%rbp),%eax
mov %eax,(%rdx)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x28(%rbp),%rax
mov (%rax),%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x4(%rbp)
jl 122d <func0+0x84>
mov -0x30(%rbp),%rax
mov (%rax),%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rax,%rdx
mov -0x8(%rbp),%eax
mov %eax,(%rdx)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x28(%rbp),%rax
mov (%rax),%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0x38(%rbp),%rax
mov -0xc(%rbp),%edx
mov %edx,(%rax)
leaveq
retq
| 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]
mov [rax], rdx
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_30]
mov [rax], rdx
mov [rbp+var_C], 0
cmp [rbp+var_1C], 0
jnz short loc_121A
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
jmp locret_131E
loc_121A:
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp loc_12BC
loc_122D:
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
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_1267
add [rbp+var_8], 1
jmp short loc_12B8
loc_1267:
mov rax, [rbp+var_30]
mov rax, [rax]
mov edx, [rbp+var_C]
movsxd rdx, edx
shl rdx, 2
add rdx, rax
mov eax, [rbp+var_8]
mov [rdx], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov rax, [rbp+var_28]
mov rax, [rax]
mov edx, [rbp+var_C]
movsxd rdx, edx
shl rdx, 2
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
add [rbp+var_C], 1
mov [rbp+var_8], 1
loc_12B8:
add [rbp+var_4], 1
loc_12BC:
mov eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_4], eax
jl loc_122D
mov rax, [rbp+var_30]
mov rax, [rax]
mov edx, [rbp+var_C]
movsxd rdx, edx
shl rdx, 2
add rdx, rax
mov eax, [rbp+var_8]
mov [rdx], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov rax, [rbp+var_28]
mov rax, [rax]
mov edx, [rbp+var_C]
movsxd rdx, edx
shl rdx, 2
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
add [rbp+var_C], 1
mov rax, [rbp+var_38]
mov edx, [rbp+var_C]
mov [rax], edx
locret_131E:
leave
retn | _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 )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4 * (i + 1LL) + a1) )
{
++v10;
}
else
{
*((_DWORD *)*a4 + v9) = v10;
*((_DWORD *)*a3 + v9++) = *(_DWORD *)(4LL * i + a1);
v10 = 1;
}
}
*((_DWORD *)*a4 + v9) = v10;
*((_DWORD *)*a3 + v9) = *(_DWORD *)(4LL * i + a1);
result = a5;
*a5 = v9 + 1;
}
else
{
result = a5;
*a5 = 0;
}
return result;
} | 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 + -0x28]
MOV qword ptr [RAX],RDX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RDX
MOV dword ptr [RBP + -0xc],0x0
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x0010121a
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
JMP 0x0010131e
LAB_0010121a:
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001012bc
LAB_0010122d:
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
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x00101267
ADD dword ptr [RBP + -0x8],0x1
JMP 0x001012b8
LAB_00101267:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0xc],0x1
MOV dword ptr [RBP + -0x8],0x1
LAB_001012b8:
ADD dword ptr [RBP + -0x4],0x1
LAB_001012bc:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JL 0x0010122d
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0xc],0x1
MOV RAX,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0xc]
MOV dword ptr [RAX],EDX
LAB_0010131e:
LEAVE
RET | 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) {
*param_5 = 0;
}
else {
local_10 = 1;
for (local_c = 0; local_c < param_2 + -1; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) == *(int *)(param_1 + ((long)local_c + 1) * 4)) {
local_10 = local_10 + 1;
}
else {
*(int *)((long)local_14 * 4 + *param_4) = local_10;
*(int4 *)((long)local_14 * 4 + *param_3) =
*(int4 *)((long)local_c * 4 + param_1);
local_14 = local_14 + 1;
local_10 = 1;
}
}
*(int *)((long)local_14 * 4 + *param_4) = local_10;
*(int4 *)((long)local_14 * 4 + *param_3) = *(int4 *)((long)local_c * 4 + param_1);
*param_5 = local_14 + 1;
}
return;
} |
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 running_count = 1;
int i;
for (i = 0; i < list_size - 1; ++i) {
if (lists[i] == lists[i + 1]) {
running_count++;
} else {
(*frequencies)[element_count] = running_count;
(*elements)[element_count] = lists[i];
element_count++;
running_count = 1;
}
}
(*frequencies)[element_count] = running_count;
(*elements)[element_count] = lists[i];
element_count++;
*return_size = element_count;
}
| 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] == 1 && frequencies[0] == 1);
assert(elements[1] == 2 && frequencies[1] == 3);
assert(elements[2] == 4 && frequencies[2] == 3);
assert(elements[3] == 5 && frequencies[3] == 4);
free(elements);
free(frequencies);
func0(list2, sizeof(list2)/sizeof(list2[0]), &elements, &frequencies, &size);
assert(size == 7);
assert(elements[0] == 2 && frequencies[0] == 2);
assert(elements[1] == 3 && frequencies[1] == 1);
free(elements);
free(frequencies);
func0(list3, sizeof(list3)/sizeof(list3[0]), &elements, &frequencies, &size);
assert(size == 12);
for (int i = 0; i < size; i++) {
assert(frequencies[i] == 1);
}
free(elements);
free(frequencies);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%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 <malloc@plt>
mov %rax,(%r12)
test %ebx,%ebx
je 1219 <func0+0x70>
cmp $0x1,%ebx
jle 1208 <func0+0x5f>
mov %r13,%rax
lea -0x2(%rbx),%edx
lea 0x4(%r13,%rdx,4),%r8
mov $0x1,%ecx
mov $0x0,%edx
jmp 1246 <func0+0x9d>
mov $0x0,%ebx
mov $0x1,%ecx
mov $0x0,%edx
jmp 1255 <func0+0xac>
movl $0x0,(%r14)
jmp 1274 <func0+0xcb>
movslq %edx,%rsi
mov (%r12),%rdi
mov %ecx,(%rdi,%rsi,4)
mov (%rax),%edi
mov 0x0(%rbp),%rcx
mov %edi,(%rcx,%rsi,4)
add $0x1,%edx
mov $0x1,%ecx
add $0x4,%rax
cmp %r8,%rax
je 1252 <func0+0xa9>
mov 0x4(%rax),%esi
cmp %esi,(%rax)
jne 1222 <func0+0x79>
add $0x1,%ecx
jmp 123d <func0+0x94>
sub $0x1,%ebx
movslq %edx,%rax
mov (%r12),%rsi
mov %ecx,(%rsi,%rax,4)
movslq %ebx,%rbx
mov 0x0(%r13,%rbx,4),%esi
mov 0x0(%rbp),%rcx
mov %esi,(%rcx,%rax,4)
add $0x1,%edx
mov %edx,(%r14)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov 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], rax
test r14d, r14d
jz short loc_125B
cmp r14d, 1
jle short loc_126E
mov rax, r12
mov r9d, r14d
lea edx, [r14-2]
lea r8, [r12+rdx*4+4]
mov ecx, 1
mov edx, 0
jmp short loc_1231
loc_120E:
movsxd rsi, edx
mov rdi, [rbp+0]
mov [rdi+rsi*4], ecx
mov edi, [rax]
mov rcx, [rbx]
mov [rcx+rsi*4], edi
add edx, 1
mov ecx, 1
loc_1228:
add rax, 4
cmp rax, r8
jz short loc_123D
loc_1231:
mov esi, [rax+4]
cmp [rax], esi
jnz short loc_120E
add ecx, 1
jmp short loc_1228
loc_123D:
lea eax, [r9-1]
loc_1241:
movsxd rsi, edx
mov rdi, [rbp+0]
mov [rdi+rsi*4], ecx
cdqe
mov ecx, [r12+rax*4]
mov rax, [rbx]
mov [rax+rsi*4], ecx
lea r14d, [rdx+1]
loc_125B:
mov [r13+0], r14d
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_126E:
mov eax, 0
mov ecx, 1
mov edx, 0
jmp short loc_1241 | 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 )
{
if ( a2 <= 1 )
{
v13 = 0;
v11 = 1;
v12 = 0;
}
else
{
v10 = a1;
v11 = 1;
v12 = 0;
do
{
if ( *v10 == v10[1] )
{
++v11;
}
else
{
*(_DWORD *)(*a4 + 4LL * v12) = v11;
*(_DWORD *)(*a3 + 4LL * v12++) = *v10;
v11 = 1;
}
++v10;
}
while ( v10 != &a1[a2 - 2 + 1] );
v13 = a2 - 1;
}
*(_DWORD *)(*a4 + 4LL * v12) = v11;
v14 = a1[v13];
result = *a3;
*(_DWORD *)(*a3 + 4LL * v12) = v14;
v5 = v12 + 1;
}
*a5 = v5;
return result;
} | 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 0x0010126e
MOV RAX,R12
MOV R9D,R14D
LEA EDX,[R14 + -0x2]
LEA R8,[R12 + RDX*0x4 + 0x4]
MOV ECX,0x1
MOV EDX,0x0
JMP 0x00101231
LAB_0010120e:
MOVSXD RSI,EDX
MOV RDI,qword ptr [RBP]
MOV dword ptr [RDI + RSI*0x4],ECX
MOV EDI,dword ptr [RAX]
MOV RCX,qword ptr [RBX]
MOV dword ptr [RCX + RSI*0x4],EDI
ADD EDX,0x1
MOV ECX,0x1
LAB_00101228:
ADD RAX,0x4
CMP RAX,R8
JZ 0x0010123d
LAB_00101231:
MOV ESI,dword ptr [RAX + 0x4]
CMP dword ptr [RAX],ESI
JNZ 0x0010120e
ADD ECX,0x1
JMP 0x00101228
LAB_0010123d:
LEA EAX,[R9 + -0x1]
LAB_00101241:
MOVSXD RSI,EDX
MOV RDI,qword ptr [RBP]
MOV dword ptr [RDI + RSI*0x4],ECX
CDQE
MOV ECX,dword ptr [R12 + RAX*0x4]
MOV RAX,qword ptr [RBX]
MOV dword ptr [RAX + RSI*0x4],ECX
LEA R14D,[RDX + 0x1]
LAB_0010125b:
MOV dword ptr [R13],R14D
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010126e:
MOV EAX,0x0
MOV ECX,0x1
MOV EDX,0x0
JMP 0x00101241 | 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) {
param_2 = 0;
iVar3 = 1;
iVar4 = 0;
}
else {
iVar3 = 1;
iVar4 = 0;
piVar2 = param_1;
do {
if (*piVar2 == piVar2[1]) {
iVar3 = iVar3 + 1;
}
else {
*(int *)(*param_4 + (long)iVar4 * 4) = iVar3;
*(int *)(*param_3 + (long)iVar4 * 4) = *piVar2;
iVar4 = iVar4 + 1;
iVar3 = 1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(param_2 - 2) + 1);
param_2 = param_2 + -1;
}
*(int *)(*param_4 + (long)iVar4 * 4) = iVar3;
*(int *)(*param_3 + (long)iVar4 * 4) = param_1[param_2];
param_2 = iVar4 + 1;
}
*param_5 = param_2;
return;
} |
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 running_count = 1;
int i;
for (i = 0; i < list_size - 1; ++i) {
if (lists[i] == lists[i + 1]) {
running_count++;
} else {
(*frequencies)[element_count] = running_count;
(*elements)[element_count] = lists[i];
element_count++;
running_count = 1;
}
}
(*frequencies)[element_count] = running_count;
(*elements)[element_count] = lists[i];
element_count++;
*return_size = element_count;
}
| 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] == 1 && frequencies[0] == 1);
assert(elements[1] == 2 && frequencies[1] == 3);
assert(elements[2] == 4 && frequencies[2] == 3);
assert(elements[3] == 5 && frequencies[3] == 4);
free(elements);
free(frequencies);
func0(list2, sizeof(list2)/sizeof(list2[0]), &elements, &frequencies, &size);
assert(size == 7);
assert(elements[0] == 2 && frequencies[0] == 2);
assert(elements[1] == 3 && frequencies[1] == 1);
free(elements);
free(frequencies);
func0(list3, sizeof(list3)/sizeof(list3[0]), &elements, &frequencies, &size);
assert(size == 12);
for (int i = 0; i < size; i++) {
assert(frequencies[i] == 1);
}
free(elements);
free(frequencies);
return 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@plt>
mov %rax,(%r15)
test %ebp,%ebp
je 1660 <func0+0xf0>
mov (%r14),%r8
cmp $0x1,%ebp
jle 1680 <func0+0x110>
lea -0x2(%rbp),%edx
mov %rbx,%rcx
mov $0x1,%esi
xor %edi,%edi
lea 0x4(%rbx,%rdx,4),%r13
jmp 1606 <func0+0x96>
nopw %cs:0x0(%rax,%rax,1)
add $0x4,%rdx
add $0x4,%rcx
mov %esi,(%r11)
mov $0x1,%esi
mov %r9d,(%r10)
lea (%rax,%rdx,1),%r11
lea (%r8,%rdx,1),%r10
lea 0x2(%rdi),%edx
mov %r14d,%edi
cmp %rcx,%r13
je 1631 <func0+0xc1>
movslq %edi,%rdx
mov (%rcx),%r9d
lea 0x1(%rdi),%r14d
shl $0x2,%rdx
lea (%rax,%rdx,1),%r11
lea (%r8,%rdx,1),%r10
cmp 0x4(%rcx),%r9d
jne 15e0 <func0+0x70>
add $0x4,%rcx
add $0x1,%esi
mov %r14d,%edx
cmp %rcx,%r13
jne 1606 <func0+0x96>
sub $0x1,%ebp
movslq %ebp,%rbp
lea (%rbx,%rbp,4),%rbx
mov (%rbx),%eax
mov %esi,(%r11)
mov %eax,(%r10)
mov %edx,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
movl $0x0,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov %r8,%r10
mov %rax,%r11
mov $0x1,%edx
mov $0x1,%esi
jmp 163b <func0+0xcb>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| 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], rax
test ebx, ebx
jz short loc_1630
lea r8d, [rbx-1]
mov r10, [r13+0]
mov r9, rax
test r8d, r8d
jle loc_1648
lea edx, [rbx-2]
mov rax, rbp
mov esi, 1
xor ecx, ecx
lea r11, [rbp+rdx*4+4]
jmp short loc_15FC
loc_15E0:
movsxd rdi, ecx
add rax, 4
add ecx, 1
mov [r9+rdi*4], esi
mov esi, 1
mov [r10+rdi*4], edx
cmp r11, rax
jz short loc_160F
loc_15FC:
mov edx, [rax]
cmp edx, [rax+4]
jnz short loc_15E0
add rax, 4
add esi, 1
cmp r11, rax
jnz short loc_15FC
loc_160F:
movsxd rax, ecx
movsxd r8, r8d
lea ebx, [rcx+1]
shl rax, 2
lea rbp, [rbp+r8*4+0]
add r9, rax
add r10, rax
loc_1627:
mov eax, [rbp+0]
mov [r9], esi
mov [r10], eax
loc_1630:
mov [r14], ebx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1648:
mov ebx, 1
mov esi, 1
jmp short loc_1627 | 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; // rdi
unsigned int v19; // edx
long long v20; // rax
v8 = a1;
v9 = a2;
*a3 = malloc(4LL * a2);
result = malloc(4LL * a2);
*a4 = result;
if ( a2 )
{
v11 = a2 - 1;
v12 = (_DWORD *)*a3;
v13 = (_DWORD *)result;
if ( a2 - 1 <= 0 )
{
v9 = 1;
v15 = 1;
}
else
{
v14 = a1;
v15 = 1;
v16 = 0;
v17 = (long long)&a1[v9 - 2 + 1];
do
{
while ( 1 )
{
v19 = *v14;
if ( *v14 == v14[1] )
break;
v18 = v16;
++v14;
++v16;
v13[v18] = v15;
v15 = 1;
v12[v18] = v19;
if ( (unsigned int *)v17 == v14 )
goto LABEL_7;
}
++v14;
++v15;
}
while ( (unsigned int *)v17 != v14 );
LABEL_7:
v9 = v16 + 1;
v20 = 4LL * v16;
v8 += v11;
v13 = (_DWORD *)((char *)v13 + v20);
v12 = (_DWORD *)((char *)v12 + v20);
}
result = *v8;
*v13 = v15;
*v12 = result;
}
*a5 = v9;
return result;
} | 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]
MOV R10,qword ptr [R13]
MOV R9,RAX
TEST R8D,R8D
JLE 0x00101648
LEA EDX,[RBX + -0x2]
MOV RAX,RBP
MOV ESI,0x1
XOR ECX,ECX
LEA R11,[RBP + RDX*0x4 + 0x4]
JMP 0x001015fc
LAB_001015e0:
MOVSXD RDI,ECX
ADD RAX,0x4
ADD ECX,0x1
MOV dword ptr [R9 + RDI*0x4],ESI
MOV ESI,0x1
MOV dword ptr [R10 + RDI*0x4],EDX
CMP R11,RAX
JZ 0x0010160f
LAB_001015fc:
MOV EDX,dword ptr [RAX]
CMP EDX,dword ptr [RAX + 0x4]
JNZ 0x001015e0
ADD RAX,0x4
ADD ESI,0x1
CMP R11,RAX
JNZ 0x001015fc
LAB_0010160f:
MOVSXD RAX,ECX
MOVSXD R8,R8D
LEA EBX,[RCX + 0x1]
SHL RAX,0x2
LEA RBP,[RBP + R8*0x4]
ADD R9,RAX
ADD R10,RAX
LAB_00101627:
MOV EAX,dword ptr [RBP]
MOV dword ptr [R9],ESI
MOV dword ptr [R10],EAX
LAB_00101630:
MOV dword ptr [R14],EBX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101648:
MOV EBX,0x1
MOV ESI,0x1
JMP 0x00101627 | 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);
*param_4 = piVar3;
if (param_2 != 0) {
iVar8 = param_2 + -1;
piVar9 = (int *)*param_3;
if (iVar8 < 1) {
param_2 = 1;
iVar7 = 1;
}
else {
iVar7 = 1;
piVar4 = param_1;
iVar6 = 0;
do {
while (iVar1 = *piVar4, iVar1 == piVar4[1]) {
piVar4 = piVar4 + 1;
iVar7 = iVar7 + 1;
iVar5 = iVar6;
if (param_1 + (ulong)(param_2 - 2) + 1 == piVar4) goto LAB_0010160f;
}
piVar4 = piVar4 + 1;
iVar5 = iVar6 + 1;
piVar3[iVar6] = iVar7;
iVar7 = 1;
piVar9[iVar6] = iVar1;
iVar6 = iVar5;
} while (param_1 + (ulong)(param_2 - 2) + 1 != piVar4);
LAB_0010160f:
param_2 = iVar5 + 1;
param_1 = param_1 + iVar8;
piVar3 = piVar3 + iVar5;
piVar9 = piVar9 + iVar5;
}
iVar8 = *param_1;
*piVar3 = iVar7;
*piVar9 = iVar8;
}
*param_5 = param_2;
return;
} |
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 running_count = 1;
int i;
for (i = 0; i < list_size - 1; ++i) {
if (lists[i] == lists[i + 1]) {
running_count++;
} else {
(*frequencies)[element_count] = running_count;
(*elements)[element_count] = lists[i];
element_count++;
running_count = 1;
}
}
(*frequencies)[element_count] = running_count;
(*elements)[element_count] = lists[i];
element_count++;
*return_size = element_count;
}
| 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] == 1 && frequencies[0] == 1);
assert(elements[1] == 2 && frequencies[1] == 3);
assert(elements[2] == 4 && frequencies[2] == 3);
assert(elements[3] == 5 && frequencies[3] == 4);
free(elements);
free(frequencies);
func0(list2, sizeof(list2)/sizeof(list2[0]), &elements, &frequencies, &size);
assert(size == 7);
assert(elements[0] == 2 && frequencies[0] == 2);
assert(elements[1] == 3 && frequencies[1] == 1);
free(elements);
free(frequencies);
func0(list3, sizeof(list3)/sizeof(list3[0]), &elements, &frequencies, &size);
assert(size == 12);
for (int i = 0; i < size; i++) {
assert(frequencies[i] == 1);
}
free(elements);
free(frequencies);
return 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@plt>
mov %rax,(%r15)
test %ebp,%ebp
je 1620 <func0+0xf0>
mov (%r14),%r8
cmp $0x1,%ebp
jle 1640 <func0+0x110>
lea -0x2(%rbp),%edx
mov %rbx,%rcx
mov $0x1,%esi
xor %edi,%edi
lea 0x4(%rbx,%rdx,4),%r13
jmp 15c6 <func0+0x96>
nopw %cs:0x0(%rax,%rax,1)
add $0x4,%rdx
add $0x4,%rcx
mov %esi,(%r11)
mov $0x1,%esi
mov %r9d,(%r10)
lea (%rax,%rdx,1),%r11
lea (%r8,%rdx,1),%r10
lea 0x2(%rdi),%edx
mov %r14d,%edi
cmp %rcx,%r13
je 15f1 <func0+0xc1>
movslq %edi,%rdx
mov (%rcx),%r9d
lea 0x1(%rdi),%r14d
shl $0x2,%rdx
lea (%rax,%rdx,1),%r11
lea (%r8,%rdx,1),%r10
cmp 0x4(%rcx),%r9d
jne 15a0 <func0+0x70>
add $0x4,%rcx
add $0x1,%esi
mov %r14d,%edx
cmp %rcx,%r13
jne 15c6 <func0+0x96>
sub $0x1,%ebp
movslq %ebp,%rbp
lea (%rbx,%rbp,4),%rbx
mov (%rbx),%eax
mov %esi,(%r11)
mov %eax,(%r10)
mov %edx,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
movl $0x0,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov %r8,%r10
mov %rax,%r11
mov $0x1,%edx
mov $0x1,%esi
jmp 15fb <func0+0xcb>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| 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 [r15], rax
test ebx, ebx
jz short loc_15F0
mov r10, [r13+0]
mov r9, rax
cmp ebx, 1
jle loc_1608
lea edx, [rbx-2]
mov rax, rbp
mov esi, 1
xor ecx, ecx
lea r11, [rbp+rdx*4+4]
jmp short loc_15BC
loc_15A0:
movsxd rdi, ecx
add rax, 4
add ecx, 1
mov [r9+rdi*4], esi
mov esi, 1
mov [r10+rdi*4], edx
cmp r11, rax
jz short loc_15CF
loc_15BC:
mov edx, [rax]
cmp edx, [rax+4]
jnz short loc_15A0
add rax, 4
add esi, 1
cmp r11, rax
jnz short loc_15BC
loc_15CF:
movsxd rax, ecx
lea edx, [rbx-1]
lea ebx, [rcx+1]
shl rax, 2
lea rbp, [rbp+rdx*4+0]
add r9, rax
add r10, rax
loc_15E7:
mov eax, [rbp+0]
mov [r9], esi
mov [r10], eax
loc_15F0:
mov [r14], ebx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1608:
mov ebx, 1
mov esi, 1
jmp short loc_15E7 | 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
long long v19; // rdx
long long v20; // rax
v8 = a1;
v9 = a2;
*a3 = malloc(4LL * a2);
result = (int *)malloc(4LL * a2);
*a4 = result;
if ( a2 )
{
v11 = *a3;
v12 = result;
if ( a2 <= 1 )
{
v9 = 1;
v14 = 1;
}
else
{
v13 = a1;
v14 = 1;
v15 = 0;
v16 = (long long)&a1[v9 - 2 + 1];
do
{
while ( 1 )
{
v18 = *v13;
if ( *v13 == v13[1] )
break;
v17 = v15;
++v13;
++v15;
v12[v17] = v14;
v14 = 1;
v11[v17] = v18;
if ( (unsigned int *)v16 == v13 )
goto LABEL_7;
}
++v13;
++v14;
}
while ( (unsigned int *)v16 != v13 );
LABEL_7:
v19 = (unsigned int)(v9 - 1);
v9 = v15 + 1;
v20 = 4LL * v15;
v8 += v19;
v12 = (int *)((char *)v12 + v20);
v11 = (_DWORD *)((char *)v11 + v20);
}
result = (int *)*v8;
*v12 = v14;
*v11 = (_DWORD)result;
}
*a5 = v9;
return result;
} | 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]
MOV R9,RAX
CMP EBX,0x1
JLE 0x00101608
LEA EDX,[RBX + -0x2]
MOV RAX,RBP
MOV ESI,0x1
XOR ECX,ECX
LEA R11,[RBP + RDX*0x4 + 0x4]
JMP 0x001015bc
LAB_001015a0:
MOVSXD RDI,ECX
ADD RAX,0x4
ADD ECX,0x1
MOV dword ptr [R9 + RDI*0x4],ESI
MOV ESI,0x1
MOV dword ptr [R10 + RDI*0x4],EDX
CMP R11,RAX
JZ 0x001015cf
LAB_001015bc:
MOV EDX,dword ptr [RAX]
CMP EDX,dword ptr [RAX + 0x4]
JNZ 0x001015a0
ADD RAX,0x4
ADD ESI,0x1
CMP R11,RAX
JNZ 0x001015bc
LAB_001015cf:
MOVSXD RAX,ECX
LEA EDX,[RBX + -0x1]
LEA EBX,[RCX + 0x1]
SHL RAX,0x2
LEA RBP,[RBP + RDX*0x4]
ADD R9,RAX
ADD R10,RAX
LAB_001015e7:
MOV EAX,dword ptr [RBP]
MOV dword ptr [R9],ESI
MOV dword ptr [R10],EAX
LAB_001015f0:
MOV dword ptr [R14],EBX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101608:
MOV EBX,0x1
MOV ESI,0x1
JMP 0x001015e7 | 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);
*param_4 = piVar3;
if (param_2 != 0) {
piVar9 = (int *)*param_3;
if (param_2 < 2) {
param_2 = 1;
iVar8 = 1;
}
else {
iVar8 = 1;
piVar4 = param_1;
iVar6 = 0;
do {
while (iVar1 = *piVar4, iVar1 == piVar4[1]) {
piVar4 = piVar4 + 1;
iVar8 = iVar8 + 1;
iVar5 = iVar6;
if (param_1 + (ulong)(param_2 - 2) + 1 == piVar4) goto LAB_001015cf;
}
piVar4 = piVar4 + 1;
iVar5 = iVar6 + 1;
piVar3[iVar6] = iVar8;
iVar8 = 1;
piVar9[iVar6] = iVar1;
iVar6 = iVar5;
} while (param_1 + (ulong)(param_2 - 2) + 1 != piVar4);
LAB_001015cf:
uVar7 = param_2 - 1;
param_2 = iVar5 + 1;
param_1 = param_1 + uVar7;
piVar3 = piVar3 + iVar5;
piVar9 = piVar9 + iVar5;
}
iVar6 = *param_1;
*piVar3 = iVar8;
*piVar9 = iVar6;
}
*param_5 = param_2;
return;
} |
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 = 0; j < dict2.size; j++) {
if (dict1.items[i].key == dict2.items[j].key) {
found = 1;
break;
}
}
if (!found) {
merged_dict.items[k++] = dict1.items[i];
}
}
for (int i = 0; i < dict2.size; i++) {
merged_dict.items[k++] = dict2.items[i];
}
merged_dict.size = k;
return merged_dict;
}
| 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);
// More assertions could be added for individual dictionary items if needed.
DictItem items3[] = {{'O', "Orange"}, {'W', "White"}, {'B', "Black"}};
Dictionary dict3 = { items3, 3 };
Dictionary result2 = func0(dict1, dict3);
assert(result2.size == 5);
// More assertions could be added for individual dictionary items if needed.
Dictionary result3 = func0(dict2, dict3);
assert(result3.size == 4);
// More assertions could be added for individual dictionary items if needed.
free(result1.items);
free(result2.items);
free(result3.items);
return 0;
}
| 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,-0x8(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x10(%rbp)
movl $0x0,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
jmpq 12dd <func0+0x134>
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
jmp 1275 <func0+0xcc>
mov -0x40(%rbp),%rcx
mov -0x20(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
add %rcx,%rax
movzbl (%rax),%ecx
mov -0x50(%rbp),%rsi
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
add %rsi,%rax
movzbl (%rax),%eax
cmp %al,%cl
jne 1271 <func0+0xc8>
movl $0x1,-0x1c(%rbp)
jmp 127d <func0+0xd4>
addl $0x1,-0x18(%rbp)
mov -0x48(%rbp),%eax
cmp %eax,-0x18(%rbp)
jl 1224 <func0+0x7b>
cmpl $0x0,-0x1c(%rbp)
jne 12d9 <func0+0x130>
mov -0x40(%rbp),%rcx
mov -0x20(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
lea (%rcx,%rax,1),%rdx
mov -0x10(%rbp),%rsi
mov -0x24(%rbp),%eax
lea 0x1(%rax),%ecx
mov %ecx,-0x24(%rbp)
movslq %eax,%rcx
mov %rcx,%rax
shl $0x2,%rax
add %rcx,%rax
add %rax,%rax
add %rcx,%rax
add %rsi,%rax
mov (%rdx),%rcx
mov %rcx,(%rax)
movzwl 0x8(%rdx),%ecx
mov %cx,0x8(%rax)
movzbl 0xa(%rdx),%edx
mov %dl,0xa(%rax)
addl $0x1,-0x20(%rbp)
mov -0x38(%rbp),%eax
cmp %eax,-0x20(%rbp)
jl 1214 <func0+0x6b>
movl $0x0,-0x14(%rbp)
jmp 134c <func0+0x1a3>
mov -0x50(%rbp),%rcx
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
add %rdx,%rax
lea (%rcx,%rax,1),%rdx
mov -0x10(%rbp),%rsi
mov -0x24(%rbp),%eax
lea 0x1(%rax),%ecx
mov %ecx,-0x24(%rbp)
movslq %eax,%rcx
mov %rcx,%rax
shl $0x2,%rax
add %rcx,%rax
add %rax,%rax
add %rcx,%rax
add %rsi,%rax
mov (%rdx),%rcx
mov %rcx,(%rax)
movzwl 0x8(%rdx),%ecx
mov %cx,0x8(%rax)
movzbl 0xa(%rdx),%edx
mov %dl,0xa(%rax)
addl $0x1,-0x14(%rbp)
mov -0x48(%rbp),%eax
cmp %eax,-0x14(%rbp)
jl 12f2 <func0+0x149>
mov -0x24(%rbp),%eax
mov %eax,-0x8(%rbp)
mov -0x10(%rbp),%rax
mov -0x8(%rbp),%rdx
leaveq
retq
| 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]
add eax, edx
mov dword ptr [rbp+var_8], eax
mov eax, dword ptr [rbp+var_8]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
mov rdi, rax; size
call _malloc
mov [rbp+var_10], rax
mov [rbp+var_24], 0
mov [rbp+var_20], 0
jmp loc_12D3
loc_1214:
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
jmp short loc_1275
loc_1224:
mov rcx, [rbp+var_40]
mov eax, [rbp+var_20]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
add rax, rcx
movzx ecx, byte ptr [rax]
mov rsi, [rbp+var_50]
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
add rax, rsi
movzx eax, byte ptr [rax]
cmp cl, al
jnz short loc_1271
mov [rbp+var_1C], 1
jmp short loc_127D
loc_1271:
add [rbp+var_18], 1
loc_1275:
mov eax, dword ptr [rbp+var_48]
cmp [rbp+var_18], eax
jl short loc_1224
loc_127D:
cmp [rbp+var_1C], 0
jnz short loc_12CF
mov rcx, [rbp+var_40]
mov eax, [rbp+var_20]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
add rcx, rax
mov rsi, [rbp+var_10]
mov eax, [rbp+var_24]
lea edx, [rax+1]
mov [rbp+var_24], edx
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
add rax, rsi
mov rdx, [rcx]
mov [rax], rdx
mov edx, [rcx+7]
mov [rax+7], edx
loc_12CF:
add [rbp+var_20], 1
loc_12D3:
mov eax, dword ptr [rbp+var_38]
cmp [rbp+var_20], eax
jl loc_1214
mov [rbp+var_14], 0
jmp short loc_1338
loc_12E8:
mov rcx, [rbp+var_50]
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
add rcx, rax
mov rsi, [rbp+var_10]
mov eax, [rbp+var_24]
lea edx, [rax+1]
mov [rbp+var_24], edx
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
add rax, rdx
add rax, rsi
mov rdx, [rcx]
mov [rax], rdx
mov edx, [rcx+7]
mov [rax+7], edx
add [rbp+var_14], 1
loc_1338:
mov eax, dword ptr [rbp+var_48]
cmp [rbp+var_14], eax
jl short loc_12E8
mov eax, [rbp+var_24]
mov dword ptr [rbp+var_8], eax
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
leave
retn | 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; // [rsp+3Ch] [rbp-14h]
char *v18; // [rsp+40h] [rbp-10h]
v18 = (char *)malloc(11LL * (a2 + a4));
v13 = 0;
for ( i = 0; i < a2; ++i )
{
v15 = 0;
for ( j = 0; j < a4; ++j )
{
if ( *(_BYTE *)(a1 + 11LL * i) == *(_BYTE *)(a3 + 11LL * j) )
{
v15 = 1;
break;
}
}
if ( !v15 )
{
v4 = 11LL * i + a1;
v5 = v13++;
v6 = &v18[11 * v5];
*(_QWORD *)v6 = *(_QWORD *)v4;
*(_DWORD *)(v6 + 7) = *(_DWORD *)(v4 + 7);
}
}
for ( k = 0; k < a4; ++k )
{
v7 = 11LL * k + a3;
v8 = v13++;
v9 = &v18[11 * v8];
*(_QWORD *)v9 = *(_QWORD *)v7;
*(_DWORD *)(v9 + 7) = *(_DWORD *)(v7 + 7);
}
return v18;
} | 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 ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x0
JMP 0x001012d3
LAB_00101214:
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101275
LAB_00101224:
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x20]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
ADD RAX,RCX
MOVZX ECX,byte ptr [RAX]
MOV RSI,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
ADD RAX,RSI
MOVZX EAX,byte ptr [RAX]
CMP CL,AL
JNZ 0x00101271
MOV dword ptr [RBP + -0x1c],0x1
JMP 0x0010127d
LAB_00101271:
ADD dword ptr [RBP + -0x18],0x1
LAB_00101275:
MOV EAX,dword ptr [RBP + -0x48]
CMP dword ptr [RBP + -0x18],EAX
JL 0x00101224
LAB_0010127d:
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x001012cf
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x20]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
ADD RCX,RAX
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x24]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x24],EDX
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
ADD RAX,RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV EDX,dword ptr [RCX + 0x7]
MOV dword ptr [RAX + 0x7],EDX
LAB_001012cf:
ADD dword ptr [RBP + -0x20],0x1
LAB_001012d3:
MOV EAX,dword ptr [RBP + -0x38]
CMP dword ptr [RBP + -0x20],EAX
JL 0x00101214
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101338
LAB_001012e8:
MOV RCX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
ADD RCX,RAX
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x24]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x24],EDX
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
ADD RAX,RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV EDX,dword ptr [RCX + 0x7]
MOV dword ptr [RAX + 0x7],EDX
ADD dword ptr [RBP + -0x14],0x1
LAB_00101338:
MOV EAX,dword ptr [RBP + -0x48]
CMP dword ptr [RBP + -0x14],EAX
JL 0x001012e8
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
LEAVE
RET | 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 = 0;
do {
if (param_2 <= local_28) {
for (local_1c = 0; local_1c < param_4; local_1c = local_1c + 1) {
puVar5 = (int8 *)(param_3 + (long)local_1c * 0xb);
puVar4 = (int8 *)((long)local_2c * 0xb + (long)pvVar3);
*puVar4 = *puVar5;
*(int4 *)((long)puVar4 + 7) = *(int4 *)((long)puVar5 + 7);
local_2c = local_2c + 1;
}
auVar1._8_4_ = local_2c;
auVar1._0_8_ = pvVar3;
auVar1._12_4_ = uStack_c;
return auVar1;
}
bVar2 = false;
for (local_20 = 0; local_20 < param_4; local_20 = local_20 + 1) {
if (*(char *)((long)local_28 * 0xb + param_1) == *(char *)((long)local_20 * 0xb + param_3)) {
bVar2 = true;
break;
}
}
if (!bVar2) {
puVar5 = (int8 *)(param_1 + (long)local_28 * 0xb);
puVar4 = (int8 *)((long)local_2c * 0xb + (long)pvVar3);
*puVar4 = *puVar5;
*(int4 *)((long)puVar4 + 7) = *(int4 *)((long)puVar5 + 7);
local_2c = local_2c + 1;
}
local_28 = local_28 + 1;
} while( true );
} |
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 = 0; j < dict2.size; j++) {
if (dict1.items[i].key == dict2.items[j].key) {
found = 1;
break;
}
}
if (!found) {
merged_dict.items[k++] = dict1.items[i];
}
}
for (int i = 0; i < dict2.size; i++) {
merged_dict.items[k++] = dict2.items[i];
}
merged_dict.size = k;
return merged_dict;
}
| 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);
// More assertions could be added for individual dictionary items if needed.
DictItem items3[] = {{'O', "Orange"}, {'W', "White"}, {'B', "Black"}};
Dictionary dict3 = { items3, 3 };
Dictionary result2 = func0(dict1, dict3);
assert(result2.size == 5);
// More assertions could be added for individual dictionary items if needed.
Dictionary result3 = func0(dict2, dict3);
assert(result3.size == 4);
// More assertions could be added for individual dictionary items if needed.
free(result1.items);
free(result2.items);
free(result3.items);
return 0;
}
| 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 %r13d,%r13d
jle 1216 <func0+0x6d>
mov %r15,%rdi
lea -0x1(%r13),%edx
lea (%rdx,%rdx,4),%rcx
lea (%rdx,%rcx,2),%rdx
lea 0xb(%r15,%rdx,1),%r9
mov %r14,%r10
lea -0x1(%rbp),%edx
lea (%rdx,%rdx,4),%rcx
lea (%rdx,%rcx,2),%rdx
lea 0xb(%rdx,%r14,1),%rsi
mov $0x0,%r8d
jmpq 12b0 <func0+0x107>
mov $0x0,%r8d
test %ebp,%ebp
jle 126a <func0+0xc1>
lea -0x1(%rbp),%edx
add $0x1,%rdx
lea (%rdx,%rdx,4),%rcx
lea (%rdx,%rcx,2),%rdi
movslq %r8d,%rdx
lea (%rdx,%rdx,4),%rcx
lea (%rdx,%rcx,2),%rcx
add %rax,%rcx
mov $0x0,%edx
mov (%rbx,%rdx,1),%rsi
mov %rsi,(%rcx,%rdx,1)
movzwl 0x8(%rbx,%rdx,1),%esi
mov %si,0x8(%rcx,%rdx,1)
movzbl 0xa(%rbx,%rdx,1),%esi
mov %sil,0xa(%rcx,%rdx,1)
add $0xb,%rdx
cmp %rdi,%rdx
jne 1242 <func0+0x99>
add %ebp,%r8d
mov %r8d,%edx
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
movslq %r8d,%rdx
lea (%rdx,%rdx,4),%rcx
lea (%rdx,%rcx,2),%rdx
add %rax,%rdx
mov (%rdi),%rcx
mov %rcx,(%rdx)
movzwl 0x8(%rdi),%ecx
mov %cx,0x8(%rdx)
movzbl 0xa(%rdi),%ecx
mov %cl,0xa(%rdx)
lea 0x1(%r8),%r8d
add $0xb,%rdi
cmp %r9,%rdi
je 121c <func0+0x73>
test %r12d,%r12d
jle 127c <func0+0xd3>
movzbl (%rdi),%ecx
mov %r10,%rdx
cmp (%rdx),%cl
je 12a3 <func0+0xfa>
add $0xb,%rdx
cmp %rsi,%rdx
jne 12bb <func0+0x112>
jmp 127c <func0+0xd3>
| 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 rsi, r14
lea eax, [r13-1]
lea rdx, [rax+rax*4]
lea rax, [rax+rdx*2]
lea r9, [r14+rax+0Bh]
lea eax, [rbp-1]
lea rdx, [rax+rax*4]
lea rax, [rax+rdx*2]
lea rcx, [rax+rbx+0Bh]
mov r8d, 0
jmp loc_129E
loc_120D:
mov r8d, 0
loc_1213:
test ebp, ebp
jle short loc_125B
mov eax, ebp
lea rdx, [rax+rax*4]
lea rsi, [rax+rdx*2]
movsxd rax, r8d
lea rdx, [rax+rax*4]
lea rdx, [rax+rdx*2]
add rdx, rdi
mov eax, 0
loc_1234:
mov rcx, [rbx+rax]
mov [rdx+rax], rcx
movzx ecx, word ptr [rax+rbx+8]
mov [rdx+rax+8], cx
movzx ecx, byte ptr [rax+rbx+0Ah]
mov [rdx+rax+0Ah], cl
add rax, 0Bh
cmp rax, rsi
jnz short loc_1234
add r8d, ebp
loc_125B:
mov edx, r8d
mov rax, rdi
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_126A:
movsxd rax, r8d
lea rdx, [rax+rax*4]
lea rax, [rax+rdx*2]
add rax, rdi
mov rdx, [rsi]
mov [rax], rdx
movzx edx, word ptr [rsi+8]
mov [rax+8], dx
movzx edx, byte ptr [rsi+0Ah]
mov [rax+0Ah], dl
lea r8d, [r8+1]
loc_1291:
add rsi, 0Bh
cmp rsi, r9
jz loc_1213
loc_129E:
test r12d, r12d
jle short loc_126A
movzx edx, byte ptr [rsi]
mov rax, rbx
loc_12A9:
cmp dl, [rax]
jz short loc_1291
add rax, 0Bh
cmp rax, rcx
jnz short loc_12A9
jmp short loc_126A | 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;
v11 = 0;
do
{
if ( a4 <= 0 )
{
LABEL_8:
v15 = v9 + 11LL * v11;
*(_QWORD *)v15 = *(_QWORD *)v10;
*(_WORD *)(v15 + 8) = *(_WORD *)(v10 + 8);
*(_BYTE *)(v15 + 10) = *(_BYTE *)(v10 + 10);
++v11;
}
else
{
v16 = a3;
while ( *(_BYTE *)v10 != *v16 )
{
v16 += 11;
if ( v16 == &a3[11 * (a4 - 1) + 11] )
goto LABEL_8;
}
}
v10 += 11LL;
}
while ( v10 != a1 + 11LL * (unsigned int)(a2 - 1) + 11 );
}
if ( a4 > 0 )
{
v12 = v9 + 11LL * v11;
v13 = 0LL;
do
{
*(_QWORD *)(v12 + v13) = *(_QWORD *)&a3[v13];
*(_WORD *)(v12 + v13 + 8) = *(_WORD *)&a3[v13 + 8];
*(_BYTE *)(v12 + v13 + 10) = a3[v13 + 10];
v13 += 11LL;
}
while ( v13 != 11LL * (unsigned int)a4 );
}
return v9;
} | 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,[RAX + RDX*0x2]
LEA R9,[R14 + RAX*0x1 + 0xb]
LEA EAX,[RBP + -0x1]
LEA RDX,[RAX + RAX*0x4]
LEA RAX,[RAX + RDX*0x2]
LEA RCX,[RAX + RBX*0x1 + 0xb]
MOV R8D,0x0
JMP 0x0010129e
LAB_0010120d:
MOV R8D,0x0
LAB_00101213:
TEST EBP,EBP
JLE 0x0010125b
MOV EAX,EBP
LEA RDX,[RAX + RAX*0x4]
LEA RSI,[RAX + RDX*0x2]
MOVSXD RAX,R8D
LEA RDX,[RAX + RAX*0x4]
LEA RDX,[RAX + RDX*0x2]
ADD RDX,RDI
MOV EAX,0x0
LAB_00101234:
MOV RCX,qword ptr [RBX + RAX*0x1]
MOV qword ptr [RDX + RAX*0x1],RCX
MOVZX ECX,word ptr [RAX + RBX*0x1 + 0x8]
MOV word ptr [RDX + RAX*0x1 + 0x8],CX
MOVZX ECX,byte ptr [RAX + RBX*0x1 + 0xa]
MOV byte ptr [RDX + RAX*0x1 + 0xa],CL
ADD RAX,0xb
CMP RAX,RSI
JNZ 0x00101234
ADD R8D,EBP
LAB_0010125b:
MOV EDX,R8D
MOV RAX,RDI
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010126a:
MOVSXD RAX,R8D
LEA RDX,[RAX + RAX*0x4]
LEA RAX,[RAX + RDX*0x2]
ADD RAX,RDI
MOV RDX,qword ptr [RSI]
MOV qword ptr [RAX],RDX
MOVZX EDX,word ptr [RSI + 0x8]
MOV word ptr [RAX + 0x8],DX
MOVZX EDX,byte ptr [RSI + 0xa]
MOV byte ptr [RAX + 0xa],DL
LEA R8D,[R8 + 0x1]
LAB_00101291:
ADD RSI,0xb
CMP RSI,R9
JZ 0x00101213
LAB_0010129e:
TEST R12D,R12D
JLE 0x0010126a
MOVZX EDX,byte ptr [RSI]
MOV RAX,RBX
LAB_001012a9:
CMP DL,byte ptr [RAX]
JZ 0x00101291
ADD RAX,0xb
CMP RAX,RCX
JNZ 0x001012a9
JMP 0x0010126a | 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_2 - 1) * 0xb + 0xb;
iVar5 = 0;
do {
if (0 < (int)param_4) {
pcVar4 = param_3;
do {
if (*param_1 == *pcVar4) goto LAB_00101291;
pcVar4 = pcVar4 + 0xb;
} while (pcVar4 != param_3 + (ulong)(param_4 - 1) * 0xb + 0xb);
}
puVar3 = (int8 *)((long)iVar5 * 0xb + (long)auVar6._0_8_);
*puVar3 = *(int8 *)param_1;
*(int2 *)(puVar3 + 1) = *(int2 *)(param_1 + 8);
*(char *)((long)puVar3 + 10) = param_1[10];
iVar5 = iVar5 + 1;
LAB_00101291:
param_1 = param_1 + 0xb;
} while (param_1 != pcVar1);
}
if (0 < (int)param_4) {
lVar2 = 0;
do {
*(int8 *)((long)auVar6._0_8_ + lVar2 + (long)iVar5 * 0xb) =
*(int8 *)(param_3 + lVar2);
*(int2 *)((long)auVar6._0_8_ + lVar2 + (long)iVar5 * 0xb + 8) =
*(int2 *)(param_3 + lVar2 + 8);
*(char *)((long)auVar6._0_8_ + lVar2 + (long)iVar5 * 0xb + 10) = param_3[lVar2 + 10];
lVar2 = lVar2 + 0xb;
} while (lVar2 != (ulong)param_4 * 0xb);
iVar5 = iVar5 + param_4;
}
auVar6._8_4_ = iVar5;
auVar6._12_4_ = 0;
return auVar6;
} |
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 = 0; j < dict2.size; j++) {
if (dict1.items[i].key == dict2.items[j].key) {
found = 1;
break;
}
}
if (!found) {
merged_dict.items[k++] = dict1.items[i];
}
}
for (int i = 0; i < dict2.size; i++) {
merged_dict.items[k++] = dict2.items[i];
}
merged_dict.size = k;
return merged_dict;
}
| 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);
// More assertions could be added for individual dictionary items if needed.
DictItem items3[] = {{'O', "Orange"}, {'W', "White"}, {'B', "Black"}};
Dictionary dict3 = { items3, 3 };
Dictionary result2 = func0(dict1, dict3);
assert(result2.size == 5);
// More assertions could be added for individual dictionary items if needed.
Dictionary result3 = func0(dict2, dict3);
assert(result3.size == 4);
// More assertions could be added for individual dictionary items if needed.
free(result1.items);
free(result2.items);
free(result3.items);
return 0;
}
| 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 -0x1(%r14),%edx
mov %r13,%r9
xor %r10d,%r10d
lea (%rdx,%rdx,4),%rcx
lea (%rdx,%rcx,2),%rdx
lea 0xb(%r13,%rdx,1),%rcx
lea -0x1(%rbp),%edx
lea (%rdx,%rdx,4),%rsi
lea (%rdx,%rsi,2),%rdx
lea 0xb(%rdx,%rbx,1),%r8
nopl (%rax)
test %r12d,%r12d
jle 14b0 <func0+0xf0>
movzbl (%r9),%edi
mov %rbx,%rsi
jmp 1441 <func0+0x81>
nopw 0x0(%rax,%rax,1)
add $0xb,%rsi
cmp %rsi,%r8
je 14b0 <func0+0xf0>
cmp (%rsi),%dil
jne 1438 <func0+0x78>
add $0xb,%r9
cmp %rcx,%r9
jne 1420 <func0+0x60>
test %ebp,%ebp
jle 14a0 <func0+0xe0>
lea -0x1(%rbp),%edx
xor %esi,%esi
add $0x1,%rdx
lea (%rdx,%rdx,4),%rcx
lea (%rdx,%rcx,2),%r8
movslq %r10d,%rdx
lea (%rdx,%rdx,4),%rcx
lea (%rdx,%rcx,2),%rdx
add %rax,%rdx
nopw 0x0(%rax,%rax,1)
mov (%rbx,%rsi,1),%rcx
movzbl 0xa(%rbx,%rsi,1),%edi
mov %rcx,(%rdx,%rsi,1)
movzwl 0x8(%rbx,%rsi,1),%ecx
mov %dil,0xa(%rdx,%rsi,1)
mov %cx,0x8(%rdx,%rsi,1)
add $0xb,%rsi
cmp %r8,%rsi
jne 1478 <func0+0xb8>
add %ebp,%r10d
pop %rbx
mov %r10d,%edx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
movslq %r10d,%rdx
add $0xb,%r9
add $0x1,%r10d
lea (%rdx,%rdx,4),%rsi
lea (%rdx,%rsi,2),%rdx
mov -0xb(%r9),%rsi
add %rax,%rdx
mov %rsi,(%rdx)
movzwl -0x3(%r9),%esi
mov %si,0x8(%rdx)
movzbl -0x1(%r9),%esi
mov %sil,0xa(%rdx)
cmp %rcx,%r9
jne 1420 <func0+0x60>
jmpq 144f <func0+0x8f>
xor %r10d,%r10d
jmpq 144f <func0+0x8f>
nopw %cs:0x0(%rax,%rax,1)
| 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
jle loc_148E
lea eax, [r15-1]
mov rsi, rbx
lea rdx, [rax+rax*4]
lea rax, [rax+rdx*2]
lea rdi, [rbx+rax+0Bh]
lea eax, [r13-1]
xor ebx, ebx
lea rdx, [rax+rax*4]
lea rax, [rax+rdx*2]
lea rcx, [rax+rbp+0Bh]
nop word ptr [rax+rax+00000000h]
loc_13F0:
test r14d, r14d
jle short loc_1458
movzx edx, byte ptr [rsi]
mov rax, rbp
jmp short loc_1409
loc_1400:
add rax, 0Bh
cmp rcx, rax
jz short loc_1458
loc_1409:
cmp dl, [rax]
jnz short loc_1400
add rsi, 0Bh
cmp rsi, rdi
jnz short loc_13F0
loc_1416:
test r13d, r13d
jle short loc_143F
movsxd rax, ebx
mov rsi, rbp
add ebx, r13d
lea rdx, [rax+rax*4]
lea rdi, [rax+rdx*2]
movsxd rax, r13d
lea rdx, [rax+rax*4]
add rdi, r12
lea rdx, [rax+rdx*2]
call _memcpy
loc_143F:
add rsp, 8
mov edx, ebx
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1458:
movsxd rax, ebx
add rsi, 0Bh
add ebx, 1
lea rdx, [rax+rax*4]
lea rax, [rax+rdx*2]
mov rdx, [rsi-0Bh]
add rax, r12
mov [rax], rdx
movzx edx, word ptr [rsi-3]
mov [rax+8], dx
movzx edx, byte ptr [rsi-1]
mov [rax+0Ah], dl
cmp rsi, rdi
jnz loc_13F0
jmp short loc_1416
loc_148E:
xor ebx, ebx
jmp short loc_1416 | 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
{
v10 = a1;
v11 = (long long)&a1[11 * (a2 - 1) + 11];
v12 = 0;
v8 = (long long)&a3[11 * (a4 - 1) + 11];
do
{
while ( a4 <= 0 )
{
LABEL_11:
v15 = v12;
v10 += 11;
++v12;
v16 = v9 + 11 * v15;
*(_QWORD *)v16 = *(_QWORD *)(v10 - 11);
*(_WORD *)(v16 + 8) = *(_WORD *)(v10 - 3);
*(_BYTE *)(v16 + 10) = *(v10 - 1);
if ( v10 == (_BYTE *)v11 )
goto LABEL_8;
}
v13 = a3;
while ( *v10 != *v13 )
{
v13 += 11;
if ( (_BYTE *)v8 == v13 )
goto LABEL_11;
}
v10 += 11;
}
while ( v10 != (_BYTE *)v11 );
}
LABEL_8:
if ( a4 > 0 )
memcpy(v9 + 11LL * v12, a3, 11LL * a4, v8);
return v9;
} | 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,[RAX + RAX*0x4]
LEA RAX,[RAX + RDX*0x2]
LEA RDI,[RBX + RAX*0x1 + 0xb]
LEA EAX,[R13 + -0x1]
XOR EBX,EBX
LEA RDX,[RAX + RAX*0x4]
LEA RAX,[RAX + RDX*0x2]
LEA RCX,[RAX + RBP*0x1 + 0xb]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013f0:
TEST R14D,R14D
JLE 0x00101458
MOVZX EDX,byte ptr [RSI]
MOV RAX,RBP
JMP 0x00101409
LAB_00101400:
ADD RAX,0xb
CMP RCX,RAX
JZ 0x00101458
LAB_00101409:
CMP DL,byte ptr [RAX]
JNZ 0x00101400
ADD RSI,0xb
CMP RSI,RDI
JNZ 0x001013f0
LAB_00101416:
TEST R13D,R13D
JLE 0x0010143f
MOVSXD RAX,EBX
MOV RSI,RBP
ADD EBX,R13D
LEA RDX,[RAX + RAX*0x4]
LEA RDI,[RAX + RDX*0x2]
MOVSXD RAX,R13D
LEA RDX,[RAX + RAX*0x4]
ADD RDI,R12
LEA RDX,[RAX + RDX*0x2]
CALL 0x001010c0
LAB_0010143f:
ADD RSP,0x8
MOV EDX,EBX
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101458:
MOVSXD RAX,EBX
ADD RSI,0xb
ADD EBX,0x1
LEA RDX,[RAX + RAX*0x4]
LEA RAX,[RAX + RDX*0x2]
MOV RDX,qword ptr [RSI + -0xb]
ADD RAX,R12
MOV qword ptr [RAX],RDX
MOVZX EDX,word ptr [RSI + -0x3]
MOV word ptr [RAX + 0x8],DX
MOVZX EDX,byte ptr [RSI + -0x1]
MOV byte ptr [RAX + 0xa],DL
CMP RSI,RDI
JNZ 0x001013f0
JMP 0x00101416
LAB_0010148e:
XOR EBX,EBX
JMP 0x00101416 | 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) * 0xb + 0xb;
iVar5 = 0;
do {
if (0 < param_4) {
pcVar2 = param_3;
do {
if (*param_1 == *pcVar2) goto joined_r0x00101414;
pcVar2 = pcVar2 + 0xb;
} while (param_3 + (ulong)(param_4 - 1) * 0xb + 0xb != pcVar2);
}
lVar3 = (long)iVar5;
iVar5 = iVar5 + 1;
puVar4 = (int8 *)(lVar3 * 0xb + (long)auVar6._0_8_);
*puVar4 = *(int8 *)param_1;
*(int2 *)(puVar4 + 1) = *(int2 *)(param_1 + 8);
*(char *)((long)puVar4 + 10) = param_1[10];
joined_r0x00101414:
param_1 = param_1 + 0xb;
} while (param_1 != pcVar1);
}
if (0 < param_4) {
lVar3 = (long)iVar5;
iVar5 = iVar5 + param_4;
memcpy((void *)(lVar3 * 0xb + (long)auVar6._0_8_),param_3,(long)param_4 * 0xb);
}
auVar6._8_4_ = iVar5;
auVar6._12_4_ = 0;
return auVar6;
} |
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 = 0; j < dict2.size; j++) {
if (dict1.items[i].key == dict2.items[j].key) {
found = 1;
break;
}
}
if (!found) {
merged_dict.items[k++] = dict1.items[i];
}
}
for (int i = 0; i < dict2.size; i++) {
merged_dict.items[k++] = dict2.items[i];
}
merged_dict.size = k;
return merged_dict;
}
| 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);
// More assertions could be added for individual dictionary items if needed.
DictItem items3[] = {{'O', "Orange"}, {'W', "White"}, {'B', "Black"}};
Dictionary dict3 = { items3, 3 };
Dictionary result2 = func0(dict1, dict3);
assert(result2.size == 5);
// More assertions could be added for individual dictionary items if needed.
Dictionary result3 = func0(dict2, dict3);
assert(result3.size == 4);
// More assertions could be added for individual dictionary items if needed.
free(result1.items);
free(result2.items);
free(result3.items);
return 0;
}
| 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 %r15d,%r15d
jle 14f6 <func0+0x116>
lea -0x1(%r15),%eax
mov %rbx,%rdi
lea (%rax,%rax,4),%rdx
lea (%rax,%rdx,2),%rax
lea 0xb(%rbx,%rax,1),%rcx
lea -0x1(%r13),%eax
xor %ebx,%ebx
lea (%rax,%rax,4),%rdx
lea (%rax,%rdx,2),%rax
lea 0xb(%rax,%rbp,1),%rsi
nopw %cs:0x0(%rax,%rax,1)
test %r14d,%r14d
jle 14c0 <func0+0xe0>
movzbl (%rdi),%edx
mov %rbp,%rax
jmp 1469 <func0+0x89>
nopl (%rax)
add $0xb,%rax
cmp %rax,%rsi
je 14c0 <func0+0xe0>
cmp (%rax),%dl
jne 1460 <func0+0x80>
add $0xb,%rdi
cmp %rcx,%rdi
jne 1450 <func0+0x70>
test %r13d,%r13d
jle 14a4 <func0+0xc4>
movslq %ebx,%rax
mov %rbp,%rsi
add %r13d,%ebx
lea (%rax,%rax,4),%rdx
lea (%rax,%rdx,2),%rdi
lea -0x1(%r13),%eax
add $0x1,%rax
add %r12,%rdi
lea (%rax,%rax,4),%rdx
lea (%rax,%rdx,2),%rdx
callq 10c0 <memcpy@plt>
add $0x8,%rsp
mov %ebx,%edx
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
movslq %ebx,%rax
add $0xb,%rdi
add $0x1,%ebx
lea (%rax,%rax,4),%rdx
lea (%rax,%rdx,2),%rax
mov -0xb(%rdi),%rdx
add %r12,%rax
mov %rdx,(%rax)
movzwl -0x3(%rdi),%edx
mov %dx,0x8(%rax)
movzbl -0x1(%rdi),%edx
mov %dl,0xa(%rax)
cmp %rcx,%rdi
jne 1450 <func0+0x70>
jmp 1476 <func0+0x96>
xor %ebx,%ebx
jmpq 1476 <func0+0x96>
nopl (%rax)
| 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, r13d
jle loc_1470
movsxd r13, r13d
mov rsi, r15
xor edi, edi
lea rax, [r13+r13*4+0]
lea r8, [r13+rax*2+0]
movsxd rax, r12d
lea rdx, [rax+rax*4]
add r8, r15
lea rcx, [rax+rdx*2]
add rcx, rbx
nop word ptr [rax+rax+00h]
loc_13D8:
test r14d, r14d
jle short loc_1440
loc_13DD:
movzx edx, byte ptr [rsi]
mov rax, rbx
jmp short loc_13F1
loc_13E8:
add rax, 0Bh
cmp rax, rcx
jz short loc_1440
loc_13F1:
cmp dl, [rax]
jnz short loc_13E8
add rsi, 0Bh
cmp r8, rsi
jnz short loc_13DD
mov r13d, edi
loc_1401:
test r12d, r12d
jle short loc_142A
movsxd rax, r13d
mov rsi, rbx; src
add r13d, r12d
lea rdx, [rax+rax*4]
lea rdi, [rax+rdx*2]
mov eax, r12d
lea rdx, [rax+rax*4]
add rdi, rbp; dest
lea rdx, [rax+rdx*2]; n
call _memcpy
loc_142A:
add rsp, 8
mov edx, r13d
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1440:
movsxd rax, edi
add rsi, 0Bh
lea r13d, [rdi+1]
lea rdx, [rax+rax*4]
lea rax, [rax+rdx*2]
mov rdx, [rsi-0Bh]
add rax, rbp
mov [rax], rdx
mov edx, [rsi-4]
mov [rax+7], edx
cmp r8, rsi
jz short loc_1401
mov edi, r13d
jmp loc_13D8
loc_1470:
xor r13d, r13d
jmp short loc_1401 | 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 = &a1[11 * a2];
while ( a4 <= 0 )
{
LABEL_12:
v10 += 11;
v14 = v11 + 1;
v16 = &v8[11 * v11];
*(_QWORD *)v16 = *(_QWORD *)(v10 - 11);
*(_DWORD *)(v16 + 7) = *((_DWORD *)v10 - 1);
if ( v12 == v10 )
goto LABEL_9;
++v11;
}
do
{
v13 = a3;
while ( *v10 != *v13 )
{
v13 += 11;
if ( v13 == &a3[11 * a4] )
goto LABEL_12;
}
v10 += 11;
}
while ( v12 != v10 );
v14 = v11;
}
LABEL_9:
if ( a4 > 0 )
memcpy(&v8[11 * v14], a3, 11LL * (unsigned int)a4);
return v8;
} | 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 RAX,[R13 + R13*0x4]
LEA R8,[R13 + RAX*0x2]
MOVSXD RAX,R12D
LEA RDX,[RAX + RAX*0x4]
ADD R8,R15
LEA RCX,[RAX + RDX*0x2]
ADD RCX,RBX
NOP word ptr [RAX + RAX*0x1]
LAB_001013d8:
TEST R14D,R14D
JLE 0x00101440
LAB_001013dd:
MOVZX EDX,byte ptr [RSI]
MOV RAX,RBX
JMP 0x001013f1
LAB_001013e8:
ADD RAX,0xb
CMP RAX,RCX
JZ 0x00101440
LAB_001013f1:
CMP DL,byte ptr [RAX]
JNZ 0x001013e8
ADD RSI,0xb
CMP R8,RSI
JNZ 0x001013dd
MOV R13D,EDI
LAB_00101401:
TEST R12D,R12D
JLE 0x0010142a
MOVSXD RAX,R13D
MOV RSI,RBX
ADD R13D,R12D
LEA RDX,[RAX + RAX*0x4]
LEA RDI,[RAX + RDX*0x2]
MOV EAX,R12D
LEA RDX,[RAX + RAX*0x4]
ADD RDI,RBP
LEA RDX,[RAX + RDX*0x2]
CALL 0x001010c0
LAB_0010142a:
ADD RSP,0x8
MOV EDX,R13D
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101440:
MOVSXD RAX,EDI
ADD RSI,0xb
LEA R13D,[RDI + 0x1]
LEA RDX,[RAX + RAX*0x4]
LEA RAX,[RAX + RDX*0x2]
MOV RDX,qword ptr [RSI + -0xb]
ADD RAX,RBP
MOV qword ptr [RAX],RDX
MOV EDX,dword ptr [RSI + -0x4]
MOV dword ptr [RAX + 0x7],EDX
CMP R8,RSI
JZ 0x00101401
MOV EDI,R13D
JMP 0x001013d8
LAB_00101470:
XOR R13D,R13D
JMP 0x00101401 | 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;
do {
if (0 < (int)param_4) {
do {
pcVar1 = param_3;
while (*pcVar4 != *pcVar1) {
pcVar1 = pcVar1 + 0xb;
if (pcVar1 == param_3 + (long)(int)param_4 * 0xb) goto LAB_00101440;
}
pcVar4 = pcVar4 + 0xb;
} while (param_1 + (long)param_2 * 0xb != pcVar4);
break;
}
LAB_00101440:
lVar2 = (long)iVar5;
pcVar1 = pcVar4 + 0xb;
iVar5 = iVar5 + 1;
puVar3 = (int8 *)(lVar2 * 0xb + (long)auVar6._0_8_);
*puVar3 = *(int8 *)pcVar4;
*(int4 *)((long)puVar3 + 7) = *(int4 *)(pcVar4 + 7);
pcVar4 = pcVar1;
} while (param_1 + (long)param_2 * 0xb != pcVar1);
}
if (0 < (int)param_4) {
lVar2 = (long)iVar5;
iVar5 = iVar5 + param_4;
memcpy((void *)(lVar2 * 0xb + (long)auVar6._0_8_),param_3,(ulong)param_4 * 0xb);
}
auVar6._8_4_ = iVar5;
auVar6._12_4_ = 0;
return auVar6;
} |
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])) {
hasLower = true;
} else if (isupper(p[i])) {
hasUpper = true;
} else if (isdigit(p[i])) {
hasDigit = true;
} else if (p[i] == '$' || p[i] == '#' || p[i] == '@') {
hasSpecial = true;
} else if (isspace(p[i])) {
return false;
}
}
return hasLower && hasUpper && hasDigit && hasSpecial;
}
| 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 $0xc,-0x4(%rbp)
jle 11ce <func0+0x45>
mov $0x0,%eax
jmpq 1336 <func0+0x1ad>
movl $0x0,-0x8(%rbp)
jmpq 1303 <func0+0x17a>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x200,%eax
test %eax,%eax
je 1214 <func0+0x8b>
movb $0x1,-0xc(%rbp)
jmpq 12ff <func0+0x176>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 124e <func0+0xc5>
movb $0x1,-0xb(%rbp)
jmpq 12ff <func0+0x176>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x800,%eax
test %eax,%eax
je 1285 <func0+0xfc>
movb $0x1,-0xa(%rbp)
jmp 12ff <func0+0x176>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x24,%al
je 12c1 <func0+0x138>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x23,%al
je 12c1 <func0+0x138>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x40,%al
jne 12c7 <func0+0x13e>
movb $0x1,-0x9(%rbp)
jmp 12ff <func0+0x176>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x2000,%eax
test %eax,%eax
je 12ff <func0+0x176>
mov $0x0,%eax
jmp 1336 <func0+0x1ad>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 11da <func0+0x51>
cmpb $0x0,-0xc(%rbp)
je 132e <func0+0x1a5>
cmpb $0x0,-0xb(%rbp)
je 132e <func0+0x1a5>
cmpb $0x0,-0xa(%rbp)
je 132e <func0+0x1a5>
cmpb $0x0,-0x9(%rbp)
je 132e <func0+0x1a5>
mov $0x1,%eax
jmp 1333 <func0+0x1aa>
mov $0x0,%eax
and $0x1,%eax
leaveq
retq
| 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], 0Ch
jle short loc_11CE
loc_11C4:
mov eax, 0
jmp locret_1336
loc_11CE:
mov [rbp+var_8], 0
jmp loc_1303
loc_11DA:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 200h
test eax, eax
jz short loc_1214
mov [rbp+var_C], 1
jmp loc_12FF
loc_1214:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz short loc_124E
mov [rbp+var_B], 1
jmp loc_12FF
loc_124E:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 800h
test eax, eax
jz short loc_1285
mov [rbp+var_A], 1
jmp short loc_12FF
loc_1285:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 24h ; '$'
jz short loc_12C1
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 23h ; '#'
jz short loc_12C1
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 40h ; '@'
jnz short loc_12C7
loc_12C1:
mov [rbp+var_9], 1
jmp short loc_12FF
loc_12C7:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 2000h
test eax, eax
jz short loc_12FF
mov eax, 0
jmp short locret_1336
loc_12FF:
add [rbp+var_8], 1
loc_1303:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jl loc_11DA
cmp [rbp+var_C], 0
jz short loc_132E
cmp [rbp+var_B], 0
jz short loc_132E
cmp [rbp+var_A], 0
jz short loc_132E
cmp [rbp+var_9], 0
jz short loc_132E
mov eax, 1
jmp short loc_1333
loc_132E:
mov eax, 0
loc_1333:
and eax, 1
locret_1336:
leave
retn | _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 )
return 0LL;
for ( i = 0; i < v8; ++i )
{
if ( ((*__ctype_b_loc())[a1[i]] & 0x200) != 0 )
{
v3 = 1;
}
else if ( ((*__ctype_b_loc())[a1[i]] & 0x100) != 0 )
{
v4 = 1;
}
else if ( ((*__ctype_b_loc())[a1[i]] & 0x800) != 0 )
{
v5 = 1;
}
else if ( a1[i] == 36 || a1[i] == 35 || a1[i] == 64 )
{
v6 = 1;
}
else if ( ((*__ctype_b_loc())[a1[i]] & 0x2000) != 0 )
{
return 0LL;
}
}
return v3 && v4 && v5 && v6;
} | 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],0x5
JLE 0x001011c4
CMP dword ptr [RBP + -0x4],0xc
JLE 0x001011ce
LAB_001011c4:
MOV EAX,0x0
JMP 0x00101336
LAB_001011ce:
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101303
LAB_001011da:
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x200
TEST EAX,EAX
JZ 0x00101214
MOV byte ptr [RBP + -0xc],0x1
JMP 0x001012ff
LAB_00101214:
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x0010124e
MOV byte ptr [RBP + -0xb],0x1
JMP 0x001012ff
LAB_0010124e:
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x800
TEST EAX,EAX
JZ 0x00101285
MOV byte ptr [RBP + -0xa],0x1
JMP 0x001012ff
LAB_00101285:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x24
JZ 0x001012c1
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x23
JZ 0x001012c1
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x40
JNZ 0x001012c7
LAB_001012c1:
MOV byte ptr [RBP + -0x9],0x1
JMP 0x001012ff
LAB_001012c7:
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x2000
TEST EAX,EAX
JZ 0x001012ff
MOV EAX,0x0
JMP 0x00101336
LAB_001012ff:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101303:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x001011da
CMP byte ptr [RBP + -0xc],0x0
JZ 0x0010132e
CMP byte ptr [RBP + -0xb],0x0
JZ 0x0010132e
CMP byte ptr [RBP + -0xa],0x0
JZ 0x0010132e
CMP byte ptr [RBP + -0x9],0x0
JZ 0x0010132e
MOV EAX,0x1
JMP 0x00101333
LAB_0010132e:
MOV EAX,0x0
LAB_00101333:
AND EAX,0x1
LAB_00101336:
LEAVE
RET | 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)) {
uVar6 = 0;
}
else {
for (local_10 = 0; local_10 < iVar5; local_10 = local_10 + 1) {
ppuVar8 = __ctype_b_loc();
if (((*ppuVar8)[param_1[local_10]] & 0x200) == 0) {
ppuVar8 = __ctype_b_loc();
if (((*ppuVar8)[param_1[local_10]] & 0x100) == 0) {
ppuVar8 = __ctype_b_loc();
if (((*ppuVar8)[param_1[local_10]] & 0x800) == 0) {
if (((param_1[local_10] == '$') || (param_1[local_10] == '#')) ||
(param_1[local_10] == '@')) {
bVar4 = true;
}
else {
ppuVar8 = __ctype_b_loc();
if (((*ppuVar8)[param_1[local_10]] & 0x2000) != 0) {
return 0;
}
}
}
else {
bVar3 = true;
}
}
else {
bVar2 = true;
}
}
else {
bVar1 = true;
}
}
if (((bVar1) && (bVar2)) && ((bVar3 && (bVar4)))) {
uVar6 = 1;
}
else {
uVar6 = 0;
}
}
return uVar6;
} |
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])) {
hasLower = true;
} else if (isupper(p[i])) {
hasUpper = true;
} else if (isdigit(p[i])) {
hasDigit = true;
} else if (p[i] == '$' || p[i] == '#' || p[i] == '@') {
hasSpecial = true;
} else if (isspace(p[i])) {
return false;
}
}
return hasLower && hasUpper && hasDigit && hasSpecial;
}
| 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 (%rax),%rdi
mov %rbx,%rdx
lea -0x1(%rbp),%eax
lea 0x1(%rbx,%rax,1),%r8
mov $0x0,%r12d
mov $0x0,%ebx
mov $0x0,%r11d
mov $0x0,%r10d
mov $0x1,%r9d
jmp 11db <func0+0x72>
mov %r9d,%r10d
add $0x1,%rdx
cmp %rdx,%r8
je 1222 <func0+0xb9>
movzbl (%rdx),%esi
movsbq %sil,%rax
movzwl (%rdi,%rax,2),%ecx
test $0x2,%ch
jne 11cf <func0+0x66>
test $0x1,%ch
jne 1213 <func0+0xaa>
test $0x8,%ch
jne 1218 <func0+0xaf>
lea -0x23(%rsi),%ebp
cmp $0x1,%bpl
setbe %al
cmp $0x40,%sil
sete %sil
or %sil,%al
jne 121d <func0+0xb4>
test $0x20,%ch
je 11d2 <func0+0x69>
jmp 1235 <func0+0xcc>
mov %r9d,%r11d
jmp 11d2 <func0+0x69>
mov %r9d,%ebx
jmp 11d2 <func0+0x69>
mov %eax,%r12d
jmp 11d2 <func0+0x69>
test %r10b,%r10b
je 1241 <func0+0xd8>
test %r11b,%r11b
je 1241 <func0+0xd8>
and %r12d,%ebx
movzbl %bl,%eax
and $0x1,%eax
pop %rbx
pop %rbp
pop %r12
retq
mov $0x0,%eax
jmp 1232 <func0+0xc9>
mov $0x0,%eax
jmp 1232 <func0+0xc9>
| 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 ebp, 0
mov ebx, 0
mov r11d, 0
mov r10d, 0
mov r9d, 1
jmp short loc_11F4
loc_11E8:
mov r10d, r9d
loc_11EB:
add rdx, 1
cmp r8, rdx
jz short loc_1238
loc_11F4:
movzx esi, byte ptr [rdx]
movsx rax, sil
movzx ecx, word ptr [rdi+rax*2]
test ch, 2
jnz short loc_11E8
test ch, 1
jnz short loc_122A
test ch, 8
jnz short loc_122F
lea eax, [rsi-23h]
cmp al, 1
setbe al
cmp sil, 40h ; '@'
setz sil
or al, sil
jnz short loc_1234
test ch, 20h
jz short loc_11EB
jmp short loc_124A
loc_122A:
mov r11d, r9d
jmp short loc_11EB
loc_122F:
mov ebx, r9d
jmp short loc_11EB
loc_1234:
mov ebp, eax
jmp short loc_11EB
loc_1238:
test r10b, r10b
jz short loc_1258
test r11b, r11b
jz short loc_1258
and ebx, ebp
movzx eax, bl
loc_1247:
and eax, 1
loc_124A:
add rsp, 8
pop rbx
pop rbp
retn
loc_1251:
mov eax, 0
jmp short loc_1247
loc_1258:
mov eax, 0
jmp short loc_1247 | 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;
if ( (unsigned int)(v2 - 6) <= 6 )
{
if ( v2 <= 0 )
{
v13 = 0;
}
else
{
v4 = *(_QWORD *)__ctype_b_loc();
v5 = a1;
v6 = (long long)&a1[v2 - 1 + 1];
v7 = 0;
v8 = 0;
v9 = 0;
v10 = 0;
do
{
v11 = *v5;
v12 = *(_WORD *)(v4 + 2LL * (char)v11);
if ( (v12 & 0x200) != 0 )
{
v10 = 1;
}
else if ( (v12 & 0x100) != 0 )
{
v9 = 1;
}
else if ( (v12 & 0x800) != 0 )
{
v8 = 1;
}
else
{
result = (unsigned int)(v11 - 35);
LOBYTE(result) = (_BYTE)v11 == 64 || (unsigned __int8)(v11 - 35) <= 1u;
if ( (_BYTE)result )
{
v7 = (_BYTE)v11 == 64 || (unsigned __int8)(v11 - 35) <= 1u;
}
else if ( (v12 & 0x2000) != 0 )
{
return result;
}
}
++v5;
}
while ( (unsigned __int8 *)v6 != v5 );
if ( v10 && v9 )
v13 = v7 & v8;
else
v13 = 0;
}
return v13 & 1;
}
return result;
} | 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,0x0
MOV R9D,0x1
JMP 0x001011f4
LAB_001011e8:
MOV R10D,R9D
LAB_001011eb:
ADD RDX,0x1
CMP R8,RDX
JZ 0x00101238
LAB_001011f4:
MOVZX ESI,byte ptr [RDX]
MOVSX RAX,SIL
MOVZX ECX,word ptr [RDI + RAX*0x2]
TEST CH,0x2
JNZ 0x001011e8
TEST CH,0x1
JNZ 0x0010122a
TEST CH,0x8
JNZ 0x0010122f
LEA EAX,[RSI + -0x23]
CMP AL,0x1
SETBE AL
CMP SIL,0x40
SETZ SIL
OR AL,SIL
JNZ 0x00101234
TEST CH,0x20
JZ 0x001011eb
JMP 0x0010124a
LAB_0010122a:
MOV R11D,R9D
JMP 0x001011eb
LAB_0010122f:
MOV EBX,R9D
JMP 0x001011eb
LAB_00101234:
MOV EBP,EAX
JMP 0x001011eb
LAB_00101238:
TEST R10B,R10B
JZ 0x00101258
TEST R11B,R11B
JZ 0x00101258
AND EBX,EBP
MOVZX EAX,BL
LAB_00101247:
AND EAX,0x1
LAB_0010124a:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00101251:
MOV EAX,0x0
JMP 0x00101247
LAB_00101258:
MOV EAX,0x0
JMP 0x00101247 | 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) {
if (iVar5 < 1) {
uVar11 = 0;
}
else {
ppuVar10 = __ctype_b_loc();
pbVar1 = param_1 + (ulong)(iVar5 - 1) + 1;
uVar11 = 0;
bVar8 = false;
bVar7 = false;
uVar13 = 0;
do {
bVar2 = *param_1;
uVar3 = (*ppuVar10)[(char)bVar2];
uVar12 = uVar13;
if ((uVar3 & 0x200) == 0) {
if ((uVar3 & 0x100) == 0) {
if ((uVar3 & 0x800) == 0) {
bVar4 = (byte)(bVar2 - 0x23) < 2;
uVar6 = CONCAT31((int3)(bVar2 - 0x23 >> 8),bVar4 || bVar2 == 0x40);
uVar12 = uVar6;
if ((!bVar4 && bVar2 != 0x40) && (uVar12 = uVar13, (uVar3 & 0x2000) != 0)) {
return uVar6;
}
}
else {
uVar11 = 1;
}
}
else {
bVar8 = true;
}
}
else {
bVar7 = true;
}
param_1 = param_1 + 1;
uVar13 = uVar12;
} while (pbVar1 != param_1);
if ((bVar7) && (bVar8)) {
uVar11 = uVar11 & uVar12;
}
else {
uVar11 = 0;
}
}
}
return uVar11;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.