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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
6,082 | func0 | #include <assert.h>
| int func0(int n) {
int i = 1;
int sum = 0;
while (n / i > 0) {
sum = sum + n / i;
i = i * 2;
}
return sum;
}
| int main() {
assert(func0(4) == 7);
assert(func0(2) == 3);
assert(func0(5) == 8);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
mov %edi,%eax
xor %r8d,%r8d
mov $0x1,%ecx
nopw 0x0(%rax,%rax,1)
add %eax,%r8d
mov %edi,%eax
add %ecx,%ecx
cltd
idiv %ecx
test %eax,%eax
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_1170
mov eax, edi
xor r8d, r8d
mov ecx, 1
nop word ptr [rax+rax+00h]
loc_1158:
add r8d, eax
mov eax, edi
add ecx, ecx
cdq
idiv ecx
test eax, eax
jnz short loc_1158
mov eax, r8d
retn
loc_1170:
xor r8d, r8d
mov eax, r8d
retn | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // r8d
int v3; // ecx
if ( a1 <= 0 )
return 0LL;
v1 = a1;
v2 = 0;
v3 = 1;
do
{
v2 += v1;
v3 *= 2;
v1 = a1 / v3;
}
while ( a1 / v3 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
MOV EAX,EDI
XOR R8D,R8D
MOV ECX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
ADD R8D,EAX
MOV EAX,EDI
ADD ECX,ECX
CDQ
IDIV ECX
TEST EAX,EAX
JNZ 0x00101158
MOV EAX,R8D
RET
LAB_00101170:
XOR R8D,R8D
MOV EAX,R8D
RET | int1 [16] func0(int param_1,int8 param_2,ulong param_3)
{
int1 auVar1 [16];
int iVar2;
int iVar3;
uint uVar4;
int1 auVar5 [16];
if (0 < param_1) {
uVar4 = 0;
iVar3 = 1;
iVar2 = param_1;
do {
uVar4 = uVar4 + iVar2;
iVar3 = iVar3 * 2;
iVar2 = param_1 / iVar3;
auVar5._8_8_ = (long)param_1 % (long)iVar3 & 0xffffffff;
} while (iVar2 != 0);
auVar5._4_4_ = 0;
auVar5._0_4_ = uVar4;
return auVar5;
}
auVar1._8_8_ = 0;
auVar1._0_8_ = param_3;
return auVar1 << 0x40;
} |
6,083 | func0 | #include <assert.h>
| int func0(int n) {
int i = 1;
int sum = 0;
while (n / i > 0) {
sum = sum + n / i;
i = i * 2;
}
return sum;
}
| int main() {
assert(func0(4) == 7);
assert(func0(2) == 3);
assert(func0(5) == 8);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
mov %edi,%eax
xor %r8d,%r8d
mov $0x1,%ecx
nopw 0x0(%rax,%rax,1)
add %eax,%r8d
mov %edi,%eax
add %ecx,%ecx
cltd
idiv %ecx
test %eax,%eax
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_1170
mov eax, edi
xor esi, esi
mov ecx, 1
nop dword ptr [rax+00000000h]
loc_1158:
add esi, eax
mov eax, edi
add ecx, ecx
cdq
idiv ecx
test eax, eax
jg short loc_1158
mov eax, esi
retn
loc_1170:
xor esi, esi
mov eax, esi
retn | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // esi
int v3; // ecx
if ( a1 <= 0 )
return 0LL;
v1 = a1;
v2 = 0;
v3 = 1;
do
{
v2 += v1;
v3 *= 2;
v1 = a1 / v3;
}
while ( a1 / v3 > 0 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
MOV EAX,EDI
XOR ESI,ESI
MOV ECX,0x1
NOP dword ptr [RAX]
LAB_00101158:
ADD ESI,EAX
MOV EAX,EDI
ADD ECX,ECX
CDQ
IDIV ECX
TEST EAX,EAX
JG 0x00101158
MOV EAX,ESI
RET
LAB_00101170:
XOR ESI,ESI
MOV EAX,ESI
RET | int [16] func0(int param_1,int8 param_2,ulong param_3)
{
int auVar1 [16];
int iVar2;
int iVar3;
uint uVar4;
int auVar5 [16];
if (0 < param_1) {
uVar4 = 0;
iVar3 = 1;
iVar2 = param_1;
do {
uVar4 = uVar4 + iVar2;
iVar3 = iVar3 * 2;
iVar2 = param_1 / iVar3;
auVar5._8_8_ = (long)param_1 % (long)iVar3 & 0xffffffff;
} while (0 < iVar2);
auVar5._4_4_ = 0;
auVar5._0_4_ = uVar4;
return auVar5;
}
auVar1._8_8_ = 0;
auVar1._0_8_ = param_3;
return auVar1 << 0x40;
} |
6,084 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int longest_increasing_subsequence[n];
for (int i = 0; i < n; i++) {
longest_increasing_subsequence[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] > arr[j] && longest_increasing_subsequence[i] < longest_increasing_subsequence[j] + 1) {
longest_increasing_subsequence[i] = longest_increasing_subsequence[j] + 1;
}
}
}
int maximum = 0;
for (int i = 0; i < n; i++) {
if (longest_increasing_subsequence[i] > maximum) {
maximum = longest_increasing_subsequence[i];
}
}
return maximum;
}
| int main() {
int arr1[] = {10, 22, 9, 33, 21, 50, 41, 60};
int n1 = sizeof(arr1)/sizeof(arr1[0]);
assert(func0(arr1, n1) == 5);
int arr2[] = {3, 10, 2, 1, 20};
int n2 = sizeof(arr2)/sizeof(arr2[0]);
assert(func0(arr2, n2) == 3);
int arr3[] = {50, 3, 10, 7, 40, 80};
int n3 = sizeof(arr3)/sizeof(arr3[0]);
assert(func0(arr3, n3) == 4);
printf("All test cases passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x4c(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 1228 <func0+0x9f>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1211 <func0+0x88>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1252 <func0+0xc9>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x20(%rbp)
movl $0x0,-0x30(%rbp)
jmp 1283 <func0+0xfa>
mov -0x20(%rbp),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
movl $0x1,(%rax,%rdx,4)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 126e <func0+0xe5>
movl $0x1,-0x34(%rbp)
jmpq 131b <func0+0x192>
movl $0x0,-0x38(%rbp)
jmp 130f <func0+0x186>
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x38(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x48(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 130b <func0+0x182>
mov -0x20(%rbp),%rax
mov -0x38(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,%ecx
jl 130b <func0+0x182>
mov -0x20(%rbp),%rax
mov -0x38(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
lea 0x1(%rax),%ecx
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x38(%rbp)
mov -0x38(%rbp),%eax
cmp -0x34(%rbp),%eax
jl 12a0 <func0+0x117>
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 1297 <func0+0x10e>
movl $0x0,-0x3c(%rbp)
movl $0x0,-0x2c(%rbp)
jmp 135d <func0+0x1d4>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,-0x3c(%rbp)
jge 1359 <func0+0x1d0>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %eax,-0x3c(%rbp)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 1337 <func0+0x1ae>
mov -0x3c(%rbp),%eax
mov %rsi,%rsp
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
je 137f <func0+0x1f6>
callq 1080 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_3C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11F6:
cmp rsp, rdx
jz short loc_120D
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11F6
loc_120D:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1237
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1237:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_2C], 0
jmp short loc_1268
loc_1253:
mov rax, [rbp+var_10]
mov edx, [rbp+var_2C]
movsxd rdx, edx
mov dword ptr [rax+rdx*4], 1
add [rbp+var_2C], 1
loc_1268:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_3C]
jl short loc_1253
mov [rbp+var_28], 1
jmp loc_1300
loc_127C:
mov [rbp+var_24], 0
jmp short loc_12F4
loc_1285:
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_24]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_12F0
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_10]
mov edx, [rbp+var_28]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp ecx, eax
jl short loc_12F0
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov eax, [rax+rdx*4]
lea ecx, [rax+1]
mov rax, [rbp+var_10]
mov edx, [rbp+var_28]
movsxd rdx, edx
mov [rax+rdx*4], ecx
loc_12F0:
add [rbp+var_24], 1
loc_12F4:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_28]
jl short loc_1285
add [rbp+var_28], 1
loc_1300:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_3C]
jl loc_127C
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
jmp short loc_1342
loc_131C:
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp [rbp+var_20], eax
jge short loc_133E
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov [rbp+var_20], eax
loc_133E:
add [rbp+var_1C], 1
loc_1342:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_3C]
jl short loc_131C
mov eax, [rbp+var_20]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1364
call ___stack_chk_fail
locret_1364:
leave
retn | long long func0(long long a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
_BYTE v5[4]; // [rsp+8h] [rbp-40h] BYREF
int v6; // [rsp+Ch] [rbp-3Ch]
long long v7; // [rsp+10h] [rbp-38h]
int i; // [rsp+1Ch] [rbp-2Ch]
int j; // [rsp+20h] [rbp-28h]
int k; // [rsp+24h] [rbp-24h]
unsigned int v11; // [rsp+28h] [rbp-20h]
int m; // [rsp+2Ch] [rbp-1Ch]
long long v13; // [rsp+30h] [rbp-18h]
_BYTE *v14; // [rsp+38h] [rbp-10h]
unsigned long long v15; // [rsp+40h] [rbp-8h]
v7 = a1;
v6 = a2;
v15 = __readfsqword(0x28u);
v13 = a2 - 1LL;
v2 = 16 * ((4LL * a2 + 15) / 0x10uLL);
while ( v5 != &v5[-(v2 & 0xFFFFFFFFFFFFF000LL)] )
;
v3 = alloca(v2 & 0xFFF);
if ( (v2 & 0xFFF) != 0 )
*(_QWORD *)&v5[(v2 & 0xFFF) - 8] = *(_QWORD *)&v5[(v2 & 0xFFF) - 8];
v14 = v5;
for ( i = 0; i < v6; ++i )
*(_DWORD *)&v14[4 * i] = 1;
for ( j = 1; j < v6; ++j )
{
for ( k = 0; k < j; ++k )
{
if ( *(_DWORD *)(4LL * j + v7) > *(_DWORD *)(4LL * k + v7) && *(_DWORD *)&v14[4 * k] >= *(_DWORD *)&v14[4 * j] )
*(_DWORD *)&v14[4 * j] = *(_DWORD *)&v14[4 * k] + 1;
}
}
v11 = 0;
for ( m = 0; m < v6; ++m )
{
if ( (signed int)v11 < *(_DWORD *)&v14[4 * m] )
v11 = *(_DWORD *)&v14[4 * m];
}
return v11;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011f6:
CMP RSP,RDX
JZ 0x0010120d
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011f6
LAB_0010120d:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101237
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101237:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x00101268
LAB_00101253:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],0x1
ADD dword ptr [RBP + -0x2c],0x1
LAB_00101268:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101253
MOV dword ptr [RBP + -0x28],0x1
JMP 0x00101300
LAB_0010127c:
MOV dword ptr [RBP + -0x24],0x0
JMP 0x001012f4
LAB_00101285:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x001012f0
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x28]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP ECX,EAX
JL 0x001012f0
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
LEA ECX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x28]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
LAB_001012f0:
ADD dword ptr [RBP + -0x24],0x1
LAB_001012f4:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x28]
JL 0x00101285
ADD dword ptr [RBP + -0x28],0x1
LAB_00101300:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x0010127c
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101342
LAB_0010131c:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP dword ptr [RBP + -0x20],EAX
JGE 0x0010133e
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV dword ptr [RBP + -0x20],EAX
LAB_0010133e:
ADD dword ptr [RBP + -0x1c],0x1
LAB_00101342:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x0010131c
MOV EAX,dword ptr [RBP + -0x20]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101364
CALL 0x00101080
LAB_00101364:
LEAVE
RET | int func0(long param_1,int param_2)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [4];
int local_44;
long local_40;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_40 = param_1;
local_44 = param_2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)param_2 + -1;
uVar2 = (((long)param_2 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_48; puVar3 != auStack_48 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
for (local_34 = 0; local_34 < local_44; local_34 = local_34 + 1) {
*(int4 *)(puVar3 + (long)local_34 * 4 + lVar1) = 1;
}
for (local_30 = 1; local_30 < local_44; local_30 = local_30 + 1) {
for (local_2c = 0; local_2c < local_30; local_2c = local_2c + 1) {
if ((*(int *)(local_40 + (long)local_2c * 4) < *(int *)(local_40 + (long)local_30 * 4)) &&
(*(int *)(puVar3 + (long)local_30 * 4 + lVar1) <=
*(int *)(puVar3 + (long)local_2c * 4 + lVar1))) {
*(int *)(puVar3 + (long)local_30 * 4 + lVar1) =
*(int *)(puVar3 + (long)local_2c * 4 + lVar1) + 1;
}
}
}
local_28 = 0;
for (local_24 = 0; local_24 < local_44; local_24 = local_24 + 1) {
if (local_28 < *(int *)(puVar3 + (long)local_24 * 4 + lVar1)) {
local_28 = *(int *)(puVar3 + (long)local_24 * 4 + lVar1);
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_28;
} |
6,085 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int longest_increasing_subsequence[n];
for (int i = 0; i < n; i++) {
longest_increasing_subsequence[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] > arr[j] && longest_increasing_subsequence[i] < longest_increasing_subsequence[j] + 1) {
longest_increasing_subsequence[i] = longest_increasing_subsequence[j] + 1;
}
}
}
int maximum = 0;
for (int i = 0; i < n; i++) {
if (longest_increasing_subsequence[i] > maximum) {
maximum = longest_increasing_subsequence[i];
}
}
return maximum;
}
| int main() {
int arr1[] = {10, 22, 9, 33, 21, 50, 41, 60};
int n1 = sizeof(arr1)/sizeof(arr1[0]);
assert(func0(arr1, n1) == 5);
int arr2[] = {3, 10, 2, 1, 20};
int n2 = sizeof(arr2)/sizeof(arr2[0]);
assert(func0(arr2, n2) == 3);
int arr3[] = {50, 3, 10, 7, 40, 80};
int n3 = sizeof(arr3)/sizeof(arr3[0]);
assert(func0(arr3, n3) == 4);
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %esi,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rcx
sub %rax,%rcx
mov %rcx,%rax
cmp %rax,%rsp
je 11dc <func0+0x53>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11c5 <func0+0x3c>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11f2 <func0+0x69>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%rdx
mov %rdx,%r9
shr $0x2,%r9
and $0xfffffffffffffffc,%rdx
mov %rdx,%r8
test %esi,%esi
jle 1223 <func0+0x9a>
mov %rdx,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdx,%rcx,4),%rdx
movl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1214 <func0+0x8b>
cmp $0x1,%esi
jle 1271 <func0+0xe8>
lea -0x2(%rsi),%r10d
add $0x2,%r10
mov $0x1,%edx
jmp 1262 <func0+0xd9>
add $0x1,%rax
cmp %rdx,%rax
je 1259 <func0+0xd0>
cmp (%rdi,%rax,4),%r9d
jle 1237 <func0+0xae>
mov (%r8,%rax,4),%ecx
cmp (%r8,%rdx,4),%ecx
jl 1237 <func0+0xae>
add $0x1,%ecx
mov %ecx,(%r8,%rdx,4)
jmp 1237 <func0+0xae>
add $0x1,%rdx
cmp %r10,%rdx
je 127a <func0+0xf1>
test %edx,%edx
jle 1259 <func0+0xd0>
mov (%rdi,%rdx,4),%r9d
mov $0x0,%eax
jmp 1240 <func0+0xb7>
je 12a8 <func0+0x11f>
mov $0x0,%edx
jmp 1295 <func0+0x10c>
mov $0x0,%eax
mov $0x0,%edx
mov (%r8,%rax,4),%ecx
cmp %ecx,%edx
cmovl %ecx,%edx
add $0x1,%rax
cmp %eax,%esi
jg 1284 <func0+0xfb>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 12c1 <func0+0x138>
mov %edx,%eax
leaveq
retq
cmpl $0x0,0x0(,%r9,4)
mov $0x0,%edx
cmovns 0x0(,%r9,4),%edx
jmp 1295 <func0+0x10c>
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov r9d, esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, esi
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11C5:
cmp rsp, rdx
jz short loc_11DC
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11C5
loc_11DC:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11F2
or [rsp+rax+10h+var_18], 0
loc_11F2:
lea rsi, [rsp+10h+var_D]
mov rcx, rsi
shr rcx, 2
and rsi, 0FFFFFFFFFFFFFFFCh
test r9d, r9d
jle short loc_1220
mov rax, rsi
mov edx, r9d
lea rdx, [rsi+rdx*4]
loc_1211:
mov dword ptr [rax], 1
add rax, 4
cmp rax, rdx
jnz short loc_1211
loc_1220:
cmp r9d, 1
jle short loc_1267
mov r10d, r9d
mov edx, 1
jmp short loc_1258
loc_1230:
add rax, 1
cmp rax, rdx
jz short loc_124F
loc_1239:
cmp r8d, [rdi+rax*4]
jle short loc_1230
mov ecx, [rsi+rax*4]
cmp ecx, [rsi+rdx*4]
jl short loc_1230
add ecx, 1
mov [rsi+rdx*4], ecx
jmp short loc_1230
loc_124F:
add rdx, 1
cmp rdx, r10
jz short loc_1270
loc_1258:
test edx, edx
jle short loc_124F
mov r8d, [rdi+rdx*4]
mov eax, 0
jmp short loc_1239
loc_1267:
jz short loc_129E
mov edx, 0
jmp short loc_128B
loc_1270:
mov eax, 0
mov edx, 0
loc_127A:
mov ecx, [rsi+rax*4]
cmp edx, ecx
cmovl edx, ecx
add rax, 1
cmp r9d, eax
jg short loc_127A
loc_128B:
mov rax, [rbp+var_8]
sub rax, fs:28h
jnz short loc_12B1
mov eax, edx
leave
retn
loc_129E:
mov edx, ds:dword_0[rcx*4]
test edx, edx
mov eax, 0
cmovs edx, eax
jmp short loc_128B
loc_12B1:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
signed long long v2; // rax
void *v3; // rsp
_DWORD *v4; // rax
long long i; // rdx
long long v6; // rax
int v7; // ecx
int v8; // r8d
unsigned int v9; // edx
long long v10; // rax
_DWORD v13[2]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v14; // [rsp+10h] [rbp-8h]
v14 = __readfsqword(0x28u);
while ( v13 != (_DWORD *)((char *)v13 - ((4LL * a2 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v2 = (4 * (_WORD)a2 + 15) & 0xFF0;
v3 = alloca(v2);
if ( ((4 * (_WORD)a2 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v13[-2] + v2) = *(_QWORD *)((char *)&v13[-2] + v2);
if ( a2 > 0 )
{
v4 = v13;
do
*v4++ = 1;
while ( v4 != &v13[a2] );
}
if ( a2 <= 1 )
{
if ( a2 == 1 )
{
v9 = v13[0];
if ( v13[0] < 0 )
return 0;
}
else
{
return 0;
}
}
else
{
for ( i = 1LL; i != a2; ++i )
{
if ( (int)i > 0 )
{
v8 = *(_DWORD *)(a1 + 4 * i);
v6 = 0LL;
do
{
if ( v8 > *(_DWORD *)(a1 + 4 * v6) )
{
v7 = v13[v6];
if ( v7 >= v13[i] )
v13[i] = v7 + 1;
}
++v6;
}
while ( v6 != i );
}
}
v10 = 0LL;
v9 = 0;
do
{
if ( (signed int)v9 < v13[v10] )
v9 = v13[v10];
++v10;
}
while ( a2 > (int)v10 );
}
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV R9D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011c5:
CMP RSP,RDX
JZ 0x001011dc
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011c5
LAB_001011dc:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011f2
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011f2:
LEA RSI,[RSP + 0x3]
MOV RCX,RSI
SHR RCX,0x2
AND RSI,-0x4
TEST R9D,R9D
JLE 0x00101220
MOV RAX,RSI
MOV EDX,R9D
LEA RDX,[RSI + RDX*0x4]
LAB_00101211:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101211
LAB_00101220:
CMP R9D,0x1
JLE 0x00101267
MOV R10D,R9D
MOV EDX,0x1
JMP 0x00101258
LAB_00101230:
ADD RAX,0x1
CMP RAX,RDX
JZ 0x0010124f
LAB_00101239:
CMP R8D,dword ptr [RDI + RAX*0x4]
JLE 0x00101230
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP ECX,dword ptr [RSI + RDX*0x4]
JL 0x00101230
ADD ECX,0x1
MOV dword ptr [RSI + RDX*0x4],ECX
JMP 0x00101230
LAB_0010124f:
ADD RDX,0x1
CMP RDX,R10
JZ 0x00101270
LAB_00101258:
TEST EDX,EDX
JLE 0x0010124f
MOV R8D,dword ptr [RDI + RDX*0x4]
MOV EAX,0x0
JMP 0x00101239
LAB_00101267:
JZ 0x0010129e
MOV EDX,0x0
JMP 0x0010128b
LAB_00101270:
MOV EAX,0x0
MOV EDX,0x0
LAB_0010127a:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x1
CMP R9D,EAX
JG 0x0010127a
LAB_0010128b:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012b1
MOV EAX,EDX
LEAVE
RET
LAB_0010129e:
MOV EDX,dword ptr [RCX*0x4]
TEST EDX,EDX
MOV EAX,0x0
CMOVS EDX,EAX
JMP 0x0010128b
LAB_001012b1:
CALL 0x00101080 | int func0(long param_1,uint param_2)
{
long lVar1;
int4 *puVar2;
ulong uVar3;
long lVar4;
int iVar5;
ulong uVar6;
int1 *puVar7;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar6 = (long)(int)param_2 * 4 + 0xf;
for (puVar7 = auStack_18; puVar7 != auStack_18 + -(uVar6 & 0xfffffffffffff000);
puVar7 = puVar7 + -0x1000) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
uVar6 = (ulong)((uint)uVar6 & 0xff0);
lVar1 = -uVar6;
puVar2 = (int4 *)(puVar7 + lVar1);
if (uVar6 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if (0 < (int)param_2) {
do {
*puVar2 = 1;
puVar2 = puVar2 + 1;
} while (puVar2 != (int4 *)(puVar7 + (ulong)param_2 * 4 + lVar1));
}
if ((int)param_2 < 2) {
if (param_2 == 1) {
iVar5 = *(int *)(puVar7 + lVar1);
if (*(int *)(puVar7 + lVar1) < 0) {
iVar5 = 0;
}
}
else {
iVar5 = 0;
}
}
else {
uVar6 = 1;
do {
if (0 < (int)uVar6) {
iVar5 = *(int *)(param_1 + uVar6 * 4);
uVar3 = 0;
do {
if ((*(int *)(param_1 + uVar3 * 4) < iVar5) &&
(*(int *)(puVar7 + uVar6 * 4 + lVar1) <= *(int *)(puVar7 + uVar3 * 4 + lVar1))) {
*(int *)(puVar7 + uVar6 * 4 + lVar1) = *(int *)(puVar7 + uVar3 * 4 + lVar1) + 1;
}
uVar3 = uVar3 + 1;
} while (uVar3 != uVar6);
}
uVar6 = uVar6 + 1;
} while (uVar6 != param_2);
lVar4 = 0;
iVar5 = 0;
do {
if (iVar5 < *(int *)(puVar7 + lVar4 * 4 + lVar1)) {
iVar5 = *(int *)(puVar7 + lVar4 * 4 + lVar1);
}
lVar4 = lVar4 + 1;
} while ((int)lVar4 < (int)param_2);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar7 + lVar1 + -8) = main;
__stack_chk_fail();
}
return iVar5;
} |
6,086 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int longest_increasing_subsequence[n];
for (int i = 0; i < n; i++) {
longest_increasing_subsequence[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] > arr[j] && longest_increasing_subsequence[i] < longest_increasing_subsequence[j] + 1) {
longest_increasing_subsequence[i] = longest_increasing_subsequence[j] + 1;
}
}
}
int maximum = 0;
for (int i = 0; i < n; i++) {
if (longest_increasing_subsequence[i] > maximum) {
maximum = longest_increasing_subsequence[i];
}
}
return maximum;
}
| int main() {
int arr1[] = {10, 22, 9, 33, 21, 50, 41, 60};
int n1 = sizeof(arr1)/sizeof(arr1[0]);
assert(func0(arr1, n1) == 5);
int arr2[] = {3, 10, 2, 1, 20};
int n2 = sizeof(arr2)/sizeof(arr2[0]);
assert(func0(arr2, n2) == 3);
int arr3[] = {50, 3, 10, 7, 40, 80};
int n3 = sizeof(arr3)/sizeof(arr3[0]);
assert(func0(arr3, n3) == 4);
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rcx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je 1356 <func0+0x56>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1341 <func0+0x41>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1417 <func0+0x117>
lea 0x3(%rsp),%r8
mov %r8,%rcx
and $0xfffffffffffffffc,%r8
shr $0x2,%rcx
test %esi,%esi
jle 1422 <func0+0x122>
lea -0x1(%rsi),%edx
mov %r8,%rax
lea 0x4(%r8,%rdx,4),%rdx
nopl 0x0(%rax,%rax,1)
movl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1390 <func0+0x90>
cmp $0x1,%esi
jle 1422 <func0+0x122>
lea -0x2(%rsi),%r10d
mov $0x1,%edx
add $0x2,%r10
nopl 0x0(%rax)
mov (%rdi,%rdx,4),%r9d
xor %eax,%eax
xchg %ax,%ax
cmp (%rdi,%rax,4),%r9d
jle 13d7 <func0+0xd7>
mov (%r8,%rax,4),%ecx
cmp (%r8,%rdx,4),%ecx
jl 13d7 <func0+0xd7>
add $0x1,%ecx
mov %ecx,(%r8,%rdx,4)
add $0x1,%rax
cmp %rax,%rdx
jne 13c0 <func0+0xc0>
add $0x1,%rdx
cmp %rdx,%r10
jne 13b8 <func0+0xb8>
xor %eax,%eax
xor %r9d,%r9d
xchg %ax,%ax
mov (%r8,%rax,4),%edx
cmp %edx,%r9d
cmovl %edx,%r9d
add $0x1,%rax
cmp %eax,%esi
jg 13f0 <func0+0xf0>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 1445 <func0+0x145>
leaveq
mov %r9d,%eax
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1368 <func0+0x68>
cmp $0x1,%esi
je 142c <func0+0x12c>
xor %r9d,%r9d
jmp 1403 <func0+0x103>
cmpl $0x0,0x0(,%rcx,4)
mov $0x0,%r9d
cmovns 0x0(,%rcx,4),%r9d
jmp 1403 <func0+0x103>
callq 1080 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
movsxd r10, esi
mov r9, r10
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, ds:0Fh[r10*4]
mov rcx, rsp
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1356
loc_1341:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rcx
jnz short loc_1341
loc_1356:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1417
loc_1368:
lea rsi, [rsp+1010h+var_100D]
mov rcx, rsi
and rsi, 0FFFFFFFFFFFFFFFCh
shr rcx, 2
test r9d, r9d
jle loc_1422
mov edx, r9d
mov rax, rsi
lea rdx, [rsi+rdx*4]
nop dword ptr [rax+rax+00h]
loc_1390:
mov dword ptr [rax], 1
add rax, 4
cmp rax, rdx
jnz short loc_1390
cmp r9d, 1
jle short loc_1422
mov edx, 1
nop word ptr [rax+rax+00h]
loc_13B0:
mov r8d, [rdi+rdx*4]
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_13C0:
cmp r8d, [rdi+rax*4]
jle short loc_13D4
mov ecx, [rsi+rax*4]
cmp ecx, [rsi+rdx*4]
jl short loc_13D4
add ecx, 1
mov [rsi+rdx*4], ecx
loc_13D4:
add rax, 1
cmp rdx, rax
jnz short loc_13C0
add rdx, 1
cmp rdx, r10
jnz short loc_13B0
xor eax, eax
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_13F0:
mov edx, [rsi+rax*4]
cmp r8d, edx
cmovl r8d, edx
add rax, 1
cmp r9d, eax
jg short loc_13F0
loc_1403:
mov rax, [rbp+var_8]
sub rax, fs:28h
jnz short loc_1440
leave
mov eax, r8d
retn
loc_1417:
or [rsp+rdx+1010h+var_1018], 0
jmp loc_1368
loc_1422:
cmp r9d, 1
jz short loc_142D
xor r8d, r8d
jmp short loc_1403
loc_142D:
mov r8d, ds:dword_0[rcx*4]
xor eax, eax
test r8d, r8d
cmovs r8d, eax
jmp short loc_1403
loc_1440:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
long long v2; // rdx
_DWORD *v3; // rcx
__int16 v4; // dx
signed long long v5; // rdx
void *v6; // rsp
_DWORD *v7; // rax
long long i; // rdx
int v9; // r8d
long long v10; // rax
int v11; // ecx
long long v12; // rax
unsigned int v13; // r8d
_DWORD v16[1022]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v17[2]; // [rsp+1008h] [rbp-10h] BYREF
v17[1] = __readfsqword(0x28u);
v2 = 4LL * a2 + 15;
v3 = (_DWORD *)((char *)v17 - (v2 & 0xFFFFFFFFFFFFF000LL));
v4 = v2 & 0xFFF0;
if ( v17 != (_QWORD *)v3 )
{
while ( v16 != v3 )
;
}
v5 = v4 & 0xFFF;
v6 = alloca(v5);
if ( v5 )
*(_QWORD *)((char *)&v16[-2] + v5) = *(_QWORD *)((char *)&v16[-2] + v5);
if ( a2 <= 0 )
goto LABEL_21;
v7 = v16;
do
*v7++ = 1;
while ( v7 != &v16[a2] );
if ( a2 <= 1 )
{
LABEL_21:
if ( a2 == 1 )
{
v13 = v16[0];
if ( v16[0] < 0 )
return 0;
}
else
{
return 0;
}
}
else
{
for ( i = 1LL; i != a2; ++i )
{
v9 = *(_DWORD *)(a1 + 4 * i);
v10 = 0LL;
do
{
if ( v9 > *(_DWORD *)(a1 + 4 * v10) )
{
v11 = v16[v10];
if ( v11 >= v16[i] )
v16[i] = v11 + 1;
}
++v10;
}
while ( i != v10 );
}
v12 = 0LL;
v13 = 0;
do
{
if ( (signed int)v13 < v16[v12] )
v13 = v16[v12];
++v12;
}
while ( a2 > (int)v12 );
}
return v13;
} | func0:
ENDBR64
PUSH RBP
MOVSXD R10,ESI
MOV R9,R10
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0xf + R10*0x4]
MOV RCX,RSP
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101356
LAB_00101341:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101341
LAB_00101356:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101417
LAB_00101368:
LEA RSI,[RSP + 0x3]
MOV RCX,RSI
AND RSI,-0x4
SHR RCX,0x2
TEST R9D,R9D
JLE 0x00101422
MOV EDX,R9D
MOV RAX,RSI
LEA RDX,[RSI + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101390:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101390
CMP R9D,0x1
JLE 0x00101422
MOV EDX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_001013b0:
MOV R8D,dword ptr [RDI + RDX*0x4]
XOR EAX,EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013c0:
CMP R8D,dword ptr [RDI + RAX*0x4]
JLE 0x001013d4
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP ECX,dword ptr [RSI + RDX*0x4]
JL 0x001013d4
ADD ECX,0x1
MOV dword ptr [RSI + RDX*0x4],ECX
LAB_001013d4:
ADD RAX,0x1
CMP RDX,RAX
JNZ 0x001013c0
ADD RDX,0x1
CMP RDX,R10
JNZ 0x001013b0
XOR EAX,EAX
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_001013f0:
MOV EDX,dword ptr [RSI + RAX*0x4]
CMP R8D,EDX
CMOVL R8D,EDX
ADD RAX,0x1
CMP R9D,EAX
JG 0x001013f0
LAB_00101403:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101440
LEAVE
MOV EAX,R8D
RET
LAB_00101417:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101368
LAB_00101422:
CMP R9D,0x1
JZ 0x0010142d
XOR R8D,R8D
JMP 0x00101403
LAB_0010142d:
MOV R8D,dword ptr [RCX*0x4]
XOR EAX,EAX
TEST R8D,R8D
CMOVS R8D,EAX
JMP 0x00101403
LAB_00101440:
CALL 0x00101080 | int func0(long param_1,uint param_2)
{
long lVar1;
int1 *puVar2;
int4 *puVar3;
long lVar4;
ulong uVar5;
long lVar6;
int1 *puVar7;
int iVar9;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar8;
puVar7 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar5 = (long)(int)param_2 * 4 + 0xf;
puVar8 = auStack_18;
puVar2 = auStack_18;
while (puVar8 != auStack_18 + -(uVar5 & 0xfffffffffffff000)) {
puVar7 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar8 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar5 = (ulong)((uint)uVar5 & 0xff0);
lVar1 = -uVar5;
puVar3 = (int4 *)(puVar7 + lVar1);
if (uVar5 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if (0 < (int)param_2) {
do {
*puVar3 = 1;
puVar3 = puVar3 + 1;
} while (puVar3 != (int4 *)(puVar7 + (ulong)param_2 * 4 + lVar1));
if (1 < (int)param_2) {
lVar6 = 1;
do {
iVar9 = *(int *)(param_1 + lVar6 * 4);
lVar4 = 0;
do {
if ((*(int *)(param_1 + lVar4 * 4) < iVar9) &&
(*(int *)(puVar7 + lVar6 * 4 + lVar1) <= *(int *)(puVar7 + lVar4 * 4 + lVar1))) {
*(int *)(puVar7 + lVar6 * 4 + lVar1) = *(int *)(puVar7 + lVar4 * 4 + lVar1) + 1;
}
lVar4 = lVar4 + 1;
} while (lVar6 != lVar4);
lVar6 = lVar6 + 1;
} while (lVar6 != (int)param_2);
lVar6 = 0;
iVar9 = 0;
do {
if (iVar9 < *(int *)(puVar7 + lVar6 * 4 + lVar1)) {
iVar9 = *(int *)(puVar7 + lVar6 * 4 + lVar1);
}
lVar6 = lVar6 + 1;
} while ((int)lVar6 < (int)param_2);
goto LAB_00101403;
}
}
if (param_2 == 1) {
iVar9 = *(int *)(puVar7 + lVar1);
if (*(int *)(puVar7 + lVar1) < 0) {
iVar9 = 0;
}
}
else {
iVar9 = 0;
}
LAB_00101403:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar9;
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + lVar1 + -8) = 0x101445;
__stack_chk_fail();
} |
6,087 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int longest_increasing_subsequence[n];
for (int i = 0; i < n; i++) {
longest_increasing_subsequence[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] > arr[j] && longest_increasing_subsequence[i] < longest_increasing_subsequence[j] + 1) {
longest_increasing_subsequence[i] = longest_increasing_subsequence[j] + 1;
}
}
}
int maximum = 0;
for (int i = 0; i < n; i++) {
if (longest_increasing_subsequence[i] > maximum) {
maximum = longest_increasing_subsequence[i];
}
}
return maximum;
}
| int main() {
int arr1[] = {10, 22, 9, 33, 21, 50, 41, 60};
int n1 = sizeof(arr1)/sizeof(arr1[0]);
assert(func0(arr1, n1) == 5);
int arr2[] = {3, 10, 2, 1, 20};
int n2 = sizeof(arr2)/sizeof(arr2[0]);
assert(func0(arr2, n2) == 3);
int arr3[] = {50, 3, 10, 7, 40, 80};
int n3 = sizeof(arr3)/sizeof(arr3[0]);
assert(func0(arr3, n3) == 4);
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rcx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je 1316 <func0+0x56>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1301 <func0+0x41>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 14d0 <func0+0x210>
lea 0x3(%rsp),%r8
mov %r8,%r11
and $0xfffffffffffffffc,%r8
shr $0x2,%r11
test %esi,%esi
jle 14db <func0+0x21b>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 14e4 <func0+0x224>
mov %esi,%edx
movdqa 0xd4a(%rip),%xmm0
mov %r8,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %r8,%rdx
nopl 0x0(%rax,%rax,1)
movups %xmm0,(%rax)
add $0x10,%rax
cmp %rdx,%rax
jne 1368 <func0+0xa8>
mov %esi,%eax
and $0xfffffffc,%eax
test $0x3,%sil
je 13ad <func0+0xed>
movslq %eax,%rdx
movl $0x1,(%r8,%rdx,4)
lea 0x1(%rax),%edx
cmp %edx,%esi
jle 13ad <func0+0xed>
movslq %edx,%rdx
add $0x2,%eax
movl $0x1,(%r8,%rdx,4)
cmp %eax,%esi
jle 13ad <func0+0xed>
cltq
movl $0x1,(%r8,%rax,4)
cmp $0x1,%esi
jle 14db <func0+0x21b>
lea -0x2(%rsi),%r10d
mov $0x1,%edx
add $0x2,%r10
nopl 0x0(%rax,%rax,1)
mov (%rdi,%rdx,4),%r9d
xor %eax,%eax
xchg %ax,%ax
cmp (%rdi,%rax,4),%r9d
jle 13e7 <func0+0x127>
mov (%r8,%rax,4),%ecx
cmp (%r8,%rdx,4),%ecx
jl 13e7 <func0+0x127>
add $0x1,%ecx
mov %ecx,(%r8,%rdx,4)
add $0x1,%rax
cmp %rdx,%rax
jne 13d0 <func0+0x110>
lea 0x1(%rax),%rdx
cmp %r10,%rdx
jne 13c8 <func0+0x108>
test %esi,%esi
mov $0x1,%ecx
cmovg %esi,%ecx
cmp $0x3,%esi
jle 14eb <func0+0x22b>
mov %ecx,%edx
pxor %xmm2,%xmm2
mov %r8,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %r8,%rdx
movdqu (%rax),%xmm0
add $0x10,%rax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rdx,%rax
jne 1420 <func0+0x160>
movdqa %xmm2,%xmm1
mov %ecx,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
and $0x3,%ecx
movdqa %xmm1,%xmm0
pcmpgtd %xmm2,%xmm0
pand %xmm0,%xmm1
pandn %xmm2,%xmm0
por %xmm0,%xmm1
movdqa %xmm1,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm0
pcmpgtd %xmm1,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm2,%xmm0
movd %xmm0,%eax
je 14bf <func0+0x1ff>
movslq %edx,%rcx
mov (%r8,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x1,%edx
cmp %edx,%esi
jle 14bf <func0+0x1ff>
movslq %edx,%rcx
mov (%r8,%rcx,4),%ecx
cmp %ecx,%eax
cmovl %ecx,%eax
add $0x1,%edx
cmp %edx,%esi
jle 14bf <func0+0x1ff>
movslq %edx,%rdx
mov (%r8,%rdx,4),%edx
cmp %edx,%eax
cmovl %edx,%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
jne 1523 <func0+0x263>
leaveq
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1328 <func0+0x68>
cmp $0x1,%esi
je 150a <func0+0x24a>
xor %eax,%eax
jmp 14bf <func0+0x1ff>
xor %eax,%eax
jmpq 137f <func0+0xbf>
mov 0x0(,%r11,4),%eax
mov $0x1,%edx
test %eax,%eax
mov $0x0,%eax
cmovns 0x0(,%r11,4),%eax
jmp 14a0 <func0+0x1e0>
cmpl $0x0,0x0(,%r11,4)
mov $0x0,%eax
cmovns 0x0(,%r11,4),%eax
jmp 14bf <func0+0x1ff>
callq 1080 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov r9d, esi
mov rbp, rsp
push r12
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
movsxd rax, esi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1319
loc_1304:
sub rsp, 1000h
or [rsp+1020h+var_28], 0
cmp rsp, rcx
jnz short loc_1304
loc_1319:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_14E0
loc_132B:
lea rsi, [rsp+1020h+var_101D]
mov r12, rsi
and rsi, 0FFFFFFFFFFFFFFFCh
shr r12, 2
mov r11, rsi
test r9d, r9d
jle loc_14EB
lea ebx, [r9-1]
cmp ebx, 2
jbe loc_14EF
mov edx, r9d
movdqa xmm0, cs:xmmword_2080
mov rax, rsi
shr edx, 2
shl rdx, 4
lea rcx, [rsi+rdx]
and edx, 10h
jz short loc_1380
lea rax, [rsi+10h]
movups xmmword ptr [rsi], xmm0
cmp rax, rcx
jz short loc_1390
xchg ax, ax
loc_1380:
movups xmmword ptr [rax], xmm0
add rax, 20h ; ' '
movups xmmword ptr [rax-10h], xmm0
cmp rax, rcx
jnz short loc_1380
loc_1390:
mov eax, r9d
and eax, 0FFFFFFFCh
test r9b, 3
jz short loc_13C6
mov edx, eax
lea ecx, [rax+1]
lea rdx, [rsi+rdx*4]
mov dword ptr [rdx], 1
cmp r9d, ecx
jle short loc_13C6
loc_13B0:
add eax, 2
mov dword ptr [rdx+4], 1
cmp r9d, eax
jle short loc_13C6
mov dword ptr [rdx+8], 1
loc_13C6:
mov r10d, r9d
mov edx, 4
shl r10, 2
nop word ptr [rax+rax+00h]
loc_13D8:
mov r8d, [rdi+rdx]
xor eax, eax
xchg ax, ax
loc_13E0:
cmp r8d, [rdi+rax]
jle short loc_13F4
mov ecx, [rsi+rax]
cmp ecx, [rsi+rdx]
jl short loc_13F4
add ecx, 1
mov [rsi+rdx], ecx
loc_13F4:
add rax, 4
cmp rax, rdx
jnz short loc_13E0
lea rdx, [rax+4]
cmp rdx, r10
jnz short loc_13D8
cmp ebx, 2
jbe loc_1511
mov edx, r9d
mov rax, rsi
pxor xmm2, xmm2
shr edx, 2
shl rdx, 4
add rdx, rsi
nop dword ptr [rax+rax+00h]
loc_1428:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rdx, rax
jnz short loc_1428
movdqa xmm0, xmm2
mov edx, r9d
psrldq xmm0, 8
and edx, 0FFFFFFFCh
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
por xmm1, xmm0
movdqa xmm2, xmm1
psrldq xmm2, 4
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm2, xmm0
pandn xmm0, xmm1
por xmm0, xmm2
movd eax, xmm0
test r9b, 3
jz short loc_14C8
movsxd rcx, edx
lea r11, [rsi+rcx*4]
mov ecx, [r11]
cmp eax, ecx
cmovl eax, ecx
lea ecx, [rdx+1]
cmp ecx, r9d
jge short loc_14C8
loc_14AE:
mov ecx, [r11+4]
cmp eax, ecx
cmovl eax, ecx
add edx, 2
cmp r9d, edx
jle short loc_14C8
mov edx, [r11+8]
cmp eax, edx
cmovl eax, edx
loc_14C8:
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jnz short loc_1522
lea rsp, [rbp-10h]
pop rbx
pop r12
pop rbp
retn
loc_14E0:
or [rsp+rdx+1020h+var_1028], 0
jmp loc_132B
loc_14EB:
xor eax, eax
jmp short loc_14C8
loc_14EF:
mov ds:dword_0[r12*4], 1
mov rdx, rsi
xor eax, eax
cmp r9d, 1
jnz loc_13B0
mov eax, 1
jmp short loc_14C8
loc_1511:
mov eax, ds:dword_0[r12*4]
xor edx, edx
test eax, eax
cmovs eax, edx
jmp short loc_14AE
loc_1522:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
long long v2; // rdx
__m128i *v3; // rcx
__int16 v4; // dx
signed long long v5; // rdx
void *v6; // rsp
int *v7; // r11
__m128i si128; // xmm0
__m128i *v9; // rax
long long v10; // rdx
__m128i *v11; // rcx
int v12; // eax
__m128i *v13; // rdx
long long v14; // rdx
int v15; // r8d
unsigned long long v16; // rax
__int32 v17; // ecx
const __m128i *v18; // rax
__m128i v19; // xmm2
__m128i v20; // xmm0
__m128i v21; // xmm1
__m128i v22; // xmm0
unsigned int v23; // edx
__m128i v24; // xmm1
__m128i v25; // xmm1
__m128i v26; // xmm2
__m128i v27; // xmm0
long long result; // rax
int v29; // ecx
int v30; // edx
long long v31; // [rsp+0h] [rbp-1028h]
__m128i v32; // [rsp+8h] [rbp-1020h] BYREF
_BYTE v33[4072]; // [rsp+18h] [rbp-1010h] BYREF
_QWORD v34[4]; // [rsp+1008h] [rbp-20h] BYREF
v34[1] = __readfsqword(0x28u);
v2 = 4LL * a2 + 15;
v3 = (__m128i *)((char *)v34 - (v2 & 0xFFFFFFFFFFFFF000LL));
v4 = v2 & 0xFFF0;
if ( v34 != (_QWORD *)v3 )
{
while ( &v32 != v3 )
;
}
v5 = v4 & 0xFFF;
v6 = alloca(v5);
if ( v5 )
*(long long *)((char *)&v31 + v5) = *(long long *)((char *)&v31 + v5);
v7 = (int *)&v32;
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v32.m128i_i32[0] = 1;
v13 = &v32;
v12 = 0;
if ( a2 == 1 )
return 1LL;
goto LABEL_12;
}
si128 = _mm_load_si128((const __m128i *)&xmmword_2080);
v9 = &v32;
v10 = 16LL * ((unsigned int)a2 >> 2);
v11 = (__m128i *)((char *)&v32 + v10);
if ( (v10 & 0x10) == 0 || (v9 = (__m128i *)v33, v32 = si128, v33 != (_BYTE *)v11) )
{
do
{
*v9 = si128;
v9 += 2;
v9[-1] = si128;
}
while ( v9 != v11 );
}
v12 = a2 & 0x7FFFFFFC;
if ( (a2 & 3) != 0 )
{
v13 = (__m128i *)((char *)&v32 + 4 * (unsigned int)v12);
v13->m128i_i32[0] = 1;
if ( a2 > v12 + 1 )
{
LABEL_12:
v13->m128i_i32[1] = 1;
if ( a2 > v12 + 2 )
v13->m128i_i32[2] = 1;
}
}
v14 = 4LL;
do
{
v15 = *(_DWORD *)(a1 + v14);
v16 = 0LL;
do
{
if ( v15 > *(_DWORD *)(a1 + v16) )
{
v17 = v32.m128i_i32[v16 / 4];
if ( v17 >= *(__int32 *)((char *)v32.m128i_i32 + v14) )
*(__int32 *)((char *)v32.m128i_i32 + v14) = v17 + 1;
}
v16 += 4LL;
}
while ( v16 != v14 );
v14 = v16 + 4;
}
while ( v16 + 4 != 4LL * (unsigned int)a2 );
if ( (unsigned int)(a2 - 1) <= 2 )
{
result = v32.m128i_u32[0];
v23 = 0;
if ( v32.m128i_i32[0] < 0 )
result = 0LL;
goto LABEL_28;
}
v18 = &v32;
v19 = 0LL;
do
{
v20 = _mm_loadu_si128(v18++);
v21 = _mm_cmpgt_epi32(v20, v19);
v19 = _mm_or_si128(_mm_andnot_si128(v21, v19), _mm_and_si128(v20, v21));
}
while ( &v32 + ((unsigned int)a2 >> 2) != v18 );
v22 = _mm_srli_si128(v19, 8);
v23 = a2 & 0xFFFFFFFC;
v24 = _mm_cmpgt_epi32(v22, v19);
v25 = _mm_or_si128(_mm_andnot_si128(v24, v19), _mm_and_si128(v22, v24));
v26 = _mm_srli_si128(v25, 4);
v27 = _mm_cmpgt_epi32(v26, v25);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v27, v25), _mm_and_si128(v26, v27)));
if ( (a2 & 3) != 0 )
{
v7 = &v32.m128i_i32[v23];
if ( (int)result < *v7 )
result = (unsigned int)*v7;
if ( (int)(v23 + 1) < a2 )
{
LABEL_28:
v29 = v7[1];
if ( (int)result < v29 )
result = (unsigned int)v29;
if ( a2 > (int)(v23 + 2) )
{
v30 = v7[2];
if ( (int)result < v30 )
return (unsigned int)v30;
}
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV R9D,ESI
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101319
LAB_00101304:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101304
LAB_00101319:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001014e0
LAB_0010132b:
LEA RSI,[RSP + 0x3]
MOV R12,RSI
AND RSI,-0x4
SHR R12,0x2
MOV R11,RSI
TEST R9D,R9D
JLE 0x001014eb
LEA EBX,[R9 + -0x1]
CMP EBX,0x2
JBE 0x001014ef
MOV EDX,R9D
MOVDQA XMM0,xmmword ptr [0x00102080]
MOV RAX,RSI
SHR EDX,0x2
SHL RDX,0x4
LEA RCX,[RSI + RDX*0x1]
AND EDX,0x10
JZ 0x00101380
LEA RAX,[RSI + 0x10]
MOVUPS xmmword ptr [RSI],XMM0
CMP RAX,RCX
JZ 0x00101390
NOP
LAB_00101380:
MOVUPS xmmword ptr [RAX],XMM0
ADD RAX,0x20
MOVUPS xmmword ptr [RAX + -0x10],XMM0
CMP RAX,RCX
JNZ 0x00101380
LAB_00101390:
MOV EAX,R9D
AND EAX,0xfffffffc
TEST R9B,0x3
JZ 0x001013c6
MOV EDX,EAX
LEA ECX,[RAX + 0x1]
LEA RDX,[RSI + RDX*0x4]
MOV dword ptr [RDX],0x1
CMP R9D,ECX
JLE 0x001013c6
LAB_001013b0:
ADD EAX,0x2
MOV dword ptr [RDX + 0x4],0x1
CMP R9D,EAX
JLE 0x001013c6
MOV dword ptr [RDX + 0x8],0x1
LAB_001013c6:
MOV R10D,R9D
MOV EDX,0x4
SHL R10,0x2
NOP word ptr [RAX + RAX*0x1]
LAB_001013d8:
MOV R8D,dword ptr [RDI + RDX*0x1]
XOR EAX,EAX
NOP
LAB_001013e0:
CMP R8D,dword ptr [RDI + RAX*0x1]
JLE 0x001013f4
MOV ECX,dword ptr [RSI + RAX*0x1]
CMP ECX,dword ptr [RSI + RDX*0x1]
JL 0x001013f4
ADD ECX,0x1
MOV dword ptr [RSI + RDX*0x1],ECX
LAB_001013f4:
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x001013e0
LEA RDX,[RAX + 0x4]
CMP RDX,R10
JNZ 0x001013d8
CMP EBX,0x2
JBE 0x00101511
MOV EDX,R9D
MOV RAX,RSI
PXOR XMM2,XMM2
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RSI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101428:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RDX,RAX
JNZ 0x00101428
MOVDQA XMM0,XMM2
MOV EDX,R9D
PSRLDQ XMM0,0x8
AND EDX,0xfffffffc
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
POR XMM1,XMM0
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x4
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM2,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM2
MOVD EAX,XMM0
TEST R9B,0x3
JZ 0x001014c8
MOVSXD RCX,EDX
LEA R11,[RSI + RCX*0x4]
MOV ECX,dword ptr [R11]
CMP EAX,ECX
CMOVL EAX,ECX
LEA ECX,[RDX + 0x1]
CMP ECX,R9D
JGE 0x001014c8
LAB_001014ae:
MOV ECX,dword ptr [R11 + 0x4]
CMP EAX,ECX
CMOVL EAX,ECX
ADD EDX,0x2
CMP R9D,EDX
JLE 0x001014c8
MOV EDX,dword ptr [R11 + 0x8]
CMP EAX,EDX
CMOVL EAX,EDX
LAB_001014c8:
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101522
LEA RSP,[RBP + -0x10]
POP RBX
POP R12
POP RBP
RET
LAB_001014e0:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x0010132b
LAB_001014eb:
XOR EAX,EAX
JMP 0x001014c8
LAB_001014ef:
MOV dword ptr [R12*0x4],0x1
MOV RDX,RSI
XOR EAX,EAX
CMP R9D,0x1
JNZ 0x001013b0
MOV EAX,0x1
JMP 0x001014c8
LAB_00101511:
MOV EAX,dword ptr [R12*0x4]
XOR EDX,EDX
TEST EAX,EAX
CMOVS EAX,EDX
JMP 0x001014ae
LAB_00101522:
CALL 0x00101080 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(long param_1,uint param_2)
{
int iVar1;
long lVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
int *puVar6;
int8 uVar7;
int8 uVar8;
long lVar9;
uint uVar10;
int8 *puVar11;
long lVar12;
uint *puVar13;
uint uVar14;
ulong uVar15;
int4 *puVar16;
long lVar17;
int *puVar18;
long in_FS_OFFSET;
uint uVar20;
uint uVar21;
uint uVar22;
uint uVar23;
uint uVar24;
uint uVar25;
uint uVar26;
int auStack_28 [8];
long local_20;
int *puVar19;
uVar8 = _UNK_00102088;
uVar7 = _DAT_00102080;
puVar18 = auStack_28;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
uVar15 = (long)(int)param_2 * 4 + 0xf;
puVar19 = auStack_28;
puVar6 = auStack_28;
while (puVar19 != auStack_28 + -(uVar15 & 0xfffffffffffff000)) {
puVar18 = puVar6 + -0x1000;
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
puVar19 = puVar6 + -0x1000;
puVar6 = puVar6 + -0x1000;
}
uVar15 = (ulong)((uint)uVar15 & 0xff0);
lVar2 = -uVar15;
puVar11 = (int8 *)(puVar18 + lVar2);
puVar16 = (int4 *)(puVar18 + lVar2);
puVar13 = (uint *)(puVar18 + lVar2);
if (uVar15 != 0) {
*(int8 *)(puVar18 + -8) = *(int8 *)(puVar18 + -8);
}
if ((int)param_2 < 1) {
uVar10 = 0;
goto LAB_001014c8;
}
if (param_2 - 1 < 3) {
*(int4 *)(((ulong)(puVar18 + lVar2 + 3) >> 2) * 4) = 1;
uVar10 = 0;
if (param_2 == 1) {
uVar10 = 1;
goto LAB_001014c8;
}
LAB_001013b0:
puVar16[1] = 1;
if ((int)(uVar10 + 2) < (int)param_2) {
puVar16[2] = 1;
}
}
else {
uVar15 = (ulong)(param_2 >> 2) * 0x10;
if ((uVar15 & 0x10) == 0) goto LAB_00101380;
*(int8 *)(puVar18 + lVar2) = _DAT_00102080;
*(int8 *)(puVar18 + lVar2 + 8) = uVar8;
for (puVar11 = (int8 *)(puVar18 + lVar2 + 0x10);
puVar11 != (int8 *)(puVar18 + uVar15 + lVar2); puVar11 = puVar11 + 4) {
LAB_00101380:
*puVar11 = uVar7;
puVar11[1] = uVar8;
puVar11[2] = uVar7;
puVar11[3] = uVar8;
}
uVar10 = param_2 & 0xfffffffc;
if ((param_2 & 3) != 0) {
puVar16 = (int4 *)(puVar18 + (ulong)uVar10 * 4 + lVar2);
*puVar16 = 1;
if ((int)(uVar10 + 1) < (int)param_2) goto LAB_001013b0;
}
}
lVar17 = 4;
do {
iVar1 = *(int *)(param_1 + lVar17);
lVar9 = 0;
do {
lVar12 = lVar9;
if ((*(int *)(param_1 + lVar12) < iVar1) &&
(*(int *)(puVar18 + lVar17 + lVar2) <= *(int *)(puVar18 + lVar12 + lVar2))) {
*(int *)(puVar18 + lVar17 + lVar2) = *(int *)(puVar18 + lVar12 + lVar2) + 1;
}
lVar9 = lVar12 + 4;
} while (lVar12 + 4 != lVar17);
lVar17 = lVar12 + 8;
} while (lVar17 != (ulong)param_2 << 2);
if (param_2 - 1 < 3) {
uVar10 = *(uint *)(((ulong)(puVar18 + lVar2 + 3) >> 2) * 4);
uVar14 = 0;
puVar13 = (uint *)(puVar18 + lVar2);
if ((int)uVar10 < 0) {
uVar10 = 0;
puVar13 = (uint *)(puVar18 + lVar2);
}
}
else {
uVar10 = 0;
uVar24 = 0;
uVar25 = 0;
uVar26 = 0;
do {
uVar14 = *puVar13;
puVar3 = puVar13 + 1;
puVar4 = puVar13 + 2;
puVar5 = puVar13 + 3;
puVar13 = puVar13 + 4;
uVar20 = -(uint)((int)uVar10 < (int)uVar14);
uVar21 = -(uint)((int)uVar24 < (int)*puVar3);
uVar22 = -(uint)((int)uVar25 < (int)*puVar4);
uVar23 = -(uint)((int)uVar26 < (int)*puVar5);
uVar10 = ~uVar20 & uVar10 | uVar14 & uVar20;
uVar24 = ~uVar21 & uVar24 | *puVar3 & uVar21;
uVar25 = ~uVar22 & uVar25 | *puVar4 & uVar22;
uVar26 = ~uVar23 & uVar26 | *puVar5 & uVar23;
} while ((uint *)(puVar18 + (ulong)(param_2 >> 2) * 0x10 + lVar2) != puVar13);
uVar14 = param_2 & 0xfffffffc;
uVar25 = ~-(uint)((int)uVar10 < (int)uVar25) & uVar10 |
uVar25 & -(uint)((int)uVar10 < (int)uVar25);
uVar24 = ~-(uint)((int)uVar24 < (int)uVar26) & uVar24 |
uVar26 & -(uint)((int)uVar24 < (int)uVar26);
uVar10 = -(uint)((int)uVar25 < (int)uVar24);
uVar10 = ~uVar10 & uVar25 | uVar24 & uVar10;
if ((param_2 & 3) == 0) goto LAB_001014c8;
uVar24 = *(uint *)(puVar18 + (long)(int)uVar14 * 4 + lVar2);
if ((int)uVar10 < (int)uVar24) {
uVar10 = uVar24;
}
puVar13 = (uint *)(puVar18 + (long)(int)uVar14 * 4 + lVar2);
if ((int)param_2 <= (int)(uVar14 + 1)) goto LAB_001014c8;
}
if ((int)uVar10 < (int)puVar13[1]) {
uVar10 = puVar13[1];
}
if (((int)(uVar14 + 2) < (int)param_2) && ((int)uVar10 < (int)puVar13[2])) {
uVar10 = puVar13[2];
}
LAB_001014c8:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar10;
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar18 + lVar2 + -8) = 0x101527;
__stack_chk_fail();
} |
6,088 | func0 |
#include <assert.h>
| int func0(int n) {
int j = 0;
int sm = 0;
for (int i = 1; i <= n; i++) {
j = (2 * i - 1);
sm += (j * j * j * j * j);
}
return sm;
}
| int main() {
assert(func0(1) == 1);
assert(func0(2) == 244);
assert(func0(3) == 3369);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
jmp 118f <func0+0x46>
mov -0x8(%rbp),%eax
add %eax,%eax
sub $0x1,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
imul -0x4(%rbp),%eax
imul -0x4(%rbp),%eax
imul -0x4(%rbp),%eax
add %eax,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 116b <func0+0x22>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 0
mov [rbp+var_C], 0
mov [rbp+var_8], 1
jmp short loc_118F
loc_116B:
mov eax, [rbp+var_8]
add eax, eax
sub eax, 1
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
imul eax, eax
imul eax, [rbp+var_4]
imul eax, [rbp+var_4]
imul eax, [rbp+var_4]
add [rbp+var_C], eax
add [rbp+var_8], 1
loc_118F:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_14]
jle short loc_116B
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(int a1)
{
unsigned int v2; // [rsp+8h] [rbp-Ch]
int i; // [rsp+Ch] [rbp-8h]
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += (2 * i - 1) * (2 * i - 1) * (2 * i - 1) * (2 * i - 1) * (2 * i - 1);
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x1
JMP 0x0010118f
LAB_0010116b:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EAX
SUB EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0xc],EAX
ADD dword ptr [RBP + -0x8],0x1
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x0010116b
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(int param_1)
{
int iVar1;
int4 local_14;
int4 local_10;
local_14 = 0;
for (local_10 = 1; local_10 <= param_1; local_10 = local_10 + 1) {
iVar1 = local_10 * 2 + -1;
local_14 = local_14 + iVar1 * iVar1 * iVar1 * iVar1 * iVar1;
}
return local_14;
} |
6,089 | func0 |
#include <assert.h>
| int func0(int n) {
int j = 0;
int sm = 0;
for (int i = 1; i <= n; i++) {
j = (2 * i - 1);
sm += (j * j * j * j * j);
}
return sm;
}
| int main() {
assert(func0(1) == 1);
assert(func0(2) == 244);
assert(func0(3) == 3369);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1176 <func0+0x2d>
lea 0x1(%rdi,%rdi,1),%esi
mov $0x1,%edx
mov $0x0,%ecx
mov %edx,%eax
imul %edx,%eax
imul %eax,%eax
imul %edx,%eax
add %eax,%ecx
add $0x2,%edx
cmp %esi,%edx
jne 115f <func0+0x16>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1173 <func0+0x2a>
| func0:
endbr64
test edi, edi
jle short loc_1176
lea esi, [rdi+rdi+1]
mov edx, 1
mov ecx, 0
loc_115F:
mov eax, edx
imul eax, edx
imul eax, eax
imul eax, edx
add ecx, eax
add edx, 2
cmp edx, esi
jnz short loc_115F
loc_1173:
mov eax, ecx
retn
loc_1176:
mov ecx, 0
jmp short loc_1173 | long long func0(int a1)
{
int v1; // edx
unsigned int v2; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = 1;
v2 = 0;
do
{
v2 += v1 * v1 * v1 * v1 * v1;
v1 += 2;
}
while ( v1 != 2 * a1 + 1 );
}
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101176
LEA ESI,[RDI + RDI*0x1 + 0x1]
MOV EDX,0x1
MOV ECX,0x0
LAB_0010115f:
MOV EAX,EDX
IMUL EAX,EDX
IMUL EAX,EAX
IMUL EAX,EDX
ADD ECX,EAX
ADD EDX,0x2
CMP EDX,ESI
JNZ 0x0010115f
LAB_00101173:
MOV EAX,ECX
RET
LAB_00101176:
MOV ECX,0x0
JMP 0x00101173 | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar1 = 0;
}
else {
iVar2 = 1;
iVar1 = 0;
do {
iVar1 = iVar1 + iVar2 * iVar2 * iVar2 * iVar2 * iVar2;
iVar2 = iVar2 + 2;
} while (iVar2 != param_1 * 2 + 1);
}
return iVar1;
} |
6,090 | func0 |
#include <assert.h>
| int func0(int n) {
int j = 0;
int sm = 0;
for (int i = 1; i <= n; i++) {
j = (2 * i - 1);
sm += (j * j * j * j * j);
}
return sm;
}
| int main() {
assert(func0(1) == 1);
assert(func0(2) == 244);
assert(func0(3) == 3369);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1178 <func0+0x38>
lea 0x1(%rdi,%rdi,1),%ecx
mov $0x1,%edx
xor %r8d,%r8d
nopl 0x0(%rax)
mov %edx,%eax
imul %edx,%eax
imul %eax,%eax
imul %edx,%eax
add $0x2,%edx
add %eax,%r8d
cmp %edx,%ecx
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
test edi, edi
jle short loc_1228
lea ecx, [rdi+rdi+1]
mov edx, 1
xor r8d, r8d
nop dword ptr [rax+00h]
loc_1208:
mov eax, edx
imul eax, edx
imul eax, eax
imul eax, edx
add edx, 2
add r8d, eax
cmp ecx, edx
jnz short loc_1208
mov eax, r8d
retn
loc_1228:
xor r8d, r8d
mov eax, r8d
retn | long long func0(int a1)
{
int v1; // edx
unsigned int v2; // r8d
int v3; // eax
if ( a1 <= 0 )
return 0LL;
v1 = 1;
v2 = 0;
do
{
v3 = v1 * v1 * v1 * v1 * v1;
v1 += 2;
v2 += v3;
}
while ( 2 * a1 + 1 != v1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101228
LEA ECX,[RDI + RDI*0x1 + 0x1]
MOV EDX,0x1
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101208:
MOV EAX,EDX
IMUL EAX,EDX
IMUL EAX,EAX
IMUL EAX,EDX
ADD EDX,0x2
ADD R8D,EAX
CMP ECX,EDX
JNZ 0x00101208
MOV EAX,R8D
RET
LAB_00101228:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar2 = 1;
iVar3 = 0;
do {
iVar1 = iVar2 * iVar2 * iVar2 * iVar2 * iVar2;
iVar2 = iVar2 + 2;
iVar3 = iVar3 + iVar1;
} while (param_1 * 2 + 1 != iVar2);
return iVar3;
}
return 0;
} |
6,091 | func0 |
#include <assert.h>
| int func0(int n) {
int j = 0;
int sm = 0;
for (int i = 1; i <= n; i++) {
j = (2 * i - 1);
sm += (j * j * j * j * j);
}
return sm;
}
| int main() {
assert(func0(1) == 1);
assert(func0(2) == 244);
assert(func0(3) == 3369);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1178 <func0+0x38>
lea 0x1(%rdi,%rdi,1),%ecx
mov $0x1,%edx
xor %r8d,%r8d
nopl 0x0(%rax)
mov %edx,%eax
imul %edx,%eax
imul %eax,%eax
imul %edx,%eax
add $0x2,%edx
add %eax,%r8d
cmp %edx,%ecx
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
test edi, edi
jle short loc_1170
lea esi, [rdi+rdi+1]
mov edx, 1
xor ecx, ecx
nop dword ptr [rax+rax+00h]
loc_1158:
mov eax, edx
imul eax, edx
imul eax, eax
imul eax, edx
add edx, 2
add ecx, eax
cmp esi, edx
jnz short loc_1158
mov eax, ecx
retn
loc_1170:
xor ecx, ecx
mov eax, ecx
retn | long long func0(int a1)
{
int v1; // edx
unsigned int v2; // ecx
int v3; // eax
if ( a1 <= 0 )
return 0LL;
v1 = 1;
v2 = 0;
do
{
v3 = v1 * v1 * v1 * v1 * v1;
v1 += 2;
v2 += v3;
}
while ( 2 * a1 + 1 != v1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
LEA ESI,[RDI + RDI*0x1 + 0x1]
MOV EDX,0x1
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EAX,EDX
IMUL EAX,EDX
IMUL EAX,EAX
IMUL EAX,EDX
ADD EDX,0x2
ADD ECX,EAX
CMP ESI,EDX
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101170:
XOR ECX,ECX
MOV EAX,ECX
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar3 = 1;
iVar2 = 0;
do {
iVar1 = iVar3 * iVar3 * iVar3 * iVar3 * iVar3;
iVar3 = iVar3 + 2;
iVar2 = iVar2 + iVar1;
} while (param_1 * 2 + 1 != iVar3);
return iVar2;
}
return 0;
} |
6,092 | func0 |
#include <assert.h>
| int func0(int arr[], int low, int high) {
if (high < low)
return arr[0];
if (high == low)
return arr[low];
int mid = low + (high - low) / 2;
if (mid < high && arr[mid + 1] < arr[mid])
return arr[mid];
if (mid > low && arr[mid] < arr[mid - 1])
return arr[mid - 1];
if (arr[low] > arr[mid])
return func0(arr, low, mid - 1);
else
return func0(arr, mid + 1, high);
}
| int main() {
int arr1[] = {2, 3, 5, 6, 9};
int arr2[] = {3, 4, 5, 2, 1};
int arr3[] = {1, 2, 3};
assert(func0(arr1, 0, 4) == 9);
assert(func0(arr2, 0, 4) == 5);
assert(func0(arr3, 0, 2) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x1c(%rbp),%eax
jge 1192 <func0+0x29>
mov -0x18(%rbp),%rax
mov (%rax),%eax
jmpq 12d5 <func0+0x16c>
mov -0x20(%rbp),%eax
cmp -0x1c(%rbp),%eax
jne 11b5 <func0+0x4c>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
jmpq 12d5 <func0+0x16c>
mov -0x20(%rbp),%eax
sub -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,%edx
mov -0x1c(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x20(%rbp),%eax
jge 1225 <func0+0xbc>
mov -0x4(%rbp),%eax
cltq
add $0x1,%rax
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 -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 1225 <func0+0xbc>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
jmpq 12d5 <func0+0x16c>
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jle 1275 <func0+0x10c>
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 1275 <func0+0x10c>
mov -0x4(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
jmp 12d5 <func0+0x16c>
mov -0x1c(%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 -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 12be <func0+0x155>
mov -0x4(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x1c(%rbp),%ecx
mov -0x18(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 1169 <func0>
jmp 12d5 <func0+0x16c>
mov -0x4(%rbp),%eax
lea 0x1(%rax),%ecx
mov -0x20(%rbp),%edx
mov -0x18(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 1169 <func0>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov eax, [rbp+var_20]
cmp eax, [rbp+var_1C]
jge short loc_1192
mov rax, [rbp+var_18]
mov eax, [rax]
jmp locret_12D5
loc_1192:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_1C]
jnz short loc_11B5
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
jmp locret_12D5
loc_11B5:
mov eax, [rbp+var_20]
sub eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov edx, eax
mov eax, [rbp+var_1C]
add eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cmp eax, [rbp+var_20]
jge short loc_1225
mov eax, [rbp+var_4]
cdqe
add rax, 1
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_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_1225
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
jmp locret_12D5
loc_1225:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jle short loc_1275
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_1275
mov eax, [rbp+var_4]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
jmp short locret_12D5
loc_1275:
mov eax, [rbp+var_1C]
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_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_12BE
mov eax, [rbp+var_4]
lea edx, [rax-1]
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov esi, ecx
mov rdi, rax
call func0
jmp short locret_12D5
loc_12BE:
mov eax, [rbp+var_4]
lea ecx, [rax+1]
mov edx, [rbp+var_20]
mov rax, [rbp+var_18]
mov esi, ecx
mov rdi, rax
call func0
locret_12D5:
leave
retn | long long func0(unsigned int *a1, signed int a2, signed int a3)
{
int v4; // [rsp+1Ch] [rbp-4h]
if ( a3 < a2 )
return *a1;
if ( a3 == a2 )
return a1[a2];
v4 = (a3 - a2) / 2 + a2;
if ( v4 < a3 && (int)a1[v4 + 1] < (int)a1[v4] )
return a1[v4];
if ( v4 > a2 && (int)a1[v4] < (int)a1[v4 - 1] )
return a1[v4 - 1];
if ( (int)a1[a2] <= (int)a1[v4] )
return func0(a1, (unsigned int)(v4 + 1), (unsigned int)a3);
return func0(a1, (unsigned int)a2, (unsigned int)(v4 - 1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x00101192
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
JMP 0x001012d5
LAB_00101192:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x1c]
JNZ 0x001011b5
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
JMP 0x001012d5
LAB_001011b5:
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x20]
JGE 0x00101225
MOV EAX,dword ptr [RBP + -0x4]
CDQE
ADD RAX,0x1
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 + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x00101225
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 0x001012d5
LAB_00101225:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JLE 0x00101275
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 0x00101275
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
JMP 0x001012d5
LAB_00101275:
MOV EAX,dword ptr [RBP + -0x1c]
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 + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x001012be
MOV EAX,dword ptr [RBP + -0x4]
LEA EDX,[RAX + -0x1]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,ECX
MOV RDI,RAX
CALL 0x00101169
JMP 0x001012d5
LAB_001012be:
MOV EAX,dword ptr [RBP + -0x4]
LEA ECX,[RAX + 0x1]
MOV EDX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,ECX
MOV RDI,RAX
CALL 0x00101169
LAB_001012d5:
LEAVE
RET | ulong func0(uint *param_1,int param_2,int param_3)
{
int iVar1;
ulong uVar2;
if (param_3 < param_2) {
uVar2 = (ulong)*param_1;
}
else if (param_3 == param_2) {
uVar2 = (ulong)param_1[param_2];
}
else {
iVar1 = param_2 + (param_3 - param_2) / 2;
if ((iVar1 < param_3) && ((int)param_1[(long)iVar1 + 1] < (int)param_1[iVar1])) {
uVar2 = (ulong)param_1[iVar1];
}
else if ((param_2 < iVar1) && ((int)param_1[iVar1] < (int)param_1[(long)iVar1 + -1])) {
uVar2 = (ulong)param_1[(long)iVar1 + -1];
}
else if ((int)param_1[iVar1] < (int)param_1[param_2]) {
uVar2 = func0(param_1,param_2,iVar1 + -1);
}
else {
uVar2 = func0(param_1,iVar1 + 1,param_3);
}
}
return uVar2;
} |
6,093 | func0 |
#include <assert.h>
| int func0(int arr[], int low, int high) {
if (high < low)
return arr[0];
if (high == low)
return arr[low];
int mid = low + (high - low) / 2;
if (mid < high && arr[mid + 1] < arr[mid])
return arr[mid];
if (mid > low && arr[mid] < arr[mid - 1])
return arr[mid - 1];
if (arr[low] > arr[mid])
return func0(arr, low, mid - 1);
else
return func0(arr, mid + 1, high);
}
| int main() {
int arr1[] = {2, 3, 5, 6, 9};
int arr2[] = {3, 4, 5, 2, 1};
int arr3[] = {1, 2, 3};
assert(func0(arr1, 0, 4) == 9);
assert(func0(arr2, 0, 4) == 5);
assert(func0(arr3, 0, 2) == 3);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edx
jl 11cb <func0+0x62>
je 11ce <func0+0x65>
mov %edx,%eax
sub %esi,%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
add %esi,%ecx
cmp %ecx,%edx
jle 1198 <func0+0x2f>
movslq %ecx,%r8
add $0x1,%r8
mov -0x4(%rdi,%r8,4),%eax
cmp %eax,(%rdi,%r8,4)
jl 11df <func0+0x76>
cmp %ecx,%esi
jge 11aa <func0+0x41>
movslq %ecx,%r8
mov -0x4(%rdi,%r8,4),%eax
cmp %eax,(%rdi,%r8,4)
jl 11df <func0+0x76>
sub $0x8,%rsp
movslq %esi,%rax
movslq %ecx,%r8
mov (%rdi,%r8,4),%r9d
cmp %r9d,(%rdi,%rax,4)
jle 11d5 <func0+0x6c>
lea -0x1(%rcx),%edx
callq 1169 <func0>
add $0x8,%rsp
retq
mov (%rdi),%eax
retq
movslq %esi,%rsi
mov (%rdi,%rsi,4),%eax
retq
lea 0x1(%rcx),%esi
callq 1169 <func0>
jmp 11c6 <func0+0x5d>
retq
| func0:
endbr64
cmp edx, esi
jl short loc_11CD
mov ecx, edx
jz short loc_11D0
mov eax, edx
sub eax, esi
mov edx, eax
shr edx, 1Fh
add edx, eax
sar edx, 1
add edx, esi
cmp ecx, edx
jle short loc_119A
movsxd r8, edx
add r8, 1
mov eax, [rdi+r8*4-4]
cmp [rdi+r8*4], eax
jl short locret_11E3
loc_119A:
cmp esi, edx
jge short loc_11AC
movsxd r8, edx
mov eax, [rdi+r8*4-4]
cmp [rdi+r8*4], eax
jl short locret_11E3
loc_11AC:
sub rsp, 8
movsxd rax, esi
movsxd r8, edx
mov r9d, [rdi+r8*4]
cmp [rdi+rax*4], r9d
jle short loc_11D7
sub edx, 1
call func0
loc_11C8:
add rsp, 8
retn
loc_11CD:
mov eax, [rdi]
retn
loc_11D0:
movsxd rsi, esi
mov eax, [rdi+rsi*4]
retn
loc_11D7:
lea esi, [rdx+1]
mov edx, ecx
call func0
jmp short loc_11C8
locret_11E3:
retn | long long func0(unsigned int *a1, long long a2, int a3)
{
int v4; // edx
long long v5; // r8
long long result; // rax
if ( a3 < (int)a2 )
return *a1;
if ( a3 == (_DWORD)a2 )
return a1[(int)a2];
v4 = a2 + (a3 - (int)a2) / 2;
if ( a3 <= v4 || (v5 = v4 + 1LL, result = a1[v5 - 1], (int)a1[v5] >= (int)result) )
{
if ( (int)a2 >= v4 || (result = a1[v4 - 1], (int)a1[v4] >= (int)result) )
{
if ( (int)a1[(int)a2] <= (int)a1[v4] )
return func0(a1, (unsigned int)(v4 + 1), (unsigned int)a3);
else
return func0(a1, a2, (unsigned int)(v4 - 1));
}
}
return result;
} | func0:
ENDBR64
CMP EDX,ESI
JL 0x001011cd
MOV ECX,EDX
JZ 0x001011d0
MOV EAX,EDX
SUB EAX,ESI
MOV EDX,EAX
SHR EDX,0x1f
ADD EDX,EAX
SAR EDX,0x1
ADD EDX,ESI
CMP ECX,EDX
JLE 0x0010119a
MOVSXD R8,EDX
ADD R8,0x1
MOV EAX,dword ptr [RDI + R8*0x4 + -0x4]
CMP dword ptr [RDI + R8*0x4],EAX
JL 0x001011e3
LAB_0010119a:
CMP ESI,EDX
JGE 0x001011ac
MOVSXD R8,EDX
MOV EAX,dword ptr [RDI + R8*0x4 + -0x4]
CMP dword ptr [RDI + R8*0x4],EAX
JL 0x001011e3
LAB_001011ac:
SUB RSP,0x8
MOVSXD RAX,ESI
MOVSXD R8,EDX
MOV R9D,dword ptr [RDI + R8*0x4]
CMP dword ptr [RDI + RAX*0x4],R9D
JLE 0x001011d7
SUB EDX,0x1
CALL 0x00101169
LAB_001011c8:
ADD RSP,0x8
RET
LAB_001011cd:
MOV EAX,dword ptr [RDI]
RET
LAB_001011d0:
MOVSXD RSI,ESI
MOV EAX,dword ptr [RDI + RSI*0x4]
RET
LAB_001011d7:
LEA ESI,[RDX + 0x1]
MOV EDX,ECX
CALL 0x00101169
JMP 0x001011c8
LAB_001011e3:
RET | ulong func0(uint *param_1,int8 param_2,int param_3)
{
uint uVar1;
ulong uVar2;
int iVar3;
int iVar4;
iVar4 = (int)param_2;
if (param_3 < iVar4) {
return (ulong)*param_1;
}
if (param_3 != iVar4) {
iVar3 = (param_3 - iVar4) / 2 + iVar4;
if (((param_3 <= iVar3) || (uVar1 = param_1[iVar3], (int)uVar1 <= (int)param_1[(long)iVar3 + 1])
) && ((iVar3 <= iVar4 ||
(uVar1 = param_1[(long)iVar3 + -1], (int)uVar1 <= (int)param_1[iVar3])))) {
if ((int)param_1[iVar3] < (int)param_1[iVar4]) {
uVar2 = func0(param_1,param_2,iVar3 + -1);
}
else {
uVar2 = func0(param_1,iVar3 + 1,param_3);
}
return uVar2;
}
return (ulong)uVar1;
}
return (ulong)param_1[iVar4];
} |
6,094 | func0 |
#include <assert.h>
| int func0(int arr[], int low, int high) {
if (high < low)
return arr[0];
if (high == low)
return arr[low];
int mid = low + (high - low) / 2;
if (mid < high && arr[mid + 1] < arr[mid])
return arr[mid];
if (mid > low && arr[mid] < arr[mid - 1])
return arr[mid - 1];
if (arr[low] > arr[mid])
return func0(arr, low, mid - 1);
else
return func0(arr, mid + 1, high);
}
| int main() {
int arr1[] = {2, 3, 5, 6, 9};
int arr2[] = {3, 4, 5, 2, 1};
int arr3[] = {1, 2, 3};
assert(func0(arr1, 0, 4) == 9);
assert(func0(arr2, 0, 4) == 5);
assert(func0(arr3, 0, 2) == 3);
return 0;
}
| O2 | c | func0:
endbr64
cmp %edx,%esi
jg 12f2 <func0+0x52>
nopl 0x0(%rax,%rax,1)
je 1308 <func0+0x68>
mov %edx,%eax
sub %esi,%eax
sar %eax
add %esi,%eax
movslq %eax,%rcx
mov (%rdi,%rcx,4),%r8d
lea 0x0(,%rcx,4),%r9
cmp %edx,%eax
jge 12d4 <func0+0x34>
cmp %r8d,0x4(%rdi,%r9,1)
jl 12f5 <func0+0x55>
cmp %esi,%eax
jle 12e2 <func0+0x42>
mov -0x4(%rdi,%r9,1),%ecx
cmp %r8d,%ecx
jg 1318 <func0+0x78>
movslq %esi,%rcx
cmp %r8d,(%rdi,%rcx,4)
jle 1300 <func0+0x60>
lea -0x1(%rax),%edx
cmp %esi,%edx
jge 12b0 <func0+0x10>
mov (%rdi),%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax)
lea 0x1(%rax),%esi
jmp 12ee <func0+0x4e>
nopl (%rax)
movslq %esi,%rsi
mov (%rdi,%rsi,4),%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
mov %ecx,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
mov rcx, rdi
cmp esi, edx
jg short loc_12F2
nop dword ptr [rax+rax+00h]
loc_12B0:
jz short loc_1308
mov eax, edx
sub eax, esi
sar eax, 1
add eax, esi
movsxd rdi, eax
mov r8d, [rcx+rdi*4]
lea r9, ds:0[rdi*4]
cmp eax, edx
jge short loc_12D4
cmp [rcx+r9+4], r8d
jl short loc_12F5
loc_12D4:
cmp eax, esi
jle short loc_12E2
mov edi, [rcx+r9-4]
cmp edi, r8d
jg short loc_1318
loc_12E2:
movsxd rdi, esi
cmp [rcx+rdi*4], r8d
jle short loc_1300
lea edx, [rax-1]
loc_12EE:
cmp edx, esi
jge short loc_12B0
loc_12F2:
mov r8d, [rcx]
loc_12F5:
mov eax, r8d
retn
loc_1300:
lea esi, [rax+1]
jmp short loc_12EE
loc_1308:
movsxd rsi, esi
mov r8d, [rcx+rsi*4]
mov eax, r8d
retn
loc_1318:
mov r8d, edi
mov eax, r8d
retn | long long func0(unsigned int *a1, int a2, int a3)
{
bool v4; // zf
int v5; // eax
signed int v6; // r8d
long long v7; // r9
unsigned int v8; // edi
v4 = a2 == a3;
if ( a2 > a3 )
{
return *a1;
}
else
{
while ( 1 )
{
if ( v4 )
return a1[a2];
v5 = a2 + ((a3 - a2) >> 1);
v6 = a1[v5];
v7 = v5;
if ( v5 < a3 && (int)a1[v7 + 1] < v6 )
return (unsigned int)v6;
if ( v5 > a2 )
{
v8 = a1[v7 - 1];
if ( (int)v8 > v6 )
break;
}
if ( (int)a1[a2] <= v6 )
a2 = v5 + 1;
else
a3 = v5 - 1;
v4 = a3 == a2;
if ( a3 < a2 )
return *a1;
}
return v8;
}
} | func0:
ENDBR64
MOV RCX,RDI
CMP ESI,EDX
JG 0x001012f2
NOP dword ptr [RAX + RAX*0x1]
LAB_001012b0:
JZ 0x00101308
MOV EAX,EDX
SUB EAX,ESI
SAR EAX,0x1
ADD EAX,ESI
MOVSXD RDI,EAX
MOV R8D,dword ptr [RCX + RDI*0x4]
LEA R9,[RDI*0x4]
CMP EAX,EDX
JGE 0x001012d4
CMP dword ptr [RCX + R9*0x1 + 0x4],R8D
JL 0x001012f5
LAB_001012d4:
CMP EAX,ESI
JLE 0x001012e2
MOV EDI,dword ptr [RCX + R9*0x1 + -0x4]
CMP EDI,R8D
JG 0x00101318
LAB_001012e2:
MOVSXD RDI,ESI
CMP dword ptr [RCX + RDI*0x4],R8D
JLE 0x00101300
LEA EDX,[RAX + -0x1]
LAB_001012ee:
CMP EDX,ESI
JGE 0x001012b0
LAB_001012f2:
MOV R8D,dword ptr [RCX]
LAB_001012f5:
MOV EAX,R8D
RET
LAB_00101300:
LEA ESI,[RAX + 0x1]
JMP 0x001012ee
LAB_00101308:
MOVSXD RSI,ESI
MOV R8D,dword ptr [RCX + RSI*0x4]
MOV EAX,R8D
RET
LAB_00101318:
MOV R8D,EDI
MOV EAX,R8D
RET | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
bool bVar3;
bVar3 = param_2 == param_3;
if (param_2 <= param_3) {
do {
if (bVar3) {
return param_1[param_2];
}
iVar2 = (param_3 - param_2 >> 1) + param_2;
iVar1 = param_1[iVar2];
if ((iVar2 < param_3) && (param_1[(long)iVar2 + 1] < iVar1)) {
return iVar1;
}
if ((param_2 < iVar2) && (iVar1 < param_1[(long)iVar2 + -1])) {
return param_1[(long)iVar2 + -1];
}
if (iVar1 < param_1[param_2]) {
param_3 = iVar2 + -1;
}
else {
param_2 = iVar2 + 1;
}
bVar3 = param_3 == param_2;
} while (param_2 <= param_3);
}
return *param_1;
} |
6,095 | func0 |
#include <assert.h>
| int func0(int arr[], int low, int high) {
if (high < low)
return arr[0];
if (high == low)
return arr[low];
int mid = low + (high - low) / 2;
if (mid < high && arr[mid + 1] < arr[mid])
return arr[mid];
if (mid > low && arr[mid] < arr[mid - 1])
return arr[mid - 1];
if (arr[low] > arr[mid])
return func0(arr, low, mid - 1);
else
return func0(arr, mid + 1, high);
}
| int main() {
int arr1[] = {2, 3, 5, 6, 9};
int arr2[] = {3, 4, 5, 2, 1};
int arr3[] = {1, 2, 3};
assert(func0(arr1, 0, 4) == 9);
assert(func0(arr2, 0, 4) == 5);
assert(func0(arr3, 0, 2) == 3);
return 0;
}
| O3 | c | func0:
endbr64
cmp %edx,%esi
jg 12e2 <func0+0x52>
nopl 0x0(%rax,%rax,1)
je 12f8 <func0+0x68>
mov %edx,%eax
sub %esi,%eax
sar %eax
add %esi,%eax
movslq %eax,%rcx
mov (%rdi,%rcx,4),%r8d
lea 0x0(,%rcx,4),%r9
cmp %edx,%eax
jge 12c4 <func0+0x34>
cmp %r8d,0x4(%rdi,%r9,1)
jl 12e5 <func0+0x55>
cmp %esi,%eax
jle 12d2 <func0+0x42>
mov -0x4(%rdi,%r9,1),%ecx
cmp %r8d,%ecx
jg 1308 <func0+0x78>
movslq %esi,%rcx
cmp %r8d,(%rdi,%rcx,4)
jle 12f0 <func0+0x60>
lea -0x1(%rax),%edx
cmp %esi,%edx
jge 12a0 <func0+0x10>
mov (%rdi),%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax)
lea 0x1(%rax),%esi
jmp 12de <func0+0x4e>
nopl (%rax)
movslq %esi,%rsi
mov (%rdi,%rsi,4),%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
mov %ecx,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
mov rcx, rdi
cmp esi, edx
jg short loc_12D0
nop dword ptr [rax+rax+00h]
loc_1290:
jz short loc_12F0
mov eax, edx
sub eax, esi
sar eax, 1
add eax, esi
movsxd rdi, eax
lea r8, ds:0[rdi*4]
mov edi, [rcx+rdi*4]
cmp eax, edx
jge short loc_12B3
cmp [rcx+r8+4], edi
jl short loc_12D2
loc_12B3:
cmp eax, esi
jg short loc_12D8
movsxd rsi, esi
cmp [rcx+rsi*4], edi
jg short loc_12D0
loc_12BF:
lea esi, [rax+1]
loc_12C2:
cmp edx, esi
jge short loc_1290
nop word ptr [rax+rax+00000000h]
loc_12D0:
mov edi, [rcx]
loc_12D2:
mov eax, edi
retn
loc_12D8:
mov r8d, [rcx+r8-4]
cmp r8d, edi
jg short loc_1300
movsxd r8, esi
cmp [rcx+r8*4], edi
jle short loc_12BF
lea edx, [rax-1]
jmp short loc_12C2
loc_12F0:
movsxd rsi, esi
mov edi, [rcx+rsi*4]
mov eax, edi
retn
loc_1300:
mov edi, r8d
mov eax, edi
retn | long long func0(unsigned int *a1, int a2, int a3)
{
bool i; // zf
int v5; // eax
long long v6; // r8
signed int v7; // edi
unsigned int v9; // r8d
for ( i = a2 == a3; a3 >= a2; i = a3 == a2 )
{
if ( i )
return a1[a2];
v5 = a2 + ((a3 - a2) >> 1);
v6 = v5;
v7 = a1[v6];
if ( v5 < a3 && (int)a1[v6 + 1] < v7 )
return (unsigned int)v7;
if ( v5 > a2 )
{
v9 = a1[v6 - 1];
if ( (int)v9 > v7 )
return v9;
if ( (int)a1[a2] > v7 )
{
a3 = v5 - 1;
continue;
}
}
else if ( (int)a1[a2] > v7 )
{
break;
}
a2 = v5 + 1;
}
return *a1;
} | func0:
ENDBR64
MOV RCX,RDI
CMP ESI,EDX
JG 0x001012d0
NOP dword ptr [RAX + RAX*0x1]
LAB_00101290:
JZ 0x001012f0
MOV EAX,EDX
SUB EAX,ESI
SAR EAX,0x1
ADD EAX,ESI
MOVSXD RDI,EAX
LEA R8,[RDI*0x4]
MOV EDI,dword ptr [RCX + RDI*0x4]
CMP EAX,EDX
JGE 0x001012b3
CMP dword ptr [RCX + R8*0x1 + 0x4],EDI
JL 0x001012d2
LAB_001012b3:
CMP EAX,ESI
JG 0x001012d8
MOVSXD RSI,ESI
CMP dword ptr [RCX + RSI*0x4],EDI
JG 0x001012d0
LAB_001012bf:
LEA ESI,[RAX + 0x1]
LAB_001012c2:
CMP EDX,ESI
JGE 0x00101290
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001012d0:
MOV EDI,dword ptr [RCX]
LAB_001012d2:
MOV EAX,EDI
RET
LAB_001012d8:
MOV R8D,dword ptr [RCX + R8*0x1 + -0x4]
CMP R8D,EDI
JG 0x00101300
MOVSXD R8,ESI
CMP dword ptr [RCX + R8*0x4],EDI
JLE 0x001012bf
LEA EDX,[RAX + -0x1]
JMP 0x001012c2
LAB_001012f0:
MOVSXD RSI,ESI
MOV EDI,dword ptr [RCX + RSI*0x4]
MOV EAX,EDI
RET
LAB_00101300:
MOV EDI,R8D
MOV EAX,EDI
RET | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
bool bVar3;
bVar3 = param_2 == param_3;
if (param_2 <= param_3) {
do {
if (bVar3) {
return param_1[param_2];
}
iVar2 = (param_3 - param_2 >> 1) + param_2;
iVar1 = param_1[iVar2];
if ((iVar2 < param_3) && (param_1[(long)iVar2 + 1] < iVar1)) {
return iVar1;
}
if (param_2 < iVar2) {
if (iVar1 < param_1[(long)iVar2 + -1]) {
return param_1[(long)iVar2 + -1];
}
if (param_1[param_2] <= iVar1) goto LAB_001012bf;
param_3 = iVar2 + -1;
}
else {
if (iVar1 < param_1[param_2]) break;
LAB_001012bf:
param_2 = iVar2 + 1;
}
bVar3 = param_3 == param_2;
} while (param_2 <= param_3);
}
return *param_1;
} |
6,096 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int* func0(int** list1, int rows, int n) {
int* result = malloc(rows * sizeof(int));
for(int i = 0; i < rows; i++) {
result[i] = list1[i][n];
}
return result;
}
| int main() {
// First test case
int row1_1[] = {1, 2, 3};
int row1_2[] = {2, 4, 5};
int row1_3[] = {1, 1, 1};
int* list1[] = {row1_1, row1_2, row1_3};
int expected1[] = {1, 2, 1};
int* result1 = func0(list1, 3, 0);
for(int i = 0; i < 3; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
// Second test case
int row2_1[] = {1, 2, 3};
int row2_2[] = {-2, 4, -5};
int row2_3[] = {1, -1, 1};
int* list2[] = {row2_1, row2_2, row2_3};
int expected2[] = {3, -5, 1};
int* result2 = func0(list2, 3, 2);
for(int i = 0; i < 3; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
// Third test case
int row3_1[] = {1, 3, 0};
int row3_2[] = {5, 7, 0};
int row3_3[] = {1, 3, 0};
int row3_4[] = {13, 15, 17};
int row3_5[] = {5, 7, 0};
int row3_6[] = {9, 11, 0};
int* list3[] = {row3_1, row3_2, row3_3, row3_4, row3_5, row3_6};
int expected3[] = {1, 5, 1, 13, 5, 9};
int* result3 = func0(list3, 6, 0);
for(int i = 0; i < 6; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 121e <func0+0x75>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11dd <func0+0x34>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_121E
loc_11DD:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_20]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rbp+var_C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_8]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_C], 1
loc_121E:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_11DD
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2, int a3)
{
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v6; // [rsp+18h] [rbp-8h]
v6 = malloc(4LL * a2);
for ( i = 0; i < a2; ++i )
v6[i] = *(_DWORD *)(4LL * a3 + *(_QWORD *)(8LL * i + a1));
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
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 + -0xc],0x0
JMP 0x0010121e
LAB_001011dd:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_0010121e:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011dd
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int param_3)
{
void *pvVar1;
int4 local_14;
pvVar1 = malloc((long)param_2 << 2);
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
*(int4 *)((long)pvVar1 + (long)local_14 * 4) =
*(int4 *)(*(long *)(param_1 + (long)local_14 * 8) + (long)param_3 * 4);
}
return pvVar1;
} |
6,097 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int* func0(int** list1, int rows, int n) {
int* result = malloc(rows * sizeof(int));
for(int i = 0; i < rows; i++) {
result[i] = list1[i][n];
}
return result;
}
| int main() {
// First test case
int row1_1[] = {1, 2, 3};
int row1_2[] = {2, 4, 5};
int row1_3[] = {1, 1, 1};
int* list1[] = {row1_1, row1_2, row1_3};
int expected1[] = {1, 2, 1};
int* result1 = func0(list1, 3, 0);
for(int i = 0; i < 3; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
// Second test case
int row2_1[] = {1, 2, 3};
int row2_2[] = {-2, 4, -5};
int row2_3[] = {1, -1, 1};
int* list2[] = {row2_1, row2_2, row2_3};
int expected2[] = {3, -5, 1};
int* result2 = func0(list2, 3, 2);
for(int i = 0; i < 3; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
// Third test case
int row3_1[] = {1, 3, 0};
int row3_2[] = {5, 7, 0};
int row3_3[] = {1, 3, 0};
int row3_4[] = {13, 15, 17};
int row3_5[] = {5, 7, 0};
int row3_6[] = {9, 11, 0};
int* list3[] = {row3_1, row3_2, row3_3, row3_4, row3_5, row3_6};
int expected3[] = {1, 5, 1, 13, 5, 9};
int* result3 = func0(list3, 6, 0);
for(int i = 0; i < 6; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %esi,%r12d
mov %edx,%ebp
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 11f1 <func0+0x48>
movslq %ebp,%rsi
shl $0x2,%rsi
lea -0x1(%r12),%edi
mov $0x0,%edx
mov (%rbx,%rdx,8),%rcx
mov (%rcx,%rsi,1),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rdi,%rcx
jne 11db <func0+0x32>
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
mov ebx, esi
mov r12d, edx
movsxd rdi, esi
shl rdi, 2
call _malloc
test ebx, ebx
jle short loc_11EB
movsxd rdi, r12d
shl rdi, 2
mov esi, ebx
mov edx, 0
loc_11D7:
mov rcx, [rbp+rdx*8+0]
mov ecx, [rcx+rdi]
mov [rax+rdx*4], ecx
add rdx, 1
cmp rdx, rsi
jnz short loc_11D7
loc_11EB:
pop rbx
pop rbp
pop r12
retn | long long func0(long long a1, int a2, int a3)
{
long long result; // rax
long long i; // rdx
result = malloc(4LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(result + 4 * i) = *(_DWORD *)(*(_QWORD *)(a1 + 8 * i) + 4LL * a3);
}
return result;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,ESI
MOV R12D,EDX
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001011eb
MOVSXD RDI,R12D
SHL RDI,0x2
MOV ESI,EBX
MOV EDX,0x0
LAB_001011d7:
MOV RCX,qword ptr [RBP + RDX*0x8]
MOV ECX,dword ptr [RCX + RDI*0x1]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP RDX,RSI
JNZ 0x001011d7
LAB_001011eb:
POP RBX
POP RBP
POP R12
RET | void func0(long param_1,uint param_2,int param_3)
{
void *pvVar1;
ulong uVar2;
pvVar1 = malloc((long)(int)param_2 << 2);
if (0 < (int)param_2) {
uVar2 = 0;
do {
*(int4 *)((long)pvVar1 + uVar2 * 4) =
*(int4 *)(*(long *)(param_1 + uVar2 * 8) + (long)param_3 * 4);
uVar2 = uVar2 + 1;
} while (uVar2 != param_2);
}
return;
} |
6,098 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int* func0(int** list1, int rows, int n) {
int* result = malloc(rows * sizeof(int));
for(int i = 0; i < rows; i++) {
result[i] = list1[i][n];
}
return result;
}
| int main() {
// First test case
int row1_1[] = {1, 2, 3};
int row1_2[] = {2, 4, 5};
int row1_3[] = {1, 1, 1};
int* list1[] = {row1_1, row1_2, row1_3};
int expected1[] = {1, 2, 1};
int* result1 = func0(list1, 3, 0);
for(int i = 0; i < 3; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
// Second test case
int row2_1[] = {1, 2, 3};
int row2_2[] = {-2, 4, -5};
int row2_3[] = {1, -1, 1};
int* list2[] = {row2_1, row2_2, row2_3};
int expected2[] = {3, -5, 1};
int* result2 = func0(list2, 3, 2);
for(int i = 0; i < 3; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
// Third test case
int row3_1[] = {1, 3, 0};
int row3_2[] = {5, 7, 0};
int row3_3[] = {1, 3, 0};
int row3_4[] = {13, 15, 17};
int row3_5[] = {5, 7, 0};
int row3_6[] = {9, 11, 0};
int* list3[] = {row3_1, row3_2, row3_3, row3_4, row3_5, row3_6};
int expected3[] = {1, 5, 1, 13, 5, 9};
int* result3 = func0(list3, 6, 0);
for(int i = 0; i < 6; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%r12
shl $0x2,%rdi
mov %edx,%ebx
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 1517 <func0+0x47>
movslq %ebx,%rdi
lea -0x1(%r12),%esi
xor %edx,%edx
shl $0x2,%rdi
mov 0x0(%rbp,%rdx,8),%rcx
mov (%rcx,%rdi,1),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rsi,%rcx
jne 1500 <func0+0x30>
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
| func0:
endbr64
push r13
push r12
movsxd r12, esi
push rbp
mov rbp, rdi
lea rdi, ds:0[r12*4]
push rbx
mov ebx, edx
sub rsp, 8
call _malloc
test r12d, r12d
jle short loc_151C
movsxd rsi, ebx
xor edx, edx
shl rsi, 2
nop dword ptr [rax+00000000h]
loc_1508:
mov rcx, [rbp+rdx*8+0]
mov ecx, [rcx+rsi]
mov [rax+rdx*4], ecx
add rdx, 1
cmp r12, rdx
jnz short loc_1508
loc_151C:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(long long a1, int a2, int a3)
{
long long result; // rax
long long i; // rdx
result = malloc(4LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(result + 4 * i) = *(_DWORD *)(*(_QWORD *)(a1 + 8 * i) + 4LL * a3);
}
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RBP,RDI
LEA RDI,[R12*0x4]
PUSH RBX
MOV EBX,EDX
SUB RSP,0x8
CALL 0x001010b0
TEST R12D,R12D
JLE 0x0010151c
MOVSXD RSI,EBX
XOR EDX,EDX
SHL RSI,0x2
NOP dword ptr [RAX]
LAB_00101508:
MOV RCX,qword ptr [RBP + RDX*0x8]
MOV ECX,dword ptr [RCX + RSI*0x1]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP R12,RDX
JNZ 0x00101508
LAB_0010151c:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(long param_1,int param_2,int param_3)
{
void *pvVar1;
long lVar2;
pvVar1 = malloc((long)param_2 * 4);
if (0 < param_2) {
lVar2 = 0;
do {
*(int4 *)((long)pvVar1 + lVar2 * 4) =
*(int4 *)(*(long *)(param_1 + lVar2 * 8) + (long)param_3 * 4);
lVar2 = lVar2 + 1;
} while (param_2 != lVar2);
}
return;
} |
6,099 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int* func0(int** list1, int rows, int n) {
int* result = malloc(rows * sizeof(int));
for(int i = 0; i < rows; i++) {
result[i] = list1[i][n];
}
return result;
}
| int main() {
// First test case
int row1_1[] = {1, 2, 3};
int row1_2[] = {2, 4, 5};
int row1_3[] = {1, 1, 1};
int* list1[] = {row1_1, row1_2, row1_3};
int expected1[] = {1, 2, 1};
int* result1 = func0(list1, 3, 0);
for(int i = 0; i < 3; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
// Second test case
int row2_1[] = {1, 2, 3};
int row2_2[] = {-2, 4, -5};
int row2_3[] = {1, -1, 1};
int* list2[] = {row2_1, row2_2, row2_3};
int expected2[] = {3, -5, 1};
int* result2 = func0(list2, 3, 2);
for(int i = 0; i < 3; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
// Third test case
int row3_1[] = {1, 3, 0};
int row3_2[] = {5, 7, 0};
int row3_3[] = {1, 3, 0};
int row3_4[] = {13, 15, 17};
int row3_5[] = {5, 7, 0};
int row3_6[] = {9, 11, 0};
int* list3[] = {row3_1, row3_2, row3_3, row3_4, row3_5, row3_6};
int expected3[] = {1, 5, 1, 13, 5, 9};
int* result3 = func0(list3, 6, 0);
for(int i = 0; i < 6; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%r12
shl $0x2,%rdi
mov %edx,%ebx
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 1537 <func0+0x47>
movslq %ebx,%rdi
lea -0x1(%r12),%esi
xor %edx,%edx
shl $0x2,%rdi
mov 0x0(%rbp,%rdx,8),%rcx
mov (%rcx,%rdi,1),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rsi,%rcx
jne 1520 <func0+0x30>
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
| func0:
endbr64
push r13
push r12
movsxd r12, esi
push rbp
mov rbp, rdi
lea rdi, ds:0[r12*4]; size
push rbx
mov ebx, edx
sub rsp, 8
call _malloc
test r12d, r12d
jle short loc_155C
movsxd rsi, ebx
xor edx, edx
shl rsi, 2
nop dword ptr [rax+00000000h]
loc_1548:
mov rcx, [rbp+rdx*8+0]
mov ecx, [rcx+rsi]
mov [rax+rdx*4], ecx
add rdx, 1
cmp r12, rdx
jnz short loc_1548
loc_155C:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _DWORD * func0(long long a1, int a2, int a3)
{
_DWORD *result; // rax
long long i; // rdx
result = malloc(4LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
result[i] = *(_DWORD *)(*(_QWORD *)(a1 + 8 * i) + 4LL * a3);
}
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RBP,RDI
LEA RDI,[R12*0x4]
PUSH RBX
MOV EBX,EDX
SUB RSP,0x8
CALL 0x001010b0
TEST R12D,R12D
JLE 0x0010155c
MOVSXD RSI,EBX
XOR EDX,EDX
SHL RSI,0x2
NOP dword ptr [RAX]
LAB_00101548:
MOV RCX,qword ptr [RBP + RDX*0x8]
MOV ECX,dword ptr [RCX + RSI*0x1]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP R12,RDX
JNZ 0x00101548
LAB_0010155c:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(long param_1,int param_2,int param_3)
{
void *pvVar1;
long lVar2;
pvVar1 = malloc((long)param_2 * 4);
if (0 < param_2) {
lVar2 = 0;
do {
*(int4 *)((long)pvVar1 + lVar2 * 4) =
*(int4 *)(*(long *)(param_1 + lVar2 * 8) + (long)param_3 * 4);
lVar2 = lVar2 + 1;
} while (param_2 != lVar2);
}
return;
} |
6,100 | func0 | #include <assert.h>
#include <stdio.h>
| char* func0(int seq_nums[], int n) {
int diff[n-1];
for (int x = 1; x < n; x++) {
diff[x-1] = seq_nums[x] - seq_nums[x-1];
}
for (int i = 1; i < n-1; i++) {
if (diff[i] != diff[0]) {
return "Non Linear Sequence";
}
}
return "Linear Sequence";
}
| int main() {
int arr1[] = {0, 2, 4, 6, 8, 10};
int arr2[] = {1, 2, 3};
int arr3[] = {1, 5, 2};
assert(func0(arr1, 6) == "Linear Sequence");
assert(func0(arr2, 3) == "Linear Sequence");
assert(func0(arr3, 3) == "Non Linear Sequence");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rdi
mov -0x3c(%rbp),%eax
sub $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%ebx
mov $0x0,%edx
div %rbx
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 120b <func0+0xa2>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11f4 <func0+0x8b>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1235 <func0+0xcc>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x20(%rbp)
movl $0x1,-0x2c(%rbp)
jmp 1295 <func0+0x12c>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
mov -0x2c(%rbp),%ecx
lea -0x1(%rcx),%esi
mov %edx,%ecx
sub %eax,%ecx
mov -0x20(%rbp),%rax
movslq %esi,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 1251 <func0+0xe8>
movl $0x1,-0x30(%rbp)
jmp 12ca <func0+0x161>
mov -0x20(%rbp),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%edx
mov -0x20(%rbp),%rax
mov (%rax),%eax
cmp %eax,%edx
je 12c6 <func0+0x15d>
lea 0xd44(%rip),%rax
jmp 12dc <func0+0x173>
addl $0x1,-0x30(%rbp)
mov -0x3c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x30(%rbp)
jl 12a6 <func0+0x13d>
lea 0xd40(%rip),%rax
mov %rdi,%rsp
mov -0x18(%rbp),%rsi
xor %fs:0x28,%rsi
je 12f3 <func0+0x18a>
callq 1060 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rdi, rax
mov eax, [rbp+var_2C]
sub eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov esi, 10h
mov edx, 0
div rsi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11D9:
cmp rsp, rdx
jz short loc_11F0
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_11D9
loc_11F0:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_121A
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_121A:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_20], 1
jmp short loc_127A
loc_1236:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_20]
cdqe
shl rax, 2
lea rcx, [rax-4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
mov ecx, [rbp+var_20]
lea esi, [rcx-1]
mov ecx, edx
sub ecx, eax
mov rax, [rbp+var_10]
movsxd rdx, esi
mov [rax+rdx*4], ecx
add [rbp+var_20], 1
loc_127A:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_2C]
jl short loc_1236
mov [rbp+var_1C], 1
jmp short loc_12AF
loc_128B:
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov edx, [rax+rdx*4]
mov rax, [rbp+var_10]
mov eax, [rax]
cmp edx, eax
jz short loc_12AB
lea rax, aNonLinearSeque; "Non Linear Sequence"
jmp short loc_12C1
loc_12AB:
add [rbp+var_1C], 1
loc_12AF:
mov eax, [rbp+var_2C]
sub eax, 1
cmp [rbp+var_1C], eax
jl short loc_128B
lea rax, aLinearSequence; "Linear Sequence"
loc_12C1:
mov rsp, rdi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12D8
call ___stack_chk_fail
locret_12D8:
leave
retn | const char * func0(long long a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
_BYTE v5[4]; // [rsp+8h] [rbp-30h] BYREF
int v6; // [rsp+Ch] [rbp-2Ch]
long long v7; // [rsp+10h] [rbp-28h]
int i; // [rsp+18h] [rbp-20h]
int j; // [rsp+1Ch] [rbp-1Ch]
long long v10; // [rsp+20h] [rbp-18h]
_DWORD *v11; // [rsp+28h] [rbp-10h]
unsigned long long v12; // [rsp+30h] [rbp-8h]
v7 = a1;
v6 = a2;
v12 = __readfsqword(0x28u);
v10 = a2 - 1 - 1LL;
v2 = 16 * ((4LL * (a2 - 1) + 15) / 0x10uLL);
while ( v5 != &v5[-(v2 & 0xFFFFFFFFFFFFF000LL)] )
;
v3 = alloca(v2 & 0xFFF);
if ( (v2 & 0xFFF) != 0 )
*(_QWORD *)&v5[(v2 & 0xFFF) - 8] = *(_QWORD *)&v5[(v2 & 0xFFF) - 8];
v11 = v5;
for ( i = 1; i < v6; ++i )
v11[i - 1] = *(_DWORD *)(4LL * i + v7) - *(_DWORD *)(4LL * i - 4 + v7);
for ( j = 1; j < v6 - 1; ++j )
{
if ( v11[j] != *v11 )
return "Non Linear Sequence";
}
return "Linear Sequence";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RDI,RAX
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV ESI,0x10
MOV EDX,0x0
DIV RSI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011d9:
CMP RSP,RDX
JZ 0x001011f0
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011d9
LAB_001011f0:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x0010121a
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_0010121a:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x20],0x1
JMP 0x0010127a
LAB_00101236:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x20]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x20]
LEA ESI,[RCX + -0x1]
MOV ECX,EDX
SUB ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,ESI
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x20],0x1
LAB_0010127a:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101236
MOV dword ptr [RBP + -0x1c],0x1
JMP 0x001012af
LAB_0010128b:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x001012ab
LEA RAX,[0x102008]
JMP 0x001012c1
LAB_001012ab:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001012af:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x1c],EAX
JL 0x0010128b
LEA RAX,[0x10201c]
LAB_001012c1:
MOV RSP,RDI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012d8
CALL 0x00101060
LAB_001012d8:
LEAVE
RET | char * func0(long param_1,int param_2)
{
long lVar1;
ulong uVar2;
char *pcVar3;
int *puVar4;
long in_FS_OFFSET;
int auStack_38 [4];
int local_34;
long local_30;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_30 = param_1;
local_34 = param_2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)(param_2 + -1) + -1;
uVar2 = (((long)(param_2 + -1) * 4 + 0xfU) / 0x10) * 0x10;
for (puVar4 = auStack_38; puVar4 != auStack_38 + -(uVar2 & 0xfffffffffffff000);
puVar4 = puVar4 + -0x1000) {
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar4 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar4 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
for (local_28 = 1; local_28 < local_34; local_28 = local_28 + 1) {
*(int *)(puVar4 + (long)(local_28 + -1) * 4 + lVar1) =
*(int *)(local_30 + (long)local_28 * 4) - *(int *)(local_30 + (long)local_28 * 4 + -4);
}
local_24 = 1;
do {
if (local_34 + -1 <= local_24) {
pcVar3 = "Linear Sequence";
LAB_001012c1:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar4 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar3;
}
if (*(int *)(puVar4 + (long)local_24 * 4 + lVar1) != *(int *)(puVar4 + lVar1)) {
pcVar3 = "Non Linear Sequence";
goto LAB_001012c1;
}
local_24 = local_24 + 1;
} while( true );
} |
6,101 | func0 | #include <assert.h>
#include <stdio.h>
| char* func0(int seq_nums[], int n) {
int diff[n-1];
for (int x = 1; x < n; x++) {
diff[x-1] = seq_nums[x] - seq_nums[x-1];
}
for (int i = 1; i < n-1; i++) {
if (diff[i] != diff[0]) {
return "Non Linear Sequence";
}
}
return "Linear Sequence";
}
| int main() {
int arr1[] = {0, 2, 4, 6, 8, 10};
int arr2[] = {1, 2, 3};
int arr3[] = {1, 5, 2};
assert(func0(arr1, 6) == "Linear Sequence");
assert(func0(arr2, 3) == "Linear Sequence");
assert(func0(arr3, 3) == "Non Linear Sequence");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x1(%rsi),%r10d
movslq %r10d,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rcx
sub %rax,%rcx
mov %rcx,%rax
cmp %rax,%rsp
je 11c0 <func0+0x57>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11a9 <func0+0x40>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11d6 <func0+0x6d>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r9
mov %r9,%r11
shr $0x2,%r11
and $0xfffffffffffffffc,%r9
mov %r9,%r8
cmp $0x1,%esi
jle 120d <func0+0xa4>
lea -0x2(%rsi),%ecx
mov $0x0,%eax
mov 0x4(%rdi,%rax,4),%edx
sub (%rdi,%rax,4),%edx
mov %edx,(%r8,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rcx,%rdx
jne 11f6 <func0+0x8d>
lea 0xdf4(%rip),%rax
cmp $0x1,%r10d
jle 124b <func0+0xe2>
mov 0x0(,%r11,4),%edx
lea 0x4(%r9),%rax
lea -0x3(%rsi),%ecx
lea 0x8(%r9,%rcx,4),%rcx
cmp %edx,(%rax)
jne 1244 <func0+0xdb>
add $0x4,%rax
cmp %rcx,%rax
jne 122e <func0+0xc5>
lea 0xdc6(%rip),%rax
jmp 124b <func0+0xe2>
lea 0xdb9(%rip),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
jne 125c <func0+0xf3>
leaveq
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov rcx, rdi
mov r8d, esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea r9d, [rsi-1]
movsxd rax, r9d
lea rax, ds:0Fh[rax*4]
mov rsi, rax
and rsi, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11AC:
cmp rsp, rdx
jz short loc_11C3
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11AC
loc_11C3:
mov rax, rsi
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11D9
or [rsp+rax+10h+var_18], 0
loc_11D9:
lea rsi, [rsp+10h+var_D]
mov r10, rsi
shr r10, 2
and rsi, 0FFFFFFFFFFFFFFFCh
cmp r8d, 1
jle short loc_120B
lea edi, [r8-1]
mov eax, 0
loc_11F8:
mov edx, [rcx+rax*4+4]
sub edx, [rcx+rax*4]
mov [rsi+rax*4], edx
add rax, 1
cmp rax, rdi
jnz short loc_11F8
loc_120B:
lea rax, aNonLinearSeque+4; "Linear Sequence"
cmp r9d, 1
jle short loc_124A
mov edx, ds:dword_0[r10*4]
lea rax, [rsi+4]
lea ecx, [r8-3]
lea rcx, [rsi+rcx*4+8]
loc_122D:
cmp [rax], edx
jnz short loc_1243
add rax, 4
cmp rax, rcx
jnz short loc_122D
lea rax, aNonLinearSeque+4; "Linear Sequence"
jmp short loc_124A
loc_1243:
lea rax, aNonLinearSeque; "Non Linear Sequence"
loc_124A:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_125B
leave
retn
loc_125B:
call ___stack_chk_fail | const char * func0(long long a1, int a2)
{
int v3; // r9d
__int16 v4; // si
signed long long v5; // rax
void *v6; // rsp
long long v7; // rax
const char *result; // rax
int *v9; // rax
long long v10; // [rsp+0h] [rbp-18h]
int v11; // [rsp+8h] [rbp-10h] BYREF
int v12; // [rsp+Ch] [rbp-Ch] BYREF
unsigned long long v13; // [rsp+10h] [rbp-8h] BYREF
v13 = __readfsqword(0x28u);
v3 = a2 - 1;
v4 = (4 * (a2 - 1) + 15) & 0xFFF0;
while ( &v11 != (int *)((char *)&v11 - ((4LL * v3 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v5 = v4 & 0xFFF;
v6 = alloca(v5);
if ( (v4 & 0xFFF) != 0 )
*(long long *)((char *)&v10 + v5) = *(long long *)((char *)&v10 + v5);
if ( a2 > 1 )
{
v7 = 0LL;
do
{
*(&v11 + v7) = *(_DWORD *)(a1 + 4 * v7 + 4) - *(_DWORD *)(a1 + 4 * v7);
++v7;
}
while ( v7 != a2 - 1 );
}
result = "Linear Sequence";
if ( v3 > 1 )
{
v9 = &v12;
while ( *v9 == v11 )
{
if ( ++v9 == (int *)((char *)&v13 + 4 * (unsigned int)(a2 - 3)) )
return "Linear Sequence";
}
return "Non Linear Sequence";
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV RCX,RDI
MOV R8D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA R9D,[RSI + -0x1]
MOVSXD RAX,R9D
LEA RAX,[0xf + RAX*0x4]
MOV RSI,RAX
AND RSI,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011ac:
CMP RSP,RDX
JZ 0x001011c3
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011ac
LAB_001011c3:
MOV RAX,RSI
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011d9
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011d9:
LEA RSI,[RSP + 0x3]
MOV R10,RSI
SHR R10,0x2
AND RSI,-0x4
CMP R8D,0x1
JLE 0x0010120b
LEA EDI,[R8 + -0x1]
MOV EAX,0x0
LAB_001011f8:
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
SUB EDX,dword ptr [RCX + RAX*0x4]
MOV dword ptr [RSI + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RDI
JNZ 0x001011f8
LAB_0010120b:
LEA RAX,[0x102008]
CMP R9D,0x1
JLE 0x0010124a
MOV EDX,dword ptr [R10*0x4]
LEA RAX,[RSI + 0x4]
LEA ECX,[R8 + -0x3]
LEA RCX,[RSI + RCX*0x4 + 0x8]
LAB_0010122d:
CMP dword ptr [RAX],EDX
JNZ 0x00101243
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010122d
LEA RAX,[0x102008]
JMP 0x0010124a
LAB_00101243:
LEA RAX,[0x102004]
LAB_0010124a:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010125b
LEAVE
RET
LAB_0010125b:
CALL 0x00101060 | char * func0(long param_1,int param_2)
{
long lVar1;
ulong uVar2;
char *pcVar3;
int *piVar4;
int1 *puVar5;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = (long)(param_2 + -1) * 4 + 0xf;
for (puVar5 = auStack_18; puVar5 != auStack_18 + -(uVar2 & 0xfffffffffffff000);
puVar5 = puVar5 + -0x1000) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
uVar2 = (ulong)((uint)uVar2 & 0xff0);
lVar1 = -uVar2;
if (uVar2 != 0) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
if (1 < param_2) {
uVar2 = 0;
do {
*(int *)(puVar5 + uVar2 * 4 + lVar1) =
*(int *)(param_1 + 4 + uVar2 * 4) - *(int *)(param_1 + uVar2 * 4);
uVar2 = uVar2 + 1;
} while (uVar2 != param_2 - 1);
}
pcVar3 = "Linear Sequence";
if (1 < param_2 + -1) {
piVar4 = (int *)(puVar5 + lVar1 + 4);
do {
if (*piVar4 != *(int *)(puVar5 + lVar1)) {
pcVar3 = "Non Linear Sequence";
goto LAB_0010124a;
}
piVar4 = piVar4 + 1;
} while (piVar4 != (int *)(puVar5 + (ulong)(param_2 - 3) * 4 + lVar1 + 8));
pcVar3 = "Linear Sequence";
}
LAB_0010124a:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar3;
}
/* WARNING: Subroutine does not return */
*(code **)(puVar5 + lVar1 + -8) = main;
__stack_chk_fail();
} |
6,102 | func0 | #include <assert.h>
#include <stdio.h>
| char* func0(int seq_nums[], int n) {
int diff[n-1];
for (int x = 1; x < n; x++) {
diff[x-1] = seq_nums[x] - seq_nums[x-1];
}
for (int i = 1; i < n-1; i++) {
if (diff[i] != diff[0]) {
return "Non Linear Sequence";
}
}
return "Linear Sequence";
}
| int main() {
int arr1[] = {0, 2, 4, 6, 8, 10};
int arr2[] = {1, 2, 3};
int arr3[] = {1, 5, 2};
assert(func0(arr1, 6) == "Linear Sequence");
assert(func0(arr2, 3) == "Linear Sequence");
assert(func0(arr3, 3) == "Non Linear Sequence");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
lea -0x1(%rsi),%r9d
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %r9d,%rax
mov %rsp,%rcx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je 130a <func0+0x5a>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 12f5 <func0+0x45>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 13b8 <func0+0x108>
lea 0x3(%rsp),%rcx
mov %rcx,%r10
and $0xfffffffffffffffc,%rcx
shr $0x2,%r10
cmp $0x1,%esi
jle 1356 <func0+0xa6>
lea -0x2(%rsi),%r8d
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov 0x4(%rdi,%rax,4),%edx
sub (%rdi,%rax,4),%edx
mov %edx,(%rcx,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rdx,%r8
jne 1340 <func0+0x90>
lea 0xcab(%rip),%rax
cmp $0x1,%r9d
jle 1394 <func0+0xe4>
sub $0x3,%esi
lea 0x4(%rcx),%rax
mov 0x0(,%r10,4),%edx
lea 0x8(%rcx,%rsi,4),%rcx
jmp 1389 <func0+0xd9>
nopl 0x0(%rax)
add $0x4,%rax
cmp %rcx,%rax
je 13a8 <func0+0xf8>
cmp %edx,(%rax)
je 1380 <func0+0xd0>
lea 0xc70(%rip),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
jne 13c3 <func0+0x113>
leaveq
retq
nopl (%rax)
lea 0xc59(%rip),%rax
jmp 1394 <func0+0xe4>
nopl 0x0(%rax)
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 131c <func0+0x6c>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
lea r9d, [rsi-1]
mov r8d, esi
mov rcx, rdi
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, r9d
mov rsi, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rsi, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rsi
jz short loc_130D
loc_12F8:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rsi
jnz short loc_12F8
loc_130D:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_13B8
loc_131F:
lea rsi, [rsp+1010h+var_100D]
mov r10, rsi
and rsi, 0FFFFFFFFFFFFFFFCh
shr r10, 2
cmp r8d, 1
jle short loc_1353
mov edi, r9d
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1340:
mov edx, [rcx+rax*4+4]
sub edx, [rcx+rax*4]
mov [rsi+rax*4], edx
add rax, 1
cmp rax, rdi
jnz short loc_1340
loc_1353:
lea rax, aNonLinearSeque+4; "Linear Sequence"
cmp r9d, 1
jle short loc_1394
lea ecx, [r8-3]
mov edx, ds:dword_0[r10*4]
lea rax, [rsi+4]
lea rcx, [rsi+rcx*4+8]
jmp short loc_1389
loc_1380:
add rax, 4
cmp rax, rcx
jz short loc_13A8
loc_1389:
cmp [rax], edx
jz short loc_1380
lea rax, aNonLinearSeque; "Non Linear Sequence"
loc_1394:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_13C3
leave
retn
loc_13A8:
lea rax, aNonLinearSeque+4; "Linear Sequence"
jmp short loc_1394
loc_13B8:
or [rsp+rdx+1010h+var_1018], 0
jmp loc_131F
loc_13C3:
call ___stack_chk_fail | const char * func0(long long a1, int a2)
{
int v2; // r9d
long long v4; // rdx
int *v5; // rsi
__int16 v6; // dx
signed long long v7; // rdx
void *v8; // rsp
long long v9; // rax
const char *result; // rax
_BYTE *v11; // rax
long long v12; // [rsp+0h] [rbp-1018h]
int v13; // [rsp+8h] [rbp-1010h] BYREF
_BYTE v14[4084]; // [rsp+Ch] [rbp-100Ch] BYREF
_QWORD v15[2]; // [rsp+1008h] [rbp-10h] BYREF
v2 = a2 - 1;
v15[1] = __readfsqword(0x28u);
v4 = 4LL * (a2 - 1) + 15;
v5 = (int *)((char *)v15 - (v4 & 0xFFFFFFFFFFFFF000LL));
v6 = v4 & 0xFFF0;
if ( v15 != (_QWORD *)v5 )
{
while ( &v13 != v5 )
;
}
v7 = v6 & 0xFFF;
v8 = alloca(v7);
if ( v7 )
*(long long *)((char *)&v12 + v7) = *(long long *)((char *)&v12 + v7);
if ( a2 > 1 )
{
v9 = 0LL;
do
{
*(_DWORD *)&v14[4 * v9 - 4] = *(_DWORD *)(a1 + 4 * v9 + 4) - *(_DWORD *)(a1 + 4 * v9);
++v9;
}
while ( v9 != v2 );
}
result = "Linear Sequence";
if ( v2 > 1 )
{
v11 = v14;
do
{
if ( *(_DWORD *)v11 != v13 )
return "Non Linear Sequence";
v11 += 4;
}
while ( v11 != &v14[4 * (a2 - 3) + 4] );
return "Linear Sequence";
}
return result;
} | func0:
ENDBR64
PUSH RBP
LEA R9D,[RSI + -0x1]
MOV R8D,ESI
MOV RCX,RDI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,R9D
MOV RSI,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RSI,RAX
AND RDX,-0x10
CMP RSP,RSI
JZ 0x0010130d
LAB_001012f8:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x001012f8
LAB_0010130d:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001013b8
LAB_0010131f:
LEA RSI,[RSP + 0x3]
MOV R10,RSI
AND RSI,-0x4
SHR R10,0x2
CMP R8D,0x1
JLE 0x00101353
MOV EDI,R9D
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101340:
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
SUB EDX,dword ptr [RCX + RAX*0x4]
MOV dword ptr [RSI + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RDI
JNZ 0x00101340
LAB_00101353:
LEA RAX,[0x102008]
CMP R9D,0x1
JLE 0x00101394
LEA ECX,[R8 + -0x3]
MOV EDX,dword ptr [R10*0x4]
LEA RAX,[RSI + 0x4]
LEA RCX,[RSI + RCX*0x4 + 0x8]
JMP 0x00101389
LAB_00101380:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x001013a8
LAB_00101389:
CMP dword ptr [RAX],EDX
JZ 0x00101380
LEA RAX,[0x102004]
LAB_00101394:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013c3
LEAVE
RET
LAB_001013a8:
LEA RAX,[0x102008]
JMP 0x00101394
LAB_001013b8:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x0010131f
LAB_001013c3:
CALL 0x00101060 | char * func0(long param_1,int param_2)
{
long lVar1;
int1 *puVar2;
ulong uVar3;
char *pcVar4;
int *piVar5;
int1 *puVar6;
uint uVar8;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar7;
uVar8 = param_2 - 1;
puVar6 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (long)(int)uVar8 * 4 + 0xf;
puVar7 = auStack_18;
puVar2 = auStack_18;
while (puVar7 != auStack_18 + -(uVar3 & 0xfffffffffffff000)) {
puVar6 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar7 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar3 = (ulong)((uint)uVar3 & 0xff0);
lVar1 = -uVar3;
if (uVar3 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (1 < param_2) {
uVar3 = 0;
do {
*(int *)(puVar6 + uVar3 * 4 + lVar1) =
*(int *)(param_1 + 4 + uVar3 * 4) - *(int *)(param_1 + uVar3 * 4);
uVar3 = uVar3 + 1;
} while (uVar3 != uVar8);
}
pcVar4 = "Linear Sequence";
if (1 < (int)uVar8) {
piVar5 = (int *)(puVar6 + lVar1 + 4);
do {
if (*piVar5 != *(int *)(puVar6 + lVar1)) {
pcVar4 = "Non Linear Sequence";
goto LAB_00101394;
}
piVar5 = piVar5 + 1;
} while (piVar5 != (int *)(puVar6 + (ulong)(param_2 - 3) * 4 + lVar1 + 8));
pcVar4 = "Linear Sequence";
}
LAB_00101394:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar6 + lVar1 + -8) = _fini;
__stack_chk_fail();
}
return pcVar4;
} |
6,103 | func0 | #include <assert.h>
#include <stdio.h>
| char* func0(int seq_nums[], int n) {
int diff[n-1];
for (int x = 1; x < n; x++) {
diff[x-1] = seq_nums[x] - seq_nums[x-1];
}
for (int i = 1; i < n-1; i++) {
if (diff[i] != diff[0]) {
return "Non Linear Sequence";
}
}
return "Linear Sequence";
}
| int main() {
int arr1[] = {0, 2, 4, 6, 8, 10};
int arr2[] = {1, 2, 3};
int arr3[] = {1, 5, 2};
assert(func0(arr1, 6) == "Linear Sequence");
assert(func0(arr2, 3) == "Linear Sequence");
assert(func0(arr3, 3) == "Non Linear Sequence");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
lea -0x1(%rsi),%r8d
mov %rsp,%rbp
push %r14
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movslq %r8d,%rax
mov %rsp,%rbx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 12fd <func0+0x5d>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 12e8 <func0+0x48>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 14d0 <func0+0x230>
lea 0x3(%rsp),%rdx
mov %rdx,%r9
and $0xfffffffffffffffc,%rdx
shr $0x2,%r9
cmp $0x1,%esi
jle 1435 <func0+0x195>
lea -0x2(%rsi),%eax
cmp $0x2,%eax
jbe 14db <func0+0x23b>
mov %r8d,%ecx
xor %eax,%eax
shr $0x2,%ecx
shl $0x4,%rcx
movdqu 0x4(%rdi,%rax,1),%xmm0
movdqu (%rdi,%rax,1),%xmm1
psubd %xmm1,%xmm0
movups %xmm0,(%rdx,%rax,1)
add $0x10,%rax
cmp %rax,%rcx
jne 1340 <func0+0xa0>
mov %r8d,%eax
and $0xfffffffc,%eax
lea 0x1(%rax),%ecx
cmp %eax,%r8d
je 1435 <func0+0x195>
movslq %ecx,%rax
lea 0x1(%rcx),%r11d
shl $0x2,%rax
lea (%rdi,%rax,1),%r10
cmp %r8d,%r11d
jge 14e5 <func0+0x245>
cmp %ecx,%esi
jle 14e5 <func0+0x245>
mov (%r10),%ebx
lea (%rdx,%rax,1),%r11
mov %ebx,%r14d
sub -0x4(%r10),%r14d
mov 0x4(%rdi,%rax,1),%r10d
mov %r14d,-0x4(%r11)
mov %r10d,%eax
sub %ebx,%eax
mov %eax,(%r11)
lea 0x3(%rcx),%r11d
lea 0x2(%rcx),%eax
cmp %r11d,%r8d
jle 13f2 <func0+0x152>
cltq
mov (%rdi,%rax,4),%r11d
lea 0x0(,%rax,4),%rbx
lea (%rdx,%rbx,1),%rax
mov %r11d,%r14d
sub %r10d,%r14d
mov 0x4(%rdi,%rbx,1),%r10d
mov %r14d,-0x4(%rax)
mov %r10d,%ebx
sub %r11d,%ebx
lea 0x5(%rcx),%r11d
mov %ebx,(%rax)
lea 0x4(%rcx),%eax
cmp %r11d,%r8d
jg 14a0 <func0+0x200>
movslq %eax,%r11
lea -0x1(%rax),%ecx
movslq %ecx,%rcx
mov (%rdi,%r11,4),%r10d
sub -0x4(%rdi,%r11,4),%r10d
mov %r10d,(%rdx,%rcx,4)
lea 0x1(%rax),%ecx
cmp %ecx,%esi
jle 1435 <func0+0x195>
movslq %ecx,%rcx
add $0x2,%eax
mov (%rdi,%rcx,4),%r10d
sub -0x4(%rdi,%rcx,4),%r10d
mov %r10d,(%rdx,%r11,4)
cmp %eax,%esi
jle 1435 <func0+0x195>
cltq
mov (%rdi,%rax,4),%r10d
sub -0x4(%rdi,%rax,4),%r10d
mov %r10d,(%rdx,%rcx,4)
lea 0xbcc(%rip),%rax
cmp $0x1,%r8d
jle 1474 <func0+0x1d4>
sub $0x3,%esi
lea 0x4(%rdx),%rax
mov 0x0(,%r9,4),%ecx
lea 0x8(%rdx,%rsi,4),%rdx
jmp 1469 <func0+0x1c9>
nopl 0x0(%rax,%rax,1)
add $0x4,%rax
cmp %rax,%rdx
je 1490 <func0+0x1f0>
cmp %ecx,(%rax)
je 1460 <func0+0x1c0>
lea 0xb90(%rip),%rax
mov -0x18(%rbp),%rbx
xor %fs:0x28,%rbx
jne 14ec <func0+0x24c>
lea -0x10(%rbp),%rsp
pop %rbx
pop %r14
pop %rbp
retq
nopl 0x0(%rax)
lea 0xb71(%rip),%rax
jmp 1474 <func0+0x1d4>
nopl 0x0(%rax)
movslq %eax,%r11
mov (%rdi,%r11,4),%ebx
lea 0x0(,%r11,4),%rax
lea (%rdx,%rax,1),%r11
mov 0x4(%rdi,%rax,1),%eax
mov %ebx,%r14d
sub %ebx,%eax
sub %r10d,%r14d
mov %eax,(%r11)
lea 0x6(%rcx),%eax
mov %r14d,-0x4(%r11)
jmpq 13f2 <func0+0x152>
xchg %ax,%ax
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 130f <func0+0x6f>
mov $0x1,%ecx
jmpq 136e <func0+0xce>
mov %ecx,%eax
jmpq 13f2 <func0+0x152>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
lea r9d, [rsi-1]
mov r8d, esi
mov rdx, rdi
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, r9d
mov rsi, rsp
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rsi, rax
and rcx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rsi
jz short loc_12ED
loc_12D8:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rsi
jnz short loc_12D8
loc_12ED:
and ecx, 0FFFh
sub rsp, rcx
test rcx, rcx
jnz loc_1408
loc_12FF:
lea rsi, [rsp+1010h+var_100D]
mov r10, rsi
and rsi, 0FFFFFFFFFFFFFFFCh
shr r10, 2
cmp r8d, 1
jle loc_13B1
lea eax, [r8-2]
cmp eax, 2
jbe loc_1413
mov ecx, r9d
xor eax, eax
shr ecx, 2
shl rcx, 4
nop word ptr [rax+rax+00h]
loc_1338:
movdqu xmm0, xmmword ptr [rdx+rax+4]
movdqu xmm2, xmmword ptr [rdx+rax]
psubd xmm0, xmm2
movups xmmword ptr [rsi+rax], xmm0
add rax, 10h
cmp rcx, rax
jnz short loc_1338
mov edi, r9d
and edi, 0FFFFFFFCh
lea eax, [rdi+1]
test r9b, 3
jz short loc_13B7
loc_1363:
mov r11d, r8d
sub r11d, edi
lea ecx, [r11-1]
cmp r11d, 2
jz short loc_139F
lea r11d, [rdi+1]
lea rdi, ds:0[r11*4]
movq xmm0, qword ptr [rdx+r11*4]
movq xmm1, qword ptr [rdx+rdi-4]
psubd xmm0, xmm1
movq qword ptr [rsi+rdi-4], xmm0
test cl, 1
jz short loc_13B1
and ecx, 0FFFFFFFEh
add eax, ecx
loc_139F:
movsxd rdi, eax
sub eax, 1
mov ecx, [rdx+rdi*4]
cdqe
sub ecx, [rdx+rdi*4-4]
mov [rsi+rax*4], ecx
loc_13B1:
cmp r9d, 1
jle short loc_13F8
loc_13B7:
lea ecx, [r8-3]
mov edx, ds:dword_0[r10*4]
lea rax, [rsi+4]
lea rcx, [rsi+rcx*4+8]
jmp short loc_13D9
loc_13D0:
add rax, 4
cmp rax, rcx
jz short loc_13F8
loc_13D9:
cmp [rax], edx
jz short loc_13D0
lea rax, aNonLinearSeque; "Non Linear Sequence"
loc_13E4:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_141F
leave
retn
loc_13F8:
lea rax, aNonLinearSeque+4; "Linear Sequence"
jmp short loc_13E4
loc_1408:
or [rsp+rcx+1010h+var_1018], 0
jmp loc_12FF
loc_1413:
xor edi, edi
mov eax, 1
jmp loc_1363
loc_141F:
call ___stack_chk_fail | const char * func0(long long a1, int a2)
{
int v2; // r9d
long long v5; // rcx
int *v6; // rsi
__int16 v7; // cx
signed long long v8; // rcx
void *v9; // rsp
long long v10; // rax
unsigned int v11; // edi
signed int v12; // eax
int v13; // ecx
_BYTE *v14; // rax
long long v16; // [rsp+0h] [rbp-1018h]
int v17; // [rsp+8h] [rbp-1010h] BYREF
_BYTE v18[4084]; // [rsp+Ch] [rbp-100Ch] BYREF
_QWORD v19[2]; // [rsp+1008h] [rbp-10h] BYREF
v2 = a2 - 1;
v19[1] = __readfsqword(0x28u);
v5 = 4LL * (a2 - 1) + 15;
v6 = (int *)((char *)v19 - (v5 & 0xFFFFFFFFFFFFF000LL));
v7 = v5 & 0xFFF0;
if ( v19 != (_QWORD *)v6 )
{
while ( &v17 != v6 )
;
}
v8 = v7 & 0xFFF;
v9 = alloca(v8);
if ( v8 )
*(long long *)((char *)&v16 + v8) = *(long long *)((char *)&v16 + v8);
if ( a2 > 1 )
{
if ( (unsigned int)(a2 - 2) <= 2 )
{
v11 = 0;
v12 = 1;
}
else
{
v10 = 0LL;
do
{
*(__m128i *)&v18[v10 - 4] = _mm_sub_epi32(
_mm_loadu_si128((const __m128i *)(a1 + v10 + 4)),
_mm_loadu_si128((const __m128i *)(a1 + v10)));
v10 += 16LL;
}
while ( 16LL * ((unsigned int)v2 >> 2) != v10 );
v11 = v2 & 0xFFFFFFFC;
v12 = (v2 & 0xFFFFFFFC) + 1;
if ( (v2 & 3) == 0 )
goto LABEL_15;
}
v13 = a2 - v11 - 1;
if ( a2 - v11 != 2 )
{
*(_QWORD *)&v18[4 * v11 - 4] = _mm_sub_epi32(
_mm_loadl_epi64((const __m128i *)(a1 + 4LL * (v11 + 1))),
_mm_loadl_epi64((const __m128i *)(a1 + 4LL * (v11 + 1) - 4))).m128i_u64[0];
if ( (v13 & 1) == 0 )
goto LABEL_14;
v12 += v13 & 0xFFFFFFFE;
}
*(&v17 + v12 - 1) = *(_DWORD *)(a1 + 4LL * v12) - *(_DWORD *)(a1 + 4LL * v12 - 4);
}
LABEL_14:
if ( v2 <= 1 )
return "Linear Sequence";
LABEL_15:
v14 = v18;
while ( *(_DWORD *)v14 == v17 )
{
v14 += 4;
if ( v14 == &v18[4 * (a2 - 3) + 4] )
return "Linear Sequence";
}
return "Non Linear Sequence";
} | func0:
ENDBR64
PUSH RBP
LEA R9D,[RSI + -0x1]
MOV R8D,ESI
MOV RDX,RDI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,R9D
MOV RSI,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RAX,-0x1000
SUB RSI,RAX
AND RCX,-0x10
CMP RSP,RSI
JZ 0x001012ed
LAB_001012d8:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x001012d8
LAB_001012ed:
AND ECX,0xfff
SUB RSP,RCX
TEST RCX,RCX
JNZ 0x00101408
LAB_001012ff:
LEA RSI,[RSP + 0x3]
MOV R10,RSI
AND RSI,-0x4
SHR R10,0x2
CMP R8D,0x1
JLE 0x001013b1
LEA EAX,[R8 + -0x2]
CMP EAX,0x2
JBE 0x00101413
MOV ECX,R9D
XOR EAX,EAX
SHR ECX,0x2
SHL RCX,0x4
NOP word ptr [RAX + RAX*0x1]
LAB_00101338:
MOVDQU XMM0,xmmword ptr [RDX + RAX*0x1 + 0x4]
MOVDQU XMM2,xmmword ptr [RDX + RAX*0x1]
PSUBD XMM0,XMM2
MOVUPS xmmword ptr [RSI + RAX*0x1],XMM0
ADD RAX,0x10
CMP RCX,RAX
JNZ 0x00101338
MOV EDI,R9D
AND EDI,0xfffffffc
LEA EAX,[RDI + 0x1]
TEST R9B,0x3
JZ 0x001013b7
LAB_00101363:
MOV R11D,R8D
SUB R11D,EDI
LEA ECX,[R11 + -0x1]
CMP R11D,0x2
JZ 0x0010139f
LEA R11D,[RDI + 0x1]
LEA RDI,[R11*0x4]
MOVQ XMM0,qword ptr [RDX + R11*0x4]
MOVQ XMM1,qword ptr [RDX + RDI*0x1 + -0x4]
PSUBD XMM0,XMM1
MOVQ qword ptr [RSI + RDI*0x1 + -0x4],XMM0
TEST CL,0x1
JZ 0x001013b1
AND ECX,0xfffffffe
ADD EAX,ECX
LAB_0010139f:
MOVSXD RDI,EAX
SUB EAX,0x1
MOV ECX,dword ptr [RDX + RDI*0x4]
CDQE
SUB ECX,dword ptr [RDX + RDI*0x4 + -0x4]
MOV dword ptr [RSI + RAX*0x4],ECX
LAB_001013b1:
CMP R9D,0x1
JLE 0x001013f8
LAB_001013b7:
LEA ECX,[R8 + -0x3]
MOV EDX,dword ptr [R10*0x4]
LEA RAX,[RSI + 0x4]
LEA RCX,[RSI + RCX*0x4 + 0x8]
JMP 0x001013d9
LAB_001013d0:
ADD RAX,0x4
CMP RAX,RCX
JZ 0x001013f8
LAB_001013d9:
CMP dword ptr [RAX],EDX
JZ 0x001013d0
LEA RAX,[0x102004]
LAB_001013e4:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010141f
LEAVE
RET
LAB_001013f8:
LEA RAX,[0x102008]
JMP 0x001013e4
LAB_00101408:
OR qword ptr [RSP + RCX*0x1 + -0x8],0x0
JMP 0x001012ff
LAB_00101413:
XOR EDI,EDI
MOV EAX,0x1
JMP 0x00101363
LAB_0010141f:
CALL 0x00101060 | char * func0(long param_1,int param_2)
{
uint uVar1;
int *piVar2;
int *piVar3;
int8 uVar4;
int8 uVar5;
long lVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int *puVar12;
int iVar13;
long lVar14;
int *piVar15;
char *pcVar16;
ulong uVar17;
int *puVar18;
uint uVar20;
uint uVar21;
long in_FS_OFFSET;
int auStack_18 [8];
long local_10;
int *puVar19;
uVar21 = param_2 - 1;
puVar18 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar17 = (long)(int)uVar21 * 4 + 0xf;
puVar19 = auStack_18;
puVar12 = auStack_18;
while (puVar19 != auStack_18 + -(uVar17 & 0xfffffffffffff000)) {
puVar18 = puVar12 + -0x1000;
*(int8 *)(puVar12 + -8) = *(int8 *)(puVar12 + -8);
puVar19 = puVar12 + -0x1000;
puVar12 = puVar12 + -0x1000;
}
uVar17 = (ulong)((uint)uVar17 & 0xff0);
lVar6 = -uVar17;
if (uVar17 != 0) {
*(int8 *)(puVar18 + -8) = *(int8 *)(puVar18 + -8);
}
if (param_2 < 2) {
LAB_001013b1:
if ((int)uVar21 < 2) goto LAB_001013f8;
}
else {
if (param_2 - 2U < 3) {
uVar20 = 0;
iVar13 = 1;
LAB_00101363:
uVar1 = (param_2 - uVar20) - 1;
if (param_2 - uVar20 != 2) {
lVar14 = (ulong)(uVar20 + 1) * 4;
uVar4 = *(int8 *)(param_1 + (ulong)(uVar20 + 1) * 4);
uVar5 = *(int8 *)(param_1 + -4 + lVar14);
*(ulong *)(puVar18 + lVar14 + lVar6 + -4) =
CONCAT44((int)((ulong)uVar4 >> 0x20) - (int)((ulong)uVar5 >> 0x20),
(int)uVar4 - (int)uVar5);
if ((uVar1 & 1) == 0) goto LAB_001013b1;
iVar13 = iVar13 + (uVar1 & 0xfffffffe);
}
*(int *)(puVar18 + (long)(iVar13 + -1) * 4 + lVar6) =
*(int *)(param_1 + (long)iVar13 * 4) - *(int *)(param_1 + -4 + (long)iVar13 * 4);
goto LAB_001013b1;
}
lVar14 = 0;
do {
piVar3 = (int *)(param_1 + 4 + lVar14);
iVar13 = piVar3[1];
iVar7 = piVar3[2];
iVar8 = piVar3[3];
piVar15 = (int *)(param_1 + lVar14);
iVar9 = piVar15[1];
iVar10 = piVar15[2];
iVar11 = piVar15[3];
piVar2 = (int *)(puVar18 + lVar14 + lVar6);
*piVar2 = *piVar3 - *piVar15;
piVar2[1] = iVar13 - iVar9;
piVar2[2] = iVar7 - iVar10;
piVar2[3] = iVar8 - iVar11;
lVar14 = lVar14 + 0x10;
} while ((ulong)(uVar21 >> 2) << 4 != lVar14);
uVar20 = uVar21 & 0xfffffffc;
iVar13 = uVar20 + 1;
if ((uVar21 & 3) != 0) goto LAB_00101363;
}
piVar15 = (int *)(puVar18 + lVar6 + 4);
do {
if (*piVar15 != *(int *)(puVar18 + lVar6)) {
pcVar16 = "Non Linear Sequence";
goto LAB_001013e4;
}
piVar15 = piVar15 + 1;
} while (piVar15 != (int *)(puVar18 + (ulong)(param_2 - 3) * 4 + lVar6 + 8));
LAB_001013f8:
pcVar16 = "Linear Sequence";
LAB_001013e4:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar18 + lVar6 + -8) = _fini;
__stack_chk_fail();
}
return pcVar16;
} |
6,104 | func0 |
#include <assert.h>
#include <math.h>
| float func0(int a, int b) {
int digits = 0;
int temp = b;
if (temp == 0) {
digits = 1;
} else {
while (temp != 0) {
digits++;
temp /= 10;
}
}
return a + b / pow(10, digits);
}
| int main() {
assert(func0(4, 56) == 4.56f);
assert(func0(7, 256) == 7.256f);
assert(func0(8, 123) == 8.123f);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jne 11b9 <func0+0x50>
movl $0x1,-0x8(%rbp)
jmp 11bf <func0+0x56>
addl $0x1,-0x8(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jne 1197 <func0+0x2e>
cvtsi2sdl -0x14(%rbp),%xmm3
movsd %xmm3,-0x20(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm2
movsd %xmm2,-0x28(%rbp)
cvtsi2sdl -0x8(%rbp),%xmm0
mov 0xeb1(%rip),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd -0x28(%rbp),%xmm2
divsd %xmm0,%xmm2
movapd %xmm2,%xmm0
addsd -0x20(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_8], 0
mov eax, [rbp+var_18]
mov [rbp+var_4], eax
cmp [rbp+var_4], 0
jnz short loc_11B9
mov [rbp+var_8], 1
jmp short loc_11BF
loc_1197:
add [rbp+var_8], 1
mov eax, [rbp+var_4]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_4], eax
loc_11B9:
cmp [rbp+var_4], 0
jnz short loc_1197
loc_11BF:
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_14]
movsd [rbp+var_20], xmm2
pxor xmm3, xmm3
cvtsi2sd xmm3, [rbp+var_18]
movsd [rbp+var_28], xmm3
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_8]
mov rax, cs:x
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movsd xmm1, [rbp+var_28]
divsd xmm1, xmm0
movsd xmm0, [rbp+var_20]
addsd xmm0, xmm1
cvtsd2ss xmm0, xmm0
leave
retn | float func0(int a1, int a2)
{
int v3; // [rsp+28h] [rbp-8h]
int v4; // [rsp+2Ch] [rbp-4h]
v3 = 0;
v4 = a2;
if ( a2 )
{
while ( v4 )
{
++v3;
v4 /= 10;
}
}
else
{
v3 = 1;
}
return (double)a1 + (double)a2 / pow(10.0, (double)v3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x001011b9
MOV dword ptr [RBP + -0x8],0x1
JMP 0x001011bf
LAB_00101197:
ADD dword ptr [RBP + -0x8],0x1
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
LAB_001011b9:
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x00101197
LAB_001011bf:
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x14]
MOVSD qword ptr [RBP + -0x20],XMM2
PXOR XMM3,XMM3
CVTSI2SD XMM3,dword ptr [RBP + -0x18]
MOVSD qword ptr [RBP + -0x28],XMM3
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x8]
MOV RAX,qword ptr [0x00102078]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
MOVSD XMM1,qword ptr [RBP + -0x28]
DIVSD XMM1,XMM0
MOVSD XMM0,qword ptr [RBP + -0x20]
ADDSD XMM0,XMM1
CVTSD2SS XMM0,XMM0
LEAVE
RET | int8 func0(int param_1,int param_2)
{
double dVar1;
int4 local_10;
int4 local_c;
local_10 = 0;
local_c = param_2;
if (param_2 == 0) {
local_10 = 1;
}
else {
for (; local_c != 0; local_c = local_c / 10) {
local_10 = local_10 + 1;
}
}
dVar1 = pow(DAT_00102078,(double)local_10);
dVar1 = (double)param_1 + (double)param_2 / dVar1;
return CONCAT44((int)((ulong)dVar1 >> 0x20),(float)dVar1);
} |
6,105 | func0 |
#include <assert.h>
#include <math.h>
| float func0(int a, int b) {
int digits = 0;
int temp = b;
if (temp == 0) {
digits = 1;
} else {
while (temp != 0) {
digits++;
temp /= 10;
}
}
return a + b / pow(10, digits);
}
| int main() {
assert(func0(4, 56) == 4.56f);
assert(func0(7, 256) == 7.256f);
assert(func0(8, 123) == 8.123f);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebp
mov %esi,%ebx
mov $0x1,%ecx
test %esi,%esi
je 11a1 <func0+0x38>
mov %esi,%edx
mov $0x0,%ecx
add $0x1,%ecx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
sar $0x1f,%edx
sub %edx,%eax
mov %eax,%edx
jne 1187 <func0+0x1e>
pxor %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
movsd 0xedf(%rip),%xmm0
callq 1060 <pow@plt>
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
divsd %xmm1,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
addsd %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov ebp, edi
mov ebx, esi
mov ecx, 1
test esi, esi
jz short loc_11A1
mov edx, esi
mov ecx, 0
loc_1187:
add ecx, 1
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
sar edx, 1Fh
sub eax, edx
mov edx, eax
jnz short loc_1187
loc_11A1:
pxor xmm1, xmm1
cvtsi2sd xmm1, ecx
movsd xmm0, cs:qword_2070
call _pow
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, ebx
divsd xmm0, xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, ebp
addsd xmm0, xmm1
cvtsd2ss xmm0, xmm0
add rsp, 8
pop rbx
pop rbp
retn | float func0(int a1, int a2)
{
int v2; // ecx
int v3; // edx
v2 = 1;
if ( a2 )
{
v3 = a2;
v2 = 0;
do
{
++v2;
v3 /= 10;
}
while ( v3 );
}
return (double)a2 / pow(10.0, (double)v2) + (double)a1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBP,EDI
MOV EBX,ESI
MOV ECX,0x1
TEST ESI,ESI
JZ 0x001011a1
MOV EDX,ESI
MOV ECX,0x0
LAB_00101187:
ADD ECX,0x1
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
SAR EDX,0x1f
SUB EAX,EDX
MOV EDX,EAX
JNZ 0x00101187
LAB_001011a1:
PXOR XMM1,XMM1
CVTSI2SD XMM1,ECX
MOVSD XMM0,qword ptr [0x00102070]
CALL 0x00101060
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBX
DIVSD XMM0,XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,EBP
ADDSD XMM0,XMM1
CVTSD2SS XMM0,XMM0
ADD RSP,0x8
POP RBX
POP RBP
RET | int8 func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
double dVar3;
iVar1 = 1;
if (param_2 != 0) {
iVar1 = 0;
iVar2 = param_2;
do {
iVar1 = iVar1 + 1;
iVar2 = iVar2 / 10;
} while (iVar2 != 0);
}
dVar3 = pow(DAT_00102070,(double)iVar1);
dVar3 = (double)param_2 / dVar3 + (double)param_1;
return CONCAT44((int)((ulong)dVar3 >> 0x20),(float)dVar3);
} |
6,106 | func0 |
#include <assert.h>
#include <math.h>
| float func0(int a, int b) {
int digits = 0;
int temp = b;
if (temp == 0) {
digits = 1;
} else {
while (temp != 0) {
digits++;
temp /= 10;
}
}
return a + b / pow(10, digits);
}
| int main() {
assert(func0(4, 56) == 4.56f);
assert(func0(7, 256) == 7.256f);
assert(func0(8, 123) == 8.123f);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %edi,%ebp
push %rbx
mov %esi,%ebx
sub $0x8,%rsp
movsd 0xe92(%rip),%xmm1
test %esi,%esi
je 11a2 <func0+0x42>
mov %esi,%edx
xor %ecx,%ecx
xchg %ax,%ax
movslq %edx,%rax
sar $0x1f,%edx
add $0x1,%ecx
imul $0x66666667,%rax,%rax
sar $0x22,%rax
sub %edx,%eax
mov %eax,%edx
jne 1180 <func0+0x20>
pxor %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
movsd 0xe66(%rip),%xmm0
callq 1050 <pow@plt>
add $0x8,%rsp
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
pop %rbx
divsd %xmm1,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
pop %rbp
addsd %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov ebp, edi
push rbx
mov ebx, esi
sub rsp, 8
movsd xmm1, cs:qword_2070
test esi, esi
jz short loc_1276
mov edx, esi
xor r8d, r8d
nop
loc_1250:
movsxd rax, edx
mov ecx, edx
add r8d, 1
imul rax, 66666667h
sar ecx, 1Fh
sar rax, 22h
sub eax, ecx
mov edx, eax
jnz short loc_1250
pxor xmm1, xmm1
cvtsi2sd xmm1, r8d
loc_1276:
movsd xmm0, cs:qword_2078
call _pow
add rsp, 8
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, ebx
pop rbx
divsd xmm0, xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, ebp
pop rbp
addsd xmm0, xmm1
cvtsd2ss xmm0, xmm0
retn | float func0(int a1, int a2)
{
double v2; // xmm1_8
int v3; // edx
int v4; // r8d
v2 = 1.0;
if ( a2 )
{
v3 = a2;
v4 = 0;
do
{
++v4;
v3 /= 10;
}
while ( v3 );
v2 = (double)v4;
}
return (double)a2 / pow(10.0, v2) + (double)a1;
} | func0:
ENDBR64
PUSH RBP
MOV EBP,EDI
PUSH RBX
MOV EBX,ESI
SUB RSP,0x8
MOVSD XMM1,qword ptr [0x00102070]
TEST ESI,ESI
JZ 0x00101276
MOV EDX,ESI
XOR R8D,R8D
NOP
LAB_00101250:
MOVSXD RAX,EDX
MOV ECX,EDX
ADD R8D,0x1
IMUL RAX,RAX,0x66666667
SAR ECX,0x1f
SAR RAX,0x22
SUB EAX,ECX
MOV EDX,EAX
JNZ 0x00101250
PXOR XMM1,XMM1
CVTSI2SD XMM1,R8D
LAB_00101276:
MOVSD XMM0,qword ptr [0x00102078]
CALL 0x00101060
ADD RSP,0x8
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBX
POP RBX
DIVSD XMM0,XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,EBP
POP RBP
ADDSD XMM0,XMM1
CVTSD2SS XMM0,XMM0
RET | int8 func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
double dVar3;
dVar3 = DAT_00102070;
if (param_2 != 0) {
iVar2 = 0;
iVar1 = param_2;
do {
iVar2 = iVar2 + 1;
iVar1 = iVar1 / 10;
} while (iVar1 != 0);
dVar3 = (double)iVar2;
}
dVar3 = pow(DAT_00102078,dVar3);
dVar3 = (double)param_2 / dVar3 + (double)param_1;
return CONCAT44((int)((ulong)dVar3 >> 0x20),(float)dVar3);
} |
6,107 | func0 |
#include <assert.h>
#include <math.h>
| float func0(int a, int b) {
int digits = 0;
int temp = b;
if (temp == 0) {
digits = 1;
} else {
while (temp != 0) {
digits++;
temp /= 10;
}
}
return a + b / pow(10, digits);
}
| int main() {
assert(func0(4, 56) == 4.56f);
assert(func0(7, 256) == 7.256f);
assert(func0(8, 123) == 8.123f);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %edi,%ebp
push %rbx
mov %esi,%ebx
sub $0x8,%rsp
movsd 0xe92(%rip),%xmm1
test %esi,%esi
je 11a2 <func0+0x42>
mov %esi,%edx
xor %ecx,%ecx
xchg %ax,%ax
movslq %edx,%rax
sar $0x1f,%edx
add $0x1,%ecx
imul $0x66666667,%rax,%rax
sar $0x22,%rax
sub %edx,%eax
mov %eax,%edx
jne 1180 <func0+0x20>
pxor %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
movsd 0xe66(%rip),%xmm0
callq 1050 <pow@plt>
add $0x8,%rsp
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
pop %rbx
divsd %xmm1,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
pop %rbp
addsd %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov ebp, edi
push rbx
mov ebx, esi
sub rsp, 8
movsd xmm1, cs:qword_2008
test esi, esi
jz short loc_11A6
mov edx, esi
xor r8d, r8d
nop
loc_1180:
movsxd rax, edx
mov ecx, edx
add r8d, 1
imul rax, 66666667h
sar ecx, 1Fh
sar rax, 22h
sub eax, ecx
mov edx, eax
jnz short loc_1180
pxor xmm1, xmm1
cvtsi2sd xmm1, r8d; y
loc_11A6:
movsd xmm0, cs:x; x
call _pow
add rsp, 8
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, ebx
pop rbx
divsd xmm0, xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, ebp
pop rbp
addsd xmm0, xmm1
cvtsd2ss xmm0, xmm0
retn | float func0(int a1, int a2)
{
double v2; // xmm1_8
int v3; // edx
int v4; // r8d
v2 = 1.0;
if ( a2 )
{
v3 = a2;
v4 = 0;
do
{
++v4;
v3 /= 10;
}
while ( v3 );
v2 = (double)v4;
}
return (double)a2 / pow(10.0, v2) + (double)a1;
} | func0:
ENDBR64
PUSH RBP
MOV EBP,EDI
PUSH RBX
MOV EBX,ESI
SUB RSP,0x8
MOVSD XMM1,qword ptr [0x00102008]
TEST ESI,ESI
JZ 0x001011a6
MOV EDX,ESI
XOR R8D,R8D
NOP
LAB_00101180:
MOVSXD RAX,EDX
MOV ECX,EDX
ADD R8D,0x1
IMUL RAX,RAX,0x66666667
SAR ECX,0x1f
SAR RAX,0x22
SUB EAX,ECX
MOV EDX,EAX
JNZ 0x00101180
PXOR XMM1,XMM1
CVTSI2SD XMM1,R8D
LAB_001011a6:
MOVSD XMM0,qword ptr [0x00102010]
CALL 0x00101050
ADD RSP,0x8
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBX
POP RBX
DIVSD XMM0,XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,EBP
POP RBP
ADDSD XMM0,XMM1
CVTSD2SS XMM0,XMM0
RET | int8 func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
double dVar3;
dVar3 = DAT_00102008;
if (param_2 != 0) {
iVar2 = 0;
iVar1 = param_2;
do {
iVar2 = iVar2 + 1;
iVar1 = iVar1 / 10;
} while (iVar1 != 0);
dVar3 = (double)iVar2;
}
dVar3 = pow(DAT_00102010,dVar3);
dVar3 = (double)param_2 / dVar3 + (double)param_1;
return CONCAT44((int)((ulong)dVar3 >> 0x20),(float)dVar3);
} |
6,108 | func0 |
#include <assert.h>
#include <stdio.h>
| int* func0(int list[], int length, int* odd_length) {
static int od_li[100];
int j = 0;
for (int i = 0; i < length; i++) {
if (list[i] % 2 != 0) {
od_li[j++] = list[i];
}
}
*odd_length = j;
return od_li;
}
| int main() {
int list1[] = {1, 2, 3, 4, 5, 6};
int list2[] = {10, 11, 12, 13};
int list3[] = {7, 8, 9, 1};
int length1, length2, length3;
int* res;
res = func0(list1, 6, &length1);
assert(length1 == 3 && res[0] == 1 && res[1] == 3 && res[2] == 5);
res = func0(list2, 4, &length2);
assert(length2 == 2 && res[0] == 11 && res[1] == 13);
res = func0(list3, 4, &length3);
assert(length3 == 3 && res[0] == 7 && res[1] == 9 && res[2] == 1);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1201 <func0+0x78>
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 11fd <func0+0x74>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
mov (%rcx),%edx
cltq
lea 0x0(,%rax,4),%rcx
lea 0x2e46(%rip),%rax
mov %edx,(%rcx,%rax,1)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ac <func0+0x23>
mov -0x28(%rbp),%rax
mov -0x8(%rbp),%edx
mov %edx,(%rax)
lea 0x2e27(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_1201
loc_11AC:
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_11FD
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
mov edx, [rcx]
cdqe
lea rcx, ds:0[rax*4]
lea rax, od_li_1
mov [rcx+rax], edx
loc_11FD:
add [rbp+var_4], 1
loc_1201:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_11AC
mov rax, [rbp+var_28]
mov edx, [rbp+var_8]
mov [rax], edx
lea rax, od_li_1
pop rbp
retn | _DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
int v5; // [rsp+20h] [rbp-8h]
int i; // [rsp+24h] [rbp-4h]
v5 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) != 0 )
{
v3 = v5++;
od_li_1[v3] = *(_DWORD *)(4LL * i + a1);
}
}
*a3 = v5;
return od_li_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101201
LAB_001011ac:
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 0x001011fd
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
MOV EDX,dword ptr [RCX]
CDQE
LEA RCX,[RAX*0x4]
LEA RAX,[0x104040]
MOV dword ptr [RCX + RAX*0x1],EDX
LAB_001011fd:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101201:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ac
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x8]
MOV dword ptr [RAX],EDX
LEA RAX,[0x104040]
POP RBP
RET | int1 * func0(long param_1,int param_2,int *param_3)
{
int local_10;
int local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((*(uint *)(param_1 + (long)local_c * 4) & 1) != 0) {
*(int4 *)(od_li_1 + (long)local_10 * 4) = *(int4 *)((long)local_c * 4 + param_1);
local_10 = local_10 + 1;
}
}
*param_3 = local_10;
return od_li_1;
} |
6,109 | func0 |
#include <assert.h>
#include <stdio.h>
| int* func0(int list[], int length, int* odd_length) {
static int od_li[100];
int j = 0;
for (int i = 0; i < length; i++) {
if (list[i] % 2 != 0) {
od_li[j++] = list[i];
}
}
*odd_length = j;
return od_li;
}
| int main() {
int list1[] = {1, 2, 3, 4, 5, 6};
int list2[] = {10, 11, 12, 13};
int list3[] = {7, 8, 9, 1};
int length1, length2, length3;
int* res;
res = func0(list1, 6, &length1);
assert(length1 == 3 && res[0] == 1 && res[1] == 3 && res[2] == 5);
res = func0(list2, 4, &length2);
assert(length2 == 2 && res[0] == 11 && res[1] == 13);
res = func0(list3, 4, &length3);
assert(length3 == 3 && res[0] == 7 && res[1] == 9 && res[2] == 1);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11c6 <func0+0x3d>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%rdi
mov $0x0,%esi
lea 0x2e98(%rip),%r9
jmp 11b3 <func0+0x2a>
add $0x4,%rax
cmp %rdi,%rax
je 11cb <func0+0x42>
mov (%rax),%ecx
test $0x1,%cl
je 11aa <func0+0x21>
movslq %esi,%r8
mov %ecx,(%r9,%r8,4)
lea 0x1(%rsi),%esi
jmp 11aa <func0+0x21>
mov $0x0,%esi
mov %esi,(%rdx)
lea 0x2e6c(%rip),%rax
retq
| func0:
endbr64
test esi, esi
jle short loc_11C6
mov rax, rdi
lea ecx, [rsi-1]
lea rdi, [rdi+rcx*4+4]
mov esi, 0
lea r9, od_li_1
jmp short loc_11B3
loc_11AA:
add rax, 4
cmp rax, rdi
jz short loc_11CB
loc_11B3:
mov ecx, [rax]
test cl, 1
jz short loc_11AA
movsxd r8, esi
mov [r9+r8*4], ecx
lea esi, [rsi+1]
jmp short loc_11AA
loc_11C6:
mov esi, 0
loc_11CB:
mov [rdx], esi
lea rax, od_li_1
retn | _DWORD * func0(_DWORD *a1, int a2, _DWORD *a3)
{
_DWORD *v3; // rax
long long v4; // rdi
int v5; // esi
if ( a2 <= 0 )
{
v5 = 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[a2 - 1 + 1];
v5 = 0;
do
{
if ( (*v3 & 1) != 0 )
od_li_1[v5++] = *v3;
++v3;
}
while ( v3 != (_DWORD *)v4 );
}
*a3 = v5;
return od_li_1;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011c6
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA RDI,[RDI + RCX*0x4 + 0x4]
MOV ESI,0x0
LEA R9,[0x104040]
JMP 0x001011b3
LAB_001011aa:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x001011cb
LAB_001011b3:
MOV ECX,dword ptr [RAX]
TEST CL,0x1
JZ 0x001011aa
MOVSXD R8,ESI
MOV dword ptr [R9 + R8*0x4],ECX
LEA ESI,[RSI + 0x1]
JMP 0x001011aa
LAB_001011c6:
MOV ESI,0x0
LAB_001011cb:
MOV dword ptr [RDX],ESI
LEA RAX,[0x104040]
RET | int4 * func0(uint *param_1,int param_2,int *param_3)
{
uint *puVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
if ((*param_1 & 1) != 0) {
(&od_li_1)[iVar2] = *param_1;
iVar2 = iVar2 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
*param_3 = iVar2;
return &od_li_1;
} |
6,110 | func0 |
#include <assert.h>
#include <stdio.h>
| int* func0(int list[], int length, int* odd_length) {
static int od_li[100];
int j = 0;
for (int i = 0; i < length; i++) {
if (list[i] % 2 != 0) {
od_li[j++] = list[i];
}
}
*odd_length = j;
return od_li;
}
| int main() {
int list1[] = {1, 2, 3, 4, 5, 6};
int list2[] = {10, 11, 12, 13};
int list3[] = {7, 8, 9, 1};
int length1, length2, length3;
int* res;
res = func0(list1, 6, &length1);
assert(length1 == 3 && res[0] == 1 && res[1] == 3 && res[2] == 5);
res = func0(list2, 4, &length2);
assert(length2 == 2 && res[0] == 11 && res[1] == 13);
res = func0(list3, 4, &length3);
assert(length3 == 3 && res[0] == 7 && res[1] == 9 && res[2] == 1);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 13c8 <func0+0x48>
lea -0x1(%rsi),%eax
xor %ecx,%ecx
lea 0x2cac(%rip),%r9
lea 0x4(%rdi,%rax,4),%rsi
nopl 0x0(%rax)
mov (%rdi),%eax
test $0x1,%al
je 13b0 <func0+0x30>
movslq %ecx,%r8
add $0x1,%ecx
mov %eax,(%r9,%r8,4)
add $0x4,%rdi
cmp %rsi,%rdi
jne 13a0 <func0+0x20>
mov %ecx,(%rdx)
lea 0x2c7e(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
xor %ecx,%ecx
lea 0x2c6f(%rip),%rax
mov %ecx,(%rdx)
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle short loc_1370
lea eax, [rsi-1]
xor ecx, ecx
lea r9, od_li_1
lea rsi, [rdi+rax*4+4]
nop dword ptr [rax+00000000h]
loc_1350:
mov eax, [rdi]
test al, 1
jz short loc_1360
movsxd r8, ecx
add ecx, 1
mov [r9+r8*4], eax
loc_1360:
add rdi, 4
cmp rdi, rsi
jnz short loc_1350
mov [rdx], ecx
mov rax, r9
retn
loc_1370:
xor ecx, ecx
lea r9, od_li_1
mov [rdx], ecx
mov rax, r9
retn | _DWORD * func0(_DWORD *a1, int a2, _DWORD *a3)
{
int v3; // ecx
long long v4; // rsi
long long v5; // r8
if ( a2 <= 0 )
{
*a3 = 0;
return od_li_1;
}
else
{
v3 = 0;
v4 = (long long)&a1[a2 - 1 + 1];
do
{
if ( (*a1 & 1) != 0 )
{
v5 = v3++;
od_li_1[v5] = *a1;
}
++a1;
}
while ( a1 != (_DWORD *)v4 );
*a3 = v3;
return od_li_1;
}
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101370
LEA EAX,[RSI + -0x1]
XOR ECX,ECX
LEA R9,[0x104040]
LEA RSI,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX]
LAB_00101350:
MOV EAX,dword ptr [RDI]
TEST AL,0x1
JZ 0x00101360
MOVSXD R8,ECX
ADD ECX,0x1
MOV dword ptr [R9 + R8*0x4],EAX
LAB_00101360:
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x00101350
MOV dword ptr [RDX],ECX
MOV RAX,R9
RET
LAB_00101370:
XOR ECX,ECX
LEA R9,[0x104040]
MOV dword ptr [RDX],ECX
MOV RAX,R9
RET | int4 * func0(uint *param_1,int param_2,int *param_3)
{
uint *puVar1;
int iVar2;
long lVar3;
if (0 < param_2) {
iVar2 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if ((*param_1 & 1) != 0) {
lVar3 = (long)iVar2;
iVar2 = iVar2 + 1;
(&od_li_1)[lVar3] = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
*param_3 = iVar2;
return &od_li_1;
}
*param_3 = 0;
return &od_li_1;
} |
6,111 | func0 |
#include <assert.h>
#include <stdio.h>
| int* func0(int list[], int length, int* odd_length) {
static int od_li[100];
int j = 0;
for (int i = 0; i < length; i++) {
if (list[i] % 2 != 0) {
od_li[j++] = list[i];
}
}
*odd_length = j;
return od_li;
}
| int main() {
int list1[] = {1, 2, 3, 4, 5, 6};
int list2[] = {10, 11, 12, 13};
int list3[] = {7, 8, 9, 1};
int length1, length2, length3;
int* res;
res = func0(list1, 6, &length1);
assert(length1 == 3 && res[0] == 1 && res[1] == 3 && res[2] == 5);
res = func0(list2, 4, &length2);
assert(length2 == 2 && res[0] == 11 && res[1] == 13);
res = func0(list3, 4, &length3);
assert(length3 == 3 && res[0] == 7 && res[1] == 9 && res[2] == 1);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1438 <func0+0x48>
lea -0x1(%rsi),%eax
xor %ecx,%ecx
lea 0x2c3c(%rip),%r9
lea 0x4(%rdi,%rax,4),%rsi
nopl 0x0(%rax)
mov (%rdi),%eax
test $0x1,%al
je 1420 <func0+0x30>
movslq %ecx,%r8
add $0x1,%ecx
mov %eax,(%r9,%r8,4)
add $0x4,%rdi
cmp %rsi,%rdi
jne 1410 <func0+0x20>
mov %ecx,(%rdx)
lea 0x2c0e(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
xor %ecx,%ecx
lea 0x2bff(%rip),%rax
mov %ecx,(%rdx)
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle short loc_11D0
movsxd rsi, esi
xor ecx, ecx
lea r9, od_li_1
lea rsi, [rdi+rsi*4]
nop dword ptr [rax+rax+00000000h]
loc_11B0:
mov eax, [rdi]
test al, 1
jz short loc_11C0
movsxd r8, ecx
add ecx, 1
mov [r9+r8*4], eax
loc_11C0:
add rdi, 4
cmp rdi, rsi
jnz short loc_11B0
mov [rdx], ecx
mov rax, r9
retn
loc_11D0:
xor ecx, ecx
lea r9, od_li_1
mov [rdx], ecx
mov rax, r9
retn | long long * func0(_DWORD *a1, int a2, _DWORD *a3)
{
int v3; // ecx
_DWORD *v4; // rsi
long long v5; // r8
if ( a2 <= 0 )
{
*a3 = 0;
return &od_li_1;
}
else
{
v3 = 0;
v4 = &a1[a2];
do
{
if ( (*a1 & 1) != 0 )
{
v5 = v3++;
*((_DWORD *)&od_li_1 + v5) = *a1;
}
++a1;
}
while ( a1 != v4 );
*a3 = v3;
return &od_li_1;
}
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011d0
MOVSXD RSI,ESI
XOR ECX,ECX
LEA R9,[0x104040]
LEA RSI,[RDI + RSI*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001011b0:
MOV EAX,dword ptr [RDI]
TEST AL,0x1
JZ 0x001011c0
MOVSXD R8,ECX
ADD ECX,0x1
MOV dword ptr [R9 + R8*0x4],EAX
LAB_001011c0:
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x001011b0
MOV dword ptr [RDX],ECX
MOV RAX,R9
RET
LAB_001011d0:
XOR ECX,ECX
LEA R9,[0x104040]
MOV dword ptr [RDX],ECX
MOV RAX,R9
RET | int4 * func0(uint *param_1,int param_2,int *param_3)
{
uint *puVar1;
int iVar2;
long lVar3;
if (0 < param_2) {
iVar2 = 0;
puVar1 = param_1 + param_2;
do {
if ((*param_1 & 1) != 0) {
lVar3 = (long)iVar2;
iVar2 = iVar2 + 1;
(&od_li_1)[lVar3] = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
*param_3 = iVar2;
return &od_li_1;
}
*param_3 = 0;
return &od_li_1;
} |
6,112 | func0 |
#include <assert.h>
| int func0(int n) {
int S = (n * (n + 1)) / 2;
int res = S * (S - 1);
return res;
}
| int main() {
assert(func0(3) == 30);
assert(func0(5) == 210);
assert(func0(2) == 6);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
add $0x1,%eax
imul -0x14(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x8(%rbp)
mov -0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x8(%rbp),%eax
imul %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
add eax, 1
imul eax, [rbp+var_14]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_8], eax
mov eax, [rbp+var_8]
lea edx, [rax-1]
mov eax, [rbp+var_8]
imul eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)((a1 * (a1 + 1) / 2 - 1) * (a1 * (a1 + 1) / 2));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
IMUL EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1)
{
int iVar1;
iVar1 = ((param_1 + 1) * param_1) / 2;
return iVar1 * (iVar1 + -1);
} |
6,113 | func0 |
#include <assert.h>
| int func0(int n) {
int S = (n * (n + 1)) / 2;
int res = S * (S - 1);
return res;
}
| int main() {
assert(func0(3) == 30);
assert(func0(5) == 210);
assert(func0(2) == 6);
return 0;
}
| O1 | c | func0:
endbr64
lea 0x1(%rdi),%eax
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
lea -0x1(%rax),%edi
imul %edi,%eax
retq
| func0:
endbr64
lea eax, [rdi+1]
imul eax, edi
mov edx, eax
shr edx, 1Fh
add edx, eax
sar edx, 1
lea eax, [rdx-1]
imul eax, edx
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1) / 2 * (a1 * (a1 + 1) / 2 - 1));
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
IMUL EAX,EDI
MOV EDX,EAX
SHR EDX,0x1f
ADD EDX,EAX
SAR EDX,0x1
LEA EAX,[RDX + -0x1]
IMUL EAX,EDX
RET | int func0(int param_1)
{
int iVar1;
iVar1 = ((param_1 + 1) * param_1) / 2;
return (iVar1 + -1) * iVar1;
} |
6,114 | func0 |
#include <assert.h>
| int func0(int n) {
int S = (n * (n + 1)) / 2;
int res = S * (S - 1);
return res;
}
| int main() {
assert(func0(3) == 30);
assert(func0(5) == 210);
assert(func0(2) == 6);
return 0;
}
| O2 | c | func0:
endbr64
lea 0x1(%rdi),%eax
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
lea -0x1(%rax),%edi
imul %edi,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi+1]
imul eax, edi
mov edx, eax
shr edx, 1Fh
add edx, eax
sar edx, 1
lea eax, [rdx-1]
imul eax, edx
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1) / 2 * (a1 * (a1 + 1) / 2 - 1));
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
IMUL EAX,EDI
MOV EDX,EAX
SHR EDX,0x1f
ADD EDX,EAX
SAR EDX,0x1
LEA EAX,[RDX + -0x1]
IMUL EAX,EDX
RET | int func0(int param_1)
{
int iVar1;
iVar1 = ((param_1 + 1) * param_1) / 2;
return (iVar1 + -1) * iVar1;
} |
6,115 | func0 |
#include <assert.h>
| int func0(int n) {
int S = (n * (n + 1)) / 2;
int res = S * (S - 1);
return res;
}
| int main() {
assert(func0(3) == 30);
assert(func0(5) == 210);
assert(func0(2) == 6);
return 0;
}
| O3 | c | func0:
endbr64
lea 0x1(%rdi),%eax
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
lea -0x1(%rax),%edi
imul %edi,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi+1]
imul eax, edi
mov edx, eax
shr edx, 1Fh
add edx, eax
sar edx, 1
lea eax, [rdx-1]
imul eax, edx
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1) / 2 * (a1 * (a1 + 1) / 2 - 1));
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
IMUL EAX,EDI
MOV EDX,EAX
SHR EDX,0x1f
ADD EDX,EAX
SAR EDX,0x1
LEA EAX,[RDX + -0x1]
IMUL EAX,EDX
RET | int func0(int param_1)
{
int iVar1;
iVar1 = ((param_1 + 1) * param_1) / 2;
return (iVar1 + -1) * iVar1;
} |
6,116 | func0 |
#include <assert.h>
| int func0(int A[], int N) {
int oddPair = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
if ((A[i] ^ A[j]) % 2 != 0) {
oddPair++;
}
}
}
return oddPair;
}
| int main() {
int array1[] = {5, 4, 7, 2, 1};
int array2[] = {7, 2, 8, 1, 0, 5, 11};
int array3[] = {1, 2, 3};
assert(func0(array1, 5) == 6);
assert(func0(array2, 7) == 12);
assert(func0(array3, 3) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11dc <func0+0x73>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11d0 <func0+0x67>
mov -0x8(%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 -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
xor %edx,%eax
and $0x1,%eax
test %eax,%eax
je 11cc <func0+0x63>
addl $0x1,-0xc(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1193 <func0+0x2a>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0xc(%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_C], 0
mov [rbp+var_8], 0
jmp short loc_11DC
loc_1188:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11D0
loc_1193:
mov eax, [rbp+var_8]
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_18]
add rax, rcx
mov eax, [rax]
xor eax, edx
and eax, 1
test eax, eax
jz short loc_11CC
add [rbp+var_C], 1
loc_11CC:
add [rbp+var_4], 1
loc_11D0:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1193
add [rbp+var_8], 1
loc_11DC:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( (((unsigned __int8)*(_DWORD *)(4LL * i + a1) ^ (unsigned __int8)*(_DWORD *)(4LL * j + a1)) & 1) != 0 )
++v3;
}
}
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 + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011dc
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011d0
LAB_00101193:
MOV EAX,dword ptr [RBP + -0x8]
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 + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
XOR EAX,EDX
AND EAX,0x1
TEST EAX,EAX
JZ 0x001011cc
ADD dword ptr [RBP + -0xc],0x1
LAB_001011cc:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d0:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101193
ADD dword ptr [RBP + -0x8],0x1
LAB_001011dc:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_c = local_10, local_10 < param_2; local_10 = local_10 + 1) {
while (local_c = local_c + 1, local_c < param_2) {
if (((*(uint *)(param_1 + (long)local_c * 4) ^ *(uint *)(param_1 + (long)local_10 * 4)) & 1)
!= 0) {
local_14 = local_14 + 1;
}
}
}
return local_14;
} |
6,117 | func0 |
#include <assert.h>
| int func0(int A[], int N) {
int oddPair = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
if ((A[i] ^ A[j]) % 2 != 0) {
oddPair++;
}
}
}
return oddPair;
}
| int main() {
int array1[] = {5, 4, 7, 2, 1};
int array2[] = {7, 2, 8, 1, 0, 5, 11};
int array3[] = {1, 2, 3};
assert(func0(array1, 5) == 6);
assert(func0(array2, 7) == 12);
assert(func0(array3, 3) == 2);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ae <func0+0x45>
lea -0x1(%rsi),%r10d
add $0x1,%r10
mov $0x1,%r9d
mov $0x0,%ecx
cmp %r10,%r9
je 11b3 <func0+0x4a>
mov -0x4(%rdi,%r9,4),%r8d
mov %r9,%rax
mov %r8d,%edx
xor (%rdi,%rax,4),%edx
and $0x1,%edx
cmp $0x1,%edx
sbb $0xffffffff,%ecx
add $0x1,%rax
cmp %eax,%esi
jg 1191 <func0+0x28>
add $0x1,%r9
jmp 1184 <func0+0x1b>
mov $0x0,%ecx
mov %ecx,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_11A9
mov r10d, esi
mov r9d, 1
mov ecx, 0
loc_117F:
cmp r9, r10
jz short loc_11AE
mov r8d, [rdi+r9*4-4]
mov rax, r9
loc_118C:
mov edx, r8d
xor edx, [rdi+rax*4]
and edx, 1
cmp edx, 1
sbb ecx, 0FFFFFFFFh
add rax, 1
cmp esi, eax
jg short loc_118C
add r9, 1
jmp short loc_117F
loc_11A9:
mov ecx, 0
loc_11AE:
mov eax, ecx
retn | long long func0(long long a1, int a2)
{
long long v2; // r9
unsigned int v3; // ecx
long long v4; // rax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = 1LL;
v3 = 0;
while ( v2 != a2 )
{
v4 = v2;
do
v3 -= (((*(_DWORD *)(a1 + 4 * v4++) ^ *(_DWORD *)(a1 + 4 * v2 - 4)) & 1) == 0) - 1;
while ( a2 > (int)v4 );
++v2;
}
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a9
MOV R10D,ESI
MOV R9D,0x1
MOV ECX,0x0
LAB_0010117f:
CMP R9,R10
JZ 0x001011ae
MOV R8D,dword ptr [RDI + R9*0x4 + -0x4]
MOV RAX,R9
LAB_0010118c:
MOV EDX,R8D
XOR EDX,dword ptr [RDI + RAX*0x4]
AND EDX,0x1
CMP EDX,0x1
SBB ECX,-0x1
ADD RAX,0x1
CMP ESI,EAX
JG 0x0010118c
ADD R9,0x1
JMP 0x0010117f
LAB_001011a9:
MOV ECX,0x0
LAB_001011ae:
MOV EAX,ECX
RET | int func0(long param_1,uint param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
if ((int)param_2 < 1) {
iVar2 = 0;
}
else {
iVar2 = 0;
for (uVar3 = 1; uVar3 != param_2; uVar3 = uVar3 + 1) {
uVar1 = uVar3;
do {
iVar2 = (iVar2 + 1) -
(uint)(((*(uint *)(param_1 + -4 + uVar3 * 4) ^ *(uint *)(param_1 + uVar1 * 4)) & 1)
== 0);
uVar1 = uVar1 + 1;
} while ((int)uVar1 < (int)param_2);
}
}
return iVar2;
} |
6,118 | func0 |
#include <assert.h>
| int func0(int A[], int N) {
int oddPair = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
if ((A[i] ^ A[j]) % 2 != 0) {
oddPair++;
}
}
}
return oddPair;
}
| int main() {
int array1[] = {5, 4, 7, 2, 1};
int array2[] = {7, 2, 8, 1, 0, 5, 11};
int array3[] = {1, 2, 3};
assert(func0(array1, 5) == 6);
assert(func0(array2, 7) == 12);
assert(func0(array3, 3) == 2);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 13c4 <func0+0x54>
lea -0x1(%rsi),%r10d
mov $0x1,%r9d
xor %r8d,%r8d
add $0x1,%r10
cmp %r10,%r9
je 13c0 <func0+0x50>
xchg %ax,%ax
mov -0x4(%rdi,%r9,4),%ecx
mov %r9,%rax
nopl 0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%edx
xor %ecx,%edx
and $0x1,%edx
cmp $0x1,%edx
sbb $0xffffffff,%r8d
add $0x1,%rax
cmp %eax,%esi
jg 13a0 <func0+0x30>
add $0x1,%r9
cmp %r10,%r9
jne 1390 <func0+0x20>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1304
movsxd r10, esi
mov r9d, 1
xor r8d, r8d
cmp r9, r10
jz short loc_1300
nop dword ptr [rax+00000000h]
loc_12D0:
mov ecx, [rdi+r9*4-4]
mov rax, r9
nop dword ptr [rax+rax+00000000h]
loc_12E0:
mov edx, [rdi+rax*4]
xor edx, ecx
and edx, 1
cmp edx, 1
sbb r8d, 0FFFFFFFFh
add rax, 1
cmp esi, eax
jg short loc_12E0
add r9, 1
cmp r9, r10
jnz short loc_12D0
loc_1300:
mov eax, r8d
retn
loc_1304:
xor r8d, r8d
mov eax, r8d
retn | long long func0(long long a1, int a2)
{
long long v2; // r9
unsigned int i; // r8d
long long v4; // rax
if ( a2 <= 0 )
return 0LL;
v2 = 1LL;
for ( i = 0; v2 != a2; ++v2 )
{
v4 = v2;
do
i -= ((((unsigned __int8)*(_DWORD *)(a1 + 4 * v2 - 4) ^ (unsigned __int8)*(_DWORD *)(a1 + 4 * v4++)) & 1) == 0)
- 1;
while ( a2 > (int)v4 );
}
return i;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101304
MOVSXD R10,ESI
MOV R9D,0x1
XOR R8D,R8D
CMP R9,R10
JZ 0x00101300
NOP dword ptr [RAX]
LAB_001012d0:
MOV ECX,dword ptr [RDI + R9*0x4 + -0x4]
MOV RAX,R9
NOP dword ptr [RAX + RAX*0x1]
LAB_001012e0:
MOV EDX,dword ptr [RDI + RAX*0x4]
XOR EDX,ECX
AND EDX,0x1
CMP EDX,0x1
SBB R8D,-0x1
ADD RAX,0x1
CMP ESI,EAX
JG 0x001012e0
ADD R9,0x1
CMP R9,R10
JNZ 0x001012d0
LAB_00101300:
MOV EAX,R8D
RET
LAB_00101304:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
long lVar3;
if (0 < param_2) {
lVar3 = 1;
iVar2 = 0;
if ((long)param_2 != 1) {
do {
lVar1 = lVar3;
do {
iVar2 = (iVar2 + 1) -
(uint)(((*(uint *)(param_1 + lVar1 * 4) ^ *(uint *)(param_1 + -4 + lVar3 * 4)) & 1
) == 0);
lVar1 = lVar1 + 1;
} while ((int)lVar1 < param_2);
lVar3 = lVar3 + 1;
} while (lVar3 != param_2);
}
return iVar2;
}
return 0;
} |
6,119 | func0 |
#include <assert.h>
| int func0(int A[], int N) {
int oddPair = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
if ((A[i] ^ A[j]) % 2 != 0) {
oddPair++;
}
}
}
return oddPair;
}
| int main() {
int array1[] = {5, 4, 7, 2, 1};
int array2[] = {7, 2, 8, 1, 0, 5, 11};
int array3[] = {1, 2, 3};
assert(func0(array1, 5) == 6);
assert(func0(array2, 7) == 12);
assert(func0(array3, 3) == 2);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 14a3 <func0+0x153>
cmp $0x1,%esi
je 14a3 <func0+0x153>
push %r14
lea 0x4(%rdi),%r10
xor %r8d,%r8d
mov $0x1,%ecx
push %rbp
mov $0x1,%r11d
pxor %xmm4,%xmm4
pcmpeqd %xmm3,%xmm3
movdqa 0xd06(%rip),%xmm5
push %rbx
lea -0x1(%rsi),%ebx
xchg %ax,%ax
mov %esi,%ebp
mov %ebx,%eax
mov -0x4(%r10),%r9d
sub %ecx,%ebp
cmp %ecx,%esi
cmovle %r11d,%ebp
sub %ecx,%eax
cmp $0x3,%eax
jbe 149c <func0+0x14c>
cmp %ecx,%esi
jle 149c <func0+0x14c>
mov %ebp,%edx
movd %r9d,%xmm6
pxor %xmm1,%xmm1
mov %r10,%rax
shr $0x2,%edx
pshufd $0x0,%xmm6,%xmm2
shl $0x4,%rdx
add %r10,%rdx
movdqu (%rax),%xmm0
add $0x10,%rax
pxor %xmm2,%xmm0
pand %xmm5,%xmm0
pcmpeqd %xmm4,%xmm0
pandn %xmm3,%xmm0
psubd %xmm0,%xmm1
cmp %rdx,%rax
jne 13d0 <func0+0x80>
movdqa %xmm1,%xmm0
mov %ebp,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%edx
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
add %eax,%r8d
lea (%rdx,%rcx,1),%eax
cmp %edx,%ebp
je 1485 <func0+0x135>
movslq %eax,%rdx
mov (%rdi,%rdx,4),%r14d
lea 0x0(,%rdx,4),%rbp
xor %r9d,%r14d
mov %r14d,%edx
and $0x1,%edx
cmp $0x1,%edx
lea 0x1(%rax),%edx
sbb $0xffffffff,%r8d
cmp %edx,%esi
jle 1485 <func0+0x135>
mov 0x4(%rdi,%rbp,1),%edx
xor %r9d,%edx
and $0x1,%edx
cmp $0x1,%edx
lea 0x2(%rax),%edx
sbb $0xffffffff,%r8d
cmp %edx,%esi
jle 1485 <func0+0x135>
mov 0x8(%rdi,%rbp,1),%edx
xor %r9d,%edx
and $0x1,%edx
cmp $0x1,%edx
sbb $0xffffffff,%r8d
add $0x3,%eax
cmp %esi,%eax
jge 1485 <func0+0x135>
xor 0xc(%rdi,%rbp,1),%r9d
and $0x1,%r9d
cmp $0x1,%r9d
sbb $0xffffffff,%r8d
add $0x1,%ecx
add $0x4,%r10
cmp %ecx,%esi
jne 1390 <func0+0x40>
pop %rbx
mov %r8d,%eax
pop %rbp
pop %r14
retq
mov %ecx,%eax
jmpq 141e <func0+0xce>
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle loc_127E
mov r8d, esi
cmp esi, 1
jz loc_127E
push r14
mov r11, rdi
lea r10, [rdi+4]
mov ecx, 1
movdqa xmm4, cs:xmmword_2010
push rbp
xor edi, edi
lea ebp, [rsi-1]
push rbx
pxor xmm2, xmm2
mov ebx, 1
xchg ax, ax
loc_1180:
mov r9d, r8d
mov eax, ebp
mov esi, [r10-4]
sub r9d, ecx
cmp r8d, ecx
cmovle r9d, ebx
sub eax, ecx
cmp eax, 2
jbe loc_127A
cmp r8d, ecx
jle loc_127A
mov edx, r9d
movd xmm5, esi
pxor xmm1, xmm1
mov rax, r10
shr edx, 2
pshufd xmm3, xmm5, 0
shl rdx, 4
add rdx, r10
nop dword ptr [rax+00h]
loc_11C8:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pxor xmm0, xmm3
pand xmm0, xmm4
pcmpeqd xmm0, xmm2
pcmpeqd xmm0, xmm2
psubd xmm1, xmm0
cmp rax, rdx
jnz short loc_11C8
movdqa xmm0, xmm1
psrldq xmm0, 8
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
add edi, eax
mov eax, r9d
and eax, 0FFFFFFFCh
add eax, ecx
and r9d, 3
jz short loc_1263
loc_1217:
movsxd rdx, eax
mov r14d, [r11+rdx*4]
lea r9, ds:0[rdx*4]
xor r14d, esi
mov edx, r14d
and edx, 1
cmp edx, 1
lea edx, [rax+1]
sbb edi, 0FFFFFFFFh
cmp r8d, edx
jle short loc_1263
mov edx, [r11+r9+4]
xor edx, esi
and edx, 1
cmp edx, 1
sbb edi, 0FFFFFFFFh
add eax, 2
cmp r8d, eax
jle short loc_1263
xor esi, [r11+r9+8]
and esi, 1
cmp esi, 1
sbb edi, 0FFFFFFFFh
loc_1263:
add ecx, 1
add r10, 4
cmp r8d, ecx
jnz loc_1180
pop rbx
mov eax, edi
pop rbp
pop r14
retn
loc_127A:
mov eax, ecx
jmp short loc_1217
loc_127E:
xor edi, edi
mov eax, edi
retn | long long func0(long long a1, int a2)
{
const __m128i *v4; // r10
int v5; // ecx
__m128i si128; // xmm4
unsigned int v7; // edi
int v8; // ebp
unsigned int v9; // esi
unsigned int v10; // r9d
__m128i v11; // xmm1
const __m128i *v12; // rax
__m128i v13; // xmm3
__m128i v14; // xmm0
__m128i v15; // xmm1
int v16; // eax
long long v17; // r9
if ( a2 > 0 && a2 != 1 )
{
v4 = (const __m128i *)(a1 + 4);
v5 = 1;
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v7 = 0;
v8 = a2 - 1;
while ( 1 )
{
v9 = v4[-1].m128i_u32[3];
v10 = a2 - v5;
if ( a2 <= v5 )
v10 = 1;
if ( (unsigned int)(v8 - v5) <= 2 || a2 <= v5 )
break;
v11 = 0LL;
v12 = v4;
v13 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v9), 0);
do
{
v14 = _mm_loadu_si128(v12++);
v11 = _mm_sub_epi32(
v11,
_mm_cmpeq_epi32(
_mm_cmpeq_epi32(_mm_and_si128(_mm_xor_si128(v14, v13), si128), (__m128i)0LL),
(__m128i)0LL));
}
while ( v12 != &v4[v10 >> 2] );
v15 = _mm_add_epi32(v11, _mm_srli_si128(v11, 8));
v7 += _mm_cvtsi128_si32(_mm_add_epi32(v15, _mm_srli_si128(v15, 4)));
v16 = v5 + (v10 & 0xFFFFFFFC);
if ( (v10 & 3) != 0 )
goto LABEL_11;
LABEL_14:
++v5;
v4 = (const __m128i *)((char *)v4 + 4);
if ( a2 == v5 )
return v7;
}
v16 = v5;
LABEL_11:
v17 = 4LL * v16;
v7 -= ((((unsigned __int8)v9 ^ *(_BYTE *)(a1 + v17)) & 1) == 0) - 1;
if ( a2 > v16 + 1 )
{
v7 -= ((((unsigned __int8)v9 ^ (unsigned __int8)*(_DWORD *)(a1 + v17 + 4)) & 1) == 0) - 1;
if ( a2 > v16 + 2 )
v7 -= (((*(_DWORD *)(a1 + v17 + 8) ^ v9) & 1) == 0) - 1;
}
goto LABEL_14;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010127e
MOV R8D,ESI
CMP ESI,0x1
JZ 0x0010127e
PUSH R14
MOV R11,RDI
LEA R10,[RDI + 0x4]
MOV ECX,0x1
MOVDQA XMM4,xmmword ptr [0x00102010]
PUSH RBP
XOR EDI,EDI
LEA EBP,[RSI + -0x1]
PUSH RBX
PXOR XMM2,XMM2
MOV EBX,0x1
NOP
LAB_00101180:
MOV R9D,R8D
MOV EAX,EBP
MOV ESI,dword ptr [R10 + -0x4]
SUB R9D,ECX
CMP R8D,ECX
CMOVLE R9D,EBX
SUB EAX,ECX
CMP EAX,0x2
JBE 0x0010127a
CMP R8D,ECX
JLE 0x0010127a
MOV EDX,R9D
MOVD XMM5,ESI
PXOR XMM1,XMM1
MOV RAX,R10
SHR EDX,0x2
PSHUFD XMM3,XMM5,0x0
SHL RDX,0x4
ADD RDX,R10
NOP dword ptr [RAX]
LAB_001011c8:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PXOR XMM0,XMM3
PAND XMM0,XMM4
PCMPEQD XMM0,XMM2
PCMPEQD XMM0,XMM2
PSUBD XMM1,XMM0
CMP RAX,RDX
JNZ 0x001011c8
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x8
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
ADD EDI,EAX
MOV EAX,R9D
AND EAX,0xfffffffc
ADD EAX,ECX
AND R9D,0x3
JZ 0x00101263
LAB_00101217:
MOVSXD RDX,EAX
MOV R14D,dword ptr [R11 + RDX*0x4]
LEA R9,[RDX*0x4]
XOR R14D,ESI
MOV EDX,R14D
AND EDX,0x1
CMP EDX,0x1
LEA EDX,[RAX + 0x1]
SBB EDI,-0x1
CMP R8D,EDX
JLE 0x00101263
MOV EDX,dword ptr [R11 + R9*0x1 + 0x4]
XOR EDX,ESI
AND EDX,0x1
CMP EDX,0x1
SBB EDI,-0x1
ADD EAX,0x2
CMP R8D,EAX
JLE 0x00101263
XOR ESI,dword ptr [R11 + R9*0x1 + 0x8]
AND ESI,0x1
CMP ESI,0x1
SBB EDI,-0x1
LAB_00101263:
ADD ECX,0x1
ADD R10,0x4
CMP R8D,ECX
JNZ 0x00101180
POP RBX
MOV EAX,EDI
POP RBP
POP R14
RET
LAB_0010127a:
MOV EAX,ECX
JMP 0x00101217
LAB_0010127e:
XOR EDI,EDI
MOV EAX,EDI
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(long param_1,int param_2)
{
long lVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
int iVar9;
int iVar10;
uint *puVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
if ((param_2 < 1) || (param_2 == 1)) {
return 0;
}
puVar11 = (uint *)(param_1 + 4);
iVar9 = 1;
iVar10 = 0;
do {
uVar2 = puVar11[-1];
uVar3 = param_2 - iVar9;
if (param_2 <= iVar9) {
uVar3 = 1;
}
iVar12 = iVar9;
if (((uint)((param_2 + -1) - iVar9) < 3) || (param_2 <= iVar9)) {
LAB_00101217:
lVar1 = (long)iVar12 * 4;
iVar10 = (iVar10 + 1) - (uint)(((*(uint *)(param_1 + (long)iVar12 * 4) ^ uVar2) & 1) == 0);
if ((iVar12 + 1 < param_2) &&
(iVar10 = (iVar10 + 1) - (uint)(((*(uint *)(param_1 + 4 + lVar1) ^ uVar2) & 1) == 0),
iVar12 + 2 < param_2)) {
iVar10 = (iVar10 + 1) - (uint)(((uVar2 ^ *(uint *)(param_1 + 8 + lVar1)) & 1) == 0);
}
}
else {
iVar12 = 0;
iVar13 = 0;
iVar14 = 0;
iVar15 = 0;
puVar8 = puVar11;
do {
uVar4 = *puVar8;
puVar5 = puVar8 + 1;
puVar6 = puVar8 + 2;
puVar7 = puVar8 + 3;
puVar8 = puVar8 + 4;
iVar12 = iVar12 + (uint)(((uVar4 ^ uVar2) & _DAT_00102010) != 0);
iVar13 = iVar13 + (uint)(((*puVar5 ^ uVar2) & _UNK_00102014) != 0);
iVar14 = iVar14 + (uint)(((*puVar6 ^ uVar2) & _UNK_00102018) != 0);
iVar15 = iVar15 + (uint)(((*puVar7 ^ uVar2) & _UNK_0010201c) != 0);
} while (puVar8 != puVar11 + (ulong)(uVar3 >> 2) * 4);
iVar10 = iVar10 + iVar12 + iVar14 + iVar13 + iVar15;
iVar12 = (uVar3 & 0xfffffffc) + iVar9;
if ((uVar3 & 3) != 0) goto LAB_00101217;
}
iVar9 = iVar9 + 1;
puVar11 = puVar11 + 1;
if (param_2 == iVar9) {
return iVar10;
}
} while( true );
} |
6,120 | func0 |
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
#include <string.h>
| char* func0(char* string) {
static char toggled_string[100];
strcpy(toggled_string, string);
for (int i = 0; toggled_string[i] != '\0'; i++) {
if (isupper(toggled_string[i])) {
toggled_string[i] = tolower(toggled_string[i]);
} else if (islower(toggled_string[i])) {
toggled_string[i] = toupper(toggled_string[i]);
}
}
return toggled_string;
}
| int main() {
assert(strcmp(func0("Python"), "pYTHON") == 0);
assert(strcmp(func0("Pangram"), "pANGRAM") == 0);
assert(strcmp(func0("LIttLE"), "liTTle") == 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,%rsi
lea 0x2e39(%rip),%rdi
callq 10a0 <strcpy@plt>
movl $0x0,-0x4(%rbp)
jmpq 12d6 <func0+0xed>
callq 10f0 <__ctype_b_loc@plt>
mov (%rax),%rdx
mov -0x4(%rbp),%eax
cltq
lea 0x2e14(%rip),%rcx
movzbl (%rax,%rcx,1),%eax
movsbq %al,%rax
add %rax,%rax
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 1276 <func0+0x8d>
mov -0x4(%rbp),%eax
cltq
lea 0x2deb(%rip),%rdx
movzbl (%rax,%rdx,1),%eax
movsbl %al,%eax
mov %eax,%edi
callq 10e0 <tolower@plt>
mov %eax,%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x2dcf(%rip),%rdx
mov %cl,(%rax,%rdx,1)
jmp 12d2 <func0+0xe9>
callq 10f0 <__ctype_b_loc@plt>
mov (%rax),%rdx
mov -0x4(%rbp),%eax
cltq
lea 0x2db6(%rip),%rcx
movzbl (%rax,%rcx,1),%eax
movsbq %al,%rax
add %rax,%rax
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x200,%eax
test %eax,%eax
je 12d2 <func0+0xe9>
mov -0x4(%rbp),%eax
cltq
lea 0x2d8d(%rip),%rdx
movzbl (%rax,%rdx,1),%eax
movsbl %al,%eax
mov %eax,%edi
callq 10b0 <toupper@plt>
mov %eax,%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x2d71(%rip),%rdx
mov %cl,(%rax,%rdx,1)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x2d5e(%rip),%rdx
movzbl (%rax,%rdx,1),%eax
test %al,%al
jne 1218 <func0+0x2f>
lea 0x2d4b(%rip),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+src], rdi
mov rax, [rbp+src]
mov rsi, rax; src
lea rax, toggled_string_1
mov rdi, rax; dest
call _strcpy
mov [rbp+var_4], 0
jmp loc_12D9
loc_121B:
call ___ctype_b_loc
mov rdx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, toggled_string_1
movzx eax, byte ptr [rax+rcx]
movsx rax, al
add rax, rax
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz short loc_1279
mov eax, [rbp+var_4]
cdqe
lea rdx, toggled_string_1
movzx eax, byte ptr [rax+rdx]
movsx eax, al
mov edi, eax; c
call _tolower
mov ecx, eax
mov eax, [rbp+var_4]
cdqe
lea rdx, toggled_string_1
mov [rax+rdx], cl
jmp short loc_12D5
loc_1279:
call ___ctype_b_loc
mov rdx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, toggled_string_1
movzx eax, byte ptr [rax+rcx]
movsx rax, al
add rax, rax
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 200h
test eax, eax
jz short loc_12D5
mov eax, [rbp+var_4]
cdqe
lea rdx, toggled_string_1
movzx eax, byte ptr [rax+rdx]
movsx eax, al
mov edi, eax; c
call _toupper
mov ecx, eax
mov eax, [rbp+var_4]
cdqe
lea rdx, toggled_string_1
mov [rax+rdx], cl
loc_12D5:
add [rbp+var_4], 1
loc_12D9:
mov eax, [rbp+var_4]
cdqe
lea rdx, toggled_string_1
movzx eax, byte ptr [rax+rdx]
test al, al
jnz loc_121B
lea rax, toggled_string_1
leave
retn | char * func0(const char *a1)
{
int i; // [rsp+1Ch] [rbp-4h]
strcpy(toggled_string_1, a1);
for ( i = 0; toggled_string_1[i]; ++i )
{
if ( ((*__ctype_b_loc())[toggled_string_1[i]] & 0x100) != 0 )
{
toggled_string_1[i] = tolower(toggled_string_1[i]);
}
else if ( ((*__ctype_b_loc())[toggled_string_1[i]] & 0x200) != 0 )
{
toggled_string_1[i] = toupper(toggled_string_1[i]);
}
}
return toggled_string_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010a0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001012d9
LAB_0010121b:
CALL 0x001010f0
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[0x104040]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOVSX RAX,AL
ADD RAX,RAX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x00101279
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOVZX EAX,byte ptr [RAX + RDX*0x1]
MOVSX EAX,AL
MOV EDI,EAX
CALL 0x001010e0
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],CL
JMP 0x001012d5
LAB_00101279:
CALL 0x001010f0
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[0x104040]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOVSX RAX,AL
ADD RAX,RAX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x200
TEST EAX,EAX
JZ 0x001012d5
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOVZX EAX,byte ptr [RAX + RDX*0x1]
MOVSX EAX,AL
MOV EDI,EAX
CALL 0x001010b0
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],CL
LAB_001012d5:
ADD dword ptr [RBP + -0x4],0x1
LAB_001012d9:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOVZX EAX,byte ptr [RAX + RDX*0x1]
TEST AL,AL
JNZ 0x0010121b
LEA RAX,[0x104040]
LEAVE
RET | int1 * func0(char *param_1)
{
int iVar1;
ushort **ppuVar2;
int local_c;
strcpy(toggled_string_1,param_1);
for (local_c = 0; toggled_string_1[local_c] != '\0'; local_c = local_c + 1) {
ppuVar2 = __ctype_b_loc();
if (((*ppuVar2)[(char)toggled_string_1[local_c]] & 0x100) == 0) {
ppuVar2 = __ctype_b_loc();
if (((*ppuVar2)[(char)toggled_string_1[local_c]] & 0x200) != 0) {
iVar1 = toupper((int)(char)toggled_string_1[local_c]);
toggled_string_1[local_c] = (char)iVar1;
}
}
else {
iVar1 = tolower((int)(char)toggled_string_1[local_c]);
toggled_string_1[local_c] = (char)iVar1;
}
}
return toggled_string_1;
} |
6,121 | func0 |
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
#include <string.h>
| char* func0(char* string) {
static char toggled_string[100];
strcpy(toggled_string, string);
for (int i = 0; toggled_string[i] != '\0'; i++) {
if (isupper(toggled_string[i])) {
toggled_string[i] = tolower(toggled_string[i]);
} else if (islower(toggled_string[i])) {
toggled_string[i] = toupper(toggled_string[i]);
}
}
return toggled_string;
}
| int main() {
assert(strcmp(func0("Python"), "pYTHON") == 0);
assert(strcmp(func0("Pangram"), "pANGRAM") == 0);
assert(strcmp(func0("LIttLE"), "liTTle") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rsi
mov $0x64,%edx
lea 0x2e60(%rip),%rdi
callq 10b0 <__strcpy_chk@plt>
movzbl 0x2e54(%rip),%ebx
test %bl,%bl
je 1241 <func0+0x78>
callq 10d0 <__ctype_b_loc@plt>
mov %rax,%r12
lea 0x2e41(%rip),%rbp
jmp 1220 <func0+0x57>
test $0x2,%ah
je 1214 <func0+0x4b>
callq 1090 <__ctype_toupper_loc@plt>
mov (%rax),%rax
mov (%rax,%rbx,4),%eax
mov %al,0x0(%rbp)
add $0x1,%rbp
movzbl 0x0(%rbp),%ebx
test %bl,%bl
je 1241 <func0+0x78>
movsbq %bl,%rbx
mov (%r12),%rax
movzwl (%rax,%rbx,2),%eax
test $0x1,%ah
je 1201 <func0+0x38>
callq 10c0 <__ctype_tolower_loc@plt>
mov (%rax),%rax
mov (%rax,%rbx,4),%eax
mov %al,0x0(%rbp)
jmp 1214 <func0+0x4b>
lea 0x2df8(%rip),%rax
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r12
push rbp
push rbx
mov rsi, rdi
mov edx, 64h ; 'd'
lea rdi, toggled_string_1
call ___strcpy_chk
movzx ebx, cs:toggled_string_1
test bl, bl
jz short loc_1261
call ___ctype_b_loc
mov r12, rax
lea rbp, toggled_string_1
jmp short loc_1240
loc_1221:
test ah, 2
jz short loc_1234
call ___ctype_toupper_loc
mov rax, [rax]
mov eax, [rax+rbx*4]
mov [rbp+0], al
loc_1234:
add rbp, 1
movzx ebx, byte ptr [rbp+0]
test bl, bl
jz short loc_1261
loc_1240:
movsx rbx, bl
mov rax, [r12]
movzx eax, word ptr [rax+rbx*2]
test ah, 1
jz short loc_1221
call ___ctype_tolower_loc
mov rax, [rax]
mov eax, [rax+rbx*4]
mov [rbp+0], al
jmp short loc_1234
loc_1261:
lea rax, toggled_string_1
pop rbx
pop rbp
pop r12
retn | char * func0(long long a1)
{
char v1; // bl
_QWORD *v2; // r12
char *v3; // rbp
__int16 v4; // ax
__strcpy_chk(&toggled_string_1, a1, 100LL);
v1 = toggled_string_1;
if ( toggled_string_1 )
{
v2 = (_QWORD *)__ctype_b_loc();
v3 = &toggled_string_1;
do
{
v4 = *(_WORD *)(*v2 + 2LL * v1);
if ( (v4 & 0x100) != 0 )
{
*v3 = *(_DWORD *)(*(_QWORD *)__ctype_tolower_loc() + 4LL * v1);
}
else if ( (v4 & 0x200) != 0 )
{
*v3 = *(_DWORD *)(*(_QWORD *)__ctype_toupper_loc() + 4LL * v1);
}
v1 = *++v3;
}
while ( *v3 );
}
return &toggled_string_1;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RSI,RDI
MOV EDX,0x64
LEA RDI,[0x104040]
CALL 0x001010d0
MOVZX EBX,byte ptr [0x00104040]
TEST BL,BL
JZ 0x00101261
CALL 0x001010f0
MOV R12,RAX
LEA RBP,[0x104040]
JMP 0x00101240
LAB_00101221:
TEST AH,0x2
JZ 0x00101234
CALL 0x001010a0
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + RBX*0x4]
MOV byte ptr [RBP],AL
LAB_00101234:
ADD RBP,0x1
MOVZX EBX,byte ptr [RBP]
TEST BL,BL
JZ 0x00101261
LAB_00101240:
MOVSX RBX,BL
MOV RAX,qword ptr [R12]
MOVZX EAX,word ptr [RAX + RBX*0x2]
TEST AH,0x1
JZ 0x00101221
CALL 0x001010e0
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + RBX*0x4]
MOV byte ptr [RBP],AL
JMP 0x00101234
LAB_00101261:
LEA RAX,[0x104040]
POP RBX
POP RBP
POP R12
RET | int1 * func0(int8 param_1)
{
ushort **ppuVar1;
__int32_t **pp_Var2;
char cVar3;
char *pcVar4;
__strcpy_chk(&toggled_string_1,param_1,100);
cVar3 = toggled_string_1;
if (toggled_string_1 != '\0') {
ppuVar1 = __ctype_b_loc();
pcVar4 = &toggled_string_1;
do {
if (((*ppuVar1)[cVar3] & 0x100) == 0) {
if (((*ppuVar1)[cVar3] & 0x200) != 0) {
pp_Var2 = __ctype_toupper_loc();
*pcVar4 = (char)(*pp_Var2)[cVar3];
}
}
else {
pp_Var2 = __ctype_tolower_loc();
*pcVar4 = (char)(*pp_Var2)[cVar3];
}
pcVar4 = pcVar4 + 1;
cVar3 = *pcVar4;
} while (cVar3 != '\0');
}
return &toggled_string_1;
} |
6,122 | func0 |
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
#include <string.h>
| char* func0(char* string) {
static char toggled_string[100];
strcpy(toggled_string, string);
for (int i = 0; toggled_string[i] != '\0'; i++) {
if (isupper(toggled_string[i])) {
toggled_string[i] = tolower(toggled_string[i]);
} else if (islower(toggled_string[i])) {
toggled_string[i] = toupper(toggled_string[i]);
}
}
return toggled_string;
}
| int main() {
assert(strcmp(func0("Python"), "pYTHON") == 0);
assert(strcmp(func0("Pangram"), "pANGRAM") == 0);
assert(strcmp(func0("LIttLE"), "liTTle") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %rdi,%rsi
mov $0x64,%edx
lea 0x2d7b(%rip),%rdi
push %rbp
push %rbx
callq 10b0 <__strcpy_chk@plt>
movsbq 0x2d6c(%rip),%rbx
test %bl,%bl
je 1338 <func0+0x88>
callq 10d0 <__ctype_b_loc@plt>
lea 0x2d5c(%rip),%rbp
mov %rax,%r12
jmp 130b <func0+0x5b>
nopl 0x0(%rax)
callq 10c0 <__ctype_tolower_loc@plt>
mov (%rax),%rax
mov (%rax,%rbx,4),%eax
mov %al,0x0(%rbp)
movsbq 0x1(%rbp),%rbx
add $0x1,%rbp
test %bl,%bl
je 1338 <func0+0x88>
mov (%r12),%rax
movzwl (%rax,%rbx,2),%eax
test $0x1,%ah
jne 12f0 <func0+0x40>
test $0x2,%ah
je 12fe <func0+0x4e>
callq 1090 <__ctype_toupper_loc@plt>
add $0x1,%rbp
mov (%rax),%rax
mov (%rax,%rbx,4),%eax
mov %al,-0x1(%rbp)
movsbq 0x0(%rbp),%rbx
test %bl,%bl
jne 130b <func0+0x5b>
pop %rbx
lea 0x2d00(%rip),%rax
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r13
mov rsi, rdi
mov edx, 64h ; 'd'
push r12
lea r12, toggled_string_1
push rbp
mov rdi, r12
push rbx
sub rsp, 8
call ___strcpy_chk
movsx rbx, cs:toggled_string_1
test bl, bl
jz short loc_1348
call ___ctype_b_loc
mov rbp, r12
mov r13, rax
jmp short loc_131B
loc_1300:
call ___ctype_tolower_loc
mov rax, [rax]
mov eax, [rax+rbx*4]
mov [rbp+0], al
loc_130E:
movsx rbx, byte ptr [rbp+1]
add rbp, 1
test bl, bl
jz short loc_1348
loc_131B:
mov rax, [r13+0]
movzx eax, word ptr [rax+rbx*2]
test ah, 1
jnz short loc_1300
test ah, 2
jz short loc_130E
call ___ctype_toupper_loc
add rbp, 1
mov rax, [rax]
mov eax, [rax+rbx*4]
mov [rbp-1], al
movsx rbx, byte ptr [rbp+0]
test bl, bl
jnz short loc_131B
loc_1348:
add rsp, 8
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn | char * func0(long long a1)
{
long long v1; // rbx
char *v2; // rbp
_QWORD *v3; // r13
__int16 v4; // ax
__strcpy_chk(&toggled_string_1, a1, 100LL);
v1 = toggled_string_1;
if ( toggled_string_1 )
{
v2 = &toggled_string_1;
v3 = (_QWORD *)__ctype_b_loc();
do
{
while ( 1 )
{
v4 = *(_WORD *)(*v3 + 2 * v1);
if ( (v4 & 0x100) == 0 )
break;
*v2 = *(_DWORD *)(*(_QWORD *)__ctype_tolower_loc() + 4 * v1);
LABEL_4:
v1 = *++v2;
if ( !(_BYTE)v1 )
return &toggled_string_1;
}
if ( (v4 & 0x200) == 0 )
goto LABEL_4;
*v2++ = *(_DWORD *)(*(_QWORD *)__ctype_toupper_loc() + 4 * v1);
v1 = *v2;
}
while ( (_BYTE)v1 );
}
return &toggled_string_1;
} | func0:
ENDBR64
PUSH R13
MOV RSI,RDI
MOV EDX,0x64
PUSH R12
LEA R12,[0x104040]
PUSH RBP
MOV RDI,R12
PUSH RBX
SUB RSP,0x8
CALL 0x001010d0
MOVSX RBX,byte ptr [0x00104040]
TEST BL,BL
JZ 0x00101348
CALL 0x001010f0
MOV RBP,R12
MOV R13,RAX
JMP 0x0010131b
LAB_00101300:
CALL 0x001010e0
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + RBX*0x4]
MOV byte ptr [RBP],AL
LAB_0010130e:
MOVSX RBX,byte ptr [RBP + 0x1]
ADD RBP,0x1
TEST BL,BL
JZ 0x00101348
LAB_0010131b:
MOV RAX,qword ptr [R13]
MOVZX EAX,word ptr [RAX + RBX*0x2]
TEST AH,0x1
JNZ 0x00101300
TEST AH,0x2
JZ 0x0010130e
CALL 0x001010a0
ADD RBP,0x1
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + RBX*0x4]
MOV byte ptr [RBP + -0x1],AL
MOVSX RBX,byte ptr [RBP]
TEST BL,BL
JNZ 0x0010131b
LAB_00101348:
ADD RSP,0x8
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET | int1 * func0(int8 param_1)
{
char *pcVar1;
char cVar2;
ushort **ppuVar3;
__int32_t **pp_Var4;
long lVar5;
char *pcVar6;
__strcpy_chk(&toggled_string_1,param_1,100);
lVar5 = (long)toggled_string_1;
if (toggled_string_1 != '\0') {
ppuVar3 = __ctype_b_loc();
pcVar6 = &toggled_string_1;
do {
while (((*ppuVar3)[lVar5] & 0x100) == 0) {
if (((*ppuVar3)[lVar5] & 0x200) == 0) goto LAB_0010130e;
pp_Var4 = __ctype_toupper_loc();
*pcVar6 = (char)(*pp_Var4)[lVar5];
cVar2 = pcVar6[1];
lVar5 = (long)cVar2;
pcVar6 = pcVar6 + 1;
if (cVar2 == '\0') {
return &toggled_string_1;
}
}
pp_Var4 = __ctype_tolower_loc();
*pcVar6 = (char)(*pp_Var4)[lVar5];
LAB_0010130e:
pcVar1 = pcVar6 + 1;
lVar5 = (long)*pcVar1;
pcVar6 = pcVar6 + 1;
} while (*pcVar1 != '\0');
}
return &toggled_string_1;
} |
6,123 | func0 |
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
#include <string.h>
| char* func0(char* string) {
static char toggled_string[100];
strcpy(toggled_string, string);
for (int i = 0; toggled_string[i] != '\0'; i++) {
if (isupper(toggled_string[i])) {
toggled_string[i] = tolower(toggled_string[i]);
} else if (islower(toggled_string[i])) {
toggled_string[i] = toupper(toggled_string[i]);
}
}
return toggled_string;
}
| int main() {
assert(strcmp(func0("Python"), "pYTHON") == 0);
assert(strcmp(func0("Pangram"), "pANGRAM") == 0);
assert(strcmp(func0("LIttLE"), "liTTle") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %rdi,%rsi
mov $0x64,%edx
lea 0x2d7b(%rip),%rdi
push %rbp
push %rbx
callq 10b0 <__strcpy_chk@plt>
movsbq 0x2d6c(%rip),%rbx
test %bl,%bl
je 1338 <func0+0x88>
callq 10d0 <__ctype_b_loc@plt>
lea 0x2d5c(%rip),%rbp
mov %rax,%r12
jmp 130b <func0+0x5b>
nopl 0x0(%rax)
callq 10c0 <__ctype_tolower_loc@plt>
mov (%rax),%rax
mov (%rax,%rbx,4),%eax
mov %al,0x0(%rbp)
movsbq 0x1(%rbp),%rbx
add $0x1,%rbp
test %bl,%bl
je 1338 <func0+0x88>
mov (%r12),%rax
movzwl (%rax,%rbx,2),%eax
test $0x1,%ah
jne 12f0 <func0+0x40>
test $0x2,%ah
je 12fe <func0+0x4e>
callq 1090 <__ctype_toupper_loc@plt>
add $0x1,%rbp
mov (%rax),%rax
mov (%rax,%rbx,4),%eax
mov %al,-0x1(%rbp)
movsbq 0x0(%rbp),%rbx
test %bl,%bl
jne 130b <func0+0x5b>
pop %rbx
lea 0x2d00(%rip),%rax
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r13
mov rsi, rdi
mov edx, 64h ; 'd'
push r12
lea r12, toggled_string_1
push rbp
mov rdi, r12
push rbx
sub rsp, 8
call ___strcpy_chk
movsx rbx, cs:toggled_string_1
test bl, bl
jz short loc_1348
call ___ctype_b_loc
mov rbp, r12
mov r13, rax
jmp short loc_131B
loc_1300:
call ___ctype_tolower_loc
mov rax, [rax]
mov eax, [rax+rbx*4]
mov [rbp+0], al
loc_130E:
movsx rbx, byte ptr [rbp+1]
add rbp, 1
test bl, bl
jz short loc_1348
loc_131B:
mov rax, [r13+0]
movzx eax, word ptr [rax+rbx*2]
test ah, 1
jnz short loc_1300
test ah, 2
jz short loc_130E
call ___ctype_toupper_loc
add rbp, 1
mov rax, [rax]
mov eax, [rax+rbx*4]
mov [rbp-1], al
movsx rbx, byte ptr [rbp+0]
test bl, bl
jnz short loc_131B
loc_1348:
add rsp, 8
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn | char * func0(long long a1)
{
long long v1; // rbx
char *v2; // rbp
const unsigned __int16 **v3; // r13
unsigned __int16 v4; // ax
__strcpy_chk(&toggled_string_1, a1, 100LL);
v1 = toggled_string_1;
if ( toggled_string_1 )
{
v2 = &toggled_string_1;
v3 = __ctype_b_loc();
do
{
while ( 1 )
{
v4 = (*v3)[v1];
if ( (v4 & 0x100) == 0 )
break;
*v2 = (*__ctype_tolower_loc())[v1];
LABEL_4:
v1 = *++v2;
if ( !(_BYTE)v1 )
return &toggled_string_1;
}
if ( (v4 & 0x200) == 0 )
goto LABEL_4;
*v2++ = (*__ctype_toupper_loc())[v1];
v1 = *v2;
}
while ( (_BYTE)v1 );
}
return &toggled_string_1;
} | func0:
ENDBR64
PUSH R13
MOV RSI,RDI
MOV EDX,0x64
PUSH R12
LEA R12,[0x104040]
PUSH RBP
MOV RDI,R12
PUSH RBX
SUB RSP,0x8
CALL 0x001010d0
MOVSX RBX,byte ptr [0x00104040]
TEST BL,BL
JZ 0x00101348
CALL 0x001010f0
MOV RBP,R12
MOV R13,RAX
JMP 0x0010131b
LAB_00101300:
CALL 0x001010e0
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + RBX*0x4]
MOV byte ptr [RBP],AL
LAB_0010130e:
MOVSX RBX,byte ptr [RBP + 0x1]
ADD RBP,0x1
TEST BL,BL
JZ 0x00101348
LAB_0010131b:
MOV RAX,qword ptr [R13]
MOVZX EAX,word ptr [RAX + RBX*0x2]
TEST AH,0x1
JNZ 0x00101300
TEST AH,0x2
JZ 0x0010130e
CALL 0x001010a0
ADD RBP,0x1
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + RBX*0x4]
MOV byte ptr [RBP + -0x1],AL
MOVSX RBX,byte ptr [RBP]
TEST BL,BL
JNZ 0x0010131b
LAB_00101348:
ADD RSP,0x8
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET | int1 * func0(int8 param_1)
{
char *pcVar1;
char cVar2;
ushort **ppuVar3;
__int32_t **pp_Var4;
long lVar5;
char *pcVar6;
__strcpy_chk(&toggled_string_1,param_1,100);
lVar5 = (long)toggled_string_1;
if (toggled_string_1 != '\0') {
ppuVar3 = __ctype_b_loc();
pcVar6 = &toggled_string_1;
do {
while (((*ppuVar3)[lVar5] & 0x100) == 0) {
if (((*ppuVar3)[lVar5] & 0x200) == 0) goto LAB_0010130e;
pp_Var4 = __ctype_toupper_loc();
*pcVar6 = (char)(*pp_Var4)[lVar5];
cVar2 = pcVar6[1];
lVar5 = (long)cVar2;
pcVar6 = pcVar6 + 1;
if (cVar2 == '\0') {
return &toggled_string_1;
}
}
pp_Var4 = __ctype_tolower_loc();
*pcVar6 = (char)(*pp_Var4)[lVar5];
LAB_0010130e:
pcVar1 = pcVar6 + 1;
lVar5 = (long)*pcVar1;
pcVar6 = pcVar6 + 1;
} while (*pcVar1 != '\0');
}
return &toggled_string_1;
} |
6,124 | func0 | #include <stdlib.h>
#include <stdio.h>
#include <assert.h>
| int func0(int n1, int n2) {
int distance = abs(n1 - n2);
int sum = 0;
while (distance > 0) {
sum += distance % 10;
distance /= 10;
}
return sum;
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(23, 56) == 6);
assert(func0(123, 256) == 7);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
sub -0x18(%rbp),%eax
mov %eax,%edx
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
mov %edx,-0x8(%rbp)
sub %eax,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c0 <func0+0x77>
mov -0x8(%rbp),%ecx
movslq %ecx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar $0x2,%edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
sub %eax,%ecx
mov %ecx,%edx
add %edx,-0x4(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jg 1175 <func0+0x2c>
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_14]
sub eax, [rbp+var_18]
mov edx, eax
neg edx
cmovns eax, edx
mov [rbp+var_8], eax
mov [rbp+var_4], 0
jmp short loc_11BB
loc_1170:
mov ecx, [rbp+var_8]
movsxd rax, ecx
imul rax, 66666667h
shr rax, 20h
mov edx, eax
sar edx, 2
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
sub ecx, eax
mov edx, ecx
add [rbp+var_4], edx
mov eax, [rbp+var_8]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_8], eax
loc_11BB:
cmp [rbp+var_8], 0
jg short loc_1170
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1, int a2)
{
int v2; // eax
int v4; // [rsp+10h] [rbp-8h]
unsigned int v5; // [rsp+14h] [rbp-4h]
v2 = a1 - a2;
if ( a2 - a1 >= 0 )
v2 = a2 - a1;
v4 = v2;
v5 = 0;
while ( v4 > 0 )
{
v5 += v4 % 10;
v4 /= 10;
}
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,dword ptr [RBP + -0x18]
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011bb
LAB_00101170:
MOV ECX,dword ptr [RBP + -0x8]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x2
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
SUB ECX,EAX
MOV EDX,ECX
ADD dword ptr [RBP + -0x4],EDX
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
LAB_001011bb:
CMP dword ptr [RBP + -0x8],0x0
JG 0x00101170
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = param_1 - param_2;
if (local_10 < 1) {
local_10 = -local_10;
}
local_c = 0;
for (; 0 < local_10; local_10 = local_10 / 10) {
local_c = local_c + local_10 % 10;
}
return local_c;
} |
6,125 | func0 | #include <stdlib.h>
#include <stdio.h>
#include <assert.h>
| int func0(int n1, int n2) {
int distance = abs(n1 - n2);
int sum = 0;
while (distance > 0) {
sum += distance % 10;
distance /= 10;
}
return sum;
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(23, 56) == 6);
assert(func0(123, 256) == 7);
return 0;
}
| O1 | c | func0:
endbr64
sub %esi,%edi
mov %edi,%eax
sar $0x1f,%eax
xor %eax,%edi
sub %eax,%edi
test %edi,%edi
jle 118d <func0+0x44>
mov $0x0,%ecx
movslq %edi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,4),%edx
add %edx,%edx
mov %edi,%esi
sub %edx,%esi
add %esi,%ecx
mov %edi,%edx
mov %eax,%edi
cmp $0x9,%edx
jg 1161 <func0+0x18>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 118a <func0+0x41>
| func0:
endbr64
sub edi, esi
mov edx, edi
neg edx
cmovs edx, edi
test edx, edx
jle short loc_118B
mov esi, 0
loc_115F:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
lea ecx, [rax+rax*4]
add ecx, ecx
mov edi, edx
sub edi, ecx
add esi, edi
mov ecx, edx
mov edx, eax
cmp ecx, 9
jg short loc_115F
loc_1188:
mov eax, esi
retn
loc_118B:
mov esi, 0
jmp short loc_1188 | long long func0(int a1, int a2)
{
int v2; // edi
int v3; // edx
unsigned int v4; // esi
int v5; // ecx
v2 = a1 - a2;
v3 = -v2;
if ( v2 > 0 )
v3 = v2;
if ( v3 <= 0 )
{
return 0;
}
else
{
v4 = 0;
do
{
v4 += v3 % 10;
v5 = v3;
v3 /= 10;
}
while ( v5 > 9 );
}
return v4;
} | func0:
ENDBR64
SUB EDI,ESI
MOV EDX,EDI
NEG EDX
CMOVS EDX,EDI
TEST EDX,EDX
JLE 0x0010118b
MOV ESI,0x0
LAB_0010115f:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
MOV EDI,EDX
SUB EDI,ECX
ADD ESI,EDI
MOV ECX,EDX
MOV EDX,EAX
CMP ECX,0x9
JG 0x0010115f
LAB_00101188:
MOV EAX,ESI
RET
LAB_0010118b:
MOV ESI,0x0
JMP 0x00101188 | int func0(int param_1,int param_2)
{
bool bVar1;
int iVar2;
int iVar3;
param_1 = param_1 - param_2;
iVar2 = -param_1;
if (0 < param_1) {
iVar2 = param_1;
}
if (iVar2 < 1) {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
iVar3 = iVar3 + iVar2 % 10;
bVar1 = 9 < iVar2;
iVar2 = iVar2 / 10;
} while (bVar1);
}
return iVar3;
} |
6,126 | func0 | #include <stdlib.h>
#include <stdio.h>
#include <assert.h>
| int func0(int n1, int n2) {
int distance = abs(n1 - n2);
int sum = 0;
while (distance > 0) {
sum += distance % 10;
distance /= 10;
}
return sum;
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(23, 56) == 6);
assert(func0(123, 256) == 7);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%edx
xor %r8d,%r8d
sub %esi,%edx
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
sub %eax,%edx
cmp %esi,%edi
je 117a <func0+0x3a>
mov $0xcccccccd,%esi
nopl (%rax)
mov %edx,%eax
imul %rsi,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%edx
add %edx,%r8d
mov %eax,%edx
test %eax,%eax
jne 1160 <func0+0x20>
mov %r8d,%eax
retq
xchg %ax,%ax
| func0:
endbr64
mov eax, edi
sub eax, esi
mov edx, eax
neg edx
cmovs edx, eax
xor r8d, r8d
cmp edi, esi
jz short loc_117A
mov esi, 0CCCCCCCDh
nop dword ptr [rax+rax+00h]
loc_1160:
mov eax, edx
imul rax, rsi
shr rax, 23h
lea ecx, [rax+rax*4]
add ecx, ecx
sub edx, ecx
add r8d, edx
mov edx, eax
test eax, eax
jnz short loc_1160
loc_117A:
mov eax, r8d
retn | long long func0(int a1, int a2)
{
unsigned int v2; // edx
unsigned int v3; // r8d
v2 = a2 - a1;
if ( a2 - a1 < 0 )
v2 = a1 - a2;
v3 = 0;
if ( a1 != a2 )
{
do
{
v3 += v2 % 0xA;
v2 /= 0xAu;
}
while ( v2 );
}
return v3;
} | func0:
ENDBR64
MOV EAX,EDI
SUB EAX,ESI
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
XOR R8D,R8D
CMP EDI,ESI
JZ 0x0010117a
MOV ESI,0xcccccccd
NOP dword ptr [RAX + RAX*0x1]
LAB_00101160:
MOV EAX,EDX
IMUL RAX,RSI
SHR RAX,0x23
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB EDX,ECX
ADD R8D,EDX
MOV EDX,EAX
TEST EAX,EAX
JNZ 0x00101160
LAB_0010117a:
MOV EAX,R8D
RET | int func0(int param_1,int param_2)
{
uint uVar1;
uint uVar2;
int iVar3;
uVar1 = param_1 - param_2;
uVar2 = -uVar1;
if (0 < (int)uVar1) {
uVar2 = uVar1;
}
iVar3 = 0;
if (param_1 != param_2) {
do {
iVar3 = iVar3 + uVar2 % 10;
uVar2 = uVar2 / 10;
} while (uVar2 != 0);
}
return iVar3;
} |
6,127 | func0 | #include <stdlib.h>
#include <stdio.h>
#include <assert.h>
| int func0(int n1, int n2) {
int distance = abs(n1 - n2);
int sum = 0;
while (distance > 0) {
sum += distance % 10;
distance /= 10;
}
return sum;
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(23, 56) == 6);
assert(func0(123, 256) == 7);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%edx
xor %r8d,%r8d
sub %esi,%edx
mov %edx,%eax
sar $0x1f,%eax
xor %eax,%edx
sub %eax,%edx
cmp %esi,%edi
je 117a <func0+0x3a>
mov $0xcccccccd,%esi
nopl (%rax)
mov %edx,%eax
imul %rsi,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%edx
add %edx,%r8d
mov %eax,%edx
test %eax,%eax
jne 1160 <func0+0x20>
mov %r8d,%eax
retq
xchg %ax,%ax
| func0:
endbr64
mov eax, edi
sub eax, esi
mov edx, eax
neg edx
cmovs edx, eax
cmp edi, esi
mov esi, 0
jz short loc_1179
mov edi, 0CCCCCCCDh
nop dword ptr [rax]
loc_1160:
mov eax, edx
imul rax, rdi
shr rax, 23h
lea ecx, [rax+rax*4]
add ecx, ecx
sub edx, ecx
add esi, edx
mov edx, eax
test eax, eax
jnz short loc_1160
loc_1179:
mov eax, esi
retn | long long func0(int a1, int a2)
{
unsigned int v2; // edx
bool v3; // zf
unsigned int v4; // esi
v2 = a2 - a1;
if ( a2 - a1 < 0 )
v2 = a1 - a2;
v3 = a1 == a2;
v4 = 0;
if ( !v3 )
{
do
{
v4 += v2 % 0xA;
v2 /= 0xAu;
}
while ( v2 );
}
return v4;
} | func0:
ENDBR64
MOV EAX,EDI
SUB EAX,ESI
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
CMP EDI,ESI
MOV ESI,0x0
JZ 0x00101179
MOV EDI,0xcccccccd
NOP dword ptr [RAX]
LAB_00101160:
MOV EAX,EDX
IMUL RAX,RDI
SHR RAX,0x23
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB EDX,ECX
ADD ESI,EDX
MOV EDX,EAX
TEST EAX,EAX
JNZ 0x00101160
LAB_00101179:
MOV EAX,ESI
RET | int func0(int param_1,int param_2)
{
uint uVar1;
uint uVar2;
int iVar3;
uVar1 = param_1 - param_2;
uVar2 = -uVar1;
if (0 < (int)uVar1) {
uVar2 = uVar1;
}
iVar3 = 0;
if (param_1 != param_2) {
do {
iVar3 = iVar3 + uVar2 % 10;
uVar2 = uVar2 / 10;
} while (uVar2 != 0);
}
return iVar3;
} |
6,128 | func0 |
#include <assert.h>
| int func0(int a[], int size) {
int max_so_far = 0;
int max_ending_here = 0;
for (int i = 0; i < size; i++) {
max_ending_here = max_ending_here + a[i];
if (max_ending_here < 0) {
max_ending_here = 0;
} else if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
}
}
return max_so_far;
}
| int main() {
int arr1[] = {-2, -3, 4, -1, -2, 1, 5, -3};
int arr2[] = {-3, -4, 5, -2, -3, 2, 6, -4};
int arr3[] = {-4, -5, 6, -3, -4, 3, 7, -5};
assert(func0(arr1, 8) == 7);
assert(func0(arr2, 8) == 8);
assert(func0(arr3, 8) == 10);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c9 <func0+0x60>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jns 11b7 <func0+0x4e>
movl $0x0,-0x8(%rbp)
jmp 11c5 <func0+0x5c>
mov -0xc(%rbp),%eax
cmp -0x8(%rbp),%eax
jge 11c5 <func0+0x5c>
mov -0x8(%rbp),%eax
mov %eax,-0xc(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118f <func0+0x26>
mov -0xc(%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_C], 0
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11C9
loc_118F:
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
cmp [rbp+var_8], 0
jns short loc_11B7
mov [rbp+var_8], 0
jmp short loc_11C5
loc_11B7:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_8]
jge short loc_11C5
mov eax, [rbp+var_8]
mov [rbp+var_C], eax
loc_11C5:
add [rbp+var_4], 1
loc_11C9:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_118F
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-Ch]
int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
v4 = 0;
for ( i = 0; i < a2; ++i )
{
v4 += *(_DWORD *)(4LL * i + a1);
if ( v4 >= 0 )
{
if ( v3 < v4 )
v3 = v4;
}
else
{
v4 = 0;
}
}
return (unsigned int)v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c9
LAB_0010118f:
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
CMP dword ptr [RBP + -0x8],0x0
JNS 0x001011b7
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011c5
LAB_001011b7:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x8]
JGE 0x001011c5
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0xc],EAX
LAB_001011c5:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c9:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118f
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
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);
if (local_10 < 0) {
local_10 = 0;
}
else if (local_14 < local_10) {
local_14 = local_10;
}
}
return local_14;
} |
6,129 | func0 |
#include <assert.h>
| int func0(int a[], int size) {
int max_so_far = 0;
int max_ending_here = 0;
for (int i = 0; i < size; i++) {
max_ending_here = max_ending_here + a[i];
if (max_ending_here < 0) {
max_ending_here = 0;
} else if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
}
}
return max_so_far;
}
| int main() {
int arr1[] = {-2, -3, 4, -1, -2, 1, 5, -3};
int arr2[] = {-3, -4, 5, -2, -3, 2, 6, -4};
int arr3[] = {-4, -5, 6, -3, -4, 3, 7, -5};
assert(func0(arr1, 8) == 7);
assert(func0(arr2, 8) == 8);
assert(func0(arr3, 8) == 10);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11a9 <func0+0x40>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdi
mov $0x0,%ecx
mov $0x0,%esi
mov $0x0,%r8d
jmp 119a <func0+0x31>
mov %r8d,%ecx
add $0x4,%rdx
cmp %rdi,%rdx
je 11ae <func0+0x45>
mov %ecx,%eax
add (%rdx),%eax
mov %eax,%ecx
js 118e <func0+0x25>
cmp %eax,%esi
cmovl %eax,%esi
jmp 1191 <func0+0x28>
mov $0x0,%esi
mov %esi,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_11A9
mov rdx, rdi
lea eax, [rsi-1]
lea rdi, [rdi+rax*4+4]
mov ecx, 0
mov esi, 0
mov r8d, 0
jmp short loc_119C
loc_118E:
cmp esi, eax
cmovl esi, eax
loc_1193:
add rdx, 4
cmp rdx, rdi
jz short loc_11AE
loc_119C:
mov eax, ecx
add eax, [rdx]
mov ecx, eax
jns short loc_118E
mov ecx, r8d
jmp short loc_1193
loc_11A9:
mov esi, 0
loc_11AE:
mov eax, esi
retn | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rdx
long long v3; // rdi
int v4; // ecx
unsigned int v5; // esi
bool v6; // sf
int v7; // eax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
v5 = 0;
do
{
v6 = *v2 + v4 < 0;
v7 = *v2 + v4;
v4 = v7;
if ( v6 )
{
v4 = 0;
}
else if ( (int)v5 < v7 )
{
v5 = v7;
}
++v2;
}
while ( v2 != (_DWORD *)v3 );
}
return v5;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a9
MOV RDX,RDI
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x4 + 0x4]
MOV ECX,0x0
MOV ESI,0x0
MOV R8D,0x0
JMP 0x0010119c
LAB_0010118e:
CMP ESI,EAX
CMOVL ESI,EAX
LAB_00101193:
ADD RDX,0x4
CMP RDX,RDI
JZ 0x001011ae
LAB_0010119c:
MOV EAX,ECX
ADD EAX,dword ptr [RDX]
MOV ECX,EAX
JNS 0x0010118e
MOV ECX,R8D
JMP 0x00101193
LAB_001011a9:
MOV ESI,0x0
LAB_001011ae:
MOV EAX,ESI
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
iVar3 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
iVar3 = 0;
do {
iVar2 = iVar2 + *param_1;
if (iVar2 < 0) {
iVar2 = 0;
}
else if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar3;
} |
6,130 | func0 |
#include <assert.h>
| int func0(int a[], int size) {
int max_so_far = 0;
int max_ending_here = 0;
for (int i = 0; i < size; i++) {
max_ending_here = max_ending_here + a[i];
if (max_ending_here < 0) {
max_ending_here = 0;
} else if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
}
}
return max_so_far;
}
| int main() {
int arr1[] = {-2, -3, 4, -1, -2, 1, 5, -3};
int arr2[] = {-3, -4, 5, -2, -3, 2, 6, -4};
int arr3[] = {-4, -5, 6, -3, -4, 3, 7, -5};
assert(func0(arr1, 8) == 7);
assert(func0(arr2, 8) == 8);
assert(func0(arr3, 8) == 10);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 13a8 <func0+0x48>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
jmp 1390 <func0+0x30>
nopw 0x0(%rax,%rax,1)
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x4,%rdi
cmp %rdx,%rdi
je 139f <func0+0x3f>
add (%rdi),%eax
jns 1380 <func0+0x20>
add $0x4,%rdi
xor %eax,%eax
cmp %rdx,%rdi
jne 1390 <func0+0x30>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_13A8
lea eax, [rsi-1]
xor r8d, r8d
lea rdx, [rdi+rax*4+4]
xor eax, eax
jmp short loc_1390
loc_1380:
cmp r8d, eax
cmovl r8d, eax
add rdi, 4
cmp rdi, rdx
jz short loc_139F
loc_1390:
add eax, [rdi]
jns short loc_1380
add rdi, 4
xor eax, eax
cmp rdi, rdx
jnz short loc_1390
loc_139F:
mov eax, r8d
retn
loc_13A8:
xor r8d, r8d
mov eax, r8d
retn | long long func0(_DWORD *a1, int a2)
{
unsigned int v2; // r8d
long long v3; // rdx
int v4; // eax
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
{
while ( 1 )
{
v4 += *a1;
if ( v4 >= 0 )
break;
++a1;
v4 = 0;
if ( a1 == (_DWORD *)v3 )
return v2;
}
if ( (int)v2 < v4 )
v2 = v4;
++a1;
}
while ( a1 != (_DWORD *)v3 );
return v2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013a8
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
LEA RDX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
JMP 0x00101390
LAB_00101380:
CMP R8D,EAX
CMOVL R8D,EAX
ADD RDI,0x4
CMP RDI,RDX
JZ 0x0010139f
LAB_00101390:
ADD EAX,dword ptr [RDI]
JNS 0x00101380
ADD RDI,0x4
XOR EAX,EAX
CMP RDI,RDX
JNZ 0x00101390
LAB_0010139f:
MOV EAX,R8D
RET
LAB_001013a8:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
return 0;
}
iVar3 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
while (iVar2 = iVar2 + *param_1, iVar2 < 0) {
param_1 = param_1 + 1;
iVar2 = 0;
if (param_1 == piVar1) {
return iVar3;
}
}
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar3;
} |
6,131 | func0 |
#include <assert.h>
| int func0(int a[], int size) {
int max_so_far = 0;
int max_ending_here = 0;
for (int i = 0; i < size; i++) {
max_ending_here = max_ending_here + a[i];
if (max_ending_here < 0) {
max_ending_here = 0;
} else if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
}
}
return max_so_far;
}
| int main() {
int arr1[] = {-2, -3, 4, -1, -2, 1, 5, -3};
int arr2[] = {-3, -4, 5, -2, -3, 2, 6, -4};
int arr3[] = {-4, -5, 6, -3, -4, 3, 7, -5};
assert(func0(arr1, 8) == 7);
assert(func0(arr2, 8) == 8);
assert(func0(arr3, 8) == 10);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1458 <func0+0x48>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
jmp 1440 <func0+0x30>
nopw 0x0(%rax,%rax,1)
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x4,%rdi
cmp %rdi,%rdx
je 144f <func0+0x3f>
add (%rdi),%eax
jns 1430 <func0+0x20>
add $0x4,%rdi
xor %eax,%eax
cmp %rdi,%rdx
jne 1440 <func0+0x30>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_1180
movsxd rsi, esi
xor eax, eax
xor edx, edx
lea rcx, [rdi+rsi*4]
jmp short loc_1166
loc_1158:
cmp edx, eax
cmovl edx, eax
add rdi, 4
cmp rcx, rdi
jz short loc_1175
loc_1166:
add eax, [rdi]
jns short loc_1158
add rdi, 4
xor eax, eax
cmp rcx, rdi
jnz short loc_1166
loc_1175:
mov eax, edx
retn
loc_1180:
xor edx, edx
mov eax, edx
retn | long long func0(_DWORD *a1, int a2)
{
int v2; // eax
unsigned int v3; // edx
_DWORD *v4; // rcx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = 0;
v4 = &a1[a2];
do
{
while ( 1 )
{
v2 += *a1;
if ( v2 >= 0 )
break;
++a1;
v2 = 0;
if ( v4 == a1 )
return v3;
}
if ( (int)v3 < v2 )
v3 = v2;
++a1;
}
while ( v4 != a1 );
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101180
MOVSXD RSI,ESI
XOR EAX,EAX
XOR EDX,EDX
LEA RCX,[RDI + RSI*0x4]
JMP 0x00101166
LAB_00101158:
CMP EDX,EAX
CMOVL EDX,EAX
ADD RDI,0x4
CMP RCX,RDI
JZ 0x00101175
LAB_00101166:
ADD EAX,dword ptr [RDI]
JNS 0x00101158
ADD RDI,0x4
XOR EAX,EAX
CMP RCX,RDI
JNZ 0x00101166
LAB_00101175:
MOV EAX,EDX
RET
LAB_00101180:
XOR EDX,EDX
MOV EAX,EDX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
return 0;
}
iVar2 = 0;
iVar3 = 0;
piVar1 = param_1 + param_2;
do {
while (iVar2 = iVar2 + *param_1, iVar2 < 0) {
param_1 = param_1 + 1;
iVar2 = 0;
if (piVar1 == param_1) {
return iVar3;
}
}
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
param_1 = param_1 + 1;
} while (piVar1 != param_1);
return iVar3;
} |
6,132 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int *elements;
int size;
} UniqueTuple;
| UniqueTuple func0(int *test_tup1, int size1, int *test_tup2, int size2) {
UniqueTuple result;
result.elements = (int *)malloc((size1 + size2) * sizeof(int));
int k = 0;
for (int i = 0; i < size1; i++) {
int j;
for (j = 0; j < k; j++) {
if (result.elements[j] == test_tup1[i])
break;
}
if (j == k) {
result.elements[k++] = test_tup1[i];
}
}
for (int i = 0; i < size2; i++) {
int j;
for (j = 0; j < k; j++) {
if (result.elements[j] == test_tup2[i])
break;
}
if (j == k) {
result.elements[k++] = test_tup2[i];
}
}
result.size = k;
return result;
}
| int main() {
int tuple1[] = {3, 4, 5, 6};
int tuple2[] = {5, 7, 4, 10};
UniqueTuple res1 = func0(tuple1, 4, tuple2, 4);
int expected1[] = {3, 4, 5, 6, 7, 10};
assert(res1.size == sizeof(expected1) / sizeof(int));
for (int i = 0; i < res1.size; i++) {
assert(res1.elements[i] == expected1[i]);
}
int tuple3[] = {1, 2, 3, 4};
int tuple4[] = {3, 4, 5, 6};
UniqueTuple res2 = func0(tuple3, 4, tuple4, 4);
int expected2[] = {1, 2, 3, 4, 5, 6};
assert(res2.size == sizeof(expected2) / sizeof(int));
for (int i = 0; i < res2.size; i++) {
assert(res2.elements[i] == expected2[i]);
}
int tuple5[] = {11, 12, 13, 14};
int tuple6[] = {13, 15, 16, 17};
UniqueTuple res3 = func0(tuple5, 4, tuple6, 4);
int expected3[] = {11, 12, 13, 14, 15, 16, 17};
assert(res3.size == sizeof(expected3) / sizeof(int));
for (int i = 0; i < res3.size; i++) {
assert(res3.elements[i] == expected3[i]);
}
free(res1.elements);
free(res2.elements);
free(res3.elements);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %rdx,-0x48(%rbp)
mov %ecx,-0x40(%rbp)
mov -0x3c(%rbp),%edx
mov -0x40(%rbp),%eax
add %edx,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x10(%rbp)
movl $0x0,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
jmpq 1291 <func0+0xc8>
movl $0x0,-0x1c(%rbp)
jmp 124a <func0+0x81>
mov -0x10(%rbp),%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%edx
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 1254 <func0+0x8b>
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 1219 <func0+0x50>
jmp 1255 <func0+0x8c>
mov -0x1c(%rbp),%eax
cmp -0x24(%rbp),%eax
jne 128d <func0+0xc4>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x10(%rbp),%rsi
mov -0x24(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x24(%rbp)
cltq
shl $0x2,%rax
lea (%rsi,%rax,1),%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 1210 <func0+0x47>
movl $0x0,-0x18(%rbp)
jmpq 132a <func0+0x161>
movl $0x0,-0x14(%rbp)
jmp 12e3 <func0+0x11a>
mov -0x10(%rbp),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%edx
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x48(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 12ed <func0+0x124>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 12b2 <func0+0xe9>
jmp 12ee <func0+0x125>
mov -0x14(%rbp),%eax
cmp -0x24(%rbp),%eax
jne 1326 <func0+0x15d>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x48(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x10(%rbp),%rsi
mov -0x24(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x24(%rbp)
cltq
shl $0x2,%rax
lea (%rsi,%rax,1),%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x40(%rbp),%eax
jl 12a9 <func0+0xe0>
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 [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_48], rdx
mov [rbp+var_40], ecx
mov edx, [rbp+var_3C]
mov eax, [rbp+var_40]
add eax, edx
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_10], rax
mov [rbp+var_24], 0
mov [rbp+var_20], 0
jmp loc_1291
loc_1210:
mov [rbp+var_1C], 0
jmp short loc_124A
loc_1219:
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_20]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_1254
add [rbp+var_1C], 1
loc_124A:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_24]
jl short loc_1219
jmp short loc_1255
loc_1254:
nop
loc_1255:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_24]
jnz short loc_128D
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
lea rcx, [rdx+rax]
mov rsi, [rbp+var_10]
mov eax, [rbp+var_24]
lea edx, [rax+1]
mov [rbp+var_24], edx
cdqe
shl rax, 2
lea rdx, [rsi+rax]
mov eax, [rcx]
mov [rdx], eax
loc_128D:
add [rbp+var_20], 1
loc_1291:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_3C]
jl loc_1210
mov [rbp+var_18], 0
jmp loc_132A
loc_12A9:
mov [rbp+var_14], 0
jmp short loc_12E3
loc_12B2:
mov rax, [rbp+var_10]
mov edx, [rbp+var_14]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_18]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_48]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_12ED
add [rbp+var_14], 1
loc_12E3:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_24]
jl short loc_12B2
jmp short loc_12EE
loc_12ED:
nop
loc_12EE:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_24]
jnz short loc_1326
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]
lea rcx, [rdx+rax]
mov rsi, [rbp+var_10]
mov eax, [rbp+var_24]
lea edx, [rax+1]
mov [rbp+var_24], edx
cdqe
shl rax, 2
lea rdx, [rsi+rax]
mov eax, [rcx]
mov [rdx], eax
loc_1326:
add [rbp+var_18], 1
loc_132A:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_40]
jl loc_12A9
mov eax, [rbp+var_24]
mov dword ptr [rbp+var_8], eax
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2, long long a3, int a4)
{
int v4; // eax
int v5; // eax
int v9; // [rsp+2Ch] [rbp-24h]
int i; // [rsp+30h] [rbp-20h]
int j; // [rsp+34h] [rbp-1Ch]
int k; // [rsp+38h] [rbp-18h]
int m; // [rsp+3Ch] [rbp-14h]
_DWORD *v14; // [rsp+40h] [rbp-10h]
v14 = malloc(4LL * (a2 + a4));
v9 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j < v9 && v14[j] != *(_DWORD *)(4LL * i + a1); ++j )
;
if ( j == v9 )
{
v4 = v9++;
v14[v4] = *(_DWORD *)(4LL * i + a1);
}
}
for ( k = 0; k < a4; ++k )
{
for ( m = 0; m < v9 && v14[m] != *(_DWORD *)(4LL * k + a3); ++m )
;
if ( m == v9 )
{
v5 = v9++;
v14[v5] = *(_DWORD *)(4LL * k + a3);
}
}
return v14;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV dword ptr [RBP + -0x40],ECX
MOV EDX,dword ptr [RBP + -0x3c]
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,EDX
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101291
LAB_00101210:
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x0010124a
LAB_00101219:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x00101254
ADD dword ptr [RBP + -0x1c],0x1
LAB_0010124a:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00101219
JMP 0x00101255
LAB_00101254:
NOP
LAB_00101255:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x24]
JNZ 0x0010128d
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x24]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x24],EDX
CDQE
SHL RAX,0x2
LEA RDX,[RSI + RAX*0x1]
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_0010128d:
ADD dword ptr [RBP + -0x20],0x1
LAB_00101291:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101210
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0010132a
LAB_001012a9:
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012e3
LAB_001012b2:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x001012ed
ADD dword ptr [RBP + -0x14],0x1
LAB_001012e3:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x001012b2
JMP 0x001012ee
LAB_001012ed:
NOP
LAB_001012ee:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x24]
JNZ 0x00101326
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x48]
LEA RCX,[RDX + RAX*0x1]
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x24]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x24],EDX
CDQE
SHL RAX,0x2
LEA RDX,[RSI + RAX*0x1]
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_00101326:
ADD dword ptr [RBP + -0x18],0x1
LAB_0010132a:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x40]
JL 0x001012a9
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];
void *pvVar2;
int local_2c;
int local_28;
int local_24;
int local_20;
int local_1c;
int4 uStack_c;
pvVar2 = malloc((long)(param_4 + param_2) << 2);
local_2c = 0;
for (local_28 = 0; local_28 < param_2; local_28 = local_28 + 1) {
local_24 = 0;
while ((local_24 < local_2c &&
(*(int *)((long)pvVar2 + (long)local_24 * 4) != *(int *)(param_1 + (long)local_28 * 4))))
{
local_24 = local_24 + 1;
}
if (local_24 == local_2c) {
*(int4 *)((long)pvVar2 + (long)local_2c * 4) =
*(int4 *)((long)local_28 * 4 + param_1);
local_2c = local_2c + 1;
}
}
for (local_20 = 0; local_20 < param_4; local_20 = local_20 + 1) {
local_1c = 0;
while ((local_1c < local_2c &&
(*(int *)((long)pvVar2 + (long)local_1c * 4) != *(int *)(param_3 + (long)local_20 * 4))))
{
local_1c = local_1c + 1;
}
if (local_1c == local_2c) {
*(int4 *)((long)pvVar2 + (long)local_2c * 4) =
*(int4 *)((long)local_20 * 4 + param_3);
local_2c = local_2c + 1;
}
}
auVar1._8_4_ = local_2c;
auVar1._0_8_ = pvVar2;
auVar1._12_4_ = uStack_c;
return auVar1;
} |
6,133 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int *elements;
int size;
} UniqueTuple;
| UniqueTuple func0(int *test_tup1, int size1, int *test_tup2, int size2) {
UniqueTuple result;
result.elements = (int *)malloc((size1 + size2) * sizeof(int));
int k = 0;
for (int i = 0; i < size1; i++) {
int j;
for (j = 0; j < k; j++) {
if (result.elements[j] == test_tup1[i])
break;
}
if (j == k) {
result.elements[k++] = test_tup1[i];
}
}
for (int i = 0; i < size2; i++) {
int j;
for (j = 0; j < k; j++) {
if (result.elements[j] == test_tup2[i])
break;
}
if (j == k) {
result.elements[k++] = test_tup2[i];
}
}
result.size = k;
return result;
}
| int main() {
int tuple1[] = {3, 4, 5, 6};
int tuple2[] = {5, 7, 4, 10};
UniqueTuple res1 = func0(tuple1, 4, tuple2, 4);
int expected1[] = {3, 4, 5, 6, 7, 10};
assert(res1.size == sizeof(expected1) / sizeof(int));
for (int i = 0; i < res1.size; i++) {
assert(res1.elements[i] == expected1[i]);
}
int tuple3[] = {1, 2, 3, 4};
int tuple4[] = {3, 4, 5, 6};
UniqueTuple res2 = func0(tuple3, 4, tuple4, 4);
int expected2[] = {1, 2, 3, 4, 5, 6};
assert(res2.size == sizeof(expected2) / sizeof(int));
for (int i = 0; i < res2.size; i++) {
assert(res2.elements[i] == expected2[i]);
}
int tuple5[] = {11, 12, 13, 14};
int tuple6[] = {13, 15, 16, 17};
UniqueTuple res3 = func0(tuple5, 4, tuple6, 4);
int expected3[] = {11, 12, 13, 14, 15, 16, 17};
assert(res3.size == sizeof(expected3) / sizeof(int));
for (int i = 0; i < res3.size; i++) {
assert(res3.elements[i] == expected3[i]);
}
free(res1.elements);
free(res2.elements);
free(res3.elements);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%r12d
mov %rdx,%rbp
mov %ecx,%ebx
lea (%rsi,%rcx,1),%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %r12d,%r12d
jle 1266 <func0+0x9d>
mov %r13,%r10
lea -0x1(%r12),%edx
lea 0x0(%r13,%rdx,4),%r11
mov $0x0,%r9d
mov $0x0,%ecx
mov $0x0,%r13d
mov $0x0,%r12d
jmp 1236 <func0+0x6d>
mov %rsi,%rdx
mov %edx,%ecx
cmp %edi,(%rax,%rdx,4)
je 1232 <func0+0x69>
lea 0x1(%rdx),%ecx
lea 0x1(%rdx),%rsi
cmp %r8,%rdx
jne 121c <func0+0x53>
add $0x4,%r10
cmp %ecx,%r9d
je 1252 <func0+0x89>
cmp %r11,%r10
je 126c <func0+0xa3>
test %r9d,%r9d
jle 1261 <func0+0x98>
mov 0x4(%r10),%edi
lea -0x1(%r9),%r8d
mov %r12,%rdx
jmp 121f <func0+0x56>
movslq %r9d,%rdx
mov (%r10),%ecx
mov %ecx,(%rax,%rdx,4)
lea 0x1(%r9),%r9d
jmp 123b <func0+0x72>
mov %r13d,%ecx
jmp 1232 <func0+0x69>
mov $0x0,%r9d
test %ebx,%ebx
jle 12cd <func0+0x104>
mov %rbp,%r10
lea -0x1(%rbx),%edx
lea 0x4(%rbp,%rdx,4),%r11
mov $0x0,%ebp
mov $0x0,%ebx
jmp 12ab <func0+0xe2>
mov %rsi,%rdx
mov %edx,%ecx
cmp %edi,(%rax,%rdx,4)
je 129d <func0+0xd4>
lea 0x1(%rdx),%ecx
lea 0x1(%rdx),%rsi
cmp %r8,%rdx
jne 1287 <func0+0xbe>
cmp %ecx,%r9d
je 12be <func0+0xf5>
add $0x4,%r10
cmp %r11,%r10
je 12cd <func0+0x104>
mov %ebp,%ecx
test %r9d,%r9d
jle 129d <func0+0xd4>
mov (%r10),%edi
lea -0x1(%r9),%r8d
mov %rbx,%rdx
jmp 128a <func0+0xc1>
movslq %r9d,%rdx
mov (%r10),%ecx
mov %ecx,(%rax,%rdx,4)
lea 0x1(%r9),%r9d
jmp 12a2 <func0+0xd9>
mov %r9d,%edx
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
mov r12d, esi
mov rbp, rdx
mov ebx, ecx
lea edi, [rsi+rcx]
movsxd rdi, edi
shl rdi, 2
call _malloc
mov r8, rax
test r12d, r12d
jle short loc_1254
mov rdi, r13
lea eax, [r12-1]
lea r9, [r13+rax*4+0]
mov ecx, 0
mov eax, 0
jmp short loc_1229
loc_1212:
movsxd rax, ecx
mov edx, [rdi]
mov [r8+rax*4], edx
lea ecx, [rcx+1]
jmp short loc_122D
loc_1220:
mov eax, 0
loc_1225:
add rdi, 4
loc_1229:
cmp ecx, eax
jz short loc_1212
loc_122D:
cmp rdi, r9
jz short loc_1259
test ecx, ecx
jle short loc_1220
mov esi, [rdi+4]
mov rdx, r8
mov eax, 0
loc_1241:
cmp [rdx], esi
jz short loc_1225
add eax, 1
add rdx, 4
cmp ecx, eax
jnz short loc_1241
mov eax, ecx
jmp short loc_1225
loc_1254:
mov ecx, 0
loc_1259:
test ebx, ebx
jle short loc_12A7
mov rdi, rbp
lea eax, [rbx-1]
lea r9, [rbp+rax*4+4]
jmp short loc_1277
loc_126A:
cmp ecx, eax
jz short loc_1299
loc_126E:
add rdi, 4
cmp rdi, r9
jz short loc_12A7
loc_1277:
mov eax, 0
test ecx, ecx
jle short loc_126A
mov esi, [rdi]
mov rdx, r8
mov eax, 0
loc_128A:
cmp [rdx], esi
jz short loc_126A
add eax, 1
add rdx, 4
cmp eax, ecx
jnz short loc_128A
loc_1299:
movsxd rax, ecx
mov edx, [rdi]
mov [r8+rax*4], edx
lea ecx, [rcx+1]
jmp short loc_126E
loc_12A7:
mov edx, ecx
mov rax, r8
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v4; // r13
long long v7; // r8
int v8; // ecx
int v9; // eax
_DWORD *v10; // rdx
_DWORD *v11; // rdi
int v12; // eax
_DWORD *v13; // rdx
v4 = a1;
v7 = malloc(4LL * (a2 + a4));
if ( a2 <= 0 )
{
v8 = 0;
}
else
{
v8 = 0;
v9 = 0;
while ( 1 )
{
if ( v8 == v9 )
*(_DWORD *)(v7 + 4LL * v8++) = *a1;
if ( a1 == &v4[a2 - 1] )
break;
if ( v8 <= 0 )
{
v9 = 0;
}
else
{
v10 = (_DWORD *)v7;
v9 = 0;
while ( *v10 != a1[1] )
{
++v9;
++v10;
if ( v8 == v9 )
{
v9 = v8;
break;
}
}
}
++a1;
}
}
if ( a4 > 0 )
{
v11 = a3;
do
{
v12 = 0;
if ( v8 > 0 )
{
v13 = (_DWORD *)v7;
v12 = 0;
while ( *v13 != *v11 )
{
++v12;
++v13;
if ( v12 == v8 )
goto LABEL_22;
}
}
if ( v8 == v12 )
LABEL_22:
*(_DWORD *)(v7 + 4LL * v8++) = *v11;
++v11;
}
while ( v11 != &a3[a4 - 1 + 1] );
}
return v7;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV R12D,ESI
MOV RBP,RDX
MOV EBX,ECX
LEA EDI,[RSI + RCX*0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV R8,RAX
TEST R12D,R12D
JLE 0x00101254
MOV RDI,R13
LEA EAX,[R12 + -0x1]
LEA R9,[R13 + RAX*0x4]
MOV ECX,0x0
MOV EAX,0x0
JMP 0x00101229
LAB_00101212:
MOVSXD RAX,ECX
MOV EDX,dword ptr [RDI]
MOV dword ptr [R8 + RAX*0x4],EDX
LEA ECX,[RCX + 0x1]
JMP 0x0010122d
LAB_00101220:
MOV EAX,0x0
LAB_00101225:
ADD RDI,0x4
LAB_00101229:
CMP ECX,EAX
JZ 0x00101212
LAB_0010122d:
CMP RDI,R9
JZ 0x00101259
TEST ECX,ECX
JLE 0x00101220
MOV ESI,dword ptr [RDI + 0x4]
MOV RDX,R8
MOV EAX,0x0
LAB_00101241:
CMP dword ptr [RDX],ESI
JZ 0x00101225
ADD EAX,0x1
ADD RDX,0x4
CMP ECX,EAX
JNZ 0x00101241
MOV EAX,ECX
JMP 0x00101225
LAB_00101254:
MOV ECX,0x0
LAB_00101259:
TEST EBX,EBX
JLE 0x001012a7
MOV RDI,RBP
LEA EAX,[RBX + -0x1]
LEA R9,[RBP + RAX*0x4 + 0x4]
JMP 0x00101277
LAB_0010126a:
CMP ECX,EAX
JZ 0x00101299
LAB_0010126e:
ADD RDI,0x4
CMP RDI,R9
JZ 0x001012a7
LAB_00101277:
MOV EAX,0x0
TEST ECX,ECX
JLE 0x0010126a
MOV ESI,dword ptr [RDI]
MOV RDX,R8
MOV EAX,0x0
LAB_0010128a:
CMP dword ptr [RDX],ESI
JZ 0x0010126a
ADD EAX,0x1
ADD RDX,0x4
CMP EAX,ECX
JNZ 0x0010128a
LAB_00101299:
MOVSXD RAX,ECX
MOV EDX,dword ptr [RDI]
MOV dword ptr [R8 + RAX*0x4],EDX
LEA ECX,[RCX + 0x1]
JMP 0x0010126e
LAB_001012a7:
MOV EDX,ECX
MOV RAX,R8
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | int1 [16] func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int *piVar5;
int1 auVar6 [16];
auVar6._0_8_ = (int *)malloc((long)(param_2 + param_4) << 2);
if (param_2 < 1) {
iVar4 = 0;
}
else {
piVar1 = param_1 + (param_2 - 1);
iVar4 = 0;
iVar3 = 0;
while( true ) {
if (iVar4 == iVar3) {
auVar6._0_8_[iVar4] = *param_1;
iVar4 = iVar4 + 1;
}
if (param_1 == piVar1) break;
if (iVar4 < 1) {
iVar3 = 0;
}
else {
iVar2 = 0;
piVar5 = auVar6._0_8_;
do {
iVar3 = iVar2;
if (*piVar5 == param_1[1]) break;
iVar2 = iVar2 + 1;
piVar5 = piVar5 + 1;
iVar3 = iVar4;
} while (iVar4 != iVar2);
}
param_1 = param_1 + 1;
}
}
if (0 < param_4) {
piVar1 = param_3 + (ulong)(param_4 - 1) + 1;
do {
iVar3 = 0;
if (iVar4 < 1) {
LAB_0010126a:
if (iVar4 == iVar3) goto LAB_00101299;
}
else {
iVar3 = 0;
piVar5 = auVar6._0_8_;
do {
if (*piVar5 == *param_3) goto LAB_0010126a;
iVar3 = iVar3 + 1;
piVar5 = piVar5 + 1;
} while (iVar3 != iVar4);
LAB_00101299:
auVar6._0_8_[iVar4] = *param_3;
iVar4 = iVar4 + 1;
}
param_3 = param_3 + 1;
} while (param_3 != piVar1);
}
auVar6._8_4_ = iVar4;
auVar6._12_4_ = 0;
return auVar6;
} |
6,134 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int *elements;
int size;
} UniqueTuple;
| UniqueTuple func0(int *test_tup1, int size1, int *test_tup2, int size2) {
UniqueTuple result;
result.elements = (int *)malloc((size1 + size2) * sizeof(int));
int k = 0;
for (int i = 0; i < size1; i++) {
int j;
for (j = 0; j < k; j++) {
if (result.elements[j] == test_tup1[i])
break;
}
if (j == k) {
result.elements[k++] = test_tup1[i];
}
}
for (int i = 0; i < size2; i++) {
int j;
for (j = 0; j < k; j++) {
if (result.elements[j] == test_tup2[i])
break;
}
if (j == k) {
result.elements[k++] = test_tup2[i];
}
}
result.size = k;
return result;
}
| int main() {
int tuple1[] = {3, 4, 5, 6};
int tuple2[] = {5, 7, 4, 10};
UniqueTuple res1 = func0(tuple1, 4, tuple2, 4);
int expected1[] = {3, 4, 5, 6, 7, 10};
assert(res1.size == sizeof(expected1) / sizeof(int));
for (int i = 0; i < res1.size; i++) {
assert(res1.elements[i] == expected1[i]);
}
int tuple3[] = {1, 2, 3, 4};
int tuple4[] = {3, 4, 5, 6};
UniqueTuple res2 = func0(tuple3, 4, tuple4, 4);
int expected2[] = {1, 2, 3, 4, 5, 6};
assert(res2.size == sizeof(expected2) / sizeof(int));
for (int i = 0; i < res2.size; i++) {
assert(res2.elements[i] == expected2[i]);
}
int tuple5[] = {11, 12, 13, 14};
int tuple6[] = {13, 15, 16, 17};
UniqueTuple res3 = func0(tuple5, 4, tuple6, 4);
int expected3[] = {11, 12, 13, 14, 15, 16, 17};
assert(res3.size == sizeof(expected3) / sizeof(int));
for (int i = 0; i < res3.size; i++) {
assert(res3.elements[i] == expected3[i]);
}
free(res1.elements);
free(res2.elements);
free(res3.elements);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %esi,%r13d
push %r12
mov %ecx,%r12d
push %rbp
mov %rdi,%rbp
lea (%rsi,%rcx,1),%edi
push %rbx
movslq %edi,%rdi
mov %rdx,%rbx
shl $0x2,%rdi
sub $0x8,%rsp
callq 10d0 <malloc@plt>
test %r13d,%r13d
jle 1638 <func0+0x138>
lea -0x1(%r13),%edx
mov %rbp,%r10
xor %r9d,%r9d
lea 0x4(%rbp,%rdx,4),%r11
nopl 0x0(%rax)
xor %r8d,%r8d
test %r9d,%r9d
jle 15f0 <func0+0xf0>
lea -0x1(%r9),%esi
mov (%r10),%edi
mov $0x1,%edx
add $0x2,%rsi
jmp 157c <func0+0x7c>
nopw %cs:0x0(%rax,%rax,1)
mov %edx,%r8d
add $0x1,%rdx
cmp %rsi,%rdx
je 15f0 <func0+0xf0>
cmp %edi,-0x4(%rax,%rdx,4)
jne 1570 <func0+0x70>
add $0x4,%r10
cmp %r11,%r10
jne 1548 <func0+0x48>
test %r12d,%r12d
jle 15da <func0+0xda>
lea -0x1(%r12),%edx
lea 0x4(%rbx,%rdx,4),%r8
nopw 0x0(%rax,%rax,1)
xor %edi,%edi
test %r9d,%r9d
jle 1618 <func0+0x118>
lea -0x1(%r9),%ecx
mov (%rbx),%esi
mov $0x1,%edx
add $0x2,%rcx
jmp 15cb <func0+0xcb>
nopl 0x0(%rax,%rax,1)
mov %edx,%edi
add $0x1,%rdx
cmp %rcx,%rdx
je 1618 <func0+0x118>
cmp %esi,-0x4(%rax,%rdx,4)
jne 15c0 <func0+0xc0>
add $0x4,%rbx
cmp %r8,%rbx
jne 15a0 <func0+0xa0>
add $0x8,%rsp
mov %r9d,%edx
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
cmp %r9d,%r8d
jne 1582 <func0+0x82>
mov (%r10),%ecx
movslq %r9d,%rdx
add $0x4,%r10
add $0x1,%r9d
mov %ecx,(%rax,%rdx,4)
cmp %r11,%r10
jne 1548 <func0+0x48>
jmpq 158b <func0+0x8b>
nopl 0x0(%rax)
cmp %r9d,%edi
jne 15d1 <func0+0xd1>
mov (%rbx),%ecx
movslq %r9d,%rdx
add $0x4,%rbx
add $0x1,%r9d
mov %ecx,(%rax,%rdx,4)
cmp %r8,%rbx
jne 15a0 <func0+0xa0>
jmp 15da <func0+0xda>
xor %r9d,%r9d
jmpq 158b <func0+0x8b>
| func0:
endbr64
push r13
mov r13d, esi
push r12
mov r12d, ecx
push rbp
mov rbp, rdi
lea edi, [rsi+rcx]
push rbx
movsxd rdi, edi
mov rbx, rdx
shl rdi, 2
sub rsp, 8
call _malloc
mov r8, rax
test r13d, r13d
jle loc_160F
lea eax, [r13-1]
mov r9, rbp
xor edi, edi
lea r10, [rbp+rax*4+4]
nop dword ptr [rax+rax+00h]
loc_1538:
xor esi, esi
test edi, edi
jle loc_15C8
mov edx, [r9]
lea ecx, [rdi+1]
mov eax, 1
jmp short loc_155B
loc_1550:
mov esi, eax
add rax, 1
cmp rax, rcx
jz short loc_15C8
loc_155B:
cmp [r8+rax*4-4], edx
jnz short loc_1550
loc_1562:
add r9, 4
cmp r9, r10
jnz short loc_1538
loc_156B:
test r12d, r12d
jle short loc_15B3
lea eax, [r12-1]
lea r9, [rbx+rax*4+4]
nop word ptr [rax+rax+00h]
loc_1580:
xor esi, esi
test edi, edi
jle short loc_15F0
mov edx, [rbx]
lea ecx, [rdi+1]
mov eax, 1
jmp short loc_15A3
loc_1598:
mov esi, eax
add rax, 1
cmp rax, rcx
jz short loc_15F0
loc_15A3:
cmp [r8+rax*4-4], edx
jnz short loc_1598
loc_15AA:
add rbx, 4
cmp rbx, r9
jnz short loc_1580
loc_15B3:
add rsp, 8
mov edx, edi
mov rax, r8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_15C8:
cmp esi, edi
jnz short loc_1562
mov edx, [r9]
movsxd rax, edi
add r9, 4
add edi, 1
mov [r8+rax*4], edx
cmp r9, r10
jnz loc_1538
jmp short loc_156B
loc_15F0:
cmp esi, edi
jnz short loc_15AA
mov edx, [rbx]
movsxd rax, edi
add rbx, 4
add edi, 1
mov [r8+rax*4], edx
cmp rbx, r9
jnz loc_1580
jmp short loc_15B3
loc_160F:
xor edi, edi
jmp loc_156B | long long func0(int *a1, int a2, int *a3, int a4)
{
long long v7; // r8
int *v8; // r9
int v9; // edi
long long v10; // r10
int v11; // esi
long long v12; // rax
long long v13; // r9
int v14; // esi
long long v15; // rax
int v17; // edx
long long v18; // rax
int v19; // edx
long long v20; // rax
v7 = malloc(4LL * (a2 + a4));
if ( a2 > 0 )
{
v8 = a1;
v9 = 0;
v10 = (long long)&a1[a2 - 1 + 1];
while ( 1 )
{
v11 = 0;
if ( v9 > 0 )
break;
LABEL_16:
if ( v11 == v9 )
{
v17 = *v8;
v18 = v9;
++v8;
++v9;
*(_DWORD *)(v7 + 4 * v18) = v17;
if ( v8 == (int *)v10 )
goto LABEL_8;
}
else
{
LABEL_7:
if ( ++v8 == (int *)v10 )
goto LABEL_8;
}
}
v12 = 1LL;
while ( *(_DWORD *)(v7 + 4 * v12 - 4) != *v8 )
{
v11 = v12++;
if ( v12 == v9 + 1 )
goto LABEL_16;
}
goto LABEL_7;
}
v9 = 0;
LABEL_8:
if ( a4 > 0 )
{
v13 = (long long)&a3[a4 - 1 + 1];
while ( 1 )
{
v14 = 0;
if ( v9 > 0 )
break;
LABEL_19:
if ( v14 == v9 )
{
v19 = *a3;
v20 = v9;
++a3;
++v9;
*(_DWORD *)(v7 + 4 * v20) = v19;
if ( a3 == (int *)v13 )
return v7;
}
else
{
LABEL_14:
if ( ++a3 == (int *)v13 )
return v7;
}
}
v15 = 1LL;
while ( *(_DWORD *)(v7 + 4 * v15 - 4) != *a3 )
{
v14 = v15++;
if ( v15 == v9 + 1 )
goto LABEL_19;
}
goto LABEL_14;
}
return v7;
} | func0:
ENDBR64
PUSH R13
MOV R13D,ESI
PUSH R12
MOV R12D,ECX
PUSH RBP
MOV RBP,RDI
LEA EDI,[RSI + RCX*0x1]
PUSH RBX
MOVSXD RDI,EDI
MOV RBX,RDX
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010d0
MOV R8,RAX
TEST R13D,R13D
JLE 0x0010160f
LEA EAX,[R13 + -0x1]
MOV R9,RBP
XOR EDI,EDI
LEA R10,[RBP + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101538:
XOR ESI,ESI
TEST EDI,EDI
JLE 0x001015c8
MOV EDX,dword ptr [R9]
LEA ECX,[RDI + 0x1]
MOV EAX,0x1
JMP 0x0010155b
LAB_00101550:
MOV ESI,EAX
ADD RAX,0x1
CMP RAX,RCX
JZ 0x001015c8
LAB_0010155b:
CMP dword ptr [R8 + RAX*0x4 + -0x4],EDX
JNZ 0x00101550
LAB_00101562:
ADD R9,0x4
CMP R9,R10
JNZ 0x00101538
LAB_0010156b:
TEST R12D,R12D
JLE 0x001015b3
LEA EAX,[R12 + -0x1]
LEA R9,[RBX + RAX*0x4 + 0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101580:
XOR ESI,ESI
TEST EDI,EDI
JLE 0x001015f0
MOV EDX,dword ptr [RBX]
LEA ECX,[RDI + 0x1]
MOV EAX,0x1
JMP 0x001015a3
LAB_00101598:
MOV ESI,EAX
ADD RAX,0x1
CMP RAX,RCX
JZ 0x001015f0
LAB_001015a3:
CMP dword ptr [R8 + RAX*0x4 + -0x4],EDX
JNZ 0x00101598
LAB_001015aa:
ADD RBX,0x4
CMP RBX,R9
JNZ 0x00101580
LAB_001015b3:
ADD RSP,0x8
MOV EDX,EDI
MOV RAX,R8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001015c8:
CMP ESI,EDI
JNZ 0x00101562
MOV EDX,dword ptr [R9]
MOVSXD RAX,EDI
ADD R9,0x4
ADD EDI,0x1
MOV dword ptr [R8 + RAX*0x4],EDX
CMP R9,R10
JNZ 0x00101538
JMP 0x0010156b
LAB_001015f0:
CMP ESI,EDI
JNZ 0x001015aa
MOV EDX,dword ptr [RBX]
MOVSXD RAX,EDI
ADD RBX,0x4
ADD EDI,0x1
MOV dword ptr [R8 + RAX*0x4],EDX
CMP RBX,R9
JNZ 0x00101580
JMP 0x001015b3
LAB_0010160f:
XOR EDI,EDI
JMP 0x0010156b | int1 [16] func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
ulong uVar2;
long lVar3;
int iVar4;
int iVar5;
int1 auVar6 [16];
auVar6._0_8_ = malloc((long)(param_2 + param_4) << 2);
if (param_2 < 1) {
iVar5 = 0;
}
else {
iVar5 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
while( true ) {
iVar4 = 0;
if (0 < iVar5) {
uVar2 = 1;
do {
if (*(int *)((long)auVar6._0_8_ + uVar2 * 4 + -4) == *param_1) goto LAB_00101562;
iVar4 = (int)uVar2;
uVar2 = uVar2 + 1;
} while (uVar2 != iVar5 + 1);
}
if (iVar4 == iVar5) break;
LAB_00101562:
param_1 = param_1 + 1;
if (param_1 == piVar1) goto LAB_0010156b;
}
iVar4 = *param_1;
lVar3 = (long)iVar5;
param_1 = param_1 + 1;
iVar5 = iVar5 + 1;
*(int *)((long)auVar6._0_8_ + lVar3 * 4) = iVar4;
} while (param_1 != piVar1);
}
LAB_0010156b:
if (0 < param_4) {
piVar1 = param_3 + (ulong)(param_4 - 1) + 1;
do {
while( true ) {
iVar4 = 0;
if (0 < iVar5) {
uVar2 = 1;
do {
if (*(int *)((long)auVar6._0_8_ + uVar2 * 4 + -4) == *param_3) goto LAB_001015aa;
iVar4 = (int)uVar2;
uVar2 = uVar2 + 1;
} while (uVar2 != iVar5 + 1);
}
if (iVar4 == iVar5) break;
LAB_001015aa:
param_3 = param_3 + 1;
if (param_3 == piVar1) goto LAB_001015b3;
}
iVar4 = *param_3;
lVar3 = (long)iVar5;
param_3 = param_3 + 1;
iVar5 = iVar5 + 1;
*(int *)((long)auVar6._0_8_ + lVar3 * 4) = iVar4;
} while (param_3 != piVar1);
}
LAB_001015b3:
auVar6._8_4_ = iVar5;
auVar6._12_4_ = 0;
return auVar6;
} |
6,135 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int *elements;
int size;
} UniqueTuple;
| UniqueTuple func0(int *test_tup1, int size1, int *test_tup2, int size2) {
UniqueTuple result;
result.elements = (int *)malloc((size1 + size2) * sizeof(int));
int k = 0;
for (int i = 0; i < size1; i++) {
int j;
for (j = 0; j < k; j++) {
if (result.elements[j] == test_tup1[i])
break;
}
if (j == k) {
result.elements[k++] = test_tup1[i];
}
}
for (int i = 0; i < size2; i++) {
int j;
for (j = 0; j < k; j++) {
if (result.elements[j] == test_tup2[i])
break;
}
if (j == k) {
result.elements[k++] = test_tup2[i];
}
}
result.size = k;
return result;
}
| int main() {
int tuple1[] = {3, 4, 5, 6};
int tuple2[] = {5, 7, 4, 10};
UniqueTuple res1 = func0(tuple1, 4, tuple2, 4);
int expected1[] = {3, 4, 5, 6, 7, 10};
assert(res1.size == sizeof(expected1) / sizeof(int));
for (int i = 0; i < res1.size; i++) {
assert(res1.elements[i] == expected1[i]);
}
int tuple3[] = {1, 2, 3, 4};
int tuple4[] = {3, 4, 5, 6};
UniqueTuple res2 = func0(tuple3, 4, tuple4, 4);
int expected2[] = {1, 2, 3, 4, 5, 6};
assert(res2.size == sizeof(expected2) / sizeof(int));
for (int i = 0; i < res2.size; i++) {
assert(res2.elements[i] == expected2[i]);
}
int tuple5[] = {11, 12, 13, 14};
int tuple6[] = {13, 15, 16, 17};
UniqueTuple res3 = func0(tuple5, 4, tuple6, 4);
int expected3[] = {11, 12, 13, 14, 15, 16, 17};
assert(res3.size == sizeof(expected3) / sizeof(int));
for (int i = 0; i < res3.size; i++) {
assert(res3.elements[i] == expected3[i]);
}
free(res1.elements);
free(res2.elements);
free(res3.elements);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r13
mov %esi,%r13d
push %r12
mov %ecx,%r12d
push %rbp
mov %rdi,%rbp
lea (%rsi,%rcx,1),%edi
push %rbx
movslq %edi,%rdi
mov %rdx,%rbx
shl $0x2,%rdi
sub $0x8,%rsp
callq 10d0 <malloc@plt>
test %r13d,%r13d
jle 1618 <func0+0x138>
lea -0x1(%r13),%edx
mov %rbp,%r10
xor %r9d,%r9d
lea 0x4(%rbp,%rdx,4),%r11
nopl 0x0(%rax)
xor %r8d,%r8d
test %r9d,%r9d
jle 15d0 <func0+0xf0>
lea -0x1(%r9),%esi
mov (%r10),%edi
mov $0x1,%edx
add $0x2,%rsi
jmp 155c <func0+0x7c>
nopw %cs:0x0(%rax,%rax,1)
mov %edx,%r8d
add $0x1,%rdx
cmp %rsi,%rdx
je 15d0 <func0+0xf0>
cmp %edi,-0x4(%rax,%rdx,4)
jne 1550 <func0+0x70>
add $0x4,%r10
cmp %r11,%r10
jne 1528 <func0+0x48>
test %r12d,%r12d
jle 15ba <func0+0xda>
lea -0x1(%r12),%edx
lea 0x4(%rbx,%rdx,4),%r8
nopw 0x0(%rax,%rax,1)
xor %edi,%edi
test %r9d,%r9d
jle 15f8 <func0+0x118>
lea -0x1(%r9),%ecx
mov (%rbx),%esi
mov $0x1,%edx
add $0x2,%rcx
jmp 15ab <func0+0xcb>
nopl 0x0(%rax,%rax,1)
mov %edx,%edi
add $0x1,%rdx
cmp %rdx,%rcx
je 15f8 <func0+0x118>
cmp %esi,-0x4(%rax,%rdx,4)
jne 15a0 <func0+0xc0>
add $0x4,%rbx
cmp %r8,%rbx
jne 1580 <func0+0xa0>
add $0x8,%rsp
mov %r9d,%edx
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
cmp %r9d,%r8d
jne 1562 <func0+0x82>
mov (%r10),%ecx
movslq %r9d,%rdx
add $0x4,%r10
add $0x1,%r9d
mov %ecx,(%rax,%rdx,4)
cmp %r11,%r10
jne 1528 <func0+0x48>
jmpq 156b <func0+0x8b>
nopl 0x0(%rax)
cmp %r9d,%edi
jne 15b1 <func0+0xd1>
mov (%rbx),%ecx
movslq %r9d,%rdx
add $0x4,%rbx
add $0x1,%r9d
mov %ecx,(%rax,%rdx,4)
cmp %r8,%rbx
jne 1580 <func0+0xa0>
jmp 15ba <func0+0xda>
xor %r9d,%r9d
jmpq 156b <func0+0x8b>
| func0:
endbr64
push r13
movsxd r13, esi
push r12
movsxd r12, ecx
push rbp
mov rbp, rdi
lea edi, [r13+r12+0]
push rbx
movsxd rdi, edi
mov rbx, rdx
shl rdi, 2; size
sub rsp, 8
call _malloc
mov r8, rax
test r13d, r13d
jle loc_1557
mov rdi, rbp
lea r9, [rbp+r13*4+0]
xor ecx, ecx
loc_1491:
xor eax, eax
test ecx, ecx
jle short loc_14AF
loc_1497:
mov esi, [rdi]
mov rdx, r8
xor eax, eax
jmp short loc_14AB
loc_14A0:
add eax, 1
add rdx, 4
cmp ecx, eax
jz short loc_1510
loc_14AB:
cmp [rdx], esi
jnz short loc_14A0
loc_14AF:
cmp ecx, eax
jz short loc_1510
add rdi, 4
cmp rdi, r9
jnz short loc_1491
loc_14BC:
test r12d, r12d
jle short loc_14FC
mov rdi, rbx
lea r9, [rbx+r12*4]
loc_14C8:
xor eax, eax
test ecx, ecx
jle short loc_14EF
loc_14CE:
mov esi, [rdi]
mov rdx, r8
xor eax, eax
jmp short loc_14EB
loc_14E0:
add eax, 1
add rdx, 4
cmp eax, ecx
jz short loc_1530
loc_14EB:
cmp [rdx], esi
jnz short loc_14E0
loc_14EF:
cmp ecx, eax
jz short loc_1530
add rdi, 4
cmp rdi, r9
jnz short loc_14C8
loc_14FC:
add rsp, 8
mov edx, ecx
mov rax, r8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1510:
mov edx, [rdi]
lea ecx, [rax+1]
add rdi, 4
cdqe
mov [r8+rax*4], edx
cmp rdi, r9
jnz loc_1497
jmp short loc_14BC
loc_1530:
mov edx, [rdi]
lea eax, [rcx+1]
add rdi, 4
movsxd rcx, ecx
mov [r8+rcx*4], edx
mov ecx, eax
cmp rdi, r9
jnz short loc_14CE
add rsp, 8
mov edx, ecx
mov rax, r8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1557:
xor ecx, ecx
jmp loc_14BC | _DWORD * func0(int *a1, int a2, int *a3, int a4)
{
long long v4; // r12
_DWORD *v6; // r8
int *v7; // r9
int v8; // ecx
int v9; // eax
_DWORD *v10; // rdx
int *v11; // rdi
int *v12; // r9
int v13; // eax
_DWORD *v14; // rdx
int v16; // edx
int v17; // edx
v4 = a4;
v6 = malloc(4LL * (a2 + a4));
if ( a2 > 0 )
{
v7 = &a1[a2];
v8 = 0;
while ( 1 )
{
v9 = 0;
if ( v8 <= 0 )
goto LABEL_7;
while ( 1 )
{
v10 = v6;
v9 = 0;
while ( *v10 != *a1 )
{
++v9;
++v10;
if ( v8 == v9 )
goto LABEL_18;
}
LABEL_7:
if ( v8 != v9 )
break;
LABEL_18:
v16 = *a1;
v8 = v9 + 1;
++a1;
v6[v9] = v16;
if ( a1 == v7 )
goto LABEL_9;
}
if ( ++a1 == v7 )
goto LABEL_9;
}
}
v8 = 0;
LABEL_9:
if ( (int)v4 <= 0 )
return v6;
v11 = a3;
v12 = &a3[v4];
LABEL_11:
v13 = 0;
if ( v8 <= 0 )
goto LABEL_15;
do
{
v14 = v6;
v13 = 0;
while ( *v14 != *v11 )
{
++v13;
++v14;
if ( v13 == v8 )
goto LABEL_20;
}
LABEL_15:
if ( v8 != v13 )
{
if ( ++v11 == v12 )
return v6;
goto LABEL_11;
}
LABEL_20:
v17 = *v11++;
v6[v8++] = v17;
}
while ( v11 != v12 );
return v6;
} | func0:
ENDBR64
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOVSXD R12,ECX
PUSH RBP
MOV RBP,RDI
LEA EDI,[R13 + R12*0x1]
PUSH RBX
MOVSXD RDI,EDI
MOV RBX,RDX
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010d0
MOV R8,RAX
TEST R13D,R13D
JLE 0x00101557
MOV RDI,RBP
LEA R9,[RBP + R13*0x4]
XOR ECX,ECX
LAB_00101491:
XOR EAX,EAX
TEST ECX,ECX
JLE 0x001014af
LAB_00101497:
MOV ESI,dword ptr [RDI]
MOV RDX,R8
XOR EAX,EAX
JMP 0x001014ab
LAB_001014a0:
ADD EAX,0x1
ADD RDX,0x4
CMP ECX,EAX
JZ 0x00101510
LAB_001014ab:
CMP dword ptr [RDX],ESI
JNZ 0x001014a0
LAB_001014af:
CMP ECX,EAX
JZ 0x00101510
ADD RDI,0x4
CMP RDI,R9
JNZ 0x00101491
LAB_001014bc:
TEST R12D,R12D
JLE 0x001014fc
MOV RDI,RBX
LEA R9,[RBX + R12*0x4]
LAB_001014c8:
XOR EAX,EAX
TEST ECX,ECX
JLE 0x001014ef
LAB_001014ce:
MOV ESI,dword ptr [RDI]
MOV RDX,R8
XOR EAX,EAX
JMP 0x001014eb
LAB_001014e0:
ADD EAX,0x1
ADD RDX,0x4
CMP EAX,ECX
JZ 0x00101530
LAB_001014eb:
CMP dword ptr [RDX],ESI
JNZ 0x001014e0
LAB_001014ef:
CMP ECX,EAX
JZ 0x00101530
ADD RDI,0x4
CMP RDI,R9
JNZ 0x001014c8
LAB_001014fc:
ADD RSP,0x8
MOV EDX,ECX
MOV RAX,R8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101510:
MOV EDX,dword ptr [RDI]
LEA ECX,[RAX + 0x1]
ADD RDI,0x4
CDQE
MOV dword ptr [R8 + RAX*0x4],EDX
CMP RDI,R9
JNZ 0x00101497
JMP 0x001014bc
LAB_00101530:
MOV EDX,dword ptr [RDI]
LEA EAX,[RCX + 0x1]
ADD RDI,0x4
MOVSXD RCX,ECX
MOV dword ptr [R8 + RCX*0x4],EDX
MOV ECX,EAX
CMP RDI,R9
JNZ 0x001014ce
ADD RSP,0x8
MOV EDX,ECX
MOV RAX,R8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101557:
XOR ECX,ECX
JMP 0x001014bc | int [16] func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int *piVar5;
int auVar6 [16];
int auVar7 [16];
auVar6._0_8_ = (int *)malloc((long)(param_2 + param_4) << 2);
if (0 < param_2) {
piVar1 = param_1 + param_2;
iVar3 = 0;
LAB_00101491:
iVar2 = 0;
if (iVar3 < 1) goto LAB_001014af;
LAB_00101497:
iVar2 = 0;
piVar5 = auVar6._0_8_;
do {
if (*piVar5 == *param_1) goto LAB_001014af;
iVar2 = iVar2 + 1;
piVar5 = piVar5 + 1;
} while (iVar3 != iVar2);
goto LAB_00101510;
}
iVar3 = 0;
LAB_001014bc:
if (param_4 < 1) {
LAB_001014fc:
auVar6._8_4_ = iVar3;
auVar6._12_4_ = 0;
return auVar6;
}
piVar1 = param_3 + param_4;
LAB_001014c8:
iVar2 = 0;
if (iVar3 < 1) goto LAB_001014ef;
LAB_001014ce:
iVar2 = 0;
piVar5 = auVar6._0_8_;
do {
if (*piVar5 == *param_3) goto LAB_001014ef;
iVar2 = iVar2 + 1;
piVar5 = piVar5 + 1;
iVar4 = iVar3;
} while (iVar2 != iVar3);
goto LAB_00101530;
LAB_001014af:
if (iVar3 != iVar2) goto code_r0x001014b3;
LAB_00101510:
iVar4 = *param_1;
iVar3 = iVar2 + 1;
param_1 = param_1 + 1;
auVar6._0_8_[iVar2] = iVar4;
if (param_1 == piVar1) goto LAB_001014bc;
goto LAB_00101497;
code_r0x001014b3:
param_1 = param_1 + 1;
if (param_1 == piVar1) goto LAB_001014bc;
goto LAB_00101491;
LAB_001014ef:
iVar4 = iVar3;
if (iVar3 != iVar2) goto code_r0x001014f3;
LAB_00101530:
iVar2 = *param_3;
iVar3 = iVar4 + 1;
param_3 = param_3 + 1;
auVar6._0_8_[iVar4] = iVar2;
if (param_3 == piVar1) {
auVar7._8_4_ = iVar3;
auVar7._0_8_ = auVar6._0_8_;
auVar7._12_4_ = 0;
return auVar7;
}
goto LAB_001014ce;
code_r0x001014f3:
param_3 = param_3 + 1;
if (param_3 == piVar1) goto LAB_001014fc;
goto LAB_001014c8;
} |
6,136 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#define MAX_ENTRIES 100
#define MAX_VALUES 10
typedef struct {
int key;
int values[MAX_VALUES];
int count;
} map_entry;
typedef struct {
map_entry entries[MAX_ENTRIES];
int size;
} map;
int find_key(map* m, int key) {
for(int i = 0; i < m->size; i++) {
if(m->entries[i].key == key)
return i;
}
return -1;
}
| map func0(int test_keys[], int test_vals[], int n) {
map res;
res.size = 0;
for(int i = 0; i < n; i++) {
int key = test_keys[i];
int val = test_vals[i];
// setdefault(val, [])
if(find_key(&res, val) == -1){
res.entries[res.size].key = val;
res.entries[res.size].count = 0;
res.size++;
}
// setdefault(key, []).append(val)
int idx = find_key(&res, key);
if(idx == -1){
res.entries[res.size].key = key;
res.entries[res.size].count = 0;
idx = res.size;
res.size++;
}
if(res.entries[idx].count < MAX_VALUES){
res.entries[idx].values[res.entries[idx].count++] = val;
}
}
return res;
}
| int main(){
// First test case
int test1_keys[] = {5, 7, 2, 3, 8};
int test1_vals[] = {3, 5, 7, 8, 4};
int n1 = 5;
map result1 = func0(test1_keys, test1_vals, n1);
map expected1;
expected1.size = 6;
expected1.entries[0].key = 3; expected1.entries[0].count = 1; expected1.entries[0].values[0] = 8;
expected1.entries[1].key = 5; expected1.entries[1].count = 1; expected1.entries[1].values[0] = 3;
expected1.entries[2].key = 7; expected1.entries[2].count = 1; expected1.entries[2].values[0] = 5;
expected1.entries[3].key = 2; expected1.entries[3].count = 1; expected1.entries[3].values[0] = 7;
expected1.entries[4].key = 8; expected1.entries[4].count = 1; expected1.entries[4].values[0] = 4;
expected1.entries[5].key = 4; expected1.entries[5].count = 0;
assert(result1.size == expected1.size);
for(int i = 0; i < result1.size; i++){
int found = 0;
for(int j = 0; j < expected1.size; j++){
if(result1.entries[i].key == expected1.entries[j].key){
assert(result1.entries[i].count == expected1.entries[j].count);
for(int k = 0; k < result1.entries[i].count; k++){
assert(result1.entries[i].values[k] == expected1.entries[j].values[k]);
}
found = 1;
break;
}
}
assert(found);
}
// Second test case
int test2_keys[] = {6, 9, 3, 4, 9};
int test2_vals[] = {4, 4, 8, 9, 5};
int n2 = 5;
map result2 = func0(test2_keys, test2_vals, n2);
map expected2;
expected2.size = 6;
expected2.entries[0].key = 4; expected2.entries[0].count = 1; expected2.entries[0].values[0] = 9;
expected2.entries[1].key = 6; expected2.entries[1].count = 1; expected2.entries[1].values[0] = 4;
expected2.entries[2].key = 9; expected2.entries[2].count = 2; expected2.entries[2].values[0] = 4; expected2.entries[2].values[1] = 5;
expected2.entries[3].key = 8; expected2.entries[3].count = 0;
expected2.entries[4].key = 3; expected2.entries[4].count = 1; expected2.entries[4].values[0] = 8;
expected2.entries[5].key = 5; expected2.entries[5].count = 0;
assert(result2.size == expected2.size);
for(int i = 0; i < result2.size; i++){
int found = 0;
for(int j = 0; j < expected2.size; j++){
if(result2.entries[i].key == expected2.entries[j].key){
assert(result2.entries[i].count == expected2.entries[j].count);
for(int k = 0; k < result2.entries[i].count; k++){
assert(result2.entries[i].values[k] == expected2.entries[j].values[k]);
}
found = 1;
break;
}
}
assert(found);
}
// Third test case
int test3_keys[] = {6, 6, 4, 4, 3};
int test3_vals[] = {2, 8, 9, 9, 7};
int n3 = 5;
map result3 = func0(test3_keys, test3_vals, n3);
map expected3;
expected3.size = 7;
expected3.entries[0].key = 2; expected3.entries[0].count = 0;
expected3.entries[1].key = 6; expected3.entries[1].count = 2; expected3.entries[1].values[0] = 2; expected3.entries[1].values[1] = 8;
expected3.entries[2].key = 8; expected3.entries[2].count = 0;
expected3.entries[3].key = 9; expected3.entries[3].count = 0;
expected3.entries[4].key = 4; expected3.entries[4].count = 2; expected3.entries[4].values[0] = 9; expected3.entries[4].values[1] = 9;
expected3.entries[5].key = 7; expected3.entries[5].count = 0;
expected3.entries[6].key = 3; expected3.entries[6].count = 1; expected3.entries[6].values[0] = 7;
assert(result3.size == expected3.size);
for(int i = 0; i < result3.size; i++){
int found = 0;
for(int j = 0; j < expected3.size; j++){
if(result3.entries[i].key == expected3.entries[j].key){
assert(result3.entries[i].count == expected3.entries[j].count);
for(int k = 0; k < result3.entries[i].count; k++){
assert(result3.entries[i].values[k] == expected3.entries[j].values[k]);
}
found = 1;
break;
}
}
assert(found);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x300,%rsp
mov %rdi,-0x12e8(%rbp)
mov %rsi,-0x12f0(%rbp)
mov %rdx,-0x12f8(%rbp)
mov %ecx,-0x12fc(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x10(%rbp)
movl $0x0,-0x12e0(%rbp)
jmpq 13e7 <func0+0x226>
mov -0x12e0(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x12f0(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x12d8(%rbp)
mov -0x12e0(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x12f8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x12d4(%rbp)
mov -0x12d4(%rbp),%edx
lea -0x12d0(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1169 <find_key>
cmp $0xffffffff,%eax
jne 12cc <func0+0x10b>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x4,%rax
add %rbp,%rax
lea -0x12d0(%rax),%rdx
mov -0x12d4(%rbp),%eax
mov %eax,(%rdx)
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x4,%rax
add %rbp,%rax
sub $0x12a4,%rax
movl $0x0,(%rax)
mov -0x10(%rbp),%eax
add $0x1,%eax
mov %eax,-0x10(%rbp)
mov -0x12d8(%rbp),%edx
lea -0x12d0(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1169 <find_key>
mov %eax,-0x12dc(%rbp)
cmpl $0xffffffff,-0x12dc(%rbp)
jne 134b <func0+0x18a>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x4,%rax
add %rbp,%rax
lea -0x12d0(%rax),%rdx
mov -0x12d8(%rbp),%eax
mov %eax,(%rdx)
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x4,%rax
add %rbp,%rax
sub $0x12a4,%rax
movl $0x0,(%rax)
mov -0x10(%rbp),%eax
mov %eax,-0x12dc(%rbp)
mov -0x10(%rbp),%eax
add $0x1,%eax
mov %eax,-0x10(%rbp)
mov -0x12dc(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x4,%rax
add %rbp,%rax
sub $0x12a4,%rax
mov (%rax),%eax
cmp $0x9,%eax
jg 13e0 <func0+0x21f>
mov -0x12dc(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x4,%rax
add %rbp,%rax
sub $0x12a4,%rax
mov (%rax),%edx
lea 0x1(%rdx),%esi
mov -0x12dc(%rbp),%eax
movslq %eax,%rcx
mov %rcx,%rax
add %rax,%rax
add %rcx,%rax
shl $0x4,%rax
add %rbp,%rax
sub $0x12a4,%rax
mov %esi,(%rax)
movslq %edx,%rcx
mov -0x12dc(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
lea (%rax,%rcx,1),%rdx
mov -0x12d4(%rbp),%eax
mov %eax,-0x12cc(%rbp,%rdx,4)
addl $0x1,-0x12e0(%rbp)
mov -0x12e0(%rbp),%eax
cmp -0x12fc(%rbp),%eax
jl 121c <func0+0x5b>
mov -0x12e8(%rbp),%rax
mov %rax,%rdx
lea -0x12d0(%rbp),%rax
mov $0x12c4,%ecx
mov (%rax),%rsi
mov %rsi,(%rdx)
mov %ecx,%esi
add %rdx,%rsi
lea 0x8(%rsi),%rdi
mov %ecx,%esi
add %rax,%rsi
add $0x8,%rsi
mov -0x10(%rsi),%rsi
mov %rsi,-0x10(%rdi)
lea 0x8(%rdx),%rdi
and $0xfffffffffffffff8,%rdi
sub %rdi,%rdx
sub %rdx,%rax
add %edx,%ecx
and $0xfffffff8,%ecx
shr $0x3,%ecx
mov %ecx,%edx
mov %edx,%edx
mov %rax,%rsi
mov %rdx,%rcx
rep movsq %ds:(%rsi),%es:(%rdi)
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
je 1466 <func0+0x2a5>
callq 1060 <__stack_chk_fail@plt>
mov -0x12e8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 1000h
or [rsp+1000h+var_1000], 0
sub rsp, 300h
mov [rbp+var_12E8], rdi
mov [rbp+var_12F0], rsi
mov [rbp+var_12F8], rdx
mov [rbp+var_12FC], ecx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_10], 0
mov [rbp+var_12E0], 0
jmp loc_13E7
loc_121C:
mov eax, [rbp+var_12E0]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_12F0]
add rax, rdx
mov eax, [rax]
mov [rbp+var_12D8], eax
mov eax, [rbp+var_12E0]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_12F8]
add rax, rdx
mov eax, [rax]
mov [rbp+var_12D4], eax
mov edx, [rbp+var_12D4]
lea rax, [rbp+var_12D0]
mov esi, edx
mov rdi, rax
call find_key
cmp eax, 0FFFFFFFFh
jnz short loc_12CC
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 4
add rax, rbp
lea rdx, [rax-12D0h]
mov eax, [rbp+var_12D4]
mov [rdx], eax
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 4
add rax, rbp
sub rax, 12A4h
mov dword ptr [rax], 0
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
loc_12CC:
mov edx, [rbp+var_12D8]
lea rax, [rbp+var_12D0]
mov esi, edx
mov rdi, rax
call find_key
mov [rbp+var_12DC], eax
cmp [rbp+var_12DC], 0FFFFFFFFh
jnz short loc_134B
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 4
add rax, rbp
lea rdx, [rax-12D0h]
mov eax, [rbp+var_12D8]
mov [rdx], eax
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 4
add rax, rbp
sub rax, 12A4h
mov dword ptr [rax], 0
mov eax, [rbp+var_10]
mov [rbp+var_12DC], eax
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
loc_134B:
mov eax, [rbp+var_12DC]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 4
add rax, rbp
sub rax, 12A4h
mov eax, [rax]
cmp eax, 9
jg short loc_13E0
mov eax, [rbp+var_12DC]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 4
add rax, rbp
sub rax, 12A4h
mov edx, [rax]
lea esi, [rdx+1]
mov eax, [rbp+var_12DC]
movsxd rcx, eax
mov rax, rcx
add rax, rax
add rax, rcx
shl rax, 4
add rax, rbp
sub rax, 12A4h
mov [rax], esi
movsxd rcx, edx
mov eax, [rbp+var_12DC]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
lea rdx, [rax+rcx]
mov eax, [rbp+var_12D4]
mov [rbp+rdx*4+var_12CC], eax
loc_13E0:
add [rbp+var_12E0], 1
loc_13E7:
mov eax, [rbp+var_12E0]
cmp eax, [rbp+var_12FC]
jl loc_121C
mov rax, [rbp+var_12E8]
mov rdx, rax
lea rax, [rbp+var_12D0]
mov ecx, 12C4h
mov rsi, [rax]
mov [rdx], rsi
mov esi, ecx
add rsi, rdx
lea rdi, [rsi+8]
mov esi, ecx
add rsi, rax
add rsi, 8
mov rsi, [rsi-10h]
mov [rdi-10h], rsi
lea rdi, [rdx+8]
and rdi, 0FFFFFFFFFFFFFFF8h
sub rdx, rdi
sub rax, rdx
add ecx, edx
and ecx, 0FFFFFFF8h
shr ecx, 3
mov edx, ecx
mov edx, edx
mov rsi, rax
mov rcx, rdx
rep movsq
mov rax, [rbp+var_8]
sub rax, fs:28h
jz short loc_1466
call ___stack_chk_fail
loc_1466:
mov rax, [rbp+var_12E8]
leave
retn | _QWORD * func0(_QWORD *a1, long long a2, long long a3, int a4)
{
int v4; // edx
int i; // [rsp+20h] [rbp-12E0h]
int key; // [rsp+24h] [rbp-12DCh]
unsigned int v10; // [rsp+28h] [rbp-12D8h]
unsigned int v11; // [rsp+2Ch] [rbp-12D4h]
_QWORD v12[90]; // [rsp+30h] [rbp-12D0h] BYREF
long long v13; // [rsp+12ECh] [rbp-14h]
unsigned long long v14; // [rsp+12F8h] [rbp-8h]
v14 = __readfsqword(0x28u);
HIDWORD(v13) = 0;
for ( i = 0; i < a4; ++i )
{
v10 = *(_DWORD *)(4LL * i + a2);
v11 = *(_DWORD *)(4LL * i + a3);
if ( (unsigned int)find_key(v12, v11) == -1 )
{
LODWORD(v12[6 * SHIDWORD(v13)]) = v11;
HIDWORD(v12[6 * SHIDWORD(v13) + 5]) = 0;
++HIDWORD(v13);
}
key = find_key(v12, v10);
if ( key == -1 )
{
LODWORD(v12[6 * SHIDWORD(v13)]) = v10;
HIDWORD(v12[6 * SHIDWORD(v13) + 5]) = 0;
key = HIDWORD(v13)++;
}
if ( SHIDWORD(v12[6 * key + 5]) <= 9 )
{
v4 = HIDWORD(v12[6 * key + 5]);
HIDWORD(v12[6 * key + 5]) = v4 + 1;
*((_DWORD *)&v12[6 * key] + v4 + 1) = v11;
}
}
*a1 = v12[0];
*(_QWORD *)((char *)a1 + 4796) = v13;
qmemcpy(
(void *)((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL),
(const void *)((char *)v12 - ((char *)a1 - ((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL))),
8LL * ((((_DWORD)a1 - (((_DWORD)a1 + 8) & 0xFFFFFFF8) + 4804) & 0xFFFFFFF8) >> 3));
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x300
MOV qword ptr [RBP + -0x12e8],RDI
MOV qword ptr [RBP + -0x12f0],RSI
MOV qword ptr [RBP + -0x12f8],RDX
MOV dword ptr [RBP + -0x12fc],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0x12e0],0x0
JMP 0x001013e7
LAB_0010121c:
MOV EAX,dword ptr [RBP + -0x12e0]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x12f0]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x12d8],EAX
MOV EAX,dword ptr [RBP + -0x12e0]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x12f8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x12d4],EAX
MOV EDX,dword ptr [RBP + -0x12d4]
LEA RAX,[RBP + -0x12d0]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101169
CMP EAX,-0x1
JNZ 0x001012cc
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x4
ADD RAX,RBP
LEA RDX,[RAX + -0x12d0]
MOV EAX,dword ptr [RBP + -0x12d4]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x4
ADD RAX,RBP
SUB RAX,0x12a4
MOV dword ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
LAB_001012cc:
MOV EDX,dword ptr [RBP + -0x12d8]
LEA RAX,[RBP + -0x12d0]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101169
MOV dword ptr [RBP + -0x12dc],EAX
CMP dword ptr [RBP + -0x12dc],-0x1
JNZ 0x0010134b
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x4
ADD RAX,RBP
LEA RDX,[RAX + -0x12d0]
MOV EAX,dword ptr [RBP + -0x12d8]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x4
ADD RAX,RBP
SUB RAX,0x12a4
MOV dword ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x12dc],EAX
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
LAB_0010134b:
MOV EAX,dword ptr [RBP + -0x12dc]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x4
ADD RAX,RBP
SUB RAX,0x12a4
MOV EAX,dword ptr [RAX]
CMP EAX,0x9
JG 0x001013e0
MOV EAX,dword ptr [RBP + -0x12dc]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x4
ADD RAX,RBP
SUB RAX,0x12a4
MOV EDX,dword ptr [RAX]
LEA ESI,[RDX + 0x1]
MOV EAX,dword ptr [RBP + -0x12dc]
MOVSXD RCX,EAX
MOV RAX,RCX
ADD RAX,RAX
ADD RAX,RCX
SHL RAX,0x4
ADD RAX,RBP
SUB RAX,0x12a4
MOV dword ptr [RAX],ESI
MOVSXD RCX,EDX
MOV EAX,dword ptr [RBP + -0x12dc]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
LEA RDX,[RAX + RCX*0x1]
MOV EAX,dword ptr [RBP + -0x12d4]
MOV dword ptr [RBP + RDX*0x4 + -0x12cc],EAX
LAB_001013e0:
ADD dword ptr [RBP + -0x12e0],0x1
LAB_001013e7:
MOV EAX,dword ptr [RBP + -0x12e0]
CMP EAX,dword ptr [RBP + -0x12fc]
JL 0x0010121c
MOV RAX,qword ptr [RBP + -0x12e8]
MOV RDX,RAX
LEA RAX,[RBP + -0x12d0]
MOV ECX,0x12c4
MOV RSI,qword ptr [RAX]
MOV qword ptr [RDX],RSI
MOV ESI,ECX
ADD RSI,RDX
LEA RDI,[RSI + 0x8]
MOV ESI,ECX
ADD RSI,RAX
ADD RSI,0x8
MOV RSI,qword ptr [RSI + -0x10]
MOV qword ptr [RDI + -0x10],RSI
LEA RDI,[RDX + 0x8]
AND RDI,-0x8
SUB RDX,RDI
SUB RAX,RDX
ADD ECX,EDX
AND ECX,0xfffffff8
SHR ECX,0x3
MOV EDX,ECX
MOV EDX,EDX
MOV RSI,RAX
MOV RCX,RDX
MOVSQ.REP RDI,RSI
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101466
CALL 0x00101060
LAB_00101466:
MOV RAX,qword ptr [RBP + -0x12e8]
LEAVE
RET | int8 * func0(int8 *param_1,long param_2,long param_3,int param_4)
{
int4 uVar1;
int4 uVar2;
int iVar3;
ulong uVar4;
long lVar5;
int8 *puVar6;
int8 *puVar7;
long in_FS_OFFSET;
byte bVar8;
int local_12e8;
int local_12e4;
int8 local_12d8;
int aiStack_12ac [1188];
int4 local_1c;
int iStack_18;
long local_10;
bVar8 = 0;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iStack_18 = 0;
for (local_12e8 = 0; local_12e8 < param_4; local_12e8 = local_12e8 + 1) {
uVar1 = *(int4 *)(param_2 + (long)local_12e8 * 4);
uVar2 = *(int4 *)(param_3 + (long)local_12e8 * 4);
iVar3 = find_key(&local_12d8,uVar2);
if (iVar3 == -1) {
*(int4 *)(&local_12d8 + (long)iStack_18 * 6) = uVar2;
aiStack_12ac[(long)iStack_18 * 0xc] = 0;
iStack_18 = iStack_18 + 1;
}
local_12e4 = find_key(&local_12d8,uVar1);
if (local_12e4 == -1) {
*(int4 *)(&local_12d8 + (long)iStack_18 * 6) = uVar1;
aiStack_12ac[(long)iStack_18 * 0xc] = 0;
local_12e4 = iStack_18;
iStack_18 = iStack_18 + 1;
}
if (aiStack_12ac[(long)local_12e4 * 0xc] < 10) {
iVar3 = aiStack_12ac[(long)local_12e4 * 0xc];
aiStack_12ac[(long)local_12e4 * 0xc] = iVar3 + 1;
*(int4 *)((long)&local_12d8 + ((long)local_12e4 * 0xc + (long)iVar3) * 4 + 4) = uVar2;
}
}
*param_1 = local_12d8;
*(ulong *)((long)param_1 + 0x12bc) = CONCAT44(iStack_18,local_1c);
lVar5 = (long)param_1 - (long)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
puVar6 = (int8 *)((long)&local_12d8 - lVar5);
puVar7 = (int8 *)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
for (uVar4 = (ulong)((int)lVar5 + 0x12c4U >> 3); uVar4 != 0; uVar4 = uVar4 - 1) {
*puVar7 = *puVar6;
puVar6 = puVar6 + (ulong)bVar8 * -2 + 1;
puVar7 = puVar7 + (ulong)bVar8 * -2 + 1;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
6,137 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#define MAX_ENTRIES 100
#define MAX_VALUES 10
typedef struct {
int key;
int values[MAX_VALUES];
int count;
} map_entry;
typedef struct {
map_entry entries[MAX_ENTRIES];
int size;
} map;
int find_key(map* m, int key) {
for(int i = 0; i < m->size; i++) {
if(m->entries[i].key == key)
return i;
}
return -1;
}
| map func0(int test_keys[], int test_vals[], int n) {
map res;
res.size = 0;
for(int i = 0; i < n; i++) {
int key = test_keys[i];
int val = test_vals[i];
// setdefault(val, [])
if(find_key(&res, val) == -1){
res.entries[res.size].key = val;
res.entries[res.size].count = 0;
res.size++;
}
// setdefault(key, []).append(val)
int idx = find_key(&res, key);
if(idx == -1){
res.entries[res.size].key = key;
res.entries[res.size].count = 0;
idx = res.size;
res.size++;
}
if(res.entries[idx].count < MAX_VALUES){
res.entries[idx].values[res.entries[idx].count++] = val;
}
}
return res;
}
| int main(){
// First test case
int test1_keys[] = {5, 7, 2, 3, 8};
int test1_vals[] = {3, 5, 7, 8, 4};
int n1 = 5;
map result1 = func0(test1_keys, test1_vals, n1);
map expected1;
expected1.size = 6;
expected1.entries[0].key = 3; expected1.entries[0].count = 1; expected1.entries[0].values[0] = 8;
expected1.entries[1].key = 5; expected1.entries[1].count = 1; expected1.entries[1].values[0] = 3;
expected1.entries[2].key = 7; expected1.entries[2].count = 1; expected1.entries[2].values[0] = 5;
expected1.entries[3].key = 2; expected1.entries[3].count = 1; expected1.entries[3].values[0] = 7;
expected1.entries[4].key = 8; expected1.entries[4].count = 1; expected1.entries[4].values[0] = 4;
expected1.entries[5].key = 4; expected1.entries[5].count = 0;
assert(result1.size == expected1.size);
for(int i = 0; i < result1.size; i++){
int found = 0;
for(int j = 0; j < expected1.size; j++){
if(result1.entries[i].key == expected1.entries[j].key){
assert(result1.entries[i].count == expected1.entries[j].count);
for(int k = 0; k < result1.entries[i].count; k++){
assert(result1.entries[i].values[k] == expected1.entries[j].values[k]);
}
found = 1;
break;
}
}
assert(found);
}
// Second test case
int test2_keys[] = {6, 9, 3, 4, 9};
int test2_vals[] = {4, 4, 8, 9, 5};
int n2 = 5;
map result2 = func0(test2_keys, test2_vals, n2);
map expected2;
expected2.size = 6;
expected2.entries[0].key = 4; expected2.entries[0].count = 1; expected2.entries[0].values[0] = 9;
expected2.entries[1].key = 6; expected2.entries[1].count = 1; expected2.entries[1].values[0] = 4;
expected2.entries[2].key = 9; expected2.entries[2].count = 2; expected2.entries[2].values[0] = 4; expected2.entries[2].values[1] = 5;
expected2.entries[3].key = 8; expected2.entries[3].count = 0;
expected2.entries[4].key = 3; expected2.entries[4].count = 1; expected2.entries[4].values[0] = 8;
expected2.entries[5].key = 5; expected2.entries[5].count = 0;
assert(result2.size == expected2.size);
for(int i = 0; i < result2.size; i++){
int found = 0;
for(int j = 0; j < expected2.size; j++){
if(result2.entries[i].key == expected2.entries[j].key){
assert(result2.entries[i].count == expected2.entries[j].count);
for(int k = 0; k < result2.entries[i].count; k++){
assert(result2.entries[i].values[k] == expected2.entries[j].values[k]);
}
found = 1;
break;
}
}
assert(found);
}
// Third test case
int test3_keys[] = {6, 6, 4, 4, 3};
int test3_vals[] = {2, 8, 9, 9, 7};
int n3 = 5;
map result3 = func0(test3_keys, test3_vals, n3);
map expected3;
expected3.size = 7;
expected3.entries[0].key = 2; expected3.entries[0].count = 0;
expected3.entries[1].key = 6; expected3.entries[1].count = 2; expected3.entries[1].values[0] = 2; expected3.entries[1].values[1] = 8;
expected3.entries[2].key = 8; expected3.entries[2].count = 0;
expected3.entries[3].key = 9; expected3.entries[3].count = 0;
expected3.entries[4].key = 4; expected3.entries[4].count = 2; expected3.entries[4].values[0] = 9; expected3.entries[4].values[1] = 9;
expected3.entries[5].key = 7; expected3.entries[5].count = 0;
expected3.entries[6].key = 3; expected3.entries[6].count = 1; expected3.entries[6].values[0] = 7;
assert(result3.size == expected3.size);
for(int i = 0; i < result3.size; i++){
int found = 0;
for(int j = 0; j < expected3.size; j++){
if(result3.entries[i].key == expected3.entries[j].key){
assert(result3.entries[i].count == expected3.entries[j].count);
for(int k = 0; k < result3.entries[i].count; k++){
assert(result3.entries[i].values[k] == expected3.entries[j].values[k]);
}
found = 1;
break;
}
}
assert(found);
}
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x2e8,%rsp
mov %rdi,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x12d8(%rsp)
xor %eax,%eax
movl $0x0,0x12d0(%rsp)
test %ecx,%ecx
jle 12d4 <func0+0x13d>
mov %rsi,%r14
mov %rdx,%r15
lea -0x1(%rcx),%eax
mov %rax,(%rsp)
mov $0x0,%ebx
lea 0x10(%rsp),%r13
jmpq 128f <func0+0xf8>
mov 0x12d0(%rsp),%edx
movslq %edx,%rcx
lea (%rcx,%rcx,1),%rax
lea (%rax,%rcx,1),%rsi
shl $0x4,%rsi
mov %ebp,0x10(%rsp,%rsi,1)
movl $0x0,0x3c(%rsp,%rsi,1)
add $0x1,%edx
mov %edx,0x12d0(%rsp)
jmp 12aa <func0+0x113>
mov 0x12d0(%rsp),%eax
movslq %eax,%rcx
lea (%rcx,%rcx,1),%rdx
lea (%rdx,%rcx,1),%rsi
shl $0x4,%rsi
mov %r12d,0x10(%rsp,%rsi,1)
movl $0x0,0x3c(%rsp,%rsi,1)
lea 0x1(%rax),%edx
mov %edx,0x12d0(%rsp)
mov $0x0,%edx
cltq
lea (%rax,%rax,1),%rcx
lea (%rcx,%rax,1),%rsi
shl $0x4,%rsi
lea 0x1(%rdx),%edi
mov %edi,0x3c(%rsp,%rsi,1)
movslq %edx,%rdx
add %rcx,%rax
lea (%rdx,%rax,4),%rax
mov %ebp,0x14(%rsp,%rax,4)
lea 0x1(%rbx),%rax
cmp (%rsp),%rbx
je 12d4 <func0+0x13d>
mov %rax,%rbx
mov (%r14,%rbx,4),%r12d
mov (%r15,%rbx,4),%ebp
mov %ebp,%esi
mov %r13,%rdi
callq 1169 <find_key>
cmp $0xffffffff,%eax
je 11ff <func0+0x68>
mov %r12d,%esi
mov %r13,%rdi
callq 1169 <find_key>
cmp $0xffffffff,%eax
je 122d <func0+0x96>
movslq %eax,%rdx
lea (%rdx,%rdx,2),%rdx
shl $0x4,%rdx
mov 0x3c(%rsp,%rdx,1),%edx
cmp $0x9,%edx
jg 1282 <func0+0xeb>
jmp 125f <func0+0xc8>
lea 0x10(%rsp),%rsi
mov 0x10(%rsp),%rax
mov 0x8(%rsp),%rbx
mov %rax,(%rbx)
mov 0x12cc(%rsp),%rax
mov %rax,0x12bc(%rbx)
mov %rbx,%rax
lea 0x8(%rbx),%rdi
and $0xfffffffffffffff8,%rdi
sub %rdi,%rax
mov %rax,%rcx
sub %rax,%rsi
add $0x12c4,%ecx
shr $0x3,%ecx
mov %ecx,%ecx
rep movsq %ds:(%rsi),%es:(%rdi)
mov 0x12d8(%rsp),%rax
xor %fs:0x28,%rax
jne 1341 <func0+0x1aa>
mov 0x8(%rsp),%rax
add $0x12e8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1000h
or [rsp+1030h+var_1030], 0
sub rsp, 2E8h
mov [rsp+1318h+var_1310], rdi
mov rax, fs:28h
mov [rsp+1318h+var_40], rax
xor eax, eax
mov [rsp+1318h+var_48], 0
test ecx, ecx
jle loc_12D0
mov r14, rsi
mov r15, rdx
mov eax, ecx
mov [rsp+1318h+var_1318], rax
mov ebx, 0
lea r13, [rsp+1318h+var_1308]
jmp loc_128B
loc_11FE:
mov edx, [rsp+1318h+var_48]
movsxd rcx, edx
lea rax, [rcx+rcx]
lea rsi, [rax+rcx]
shl rsi, 4
mov dword ptr [rsp+rsi+1318h+var_1308], ebp
mov [rsp+rsi+1318h+var_12DC], 0
add edx, 1
mov [rsp+1318h+var_48], edx
jmp short loc_12A6
loc_122C:
mov eax, [rsp+1318h+var_48]
movsxd rcx, eax
lea rdx, [rcx+rcx]
lea rsi, [rdx+rcx]
shl rsi, 4
mov dword ptr [rsp+rsi+1318h+var_1308], r12d
mov [rsp+rsi+1318h+var_12DC], 0
lea edx, [rax+1]
mov [rsp+1318h+var_48], edx
mov edx, 0
loc_125E:
cdqe
lea rcx, [rax+rax]
lea rsi, [rcx+rax]
shl rsi, 4
lea edi, [rdx+1]
mov [rsp+rsi+1318h+var_12DC], edi
movsxd rdx, edx
add rcx, rax
lea rax, [rdx+rcx*4]
mov dword ptr [rsp+rax*4+1318h+var_1308+4], ebp
loc_1281:
add rbx, 1
cmp rbx, [rsp+1318h+var_1318]
jz short loc_12D0
loc_128B:
mov r12d, [r14+rbx*4]
mov ebp, [r15+rbx*4]
mov esi, ebp
mov rdi, r13
call find_key
cmp eax, 0FFFFFFFFh
jz loc_11FE
loc_12A6:
mov esi, r12d
mov rdi, r13
call find_key
cmp eax, 0FFFFFFFFh
jz loc_122C
movsxd rdx, eax
lea rdx, [rdx+rdx*2]
shl rdx, 4
mov edx, [rsp+rdx+1318h+var_12DC]
cmp edx, 9
jg short loc_1281
jmp short loc_125E
loc_12D0:
lea rsi, [rsp+1318h+var_1308]
mov rax, [rsp+1318h+var_1308]
mov rdi, [rsp+1318h+var_1310]
mov [rdi], rax
mov rax, [rsp+12CCh]
mov [rdi+12BCh], rax
mov rax, rdi
lea rdi, [rdi+8]
and rdi, 0FFFFFFFFFFFFFFF8h
sub rax, rdi
mov rcx, rax
sub rsi, rax
add ecx, 12C4h
shr ecx, 3
mov ecx, ecx
rep movsq
mov rax, [rsp+1318h+var_40]
sub rax, fs:28h
jnz short loc_133D
mov rax, [rsp+1318h+var_1310]
add rsp, 12E8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_133D:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, long long a2, long long a3, int a4)
{
long long i; // rbx
int v7; // edx
long long v8; // rsi
int key; // eax
long long v10; // rsi
int v11; // edx
unsigned int v12; // r12d
unsigned int v13; // ebp
long long v15; // [rsp+0h] [rbp-1318h]
_QWORD v16[91]; // [rsp+10h] [rbp-1308h] BYREF
long long v17; // [rsp+12CCh] [rbp-4Ch]
unsigned long long v18; // [rsp+12D8h] [rbp-40h]
v18 = __readfsqword(0x28u);
HIDWORD(v17) = 0;
if ( a4 > 0 )
{
v15 = (unsigned int)a4;
for ( i = 0LL; i != v15; ++i )
{
v12 = *(_DWORD *)(a2 + 4 * i);
v13 = *(_DWORD *)(a3 + 4 * i);
if ( (unsigned int)find_key(v16, v13) == -1 )
{
v7 = HIDWORD(v17);
v8 = 6LL * SHIDWORD(v17);
LODWORD(v16[v8]) = v13;
HIDWORD(v16[v8 + 5]) = 0;
HIDWORD(v17) = v7 + 1;
}
key = find_key(v16, v12);
if ( key == -1 )
{
key = HIDWORD(v17);
v10 = 6LL * SHIDWORD(v17);
LODWORD(v16[v10]) = v12;
HIDWORD(v16[v10 + 5]) = 0;
HIDWORD(v17) = key + 1;
v11 = 0;
}
else
{
v11 = HIDWORD(v16[6 * key + 5]);
if ( v11 > 9 )
continue;
}
HIDWORD(v16[6 * key + 5]) = v11 + 1;
*((_DWORD *)&v16[6 * key] + v11 + 1) = v13;
}
}
*a1 = v16[0];
*(_QWORD *)((char *)a1 + 4796) = v17;
qmemcpy(
(void *)((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL),
(const void *)((char *)v16 - ((char *)a1 - ((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL))),
8LL * (((unsigned int)a1 - (((_DWORD)a1 + 8) & 0xFFFFFFF8) + 4804) >> 3));
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x2e8
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x12d8],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x12d0],0x0
TEST ECX,ECX
JLE 0x001012d0
MOV R14,RSI
MOV R15,RDX
MOV EAX,ECX
MOV qword ptr [RSP],RAX
MOV EBX,0x0
LEA R13,[RSP + 0x10]
JMP 0x0010128b
LAB_001011fe:
MOV EDX,dword ptr [RSP + 0x12d0]
MOVSXD RCX,EDX
LEA RAX,[RCX + RCX*0x1]
LEA RSI,[RAX + RCX*0x1]
SHL RSI,0x4
MOV dword ptr [RSP + RSI*0x1 + 0x10],EBP
MOV dword ptr [RSP + RSI*0x1 + 0x3c],0x0
ADD EDX,0x1
MOV dword ptr [RSP + 0x12d0],EDX
JMP 0x001012a6
LAB_0010122c:
MOV EAX,dword ptr [RSP + 0x12d0]
MOVSXD RCX,EAX
LEA RDX,[RCX + RCX*0x1]
LEA RSI,[RDX + RCX*0x1]
SHL RSI,0x4
MOV dword ptr [RSP + RSI*0x1 + 0x10],R12D
MOV dword ptr [RSP + RSI*0x1 + 0x3c],0x0
LEA EDX,[RAX + 0x1]
MOV dword ptr [RSP + 0x12d0],EDX
MOV EDX,0x0
LAB_0010125e:
CDQE
LEA RCX,[RAX + RAX*0x1]
LEA RSI,[RCX + RAX*0x1]
SHL RSI,0x4
LEA EDI,[RDX + 0x1]
MOV dword ptr [RSP + RSI*0x1 + 0x3c],EDI
MOVSXD RDX,EDX
ADD RCX,RAX
LEA RAX,[RDX + RCX*0x4]
MOV dword ptr [RSP + RAX*0x4 + 0x14],EBP
LAB_00101281:
ADD RBX,0x1
CMP RBX,qword ptr [RSP]
JZ 0x001012d0
LAB_0010128b:
MOV R12D,dword ptr [R14 + RBX*0x4]
MOV EBP,dword ptr [R15 + RBX*0x4]
MOV ESI,EBP
MOV RDI,R13
CALL 0x00101169
CMP EAX,-0x1
JZ 0x001011fe
LAB_001012a6:
MOV ESI,R12D
MOV RDI,R13
CALL 0x00101169
CMP EAX,-0x1
JZ 0x0010122c
MOVSXD RDX,EAX
LEA RDX,[RDX + RDX*0x2]
SHL RDX,0x4
MOV EDX,dword ptr [RSP + RDX*0x1 + 0x3c]
CMP EDX,0x9
JG 0x00101281
JMP 0x0010125e
LAB_001012d0:
LEA RSI,[RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSP + 0x12cc]
MOV qword ptr [RDI + 0x12bc],RAX
MOV RAX,RDI
LEA RDI,[RDI + 0x8]
AND RDI,-0x8
SUB RAX,RDI
MOV RCX,RAX
SUB RSI,RAX
ADD ECX,0x12c4
SHR ECX,0x3
MOV ECX,ECX
MOVSQ.REP RDI,RSI
MOV RAX,qword ptr [RSP + 0x12d8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010133d
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x12e8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010133d:
CALL 0x00101060 | int8 * func0(int8 *param_1,long param_2,long param_3,uint param_4)
{
int4 uVar1;
int4 uVar2;
int iVar3;
long lVar4;
int iVar5;
ulong uVar6;
int8 *puVar7;
int8 *puVar8;
long in_FS_OFFSET;
byte bVar9;
int8 local_1308;
int aiStack_12dc [1188];
int4 local_4c;
int iStack_48;
long local_40;
bVar9 = 0;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
iStack_48 = 0;
if (0 < (int)param_4) {
uVar6 = 0;
do {
uVar1 = *(int4 *)(param_2 + uVar6 * 4);
uVar2 = *(int4 *)(param_3 + uVar6 * 4);
iVar3 = find_key(&local_1308,uVar2);
if (iVar3 == -1) {
*(int4 *)(&local_1308 + (long)iStack_48 * 6) = uVar2;
aiStack_12dc[(long)iStack_48 * 0xc] = 0;
iStack_48 = iStack_48 + 1;
}
iVar3 = find_key(&local_1308,uVar1);
if (iVar3 == -1) {
*(int4 *)(&local_1308 + (long)iStack_48 * 6) = uVar1;
aiStack_12dc[(long)iStack_48 * 0xc] = 0;
iVar5 = 0;
iVar3 = iStack_48;
iStack_48 = iStack_48 + 1;
LAB_0010125e:
aiStack_12dc[(long)iVar3 * 0xc] = iVar5 + 1;
*(int4 *)((long)&local_1308 + (long)iVar5 * 4 + (long)iVar3 * 0x30 + 4) = uVar2;
}
else {
iVar5 = aiStack_12dc[(long)iVar3 * 0xc];
if (iVar5 < 10) goto LAB_0010125e;
}
uVar6 = uVar6 + 1;
} while (uVar6 != param_4);
}
*param_1 = local_1308;
*(ulong *)((long)param_1 + 0x12bc) = CONCAT44(iStack_48,local_4c);
lVar4 = (long)param_1 - (long)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
puVar7 = (int8 *)((long)&local_1308 - lVar4);
puVar8 = (int8 *)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
for (uVar6 = (ulong)((int)lVar4 + 0x12c4U >> 3); uVar6 != 0; uVar6 = uVar6 - 1) {
*puVar8 = *puVar7;
puVar7 = puVar7 + (ulong)bVar9 * -2 + 1;
puVar8 = puVar8 + (ulong)bVar9 * -2 + 1;
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
6,138 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#define MAX_ENTRIES 100
#define MAX_VALUES 10
typedef struct {
int key;
int values[MAX_VALUES];
int count;
} map_entry;
typedef struct {
map_entry entries[MAX_ENTRIES];
int size;
} map;
int find_key(map* m, int key) {
for(int i = 0; i < m->size; i++) {
if(m->entries[i].key == key)
return i;
}
return -1;
}
| map func0(int test_keys[], int test_vals[], int n) {
map res;
res.size = 0;
for(int i = 0; i < n; i++) {
int key = test_keys[i];
int val = test_vals[i];
// setdefault(val, [])
if(find_key(&res, val) == -1){
res.entries[res.size].key = val;
res.entries[res.size].count = 0;
res.size++;
}
// setdefault(key, []).append(val)
int idx = find_key(&res, key);
if(idx == -1){
res.entries[res.size].key = key;
res.entries[res.size].count = 0;
idx = res.size;
res.size++;
}
if(res.entries[idx].count < MAX_VALUES){
res.entries[idx].values[res.entries[idx].count++] = val;
}
}
return res;
}
| int main(){
// First test case
int test1_keys[] = {5, 7, 2, 3, 8};
int test1_vals[] = {3, 5, 7, 8, 4};
int n1 = 5;
map result1 = func0(test1_keys, test1_vals, n1);
map expected1;
expected1.size = 6;
expected1.entries[0].key = 3; expected1.entries[0].count = 1; expected1.entries[0].values[0] = 8;
expected1.entries[1].key = 5; expected1.entries[1].count = 1; expected1.entries[1].values[0] = 3;
expected1.entries[2].key = 7; expected1.entries[2].count = 1; expected1.entries[2].values[0] = 5;
expected1.entries[3].key = 2; expected1.entries[3].count = 1; expected1.entries[3].values[0] = 7;
expected1.entries[4].key = 8; expected1.entries[4].count = 1; expected1.entries[4].values[0] = 4;
expected1.entries[5].key = 4; expected1.entries[5].count = 0;
assert(result1.size == expected1.size);
for(int i = 0; i < result1.size; i++){
int found = 0;
for(int j = 0; j < expected1.size; j++){
if(result1.entries[i].key == expected1.entries[j].key){
assert(result1.entries[i].count == expected1.entries[j].count);
for(int k = 0; k < result1.entries[i].count; k++){
assert(result1.entries[i].values[k] == expected1.entries[j].values[k]);
}
found = 1;
break;
}
}
assert(found);
}
// Second test case
int test2_keys[] = {6, 9, 3, 4, 9};
int test2_vals[] = {4, 4, 8, 9, 5};
int n2 = 5;
map result2 = func0(test2_keys, test2_vals, n2);
map expected2;
expected2.size = 6;
expected2.entries[0].key = 4; expected2.entries[0].count = 1; expected2.entries[0].values[0] = 9;
expected2.entries[1].key = 6; expected2.entries[1].count = 1; expected2.entries[1].values[0] = 4;
expected2.entries[2].key = 9; expected2.entries[2].count = 2; expected2.entries[2].values[0] = 4; expected2.entries[2].values[1] = 5;
expected2.entries[3].key = 8; expected2.entries[3].count = 0;
expected2.entries[4].key = 3; expected2.entries[4].count = 1; expected2.entries[4].values[0] = 8;
expected2.entries[5].key = 5; expected2.entries[5].count = 0;
assert(result2.size == expected2.size);
for(int i = 0; i < result2.size; i++){
int found = 0;
for(int j = 0; j < expected2.size; j++){
if(result2.entries[i].key == expected2.entries[j].key){
assert(result2.entries[i].count == expected2.entries[j].count);
for(int k = 0; k < result2.entries[i].count; k++){
assert(result2.entries[i].values[k] == expected2.entries[j].values[k]);
}
found = 1;
break;
}
}
assert(found);
}
// Third test case
int test3_keys[] = {6, 6, 4, 4, 3};
int test3_vals[] = {2, 8, 9, 9, 7};
int n3 = 5;
map result3 = func0(test3_keys, test3_vals, n3);
map expected3;
expected3.size = 7;
expected3.entries[0].key = 2; expected3.entries[0].count = 0;
expected3.entries[1].key = 6; expected3.entries[1].count = 2; expected3.entries[1].values[0] = 2; expected3.entries[1].values[1] = 8;
expected3.entries[2].key = 8; expected3.entries[2].count = 0;
expected3.entries[3].key = 9; expected3.entries[3].count = 0;
expected3.entries[4].key = 4; expected3.entries[4].count = 2; expected3.entries[4].values[0] = 9; expected3.entries[4].values[1] = 9;
expected3.entries[5].key = 7; expected3.entries[5].count = 0;
expected3.entries[6].key = 3; expected3.entries[6].count = 1; expected3.entries[6].values[0] = 7;
assert(result3.size == expected3.size);
for(int i = 0; i < result3.size; i++){
int found = 0;
for(int j = 0; j < expected3.size; j++){
if(result3.entries[i].key == expected3.entries[j].key){
assert(result3.entries[i].count == expected3.entries[j].count);
for(int k = 0; k < result3.entries[i].count; k++){
assert(result3.entries[i].values[k] == expected3.entries[j].values[k]);
}
found = 1;
break;
}
}
assert(found);
}
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x2d8,%rsp
mov %fs:0x28,%rax
mov %rax,0x12c8(%rsp)
xor %eax,%eax
mov %rdi,%r10
test %ecx,%ecx
jle 19e4 <func0+0x194>
mov %rsi,%r11
xor %r9d,%r9d
xor %edi,%edi
mov %rsp,%rsi
mov (%r11,%r9,4),%r12d
mov (%rdx,%r9,4),%r8d
lea -0x1(%rcx),%ebx
lea 0x30(%rsp),%rbp
test %edi,%edi
je 1920 <func0+0xd0>
nopw 0x0(%rax,%rax,1)
lea -0x1(%rdi),%ecx
mov %rsi,%rax
lea (%rcx,%rcx,2),%rcx
shl $0x4,%rcx
add %rbp,%rcx
jmp 18d1 <func0+0x81>
nopl 0x0(%rax,%rax,1)
add $0x30,%rax
cmp %rcx,%rax
je 1920 <func0+0xd0>
cmp (%rax),%r8d
jne 18c8 <func0+0x78>
mov %rsi,%rcx
xor %eax,%eax
jmp 18eb <func0+0x9b>
nopl (%rax)
add $0x1,%eax
add $0x30,%rcx
cmp %edi,%eax
jge 1940 <func0+0xf0>
cmp (%rcx),%r12d
jne 18e0 <func0+0x90>
cltq
lea (%rax,%rax,2),%rcx
shl $0x4,%rcx
movslq 0x2c(%rsp,%rcx,1),%rcx
cmp $0x9,%ecx
jle 195f <func0+0x10f>
lea 0x1(%r9),%rax
cmp %rbx,%r9
je 1985 <func0+0x135>
mov %rax,%r9
mov (%r11,%r9,4),%r12d
mov (%rdx,%r9,4),%r8d
test %edi,%edi
jne 18b0 <func0+0x60>
nopl 0x0(%rax)
movslq %edi,%rax
add $0x1,%edi
lea (%rax,%rax,2),%rax
shl $0x4,%rax
mov %r8d,(%rsp,%rax,1)
movl $0x0,0x2c(%rsp,%rax,1)
jmp 18d6 <func0+0x86>
nopl 0x0(%rax)
movslq %edi,%rax
xor %ecx,%ecx
lea (%rax,%rax,2),%rax
shl $0x4,%rax
mov %r12d,(%rsp,%rax,1)
movl $0x0,0x2c(%rsp,%rax,1)
movslq %edi,%rax
add $0x1,%edi
lea (%rax,%rax,2),%rax
lea 0x1(%rcx),%r13d
mov %rax,%r12
lea (%rcx,%rax,4),%rax
shl $0x4,%r12
mov %r8d,0x4(%rsp,%rax,4)
lea 0x1(%r9),%rax
mov %r13d,0x2c(%rsp,%r12,1)
cmp %rbx,%r9
jne 190d <func0+0xbd>
mov (%rsp),%rax
mov %edi,0x12c0(%rsp)
lea 0x8(%r10),%rdi
and $0xfffffffffffffff8,%rdi
mov %rax,(%r10)
mov 0x12bc(%rsp),%rax
mov %rax,0x12bc(%r10)
mov %r10,%rax
sub %rdi,%rax
sub %rax,%rsi
add $0x12c4,%eax
shr $0x3,%eax
mov %eax,%ecx
rep movsq %ds:(%rsi),%es:(%rdi)
mov 0x12c8(%rsp),%rax
xor %fs:0x28,%rax
jne 19eb <func0+0x19b>
add $0x12d8,%rsp
mov %r10,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xor %edi,%edi
mov %rsp,%rsi
jmp 1985 <func0+0x135>
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 1000h
or [rsp+1020h+var_1020], 0
sub rsp, 2D8h
mov rax, fs:28h
mov [rsp+12F8h+var_30], rax
xor eax, eax
mov r9, rdi
test ecx, ecx
jle loc_19FE
mov r11, rsi
movsxd r10, ecx
mov rbx, rdx
xor r8d, r8d
xor ecx, ecx
mov rsi, rsp
lea rbp, [rsp+12F8h+var_12C8]
nop dword ptr [rax+00000000h]
loc_18A8:
mov r12d, [r11+r8*4]
mov edi, [rbx+r8*4]
test ecx, ecx
jz loc_1990
lea edx, [rcx-1]
mov rax, rsi
lea rdx, [rdx+rdx*2]
shl rdx, 4
add rdx, rbp
jmp short loc_18DD
loc_18D0:
add rax, 30h ; '0'
cmp rax, rdx
jz loc_1990
loc_18DD:
cmp edi, [rax]
jnz short loc_18D0
loc_18E1:
mov rdx, rsi
xor eax, eax
jmp short loc_18FF
loc_18F0:
add eax, 1
add rdx, 30h ; '0'
cmp eax, ecx
jge loc_19B0
loc_18FF:
cmp r12d, [rdx]
jnz short loc_18F0
cdqe
lea rdx, [rax+rax*2]
shl rdx, 4
movsxd rdx, [rsp+rdx+12F8h+var_12CC]
cmp edx, 9
jle loc_19F8
loc_191C:
add r8, 1
cmp r8, r10
jnz short loc_18A8
loc_1925:
mov rax, [rsp+12F8h+var_12F8]
mov [rsp+12F8h+var_38], ecx
lea rdi, [r9+8]
and rdi, 0FFFFFFFFFFFFFFF8h
mov [r9], rax
mov rax, [rsp+12BCh]
mov [r9+12BCh], rax
mov rax, r9
sub rax, rdi
sub rsi, rax
add eax, 12C4h
shr eax, 3
mov ecx, eax
rep movsq
mov rax, [rsp+12F8h+var_30]
sub rax, fs:28h
jnz loc_1A08
add rsp, 12D8h
mov rax, r9
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1990:
movsxd rax, ecx
add ecx, 1
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rsp+rax+12F8h+var_12F8], edi
mov [rsp+rax+12F8h+var_12CC], 0
jmp loc_18E1
loc_19B0:
movsxd rax, ecx
xor edx, edx
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rsp+rax+12F8h+var_12F8], r12d
mov r12d, 1
mov [rsp+rax+12F8h+var_12CC], 0
movsxd rax, ecx
add ecx, 1
loc_19D5:
lea rax, [rax+rax*2]
mov r13, rax
lea rax, [rdx+rax*4]
shl r13, 4
mov dword ptr [rsp+rax*4+12F8h+var_12F8+4], edi
mov [rsp+r13+12F8h+var_12CC], r12d
jmp loc_191C
loc_19F8:
lea r12d, [rdx+1]
jmp short loc_19D5
loc_19FE:
xor ecx, ecx
mov rsi, rsp
jmp loc_1925
loc_1A08:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, long long a2, long long a3, int a4)
{
long long v5; // r10
long long v7; // r8
int v8; // ecx
int v9; // r12d
int v10; // edi
_QWORD *v11; // rax
_DWORD *v12; // rdx
long long v13; // rax
long long v14; // rdx
long long v16; // rax
long long v17; // rax
int v18; // r12d
_QWORD v19[91]; // [rsp+0h] [rbp-12F8h] BYREF
long long v20; // [rsp+12BCh] [rbp-3Ch]
unsigned long long v21; // [rsp+12C8h] [rbp-30h]
v21 = __readfsqword(0x28u);
if ( a4 <= 0 )
{
v8 = 0;
}
else
{
v5 = a4;
v7 = 0LL;
v8 = 0;
do
{
v9 = *(_DWORD *)(a2 + 4 * v7);
v10 = *(_DWORD *)(a3 + 4 * v7);
if ( v8 )
{
v11 = v19;
while ( v10 != *(_DWORD *)v11 )
{
v11 += 6;
if ( v11 == &v19[6 * (unsigned int)(v8 - 1) + 6] )
goto LABEL_13;
}
}
else
{
LABEL_13:
v16 = v8++;
v16 *= 48LL;
*(_DWORD *)((char *)v19 + v16) = v10;
*(_DWORD *)((char *)&v19[5] + v16 + 4) = 0;
}
v12 = v19;
LODWORD(v13) = 0;
while ( v9 != *v12 )
{
LODWORD(v13) = v13 + 1;
v12 += 12;
if ( (int)v13 >= v8 )
{
v14 = 0LL;
v17 = 6LL * v8;
LODWORD(v19[v17]) = v9;
v18 = 1;
HIDWORD(v19[v17 + 5]) = 0;
v13 = v8++;
goto LABEL_15;
}
}
v13 = (int)v13;
v14 = SHIDWORD(v19[6 * (int)v13 + 5]);
if ( (int)v14 > 9 )
goto LABEL_11;
v18 = v14 + 1;
LABEL_15:
*((_DWORD *)&v19[6 * v13] + v14 + 1) = v10;
HIDWORD(v19[6 * v13 + 5]) = v18;
LABEL_11:
++v7;
}
while ( v7 != v5 );
}
HIDWORD(v20) = v8;
*a1 = v19[0];
*(_QWORD *)((char *)a1 + 4796) = v20;
qmemcpy(
(void *)((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL),
(const void *)((char *)v19 - ((char *)a1 - ((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL))),
8LL * (((unsigned int)a1 - (((_DWORD)a1 + 8) & 0xFFFFFFF8) + 4804) >> 3));
return a1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x2d8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x12c8],RAX
XOR EAX,EAX
MOV R9,RDI
TEST ECX,ECX
JLE 0x001019fe
MOV R11,RSI
MOVSXD R10,ECX
MOV RBX,RDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RSP
LEA RBP,[RSP + 0x30]
NOP dword ptr [RAX]
LAB_001018a8:
MOV R12D,dword ptr [R11 + R8*0x4]
MOV EDI,dword ptr [RBX + R8*0x4]
TEST ECX,ECX
JZ 0x00101990
LEA EDX,[RCX + -0x1]
MOV RAX,RSI
LEA RDX,[RDX + RDX*0x2]
SHL RDX,0x4
ADD RDX,RBP
JMP 0x001018dd
LAB_001018d0:
ADD RAX,0x30
CMP RAX,RDX
JZ 0x00101990
LAB_001018dd:
CMP EDI,dword ptr [RAX]
JNZ 0x001018d0
LAB_001018e1:
MOV RDX,RSI
XOR EAX,EAX
JMP 0x001018ff
LAB_001018f0:
ADD EAX,0x1
ADD RDX,0x30
CMP EAX,ECX
JGE 0x001019b0
LAB_001018ff:
CMP R12D,dword ptr [RDX]
JNZ 0x001018f0
CDQE
LEA RDX,[RAX + RAX*0x2]
SHL RDX,0x4
MOVSXD RDX,dword ptr [RSP + RDX*0x1 + 0x2c]
CMP EDX,0x9
JLE 0x001019f8
LAB_0010191c:
ADD R8,0x1
CMP R8,R10
JNZ 0x001018a8
LAB_00101925:
MOV RAX,qword ptr [RSP]
MOV dword ptr [RSP + 0x12c0],ECX
LEA RDI,[R9 + 0x8]
AND RDI,-0x8
MOV qword ptr [R9],RAX
MOV RAX,qword ptr [RSP + 0x12bc]
MOV qword ptr [R9 + 0x12bc],RAX
MOV RAX,R9
SUB RAX,RDI
SUB RSI,RAX
ADD EAX,0x12c4
SHR EAX,0x3
MOV ECX,EAX
MOVSQ.REP RDI,RSI
MOV RAX,qword ptr [RSP + 0x12c8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101a08
ADD RSP,0x12d8
MOV RAX,R9
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101990:
MOVSXD RAX,ECX
ADD ECX,0x1
LEA RAX,[RAX + RAX*0x2]
SHL RAX,0x4
MOV dword ptr [RSP + RAX*0x1],EDI
MOV dword ptr [RSP + RAX*0x1 + 0x2c],0x0
JMP 0x001018e1
LAB_001019b0:
MOVSXD RAX,ECX
XOR EDX,EDX
LEA RAX,[RAX + RAX*0x2]
SHL RAX,0x4
MOV dword ptr [RSP + RAX*0x1],R12D
MOV R12D,0x1
MOV dword ptr [RSP + RAX*0x1 + 0x2c],0x0
MOVSXD RAX,ECX
ADD ECX,0x1
LAB_001019d5:
LEA RAX,[RAX + RAX*0x2]
MOV R13,RAX
LEA RAX,[RDX + RAX*0x4]
SHL R13,0x4
MOV dword ptr [RSP + RAX*0x4 + 0x4],EDI
MOV dword ptr [RSP + R13*0x1 + 0x2c],R12D
JMP 0x0010191c
LAB_001019f8:
LEA R12D,[RDX + 0x1]
JMP 0x001019d5
LAB_001019fe:
XOR ECX,ECX
MOV RSI,RSP
JMP 0x00101925
LAB_00101a08:
CALL 0x00101060 | int8 * func0(int8 *param_1,long param_2,long param_3,int param_4)
{
int iVar1;
int iVar2;
int *piVar3;
long lVar4;
ulong uVar5;
long lVar6;
int8 *puVar7;
int8 *puVar8;
long lVar9;
int iVar10;
long in_FS_OFFSET;
int8 local_12f8;
int aiStack_12cc [1188];
int4 local_3c;
int iStack_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_4 < 1) {
iStack_38 = 0;
}
else {
lVar9 = 0;
iStack_38 = 0;
do {
iVar10 = *(int *)(param_2 + lVar9 * 4);
iVar1 = *(int *)(param_3 + lVar9 * 4);
if (iStack_38 != 0) {
piVar3 = (int *)&local_12f8;
do {
if (iVar1 == *piVar3) goto LAB_001018e1;
piVar3 = piVar3 + 0xc;
} while (piVar3 != aiStack_12cc + (ulong)(iStack_38 - 1) * 0xc + 1);
}
lVar4 = (long)iStack_38;
iStack_38 = iStack_38 + 1;
*(int *)(&local_12f8 + lVar4 * 6) = iVar1;
aiStack_12cc[lVar4 * 0xc] = 0;
LAB_001018e1:
iVar2 = 0;
piVar3 = (int *)&local_12f8;
do {
if (iVar10 == *piVar3) {
lVar4 = (long)iVar2;
iVar10 = aiStack_12cc[lVar4 * 0xc];
lVar6 = (long)iVar10;
if (9 < iVar10) goto LAB_0010191c;
iVar10 = iVar10 + 1;
goto LAB_001019d5;
}
iVar2 = iVar2 + 1;
piVar3 = piVar3 + 0xc;
} while (iVar2 < iStack_38);
lVar6 = 0;
*(int *)(&local_12f8 + (long)iStack_38 * 6) = iVar10;
iVar10 = 1;
aiStack_12cc[(long)iStack_38 * 0xc] = 0;
lVar4 = (long)iStack_38;
iStack_38 = iStack_38 + 1;
LAB_001019d5:
*(int *)((long)&local_12f8 + (lVar6 + lVar4 * 0xc) * 4 + 4) = iVar1;
aiStack_12cc[lVar4 * 0xc] = iVar10;
LAB_0010191c:
lVar9 = lVar9 + 1;
} while (lVar9 != param_4);
}
*param_1 = local_12f8;
*(ulong *)((long)param_1 + 0x12bc) = CONCAT44(iStack_38,local_3c);
lVar9 = (long)param_1 - (long)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
puVar7 = (int8 *)((long)&local_12f8 - lVar9);
puVar8 = (int8 *)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
for (uVar5 = (ulong)((int)lVar9 + 0x12c4U >> 3); uVar5 != 0; uVar5 = uVar5 - 1) {
*puVar8 = *puVar7;
puVar7 = puVar7 + 1;
puVar8 = puVar8 + 1;
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,139 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#define MAX_ENTRIES 100
#define MAX_VALUES 10
typedef struct {
int key;
int values[MAX_VALUES];
int count;
} map_entry;
typedef struct {
map_entry entries[MAX_ENTRIES];
int size;
} map;
int find_key(map* m, int key) {
for(int i = 0; i < m->size; i++) {
if(m->entries[i].key == key)
return i;
}
return -1;
}
| map func0(int test_keys[], int test_vals[], int n) {
map res;
res.size = 0;
for(int i = 0; i < n; i++) {
int key = test_keys[i];
int val = test_vals[i];
// setdefault(val, [])
if(find_key(&res, val) == -1){
res.entries[res.size].key = val;
res.entries[res.size].count = 0;
res.size++;
}
// setdefault(key, []).append(val)
int idx = find_key(&res, key);
if(idx == -1){
res.entries[res.size].key = key;
res.entries[res.size].count = 0;
idx = res.size;
res.size++;
}
if(res.entries[idx].count < MAX_VALUES){
res.entries[idx].values[res.entries[idx].count++] = val;
}
}
return res;
}
| int main(){
// First test case
int test1_keys[] = {5, 7, 2, 3, 8};
int test1_vals[] = {3, 5, 7, 8, 4};
int n1 = 5;
map result1 = func0(test1_keys, test1_vals, n1);
map expected1;
expected1.size = 6;
expected1.entries[0].key = 3; expected1.entries[0].count = 1; expected1.entries[0].values[0] = 8;
expected1.entries[1].key = 5; expected1.entries[1].count = 1; expected1.entries[1].values[0] = 3;
expected1.entries[2].key = 7; expected1.entries[2].count = 1; expected1.entries[2].values[0] = 5;
expected1.entries[3].key = 2; expected1.entries[3].count = 1; expected1.entries[3].values[0] = 7;
expected1.entries[4].key = 8; expected1.entries[4].count = 1; expected1.entries[4].values[0] = 4;
expected1.entries[5].key = 4; expected1.entries[5].count = 0;
assert(result1.size == expected1.size);
for(int i = 0; i < result1.size; i++){
int found = 0;
for(int j = 0; j < expected1.size; j++){
if(result1.entries[i].key == expected1.entries[j].key){
assert(result1.entries[i].count == expected1.entries[j].count);
for(int k = 0; k < result1.entries[i].count; k++){
assert(result1.entries[i].values[k] == expected1.entries[j].values[k]);
}
found = 1;
break;
}
}
assert(found);
}
// Second test case
int test2_keys[] = {6, 9, 3, 4, 9};
int test2_vals[] = {4, 4, 8, 9, 5};
int n2 = 5;
map result2 = func0(test2_keys, test2_vals, n2);
map expected2;
expected2.size = 6;
expected2.entries[0].key = 4; expected2.entries[0].count = 1; expected2.entries[0].values[0] = 9;
expected2.entries[1].key = 6; expected2.entries[1].count = 1; expected2.entries[1].values[0] = 4;
expected2.entries[2].key = 9; expected2.entries[2].count = 2; expected2.entries[2].values[0] = 4; expected2.entries[2].values[1] = 5;
expected2.entries[3].key = 8; expected2.entries[3].count = 0;
expected2.entries[4].key = 3; expected2.entries[4].count = 1; expected2.entries[4].values[0] = 8;
expected2.entries[5].key = 5; expected2.entries[5].count = 0;
assert(result2.size == expected2.size);
for(int i = 0; i < result2.size; i++){
int found = 0;
for(int j = 0; j < expected2.size; j++){
if(result2.entries[i].key == expected2.entries[j].key){
assert(result2.entries[i].count == expected2.entries[j].count);
for(int k = 0; k < result2.entries[i].count; k++){
assert(result2.entries[i].values[k] == expected2.entries[j].values[k]);
}
found = 1;
break;
}
}
assert(found);
}
// Third test case
int test3_keys[] = {6, 6, 4, 4, 3};
int test3_vals[] = {2, 8, 9, 9, 7};
int n3 = 5;
map result3 = func0(test3_keys, test3_vals, n3);
map expected3;
expected3.size = 7;
expected3.entries[0].key = 2; expected3.entries[0].count = 0;
expected3.entries[1].key = 6; expected3.entries[1].count = 2; expected3.entries[1].values[0] = 2; expected3.entries[1].values[1] = 8;
expected3.entries[2].key = 8; expected3.entries[2].count = 0;
expected3.entries[3].key = 9; expected3.entries[3].count = 0;
expected3.entries[4].key = 4; expected3.entries[4].count = 2; expected3.entries[4].values[0] = 9; expected3.entries[4].values[1] = 9;
expected3.entries[5].key = 7; expected3.entries[5].count = 0;
expected3.entries[6].key = 3; expected3.entries[6].count = 1; expected3.entries[6].values[0] = 7;
assert(result3.size == expected3.size);
for(int i = 0; i < result3.size; i++){
int found = 0;
for(int j = 0; j < expected3.size; j++){
if(result3.entries[i].key == expected3.entries[j].key){
assert(result3.entries[i].count == expected3.entries[j].count);
for(int k = 0; k < result3.entries[i].count; k++){
assert(result3.entries[i].values[k] == expected3.entries[j].values[k]);
}
found = 1;
break;
}
}
assert(found);
}
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x2d8,%rsp
mov %fs:0x28,%rax
mov %rax,0x12c8(%rsp)
xor %eax,%eax
mov %rdi,%r10
test %ecx,%ecx
jle 1c94 <func0+0x194>
mov %rsi,%r11
xor %r9d,%r9d
xor %edi,%edi
mov %rsp,%rsi
mov (%r11,%r9,4),%r12d
mov (%rdx,%r9,4),%r8d
lea -0x1(%rcx),%ebx
lea 0x30(%rsp),%rbp
test %edi,%edi
je 1bd0 <func0+0xd0>
nopw 0x0(%rax,%rax,1)
lea -0x1(%rdi),%ecx
mov %rsi,%rax
lea (%rcx,%rcx,2),%rcx
shl $0x4,%rcx
add %rbp,%rcx
jmp 1b81 <func0+0x81>
nopl 0x0(%rax,%rax,1)
add $0x30,%rax
cmp %rcx,%rax
je 1bd0 <func0+0xd0>
cmp (%rax),%r8d
jne 1b78 <func0+0x78>
mov %rsi,%rcx
xor %eax,%eax
jmp 1b9b <func0+0x9b>
nopl (%rax)
add $0x1,%eax
add $0x30,%rcx
cmp %edi,%eax
jge 1bf0 <func0+0xf0>
cmp (%rcx),%r12d
jne 1b90 <func0+0x90>
cltq
lea (%rax,%rax,2),%rcx
shl $0x4,%rcx
movslq 0x2c(%rsp,%rcx,1),%rcx
cmp $0x9,%ecx
jle 1c0f <func0+0x10f>
lea 0x1(%r9),%rax
cmp %rbx,%r9
je 1c35 <func0+0x135>
mov %rax,%r9
mov (%r11,%r9,4),%r12d
mov (%rdx,%r9,4),%r8d
test %edi,%edi
jne 1b60 <func0+0x60>
nopl 0x0(%rax)
movslq %edi,%rax
add $0x1,%edi
lea (%rax,%rax,2),%rax
shl $0x4,%rax
mov %r8d,(%rsp,%rax,1)
movl $0x0,0x2c(%rsp,%rax,1)
jmp 1b86 <func0+0x86>
nopl 0x0(%rax)
movslq %edi,%rax
xor %ecx,%ecx
lea (%rax,%rax,2),%rax
shl $0x4,%rax
mov %r12d,(%rsp,%rax,1)
movl $0x0,0x2c(%rsp,%rax,1)
movslq %edi,%rax
add $0x1,%edi
lea (%rax,%rax,2),%rax
lea 0x1(%rcx),%r13d
mov %rax,%r12
lea (%rcx,%rax,4),%rax
shl $0x4,%r12
mov %r8d,0x4(%rsp,%rax,4)
lea 0x1(%r9),%rax
mov %r13d,0x2c(%rsp,%r12,1)
cmp %rbx,%r9
jne 1bbd <func0+0xbd>
mov (%rsp),%rax
mov %edi,0x12c0(%rsp)
lea 0x8(%r10),%rdi
and $0xfffffffffffffff8,%rdi
mov %rax,(%r10)
mov 0x12bc(%rsp),%rax
mov %rax,0x12bc(%r10)
mov %r10,%rax
sub %rdi,%rax
sub %rax,%rsi
add $0x12c4,%eax
shr $0x3,%eax
mov %eax,%ecx
rep movsq %ds:(%rsi),%es:(%rdi)
mov 0x12c8(%rsp),%rax
xor %fs:0x28,%rax
jne 1c9b <func0+0x19b>
add $0x12d8,%rsp
mov %r10,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xor %edi,%edi
mov %rsp,%rsi
jmp 1c35 <func0+0x135>
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 1000h
or [rsp+1018h+var_1018], 0
sub rsp, 2D0h
mov rax, fs:28h
mov [rsp+12E8h+var_20], rax
xor eax, eax
mov r10, rdi
test ecx, ecx
jle loc_1C69
movsxd rcx, ecx
mov r11, rsi
mov rbx, rdx
xor r9d, r9d
lea rbp, ds:0[rcx*4]
mov rsi, rsp
xor ecx, ecx
nop word ptr [rax+rax+00h]
loc_1AF8:
mov r8d, [r11+r9]
mov edi, [rbx+r9]
test ecx, ecx
jle loc_1B90
loc_1B08:
mov rax, rsi
xor edx, edx
jmp short loc_1B1B
loc_1B10:
add edx, 1
add rax, 30h ; '0'
cmp edx, ecx
jz short loc_1B70
loc_1B1B:
cmp [rax], edi
jnz short loc_1B10
loc_1B1F:
mov rdx, rsi
xor eax, eax
jmp short loc_1B3B
loc_1B30:
add eax, 1
add rdx, 30h ; '0'
cmp eax, ecx
jz short loc_1BB8
loc_1B3B:
cmp [rdx], r8d
jnz short loc_1B30
cdqe
lea rdx, [rax+rax*2]
shl rdx, 4
movsxd rdx, [rsp+rdx+12E8h+var_12BC]
cmp edx, 9
jle loc_1C60
add r9, 4
cmp r9, rbp
jz loc_1C02
mov r8d, [r11+r9]
mov edi, [rbx+r9]
jmp short loc_1B08
loc_1B70:
movsxd rax, ecx
add ecx, 1
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rsp+rax+12E8h+var_12E8], edi
mov [rsp+rax+12E8h+var_12BC], 0
jmp short loc_1B1F
loc_1B90:
movsxd rax, ecx
add ecx, 1
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rsp+rax+12E8h+var_12E8], edi
mov [rsp+rax+12E8h+var_12BC], 0
cmp ecx, 1
jz loc_1B1F
nop word ptr [rax+rax+00h]
loc_1BB8:
movsxd rax, ecx
mov r12d, 1
xor edx, edx
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rsp+rax+12E8h+var_12E8], r8d
mov [rsp+rax+12E8h+var_12BC], 0
movsxd rax, ecx
add ecx, 1
loc_1BDD:
lea rax, [rax+rax*2]
add r9, 4
mov r8, rax
lea rax, [rdx+rax*4]
shl r8, 4
mov dword ptr [rsp+rax*4+12E8h+var_12E8+4], edi
mov [rsp+r8+12E8h+var_12BC], r12d
cmp r9, rbp
jnz loc_1AF8
loc_1C02:
mov rax, [rsp+12E8h+var_12E8]
mov [rsp+12E8h+var_28], ecx
lea rdi, [r10+8]
and rdi, 0FFFFFFFFFFFFFFF8h
mov [r10], rax
mov rax, [rsp+12BCh]
mov [r10+12BCh], rax
mov rax, r10
sub rax, rdi
sub rsi, rax
add eax, 12C4h
shr eax, 3
mov ecx, eax
rep movsq
mov rax, [rsp+12E8h+var_20]
sub rax, fs:28h
jnz short loc_1C70
add rsp, 12D0h
mov rax, r10
pop rbx
pop rbp
pop r12
retn
loc_1C60:
lea r12d, [rdx+1]
jmp loc_1BDD
loc_1C69:
xor ecx, ecx
mov rsi, rsp
jmp short loc_1C02
loc_1C70:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, long long a2, long long a3, int a4)
{
long long v6; // r9
long long v7; // rbp
int v8; // ecx
int v9; // r8d
int v10; // edi
_DWORD *v11; // rax
int v12; // edx
_DWORD *v13; // rdx
long long v14; // rax
long long v15; // rdx
long long v16; // rax
long long v17; // rax
int v18; // r12d
long long v19; // rax
_QWORD v21[90]; // [rsp+0h] [rbp-12E8h] BYREF
long long v22; // [rsp+12BCh] [rbp-2Ch]
unsigned long long v23; // [rsp+12C8h] [rbp-20h]
v23 = __readfsqword(0x28u);
if ( a4 > 0 )
{
v6 = 0LL;
v7 = 4LL * a4;
v8 = 0;
while ( 1 )
{
v9 = *(_DWORD *)(a2 + v6);
v10 = *(_DWORD *)(a3 + v6);
if ( v8 > 0 )
break;
v17 = v8++;
v17 *= 48LL;
*(_DWORD *)((char *)v21 + v17) = v10;
*(_DWORD *)((char *)&v21[5] + v17 + 4) = 0;
if ( v8 == 1 )
goto LABEL_7;
LABEL_15:
v18 = 1;
v15 = 0LL;
v19 = 6LL * v8;
LODWORD(v21[v19]) = v9;
HIDWORD(v21[v19 + 5]) = 0;
v14 = v8++;
LABEL_16:
v6 += 4LL;
*((_DWORD *)&v21[6 * v14] + v15 + 1) = v10;
HIDWORD(v21[6 * v14 + 5]) = v18;
if ( v6 == v7 )
goto LABEL_17;
}
while ( 1 )
{
v11 = v21;
v12 = 0;
while ( *v11 != v10 )
{
++v12;
v11 += 12;
if ( v12 == v8 )
{
v16 = v8++;
v16 *= 48LL;
*(_DWORD *)((char *)v21 + v16) = v10;
*(_DWORD *)((char *)&v21[5] + v16 + 4) = 0;
break;
}
}
LABEL_7:
v13 = v21;
LODWORD(v14) = 0;
while ( *v13 != v9 )
{
LODWORD(v14) = v14 + 1;
v13 += 12;
if ( (_DWORD)v14 == v8 )
goto LABEL_15;
}
v14 = (int)v14;
v15 = SHIDWORD(v21[6 * (int)v14 + 5]);
if ( (int)v15 <= 9 )
{
v18 = v15 + 1;
goto LABEL_16;
}
v6 += 4LL;
if ( v6 == v7 )
goto LABEL_17;
v9 = *(_DWORD *)(a2 + v6);
v10 = *(_DWORD *)(a3 + v6);
}
}
v8 = 0;
LABEL_17:
HIDWORD(v22) = v8;
*a1 = v21[0];
*(_QWORD *)((char *)a1 + 4796) = v22;
qmemcpy(
(void *)((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL),
(const void *)((char *)v21 - ((char *)a1 - ((unsigned long long)(a1 + 1) & 0xFFFFFFFFFFFFFFF8LL))),
8LL * (((unsigned int)a1 - (((_DWORD)a1 + 8) & 0xFFFFFFF8) + 4804) >> 3));
return a1;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x2d0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x12c8],RAX
XOR EAX,EAX
MOV R10,RDI
TEST ECX,ECX
JLE 0x00101c69
MOVSXD RCX,ECX
MOV R11,RSI
MOV RBX,RDX
XOR R9D,R9D
LEA RBP,[RCX*0x4]
MOV RSI,RSP
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101af8:
MOV R8D,dword ptr [R11 + R9*0x1]
MOV EDI,dword ptr [RBX + R9*0x1]
TEST ECX,ECX
JLE 0x00101b90
LAB_00101b08:
MOV RAX,RSI
XOR EDX,EDX
JMP 0x00101b1b
LAB_00101b10:
ADD EDX,0x1
ADD RAX,0x30
CMP EDX,ECX
JZ 0x00101b70
LAB_00101b1b:
CMP dword ptr [RAX],EDI
JNZ 0x00101b10
LAB_00101b1f:
MOV RDX,RSI
XOR EAX,EAX
JMP 0x00101b3b
LAB_00101b30:
ADD EAX,0x1
ADD RDX,0x30
CMP EAX,ECX
JZ 0x00101bb8
LAB_00101b3b:
CMP dword ptr [RDX],R8D
JNZ 0x00101b30
CDQE
LEA RDX,[RAX + RAX*0x2]
SHL RDX,0x4
MOVSXD RDX,dword ptr [RSP + RDX*0x1 + 0x2c]
CMP EDX,0x9
JLE 0x00101c60
ADD R9,0x4
CMP R9,RBP
JZ 0x00101c02
MOV R8D,dword ptr [R11 + R9*0x1]
MOV EDI,dword ptr [RBX + R9*0x1]
JMP 0x00101b08
LAB_00101b70:
MOVSXD RAX,ECX
ADD ECX,0x1
LEA RAX,[RAX + RAX*0x2]
SHL RAX,0x4
MOV dword ptr [RSP + RAX*0x1],EDI
MOV dword ptr [RSP + RAX*0x1 + 0x2c],0x0
JMP 0x00101b1f
LAB_00101b90:
MOVSXD RAX,ECX
ADD ECX,0x1
LEA RAX,[RAX + RAX*0x2]
SHL RAX,0x4
MOV dword ptr [RSP + RAX*0x1],EDI
MOV dword ptr [RSP + RAX*0x1 + 0x2c],0x0
CMP ECX,0x1
JZ 0x00101b1f
NOP word ptr [RAX + RAX*0x1]
LAB_00101bb8:
MOVSXD RAX,ECX
MOV R12D,0x1
XOR EDX,EDX
LEA RAX,[RAX + RAX*0x2]
SHL RAX,0x4
MOV dword ptr [RSP + RAX*0x1],R8D
MOV dword ptr [RSP + RAX*0x1 + 0x2c],0x0
MOVSXD RAX,ECX
ADD ECX,0x1
LAB_00101bdd:
LEA RAX,[RAX + RAX*0x2]
ADD R9,0x4
MOV R8,RAX
LEA RAX,[RDX + RAX*0x4]
SHL R8,0x4
MOV dword ptr [RSP + RAX*0x4 + 0x4],EDI
MOV dword ptr [RSP + R8*0x1 + 0x2c],R12D
CMP R9,RBP
JNZ 0x00101af8
LAB_00101c02:
MOV RAX,qword ptr [RSP]
MOV dword ptr [RSP + 0x12c0],ECX
LEA RDI,[R10 + 0x8]
AND RDI,-0x8
MOV qword ptr [R10],RAX
MOV RAX,qword ptr [RSP + 0x12bc]
MOV qword ptr [R10 + 0x12bc],RAX
MOV RAX,R10
SUB RAX,RDI
SUB RSI,RAX
ADD EAX,0x12c4
SHR EAX,0x3
MOV ECX,EAX
MOVSQ.REP RDI,RSI
MOV RAX,qword ptr [RSP + 0x12c8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101c70
ADD RSP,0x12d0
MOV RAX,R10
POP RBX
POP RBP
POP R12
RET
LAB_00101c60:
LEA R12D,[RDX + 0x1]
JMP 0x00101bdd
LAB_00101c69:
XOR ECX,ECX
MOV RSI,RSP
JMP 0x00101c02
LAB_00101c70:
CALL 0x00101060 | int8 * func0(int8 *param_1,long param_2,long param_3,int param_4)
{
int *piVar1;
long lVar2;
ulong uVar3;
long lVar4;
int8 *puVar5;
int iVar6;
int8 *puVar7;
int iVar8;
long lVar9;
int iVar10;
long in_FS_OFFSET;
int8 local_12e8;
int aiStack_12bc [1188];
int4 local_2c;
int iStack_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (param_4 < 1) {
iStack_28 = 0;
}
else {
lVar9 = 0;
iStack_28 = 0;
do {
iVar8 = *(int *)(param_2 + lVar9);
iVar6 = *(int *)(param_3 + lVar9);
if (0 < iStack_28) goto LAB_00101b08;
lVar2 = (long)iStack_28;
iStack_28 = iStack_28 + 1;
*(int *)(&local_12e8 + lVar2 * 6) = iVar6;
aiStack_12bc[lVar2 * 0xc] = 0;
if (iStack_28 == 1) {
LAB_00101b1f:
iVar10 = 0;
piVar1 = (int *)&local_12e8;
while (*piVar1 != iVar8) {
iVar10 = iVar10 + 1;
piVar1 = piVar1 + 0xc;
if (iVar10 == iStack_28) goto LAB_00101bb8;
}
lVar2 = (long)iVar10;
iVar10 = aiStack_12bc[lVar2 * 0xc];
lVar4 = (long)iVar10;
if (9 < iVar10) {
lVar9 = lVar9 + 4;
if (lVar9 == (long)param_4 * 4) break;
iVar8 = *(int *)(param_2 + lVar9);
iVar6 = *(int *)(param_3 + lVar9);
LAB_00101b08:
iVar10 = 0;
piVar1 = (int *)&local_12e8;
do {
if (*piVar1 == iVar6) goto LAB_00101b1f;
iVar10 = iVar10 + 1;
piVar1 = piVar1 + 0xc;
} while (iVar10 != iStack_28);
lVar2 = (long)iStack_28;
iStack_28 = iStack_28 + 1;
*(int *)(&local_12e8 + lVar2 * 6) = iVar6;
aiStack_12bc[lVar2 * 0xc] = 0;
goto LAB_00101b1f;
}
iVar10 = iVar10 + 1;
}
else {
LAB_00101bb8:
iVar10 = 1;
lVar4 = 0;
*(int *)(&local_12e8 + (long)iStack_28 * 6) = iVar8;
aiStack_12bc[(long)iStack_28 * 0xc] = 0;
lVar2 = (long)iStack_28;
iStack_28 = iStack_28 + 1;
}
lVar9 = lVar9 + 4;
*(int *)((long)&local_12e8 + (lVar4 + lVar2 * 0xc) * 4 + 4) = iVar6;
aiStack_12bc[lVar2 * 0xc] = iVar10;
} while (lVar9 != (long)param_4 * 4);
}
*param_1 = local_12e8;
*(ulong *)((long)param_1 + 0x12bc) = CONCAT44(iStack_28,local_2c);
lVar9 = (long)param_1 - (long)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
puVar5 = (int8 *)((long)&local_12e8 - lVar9);
puVar7 = (int8 *)((ulong)(param_1 + 1) & 0xfffffffffffffff8);
for (uVar3 = (ulong)((int)lVar9 + 0x12c4U >> 3); uVar3 != 0; uVar3 = uVar3 - 1) {
*puVar7 = *puVar5;
puVar5 = puVar5 + 1;
puVar7 = puVar7 + 1;
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
6,140 | func0 | #include <assert.h>
#include <stdlib.h>
| int func0(int** lst, int* sizes, int lst_size) {
int maxLength = 0;
for (int i = 0; i < lst_size; i++) {
if (sizes[i] > maxLength) {
maxLength = sizes[i];
}
}
return maxLength;
}
| int main() {
int lst1_sizes[] = {1, 2, 4};
int* lst1[] = {(int[]){1}, (int[]){1, 4}, (int[]){5, 6, 7, 8}};
assert(func0(lst1, lst1_sizes, 3) == 4);
int lst2_sizes[] = {2, 2, 3};
int* lst2[] = {(int[]){0, 1}, (int[]){2, 2}, (int[]){3, 2, 1}};
assert(func0(lst2, lst2_sizes, 3) == 3);
int lst3_sizes[] = {1, 2, 3, 5};
int* lst3[] = {(int[]){7}, (int[]){22, 23}, (int[]){13, 14, 15}, (int[]){10, 20, 30, 40, 50}};
assert(func0(lst3, lst3_sizes, 4) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c4 <func0+0x5b>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x8(%rbp)
jge 11c0 <func0+0x57>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 118c <func0+0x23>
mov -0x8(%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_8], 0
mov [rbp+var_4], 0
jmp short loc_11C4
loc_118C:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_8], eax
jge short loc_11C0
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rdx
mov eax, [rax]
mov [rbp+var_8], eax
loc_11C0:
add [rbp+var_4], 1
loc_11C4:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_24]
jl short loc_118C
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, long long a2, int a3)
{
unsigned int v4; // [rsp+1Ch] [rbp-8h]
int i; // [rsp+20h] [rbp-4h]
v4 = 0;
for ( i = 0; i < a3; ++i )
{
if ( (signed int)v4 < *(_DWORD *)(4LL * i + a2) )
v4 = *(_DWORD *)(4LL * i + a2);
}
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 dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c4
LAB_0010118c:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x8],EAX
JGE 0x001011c0
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x8],EAX
LAB_001011c0:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c4:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x0010118c
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(int8 param_1,long param_2,int param_3)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
if (local_10 < *(int *)(param_2 + (long)local_c * 4)) {
local_10 = *(int *)(param_2 + (long)local_c * 4);
}
}
return local_10;
} |
6,141 | func0 | #include <assert.h>
#include <stdlib.h>
| int func0(int** lst, int* sizes, int lst_size) {
int maxLength = 0;
for (int i = 0; i < lst_size; i++) {
if (sizes[i] > maxLength) {
maxLength = sizes[i];
}
}
return maxLength;
}
| int main() {
int lst1_sizes[] = {1, 2, 4};
int* lst1[] = {(int[]){1}, (int[]){1, 4}, (int[]){5, 6, 7, 8}};
assert(func0(lst1, lst1_sizes, 3) == 4);
int lst2_sizes[] = {2, 2, 3};
int* lst2[] = {(int[]){0, 1}, (int[]){2, 2}, (int[]){3, 2, 1}};
assert(func0(lst2, lst2_sizes, 3) == 3);
int lst3_sizes[] = {1, 2, 3, 5};
int* lst3[] = {(int[]){7}, (int[]){22, 23}, (int[]){13, 14, 15}, (int[]){10, 20, 30, 40, 50}};
assert(func0(lst3, lst3_sizes, 4) == 5);
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
jle 1194 <func0+0x2b>
mov %rsi,%rax
lea -0x1(%rdx),%edx
lea 0x4(%rsi,%rdx,4),%rsi
mov $0x0,%edx
mov (%rax),%ecx
cmp %ecx,%edx
cmovl %ecx,%edx
add $0x4,%rax
cmp %rsi,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1191 <func0+0x28>
| func0:
endbr64
test edx, edx
jle short loc_1194
mov rax, rsi
lea edx, [rdx-1]
lea rsi, [rsi+rdx*4+4]
mov edx, 0
loc_1181:
mov ecx, [rax]
cmp edx, ecx
cmovl edx, ecx
add rax, 4
cmp rax, rsi
jnz short loc_1181
loc_1191:
mov eax, edx
retn
loc_1194:
mov edx, 0
jmp short loc_1191 | long long func0(long long a1, unsigned int *a2, int a3)
{
unsigned int *v3; // rax
long long v4; // rsi
unsigned int v5; // edx
if ( a3 <= 0 )
{
return 0;
}
else
{
v3 = a2;
v4 = (long long)&a2[a3 - 1 + 1];
v5 = 0;
do
{
if ( (int)v5 < (int)*v3 )
v5 = *v3;
++v3;
}
while ( v3 != (unsigned int *)v4 );
}
return v5;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x00101194
MOV RAX,RSI
LEA EDX,[RDX + -0x1]
LEA RSI,[RSI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101181
LAB_00101191:
MOV EAX,EDX
RET
LAB_00101194:
MOV EDX,0x0
JMP 0x00101191 | int func0(int8 param_1,int *param_2,int param_3)
{
int *piVar1;
int iVar2;
if (param_3 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_2 + (ulong)(param_3 - 1) + 1;
iVar2 = 0;
do {
if (iVar2 < *param_2) {
iVar2 = *param_2;
}
param_2 = param_2 + 1;
} while (param_2 != piVar1);
}
return iVar2;
} |
6,142 | func0 | #include <assert.h>
#include <stdlib.h>
| int func0(int** lst, int* sizes, int lst_size) {
int maxLength = 0;
for (int i = 0; i < lst_size; i++) {
if (sizes[i] > maxLength) {
maxLength = sizes[i];
}
}
return maxLength;
}
| int main() {
int lst1_sizes[] = {1, 2, 4};
int* lst1[] = {(int[]){1}, (int[]){1, 4}, (int[]){5, 6, 7, 8}};
assert(func0(lst1, lst1_sizes, 3) == 4);
int lst2_sizes[] = {2, 2, 3};
int* lst2[] = {(int[]){0, 1}, (int[]){2, 2}, (int[]){3, 2, 1}};
assert(func0(lst2, lst2_sizes, 3) == 3);
int lst3_sizes[] = {1, 2, 3, 5};
int* lst3[] = {(int[]){7}, (int[]){22, 23}, (int[]){13, 14, 15}, (int[]){10, 20, 30, 40, 50}};
assert(func0(lst3, lst3_sizes, 4) == 5);
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
jle 1170 <func0+0x30>
lea -0x1(%rdx),%eax
lea 0x4(%rsi,%rax,4),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rsi),%edx
cmp %edx,%eax
cmovl %edx,%eax
add $0x4,%rsi
cmp %rcx,%rsi
jne 1158 <func0+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test edx, edx
jle short loc_1170
lea eax, [rdx-1]
lea rcx, [rsi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1158:
mov edx, [rsi]
cmp eax, edx
cmovl eax, edx
add rsi, 4
cmp rsi, rcx
jnz short loc_1158
retn
loc_1170:
xor eax, eax
retn | long long func0(long long a1, _DWORD *a2, int a3)
{
long long v3; // rcx
long long result; // rax
if ( a3 <= 0 )
return 0LL;
v3 = (long long)&a2[a3 - 1 + 1];
result = 0LL;
do
{
if ( (int)result < *a2 )
result = (unsigned int)*a2;
++a2;
}
while ( a2 != (_DWORD *)v3 );
return result;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x00101170
LEA EAX,[RDX + -0x1]
LEA RCX,[RSI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,dword ptr [RSI]
CMP EAX,EDX
CMOVL EAX,EDX
ADD RSI,0x4
CMP RSI,RCX
JNZ 0x00101158
RET
LAB_00101170:
XOR EAX,EAX
RET | int func0(int8 param_1,int *param_2,int param_3)
{
int *piVar1;
int iVar2;
if (0 < param_3) {
piVar1 = param_2 + (ulong)(param_3 - 1) + 1;
iVar2 = 0;
do {
if (iVar2 < *param_2) {
iVar2 = *param_2;
}
param_2 = param_2 + 1;
} while (param_2 != piVar1);
return iVar2;
}
return 0;
} |
6,143 | func0 | #include <assert.h>
#include <stdlib.h>
| int func0(int** lst, int* sizes, int lst_size) {
int maxLength = 0;
for (int i = 0; i < lst_size; i++) {
if (sizes[i] > maxLength) {
maxLength = sizes[i];
}
}
return maxLength;
}
| int main() {
int lst1_sizes[] = {1, 2, 4};
int* lst1[] = {(int[]){1}, (int[]){1, 4}, (int[]){5, 6, 7, 8}};
assert(func0(lst1, lst1_sizes, 3) == 4);
int lst2_sizes[] = {2, 2, 3};
int* lst2[] = {(int[]){0, 1}, (int[]){2, 2}, (int[]){3, 2, 1}};
assert(func0(lst2, lst2_sizes, 3) == 3);
int lst3_sizes[] = {1, 2, 3, 5};
int* lst3[] = {(int[]){7}, (int[]){22, 23}, (int[]){13, 14, 15}, (int[]){10, 20, 30, 40, 50}};
assert(func0(lst3, lst3_sizes, 4) == 5);
return 0;
}
| O3 | c | func0:
endbr64
test %edx,%edx
jle 1210 <func0+0xd0>
lea -0x1(%rdx),%eax
cmp $0x2,%eax
jbe 1219 <func0+0xd9>
mov %edx,%ecx
mov %rsi,%rax
pxor %xmm2,%xmm2
shr $0x2,%ecx
shl $0x4,%rcx
add %rsi,%rcx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
add $0x10,%rax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rcx,%rax
jne 1170 <func0+0x30>
movdqa %xmm2,%xmm1
mov %edx,%ecx
psrldq $0x8,%xmm1
and $0xfffffffc,%ecx
movdqa %xmm1,%xmm0
pcmpgtd %xmm2,%xmm0
pand %xmm0,%xmm1
pandn %xmm2,%xmm0
por %xmm0,%xmm1
movdqa %xmm1,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm0
pcmpgtd %xmm1,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm2,%xmm0
movd %xmm0,%eax
test $0x3,%dl
je 1218 <func0+0xd8>
movslq %ecx,%rdi
mov (%rsi,%rdi,4),%edi
cmp %edi,%eax
cmovl %edi,%eax
lea 0x1(%rcx),%edi
cmp %edi,%edx
jle 1212 <func0+0xd2>
movslq %edi,%rdi
mov (%rsi,%rdi,4),%edi
cmp %edi,%eax
cmovl %edi,%eax
add $0x2,%ecx
cmp %ecx,%edx
jle 1212 <func0+0xd2>
movslq %ecx,%rcx
mov (%rsi,%rcx,4),%edx
cmp %edx,%eax
cmovl %edx,%eax
retq
nopl (%rax)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %ecx,%ecx
xor %eax,%eax
jmp 11dd <func0+0x9d>
| func0:
endbr64
mov rdi, rsi
mov ecx, edx
test edx, edx
jle loc_1218
lea eax, [rdx-1]
cmp eax, 2
jbe loc_1221
shr edx, 2
mov rax, rsi
pxor xmm2, xmm2
shl rdx, 4
add rdx, rsi
xchg ax, ax
loc_1170:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rax, rdx
jnz short loc_1170
movdqa xmm0, xmm2
mov edx, ecx
psrldq xmm0, 8
and edx, 0FFFFFFFCh
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
por xmm1, xmm0
movdqa xmm2, xmm1
psrldq xmm2, 4
movdqa xmm0, xmm2
pcmpgtd xmm0, xmm1
pand xmm2, xmm0
pandn xmm0, xmm1
por xmm0, xmm2
movd eax, xmm0
test cl, 3
jz short locret_1220
loc_11DD:
movsxd rsi, edx
lea r8, ds:0[rsi*4]
mov esi, [rdi+rsi*4]
cmp eax, esi
cmovl eax, esi
lea esi, [rdx+1]
cmp ecx, esi
jle short locret_121A
mov esi, [rdi+r8+4]
cmp eax, esi
cmovl eax, esi
add edx, 2
cmp ecx, edx
jle short locret_121A
mov edx, [rdi+r8+8]
cmp eax, edx
cmovl eax, edx
retn
loc_1218:
xor eax, eax
locret_121A:
retn
locret_1220:
retn
loc_1221:
xor edx, edx
xor eax, eax
jmp short loc_11DD | long long func0(long long a1, const __m128i *a2, int a3)
{
const __m128i *v5; // rax
__m128i v6; // xmm2
const __m128i *v7; // rdx
__m128i v8; // xmm0
__m128i v9; // xmm1
__m128i v10; // xmm0
signed int v11; // edx
__m128i v12; // xmm1
__m128i v13; // xmm1
__m128i v14; // xmm2
__m128i v15; // xmm0
long long result; // rax
long long v17; // r8
int v18; // esi
int v19; // esi
int v20; // edx
if ( a3 <= 0 )
return 0LL;
if ( (unsigned int)(a3 - 1) <= 2 )
{
v11 = 0;
result = 0LL;
}
else
{
v5 = a2;
v6 = 0LL;
v7 = &a2[(unsigned int)a3 >> 2];
do
{
v8 = _mm_loadu_si128(v5++);
v9 = _mm_cmpgt_epi32(v8, v6);
v6 = _mm_or_si128(_mm_andnot_si128(v9, v6), _mm_and_si128(v8, v9));
}
while ( v5 != v7 );
v10 = _mm_srli_si128(v6, 8);
v11 = a3 & 0xFFFFFFFC;
v12 = _mm_cmpgt_epi32(v10, v6);
v13 = _mm_or_si128(_mm_andnot_si128(v12, v6), _mm_and_si128(v10, v12));
v14 = _mm_srli_si128(v13, 4);
v15 = _mm_cmpgt_epi32(v14, v13);
result = (unsigned int)_mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v15, v13), _mm_and_si128(v14, v15)));
if ( (a3 & 3) == 0 )
return result;
}
v17 = v11;
v18 = a2->m128i_i32[v17];
if ( (int)result < v18 )
result = (unsigned int)v18;
if ( a3 > v11 + 1 )
{
v19 = a2->m128i_i32[v17 + 1];
if ( (int)result < v19 )
result = (unsigned int)v19;
if ( a3 > v11 + 2 )
{
v20 = a2->m128i_i32[v17 + 2];
if ( (int)result < v20 )
return (unsigned int)v20;
}
}
return result;
} | func0:
ENDBR64
MOV RDI,RSI
MOV ECX,EDX
TEST EDX,EDX
JLE 0x00101218
LEA EAX,[RDX + -0x1]
CMP EAX,0x2
JBE 0x00101221
SHR EDX,0x2
MOV RAX,RSI
PXOR XMM2,XMM2
SHL RDX,0x4
ADD RDX,RSI
NOP
LAB_00101170:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RAX,RDX
JNZ 0x00101170
MOVDQA XMM0,XMM2
MOV EDX,ECX
PSRLDQ XMM0,0x8
AND EDX,0xfffffffc
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
POR XMM1,XMM0
MOVDQA XMM2,XMM1
PSRLDQ XMM2,0x4
MOVDQA XMM0,XMM2
PCMPGTD XMM0,XMM1
PAND XMM2,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM2
MOVD EAX,XMM0
TEST CL,0x3
JZ 0x00101220
LAB_001011dd:
MOVSXD RSI,EDX
LEA R8,[RSI*0x4]
MOV ESI,dword ptr [RDI + RSI*0x4]
CMP EAX,ESI
CMOVL EAX,ESI
LEA ESI,[RDX + 0x1]
CMP ECX,ESI
JLE 0x0010121a
MOV ESI,dword ptr [RDI + R8*0x1 + 0x4]
CMP EAX,ESI
CMOVL EAX,ESI
ADD EDX,0x2
CMP ECX,EDX
JLE 0x0010121a
MOV EDX,dword ptr [RDI + R8*0x1 + 0x8]
CMP EAX,EDX
CMOVL EAX,EDX
RET
LAB_00101218:
XOR EAX,EAX
LAB_0010121a:
RET
LAB_00101220:
RET
LAB_00101221:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011dd | uint func0(int8 param_1,uint *param_2,uint param_3)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
uint uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
if ((int)param_3 < 1) {
uVar6 = 0;
}
else {
if (param_3 - 1 < 3) {
uVar5 = 0;
uVar6 = 0;
}
else {
uVar6 = 0;
uVar11 = 0;
uVar12 = 0;
uVar13 = 0;
puVar4 = param_2;
do {
uVar5 = *puVar4;
puVar1 = puVar4 + 1;
puVar2 = puVar4 + 2;
puVar3 = puVar4 + 3;
puVar4 = puVar4 + 4;
uVar7 = -(uint)((int)uVar6 < (int)uVar5);
uVar8 = -(uint)((int)uVar11 < (int)*puVar1);
uVar9 = -(uint)((int)uVar12 < (int)*puVar2);
uVar10 = -(uint)((int)uVar13 < (int)*puVar3);
uVar6 = ~uVar7 & uVar6 | uVar5 & uVar7;
uVar11 = ~uVar8 & uVar11 | *puVar1 & uVar8;
uVar12 = ~uVar9 & uVar12 | *puVar2 & uVar9;
uVar13 = ~uVar10 & uVar13 | *puVar3 & uVar10;
} while (puVar4 != param_2 + (ulong)(param_3 >> 2) * 4);
uVar5 = param_3 & 0xfffffffc;
uVar12 = ~-(uint)((int)uVar6 < (int)uVar12) & uVar6 |
uVar12 & -(uint)((int)uVar6 < (int)uVar12);
uVar11 = ~-(uint)((int)uVar11 < (int)uVar13) & uVar11 |
uVar13 & -(uint)((int)uVar11 < (int)uVar13);
uVar6 = -(uint)((int)uVar12 < (int)uVar11);
uVar6 = ~uVar6 & uVar12 | uVar11 & uVar6;
if ((param_3 & 3) == 0) {
return uVar6;
}
}
if ((int)uVar6 < (int)param_2[(int)uVar5]) {
uVar6 = param_2[(int)uVar5];
}
if ((int)(uVar5 + 1) < (int)param_3) {
if ((int)uVar6 < (int)param_2[(long)(int)uVar5 + 1]) {
uVar6 = param_2[(long)(int)uVar5 + 1];
}
if ((int)(uVar5 + 2) < (int)param_3) {
if ((int)uVar6 < (int)param_2[(long)(int)uVar5 + 2]) {
uVar6 = param_2[(long)(int)uVar5 + 2];
}
return uVar6;
}
}
}
return uVar6;
} |
6,144 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| void func0(const char *text, char values[][50], int *count) {
int index = 0;
*count = 0;
const char *start = NULL;
const char *end = NULL;
while ((start = strchr(text, '"')) != NULL) {
end = strchr(start + 1, '"');
if (end == NULL) break;
int len = end - (start + 1);
strncpy(values[index], start + 1, len);
values[index][len] = '\0';
index++;
text = end + 1;
}
*count = index;
}
| int main() {
char values[10][50];
int count, i;
func0("\"Python\", \"PHP\", \"Java\"", values, &count);
assert(count == 3);
assert(strcmp(values[0], "Python") == 0);
assert(strcmp(values[1], "PHP") == 0);
assert(strcmp(values[2], "Java") == 0);
func0("\"python\",\"program\",\"language\"", values, &count);
assert(count == 3);
assert(strcmp(values[0], "python") == 0);
assert(strcmp(values[1], "program") == 0);
assert(strcmp(values[2], "language") == 0);
func0("\"red\",\"blue\",\"green\",\"yellow\"", values, &count);
assert(count == 4);
assert(strcmp(values[0], "red") == 0);
assert(strcmp(values[1], "blue") == 0);
assert(strcmp(values[2], "green") == 0);
assert(strcmp(values[3], "yellow") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %rdx,-0x38(%rbp)
movl $0x0,-0x18(%rbp)
mov -0x38(%rbp),%rax
movl $0x0,(%rax)
movq $0x0,-0x10(%rbp)
movq $0x0,-0x8(%rbp)
jmpq 12bf <func0+0xf6>
mov -0x10(%rbp),%rax
add $0x1,%rax
mov $0x22,%esi
mov %rax,%rdi
callq 10b0 <strchr@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
je 12e1 <func0+0x118>
mov -0x10(%rbp),%rax
lea 0x1(%rax),%rdx
mov -0x8(%rbp),%rax
sub %rdx,%rax
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rcx
mov -0x10(%rbp),%rax
lea 0x1(%rax),%rsi
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
add %rax,%rax
mov %rax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
mov %rcx,%rdx
mov %rax,%rdi
callq 1090 <strncpy@plt>
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
lea 0x0(,%rax,4),%rdx
add %rdx,%rax
add %rax,%rax
mov %rax,%rdx
mov -0x30(%rbp),%rax
add %rax,%rdx
mov -0x14(%rbp),%eax
cltq
movb $0x0,(%rdx,%rax,1)
addl $0x1,-0x18(%rbp)
mov -0x8(%rbp),%rax
add $0x1,%rax
mov %rax,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov $0x22,%esi
mov %rax,%rdi
callq 10b0 <strchr@plt>
mov %rax,-0x10(%rbp)
cmpq $0x0,-0x10(%rbp)
jne 1207 <func0+0x3e>
jmp 12e2 <func0+0x119>
mov -0x38(%rbp),%rax
mov -0x18(%rbp),%edx
mov %edx,(%rax)
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+s], rdi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov [rbp+var_18], 0
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov [rbp+var_10], 0
mov [rbp+var_8], 0
jmp loc_12BF
loc_1207:
mov rax, [rbp+var_10]
add rax, 1
mov esi, 22h ; '"'; c
mov rdi, rax; s
call _strchr
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jz loc_12E1
mov rax, [rbp+var_10]
lea rdx, [rax+1]
mov rax, [rbp+var_8]
sub rax, rdx
mov [rbp+var_14], eax
mov eax, [rbp+var_14]
movsxd rcx, eax
mov rax, [rbp+var_10]
lea rsi, [rax+1]; src
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
add rax, rax
mov rdx, rax
mov rax, [rbp+var_30]
add rax, rdx
mov rdx, rcx; n
mov rdi, rax; dest
call _strncpy
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
add rax, rdx
lea rdx, ds:0[rax*4]
add rax, rdx
add rax, rax
mov rdx, rax
mov rax, [rbp+var_30]
add rdx, rax
mov eax, [rbp+var_14]
cdqe
mov byte ptr [rdx+rax], 0
add [rbp+var_18], 1
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+s], rax
loc_12BF:
mov rax, [rbp+s]
mov esi, 22h ; '"'; c
mov rdi, rax; s
call _strchr
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jnz loc_1207
jmp short loc_12E2
loc_12E1:
nop
loc_12E2:
mov rax, [rbp+var_38]
mov edx, [rbp+var_18]
mov [rax], edx
nop
leave
retn | _DWORD * func0(const char *a1, long long a2, _DWORD *a3)
{
char *i; // rax
_DWORD *result; // rax
int v6; // [rsp+28h] [rbp-18h]
char *v7; // [rsp+30h] [rbp-10h]
char *v8; // [rsp+38h] [rbp-8h]
v6 = 0;
*a3 = 0;
for ( i = strchr(a1, 34); ; i = strchr(v8 + 1, 34) )
{
v7 = i;
if ( !i )
break;
v8 = strchr(i + 1, 34);
if ( !v8 )
break;
strncpy((char *)(50LL * v6 + a2), v7 + 1, (int)v8 - ((int)v7 + 1));
*(_BYTE *)(a2 + 50LL * v6++ + (int)v8 - ((int)v7 + 1)) = 0;
}
result = a3;
*a3 = v6;
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV dword ptr [RBP + -0x18],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV qword ptr [RBP + -0x10],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001012bf
LAB_00101207:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV ESI,0x22
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JZ 0x001012e1
MOV RAX,qword ptr [RBP + -0x10]
LEA RDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,RDX
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x10]
LEA RSI,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
ADD RAX,RAX
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV RDX,RCX
MOV RDI,RAX
CALL 0x00101090
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
LEA RDX,[RAX*0x4]
ADD RAX,RDX
ADD RAX,RAX
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV byte ptr [RDX + RAX*0x1],0x0
ADD dword ptr [RBP + -0x18],0x1
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_001012bf:
MOV RAX,qword ptr [RBP + -0x28]
MOV ESI,0x22
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x00101207
JMP 0x001012e2
LAB_001012e1:
NOP
LAB_001012e2:
MOV RAX,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x18]
MOV dword ptr [RAX],EDX
NOP
LEAVE
RET | void func0(char *param_1,long param_2,int *param_3)
{
int iVar1;
char *pcVar2;
char *local_30;
int local_20;
local_20 = 0;
*param_3 = 0;
local_30 = param_1;
while ((pcVar2 = strchr(local_30,0x22), pcVar2 != (char *)0x0 &&
(local_30 = strchr(pcVar2 + 1,0x22), local_30 != (char *)0x0))) {
iVar1 = (int)local_30 - ((int)pcVar2 + 1);
strncpy((char *)(param_2 + (long)local_20 * 0x32),pcVar2 + 1,(long)iVar1);
*(int *)((long)local_20 * 0x32 + param_2 + (long)iVar1) = 0;
local_20 = local_20 + 1;
local_30 = local_30 + 1;
}
*param_3 = local_20;
return;
} |
6,145 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| void func0(const char *text, char values[][50], int *count) {
int index = 0;
*count = 0;
const char *start = NULL;
const char *end = NULL;
while ((start = strchr(text, '"')) != NULL) {
end = strchr(start + 1, '"');
if (end == NULL) break;
int len = end - (start + 1);
strncpy(values[index], start + 1, len);
values[index][len] = '\0';
index++;
text = end + 1;
}
*count = index;
}
| int main() {
char values[10][50];
int count, i;
func0("\"Python\", \"PHP\", \"Java\"", values, &count);
assert(count == 3);
assert(strcmp(values[0], "Python") == 0);
assert(strcmp(values[1], "PHP") == 0);
assert(strcmp(values[2], "Java") == 0);
func0("\"python\",\"program\",\"language\"", values, &count);
assert(count == 3);
assert(strcmp(values[0], "python") == 0);
assert(strcmp(values[1], "program") == 0);
assert(strcmp(values[2], "language") == 0);
func0("\"red\",\"blue\",\"green\",\"yellow\"", values, &count);
assert(count == 4);
assert(strcmp(values[0], "red") == 0);
assert(strcmp(values[1], "blue") == 0);
assert(strcmp(values[2], "green") == 0);
assert(strcmp(values[3], "yellow") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdx,%r13
movl $0x0,(%rdx)
mov %rsi,%rbp
mov $0x0,%r12d
mov $0x22,%esi
callq 10a0 <strchr@plt>
test %rax,%rax
je 1220 <func0+0x77>
lea 0x1(%rax),%rbx
mov $0x22,%esi
mov %rbx,%rdi
callq 10a0 <strchr@plt>
mov %rax,%r14
test %rax,%rax
je 1220 <func0+0x77>
mov %rax,%r15
sub %rbx,%r15
movslq %r15d,%r15
mov %r15,%rdx
mov %rbx,%rsi
mov %rbp,%rdi
callq 1080 <strncpy@plt>
movb $0x0,0x0(%rbp,%r15,1)
add $0x1,%r12d
lea 0x1(%r14),%rdi
add $0x32,%rbp
jmp 11cd <func0+0x24>
mov %r12d,0x0(%r13)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rdx
mov dword ptr [rdx], 0
mov rbp, rsi
mov r12d, 0
jmp short loc_1218
loc_11EF:
mov r15, rax
sub r15, rbx
movsxd r15, r15d
mov rdx, r15
mov rsi, rbx
mov rdi, rbp
call _strncpy
mov byte ptr [rbp+r15+0], 0
add r12d, 1
lea rdi, [r14+1]
add rbp, 32h ; '2'
loc_1218:
mov esi, 22h ; '"'
call _strchr
test rax, rax
jz short loc_1240
lea rbx, [rax+1]
mov esi, 22h ; '"'
mov rdi, rbx
call _strchr
mov r14, rax
test rax, rax
jnz short loc_11EF
loc_1240:
mov [r13+0], r12d
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, long long a2, _DWORD *a3)
{
int i; // r12d
long long v6; // r15
long long result; // rax
long long v8; // rbx
long long v9; // r14
*a3 = 0;
for ( i = 0; ; ++i )
{
result = strchr(a1, 34LL);
if ( !result )
break;
v8 = result + 1;
result = strchr(result + 1, 34LL);
v9 = result;
if ( !result )
break;
v6 = (int)result - (int)v8;
strncpy(a2, v8, v6);
*(_BYTE *)(a2 + v6) = 0;
a1 = v9 + 1;
a2 += 50LL;
}
*a3 = i;
return result;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDX
MOV dword ptr [RDX],0x0
MOV RBP,RSI
MOV R12D,0x0
JMP 0x00101218
LAB_001011ef:
MOV R15,RAX
SUB R15,RBX
MOVSXD R15,R15D
MOV RDX,R15
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101090
MOV byte ptr [RBP + R15*0x1],0x0
ADD R12D,0x1
LEA RDI,[R14 + 0x1]
ADD RBP,0x32
LAB_00101218:
MOV ESI,0x22
CALL 0x001010b0
TEST RAX,RAX
JZ 0x00101240
LEA RBX,[RAX + 0x1]
MOV ESI,0x22
MOV RDI,RBX
CALL 0x001010b0
MOV R14,RAX
TEST RAX,RAX
JNZ 0x001011ef
LAB_00101240:
MOV dword ptr [R13],R12D
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void func0(char *param_1,char *param_2,int *param_3)
{
char *pcVar1;
int iVar2;
size_t __n;
*param_3 = 0;
iVar2 = 0;
while( true ) {
pcVar1 = strchr(param_1,0x22);
if (pcVar1 == (char *)0x0) break;
pcVar1 = pcVar1 + 1;
param_1 = strchr(pcVar1,0x22);
if (param_1 == (char *)0x0) break;
__n = (size_t)((int)param_1 - (int)pcVar1);
strncpy(param_2,pcVar1,__n);
param_2[__n] = '\0';
iVar2 = iVar2 + 1;
param_1 = param_1 + 1;
param_2 = param_2 + 0x32;
}
*param_3 = iVar2;
return;
} |
6,146 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| void func0(const char *text, char values[][50], int *count) {
int index = 0;
*count = 0;
const char *start = NULL;
const char *end = NULL;
while ((start = strchr(text, '"')) != NULL) {
end = strchr(start + 1, '"');
if (end == NULL) break;
int len = end - (start + 1);
strncpy(values[index], start + 1, len);
values[index][len] = '\0';
index++;
text = end + 1;
}
*count = index;
}
| int main() {
char values[10][50];
int count, i;
func0("\"Python\", \"PHP\", \"Java\"", values, &count);
assert(count == 3);
assert(strcmp(values[0], "Python") == 0);
assert(strcmp(values[1], "PHP") == 0);
assert(strcmp(values[2], "Java") == 0);
func0("\"python\",\"program\",\"language\"", values, &count);
assert(count == 3);
assert(strcmp(values[0], "python") == 0);
assert(strcmp(values[1], "program") == 0);
assert(strcmp(values[2], "language") == 0);
func0("\"red\",\"blue\",\"green\",\"yellow\"", values, &count);
assert(count == 4);
assert(strcmp(values[0], "red") == 0);
assert(strcmp(values[1], "blue") == 0);
assert(strcmp(values[2], "green") == 0);
assert(strcmp(values[3], "yellow") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdx,%r13
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
movl $0x0,(%rdx)
jmp 152a <func0+0x6a>
nopl 0x0(%rax,%rax,1)
lea 0x1(%rax),%rbp
mov $0x22,%esi
mov %rbp,%rdi
callq 10a0 <strchr@plt>
mov %rax,%r14
test %rax,%rax
je 1539 <func0+0x79>
mov %rax,%r15
mov %rbx,%rdi
mov %rbp,%rsi
add $0x1,%r12d
sub %rbp,%r15
add $0x32,%rbx
movslq %r15d,%r15
mov %r15,%rdx
callq 1080 <strncpy@plt>
movb $0x0,-0x32(%rbx,%r15,1)
lea 0x1(%r14),%rdi
mov $0x22,%esi
callq 10a0 <strchr@plt>
test %rax,%rax
jne 14e8 <func0+0x28>
mov %r12d,0x0(%r13)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
push r13
mov r13, rdx
push r12
xor r12d, r12d
push rbp
push rbx
mov rbx, rsi
sub rsp, 8
mov dword ptr [rdx], 0
jmp short loc_152A
loc_14E8:
lea rbp, [rax+1]
mov esi, 22h ; '"'
mov rdi, rbp
call _strchr
mov r14, rax
test rax, rax
jz short loc_1539
mov r15, rax
mov rdi, rbx
mov rsi, rbp
add r12d, 1
sub r15, rbp
add rbx, 32h ; '2'
movsxd r15, r15d
mov rdx, r15
call _strncpy
mov byte ptr [rbx+r15-32h], 0
lea rdi, [r14+1]
loc_152A:
mov esi, 22h ; '"'
call _strchr
test rax, rax
jnz short loc_14E8
loc_1539:
mov [r13+0], r12d
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, long long a2, _DWORD *a3)
{
int v4; // r12d
long long v6; // rbp
long long result; // rax
long long v8; // r14
long long v9; // rdi
long long v10; // r15
v4 = 0;
*a3 = 0;
while ( 1 )
{
result = strchr(a1, 34LL);
if ( !result )
break;
v6 = result + 1;
result = strchr(result + 1, 34LL);
v8 = result;
if ( !result )
break;
v9 = a2;
++v4;
a2 += 50LL;
v10 = (int)result - (int)v6;
strncpy(v9, v6, v10);
*(_BYTE *)(a2 + v10 - 50) = 0;
a1 = v8 + 1;
}
*a3 = v4;
return result;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
MOV dword ptr [RDX],0x0
JMP 0x0010152a
LAB_001014e8:
LEA RBP,[RAX + 0x1]
MOV ESI,0x22
MOV RDI,RBP
CALL 0x001010a0
MOV R14,RAX
TEST RAX,RAX
JZ 0x00101539
MOV R15,RAX
MOV RDI,RBX
MOV RSI,RBP
ADD R12D,0x1
SUB R15,RBP
ADD RBX,0x32
MOVSXD R15,R15D
MOV RDX,R15
CALL 0x00101080
MOV byte ptr [RBX + R15*0x1 + -0x32],0x0
LEA RDI,[R14 + 0x1]
LAB_0010152a:
MOV ESI,0x22
CALL 0x001010a0
TEST RAX,RAX
JNZ 0x001014e8
LAB_00101539:
MOV dword ptr [R13],R12D
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void func0(char *param_1,char *param_2,int *param_3)
{
char *pcVar1;
int iVar2;
size_t __n;
iVar2 = 0;
*param_3 = 0;
while( true ) {
pcVar1 = strchr(param_1,0x22);
if (pcVar1 == (char *)0x0) break;
pcVar1 = pcVar1 + 1;
param_1 = strchr(pcVar1,0x22);
if (param_1 == (char *)0x0) break;
iVar2 = iVar2 + 1;
__n = (size_t)((int)param_1 - (int)pcVar1);
strncpy(param_2,pcVar1,__n);
param_2[__n] = '\0';
param_1 = param_1 + 1;
param_2 = param_2 + 0x32;
}
*param_3 = iVar2;
return;
} |
6,147 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| void func0(const char *text, char values[][50], int *count) {
int index = 0;
*count = 0;
const char *start = NULL;
const char *end = NULL;
while ((start = strchr(text, '"')) != NULL) {
end = strchr(start + 1, '"');
if (end == NULL) break;
int len = end - (start + 1);
strncpy(values[index], start + 1, len);
values[index][len] = '\0';
index++;
text = end + 1;
}
*count = index;
}
| int main() {
char values[10][50];
int count, i;
func0("\"Python\", \"PHP\", \"Java\"", values, &count);
assert(count == 3);
assert(strcmp(values[0], "Python") == 0);
assert(strcmp(values[1], "PHP") == 0);
assert(strcmp(values[2], "Java") == 0);
func0("\"python\",\"program\",\"language\"", values, &count);
assert(count == 3);
assert(strcmp(values[0], "python") == 0);
assert(strcmp(values[1], "program") == 0);
assert(strcmp(values[2], "language") == 0);
func0("\"red\",\"blue\",\"green\",\"yellow\"", values, &count);
assert(count == 4);
assert(strcmp(values[0], "red") == 0);
assert(strcmp(values[1], "blue") == 0);
assert(strcmp(values[2], "green") == 0);
assert(strcmp(values[3], "yellow") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdx,%r13
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
movl $0x0,(%rdx)
jmp 152a <func0+0x6a>
nopl 0x0(%rax,%rax,1)
lea 0x1(%rax),%rbp
mov $0x22,%esi
mov %rbp,%rdi
callq 10a0 <strchr@plt>
mov %rax,%r14
test %rax,%rax
je 1539 <func0+0x79>
mov %rax,%r15
mov %rbx,%rdi
mov %rbp,%rsi
add $0x1,%r12d
sub %rbp,%r15
add $0x32,%rbx
movslq %r15d,%r15
mov %r15,%rdx
callq 1080 <strncpy@plt>
movb $0x0,-0x32(%rbx,%r15,1)
lea 0x1(%r14),%rdi
mov $0x22,%esi
callq 10a0 <strchr@plt>
test %rax,%rax
jne 14e8 <func0+0x28>
mov %r12d,0x0(%r13)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
push r13
mov r13, rdx
push r12
xor r12d, r12d
push rbp
mov rbp, rsi
push rbx
sub rsp, 8
mov dword ptr [rdx], 0
jmp short loc_150A
loc_14C8:
lea rbx, [rax+1]
mov esi, 22h ; '"'; c
mov rdi, rbx; s
call _strchr
mov r14, rax
test rax, rax
jz short loc_1519
mov r15, rax
mov rdi, rbp; dest
mov rsi, rbx; src
add r12d, 1
sub r15, rbx
add rbp, 32h ; '2'
movsxd r15, r15d
mov rdx, r15; n
call _strncpy
mov byte ptr [rbp+r15-32h], 0
lea rdi, [r14+1]; s
loc_150A:
mov esi, 22h ; '"'; c
call _strchr
test rax, rax
jnz short loc_14C8
loc_1519:
mov [r13+0], r12d
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | char * func0(const char *a1, char *a2, _DWORD *a3)
{
int v4; // r12d
const char *v6; // rbx
char *result; // rax
char *v8; // r14
char *v9; // rdi
size_t v10; // r15
v4 = 0;
*a3 = 0;
while ( 1 )
{
result = strchr(a1, 34);
if ( !result )
break;
v6 = result + 1;
result = strchr(result + 1, 34);
v8 = result;
if ( !result )
break;
v9 = a2;
++v4;
a2 += 50;
v10 = (int)result - (int)v6;
strncpy(v9, v6, v10);
a2[v10 - 50] = 0;
a1 = v8 + 1;
}
*a3 = v4;
return result;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,RSI
PUSH RBX
SUB RSP,0x8
MOV dword ptr [RDX],0x0
JMP 0x0010150a
LAB_001014c8:
LEA RBX,[RAX + 0x1]
MOV ESI,0x22
MOV RDI,RBX
CALL 0x001010a0
MOV R14,RAX
TEST RAX,RAX
JZ 0x00101519
MOV R15,RAX
MOV RDI,RBP
MOV RSI,RBX
ADD R12D,0x1
SUB R15,RBX
ADD RBP,0x32
MOVSXD R15,R15D
MOV RDX,R15
CALL 0x00101080
MOV byte ptr [RBP + R15*0x1 + -0x32],0x0
LEA RDI,[R14 + 0x1]
LAB_0010150a:
MOV ESI,0x22
CALL 0x001010a0
TEST RAX,RAX
JNZ 0x001014c8
LAB_00101519:
MOV dword ptr [R13],R12D
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void func0(char *param_1,char *param_2,int *param_3)
{
char *pcVar1;
int iVar2;
size_t __n;
iVar2 = 0;
*param_3 = 0;
while( true ) {
pcVar1 = strchr(param_1,0x22);
if (pcVar1 == (char *)0x0) break;
pcVar1 = pcVar1 + 1;
param_1 = strchr(pcVar1,0x22);
if (param_1 == (char *)0x0) break;
iVar2 = iVar2 + 1;
__n = (size_t)((int)param_1 - (int)pcVar1);
strncpy(param_2,pcVar1,__n);
param_2[__n] = '\0';
param_1 = param_1 + 1;
param_2 = param_2 + 0x32;
}
*param_3 = iVar2;
return;
} |
6,148 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] != arr[j]) {
cnt++;
}
}
}
return cnt;
}
| int main() {
int arr1[] = {1, 2, 1};
int arr2[] = {1, 1, 1, 1};
int arr3[] = {1, 2, 3, 4, 5};
assert(func0(arr1, 3) == 2);
assert(func0(arr2, 4) == 0);
assert(func0(arr3, 5) == 10);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d7 <func0+0x6e>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11cb <func0+0x62>
mov -0x8(%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 -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 11c7 <func0+0x5e>
addl $0x1,-0xc(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1193 <func0+0x2a>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0xc(%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_C], 0
mov [rbp+var_8], 0
jmp short loc_11D7
loc_1188:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11CB
loc_1193:
mov eax, [rbp+var_8]
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_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_11C7
add [rbp+var_C], 1
loc_11C7:
add [rbp+var_4], 1
loc_11CB:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1193
add [rbp+var_8], 1
loc_11D7:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) != *(_DWORD *)(4LL * j + a1) )
++v3;
}
}
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 + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d7
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011cb
LAB_00101193:
MOV EAX,dword ptr [RBP + -0x8]
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 + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x001011c7
ADD dword ptr [RBP + -0xc],0x1
LAB_001011c7:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011cb:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101193
ADD dword ptr [RBP + -0x8],0x1
LAB_001011d7:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_c = local_10, local_10 < param_2; local_10 = local_10 + 1) {
while (local_c = local_c + 1, local_c < param_2) {
if (*(int *)(param_1 + (long)local_10 * 4) != *(int *)(param_1 + (long)local_c * 4)) {
local_14 = local_14 + 1;
}
}
}
return local_14;
} |
6,149 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] != arr[j]) {
cnt++;
}
}
}
return cnt;
}
| int main() {
int arr1[] = {1, 2, 1};
int arr2[] = {1, 1, 1, 1};
int arr3[] = {1, 2, 3, 4, 5};
assert(func0(arr1, 3) == 2);
assert(func0(arr2, 4) == 0);
assert(func0(arr3, 5) == 10);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ab <func0+0x42>
lea -0x1(%rsi),%r9d
add $0x1,%r9
mov $0x1,%r8d
mov $0x0,%edx
jmp 119c <func0+0x33>
add $0x1,%edx
add $0x1,%rax
cmp %eax,%esi
jle 1198 <func0+0x2f>
cmp (%rdi,%rax,4),%ecx
jne 1186 <func0+0x1d>
jmp 1189 <func0+0x20>
add $0x1,%r8
cmp %r9,%r8
je 11b0 <func0+0x47>
mov -0x4(%rdi,%r8,4),%ecx
mov %r8,%rax
jmp 1191 <func0+0x28>
mov $0x0,%edx
mov %edx,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_11A6
mov r9d, esi
mov r8d, 1
mov edx, 0
jmp short loc_1197
loc_1181:
add edx, 1
loc_1184:
add rax, 1
cmp esi, eax
jle short loc_1193
loc_118C:
cmp ecx, [rdi+rax*4]
jnz short loc_1181
jmp short loc_1184
loc_1193:
add r8, 1
loc_1197:
cmp r8, r9
jz short loc_11AB
mov ecx, [rdi+r8*4-4]
mov rax, r8
jmp short loc_118C
loc_11A6:
mov edx, 0
loc_11AB:
mov eax, edx
retn | long long func0(long long a1, int a2)
{
long long v2; // r8
unsigned int v3; // edx
long long v4; // rax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = 1LL;
v3 = 0;
while ( v2 != a2 )
{
v4 = v2;
do
{
if ( *(_DWORD *)(a1 + 4 * v2 - 4) != *(_DWORD *)(a1 + 4 * v4) )
++v3;
++v4;
}
while ( a2 > (int)v4 );
++v2;
}
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a6
MOV R9D,ESI
MOV R8D,0x1
MOV EDX,0x0
JMP 0x00101197
LAB_00101181:
ADD EDX,0x1
LAB_00101184:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101193
LAB_0010118c:
CMP ECX,dword ptr [RDI + RAX*0x4]
JNZ 0x00101181
JMP 0x00101184
LAB_00101193:
ADD R8,0x1
LAB_00101197:
CMP R8,R9
JZ 0x001011ab
MOV ECX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
JMP 0x0010118c
LAB_001011a6:
MOV EDX,0x0
LAB_001011ab:
MOV EAX,EDX
RET | int func0(long param_1,uint param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
if ((int)param_2 < 1) {
iVar2 = 0;
}
else {
iVar2 = 0;
for (uVar3 = 1; uVar3 != param_2; uVar3 = uVar3 + 1) {
uVar1 = uVar3;
do {
if (*(int *)(param_1 + -4 + uVar3 * 4) != *(int *)(param_1 + uVar1 * 4)) {
iVar2 = iVar2 + 1;
}
uVar1 = uVar1 + 1;
} while ((int)uVar1 < (int)param_2);
}
}
return iVar2;
} |
6,150 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] != arr[j]) {
cnt++;
}
}
}
return cnt;
}
| int main() {
int arr1[] = {1, 2, 1};
int arr2[] = {1, 1, 1, 1};
int arr3[] = {1, 2, 3, 4, 5};
assert(func0(arr1, 3) == 2);
assert(func0(arr2, 4) == 0);
assert(func0(arr3, 5) == 10);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 136e <func0+0x4e>
lea -0x1(%rsi),%r9d
mov $0x1,%ecx
xor %r8d,%r8d
add $0x1,%r9
cmp %r9,%rcx
je 136a <func0+0x4a>
nopl (%rax)
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
nopw 0x0(%rax,%rax,1)
cmp (%rdi,%rax,4),%edx
je 1359 <func0+0x39>
add $0x1,%r8d
add $0x1,%rax
cmp %eax,%esi
jg 1350 <func0+0x30>
add $0x1,%rcx
cmp %r9,%rcx
jne 1340 <func0+0x20>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_12DE
movsxd r9, esi
mov ecx, 1
xor r8d, r8d
cmp rcx, r9
jz short loc_12DA
nop dword ptr [rax+rax+00000000h]
loc_12B0:
mov edx, [rdi+rcx*4-4]
mov rax, rcx
nop word ptr [rax+rax+00000000h]
loc_12C0:
cmp edx, [rdi+rax*4]
jz short loc_12C9
add r8d, 1
loc_12C9:
add rax, 1
cmp esi, eax
jg short loc_12C0
add rcx, 1
cmp rcx, r9
jnz short loc_12B0
loc_12DA:
mov eax, r8d
retn
loc_12DE:
xor r8d, r8d
mov eax, r8d
retn | long long func0(long long a1, int a2)
{
long long v2; // rcx
unsigned int i; // r8d
long long v4; // rax
if ( a2 <= 0 )
return 0LL;
v2 = 1LL;
for ( i = 0; v2 != a2; ++v2 )
{
v4 = v2;
do
{
if ( *(_DWORD *)(a1 + 4 * v2 - 4) != *(_DWORD *)(a1 + 4 * v4) )
++i;
++v4;
}
while ( a2 > (int)v4 );
}
return i;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012de
MOVSXD R9,ESI
MOV ECX,0x1
XOR R8D,R8D
CMP RCX,R9
JZ 0x001012da
NOP dword ptr [RAX + RAX*0x1]
LAB_001012b0:
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
NOP word ptr [RAX + RAX*0x1]
LAB_001012c0:
CMP EDX,dword ptr [RDI + RAX*0x4]
JZ 0x001012c9
ADD R8D,0x1
LAB_001012c9:
ADD RAX,0x1
CMP ESI,EAX
JG 0x001012c0
ADD RCX,0x1
CMP RCX,R9
JNZ 0x001012b0
LAB_001012da:
MOV EAX,R8D
RET
LAB_001012de:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
int iVar3;
if (param_2 < 1) {
return 0;
}
lVar2 = 1;
iVar3 = 0;
if ((long)param_2 != 1) {
do {
lVar1 = lVar2;
do {
if (*(int *)(param_1 + -4 + lVar2 * 4) != *(int *)(param_1 + lVar1 * 4)) {
iVar3 = iVar3 + 1;
}
lVar1 = lVar1 + 1;
} while ((int)lVar1 < param_2);
lVar2 = lVar2 + 1;
} while (lVar2 != param_2);
}
return iVar3;
} |
6,151 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] != arr[j]) {
cnt++;
}
}
}
return cnt;
}
| int main() {
int arr1[] = {1, 2, 1};
int arr2[] = {1, 1, 1, 1};
int arr3[] = {1, 2, 3, 4, 5};
assert(func0(arr1, 3) == 2);
assert(func0(arr2, 4) == 0);
assert(func0(arr3, 5) == 10);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 143d <func0+0x12d>
cmp $0x1,%esi
je 143d <func0+0x12d>
push %rbp
lea 0x4(%rdi),%r10
xor %r8d,%r8d
mov $0x1,%ecx
push %rbx
lea -0x1(%rsi),%ebp
mov $0x1,%ebx
pcmpeqd %xmm3,%xmm3
mov %esi,%r9d
mov %ebp,%eax
mov -0x4(%r10),%r11d
sub %ecx,%r9d
cmp %ecx,%esi
cmovle %ebx,%r9d
sub %ecx,%eax
cmp $0x3,%eax
jbe 1439 <func0+0x129>
cmp %ecx,%esi
jle 1439 <func0+0x129>
mov %r9d,%edx
movd %r11d,%xmm4
pxor %xmm1,%xmm1
mov %r10,%rax
shr $0x2,%edx
pshufd $0x0,%xmm4,%xmm2
shl $0x4,%rdx
add %r10,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
add $0x10,%rax
pcmpeqd %xmm2,%xmm0
pandn %xmm3,%xmm0
psubd %xmm0,%xmm1
cmp %rax,%rdx
jne 1388 <func0+0x78>
movdqa %xmm1,%xmm0
mov %r9d,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%edx
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
add %eax,%r8d
lea (%rdx,%rcx,1),%eax
cmp %edx,%r9d
je 1424 <func0+0x114>
movslq %eax,%r9
cmp (%rdi,%r9,4),%r11d
lea 0x0(,%r9,4),%rdx
setne %r9b
movzbl %r9b,%r9d
add %r9d,%r8d
lea 0x1(%rax),%r9d
cmp %r9d,%esi
jle 1424 <func0+0x114>
cmp 0x4(%rdi,%rdx,1),%r11d
je 13fe <func0+0xee>
add $0x1,%r8d
lea 0x2(%rax),%r9d
cmp %r9d,%esi
jle 1424 <func0+0x114>
cmp 0x8(%rdi,%rdx,1),%r11d
je 1412 <func0+0x102>
add $0x1,%r8d
add $0x3,%eax
cmp %esi,%eax
jge 1424 <func0+0x114>
cmp 0xc(%rdi,%rdx,1),%r11d
je 1424 <func0+0x114>
add $0x1,%r8d
add $0x1,%ecx
add $0x4,%r10
cmp %ecx,%esi
jne 1340 <func0+0x30>
mov %r8d,%eax
pop %rbx
pop %rbp
retq
mov %ecx,%eax
jmp 13d0 <func0+0xc0>
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle loc_1258
cmp esi, 1
jz loc_1258
push rbp
mov r11, rdi
lea r9, [rdi+4]
xor r8d, r8d
push rbx
mov ecx, 1
lea ebp, [rsi-1]
mov ebx, 1
pxor xmm3, xmm3
nop word ptr [rax+rax+00h]
loc_1178:
mov edi, esi
mov eax, ebp
mov r10d, [r9-4]
sub edi, ecx
cmp esi, ecx
cmovle edi, ebx
sub eax, ecx
cmp eax, 2
jbe loc_1254
cmp esi, ecx
jle loc_1254
mov edx, edi
movd xmm4, r10d
pxor xmm1, xmm1
mov rax, r9
shr edx, 2
pshufd xmm2, xmm4, 0
shl rdx, 4
add rdx, r9
nop word ptr [rax+rax+00000000h]
loc_11C0:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pcmpeqd xmm0, xmm2
pcmpeqd xmm0, xmm3
psubd xmm1, xmm0
cmp rax, rdx
jnz short loc_11C0
movdqa xmm0, xmm1
psrldq xmm0, 8
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
add r8d, eax
mov eax, edi
and eax, 0FFFFFFFCh
add eax, ecx
and edi, 3
jz short loc_123F
loc_1206:
movsxd rdx, eax
lea rdi, ds:0[rdx*4]
cmp r10d, [r11+rdx*4]
jz short loc_121B
add r8d, 1
loc_121B:
lea edx, [rax+1]
cmp esi, edx
jle short loc_123F
cmp r10d, [r11+rdi+4]
jz short loc_122D
add r8d, 1
loc_122D:
add eax, 2
cmp esi, eax
jle short loc_123F
cmp r10d, [r11+rdi+8]
jz short loc_123F
add r8d, 1
loc_123F:
add ecx, 1
add r9, 4
cmp esi, ecx
jnz loc_1178
mov eax, r8d
pop rbx
pop rbp
retn
loc_1254:
mov eax, ecx
jmp short loc_1206
loc_1258:
xor r8d, r8d
mov eax, r8d
retn | long long func0(long long a1, int a2)
{
const __m128i *v3; // r9
unsigned int v4; // r8d
int v5; // ecx
unsigned int v6; // r10d
unsigned int v7; // edi
__m128i v8; // xmm1
const __m128i *v9; // rax
__m128i v10; // xmm2
__m128i v11; // xmm0
__m128i v12; // xmm1
int v13; // eax
long long v14; // rdi
if ( a2 >= 2 )
{
v3 = (const __m128i *)(a1 + 4);
v4 = 0;
v5 = 1;
while ( 1 )
{
v6 = v3[-1].m128i_u32[3];
v7 = a2 - v5;
if ( a2 <= v5 )
v7 = 1;
if ( (unsigned int)(a2 - 1 - v5) <= 2 || a2 <= v5 )
break;
v8 = 0LL;
v9 = v3;
v10 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v6), 0);
do
{
v11 = _mm_loadu_si128(v9++);
v8 = _mm_sub_epi32(v8, _mm_cmpeq_epi32(_mm_cmpeq_epi32(v11, v10), (__m128i)0LL));
}
while ( v9 != &v3[v7 >> 2] );
v12 = _mm_add_epi32(v8, _mm_srli_si128(v8, 8));
v4 += _mm_cvtsi128_si32(_mm_add_epi32(v12, _mm_srli_si128(v12, 4)));
v13 = v5 + (v7 & 0xFFFFFFFC);
if ( (v7 & 3) != 0 )
goto LABEL_10;
LABEL_18:
++v5;
v3 = (const __m128i *)((char *)v3 + 4);
if ( a2 == v5 )
return v4;
}
v13 = v5;
LABEL_10:
v14 = 4LL * v13;
if ( v6 != *(_DWORD *)(a1 + v14) )
++v4;
if ( a2 > v13 + 1 )
{
if ( v6 != *(_DWORD *)(a1 + v14 + 4) )
++v4;
if ( a2 > v13 + 2 && v6 != *(_DWORD *)(a1 + v14 + 8) )
++v4;
}
goto LABEL_18;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101258
CMP ESI,0x1
JZ 0x00101258
PUSH RBP
MOV R11,RDI
LEA R9,[RDI + 0x4]
XOR R8D,R8D
PUSH RBX
MOV ECX,0x1
LEA EBP,[RSI + -0x1]
MOV EBX,0x1
PXOR XMM3,XMM3
NOP word ptr [RAX + RAX*0x1]
LAB_00101178:
MOV EDI,ESI
MOV EAX,EBP
MOV R10D,dword ptr [R9 + -0x4]
SUB EDI,ECX
CMP ESI,ECX
CMOVLE EDI,EBX
SUB EAX,ECX
CMP EAX,0x2
JBE 0x00101254
CMP ESI,ECX
JLE 0x00101254
MOV EDX,EDI
MOVD XMM4,R10D
PXOR XMM1,XMM1
MOV RAX,R9
SHR EDX,0x2
PSHUFD XMM2,XMM4,0x0
SHL RDX,0x4
ADD RDX,R9
NOP word ptr [RAX + RAX*0x1]
LAB_001011c0:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PCMPEQD XMM0,XMM2
PCMPEQD XMM0,XMM3
PSUBD XMM1,XMM0
CMP RAX,RDX
JNZ 0x001011c0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x8
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
ADD R8D,EAX
MOV EAX,EDI
AND EAX,0xfffffffc
ADD EAX,ECX
AND EDI,0x3
JZ 0x0010123f
LAB_00101206:
MOVSXD RDX,EAX
LEA RDI,[RDX*0x4]
CMP R10D,dword ptr [R11 + RDX*0x4]
JZ 0x0010121b
ADD R8D,0x1
LAB_0010121b:
LEA EDX,[RAX + 0x1]
CMP ESI,EDX
JLE 0x0010123f
CMP R10D,dword ptr [R11 + RDI*0x1 + 0x4]
JZ 0x0010122d
ADD R8D,0x1
LAB_0010122d:
ADD EAX,0x2
CMP ESI,EAX
JLE 0x0010123f
CMP R10D,dword ptr [R11 + RDI*0x1 + 0x8]
JZ 0x0010123f
ADD R8D,0x1
LAB_0010123f:
ADD ECX,0x1
ADD R9,0x4
CMP ESI,ECX
JNZ 0x00101178
MOV EAX,R8D
POP RBX
POP RBP
RET
LAB_00101254:
MOV EAX,ECX
JMP 0x00101206
LAB_00101258:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
uint uVar3;
int iVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int iVar9;
int iVar10;
int *piVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
if ((param_2 < 1) || (param_2 == 1)) {
return 0;
}
piVar11 = (int *)(param_1 + 4);
iVar10 = 0;
iVar9 = 1;
do {
iVar2 = piVar11[-1];
uVar3 = param_2 - iVar9;
if (param_2 <= iVar9) {
uVar3 = 1;
}
iVar12 = iVar9;
if (((uint)((param_2 + -1) - iVar9) < 3) || (param_2 <= iVar9)) {
LAB_00101206:
lVar1 = (long)iVar12 * 4;
if (iVar2 != *(int *)(param_1 + (long)iVar12 * 4)) {
iVar10 = iVar10 + 1;
}
if (iVar12 + 1 < param_2) {
if (iVar2 != *(int *)(param_1 + 4 + lVar1)) {
iVar10 = iVar10 + 1;
}
if ((iVar12 + 2 < param_2) && (iVar2 != *(int *)(param_1 + 8 + lVar1))) {
iVar10 = iVar10 + 1;
}
}
}
else {
iVar12 = 0;
iVar13 = 0;
iVar14 = 0;
iVar15 = 0;
piVar8 = piVar11;
do {
iVar4 = *piVar8;
piVar5 = piVar8 + 1;
piVar6 = piVar8 + 2;
piVar7 = piVar8 + 3;
piVar8 = piVar8 + 4;
iVar12 = iVar12 + (uint)(iVar4 != iVar2);
iVar13 = iVar13 + (uint)(*piVar5 != iVar2);
iVar14 = iVar14 + (uint)(*piVar6 != iVar2);
iVar15 = iVar15 + (uint)(*piVar7 != iVar2);
} while (piVar8 != piVar11 + (ulong)(uVar3 >> 2) * 4);
iVar10 = iVar10 + iVar12 + iVar14 + iVar13 + iVar15;
iVar12 = (uVar3 & 0xfffffffc) + iVar9;
if ((uVar3 & 3) != 0) goto LAB_00101206;
}
iVar9 = iVar9 + 1;
piVar11 = piVar11 + 1;
if (param_2 == iVar9) {
return iVar10;
}
} while( true );
} |
6,152 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* word, char* result) {
int length = strlen(word);
for (int i = 0; i < length; i++) {
result[i] = word[i];
}
result[length] = '\0'; // Null-terminate the resulting array
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("python", result), "python") == 0);
assert(strcmp(func0("Name", result), "Name") == 0);
assert(strcmp(func0("program", result), "program") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11f8 <func0+0x4f>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x8(%rbp),%edx
movslq %edx,%rcx
mov -0x20(%rbp),%rdx
add %rcx,%rdx
movzbl (%rax),%eax
mov %al,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 11d5 <func0+0x2c>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x20(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_8], 0
jmp short loc_11F8
loc_11D5:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
mov edx, [rbp+var_8]
movsxd rcx, edx
mov rdx, [rbp+var_20]
add rdx, rcx
movzx eax, byte ptr [rax]
mov [rdx], al
add [rbp+var_8], 1
loc_11F8:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jl short loc_11D5
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_20]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+var_20]
leave
retn | long long func0(const char *a1, long long a2)
{
int i; // [rsp+18h] [rbp-8h]
int v4; // [rsp+1Ch] [rbp-4h]
v4 = strlen(a1);
for ( i = 0; i < v4; ++i )
*(_BYTE *)(i + a2) = a1[i];
*(_BYTE *)(v4 + a2) = 0;
return a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011f8
LAB_001011d5:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,RCX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RDX],AL
ADD dword ptr [RBP + -0x8],0x1
LAB_001011f8:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x001011d5
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x20]
LEAVE
RET | long func0(char *param_1,long param_2)
{
size_t sVar1;
int local_10;
sVar1 = strlen(param_1);
for (local_10 = 0; local_10 < (int)sVar1; local_10 = local_10 + 1) {
*(char *)(param_2 + local_10) = param_1[local_10];
}
*(int *)(param_2 + (int)sVar1) = 0;
return param_2;
} |
6,153 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* word, char* result) {
int length = strlen(word);
for (int i = 0; i < length; i++) {
result[i] = word[i];
}
result[length] = '\0'; // Null-terminate the resulting array
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("python", result), "python") == 0);
assert(strcmp(func0("Name", result), "Name") == 0);
assert(strcmp(func0("program", result), "program") == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
test %ecx,%ecx
jle 11a5 <func0+0x3c>
lea -0x1(%rcx),%edi
mov $0x0,%eax
movzbl (%r8,%rax,1),%edx
mov %dl,(%rsi,%rax,1)
mov %rax,%rdx
add $0x1,%rax
cmp %rdi,%rdx
jne 1191 <func0+0x28>
movslq %ecx,%rcx
movb $0x0,(%rsi,%rcx,1)
mov %rsi,%rax
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rbx, rsi
call _strlen
test eax, eax
jle short loc_11DE
lea esi, [rax-1]
mov edx, 0
loc_11CA:
movzx ecx, byte ptr [rbp+rdx+0]
mov [rbx+rdx], cl
mov rcx, rdx
add rdx, 1
cmp rcx, rsi
jnz short loc_11CA
loc_11DE:
cdqe
mov byte ptr [rbx+rax], 0
mov rax, rbx
add rsp, 8
pop rbx
pop rbp
retn | long long func0(long long a1, long long a2)
{
int v2; // eax
long long v3; // rdx
long long v4; // rcx
v2 = strlen();
if ( v2 > 0 )
{
v3 = 0LL;
do
{
*(_BYTE *)(a2 + v3) = *(_BYTE *)(a1 + v3);
v4 = v3++;
}
while ( v4 != v2 - 1 );
}
*(_BYTE *)(a2 + v2) = 0;
return a2;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RBX,RSI
CALL 0x00101080
TEST EAX,EAX
JLE 0x001011de
LEA ESI,[RAX + -0x1]
MOV EDX,0x0
LAB_001011ca:
MOVZX ECX,byte ptr [RBP + RDX*0x1]
MOV byte ptr [RBX + RDX*0x1],CL
MOV RCX,RDX
ADD RDX,0x1
CMP RCX,RSI
JNZ 0x001011ca
LAB_001011de:
CDQE
MOV byte ptr [RBX + RAX*0x1],0x0
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
RET | long func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
bool bVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (0 < iVar1) {
uVar3 = 0;
do {
*(char *)(param_2 + uVar3) = param_1[uVar3];
bVar4 = uVar3 != iVar1 - 1;
uVar3 = uVar3 + 1;
} while (bVar4);
}
*(int1 *)(param_2 + iVar1) = 0;
return param_2;
} |
6,154 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* word, char* result) {
int length = strlen(word);
for (int i = 0; i < length; i++) {
result[i] = word[i];
}
result[length] = '\0'; // Null-terminate the resulting array
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("python", result), "python") == 0);
assert(strcmp(func0("Name", result), "Name") == 0);
assert(strcmp(func0("program", result), "program") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %rsi,%r12
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
test %eax,%eax
jle 12e4 <func0+0x34>
lea -0x1(%rax),%esi
xor %edx,%edx
movzbl (%rbx,%rdx,1),%ecx
mov %cl,(%r12,%rdx,1)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rcx,%rsi
jne 12d0 <func0+0x20>
cltq
movb $0x0,(%r12,%rax,1)
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r12
mov r12, rsi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test eax, eax
jle short loc_12E4
lea esi, [rax-1]
xor edx, edx
nop
loc_12D0:
movzx ecx, byte ptr [rbx+rdx]
mov [r12+rdx], cl
mov rcx, rdx
add rdx, 1
cmp rcx, rsi
jnz short loc_12D0
loc_12E4:
cdqe
mov byte ptr [r12+rax], 0
add rsp, 8
mov rax, r12
pop rbx
pop r12
retn | long long func0(long long a1, long long a2)
{
int v2; // eax
long long v3; // rdx
long long v4; // rcx
v2 = strlen();
if ( v2 > 0 )
{
v3 = 0LL;
do
{
*(_BYTE *)(a2 + v3) = *(_BYTE *)(a1 + v3);
v4 = v3++;
}
while ( v4 != v2 - 1 );
}
*(_BYTE *)(a2 + v2) = 0;
return a2;
} | func0:
ENDBR64
PUSH R12
MOV R12,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101080
TEST EAX,EAX
JLE 0x001012e4
LEA ESI,[RAX + -0x1]
XOR EDX,EDX
NOP
LAB_001012d0:
MOVZX ECX,byte ptr [RBX + RDX*0x1]
MOV byte ptr [R12 + RDX*0x1],CL
MOV RCX,RDX
ADD RDX,0x1
CMP RCX,RSI
JNZ 0x001012d0
LAB_001012e4:
CDQE
MOV byte ptr [R12 + RAX*0x1],0x0
ADD RSP,0x8
MOV RAX,R12
POP RBX
POP R12
RET | long func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
bool bVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (0 < iVar1) {
uVar3 = 0;
do {
*(char *)(param_2 + uVar3) = param_1[uVar3];
bVar4 = uVar3 != iVar1 - 1;
uVar3 = uVar3 + 1;
} while (bVar4);
}
*(int1 *)(param_2 + iVar1) = 0;
return param_2;
} |
6,155 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* word, char* result) {
int length = strlen(word);
for (int i = 0; i < length; i++) {
result[i] = word[i];
}
result[length] = '\0'; // Null-terminate the resulting array
return result;
}
| int main() {
char result[100];
assert(strcmp(func0("python", result), "python") == 0);
assert(strcmp(func0("Name", result), "Name") == 0);
assert(strcmp(func0("program", result), "program") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %rsi,%r12
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
test %eax,%eax
jle 1443 <func0+0x193>
lea 0xf(%rbx),%rcx
lea -0x1(%rax),%edx
sub %r12,%rcx
cmp $0x1e,%rcx
jbe 1458 <func0+0x1a8>
cmp $0xe,%edx
jbe 1458 <func0+0x1a8>
mov %eax,%ecx
xor %edx,%edx
shr $0x4,%ecx
shl $0x4,%rcx
nopw %cs:0x0(%rax,%rax,1)
movdqu (%rbx,%rdx,1),%xmm0
movups %xmm0,(%r12,%rdx,1)
add $0x10,%rdx
cmp %rcx,%rdx
jne 1300 <func0+0x50>
mov %eax,%edx
and $0xfffffff0,%edx
test $0xf,%al
je 1443 <func0+0x193>
movslq %edx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0x1(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0x2(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0x3(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0x4(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0x5(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0x6(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0x7(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0x8(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0x9(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0xa(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0xb(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0xc(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
lea 0xd(%rdx),%ecx
cmp %ecx,%eax
jle 1443 <func0+0x193>
movslq %ecx,%rcx
add $0xe,%edx
movzbl (%rbx,%rcx,1),%esi
mov %sil,(%r12,%rcx,1)
cmp %edx,%eax
jle 1443 <func0+0x193>
movslq %edx,%rdx
movzbl (%rbx,%rdx,1),%ecx
mov %cl,(%r12,%rdx,1)
cltq
movb $0x0,(%r12,%rax,1)
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %r12
retq
nopl (%rax)
mov %edx,%ecx
xor %edx,%edx
nopl 0x0(%rax)
movzbl (%rbx,%rdx,1),%esi
mov %sil,(%r12,%rdx,1)
mov %rdx,%rsi
add $0x1,%rdx
cmp %rcx,%rsi
jne 1460 <func0+0x1b0>
jmp 1443 <func0+0x193>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
call _strlen
mov rdx, rax
test eax, eax
jle short loc_1304
lea esi, [rax-1]
mov edi, eax
cmp esi, 6
jbe short loc_12E6
lea rcx, [rbp+1]
mov rax, rbx
sub rax, rcx
cmp rax, 0Eh
ja short loc_1318
loc_12E6:
xor eax, eax
nop dword ptr [rax+rax+00000000h]
loc_12F0:
movzx ecx, byte ptr [rbp+rax+0]
mov [rbx+rax], cl
mov rcx, rax
add rax, 1
cmp rcx, rsi
jnz short loc_12F0
loc_1304:
movsxd rdx, edx
mov rax, rbx
mov byte ptr [rbx+rdx], 0
add rsp, 8
pop rbx
pop rbp
retn
loc_1318:
cmp esi, 0Eh
jbe loc_1405
mov ecx, edx
xor eax, eax
shr ecx, 4
shl rcx, 4
nop dword ptr [rax+00h]
loc_1330:
movdqu xmm0, xmmword ptr [rbp+rax+0]
movups xmmword ptr [rbx+rax], xmm0
add rax, 10h
cmp rax, rcx
jnz short loc_1330
mov ecx, edx
and ecx, 0FFFFFFF0h
mov eax, ecx
test dl, 0Fh
jz short loc_1304
mov edi, edx
sub edi, ecx
lea esi, [rdi-1]
cmp esi, 6
jbe short loc_1370
loc_135B:
mov rsi, [rbp+rcx+0]
mov [rbx+rcx], rsi
mov ecx, edi
and ecx, 0FFFFFFF8h
add eax, ecx
and edi, 7
jz short loc_1304
loc_1370:
movsxd rcx, eax
movzx esi, byte ptr [rbp+rcx+0]
mov [rbx+rcx], sil
lea ecx, [rax+1]
cmp edx, ecx
jle short loc_1304
movsxd rcx, ecx
movzx esi, byte ptr [rbp+rcx+0]
mov [rbx+rcx], sil
lea ecx, [rax+2]
cmp edx, ecx
jle loc_1304
movsxd rcx, ecx
movzx esi, byte ptr [rbp+rcx+0]
mov [rbx+rcx], sil
lea ecx, [rax+3]
cmp edx, ecx
jle loc_1304
movsxd rcx, ecx
movzx esi, byte ptr [rbp+rcx+0]
mov [rbx+rcx], sil
lea ecx, [rax+4]
cmp edx, ecx
jle loc_1304
movsxd rcx, ecx
movzx esi, byte ptr [rbp+rcx+0]
mov [rbx+rcx], sil
lea ecx, [rax+5]
cmp edx, ecx
jle loc_1304
movsxd rcx, ecx
add eax, 6
movzx esi, byte ptr [rbp+rcx+0]
mov [rbx+rcx], sil
cmp edx, eax
jle loc_1304
cdqe
movzx ecx, byte ptr [rbp+rax+0]
mov [rbx+rax], cl
jmp loc_1304
loc_1405:
xor ecx, ecx
xor eax, eax
jmp loc_135B | long long func0(const char *a1, long long a2)
{
int v4; // eax
int v5; // edx
long long v6; // rsi
int v7; // edi
long long v8; // rax
long long v9; // rcx
long long result; // rax
long long v11; // rax
long long v12; // rcx
signed int v13; // eax
int v14; // ecx
int v15; // eax
v4 = strlen(a1);
v5 = v4;
if ( v4 <= 0 )
goto LABEL_6;
v6 = (unsigned int)(v4 - 1);
v7 = v4;
if ( (unsigned int)v6 <= 6 || (unsigned long long)(a2 - (_QWORD)(a1 + 1)) <= 0xE )
{
v8 = 0LL;
do
{
*(_BYTE *)(a2 + v8) = a1[v8];
v9 = v8++;
}
while ( v9 != v6 );
goto LABEL_6;
}
if ( (unsigned int)v6 <= 0xE )
{
v12 = 0LL;
v13 = 0;
}
else
{
v11 = 0LL;
do
{
*(__m128i *)(a2 + v11) = _mm_loadu_si128((const __m128i *)&a1[v11]);
v11 += 16LL;
}
while ( v11 != 16LL * ((unsigned int)v5 >> 4) );
v12 = v5 & 0xFFFFFFF0;
v13 = v5 & 0xFFFFFFF0;
if ( (v5 & 0xF) == 0 )
goto LABEL_6;
v7 = v5 - v12;
if ( (unsigned int)(v5 - v12 - 1) <= 6 )
goto LABEL_13;
}
*(_QWORD *)(a2 + v12) = *(_QWORD *)&a1[v12];
v13 += v7 & 0xFFFFFFF8;
if ( (v7 & 7) == 0 )
goto LABEL_6;
LABEL_13:
*(_BYTE *)(a2 + v13) = a1[v13];
if ( v5 > v13 + 1 )
{
*(_BYTE *)(a2 + v13 + 1) = a1[v13 + 1];
if ( v5 > v13 + 2 )
{
*(_BYTE *)(a2 + v13 + 2) = a1[v13 + 2];
if ( v5 > v13 + 3 )
{
*(_BYTE *)(a2 + v13 + 3) = a1[v13 + 3];
if ( v5 > v13 + 4 )
{
*(_BYTE *)(a2 + v13 + 4) = a1[v13 + 4];
v14 = v13 + 5;
if ( v5 > v13 + 5 )
{
v15 = v13 + 6;
*(_BYTE *)(a2 + v14) = a1[v14];
if ( v5 > v15 )
*(_BYTE *)(a2 + v15) = a1[v15];
}
}
}
}
}
LABEL_6:
result = a2;
*(_BYTE *)(a2 + v5) = 0;
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
CALL 0x00101080
MOV RDX,RAX
TEST EAX,EAX
JLE 0x00101304
LEA ESI,[RAX + -0x1]
MOV EDI,EAX
CMP ESI,0x6
JBE 0x001012e6
LEA RCX,[RBP + 0x1]
MOV RAX,RBX
SUB RAX,RCX
CMP RAX,0xe
JA 0x00101318
LAB_001012e6:
XOR EAX,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001012f0:
MOVZX ECX,byte ptr [RBP + RAX*0x1]
MOV byte ptr [RBX + RAX*0x1],CL
MOV RCX,RAX
ADD RAX,0x1
CMP RCX,RSI
JNZ 0x001012f0
LAB_00101304:
MOVSXD RDX,EDX
MOV RAX,RBX
MOV byte ptr [RBX + RDX*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00101318:
CMP ESI,0xe
JBE 0x00101405
MOV ECX,EDX
XOR EAX,EAX
SHR ECX,0x4
SHL RCX,0x4
NOP dword ptr [RAX]
LAB_00101330:
MOVDQU XMM0,xmmword ptr [RBP + RAX*0x1]
MOVUPS xmmword ptr [RBX + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,RCX
JNZ 0x00101330
MOV ECX,EDX
AND ECX,0xfffffff0
MOV EAX,ECX
TEST DL,0xf
JZ 0x00101304
MOV EDI,EDX
SUB EDI,ECX
LEA ESI,[RDI + -0x1]
CMP ESI,0x6
JBE 0x00101370
LAB_0010135b:
MOV RSI,qword ptr [RBP + RCX*0x1]
MOV qword ptr [RBX + RCX*0x1],RSI
MOV ECX,EDI
AND ECX,0xfffffff8
ADD EAX,ECX
AND EDI,0x7
JZ 0x00101304
LAB_00101370:
MOVSXD RCX,EAX
MOVZX ESI,byte ptr [RBP + RCX*0x1]
MOV byte ptr [RBX + RCX*0x1],SIL
LEA ECX,[RAX + 0x1]
CMP EDX,ECX
JLE 0x00101304
MOVSXD RCX,ECX
MOVZX ESI,byte ptr [RBP + RCX*0x1]
MOV byte ptr [RBX + RCX*0x1],SIL
LEA ECX,[RAX + 0x2]
CMP EDX,ECX
JLE 0x00101304
MOVSXD RCX,ECX
MOVZX ESI,byte ptr [RBP + RCX*0x1]
MOV byte ptr [RBX + RCX*0x1],SIL
LEA ECX,[RAX + 0x3]
CMP EDX,ECX
JLE 0x00101304
MOVSXD RCX,ECX
MOVZX ESI,byte ptr [RBP + RCX*0x1]
MOV byte ptr [RBX + RCX*0x1],SIL
LEA ECX,[RAX + 0x4]
CMP EDX,ECX
JLE 0x00101304
MOVSXD RCX,ECX
MOVZX ESI,byte ptr [RBP + RCX*0x1]
MOV byte ptr [RBX + RCX*0x1],SIL
LEA ECX,[RAX + 0x5]
CMP EDX,ECX
JLE 0x00101304
MOVSXD RCX,ECX
ADD EAX,0x6
MOVZX ESI,byte ptr [RBP + RCX*0x1]
MOV byte ptr [RBX + RCX*0x1],SIL
CMP EDX,EAX
JLE 0x00101304
CDQE
MOVZX ECX,byte ptr [RBP + RAX*0x1]
MOV byte ptr [RBX + RAX*0x1],CL
JMP 0x00101304
LAB_00101405:
XOR ECX,ECX
XOR EAX,EAX
JMP 0x0010135b | long func0(char *param_1,long param_2)
{
int8 uVar1;
uint uVar2;
int iVar3;
size_t sVar4;
ulong uVar5;
long lVar6;
uint uVar7;
int iVar8;
uint uVar9;
bool bVar10;
sVar4 = strlen(param_1);
uVar2 = (uint)sVar4;
if ((int)uVar2 < 1) goto LAB_00101304;
uVar9 = uVar2 - 1;
if ((uVar9 < 7) || ((ulong)(param_2 - (long)(param_1 + 1)) < 0xf)) {
uVar5 = 0;
do {
*(char *)(param_2 + uVar5) = param_1[uVar5];
bVar10 = uVar5 != uVar9;
uVar5 = uVar5 + 1;
} while (bVar10);
goto LAB_00101304;
}
if (uVar9 < 0xf) {
uVar5 = 0;
uVar7 = 0;
uVar9 = uVar2;
LAB_0010135b:
*(int8 *)(param_2 + uVar5) = *(int8 *)(param_1 + uVar5);
uVar7 = uVar7 + (uVar9 & 0xfffffff8);
if ((uVar9 & 7) == 0) goto LAB_00101304;
}
else {
lVar6 = 0;
do {
uVar1 = *(int8 *)(param_1 + lVar6 + 8);
*(int8 *)(param_2 + lVar6) = *(int8 *)(param_1 + lVar6);
((int8 *)(param_2 + lVar6))[1] = uVar1;
lVar6 = lVar6 + 0x10;
} while (lVar6 != (sVar4 >> 4 & 0xfffffff) << 4);
uVar7 = uVar2 & 0xfffffff0;
uVar5 = (ulong)uVar7;
if ((sVar4 & 0xf) == 0) goto LAB_00101304;
uVar9 = uVar2 - uVar7;
if (6 < (uVar2 - uVar7) - 1) goto LAB_0010135b;
}
*(char *)(param_2 + (int)uVar7) = param_1[(int)uVar7];
iVar8 = uVar7 + 1;
if (iVar8 < (int)uVar2) {
*(char *)(param_2 + iVar8) = param_1[iVar8];
iVar8 = uVar7 + 2;
if (iVar8 < (int)uVar2) {
*(char *)(param_2 + iVar8) = param_1[iVar8];
iVar8 = uVar7 + 3;
if (iVar8 < (int)uVar2) {
*(char *)(param_2 + iVar8) = param_1[iVar8];
iVar8 = uVar7 + 4;
if (iVar8 < (int)uVar2) {
*(char *)(param_2 + iVar8) = param_1[iVar8];
iVar8 = uVar7 + 5;
if (iVar8 < (int)uVar2) {
iVar3 = uVar7 + 6;
*(char *)(param_2 + iVar8) = param_1[iVar8];
if (iVar3 < (int)uVar2) {
*(char *)(param_2 + iVar3) = param_1[iVar3];
}
}
}
}
}
}
LAB_00101304:
*(int *)(param_2 + (int)uVar2) = 0;
return param_2;
} |
6,156 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 0)
return 0;
else
return n % 10 + func0(n / 10);
}
| int main() {
assert(func0(345) == 12);
assert(func0(12) == 3);
assert(func0(97) == 16);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jne 1166 <func0+0x1d>
mov $0x0,%eax
jmp 11b6 <func0+0x6d>
mov -0x14(%rbp),%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%ebx
mov %ebx,%eax
shl $0x2,%eax
add %ebx,%eax
add %eax,%eax
mov %edx,%ebx
sub %eax,%ebx
mov -0x14(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,%edi
callq 1149 <func0>
add %ebx,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jnz short loc_1166
mov eax, 0
jmp short loc_11B6
loc_1166:
mov edx, [rbp+var_14]
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
mov ecx, eax
sar ecx, 2
mov eax, edx
sar eax, 1Fh
mov ebx, ecx
sub ebx, eax
mov eax, ebx
shl eax, 2
add eax, ebx
add eax, eax
mov ebx, edx
sub ebx, eax
mov eax, [rbp+var_14]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov edi, eax
call func0
add eax, ebx
loc_11B6:
mov rbx, [rbp+var_8]
leave
retn | long long func0(int a1)
{
if ( a1 )
return a1 % 10 + (unsigned int)func0((unsigned int)(a1 / 10));
else
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00101166
MOV EAX,0x0
JMP 0x001011b6
LAB_00101166:
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV ECX,EAX
SAR ECX,0x2
MOV EAX,EDX
SAR EAX,0x1f
MOV EBX,ECX
SUB EBX,EAX
MOV EAX,EBX
SHL EAX,0x2
ADD EAX,EBX
ADD EAX,EAX
MOV EBX,EDX
SUB EBX,EAX
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV EDI,EAX
CALL 0x00101149
ADD EAX,EBX
LAB_001011b6:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int func0(int param_1)
{
int iVar1;
if (param_1 == 0) {
iVar1 = 0;
}
else {
iVar1 = func0(param_1 / 10);
iVar1 = iVar1 + param_1 % 10;
}
return iVar1;
} |
6,157 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 0)
return 0;
else
return n % 10 + func0(n / 10);
}
| int main() {
assert(func0(345) == 12);
assert(func0(12) == 3);
assert(func0(97) == 16);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebx
test %edi,%edi
jne 1162 <func0+0x19>
mov %ebx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
movslq %edi,%rbp
imul $0x66666667,%rbp,%rbp
sar $0x22,%rbp
mov %edi,%eax
sar $0x1f,%eax
sub %eax,%ebp
mov %ebp,%edi
callq 1149 <func0>
mov %eax,%edx
lea 0x0(%rbp,%rbp,4),%eax
add %eax,%eax
sub %eax,%ebx
add %edx,%ebx
jmp 1159 <func0+0x10>
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov ebx, edi
test edi, edi
jnz short loc_1162
loc_1159:
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
retn
loc_1162:
movsxd rbp, edi
imul rbp, 66666667h
sar rbp, 22h
mov eax, edi
sar eax, 1Fh
sub ebp, eax
mov edi, ebp
call func0
mov edx, eax
lea eax, [rbp+rbp*4+0]
add eax, eax
sub ebx, eax
add ebx, edx
jmp short loc_1159 | long long func0(signed int a1)
{
unsigned int v1; // ebx
v1 = a1;
if ( a1 )
return (unsigned int)func0((unsigned int)(a1 / 10)) + a1 % 10;
return v1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
TEST EDI,EDI
JNZ 0x00101162
LAB_00101159:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00101162:
MOVSXD RBP,EDI
IMUL RBP,RBP,0x66666667
SAR RBP,0x22
MOV EAX,EDI
SAR EAX,0x1f
SUB EBP,EAX
MOV EDI,EBP
CALL 0x00101149
MOV EDX,EAX
LEA EAX,[RBP + RBP*0x4]
ADD EAX,EAX
SUB EBX,EAX
ADD EBX,EDX
JMP 0x00101159 | int func0(int param_1)
{
int iVar1;
if (param_1 != 0) {
iVar1 = func0(param_1 / 10);
param_1 = param_1 % 10 + iVar1;
}
return param_1;
} |
6,158 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 0)
return 0;
else
return n % 10 + func0(n / 10);
}
| int main() {
assert(func0(345) == 12);
assert(func0(12) == 3);
assert(func0(97) == 16);
return 0;
}
| O2 | c | func0:
endbr64
xor %r8d,%r8d
test %edi,%edi
je 1179 <func0+0x39>
nopl 0x0(%rax,%rax,1)
movslq %edi,%rax
mov %edi,%edx
imul $0x66666667,%rax,%rax
sar $0x1f,%edx
sar $0x22,%rax
sub %edx,%eax
mov %eax,%edx
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%edi
mov %edi,%eax
mov %edx,%edi
add %eax,%r8d
test %edx,%edx
jne 1150 <func0+0x10>
mov %r8d,%eax
retq
nopl (%rax)
| func0:
endbr64
xor r8d, r8d
test edi, edi
jz short loc_1179
nop dword ptr [rax+rax+00h]
loc_1150:
movsxd rax, edi
mov edx, edi
imul rax, 66666667h
sar edx, 1Fh
sar rax, 22h
sub eax, edx
lea ecx, [rax+rax*4]
mov edx, eax
mov eax, edi
add ecx, ecx
mov edi, edx
sub eax, ecx
add r8d, eax
test edx, edx
jnz short loc_1150
loc_1179:
mov eax, r8d
retn | long long func0(int a1)
{
unsigned int i; // r8d
int v2; // eax
int v3; // ecx
for ( i = 0; a1; i += v2 - v3 )
{
v2 = a1;
v3 = 10 * (a1 / 10);
a1 /= 10;
}
return i;
} | func0:
ENDBR64
XOR R8D,R8D
TEST EDI,EDI
JZ 0x00101179
NOP dword ptr [RAX + RAX*0x1]
LAB_00101150:
MOVSXD RAX,EDI
MOV EDX,EDI
IMUL RAX,RAX,0x66666667
SAR EDX,0x1f
SAR RAX,0x22
SUB EAX,EDX
LEA ECX,[RAX + RAX*0x4]
MOV EDX,EAX
MOV EAX,EDI
ADD ECX,ECX
MOV EDI,EDX
SUB EAX,ECX
ADD R8D,EAX
TEST EDX,EDX
JNZ 0x00101150
LAB_00101179:
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
iVar2 = 0;
if (param_1 != 0) {
do {
iVar1 = param_1 / 10;
iVar2 = iVar2 + param_1 % 10;
param_1 = iVar1;
} while (iVar1 != 0);
}
return iVar2;
} |
6,159 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 0)
return 0;
else
return n % 10 + func0(n / 10);
}
| int main() {
assert(func0(345) == 12);
assert(func0(12) == 3);
assert(func0(97) == 16);
return 0;
}
| O3 | c | func0:
endbr64
xor %r8d,%r8d
test %edi,%edi
je 1179 <func0+0x39>
nopl 0x0(%rax,%rax,1)
movslq %edi,%rax
mov %edi,%edx
imul $0x66666667,%rax,%rax
sar $0x1f,%edx
sar $0x22,%rax
sub %edx,%eax
mov %eax,%edx
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%edi
mov %edi,%eax
mov %edx,%edi
add %eax,%r8d
test %edx,%edx
jne 1150 <func0+0x10>
mov %r8d,%eax
retq
nopl (%rax)
| func0:
endbr64
xor esi, esi
test edi, edi
jz short loc_1178
nop word ptr [rax+rax+00h]
loc_1150:
movsxd rax, edi
mov edx, edi
imul rax, 66666667h
sar edx, 1Fh
sar rax, 22h
sub eax, edx
lea ecx, [rax+rax*4]
mov edx, eax
mov eax, edi
add ecx, ecx
mov edi, edx
sub eax, ecx
add esi, eax
test edx, edx
jnz short loc_1150
loc_1178:
mov eax, esi
retn | long long func0(int a1)
{
unsigned int i; // esi
int v2; // eax
int v3; // ecx
for ( i = 0; a1; i += v2 - v3 )
{
v2 = a1;
v3 = 10 * (a1 / 10);
a1 /= 10;
}
return i;
} | func0:
ENDBR64
XOR ESI,ESI
TEST EDI,EDI
JZ 0x00101178
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
MOVSXD RAX,EDI
MOV EDX,EDI
IMUL RAX,RAX,0x66666667
SAR EDX,0x1f
SAR RAX,0x22
SUB EAX,EDX
LEA ECX,[RAX + RAX*0x4]
MOV EDX,EAX
MOV EAX,EDI
ADD ECX,ECX
MOV EDI,EDX
SUB EAX,ECX
ADD ESI,EAX
TEST EDX,EDX
JNZ 0x00101150
LAB_00101178:
MOV EAX,ESI
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
iVar2 = 0;
if (param_1 != 0) {
do {
iVar1 = param_1 / 10;
iVar2 = iVar2 + param_1 % 10;
param_1 = iVar1;
} while (iVar1 != 0);
}
return iVar2;
} |
6,160 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int list1[], int size) {
for (int i = 0; i < size - 1; i++) {
if (list1[i] > list1[i + 1]) {
return false;
}
}
return true;
}
| int main() {
int list1[] = {1,2,4,6,8,10,12,14,16,17};
int list2[] = {1, 2, 4, 6, 8, 10, 12, 14, 20, 17};
int list3[] = {1, 2, 4, 6, 8, 10, 15, 14, 20};
assert(func0(list1, 10) == true);
assert(func0(list2, 10) == false);
assert(func0(list3, 9) == 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 11c0 <func0+0x57>
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
jle 11bc <func0+0x53>
mov $0x0,%eax
jmp 11d0 <func0+0x67>
addl $0x1,-0x4(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x4(%rbp)
jl 1181 <func0+0x18>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_11C0
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
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_11BC
mov eax, 0
jmp short loc_11D0
loc_11BC:
add [rbp+var_4], 1
loc_11C0:
mov eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_4], eax
jl short loc_1181
mov eax, 1
loc_11D0:
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2 - 1; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) > *(_DWORD *)(4 * (i + 1LL) + a1) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c0
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
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x001011bc
MOV EAX,0x0
JMP 0x001011d0
LAB_001011bc:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c0:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JL 0x00101181
MOV EAX,0x1
LAB_001011d0:
POP RBP
RET | int8 func0(long param_1,int param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 + -1 <= local_c) {
return 1;
}
if (*(int *)(param_1 + ((long)local_c + 1) * 4) < *(int *)(param_1 + (long)local_c * 4)) break;
local_c = local_c + 1;
}
return 0;
} |
6,161 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int list1[], int size) {
for (int i = 0; i < size - 1; i++) {
if (list1[i] > list1[i + 1]) {
return false;
}
}
return true;
}
| int main() {
int list1[] = {1,2,4,6,8,10,12,14,16,17};
int list2[] = {1, 2, 4, 6, 8, 10, 12, 14, 20, 17};
int list3[] = {1, 2, 4, 6, 8, 10, 15, 14, 20};
assert(func0(list1, 10) == true);
assert(func0(list2, 10) == false);
assert(func0(list3, 9) == false);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 1193 <func0+0x2a>
mov %rdi,%rax
lea -0x2(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdx
mov 0x4(%rax),%ecx
cmp %ecx,(%rax)
jg 1199 <func0+0x30>
add $0x4,%rax
cmp %rdx,%rax
jne 117d <func0+0x14>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
cmp esi, 1
jle short loc_1193
mov rax, rdi
lea edx, [rsi-2]
lea rdx, [rdi+rdx*4+4]
loc_117D:
mov ecx, [rax+4]
cmp [rax], ecx
jg short loc_1199
add rax, 4
cmp rax, rdx
jnz short loc_117D
mov eax, 1
retn
loc_1193:
mov eax, 1
retn
loc_1199:
mov eax, 0
retn | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
if ( a2 <= 1 )
return 1LL;
v2 = a1;
while ( *v2 <= v2[1] )
{
if ( ++v2 == &a1[a2 - 2 + 1] )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101193
MOV RAX,RDI
LEA EDX,[RSI + -0x2]
LEA RDX,[RDI + RDX*0x4 + 0x4]
LAB_0010117d:
MOV ECX,dword ptr [RAX + 0x4]
CMP dword ptr [RAX],ECX
JG 0x00101199
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x0010117d
MOV EAX,0x1
RET
LAB_00101193:
MOV EAX,0x1
RET
LAB_00101199:
MOV EAX,0x0
RET | int8 func0(int *param_1,int param_2)
{
int *piVar1;
if (param_2 < 2) {
return 1;
}
piVar1 = param_1 + (ulong)(param_2 - 2) + 1;
do {
if (param_1[1] < *param_1) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return 1;
} |
6,162 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int list1[], int size) {
for (int i = 0; i < size - 1; i++) {
if (list1[i] > list1[i + 1]) {
return false;
}
}
return true;
}
| int main() {
int list1[] = {1,2,4,6,8,10,12,14,16,17};
int list2[] = {1, 2, 4, 6, 8, 10, 12, 14, 20, 17};
int list3[] = {1, 2, 4, 6, 8, 10, 15, 14, 20};
assert(func0(list1, 10) == true);
assert(func0(list2, 10) == false);
assert(func0(list3, 9) == false);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 1340 <func0+0x30>
lea -0x2(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1331 <func0+0x21>
nopl 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1340 <func0+0x30>
mov 0x4(%rdi),%edx
cmp %edx,(%rdi)
jle 1328 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
cmp esi, 1
jle short loc_1310
lea eax, [rsi-2]
lea rax, [rdi+rax*4+4]
jmp short loc_1301
loc_12F8:
add rdi, 4
cmp rdi, rax
jz short loc_1310
loc_1301:
mov edx, [rdi+4]
cmp [rdi], edx
jle short loc_12F8
xor eax, eax
retn
loc_1310:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rax
if ( a2 <= 1 )
return 1LL;
v2 = (long long)&a1[a2 - 2 + 1];
while ( *a1 <= a1[1] )
{
if ( ++a1 == (_DWORD *)v2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101310
LEA EAX,[RSI + -0x2]
LEA RAX,[RDI + RAX*0x4 + 0x4]
JMP 0x00101301
LAB_001012f8:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101310
LAB_00101301:
MOV EDX,dword ptr [RDI + 0x4]
CMP dword ptr [RDI],EDX
JLE 0x001012f8
XOR EAX,EAX
RET
LAB_00101310:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2)
{
int *piVar1;
if (1 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 2) + 1;
do {
if (param_1[1] < *param_1) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 1;
} |
6,163 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int list1[], int size) {
for (int i = 0; i < size - 1; i++) {
if (list1[i] > list1[i + 1]) {
return false;
}
}
return true;
}
| int main() {
int list1[] = {1,2,4,6,8,10,12,14,16,17};
int list2[] = {1, 2, 4, 6, 8, 10, 12, 14, 20, 17};
int list3[] = {1, 2, 4, 6, 8, 10, 15, 14, 20};
assert(func0(list1, 10) == true);
assert(func0(list2, 10) == false);
assert(func0(list3, 9) == false);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 1318 <func0+0x38>
lea -0x2(%rsi),%ecx
mov (%rdi),%edx
lea 0x4(%rdi),%rax
lea 0x8(%rdi,%rcx,4),%rsi
jmp 1309 <func0+0x29>
nopl 0x0(%rax)
add $0x4,%rax
cmp %rsi,%rax
je 1318 <func0+0x38>
mov %edx,%ecx
mov (%rax),%edx
cmp %ecx,%edx
jge 1300 <func0+0x20>
xor %eax,%eax
retq
nopl 0x0(%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
cmp esi, 1
jle short loc_1178
lea ecx, [rsi-2]
mov edx, [rdi]
lea rax, [rdi+4]
lea rsi, [rdi+rcx*4+8]
jmp short loc_1169
loc_1160:
add rax, 4
cmp rax, rsi
jz short loc_1178
loc_1169:
mov ecx, edx
mov edx, [rax]
cmp edx, ecx
jge short loc_1160
xor eax, eax
retn
loc_1178:
mov eax, 1
retn | long long func0(int *a1, int a2)
{
int v2; // edx
int *v3; // rax
long long v4; // rsi
int v5; // ecx
if ( a2 <= 1 )
return 1LL;
v2 = *a1;
v3 = a1 + 1;
v4 = (long long)&a1[a2 - 2 + 2];
while ( 1 )
{
v5 = v2;
v2 = *v3;
if ( *v3 < v5 )
break;
if ( ++v3 == (int *)v4 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101178
LEA ECX,[RSI + -0x2]
MOV EDX,dword ptr [RDI]
LEA RAX,[RDI + 0x4]
LEA RSI,[RDI + RCX*0x4 + 0x8]
JMP 0x00101169
LAB_00101160:
ADD RAX,0x4
CMP RAX,RSI
JZ 0x00101178
LAB_00101169:
MOV ECX,EDX
MOV EDX,dword ptr [RAX]
CMP EDX,ECX
JGE 0x00101160
XOR EAX,EAX
RET
LAB_00101178:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
if (1 < param_2) {
piVar2 = param_1 + 1;
iVar3 = *param_1;
do {
iVar1 = *piVar2;
if (iVar1 < iVar3) {
return 0;
}
piVar2 = piVar2 + 1;
iVar3 = iVar1;
} while (piVar2 != param_1 + (ulong)(param_2 - 2) + 2);
}
return 1;
} |
6,164 | func0 |
#include <assert.h>
#include <stdlib.h>
// Define a function to create an array of empty dictionaries
struct EmptyDict {
// We can use an empty struct to represent an empty dictionary
};
| struct EmptyDict* func0(int length) {
struct EmptyDict* array = malloc(sizeof(struct EmptyDict) * length);
return array;
}
| int main() {
// Test the function with different lengths
assert(func0(5) != NULL);
assert(func0(6) != NULL);
assert(func0(7) != NULL);
// Free the allocated memory after using
free(func0(5));
free(func0(6));
free(func0(7));
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov $0x0,%edi
callq 1090 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov edi, 0; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
leave
retn | void *func0()
{
return malloc(0LL);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV EDI,0x0
CALL 0x00101090
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(void)
{
void *pvVar1;
pvVar1 = malloc(0);
return pvVar1;
} |
6,165 | func0 |
#include <assert.h>
#include <stdlib.h>
// Define a function to create an array of empty dictionaries
struct EmptyDict {
// We can use an empty struct to represent an empty dictionary
};
| struct EmptyDict* func0(int length) {
struct EmptyDict* array = malloc(sizeof(struct EmptyDict) * length);
return array;
}
| int main() {
// Test the function with different lengths
assert(func0(5) != NULL);
assert(func0(6) != NULL);
assert(func0(7) != NULL);
// Free the allocated memory after using
free(func0(5));
free(func0(6));
free(func0(7));
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
mov $0x0,%edi
callq 1070 <malloc@plt>
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
mov edi, 0
call _malloc
add rsp, 8
retn | long long func0()
{
return malloc(0LL);
} | func0:
ENDBR64
SUB RSP,0x8
MOV EDI,0x0
CALL 0x00101070
ADD RSP,0x8
RET | void func0(void)
{
malloc(0);
return;
} |
6,166 | func0 |
#include <assert.h>
#include <stdlib.h>
// Define a function to create an array of empty dictionaries
struct EmptyDict {
// We can use an empty struct to represent an empty dictionary
};
| struct EmptyDict* func0(int length) {
struct EmptyDict* array = malloc(sizeof(struct EmptyDict) * length);
return array;
}
| int main() {
// Test the function with different lengths
assert(func0(5) != NULL);
assert(func0(6) != NULL);
assert(func0(7) != NULL);
// Free the allocated memory after using
free(func0(5));
free(func0(6));
free(func0(7));
return 0;
}
| O2 | c | func0:
endbr64
xor %edi,%edi
jmpq 1070 <malloc@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
xor edi, edi
jmp _malloc | long long func0()
{
return malloc(0LL);
} | func0:
ENDBR64
XOR EDI,EDI
JMP 0x00101070 | void func0(void)
{
malloc(0);
return;
} |
6,167 | func0 |
#include <assert.h>
#include <stdlib.h>
// Define a function to create an array of empty dictionaries
struct EmptyDict {
// We can use an empty struct to represent an empty dictionary
};
| struct EmptyDict* func0(int length) {
struct EmptyDict* array = malloc(sizeof(struct EmptyDict) * length);
return array;
}
| int main() {
// Test the function with different lengths
assert(func0(5) != NULL);
assert(func0(6) != NULL);
assert(func0(7) != NULL);
// Free the allocated memory after using
free(func0(5));
free(func0(6));
free(func0(7));
return 0;
}
| O3 | c | func0:
endbr64
xor %edi,%edi
jmpq 1070 <malloc@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
xor edi, edi; size
jmp _malloc | void *func0()
{
return malloc(0LL);
} | func0:
ENDBR64
XOR EDI,EDI
JMP 0x00101070 | void func0(void)
{
malloc(0);
return;
} |
6,168 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare two strings for qsort
int cmpfunc(const void * a, const void * b) {
const char **sa = (const char **)a;
const char **sb = (const char **)b;
return strcmp(*sa, *sb);
}
// Function to sort sublists
char*** sort_sublists(char ***list, int num_sublists, int *sizes) {
for(int i=0; i<num_sublists; i++) {
qsort(list[i], sizes[i], sizeof(char*), cmpfunc);
}
return list;
}
// Function to compare two 2D string arrays
| int func0(char ***a, char ***b, int num_sublists, int *sizes_a, int *sizes_b) {
for(int i=0; i<num_sublists; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
for(int j=0; j<sizes_a[i]; j++) {
if(strcmp(a[i][j], b[i][j]) !=0 ) return 0;
}
}
return 1;
}
| int main() {
// First test case
char *test1[][3] = { {"green", "orange", NULL}, {"black", "white", NULL}, {"white", "black", "orange"} };
int sizes1[] = {2, 2, 3};
// Expected
char *expected1[][3] = { {"green", "orange", NULL}, {"black", "white", NULL}, {"black", "orange", "white"} };
// Convert to char***
char **list1[3];
for(int i=0;i<3;i++) list1[i] = test1[i];
char **expected_list1[3];
for(int i=0;i<3;i++) expected_list1[i] = expected1[i];
sort_sublists(list1, 3, sizes1);
assert(func0(list1, expected_list1, 3, sizes1, sizes1));
// Second test case
char *test2[][2] = { {"green", "orange"}, {"black", NULL}, {"green", "orange"}, {"white", NULL} };
int sizes2[] = {2,1,2,1};
char *expected2[][2] = { {"green", "orange"}, {"black", NULL}, {"green", "orange"}, {"white", NULL} };
char **list2[4];
for(int i=0;i<4;i++) list2[i] = test2[i];
char **expected_list2[4];
for(int i=0;i<4;i++) expected_list2[i] = expected2[i];
sort_sublists(list2,4,sizes2);
assert(func0(list2, expected_list2,4,sizes2,sizes2));
// Third test case
char *test3[][2] = { {"a","b"}, {"d","c"}, {"g","h"}, {"f","e"} };
int sizes3[] = {2,2,2,2};
char *expected3[][2] = { {"a","b"}, {"c","d"}, {"g","h"}, {"e","f"} };
char **list3[4];
for(int i=0;i<4;i++) list3[i] = test3[i];
char **expected_list3[4];
for(int i=0;i<4;i++) expected_list3[i] = expected3[i];
sort_sublists(list3,4,sizes3);
assert(func0(list3, expected_list3,4,sizes3,sizes3));
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %rcx,-0x30(%rbp)
mov %r8,-0x38(%rbp)
movl $0x0,-0x8(%rbp)
jmpq 1357 <func0+0xf9>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 12c3 <func0+0x65>
mov $0x0,%eax
jmpq 1368 <func0+0x10a>
movl $0x0,-0x4(%rbp)
jmp 1334 <func0+0xd6>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
shl $0x3,%rdx
add %rdx,%rax
mov (%rax),%rdx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov -0x4(%rbp),%ecx
movslq %ecx,%rcx
shl $0x3,%rcx
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 1330 <func0+0xd2>
mov $0x0,%eax
jmp 1368 <func0+0x10a>
addl $0x1,-0x4(%rbp)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x4(%rbp)
jl 12cc <func0+0x6e>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 1289 <func0+0x2b>
mov $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_30], rcx
mov [rbp+var_38], r8
mov [rbp+var_8], 0
jmp loc_135A
loc_128C:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_30]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_8]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_12C6
mov eax, 0
jmp locret_136B
loc_12C6:
mov [rbp+var_4], 0
jmp short loc_1337
loc_12CF:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_20]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_4]
movsxd rdx, edx
shl rdx, 3
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_8]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rcx
mov rax, [rax]
mov ecx, [rbp+var_4]
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
mov rax, [rax]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz short loc_1333
mov eax, 0
jmp short locret_136B
loc_1333:
add [rbp+var_4], 1
loc_1337:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_30]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_4], eax
jl loc_12CF
add [rbp+var_8], 1
loc_135A:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_24]
jl loc_128C
mov eax, 1
locret_136B:
leave
retn | long long func0(long long a1, long long a2, int a3, long long a4, long long a5)
{
int i; // [rsp+38h] [rbp-8h]
int j; // [rsp+3Ch] [rbp-4h]
for ( i = 0; i < a3; ++i )
{
if ( *(_DWORD *)(4LL * i + a4) != *(_DWORD *)(4LL * i + a5) )
return 0LL;
for ( j = 0; j < *(_DWORD *)(4LL * i + a4); ++j )
{
if ( strcmp(
*(const char **)(8LL * j + *(_QWORD *)(8LL * i + a1)),
*(const char **)(8LL * j + *(_QWORD *)(8LL * i + a2))) )
{
return 0LL;
}
}
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x38],R8
MOV dword ptr [RBP + -0x8],0x0
JMP 0x0010135a
LAB_0010128c:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x001012c6
MOV EAX,0x0
JMP 0x0010136b
LAB_001012c6:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101337
LAB_001012cf:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
SHL RDX,0x3
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RCX,ECX
SHL RCX,0x3
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010b0
TEST EAX,EAX
JZ 0x00101333
MOV EAX,0x0
JMP 0x0010136b
LAB_00101333:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101337:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x4],EAX
JL 0x001012cf
ADD dword ptr [RBP + -0x8],0x1
LAB_0010135a:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x0010128c
MOV EAX,0x1
LAB_0010136b:
LEAVE
RET | int8 func0(long param_1,long param_2,int param_3,long param_4,long param_5)
{
int iVar1;
int local_10;
int local_c;
local_10 = 0;
while( true ) {
if (param_3 <= local_10) {
return 1;
}
if (*(int *)(param_4 + (long)local_10 * 4) != *(int *)(param_5 + (long)local_10 * 4)) break;
for (local_c = 0; local_c < *(int *)(param_4 + (long)local_10 * 4); local_c = local_c + 1) {
iVar1 = strcmp(*(char **)(*(long *)(param_1 + (long)local_10 * 8) + (long)local_c * 8),
*(char **)(*(long *)(param_2 + (long)local_10 * 8) + (long)local_c * 8));
if (iVar1 != 0) {
return 0;
}
}
local_10 = local_10 + 1;
}
return 0;
} |
6,169 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare two strings for qsort
int cmpfunc(const void * a, const void * b) {
const char **sa = (const char **)a;
const char **sb = (const char **)b;
return strcmp(*sa, *sb);
}
// Function to sort sublists
char*** sort_sublists(char ***list, int num_sublists, int *sizes) {
for(int i=0; i<num_sublists; i++) {
qsort(list[i], sizes[i], sizeof(char*), cmpfunc);
}
return list;
}
// Function to compare two 2D string arrays
| int func0(char ***a, char ***b, int num_sublists, int *sizes_a, int *sizes_b) {
for(int i=0; i<num_sublists; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
for(int j=0; j<sizes_a[i]; j++) {
if(strcmp(a[i][j], b[i][j]) !=0 ) return 0;
}
}
return 1;
}
| int main() {
// First test case
char *test1[][3] = { {"green", "orange", NULL}, {"black", "white", NULL}, {"white", "black", "orange"} };
int sizes1[] = {2, 2, 3};
// Expected
char *expected1[][3] = { {"green", "orange", NULL}, {"black", "white", NULL}, {"black", "orange", "white"} };
// Convert to char***
char **list1[3];
for(int i=0;i<3;i++) list1[i] = test1[i];
char **expected_list1[3];
for(int i=0;i<3;i++) expected_list1[i] = expected1[i];
sort_sublists(list1, 3, sizes1);
assert(func0(list1, expected_list1, 3, sizes1, sizes1));
// Second test case
char *test2[][2] = { {"green", "orange"}, {"black", NULL}, {"green", "orange"}, {"white", NULL} };
int sizes2[] = {2,1,2,1};
char *expected2[][2] = { {"green", "orange"}, {"black", NULL}, {"green", "orange"}, {"white", NULL} };
char **list2[4];
for(int i=0;i<4;i++) list2[i] = test2[i];
char **expected_list2[4];
for(int i=0;i<4;i++) expected_list2[i] = expected2[i];
sort_sublists(list2,4,sizes2);
assert(func0(list2, expected_list2,4,sizes2,sizes2));
// Third test case
char *test3[][2] = { {"a","b"}, {"d","c"}, {"g","h"}, {"f","e"} };
int sizes3[] = {2,2,2,2};
char *expected3[][2] = { {"a","b"}, {"c","d"}, {"g","h"}, {"e","f"} };
char **list3[4];
for(int i=0;i<4;i++) list3[i] = test3[i];
char **expected_list3[4];
for(int i=0;i<4;i++) expected_list3[i] = expected3[i];
sort_sublists(list3,4,sizes3);
assert(func0(list3, expected_list3,4,sizes3,sizes3));
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,0x8(%rsp)
mov %rsi,0x10(%rsp)
mov %rcx,(%rsp)
test %edx,%edx
jle 12ae <func0+0x99>
mov %r8,%r15
lea -0x1(%rdx),%eax
mov %rax,0x18(%rsp)
mov $0x0,%r14d
mov (%rsp),%rax
mov (%rax,%r14,4),%eax
cmp (%r15,%r14,4),%eax
jne 12b5 <func0+0xa0>
test %eax,%eax
jle 1297 <func0+0x82>
mov 0x10(%rsp),%rcx
mov (%rcx,%r14,8),%r12
mov 0x8(%rsp),%rdx
mov (%rdx,%r14,8),%rbp
lea -0x1(%rax),%r13d
mov $0x0,%ebx
jmp 127c <func0+0x67>
mov %rax,%rbx
mov (%r12,%rbx,8),%rsi
mov 0x0(%rbp,%rbx,8),%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 12bc <func0+0xa7>
lea 0x1(%rbx),%rax
cmp %r13,%rbx
jne 1279 <func0+0x64>
lea 0x1(%r14),%rax
cmp 0x18(%rsp),%r14
je 12a7 <func0+0x92>
mov %rax,%r14
jmp 124a <func0+0x35>
mov $0x1,%eax
jmp 12c1 <func0+0xac>
mov $0x1,%eax
jmp 12c1 <func0+0xac>
mov $0x0,%eax
jmp 12c1 <func0+0xac>
mov $0x0,%eax
add $0x28,%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, 28h
mov [rsp+58h+var_50], rdi
mov [rsp+58h+var_48], rsi
mov [rsp+58h+var_58], rcx
test edx, edx
jle short loc_12A3
mov r15, r8
mov eax, edx
mov [rsp+58h+var_40], rax
mov r14d, 0
loc_1244:
mov rax, [rsp+58h+var_58]
mov eax, [rax+r14*4]
cmp eax, [r15+r14*4]
jnz short loc_12AA
test eax, eax
jle short loc_1291
mov rcx, [rsp+58h+var_48]
mov r12, [rcx+r14*8]
mov rdx, [rsp+58h+var_50]
mov rbp, [rdx+r14*8]
lea r13d, [rax-1]
mov ebx, 0
jmp short loc_1276
loc_1273:
mov rbx, rax
loc_1276:
mov rsi, [r12+rbx*8]
mov rdi, [rbp+rbx*8+0]
call _strcmp
test eax, eax
jnz short loc_12B1
lea rax, [rbx+1]
cmp rbx, r13
jnz short loc_1273
loc_1291:
add r14, 1
cmp r14, [rsp+58h+var_40]
jnz short loc_1244
mov eax, 1
jmp short loc_12B6
loc_12A3:
mov eax, 1
jmp short loc_12B6
loc_12AA:
mov eax, 0
jmp short loc_12B6
loc_12B1:
mov eax, 0
loc_12B6:
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, long long a2, int a3, long long a4, long long a5)
{
long long v6; // r14
int v7; // eax
long long v8; // r12
long long v9; // rbp
long long v10; // r13
long long i; // rbx
long long v14; // [rsp+18h] [rbp-40h]
if ( a3 <= 0 )
return 1LL;
v14 = (unsigned int)a3;
v6 = 0LL;
while ( 1 )
{
v7 = *(_DWORD *)(a4 + 4 * v6);
if ( v7 != *(_DWORD *)(a5 + 4 * v6) )
return 0LL;
if ( v7 > 0 )
break;
LABEL_9:
if ( ++v6 == v14 )
return 1LL;
}
v8 = *(_QWORD *)(a2 + 8 * v6);
v9 = *(_QWORD *)(a1 + 8 * v6);
v10 = (unsigned int)(v7 - 1);
for ( i = 0LL; !(unsigned int)strcmp(*(_QWORD *)(v9 + 8 * i), *(_QWORD *)(v8 + 8 * i)); ++i )
{
if ( i == v10 )
goto LABEL_9;
}
return 0LL;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP],RCX
TEST EDX,EDX
JLE 0x001012a3
MOV R15,R8
MOV EAX,EDX
MOV qword ptr [RSP + 0x18],RAX
MOV R14D,0x0
LAB_00101244:
MOV RAX,qword ptr [RSP]
MOV EAX,dword ptr [RAX + R14*0x4]
CMP EAX,dword ptr [R15 + R14*0x4]
JNZ 0x001012aa
TEST EAX,EAX
JLE 0x00101291
MOV RCX,qword ptr [RSP + 0x10]
MOV R12,qword ptr [RCX + R14*0x8]
MOV RDX,qword ptr [RSP + 0x8]
MOV RBP,qword ptr [RDX + R14*0x8]
LEA R13D,[RAX + -0x1]
MOV EBX,0x0
JMP 0x00101276
LAB_00101273:
MOV RBX,RAX
LAB_00101276:
MOV RSI,qword ptr [R12 + RBX*0x8]
MOV RDI,qword ptr [RBP + RBX*0x8]
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x001012b1
LEA RAX,[RBX + 0x1]
CMP RBX,R13
JNZ 0x00101273
LAB_00101291:
ADD R14,0x1
CMP R14,qword ptr [RSP + 0x18]
JNZ 0x00101244
MOV EAX,0x1
JMP 0x001012b6
LAB_001012a3:
MOV EAX,0x1
JMP 0x001012b6
LAB_001012aa:
MOV EAX,0x0
JMP 0x001012b6
LAB_001012b1:
MOV EAX,0x0
LAB_001012b6:
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 func0(long param_1,long param_2,uint param_3,long param_4,long param_5)
{
int iVar1;
long lVar2;
long lVar3;
int iVar4;
ulong uVar5;
ulong uVar6;
bool bVar7;
if (0 < (int)param_3) {
uVar6 = 0;
do {
iVar1 = *(int *)(param_4 + uVar6 * 4);
if (iVar1 != *(int *)(param_5 + uVar6 * 4)) {
return 0;
}
if (0 < iVar1) {
lVar2 = *(long *)(param_2 + uVar6 * 8);
lVar3 = *(long *)(param_1 + uVar6 * 8);
uVar5 = 0;
do {
iVar4 = strcmp(*(char **)(lVar3 + uVar5 * 8),*(char **)(lVar2 + uVar5 * 8));
if (iVar4 != 0) {
return 0;
}
bVar7 = uVar5 != iVar1 - 1;
uVar5 = uVar5 + 1;
} while (bVar7);
}
uVar6 = uVar6 + 1;
} while (uVar6 != param_3);
}
return 1;
} |
6,170 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare two strings for qsort
int cmpfunc(const void * a, const void * b) {
const char **sa = (const char **)a;
const char **sb = (const char **)b;
return strcmp(*sa, *sb);
}
// Function to sort sublists
char*** sort_sublists(char ***list, int num_sublists, int *sizes) {
for(int i=0; i<num_sublists; i++) {
qsort(list[i], sizes[i], sizeof(char*), cmpfunc);
}
return list;
}
// Function to compare two 2D string arrays
| int func0(char ***a, char ***b, int num_sublists, int *sizes_a, int *sizes_b) {
for(int i=0; i<num_sublists; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
for(int j=0; j<sizes_a[i]; j++) {
if(strcmp(a[i][j], b[i][j]) !=0 ) return 0;
}
}
return 1;
}
| int main() {
// First test case
char *test1[][3] = { {"green", "orange", NULL}, {"black", "white", NULL}, {"white", "black", "orange"} };
int sizes1[] = {2, 2, 3};
// Expected
char *expected1[][3] = { {"green", "orange", NULL}, {"black", "white", NULL}, {"black", "orange", "white"} };
// Convert to char***
char **list1[3];
for(int i=0;i<3;i++) list1[i] = test1[i];
char **expected_list1[3];
for(int i=0;i<3;i++) expected_list1[i] = expected1[i];
sort_sublists(list1, 3, sizes1);
assert(func0(list1, expected_list1, 3, sizes1, sizes1));
// Second test case
char *test2[][2] = { {"green", "orange"}, {"black", NULL}, {"green", "orange"}, {"white", NULL} };
int sizes2[] = {2,1,2,1};
char *expected2[][2] = { {"green", "orange"}, {"black", NULL}, {"green", "orange"}, {"white", NULL} };
char **list2[4];
for(int i=0;i<4;i++) list2[i] = test2[i];
char **expected_list2[4];
for(int i=0;i<4;i++) expected_list2[i] = expected2[i];
sort_sublists(list2,4,sizes2);
assert(func0(list2, expected_list2,4,sizes2,sizes2));
// Third test case
char *test3[][2] = { {"a","b"}, {"d","c"}, {"g","h"}, {"f","e"} };
int sizes3[] = {2,2,2,2};
char *expected3[][2] = { {"a","b"}, {"c","d"}, {"g","h"}, {"e","f"} };
char **list3[4];
for(int i=0;i<4;i++) list3[i] = test3[i];
char **expected_list3[4];
for(int i=0;i<4;i++) expected_list3[i] = expected3[i];
sort_sublists(list3,4,sizes3);
assert(func0(list3, expected_list3,4,sizes3,sizes3));
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,0x8(%rsp)
mov %rsi,0x10(%rsp)
mov %rcx,(%rsp)
test %edx,%edx
jle 17c0 <func0+0xa0>
lea -0x1(%rdx),%eax
mov %r8,%r13
xor %ebp,%ebp
mov %rax,0x18(%rsp)
mov (%rsp),%rax
mov (%rax,%rbp,4),%eax
cmp 0x0(%r13,%rbp,4),%eax
jne 179d <func0+0x7d>
test %eax,%eax
jle 17b0 <func0+0x90>
mov 0x10(%rsp),%rcx
mov 0x8(%rsp),%rdx
lea -0x1(%rax),%ebx
xor %r14d,%r14d
mov (%rcx,%rbp,8),%r12
mov (%rdx,%rbp,8),%r15
jmp 178c <func0+0x6c>
nopl (%rax)
lea 0x1(%r14),%rax
cmp %r14,%rbx
je 17b0 <func0+0x90>
mov %rax,%r14
mov (%r12,%r14,8),%rsi
mov (%r15,%r14,8),%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 1780 <func0+0x60>
xor %eax,%eax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xchg %ax,%ax
lea 0x1(%rbp),%rax
cmp %rbp,0x18(%rsp)
je 17c0 <func0+0xa0>
mov %rax,%rbp
jmp 1751 <func0+0x31>
mov $0x1,%eax
jmp 179f <func0+0x7f>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_50], rdi
mov [rsp+58h+var_48], rsi
mov [rsp+58h+var_58], rcx
test edx, edx
jle short loc_17BB
movsxd rax, edx
mov r13, r8
xor ebp, ebp
mov [rsp+58h+var_40], rax
loc_1751:
mov rax, [rsp+58h+var_58]
movsxd rbx, dword ptr [rax+rbp*4]
cmp ebx, [r13+rbp*4+0]
jnz short loc_179A
test ebx, ebx
jle short loc_17B0
mov rax, [rsp+58h+var_48]
xor r14d, r14d
mov r12, [rax+rbp*8]
mov rax, [rsp+58h+var_50]
mov r15, [rax+rbp*8]
jmp short loc_1789
loc_1780:
add r14, 1
cmp rbx, r14
jz short loc_17B0
loc_1789:
mov rsi, [r12+r14*8]
mov rdi, [r15+r14*8]
call _strcmp
test eax, eax
jz short loc_1780
loc_179A:
xor eax, eax
loc_179C:
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_17B0:
add rbp, 1
cmp [rsp+58h+var_40], rbp
jnz short loc_1751
loc_17BB:
mov eax, 1
jmp short loc_179C | long long func0(long long a1, long long a2, int a3, long long a4, long long a5)
{
long long v6; // rbp
long long v7; // rbx
long long v8; // r14
long long v9; // r12
long long v10; // r15
long long v13; // [rsp+18h] [rbp-40h]
if ( a3 <= 0 )
return 1LL;
v6 = 0LL;
v13 = a3;
while ( 1 )
{
v7 = *(int *)(a4 + 4 * v6);
if ( (_DWORD)v7 != *(_DWORD *)(a5 + 4 * v6) )
return 0LL;
if ( (int)v7 > 0 )
{
v8 = 0LL;
v9 = *(_QWORD *)(a2 + 8 * v6);
v10 = *(_QWORD *)(a1 + 8 * v6);
while ( !(unsigned int)strcmp(*(_QWORD *)(v10 + 8 * v8), *(_QWORD *)(v9 + 8 * v8)) )
{
if ( v7 == ++v8 )
goto LABEL_9;
}
return 0LL;
}
LABEL_9:
if ( v13 == ++v6 )
return 1LL;
}
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP],RCX
TEST EDX,EDX
JLE 0x001017bb
MOVSXD RAX,EDX
MOV R13,R8
XOR EBP,EBP
MOV qword ptr [RSP + 0x18],RAX
LAB_00101751:
MOV RAX,qword ptr [RSP]
MOVSXD RBX,dword ptr [RAX + RBP*0x4]
CMP EBX,dword ptr [R13 + RBP*0x4]
JNZ 0x0010179a
TEST EBX,EBX
JLE 0x001017b0
MOV RAX,qword ptr [RSP + 0x10]
XOR R14D,R14D
MOV R12,qword ptr [RAX + RBP*0x8]
MOV RAX,qword ptr [RSP + 0x8]
MOV R15,qword ptr [RAX + RBP*0x8]
JMP 0x00101789
LAB_00101780:
ADD R14,0x1
CMP RBX,R14
JZ 0x001017b0
LAB_00101789:
MOV RSI,qword ptr [R12 + R14*0x8]
MOV RDI,qword ptr [R15 + R14*0x8]
CALL 0x001010b0
TEST EAX,EAX
JZ 0x00101780
LAB_0010179a:
XOR EAX,EAX
LAB_0010179c:
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001017b0:
ADD RBP,0x1
CMP qword ptr [RSP + 0x18],RBP
JNZ 0x00101751
LAB_001017bb:
MOV EAX,0x1
JMP 0x0010179c | int8 func0(long param_1,long param_2,int param_3,long param_4,long param_5)
{
int iVar1;
long lVar2;
long lVar3;
int iVar4;
long lVar5;
long lVar6;
if (0 < param_3) {
lVar5 = 0;
do {
iVar1 = *(int *)(param_4 + lVar5 * 4);
if (iVar1 != *(int *)(param_5 + lVar5 * 4)) {
return 0;
}
if (0 < iVar1) {
lVar6 = 0;
lVar2 = *(long *)(param_2 + lVar5 * 8);
lVar3 = *(long *)(param_1 + lVar5 * 8);
do {
iVar4 = strcmp(*(char **)(lVar3 + lVar6 * 8),*(char **)(lVar2 + lVar6 * 8));
if (iVar4 != 0) {
return 0;
}
lVar6 = lVar6 + 1;
} while (iVar1 != lVar6);
}
lVar5 = lVar5 + 1;
} while (param_3 != lVar5);
}
return 1;
} |
6,171 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
// Function to compare two strings for qsort
int cmpfunc(const void * a, const void * b) {
const char **sa = (const char **)a;
const char **sb = (const char **)b;
return strcmp(*sa, *sb);
}
// Function to sort sublists
char*** sort_sublists(char ***list, int num_sublists, int *sizes) {
for(int i=0; i<num_sublists; i++) {
qsort(list[i], sizes[i], sizeof(char*), cmpfunc);
}
return list;
}
// Function to compare two 2D string arrays
| int func0(char ***a, char ***b, int num_sublists, int *sizes_a, int *sizes_b) {
for(int i=0; i<num_sublists; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
for(int j=0; j<sizes_a[i]; j++) {
if(strcmp(a[i][j], b[i][j]) !=0 ) return 0;
}
}
return 1;
}
| int main() {
// First test case
char *test1[][3] = { {"green", "orange", NULL}, {"black", "white", NULL}, {"white", "black", "orange"} };
int sizes1[] = {2, 2, 3};
// Expected
char *expected1[][3] = { {"green", "orange", NULL}, {"black", "white", NULL}, {"black", "orange", "white"} };
// Convert to char***
char **list1[3];
for(int i=0;i<3;i++) list1[i] = test1[i];
char **expected_list1[3];
for(int i=0;i<3;i++) expected_list1[i] = expected1[i];
sort_sublists(list1, 3, sizes1);
assert(func0(list1, expected_list1, 3, sizes1, sizes1));
// Second test case
char *test2[][2] = { {"green", "orange"}, {"black", NULL}, {"green", "orange"}, {"white", NULL} };
int sizes2[] = {2,1,2,1};
char *expected2[][2] = { {"green", "orange"}, {"black", NULL}, {"green", "orange"}, {"white", NULL} };
char **list2[4];
for(int i=0;i<4;i++) list2[i] = test2[i];
char **expected_list2[4];
for(int i=0;i<4;i++) expected_list2[i] = expected2[i];
sort_sublists(list2,4,sizes2);
assert(func0(list2, expected_list2,4,sizes2,sizes2));
// Third test case
char *test3[][2] = { {"a","b"}, {"d","c"}, {"g","h"}, {"f","e"} };
int sizes3[] = {2,2,2,2};
char *expected3[][2] = { {"a","b"}, {"c","d"}, {"g","h"}, {"e","f"} };
char **list3[4];
for(int i=0;i<4;i++) list3[i] = test3[i];
char **expected_list3[4];
for(int i=0;i<4;i++) expected_list3[i] = expected3[i];
sort_sublists(list3,4,sizes3);
assert(func0(list3, expected_list3,4,sizes3,sizes3));
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,0x8(%rsp)
mov %rsi,0x10(%rsp)
mov %rcx,(%rsp)
test %edx,%edx
jle 17e0 <func0+0xa0>
lea -0x1(%rdx),%eax
mov %r8,%r13
xor %ebp,%ebp
mov %rax,0x18(%rsp)
mov (%rsp),%rax
mov (%rax,%rbp,4),%eax
cmp 0x0(%r13,%rbp,4),%eax
jne 17bd <func0+0x7d>
test %eax,%eax
jle 17d0 <func0+0x90>
mov 0x10(%rsp),%rcx
mov 0x8(%rsp),%rdx
lea -0x1(%rax),%ebx
xor %r14d,%r14d
mov (%rcx,%rbp,8),%r12
mov (%rdx,%rbp,8),%r15
jmp 17ac <func0+0x6c>
nopl (%rax)
lea 0x1(%r14),%rax
cmp %r14,%rbx
je 17d0 <func0+0x90>
mov %rax,%r14
mov (%r12,%r14,8),%rsi
mov (%r15,%r14,8),%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 17a0 <func0+0x60>
xor %eax,%eax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xchg %ax,%ax
lea 0x1(%rbp),%rax
cmp %rbp,0x18(%rsp)
je 17e0 <func0+0xa0>
mov %rax,%rbp
jmp 1771 <func0+0x31>
mov $0x1,%eax
jmp 17bf <func0+0x7f>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_50], rdi
mov [rsp+58h+var_48], rsi
test edx, edx
jle short loc_18DB
movsxd rdx, edx
mov r12, rcx
mov r13, r8
xor ebp, ebp
lea rax, ds:0[rdx*4]
mov [rsp+58h+var_40], rax
loc_1878:
movsxd rax, dword ptr [r12+rbp]
cmp eax, [r13+rbp+0]
jnz short loc_18BC
test eax, eax
jle short loc_18D0
mov rcx, [rsp+58h+var_48]
mov r14, [rcx+rbp*2]
mov rcx, [rsp+58h+var_50]
lea rbx, [r14+rax*8]
mov r15, [rcx+rbp*2]
jmp short loc_18AD
loc_18A0:
add r14, 8
add r15, 8
cmp rbx, r14
jz short loc_18D0
loc_18AD:
mov rsi, [r14]; s2
mov rdi, [r15]; s1
call _strcmp
test eax, eax
jz short loc_18A0
loc_18BC:
xor eax, eax
loc_18BE:
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_18D0:
add rbp, 4
cmp [rsp+58h+var_40], rbp
jnz short loc_1878
loc_18DB:
mov eax, 1
jmp short loc_18BE | long long func0(long long a1, long long a2, int a3, long long a4, long long a5)
{
long long v7; // rbp
long long v8; // rax
const char **v9; // r14
const char **v10; // rbx
const char **v11; // r15
long long v13; // [rsp+18h] [rbp-40h]
if ( a3 <= 0 )
return 1LL;
v7 = 0LL;
v13 = 4LL * a3;
while ( 1 )
{
v8 = *(int *)(a4 + v7);
if ( (_DWORD)v8 != *(_DWORD *)(a5 + v7) )
return 0LL;
if ( (int)v8 > 0 )
{
v9 = *(const char ***)(a2 + 2 * v7);
v10 = &v9[v8];
v11 = *(const char ***)(a1 + 2 * v7);
while ( !strcmp(*v11, *v9) )
{
++v9;
++v11;
if ( v10 == v9 )
goto LABEL_9;
}
return 0LL;
}
LABEL_9:
v7 += 4LL;
if ( v13 == v7 )
return 1LL;
}
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP + 0x10],RSI
TEST EDX,EDX
JLE 0x001018db
MOVSXD RDX,EDX
MOV R12,RCX
MOV R13,R8
XOR EBP,EBP
LEA RAX,[RDX*0x4]
MOV qword ptr [RSP + 0x18],RAX
LAB_00101878:
MOVSXD RAX,dword ptr [R12 + RBP*0x1]
CMP EAX,dword ptr [R13 + RBP*0x1]
JNZ 0x001018bc
TEST EAX,EAX
JLE 0x001018d0
MOV RCX,qword ptr [RSP + 0x10]
MOV R14,qword ptr [RCX + RBP*0x2]
MOV RCX,qword ptr [RSP + 0x8]
LEA RBX,[R14 + RAX*0x8]
MOV R15,qword ptr [RCX + RBP*0x2]
JMP 0x001018ad
LAB_001018a0:
ADD R14,0x8
ADD R15,0x8
CMP RBX,R14
JZ 0x001018d0
LAB_001018ad:
MOV RSI,qword ptr [R14]
MOV RDI,qword ptr [R15]
CALL 0x001010b0
TEST EAX,EAX
JZ 0x001018a0
LAB_001018bc:
XOR EAX,EAX
LAB_001018be:
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001018d0:
ADD RBP,0x4
CMP qword ptr [RSP + 0x18],RBP
JNZ 0x00101878
LAB_001018db:
MOV EAX,0x1
JMP 0x001018be | int8 func0(long param_1,long param_2,int param_3,long param_4,long param_5)
{
int8 *puVar1;
int iVar2;
long lVar3;
int8 *puVar4;
int8 *puVar5;
if (0 < param_3) {
lVar3 = 0;
do {
iVar2 = *(int *)(param_4 + lVar3);
if (iVar2 != *(int *)(param_5 + lVar3)) {
return 0;
}
if (0 < iVar2) {
puVar4 = *(int8 **)(param_2 + lVar3 * 2);
puVar1 = puVar4 + iVar2;
puVar5 = *(int8 **)(param_1 + lVar3 * 2);
do {
iVar2 = strcmp((char *)*puVar5,(char *)*puVar4);
if (iVar2 != 0) {
return 0;
}
puVar4 = puVar4 + 1;
puVar5 = puVar5 + 1;
} while (puVar1 != puVar4);
}
lVar3 = lVar3 + 4;
} while ((long)param_3 * 4 != lVar3);
}
return 1;
} |
6,172 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
| char** func0(char* list1[], int n1, char* charlist[], int n_char) {
char** new_list = malloc(n1 * sizeof(char*));
for(int i = 0; i < n1; i++) {
char* line = strdup(list1[i]);
char* token;
char buffer[1024] = "";
token = strtok(line, " ");
while(token != NULL) {
int skip = 0;
for(int j = 0; j < n_char; j++) {
if(strstr(token, charlist[j]) != NULL) {
skip = 1;
break;
}
}
if(!skip) {
if(strlen(buffer) > 0) strcat(buffer, " ");
strcat(buffer, token);
}
token = strtok(NULL, " ");
}
new_list[i] = strdup(buffer);
free(line);
}
return new_list;
}
| int main() {
// Test case 1
char* list1_a[] = {"Red color", "Orange#", "Green", "Orange @", "White"};
char* charlist_a[] = {"#", "color", "@"};
char* expected_a[] = {"Red", "", "Green", "Orange", "White"};
char** result_a = func0(list1_a, 5, charlist_a, 3);
for(int i = 0; i < 5; i++) {
assert(strcmp(result_a[i], expected_a[i]) == 0);
free(result_a[i]);
}
free(result_a);
// Test case 2
char* list1_b[] = {"Red &", "Orange+", "Green", "Orange @", "White"};
char* charlist_b[] = {"&", "+", "@"};
char* expected_b[] = {"Red", "", "Green", "Orange", "White"};
char** result_b = func0(list1_b, 5, charlist_b, 3);
for(int i = 0; i < 5; i++) {
assert(strcmp(result_b[i], expected_b[i]) == 0);
free(result_b[i]);
}
free(result_b);
// Test case 3
char* list1_c[] = {"Red &", "Orange+", "Green", "Orange @", "White"};
char* charlist_c[] = {"@"};
char* expected_c[] = {"Red &", "Orange+", "Green", "Orange", "White"};
char** result_c = func0(list1_c, 5, charlist_c, 1);
for(int i = 0; i < 5; i++) {
assert(strcmp(result_c[i], expected_c[i]) == 0);
free(result_c[i]);
}
free(result_c);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x468,%rsp
mov %rdi,-0x458(%rbp)
mov %esi,-0x45c(%rbp)
mov %rdx,-0x468(%rbp)
mov %ecx,-0x460(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x45c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1110 <malloc@plt>
mov %rax,-0x430(%rbp)
movl $0x0,-0x444(%rbp)
jmpq 145f <func0+0x216>
mov -0x444(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x458(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1140 <strdup@plt>
mov %rax,-0x428(%rbp)
movq $0x0,-0x420(%rbp)
movq $0x0,-0x418(%rbp)
lea -0x410(%rbp),%rdx
mov $0x0,%eax
mov $0x7e,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
mov -0x428(%rbp),%rax
lea 0xcf5(%rip),%rsi
mov %rax,%rdi
callq 1120 <strtok@plt>
mov %rax,-0x438(%rbp)
jmpq 140e <func0+0x1c5>
movl $0x0,-0x440(%rbp)
movl $0x0,-0x43c(%rbp)
jmp 1384 <func0+0x13b>
mov -0x43c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x468(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x438(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1150 <strstr@plt>
test %rax,%rax
je 137d <func0+0x134>
movl $0x1,-0x440(%rbp)
jmp 1392 <func0+0x149>
addl $0x1,-0x43c(%rbp)
mov -0x43c(%rbp),%eax
cmp -0x460(%rbp),%eax
jl 133d <func0+0xf4>
cmpl $0x0,-0x440(%rbp)
jne 13f6 <func0+0x1ad>
lea -0x420(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
je 13dd <func0+0x194>
lea -0x420(%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
lea -0x420(%rbp),%rax
add %rdx,%rax
movw $0x20,(%rax)
mov -0x438(%rbp),%rdx
lea -0x420(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1130 <strcat@plt>
lea 0xc0b(%rip),%rsi
mov $0x0,%edi
callq 1120 <strtok@plt>
mov %rax,-0x438(%rbp)
cmpq $0x0,-0x438(%rbp)
jne 1327 <func0+0xde>
mov -0x444(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x430(%rbp),%rax
lea (%rdx,%rax,1),%rbx
lea -0x420(%rbp),%rax
mov %rax,%rdi
callq 1140 <strdup@plt>
mov %rax,(%rbx)
mov -0x428(%rbp),%rax
mov %rax,%rdi
callq 10d0 <free@plt>
addl $0x1,-0x444(%rbp)
mov -0x444(%rbp),%eax
cmp -0x45c(%rbp),%eax
jl 12ac <func0+0x63>
mov -0x430(%rbp),%rax
mov -0x18(%rbp),%rbx
xor %fs:0x28,%rbx
je 148c <func0+0x243>
callq 10e0 <__stack_chk_fail@plt>
add $0x468,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 468h
mov [rbp+var_458], rdi
mov [rbp+var_45C], esi
mov [rbp+var_468], rdx
mov [rbp+var_460], ecx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_45C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_430], rax
mov [rbp+var_444], 0
jmp loc_145C
loc_12CC:
mov eax, [rbp+var_444]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_458]
add rax, rdx
mov rax, [rax]
mov rdi, rax; s
call _strdup
mov [rbp+s], rax
lea rdx, [rbp+dest]
mov eax, 0
mov ecx, 80h
mov rdi, rdx
rep stosq
mov rax, [rbp+s]
lea rdx, delim; " "
mov rsi, rdx; delim
mov rdi, rax; s
call _strtok
mov [rbp+haystack], rax
jmp loc_140B
loc_1334:
mov [rbp+var_440], 0
mov [rbp+var_43C], 0
jmp short loc_1391
loc_134A:
mov eax, [rbp+var_43C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_468]
add rax, rdx
mov rdx, [rax]
mov rax, [rbp+haystack]
mov rsi, rdx; needle
mov rdi, rax; haystack
call _strstr
test rax, rax
jz short loc_138A
mov [rbp+var_440], 1
jmp short loc_139F
loc_138A:
add [rbp+var_43C], 1
loc_1391:
mov eax, [rbp+var_43C]
cmp eax, [rbp+var_460]
jl short loc_134A
loc_139F:
cmp [rbp+var_440], 0
jnz short loc_13F0
lea rax, [rbp+dest]
movzx eax, byte ptr [rax]
test al, al
jz short loc_13D7
lea rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, [rbp+dest]
add rax, rdx
mov word ptr [rax], 20h ; ' '
loc_13D7:
mov rdx, [rbp+haystack]
lea rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcat
loc_13F0:
lea rax, delim; " "
mov rsi, rax; delim
mov edi, 0; s
call _strtok
mov [rbp+haystack], rax
loc_140B:
cmp [rbp+haystack], 0
jnz loc_1334
mov eax, [rbp+var_444]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_430]
lea rbx, [rdx+rax]
lea rax, [rbp+dest]
mov rdi, rax; s
call _strdup
mov [rbx], rax
mov rax, [rbp+s]
mov rdi, rax; ptr
call _free
add [rbp+var_444], 1
loc_145C:
mov eax, [rbp+var_444]
cmp eax, [rbp+var_45C]
jl loc_12CC
mov rax, [rbp+var_430]
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1489
call ___stack_chk_fail
loc_1489:
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+2Ch] [rbp-444h]
int v8; // [rsp+30h] [rbp-440h]
int j; // [rsp+34h] [rbp-43Ch]
const char *haystack; // [rsp+38h] [rbp-438h]
_QWORD *v11; // [rsp+40h] [rbp-430h]
char *s; // [rsp+48h] [rbp-428h]
char dest[1032]; // [rsp+50h] [rbp-420h] BYREF
unsigned long long v14; // [rsp+458h] [rbp-18h]
v14 = __readfsqword(0x28u);
v11 = malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
{
s = strdup(*(const char **)(8LL * i + a1));
memset(dest, 0, 0x400uLL);
for ( haystack = strtok(s, " "); haystack; haystack = strtok(0LL, " ") )
{
v8 = 0;
for ( j = 0; j < a4; ++j )
{
if ( strstr(haystack, *(const char **)(8LL * j + a3)) )
{
v8 = 1;
break;
}
}
if ( !v8 )
{
if ( dest[0] )
*(_WORD *)&dest[strlen(dest)] = 32;
strcat(dest, haystack);
}
}
v11[i] = strdup(dest);
free(s);
}
return v11;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x468
MOV qword ptr [RBP + -0x458],RDI
MOV dword ptr [RBP + -0x45c],ESI
MOV qword ptr [RBP + -0x468],RDX
MOV dword ptr [RBP + -0x460],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x45c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBP + -0x430],RAX
MOV dword ptr [RBP + -0x444],0x0
JMP 0x0010145c
LAB_001012cc:
MOV EAX,dword ptr [RBP + -0x444]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x458]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101160
MOV qword ptr [RBP + -0x428],RAX
LEA RDX,[RBP + -0x420]
MOV EAX,0x0
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOV RAX,qword ptr [RBP + -0x428]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101140
MOV qword ptr [RBP + -0x438],RAX
JMP 0x0010140b
LAB_00101334:
MOV dword ptr [RBP + -0x440],0x0
MOV dword ptr [RBP + -0x43c],0x0
JMP 0x00101391
LAB_0010134a:
MOV EAX,dword ptr [RBP + -0x43c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x468]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x438]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101170
TEST RAX,RAX
JZ 0x0010138a
MOV dword ptr [RBP + -0x440],0x1
JMP 0x0010139f
LAB_0010138a:
ADD dword ptr [RBP + -0x43c],0x1
LAB_00101391:
MOV EAX,dword ptr [RBP + -0x43c]
CMP EAX,dword ptr [RBP + -0x460]
JL 0x0010134a
LAB_0010139f:
CMP dword ptr [RBP + -0x440],0x0
JNZ 0x001013f0
LEA RAX,[RBP + -0x420]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JZ 0x001013d7
LEA RAX,[RBP + -0x420]
MOV RDI,RAX
CALL 0x001010f0
MOV RDX,RAX
LEA RAX,[RBP + -0x420]
ADD RAX,RDX
MOV word ptr [RAX],0x20
LAB_001013d7:
MOV RDX,qword ptr [RBP + -0x438]
LEA RAX,[RBP + -0x420]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101150
LAB_001013f0:
LEA RAX,[0x102008]
MOV RSI,RAX
MOV EDI,0x0
CALL 0x00101140
MOV qword ptr [RBP + -0x438],RAX
LAB_0010140b:
CMP qword ptr [RBP + -0x438],0x0
JNZ 0x00101334
MOV EAX,dword ptr [RBP + -0x444]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x430]
LEA RBX,[RDX + RAX*0x1]
LEA RAX,[RBP + -0x420]
MOV RDI,RAX
CALL 0x00101160
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [RBP + -0x428]
MOV RDI,RAX
CALL 0x001010e0
ADD dword ptr [RBP + -0x444],0x1
LAB_0010145c:
MOV EAX,dword ptr [RBP + -0x444]
CMP EAX,dword ptr [RBP + -0x45c]
JL 0x001012cc
MOV RAX,qword ptr [RBP + -0x430]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101489
CALL 0x00101100
LAB_00101489:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,long param_3,int param_4)
{
bool bVar1;
void *pvVar2;
char *__s;
size_t sVar3;
char *pcVar4;
long lVar5;
long in_FS_OFFSET;
byte bVar6;
int local_44c;
int local_444;
char *local_440;
char local_428 [1032];
long local_20;
bVar6 = 0;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
pvVar2 = malloc((long)param_2 << 3);
local_44c = 0;
do {
if (param_2 <= local_44c) {
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pvVar2;
}
__s = strdup(*(char **)(param_1 + (long)local_44c * 8));
pcVar4 = local_428;
for (lVar5 = 0x80; lVar5 != 0; lVar5 = lVar5 + -1) {
pcVar4[0] = '\0';
pcVar4[1] = '\0';
pcVar4[2] = '\0';
pcVar4[3] = '\0';
pcVar4[4] = '\0';
pcVar4[5] = '\0';
pcVar4[6] = '\0';
pcVar4[7] = '\0';
pcVar4 = pcVar4 + ((ulong)bVar6 * -2 + 1) * 8;
}
local_440 = strtok(__s," ");
while (local_440 != (char *)0x0) {
bVar1 = false;
for (local_444 = 0; local_444 < param_4; local_444 = local_444 + 1) {
pcVar4 = strstr(local_440,*(char **)(param_3 + (long)local_444 * 8));
if (pcVar4 != (char *)0x0) {
bVar1 = true;
break;
}
}
if (!bVar1) {
if (local_428[0] != '\0') {
sVar3 = strlen(local_428);
(local_428 + sVar3)[0] = ' ';
(local_428 + sVar3)[1] = '\0';
}
strcat(local_428,local_440);
}
local_440 = strtok((char *)0x0," ");
}
pcVar4 = strdup(local_428);
*(char **)((long)local_44c * 8 + (long)pvVar2) = pcVar4;
free(__s);
local_44c = local_44c + 1;
} while( true );
} |
6,173 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
| char** func0(char* list1[], int n1, char* charlist[], int n_char) {
char** new_list = malloc(n1 * sizeof(char*));
for(int i = 0; i < n1; i++) {
char* line = strdup(list1[i]);
char* token;
char buffer[1024] = "";
token = strtok(line, " ");
while(token != NULL) {
int skip = 0;
for(int j = 0; j < n_char; j++) {
if(strstr(token, charlist[j]) != NULL) {
skip = 1;
break;
}
}
if(!skip) {
if(strlen(buffer) > 0) strcat(buffer, " ");
strcat(buffer, token);
}
token = strtok(NULL, " ");
}
new_list[i] = strdup(buffer);
free(line);
}
return new_list;
}
| int main() {
// Test case 1
char* list1_a[] = {"Red color", "Orange#", "Green", "Orange @", "White"};
char* charlist_a[] = {"#", "color", "@"};
char* expected_a[] = {"Red", "", "Green", "Orange", "White"};
char** result_a = func0(list1_a, 5, charlist_a, 3);
for(int i = 0; i < 5; i++) {
assert(strcmp(result_a[i], expected_a[i]) == 0);
free(result_a[i]);
}
free(result_a);
// Test case 2
char* list1_b[] = {"Red &", "Orange+", "Green", "Orange @", "White"};
char* charlist_b[] = {"&", "+", "@"};
char* expected_b[] = {"Red", "", "Green", "Orange", "White"};
char** result_b = func0(list1_b, 5, charlist_b, 3);
for(int i = 0; i < 5; i++) {
assert(strcmp(result_b[i], expected_b[i]) == 0);
free(result_b[i]);
}
free(result_b);
// Test case 3
char* list1_c[] = {"Red &", "Orange+", "Green", "Orange @", "White"};
char* charlist_c[] = {"@"};
char* expected_c[] = {"Red &", "Orange+", "Green", "Orange", "White"};
char** result_c = func0(list1_c, 5, charlist_c, 1);
for(int i = 0; i < 5; i++) {
assert(strcmp(result_c[i], expected_c[i]) == 0);
free(result_c[i]);
}
free(result_c);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x448,%rsp
mov %rdi,0x28(%rsp)
mov %esi,%ebp
mov %rdx,%rbx
mov %ecx,%r14d
mov %fs:0x28,%rax
mov %rax,0x438(%rsp)
xor %eax,%eax
movslq %esi,%rdi
shl $0x3,%rdi
callq 1120 <malloc@plt>
mov %rax,0x18(%rsp)
test %ebp,%ebp
jle 13bd <func0+0x174>
lea -0x1(%rbp),%eax
mov %rax,0x20(%rsp)
mov %rbx,%r15
lea -0x1(%r14),%eax
lea 0x8(%rbx,%rax,8),%r12
movq $0x0,0x8(%rsp)
mov $0x0,%r13d
lea 0x30(%rsp),%rax
mov %rax,(%rsp)
jmpq 1360 <func0+0x117>
mov $0x400,%edx
lea 0xd30(%rip),%rsi
mov (%rsp),%rdi
callq 10d0 <__strcat_chk@plt>
mov $0x400,%edx
mov %rbp,%rsi
mov (%rsp),%rdi
callq 10d0 <__strcat_chk@plt>
lea 0xd0f(%rip),%rsi
mov %r13,%rdi
callq 1130 <strtok@plt>
mov %rax,%rbp
test %rax,%rax
je 132f <func0+0xe6>
mov %r15,%rbx
test %r14d,%r14d
jle 1326 <func0+0xdd>
mov (%rbx),%rsi
mov %rbp,%rdi
callq 1150 <strstr@plt>
test %rax,%rax
jne 12ee <func0+0xa5>
add $0x8,%rbx
cmp %r12,%rbx
jne 130d <func0+0xc4>
cmpb $0x0,0x30(%rsp)
je 12dd <func0+0x94>
jmp 12c8 <func0+0x7f>
mov (%rsp),%rdi
callq 1140 <strdup@plt>
mov 0x18(%rsp),%rdx
mov 0x8(%rsp),%rbx
mov %rax,(%rdx,%rbx,8)
mov 0x10(%rsp),%rdi
callq 10e0 <free@plt>
lea 0x1(%rbx),%rax
cmp 0x20(%rsp),%rbx
je 13bd <func0+0x174>
mov %rax,0x8(%rsp)
mov 0x28(%rsp),%rax
mov 0x8(%rsp),%rdx
mov (%rax,%rdx,8),%rdi
callq 1140 <strdup@plt>
mov %rax,%rdx
mov %rax,0x10(%rsp)
movq $0x0,0x30(%rsp)
movq $0x0,0x38(%rsp)
lea 0x40(%rsp),%rdi
mov $0x7e,%ecx
mov %r13,%rax
rep stos %rax,%es:(%rdi)
lea 0xc60(%rip),%rsi
mov %rdx,%rdi
callq 1130 <strtok@plt>
mov %rax,%rbp
test %rax,%rax
jne 1305 <func0+0xbc>
jmpq 132f <func0+0xe6>
mov 0x438(%rsp),%rax
xor %fs:0x28,%rax
jne 13e7 <func0+0x19e>
mov 0x18(%rsp),%rax
add $0x448,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10f0 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 448h
mov [rsp+478h+var_450], rdi
mov ebx, esi
mov r14, rdx
mov r15d, ecx
mov rax, fs:28h
mov [rsp+478h+var_40], rax
xor eax, eax
movsxd rdi, esi
shl rdi, 3
call _malloc
mov [rsp+478h+var_460], rax
test ebx, ebx
jle loc_13AF
mov eax, ebx
mov [rsp+478h+var_458], rax
lea eax, [r15-1]
lea r12, [r14+rax*8+8]
mov [rsp+478h+var_470], 0
lea r13, unk_2004
jmp loc_1354
loc_12BC:
lea rdi, [rsp+478h+var_448]
mov edx, 400h
mov rsi, r13
call ___strcat_chk
loc_12CE:
lea rdi, [rsp+478h+var_448]
mov edx, 400h
mov rsi, rbp
call ___strcat_chk
loc_12E0:
mov rsi, r13
mov edi, 0
call _strtok
mov rbp, rax
test rax, rax
jz short loc_131F
loc_12F5:
mov rbx, r14
test r15d, r15d
jle short loc_1316
loc_12FD:
mov rsi, [rbx]
mov rdi, rbp
call _strstr
test rax, rax
jnz short loc_12E0
add rbx, 8
cmp rbx, r12
jnz short loc_12FD
loc_1316:
cmp byte ptr [rsp+478h+var_448], 0
jz short loc_12CE
jmp short loc_12BC
loc_131F:
lea rdi, [rsp+478h+var_448]
call _strdup
mov rdx, [rsp+478h+var_460]
mov rbx, [rsp+478h+var_470]
mov [rdx+rbx*8], rax
mov rdi, [rsp+478h+var_468]
call _free
mov rcx, rbx
add rcx, 1
mov [rsp+478h+var_470], rcx
cmp rcx, [rsp+478h+var_458]
jz short loc_13AF
loc_1354:
mov rax, [rsp+478h+var_450]
mov rdx, [rsp+478h+var_470]
mov rdi, [rax+rdx*8]
call _strdup
mov rdx, rax
mov [rsp+478h+var_468], rax
mov [rsp+478h+var_448], 0
mov [rsp+478h+var_440], 0
lea rdi, [rsp+478h+var_438]
mov ecx, 7Eh ; '~'
mov eax, 0
rep stosq
mov rsi, r13
mov rdi, rdx
call _strtok
mov rbp, rax
test rax, rax
jnz loc_12F5
jmp loc_131F
loc_13AF:
mov rax, [rsp+478h+var_40]
sub rax, fs:28h
jnz short loc_13D9
mov rax, [rsp+478h+var_460]
add rsp, 448h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_13D9:
call ___stack_chk_fail | long long func0(long long a1, int a2, _QWORD *a3, int a4)
{
long long j; // rbp
_QWORD *v7; // rbx
long long i; // [rsp+8h] [rbp-470h]
long long v10; // [rsp+10h] [rbp-468h]
long long v11; // [rsp+18h] [rbp-460h]
_QWORD v12[137]; // [rsp+30h] [rbp-448h] BYREF
v12[129] = __readfsqword(0x28u);
v11 = malloc(8LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
v10 = strdup(*(_QWORD *)(a1 + 8 * i));
memset(v12, 0, 1024);
for ( j = strtok(v10, &unk_2004); j; j = strtok(0LL, &unk_2004) )
{
v7 = a3;
if ( a4 <= 0 )
{
LABEL_8:
if ( LOBYTE(v12[0]) )
__strcat_chk(v12, &unk_2004, 1024LL);
__strcat_chk(v12, j, 1024LL);
}
else
{
while ( !strstr(j, *v7) )
{
if ( ++v7 == &a3[(unsigned int)(a4 - 1) + 1] )
goto LABEL_8;
}
}
}
*(_QWORD *)(v11 + 8 * i) = strdup(v12);
free(v10);
}
}
return v11;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x448
MOV qword ptr [RSP + 0x28],RDI
MOV EBX,ESI
MOV R14,RDX
MOV R15D,ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x438],RAX
XOR EAX,EAX
MOVSXD RDI,ESI
SHL RDI,0x3
CALL 0x00101120
MOV qword ptr [RSP + 0x18],RAX
TEST EBX,EBX
JLE 0x001013af
MOV EAX,EBX
MOV qword ptr [RSP + 0x20],RAX
LEA EAX,[R15 + -0x1]
LEA R12,[R14 + RAX*0x8 + 0x8]
MOV qword ptr [RSP + 0x8],0x0
LEA R13,[0x102004]
JMP 0x00101354
LAB_001012bc:
LEA RDI,[RSP + 0x30]
MOV EDX,0x400
MOV RSI,R13
CALL 0x001010d0
LAB_001012ce:
LEA RDI,[RSP + 0x30]
MOV EDX,0x400
MOV RSI,RBP
CALL 0x001010d0
LAB_001012e0:
MOV RSI,R13
MOV EDI,0x0
CALL 0x00101130
MOV RBP,RAX
TEST RAX,RAX
JZ 0x0010131f
LAB_001012f5:
MOV RBX,R14
TEST R15D,R15D
JLE 0x00101316
LAB_001012fd:
MOV RSI,qword ptr [RBX]
MOV RDI,RBP
CALL 0x00101150
TEST RAX,RAX
JNZ 0x001012e0
ADD RBX,0x8
CMP RBX,R12
JNZ 0x001012fd
LAB_00101316:
CMP byte ptr [RSP + 0x30],0x0
JZ 0x001012ce
JMP 0x001012bc
LAB_0010131f:
LEA RDI,[RSP + 0x30]
CALL 0x00101140
MOV RDX,qword ptr [RSP + 0x18]
MOV RBX,qword ptr [RSP + 0x8]
MOV qword ptr [RDX + RBX*0x8],RAX
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001010e0
MOV RCX,RBX
ADD RCX,0x1
MOV qword ptr [RSP + 0x8],RCX
CMP RCX,qword ptr [RSP + 0x20]
JZ 0x001013af
LAB_00101354:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + RDX*0x8]
CALL 0x00101140
MOV RDX,RAX
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x38],0x0
LEA RDI,[RSP + 0x40]
MOV ECX,0x7e
MOV EAX,0x0
STOSQ.REP RDI
MOV RSI,R13
MOV RDI,RDX
CALL 0x00101130
MOV RBP,RAX
TEST RAX,RAX
JNZ 0x001012f5
JMP 0x0010131f
LAB_001013af:
MOV RAX,qword ptr [RSP + 0x438]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013d9
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x448
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001013d9:
CALL 0x001010f0 | void * func0(long param_1,uint param_2,int8 *param_3,int param_4)
{
void *pvVar1;
char *pcVar2;
char *__s;
char *pcVar3;
long lVar4;
int8 *puVar5;
long in_FS_OFFSET;
byte bVar6;
ulong local_470;
int8 local_448;
int8 local_440;
int8 local_438 [127];
long local_40;
bVar6 = 0;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
pvVar1 = malloc((long)(int)param_2 << 3);
if (0 < (int)param_2) {
local_470 = 0;
do {
__s = strdup(*(char **)(param_1 + local_470 * 8));
local_448 = 0;
local_440 = 0;
puVar5 = local_438;
for (lVar4 = 0x7e; lVar4 != 0; lVar4 = lVar4 + -1) {
*puVar5 = 0;
puVar5 = puVar5 + (ulong)bVar6 * -2 + 1;
}
pcVar3 = strtok(__s," ");
while (pcVar3 != (char *)0x0) {
puVar5 = param_3;
if (0 < param_4) {
do {
pcVar2 = strstr(pcVar3,(char *)*puVar5);
if (pcVar2 != (char *)0x0) goto LAB_001012e0;
puVar5 = puVar5 + 1;
} while (puVar5 != param_3 + (ulong)(param_4 - 1) + 1);
}
if ((char)local_448 != '\0') {
__strcat_chk(&local_448,&DAT_00102004,0x400);
}
__strcat_chk(&local_448,pcVar3,0x400);
LAB_001012e0:
pcVar3 = strtok((char *)0x0," ");
}
pcVar3 = strdup((char *)&local_448);
*(char **)((long)pvVar1 + local_470 * 8) = pcVar3;
free(__s);
local_470 = local_470 + 1;
} while (local_470 != param_2);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return pvVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,174 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
| char** func0(char* list1[], int n1, char* charlist[], int n_char) {
char** new_list = malloc(n1 * sizeof(char*));
for(int i = 0; i < n1; i++) {
char* line = strdup(list1[i]);
char* token;
char buffer[1024] = "";
token = strtok(line, " ");
while(token != NULL) {
int skip = 0;
for(int j = 0; j < n_char; j++) {
if(strstr(token, charlist[j]) != NULL) {
skip = 1;
break;
}
}
if(!skip) {
if(strlen(buffer) > 0) strcat(buffer, " ");
strcat(buffer, token);
}
token = strtok(NULL, " ");
}
new_list[i] = strdup(buffer);
free(line);
}
return new_list;
}
| int main() {
// Test case 1
char* list1_a[] = {"Red color", "Orange#", "Green", "Orange @", "White"};
char* charlist_a[] = {"#", "color", "@"};
char* expected_a[] = {"Red", "", "Green", "Orange", "White"};
char** result_a = func0(list1_a, 5, charlist_a, 3);
for(int i = 0; i < 5; i++) {
assert(strcmp(result_a[i], expected_a[i]) == 0);
free(result_a[i]);
}
free(result_a);
// Test case 2
char* list1_b[] = {"Red &", "Orange+", "Green", "Orange @", "White"};
char* charlist_b[] = {"&", "+", "@"};
char* expected_b[] = {"Red", "", "Green", "Orange", "White"};
char** result_b = func0(list1_b, 5, charlist_b, 3);
for(int i = 0; i < 5; i++) {
assert(strcmp(result_b[i], expected_b[i]) == 0);
free(result_b[i]);
}
free(result_b);
// Test case 3
char* list1_c[] = {"Red &", "Orange+", "Green", "Orange @", "White"};
char* charlist_c[] = {"@"};
char* expected_c[] = {"Red &", "Orange+", "Green", "Orange", "White"};
char** result_c = func0(list1_c, 5, charlist_c, 1);
for(int i = 0; i < 5; i++) {
assert(strcmp(result_c[i], expected_c[i]) == 0);
free(result_c[i]);
}
free(result_c);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
mov %rdx,%r14
push %r13
mov %ecx,%r13d
push %r12
push %rbp
push %rbx
sub $0x458,%rsp
mov %rdi,0x30(%rsp)
movslq %esi,%rdi
mov %rdx,0x8(%rsp)
mov %rdi,%rbx
shl $0x3,%rdi
mov %fs:0x28,%rax
mov %rax,0x448(%rsp)
xor %eax,%eax
callq 1120 <malloc@plt>
mov %rax,0x20(%rsp)
test %ebx,%ebx
jle 1742 <func0+0x182>
movq $0x0,0x10(%rsp)
lea -0x1(%rbx),%eax
mov %rax,0x28(%rsp)
lea -0x1(%r13),%eax
lea 0x8(%r14,%rax,8),%rbx
lea 0x50(%rsp),%rax
mov %rax,0x38(%rsp)
lea 0x40(%rsp),%r14
nopl (%rax)
mov 0x10(%rsp),%rdx
mov 0x30(%rsp),%rax
lea 0x9b3(%rip),%rbp
mov (%rax,%rdx,8),%rdi
callq 1140 <strdup@plt>
mov 0x38(%rsp),%rdi
pxor %xmm0,%xmm0
mov $0x7e,%ecx
mov %rax,%rdx
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x98b(%rip),%rsi
rep stos %rax,%es:(%rdi)
mov %rdx,%rdi
movaps %xmm0,0x40(%rsp)
callq 1130 <strtok@plt>
mov %rax,%r15
test %rax,%rax
je 16d4 <func0+0x114>
nopl 0x0(%rax)
mov 0x8(%rsp),%r12
test %r13d,%r13d
jg 16b1 <func0+0xf1>
jmp 1710 <func0+0x150>
nopl 0x0(%rax)
add $0x8,%r12
cmp %rbx,%r12
je 1710 <func0+0x150>
mov (%r12),%rsi
mov %r15,%rdi
callq 1150 <strstr@plt>
test %rax,%rax
je 16a8 <func0+0xe8>
mov %rbp,%rsi
xor %edi,%edi
callq 1130 <strtok@plt>
mov %rax,%r15
test %rax,%rax
jne 1698 <func0+0xd8>
mov %r14,%rdi
callq 1140 <strdup@plt>
mov 0x10(%rsp),%r15
mov 0x20(%rsp),%rdx
mov 0x18(%rsp),%rdi
mov %rax,(%rdx,%r15,8)
callq 10e0 <free@plt>
lea 0x1(%r15),%rax
cmp %r15,0x28(%rsp)
je 1742 <func0+0x182>
mov %rax,0x10(%rsp)
jmpq 1640 <func0+0x80>
nopl 0x0(%rax)
cmpb $0x0,0x40(%rsp)
jne 1730 <func0+0x170>
mov $0x400,%edx
mov %r15,%rsi
mov %r14,%rdi
callq 10d0 <__strcat_chk@plt>
jmp 16c2 <func0+0x102>
nopl 0x0(%rax)
mov $0x400,%edx
mov %rbp,%rsi
mov %r14,%rdi
callq 10d0 <__strcat_chk@plt>
jmp 1717 <func0+0x157>
mov 0x448(%rsp),%rax
xor %fs:0x28,%rax
jne 176c <func0+0x1ac>
mov 0x20(%rsp),%rax
add $0x458,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10f0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
mov r14, rdx
push r13
mov r13d, ecx
push r12
push rbp
push rbx
mov ebx, esi
sub rsp, 458h
mov [rsp+488h+var_460], rdi
mov [rsp+488h+var_480], rdx
mov rax, fs:28h
mov [rsp+488h+var_40], rax
xor eax, eax
movsxd rax, esi
lea rdi, ds:0[rax*8]
mov [rsp+488h+var_458], rax
call _malloc
mov [rsp+488h+var_468], rax
test ebx, ebx
jle loc_1707
lea eax, [r13-1]
lea rbp, unk_2004
mov [rsp+488h+var_478], 0
lea rbx, [r14+rax*8+8]
lea rax, [rsp+488h+var_438]
mov [rsp+488h+var_450], rax
lea r14, [rsp+488h+var_448]
nop dword ptr [rax+00h]
loc_1648:
mov rdx, [rsp+488h+var_478]
mov rax, [rsp+488h+var_460]
mov rdi, [rax+rdx*8]
call _strdup
mov rdi, [rsp+488h+var_450]
mov ecx, 7Eh ; '~'
mov rsi, rbp
mov rdx, rax
mov [rsp+488h+var_470], rax
xor eax, eax
pxor xmm0, xmm0
rep stosq
mov rdi, rdx
movaps [rsp+488h+var_448], xmm0
call _strtok
mov r15, rax
test rax, rax
jz short loc_16D0
xchg ax, ax
loc_1690:
mov r12, [rsp+488h+var_480]
test r13d, r13d
jg short loc_16AD
jmp loc_1738
loc_16A0:
add r12, 8
cmp r12, rbx
jz loc_1738
loc_16AD:
mov rsi, [r12]
mov rdi, r15
call _strstr
test rax, rax
jz short loc_16A0
loc_16BE:
mov rsi, rbp
xor edi, edi
call _strtok
mov r15, rax
test rax, rax
jnz short loc_1690
loc_16D0:
mov rdi, r14
call _strdup
mov r15, [rsp+488h+var_478]
mov rdx, [rsp+488h+var_468]
mov rdi, [rsp+488h+var_470]
mov [rdx+r15*8], rax
call _free
mov rcx, r15
add rcx, 1
mov [rsp+488h+var_478], rcx
cmp rcx, [rsp+488h+var_458]
jnz loc_1648
loc_1707:
mov rax, [rsp+488h+var_40]
sub rax, fs:28h
jnz short loc_176A
mov rax, [rsp+488h+var_468]
add rsp, 458h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1738:
cmp byte ptr [rsp+488h+var_448], 0
jnz short loc_1758
loc_173F:
mov edx, 400h
mov rsi, r15
mov rdi, r14
call ___strcat_chk
jmp loc_16BE
loc_1758:
mov edx, 400h
mov rsi, rbp
mov rdi, r14
call ___strcat_chk
jmp short loc_173F
loc_176A:
call ___stack_chk_fail | long long func0(long long a1, int a2, _QWORD *a3, int a4)
{
long long j; // r15
_QWORD *v7; // r12
long long i; // [rsp+10h] [rbp-478h]
long long v11; // [rsp+18h] [rbp-470h]
long long v12; // [rsp+20h] [rbp-468h]
_OWORD v13[64]; // [rsp+40h] [rbp-448h] BYREF
unsigned long long v14; // [rsp+448h] [rbp-40h]
v14 = __readfsqword(0x28u);
v12 = malloc(8LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
v11 = strdup(*(_QWORD *)(a1 + 8 * i));
memset(v13, 0, sizeof(v13));
for ( j = strtok(v11, &unk_2004); j; j = strtok(0LL, &unk_2004) )
{
v7 = a3;
if ( a4 > 0 )
{
while ( !strstr(j, *v7, 0.0) )
{
if ( ++v7 == &a3[(unsigned int)(a4 - 1) + 1] )
goto LABEL_11;
}
}
else
{
LABEL_11:
if ( LOBYTE(v13[0]) )
__strcat_chk(v13, &unk_2004, 1024LL, 0.0);
__strcat_chk(v13, j, 1024LL, 0.0);
}
}
*(_QWORD *)(v12 + 8 * i) = strdup(v13);
free(v11, 0.0);
}
}
return v12;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDX
PUSH R13
MOV R13D,ECX
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
SUB RSP,0x458
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x448],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
LEA RDI,[RAX*0x8]
MOV qword ptr [RSP + 0x30],RAX
CALL 0x00101120
MOV qword ptr [RSP + 0x20],RAX
TEST EBX,EBX
JLE 0x00101707
LEA EAX,[R13 + -0x1]
LEA RBP,[0x102004]
MOV qword ptr [RSP + 0x10],0x0
LEA RBX,[R14 + RAX*0x8 + 0x8]
LEA RAX,[RSP + 0x50]
MOV qword ptr [RSP + 0x38],RAX
LEA R14,[RSP + 0x40]
NOP dword ptr [RAX]
LAB_00101648:
MOV RDX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX + RDX*0x8]
CALL 0x00101140
MOV RDI,qword ptr [RSP + 0x38]
MOV ECX,0x7e
MOV RSI,RBP
MOV RDX,RAX
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
STOSQ.REP RDI
MOV RDI,RDX
MOVAPS xmmword ptr [RSP + 0x40],XMM0
CALL 0x00101130
MOV R15,RAX
TEST RAX,RAX
JZ 0x001016d0
NOP
LAB_00101690:
MOV R12,qword ptr [RSP + 0x8]
TEST R13D,R13D
JG 0x001016ad
JMP 0x00101738
LAB_001016a0:
ADD R12,0x8
CMP R12,RBX
JZ 0x00101738
LAB_001016ad:
MOV RSI,qword ptr [R12]
MOV RDI,R15
CALL 0x00101150
TEST RAX,RAX
JZ 0x001016a0
LAB_001016be:
MOV RSI,RBP
XOR EDI,EDI
CALL 0x00101130
MOV R15,RAX
TEST RAX,RAX
JNZ 0x00101690
LAB_001016d0:
MOV RDI,R14
CALL 0x00101140
MOV R15,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RDX + R15*0x8],RAX
CALL 0x001010e0
MOV RCX,R15
ADD RCX,0x1
MOV qword ptr [RSP + 0x10],RCX
CMP RCX,qword ptr [RSP + 0x30]
JNZ 0x00101648
LAB_00101707:
MOV RAX,qword ptr [RSP + 0x448]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010176a
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x458
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101738:
CMP byte ptr [RSP + 0x40],0x0
JNZ 0x00101758
LAB_0010173f:
MOV EDX,0x400
MOV RSI,R15
MOV RDI,R14
CALL 0x001010d0
JMP 0x001016be
LAB_00101758:
MOV EDX,0x400
MOV RSI,RBP
MOV RDI,R14
CALL 0x001010d0
JMP 0x0010173f
LAB_0010176a:
CALL 0x001010f0 | void * func0(long param_1,int param_2,int8 *param_3,int param_4)
{
void *pvVar1;
char *__s;
char *pcVar2;
char *pcVar3;
long lVar4;
int8 *puVar5;
long in_FS_OFFSET;
byte bVar6;
long local_478;
int1 local_448 [16];
int8 local_438 [127];
long local_40;
bVar6 = 0;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
pvVar1 = malloc((long)param_2 * 8);
if (0 < param_2) {
local_478 = 0;
do {
__s = strdup(*(char **)(param_1 + local_478 * 8));
puVar5 = local_438;
for (lVar4 = 0x7e; lVar4 != 0; lVar4 = lVar4 + -1) {
*puVar5 = 0;
puVar5 = puVar5 + (ulong)bVar6 * -2 + 1;
}
local_448 = (int1 [16])0x0;
pcVar2 = strtok(__s," ");
while (pcVar2 != (char *)0x0) {
puVar5 = param_3;
if (0 < param_4) {
do {
pcVar3 = strstr(pcVar2,(char *)*puVar5);
if (pcVar3 != (char *)0x0) goto LAB_001016be;
puVar5 = puVar5 + 1;
} while (puVar5 != param_3 + (ulong)(param_4 - 1) + 1);
}
if (local_448[0] != '\0') {
__strcat_chk(local_448,&DAT_00102004,0x400);
}
__strcat_chk(local_448,pcVar2,0x400);
LAB_001016be:
pcVar2 = strtok((char *)0x0," ");
}
pcVar2 = strdup(local_448);
*(char **)((long)pvVar1 + local_478 * 8) = pcVar2;
free(__s);
local_478 = local_478 + 1;
} while (local_478 != param_2);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return pvVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,175 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
| char** func0(char* list1[], int n1, char* charlist[], int n_char) {
char** new_list = malloc(n1 * sizeof(char*));
for(int i = 0; i < n1; i++) {
char* line = strdup(list1[i]);
char* token;
char buffer[1024] = "";
token = strtok(line, " ");
while(token != NULL) {
int skip = 0;
for(int j = 0; j < n_char; j++) {
if(strstr(token, charlist[j]) != NULL) {
skip = 1;
break;
}
}
if(!skip) {
if(strlen(buffer) > 0) strcat(buffer, " ");
strcat(buffer, token);
}
token = strtok(NULL, " ");
}
new_list[i] = strdup(buffer);
free(line);
}
return new_list;
}
| int main() {
// Test case 1
char* list1_a[] = {"Red color", "Orange#", "Green", "Orange @", "White"};
char* charlist_a[] = {"#", "color", "@"};
char* expected_a[] = {"Red", "", "Green", "Orange", "White"};
char** result_a = func0(list1_a, 5, charlist_a, 3);
for(int i = 0; i < 5; i++) {
assert(strcmp(result_a[i], expected_a[i]) == 0);
free(result_a[i]);
}
free(result_a);
// Test case 2
char* list1_b[] = {"Red &", "Orange+", "Green", "Orange @", "White"};
char* charlist_b[] = {"&", "+", "@"};
char* expected_b[] = {"Red", "", "Green", "Orange", "White"};
char** result_b = func0(list1_b, 5, charlist_b, 3);
for(int i = 0; i < 5; i++) {
assert(strcmp(result_b[i], expected_b[i]) == 0);
free(result_b[i]);
}
free(result_b);
// Test case 3
char* list1_c[] = {"Red &", "Orange+", "Green", "Orange @", "White"};
char* charlist_c[] = {"@"};
char* expected_c[] = {"Red &", "Orange+", "Green", "Orange", "White"};
char** result_c = func0(list1_c, 5, charlist_c, 1);
for(int i = 0; i < 5; i++) {
assert(strcmp(result_c[i], expected_c[i]) == 0);
free(result_c[i]);
}
free(result_c);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdx,%r14
push %r13
mov %ecx,%r13d
push %r12
push %rbp
push %rbx
sub $0x458,%rsp
mov %rdi,0x30(%rsp)
movslq %esi,%rdi
mov %rdx,0x8(%rsp)
mov %rdi,%rbx
shl $0x3,%rdi
mov %fs:0x28,%rax
mov %rax,0x448(%rsp)
xor %eax,%eax
callq 1120 <malloc@plt>
mov %rax,0x20(%rsp)
test %ebx,%ebx
jle 1752 <func0+0x182>
movq $0x0,0x10(%rsp)
lea -0x1(%rbx),%eax
mov 0x10(%rsp),%rdx
mov %rax,0x28(%rsp)
lea -0x1(%r13),%eax
lea 0x8(%r14,%rax,8),%rbx
lea 0x50(%rsp),%rax
mov %rax,0x38(%rsp)
lea 0x40(%rsp),%r14
nopw 0x0(%rax,%rax,1)
mov 0x30(%rsp),%rax
lea 0x9a0(%rip),%rbp
mov (%rax,%rdx,8),%rdi
callq 1140 <strdup@plt>
mov 0x38(%rsp),%rdi
pxor %xmm0,%xmm0
mov $0x7e,%ecx
mov %rax,%rdx
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x978(%rip),%rsi
rep stos %rax,%es:(%rdi)
mov %rdx,%rdi
movaps %xmm0,0x40(%rsp)
callq 1130 <strtok@plt>
mov %rax,%r15
test %rax,%rax
je 16e4 <func0+0x114>
nopl 0x0(%rax)
mov 0x8(%rsp),%r12
test %r13d,%r13d
jg 16c1 <func0+0xf1>
jmp 1720 <func0+0x150>
nopl 0x0(%rax)
add $0x8,%r12
cmp %r12,%rbx
je 1720 <func0+0x150>
mov (%r12),%rsi
mov %r15,%rdi
callq 1150 <strstr@plt>
test %rax,%rax
je 16b8 <func0+0xe8>
mov %rbp,%rsi
xor %edi,%edi
callq 1130 <strtok@plt>
mov %rax,%r15
test %rax,%rax
jne 16a8 <func0+0xd8>
mov %r14,%rdi
callq 1140 <strdup@plt>
mov 0x10(%rsp),%r15
mov 0x20(%rsp),%rdx
mov 0x18(%rsp),%rdi
mov %rax,(%rdx,%r15,8)
callq 10e0 <free@plt>
lea 0x1(%r15),%rax
cmp 0x28(%rsp),%r15
je 1752 <func0+0x182>
mov %rax,0x10(%rsp)
mov %rax,%rdx
jmpq 1658 <func0+0x88>
nopl 0x0(%rax)
cmpb $0x0,0x40(%rsp)
jne 1740 <func0+0x170>
mov $0x400,%edx
mov %r15,%rsi
mov %r14,%rdi
callq 10d0 <__strcat_chk@plt>
jmp 16d2 <func0+0x102>
nopl 0x0(%rax)
mov $0x400,%edx
mov %rbp,%rsi
mov %r14,%rdi
callq 10d0 <__strcat_chk@plt>
jmp 1727 <func0+0x157>
mov 0x448(%rsp),%rax
xor %fs:0x28,%rax
jne 177c <func0+0x1ac>
mov 0x20(%rsp),%rax
add $0x458,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10f0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
mov r15d, ecx
push r14
mov r14, rdx
push r13
push r12
push rbp
mov rbp, rdi
push rbx
movsxd rbx, esi
mov r12, rbx
shl rbx, 3
mov rdi, rbx; size
sub rsp, 448h
mov [rsp+478h+var_474], ecx
mov rax, fs:28h
mov [rsp+478h+var_40], rax
xor eax, eax
call _malloc
mov [rsp+478h+var_450], rax
test r12d, r12d
jle loc_170B
mov [rsp+478h+var_468], rax
lea rax, [rbp+rbx+0]
lea r13, [rsp+478h+s]
mov [rsp+478h+var_458], rax
movsxd rax, r15d
lea r12, delim; " "
mov [rsp+478h+var_470], rbp
lea rbp, [r14+rax*8]
nop dword ptr [rax+00h]
loc_1650:
mov rax, [rsp+478h+var_470]
mov rdi, [rax]; s
call _strdup
mov ecx, 80h
mov rdi, r13
mov rsi, r12; delim
mov rdx, rax
mov [rsp+478h+ptr], rax
xor eax, eax
rep stosq
mov rdi, rdx; s
call _strtok
mov rbx, rax
test rax, rax
jz short loc_16CF
nop dword ptr [rax]
loc_1688:
mov eax, [rsp+478h+var_474]
test eax, eax
jle loc_1738
loc_1694:
mov r15, r14
jmp short loc_16AD
loc_16A0:
add r15, 8
cmp rbp, r15
jz loc_1738
loc_16AD:
mov rsi, [r15]; needle
mov rdi, rbx; haystack
call _strstr
test rax, rax
jz short loc_16A0
mov rsi, r12; delim
xor edi, edi; s
call _strtok
mov rbx, rax
test rax, rax
jnz short loc_1694
loc_16CF:
mov rdi, r13; s
call _strdup
mov rbx, [rsp+478h+var_468]
mov rdi, [rsp+478h+ptr]; ptr
mov [rbx], rax
add rbx, 8
call _free
add [rsp+478h+var_470], 8
mov rcx, [rsp+478h+var_458]
mov rax, [rsp+478h+var_470]
mov [rsp+478h+var_468], rbx
cmp rax, rcx
jnz loc_1650
loc_170B:
mov rax, [rsp+478h+var_40]
sub rax, fs:28h
jnz short loc_1782
mov rax, [rsp+478h+var_450]
add rsp, 448h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1738:
cmp [rsp+478h+s], 0
jnz short loc_1770
loc_173F:
mov rsi, rbx
mov edx, 400h
mov rdi, r13
call ___strcat_chk
mov rsi, r12; delim
xor edi, edi; s
call _strtok
mov rbx, rax
test rax, rax
jnz loc_1688
jmp loc_16CF
loc_1770:
mov edx, 400h
mov rsi, r12
mov rdi, r13
call ___strcat_chk
jmp short loc_173F
loc_1782:
call ___stack_chk_fail | _QWORD * func0(const char **a1, int a2, const char **a3, int a4)
{
_QWORD *v6; // rax
const char **v7; // rbp
char *v8; // rbx
const char **v9; // r15
const char **v12; // [rsp+8h] [rbp-470h]
char **v13; // [rsp+10h] [rbp-468h]
char *ptr; // [rsp+18h] [rbp-460h]
_QWORD *v15; // [rsp+28h] [rbp-450h]
char s[1032]; // [rsp+30h] [rbp-448h] BYREF
unsigned long long v17; // [rsp+438h] [rbp-40h]
v17 = __readfsqword(0x28u);
v6 = malloc(8LL * a2);
v15 = v6;
if ( a2 > 0 )
{
v13 = (char **)v6;
v12 = a1;
v7 = &a3[a4];
do
{
ptr = strdup(*v12);
memset(s, 0, 0x400uLL);
v8 = strtok(ptr, " ");
if ( v8 )
{
while ( a4 <= 0 )
{
LABEL_11:
if ( s[0] )
__strcat_chk(s, " ", 1024LL);
__strcat_chk(s, v8, 1024LL);
v8 = strtok(0LL, " ");
if ( !v8 )
goto LABEL_9;
}
do
{
v9 = a3;
while ( !strstr(v8, *v9) )
{
if ( v7 == ++v9 )
goto LABEL_11;
}
v8 = strtok(0LL, " ");
}
while ( v8 );
}
LABEL_9:
*v13 = strdup(s);
free(ptr);
++v12;
++v13;
}
while ( v12 != &a1[a2] );
}
return v15;
} | func0:
ENDBR64
PUSH R15
MOV R15D,ECX
PUSH R14
MOV R14,RDX
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOVSXD RBX,ESI
MOV R12,RBX
SHL RBX,0x3
MOV RDI,RBX
SUB RSP,0x448
MOV dword ptr [RSP + 0x4],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x438],RAX
XOR EAX,EAX
CALL 0x00101120
MOV qword ptr [RSP + 0x28],RAX
TEST R12D,R12D
JLE 0x0010170b
MOV qword ptr [RSP + 0x10],RAX
LEA RAX,[RBP + RBX*0x1]
LEA R13,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
MOVSXD RAX,R15D
LEA R12,[0x102004]
MOV qword ptr [RSP + 0x8],RBP
LEA RBP,[R14 + RAX*0x8]
NOP dword ptr [RAX]
LAB_00101650:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
CALL 0x00101140
MOV ECX,0x80
MOV RDI,R13
MOV RSI,R12
MOV RDX,RAX
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
STOSQ.REP RDI
MOV RDI,RDX
CALL 0x00101130
MOV RBX,RAX
TEST RAX,RAX
JZ 0x001016cf
NOP dword ptr [RAX]
LAB_00101688:
MOV EAX,dword ptr [RSP + 0x4]
TEST EAX,EAX
JLE 0x00101738
LAB_00101694:
MOV R15,R14
JMP 0x001016ad
LAB_001016a0:
ADD R15,0x8
CMP RBP,R15
JZ 0x00101738
LAB_001016ad:
MOV RSI,qword ptr [R15]
MOV RDI,RBX
CALL 0x00101150
TEST RAX,RAX
JZ 0x001016a0
MOV RSI,R12
XOR EDI,EDI
CALL 0x00101130
MOV RBX,RAX
TEST RAX,RAX
JNZ 0x00101694
LAB_001016cf:
MOV RDI,R13
CALL 0x00101140
MOV RBX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RBX],RAX
ADD RBX,0x8
CALL 0x001010e0
ADD qword ptr [RSP + 0x8],0x8
MOV RCX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RBX
CMP RAX,RCX
JNZ 0x00101650
LAB_0010170b:
MOV RAX,qword ptr [RSP + 0x438]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101782
MOV RAX,qword ptr [RSP + 0x28]
ADD RSP,0x448
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101738:
CMP byte ptr [RSP + 0x30],0x0
JNZ 0x00101770
LAB_0010173f:
MOV RSI,RBX
MOV EDX,0x400
MOV RDI,R13
CALL 0x001010d0
MOV RSI,R12
XOR EDI,EDI
CALL 0x00101130
MOV RBX,RAX
TEST RAX,RAX
JNZ 0x00101688
JMP 0x001016cf
LAB_00101770:
MOV EDX,0x400
MOV RSI,R12
MOV RDI,R13
CALL 0x001010d0
JMP 0x0010173f
LAB_00101782:
CALL 0x001010f0 | int8 * func0(int8 *param_1,int param_2,int8 *param_3,int param_4)
{
int8 *puVar1;
char *__s;
char *pcVar2;
char *pcVar3;
long lVar4;
int8 *puVar5;
long in_FS_OFFSET;
byte bVar6;
int8 *local_470;
int8 *local_468;
char local_448 [1032];
long local_40;
bVar6 = 0;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
puVar1 = (int8 *)malloc((long)param_2 * 8);
if (0 < param_2) {
local_470 = param_1;
local_468 = puVar1;
do {
__s = strdup((char *)*local_470);
pcVar2 = local_448;
for (lVar4 = 0x80; lVar4 != 0; lVar4 = lVar4 + -1) {
pcVar2[0] = '\0';
pcVar2[1] = '\0';
pcVar2[2] = '\0';
pcVar2[3] = '\0';
pcVar2[4] = '\0';
pcVar2[5] = '\0';
pcVar2[6] = '\0';
pcVar2[7] = '\0';
pcVar2 = pcVar2 + (ulong)bVar6 * -0x10 + 8;
}
pcVar2 = strtok(__s," ");
while (pcVar2 != (char *)0x0) {
puVar5 = param_3;
if (0 < param_4) {
do {
while (pcVar3 = strstr(pcVar2,(char *)*puVar5), pcVar3 != (char *)0x0) {
pcVar2 = strtok((char *)0x0," ");
puVar5 = param_3;
if (pcVar2 == (char *)0x0) goto LAB_001016cf;
}
puVar5 = puVar5 + 1;
} while (param_3 + param_4 != puVar5);
}
if (local_448[0] != '\0') {
__strcat_chk(local_448,&DAT_00102004,0x400);
}
__strcat_chk(local_448,pcVar2,0x400);
pcVar2 = strtok((char *)0x0," ");
}
LAB_001016cf:
pcVar2 = strdup(local_448);
*local_468 = pcVar2;
local_468 = local_468 + 1;
free(__s);
local_470 = local_470 + 1;
} while (local_470 != param_1 + param_2);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,176 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int cmpfunc(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| int func0(int arr[], int N, int K) {
qsort(arr, N, sizeof(int), cmpfunc);
int *dp = (int *)malloc(N * sizeof(int));
dp[0] = 0;
for (int i = 1; i < N; i++) {
dp[i] = dp[i-1];
if (arr[i] - arr[i-1] < K) {
if (i >= 2) {
dp[i] = (dp[i] > (dp[i-2] + arr[i] + arr[i-1])) ? dp[i] : (dp[i-2] + arr[i] + arr[i-1]);
} else {
dp[i] = (dp[i] > (arr[i] + arr[i-1])) ? dp[i] : (arr[i] + arr[i-1]);
}
}
}
int result = dp[N-1];
free(dp);
return result;
}
| int main() {
int arr1[] = {3, 5, 10, 15, 17, 12, 9};
int arr2[] = {5, 15, 10, 300};
int arr3[] = {1, 2, 3, 4, 5, 6};
assert(func0(arr1, 7, 4) == 62);
assert(func0(arr2, 4, 12) == 25);
assert(func0(arr3, 6, 6) == 21);
printf("All assertions passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rsi
mov -0x18(%rbp),%rax
lea -0x49(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 10c0 <qsort@plt>
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
movl $0x0,(%rax)
movl $0x1,-0x10(%rbp)
jmpq 13b4 <func0+0x1a9>
mov -0x10(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
sub %eax,%edx
mov %edx,%eax
cmp %eax,-0x20(%rbp)
jle 13b0 <func0+0x1a5>
cmpl $0x1,-0x10(%rbp)
jle 1350 <func0+0x145>
mov -0x10(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x8(%rax),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
add %eax,%edx
mov -0x10(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
add %eax,%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
mov -0x10(%rbp),%ecx
movslq %ecx,%rcx
lea 0x0(,%rcx,4),%rsi
mov -0x8(%rbp),%rcx
add %rsi,%rcx
cmp %eax,%edx
cmovge %edx,%eax
mov %eax,(%rcx)
jmp 13b0 <func0+0x1a5>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x10(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
add %eax,%edx
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
mov -0x10(%rbp),%ecx
movslq %ecx,%rcx
lea 0x0(,%rcx,4),%rsi
mov -0x8(%rbp),%rcx
add %rsi,%rcx
cmp %eax,%edx
cmovge %edx,%eax
mov %eax,(%rcx)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 126a <func0+0x5f>
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 10a0 <free@plt>
mov -0xc(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+base], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov eax, [rbp+var_1C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, cmpfunc
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov rax, [rbp+ptr]
mov dword ptr [rax], 0
mov [rbp+var_10], 1
jmp loc_13B5
loc_126D:
mov eax, [rbp+var_10]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rbp+var_10]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+ptr]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
shl rax, 2
lea rcx, [rax-4]
mov rax, [rbp+base]
add rax, rcx
mov eax, [rax]
sub edx, eax
cmp [rbp+var_20], edx
jle loc_13B1
cmp [rbp+var_10], 1
jle short loc_1351
mov eax, [rbp+var_10]
cdqe
shl rax, 2
lea rdx, [rax-8]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+base]
add rax, rcx
mov eax, [rax]
add edx, eax
mov eax, [rbp+var_10]
cdqe
shl rax, 2
lea rcx, [rax-4]
mov rax, [rbp+base]
add rax, rcx
mov eax, [rax]
add edx, eax
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rcx
mov eax, [rax]
mov ecx, [rbp+var_10]
movsxd rcx, ecx
lea rsi, ds:0[rcx*4]
mov rcx, [rbp+ptr]
add rcx, rsi
cmp edx, eax
cmovge eax, edx
mov [rcx], eax
jmp short loc_13B1
loc_1351:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_10]
cdqe
shl rax, 2
lea rcx, [rax-4]
mov rax, [rbp+base]
add rax, rcx
mov eax, [rax]
add edx, eax
mov eax, [rbp+var_10]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rcx
mov eax, [rax]
mov ecx, [rbp+var_10]
movsxd rcx, ecx
lea rsi, ds:0[rcx*4]
mov rcx, [rbp+ptr]
add rcx, rsi
cmp edx, eax
cmovge eax, edx
mov [rcx], eax
loc_13B1:
add [rbp+var_10], 1
loc_13B5:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_1C]
jl loc_126D
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov eax, [rbp+var_C]
leave
retn | long long func0(void *a1, int a2, int a3)
{
int v3; // eax
int v4; // eax
int i; // [rsp+10h] [rbp-10h]
unsigned int v8; // [rsp+14h] [rbp-Ch]
_DWORD *ptr; // [rsp+18h] [rbp-8h]
qsort(a1, a2, 4uLL, cmpfunc);
ptr = malloc(4LL * a2);
*ptr = 0;
for ( i = 1; i < a2; ++i )
{
ptr[i] = ptr[i - 1];
if ( a3 > *((_DWORD *)a1 + i) - *((_DWORD *)a1 + i - 1) )
{
if ( i <= 1 )
{
v4 = ptr[i];
if ( *((_DWORD *)a1 + i - 1) + *((_DWORD *)a1 + i) >= v4 )
v4 = *((_DWORD *)a1 + i - 1) + *((_DWORD *)a1 + i);
ptr[i] = v4;
}
else
{
v3 = ptr[i];
if ( *((_DWORD *)a1 + i - 1) + *((_DWORD *)a1 + i) + ptr[i - 2] >= v3 )
v3 = *((_DWORD *)a1 + i - 1) + *((_DWORD *)a1 + i) + ptr[i - 2];
ptr[i] = v3;
}
}
}
v8 = ptr[a2 - 1];
free(ptr);
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x1011e9]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x001010c0
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x10],0x1
JMP 0x001013b5
LAB_0010126d:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
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 + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
SUB EDX,EAX
CMP dword ptr [RBP + -0x20],EDX
JLE 0x001013b1
CMP dword ptr [RBP + -0x10],0x1
JLE 0x00101351
MOV EAX,dword ptr [RBP + -0x10]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x10]
MOVSXD RCX,ECX
LEA RSI,[RCX*0x4]
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,RSI
CMP EDX,EAX
CMOVGE EAX,EDX
MOV dword ptr [RCX],EAX
JMP 0x001013b1
LAB_00101351:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x10]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x10]
MOVSXD RCX,ECX
LEA RSI,[RCX*0x4]
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,RSI
CMP EDX,EAX
CMOVGE EAX,EDX
MOV dword ptr [RCX],EAX
LAB_001013b1:
ADD dword ptr [RBP + -0x10],0x1
LAB_001013b5:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010126d
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x001010a0
MOV EAX,dword ptr [RBP + -0xc]
LEAVE
RET | int4 func0(void *param_1,int param_2,int param_3)
{
int4 uVar1;
int iVar2;
int4 *__ptr;
int iVar3;
int local_18;
qsort(param_1,(long)param_2,4,cmpfunc);
__ptr = (int4 *)malloc((long)param_2 << 2);
*__ptr = 0;
for (local_18 = 1; local_18 < param_2; local_18 = local_18 + 1) {
__ptr[local_18] = __ptr[(long)local_18 + -1];
if (*(int *)((long)param_1 + (long)local_18 * 4) -
*(int *)((long)param_1 + (long)local_18 * 4 + -4) < param_3) {
if (local_18 < 2) {
iVar3 = *(int *)((long)param_1 + (long)local_18 * 4) +
*(int *)((long)param_1 + (long)local_18 * 4 + -4);
iVar2 = __ptr[local_18];
if ((int)__ptr[local_18] <= iVar3) {
iVar2 = iVar3;
}
__ptr[local_18] = iVar2;
}
else {
iVar3 = __ptr[(long)local_18 + -2] + *(int *)((long)param_1 + (long)local_18 * 4) +
*(int *)((long)param_1 + (long)local_18 * 4 + -4);
iVar2 = __ptr[local_18];
if ((int)__ptr[local_18] <= iVar3) {
iVar2 = iVar3;
}
__ptr[local_18] = iVar2;
}
}
}
uVar1 = __ptr[(long)param_2 + -1];
free(__ptr);
return uVar1;
} |
6,177 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int cmpfunc(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| int func0(int arr[], int N, int K) {
qsort(arr, N, sizeof(int), cmpfunc);
int *dp = (int *)malloc(N * sizeof(int));
dp[0] = 0;
for (int i = 1; i < N; i++) {
dp[i] = dp[i-1];
if (arr[i] - arr[i-1] < K) {
if (i >= 2) {
dp[i] = (dp[i] > (dp[i-2] + arr[i] + arr[i-1])) ? dp[i] : (dp[i-2] + arr[i] + arr[i-1]);
} else {
dp[i] = (dp[i] > (arr[i] + arr[i-1])) ? dp[i] : (arr[i] + arr[i-1]);
}
}
}
int result = dp[N-1];
free(dp);
return result;
}
| int main() {
int arr1[] = {3, 5, 10, 15, 17, 12, 9};
int arr2[] = {5, 15, 10, 300};
int arr3[] = {1, 2, 3, 4, 5, 6};
assert(func0(arr1, 7, 4) == 62);
assert(func0(arr2, 4, 12) == 25);
assert(func0(arr3, 6, 6) == 21);
printf("All assertions passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%r13d
mov %edx,%ebp
movslq %esi,%r12
lea -0x29(%rip),%rcx
mov $0x4,%edx
mov %r12,%rsi
callq 10c0 <qsort@plt>
shl $0x2,%r12
mov %r12,%rdi
callq 10f0 <malloc@plt>
mov %rax,%rdi
movl $0x0,(%rax)
cmp $0x1,%r13d
jle 128a <func0+0x98>
lea -0x2(%r13),%r9d
add $0x2,%r9
mov $0x1,%edx
jmp 1260 <func0+0x6e>
add -0x8(%rdi,%rdx,4),%ecx
add %esi,%ecx
cmp %eax,%ecx
cmovl %eax,%ecx
mov %ecx,(%rdi,%rdx,4)
add $0x1,%rdx
cmp %r9,%rdx
je 128a <func0+0x98>
mov -0x4(%rdi,%rdx,4),%eax
mov %eax,(%rdi,%rdx,4)
mov (%rbx,%rdx,4),%ecx
mov -0x4(%rbx,%rdx,4),%esi
mov %ecx,%r8d
sub %esi,%r8d
cmp %ebp,%r8d
jge 1257 <func0+0x65>
cmp $0x1,%edx
jg 1249 <func0+0x57>
add %ecx,%esi
cmp %eax,%esi
cmovge %esi,%eax
mov %eax,(%rdi,%rdx,4)
jmp 1257 <func0+0x65>
mov -0x4(%rdi,%r12,1),%ebx
callq 10a0 <free@plt>
mov %ebx,%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 rbx, rdi
mov r13d, esi
mov ebp, edx
movsxd r12, esi
lea rcx, cmpfunc
mov edx, 4
mov rsi, r12
call _qsort
shl r12, 2
mov rdi, r12
call _malloc
mov rdi, rax
mov dword ptr [rax], 0
cmp r13d, 1
jle short loc_1285
mov r9d, r13d
mov eax, 1
jmp short loc_1257
loc_1244:
add edx, esi
cmp edx, ecx
cmovl edx, ecx
mov [rdi+rax*4], edx
loc_124E:
add rax, 1
cmp rax, r9
jz short loc_1285
loc_1257:
mov ecx, [rdi+rax*4-4]
mov [rdi+rax*4], ecx
mov edx, [rbx+rax*4]
mov esi, [rbx+rax*4-4]
mov r8d, edx
sub r8d, esi
cmp r8d, ebp
jge short loc_124E
cmp eax, 1
jle short loc_1244
add edx, [rdi+rax*4-8]
add edx, esi
cmp edx, ecx
cmovl edx, ecx
mov [rdi+rax*4], edx
jmp short loc_124E
loc_1285:
mov ebx, [rdi+r12-4]
call _free
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(long long a1, int a2, int a3)
{
long long v6; // r12
_DWORD *v7; // rdi
long long i; // rax
int v9; // edx
int v10; // ecx
int v11; // edx
int v12; // esi
int v13; // edx
unsigned int v14; // ebx
qsort(a1, a2, 4LL, cmpfunc);
v6 = a2;
v7 = (_DWORD *)malloc(v6 * 4);
*v7 = 0;
if ( a2 > 1 )
{
for ( i = 1LL; i != a2; ++i )
{
v10 = v7[i - 1];
v7[i] = v10;
v11 = *(_DWORD *)(a1 + 4 * i);
v12 = *(_DWORD *)(a1 + 4 * i - 4);
if ( v11 - v12 < a3 )
{
if ( (int)i <= 1 )
{
v9 = v12 + v11;
if ( v9 < v10 )
v9 = v10;
v7[i] = v9;
}
else
{
v13 = v12 + v7[i - 2] + v11;
if ( v13 < v10 )
v13 = v10;
v7[i] = v13;
}
}
}
}
v14 = v7[v6 - 1];
free();
return v14;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV R13D,ESI
MOV EBP,EDX
MOVSXD R12,ESI
LEA RCX,[0x1011e9]
MOV EDX,0x4
MOV RSI,R12
CALL 0x001010c0
SHL R12,0x2
MOV RDI,R12
CALL 0x001010f0
MOV RDI,RAX
MOV dword ptr [RAX],0x0
CMP R13D,0x1
JLE 0x00101285
MOV R9D,R13D
MOV EAX,0x1
JMP 0x00101257
LAB_00101244:
ADD EDX,ESI
CMP EDX,ECX
CMOVL EDX,ECX
MOV dword ptr [RDI + RAX*0x4],EDX
LAB_0010124e:
ADD RAX,0x1
CMP RAX,R9
JZ 0x00101285
LAB_00101257:
MOV ECX,dword ptr [RDI + RAX*0x4 + -0x4]
MOV dword ptr [RDI + RAX*0x4],ECX
MOV EDX,dword ptr [RBX + RAX*0x4]
MOV ESI,dword ptr [RBX + RAX*0x4 + -0x4]
MOV R8D,EDX
SUB R8D,ESI
CMP R8D,EBP
JGE 0x0010124e
CMP EAX,0x1
JLE 0x00101244
ADD EDX,dword ptr [RDI + RAX*0x4 + -0x8]
ADD EDX,ESI
CMP EDX,ECX
CMOVL EDX,ECX
MOV dword ptr [RDI + RAX*0x4],EDX
JMP 0x0010124e
LAB_00101285:
MOV EBX,dword ptr [RDI + R12*0x1 + -0x4]
CALL 0x001010a0
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | int4 func0(void *param_1,uint param_2,int param_3)
{
int iVar1;
int iVar2;
int4 uVar3;
int4 *__ptr;
ulong uVar4;
int iVar5;
int iVar6;
size_t __nmemb;
__nmemb = (size_t)(int)param_2;
qsort(param_1,__nmemb,4,cmpfunc);
__ptr = (int4 *)malloc(__nmemb * 4);
*__ptr = 0;
if (1 < (int)param_2) {
uVar4 = 1;
do {
iVar1 = __ptr[uVar4 - 1];
__ptr[uVar4] = iVar1;
iVar2 = *(int *)((long)param_1 + uVar4 * 4);
iVar6 = *(int *)((long)param_1 + uVar4 * 4 + -4);
if (iVar2 - iVar6 < param_3) {
if ((int)uVar4 < 2) {
iVar5 = iVar2 + iVar6;
if (iVar2 + iVar6 < iVar1) {
iVar5 = iVar1;
}
__ptr[uVar4] = iVar5;
}
else {
iVar6 = iVar2 + __ptr[uVar4 - 2] + iVar6;
if (iVar6 < iVar1) {
iVar6 = iVar1;
}
__ptr[uVar4] = iVar6;
}
}
uVar4 = uVar4 + 1;
} while (uVar4 != param_2);
}
uVar3 = __ptr[__nmemb - 1];
free(__ptr);
return uVar3;
} |
6,178 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int cmpfunc(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| int func0(int arr[], int N, int K) {
qsort(arr, N, sizeof(int), cmpfunc);
int *dp = (int *)malloc(N * sizeof(int));
dp[0] = 0;
for (int i = 1; i < N; i++) {
dp[i] = dp[i-1];
if (arr[i] - arr[i-1] < K) {
if (i >= 2) {
dp[i] = (dp[i] > (dp[i-2] + arr[i] + arr[i-1])) ? dp[i] : (dp[i-2] + arr[i] + arr[i-1]);
} else {
dp[i] = (dp[i] > (arr[i] + arr[i-1])) ? dp[i] : (arr[i] + arr[i-1]);
}
}
}
int result = dp[N-1];
free(dp);
return result;
}
| int main() {
int arr1[] = {3, 5, 10, 15, 17, 12, 9};
int arr2[] = {5, 15, 10, 300};
int arr3[] = {1, 2, 3, 4, 5, 6};
assert(func0(arr1, 7, 4) == 62);
assert(func0(arr2, 4, 12) == 25);
assert(func0(arr3, 6, 6) == 21);
printf("All assertions passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r13
lea -0x1d(%rip),%rcx
push %r12
movslq %esi,%r12
push %rbp
mov %r12,%rsi
mov %r12,%r13
mov %edx,%ebp
push %rbx
mov $0x4,%edx
shl $0x2,%r12
mov %rdi,%rbx
sub $0x8,%rsp
callq 10c0 <qsort@plt>
mov %r12,%rdi
callq 10f0 <malloc@plt>
movl $0x0,(%rax)
mov %rax,%rdi
cmp $0x1,%r13d
jle 1414 <func0+0xa4>
lea -0x2(%r13),%r9d
mov $0x1,%edx
xor %eax,%eax
add $0x1,%r9
jmp 13ea <func0+0x7a>
nopl 0x0(%rax)
add -0x8(%rdi,%rdx,4),%ecx
add %esi,%ecx
cmp %eax,%ecx
cmovl %eax,%ecx
mov %ecx,(%rdi,%rdx,4)
cmp %r9,%rdx
je 1414 <func0+0xa4>
mov (%rdi,%rdx,4),%eax
add $0x1,%rdx
mov (%rbx,%rdx,4),%ecx
mov -0x4(%rbx,%rdx,4),%esi
mov %eax,(%rdi,%rdx,4)
mov %ecx,%r8d
sub %esi,%r8d
cmp %ebp,%r8d
jge 13de <func0+0x6e>
cmp $0x1,%rdx
jne 13d0 <func0+0x60>
add %ecx,%esi
cmp %eax,%esi
cmovge %esi,%eax
mov %eax,0x4(%rdi)
cmp %r9,%rdx
jne 13e3 <func0+0x73>
mov -0x4(%rdi,%r12,1),%r12d
callq 10a0 <free@plt>
add $0x8,%rsp
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
| func0:
endbr64
push r13
lea rcx, cmpfunc
push r12
movsxd r12, esi
push rbp
mov rsi, r12
mov r13, r12
mov ebp, edx
push rbx
mov edx, 4
shl r12, 2
mov rbx, rdi
sub rsp, 8
call _qsort
mov rdi, r12
call _malloc
mov dword ptr [rax], 0
mov rdi, rax
cmp r13d, 1
jle short loc_140C
lea r9d, [r13-1]
mov eax, 1
xor ecx, ecx
jmp short loc_13E2
loc_13C8:
add edx, [rdi+rax*4-8]
add edx, esi
cmp edx, ecx
cmovl edx, ecx
mov [rdi+rax*4], edx
loc_13D6:
cmp rax, r9
jz short loc_140C
loc_13DB:
mov ecx, [rdi+rax*4]
add rax, 1
loc_13E2:
mov edx, [rbx+rax*4]
mov esi, [rbx+rax*4-4]
mov [rdi+rax*4], ecx
mov r8d, edx
sub r8d, esi
cmp r8d, ebp
jge short loc_13D6
cmp rax, 1
jnz short loc_13C8
add edx, esi
cmp edx, ecx
cmovl edx, ecx
mov [rdi+4], edx
cmp rax, r9
jnz short loc_13DB
loc_140C:
mov r12d, [rdi+r12-4]
call _free
add rsp, 8
pop rbx
mov eax, r12d
pop rbp
pop r12
pop r13
retn | long long func0(long long a1, int a2, int a3)
{
long long v4; // r12
_DWORD *v6; // rax
_DWORD *v7; // rdi
long long v8; // r9
long long v9; // rax
int i; // ecx
int v11; // edx
int v12; // edx
int v13; // esi
int v14; // edx
unsigned int v15; // r12d
v4 = a2;
qsort(a1, a2, 4LL, cmpfunc);
v6 = (_DWORD *)malloc(v4 * 4);
*v6 = 0;
v7 = v6;
if ( a2 > 1 )
{
v8 = (unsigned int)(a2 - 1);
v9 = 1LL;
for ( i = 0; ; i = v7[v9++] )
{
v12 = *(_DWORD *)(a1 + 4 * v9);
v13 = *(_DWORD *)(a1 + 4 * v9 - 4);
v7[v9] = i;
if ( v12 - v13 >= a3 )
goto LABEL_6;
if ( v9 != 1 )
break;
v14 = v13 + v12;
if ( v14 < i )
v14 = i;
v7[1] = v14;
if ( v8 == 1 )
goto LABEL_13;
LABEL_7:
;
}
v11 = v13 + v7[v9 - 2] + v12;
if ( v11 < i )
v11 = i;
v7[v9] = v11;
LABEL_6:
if ( v9 == v8 )
goto LABEL_13;
goto LABEL_7;
}
LABEL_13:
v15 = v7[v4 - 1];
free();
return v15;
} | func0:
ENDBR64
PUSH R13
LEA RCX,[0x101360]
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RSI,R12
MOV R13,R12
MOV EBP,EDX
PUSH RBX
MOV EDX,0x4
SHL R12,0x2
MOV RBX,RDI
SUB RSP,0x8
CALL 0x001010c0
MOV RDI,R12
CALL 0x001010f0
MOV dword ptr [RAX],0x0
MOV RDI,RAX
CMP R13D,0x1
JLE 0x0010140c
LEA R9D,[R13 + -0x1]
MOV EAX,0x1
XOR ECX,ECX
JMP 0x001013e2
LAB_001013c8:
ADD EDX,dword ptr [RDI + RAX*0x4 + -0x8]
ADD EDX,ESI
CMP EDX,ECX
CMOVL EDX,ECX
MOV dword ptr [RDI + RAX*0x4],EDX
LAB_001013d6:
CMP RAX,R9
JZ 0x0010140c
LAB_001013db:
MOV ECX,dword ptr [RDI + RAX*0x4]
ADD RAX,0x1
LAB_001013e2:
MOV EDX,dword ptr [RBX + RAX*0x4]
MOV ESI,dword ptr [RBX + RAX*0x4 + -0x4]
MOV dword ptr [RDI + RAX*0x4],ECX
MOV R8D,EDX
SUB R8D,ESI
CMP R8D,EBP
JGE 0x001013d6
CMP RAX,0x1
JNZ 0x001013c8
ADD EDX,ESI
CMP EDX,ECX
CMOVL EDX,ECX
MOV dword ptr [RDI + 0x4],EDX
CMP RAX,R9
JNZ 0x001013db
LAB_0010140c:
MOV R12D,dword ptr [RDI + R12*0x1 + -0x4]
CALL 0x001010a0
ADD RSP,0x8
POP RBX
MOV EAX,R12D
POP RBP
POP R12
POP R13
RET | int4 func0(void *param_1,int param_2,int param_3)
{
int iVar1;
int4 uVar2;
int4 *__ptr;
ulong uVar3;
int iVar4;
int iVar5;
int iVar6;
size_t __nmemb;
__nmemb = (size_t)param_2;
qsort(param_1,__nmemb,4,cmpfunc);
__ptr = (int4 *)malloc(__nmemb * 4);
*__ptr = 0;
if (1 < param_2) {
uVar3 = 1;
iVar4 = 0;
do {
iVar1 = *(int *)((long)param_1 + uVar3 * 4);
iVar5 = *(int *)((long)param_1 + uVar3 * 4 + -4);
__ptr[uVar3] = iVar4;
if (iVar1 - iVar5 < param_3) {
if (uVar3 != 1) {
iVar5 = iVar1 + __ptr[uVar3 - 2] + iVar5;
if (iVar5 < iVar4) {
iVar5 = iVar4;
}
__ptr[uVar3] = iVar5;
goto LAB_001013d6;
}
iVar6 = iVar1 + iVar5;
if (iVar1 + iVar5 < iVar4) {
iVar6 = iVar4;
}
__ptr[1] = iVar6;
if ((ulong)(param_2 - 1) == 1) break;
}
else {
LAB_001013d6:
if (uVar3 == param_2 - 1) break;
}
iVar4 = __ptr[uVar3];
uVar3 = uVar3 + 1;
} while( true );
}
uVar2 = __ptr[__nmemb - 1];
free(__ptr);
return uVar2;
} |
6,179 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int cmpfunc(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| int func0(int arr[], int N, int K) {
qsort(arr, N, sizeof(int), cmpfunc);
int *dp = (int *)malloc(N * sizeof(int));
dp[0] = 0;
for (int i = 1; i < N; i++) {
dp[i] = dp[i-1];
if (arr[i] - arr[i-1] < K) {
if (i >= 2) {
dp[i] = (dp[i] > (dp[i-2] + arr[i] + arr[i-1])) ? dp[i] : (dp[i-2] + arr[i] + arr[i-1]);
} else {
dp[i] = (dp[i] > (arr[i] + arr[i-1])) ? dp[i] : (arr[i] + arr[i-1]);
}
}
}
int result = dp[N-1];
free(dp);
return result;
}
| int main() {
int arr1[] = {3, 5, 10, 15, 17, 12, 9};
int arr2[] = {5, 15, 10, 300};
int arr3[] = {1, 2, 3, 4, 5, 6};
assert(func0(arr1, 7, 4) == 62);
assert(func0(arr2, 4, 12) == 25);
assert(func0(arr3, 6, 6) == 21);
printf("All assertions passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r13
movslq %esi,%r13
lea -0x20(%rip),%rcx
push %r12
mov %r13,%rsi
mov %edx,%r12d
mov $0x4,%edx
push %rbp
mov %r13,%rbp
shl $0x2,%r13
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 10c0 <qsort@plt>
mov %r13,%rdi
callq 10f0 <malloc@plt>
movl $0x0,(%rax)
mov %rax,%rdi
cmp $0x1,%ebp
jle 144e <func0+0x10e>
cmp $0x3,%ebp
jle 14b6 <func0+0x176>
lea -0x4(%rbp),%edx
mov (%rbx),%r8d
mov $0x3,%ecx
shr %edx
lea 0x5(%rdx,%rdx,1),%r9
mov -0x8(%rbx,%rcx,4),%r10d
mov (%rax),%edx
mov %r10d,%esi
mov %edx,0x4(%rax)
sub %r8d,%esi
cmp %r12d,%esi
jge 13d9 <func0+0x99>
cmp $0x3,%ecx
je 1466 <func0+0x126>
mov -0x4(%rax),%esi
add %r10d,%esi
add %esi,%r8d
cmp %edx,%r8d
cmovl %edx,%r8d
mov %r8d,0x4(%rax)
mov -0x4(%rbx,%rcx,4),%r8d
mov 0x4(%rax),%esi
mov %r8d,%r11d
mov %esi,0x8(%rax)
sub %r10d,%r11d
cmp %r11d,%r12d
jg 1490 <func0+0x150>
movslq %ecx,%rdx
add $0x2,%rcx
add $0x8,%rax
cmp %r9,%rcx
jne 13a7 <func0+0x67>
jmp 141e <func0+0xde>
nopl (%rax)
add -0x8(%rdi,%rdx,4),%ecx
add %esi,%ecx
cmp %eax,%ecx
cmovl %eax,%ecx
mov %ecx,(%rdi,%rdx,4)
add $0x1,%rdx
cmp %edx,%ebp
jle 144e <func0+0x10e>
mov (%rbx,%rdx,4),%ecx
mov -0x4(%rbx,%rdx,4),%esi
mov -0x4(%rdi,%rdx,4),%eax
mov %ecx,%r8d
sub %esi,%r8d
mov %eax,(%rdi,%rdx,4)
cmp %r8d,%r12d
jle 1416 <func0+0xd6>
cmp $0x1,%edx
jne 1408 <func0+0xc8>
add %ecx,%esi
cmp %eax,%esi
cmovge %esi,%eax
mov %eax,(%rdi,%rdx,4)
add $0x1,%rdx
cmp %edx,%ebp
jg 141e <func0+0xde>
mov -0x4(%rdi,%r13,1),%r12d
callq 10a0 <free@plt>
add $0x8,%rsp
pop %rbx
mov %r12d,%eax
pop %rbp
pop %r12
pop %r13
retq
lea (%r10,%r8,1),%esi
mov -0x4(%rbx,%rcx,4),%r8d
cmp %edx,%esi
cmovl %edx,%esi
mov %r8d,%r11d
sub %r10d,%r11d
mov %esi,0x4(%rax)
mov %esi,0x8(%rax)
cmp %r12d,%r11d
jge 13f3 <func0+0xb3>
nopl 0x0(%rax)
add %r8d,%edx
add %r10d,%edx
cmp %esi,%edx
cmovl %esi,%edx
add $0x8,%rax
mov %edx,(%rax)
movslq %ecx,%rdx
add $0x2,%rcx
cmp %r9,%rcx
jne 13a7 <func0+0x67>
jmpq 141e <func0+0xde>
mov $0x1,%edx
jmpq 141e <func0+0xde>
| func0:
endbr64
push r13
movsxd r13, esi
lea rcx, cmpfunc; compar
push r12
mov rsi, r13; nmemb
mov r12d, edx
mov edx, 4; size
push rbp
mov rbp, r13
shl r13, 2
push rbx
mov rbx, rdi
sub rsp, 8
call _qsort
mov rdi, r13; size
call _malloc
mov dword ptr [rax], 0
mov rdi, rax; ptr
cmp ebp, 1
jle loc_13F8
cmp ebp, 3
jle loc_1488
mov rdx, rax
lea eax, [rbp-4]
mov esi, [rbx]
shr eax, 1
lea r9d, [rax+rax]
mov eax, 1
add r9, 3
loc_139C:
mov r8d, [rbx+rax*4]
mov ecx, [rdx]
mov r10d, r8d
mov [rdx+4], ecx
sub r10d, esi
cmp r10d, r12d
jge short loc_13CC
cmp rax, 1
jz loc_1478
mov r10d, [rdx-4]
add r10d, r8d
add esi, r10d
cmp esi, ecx
cmovl esi, ecx
mov [rdx+4], esi
loc_13CC:
mov esi, [rbx+rax*4+4]
mov r10d, [rdx+4]
mov r11d, esi
mov [rdx+8], r10d
sub r11d, r8d
cmp r12d, r11d
jg short loc_1410
lea rcx, [rax+2]
add rdx, 8
cmp rcx, r9
jz short loc_142B
loc_13F0:
mov rax, rcx
jmp short loc_139C
loc_13F8:
mov ebx, [rdi+r13-4]
call _free
add rsp, 8
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1410:
add ecx, esi
add ecx, r8d
cmp ecx, r10d
cmovl ecx, r10d
add rdx, 8
mov [rdx], ecx
lea rcx, [rax+2]
cmp rcx, r9
jnz short loc_13F0
loc_142B:
add eax, 2
loc_142E:
cdqe
jmp short loc_144E
loc_1438:
add edx, [rdi+rax*4-8]
add edx, ecx
cmp edx, esi
cmovl edx, esi
mov [rdi+rax*4], edx
loc_1446:
add rax, 1
cmp ebp, eax
jle short loc_13F8
loc_144E:
mov edx, [rbx+rax*4]
mov ecx, [rbx+rax*4-4]
mov esi, [rdi+rax*4-4]
mov r8d, edx
sub r8d, ecx
mov [rdi+rax*4], esi
cmp r8d, r12d
jge short loc_1446
cmp eax, 1
jnz short loc_1438
add ecx, edx
cmp ecx, esi
cmovl ecx, esi
mov [rdi+rax*4], ecx
jmp short loc_1446
loc_1478:
add esi, r8d
cmp esi, ecx
cmovl esi, ecx
mov [rdx+4], esi
jmp loc_13CC
loc_1488:
mov eax, 1
jmp short loc_142E | long long func0(int *a1, int a2, int a3)
{
size_t v5; // r13
_DWORD *v7; // rax
_DWORD *v8; // rdi
int *v9; // rdx
int v10; // esi
long long v11; // rax
long long v12; // r9
int v13; // r8d
int v14; // ecx
int v15; // esi
int v16; // r10d
long long v17; // rcx
unsigned int v18; // ebx
int v20; // ecx
int v21; // edx
int v22; // edx
int v23; // ecx
int v24; // esi
int v25; // ecx
int v26; // esi
v5 = a2;
qsort(a1, a2, 4uLL, cmpfunc);
v7 = malloc(v5 * 4);
*v7 = 0;
v8 = v7;
if ( a2 <= 1 )
goto LABEL_12;
if ( a2 <= 3 )
{
LODWORD(v11) = 1;
goto LABEL_17;
}
v9 = v7;
v10 = *a1;
v11 = 1LL;
v12 = 2 * ((unsigned int)(a2 - 4) >> 1) + 3LL;
while ( 1 )
{
v13 = a1[v11];
v14 = *v9;
v9[1] = *v9;
if ( v13 - v10 < a3 )
{
if ( v11 == 1 )
{
v26 = v13 + v10;
if ( v26 < v14 )
v26 = v14;
v9[1] = v26;
}
else
{
v15 = v13 + *(v9 - 1) + v10;
if ( v15 < v14 )
v15 = v14;
v9[1] = v15;
}
}
v10 = a1[v11 + 1];
v16 = v9[1];
v9[2] = v16;
if ( a3 > v10 - v13 )
break;
v17 = v11 + 2;
v9 += 2;
if ( v11 + 2 == v12 )
goto LABEL_16;
LABEL_11:
v11 = v17;
}
v20 = v13 + v10 + v14;
if ( v20 < v16 )
v20 = v16;
v9 += 2;
*v9 = v20;
v17 = v11 + 2;
if ( v11 + 2 != v12 )
goto LABEL_11;
LABEL_16:
LODWORD(v11) = v11 + 2;
LABEL_17:
v11 = (int)v11;
do
{
v22 = a1[v11];
v23 = a1[v11 - 1];
v24 = v8[v11 - 1];
v8[v11] = v24;
if ( v22 - v23 < a3 )
{
if ( (_DWORD)v11 == 1 )
{
v25 = v22 + v23;
if ( v25 < v24 )
v25 = v24;
v8[v11] = v25;
}
else
{
v21 = v23 + v8[v11 - 2] + v22;
if ( v21 < v24 )
v21 = v24;
v8[v11] = v21;
}
}
++v11;
}
while ( a2 > (int)v11 );
LABEL_12:
v18 = v8[v5 - 1];
free(v8);
return v18;
} | func0:
ENDBR64
PUSH R13
MOVSXD R13,ESI
LEA RCX,[0x101320]
PUSH R12
MOV RSI,R13
MOV R12D,EDX
MOV EDX,0x4
PUSH RBP
MOV RBP,R13
SHL R13,0x2
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x001010c0
MOV RDI,R13
CALL 0x001010f0
MOV dword ptr [RAX],0x0
MOV RDI,RAX
CMP EBP,0x1
JLE 0x001013f8
CMP EBP,0x3
JLE 0x00101488
MOV RDX,RAX
LEA EAX,[RBP + -0x4]
MOV ESI,dword ptr [RBX]
SHR EAX,0x1
LEA R9D,[RAX + RAX*0x1]
MOV EAX,0x1
ADD R9,0x3
LAB_0010139c:
MOV R8D,dword ptr [RBX + RAX*0x4]
MOV ECX,dword ptr [RDX]
MOV R10D,R8D
MOV dword ptr [RDX + 0x4],ECX
SUB R10D,ESI
CMP R10D,R12D
JGE 0x001013cc
CMP RAX,0x1
JZ 0x00101478
MOV R10D,dword ptr [RDX + -0x4]
ADD R10D,R8D
ADD ESI,R10D
CMP ESI,ECX
CMOVL ESI,ECX
MOV dword ptr [RDX + 0x4],ESI
LAB_001013cc:
MOV ESI,dword ptr [RBX + RAX*0x4 + 0x4]
MOV R10D,dword ptr [RDX + 0x4]
MOV R11D,ESI
MOV dword ptr [RDX + 0x8],R10D
SUB R11D,R8D
CMP R12D,R11D
JG 0x00101410
LEA RCX,[RAX + 0x2]
ADD RDX,0x8
CMP RCX,R9
JZ 0x0010142b
LAB_001013f0:
MOV RAX,RCX
JMP 0x0010139c
LAB_001013f8:
MOV EBX,dword ptr [RDI + R13*0x1 + -0x4]
CALL 0x001010a0
ADD RSP,0x8
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101410:
ADD ECX,ESI
ADD ECX,R8D
CMP ECX,R10D
CMOVL ECX,R10D
ADD RDX,0x8
MOV dword ptr [RDX],ECX
LEA RCX,[RAX + 0x2]
CMP RCX,R9
JNZ 0x001013f0
LAB_0010142b:
ADD EAX,0x2
LAB_0010142e:
CDQE
JMP 0x0010144e
LAB_00101438:
ADD EDX,dword ptr [RDI + RAX*0x4 + -0x8]
ADD EDX,ECX
CMP EDX,ESI
CMOVL EDX,ESI
MOV dword ptr [RDI + RAX*0x4],EDX
LAB_00101446:
ADD RAX,0x1
CMP EBP,EAX
JLE 0x001013f8
LAB_0010144e:
MOV EDX,dword ptr [RBX + RAX*0x4]
MOV ECX,dword ptr [RBX + RAX*0x4 + -0x4]
MOV ESI,dword ptr [RDI + RAX*0x4 + -0x4]
MOV R8D,EDX
SUB R8D,ECX
MOV dword ptr [RDI + RAX*0x4],ESI
CMP R8D,R12D
JGE 0x00101446
CMP EAX,0x1
JNZ 0x00101438
ADD ECX,EDX
CMP ECX,ESI
CMOVL ECX,ESI
MOV dword ptr [RDI + RAX*0x4],ECX
JMP 0x00101446
LAB_00101478:
ADD ESI,R8D
CMP ESI,ECX
CMOVL ESI,ECX
MOV dword ptr [RDX + 0x4],ESI
JMP 0x001013cc
LAB_00101488:
MOV EAX,0x1
JMP 0x0010142e | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int *__ptr;
long lVar2;
int iVar3;
int iVar4;
int *piVar5;
int iVar6;
size_t __nmemb;
__nmemb = (size_t)param_2;
qsort(param_1,__nmemb,4,cmpfunc);
__ptr = (int *)malloc(__nmemb * 4);
*__ptr = 0;
if (1 < param_2) {
if (param_2 < 4) {
iVar6 = 1;
}
else {
iVar6 = *param_1;
lVar2 = 1;
piVar5 = __ptr;
while( true ) {
iVar4 = param_1[lVar2];
iVar1 = *piVar5;
piVar5[1] = iVar1;
if (iVar4 - iVar6 < param_3) {
if (lVar2 == 1) {
iVar3 = iVar6 + iVar4;
if (iVar6 + iVar4 < iVar1) {
iVar3 = iVar1;
}
piVar5[1] = iVar3;
}
else {
iVar6 = iVar6 + piVar5[-1] + iVar4;
if (iVar6 < iVar1) {
iVar6 = iVar1;
}
piVar5[1] = iVar6;
}
}
iVar6 = param_1[lVar2 + 1];
iVar3 = piVar5[1];
piVar5[2] = iVar3;
if (iVar6 - iVar4 < param_3) {
iVar4 = iVar1 + iVar6 + iVar4;
if (iVar4 < iVar3) {
iVar4 = iVar3;
}
piVar5[2] = iVar4;
}
if (lVar2 + 2 == (ulong)(param_2 - 4U & 0xfffffffe) + 3) break;
lVar2 = lVar2 + 2;
piVar5 = piVar5 + 2;
}
iVar6 = (int)lVar2 + 2;
}
lVar2 = (long)iVar6;
do {
iVar6 = param_1[lVar2];
iVar4 = param_1[lVar2 + -1];
iVar1 = __ptr[lVar2 + -1];
__ptr[lVar2] = iVar1;
if (iVar6 - iVar4 < param_3) {
if ((int)lVar2 == 1) {
iVar3 = iVar4 + iVar6;
if (iVar4 + iVar6 < iVar1) {
iVar3 = iVar1;
}
__ptr[lVar2] = iVar3;
}
else {
iVar4 = iVar6 + __ptr[lVar2 + -2] + iVar4;
if (iVar4 < iVar1) {
iVar4 = iVar1;
}
__ptr[lVar2] = iVar4;
}
}
lVar2 = lVar2 + 1;
} while ((int)lVar2 < param_2);
}
iVar6 = __ptr[__nmemb - 1];
free(__ptr);
return iVar6;
} |
6,180 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
void print_array(int arr[], int size) {
printf("[");
for (int i = 0; i < size; i++) {
printf("%d", arr[i]);
if (i < size - 1) printf(", ");
}
printf("]\n");
}
int arrays_equal(int a[], int b[], int sizeA, int sizeB) {
if (sizeA != sizeB) return 0;
for (int i = 0; i < sizeA; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
| int* func0(int nums[], int size, int *returnSize) {
int *result = (int*)malloc(size * sizeof(int));
int k = 0;
for (int i = 0; i < size; i++) {
int count = 0;
for (int j = 0; j < size; j++) {
if (nums[i] == nums[j]) {
count++;
}
}
if (count == 1) {
result[k++] = nums[i];
}
}
*returnSize = k;
return result;
}
| int main() {
int sz;
int testArr1[] = {1, 2, 3, 2, 3, 4, 5};
int expected1[] = {1, 4, 5};
int* result1 = func0(testArr1, 7, &sz);
assert(arrays_equal(result1, expected1, sz, 3));
int testArr2[] = {1, 2, 3, 2, 4, 5};
int expected2[] = {1, 3, 4, 5};
int* result2 = func0(testArr2, 6, &sz);
assert(arrays_equal(result2, expected2, sz, 4));
int testArr3[] = {1, 2, 3, 4, 5};
int expected3[] = {1, 2, 3, 4, 5};
int* result3 = func0(testArr3, 5, &sz);
assert(arrays_equal(result3, expected3, sz, 5));
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 1110 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmpq 13d3 <func0+0xcc>
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 138e <func0+0x87>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 138a <func0+0x83>
addl $0x1,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1356 <func0+0x4f>
cmpl $0x1,-0x10(%rbp)
jne 13cf <func0+0xc8>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1346 <func0+0x3f>
mov -0x38(%rbp),%rax
mov -0x18(%rbp),%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp loc_13DC
loc_134F:
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp short loc_1397
loc_135F:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_1393
add [rbp+var_10], 1
loc_1393:
add [rbp+var_C], 1
loc_1397:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_2C]
jl short loc_135F
cmp [rbp+var_10], 1
jnz short loc_13D8
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_13D8:
add [rbp+var_14], 1
loc_13DC:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl loc_134F
mov rax, [rbp+var_38]
mov edx, [rbp+var_18]
mov [rax], edx
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
int v6; // [rsp+28h] [rbp-18h]
int i; // [rsp+2Ch] [rbp-14h]
int v8; // [rsp+30h] [rbp-10h]
int j; // [rsp+34h] [rbp-Ch]
_DWORD *v10; // [rsp+38h] [rbp-8h]
v10 = malloc(4LL * a2);
v6 = 0;
for ( i = 0; i < a2; ++i )
{
v8 = 0;
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * j + a1) )
++v8;
}
if ( v8 == 1 )
{
v3 = v6++;
v10[v3] = *(_DWORD *)(4LL * i + a1);
}
}
*a3 = v6;
return v10;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x00101110
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001013dc
LAB_0010134f:
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101397
LAB_0010135f:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x00101393
ADD dword ptr [RBP + -0x10],0x1
LAB_00101393:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101397:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x0010135f
CMP dword ptr [RBP + -0x10],0x1
JNZ 0x001013d8
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
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_001013d8:
ADD dword ptr [RBP + -0x14],0x1
LAB_001013dc:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x0010134f
MOV RAX,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x18]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int *param_3)
{
void *pvVar1;
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
pvVar1 = malloc((long)param_2 << 2);
local_20 = 0;
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (*(int *)(param_1 + (long)local_1c * 4) == *(int *)(param_1 + (long)local_14 * 4)) {
local_18 = local_18 + 1;
}
}
if (local_18 == 1) {
*(int4 *)((long)local_20 * 4 + (long)pvVar1) =
*(int4 *)((long)local_1c * 4 + param_1);
local_20 = local_20 + 1;
}
}
*param_3 = local_20;
return pvVar1;
} |
6,181 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
void print_array(int arr[], int size) {
printf("[");
for (int i = 0; i < size; i++) {
printf("%d", arr[i]);
if (i < size - 1) printf(", ");
}
printf("]\n");
}
int arrays_equal(int a[], int b[], int sizeA, int sizeB) {
if (sizeA != sizeB) return 0;
for (int i = 0; i < sizeA; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
| int* func0(int nums[], int size, int *returnSize) {
int *result = (int*)malloc(size * sizeof(int));
int k = 0;
for (int i = 0; i < size; i++) {
int count = 0;
for (int j = 0; j < size; j++) {
if (nums[i] == nums[j]) {
count++;
}
}
if (count == 1) {
result[k++] = nums[i];
}
}
*returnSize = k;
return result;
}
| int main() {
int sz;
int testArr1[] = {1, 2, 3, 2, 3, 4, 5};
int expected1[] = {1, 4, 5};
int* result1 = func0(testArr1, 7, &sz);
assert(arrays_equal(result1, expected1, sz, 3));
int testArr2[] = {1, 2, 3, 2, 4, 5};
int expected2[] = {1, 3, 4, 5};
int* result2 = func0(testArr2, 6, &sz);
assert(arrays_equal(result2, expected2, sz, 4));
int testArr3[] = {1, 2, 3, 4, 5};
int expected3[] = {1, 2, 3, 4, 5};
int* result3 = func0(testArr3, 5, &sz);
assert(arrays_equal(result3, expected3, sz, 5));
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%r12d
mov %rdx,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
callq 1100 <malloc@plt>
test %r12d,%r12d
jle 1346 <func0+0x74>
mov %rbp,%r11
lea -0x1(%r12),%edx
lea 0x4(%rbp,%rdx,4),%r8
mov %rbp,%r9
mov $0x0,%r10d
jmp 1315 <func0+0x43>
add $0x4,%r9
cmp %r8,%r9
je 134c <func0+0x7a>
mov (%r9),%edi
mov %r11,%rdx
mov $0x0,%ecx
cmp (%rdx),%edi
sete %sil
movzbl %sil,%esi
add %esi,%ecx
add $0x4,%rdx
cmp %r8,%rdx
jne 1320 <func0+0x4e>
cmp $0x1,%ecx
jne 130c <func0+0x3a>
movslq %r10d,%rdx
mov %edi,(%rax,%rdx,4)
lea 0x1(%r10),%r10d
jmp 130c <func0+0x3a>
mov $0x0,%r10d
mov %r10d,(%rbx)
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
mov r12d, esi
mov rbp, rdx
movsxd rdi, esi
shl rdi, 2
call _malloc
test r12d, r12d
jle short loc_134D
lea edx, [r12-1]
lea r8, [rbx+rdx*4+4]
mov r9, rbx
mov r10d, 0
jmp short loc_131C
loc_1313:
add r9, 4
cmp r9, r8
jz short loc_1353
loc_131C:
mov edi, [r9]
mov rdx, rbx
mov ecx, 0
loc_1327:
cmp edi, [rdx]
setz sil
movzx esi, sil
add ecx, esi
add rdx, 4
cmp rdx, r8
jnz short loc_1327
cmp ecx, 1
jnz short loc_1313
movsxd rdx, r10d
mov [rax+rdx*4], edi
lea r10d, [r10+1]
jmp short loc_1313
loc_134D:
mov r10d, 0
loc_1353:
mov [rbp+0], r10d
pop rbx
pop rbp
pop r12
retn | long long func0(int *a1, int a2, _DWORD *a3)
{
long long result; // rax
long long v6; // r8
int *v7; // r9
int v8; // r10d
int v9; // edi
int *v10; // rdx
int v11; // ecx
result = malloc(4LL * a2);
if ( a2 <= 0 )
{
v8 = 0;
}
else
{
v6 = (long long)&a1[a2 - 1 + 1];
v7 = a1;
v8 = 0;
do
{
v9 = *v7;
v10 = a1;
v11 = 0;
do
v11 += v9 == *v10++;
while ( v10 != (int *)v6 );
if ( v11 == 1 )
*(_DWORD *)(result + 4LL * v8++) = v9;
++v7;
}
while ( v7 != (int *)v6 );
}
*a3 = v8;
return result;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV R12D,ESI
MOV RBP,RDX
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x00101100
TEST R12D,R12D
JLE 0x0010134d
LEA EDX,[R12 + -0x1]
LEA R8,[RBX + RDX*0x4 + 0x4]
MOV R9,RBX
MOV R10D,0x0
JMP 0x0010131c
LAB_00101313:
ADD R9,0x4
CMP R9,R8
JZ 0x00101353
LAB_0010131c:
MOV EDI,dword ptr [R9]
MOV RDX,RBX
MOV ECX,0x0
LAB_00101327:
CMP EDI,dword ptr [RDX]
SETZ SIL
MOVZX ESI,SIL
ADD ECX,ESI
ADD RDX,0x4
CMP RDX,R8
JNZ 0x00101327
CMP ECX,0x1
JNZ 0x00101313
MOVSXD RDX,R10D
MOV dword ptr [RAX + RDX*0x4],EDI
LEA R10D,[R10 + 0x1]
JMP 0x00101313
LAB_0010134d:
MOV R10D,0x0
LAB_00101353:
MOV dword ptr [RBP],R10D
POP RBX
POP RBP
POP R12
RET | void func0(int *param_1,int param_2,int *param_3)
{
void *pvVar1;
int iVar2;
int *piVar3;
int *piVar4;
int iVar5;
pvVar1 = malloc((long)param_2 << 2);
if (param_2 < 1) {
iVar5 = 0;
}
else {
iVar5 = 0;
piVar4 = param_1;
do {
iVar2 = 0;
piVar3 = param_1;
do {
iVar2 = iVar2 + (uint)(*piVar4 == *piVar3);
piVar3 = piVar3 + 1;
} while (piVar3 != param_1 + (ulong)(param_2 - 1) + 1);
if (iVar2 == 1) {
*(int *)((long)pvVar1 + (long)iVar5 * 4) = *piVar4;
iVar5 = iVar5 + 1;
}
piVar4 = piVar4 + 1;
} while (piVar4 != param_1 + (ulong)(param_2 - 1) + 1);
}
*param_3 = iVar5;
return;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.