index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
7,182 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
| bool func0(const char *p) {
int len = strlen(p);
bool hasLower = false;
bool hasUpper = false;
bool hasDigit = false;
bool hasSpecial = false;
if (len < 6 || len > 12) {
return false;
}
for (int i = 0; i < len; i++) {
if (islower(p[i])) {
hasLower = true;
} else if (isupper(p[i])) {
hasUpper = true;
} else if (isdigit(p[i])) {
hasDigit = true;
} else if (p[i] == '$' || p[i] == '#' || p[i] == '@') {
hasSpecial = true;
} else if (isspace(p[i])) {
return false;
}
}
return hasLower && hasUpper && hasDigit && hasSpecial;
}
| int main() {
assert(func0("password") == false);
assert(func0("Password@10") == true);
assert(func0("password@10") == false);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
lea -0x6(%rax),%edx
mov %rax,%rbx
xor %eax,%eax
cmp $0x6,%edx
ja 12de <func0+0xae>
test %ebx,%ebx
jle 12de <func0+0xae>
callq 1090 <__ctype_b_loc@plt>
mov %rbp,%rdi
xor %r10d,%r10d
xor %r9d,%r9d
mov (%rax),%r11
lea -0x1(%rbx),%eax
xor %r8d,%r8d
xor %ebx,%ebx
lea 0x1(%rbp,%rax,1),%rsi
jmp 12b1 <func0+0x81>
nopl 0x0(%rax,%rax,1)
test $0x1,%dh
jne 12e8 <func0+0xb8>
test $0x8,%dh
jne 12f0 <func0+0xc0>
lea -0x23(%rax),%eax
cmp $0x1,%al
setbe %al
cmp $0x40,%cl
sete %cl
or %cl,%al
jne 1300 <func0+0xd0>
and $0x20,%dh
jne 12de <func0+0xae>
nopl 0x0(%rax)
add $0x1,%rdi
cmp %rdi,%rsi
je 12d1 <func0+0xa1>
movsbq (%rdi),%rax
movzwl (%r11,%rax,2),%edx
mov %rax,%rcx
test $0x2,%dh
je 1280 <func0+0x50>
add $0x1,%rdi
mov $0x1,%r8d
cmp %rdi,%rsi
jne 12b1 <func0+0x81>
mov %r8d,%eax
and %ebx,%r10d
and %r9b,%al
cmovne %r10d,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopl (%rax)
mov $0x1,%r9d
jmp 12a8 <func0+0x78>
mov $0x1,%r10d
jmp 12a8 <func0+0x78>
nopl 0x0(%rax,%rax,1)
mov %eax,%ebx
jmp 12a8 <func0+0x78>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
call _strlen
lea edx, [rax-6]
mov rbx, rax
xor eax, eax
cmp edx, 6
ja loc_12DE
test ebx, ebx
jle loc_12DE
call ___ctype_b_loc
mov rdx, rbp
xor r10d, r10d
xor r9d, r9d
mov r11, [rax]
lea eax, [rbx-1]
xor r8d, r8d
xor ebx, ebx
lea rdi, [rbp+rax+1]
jmp short loc_12B1
loc_1280:
test ch, 1
jnz short loc_12E8
test ch, 8
jnz short loc_12F0
lea eax, [rax-23h]
cmp al, 1
setbe al
cmp sil, 40h ; '@'
setz sil
or al, sil
jnz short loc_1300
and ch, 20h
jnz short loc_12DE
nop dword ptr [rax+00h]
loc_12A8:
add rdx, 1
cmp rdi, rdx
jz short loc_12D1
loc_12B1:
movsx rax, byte ptr [rdx]
movzx ecx, word ptr [r11+rax*2]
mov rsi, rax
test ch, 2
jz short loc_1280
add rdx, 1
mov r8d, 1
cmp rdi, rdx
jnz short loc_12B1
loc_12D1:
mov eax, r8d
and r10d, ebx
and al, r9b
cmovnz eax, r10d
loc_12DE:
add rsp, 8
pop rbx
pop rbp
retn
loc_12E8:
mov r9d, 1
jmp short loc_12A8
loc_12F0:
mov r10d, 1
jmp short loc_12A8
loc_1300:
mov ebx, eax
jmp short loc_12A8 | char func0(_BYTE *a1)
{
int v1; // eax
unsigned int v2; // edx
int v3; // ebx
char result; // al
long long *v5; // rax
_BYTE *v6; // rdx
char v7; // r10
char v8; // r9
long long v9; // r11
long long v10; // rax
char v11; // r8
char v12; // bl
long long v13; // rdi
long long v14; // rax
__int16 v15; // cx
char v16; // r10
v1 = strlen();
v2 = v1 - 6;
v3 = v1;
result = 0;
if ( v2 <= 6 && v3 > 0 )
{
v5 = (long long *)__ctype_b_loc();
v6 = a1;
v7 = 0;
v8 = 0;
v9 = *v5;
v10 = (unsigned int)(v3 - 1);
v11 = 0;
v12 = 0;
v13 = (long long)&a1[v10 + 1];
do
{
while ( 1 )
{
v14 = (char)*v6;
v15 = *(_WORD *)(v9 + 2 * v14);
if ( (v15 & 0x200) == 0 )
break;
++v6;
v11 = 1;
if ( (_BYTE *)v13 == v6 )
goto LABEL_11;
}
if ( (v15 & 0x100) != 0 )
{
v8 = 1;
}
else if ( (v15 & 0x800) != 0 )
{
v7 = 1;
}
else
{
result = *v6 == 64 || (unsigned __int8)(v14 - 35) <= 1u;
if ( result )
{
v12 = result;
}
else if ( (v15 & 0x2000) != 0 )
{
return result;
}
}
++v6;
}
while ( (_BYTE *)v13 != v6 );
LABEL_11:
v16 = v12 & v7;
result = v8 & v11;
if ( ((unsigned __int8)v8 & (unsigned __int8)v11) != 0 )
return v16;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
LEA EDX,[RAX + -0x6]
MOV RBX,RAX
XOR EAX,EAX
CMP EDX,0x6
JA 0x001012de
TEST EBX,EBX
JLE 0x001012de
CALL 0x00101090
MOV RDX,RBP
XOR R10D,R10D
XOR R9D,R9D
MOV R11,qword ptr [RAX]
LEA EAX,[RBX + -0x1]
XOR R8D,R8D
XOR EBX,EBX
LEA RDI,[RBP + RAX*0x1 + 0x1]
JMP 0x001012b1
LAB_00101280:
TEST CH,0x1
JNZ 0x001012e8
TEST CH,0x8
JNZ 0x001012f0
LEA EAX,[RAX + -0x23]
CMP AL,0x1
SETBE AL
CMP SIL,0x40
SETZ SIL
OR AL,SIL
JNZ 0x00101300
AND CH,0x20
JNZ 0x001012de
NOP dword ptr [RAX]
LAB_001012a8:
ADD RDX,0x1
CMP RDI,RDX
JZ 0x001012d1
LAB_001012b1:
MOVSX RAX,byte ptr [RDX]
MOVZX ECX,word ptr [R11 + RAX*0x2]
MOV RSI,RAX
TEST CH,0x2
JZ 0x00101280
ADD RDX,0x1
MOV R8D,0x1
CMP RDI,RDX
JNZ 0x001012b1
LAB_001012d1:
MOV EAX,R8D
AND R10D,EBX
AND AL,R9B
CMOVNZ EAX,R10D
LAB_001012de:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001012e8:
MOV R9D,0x1
JMP 0x001012a8
LAB_001012f0:
MOV R10D,0x1
JMP 0x001012a8
LAB_00101300:
MOV EBX,EAX
JMP 0x001012a8 | uint func0(char *param_1)
{
char *pcVar1;
char cVar2;
ushort uVar3;
bool bVar4;
int iVar5;
uint uVar6;
byte bVar7;
uint uVar8;
size_t sVar9;
ushort **ppuVar10;
uint uVar11;
byte bVar12;
byte bVar13;
uint uVar14;
sVar9 = strlen(param_1);
iVar5 = (int)sVar9;
uVar8 = 0;
if ((iVar5 - 6U < 7) && (0 < iVar5)) {
ppuVar10 = __ctype_b_loc();
uVar14 = 0;
bVar13 = 0;
uVar11 = 0;
pcVar1 = param_1 + (ulong)(iVar5 - 1) + 1;
bVar7 = 0;
do {
while( true ) {
bVar12 = bVar7;
cVar2 = *param_1;
uVar3 = (*ppuVar10)[cVar2];
if ((uVar3 & 0x200) == 0) break;
param_1 = param_1 + 1;
bVar12 = 1;
bVar7 = 1;
if (pcVar1 == param_1) goto LAB_001012d1;
}
uVar8 = uVar11;
if ((uVar3 & 0x100) == 0) {
if ((uVar3 & 0x800) == 0) {
bVar4 = (byte)(cVar2 + -0x23) < 2;
uVar6 = CONCAT31((int3)((uint)(cVar2 + -0x23) >> 8),bVar4 || cVar2 == '@');
uVar8 = uVar6;
if ((!bVar4 && cVar2 != '@') && (uVar8 = uVar11, (uVar3 & 0x2000) != 0)) {
return uVar6;
}
}
else {
uVar14 = 1;
}
}
else {
bVar13 = 1;
}
uVar11 = uVar8;
param_1 = param_1 + 1;
bVar7 = bVar12;
} while (pcVar1 != param_1);
LAB_001012d1:
uVar8 = (uint)(bVar12 & bVar13);
if ((bVar12 & bVar13) != 0) {
uVar8 = uVar14 & uVar11;
}
}
return uVar8;
} |
7,183 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
| bool func0(const char *p) {
int len = strlen(p);
bool hasLower = false;
bool hasUpper = false;
bool hasDigit = false;
bool hasSpecial = false;
if (len < 6 || len > 12) {
return false;
}
for (int i = 0; i < len; i++) {
if (islower(p[i])) {
hasLower = true;
} else if (isupper(p[i])) {
hasUpper = true;
} else if (isdigit(p[i])) {
hasDigit = true;
} else if (p[i] == '$' || p[i] == '#' || p[i] == '@') {
hasSpecial = true;
} else if (isspace(p[i])) {
return false;
}
}
return hasLower && hasUpper && hasDigit && hasSpecial;
}
| int main() {
assert(func0("password") == false);
assert(func0("Password@10") == true);
assert(func0("password@10") == false);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
lea -0x6(%rax),%edx
mov %rax,%rbx
xor %eax,%eax
cmp $0x6,%edx
ja 12de <func0+0xae>
test %ebx,%ebx
jle 12de <func0+0xae>
callq 1090 <__ctype_b_loc@plt>
mov %rbp,%rdi
xor %r10d,%r10d
xor %r9d,%r9d
mov (%rax),%r11
lea -0x1(%rbx),%eax
xor %r8d,%r8d
xor %ebx,%ebx
lea 0x1(%rbp,%rax,1),%rsi
jmp 12b1 <func0+0x81>
nopl 0x0(%rax,%rax,1)
test $0x1,%dh
jne 12e8 <func0+0xb8>
test $0x8,%dh
jne 12f0 <func0+0xc0>
lea -0x23(%rax),%eax
cmp $0x1,%al
setbe %al
cmp $0x40,%cl
sete %cl
or %cl,%al
jne 1300 <func0+0xd0>
and $0x20,%dh
jne 12de <func0+0xae>
nopl 0x0(%rax)
add $0x1,%rdi
cmp %rdi,%rsi
je 12d1 <func0+0xa1>
movsbq (%rdi),%rax
movzwl (%r11,%rax,2),%edx
mov %rax,%rcx
test $0x2,%dh
je 1280 <func0+0x50>
add $0x1,%rdi
mov $0x1,%r8d
cmp %rdi,%rsi
jne 12b1 <func0+0x81>
mov %r8d,%eax
and %ebx,%r10d
and %r9b,%al
cmovne %r10d,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopl (%rax)
mov $0x1,%r9d
jmp 12a8 <func0+0x78>
mov $0x1,%r10d
jmp 12a8 <func0+0x78>
nopl 0x0(%rax,%rax,1)
mov %eax,%ebx
jmp 12a8 <func0+0x78>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
call _strlen
lea edx, [rax-6]
mov rbx, rax
xor eax, eax
cmp edx, 6
ja short loc_12CD
call ___ctype_b_loc
xor edx, edx
xor r11d, r11d
xor r10d, r10d
mov rdi, [rax]
xor r9d, r9d
xor r8d, r8d
jmp short loc_12A0
loc_1270:
test ch, 1
jnz short loc_12D8
test ch, 8
jnz short loc_12E0
lea eax, [rsi-23h]
cmp al, 1
setbe al
cmp sil, 40h ; '@'
setz sil
or al, sil
jnz short loc_12F0
and ch, 20h
jnz short loc_12CD
nop dword ptr [rax+00h]
loc_1298:
add rdx, 1
cmp ebx, edx
jle short loc_12C0
loc_12A0:
movsx rcx, byte ptr [rbp+rdx+0]
mov rsi, rcx
movzx ecx, word ptr [rdi+rcx*2]
test ch, 2
jz short loc_1270
add rdx, 1
mov r8d, 1
cmp ebx, edx
jg short loc_12A0
loc_12C0:
mov eax, r8d
and r10d, r11d
and al, r9b
cmovnz eax, r10d
loc_12CD:
add rsp, 8
pop rbx
pop rbp
retn
loc_12D8:
mov r9d, 1
jmp short loc_1298
loc_12E0:
mov r10d, 1
jmp short loc_1298
loc_12F0:
mov r11d, eax
jmp short loc_1298 | char func0(const char *a1)
{
int v2; // eax
unsigned int v3; // edx
int v4; // ebx
char result; // al
const unsigned __int16 **v6; // rax
long long v7; // rdx
bool v8; // r11
char v9; // r10
const unsigned __int16 *v10; // rdi
char v11; // r9
char v12; // r8
long long v13; // rsi
unsigned __int16 v14; // cx
char v15; // r10
v2 = strlen(a1);
v3 = v2 - 6;
v4 = v2;
result = 0;
if ( v3 <= 6 )
{
v6 = __ctype_b_loc();
v7 = 0LL;
v8 = 0;
v9 = 0;
v10 = *v6;
v11 = 0;
v12 = 0;
do
{
while ( 1 )
{
v13 = a1[v7];
v14 = v10[v13];
if ( (v14 & 0x200) == 0 )
break;
++v7;
v12 = 1;
if ( v4 <= (int)v7 )
goto LABEL_10;
}
if ( (v14 & 0x100) != 0 )
{
v11 = 1;
}
else if ( (v14 & 0x800) != 0 )
{
v9 = 1;
}
else
{
result = (_BYTE)v13 == 64 || (unsigned __int8)(v13 - 35) <= 1u;
if ( result )
{
v8 = (_BYTE)v13 == 64 || (unsigned __int8)(v13 - 35) <= 1u;
}
else if ( (v14 & 0x2000) != 0 )
{
return result;
}
}
++v7;
}
while ( v4 > (int)v7 );
LABEL_10:
v15 = v8 & v9;
result = v11 & v12;
if ( ((unsigned __int8)v11 & (unsigned __int8)v12) != 0 )
return v15;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
LEA EDX,[RAX + -0x6]
MOV RBX,RAX
XOR EAX,EAX
CMP EDX,0x6
JA 0x001012cd
CALL 0x00101090
XOR EDX,EDX
XOR R11D,R11D
XOR R10D,R10D
MOV RDI,qword ptr [RAX]
XOR R9D,R9D
XOR R8D,R8D
JMP 0x001012a0
LAB_00101270:
TEST CH,0x1
JNZ 0x001012d8
TEST CH,0x8
JNZ 0x001012e0
LEA EAX,[RSI + -0x23]
CMP AL,0x1
SETBE AL
CMP SIL,0x40
SETZ SIL
OR AL,SIL
JNZ 0x001012f0
AND CH,0x20
JNZ 0x001012cd
NOP dword ptr [RAX]
LAB_00101298:
ADD RDX,0x1
CMP EBX,EDX
JLE 0x001012c0
LAB_001012a0:
MOVSX RCX,byte ptr [RBP + RDX*0x1]
MOV RSI,RCX
MOVZX ECX,word ptr [RDI + RCX*0x2]
TEST CH,0x2
JZ 0x00101270
ADD RDX,0x1
MOV R8D,0x1
CMP EBX,EDX
JG 0x001012a0
LAB_001012c0:
MOV EAX,R8D
AND R10D,R11D
AND AL,R9B
CMOVNZ EAX,R10D
LAB_001012cd:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001012d8:
MOV R9D,0x1
JMP 0x00101298
LAB_001012e0:
MOV R10D,0x1
JMP 0x00101298
LAB_001012f0:
MOV R11D,EAX
JMP 0x00101298 | uint func0(char *param_1)
{
char cVar1;
ushort uVar2;
bool bVar3;
int iVar4;
uint uVar5;
byte bVar6;
uint uVar7;
size_t sVar8;
ushort **ppuVar9;
long lVar10;
byte bVar11;
byte bVar12;
uint uVar13;
uint uVar14;
sVar8 = strlen(param_1);
iVar4 = (int)sVar8;
uVar7 = 0;
if (iVar4 - 6U < 7) {
ppuVar9 = __ctype_b_loc();
lVar10 = 0;
uVar14 = 0;
uVar13 = 0;
bVar12 = 0;
bVar6 = 0;
do {
while( true ) {
bVar11 = bVar6;
cVar1 = param_1[lVar10];
uVar2 = (*ppuVar9)[cVar1];
if ((uVar2 & 0x200) == 0) break;
lVar10 = lVar10 + 1;
bVar11 = 1;
bVar6 = 1;
if (iVar4 <= (int)lVar10) goto LAB_001012c0;
}
uVar7 = uVar14;
if ((uVar2 & 0x100) == 0) {
if ((uVar2 & 0x800) == 0) {
bVar3 = (byte)(cVar1 + -0x23) < 2;
uVar5 = CONCAT31((int3)((uint)(cVar1 + -0x23) >> 8),bVar3 || cVar1 == '@');
uVar7 = uVar5;
if ((!bVar3 && cVar1 != '@') && (uVar7 = uVar14, (uVar2 & 0x2000) != 0)) {
return uVar5;
}
}
else {
uVar13 = 1;
}
}
else {
bVar12 = 1;
}
uVar14 = uVar7;
lVar10 = lVar10 + 1;
bVar6 = bVar11;
} while ((int)lVar10 < iVar4);
LAB_001012c0:
uVar7 = (uint)(bVar11 & bVar12);
if ((bVar11 & bVar12) != 0) {
uVar7 = uVar13 & uVar14;
}
}
return uVar7;
} |
7,184 | func0 | #include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* string, const char* sample) {
if (strstr(string, sample) != NULL) {
regex_t regex;
int result;
char pattern[100] = "^";
strcat(pattern, sample);
regcomp(®ex, pattern, 0);
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return "string starts with the given substring";
} else {
return "string doesnt start with the given substring";
}
} else {
return "entered string isnt a substring";
}
}
| int main() {
assert(strcmp(func0("dreams for dreams makes life fun", "makes"), "string doesnt start with the given substring") == 0);
assert(strcmp(func0("Hi there how are you Hi alex", "Hi"), "string starts with the given substring") == 0);
assert(strcmp(func0("Its been a long day", "been"), "string doesnt start with the given substring") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xd0,%rsp
mov %rdi,-0xc8(%rbp)
mov %rsi,-0xd0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0xd0(%rbp),%rdx
mov -0xc8(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1130 <strstr@plt>
test %rax,%rax
je 1365 <func0+0x13c>
movq $0x5e,-0x70(%rbp)
movq $0x0,-0x68(%rbp)
movq $0x0,-0x60(%rbp)
movq $0x0,-0x58(%rbp)
movq $0x0,-0x50(%rbp)
movq $0x0,-0x48(%rbp)
movq $0x0,-0x40(%rbp)
movq $0x0,-0x38(%rbp)
movq $0x0,-0x30(%rbp)
movq $0x0,-0x28(%rbp)
movq $0x0,-0x20(%rbp)
movq $0x0,-0x18(%rbp)
movl $0x0,-0x10(%rbp)
mov -0xd0(%rbp),%rdx
lea -0x70(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1120 <strcat@plt>
lea -0x70(%rbp),%rcx
lea -0xb0(%rbp),%rax
mov $0x0,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10f0 <regcomp@plt>
mov -0xc8(%rbp),%rsi
lea -0xb0(%rbp),%rax
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 1110 <regexec@plt>
mov %eax,-0xb4(%rbp)
lea -0xb0(%rbp),%rax
mov %rax,%rdi
callq 10c0 <regfree@plt>
cmpl $0x0,-0xb4(%rbp)
jne 135c <func0+0x133>
lea 0xcae(%rip),%rax
jmp 136c <func0+0x143>
lea 0xccd(%rip),%rax
jmp 136c <func0+0x143>
lea 0xcf4(%rip),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1380 <func0+0x157>
callq 10d0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+haystack], rdi
mov [rbp+needle], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rdx, [rbp+needle]
mov rax, [rbp+haystack]
mov rsi, rdx; needle
mov rdi, rax; haystack
call _strstr
test rax, rax
jz loc_1365
mov qword ptr [rbp+dest], 5Eh ; '^'
mov [rbp+var_68], 0
mov [rbp+var_60], 0
mov [rbp+var_58], 0
mov [rbp+var_50], 0
mov [rbp+var_48], 0
mov [rbp+var_40], 0
mov [rbp+var_38], 0
mov [rbp+var_30], 0
mov [rbp+var_28], 0
mov [rbp+var_20], 0
mov [rbp+var_18], 0
mov [rbp+var_10], 0
mov rdx, [rbp+needle]
lea rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcat
lea rcx, [rbp+dest]
lea rax, [rbp+preg]
mov edx, 0; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov rsi, [rbp+haystack]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov ecx, 0; pmatch
mov edx, 0; nmatch
mov rdi, rax; preg
call _regexec
mov [rbp+var_B4], eax
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
cmp [rbp+var_B4], 0
jnz short loc_135C
lea rax, aStringStartsWi; "string starts with the given substring"
jmp short loc_136C
loc_135C:
lea rax, s2; "string doesnt start with the given subs"...
jmp short loc_136C
loc_1365:
lea rax, aEnteredStringI; "entered string isnt a substring"
loc_136C:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1380
call ___stack_chk_fail
locret_1380:
leave
retn | const char * func0(const char *a1, const char *a2)
{
int v3; // [rsp+1Ch] [rbp-B4h]
regex_t preg; // [rsp+20h] [rbp-B0h] BYREF
char dest[8]; // [rsp+60h] [rbp-70h] BYREF
long long v6; // [rsp+68h] [rbp-68h]
long long v7; // [rsp+70h] [rbp-60h]
long long v8; // [rsp+78h] [rbp-58h]
long long v9; // [rsp+80h] [rbp-50h]
long long v10; // [rsp+88h] [rbp-48h]
long long v11; // [rsp+90h] [rbp-40h]
long long v12; // [rsp+98h] [rbp-38h]
long long v13; // [rsp+A0h] [rbp-30h]
long long v14; // [rsp+A8h] [rbp-28h]
long long v15; // [rsp+B0h] [rbp-20h]
long long v16; // [rsp+B8h] [rbp-18h]
int v17; // [rsp+C0h] [rbp-10h]
unsigned long long v18; // [rsp+C8h] [rbp-8h]
v18 = __readfsqword(0x28u);
if ( !strstr(a1, a2) )
return "entered string isnt a substring";
*(_QWORD *)dest = 94LL;
v6 = 0LL;
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
v10 = 0LL;
v11 = 0LL;
v12 = 0LL;
v13 = 0LL;
v14 = 0LL;
v15 = 0LL;
v16 = 0LL;
v17 = 0;
strcat(dest, a2);
regcomp(&preg, dest, 0);
v3 = regexec(&preg, a1, 0LL, 0LL, 0);
regfree(&preg);
if ( v3 )
return "string doesnt start with the given substring";
else
return "string starts with the given substring";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV qword ptr [RBP + -0xc8],RDI
MOV qword ptr [RBP + -0xd0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RBP + -0xd0]
MOV RAX,qword ptr [RBP + -0xc8]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101130
TEST RAX,RAX
JZ 0x00101365
MOV qword ptr [RBP + -0x70],0x5e
MOV qword ptr [RBP + -0x68],0x0
MOV qword ptr [RBP + -0x60],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x48],0x0
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x38],0x0
MOV qword ptr [RBP + -0x30],0x0
MOV qword ptr [RBP + -0x28],0x0
MOV qword ptr [RBP + -0x20],0x0
MOV qword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV RDX,qword ptr [RBP + -0xd0]
LEA RAX,[RBP + -0x70]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101120
LEA RCX,[RBP + -0x70]
LEA RAX,[RBP + -0xb0]
MOV EDX,0x0
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010f0
MOV RSI,qword ptr [RBP + -0xc8]
LEA RAX,[RBP + -0xb0]
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x00101110
MOV dword ptr [RBP + -0xb4],EAX
LEA RAX,[RBP + -0xb0]
MOV RDI,RAX
CALL 0x001010c0
CMP dword ptr [RBP + -0xb4],0x0
JNZ 0x0010135c
LEA RAX,[0x102008]
JMP 0x0010136c
LAB_0010135c:
LEA RAX,[0x102030]
JMP 0x0010136c
LAB_00101365:
LEA RAX,[0x102060]
LAB_0010136c:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101380
CALL 0x001010d0
LAB_00101380:
LEAVE
RET | char * func0(char *param_1,char *param_2)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_b8;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = strstr(param_1,param_2);
if (pcVar2 == (char *)0x0) {
pcVar2 = "entered string isnt a substring";
}
else {
local_78[0] = '^';
local_78[1] = '\0';
local_78[2] = '\0';
local_78[3] = '\0';
local_78[4] = '\0';
local_78[5] = '\0';
local_78[6] = '\0';
local_78[7] = '\0';
local_78[8] = '\0';
local_78[9] = '\0';
local_78[10] = '\0';
local_78[0xb] = '\0';
local_78[0xc] = '\0';
local_78[0xd] = '\0';
local_78[0xe] = '\0';
local_78[0xf] = '\0';
local_78[0x10] = '\0';
local_78[0x11] = '\0';
local_78[0x12] = '\0';
local_78[0x13] = '\0';
local_78[0x14] = '\0';
local_78[0x15] = '\0';
local_78[0x16] = '\0';
local_78[0x17] = '\0';
local_78[0x18] = '\0';
local_78[0x19] = '\0';
local_78[0x1a] = '\0';
local_78[0x1b] = '\0';
local_78[0x1c] = '\0';
local_78[0x1d] = '\0';
local_78[0x1e] = '\0';
local_78[0x1f] = '\0';
local_78[0x20] = '\0';
local_78[0x21] = '\0';
local_78[0x22] = '\0';
local_78[0x23] = '\0';
local_78[0x24] = '\0';
local_78[0x25] = '\0';
local_78[0x26] = '\0';
local_78[0x27] = '\0';
local_78[0x28] = '\0';
local_78[0x29] = '\0';
local_78[0x2a] = '\0';
local_78[0x2b] = '\0';
local_78[0x2c] = '\0';
local_78[0x2d] = '\0';
local_78[0x2e] = '\0';
local_78[0x2f] = '\0';
local_78[0x30] = '\0';
local_78[0x31] = '\0';
local_78[0x32] = '\0';
local_78[0x33] = '\0';
local_78[0x34] = '\0';
local_78[0x35] = '\0';
local_78[0x36] = '\0';
local_78[0x37] = '\0';
local_78[0x38] = '\0';
local_78[0x39] = '\0';
local_78[0x3a] = '\0';
local_78[0x3b] = '\0';
local_78[0x3c] = '\0';
local_78[0x3d] = '\0';
local_78[0x3e] = '\0';
local_78[0x3f] = '\0';
local_78[0x40] = '\0';
local_78[0x41] = '\0';
local_78[0x42] = '\0';
local_78[0x43] = '\0';
local_78[0x44] = '\0';
local_78[0x45] = '\0';
local_78[0x46] = '\0';
local_78[0x47] = '\0';
local_78[0x48] = '\0';
local_78[0x49] = '\0';
local_78[0x4a] = '\0';
local_78[0x4b] = '\0';
local_78[0x4c] = '\0';
local_78[0x4d] = '\0';
local_78[0x4e] = '\0';
local_78[0x4f] = '\0';
local_78[0x50] = '\0';
local_78[0x51] = '\0';
local_78[0x52] = '\0';
local_78[0x53] = '\0';
local_78[0x54] = '\0';
local_78[0x55] = '\0';
local_78[0x56] = '\0';
local_78[0x57] = '\0';
local_78[0x58] = '\0';
local_78[0x59] = '\0';
local_78[0x5a] = '\0';
local_78[0x5b] = '\0';
local_78[0x5c] = '\0';
local_78[0x5d] = '\0';
local_78[0x5e] = '\0';
local_78[0x5f] = '\0';
local_78[0x60] = '\0';
local_78[0x61] = '\0';
local_78[0x62] = '\0';
local_78[99] = '\0';
strcat(local_78,param_2);
regcomp(&local_b8,local_78,0);
iVar1 = regexec(&local_b8,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_b8);
if (iVar1 == 0) {
pcVar2 = "string starts with the given substring";
}
else {
pcVar2 = "string doesnt start with the given substring";
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
7,185 | func0 | #include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* string, const char* sample) {
if (strstr(string, sample) != NULL) {
regex_t regex;
int result;
char pattern[100] = "^";
strcat(pattern, sample);
regcomp(®ex, pattern, 0);
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return "string starts with the given substring";
} else {
return "string doesnt start with the given substring";
}
} else {
return "entered string isnt a substring";
}
}
| int main() {
assert(strcmp(func0("dreams for dreams makes life fun", "makes"), "string doesnt start with the given substring") == 0);
assert(strcmp(func0("Hi there how are you Hi alex", "Hi"), "string starts with the given substring") == 0);
assert(strcmp(func0("Its been a long day", "been"), "string doesnt start with the given substring") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0xb0,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
callq 1110 <strstr@plt>
mov %rax,%rdx
lea 0xe20(%rip),%rax
test %rdx,%rdx
je 132d <func0+0x124>
movq $0x5e,0x40(%rsp)
movq $0x0,0x48(%rsp)
movq $0x0,0x50(%rsp)
movq $0x0,0x58(%rsp)
movq $0x0,0x60(%rsp)
movq $0x0,0x68(%rsp)
movq $0x0,0x70(%rsp)
movq $0x0,0x78(%rsp)
movq $0x0,0x80(%rsp)
movq $0x0,0x88(%rsp)
movq $0x0,0x90(%rsp)
movq $0x0,0x98(%rsp)
movl $0x0,0xa0(%rsp)
lea 0x40(%rsp),%r12
mov $0x64,%edx
mov %rbp,%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
mov %rsp,%rbp
mov $0x0,%edx
mov %r12,%rsi
mov %rbp,%rdi
callq 10f0 <regcomp@plt>
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 1100 <regexec@plt>
mov %eax,%ebx
mov %rbp,%rdi
callq 10c0 <regfree@plt>
test %ebx,%ebx
lea 0xce6(%rip),%rax
lea 0xd07(%rip),%rdx
cmovne %rdx,%rax
mov 0xa8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 134c <func0+0x143>
add $0xb0,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10d0 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 0B0h
mov rbx, rdi
mov rbp, rsi
mov rax, fs:28h
mov [rsp+0C8h+var_20], rax
xor eax, eax
call _strstr
mov rdx, rax
lea rax, aEnteredStringI; "entered string isnt a substring"
test rdx, rdx
jz loc_134D
mov [rsp+0C8h+var_88], 5Eh ; '^'
mov [rsp+0C8h+var_80], 0
mov [rsp+0C8h+var_78], 0
mov [rsp+0C8h+var_70], 0
mov [rsp+0C8h+var_68], 0
mov [rsp+0C8h+var_60], 0
mov [rsp+0C8h+var_58], 0
mov [rsp+0C8h+var_50], 0
mov [rsp+0C8h+var_48], 0
mov [rsp+0C8h+var_40], 0
mov [rsp+0C8h+var_38], 0
mov [rsp+0C8h+var_30], 0
mov [rsp+0C8h+var_28], 0
lea r12, [rsp+0C8h+var_88]
mov edx, 64h ; 'd'
mov rsi, rbp
mov rdi, r12
call ___strcat_chk
mov rbp, rsp
mov edx, 0
mov rsi, r12
mov rdi, rbp
call _regcomp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
mov rdi, rbp
call _regexec
mov ebx, eax
mov rdi, rbp
call _regfree
test ebx, ebx
lea rax, aStringStartsWi; "string starts with the given substring"
lea rdx, aStringDoesntSt; "string doesnt start with the given subs"...
cmovnz rax, rdx
loc_134D:
mov rdx, [rsp+0C8h+var_20]
sub rdx, fs:28h
jnz short loc_136C
add rsp, 0B0h
pop rbx
pop rbp
pop r12
retn
loc_136C:
call ___stack_chk_fail | const char * func0(long long a1, long long a2)
{
long long v2; // rdx
const char *result; // rax
int v4; // ebx
_BYTE v5[64]; // [rsp+0h] [rbp-C8h] BYREF
_QWORD v6[12]; // [rsp+40h] [rbp-88h] BYREF
int v7; // [rsp+A0h] [rbp-28h]
unsigned long long v8; // [rsp+A8h] [rbp-20h]
v8 = __readfsqword(0x28u);
v2 = strstr();
result = "entered string isnt a substring";
if ( v2 )
{
v6[0] = 94LL;
memset(&v6[1], 0, 88);
v7 = 0;
__strcat_chk(v6, a2, 100LL);
regcomp(v5, v6, 0LL);
v4 = regexec(v5, a1, 0LL, 0LL, 0LL);
regfree(v5);
result = "string starts with the given substring";
if ( v4 )
return "string doesnt start with the given substring";
}
return result;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb0
MOV RBX,RDI
MOV RBP,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
CALL 0x00101130
MOV RDX,RAX
LEA RAX,[0x102060]
TEST RDX,RDX
JZ 0x0010134d
MOV qword ptr [RSP + 0x40],0x5e
MOV qword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x0
MOV qword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x0
MOV qword ptr [RSP + 0x88],0x0
MOV qword ptr [RSP + 0x90],0x0
MOV qword ptr [RSP + 0x98],0x0
MOV dword ptr [RSP + 0xa0],0x0
LEA R12,[RSP + 0x40]
MOV EDX,0x64
MOV RSI,RBP
MOV RDI,R12
CALL 0x001010c0
MOV RBP,RSP
MOV EDX,0x0
MOV RSI,R12
MOV RDI,RBP
CALL 0x00101100
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101120
MOV EBX,EAX
MOV RDI,RBP
CALL 0x001010d0
TEST EBX,EBX
LEA RAX,[0x102008]
LEA RDX,[0x102030]
CMOVNZ RAX,RDX
LAB_0010134d:
MOV RDX,qword ptr [RSP + 0xa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010136c
ADD RSP,0xb0
POP RBX
POP RBP
POP R12
RET
LAB_0010136c:
CALL 0x001010e0 | char * func0(char *param_1,char *param_2)
{
int iVar1;
char *pcVar2;
char *pcVar3;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = strstr(param_1,param_2);
pcVar3 = "entered string isnt a substring";
if (pcVar2 != (char *)0x0) {
local_88[0] = '^';
local_88[1] = '\0';
local_88[2] = '\0';
local_88[3] = '\0';
local_88[4] = '\0';
local_88[5] = '\0';
local_88[6] = '\0';
local_88[7] = '\0';
local_88[8] = '\0';
local_88[9] = '\0';
local_88[10] = '\0';
local_88[0xb] = '\0';
local_88[0xc] = '\0';
local_88[0xd] = '\0';
local_88[0xe] = '\0';
local_88[0xf] = '\0';
local_88[0x10] = '\0';
local_88[0x11] = '\0';
local_88[0x12] = '\0';
local_88[0x13] = '\0';
local_88[0x14] = '\0';
local_88[0x15] = '\0';
local_88[0x16] = '\0';
local_88[0x17] = '\0';
local_88[0x18] = '\0';
local_88[0x19] = '\0';
local_88[0x1a] = '\0';
local_88[0x1b] = '\0';
local_88[0x1c] = '\0';
local_88[0x1d] = '\0';
local_88[0x1e] = '\0';
local_88[0x1f] = '\0';
local_88[0x20] = '\0';
local_88[0x21] = '\0';
local_88[0x22] = '\0';
local_88[0x23] = '\0';
local_88[0x24] = '\0';
local_88[0x25] = '\0';
local_88[0x26] = '\0';
local_88[0x27] = '\0';
local_88[0x28] = '\0';
local_88[0x29] = '\0';
local_88[0x2a] = '\0';
local_88[0x2b] = '\0';
local_88[0x2c] = '\0';
local_88[0x2d] = '\0';
local_88[0x2e] = '\0';
local_88[0x2f] = '\0';
local_88[0x30] = '\0';
local_88[0x31] = '\0';
local_88[0x32] = '\0';
local_88[0x33] = '\0';
local_88[0x34] = '\0';
local_88[0x35] = '\0';
local_88[0x36] = '\0';
local_88[0x37] = '\0';
local_88[0x38] = '\0';
local_88[0x39] = '\0';
local_88[0x3a] = '\0';
local_88[0x3b] = '\0';
local_88[0x3c] = '\0';
local_88[0x3d] = '\0';
local_88[0x3e] = '\0';
local_88[0x3f] = '\0';
local_88[0x40] = '\0';
local_88[0x41] = '\0';
local_88[0x42] = '\0';
local_88[0x43] = '\0';
local_88[0x44] = '\0';
local_88[0x45] = '\0';
local_88[0x46] = '\0';
local_88[0x47] = '\0';
local_88[0x48] = '\0';
local_88[0x49] = '\0';
local_88[0x4a] = '\0';
local_88[0x4b] = '\0';
local_88[0x4c] = '\0';
local_88[0x4d] = '\0';
local_88[0x4e] = '\0';
local_88[0x4f] = '\0';
local_88[0x50] = '\0';
local_88[0x51] = '\0';
local_88[0x52] = '\0';
local_88[0x53] = '\0';
local_88[0x54] = '\0';
local_88[0x55] = '\0';
local_88[0x56] = '\0';
local_88[0x57] = '\0';
local_88[0x58] = '\0';
local_88[0x59] = '\0';
local_88[0x5a] = '\0';
local_88[0x5b] = '\0';
local_88[0x5c] = '\0';
local_88[0x5d] = '\0';
local_88[0x5e] = '\0';
local_88[0x5f] = '\0';
local_88[0x60] = '\0';
local_88[0x61] = '\0';
local_88[0x62] = '\0';
local_88[99] = '\0';
__strcat_chk(local_88,param_2,100);
regcomp(&rStack_c8,local_88,0);
iVar1 = regexec(&rStack_c8,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_c8);
pcVar3 = "string starts with the given substring";
if (iVar1 != 0) {
pcVar3 = "string doesnt start with the given substring";
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,186 | func0 | #include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* string, const char* sample) {
if (strstr(string, sample) != NULL) {
regex_t regex;
int result;
char pattern[100] = "^";
strcat(pattern, sample);
regcomp(®ex, pattern, 0);
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return "string starts with the given substring";
} else {
return "string doesnt start with the given substring";
}
} else {
return "entered string isnt a substring";
}
}
| int main() {
assert(strcmp(func0("dreams for dreams makes life fun", "makes"), "string doesnt start with the given substring") == 0);
assert(strcmp(func0("Hi there how are you Hi alex", "Hi"), "string starts with the given substring") == 0);
assert(strcmp(func0("Its been a long day", "been"), "string doesnt start with the given substring") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
mov %rsi,%r12
push %rbp
mov %rdi,%rbp
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
callq 1110 <strstr@plt>
mov %rax,%r8
lea 0xd28(%rip),%rax
test %r8,%r8
je 13d8 <func0+0xd8>
pxor %xmm0,%xmm0
mov %r12,%rsi
lea 0x41(%rsp),%rdi
mov %rsp,%r12
mov $0x63,%edx
lea 0x40(%rsp),%r13
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movq $0x5e,0x40(%rsp)
movq $0x0,0x48(%rsp)
movl $0x0,0xa0(%rsp)
callq 1100 <__strcpy_chk@plt>
xor %edx,%edx
mov %r13,%rsi
mov %r12,%rdi
callq 10e0 <regcomp@plt>
xor %edx,%edx
xor %r8d,%r8d
xor %ecx,%ecx
mov %rbp,%rsi
mov %r12,%rdi
callq 10f0 <regexec@plt>
mov %r12,%rdi
mov %eax,%ebp
callq 10b0 <regfree@plt>
test %ebp,%ebp
lea 0xc3b(%rip),%rax
lea 0xc5c(%rip),%rdx
cmovne %rdx,%rax
mov 0xa8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 13f8 <func0+0xf8>
add $0xb0,%rsp
pop %rbp
pop %r12
pop %r13
retq
callq 10c0 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
sub rsp, 0B0h
mov rax, fs:28h
mov [rsp+0C8h+var_20], rax
xor eax, eax
call _strstr
mov r8, rax
lea rax, aEnteredStringI; "entered string isnt a substring"
test r8, r8
jz loc_13E8
pxor xmm0, xmm0
mov rsi, r12
lea rdi, [rsp+0C8h+var_88+1]
mov r12, rsp
mov edx, 63h ; 'c'
lea r13, [rsp+0C8h+var_88]
movaps [rsp+0C8h+var_78], xmm0
movaps [rsp+0C8h+var_68], xmm0
movaps [rsp+0C8h+var_58], xmm0
movaps [rsp+0C8h+var_48], xmm0
movaps [rsp+0C8h+var_38], xmm0
mov [rsp+0C8h+var_88], 5Eh ; '^'
mov [rsp+0C8h+var_80], 0
mov [rsp+0C8h+var_28], 0
call ___strcpy_chk
xor edx, edx
mov rsi, r13
mov rdi, r12
call _regcomp
xor edx, edx
xor r8d, r8d
xor ecx, ecx
mov rsi, rbp
mov rdi, r12
call _regexec
mov rdi, r12
mov ebp, eax
call _regfree
test ebp, ebp
lea rax, aStringStartsWi; "string starts with the given substring"
lea rdx, aStringDoesntSt; "string doesnt start with the given subs"...
cmovnz rax, rdx
loc_13E8:
mov rdx, [rsp+0C8h+var_20]
sub rdx, fs:28h
jnz short loc_1408
add rsp, 0B0h
pop rbp
pop r12
pop r13
retn
loc_1408:
call ___stack_chk_fail | const char * func0(long long a1, long long a2)
{
long long v2; // r8
const char *result; // rax
int v4; // ebp
_BYTE v5[64]; // [rsp+0h] [rbp-C8h] BYREF
_QWORD v6[2]; // [rsp+40h] [rbp-88h] BYREF
__int128 v7; // [rsp+50h] [rbp-78h]
__int128 v8; // [rsp+60h] [rbp-68h]
__int128 v9; // [rsp+70h] [rbp-58h]
__int128 v10; // [rsp+80h] [rbp-48h]
__int128 v11; // [rsp+90h] [rbp-38h]
int v12; // [rsp+A0h] [rbp-28h]
unsigned long long v13; // [rsp+A8h] [rbp-20h]
v13 = __readfsqword(0x28u);
v2 = strstr();
result = "entered string isnt a substring";
if ( v2 )
{
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
v10 = 0LL;
v11 = 0LL;
v6[0] = 94LL;
v6[1] = 0LL;
v12 = 0;
__strcpy_chk((char *)v6 + 1, a2, 99LL);
regcomp(v5, v6, 0LL);
v4 = regexec(v5, a1, 0LL, 0LL, 0LL);
regfree(v5);
result = "string starts with the given substring";
if ( v4 )
return "string doesnt start with the given substring";
}
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
CALL 0x00101130
MOV R8,RAX
LEA RAX,[0x102060]
TEST R8,R8
JZ 0x001013e8
PXOR XMM0,XMM0
MOV RSI,R12
LEA RDI,[RSP + 0x41]
MOV R12,RSP
MOV EDX,0x63
LEA R13,[RSP + 0x40]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOV qword ptr [RSP + 0x40],0x5e
MOV qword ptr [RSP + 0x48],0x0
MOV dword ptr [RSP + 0xa0],0x0
CALL 0x00101120
XOR EDX,EDX
MOV RSI,R13
MOV RDI,R12
CALL 0x001010f0
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBP
MOV RDI,R12
CALL 0x00101110
MOV RDI,R12
MOV EBP,EAX
CALL 0x001010c0
TEST EBP,EBP
LEA RAX,[0x102008]
LEA RDX,[0x102030]
CMOVNZ RAX,RDX
LAB_001013e8:
MOV RDX,qword ptr [RSP + 0xa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101408
ADD RSP,0xb0
POP RBP
POP R12
POP R13
RET
LAB_00101408:
CALL 0x001010d0 | char * func0(char *param_1,char *param_2)
{
int iVar1;
char *pcVar2;
char *pcVar3;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [16];
int1 local_78 [16];
int1 local_68 [16];
int1 local_58 [16];
int1 local_48 [16];
int1 local_38 [16];
int4 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = strstr(param_1,param_2);
pcVar3 = "entered string isnt a substring";
if (pcVar2 != (char *)0x0) {
local_78 = (int1 [16])0x0;
local_68 = (int1 [16])0x0;
local_58 = (int1 [16])0x0;
local_48 = (int1 [16])0x0;
local_38 = (int1 [16])0x0;
local_88[0] = '^';
local_88[1] = '\0';
local_88[2] = '\0';
local_88[3] = '\0';
local_88[4] = '\0';
local_88[5] = '\0';
local_88[6] = '\0';
local_88[7] = '\0';
local_88[8] = '\0';
local_88[9] = '\0';
local_88[10] = '\0';
local_88[0xb] = '\0';
local_88[0xc] = '\0';
local_88[0xd] = '\0';
local_88[0xe] = '\0';
local_88[0xf] = '\0';
local_28 = 0;
__strcpy_chk(local_88 + 1,param_2,99);
regcomp(&rStack_c8,local_88,0);
iVar1 = regexec(&rStack_c8,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_c8);
pcVar3 = "string starts with the given substring";
if (iVar1 != 0) {
pcVar3 = "string doesnt start with the given substring";
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,187 | func0 | #include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* string, const char* sample) {
if (strstr(string, sample) != NULL) {
regex_t regex;
int result;
char pattern[100] = "^";
strcat(pattern, sample);
regcomp(®ex, pattern, 0);
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return "string starts with the given substring";
} else {
return "string doesnt start with the given substring";
}
} else {
return "entered string isnt a substring";
}
}
| int main() {
assert(strcmp(func0("dreams for dreams makes life fun", "makes"), "string doesnt start with the given substring") == 0);
assert(strcmp(func0("Hi there how are you Hi alex", "Hi"), "string starts with the given substring") == 0);
assert(strcmp(func0("Its been a long day", "been"), "string doesnt start with the given substring") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
mov %rsi,%r12
push %rbp
mov %rdi,%rbp
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
callq 1110 <strstr@plt>
mov %rax,%r8
lea 0xd28(%rip),%rax
test %r8,%r8
je 13d8 <func0+0xd8>
pxor %xmm0,%xmm0
mov %r12,%rsi
lea 0x41(%rsp),%rdi
mov %rsp,%r12
mov $0x63,%edx
lea 0x40(%rsp),%r13
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movq $0x5e,0x40(%rsp)
movq $0x0,0x48(%rsp)
movl $0x0,0xa0(%rsp)
callq 1100 <__strcpy_chk@plt>
xor %edx,%edx
mov %r13,%rsi
mov %r12,%rdi
callq 10e0 <regcomp@plt>
xor %edx,%edx
xor %r8d,%r8d
xor %ecx,%ecx
mov %rbp,%rsi
mov %r12,%rdi
callq 10f0 <regexec@plt>
mov %r12,%rdi
mov %eax,%ebp
callq 10b0 <regfree@plt>
test %ebp,%ebp
lea 0xc3b(%rip),%rax
lea 0xc5c(%rip),%rdx
cmovne %rdx,%rax
mov 0xa8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 13f8 <func0+0xf8>
add $0xb0,%rsp
pop %rbp
pop %r12
pop %r13
retq
callq 10c0 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
push r12
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 0B0h
mov rax, fs:28h
mov [rsp+0C8h+var_20], rax
xor eax, eax
call _strstr
mov rdx, rax
lea rax, aEnteredStringI; "entered string isnt a substring"
test rdx, rdx
jz loc_13E7
pxor xmm0, xmm0
mov rsi, rbp
lea rdi, [rsp+0C8h+pattern+1]
mov rbp, rsp
mov edx, 63h ; 'c'
lea r12, [rsp+0C8h+pattern]
movaps [rsp+0C8h+var_78], xmm0
movaps [rsp+0C8h+var_68], xmm0
movaps [rsp+0C8h+var_58], xmm0
movaps [rsp+0C8h+var_48], xmm0
movaps [rsp+0C8h+var_38], xmm0
mov qword ptr [rsp+0C8h+pattern], 5Eh ; '^'
mov [rsp+0C8h+var_80], 0
mov [rsp+0C8h+var_28], 0
call ___strcpy_chk
xor edx, edx; cflags
mov rsi, r12; pattern
mov rdi, rbp; preg
call _regcomp
xor edx, edx; nmatch
xor r8d, r8d; eflags
xor ecx, ecx; pmatch
mov rsi, rbx; string
mov rdi, rbp; preg
call _regexec
mov rdi, rbp; preg
mov ebx, eax
call _regfree
test ebx, ebx
lea rax, s2; "string doesnt start with the given subs"...
lea rdx, aStringStartsWi; "string starts with the given substring"
cmovz rax, rdx
loc_13E7:
mov rdx, [rsp+0C8h+var_20]
sub rdx, fs:28h
jnz short loc_1406
add rsp, 0B0h
pop rbx
pop rbp
pop r12
retn
loc_1406:
call ___stack_chk_fail | const char * func0(char *string, const char *a2)
{
char *v2; // rdx
const char *result; // rax
int v4; // ebx
regex_t v5; // [rsp+0h] [rbp-C8h] BYREF
char pattern[8]; // [rsp+40h] [rbp-88h] BYREF
long long v7; // [rsp+48h] [rbp-80h]
__int128 v8; // [rsp+50h] [rbp-78h]
__int128 v9; // [rsp+60h] [rbp-68h]
__int128 v10; // [rsp+70h] [rbp-58h]
__int128 v11; // [rsp+80h] [rbp-48h]
__int128 v12; // [rsp+90h] [rbp-38h]
int v13; // [rsp+A0h] [rbp-28h]
unsigned long long v14; // [rsp+A8h] [rbp-20h]
v14 = __readfsqword(0x28u);
v2 = strstr(string, a2);
result = "entered string isnt a substring";
if ( v2 )
{
v8 = 0LL;
v9 = 0LL;
v10 = 0LL;
v11 = 0LL;
v12 = 0LL;
*(_QWORD *)pattern = 94LL;
v7 = 0LL;
v13 = 0;
__strcpy_chk(&pattern[1], a2, 99LL);
regcomp(&v5, pattern, 0);
v4 = regexec(&v5, string, 0LL, 0LL, 0);
regfree(&v5);
result = "string doesnt start with the given substring";
if ( !v4 )
return "string starts with the given substring";
}
return result;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
CALL 0x00101130
MOV RDX,RAX
LEA RAX,[0x102068]
TEST RDX,RDX
JZ 0x001013e7
PXOR XMM0,XMM0
MOV RSI,RBP
LEA RDI,[RSP + 0x41]
MOV RBP,RSP
MOV EDX,0x63
LEA R12,[RSP + 0x40]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOV qword ptr [RSP + 0x40],0x5e
MOV qword ptr [RSP + 0x48],0x0
MOV dword ptr [RSP + 0xa0],0x0
CALL 0x00101120
XOR EDX,EDX
MOV RSI,R12
MOV RDI,RBP
CALL 0x001010f0
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101110
MOV RDI,RBP
MOV EBX,EAX
CALL 0x001010c0
TEST EBX,EBX
LEA RAX,[0x102038]
LEA RDX,[0x102008]
CMOVZ RAX,RDX
LAB_001013e7:
MOV RDX,qword ptr [RSP + 0xa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101406
ADD RSP,0xb0
POP RBX
POP RBP
POP R12
RET
LAB_00101406:
CALL 0x001010d0 | char * func0(char *param_1,char *param_2)
{
int iVar1;
char *pcVar2;
char *pcVar3;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [16];
int local_78 [16];
int local_68 [16];
int local_58 [16];
int local_48 [16];
int local_38 [16];
int4 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = strstr(param_1,param_2);
pcVar3 = "entered string isnt a substring";
if (pcVar2 != (char *)0x0) {
local_78 = (int [16])0x0;
local_68 = (int [16])0x0;
local_58 = (int [16])0x0;
local_48 = (int [16])0x0;
local_38 = (int [16])0x0;
local_88[0] = '^';
local_88[1] = '\0';
local_88[2] = '\0';
local_88[3] = '\0';
local_88[4] = '\0';
local_88[5] = '\0';
local_88[6] = '\0';
local_88[7] = '\0';
local_88[8] = '\0';
local_88[9] = '\0';
local_88[10] = '\0';
local_88[0xb] = '\0';
local_88[0xc] = '\0';
local_88[0xd] = '\0';
local_88[0xe] = '\0';
local_88[0xf] = '\0';
local_28 = 0;
__strcpy_chk(local_88 + 1,param_2,99);
regcomp(&rStack_c8,local_88,0);
iVar1 = regexec(&rStack_c8,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_c8);
pcVar3 = "string doesnt start with the given substring";
if (iVar1 == 0) {
pcVar3 = "string starts with the given substring";
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,188 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| void func0(int *l, int len, int **out, int *out_len) {
int i, j = 0;
*out = (int*) malloc(len * sizeof(int));
for(i = 0; i < len; i++) {
if (l[i] % 2 != 0) {
(*out)[j++] = l[i];
}
}
*out_len = j;
}
| int main() {
int arr1[] = {1,3,5,2}, arr2[] = {5,6,7}, arr3[] = {1,2,3,4};
int *res;
int res_len;
func0(arr1, 4, &res, &res_len);
assert(res_len == 3 && res[0] == 1 && res[1] == 3 && res[2] == 5);
free(res);
func0(arr2, 3, &res, &res_len);
assert(res_len == 2 && res[0] == 5 && res[1] == 7);
free(res);
func0(arr3, 4, &res, &res_len);
assert(res_len == 2 && res[0] == 1 && res[1] == 3);
free(res);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,(%rax)
movl $0x0,-0x8(%rbp)
jmp 1243 <func0+0x9a>
mov -0x8(%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 123f <func0+0x96>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x28(%rbp),%rax
mov (%rax),%rsi
mov -0x4(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x4(%rbp)
cltq
shl $0x2,%rax
lea (%rsi,%rax,1),%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ef <func0+0x46>
mov -0x30(%rbp),%rax
mov -0x4(%rbp),%edx
mov %edx,(%rax)
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_4], 0
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_28]
mov [rax], rdx
mov [rbp+var_8], 0
jmp short loc_1243
loc_11EF:
mov eax, [rbp+var_8]
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_123F
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov rax, [rbp+var_28]
mov rsi, [rax]
mov eax, [rbp+var_4]
lea edx, [rax+1]
mov [rbp+var_4], edx
cdqe
shl rax, 2
lea rdx, [rsi+rax]
mov eax, [rcx]
mov [rdx], eax
loc_123F:
add [rbp+var_8], 1
loc_1243:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_11EF
mov rax, [rbp+var_30]
mov edx, [rbp+var_4]
mov [rax], edx
nop
leave
retn | _DWORD * func0(long long a1, int a2, void **a3, _DWORD *a4)
{
int v4; // eax
_DWORD *result; // rax
int i; // [rsp+28h] [rbp-8h]
int v9; // [rsp+2Ch] [rbp-4h]
v9 = 0;
*a3 = malloc(4LL * a2);
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) != 0 )
{
v4 = v9++;
*((_DWORD *)*a3 + v4) = *(_DWORD *)(4LL * i + a1);
}
}
result = a4;
*a4 = v9;
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x4],0x0
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RDX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101243
LAB_001011ef:
MOV EAX,dword ptr [RBP + -0x8]
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 0x0010123f
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x4],EDX
CDQE
SHL RAX,0x2
LEA RDX,[RSI + RAX*0x1]
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_0010123f:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101243:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ef
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x4]
MOV dword ptr [RAX],EDX
NOP
LEAVE
RET | void func0(long param_1,int param_2,long *param_3,int *param_4)
{
void *pvVar1;
int4 local_10;
int4 local_c;
local_c = 0;
pvVar1 = malloc((long)param_2 << 2);
*param_3 = (long)pvVar1;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
if ((*(uint *)(param_1 + (long)local_10 * 4) & 1) != 0) {
*(int4 *)(*param_3 + (long)local_c * 4) = *(int4 *)((long)local_10 * 4 + param_1);
local_c = local_c + 1;
}
}
*param_4 = local_c;
return;
} |
7,189 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| void func0(int *l, int len, int **out, int *out_len) {
int i, j = 0;
*out = (int*) malloc(len * sizeof(int));
for(i = 0; i < len; i++) {
if (l[i] % 2 != 0) {
(*out)[j++] = l[i];
}
}
*out_len = j;
}
| int main() {
int arr1[] = {1,3,5,2}, arr2[] = {5,6,7}, arr3[] = {1,2,3,4};
int *res;
int res_len;
func0(arr1, 4, &res, &res_len);
assert(res_len == 3 && res[0] == 1 && res[1] == 3 && res[2] == 5);
free(res);
func0(arr2, 3, &res, &res_len);
assert(res_len == 2 && res[0] == 5 && res[1] == 7);
free(res);
func0(arr3, 4, &res, &res_len);
assert(res_len == 2 && res[0] == 1 && res[1] == 3);
free(res);
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,%rbx
mov %rcx,%rbp
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,(%rbx)
test %r12d,%r12d
jle 120a <func0+0x61>
mov %r13,%rax
lea -0x1(%r12),%edx
lea 0x4(%r13,%rdx,4),%rsi
mov $0x0,%ecx
jmp 11f4 <func0+0x4b>
add $0x4,%rax
cmp %rsi,%rax
je 120f <func0+0x66>
mov (%rax),%edx
test $0x1,%dl
je 11eb <func0+0x42>
movslq %ecx,%r8
mov (%rbx),%rdi
mov %edx,(%rdi,%r8,4)
lea 0x1(%rcx),%ecx
jmp 11eb <func0+0x42>
mov $0x0,%ecx
mov %ecx,0x0(%rbp)
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 rbx, rdx
mov rbp, rcx
movsxd rdi, esi
shl rdi, 2
call _malloc
mov [rbx], rax
test r12d, r12d
jle short loc_120A
mov rax, r13
lea edx, [r12-1]
lea rsi, [r13+rdx*4+4]
mov ecx, 0
jmp short loc_11F4
loc_11EB:
add rax, 4
cmp rax, rsi
jz short loc_120F
loc_11F4:
mov edx, [rax]
test dl, 1
jz short loc_11EB
movsxd r8, ecx
mov rdi, [rbx]
mov [rdi+r8*4], edx
lea ecx, [rcx+1]
jmp short loc_11EB
loc_120A:
mov ecx, 0
loc_120F:
mov [rbp+0], ecx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _DWORD * func0(_DWORD *a1, int a2, _QWORD *a3, _DWORD *a4)
{
_DWORD *result; // rax
int v7; // ecx
result = (_DWORD *)malloc(4LL * a2);
*a3 = result;
if ( a2 <= 0 )
{
v7 = 0;
}
else
{
result = a1;
v7 = 0;
do
{
if ( (*result & 1) != 0 )
*(_DWORD *)(*a3 + 4LL * v7++) = *result;
++result;
}
while ( result != &a1[a2 - 1 + 1] );
}
*a4 = v7;
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV R12D,ESI
MOV RBX,RDX
MOV RBP,RCX
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
MOV qword ptr [RBX],RAX
TEST R12D,R12D
JLE 0x0010120a
MOV RAX,R13
LEA EDX,[R12 + -0x1]
LEA RSI,[R13 + RDX*0x4 + 0x4]
MOV ECX,0x0
JMP 0x001011f4
LAB_001011eb:
ADD RAX,0x4
CMP RAX,RSI
JZ 0x0010120f
LAB_001011f4:
MOV EDX,dword ptr [RAX]
TEST DL,0x1
JZ 0x001011eb
MOVSXD R8,ECX
MOV RDI,qword ptr [RBX]
MOV dword ptr [RDI + R8*0x4],EDX
LEA ECX,[RCX + 0x1]
JMP 0x001011eb
LAB_0010120a:
MOV ECX,0x0
LAB_0010120f:
MOV dword ptr [RBP],ECX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(uint *param_1,int param_2,long *param_3,int *param_4)
{
uint *puVar1;
void *pvVar2;
int iVar3;
pvVar2 = malloc((long)param_2 << 2);
*param_3 = (long)pvVar2;
if (param_2 < 1) {
iVar3 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
if ((*param_1 & 1) != 0) {
*(uint *)(*param_3 + (long)iVar3 * 4) = *param_1;
iVar3 = iVar3 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
*param_4 = iVar3;
return;
} |
7,190 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| void func0(int *l, int len, int **out, int *out_len) {
int i, j = 0;
*out = (int*) malloc(len * sizeof(int));
for(i = 0; i < len; i++) {
if (l[i] % 2 != 0) {
(*out)[j++] = l[i];
}
}
*out_len = j;
}
| int main() {
int arr1[] = {1,3,5,2}, arr2[] = {5,6,7}, arr3[] = {1,2,3,4};
int *res;
int res_len;
func0(arr1, 4, &res, &res_len);
assert(res_len == 3 && res[0] == 1 && res[1] == 3 && res[2] == 5);
free(res);
func0(arr2, 3, &res, &res_len);
assert(res_len == 2 && res[0] == 5 && res[1] == 7);
free(res);
func0(arr3, 4, &res, &res_len);
assert(res_len == 2 && res[0] == 1 && res[1] == 3);
free(res);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %rdx,%r13
push %r12
mov %rcx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %rax,0x0(%r13)
test %ebp,%ebp
jle 13d0 <func0+0x70>
lea -0x1(%rbp),%edx
mov %rbx,%rdi
xor %esi,%esi
lea 0x4(%rbx,%rdx,4),%r8
nopl 0x0(%rax,%rax,1)
mov (%rdi),%edx
test $0x1,%dl
je 13b1 <func0+0x51>
movslq %esi,%r9
add $0x1,%esi
mov %edx,(%rax,%r9,4)
add $0x4,%rdi
cmp %r8,%rdi
jne 13a0 <func0+0x40>
mov %esi,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
xor %esi,%esi
mov %esi,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
mov r13, rdx
push r12
mov r12, rcx
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov rbp, rdi
shl rdi, 2
sub rsp, 8
call _malloc
mov [r13+0], rax
test ebp, ebp
jle short loc_13D0
lea ecx, [rbp-1]
mov rdx, rbx
xor esi, esi
lea rdi, [rbx+rcx*4+4]
nop dword ptr [rax+rax+00h]
loc_13A0:
mov ecx, [rdx]
test cl, 1
jz short loc_13B1
movsxd r8, esi
add esi, 1
mov [rax+r8*4], ecx
loc_13B1:
add rdx, 4
cmp rdx, rdi
jnz short loc_13A0
mov [r12], esi
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_13D0:
xor esi, esi
mov [r12], esi
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(_DWORD *a1, int a2, long long *a3, _DWORD *a4)
{
long long result; // rax
_DWORD *v8; // rdx
int v9; // esi
long long v10; // r8
result = malloc(4LL * a2);
*a3 = result;
if ( a2 <= 0 )
{
*a4 = 0;
}
else
{
v8 = a1;
v9 = 0;
do
{
if ( (*v8 & 1) != 0 )
{
v10 = v9++;
*(_DWORD *)(result + 4 * v10) = *v8;
}
++v8;
}
while ( v8 != &a1[a2 - 1 + 1] );
*a4 = v9;
}
return result;
} | func0:
ENDBR64
PUSH R13
MOV R13,RDX
PUSH R12
MOV R12,RCX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV RBP,RDI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010b0
MOV qword ptr [R13],RAX
TEST EBP,EBP
JLE 0x001013d0
LEA ECX,[RBP + -0x1]
MOV RDX,RBX
XOR ESI,ESI
LEA RDI,[RBX + RCX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001013a0:
MOV ECX,dword ptr [RDX]
TEST CL,0x1
JZ 0x001013b1
MOVSXD R8,ESI
ADD ESI,0x1
MOV dword ptr [RAX + R8*0x4],ECX
LAB_001013b1:
ADD RDX,0x4
CMP RDX,RDI
JNZ 0x001013a0
MOV dword ptr [R12],ESI
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001013d0:
XOR ESI,ESI
MOV dword ptr [R12],ESI
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(uint *param_1,int param_2,int8 *param_3,int *param_4)
{
uint *puVar1;
void *pvVar2;
int iVar3;
long lVar4;
pvVar2 = malloc((long)param_2 << 2);
*param_3 = pvVar2;
if (0 < param_2) {
iVar3 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if ((*param_1 & 1) != 0) {
lVar4 = (long)iVar3;
iVar3 = iVar3 + 1;
*(uint *)((long)pvVar2 + lVar4 * 4) = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
*param_4 = iVar3;
return;
}
*param_4 = 0;
return;
} |
7,191 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| void func0(int *l, int len, int **out, int *out_len) {
int i, j = 0;
*out = (int*) malloc(len * sizeof(int));
for(i = 0; i < len; i++) {
if (l[i] % 2 != 0) {
(*out)[j++] = l[i];
}
}
*out_len = j;
}
| int main() {
int arr1[] = {1,3,5,2}, arr2[] = {5,6,7}, arr3[] = {1,2,3,4};
int *res;
int res_len;
func0(arr1, 4, &res, &res_len);
assert(res_len == 3 && res[0] == 1 && res[1] == 3 && res[2] == 5);
free(res);
func0(arr2, 3, &res, &res_len);
assert(res_len == 2 && res[0] == 5 && res[1] == 7);
free(res);
func0(arr3, 4, &res, &res_len);
assert(res_len == 2 && res[0] == 1 && res[1] == 3);
free(res);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
mov %rdx,%r13
push %r12
mov %rcx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %rax,0x0(%r13)
test %ebp,%ebp
jle 13b0 <func0+0x70>
lea -0x1(%rbp),%edx
mov %rbx,%rdi
xor %esi,%esi
lea 0x4(%rbx,%rdx,4),%r8
nopl 0x0(%rax,%rax,1)
mov (%rdi),%edx
test $0x1,%dl
je 1391 <func0+0x51>
movslq %esi,%r9
add $0x1,%esi
mov %edx,(%rax,%r9,4)
add $0x4,%rdi
cmp %r8,%rdi
jne 1380 <func0+0x40>
mov %esi,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
xor %esi,%esi
mov %esi,(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
movsxd r8, esi
mov r14, rdx
push r13
mov r13, rcx
push r12
mov r12, r8
push rbp
lea rbp, ds:0[r8*4]
push rbx
mov rbx, rdi
mov rdi, rbp; size
call _malloc
mov [r14], rax
test r12d, r12d
jle short loc_13B0
mov rdx, rbx
lea r8, [rbx+rbp]
xor edi, edi
nop dword ptr [rax+00h]
loc_1380:
mov esi, [rdx]
test sil, 1
jz short loc_1392
movsxd r9, edi
add edi, 1
mov [rax+r9*4], esi
loc_1392:
add rdx, 4
cmp rdx, r8
jnz short loc_1380
mov [r13+0], edi
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_13B0:
xor edi, edi
mov [r13+0], edi
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | _DWORD * func0(_DWORD *a1, int a2, _QWORD *a3, _DWORD *a4)
{
_DWORD *result; // rax
_DWORD *v8; // rdx
int v9; // edi
long long v10; // r9
result = malloc(4LL * a2);
*a3 = result;
if ( a2 <= 0 )
{
*a4 = 0;
}
else
{
v8 = a1;
v9 = 0;
do
{
if ( (*v8 & 1) != 0 )
{
v10 = v9++;
result[v10] = *v8;
}
++v8;
}
while ( v8 != &a1[a2] );
*a4 = v9;
}
return result;
} | func0:
ENDBR64
PUSH R14
MOVSXD R8,ESI
MOV R14,RDX
PUSH R13
MOV R13,RCX
PUSH R12
MOV R12,R8
PUSH RBP
LEA RBP,[R8*0x4]
PUSH RBX
MOV RBX,RDI
MOV RDI,RBP
CALL 0x001010b0
MOV qword ptr [R14],RAX
TEST R12D,R12D
JLE 0x001013b0
MOV RDX,RBX
LEA R8,[RBX + RBP*0x1]
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_00101380:
MOV ESI,dword ptr [RDX]
TEST SIL,0x1
JZ 0x00101392
MOVSXD R9,EDI
ADD EDI,0x1
MOV dword ptr [RAX + R9*0x4],ESI
LAB_00101392:
ADD RDX,0x4
CMP RDX,R8
JNZ 0x00101380
MOV dword ptr [R13],EDI
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001013b0:
XOR EDI,EDI
MOV dword ptr [R13],EDI
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | void func0(uint *param_1,int param_2,int8 *param_3,int *param_4)
{
uint *puVar1;
void *pvVar2;
int iVar3;
long lVar4;
pvVar2 = malloc((long)param_2 * 4);
*param_3 = pvVar2;
if (0 < param_2) {
puVar1 = param_1 + param_2;
iVar3 = 0;
do {
if ((*param_1 & 1) != 0) {
lVar4 = (long)iVar3;
iVar3 = iVar3 + 1;
*(uint *)((long)pvVar2 + lVar4 * 4) = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
*param_4 = iVar3;
return;
}
*param_4 = 0;
return;
} |
7,192 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int nums[], int num_size, int list_index[], int index_size, int* result_size) {
static int result[100];
for (int i = 0; i < index_size; i++) {
result[i] = nums[list_index[i]];
}
*result_size = index_size;
return result;
}
| int main() {
int result_size;
int *result;
result = func0((int[]){2,3,8,4,7,9}, 6, (int[]){0,3,5}, 3, &result_size);
assert(result_size == 3 && result[0] == 2 && result[1] == 4 && result[2] == 9);
result = func0((int[]){1, 2, 3, 4, 5}, 5, (int[]){1, 2}, 2, &result_size);
assert(result_size == 2 && result[0] == 2 && result[1] == 3);
result = func0((int[]){1,0,2,3}, 4, (int[]){0, 1}, 2, &result_size);
assert(result_size == 2 && result[0] == 1 && result[1] == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
mov %r8,-0x30(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d1 <func0+0x68>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
lea 0x2e76(%rip),%rdx
mov %eax,(%rcx,%rdx,1)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 118c <func0+0x23>
mov -0x30(%rbp),%rax
mov -0x20(%rbp),%edx
mov %edx,(%rax)
lea 0x2e57(%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_20], ecx
mov [rbp+var_30], r8
mov [rbp+var_4], 0
jmp short loc_11D1
loc_118C:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_4]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
lea rdx, result_1
mov [rcx+rdx], eax
add [rbp+var_4], 1
loc_11D1:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_20]
jl short loc_118C
mov rax, [rbp+var_30]
mov edx, [rbp+var_20]
mov [rax], edx
lea rax, result_1
pop rbp
retn | _DWORD * func0(long long a1, long long a2, long long a3, int a4, _DWORD *a5)
{
int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; i < a4; ++i )
result_1[i] = *(_DWORD *)(4LL * *(int *)(4LL * i + a3) + a1);
*a5 = a4;
return result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d1
LAB_0010118c:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
LEA RDX,[0x104040]
MOV dword ptr [RCX + RDX*0x1],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d1:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x0010118c
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX],EDX
LEA RAX,[0x104040]
POP RBP
RET | int1 * func0(long param_1,int8 param_2,long param_3,int param_4,int *param_5)
{
int local_c;
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
*(int4 *)(result_1 + (long)local_c * 4) =
*(int4 *)(param_1 + (long)*(int *)(param_3 + (long)local_c * 4) * 4);
}
*param_5 = param_4;
return result_1;
} |
7,193 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int nums[], int num_size, int list_index[], int index_size, int* result_size) {
static int result[100];
for (int i = 0; i < index_size; i++) {
result[i] = nums[list_index[i]];
}
*result_size = index_size;
return result;
}
| int main() {
int result_size;
int *result;
result = func0((int[]){2,3,8,4,7,9}, 6, (int[]){0,3,5}, 3, &result_size);
assert(result_size == 3 && result[0] == 2 && result[1] == 4 && result[2] == 9);
result = func0((int[]){1, 2, 3, 4, 5}, 5, (int[]){1, 2}, 2, &result_size);
assert(result_size == 2 && result[0] == 2 && result[1] == 3);
result = func0((int[]){1,0,2,3}, 4, (int[]){0, 1}, 2, &result_size);
assert(result_size == 2 && result[0] == 1 && result[1] == 0);
return 0;
}
| O1 | c | func0:
endbr64
test %ecx,%ecx
jle 1198 <func0+0x2f>
lea -0x1(%rcx),%r10d
mov $0x0,%eax
lea 0x2ebf(%rip),%r9
movslq (%rdx,%rax,4),%rsi
mov (%rdi,%rsi,4),%esi
mov %esi,(%r9,%rax,4)
mov %rax,%rsi
add $0x1,%rax
cmp %r10,%rsi
jne 1181 <func0+0x18>
mov %ecx,(%r8)
lea 0x2e9e(%rip),%rax
retq
| func0:
endbr64
test ecx, ecx
jle short loc_1194
mov r10d, ecx
mov eax, 0
lea r9, result_1
loc_1180:
movsxd rsi, dword ptr [rdx+rax*4]
mov esi, [rdi+rsi*4]
mov [r9+rax*4], esi
add rax, 1
cmp rax, r10
jnz short loc_1180
loc_1194:
mov [r8], ecx
lea rax, result_1
retn | _DWORD * func0(long long a1, long long a2, long long a3, int a4, int *a5)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
result_1[i] = *(_DWORD *)(a1 + 4LL * *(int *)(a3 + 4 * i));
}
*a5 = a4;
return result_1;
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x00101194
MOV R10D,ECX
MOV EAX,0x0
LEA R9,[0x104040]
LAB_00101180:
MOVSXD RSI,dword ptr [RDX + RAX*0x4]
MOV ESI,dword ptr [RDI + RSI*0x4]
MOV dword ptr [R9 + RAX*0x4],ESI
ADD RAX,0x1
CMP RAX,R10
JNZ 0x00101180
LAB_00101194:
MOV dword ptr [R8],ECX
LEA RAX,[0x104040]
RET | int4 * func0(long param_1,int8 param_2,long param_3,uint param_4,uint *param_5)
{
ulong uVar1;
if (0 < (int)param_4) {
uVar1 = 0;
do {
(&result_1)[uVar1] = *(int4 *)(param_1 + (long)*(int *)(param_3 + uVar1 * 4) * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_4);
}
*param_5 = param_4;
return &result_1;
} |
7,194 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int nums[], int num_size, int list_index[], int index_size, int* result_size) {
static int result[100];
for (int i = 0; i < index_size; i++) {
result[i] = nums[list_index[i]];
}
*result_size = index_size;
return result;
}
| int main() {
int result_size;
int *result;
result = func0((int[]){2,3,8,4,7,9}, 6, (int[]){0,3,5}, 3, &result_size);
assert(result_size == 3 && result[0] == 2 && result[1] == 4 && result[2] == 9);
result = func0((int[]){1, 2, 3, 4, 5}, 5, (int[]){1, 2}, 2, &result_size);
assert(result_size == 2 && result[0] == 2 && result[1] == 3);
result = func0((int[]){1,0,2,3}, 4, (int[]){0, 1}, 2, &result_size);
assert(result_size == 2 && result[0] == 1 && result[1] == 0);
return 0;
}
| O2 | c | func0:
endbr64
test %ecx,%ecx
jle 117f <func0+0x2f>
lea -0x1(%rcx),%r10d
xor %eax,%eax
lea 0x2edb(%rip),%r9
nopl (%rax)
movslq (%rdx,%rax,4),%rsi
mov (%rdi,%rsi,4),%esi
mov %esi,(%r9,%rax,4)
mov %rax,%rsi
add $0x1,%rax
cmp %r10,%rsi
jne 1168 <func0+0x18>
mov %ecx,(%r8)
lea 0x2eb7(%rip),%rax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
lea r9, result_1
test ecx, ecx
jle short loc_117C
movsxd r10, ecx
xor eax, eax
nop dword ptr [rax+00h]
loc_1168:
movsxd rsi, dword ptr [rdx+rax*4]
mov esi, [rdi+rsi*4]
mov [r9+rax*4], esi
add rax, 1
cmp r10, rax
jnz short loc_1168
loc_117C:
mov [r8], ecx
mov rax, r9
retn | long long * func0(long long a1, long long a2, long long a3, int a4, int *a5)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
*((_DWORD *)&result_1 + i) = *(_DWORD *)(a1 + 4LL * *(int *)(a3 + 4 * i));
}
*a5 = a4;
return &result_1;
} | func0:
ENDBR64
LEA R9,[0x104040]
TEST ECX,ECX
JLE 0x0010117c
MOVSXD R10,ECX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101168:
MOVSXD RSI,dword ptr [RDX + RAX*0x4]
MOV ESI,dword ptr [RDI + RSI*0x4]
MOV dword ptr [R9 + RAX*0x4],ESI
ADD RAX,0x1
CMP R10,RAX
JNZ 0x00101168
LAB_0010117c:
MOV dword ptr [R8],ECX
MOV RAX,R9
RET | int4 * func0(long param_1,int8 param_2,long param_3,int param_4,int *param_5)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
(&result_1)[lVar1] = *(int4 *)(param_1 + (long)*(int *)(param_3 + lVar1 * 4) * 4);
lVar1 = lVar1 + 1;
} while (param_4 != lVar1);
}
*param_5 = param_4;
return &result_1;
} |
7,195 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int nums[], int num_size, int list_index[], int index_size, int* result_size) {
static int result[100];
for (int i = 0; i < index_size; i++) {
result[i] = nums[list_index[i]];
}
*result_size = index_size;
return result;
}
| int main() {
int result_size;
int *result;
result = func0((int[]){2,3,8,4,7,9}, 6, (int[]){0,3,5}, 3, &result_size);
assert(result_size == 3 && result[0] == 2 && result[1] == 4 && result[2] == 9);
result = func0((int[]){1, 2, 3, 4, 5}, 5, (int[]){1, 2}, 2, &result_size);
assert(result_size == 2 && result[0] == 2 && result[1] == 3);
result = func0((int[]){1,0,2,3}, 4, (int[]){0, 1}, 2, &result_size);
assert(result_size == 2 && result[0] == 1 && result[1] == 0);
return 0;
}
| O3 | c | func0:
endbr64
test %ecx,%ecx
jle 117f <func0+0x2f>
lea -0x1(%rcx),%r10d
xor %eax,%eax
lea 0x2edb(%rip),%r9
nopl (%rax)
movslq (%rdx,%rax,4),%rsi
mov (%rdi,%rsi,4),%esi
mov %esi,(%r9,%rax,4)
mov %rax,%rsi
add $0x1,%rax
cmp %r10,%rsi
jne 1168 <func0+0x18>
mov %ecx,(%r8)
lea 0x2eb7(%rip),%rax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
lea r10, result_1
test ecx, ecx
jle short loc_1184
movsxd r9, ecx
xor eax, eax
shl r9, 2
nop dword ptr [rax+rax+00000000h]
loc_1170:
movsxd rsi, dword ptr [rdx+rax]
mov esi, [rdi+rsi*4]
mov [r10+rax], esi
add rax, 4
cmp rax, r9
jnz short loc_1170
loc_1184:
mov [r8], ecx
mov rax, r10
retn | long long * func0(long long a1, long long a2, long long a3, int a4, int *a5)
{
long long v5; // rax
if ( a4 > 0 )
{
v5 = 0LL;
do
{
*(_DWORD *)((char *)&result_1 + v5) = *(_DWORD *)(a1 + 4LL * *(int *)(a3 + v5));
v5 += 4LL;
}
while ( v5 != 4LL * a4 );
}
*a5 = a4;
return &result_1;
} | func0:
ENDBR64
LEA R10,[0x104040]
TEST ECX,ECX
JLE 0x00101184
MOVSXD R9,ECX
XOR EAX,EAX
SHL R9,0x2
NOP dword ptr [RAX + RAX*0x1]
LAB_00101170:
MOVSXD RSI,dword ptr [RDX + RAX*0x1]
MOV ESI,dword ptr [RDI + RSI*0x4]
MOV dword ptr [R10 + RAX*0x1],ESI
ADD RAX,0x4
CMP RAX,R9
JNZ 0x00101170
LAB_00101184:
MOV dword ptr [R8],ECX
MOV RAX,R10
RET | int4 * func0(long param_1,int8 param_2,long param_3,int param_4,int *param_5)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
*(int4 *)((long)&result_1 + lVar1) =
*(int4 *)(param_1 + (long)*(int *)(param_3 + lVar1) * 4);
lVar1 = lVar1 + 4;
} while (lVar1 != (long)param_4 * 4);
}
*param_5 = param_4;
return &result_1;
} |
7,196 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
int sqa = pow(a, 2);
int sqb = pow(b, 2);
int sqc = pow(c, 2);
if (sqa == sqb + sqc || sqb == sqa + sqc || sqc == sqa + sqb) {
return "Right-angled Triangle";
} else if (sqa > sqc + sqb || sqb > sqa + sqc || sqc > sqa + sqb) {
return "Obtuse-angled Triangle";
} else {
return "Acute-angled Triangle";
}
}
| int main() {
assert(strcmp(func0(1, 2, 3), "Obtuse-angled Triangle") == 0);
assert(strcmp(func0(2, 2, 2), "Acute-angled Triangle") == 0);
assert(strcmp(func0(1, 0, 1), "Right-angled Triangle") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd 0xf95(%rip),%xmm1
callq 1070 <pow@plt>
cvttsd2si %xmm0,%eax
mov %eax,-0xc(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm0
movsd 0xf7c(%rip),%xmm1
callq 1070 <pow@plt>
cvttsd2si %xmm0,%eax
mov %eax,-0x8(%rbp)
cvtsi2sdl -0x1c(%rbp),%xmm0
movsd 0xf63(%rip),%xmm1
callq 1070 <pow@plt>
cvttsd2si %xmm0,%eax
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%edx
mov -0x4(%rbp),%eax
add %edx,%eax
cmp %eax,-0xc(%rbp)
je 1210 <func0+0x87>
mov -0xc(%rbp),%edx
mov -0x4(%rbp),%eax
add %edx,%eax
cmp %eax,-0x8(%rbp)
je 1210 <func0+0x87>
mov -0xc(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
cmp %eax,-0x4(%rbp)
jne 1219 <func0+0x90>
lea 0xdf1(%rip),%rax
jmp 1250 <func0+0xc7>
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
cmp %eax,-0xc(%rbp)
jg 1240 <func0+0xb7>
mov -0xc(%rbp),%edx
mov -0x4(%rbp),%eax
add %edx,%eax
cmp %eax,-0x8(%rbp)
jg 1240 <func0+0xb7>
mov -0xc(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
cmp %eax,-0x4(%rbp)
jle 1249 <func0+0xc0>
lea 0xdd7(%rip),%rax
jmp 1250 <func0+0xc7>
lea 0xde5(%rip),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_14]
movq rax, xmm2
movsd xmm0, cs:y
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
cvttsd2si eax, xmm0
mov [rbp+var_C], eax
pxor xmm3, xmm3
cvtsi2sd xmm3, [rbp+var_18]
movq rax, xmm3
movsd xmm0, cs:y
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
cvttsd2si eax, xmm0
mov [rbp+var_8], eax
pxor xmm4, xmm4
cvtsi2sd xmm4, [rbp+var_1C]
movq rax, xmm4
movsd xmm0, cs:y
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
cvttsd2si eax, xmm0
mov [rbp+var_4], eax
mov edx, [rbp+var_8]
mov eax, [rbp+var_4]
add eax, edx
cmp [rbp+var_C], eax
jz short loc_1246
mov edx, [rbp+var_C]
mov eax, [rbp+var_4]
add eax, edx
cmp [rbp+var_8], eax
jz short loc_1246
mov edx, [rbp+var_C]
mov eax, [rbp+var_8]
add eax, edx
cmp [rbp+var_4], eax
jnz short loc_124F
loc_1246:
lea rax, aRightAngledTri; "Right-angled Triangle"
jmp short locret_1286
loc_124F:
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
add eax, edx
cmp [rbp+var_C], eax
jg short loc_1276
mov edx, [rbp+var_C]
mov eax, [rbp+var_4]
add eax, edx
cmp [rbp+var_8], eax
jg short loc_1276
mov edx, [rbp+var_C]
mov eax, [rbp+var_8]
add eax, edx
cmp [rbp+var_4], eax
jle short loc_127F
loc_1276:
lea rax, s2; "Obtuse-angled Triangle"
jmp short locret_1286
loc_127F:
lea rax, aAcuteAngledTri; "Acute-angled Triangle"
locret_1286:
leave
retn | const char * func0(int a1, int a2, int a3)
{
int v5; // [rsp+14h] [rbp-Ch]
int v6; // [rsp+18h] [rbp-8h]
int v7; // [rsp+1Ch] [rbp-4h]
v5 = (int)pow((double)a1, 2.0);
v6 = (int)pow((double)a2, 2.0);
v7 = (int)pow((double)a3, 2.0);
if ( v5 == v6 + v7 || v6 == v5 + v7 || v7 == v5 + v6 )
return "Right-angled Triangle";
if ( v5 <= v7 + v6 && v6 <= v5 + v7 && v7 <= v5 + v6 )
return "Acute-angled Triangle";
return "Obtuse-angled Triangle";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x14]
MOVQ RAX,XMM2
MOVSD XMM0,qword ptr [0x00102120]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101070
CVTTSD2SI EAX,XMM0
MOV dword ptr [RBP + -0xc],EAX
PXOR XMM3,XMM3
CVTSI2SD XMM3,dword ptr [RBP + -0x18]
MOVQ RAX,XMM3
MOVSD XMM0,qword ptr [0x00102120]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101070
CVTTSD2SI EAX,XMM0
MOV dword ptr [RBP + -0x8],EAX
PXOR XMM4,XMM4
CVTSI2SD XMM4,dword ptr [RBP + -0x1c]
MOVQ RAX,XMM4
MOVSD XMM0,qword ptr [0x00102120]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101070
CVTTSD2SI EAX,XMM0
MOV dword ptr [RBP + -0x4],EAX
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EDX
CMP dword ptr [RBP + -0xc],EAX
JZ 0x00101246
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EDX
CMP dword ptr [RBP + -0x8],EAX
JZ 0x00101246
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
CMP dword ptr [RBP + -0x4],EAX
JNZ 0x0010124f
LAB_00101246:
LEA RAX,[0x102008]
JMP 0x00101286
LAB_0010124f:
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
CMP dword ptr [RBP + -0xc],EAX
JG 0x00101276
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EDX
CMP dword ptr [RBP + -0x8],EAX
JG 0x00101276
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
CMP dword ptr [RBP + -0x4],EAX
JLE 0x0010127f
LAB_00101276:
LEA RAX,[0x10201e]
JMP 0x00101286
LAB_0010127f:
LEA RAX,[0x102035]
LAB_00101286:
LEAVE
RET | char * func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
char *pcVar4;
double dVar5;
dVar5 = pow((double)param_1,DAT_00102120);
iVar1 = (int)dVar5;
dVar5 = pow((double)param_2,DAT_00102120);
iVar2 = (int)dVar5;
dVar5 = pow((double)param_3,DAT_00102120);
iVar3 = (int)dVar5;
if (((iVar1 == iVar3 + iVar2) || (iVar2 == iVar3 + iVar1)) || (iVar3 == iVar2 + iVar1)) {
pcVar4 = "Right-angled Triangle";
}
else if (((iVar2 + iVar3 < iVar1) || (iVar3 + iVar1 < iVar2)) || (iVar2 + iVar1 < iVar3)) {
pcVar4 = "Obtuse-angled Triangle";
}
else {
pcVar4 = "Acute-angled Triangle";
}
return pcVar4;
} |
7,197 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
int sqa = pow(a, 2);
int sqb = pow(b, 2);
int sqc = pow(c, 2);
if (sqa == sqb + sqc || sqb == sqa + sqc || sqc == sqa + sqb) {
return "Right-angled Triangle";
} else if (sqa > sqc + sqb || sqb > sqa + sqc || sqc > sqa + sqb) {
return "Obtuse-angled Triangle";
} else {
return "Acute-angled Triangle";
}
}
| int main() {
assert(strcmp(func0(1, 2, 3), "Obtuse-angled Triangle") == 0);
assert(strcmp(func0(2, 2, 2), "Acute-angled Triangle") == 0);
assert(strcmp(func0(1, 0, 1), "Right-angled Triangle") == 0);
return 0;
}
| O1 | c | func0:
endbr64
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%edi
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%ecx
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%eax
lea (%rcx,%rax,1),%esi
lea 0xe94(%rip),%rdx
cmp %edi,%esi
je 11bf <func0+0x76>
lea (%rdi,%rax,1),%r8d
cmp %ecx,%r8d
je 11bf <func0+0x76>
lea (%rdi,%rcx,1),%r9d
cmp %eax,%r9d
je 11bf <func0+0x76>
cmp %ecx,%r8d
setl %dl
cmp %eax,%r9d
setl %al
or %al,%dl
jne 11b8 <func0+0x6f>
lea 0xe7d(%rip),%rdx
cmp %edi,%esi
jge 11bf <func0+0x76>
lea 0xe45(%rip),%rdx
mov %rdx,%rax
retq
| func0:
endbr64
mov eax, esi
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
mulsd xmm0, xmm0
cvttsd2si esi, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mulsd xmm0, xmm0
cvttsd2si ecx, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
mulsd xmm0, xmm0
cvttsd2si edx, xmm0
lea edi, [rcx+rdx]
lea rax, aRightAngledTri; "Right-angled Triangle"
cmp edi, esi
jz short locret_11DA
lea r8d, [rsi+rdx]
cmp r8d, ecx
jz short locret_11DA
lea r9d, [rsi+rcx]
cmp r9d, edx
jz short locret_11DA
cmp r8d, ecx
setl al
cmp r9d, edx
setl dl
or al, dl
jnz short loc_11D3
cmp edi, esi
jge short loc_11DB
loc_11D3:
lea rax, aObtuseAngledTr; "Obtuse-angled Triangle"
locret_11DA:
retn
loc_11DB:
lea rax, aAcuteAngledTri; "Acute-angled Triangle"
retn | const char * func0(int a1, int a2, int a3)
{
int v4; // esi
int v5; // ecx
int v6; // edx
const char *result; // rax
v4 = (int)((double)a1 * (double)a1);
v5 = (int)((double)a2 * (double)a2);
v6 = (int)((double)a3 * (double)a3);
result = "Right-angled Triangle";
if ( v5 + v6 != v4 && v4 + v6 != v5 && v4 + v5 != v6 )
{
if ( v4 + v5 < v6 || v4 + v6 < v5 || v5 + v6 < v4 )
return "Obtuse-angled Triangle";
else
return "Acute-angled Triangle";
}
return result;
} | func0:
ENDBR64
MOV EAX,ESI
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MULSD XMM0,XMM0
CVTTSD2SI ESI,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MULSD XMM0,XMM0
CVTTSD2SI ECX,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
MULSD XMM0,XMM0
CVTTSD2SI EDX,XMM0
LEA EDI,[RCX + RDX*0x1]
LEA RAX,[0x102004]
CMP EDI,ESI
JZ 0x001011da
LEA R8D,[RSI + RDX*0x1]
CMP R8D,ECX
JZ 0x001011da
LEA R9D,[RSI + RCX*0x1]
CMP R9D,EDX
JZ 0x001011da
CMP R8D,ECX
SETL AL
CMP R9D,EDX
SETL DL
OR AL,DL
JNZ 0x001011d3
CMP EDI,ESI
JGE 0x001011db
LAB_001011d3:
LEA RAX,[0x10201a]
LAB_001011da:
RET
LAB_001011db:
LEA RAX,[0x102031]
RET | char * func0(int param_1,int param_2,int param_3)
{
char *pcVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = (int)((double)param_1 * (double)param_1);
iVar2 = (int)((double)param_2 * (double)param_2);
iVar3 = (int)((double)param_3 * (double)param_3);
pcVar1 = "Right-angled Triangle";
if (((iVar2 + iVar3 != iVar4) && (iVar4 + iVar3 != iVar2)) && (iVar4 + iVar2 != iVar3)) {
if ((iVar2 <= iVar4 + iVar3 && iVar3 <= iVar4 + iVar2) && (iVar4 <= iVar2 + iVar3)) {
return "Acute-angled Triangle";
}
pcVar1 = "Obtuse-angled Triangle";
}
return pcVar1;
} |
7,198 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
int sqa = pow(a, 2);
int sqb = pow(b, 2);
int sqc = pow(c, 2);
if (sqa == sqb + sqc || sqb == sqa + sqc || sqc == sqa + sqb) {
return "Right-angled Triangle";
} else if (sqa > sqc + sqb || sqb > sqa + sqc || sqc > sqa + sqb) {
return "Obtuse-angled Triangle";
} else {
return "Acute-angled Triangle";
}
}
| int main() {
assert(strcmp(func0(1, 2, 3), "Obtuse-angled Triangle") == 0);
assert(strcmp(func0(2, 2, 2), "Acute-angled Triangle") == 0);
assert(strcmp(func0(1, 0, 1), "Right-angled Triangle") == 0);
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm0,%xmm0
mov %edx,%r8d
cvtsi2sd %edi,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%edx
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%eax
pxor %xmm0,%xmm0
cvtsi2sd %r8d,%xmm0
lea 0xd7d(%rip),%r8
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%ecx
lea (%rax,%rcx,1),%esi
cmp %edx,%esi
je 12c4 <func0+0x74>
lea (%rdx,%rcx,1),%edi
cmp %eax,%edi
je 12c4 <func0+0x74>
lea (%rdx,%rax,1),%r9d
cmp %ecx,%r9d
je 12c4 <func0+0x74>
setl %cl
cmp %eax,%edi
setl %al
or %al,%cl
jne 12bd <func0+0x6d>
lea 0xd78(%rip),%r8
cmp %edx,%esi
jge 12c4 <func0+0x74>
lea 0xd56(%rip),%r8
mov %r8,%rax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
pxor xmm0, xmm0
mov r8d, edx
cvtsi2sd xmm0, edi
mulsd xmm0, xmm0
cvttsd2si edx, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, esi
mulsd xmm0, xmm0
cvttsd2si eax, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, r8d
lea r8, aRightAngledTri; "Right-angled Triangle"
mulsd xmm0, xmm0
cvttsd2si ecx, xmm0
lea esi, [rax+rcx]
cmp esi, edx
jz short loc_12C4
lea edi, [rdx+rcx]
cmp edi, eax
jz short loc_12C4
lea r9d, [rdx+rax]
cmp r9d, ecx
jz short loc_12C4
setl cl
cmp edi, eax
setl al
or cl, al
jnz short loc_12BD
lea r8, aAcuteAngledTri; "Acute-angled Triangle"
cmp esi, edx
jge short loc_12C4
loc_12BD:
lea r8, aObtuseAngledTr; "Obtuse-angled Triangle"
loc_12C4:
mov rax, r8
retn | const char * func0(int a1, int a2, int a3)
{
int v4; // edx
int v5; // eax
double v6; // xmm0_8
const char *v7; // r8
int v8; // ecx
v4 = (int)((double)a1 * (double)a1);
v5 = (int)((double)a2 * (double)a2);
v6 = (double)a3;
v7 = "Right-angled Triangle";
v8 = (int)(v6 * v6);
if ( v5 + v8 != v4 && v4 + v8 != v5 && v4 + v5 != v8 )
{
if ( v4 + v8 < v5 || v4 + v5 < v8 )
return "Obtuse-angled Triangle";
v7 = "Acute-angled Triangle";
if ( v5 + v8 < v4 )
return "Obtuse-angled Triangle";
}
return v7;
} | func0:
ENDBR64
PXOR XMM0,XMM0
MOV R8D,EDX
CVTSI2SD XMM0,EDI
MULSD XMM0,XMM0
CVTTSD2SI EDX,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,ESI
MULSD XMM0,XMM0
CVTTSD2SI EAX,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,R8D
LEA R8,[0x102004]
MULSD XMM0,XMM0
CVTTSD2SI ECX,XMM0
LEA ESI,[RAX + RCX*0x1]
CMP ESI,EDX
JZ 0x001012c4
LEA EDI,[RDX + RCX*0x1]
CMP EDI,EAX
JZ 0x001012c4
LEA R9D,[RDX + RAX*0x1]
CMP R9D,ECX
JZ 0x001012c4
SETL CL
CMP EDI,EAX
SETL AL
OR CL,AL
JNZ 0x001012bd
LEA R8,[0x102031]
CMP ESI,EDX
JGE 0x001012c4
LAB_001012bd:
LEA R8,[0x10201a]
LAB_001012c4:
MOV RAX,R8
RET | char * func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
char *pcVar4;
iVar3 = (int)((double)param_1 * (double)param_1);
iVar1 = (int)((double)param_2 * (double)param_2);
pcVar4 = "Right-angled Triangle";
iVar2 = (int)((double)param_3 * (double)param_3);
if ((((iVar1 + iVar2 != iVar3) && (iVar3 + iVar2 != iVar1)) && (iVar3 + iVar1 != iVar2)) &&
((iVar3 + iVar1 < iVar2 || iVar3 + iVar2 < iVar1 ||
(pcVar4 = "Acute-angled Triangle", iVar1 + iVar2 < iVar3)))) {
pcVar4 = "Obtuse-angled Triangle";
}
return pcVar4;
} |
7,199 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
int sqa = pow(a, 2);
int sqb = pow(b, 2);
int sqc = pow(c, 2);
if (sqa == sqb + sqc || sqb == sqa + sqc || sqc == sqa + sqb) {
return "Right-angled Triangle";
} else if (sqa > sqc + sqb || sqb > sqa + sqc || sqc > sqa + sqb) {
return "Obtuse-angled Triangle";
} else {
return "Acute-angled Triangle";
}
}
| int main() {
assert(strcmp(func0(1, 2, 3), "Obtuse-angled Triangle") == 0);
assert(strcmp(func0(2, 2, 2), "Acute-angled Triangle") == 0);
assert(strcmp(func0(1, 0, 1), "Right-angled Triangle") == 0);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm0,%xmm0
mov %edx,%r8d
cvtsi2sd %edi,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%edx
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%eax
pxor %xmm0,%xmm0
cvtsi2sd %r8d,%xmm0
lea 0xd7d(%rip),%r8
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%ecx
lea (%rax,%rcx,1),%esi
cmp %edx,%esi
je 12c4 <func0+0x74>
lea (%rdx,%rcx,1),%edi
cmp %eax,%edi
je 12c4 <func0+0x74>
lea (%rdx,%rax,1),%r9d
cmp %ecx,%r9d
je 12c4 <func0+0x74>
setl %cl
cmp %eax,%edi
setl %al
or %al,%cl
jne 12bd <func0+0x6d>
lea 0xd78(%rip),%r8
cmp %edx,%esi
jge 12c4 <func0+0x74>
lea 0xd56(%rip),%r8
mov %r8,%rax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
pxor xmm0, xmm0
mov eax, edx
cvtsi2sd xmm0, edi
mulsd xmm0, xmm0
cvttsd2si ecx, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, esi
lea rsi, aRightAngledTri; "Right-angled Triangle"
mulsd xmm0, xmm0
cvttsd2si edx, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mulsd xmm0, xmm0
cvttsd2si eax, xmm0
lea edi, [rdx+rax]
cmp edi, ecx
jz short loc_12C8
lea r8d, [rcx+rax]
cmp r8d, edx
jz short loc_12C8
lea r9d, [rcx+rdx]
cmp r9d, eax
jz short loc_12C8
cmp r8d, edx
setl dl
cmp r9d, eax
setl al
or dl, al
jnz short loc_12C1
lea rsi, aAcuteAngledTri; "Acute-angled Triangle"
cmp edi, ecx
jge short loc_12C8
loc_12C1:
lea rsi, s2; "Obtuse-angled Triangle"
loc_12C8:
mov rax, rsi
retn | const char * func0(int a1, int a2, int a3)
{
int v4; // ecx
double v5; // xmm0_8
const char *v6; // rsi
int v7; // edx
int v8; // eax
v4 = (int)((double)a1 * (double)a1);
v5 = (double)a2;
v6 = "Right-angled Triangle";
v7 = (int)(v5 * v5);
v8 = (int)((double)a3 * (double)a3);
if ( v7 + v8 != v4 && v4 + v8 != v7 && v4 + v7 != v8 )
{
if ( v4 + v7 < v8 || v4 + v8 < v7 )
return "Obtuse-angled Triangle";
v6 = "Acute-angled Triangle";
if ( v7 + v8 < v4 )
return "Obtuse-angled Triangle";
}
return v6;
} | func0:
ENDBR64
PXOR XMM0,XMM0
MOV EAX,EDX
CVTSI2SD XMM0,EDI
MULSD XMM0,XMM0
CVTTSD2SI ECX,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,ESI
LEA RSI,[0x102004]
MULSD XMM0,XMM0
CVTTSD2SI EDX,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MULSD XMM0,XMM0
CVTTSD2SI EAX,XMM0
LEA EDI,[RDX + RAX*0x1]
CMP EDI,ECX
JZ 0x001012c8
LEA R8D,[RCX + RAX*0x1]
CMP R8D,EDX
JZ 0x001012c8
LEA R9D,[RCX + RDX*0x1]
CMP R9D,EAX
JZ 0x001012c8
CMP R8D,EDX
SETL DL
CMP R9D,EAX
SETL AL
OR DL,AL
JNZ 0x001012c1
LEA RSI,[0x102031]
CMP EDI,ECX
JGE 0x001012c8
LAB_001012c1:
LEA RSI,[0x10201a]
LAB_001012c8:
MOV RAX,RSI
RET | char * func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
char *pcVar4;
iVar2 = (int)((double)param_1 * (double)param_1);
pcVar4 = "Right-angled Triangle";
iVar3 = (int)((double)param_2 * (double)param_2);
iVar1 = (int)((double)param_3 * (double)param_3);
if ((((iVar3 + iVar1 != iVar2) && (iVar2 + iVar1 != iVar3)) && (iVar2 + iVar3 != iVar1)) &&
((iVar2 + iVar1 < iVar3 || iVar2 + iVar3 < iVar1 ||
(pcVar4 = "Acute-angled Triangle", iVar3 + iVar1 < iVar2)))) {
pcVar4 = "Obtuse-angled Triangle";
}
return pcVar4;
} |
7,200 | func0 |
#include <assert.h>
| int func0(int list1[][4], int rows, int C) {
int result = 0;
for (int i = 0; i < rows; i++) {
result += list1[i][C];
}
return result;
}
| int main() {
int array1[3][4] = {{1,2,3,2},{4,5,6,2},{7,8,9,5}};
assert(func0(array1, 3, 0) == 12);
assert(func0(array1, 3, 1) == 15);
assert(func0(array1, 3, 3) == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ad <func0+0x44>
mov -0x4(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x20(%rbp),%eax
cltq
mov (%rdx,%rax,4),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 118b <func0+0x22>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11AD
loc_118B:
mov eax, [rbp+var_4]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_20]
cdqe
mov eax, [rdx+rax*4]
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_11AD:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_118B
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2, int a3)
{
unsigned int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
v4 += *(_DWORD *)(a1 + 16LL * i + 4LL * a3);
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ad
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x20]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ad:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010118b
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2,int param_3)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 + *(int *)((long)local_c * 0x10 + param_1 + (long)param_3 * 4);
}
return local_10;
} |
7,201 | func0 |
#include <assert.h>
| int func0(int list1[][4], int rows, int C) {
int result = 0;
for (int i = 0; i < rows; i++) {
result += list1[i][C];
}
return result;
}
| int main() {
int array1[3][4] = {{1,2,3,2},{4,5,6,2},{7,8,9,5}};
assert(func0(array1, 3, 0) == 12);
assert(func0(array1, 3, 1) == 15);
assert(func0(array1, 3, 3) == 9);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1197 <func0+0x2e>
movslq %edx,%rdx
lea (%rdi,%rdx,4),%rax
lea -0x1(%rsi),%ecx
lea (%rdx,%rcx,4),%rdx
lea 0x10(%rdi,%rdx,4),%rcx
mov $0x0,%edx
add (%rax),%edx
add $0x10,%rax
cmp %rcx,%rax
jne 1189 <func0+0x20>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1194 <func0+0x2b>
| func0:
endbr64
test esi, esi
jle short loc_1197
movsxd rdx, edx
lea rax, [rdi+rdx*4]
lea ecx, [rsi-1]
lea rdx, [rdx+rcx*4]
lea rcx, [rdi+rdx*4+10h]
mov edx, 0
loc_1189:
add edx, [rax]
add rax, 10h
cmp rax, rcx
jnz short loc_1189
loc_1194:
mov eax, edx
retn
loc_1197:
mov edx, 0
jmp short loc_1194 | long long func0(long long a1, int a2, int a3)
{
_DWORD *v3; // rax
long long v4; // rcx
unsigned int v5; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v3 = (_DWORD *)(a1 + 4LL * a3);
v4 = a1 + 4 * (a3 + 4LL * (unsigned int)(a2 - 1)) + 16;
v5 = 0;
do
{
v5 += *v3;
v3 += 4;
}
while ( v3 != (_DWORD *)v4 );
}
return v5;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101197
MOVSXD RDX,EDX
LEA RAX,[RDI + RDX*0x4]
LEA ECX,[RSI + -0x1]
LEA RDX,[RDX + RCX*0x4]
LEA RCX,[RDI + RDX*0x4 + 0x10]
MOV EDX,0x0
LAB_00101189:
ADD EDX,dword ptr [RAX]
ADD RAX,0x10
CMP RAX,RCX
JNZ 0x00101189
LAB_00101194:
MOV EAX,EDX
RET
LAB_00101197:
MOV EDX,0x0
JMP 0x00101194 | int func0(long param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = (int *)(param_1 + (long)param_3 * 4);
iVar2 = 0;
do {
iVar2 = iVar2 + *piVar1;
piVar1 = piVar1 + 4;
} while (piVar1 != (int *)(param_1 + 0x10 + ((long)param_3 + (ulong)(param_2 - 1) * 4) * 4));
}
return iVar2;
} |
7,202 | func0 |
#include <assert.h>
| int func0(int list1[][4], int rows, int C) {
int result = 0;
for (int i = 0; i < rows; i++) {
result += list1[i][C];
}
return result;
}
| int main() {
int array1[3][4] = {{1,2,3,2},{4,5,6,2},{7,8,9,5}};
assert(func0(array1, 3, 0) == 12);
assert(func0(array1, 3, 1) == 15);
assert(func0(array1, 3, 3) == 9);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
movslq %edx,%rdx
lea -0x1(%rsi),%ecx
xor %r8d,%r8d
lea (%rdi,%rdx,4),%rax
lea (%rdx,%rcx,4),%rdx
lea 0x10(%rdi,%rdx,4),%rdx
xchg %ax,%ax
add (%rax),%r8d
add $0x10,%rax
cmp %rdx,%rax
jne 1160 <func0+0x20>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rdx, edx
lea ecx, [rsi-1]
xor r8d, r8d
lea rax, [rdi+rdx*4]
lea rdx, [rdx+rcx*4]
lea rdx, [rdi+rdx*4+10h]
xchg ax, ax
loc_1160:
add r8d, [rax]
add rax, 10h
cmp rax, rdx
jnz short loc_1160
mov eax, r8d
retn
loc_1170:
xor r8d, r8d
mov eax, r8d
retn | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r8d
_DWORD *v4; // rax
long long v5; // rdx
if ( a2 <= 0 )
return 0LL;
v3 = 0;
v4 = (_DWORD *)(a1 + 4LL * a3);
v5 = a1 + 4 * (a3 + 4LL * (unsigned int)(a2 - 1)) + 16;
do
{
v3 += *v4;
v4 += 4;
}
while ( v4 != (_DWORD *)v5 );
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RDX,EDX
LEA ECX,[RSI + -0x1]
XOR R8D,R8D
LEA RAX,[RDI + RDX*0x4]
LEA RDX,[RDX + RCX*0x4]
LEA RDX,[RDI + RDX*0x4 + 0x10]
NOP
LAB_00101160:
ADD R8D,dword ptr [RAX]
ADD RAX,0x10
CMP RAX,RDX
JNZ 0x00101160
MOV EAX,R8D
RET
LAB_00101170:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(long param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
iVar2 = 0;
piVar1 = (int *)(param_1 + (long)param_3 * 4);
do {
iVar2 = iVar2 + *piVar1;
piVar1 = piVar1 + 4;
} while (piVar1 != (int *)(param_1 + 0x10 + ((long)param_3 + (ulong)(param_2 - 1) * 4) * 4));
return iVar2;
}
return 0;
} |
7,203 | func0 |
#include <assert.h>
| int func0(int list1[][4], int rows, int C) {
int result = 0;
for (int i = 0; i < rows; i++) {
result += list1[i][C];
}
return result;
}
| int main() {
int array1[3][4] = {{1,2,3,2},{4,5,6,2},{7,8,9,5}};
assert(func0(array1, 3, 0) == 12);
assert(func0(array1, 3, 1) == 15);
assert(func0(array1, 3, 3) == 9);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1268 <func0+0x128>
lea -0x1(%rsi),%ecx
cmp $0x7,%ecx
jbe 126b <func0+0x12b>
movslq %edx,%r8
mov %ecx,%edx
pxor %xmm2,%xmm2
shr $0x2,%edx
lea (%rdi,%r8,4),%rax
shl $0x6,%rdx
add %rax,%rdx
movdqu (%rax),%xmm0
movdqu 0x10(%rax),%xmm3
add $0x40,%rax
movdqu -0x20(%rax),%xmm1
movdqu -0x10(%rax),%xmm4
shufps $0x88,%xmm3,%xmm0
shufps $0x88,%xmm4,%xmm1
shufps $0x88,%xmm1,%xmm0
paddd %xmm0,%xmm2
cmp %rdx,%rax
jne 1170 <func0+0x30>
movdqa %xmm2,%xmm0
and $0xfffffffc,%ecx
psrldq $0x8,%xmm0
paddd %xmm0,%xmm2
movdqa %xmm2,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm2
movd %xmm2,%eax
movslq %ecx,%rdx
shl $0x4,%rdx
add %rdi,%rdx
add (%rdx,%r8,4),%eax
lea 0x1(%rcx),%edx
cmp %edx,%esi
jle 126a <func0+0x12a>
movslq %edx,%rdx
shl $0x4,%rdx
add %rdi,%rdx
add (%rdx,%r8,4),%eax
lea 0x2(%rcx),%edx
cmp %edx,%esi
jle 126a <func0+0x12a>
movslq %edx,%rdx
shl $0x4,%rdx
add %rdi,%rdx
add (%rdx,%r8,4),%eax
lea 0x3(%rcx),%edx
cmp %edx,%esi
jle 126a <func0+0x12a>
movslq %edx,%rdx
shl $0x4,%rdx
add %rdi,%rdx
add (%rdx,%r8,4),%eax
lea 0x4(%rcx),%edx
cmp %edx,%esi
jle 126a <func0+0x12a>
movslq %edx,%rdx
shl $0x4,%rdx
add %rdi,%rdx
add (%rdx,%r8,4),%eax
lea 0x5(%rcx),%edx
cmp %edx,%esi
jle 126a <func0+0x12a>
movslq %edx,%rdx
shl $0x4,%rdx
add %rdi,%rdx
add (%rdx,%r8,4),%eax
lea 0x6(%rcx),%edx
cmp %edx,%esi
jle 126a <func0+0x12a>
movslq %edx,%rdx
add $0x7,%ecx
shl $0x4,%rdx
add %rdi,%rdx
add (%rdx,%r8,4),%eax
cmp %ecx,%esi
jle 126a <func0+0x12a>
movslq %ecx,%rcx
shl $0x4,%rcx
add %rdi,%rcx
add (%rcx,%r8,4),%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
xor %ecx,%ecx
xor %eax,%eax
movslq %edx,%r8
jmpq 11bd <func0+0x7d>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov r8, rdi
mov edi, esi
test esi, esi
jle loc_1200
lea esi, [rsi-1]
cmp esi, 3
jbe loc_1203
mov ecx, esi
movsxd rdx, edx
pxor xmm1, xmm1
shr ecx, 2
lea rax, [r8+rdx*4]
shl rcx, 6
add rcx, rax
nop dword ptr [rax+00h]
loc_1178:
movdqu xmm0, xmmword ptr [rax]
movdqu xmm3, xmmword ptr [rax+10h]
add rax, 40h ; '@'
movdqu xmm2, xmmword ptr [rax-20h]
movdqu xmm4, xmmword ptr [rax-10h]
shufps xmm0, xmm3, 88h
shufps xmm2, xmm4, 88h
shufps xmm0, xmm2, 88h
paddd xmm1, xmm0
cmp rax, rcx
jnz short loc_1178
movdqa xmm0, xmm1
and esi, 0FFFFFFFCh
psrldq xmm0, 8
mov ecx, esi
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
loc_11C7:
movsxd rsi, ecx
shl rsi, 4
add r8, rsi
lea esi, [rcx+1]
lea rdx, [r8+rdx*4]
add eax, [rdx]
cmp edi, esi
jle short locret_1202
lea esi, [rcx+2]
add eax, [rdx+10h]
cmp edi, esi
jle short locret_1202
add ecx, 3
add eax, [rdx+20h]
cmp edi, ecx
jle short locret_1202
add eax, [rdx+30h]
retn
loc_1200:
xor eax, eax
locret_1202:
retn
loc_1203:
xor ecx, ecx
xor eax, eax
movsxd rdx, edx
jmp short loc_11C7 | long long func0(long long a1, int a2, long long a3)
{
unsigned int v5; // esi
__m128i v6; // xmm1
const __m128i *v7; // rax
const __m128i *v8; // rcx
__m128 v9; // xmm0
__m128 v10; // xmm3
signed int v11; // ecx
__m128i v12; // xmm1
int v13; // eax
_DWORD *v14; // rdx
long long result; // rax
if ( a2 <= 0 )
return 0LL;
v5 = a2 - 1;
if ( v5 <= 3 )
{
v11 = 0;
v13 = 0;
a3 = (int)a3;
}
else
{
a3 = (int)a3;
v6 = 0LL;
v7 = (const __m128i *)(a1 + 4LL * (int)a3);
v8 = &v7[4 * (unsigned long long)(v5 >> 2)];
do
{
v9 = (__m128)_mm_loadu_si128(v7);
v10 = (__m128)_mm_loadu_si128(v7 + 1);
v7 += 4;
v6 = _mm_add_epi32(
v6,
(__m128i)_mm_shuffle_ps(
_mm_shuffle_ps(v9, v10, 136),
_mm_shuffle_ps((__m128)_mm_loadu_si128(v7 - 2), (__m128)_mm_loadu_si128(v7 - 1), 136),
136));
}
while ( v7 != v8 );
v11 = v5 & 0xFFFFFFFC;
v12 = _mm_add_epi32(v6, _mm_srli_si128(v6, 8));
v13 = _mm_cvtsi128_si32(_mm_add_epi32(v12, _mm_srli_si128(v12, 4)));
}
v14 = (_DWORD *)(16LL * v11 + a1 + 4 * a3);
result = (unsigned int)(*v14 + v13);
if ( a2 > v11 + 1 )
{
result = (unsigned int)(v14[4] + result);
if ( a2 > v11 + 2 )
{
result = (unsigned int)(v14[8] + result);
if ( a2 > v11 + 3 )
return (unsigned int)(v14[12] + result);
}
}
return result;
} | func0:
ENDBR64
MOV R8,RDI
MOV EDI,ESI
TEST ESI,ESI
JLE 0x00101200
LEA ESI,[RSI + -0x1]
CMP ESI,0x3
JBE 0x00101203
MOV ECX,ESI
MOVSXD RDX,EDX
PXOR XMM1,XMM1
SHR ECX,0x2
LEA RAX,[R8 + RDX*0x4]
SHL RCX,0x6
ADD RCX,RAX
NOP dword ptr [RAX]
LAB_00101178:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQU XMM3,xmmword ptr [RAX + 0x10]
ADD RAX,0x40
MOVDQU XMM2,xmmword ptr [RAX + -0x20]
MOVDQU XMM4,xmmword ptr [RAX + -0x10]
SHUFPS XMM0,XMM3,0x88
SHUFPS XMM2,XMM4,0x88
SHUFPS XMM0,XMM2,0x88
PADDD XMM1,XMM0
CMP RAX,RCX
JNZ 0x00101178
MOVDQA XMM0,XMM1
AND ESI,0xfffffffc
PSRLDQ XMM0,0x8
MOV ECX,ESI
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
LAB_001011c7:
MOVSXD RSI,ECX
SHL RSI,0x4
ADD R8,RSI
LEA ESI,[RCX + 0x1]
LEA RDX,[R8 + RDX*0x4]
ADD EAX,dword ptr [RDX]
CMP EDI,ESI
JLE 0x00101202
LEA ESI,[RCX + 0x2]
ADD EAX,dword ptr [RDX + 0x10]
CMP EDI,ESI
JLE 0x00101202
ADD ECX,0x3
ADD EAX,dword ptr [RDX + 0x20]
CMP EDI,ECX
JLE 0x00101202
ADD EAX,dword ptr [RDX + 0x30]
RET
LAB_00101200:
XOR EAX,EAX
LAB_00101202:
RET
LAB_00101203:
XOR ECX,ECX
XOR EAX,EAX
MOVSXD RDX,EDX
JMP 0x001011c7 | int func0(long param_1,int param_2,int param_3)
{
int *piVar1;
int *piVar2;
int *piVar3;
uint uVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
if (param_2 < 1) {
iVar5 = 0;
}
else {
uVar4 = param_2 - 1;
if (uVar4 < 4) {
uVar4 = 0;
iVar5 = 0;
}
else {
iVar5 = 0;
iVar6 = 0;
iVar7 = 0;
iVar8 = 0;
piVar1 = (int *)(param_1 + (long)param_3 * 4);
piVar2 = piVar1;
do {
piVar3 = piVar2 + 0x10;
iVar5 = iVar5 + *piVar2;
iVar6 = iVar6 + piVar2[4];
iVar7 = iVar7 + piVar2[8];
iVar8 = iVar8 + piVar2[0xc];
piVar2 = piVar3;
} while (piVar3 != piVar1 + (ulong)(uVar4 >> 2) * 0x10);
uVar4 = uVar4 & 0xfffffffc;
iVar5 = iVar5 + iVar7 + iVar6 + iVar8;
}
piVar1 = (int *)(param_1 + (long)(int)uVar4 * 0x10 + (long)param_3 * 4);
iVar5 = iVar5 + *piVar1;
if ((int)(uVar4 + 1) < param_2) {
iVar5 = iVar5 + piVar1[4];
if ((int)(uVar4 + 2) < param_2) {
iVar5 = iVar5 + piVar1[8];
if ((int)(uVar4 + 3) < param_2) {
return iVar5 + piVar1[0xc];
}
}
}
}
return iVar5;
} |
7,204 | func0 | #include <assert.h>
#include <ctype.h>
| void func0(const char* string, int* alphabets, int* digits, int* special) {
*alphabets = *digits = *special = 0;
for (int i = 0; string[i] != '\0'; i++) {
if (isalpha(string[i]))
(*alphabets)++;
else if (isdigit(string[i]))
(*digits)++;
else
(*special)++;
}
}
| int main() {
int alphabets, digits, special;
func0("abc!@#123", &alphabets, &digits, &special);
assert(alphabets == 3 && digits == 3 && special == 3);
func0("dgsuy@#$%&1255", &alphabets, &digits, &special);
assert(alphabets == 5 && digits == 4 && special == 5);
func0("fjdsif627348#%$^&", &alphabets, &digits, &special);
assert(alphabets == 6 && digits == 6 && special == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
mov -0x30(%rbp),%rax
movl $0x0,(%rax)
mov -0x30(%rbp),%rax
mov (%rax),%edx
mov -0x28(%rbp),%rax
mov %edx,(%rax)
mov -0x28(%rbp),%rax
mov (%rax),%edx
mov -0x20(%rbp),%rax
mov %edx,(%rax)
movl $0x0,-0x4(%rbp)
jmpq 126a <func0+0xe1>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x400,%eax
test %eax,%eax
je 1215 <func0+0x8c>
mov -0x20(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x20(%rbp),%rax
mov %edx,(%rax)
jmp 1266 <func0+0xdd>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x800,%eax
test %eax,%eax
je 1257 <func0+0xce>
mov -0x28(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x28(%rbp),%rax
mov %edx,(%rax)
jmp 1266 <func0+0xdd>
mov -0x30(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x30(%rbp),%rax
mov %edx,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11d3 <func0+0x4a>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov rax, [rbp+var_30]
mov dword ptr [rax], 0
mov rax, [rbp+var_30]
mov edx, [rax]
mov rax, [rbp+var_28]
mov [rax], edx
mov rax, [rbp+var_28]
mov edx, [rax]
mov rax, [rbp+var_20]
mov [rax], edx
mov [rbp+var_4], 0
jmp loc_126A
loc_11D3:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_4]
movsxd rcx, edx
mov rdx, [rbp+var_18]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 400h
test eax, eax
jz short loc_1215
mov rax, [rbp+var_20]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_20]
mov [rax], edx
jmp short loc_1266
loc_1215:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_4]
movsxd rcx, edx
mov rdx, [rbp+var_18]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 800h
test eax, eax
jz short loc_1257
mov rax, [rbp+var_28]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_28]
mov [rax], edx
jmp short loc_1266
loc_1257:
mov rax, [rbp+var_30]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_30]
mov [rax], edx
loc_1266:
add [rbp+var_4], 1
loc_126A:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_11D3
nop
nop
leave
retn | long long func0(long long a1, _DWORD *a2, _DWORD *a3, _DWORD *a4)
{
long long result; // rax
int i; // [rsp+2Ch] [rbp-4h]
*a4 = 0;
*a3 = *a4;
*a2 = *a3;
for ( i = 0; ; ++i )
{
result = *(unsigned __int8 *)(i + a1);
if ( !(_BYTE)result )
break;
if ( ((*__ctype_b_loc())[*(char *)(i + a1)] & 0x400) != 0 )
{
++*a2;
}
else if ( ((*__ctype_b_loc())[*(char *)(i + a1)] & 0x800) != 0 )
{
++*a3;
}
else
{
++*a4;
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],EDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010126a
LAB_001011d3:
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x400
TEST EAX,EAX
JZ 0x00101215
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],EDX
JMP 0x00101266
LAB_00101215:
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x800
TEST EAX,EAX
JZ 0x00101257
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],EDX
JMP 0x00101266
LAB_00101257:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],EDX
LAB_00101266:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010126a:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011d3
NOP
NOP
LEAVE
RET | void func0(long param_1,int *param_2,int *param_3,int *param_4)
{
ushort **ppuVar1;
int local_c;
*param_4 = 0;
*param_3 = *param_4;
*param_2 = *param_3;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[*(char *)(param_1 + local_c)] & 0x400) == 0) {
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[*(char *)(param_1 + local_c)] & 0x800) == 0) {
*param_4 = *param_4 + 1;
}
else {
*param_3 = *param_3 + 1;
}
}
else {
*param_2 = *param_2 + 1;
}
}
return;
} |
7,205 | func0 | #include <assert.h>
#include <ctype.h>
| void func0(const char* string, int* alphabets, int* digits, int* special) {
*alphabets = *digits = *special = 0;
for (int i = 0; string[i] != '\0'; i++) {
if (isalpha(string[i]))
(*alphabets)++;
else if (isdigit(string[i]))
(*digits)++;
else
(*special)++;
}
}
| int main() {
int alphabets, digits, special;
func0("abc!@#123", &alphabets, &digits, &special);
assert(alphabets == 3 && digits == 3 && special == 3);
func0("dgsuy@#$%&1255", &alphabets, &digits, &special);
assert(alphabets == 5 && digits == 4 && special == 5);
func0("fjdsif627348#%$^&", &alphabets, &digits, &special);
assert(alphabets == 6 && digits == 6 && special == 5);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
movl $0x0,(%rcx)
movl $0x0,(%rdx)
movl $0x0,(%rsi)
movzbl (%rdi),%ebx
test %bl,%bl
je 11f8 <func0+0x6f>
mov %rdi,%rbp
mov %rsi,%r12
mov %rdx,%r13
mov %rcx,%r14
callq 1090 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
jmp 11db <func0+0x52>
test $0x8,%dh
je 11f2 <func0+0x69>
addl $0x1,0x0(%r13)
add $0x1,%rdi
movzbl -0x1(%rdi),%ebx
test %bl,%bl
je 11f8 <func0+0x6f>
movsbq %bl,%rbx
mov (%rax),%rdx
movzwl (%rdx,%rbx,2),%edx
test $0x4,%dh
je 11c5 <func0+0x3c>
addl $0x1,(%r12)
jmp 11cf <func0+0x46>
addl $0x1,(%r14)
jmp 11cf <func0+0x46>
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov dword ptr [rcx], 0
mov dword ptr [rdx], 0
mov dword ptr [rsi], 0
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_11F8
mov rbp, rdi
mov r12, rsi
mov r13, rdx
mov r14, rcx
call ___ctype_b_loc
lea rdx, [rbp+1]
jmp short loc_11DB
loc_11C5:
test ch, 8
jz short loc_11F2
add dword ptr [r13+0], 1
loc_11CF:
add rdx, 1
movzx ebx, byte ptr [rdx-1]
test bl, bl
jz short loc_11F8
loc_11DB:
movsx rbx, bl
mov rcx, [rax]
movzx ecx, word ptr [rcx+rbx*2]
test ch, 4
jz short loc_11C5
add dword ptr [r12], 1
jmp short loc_11CF
loc_11F2:
add dword ptr [r14], 1
jmp short loc_11CF
loc_11F8:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | void func0(char *a1, _DWORD *a2, _DWORD *a3, _DWORD *a4)
{
char v4; // bl
_QWORD *v7; // rax
char *v8; // rdx
__int16 v9; // cx
*a4 = 0;
*a3 = 0;
*a2 = 0;
v4 = *a1;
if ( *a1 )
{
v7 = (_QWORD *)__ctype_b_loc();
v8 = a1 + 1;
do
{
v9 = *(_WORD *)(*v7 + 2LL * v4);
if ( (v9 & 0x400) != 0 )
{
++*a2;
}
else if ( (v9 & 0x800) != 0 )
{
++*a3;
}
else
{
++*a4;
}
v4 = *v8++;
}
while ( v4 );
}
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV dword ptr [RCX],0x0
MOV dword ptr [RDX],0x0
MOV dword ptr [RSI],0x0
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001011f8
MOV RBP,RDI
MOV R12,RSI
MOV R13,RDX
MOV R14,RCX
CALL 0x00101090
LEA RDX,[RBP + 0x1]
JMP 0x001011db
LAB_001011c5:
TEST CH,0x8
JZ 0x001011f2
ADD dword ptr [R13],0x1
LAB_001011cf:
ADD RDX,0x1
MOVZX EBX,byte ptr [RDX + -0x1]
TEST BL,BL
JZ 0x001011f8
LAB_001011db:
MOVSX RBX,BL
MOV RCX,qword ptr [RAX]
MOVZX ECX,word ptr [RCX + RBX*0x2]
TEST CH,0x4
JZ 0x001011c5
ADD dword ptr [R12],0x1
JMP 0x001011cf
LAB_001011f2:
ADD dword ptr [R14],0x1
JMP 0x001011cf
LAB_001011f8:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | void func0(char *param_1,int *param_2,int *param_3,int *param_4)
{
ushort **ppuVar1;
char *pcVar2;
char cVar3;
*param_4 = 0;
*param_3 = 0;
*param_2 = 0;
cVar3 = *param_1;
if (cVar3 != '\0') {
ppuVar1 = __ctype_b_loc();
pcVar2 = param_1 + 1;
do {
if (((*ppuVar1)[cVar3] & 0x400) == 0) {
if (((*ppuVar1)[cVar3] & 0x800) == 0) {
*param_4 = *param_4 + 1;
}
else {
*param_3 = *param_3 + 1;
}
}
else {
*param_2 = *param_2 + 1;
}
cVar3 = *pcVar2;
pcVar2 = pcVar2 + 1;
} while (cVar3 != '\0');
}
return;
} |
7,206 | func0 | #include <assert.h>
#include <ctype.h>
| void func0(const char* string, int* alphabets, int* digits, int* special) {
*alphabets = *digits = *special = 0;
for (int i = 0; string[i] != '\0'; i++) {
if (isalpha(string[i]))
(*alphabets)++;
else if (isdigit(string[i]))
(*digits)++;
else
(*special)++;
}
}
| int main() {
int alphabets, digits, special;
func0("abc!@#123", &alphabets, &digits, &special);
assert(alphabets == 3 && digits == 3 && special == 3);
func0("dgsuy@#$%&1255", &alphabets, &digits, &special);
assert(alphabets == 5 && digits == 4 && special == 5);
func0("fjdsif627348#%$^&", &alphabets, &digits, &special);
assert(alphabets == 6 && digits == 6 && special == 5);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
movl $0x0,(%rcx)
push %r13
movl $0x0,(%rdx)
push %r12
push %rbp
push %rbx
movl $0x0,(%rsi)
movsbq (%rdi),%rbx
test %bl,%bl
je 1341 <func0+0x71>
mov %rdi,%rbp
mov %rsi,%r12
mov %rdx,%r13
mov %rcx,%r14
callq 1090 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
mov (%rax),%rsi
jmp 1321 <func0+0x51>
addl $0x1,(%r12)
movsbq (%rdi),%rbx
add $0x1,%rdi
test %bl,%bl
je 1341 <func0+0x71>
movzwl (%rsi,%rbx,2),%eax
test $0x4,%ah
jne 1310 <func0+0x40>
test $0x8,%ah
je 1350 <func0+0x80>
add $0x1,%rdi
addl $0x1,0x0(%r13)
movsbq -0x1(%rdi),%rbx
test %bl,%bl
jne 1321 <func0+0x51>
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
addl $0x1,(%r14)
jmp 1315 <func0+0x45>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r14
mov dword ptr [rcx], 0
push r13
mov dword ptr [rdx], 0
push r12
push rbp
push rbx
mov dword ptr [rsi], 0
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1341
mov rbp, rdi
mov r12, rsi
mov r13, rdx
mov r14, rcx
call ___ctype_b_loc
lea rdi, [rbp+1]
mov rsi, [rax]
jmp short loc_1321
loc_1310:
add dword ptr [r12], 1
loc_1315:
movsx rbx, byte ptr [rdi]
add rdi, 1
test bl, bl
jz short loc_1341
loc_1321:
movzx eax, word ptr [rsi+rbx*2]
test ah, 4
jnz short loc_1310
test ah, 8
jz short loc_1350
add rdi, 1
add dword ptr [r13+0], 1
movsx rbx, byte ptr [rdi-1]
test bl, bl
jnz short loc_1321
loc_1341:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1350:
add dword ptr [r14], 1
jmp short loc_1315 | void func0(char *a1, _DWORD *a2, _DWORD *a3, _DWORD *a4)
{
long long v4; // rbx
char *v8; // rdi
long long v9; // rsi
__int16 v10; // ax
*a4 = 0;
*a3 = 0;
*a2 = 0;
v4 = *a1;
if ( (_BYTE)v4 )
{
v8 = a1 + 1;
v9 = *(_QWORD *)__ctype_b_loc();
do
{
while ( 1 )
{
v10 = *(_WORD *)(v9 + 2 * v4);
if ( (v10 & 0x400) == 0 )
break;
++*a2;
LABEL_4:
v4 = *v8++;
if ( !(_BYTE)v4 )
return;
}
if ( (v10 & 0x800) == 0 )
{
++*a4;
goto LABEL_4;
}
++v8;
++*a3;
v4 = *(v8 - 1);
}
while ( (_BYTE)v4 );
}
} | func0:
ENDBR64
PUSH R14
MOV dword ptr [RCX],0x0
PUSH R13
MOV dword ptr [RDX],0x0
PUSH R12
PUSH RBP
PUSH RBX
MOV dword ptr [RSI],0x0
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101341
MOV RBP,RDI
MOV R12,RSI
MOV R13,RDX
MOV R14,RCX
CALL 0x00101090
LEA RDI,[RBP + 0x1]
MOV RSI,qword ptr [RAX]
JMP 0x00101321
LAB_00101310:
ADD dword ptr [R12],0x1
LAB_00101315:
MOVSX RBX,byte ptr [RDI]
ADD RDI,0x1
TEST BL,BL
JZ 0x00101341
LAB_00101321:
MOVZX EAX,word ptr [RSI + RBX*0x2]
TEST AH,0x4
JNZ 0x00101310
TEST AH,0x8
JZ 0x00101350
ADD RDI,0x1
ADD dword ptr [R13],0x1
MOVSX RBX,byte ptr [RDI + -0x1]
TEST BL,BL
JNZ 0x00101321
LAB_00101341:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101350:
ADD dword ptr [R14],0x1
JMP 0x00101315 | void func0(char *param_1,int *param_2,int *param_3,int *param_4)
{
char cVar1;
ushort *puVar2;
ushort **ppuVar3;
long lVar4;
char *pcVar5;
*param_4 = 0;
*param_3 = 0;
*param_2 = 0;
lVar4 = (long)*param_1;
if (*param_1 != '\0') {
ppuVar3 = __ctype_b_loc();
puVar2 = *ppuVar3;
pcVar5 = param_1 + 1;
do {
while ((puVar2[lVar4] & 0x400) == 0) {
if ((puVar2[lVar4] & 0x800) == 0) {
*param_4 = *param_4 + 1;
goto LAB_00101315;
}
*param_3 = *param_3 + 1;
cVar1 = *pcVar5;
lVar4 = (long)cVar1;
pcVar5 = pcVar5 + 1;
if (cVar1 == '\0') {
return;
}
}
*param_2 = *param_2 + 1;
LAB_00101315:
cVar1 = *pcVar5;
lVar4 = (long)cVar1;
pcVar5 = pcVar5 + 1;
} while (cVar1 != '\0');
}
return;
} |
7,207 | func0 | #include <assert.h>
#include <ctype.h>
| void func0(const char* string, int* alphabets, int* digits, int* special) {
*alphabets = *digits = *special = 0;
for (int i = 0; string[i] != '\0'; i++) {
if (isalpha(string[i]))
(*alphabets)++;
else if (isdigit(string[i]))
(*digits)++;
else
(*special)++;
}
}
| int main() {
int alphabets, digits, special;
func0("abc!@#123", &alphabets, &digits, &special);
assert(alphabets == 3 && digits == 3 && special == 3);
func0("dgsuy@#$%&1255", &alphabets, &digits, &special);
assert(alphabets == 5 && digits == 4 && special == 5);
func0("fjdsif627348#%$^&", &alphabets, &digits, &special);
assert(alphabets == 6 && digits == 6 && special == 5);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
movl $0x0,(%rcx)
push %r13
movl $0x0,(%rdx)
push %r12
push %rbp
push %rbx
movl $0x0,(%rsi)
movsbq (%rdi),%rbx
test %bl,%bl
je 1341 <func0+0x71>
mov %rdi,%rbp
mov %rsi,%r12
mov %rdx,%r13
mov %rcx,%r14
callq 1090 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
mov (%rax),%rsi
jmp 1321 <func0+0x51>
addl $0x1,(%r12)
movsbq (%rdi),%rbx
add $0x1,%rdi
test %bl,%bl
je 1341 <func0+0x71>
movzwl (%rsi,%rbx,2),%eax
test $0x4,%ah
jne 1310 <func0+0x40>
test $0x8,%ah
je 1350 <func0+0x80>
add $0x1,%rdi
addl $0x1,0x0(%r13)
movsbq -0x1(%rdi),%rbx
test %bl,%bl
jne 1321 <func0+0x51>
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
addl $0x1,(%r14)
jmp 1315 <func0+0x45>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov dword ptr [rcx], 0
mov dword ptr [rdx], 0
mov dword ptr [rsi], 0
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1341
mov rbp, rdi
mov r12, rsi
mov r13, rdx
mov r14, rcx
call ___ctype_b_loc
lea rdi, [rbp+1]
mov rsi, [rax]
jmp short loc_1321
loc_1310:
add dword ptr [r12], 1
loc_1315:
movsx rbx, byte ptr [rdi]
add rdi, 1
test bl, bl
jz short loc_1341
loc_1321:
movzx eax, word ptr [rsi+rbx*2]
test ah, 4
jnz short loc_1310
test ah, 8
jz short loc_1350
add rdi, 1
add dword ptr [r13+0], 1
movsx rbx, byte ptr [rdi-1]
test bl, bl
jnz short loc_1321
loc_1341:
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1350:
add dword ptr [r14], 1
jmp short loc_1315 | void func0(char *a1, _DWORD *a2, _DWORD *a3, _DWORD *a4)
{
long long v4; // rbx
char *v8; // rdi
const unsigned __int16 *v9; // rsi
unsigned __int16 v10; // ax
*a4 = 0;
*a3 = 0;
*a2 = 0;
v4 = *a1;
if ( (_BYTE)v4 )
{
v8 = a1 + 1;
v9 = *__ctype_b_loc();
do
{
while ( 1 )
{
v10 = v9[v4];
if ( (v10 & 0x400) == 0 )
break;
++*a2;
LABEL_4:
v4 = *v8++;
if ( !(_BYTE)v4 )
return;
}
if ( (v10 & 0x800) == 0 )
{
++*a4;
goto LABEL_4;
}
++v8;
++*a3;
v4 = *(v8 - 1);
}
while ( (_BYTE)v4 );
}
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV dword ptr [RCX],0x0
MOV dword ptr [RDX],0x0
MOV dword ptr [RSI],0x0
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101341
MOV RBP,RDI
MOV R12,RSI
MOV R13,RDX
MOV R14,RCX
CALL 0x00101090
LEA RDI,[RBP + 0x1]
MOV RSI,qword ptr [RAX]
JMP 0x00101321
LAB_00101310:
ADD dword ptr [R12],0x1
LAB_00101315:
MOVSX RBX,byte ptr [RDI]
ADD RDI,0x1
TEST BL,BL
JZ 0x00101341
LAB_00101321:
MOVZX EAX,word ptr [RSI + RBX*0x2]
TEST AH,0x4
JNZ 0x00101310
TEST AH,0x8
JZ 0x00101350
ADD RDI,0x1
ADD dword ptr [R13],0x1
MOVSX RBX,byte ptr [RDI + -0x1]
TEST BL,BL
JNZ 0x00101321
LAB_00101341:
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101350:
ADD dword ptr [R14],0x1
JMP 0x00101315 | void func0(char *param_1,int *param_2,int *param_3,int *param_4)
{
char cVar1;
ushort *puVar2;
ushort **ppuVar3;
long lVar4;
char *pcVar5;
*param_4 = 0;
*param_3 = 0;
*param_2 = 0;
lVar4 = (long)*param_1;
if (*param_1 != '\0') {
ppuVar3 = __ctype_b_loc();
puVar2 = *ppuVar3;
pcVar5 = param_1 + 1;
do {
while ((puVar2[lVar4] & 0x400) == 0) {
if ((puVar2[lVar4] & 0x800) == 0) {
*param_4 = *param_4 + 1;
goto LAB_00101315;
}
*param_3 = *param_3 + 1;
cVar1 = *pcVar5;
lVar4 = (long)cVar1;
pcVar5 = pcVar5 + 1;
if (cVar1 == '\0') {
return;
}
}
*param_2 = *param_2 + 1;
LAB_00101315:
cVar1 = *pcVar5;
lVar4 = (long)cVar1;
pcVar5 = pcVar5 + 1;
} while (cVar1 != '\0');
}
return;
} |
7,208 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
| char* func0(char* input[], int size) {
int count[100] = {0};
char* unique[100];
int unique_count = 0;
for(int i = 0; i < size; i++) {
int found = 0;
for(int j = 0; j < unique_count; j++) {
if(strcmp(input[i], unique[j]) == 0) {
count[j]++;
found = 1;
break;
}
}
if(!found) {
unique[unique_count] = input[i];
count[unique_count] = 1;
unique_count++;
}
}
// Find the second largest count
int first = 0, second = 0;
for(int i = 0; i < unique_count; i++) {
if(count[i] > first) {
second = first;
first = count[i];
}
else if(count[i] > second && count[i] < first) {
second = count[i];
}
}
// Find the string with the second largest count
for(int i = 0; i < unique_count; i++) {
if(count[i] == second) {
return unique[i];
}
}
return NULL;
}
| int main() {
char* arr1[] = {"aaa","bbb","ccc","bbb","aaa","aaa"};
assert(strcmp(func0(arr1, 6), "bbb") == 0);
char* arr2[] = {"abc","bcd","abc","bcd","bcd","bcd"};
assert(strcmp(func0(arr2, 6), "abc") == 0);
char* arr3[] = {"cdma","gsm","hspa","gsm","cdma","cdma"};
assert(strcmp(func0(arr3, 6), "gsm") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x4f0,%rsp
mov %rdi,-0x4e8(%rbp)
mov %esi,-0x4ec(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x4c0(%rbp),%rdx
mov $0x0,%eax
mov $0x32,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0x4e0(%rbp)
movl $0x0,-0x4dc(%rbp)
jmpq 12cf <func0+0x146>
movl $0x0,-0x4d8(%rbp)
movl $0x0,-0x4d4(%rbp)
jmp 126a <func0+0xe1>
mov -0x4d4(%rbp),%eax
cltq
mov -0x330(%rbp,%rax,8),%rdx
mov -0x4dc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x4e8(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
jne 1263 <func0+0xda>
mov -0x4d4(%rbp),%eax
cltq
mov -0x4c0(%rbp,%rax,4),%eax
lea 0x1(%rax),%edx
mov -0x4d4(%rbp),%eax
cltq
mov %edx,-0x4c0(%rbp,%rax,4)
movl $0x1,-0x4d8(%rbp)
jmp 1278 <func0+0xef>
addl $0x1,-0x4d4(%rbp)
mov -0x4d4(%rbp),%eax
cmp -0x4e0(%rbp),%eax
jl 11fa <func0+0x71>
cmpl $0x0,-0x4d8(%rbp)
jne 12c8 <func0+0x13f>
mov -0x4dc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x4e8(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x4e0(%rbp),%eax
cltq
mov %rdx,-0x330(%rbp,%rax,8)
mov -0x4e0(%rbp),%eax
cltq
movl $0x1,-0x4c0(%rbp,%rax,4)
addl $0x1,-0x4e0(%rbp)
addl $0x1,-0x4dc(%rbp)
mov -0x4dc(%rbp),%eax
cmp -0x4ec(%rbp),%eax
jl 11e4 <func0+0x5b>
movl $0x0,-0x4d0(%rbp)
movl $0x0,-0x4cc(%rbp)
movl $0x0,-0x4c8(%rbp)
jmpq 1388 <func0+0x1ff>
mov -0x4c8(%rbp),%eax
cltq
mov -0x4c0(%rbp,%rax,4),%eax
cmp %eax,-0x4d0(%rbp)
jge 133e <func0+0x1b5>
mov -0x4d0(%rbp),%eax
mov %eax,-0x4cc(%rbp)
mov -0x4c8(%rbp),%eax
cltq
mov -0x4c0(%rbp,%rax,4),%eax
mov %eax,-0x4d0(%rbp)
jmp 1381 <func0+0x1f8>
mov -0x4c8(%rbp),%eax
cltq
mov -0x4c0(%rbp,%rax,4),%eax
cmp %eax,-0x4cc(%rbp)
jge 1381 <func0+0x1f8>
mov -0x4c8(%rbp),%eax
cltq
mov -0x4c0(%rbp,%rax,4),%eax
cmp %eax,-0x4d0(%rbp)
jle 1381 <func0+0x1f8>
mov -0x4c8(%rbp),%eax
cltq
mov -0x4c0(%rbp,%rax,4),%eax
mov %eax,-0x4cc(%rbp)
addl $0x1,-0x4c8(%rbp)
mov -0x4c8(%rbp),%eax
cmp -0x4e0(%rbp),%eax
jl 1304 <func0+0x17b>
movl $0x0,-0x4c4(%rbp)
jmp 13d6 <func0+0x24d>
mov -0x4c4(%rbp),%eax
cltq
mov -0x4c0(%rbp,%rax,4),%eax
cmp %eax,-0x4cc(%rbp)
jne 13cf <func0+0x246>
mov -0x4c4(%rbp),%eax
cltq
mov -0x330(%rbp,%rax,8),%rax
jmp 13e9 <func0+0x260>
addl $0x1,-0x4c4(%rbp)
mov -0x4c4(%rbp),%eax
cmp -0x4e0(%rbp),%eax
jl 13a6 <func0+0x21d>
mov $0x0,%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 13fd <func0+0x274>
callq 1070 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 4F0h
mov [rbp+var_4E8], rdi
mov [rbp+var_4EC], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_4C0]
mov eax, 0
mov ecx, 32h ; '2'
mov rdi, rdx
rep stosq
mov [rbp+var_4E0], 0
mov [rbp+var_4DC], 0
jmp loc_12CF
loc_11E4:
mov [rbp+var_4D8], 0
mov [rbp+var_4D4], 0
jmp short loc_126A
loc_11FA:
mov eax, [rbp+var_4D4]
cdqe
mov rdx, [rbp+rax*8+s2]
mov eax, [rbp+var_4DC]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_4E8]
add rax, rcx
mov rax, [rax]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_1263
mov eax, [rbp+var_4D4]
cdqe
mov eax, [rbp+rax*4+var_4C0]
lea edx, [rax+1]
mov eax, [rbp+var_4D4]
cdqe
mov [rbp+rax*4+var_4C0], edx
mov [rbp+var_4D8], 1
jmp short loc_1278
loc_1263:
add [rbp+var_4D4], 1
loc_126A:
mov eax, [rbp+var_4D4]
cmp eax, [rbp+var_4E0]
jl short loc_11FA
loc_1278:
cmp [rbp+var_4D8], 0
jnz short loc_12C8
mov eax, [rbp+var_4DC]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_4E8]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_4E0]
cdqe
mov [rbp+rax*8+s2], rdx
mov eax, [rbp+var_4E0]
cdqe
mov [rbp+rax*4+var_4C0], 1
add [rbp+var_4E0], 1
loc_12C8:
add [rbp+var_4DC], 1
loc_12CF:
mov eax, [rbp+var_4DC]
cmp eax, [rbp+var_4EC]
jl loc_11E4
mov [rbp+var_4D0], 0
mov [rbp+var_4CC], 0
mov [rbp+var_4C8], 0
jmp loc_1388
loc_1304:
mov eax, [rbp+var_4C8]
cdqe
mov eax, [rbp+rax*4+var_4C0]
cmp [rbp+var_4D0], eax
jge short loc_133E
mov eax, [rbp+var_4D0]
mov [rbp+var_4CC], eax
mov eax, [rbp+var_4C8]
cdqe
mov eax, [rbp+rax*4+var_4C0]
mov [rbp+var_4D0], eax
jmp short loc_1381
loc_133E:
mov eax, [rbp+var_4C8]
cdqe
mov eax, [rbp+rax*4+var_4C0]
cmp [rbp+var_4CC], eax
jge short loc_1381
mov eax, [rbp+var_4C8]
cdqe
mov eax, [rbp+rax*4+var_4C0]
cmp [rbp+var_4D0], eax
jle short loc_1381
mov eax, [rbp+var_4C8]
cdqe
mov eax, [rbp+rax*4+var_4C0]
mov [rbp+var_4CC], eax
loc_1381:
add [rbp+var_4C8], 1
loc_1388:
mov eax, [rbp+var_4C8]
cmp eax, [rbp+var_4E0]
jl loc_1304
mov [rbp+var_4C4], 0
jmp short loc_13D6
loc_13A6:
mov eax, [rbp+var_4C4]
cdqe
mov eax, [rbp+rax*4+var_4C0]
cmp [rbp+var_4CC], eax
jnz short loc_13CF
mov eax, [rbp+var_4C4]
cdqe
mov rax, [rbp+rax*8+s2]
jmp short loc_13E9
loc_13CF:
add [rbp+var_4C4], 1
loc_13D6:
mov eax, [rbp+var_4C4]
cmp eax, [rbp+var_4E0]
jl short loc_13A6
mov eax, 0
loc_13E9:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_13FD
call ___stack_chk_fail
locret_13FD:
leave
retn | char * func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-4E0h]
int i; // [rsp+14h] [rbp-4DCh]
int v5; // [rsp+18h] [rbp-4D8h]
int j; // [rsp+1Ch] [rbp-4D4h]
int v7; // [rsp+20h] [rbp-4D0h]
int v8; // [rsp+24h] [rbp-4CCh]
int k; // [rsp+28h] [rbp-4C8h]
int m; // [rsp+2Ch] [rbp-4C4h]
_DWORD v11[100]; // [rsp+30h] [rbp-4C0h] BYREF
char *s2[102]; // [rsp+1C0h] [rbp-330h]
s2[101] = (char *)__readfsqword(0x28u);
memset(v11, 0, sizeof(v11));
v3 = 0;
for ( i = 0; i < a2; ++i )
{
v5 = 0;
for ( j = 0; j < v3; ++j )
{
if ( !strcmp(*(const char **)(8LL * i + a1), s2[j]) )
{
++v11[j];
v5 = 1;
break;
}
}
if ( !v5 )
{
s2[v3] = *(char **)(8LL * i + a1);
v11[v3++] = 1;
}
}
v7 = 0;
v8 = 0;
for ( k = 0; k < v3; ++k )
{
if ( v7 >= v11[k] )
{
if ( v8 < v11[k] && v7 > v11[k] )
v8 = v11[k];
}
else
{
v8 = v7;
v7 = v11[k];
}
}
for ( m = 0; m < v3; ++m )
{
if ( v8 == v11[m] )
return s2[m];
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x4f0
MOV qword ptr [RBP + -0x4e8],RDI
MOV dword ptr [RBP + -0x4ec],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0x4c0]
MOV EAX,0x0
MOV ECX,0x32
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x4e0],0x0
MOV dword ptr [RBP + -0x4dc],0x0
JMP 0x001012cf
LAB_001011e4:
MOV dword ptr [RBP + -0x4d8],0x0
MOV dword ptr [RBP + -0x4d4],0x0
JMP 0x0010126a
LAB_001011fa:
MOV EAX,dword ptr [RBP + -0x4d4]
CDQE
MOV RDX,qword ptr [RBP + RAX*0x8 + -0x330]
MOV EAX,dword ptr [RBP + -0x4dc]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x4e8]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101090
TEST EAX,EAX
JNZ 0x00101263
MOV EAX,dword ptr [RBP + -0x4d4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x4c0]
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x4d4]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x4c0],EDX
MOV dword ptr [RBP + -0x4d8],0x1
JMP 0x00101278
LAB_00101263:
ADD dword ptr [RBP + -0x4d4],0x1
LAB_0010126a:
MOV EAX,dword ptr [RBP + -0x4d4]
CMP EAX,dword ptr [RBP + -0x4e0]
JL 0x001011fa
LAB_00101278:
CMP dword ptr [RBP + -0x4d8],0x0
JNZ 0x001012c8
MOV EAX,dword ptr [RBP + -0x4dc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x4e8]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4e0]
CDQE
MOV qword ptr [RBP + RAX*0x8 + -0x330],RDX
MOV EAX,dword ptr [RBP + -0x4e0]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x4c0],0x1
ADD dword ptr [RBP + -0x4e0],0x1
LAB_001012c8:
ADD dword ptr [RBP + -0x4dc],0x1
LAB_001012cf:
MOV EAX,dword ptr [RBP + -0x4dc]
CMP EAX,dword ptr [RBP + -0x4ec]
JL 0x001011e4
MOV dword ptr [RBP + -0x4d0],0x0
MOV dword ptr [RBP + -0x4cc],0x0
MOV dword ptr [RBP + -0x4c8],0x0
JMP 0x00101388
LAB_00101304:
MOV EAX,dword ptr [RBP + -0x4c8]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x4c0]
CMP dword ptr [RBP + -0x4d0],EAX
JGE 0x0010133e
MOV EAX,dword ptr [RBP + -0x4d0]
MOV dword ptr [RBP + -0x4cc],EAX
MOV EAX,dword ptr [RBP + -0x4c8]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x4c0]
MOV dword ptr [RBP + -0x4d0],EAX
JMP 0x00101381
LAB_0010133e:
MOV EAX,dword ptr [RBP + -0x4c8]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x4c0]
CMP dword ptr [RBP + -0x4cc],EAX
JGE 0x00101381
MOV EAX,dword ptr [RBP + -0x4c8]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x4c0]
CMP dword ptr [RBP + -0x4d0],EAX
JLE 0x00101381
MOV EAX,dword ptr [RBP + -0x4c8]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x4c0]
MOV dword ptr [RBP + -0x4cc],EAX
LAB_00101381:
ADD dword ptr [RBP + -0x4c8],0x1
LAB_00101388:
MOV EAX,dword ptr [RBP + -0x4c8]
CMP EAX,dword ptr [RBP + -0x4e0]
JL 0x00101304
MOV dword ptr [RBP + -0x4c4],0x0
JMP 0x001013d6
LAB_001013a6:
MOV EAX,dword ptr [RBP + -0x4c4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x4c0]
CMP dword ptr [RBP + -0x4cc],EAX
JNZ 0x001013cf
MOV EAX,dword ptr [RBP + -0x4c4]
CDQE
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x330]
JMP 0x001013e9
LAB_001013cf:
ADD dword ptr [RBP + -0x4c4],0x1
LAB_001013d6:
MOV EAX,dword ptr [RBP + -0x4c4]
CMP EAX,dword ptr [RBP + -0x4e0]
JL 0x001013a6
MOV EAX,0x0
LAB_001013e9:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001013fd
CALL 0x00101070
LAB_001013fd:
LEAVE
RET | int8 func0(long param_1,int param_2)
{
bool bVar1;
int iVar2;
int8 uVar3;
long lVar4;
int *piVar5;
long in_FS_OFFSET;
int local_4e8;
int local_4e4;
int local_4dc;
int local_4d8;
int local_4d4;
int local_4d0;
int local_4cc;
int local_4c8 [100];
int8 auStack_338 [101];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar5 = local_4c8;
for (lVar4 = 0x32; lVar4 != 0; lVar4 = lVar4 + -1) {
piVar5[0] = 0;
piVar5[1] = 0;
piVar5 = piVar5 + 2;
}
local_4e8 = 0;
for (local_4e4 = 0; local_4e4 < param_2; local_4e4 = local_4e4 + 1) {
bVar1 = false;
for (local_4dc = 0; local_4dc < local_4e8; local_4dc = local_4dc + 1) {
iVar2 = strcmp(*(char **)(param_1 + (long)local_4e4 * 8),(char *)auStack_338[local_4dc]);
if (iVar2 == 0) {
local_4c8[local_4dc] = local_4c8[local_4dc] + 1;
bVar1 = true;
break;
}
}
if (!bVar1) {
auStack_338[local_4e8] = *(int8 *)(param_1 + (long)local_4e4 * 8);
local_4c8[local_4e8] = 1;
local_4e8 = local_4e8 + 1;
}
}
local_4d8 = 0;
local_4d4 = 0;
for (local_4d0 = 0; local_4d0 < local_4e8; local_4d0 = local_4d0 + 1) {
if (local_4d8 < local_4c8[local_4d0]) {
local_4d4 = local_4d8;
local_4d8 = local_4c8[local_4d0];
}
else if ((local_4d4 < local_4c8[local_4d0]) && (local_4c8[local_4d0] < local_4d8)) {
local_4d4 = local_4c8[local_4d0];
}
}
local_4cc = 0;
do {
if (local_4e8 <= local_4cc) {
uVar3 = 0;
LAB_001013e9:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
}
if (local_4d4 == local_4c8[local_4cc]) {
uVar3 = auStack_338[local_4cc];
goto LAB_001013e9;
}
local_4cc = local_4cc + 1;
} while( true );
} |
7,209 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
| char* func0(char* input[], int size) {
int count[100] = {0};
char* unique[100];
int unique_count = 0;
for(int i = 0; i < size; i++) {
int found = 0;
for(int j = 0; j < unique_count; j++) {
if(strcmp(input[i], unique[j]) == 0) {
count[j]++;
found = 1;
break;
}
}
if(!found) {
unique[unique_count] = input[i];
count[unique_count] = 1;
unique_count++;
}
}
// Find the second largest count
int first = 0, second = 0;
for(int i = 0; i < unique_count; i++) {
if(count[i] > first) {
second = first;
first = count[i];
}
else if(count[i] > second && count[i] < first) {
second = count[i];
}
}
// Find the string with the second largest count
for(int i = 0; i < unique_count; i++) {
if(count[i] == second) {
return unique[i];
}
}
return NULL;
}
| int main() {
char* arr1[] = {"aaa","bbb","ccc","bbb","aaa","aaa"};
assert(strcmp(func0(arr1, 6), "bbb") == 0);
char* arr2[] = {"abc","bcd","abc","bcd","bcd","bcd"};
assert(strcmp(func0(arr2, 6), "abc") == 0);
char* arr3[] = {"cdma","gsm","hspa","gsm","cdma","cdma"};
assert(strcmp(func0(arr3, 6), "gsm") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x4d8,%rsp
mov %rdi,%rdx
mov %fs:0x28,%rax
mov %rax,0x4c8(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rdi
mov $0x32,%ecx
rep stos %rax,%es:(%rdi)
test %esi,%esi
jle 12d6 <func0+0x14d>
mov %rdx,%r14
lea -0x1(%rsi),%eax
lea 0x8(%rdx,%rax,8),%rax
mov %rax,0x8(%rsp)
mov $0x0,%r15d
jmp 1226 <func0+0x9d>
mov %rax,%rbx
mov 0x1a0(%rsp,%rbx,8),%rsi
mov %r12,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
je 1239 <func0+0xb0>
lea 0x1(%rbx),%rax
cmp %r13,%rbx
jne 11e1 <func0+0x58>
movslq %r15d,%rax
mov (%r14),%rdx
mov %rdx,0x1a0(%rsp,%rax,8)
movl $0x1,0x10(%rsp,%rax,4)
add $0x1,%r15d
add $0x8,%r14
cmp 0x8(%rsp),%r14
je 1243 <func0+0xba>
test %r15d,%r15d
jle 1201 <func0+0x78>
mov (%r14),%r12
lea -0x1(%r15),%r13d
mov $0x0,%ebx
jmp 11e4 <func0+0x5b>
movslq %ebx,%rbp
addl $0x1,0x10(%rsp,%rbp,4)
jmp 121b <func0+0x92>
test %r15d,%r15d
jle 12d6 <func0+0x14d>
lea 0x10(%rsp),%rax
lea -0x1(%r15),%edi
lea 0x14(%rsp,%rdi,4),%r8
mov $0x0,%ecx
mov $0x0,%esi
jmp 1273 <func0+0xea>
mov %esi,%ecx
mov %edx,%esi
add $0x4,%rax
cmp %r8,%rax
je 1282 <func0+0xf9>
mov (%rax),%edx
cmp %esi,%edx
jg 1266 <func0+0xdd>
jge 126a <func0+0xe1>
cmp %ecx,%edx
cmovg %edx,%ecx
jmp 126a <func0+0xe1>
mov $0x0,%eax
lea 0x10(%rsp),%rsi
jmp 1291 <func0+0x108>
mov %rdx,%rax
cmp %ecx,(%rsi,%rax,4)
je 12a6 <func0+0x11d>
lea 0x1(%rax),%rdx
cmp %rdi,%rax
jne 128e <func0+0x105>
mov $0x0,%eax
jmp 12b1 <func0+0x128>
movslq %eax,%rdx
mov 0x1a0(%rsp,%rdx,8),%rax
mov 0x4c8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 12dd <func0+0x154>
add $0x4d8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x0,%eax
jmp 12b1 <func0+0x128>
callq 1070 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 4D8h
mov rdx, rdi
mov rax, fs:28h
mov [rsp+508h+var_40], rax
xor eax, eax
lea rdi, [rsp+508h+var_4F8]
mov ecx, 32h ; '2'
rep stosq
test esi, esi
jle loc_12D9
mov r14, rdx
lea eax, [rsi-1]
lea rax, [rdx+rax*8+8]
mov [rsp+508h+var_500], rax
mov r15d, 0
jmp short loc_1210
loc_11E1:
movsxd rbp, ebx
add [rsp+rbp*4+508h+var_4F8], 1
jmp short loc_1205
loc_11EB:
movsxd rax, r15d
mov rdx, [r14]
mov [rsp+rax*8+508h+var_368], rdx
mov [rsp+rax*4+508h+var_4F8], 1
add r15d, 1
loc_1205:
add r14, 8
cmp r14, [rsp+508h+var_500]
jz short loc_123F
loc_1210:
test r15d, r15d
jle short loc_11EB
mov r12, [r14]
mov r13d, r15d
mov ebx, 0
loc_1220:
mov rsi, [rsp+rbx*8+508h+var_368]
mov rdi, r12
call _strcmp
test eax, eax
jz short loc_11E1
add rbx, 1
cmp rbx, r13
jnz short loc_1220
jmp short loc_11EB
loc_123F:
test r15d, r15d
jle loc_12D9
lea rcx, [rsp+508h+var_4F8]
mov edi, r15d
lea eax, [r15-1]
lea r8, [rsp+rax*4+508h+var_4F4]
mov edx, 0
mov esi, 0
jmp short loc_1272
loc_1265:
mov edx, esi
mov esi, eax
loc_1269:
add rcx, 4
cmp rcx, r8
jz short loc_1288
loc_1272:
mov eax, [rcx]
cmp eax, esi
jg short loc_1265
mov r9d, edx
cmp eax, edx
cmovge edx, eax
cmp eax, esi
cmovge edx, r9d
jmp short loc_1269
loc_1288:
mov ecx, edi
mov eax, 0
lea rdi, [rsp+508h+var_4F8]
loc_1294:
cmp [rdi+rax*4], edx
jz short loc_12A9
add rax, 1
cmp rax, rcx
jnz short loc_1294
mov eax, 0
jmp short loc_12B4
loc_12A9:
movsxd rsi, eax
mov rax, [rsp+rsi*8+508h+var_368]
loc_12B4:
mov rdx, [rsp+508h+var_40]
sub rdx, fs:28h
jnz short loc_12E0
add rsp, 4D8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12D9:
mov eax, 0
jmp short loc_12B4
loc_12E0:
call ___stack_chk_fail | long long func0(_QWORD *a1, int a2)
{
_QWORD *v2; // r14
int v3; // r15d
long long v4; // r12
long long v5; // rbx
int *v6; // rcx
int v7; // edx
int v8; // esi
int v9; // eax
int v10; // r9d
long long v11; // rax
_DWORD v13[302]; // [rsp+10h] [rbp-4F8h] BYREF
unsigned long long v14; // [rsp+4C8h] [rbp-40h]
v14 = __readfsqword(0x28u);
memset(v13, 0, 0x190uLL);
if ( a2 <= 0 )
return 0LL;
v2 = a1;
v3 = 0;
do
{
if ( v3 <= 0 )
{
LABEL_4:
*(_QWORD *)&v13[2 * v3 + 100] = *v2;
v13[v3++] = 1;
}
else
{
v4 = *v2;
v5 = 0LL;
while ( (unsigned int)strcmp(v4, *(_QWORD *)&v13[2 * v5 + 100]) )
{
if ( ++v5 == v3 )
goto LABEL_4;
}
++v13[(int)v5];
}
++v2;
}
while ( v2 != &a1[(unsigned int)(a2 - 1) + 1] );
if ( v3 <= 0 )
return 0LL;
v6 = v13;
v7 = 0;
v8 = 0;
do
{
v9 = *v6;
if ( *v6 > v8 )
{
v7 = v8;
v8 = *v6;
}
else
{
v10 = v7;
if ( v9 >= v7 )
v7 = *v6;
if ( v9 >= v8 )
v7 = v10;
}
++v6;
}
while ( v6 != &v13[v3 - 1 + 1] );
v11 = 0LL;
while ( v13[v11] != v7 )
{
if ( ++v11 == v3 )
return 0LL;
}
return *(_QWORD *)&v13[2 * (int)v11 + 100];
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x4d8
MOV RDX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x4c8],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x10]
MOV ECX,0x32
STOSQ.REP RDI
TEST ESI,ESI
JLE 0x001012d9
MOV R14,RDX
LEA EAX,[RSI + -0x1]
LEA RAX,[RDX + RAX*0x8 + 0x8]
MOV qword ptr [RSP + 0x8],RAX
MOV R15D,0x0
JMP 0x00101210
LAB_001011e1:
MOVSXD RBP,EBX
ADD dword ptr [RSP + RBP*0x4 + 0x10],0x1
JMP 0x00101205
LAB_001011eb:
MOVSXD RAX,R15D
MOV RDX,qword ptr [R14]
MOV qword ptr [RSP + RAX*0x8 + 0x1a0],RDX
MOV dword ptr [RSP + RAX*0x4 + 0x10],0x1
ADD R15D,0x1
LAB_00101205:
ADD R14,0x8
CMP R14,qword ptr [RSP + 0x8]
JZ 0x0010123f
LAB_00101210:
TEST R15D,R15D
JLE 0x001011eb
MOV R12,qword ptr [R14]
MOV R13D,R15D
MOV EBX,0x0
LAB_00101220:
MOV RSI,qword ptr [RSP + RBX*0x8 + 0x1a0]
MOV RDI,R12
CALL 0x00101090
TEST EAX,EAX
JZ 0x001011e1
ADD RBX,0x1
CMP RBX,R13
JNZ 0x00101220
JMP 0x001011eb
LAB_0010123f:
TEST R15D,R15D
JLE 0x001012d9
LEA RCX,[RSP + 0x10]
MOV EDI,R15D
LEA EAX,[R15 + -0x1]
LEA R8,[RSP + RAX*0x4 + 0x14]
MOV EDX,0x0
MOV ESI,0x0
JMP 0x00101272
LAB_00101265:
MOV EDX,ESI
MOV ESI,EAX
LAB_00101269:
ADD RCX,0x4
CMP RCX,R8
JZ 0x00101288
LAB_00101272:
MOV EAX,dword ptr [RCX]
CMP EAX,ESI
JG 0x00101265
MOV R9D,EDX
CMP EAX,EDX
CMOVGE EDX,EAX
CMP EAX,ESI
CMOVGE EDX,R9D
JMP 0x00101269
LAB_00101288:
MOV ECX,EDI
MOV EAX,0x0
LEA RDI,[RSP + 0x10]
LAB_00101294:
CMP dword ptr [RDI + RAX*0x4],EDX
JZ 0x001012a9
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101294
MOV EAX,0x0
JMP 0x001012b4
LAB_001012a9:
MOVSXD RSI,EAX
MOV RAX,qword ptr [RSP + RSI*0x8 + 0x1a0]
LAB_001012b4:
MOV RDX,qword ptr [RSP + 0x4c8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012e0
ADD RSP,0x4d8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001012d9:
MOV EAX,0x0
JMP 0x001012b4
LAB_001012e0:
CALL 0x00101070 | int8 func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
char *__s1;
int iVar3;
int8 uVar4;
long lVar5;
int *piVar6;
int iVar7;
int iVar8;
ulong uVar9;
int iVar10;
uint uVar11;
long in_FS_OFFSET;
int local_4f8 [100];
int8 auStack_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
piVar6 = local_4f8;
for (lVar5 = 0x32; lVar5 != 0; lVar5 = lVar5 + -1) {
piVar6[0] = 0;
piVar6[1] = 0;
piVar6 = piVar6 + 2;
}
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar11 = 0;
do {
if (0 < (int)uVar11) {
__s1 = (char *)*param_1;
uVar9 = 0;
do {
iVar3 = strcmp(__s1,(char *)auStack_368[uVar9]);
if (iVar3 == 0) {
local_4f8[(int)uVar9] = local_4f8[(int)uVar9] + 1;
goto LAB_00101205;
}
uVar9 = uVar9 + 1;
} while (uVar9 != uVar11);
}
auStack_368[(int)uVar11] = *param_1;
local_4f8[(int)uVar11] = 1;
uVar11 = uVar11 + 1;
LAB_00101205:
param_1 = param_1 + 1;
} while (param_1 != puVar1);
if (0 < (int)uVar11) {
piVar6 = local_4f8;
iVar3 = 0;
iVar8 = 0;
do {
iVar2 = *piVar6;
iVar10 = iVar2;
iVar7 = iVar3;
if (iVar2 <= iVar3) {
iVar7 = iVar8;
if (iVar8 <= iVar2) {
iVar7 = iVar2;
}
iVar10 = iVar3;
if (iVar3 <= iVar2) {
iVar7 = iVar8;
}
}
piVar6 = piVar6 + 1;
iVar3 = iVar10;
iVar8 = iVar7;
} while (piVar6 != local_4f8 + (ulong)(uVar11 - 1) + 1);
uVar9 = 0;
do {
if (local_4f8[uVar9] == iVar7) {
uVar4 = auStack_368[(int)uVar9];
goto LAB_001012b4;
}
uVar9 = uVar9 + 1;
} while (uVar9 != uVar11);
uVar4 = 0;
goto LAB_001012b4;
}
}
uVar4 = 0;
LAB_001012b4:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar4;
} |
7,210 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
| char* func0(char* input[], int size) {
int count[100] = {0};
char* unique[100];
int unique_count = 0;
for(int i = 0; i < size; i++) {
int found = 0;
for(int j = 0; j < unique_count; j++) {
if(strcmp(input[i], unique[j]) == 0) {
count[j]++;
found = 1;
break;
}
}
if(!found) {
unique[unique_count] = input[i];
count[unique_count] = 1;
unique_count++;
}
}
// Find the second largest count
int first = 0, second = 0;
for(int i = 0; i < unique_count; i++) {
if(count[i] > first) {
second = first;
first = count[i];
}
else if(count[i] > second && count[i] < first) {
second = count[i];
}
}
// Find the string with the second largest count
for(int i = 0; i < unique_count; i++) {
if(count[i] == second) {
return unique[i];
}
}
return NULL;
}
| int main() {
char* arr1[] = {"aaa","bbb","ccc","bbb","aaa","aaa"};
assert(strcmp(func0(arr1, 6), "bbb") == 0);
char* arr2[] = {"abc","bcd","abc","bcd","bcd","bcd"};
assert(strcmp(func0(arr2, 6), "abc") == 0);
char* arr3[] = {"cdma","gsm","hspa","gsm","cdma","cdma"};
assert(strcmp(func0(arr3, 6), "gsm") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
mov $0x32,%ecx
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x4e8,%rsp
mov %fs:0x28,%rax
mov %rax,0x4d8(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rdi
mov %rdi,0x10(%rsp)
rep stos %rax,%es:(%rdi)
test %esi,%esi
jle 148c <func0+0x14c>
lea -0x1(%rsi),%eax
movl $0x0,0xc(%rsp)
lea 0x8(%r13,%rax,8),%rax
mov %rax,0x18(%rsp)
nopw 0x0(%rax,%rax,1)
mov 0xc(%rsp),%eax
mov 0x0(%r13),%rbp
test %eax,%eax
je 1468 <func0+0x128>
mov 0xc(%rsp),%eax
xor %r14d,%r14d
lea 0x1b0(%rsp),%r15
lea -0x1(%rax),%r12d
jmp 13d8 <func0+0x98>
nopl (%rax)
lea 0x1(%r14),%rax
cmp %r12,%r14
je 1468 <func0+0x128>
mov %rax,%r14
mov (%r15,%r14,8),%rsi
mov %rbp,%rdi
movslq %r14d,%rbx
callq 1090 <strcmp@plt>
test %eax,%eax
jne 13c8 <func0+0x88>
addl $0x1,0x20(%rsp,%rbx,4)
add $0x8,%r13
cmp 0x18(%rsp),%r13
jne 13a0 <func0+0x60>
mov 0xc(%rsp),%edx
mov 0x10(%rsp),%rax
xor %ecx,%ecx
xor %esi,%esi
lea -0x1(%rdx),%edi
lea 0x24(%rsp,%rdi,4),%r8
jmp 1428 <func0+0xe8>
nopw 0x0(%rax,%rax,1)
jge 141f <func0+0xdf>
cmp %ecx,%edx
cmovg %edx,%ecx
add $0x4,%rax
cmp %r8,%rax
je 143b <func0+0xfb>
mov (%rax),%edx
cmp %esi,%edx
jle 1418 <func0+0xd8>
add $0x4,%rax
mov %esi,%ecx
mov %edx,%esi
cmp %r8,%rax
jne 1428 <func0+0xe8>
xor %eax,%eax
jmp 144c <func0+0x10c>
lea 0x1(%rax),%rdx
cmp %rax,%rdi
je 148c <func0+0x14c>
mov %rdx,%rax
mov 0x10(%rsp),%rbx
movslq %eax,%rdx
cmp %ecx,(%rbx,%rax,4)
jne 1440 <func0+0x100>
mov 0x1b0(%rsp,%rdx,8),%rax
jmp 148e <func0+0x14e>
nopl 0x0(%rax,%rax,1)
movslq 0xc(%rsp),%rax
mov %rax,%rcx
mov %rbp,0x1b0(%rsp,%rax,8)
add $0x1,%ecx
movl $0x1,0x20(%rsp,%rax,4)
mov %ecx,0xc(%rsp)
jmpq 13f0 <func0+0xb0>
xor %eax,%eax
mov 0x4d8(%rsp),%rdx
xor %fs:0x28,%rdx
jne 14b3 <func0+0x173>
add $0x4e8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1070 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
mov ecx, 32h ; '2'
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 4E8h
mov rax, fs:28h
mov [rsp+518h+var_40], rax
xor eax, eax
lea rdi, [rsp+518h+var_4F8]
mov [rsp+518h+var_508], rdi
rep stosq
test esi, esi
jle loc_1472
lea eax, [rsi-1]
mov [rsp+518h+var_50C], 0
lea rax, [r13+rax*8+8]
mov [rsp+518h+var_500], rax
nop word ptr [rax+rax+00h]
loc_1390:
movsxd rbp, [rsp+518h+var_50C]
mov r12, [r13+0]
xor r14d, r14d
lea r15, [rsp+518h+var_368]
test ebp, ebp
jnz short loc_13BD
jmp loc_1450
loc_13B0:
add r14, 1
cmp r14, rbp
jz loc_1458
loc_13BD:
mov rsi, [r15+r14*8]
mov rdi, r12
movsxd rbx, r14d
call _strcmp
test eax, eax
jnz short loc_13B0
add [rsp+rbx*4+518h+var_4F8], 1
loc_13D5:
add r13, 8
cmp r13, [rsp+518h+var_500]
jnz short loc_1390
mov ecx, [rsp+518h+var_50C]
mov rax, [rsp+518h+var_508]
xor esi, esi
lea edx, [rcx-1]
xor ecx, ecx
lea rdi, [rsp+rdx*4+518h+var_4F4]
jmp short loc_1410
loc_1400:
jge short loc_1407
cmp edx, ecx
cmovge ecx, edx
loc_1407:
add rax, 4
cmp rax, rdi
jz short loc_1423
loc_1410:
mov edx, [rax]
cmp edx, esi
jle short loc_1400
add rax, 4
mov ecx, esi
mov esi, edx
cmp rax, rdi
jnz short loc_1410
loc_1423:
mov r14d, [rsp+518h+var_50C]
xor eax, eax
jmp short loc_1439
loc_1430:
add rax, 1
cmp r14, rax
jz short loc_1472
loc_1439:
mov rbx, [rsp+518h+var_508]
movsxd rdx, eax
cmp [rbx+rax*4], ecx
jnz short loc_1430
mov rax, [rsp+rdx*8+518h+var_368]
jmp short loc_1474
loc_1450:
xor ebp, ebp
nop word ptr [rax+rax+00h]
loc_1458:
add [rsp+518h+var_50C], 1
mov [rsp+rbp*8+518h+var_368], r12
mov [rsp+rbp*4+518h+var_4F8], 1
jmp loc_13D5
loc_1472:
xor eax, eax
loc_1474:
mov rdx, [rsp+518h+var_40]
sub rdx, fs:28h
jnz short loc_1499
add rsp, 4E8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1499:
call ___stack_chk_fail | long long func0(long long *a1, int a2)
{
long long *v2; // r13
long long v3; // rbp
long long v4; // r12
long long v5; // r14
int *v6; // rax
int v7; // esi
int v8; // ecx
int *v9; // rdi
int v10; // edx
long long v11; // rax
int v13; // [rsp+Ch] [rbp-50Ch]
_DWORD v14[302]; // [rsp+20h] [rbp-4F8h] BYREF
unsigned long long v15; // [rsp+4D8h] [rbp-40h]
v2 = a1;
v15 = __readfsqword(0x28u);
memset(v14, 0, 0x190uLL);
if ( a2 <= 0 )
return 0LL;
v13 = 0;
do
{
v3 = v13;
v4 = *v2;
v5 = 0LL;
if ( v13 )
{
while ( (unsigned int)strcmp(v4, *(_QWORD *)&v14[2 * v5 + 100]) )
{
if ( ++v5 == v13 )
goto LABEL_20;
}
++v14[(int)v5];
}
else
{
v3 = 0LL;
LABEL_20:
++v13;
*(_QWORD *)&v14[2 * v3 + 100] = v4;
v14[v3] = 1;
}
++v2;
}
while ( v2 != &a1[(unsigned int)(a2 - 1) + 1] );
v6 = v14;
v7 = 0;
v8 = 0;
v9 = &v14[v13 - 1 + 1];
do
{
while ( 1 )
{
v10 = *v6;
if ( *v6 <= v7 )
break;
++v6;
v8 = v7;
v7 = v10;
if ( v6 == v9 )
goto LABEL_16;
}
if ( v10 < v7 && v10 >= v8 )
v8 = *v6;
++v6;
}
while ( v6 != v9 );
LABEL_16:
v11 = 0LL;
while ( v14[v11] != v8 )
{
if ( v13 == ++v11 )
return 0LL;
}
return *(_QWORD *)&v14[2 * (int)v11 + 100];
} | func0:
ENDBR64
PUSH R15
MOV ECX,0x32
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x4e8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x4d8],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RDI
STOSQ.REP RDI
TEST ESI,ESI
JLE 0x00101472
LEA EAX,[RSI + -0x1]
MOV dword ptr [RSP + 0xc],0x0
LEA RAX,[R13 + RAX*0x8 + 0x8]
MOV qword ptr [RSP + 0x18],RAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101390:
MOVSXD RBP,dword ptr [RSP + 0xc]
MOV R12,qword ptr [R13]
XOR R14D,R14D
LEA R15,[RSP + 0x1b0]
TEST EBP,EBP
JNZ 0x001013bd
JMP 0x00101450
LAB_001013b0:
ADD R14,0x1
CMP R14,RBP
JZ 0x00101458
LAB_001013bd:
MOV RSI,qword ptr [R15 + R14*0x8]
MOV RDI,R12
MOVSXD RBX,R14D
CALL 0x00101090
TEST EAX,EAX
JNZ 0x001013b0
ADD dword ptr [RSP + RBX*0x4 + 0x20],0x1
LAB_001013d5:
ADD R13,0x8
CMP R13,qword ptr [RSP + 0x18]
JNZ 0x00101390
MOV ECX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RSP + 0x10]
XOR ESI,ESI
LEA EDX,[RCX + -0x1]
XOR ECX,ECX
LEA RDI,[RSP + RDX*0x4 + 0x24]
JMP 0x00101410
LAB_00101400:
JGE 0x00101407
CMP EDX,ECX
CMOVGE ECX,EDX
LAB_00101407:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x00101423
LAB_00101410:
MOV EDX,dword ptr [RAX]
CMP EDX,ESI
JLE 0x00101400
ADD RAX,0x4
MOV ECX,ESI
MOV ESI,EDX
CMP RAX,RDI
JNZ 0x00101410
LAB_00101423:
MOV R14D,dword ptr [RSP + 0xc]
XOR EAX,EAX
JMP 0x00101439
LAB_00101430:
ADD RAX,0x1
CMP R14,RAX
JZ 0x00101472
LAB_00101439:
MOV RBX,qword ptr [RSP + 0x10]
MOVSXD RDX,EAX
CMP dword ptr [RBX + RAX*0x4],ECX
JNZ 0x00101430
MOV RAX,qword ptr [RSP + RDX*0x8 + 0x1b0]
JMP 0x00101474
LAB_00101450:
XOR EBP,EBP
NOP word ptr [RAX + RAX*0x1]
LAB_00101458:
ADD dword ptr [RSP + 0xc],0x1
MOV qword ptr [RSP + RBP*0x8 + 0x1b0],R12
MOV dword ptr [RSP + RBP*0x4 + 0x20],0x1
JMP 0x001013d5
LAB_00101472:
XOR EAX,EAX
LAB_00101474:
MOV RDX,qword ptr [RSP + 0x4d8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101499
ADD RSP,0x4e8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101499:
CALL 0x00101070 | int8 func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
char *__s1;
int iVar3;
int *piVar4;
ulong uVar5;
int8 uVar6;
long lVar7;
int iVar8;
long lVar9;
long in_FS_OFFSET;
uint local_50c;
int local_4f8 [100];
int8 local_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
piVar4 = local_4f8;
for (lVar7 = 0x32; lVar7 != 0; lVar7 = lVar7 + -1) {
piVar4[0] = 0;
piVar4[1] = 0;
piVar4 = piVar4 + 2;
}
if (0 < param_2) {
local_50c = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
lVar7 = (long)(int)local_50c;
__s1 = (char *)*param_1;
lVar9 = 0;
if (local_50c == 0) {
lVar7 = 0;
}
else {
do {
iVar3 = strcmp(__s1,(char *)local_368[lVar9]);
if (iVar3 == 0) {
local_4f8[(int)lVar9] = local_4f8[(int)lVar9] + 1;
goto LAB_001013d5;
}
lVar9 = lVar9 + 1;
} while (lVar9 != lVar7);
}
local_50c = local_50c + 1;
local_368[lVar7] = __s1;
local_4f8[lVar7] = 1;
LAB_001013d5:
param_1 = param_1 + 1;
} while (param_1 != puVar1);
piVar4 = local_4f8;
iVar3 = 0;
iVar8 = 0;
do {
while( true ) {
iVar2 = *piVar4;
if (iVar2 <= iVar8) break;
piVar4 = piVar4 + 1;
iVar3 = iVar8;
iVar8 = iVar2;
if (piVar4 == local_4f8 + (ulong)(local_50c - 1) + 1) goto LAB_00101423;
}
if ((iVar2 < iVar8) && (iVar3 <= iVar2)) {
iVar3 = iVar2;
}
piVar4 = piVar4 + 1;
} while (piVar4 != local_4f8 + (ulong)(local_50c - 1) + 1);
LAB_00101423:
uVar5 = 0;
do {
if (local_4f8[uVar5] == iVar3) {
uVar6 = local_368[(int)uVar5];
goto LAB_00101474;
}
uVar5 = uVar5 + 1;
} while (local_50c != uVar5);
}
uVar6 = 0;
LAB_00101474:
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar6;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,211 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
| char* func0(char* input[], int size) {
int count[100] = {0};
char* unique[100];
int unique_count = 0;
for(int i = 0; i < size; i++) {
int found = 0;
for(int j = 0; j < unique_count; j++) {
if(strcmp(input[i], unique[j]) == 0) {
count[j]++;
found = 1;
break;
}
}
if(!found) {
unique[unique_count] = input[i];
count[unique_count] = 1;
unique_count++;
}
}
// Find the second largest count
int first = 0, second = 0;
for(int i = 0; i < unique_count; i++) {
if(count[i] > first) {
second = first;
first = count[i];
}
else if(count[i] > second && count[i] < first) {
second = count[i];
}
}
// Find the string with the second largest count
for(int i = 0; i < unique_count; i++) {
if(count[i] == second) {
return unique[i];
}
}
return NULL;
}
| int main() {
char* arr1[] = {"aaa","bbb","ccc","bbb","aaa","aaa"};
assert(strcmp(func0(arr1, 6), "bbb") == 0);
char* arr2[] = {"abc","bcd","abc","bcd","bcd","bcd"};
assert(strcmp(func0(arr2, 6), "abc") == 0);
char* arr3[] = {"cdma","gsm","hspa","gsm","cdma","cdma"};
assert(strcmp(func0(arr3, 6), "gsm") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
mov $0x32,%ecx
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x4e8,%rsp
mov %fs:0x28,%rax
mov %rax,0x4d8(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rdi
mov %rdi,0x10(%rsp)
rep stos %rax,%es:(%rdi)
test %esi,%esi
jle 14b4 <func0+0x154>
lea -0x1(%rsi),%eax
movl $0x0,0xc(%rsp)
lea 0x8(%r13,%rax,8),%rax
mov %rax,0x18(%rsp)
nopw 0x0(%rax,%rax,1)
mov 0xc(%rsp),%eax
mov 0x0(%r13),%rbp
test %eax,%eax
je 1490 <func0+0x130>
mov 0xc(%rsp),%eax
xor %r14d,%r14d
lea 0x1b0(%rsp),%r15
lea -0x1(%rax),%r12d
jmp 13f8 <func0+0x98>
nopl (%rax)
lea 0x1(%r14),%rax
cmp %r12,%r14
je 1490 <func0+0x130>
mov %rax,%r14
mov (%r15,%r14,8),%rsi
mov %rbp,%rdi
movslq %r14d,%rbx
callq 1090 <strcmp@plt>
test %eax,%eax
jne 13e8 <func0+0x88>
addl $0x1,0x20(%rsp,%rbx,4)
add $0x8,%r13
cmp 0x18(%rsp),%r13
jne 13c0 <func0+0x60>
mov 0xc(%rsp),%edx
mov 0x10(%rsp),%rax
xor %ecx,%ecx
xor %esi,%esi
lea -0x1(%rdx),%edi
lea 0x24(%rsp,%rdi,4),%r8
jmp 1448 <func0+0xe8>
nopw 0x0(%rax,%rax,1)
jge 143f <func0+0xdf>
cmp %ecx,%edx
cmovg %edx,%ecx
add $0x4,%rax
cmp %rax,%r8
je 145b <func0+0xfb>
mov (%rax),%edx
cmp %esi,%edx
jle 1438 <func0+0xd8>
add $0x4,%rax
mov %esi,%ecx
mov %edx,%esi
cmp %rax,%r8
jne 1448 <func0+0xe8>
mov 0x10(%rsp),%rbx
xor %eax,%eax
jmp 1474 <func0+0x114>
nopl 0x0(%rax)
lea 0x1(%rax),%rdx
cmp %rdi,%rax
je 14b4 <func0+0x154>
mov %rdx,%rax
movslq %eax,%rdx
cmp (%rbx,%rax,4),%ecx
jne 1468 <func0+0x108>
mov 0x1b0(%rsp,%rdx,8),%rax
jmp 14b6 <func0+0x156>
nopw %cs:0x0(%rax,%rax,1)
movslq 0xc(%rsp),%rax
mov %rax,%rcx
mov %rbp,0x1b0(%rsp,%rax,8)
add $0x1,%ecx
movl $0x1,0x20(%rsp,%rax,4)
mov %ecx,0xc(%rsp)
jmpq 1410 <func0+0xb0>
xor %eax,%eax
mov 0x4d8(%rsp),%rdx
xor %fs:0x28,%rdx
jne 14db <func0+0x17b>
add $0x4e8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1070 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
mov ecx, 32h ; '2'
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 4D8h
mov rax, fs:28h
mov [rsp+508h+var_40], rax
xor eax, eax
lea rdi, [rsp+508h+var_4F8]
mov [rsp+508h+var_508], rdi
rep stosq
test esi, esi
jle loc_14DE
movsxd rsi, esi
xor r13d, r13d
lea rax, [r12+rsi*8]
mov [rsp+508h+var_500], rax
nop dword ptr [rax+rax+00h]
loc_13F8:
mov rbx, [r12]
movsxd rbp, r13d
lea r15, [rsp+508h+var_368]
test r13d, r13d
jle short loc_1450
loc_140C:
xor r14d, r14d
jmp short loc_1421
loc_1418:
add r14, 1
cmp r14, rbp
jz short loc_1450
loc_1421:
mov rsi, [r15+r14*8]; s2
mov rdi, rbx; s1
call _strcmp
test eax, eax
jnz short loc_1418
mov rax, [rsp+508h+var_500]
movsxd rdx, r14d
add r12, 8
add [rsp+rdx*4+508h+var_4F8], 1
cmp r12, rax
jz short loc_1472
mov rbx, [r12]
jmp short loc_140C
loc_1450:
mov rax, [rsp+508h+var_500]
add r12, 8
add r13d, 1
mov [rsp+rbp*8+508h+var_368], rbx
mov [rsp+rbp*4+508h+var_4F8], 1
cmp r12, rax
jnz short loc_13F8
loc_1472:
test r13d, r13d
jle short loc_14DE
mov rcx, [rsp+508h+var_508]
movsxd r13, r13d
xor esi, esi
mov rax, rcx
lea rdi, [rcx+r13*4]
xor ecx, ecx
jmp short loc_14A0
loc_1490:
jge short loc_1497
cmp edx, ecx
cmovge ecx, edx
loc_1497:
add rax, 4
cmp rdi, rax
jz short loc_14B3
loc_14A0:
mov edx, [rax]
cmp edx, esi
jle short loc_1490
add rax, 4
mov ecx, esi
mov esi, edx
cmp rdi, rax
jnz short loc_14A0
loc_14B3:
xor eax, eax
jmp short loc_14C9
loc_14C0:
add rax, 1
cmp r13, rax
jz short loc_14DE
loc_14C9:
mov rdx, [rsp+508h+var_508]
cmp [rdx+rax*4], ecx
jnz short loc_14C0
cdqe
mov rax, [rsp+rax*8+508h+var_368]
jmp short loc_14E0
loc_14DE:
xor eax, eax
loc_14E0:
mov rdx, [rsp+508h+var_40]
sub rdx, fs:28h
jnz short loc_1505
add rsp, 4D8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1505:
call ___stack_chk_fail | long long func0(const char **a1, int a2)
{
const char **v2; // r12
int v3; // r13d
const char *v4; // rbx
long long v5; // rbp
long long v6; // r14
int v7; // esi
int *v8; // rax
int *v9; // rdi
int v10; // ecx
int v11; // edx
long long v12; // rax
const char **v14; // [rsp+8h] [rbp-500h]
_DWORD v15[302]; // [rsp+10h] [rbp-4F8h] BYREF
unsigned long long v16; // [rsp+4C8h] [rbp-40h]
v2 = a1;
v16 = __readfsqword(0x28u);
memset(v15, 0, 0x190uLL);
if ( a2 <= 0 )
return 0LL;
v3 = 0;
v14 = &a1[a2];
while ( 1 )
{
v4 = *v2;
v5 = v3;
if ( v3 > 0 )
break;
LABEL_9:
++v2;
++v3;
*(_QWORD *)&v15[2 * v5 + 100] = v4;
v15[v5] = 1;
if ( v2 == v14 )
goto LABEL_10;
}
while ( 1 )
{
v6 = 0LL;
while ( strcmp(v4, *(const char **)&v15[2 * v6 + 100]) )
{
if ( ++v6 == v3 )
goto LABEL_9;
}
++v2;
++v15[(int)v6];
if ( v2 == v14 )
break;
v4 = *v2;
}
LABEL_10:
if ( v3 <= 0 )
return 0LL;
v7 = 0;
v8 = v15;
v9 = &v15[v3];
v10 = 0;
do
{
while ( 1 )
{
v11 = *v8;
if ( *v8 <= v7 )
break;
++v8;
v10 = v7;
v7 = v11;
if ( v9 == v8 )
goto LABEL_18;
}
if ( v11 < v7 && v11 >= v10 )
v10 = *v8;
++v8;
}
while ( v9 != v8 );
LABEL_18:
v12 = 0LL;
while ( v15[v12] != v10 )
{
if ( v3 == ++v12 )
return 0LL;
}
return *(_QWORD *)&v15[2 * (int)v12 + 100];
} | func0:
ENDBR64
PUSH R15
MOV ECX,0x32
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x4d8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x4c8],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x10]
MOV qword ptr [RSP],RDI
STOSQ.REP RDI
TEST ESI,ESI
JLE 0x001014de
MOVSXD RSI,ESI
XOR R13D,R13D
LEA RAX,[R12 + RSI*0x8]
MOV qword ptr [RSP + 0x8],RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013f8:
MOV RBX,qword ptr [R12]
MOVSXD RBP,R13D
LEA R15,[RSP + 0x1a0]
TEST R13D,R13D
JLE 0x00101450
LAB_0010140c:
XOR R14D,R14D
JMP 0x00101421
LAB_00101418:
ADD R14,0x1
CMP R14,RBP
JZ 0x00101450
LAB_00101421:
MOV RSI,qword ptr [R15 + R14*0x8]
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JNZ 0x00101418
MOV RAX,qword ptr [RSP + 0x8]
MOVSXD RDX,R14D
ADD R12,0x8
ADD dword ptr [RSP + RDX*0x4 + 0x10],0x1
CMP R12,RAX
JZ 0x00101472
MOV RBX,qword ptr [R12]
JMP 0x0010140c
LAB_00101450:
MOV RAX,qword ptr [RSP + 0x8]
ADD R12,0x8
ADD R13D,0x1
MOV qword ptr [RSP + RBP*0x8 + 0x1a0],RBX
MOV dword ptr [RSP + RBP*0x4 + 0x10],0x1
CMP R12,RAX
JNZ 0x001013f8
LAB_00101472:
TEST R13D,R13D
JLE 0x001014de
MOV RCX,qword ptr [RSP]
MOVSXD R13,R13D
XOR ESI,ESI
MOV RAX,RCX
LEA RDI,[RCX + R13*0x4]
XOR ECX,ECX
JMP 0x001014a0
LAB_00101490:
JGE 0x00101497
CMP EDX,ECX
CMOVGE ECX,EDX
LAB_00101497:
ADD RAX,0x4
CMP RDI,RAX
JZ 0x001014b3
LAB_001014a0:
MOV EDX,dword ptr [RAX]
CMP EDX,ESI
JLE 0x00101490
ADD RAX,0x4
MOV ECX,ESI
MOV ESI,EDX
CMP RDI,RAX
JNZ 0x001014a0
LAB_001014b3:
XOR EAX,EAX
JMP 0x001014c9
LAB_001014c0:
ADD RAX,0x1
CMP R13,RAX
JZ 0x001014de
LAB_001014c9:
MOV RDX,qword ptr [RSP]
CMP dword ptr [RDX + RAX*0x4],ECX
JNZ 0x001014c0
CDQE
MOV RAX,qword ptr [RSP + RAX*0x8 + 0x1a0]
JMP 0x001014e0
LAB_001014de:
XOR EAX,EAX
LAB_001014e0:
MOV RDX,qword ptr [RSP + 0x4c8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101505
ADD RSP,0x4d8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101505:
CALL 0x00101070 | int8 func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
int iVar3;
int *piVar4;
int8 uVar5;
long lVar6;
char *__s1;
int iVar7;
int *piVar8;
int iVar9;
long lVar10;
long in_FS_OFFSET;
int local_4f8 [100];
int8 local_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
piVar8 = local_4f8;
for (lVar6 = 0x32; lVar6 != 0; lVar6 = lVar6 + -1) {
piVar8[0] = 0;
piVar8[1] = 0;
piVar8 = piVar8 + 2;
}
if (0 < param_2) {
iVar9 = 0;
puVar1 = param_1 + param_2;
do {
__s1 = (char *)*param_1;
lVar6 = (long)iVar9;
if (0 < iVar9) {
while( true ) {
lVar10 = 0;
while( true ) {
iVar3 = strcmp(__s1,(char *)local_368[lVar10]);
if (iVar3 == 0) break;
lVar10 = lVar10 + 1;
if (lVar10 == lVar6) goto LAB_00101450;
}
param_1 = param_1 + 1;
local_4f8[(int)lVar10] = local_4f8[(int)lVar10] + 1;
if (param_1 == puVar1) break;
__s1 = (char *)*param_1;
}
break;
}
LAB_00101450:
param_1 = param_1 + 1;
iVar9 = iVar9 + 1;
local_368[lVar6] = __s1;
local_4f8[lVar6] = 1;
} while (param_1 != puVar1);
if (0 < iVar9) {
piVar8 = local_4f8 + iVar9;
piVar4 = local_4f8;
iVar3 = 0;
iVar7 = 0;
do {
while( true ) {
iVar2 = *piVar4;
if (iVar2 <= iVar7) break;
piVar4 = piVar4 + 1;
iVar3 = iVar7;
iVar7 = iVar2;
if (piVar8 == piVar4) goto LAB_001014b3;
}
if ((iVar2 < iVar7) && (iVar3 <= iVar2)) {
iVar3 = iVar2;
}
piVar4 = piVar4 + 1;
} while (piVar8 != piVar4);
LAB_001014b3:
lVar6 = 0;
do {
if (local_4f8[lVar6] == iVar3) {
uVar5 = local_368[(int)lVar6];
goto LAB_001014e0;
}
lVar6 = lVar6 + 1;
} while (iVar9 != lVar6);
}
}
uVar5 = 0;
LAB_001014e0:
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,212 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double a, int digits) {
double n = pow(10, -digits);
return round(ceil(a / n) * n * pow(10, digits)) / pow(10, digits);
}
| int main() {
assert(func0(123.01247,0) == 124);
assert(func0(123.01247,1) == 123.1);
assert(func0(123.01247,2) == 123.02);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
movsd %xmm0,-0x18(%rbp)
mov %edi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
neg %eax
cvtsi2sd %eax,%xmm0
mov 0xed3(%rip),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1090 <pow@plt>
movq %xmm0,%rax
mov %rax,-0x8(%rbp)
movsd -0x18(%rbp),%xmm0
divsd -0x8(%rbp),%xmm0
callq 10b0 <ceil@plt>
mulsd -0x8(%rbp),%xmm0
movsd %xmm0,-0x28(%rbp)
cvtsi2sdl -0x1c(%rbp),%xmm0
mov 0xe97(%rip),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1090 <pow@plt>
mulsd -0x28(%rbp),%xmm0
callq 1080 <round@plt>
movsd %xmm0,-0x28(%rbp)
cvtsi2sdl -0x1c(%rbp),%xmm0
mov 0xe6e(%rip),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1090 <pow@plt>
movsd -0x28(%rbp),%xmm3
divsd %xmm0,%xmm3
movapd %xmm3,%xmm0
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
movsd [rbp+var_28], xmm0
mov [rbp+var_2C], edi
mov eax, [rbp+var_2C]
neg eax
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mov rax, cs:x
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movq rax, xmm0
mov [rbp+var_18], rax
movsd xmm0, [rbp+var_28]
divsd xmm0, [rbp+var_18]
movq rax, xmm0
movq xmm0, rax; x
call _ceil
movq rax, xmm0
movq xmm2, rax
mulsd xmm2, [rbp+var_18]
movsd [rbp+var_38], xmm2
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_2C]
mov rax, cs:x
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
mulsd xmm0, [rbp+var_38]
movq rax, xmm0
movq xmm0, rax; x
call _round
movq rbx, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_2C]
mov rax, cs:x
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movq xmm1, rbx
divsd xmm1, xmm0
movapd xmm0, xmm1
mov rbx, [rbp+var_8]
leave
retn | __int128 __usercall func0@<xmm0>(int a1@<edi>, double a2@<xmm0>)
{
double v2; // xmm0_8
double v3; // rbx
__int128 v4; // xmm1
double v6; // [rsp+8h] [rbp-38h]
double v8; // [rsp+28h] [rbp-18h]
v8 = pow(10.0, (double)-a1);
v6 = ceil(a2 / v8) * v8;
v2 = pow(10.0, (double)a1);
v3 = round(v2 * v6);
v4 = *(unsigned long long *)&v3;
*(double *)&v4 = v3 / pow(10.0, (double)a1);
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOVSD qword ptr [RBP + -0x28],XMM0
MOV dword ptr [RBP + -0x2c],EDI
MOV EAX,dword ptr [RBP + -0x2c]
NEG EAX
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOV RAX,qword ptr [0x00102080]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101090
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x18],RAX
MOVSD XMM0,qword ptr [RBP + -0x28]
DIVSD XMM0,qword ptr [RBP + -0x18]
MOVQ RAX,XMM0
MOVQ XMM0,RAX
CALL 0x001010b0
MOVQ RAX,XMM0
MOVQ XMM2,RAX
MULSD XMM2,qword ptr [RBP + -0x18]
MOVSD qword ptr [RBP + -0x38],XMM2
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [0x00102080]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101090
MULSD XMM0,qword ptr [RBP + -0x38]
MOVQ RAX,XMM0
MOVQ XMM0,RAX
CALL 0x00101080
MOVQ RBX,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [0x00102080]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101090
MOVQ XMM1,RBX
DIVSD XMM1,XMM0
MOVAPD XMM0,XMM1
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | double func0(double param_1,int param_2)
{
double dVar1;
double dVar2;
double dVar3;
dVar1 = pow(DAT_00102080,(double)-param_2);
dVar2 = ceil(param_1 / dVar1);
dVar3 = pow(DAT_00102080,(double)param_2);
dVar1 = round(dVar3 * dVar2 * dVar1);
dVar2 = pow(DAT_00102080,(double)param_2);
return dVar1 / dVar2;
} |
7,213 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double a, int digits) {
double n = pow(10, -digits);
return round(ceil(a / n) * n * pow(10, digits)) / pow(10, digits);
}
| int main() {
assert(func0(123.01247,0) == 124);
assert(func0(123.01247,1) == 123.1);
assert(func0(123.01247,2) == 123.02);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
sub $0x20,%rsp
movsd %xmm0,0x8(%rsp)
mov %edi,%ebx
mov %edi,%eax
neg %eax
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd 0xef2(%rip),%xmm0
callq 1080 <pow@plt>
movsd %xmm0,0x18(%rsp)
movsd 0x8(%rsp),%xmm1
divsd %xmm0,%xmm1
movsd %xmm1,0x8(%rsp)
movsd 0xf0f(%rip),%xmm0
movapd %xmm1,%xmm2
andpd %xmm0,%xmm2
movsd 0xec7(%rip),%xmm3
ucomisd %xmm2,%xmm3
jbe 121c <func0+0x93>
cvttsd2si %xmm1,%rax
pxor %xmm2,%xmm2
cvtsi2sd %rax,%xmm2
movapd %xmm1,%xmm3
cmpnlesd %xmm2,%xmm3
movsd 0xeaa(%rip),%xmm4
andpd %xmm4,%xmm3
addsd %xmm3,%xmm2
andnpd %xmm1,%xmm0
orpd %xmm0,%xmm2
movsd %xmm2,0x8(%rsp)
pxor %xmm6,%xmm6
cvtsi2sd %ebx,%xmm6
movsd %xmm6,0x10(%rsp)
movapd %xmm6,%xmm1
mov 0xe6b(%rip),%rax
movq %rax,%xmm0
callq 1080 <pow@plt>
movapd %xmm0,%xmm1
movsd 0x8(%rsp),%xmm0
mulsd 0x18(%rsp),%xmm0
mulsd %xmm1,%xmm0
callq 1070 <round@plt>
movsd %xmm0,0x8(%rsp)
movsd 0x10(%rsp),%xmm1
mov 0xe35(%rip),%rax
movq %rax,%xmm0
callq 1080 <pow@plt>
movsd 0x8(%rsp),%xmm7
divsd %xmm0,%xmm7
movapd %xmm7,%xmm0
add $0x20,%rsp
pop %rbx
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 18h
movq rbx, xmm0
mov ebp, edi
mov eax, edi
neg eax
pxor xmm1, xmm1
cvtsi2sd xmm1, eax
movsd xmm0, cs:qword_2080
call _pow
movsd [rsp+28h+var_20], xmm0
movq xmm5, rbx
divsd xmm5, xmm0
movq rbx, xmm5
movsd xmm2, cs:qword_20C0
movapd xmm1, xmm5
andpd xmm1, xmm2
movsd xmm3, cs:qword_2088
ucomisd xmm3, xmm1
jbe short loc_1219
cvttsd2si rax, xmm5
pxor xmm1, xmm1
cvtsi2sd xmm1, rax
movapd xmm3, xmm5
cmpnlesd xmm3, xmm1
movsd xmm4, cs:qword_2090
andpd xmm3, xmm4
addsd xmm1, xmm3
andnpd xmm2, xmm5
orpd xmm1, xmm2
movq rbx, xmm1
loc_1219:
pxor xmm6, xmm6
cvtsi2sd xmm6, ebp
movq rbp, xmm6
movapd xmm1, xmm6
mov rax, cs:qword_2080
movq xmm0, rax
call _pow
movapd xmm1, xmm0
movq xmm0, rbx
mulsd xmm0, [rsp+28h+var_20]
mulsd xmm0, xmm1
call _round
movq rbx, xmm0
movq xmm1, rbp
mov rax, cs:qword_2080
movq xmm0, rax
call _pow
movapd xmm1, xmm0
movq xmm0, rbx
divsd xmm0, xmm1
add rsp, 18h
pop rbx
pop rbp
retn | double func0(int a1, double a2)
{
__m128d v3; // xmm5
double v4; // rbx
__m128d v5; // xmm1
double v6; // xmm0_8
double v7; // rbx
double v9; // [rsp+8h] [rbp-20h]
v9 = pow(10.0, (double)-a1);
v3 = (__m128d)*(unsigned long long *)&a2;
v4 = a2 / v9;
v3.m128d_f64[0] = v4;
if ( fabs(v4) < 4.503599627370496e15 )
{
v5.m128d_f64[0] = (double)(int)v4;
*(_QWORD *)&v4 = COERCE_UNSIGNED_INT64(v5.m128d_f64[0] + COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(v3, v5) & 0x3FF0000000000000LL)) | *(_QWORD *)&v4 & 0x8000000000000000LL;
}
v6 = pow(10.0, (double)a1);
v7 = round(v4 * v9 * v6);
return v7 / pow(10.0, (double)a1);
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOVQ RBX,XMM0
MOV EBP,EDI
MOV EAX,EDI
NEG EAX
PXOR XMM1,XMM1
CVTSI2SD XMM1,EAX
MOVSD XMM0,qword ptr [0x00102080]
CALL 0x00101080
MOVSD qword ptr [RSP + 0x8],XMM0
MOVQ XMM5,RBX
DIVSD XMM5,XMM0
MOVQ RBX,XMM5
MOVSD XMM2,qword ptr [0x001020c0]
MOVAPD XMM1,XMM5
ANDPD XMM1,XMM2
MOVSD XMM3,qword ptr [0x00102088]
UCOMISD XMM3,XMM1
JBE 0x00101219
CVTTSD2SI RAX,XMM5
PXOR XMM1,XMM1
CVTSI2SD XMM1,RAX
MOVAPD XMM3,XMM5
CMPNLESD XMM3,XMM1
MOVSD XMM4,qword ptr [0x00102090]
ANDPD XMM3,XMM4
ADDSD XMM1,XMM3
ANDNPD XMM2,XMM5
ORPD XMM1,XMM2
MOVQ RBX,XMM1
LAB_00101219:
PXOR XMM6,XMM6
CVTSI2SD XMM6,EBP
MOVQ RBP,XMM6
MOVAPD XMM1,XMM6
MOV RAX,qword ptr [0x00102080]
MOVQ XMM0,RAX
CALL 0x00101080
MOVAPD XMM1,XMM0
MOVQ XMM0,RBX
MULSD XMM0,qword ptr [RSP + 0x8]
MULSD XMM0,XMM1
CALL 0x00101070
MOVQ RBX,XMM0
MOVQ XMM1,RBP
MOV RAX,qword ptr [0x00102080]
MOVQ XMM0,RAX
CALL 0x00101080
MOVAPD XMM1,XMM0
MOVQ XMM0,RBX
DIVSD XMM0,XMM1
ADD RSP,0x18
POP RBX
POP RBP
RET | double func0(double param_1,int param_2)
{
double dVar1;
double dVar2;
dVar1 = pow(DAT_00102080,(double)-param_2);
param_1 = param_1 / dVar1;
if ((double)((ulong)param_1 & DAT_001020c0) < DAT_00102088) {
param_1 = (double)((ulong)((double)(long)param_1 +
(double)(-(ulong)((double)(long)param_1 < param_1) & DAT_00102090)) |
~DAT_001020c0 & (ulong)param_1);
}
dVar2 = pow(DAT_00102080,(double)param_2);
dVar1 = round(param_1 * dVar1 * dVar2);
dVar2 = pow(DAT_00102080,(double)param_2);
return dVar1 / dVar2;
} |
7,214 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double a, int digits) {
double n = pow(10, -digits);
return round(ceil(a / n) * n * pow(10, digits)) / pow(10, digits);
}
| int main() {
assert(func0(123.01247,0) == 124);
assert(func0(123.01247,1) == 123.1);
assert(func0(123.01247,2) == 123.02);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %edi,%eax
pxor %xmm1,%xmm1
mov %edi,%ebx
neg %eax
cvtsi2sd %eax,%xmm1
sub $0x20,%rsp
movsd 0xe21(%rip),%xmm4
movsd %xmm0,0x8(%rsp)
movapd %xmm4,%xmm0
callq 1080 <pow@plt>
movsd 0x8(%rsp),%xmm2
movsd 0xe0c(%rip),%xmm5
movapd %xmm0,%xmm3
mov 0xdf9(%rip),%rax
divsd %xmm0,%xmm2
movsd 0xe2d(%rip),%xmm0
movq %rax,%xmm4
movapd %xmm2,%xmm1
andpd %xmm0,%xmm1
ucomisd %xmm1,%xmm5
jbe 12f9 <func0+0x99>
cvttsd2si %xmm2,%rax
pxor %xmm1,%xmm1
movapd %xmm2,%xmm5
movsd 0xdd5(%rip),%xmm6
andnpd %xmm2,%xmm0
movapd %xmm0,%xmm2
cvtsi2sd %rax,%xmm1
cmpnlesd %xmm1,%xmm5
andpd %xmm6,%xmm5
addsd %xmm5,%xmm1
orpd %xmm1,%xmm2
pxor %xmm1,%xmm1
movapd %xmm4,%xmm0
movsd %xmm2,0x18(%rsp)
cvtsi2sd %ebx,%xmm1
movsd %xmm3,0x8(%rsp)
movsd %xmm1,0x10(%rsp)
callq 1080 <pow@plt>
movsd 0x8(%rsp),%xmm3
movsd 0x18(%rsp),%xmm2
mulsd %xmm3,%xmm2
mulsd %xmm2,%xmm0
callq 1070 <round@plt>
mov 0xd64(%rip),%rax
movsd 0x10(%rsp),%xmm1
movsd %xmm0,0x8(%rsp)
movq %rax,%xmm0
callq 1080 <pow@plt>
movsd 0x8(%rsp),%xmm2
add $0x20,%rsp
pop %rbx
divsd %xmm0,%xmm2
movapd %xmm2,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov eax, edi
pxor xmm1, xmm1
mov ebx, edi
neg eax
cvtsi2sd xmm1, eax
sub rsp, 20h
movsd xmm4, cs:qword_2080
movsd [rsp+28h+var_20], xmm0
movapd xmm0, xmm4
call _pow
movsd xmm2, [rsp+28h+var_20]
movsd xmm1, cs:qword_20C0
movsd xmm5, cs:qword_2088
movapd xmm3, xmm0
mov rax, cs:qword_2080
divsd xmm2, xmm0
movq xmm4, rax
movapd xmm0, xmm2
andpd xmm0, xmm1
ucomisd xmm5, xmm0
jbe short loc_12F9
cvttsd2si rax, xmm2
pxor xmm0, xmm0
movapd xmm5, xmm2
movsd xmm6, cs:qword_2090
andnpd xmm1, xmm2
cvtsi2sd xmm0, rax
cmpnlesd xmm5, xmm0
andpd xmm5, xmm6
addsd xmm0, xmm5
movapd xmm2, xmm0
orpd xmm2, xmm1
loc_12F9:
pxor xmm1, xmm1
movapd xmm0, xmm4
movsd [rsp+28h+var_10], xmm2
cvtsi2sd xmm1, ebx
movsd [rsp+28h+var_20], xmm3
movsd [rsp+28h+var_18], xmm1
call _pow
movsd xmm3, [rsp+28h+var_20]
movsd xmm2, [rsp+28h+var_10]
mulsd xmm2, xmm3
mulsd xmm0, xmm2
call _round
mov rax, cs:qword_2080
movsd xmm1, [rsp+28h+var_18]
movsd [rsp+28h+var_20], xmm0
movq xmm0, rax
call _pow
movsd xmm2, [rsp+28h+var_20]
add rsp, 20h
pop rbx
divsd xmm2, xmm0
movapd xmm0, xmm2
retn | __int128 __usercall func0@<xmm0>(int a1@<edi>, double a2@<xmm0>)
{
double v2; // xmm3_8
__m128d v3; // xmm2
__m128d v4; // xmm0
double v5; // xmm0_8
__int128 v6; // xmm2
double v9; // [rsp+0h] [rbp-20h]
v3 = (__m128d)*(unsigned long long *)&a2;
v2 = pow(10.0, (double)-a1);
v3.m128d_f64[0] = a2 / v2;
if ( fabs(a2 / v2) < 4.503599627370496e15 )
{
v4.m128d_f64[0] = (double)(int)v3.m128d_f64[0];
*(_QWORD *)&v3.m128d_f64[0] = COERCE_UNSIGNED_INT64(
v4.m128d_f64[0]
+ COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(v3, v4) & 0x3FF0000000000000LL)) | *(_QWORD *)&v3.m128d_f64[0] & 0x8000000000000000LL;
}
v5 = pow(10.0, (double)a1);
v9 = round(v5 * (v3.m128d_f64[0] * v2));
v6 = *(unsigned long long *)&v9;
*(double *)&v6 = v9 / pow(10.0, (double)a1);
return v6;
} | func0:
ENDBR64
PUSH RBX
MOV EAX,EDI
PXOR XMM1,XMM1
MOV EBX,EDI
NEG EAX
CVTSI2SD XMM1,EAX
SUB RSP,0x20
MOVSD XMM4,qword ptr [0x00102080]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVAPD XMM0,XMM4
CALL 0x00101080
MOVSD XMM2,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [0x001020c0]
MOVSD XMM5,qword ptr [0x00102088]
MOVAPD XMM3,XMM0
MOV RAX,qword ptr [0x00102080]
DIVSD XMM2,XMM0
MOVQ XMM4,RAX
MOVAPD XMM0,XMM2
ANDPD XMM0,XMM1
UCOMISD XMM5,XMM0
JBE 0x001012f9
CVTTSD2SI RAX,XMM2
PXOR XMM0,XMM0
MOVAPD XMM5,XMM2
MOVSD XMM6,qword ptr [0x00102090]
ANDNPD XMM1,XMM2
CVTSI2SD XMM0,RAX
CMPNLESD XMM5,XMM0
ANDPD XMM5,XMM6
ADDSD XMM0,XMM5
MOVAPD XMM2,XMM0
ORPD XMM2,XMM1
LAB_001012f9:
PXOR XMM1,XMM1
MOVAPD XMM0,XMM4
MOVSD qword ptr [RSP + 0x18],XMM2
CVTSI2SD XMM1,EBX
MOVSD qword ptr [RSP + 0x8],XMM3
MOVSD qword ptr [RSP + 0x10],XMM1
CALL 0x00101080
MOVSD XMM3,qword ptr [RSP + 0x8]
MOVSD XMM2,qword ptr [RSP + 0x18]
MULSD XMM2,XMM3
MULSD XMM0,XMM2
CALL 0x00101070
MOV RAX,qword ptr [0x00102080]
MOVSD XMM1,qword ptr [RSP + 0x10]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVQ XMM0,RAX
CALL 0x00101080
MOVSD XMM2,qword ptr [RSP + 0x8]
ADD RSP,0x20
POP RBX
DIVSD XMM2,XMM0
MOVAPD XMM0,XMM2
RET | double func0(double param_1,int param_2)
{
double dVar1;
double dVar2;
dVar1 = pow(DAT_00102080,(double)-param_2);
param_1 = param_1 / dVar1;
if ((double)((ulong)param_1 & DAT_001020c0) < DAT_00102088) {
param_1 = (double)((ulong)((double)(long)param_1 +
(double)(-(ulong)((double)(long)param_1 < param_1) & DAT_00102090)) |
~DAT_001020c0 & (ulong)param_1);
}
dVar2 = pow(DAT_00102080,(double)param_2);
dVar1 = round(dVar2 * param_1 * dVar1);
dVar2 = pow(DAT_00102080,(double)param_2);
return dVar1 / dVar2;
} |
7,215 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double a, int digits) {
double n = pow(10, -digits);
return round(ceil(a / n) * n * pow(10, digits)) / pow(10, digits);
}
| int main() {
assert(func0(123.01247,0) == 124);
assert(func0(123.01247,1) == 123.1);
assert(func0(123.01247,2) == 123.02);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %edi,%eax
pxor %xmm1,%xmm1
mov %edi,%ebx
neg %eax
cvtsi2sd %eax,%xmm1
sub $0x20,%rsp
movsd 0xe21(%rip),%xmm4
movsd %xmm0,0x8(%rsp)
movapd %xmm4,%xmm0
callq 1080 <pow@plt>
movsd 0x8(%rsp),%xmm2
movsd 0xe0c(%rip),%xmm5
movapd %xmm0,%xmm3
mov 0xdf9(%rip),%rax
divsd %xmm0,%xmm2
movsd 0xe2d(%rip),%xmm0
movq %rax,%xmm4
movapd %xmm2,%xmm1
andpd %xmm0,%xmm1
ucomisd %xmm1,%xmm5
jbe 12f9 <func0+0x99>
cvttsd2si %xmm2,%rax
pxor %xmm1,%xmm1
movapd %xmm2,%xmm5
movsd 0xdd5(%rip),%xmm6
andnpd %xmm2,%xmm0
movapd %xmm0,%xmm2
cvtsi2sd %rax,%xmm1
cmpnlesd %xmm1,%xmm5
andpd %xmm6,%xmm5
addsd %xmm5,%xmm1
orpd %xmm1,%xmm2
pxor %xmm1,%xmm1
movapd %xmm4,%xmm0
movsd %xmm2,0x18(%rsp)
cvtsi2sd %ebx,%xmm1
movsd %xmm3,0x8(%rsp)
movsd %xmm1,0x10(%rsp)
callq 1080 <pow@plt>
movsd 0x8(%rsp),%xmm3
movsd 0x18(%rsp),%xmm2
mulsd %xmm3,%xmm2
mulsd %xmm2,%xmm0
callq 1070 <round@plt>
mov 0xd64(%rip),%rax
movsd 0x10(%rsp),%xmm1
movsd %xmm0,0x8(%rsp)
movq %rax,%xmm0
callq 1080 <pow@plt>
movsd 0x8(%rsp),%xmm2
add $0x20,%rsp
pop %rbx
divsd %xmm0,%xmm2
movapd %xmm2,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov eax, edi
pxor xmm1, xmm1
mov ebx, edi
neg eax
cvtsi2sd xmm1, eax; y
sub rsp, 20h
movsd [rsp+28h+var_20], xmm0
movsd xmm0, cs:x; x
call _pow
movsd xmm2, [rsp+28h+var_20]
movsd xmm1, cs:qword_2098
movsd xmm4, cs:qword_2088
movapd xmm3, xmm0
divsd xmm2, xmm0
movapd xmm0, xmm2
andpd xmm0, xmm1
ucomisd xmm4, xmm0
jbe short loc_12E9
cvttsd2si rax, xmm2
pxor xmm0, xmm0
movapd xmm4, xmm2
movsd xmm5, cs:qword_2090
andnpd xmm1, xmm2
cvtsi2sd xmm0, rax
cmpnlesd xmm4, xmm0
andpd xmm4, xmm5
addsd xmm0, xmm4
movapd xmm2, xmm0
orpd xmm2, xmm1
loc_12E9:
pxor xmm1, xmm1
movsd xmm0, cs:x; x
movsd [rsp+28h+var_10], xmm2
cvtsi2sd xmm1, ebx; y
movsd [rsp+28h+var_20], xmm3
movsd [rsp+28h+y], xmm1
call _pow
movsd xmm3, [rsp+28h+var_20]
movsd xmm2, [rsp+28h+var_10]
mulsd xmm2, xmm3
mulsd xmm0, xmm2; x
call _round
movsd xmm1, [rsp+28h+y]; y
movsd [rsp+28h+var_20], xmm0
movsd xmm0, cs:x; x
call _pow
movsd xmm2, [rsp+28h+var_20]
add rsp, 20h
pop rbx
divsd xmm2, xmm0
movapd xmm0, xmm2
retn | __int128 __usercall func0@<xmm0>(int a1@<edi>, double a2@<xmm0>)
{
double v2; // xmm3_8
__m128d v3; // xmm2
__m128d v4; // xmm0
double v5; // xmm0_8
__int128 v6; // xmm2
double v9; // [rsp+0h] [rbp-20h]
v3 = (__m128d)*(unsigned long long *)&a2;
v2 = pow(10.0, (double)-a1);
v3.m128d_f64[0] = a2 / v2;
if ( fabs(a2 / v2) < 4.503599627370496e15 )
{
v4.m128d_f64[0] = (double)(int)v3.m128d_f64[0];
*(_QWORD *)&v3.m128d_f64[0] = COERCE_UNSIGNED_INT64(
v4.m128d_f64[0]
+ COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(v3, v4) & 0x3FF0000000000000LL)) | *(_QWORD *)&v3.m128d_f64[0] & 0x8000000000000000LL;
}
v5 = pow(10.0, (double)a1);
v9 = round(v5 * (v3.m128d_f64[0] * v2));
v6 = *(unsigned long long *)&v9;
*(double *)&v6 = v9 / pow(10.0, (double)a1);
return v6;
} | func0:
ENDBR64
PUSH RBX
MOV EAX,EDI
PXOR XMM1,XMM1
MOV EBX,EDI
NEG EAX
CVTSI2SD XMM1,EAX
SUB RSP,0x20
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD XMM0,qword ptr [0x00102080]
CALL 0x00101080
MOVSD XMM2,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [0x00102098]
MOVSD XMM4,qword ptr [0x00102088]
MOVAPD XMM3,XMM0
DIVSD XMM2,XMM0
MOVAPD XMM0,XMM2
ANDPD XMM0,XMM1
UCOMISD XMM4,XMM0
JBE 0x001012e9
CVTTSD2SI RAX,XMM2
PXOR XMM0,XMM0
MOVAPD XMM4,XMM2
MOVSD XMM5,qword ptr [0x00102090]
ANDNPD XMM1,XMM2
CVTSI2SD XMM0,RAX
CMPNLESD XMM4,XMM0
ANDPD XMM4,XMM5
ADDSD XMM0,XMM4
MOVAPD XMM2,XMM0
ORPD XMM2,XMM1
LAB_001012e9:
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102080]
MOVSD qword ptr [RSP + 0x18],XMM2
CVTSI2SD XMM1,EBX
MOVSD qword ptr [RSP + 0x8],XMM3
MOVSD qword ptr [RSP + 0x10],XMM1
CALL 0x00101080
MOVSD XMM3,qword ptr [RSP + 0x8]
MOVSD XMM2,qword ptr [RSP + 0x18]
MULSD XMM2,XMM3
MULSD XMM0,XMM2
CALL 0x00101070
MOVSD XMM1,qword ptr [RSP + 0x10]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD XMM0,qword ptr [0x00102080]
CALL 0x00101080
MOVSD XMM2,qword ptr [RSP + 0x8]
ADD RSP,0x20
POP RBX
DIVSD XMM2,XMM0
MOVAPD XMM0,XMM2
RET | double func0(double param_1,int param_2)
{
double dVar1;
double dVar2;
dVar1 = pow(DAT_00102080,(double)-param_2);
param_1 = param_1 / dVar1;
if ((double)((ulong)param_1 & DAT_00102098) < DAT_00102088) {
param_1 = (double)((ulong)((double)(long)param_1 +
(double)(-(ulong)((double)(long)param_1 < param_1) & DAT_00102090)) |
~DAT_00102098 & (ulong)param_1);
}
dVar2 = pow(DAT_00102080,(double)param_2);
dVar1 = round(dVar2 * param_1 * dVar1);
dVar2 = pow(DAT_00102080,(double)param_2);
return dVar1 / dVar2;
} |
7,216 | 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, 1, 1, 1};
int arr2[] = {1, 5, 1};
int arr3[] = {3, 2, 1, 7, 8, 9};
assert(func0(arr1, 4) == 6);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 6) == 0);
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
jne 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
jnz 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
JNZ 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;
} |
7,217 | 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, 1, 1, 1};
int arr2[] = {1, 5, 1};
int arr3[] = {3, 2, 1, 7, 8, 9};
assert(func0(arr1, 4) == 6);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 6) == 0);
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,%ecx
jmp 119c <func0+0x33>
add $0x1,%rax
cmp %eax,%esi
jle 1198 <func0+0x2f>
cmp (%rdi,%rax,4),%edx
jne 1186 <func0+0x1d>
add $0x1,%ecx
jmp 1186 <func0+0x1d>
add $0x1,%r8
cmp %r9,%r8
je 11b0 <func0+0x47>
mov -0x4(%rdi,%r8,4),%edx
mov %r8,%rax
jmp 118e <func0+0x25>
mov $0x0,%ecx
mov %ecx,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_11A6
mov r9d, esi
mov r8d, 1
mov ecx, 0
jmp short loc_1197
loc_1181:
add rax, 1
cmp esi, eax
jle short loc_1193
loc_1189:
cmp edx, [rdi+rax*4]
jnz short loc_1181
add ecx, 1
jmp short loc_1181
loc_1193:
add r8, 1
loc_1197:
cmp r8, r9
jz short loc_11AB
mov edx, [rdi+r8*4-4]
mov rax, r8
jmp short loc_1189
loc_11A6:
mov ecx, 0
loc_11AB:
mov eax, ecx
retn | long long func0(long long a1, int a2)
{
long long v2; // r8
unsigned int v3; // ecx
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 ECX,0x0
JMP 0x00101197
LAB_00101181:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101193
LAB_00101189:
CMP EDX,dword ptr [RDI + RAX*0x4]
JNZ 0x00101181
ADD ECX,0x1
JMP 0x00101181
LAB_00101193:
ADD R8,0x1
LAB_00101197:
CMP R8,R9
JZ 0x001011ab
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
JMP 0x00101189
LAB_001011a6:
MOV ECX,0x0
LAB_001011ab:
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 {
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;
} |
7,218 | 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, 1, 1, 1};
int arr2[] = {1, 5, 1};
int arr3[] = {3, 2, 1, 7, 8, 9};
assert(func0(arr1, 4) == 6);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 6) == 0);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 137e <func0+0x4e>
lea -0x1(%rsi),%r9d
mov $0x1,%ecx
xor %r8d,%r8d
add $0x1,%r9
cmp %r9,%rcx
je 137a <func0+0x4a>
nopl (%rax)
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
nopw 0x0(%rax,%rax,1)
cmp (%rdi,%rax,4),%edx
jne 1369 <func0+0x39>
add $0x1,%r8d
add $0x1,%rax
cmp %eax,%esi
jg 1360 <func0+0x30>
add $0x1,%rcx
cmp %r9,%rcx
jne 1350 <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_12EE
movsxd r9, esi
mov ecx, 1
xor r8d, r8d
cmp rcx, r9
jz short loc_12EA
nop dword ptr [rax+rax+00000000h]
loc_12C0:
mov edx, [rdi+rcx*4-4]
mov rax, rcx
nop word ptr [rax+rax+00000000h]
loc_12D0:
cmp edx, [rdi+rax*4]
jnz short loc_12D9
add r8d, 1
loc_12D9:
add rax, 1
cmp esi, eax
jg short loc_12D0
add rcx, 1
cmp rcx, r9
jnz short loc_12C0
loc_12EA:
mov eax, r8d
retn
loc_12EE:
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 0x001012ee
MOVSXD R9,ESI
MOV ECX,0x1
XOR R8D,R8D
CMP RCX,R9
JZ 0x001012ea
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
NOP word ptr [RAX + RAX*0x1]
LAB_001012d0:
CMP EDX,dword ptr [RDI + RAX*0x4]
JNZ 0x001012d9
ADD R8D,0x1
LAB_001012d9:
ADD RAX,0x1
CMP ESI,EAX
JG 0x001012d0
ADD RCX,0x1
CMP RCX,R9
JNZ 0x001012c0
LAB_001012ea:
MOV EAX,R8D
RET
LAB_001012ee:
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;
} |
7,219 | 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, 1, 1, 1};
int arr2[] = {1, 5, 1};
int arr3[] = {3, 2, 1, 7, 8, 9};
assert(func0(arr1, 4) == 6);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 6) == 0);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1439 <func0+0x129>
cmp $0x1,%esi
je 1439 <func0+0x129>
push %rbp
lea 0x4(%rdi),%r9
xor %r10d,%r10d
mov $0x1,%ecx
push %rbx
lea -0x1(%rsi),%ebp
mov $0x1,%ebx
nopl 0x0(%rax,%rax,1)
mov %esi,%r8d
mov %ebp,%eax
mov -0x4(%r9),%r11d
sub %ecx,%r8d
cmp %ecx,%esi
cmovle %ebx,%r8d
sub %ecx,%eax
cmp $0x3,%eax
jbe 1435 <func0+0x125>
cmp %ecx,%esi
jle 1435 <func0+0x125>
mov %r8d,%edx
movd %r11d,%xmm3
pxor %xmm1,%xmm1
mov %r9,%rax
shr $0x2,%edx
pshufd $0x0,%xmm3,%xmm2
shl $0x4,%rdx
add %r9,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
add $0x10,%rax
pcmpeqd %xmm2,%xmm0
psubd %xmm0,%xmm1
cmp %rax,%rdx
jne 1388 <func0+0x78>
movdqa %xmm1,%xmm0
mov %r8d,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%edx
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
add %eax,%r10d
lea (%rdx,%rcx,1),%eax
cmp %edx,%r8d
je 1420 <func0+0x110>
movslq %eax,%r8
cmp (%rdi,%r8,4),%r11d
lea 0x0(,%r8,4),%rdx
sete %r8b
movzbl %r8b,%r8d
add %r8d,%r10d
lea 0x1(%rax),%r8d
cmp %r8d,%esi
jle 1420 <func0+0x110>
cmp 0x4(%rdi,%rdx,1),%r11d
jne 13fa <func0+0xea>
add $0x1,%r10d
lea 0x2(%rax),%r8d
cmp %r8d,%esi
jle 1420 <func0+0x110>
cmp 0x8(%rdi,%rdx,1),%r11d
jne 140e <func0+0xfe>
add $0x1,%r10d
add $0x3,%eax
cmp %esi,%eax
jge 1420 <func0+0x110>
cmp 0xc(%rdi,%rdx,1),%r11d
jne 1420 <func0+0x110>
add $0x1,%r10d
add $0x1,%ecx
add $0x4,%r9
cmp %ecx,%esi
jne 1340 <func0+0x30>
mov %r10d,%eax
pop %rbx
pop %rbp
retq
mov %ecx,%eax
jmp 13cc <func0+0xbc>
xor %r10d,%r10d
mov %r10d,%eax
retq
| func0:
endbr64
test esi, esi
jle loc_1244
cmp esi, 1
jz loc_1244
push rbp
mov r11, rdi
lea r8, [rdi+4]
xor r10d, r10d
push rbx
mov ecx, 1
lea ebp, [rsi-1]
mov ebx, 1
xchg ax, ax
loc_1170:
mov edi, esi
mov eax, ebp
mov r9d, [r8-4]
sub edi, ecx
cmp esi, ecx
cmovle edi, ebx
sub eax, ecx
cmp eax, 2
jbe loc_1240
cmp esi, ecx
jle loc_1240
mov edx, edi
movd xmm3, r9d
pxor xmm1, xmm1
mov rax, r8
shr edx, 2
pshufd xmm2, xmm3, 0
shl rdx, 4
add rdx, r8
nop
loc_11B0:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pcmpeqd xmm0, xmm2
psubd xmm1, xmm0
cmp rax, rdx
jnz short loc_11B0
movdqa xmm0, xmm1
psrldq xmm0, 8
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
add r10d, eax
mov eax, edi
and eax, 0FFFFFFFCh
add eax, ecx
and edi, 3
jz short loc_122B
loc_11F2:
movsxd rdx, eax
lea rdi, ds:0[rdx*4]
cmp r9d, [r11+rdx*4]
jnz short loc_1207
add r10d, 1
loc_1207:
lea edx, [rax+1]
cmp esi, edx
jle short loc_122B
cmp r9d, [r11+rdi+4]
jnz short loc_1219
add r10d, 1
loc_1219:
add eax, 2
cmp esi, eax
jle short loc_122B
cmp r9d, [r11+rdi+8]
jnz short loc_122B
add r10d, 1
loc_122B:
add ecx, 1
add r8, 4
cmp esi, ecx
jnz loc_1170
mov eax, r10d
pop rbx
pop rbp
retn
loc_1240:
mov eax, ecx
jmp short loc_11F2
loc_1244:
xor r10d, r10d
mov eax, r10d
retn | long long func0(long long a1, int a2)
{
const __m128i *v3; // r8
unsigned int v4; // r10d
int v5; // ecx
unsigned int v6; // r9d
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(v11, v10));
}
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 0x00101244
CMP ESI,0x1
JZ 0x00101244
PUSH RBP
MOV R11,RDI
LEA R8,[RDI + 0x4]
XOR R10D,R10D
PUSH RBX
MOV ECX,0x1
LEA EBP,[RSI + -0x1]
MOV EBX,0x1
NOP
LAB_00101170:
MOV EDI,ESI
MOV EAX,EBP
MOV R9D,dword ptr [R8 + -0x4]
SUB EDI,ECX
CMP ESI,ECX
CMOVLE EDI,EBX
SUB EAX,ECX
CMP EAX,0x2
JBE 0x00101240
CMP ESI,ECX
JLE 0x00101240
MOV EDX,EDI
MOVD XMM3,R9D
PXOR XMM1,XMM1
MOV RAX,R8
SHR EDX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RDX,0x4
ADD RDX,R8
NOP
LAB_001011b0:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PCMPEQD XMM0,XMM2
PSUBD XMM1,XMM0
CMP RAX,RDX
JNZ 0x001011b0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x8
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
ADD R10D,EAX
MOV EAX,EDI
AND EAX,0xfffffffc
ADD EAX,ECX
AND EDI,0x3
JZ 0x0010122b
LAB_001011f2:
MOVSXD RDX,EAX
LEA RDI,[RDX*0x4]
CMP R9D,dword ptr [R11 + RDX*0x4]
JNZ 0x00101207
ADD R10D,0x1
LAB_00101207:
LEA EDX,[RAX + 0x1]
CMP ESI,EDX
JLE 0x0010122b
CMP R9D,dword ptr [R11 + RDI*0x1 + 0x4]
JNZ 0x00101219
ADD R10D,0x1
LAB_00101219:
ADD EAX,0x2
CMP ESI,EAX
JLE 0x0010122b
CMP R9D,dword ptr [R11 + RDI*0x1 + 0x8]
JNZ 0x0010122b
ADD R10D,0x1
LAB_0010122b:
ADD ECX,0x1
ADD R8,0x4
CMP ESI,ECX
JNZ 0x00101170
MOV EAX,R10D
POP RBX
POP RBP
RET
LAB_00101240:
MOV EAX,ECX
JMP 0x001011f2
LAB_00101244:
XOR R10D,R10D
MOV EAX,R10D
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 *piVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
if ((param_2 < 1) || (param_2 == 1)) {
return 0;
}
piVar10 = (int *)(param_1 + 4);
iVar11 = 0;
iVar9 = 1;
do {
iVar2 = piVar10[-1];
uVar3 = param_2 - iVar9;
if (param_2 <= iVar9) {
uVar3 = 1;
}
iVar12 = iVar9;
if (((uint)((param_2 + -1) - iVar9) < 3) || (param_2 <= iVar9)) {
LAB_001011f2:
lVar1 = (long)iVar12 * 4;
if (iVar2 == *(int *)(param_1 + (long)iVar12 * 4)) {
iVar11 = iVar11 + 1;
}
if (iVar12 + 1 < param_2) {
if (iVar2 == *(int *)(param_1 + 4 + lVar1)) {
iVar11 = iVar11 + 1;
}
if ((iVar12 + 2 < param_2) && (iVar2 == *(int *)(param_1 + 8 + lVar1))) {
iVar11 = iVar11 + 1;
}
}
}
else {
iVar12 = 0;
iVar13 = 0;
iVar14 = 0;
iVar15 = 0;
piVar8 = piVar10;
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 != piVar10 + (ulong)(uVar3 >> 2) * 4);
iVar11 = iVar11 + iVar12 + iVar14 + iVar13 + iVar15;
iVar12 = (uVar3 & 0xfffffffc) + iVar9;
if ((uVar3 & 3) != 0) goto LAB_001011f2;
}
iVar9 = iVar9 + 1;
piVar10 = piVar10 + 1;
if (param_2 == iVar9) {
return iVar11;
}
} while( true );
} |
7,220 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(const char *input) {
int max = 0;
char temp[256]; // Temporary string for holding digits
int index = 0;
for (int i = 0; input[i] != '\0'; i++) {
if (input[i] >= '0' && input[i] <= '9') {
temp[index++] = input[i]; // collect digits
} else {
if (index != 0) {
temp[index] = '\0'; // null terminate the temporary string
int number = atoi(temp); // convert to integer
if (number > max)
max = number; // find maximum
index = 0;
}
}
}
// Check the last number in the string
if (index != 0) {
temp[index] = '\0';
int number = atoi(temp);
if (number > max)
max = number;
}
return max;
}
| int main() {
assert(func0("100klh564abc365bg") == 564);
assert(func0("hello300how546mer231") == 546);
assert(func0("its233beenalong343journey234") == 343);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x140,%rsp
mov %rdi,-0x138(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x124(%rbp)
movl $0x0,-0x120(%rbp)
movl $0x0,-0x11c(%rbp)
jmpq 128f <func0+0x106>
mov -0x11c(%rbp),%eax
movslq %eax,%rdx
mov -0x138(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2f,%al
jle 1236 <func0+0xad>
mov -0x11c(%rbp),%eax
movslq %eax,%rdx
mov -0x138(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x39,%al
jg 1236 <func0+0xad>
mov -0x11c(%rbp),%eax
movslq %eax,%rdx
mov -0x138(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x120(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x120(%rbp)
movzbl (%rcx),%edx
cltq
mov %dl,-0x110(%rbp,%rax,1)
jmp 1288 <func0+0xff>
cmpl $0x0,-0x120(%rbp)
je 1288 <func0+0xff>
mov -0x120(%rbp),%eax
cltq
movb $0x0,-0x110(%rbp,%rax,1)
lea -0x110(%rbp),%rax
mov %rax,%rdi
callq 1090 <atoi@plt>
mov %eax,-0x114(%rbp)
mov -0x114(%rbp),%eax
cmp -0x124(%rbp),%eax
jle 127e <func0+0xf5>
mov -0x114(%rbp),%eax
mov %eax,-0x124(%rbp)
movl $0x0,-0x120(%rbp)
addl $0x1,-0x11c(%rbp)
mov -0x11c(%rbp),%eax
movslq %eax,%rdx
mov -0x138(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11d1 <func0+0x48>
cmpl $0x0,-0x120(%rbp)
je 12f5 <func0+0x16c>
mov -0x120(%rbp),%eax
cltq
movb $0x0,-0x110(%rbp,%rax,1)
lea -0x110(%rbp),%rax
mov %rax,%rdi
callq 1090 <atoi@plt>
mov %eax,-0x118(%rbp)
mov -0x118(%rbp),%eax
cmp -0x124(%rbp),%eax
jle 12f5 <func0+0x16c>
mov -0x118(%rbp),%eax
mov %eax,-0x124(%rbp)
mov -0x124(%rbp),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 130f <func0+0x186>
callq 1070 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 140h
mov [rbp+var_138], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_124], 0
mov [rbp+var_120], 0
mov [rbp+var_11C], 0
jmp loc_128F
loc_11D1:
mov eax, [rbp+var_11C]
movsxd rdx, eax
mov rax, [rbp+var_138]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Fh ; '/'
jle short loc_1236
mov eax, [rbp+var_11C]
movsxd rdx, eax
mov rax, [rbp+var_138]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 39h ; '9'
jg short loc_1236
mov eax, [rbp+var_11C]
movsxd rdx, eax
mov rax, [rbp+var_138]
lea rcx, [rdx+rax]
mov eax, [rbp+var_120]
lea edx, [rax+1]
mov [rbp+var_120], edx
movzx edx, byte ptr [rcx]
cdqe
mov [rbp+rax+nptr], dl
jmp short loc_1288
loc_1236:
cmp [rbp+var_120], 0
jz short loc_1288
mov eax, [rbp+var_120]
cdqe
mov [rbp+rax+nptr], 0
lea rax, [rbp+nptr]
mov rdi, rax; nptr
call _atoi
mov [rbp+var_114], eax
mov eax, [rbp+var_114]
cmp eax, [rbp+var_124]
jle short loc_127E
mov eax, [rbp+var_114]
mov [rbp+var_124], eax
loc_127E:
mov [rbp+var_120], 0
loc_1288:
add [rbp+var_11C], 1
loc_128F:
mov eax, [rbp+var_11C]
movsxd rdx, eax
mov rax, [rbp+var_138]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_11D1
cmp [rbp+var_120], 0
jz short loc_12F5
mov eax, [rbp+var_120]
cdqe
mov [rbp+rax+nptr], 0
lea rax, [rbp+nptr]
mov rdi, rax; nptr
call _atoi
mov [rbp+var_118], eax
mov eax, [rbp+var_118]
cmp eax, [rbp+var_124]
jle short loc_12F5
mov eax, [rbp+var_118]
mov [rbp+var_124], eax
loc_12F5:
mov eax, [rbp+var_124]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_130F
call ___stack_chk_fail
locret_130F:
leave
retn | long long func0(long long a1)
{
int v1; // eax
int v3; // [rsp+1Ch] [rbp-124h]
int v4; // [rsp+20h] [rbp-120h]
int i; // [rsp+24h] [rbp-11Ch]
int v6; // [rsp+28h] [rbp-118h]
int v7; // [rsp+2Ch] [rbp-114h]
char nptr[264]; // [rsp+30h] [rbp-110h] BYREF
unsigned long long v9; // [rsp+138h] [rbp-8h]
v9 = __readfsqword(0x28u);
v3 = 0;
v4 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( *(char *)(i + a1) <= 47 || *(char *)(i + a1) > 57 )
{
if ( v4 )
{
nptr[v4] = 0;
v7 = atoi(nptr);
if ( v7 > v3 )
v3 = v7;
v4 = 0;
}
}
else
{
v1 = v4++;
nptr[v1] = *(_BYTE *)(i + a1);
}
}
if ( v4 )
{
nptr[v4] = 0;
v6 = atoi(nptr);
if ( v6 > v3 )
return (unsigned int)v6;
}
return (unsigned int)v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x140
MOV qword ptr [RBP + -0x138],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x124],0x0
MOV dword ptr [RBP + -0x120],0x0
MOV dword ptr [RBP + -0x11c],0x0
JMP 0x0010128f
LAB_001011d1:
MOV EAX,dword ptr [RBP + -0x11c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x138]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2f
JLE 0x00101236
MOV EAX,dword ptr [RBP + -0x11c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x138]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x39
JG 0x00101236
MOV EAX,dword ptr [RBP + -0x11c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x138]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x120]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x120],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x110],DL
JMP 0x00101288
LAB_00101236:
CMP dword ptr [RBP + -0x120],0x0
JZ 0x00101288
MOV EAX,dword ptr [RBP + -0x120]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x110],0x0
LEA RAX,[RBP + -0x110]
MOV RDI,RAX
CALL 0x00101090
MOV dword ptr [RBP + -0x114],EAX
MOV EAX,dword ptr [RBP + -0x114]
CMP EAX,dword ptr [RBP + -0x124]
JLE 0x0010127e
MOV EAX,dword ptr [RBP + -0x114]
MOV dword ptr [RBP + -0x124],EAX
LAB_0010127e:
MOV dword ptr [RBP + -0x120],0x0
LAB_00101288:
ADD dword ptr [RBP + -0x11c],0x1
LAB_0010128f:
MOV EAX,dword ptr [RBP + -0x11c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x138]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011d1
CMP dword ptr [RBP + -0x120],0x0
JZ 0x001012f5
MOV EAX,dword ptr [RBP + -0x120]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x110],0x0
LEA RAX,[RBP + -0x110]
MOV RDI,RAX
CALL 0x00101090
MOV dword ptr [RBP + -0x118],EAX
MOV EAX,dword ptr [RBP + -0x118]
CMP EAX,dword ptr [RBP + -0x124]
JLE 0x001012f5
MOV EAX,dword ptr [RBP + -0x118]
MOV dword ptr [RBP + -0x124],EAX
LAB_001012f5:
MOV EAX,dword ptr [RBP + -0x124]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010130f
CALL 0x00101070
LAB_0010130f:
LEAVE
RET | int func0(long param_1)
{
int iVar1;
long in_FS_OFFSET;
int local_12c;
int local_128;
int local_124;
char local_118 [264];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_12c = 0;
local_128 = 0;
for (local_124 = 0; *(char *)(param_1 + local_124) != '\0'; local_124 = local_124 + 1) {
if ((*(char *)(param_1 + local_124) < '0') || ('9' < *(char *)(param_1 + local_124))) {
if (local_128 != 0) {
local_118[local_128] = '\0';
iVar1 = atoi(local_118);
if (local_12c < iVar1) {
local_12c = iVar1;
}
local_128 = 0;
}
}
else {
local_118[local_128] = *(char *)(local_124 + param_1);
local_128 = local_128 + 1;
}
}
if (local_128 != 0) {
local_118[local_128] = '\0';
iVar1 = atoi(local_118);
if (local_12c < iVar1) {
local_12c = iVar1;
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_12c;
} |
7,221 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(const char *input) {
int max = 0;
char temp[256]; // Temporary string for holding digits
int index = 0;
for (int i = 0; input[i] != '\0'; i++) {
if (input[i] >= '0' && input[i] <= '9') {
temp[index++] = input[i]; // collect digits
} else {
if (index != 0) {
temp[index] = '\0'; // null terminate the temporary string
int number = atoi(temp); // convert to integer
if (number > max)
max = number; // find maximum
index = 0;
}
}
}
// Check the last number in the string
if (index != 0) {
temp[index] = '\0';
int number = atoi(temp);
if (number > max)
max = number;
}
return max;
}
| int main() {
assert(func0("100klh564abc365bg") == 564);
assert(func0("hello300how546mer231") == 546);
assert(func0("its233beenalong343journey234") == 343);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x110,%rsp
mov %fs:0x28,%rax
mov %rax,0x108(%rsp)
xor %eax,%eax
movzbl (%rdi),%eax
test %al,%al
je 1256 <func0+0xcd>
lea 0x1(%rdi),%rbx
mov $0x0,%edx
mov $0x0,%ebp
mov %rsp,%r12
jmp 11d9 <func0+0x50>
test %edx,%edx
jne 11ec <func0+0x63>
add $0x1,%rbx
movzbl -0x1(%rbx),%eax
test %al,%al
je 1211 <func0+0x88>
lea -0x30(%rax),%ecx
cmp $0x9,%cl
ja 11c9 <func0+0x40>
movslq %edx,%rcx
mov %al,(%rsp,%rcx,1)
lea 0x1(%rdx),%edx
jmp 11cd <func0+0x44>
movslq %edx,%rdx
movb $0x0,(%rsp,%rdx,1)
mov $0xa,%edx
mov $0x0,%esi
mov %r12,%rdi
callq 1090 <strtol@plt>
cmp %eax,%ebp
cmovl %eax,%ebp
mov $0x0,%edx
jmp 11cd <func0+0x44>
test %edx,%edx
jne 1236 <func0+0xad>
mov 0x108(%rsp),%rax
xor %fs:0x28,%rax
jne 125d <func0+0xd4>
mov %ebp,%eax
add $0x110,%rsp
pop %rbx
pop %rbp
pop %r12
retq
movslq %edx,%rdx
movb $0x0,(%rsp,%rdx,1)
mov %rsp,%rdi
mov $0xa,%edx
mov $0x0,%esi
callq 1090 <strtol@plt>
cmp %eax,%ebp
cmovl %eax,%ebp
jmp 1215 <func0+0x8c>
mov $0x0,%ebp
jmp 1215 <func0+0x8c>
callq 1070 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 110h
mov rax, fs:28h
mov [rsp+128h+var_20], rax
xor eax, eax
movzx eax, byte ptr [rdi]
test al, al
jz loc_1256
lea rbx, [rdi+1]
mov edx, 0
mov ebp, 0
mov r12, rsp
jmp short loc_11D9
loc_11C9:
test edx, edx
jnz short loc_11EC
loc_11CD:
add rbx, 1
movzx eax, byte ptr [rbx-1]
test al, al
jz short loc_1211
loc_11D9:
lea ecx, [rax-30h]
cmp cl, 9
ja short loc_11C9
movsxd rcx, edx
mov [rsp+rcx+128h+var_128], al
lea edx, [rdx+1]
jmp short loc_11CD
loc_11EC:
movsxd rdx, edx
mov [rsp+rdx+128h+var_128], 0
mov edx, 0Ah
mov esi, 0
mov rdi, r12
call _strtol
cmp ebp, eax
cmovl ebp, eax
mov edx, 0
jmp short loc_11CD
loc_1211:
test edx, edx
jnz short loc_1236
loc_1215:
mov rax, [rsp+128h+var_20]
sub rax, fs:28h
jnz short loc_125D
mov eax, ebp
add rsp, 110h
pop rbx
pop rbp
pop r12
retn
loc_1236:
movsxd rdx, edx
mov [rsp+rdx+128h+var_128], 0
mov rdi, rsp
mov edx, 0Ah
mov esi, 0
call _strtol
cmp ebp, eax
cmovl ebp, eax
jmp short loc_1215
loc_1256:
mov ebp, 0
jmp short loc_1215
loc_125D:
call ___stack_chk_fail | long long func0(char *a1)
{
char v1; // al
char *v2; // rbx
int v3; // edx
signed int v4; // ebp
int v5; // eax
unsigned int v7; // eax
_BYTE v8[264]; // [rsp+0h] [rbp-128h] BYREF
unsigned long long v9; // [rsp+108h] [rbp-20h]
v9 = __readfsqword(0x28u);
v1 = *a1;
if ( *a1 )
{
v2 = a1 + 1;
v3 = 0;
v4 = 0;
do
{
if ( (unsigned __int8)(v1 - 48) > 9u )
{
if ( v3 )
{
v8[v3] = 0;
v5 = strtol(v8, 0LL, 10LL);
if ( v4 < v5 )
v4 = v5;
v3 = 0;
}
}
else
{
v8[v3++] = v1;
}
v1 = *v2++;
}
while ( v1 );
if ( v3 )
{
v8[v3] = 0;
v7 = strtol(v8, 0LL, 10LL);
if ( v4 < (int)v7 )
return v7;
}
}
else
{
return 0;
}
return (unsigned int)v4;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x110
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x108],RAX
XOR EAX,EAX
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101256
LEA RBX,[RDI + 0x1]
MOV EDX,0x0
MOV EBP,0x0
MOV R12,RSP
JMP 0x001011d9
LAB_001011c9:
TEST EDX,EDX
JNZ 0x001011ec
LAB_001011cd:
ADD RBX,0x1
MOVZX EAX,byte ptr [RBX + -0x1]
TEST AL,AL
JZ 0x00101211
LAB_001011d9:
LEA ECX,[RAX + -0x30]
CMP CL,0x9
JA 0x001011c9
MOVSXD RCX,EDX
MOV byte ptr [RSP + RCX*0x1],AL
LEA EDX,[RDX + 0x1]
JMP 0x001011cd
LAB_001011ec:
MOVSXD RDX,EDX
MOV byte ptr [RSP + RDX*0x1],0x0
MOV EDX,0xa
MOV ESI,0x0
MOV RDI,R12
CALL 0x00101090
CMP EBP,EAX
CMOVL EBP,EAX
MOV EDX,0x0
JMP 0x001011cd
LAB_00101211:
TEST EDX,EDX
JNZ 0x00101236
LAB_00101215:
MOV RAX,qword ptr [RSP + 0x108]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010125d
MOV EAX,EBP
ADD RSP,0x110
POP RBX
POP RBP
POP R12
RET
LAB_00101236:
MOVSXD RDX,EDX
MOV byte ptr [RSP + RDX*0x1],0x0
MOV RDI,RSP
MOV EDX,0xa
MOV ESI,0x0
CALL 0x00101090
CMP EBP,EAX
CMOVL EBP,EAX
JMP 0x00101215
LAB_00101256:
MOV EBP,0x0
JMP 0x00101215
LAB_0010125d:
CALL 0x00101070 | int func0(char *param_1)
{
char cVar1;
long lVar2;
int iVar3;
char *pcVar4;
int iVar5;
long in_FS_OFFSET;
char local_128 [264];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar5 = 0;
}
else {
iVar3 = 0;
iVar5 = 0;
pcVar4 = param_1 + 1;
do {
if ((byte)(cVar1 - 0x30U) < 10) {
local_128[iVar3] = cVar1;
iVar3 = iVar3 + 1;
}
else if (iVar3 != 0) {
local_128[iVar3] = '\0';
lVar2 = strtol(local_128,(char **)0x0,10);
if (iVar5 < (int)lVar2) {
iVar5 = (int)lVar2;
}
iVar3 = 0;
}
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
} while (cVar1 != '\0');
if (iVar3 != 0) {
local_128[iVar3] = '\0';
lVar2 = strtol(local_128,(char **)0x0,10);
if (iVar5 < (int)lVar2) {
iVar5 = (int)lVar2;
}
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar5;
} |
7,222 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(const char *input) {
int max = 0;
char temp[256]; // Temporary string for holding digits
int index = 0;
for (int i = 0; input[i] != '\0'; i++) {
if (input[i] >= '0' && input[i] <= '9') {
temp[index++] = input[i]; // collect digits
} else {
if (index != 0) {
temp[index] = '\0'; // null terminate the temporary string
int number = atoi(temp); // convert to integer
if (number > max)
max = number; // find maximum
index = 0;
}
}
}
// Check the last number in the string
if (index != 0) {
temp[index] = '\0';
int number = atoi(temp);
if (number > max)
max = number;
}
return max;
}
| int main() {
assert(func0("100klh564abc365bg") == 564);
assert(func0("hello300how546mer231") == 546);
assert(func0("its233beenalong343journey234") == 343);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x110,%rsp
mov %fs:0x28,%rax
mov %rax,0x108(%rsp)
xor %eax,%eax
movzbl (%rdi),%eax
test %al,%al
je 1318 <func0+0xd8>
lea 0x1(%rdi),%rbx
xor %edx,%edx
xor %r12d,%r12d
mov %rsp,%rbp
jmp 1294 <func0+0x54>
nopl 0x0(%rax,%rax,1)
movslq %edx,%rcx
add $0x1,%edx
mov %al,(%rsp,%rcx,1)
movzbl (%rbx),%eax
add $0x1,%rbx
test %al,%al
je 12d0 <func0+0x90>
lea -0x30(%rax),%ecx
cmp $0x9,%cl
jbe 1280 <func0+0x40>
test %edx,%edx
je 1289 <func0+0x49>
movslq %edx,%rdx
xor %esi,%esi
mov %rbp,%rdi
movb $0x0,(%rsp,%rdx,1)
mov $0xa,%edx
callq 1090 <strtol@plt>
cmp %eax,%r12d
cmovl %eax,%r12d
movzbl (%rbx),%eax
add $0x1,%rbx
xor %edx,%edx
test %al,%al
jne 1294 <func0+0x54>
nopw 0x0(%rax,%rax,1)
test %edx,%edx
je 12f1 <func0+0xb1>
movslq %edx,%rdx
xor %esi,%esi
mov %rsp,%rdi
movb $0x0,(%rsp,%rdx,1)
mov $0xa,%edx
callq 1090 <strtol@plt>
cmp %eax,%r12d
cmovl %eax,%r12d
mov 0x108(%rsp),%rax
xor %fs:0x28,%rax
jne 131d <func0+0xdd>
add $0x110,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
xor %r12d,%r12d
jmp 12f1 <func0+0xb1>
callq 1070 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 110h
mov rax, fs:28h
mov [rsp+128h+var_20], rax
xor eax, eax
movzx eax, byte ptr [rdi]
test al, al
jz loc_1318
lea rbx, [rdi+1]
xor edx, edx
xor r12d, r12d
mov rbp, rsp
jmp short loc_1294
loc_1280:
movsxd rcx, edx
add edx, 1
mov [rsp+rcx+128h+var_128], al
loc_1289:
movzx eax, byte ptr [rbx]
add rbx, 1
test al, al
jz short loc_12D0
loc_1294:
lea ecx, [rax-30h]
cmp cl, 9
jbe short loc_1280
test edx, edx
jz short loc_1289
movsxd rdx, edx
xor esi, esi
mov rdi, rbp
mov [rsp+rdx+128h+var_128], 0
mov edx, 0Ah
call _strtol
cmp r12d, eax
cmovl r12d, eax
movzx eax, byte ptr [rbx]
add rbx, 1
xor edx, edx
test al, al
jnz short loc_1294
nop word ptr [rax+rax+00h]
loc_12D0:
test edx, edx
jz short loc_12F1
movsxd rdx, edx
xor esi, esi
mov rdi, rsp
mov [rsp+rdx+128h+var_128], 0
mov edx, 0Ah
call _strtol
cmp r12d, eax
cmovl r12d, eax
loc_12F1:
mov rax, [rsp+128h+var_20]
sub rax, fs:28h
jnz short loc_131D
add rsp, 110h
mov eax, r12d
pop rbx
pop rbp
pop r12
retn
loc_1318:
xor r12d, r12d
jmp short loc_12F1
loc_131D:
call ___stack_chk_fail | long long func0(char *a1)
{
char v1; // al
char *v2; // rbx
int v3; // edx
signed int v4; // r12d
long long v5; // rcx
int v6; // eax
unsigned int v7; // eax
_BYTE v9[264]; // [rsp+0h] [rbp-128h] BYREF
unsigned long long v10; // [rsp+108h] [rbp-20h]
v10 = __readfsqword(0x28u);
v1 = *a1;
if ( !*a1 )
return 0;
v2 = a1 + 1;
v3 = 0;
v4 = 0;
do
{
while ( (unsigned __int8)(v1 - 48) <= 9u )
{
v5 = v3++;
v9[v5] = v1;
LABEL_4:
v1 = *v2++;
if ( !v1 )
goto LABEL_10;
}
if ( !v3 )
goto LABEL_4;
v9[v3] = 0;
v6 = strtol(v9, 0LL, 10LL);
if ( v4 < v6 )
v4 = v6;
v1 = *v2++;
v3 = 0;
}
while ( v1 );
LABEL_10:
if ( v3 )
{
v9[v3] = 0;
v7 = strtol(v9, 0LL, 10LL);
if ( v4 < (int)v7 )
return v7;
}
return (unsigned int)v4;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x110
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x108],RAX
XOR EAX,EAX
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101318
LEA RBX,[RDI + 0x1]
XOR EDX,EDX
XOR R12D,R12D
MOV RBP,RSP
JMP 0x00101294
LAB_00101280:
MOVSXD RCX,EDX
ADD EDX,0x1
MOV byte ptr [RSP + RCX*0x1],AL
LAB_00101289:
MOVZX EAX,byte ptr [RBX]
ADD RBX,0x1
TEST AL,AL
JZ 0x001012d0
LAB_00101294:
LEA ECX,[RAX + -0x30]
CMP CL,0x9
JBE 0x00101280
TEST EDX,EDX
JZ 0x00101289
MOVSXD RDX,EDX
XOR ESI,ESI
MOV RDI,RBP
MOV byte ptr [RSP + RDX*0x1],0x0
MOV EDX,0xa
CALL 0x00101090
CMP R12D,EAX
CMOVL R12D,EAX
MOVZX EAX,byte ptr [RBX]
ADD RBX,0x1
XOR EDX,EDX
TEST AL,AL
JNZ 0x00101294
NOP word ptr [RAX + RAX*0x1]
LAB_001012d0:
TEST EDX,EDX
JZ 0x001012f1
MOVSXD RDX,EDX
XOR ESI,ESI
MOV RDI,RSP
MOV byte ptr [RSP + RDX*0x1],0x0
MOV EDX,0xa
CALL 0x00101090
CMP R12D,EAX
CMOVL R12D,EAX
LAB_001012f1:
MOV RAX,qword ptr [RSP + 0x108]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010131d
ADD RSP,0x110
MOV EAX,R12D
POP RBX
POP RBP
POP R12
RET
LAB_00101318:
XOR R12D,R12D
JMP 0x001012f1
LAB_0010131d:
CALL 0x00101070 | int func0(char *param_1)
{
char cVar1;
long lVar2;
int iVar3;
int iVar4;
long in_FS_OFFSET;
char local_128 [264];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar4 = 0;
}
else {
param_1 = param_1 + 1;
iVar3 = 0;
iVar4 = 0;
do {
while ((byte)(cVar1 - 0x30U) < 10) {
lVar2 = (long)iVar3;
iVar3 = iVar3 + 1;
local_128[lVar2] = cVar1;
LAB_00101289:
cVar1 = *param_1;
param_1 = param_1 + 1;
if (cVar1 == '\0') goto LAB_001012d0;
}
if (iVar3 == 0) goto LAB_00101289;
local_128[iVar3] = '\0';
lVar2 = strtol(local_128,(char **)0x0,10);
if (iVar4 < (int)lVar2) {
iVar4 = (int)lVar2;
}
cVar1 = *param_1;
param_1 = param_1 + 1;
iVar3 = 0;
} while (cVar1 != '\0');
LAB_001012d0:
if (iVar3 != 0) {
local_128[iVar3] = '\0';
lVar2 = strtol(local_128,(char **)0x0,10);
if (iVar4 < (int)lVar2) {
iVar4 = (int)lVar2;
}
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar4;
} |
7,223 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(const char *input) {
int max = 0;
char temp[256]; // Temporary string for holding digits
int index = 0;
for (int i = 0; input[i] != '\0'; i++) {
if (input[i] >= '0' && input[i] <= '9') {
temp[index++] = input[i]; // collect digits
} else {
if (index != 0) {
temp[index] = '\0'; // null terminate the temporary string
int number = atoi(temp); // convert to integer
if (number > max)
max = number; // find maximum
index = 0;
}
}
}
// Check the last number in the string
if (index != 0) {
temp[index] = '\0';
int number = atoi(temp);
if (number > max)
max = number;
}
return max;
}
| int main() {
assert(func0("100klh564abc365bg") == 564);
assert(func0("hello300how546mer231") == 546);
assert(func0("its233beenalong343journey234") == 343);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x110,%rsp
mov %fs:0x28,%rax
mov %rax,0x108(%rsp)
xor %eax,%eax
movzbl (%rdi),%eax
test %al,%al
je 1318 <func0+0xd8>
lea 0x1(%rdi),%rbx
xor %edx,%edx
xor %r12d,%r12d
mov %rsp,%rbp
jmp 1294 <func0+0x54>
nopl 0x0(%rax,%rax,1)
movslq %edx,%rcx
add $0x1,%edx
mov %al,(%rsp,%rcx,1)
movzbl (%rbx),%eax
add $0x1,%rbx
test %al,%al
je 12d0 <func0+0x90>
lea -0x30(%rax),%ecx
cmp $0x9,%cl
jbe 1280 <func0+0x40>
test %edx,%edx
je 1289 <func0+0x49>
movslq %edx,%rdx
xor %esi,%esi
mov %rbp,%rdi
movb $0x0,(%rsp,%rdx,1)
mov $0xa,%edx
callq 1090 <strtol@plt>
cmp %eax,%r12d
cmovl %eax,%r12d
movzbl (%rbx),%eax
add $0x1,%rbx
xor %edx,%edx
test %al,%al
jne 1294 <func0+0x54>
nopw 0x0(%rax,%rax,1)
test %edx,%edx
je 12f1 <func0+0xb1>
movslq %edx,%rdx
xor %esi,%esi
mov %rsp,%rdi
movb $0x0,(%rsp,%rdx,1)
mov $0xa,%edx
callq 1090 <strtol@plt>
cmp %eax,%r12d
cmovl %eax,%r12d
mov 0x108(%rsp),%rax
xor %fs:0x28,%rax
jne 131d <func0+0xdd>
add $0x110,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
xor %r12d,%r12d
jmp 12f1 <func0+0xb1>
callq 1070 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 110h
mov rax, fs:28h
mov [rsp+128h+var_20], rax
xor eax, eax
movzx eax, byte ptr [rdi]
test al, al
jz loc_1318
lea rbx, [rdi+1]
xor edx, edx
xor r12d, r12d
mov rbp, rsp
jmp short loc_1294
loc_1280:
movsxd rcx, edx
add edx, 1
mov [rsp+rcx+128h+var_128], al
loc_1289:
movzx eax, byte ptr [rbx]
add rbx, 1
test al, al
jz short loc_12D0
loc_1294:
lea ecx, [rax-30h]
cmp cl, 9
jbe short loc_1280
test edx, edx
jz short loc_1289
movsxd rdx, edx
xor esi, esi; endptr
mov rdi, rbp; nptr
mov [rsp+rdx+128h+var_128], 0
mov edx, 0Ah; base
call _strtol
cmp r12d, eax
cmovl r12d, eax
movzx eax, byte ptr [rbx]
add rbx, 1
xor edx, edx
test al, al
jnz short loc_1294
nop word ptr [rax+rax+00h]
loc_12D0:
test edx, edx
jz short loc_12F1
movsxd rdx, edx
xor esi, esi; endptr
mov rdi, rsp; nptr
mov [rsp+rdx+128h+var_128], 0
mov edx, 0Ah; base
call _strtol
cmp r12d, eax
cmovl r12d, eax
loc_12F1:
mov rax, [rsp+128h+var_20]
sub rax, fs:28h
jnz short loc_131D
add rsp, 110h
mov eax, r12d
pop rbx
pop rbp
pop r12
retn
loc_1318:
xor r12d, r12d
jmp short loc_12F1
loc_131D:
call ___stack_chk_fail | long long func0(char *a1)
{
char v1; // al
char *v2; // rbx
int v3; // edx
signed int v4; // r12d
long long v5; // rcx
int v6; // eax
unsigned int v7; // eax
char v9[264]; // [rsp+0h] [rbp-128h] BYREF
unsigned long long v10; // [rsp+108h] [rbp-20h]
v10 = __readfsqword(0x28u);
v1 = *a1;
if ( !*a1 )
return 0;
v2 = a1 + 1;
v3 = 0;
v4 = 0;
do
{
while ( (unsigned __int8)(v1 - 48) <= 9u )
{
v5 = v3++;
v9[v5] = v1;
LABEL_4:
v1 = *v2++;
if ( !v1 )
goto LABEL_10;
}
if ( !v3 )
goto LABEL_4;
v9[v3] = 0;
v6 = strtol(v9, 0LL, 10);
if ( v4 < v6 )
v4 = v6;
v1 = *v2++;
v3 = 0;
}
while ( v1 );
LABEL_10:
if ( v3 )
{
v9[v3] = 0;
v7 = strtol(v9, 0LL, 10);
if ( v4 < (int)v7 )
return v7;
}
return (unsigned int)v4;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x110
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x108],RAX
XOR EAX,EAX
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101318
LEA RBX,[RDI + 0x1]
XOR EDX,EDX
XOR R12D,R12D
MOV RBP,RSP
JMP 0x00101294
LAB_00101280:
MOVSXD RCX,EDX
ADD EDX,0x1
MOV byte ptr [RSP + RCX*0x1],AL
LAB_00101289:
MOVZX EAX,byte ptr [RBX]
ADD RBX,0x1
TEST AL,AL
JZ 0x001012d0
LAB_00101294:
LEA ECX,[RAX + -0x30]
CMP CL,0x9
JBE 0x00101280
TEST EDX,EDX
JZ 0x00101289
MOVSXD RDX,EDX
XOR ESI,ESI
MOV RDI,RBP
MOV byte ptr [RSP + RDX*0x1],0x0
MOV EDX,0xa
CALL 0x00101090
CMP R12D,EAX
CMOVL R12D,EAX
MOVZX EAX,byte ptr [RBX]
ADD RBX,0x1
XOR EDX,EDX
TEST AL,AL
JNZ 0x00101294
NOP word ptr [RAX + RAX*0x1]
LAB_001012d0:
TEST EDX,EDX
JZ 0x001012f1
MOVSXD RDX,EDX
XOR ESI,ESI
MOV RDI,RSP
MOV byte ptr [RSP + RDX*0x1],0x0
MOV EDX,0xa
CALL 0x00101090
CMP R12D,EAX
CMOVL R12D,EAX
LAB_001012f1:
MOV RAX,qword ptr [RSP + 0x108]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010131d
ADD RSP,0x110
MOV EAX,R12D
POP RBX
POP RBP
POP R12
RET
LAB_00101318:
XOR R12D,R12D
JMP 0x001012f1
LAB_0010131d:
CALL 0x00101070 | int func0(char *param_1)
{
char cVar1;
long lVar2;
int iVar3;
int iVar4;
long in_FS_OFFSET;
char local_128 [264];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar4 = 0;
}
else {
param_1 = param_1 + 1;
iVar3 = 0;
iVar4 = 0;
do {
while ((byte)(cVar1 - 0x30U) < 10) {
lVar2 = (long)iVar3;
iVar3 = iVar3 + 1;
local_128[lVar2] = cVar1;
LAB_00101289:
cVar1 = *param_1;
param_1 = param_1 + 1;
if (cVar1 == '\0') goto LAB_001012d0;
}
if (iVar3 == 0) goto LAB_00101289;
local_128[iVar3] = '\0';
lVar2 = strtol(local_128,(char **)0x0,10);
if (iVar4 < (int)lVar2) {
iVar4 = (int)lVar2;
}
cVar1 = *param_1;
param_1 = param_1 + 1;
iVar3 = 0;
} while (cVar1 != '\0');
LAB_001012d0:
if (iVar3 != 0) {
local_128[iVar3] = '\0';
lVar2 = strtol(local_128,(char **)0x0,10);
if (iVar4 < (int)lVar2) {
iVar4 = (int)lVar2;
}
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar4;
} |
7,224 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
char* value;
} Item;
typedef struct {
Item* items;
int size;
} Dictionary;
| int* func0(Dictionary dict) {
int* keys = malloc(dict.size * sizeof(int));
for (int i = 0; i < dict.size; i++) {
keys[i] = dict.items[i].key;
}
return keys;
}
| int main() {
Dictionary dict1 = {
.items = (Item[]){{1, "python"}, {2, "java"}},
.size = 2
};
int* keys1 = func0(dict1);
assert(keys1[0] == 1 && keys1[1] == 2);
free(keys1);
Dictionary dict2 = {
.items = (Item[]){{10, "red"}, {20, "blue"}, {30, "black"}},
.size = 3
};
int* keys2 = func0(dict2);
assert(keys2[0] == 10 && keys2[1] == 20 && keys2[2] == 30);
free(keys2);
Dictionary dict3 = {
.items = (Item[]){{27, "language"}, {39, "java"}, {44, "little"}},
.size = 3
};
int* keys3 = func0(dict3);
assert(keys3[0] == 27 && keys3[1] == 39 && keys3[2] == 44);
free(keys3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,%rax
mov %rsi,%rcx
mov %rcx,%rdx
mov %rax,-0x20(%rbp)
mov %rdx,-0x18(%rbp)
mov -0x18(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1212 <func0+0x69>
mov -0x20(%rbp),%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
shl $0x4,%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 -0x18(%rbp),%eax
cmp %eax,-0xc(%rbp)
jl 11e4 <func0+0x3b>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov rax, rdi
mov rcx, rsi
mov rdx, rcx
mov [rbp+var_20], rax
mov [rbp+var_18], rdx
mov eax, dword ptr [rbp+var_18]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_1212
loc_11E4:
mov rax, [rbp+var_20]
mov edx, [rbp+var_C]
movsxd rdx, edx
shl rdx, 4
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_1212:
mov eax, dword ptr [rbp+var_18]
cmp [rbp+var_C], eax
jl short loc_11E4
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v4; // [rsp+18h] [rbp-8h]
v4 = malloc(4LL * a2);
for ( i = 0; i < a2; ++i )
v4[i] = *(_DWORD *)(16LL * i + a1);
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV RAX,RDI
MOV RCX,RSI
MOV RDX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x18],RDX
MOV EAX,dword ptr [RBP + -0x18]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101212
LAB_001011e4:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
SHL RDX,0x4
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_00101212:
MOV EAX,dword ptr [RBP + -0x18]
CMP dword ptr [RBP + -0xc],EAX
JL 0x001011e4
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2)
{
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 *)(param_1 + (long)local_14 * 0x10);
}
return pvVar1;
} |
7,225 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
char* value;
} Item;
typedef struct {
Item* items;
int size;
} Dictionary;
| int* func0(Dictionary dict) {
int* keys = malloc(dict.size * sizeof(int));
for (int i = 0; i < dict.size; i++) {
keys[i] = dict.items[i].key;
}
return keys;
}
| int main() {
Dictionary dict1 = {
.items = (Item[]){{1, "python"}, {2, "java"}},
.size = 2
};
int* keys1 = func0(dict1);
assert(keys1[0] == 1 && keys1[1] == 2);
free(keys1);
Dictionary dict2 = {
.items = (Item[]){{10, "red"}, {20, "blue"}, {30, "black"}},
.size = 3
};
int* keys2 = func0(dict2);
assert(keys2[0] == 10 && keys2[1] == 20 && keys2[2] == 30);
free(keys2);
Dictionary dict3 = {
.items = (Item[]){{27, "language"}, {39, "java"}, {44, "little"}},
.size = 3
};
int* keys3 = func0(dict3);
assert(keys3[0] == 27 && keys3[1] == 39 && keys3[2] == 44);
free(keys3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 11ec <func0+0x43>
mov %rbp,%rdx
mov %rax,%rcx
lea -0x1(%rbx),%esi
shl $0x4,%rsi
lea 0x10(%rbp,%rsi,1),%rdi
mov (%rdx),%esi
mov %esi,(%rcx)
add $0x10,%rdx
add $0x4,%rcx
cmp %rdi,%rdx
jne 11db <func0+0x32>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rbx, rsi
movsxd rdi, esi
shl rdi, 2
call _malloc
test ebx, ebx
jle short loc_11EC
mov rdx, rbp
mov rcx, rax
lea esi, [rbx-1]
shl rsi, 4
lea rdi, [rbp+rsi+10h]
loc_11DB:
mov esi, [rdx]
mov [rcx], esi
add rdx, 10h
add rcx, 4
cmp rdx, rdi
jnz short loc_11DB
loc_11EC:
add rsp, 8
pop rbx
pop rbp
retn | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
_DWORD *v3; // rdx
_DWORD *v4; // rcx
result = malloc(4LL * a2);
if ( a2 > 0 )
{
v3 = a1;
v4 = (_DWORD *)result;
do
{
*v4 = *v3;
v3 += 4;
++v4;
}
while ( v3 != &a1[4 * (a2 - 1) + 4] );
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RBX,RSI
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001011ec
MOV RDX,RBP
MOV RCX,RAX
LEA ESI,[RBX + -0x1]
SHL RSI,0x4
LEA RDI,[RBP + RSI*0x1 + 0x10]
LAB_001011db:
MOV ESI,dword ptr [RDX]
MOV dword ptr [RCX],ESI
ADD RDX,0x10
ADD RCX,0x4
CMP RDX,RDI
JNZ 0x001011db
LAB_001011ec:
ADD RSP,0x8
POP RBX
POP RBP
RET | void func0(int4 *param_1,int param_2)
{
int4 *puVar1;
int4 *puVar2;
puVar2 = (int4 *)malloc((long)param_2 << 2);
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
do {
*puVar2 = *param_1;
param_1 = param_1 + 4;
puVar2 = puVar2 + 1;
} while (param_1 != puVar1);
}
return;
} |
7,226 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
char* value;
} Item;
typedef struct {
Item* items;
int size;
} Dictionary;
| int* func0(Dictionary dict) {
int* keys = malloc(dict.size * sizeof(int));
for (int i = 0; i < dict.size; i++) {
keys[i] = dict.items[i].key;
}
return keys;
}
| int main() {
Dictionary dict1 = {
.items = (Item[]){{1, "python"}, {2, "java"}},
.size = 2
};
int* keys1 = func0(dict1);
assert(keys1[0] == 1 && keys1[1] == 2);
free(keys1);
Dictionary dict2 = {
.items = (Item[]){{10, "red"}, {20, "blue"}, {30, "black"}},
.size = 3
};
int* keys2 = func0(dict2);
assert(keys2[0] == 10 && keys2[1] == 20 && keys2[2] == 30);
free(keys2);
Dictionary dict3 = {
.items = (Item[]){{27, "language"}, {39, "java"}, {44, "little"}},
.size = 3
};
int* keys3 = func0(dict3);
assert(keys3[0] == 27 && keys3[1] == 39 && keys3[2] == 44);
free(keys3);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 13ba <func0+0x4a>
lea -0x1(%rbp),%ecx
mov %rbx,%rdi
mov %rax,%rdx
shl $0x4,%rcx
lea 0x10(%rbx,%rcx,1),%rsi
nopw 0x0(%rax,%rax,1)
mov (%rdi),%ecx
add $0x10,%rdi
add $0x4,%rdx
mov %ecx,-0x4(%rdx)
cmp %rsi,%rdi
jne 13a8 <func0+0x38>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
movsxd rdi, esi
shl rdi, 2
sub rsp, 8
call _malloc
test ebp, ebp
jle short loc_13BA
lea esi, [rbp-1]
mov rdx, rbx
mov rcx, rax
shl rsi, 4
lea rdi, [rbx+rsi+10h]
nop word ptr [rax+rax+00h]
loc_13A8:
mov esi, [rdx]
add rdx, 10h
add rcx, 4
mov [rcx-4], esi
cmp rdx, rdi
jnz short loc_13A8
loc_13BA:
add rsp, 8
pop rbx
pop rbp
retn | long long func0(int *a1, int a2)
{
long long result; // rax
int *v3; // rdx
long long v4; // rcx
long long v5; // rdi
int v6; // esi
result = malloc(4LL * a2);
if ( a2 > 0 )
{
v3 = a1;
v4 = result;
v5 = (long long)&a1[4 * (a2 - 1) + 4];
do
{
v6 = *v3;
v3 += 4;
v4 += 4LL;
*(_DWORD *)(v4 - 4) = v6;
}
while ( v3 != (int *)v5 );
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010b0
TEST EBP,EBP
JLE 0x001013ba
LEA ESI,[RBP + -0x1]
MOV RDX,RBX
MOV RCX,RAX
SHL RSI,0x4
LEA RDI,[RBX + RSI*0x1 + 0x10]
NOP word ptr [RAX + RAX*0x1]
LAB_001013a8:
MOV ESI,dword ptr [RDX]
ADD RDX,0x10
ADD RCX,0x4
MOV dword ptr [RCX + -0x4],ESI
CMP RDX,RDI
JNZ 0x001013a8
LAB_001013ba:
ADD RSP,0x8
POP RBX
POP RBP
RET | void func0(int4 *param_1,int param_2)
{
int4 *puVar1;
int4 uVar2;
int4 *puVar3;
puVar3 = (int4 *)malloc((long)param_2 << 2);
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
do {
uVar2 = *param_1;
param_1 = param_1 + 4;
*puVar3 = uVar2;
puVar3 = puVar3 + 1;
} while (param_1 != puVar1);
}
return;
} |
7,227 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
char* value;
} Item;
typedef struct {
Item* items;
int size;
} Dictionary;
| int* func0(Dictionary dict) {
int* keys = malloc(dict.size * sizeof(int));
for (int i = 0; i < dict.size; i++) {
keys[i] = dict.items[i].key;
}
return keys;
}
| int main() {
Dictionary dict1 = {
.items = (Item[]){{1, "python"}, {2, "java"}},
.size = 2
};
int* keys1 = func0(dict1);
assert(keys1[0] == 1 && keys1[1] == 2);
free(keys1);
Dictionary dict2 = {
.items = (Item[]){{10, "red"}, {20, "blue"}, {30, "black"}},
.size = 3
};
int* keys2 = func0(dict2);
assert(keys2[0] == 10 && keys2[1] == 20 && keys2[2] == 30);
free(keys2);
Dictionary dict3 = {
.items = (Item[]){{27, "language"}, {39, "java"}, {44, "little"}},
.size = 3
};
int* keys3 = func0(dict3);
assert(keys3[0] == 27 && keys3[1] == 39 && keys3[2] == 44);
free(keys3);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
shl $0x2,%rdi
mov %rsi,%rbx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 1446 <func0+0xd6>
lea -0x1(%rbx),%edi
cmp $0x3,%edi
jbe 144d <func0+0xdd>
mov %edi,%r8d
mov %rbp,%rdx
mov %rax,%rcx
shr $0x2,%r8d
shl $0x6,%r8
add %rbp,%r8
nopl 0x0(%rax)
movdqu (%rdx),%xmm0
movdqu 0x10(%rdx),%xmm2
add $0x40,%rdx
add $0x10,%rcx
movdqu -0x20(%rdx),%xmm1
movdqu -0x10(%rdx),%xmm3
shufps $0x88,%xmm2,%xmm0
shufps $0x88,%xmm3,%xmm1
shufps $0x88,%xmm1,%xmm0
movups %xmm0,-0x10(%rcx)
cmp %r8,%rdx
jne 13b8 <func0+0x48>
and $0xfffffffc,%edi
mov %edi,%edx
movslq %edx,%rcx
mov %rcx,%rsi
shl $0x4,%rsi
mov 0x0(%rbp,%rsi,1),%esi
mov %esi,(%rax,%rcx,4)
lea 0x1(%rdx),%ecx
cmp %ecx,%ebx
jle 1446 <func0+0xd6>
movslq %ecx,%rcx
mov %rcx,%rsi
shl $0x4,%rsi
mov 0x0(%rbp,%rsi,1),%esi
mov %esi,(%rax,%rcx,4)
lea 0x2(%rdx),%ecx
cmp %ecx,%ebx
jle 1446 <func0+0xd6>
movslq %ecx,%rcx
add $0x3,%edx
mov %rcx,%rsi
shl $0x4,%rsi
mov 0x0(%rbp,%rsi,1),%esi
mov %esi,(%rax,%rcx,4)
cmp %edx,%ebx
jle 1446 <func0+0xd6>
movslq %edx,%rdx
mov %rdx,%rcx
shl $0x4,%rcx
mov 0x0(%rbp,%rcx,1),%ecx
mov %ecx,(%rax,%rdx,4)
add $0x8,%rsp
pop %rbx
pop %rbp
retq
xor %edx,%edx
jmp 13ed <func0+0x7d>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rdi
movsxd rdi, esi
push rbx
shl rdi, 2; size
mov rbx, rsi
sub rsp, 8
call _malloc
mov rdi, rax
test ebx, ebx
jle loc_1435
lea esi, [rbx-1]
cmp esi, 3
jbe loc_143F
mov ecx, esi
mov rax, rbp
mov rdx, rdi
shr ecx, 2
shl rcx, 6
add rcx, rbp
nop dword ptr [rax]
loc_13B8:
movdqu xmm0, xmmword ptr [rax]
movdqu xmm2, xmmword ptr [rax+10h]
add rax, 40h ; '@'
add rdx, 10h
movdqu xmm1, xmmword ptr [rax-20h]
movdqu xmm3, xmmword ptr [rax-10h]
shufps xmm0, xmm2, 88h
shufps xmm1, xmm3, 88h
shufps xmm0, xmm1, 88h
movups xmmword ptr [rdx-10h], xmm0
cmp rax, rcx
jnz short loc_13B8
mov eax, esi
and eax, 0FFFFFFFCh
loc_13ED:
movsxd rcx, eax
mov rdx, rcx
lea rsi, ds:0[rcx*4]
shl rdx, 4
mov r8d, [rbp+rdx+0]
mov [rdi+rcx*4], r8d
lea ecx, [rax+1]
cmp ebx, ecx
jle short loc_1435
mov ecx, [rdx+rbp+10h]
mov [rdi+rsi+4], ecx
lea ecx, [rax+2]
cmp ecx, ebx
jge short loc_1435
mov ecx, [rdx+rbp+20h]
add eax, 3
mov [rdi+rsi+8], ecx
cmp ebx, eax
jle short loc_1435
mov eax, [rdx+rbp+30h]
mov [rdi+rsi+0Ch], eax
loc_1435:
add rsp, 8
mov rax, rdi
pop rbx
pop rbp
retn
loc_143F:
xor eax, eax
jmp short loc_13ED | __m128 * func0(const __m128i *a1, int a2)
{
__m128 *v4; // rdi
unsigned int v5; // esi
const __m128i *v6; // rax
__m128 *v7; // rdx
__m128 v8; // xmm0
__m128 v9; // xmm2
signed int v10; // eax
long long v11; // rsi
long long v12; // rdx
v4 = (__m128 *)malloc(4LL * a2);
if ( a2 > 0 )
{
v5 = a2 - 1;
if ( v5 <= 3 )
{
v10 = 0;
}
else
{
v6 = a1;
v7 = v4;
do
{
v8 = (__m128)_mm_loadu_si128(v6);
v9 = (__m128)_mm_loadu_si128(v6 + 1);
v6 += 4;
++v7;
v7[-1] = _mm_shuffle_ps(
_mm_shuffle_ps(v8, v9, 136),
_mm_shuffle_ps((__m128)_mm_loadu_si128(v6 - 2), (__m128)_mm_loadu_si128(v6 - 1), 136),
136);
}
while ( v6 != &a1[4 * (unsigned long long)(v5 >> 2)] );
v10 = v5 & 0xFFFFFFFC;
}
v11 = v10;
v12 = v10;
v4->m128_i32[v11] = a1[v12].m128i_i32[0];
if ( a2 > v10 + 1 )
{
v4->m128_i32[v11 + 1] = a1[v12 + 1].m128i_i32[0];
if ( v10 + 2 < a2 )
{
v4->m128_i32[v11 + 2] = a1[v12 + 2].m128i_i32[0];
if ( a2 > v10 + 3 )
v4->m128_i32[v11 + 3] = a1[v12 + 3].m128i_i32[0];
}
}
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,ESI
PUSH RBX
SHL RDI,0x2
MOV RBX,RSI
SUB RSP,0x8
CALL 0x001010b0
MOV RDI,RAX
TEST EBX,EBX
JLE 0x00101435
LEA ESI,[RBX + -0x1]
CMP ESI,0x3
JBE 0x0010143f
MOV ECX,ESI
MOV RAX,RBP
MOV RDX,RDI
SHR ECX,0x2
SHL RCX,0x6
ADD RCX,RBP
NOP dword ptr [RAX]
LAB_001013b8:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQU XMM2,xmmword ptr [RAX + 0x10]
ADD RAX,0x40
ADD RDX,0x10
MOVDQU XMM1,xmmword ptr [RAX + -0x20]
MOVDQU XMM3,xmmword ptr [RAX + -0x10]
SHUFPS XMM0,XMM2,0x88
SHUFPS XMM1,XMM3,0x88
SHUFPS XMM0,XMM1,0x88
MOVUPS xmmword ptr [RDX + -0x10],XMM0
CMP RAX,RCX
JNZ 0x001013b8
MOV EAX,ESI
AND EAX,0xfffffffc
LAB_001013ed:
MOVSXD RCX,EAX
MOV RDX,RCX
LEA RSI,[RCX*0x4]
SHL RDX,0x4
MOV R8D,dword ptr [RBP + RDX*0x1]
MOV dword ptr [RDI + RCX*0x4],R8D
LEA ECX,[RAX + 0x1]
CMP EBX,ECX
JLE 0x00101435
MOV ECX,dword ptr [RDX + RBP*0x1 + 0x10]
MOV dword ptr [RDI + RSI*0x1 + 0x4],ECX
LEA ECX,[RAX + 0x2]
CMP ECX,EBX
JGE 0x00101435
MOV ECX,dword ptr [RDX + RBP*0x1 + 0x20]
ADD EAX,0x3
MOV dword ptr [RDI + RSI*0x1 + 0x8],ECX
CMP EBX,EAX
JLE 0x00101435
MOV EAX,dword ptr [RDX + RBP*0x1 + 0x30]
MOV dword ptr [RDI + RSI*0x1 + 0xc],EAX
LAB_00101435:
ADD RSP,0x8
MOV RAX,RDI
POP RBX
POP RBP
RET
LAB_0010143f:
XOR EAX,EAX
JMP 0x001013ed | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
uint uVar4;
int4 *puVar5;
int4 *puVar6;
int4 *puVar7;
long lVar8;
int4 *puVar9;
puVar5 = (int4 *)malloc((long)param_2 << 2);
if (0 < param_2) {
uVar4 = param_2 - 1;
if (uVar4 < 4) {
uVar4 = 0;
}
else {
puVar6 = param_1;
puVar9 = puVar5;
do {
uVar1 = puVar6[4];
puVar7 = puVar6 + 0x10;
uVar2 = puVar6[8];
uVar3 = puVar6[0xc];
*puVar9 = *puVar6;
puVar9[1] = uVar1;
puVar9[2] = uVar2;
puVar9[3] = uVar3;
puVar6 = puVar7;
puVar9 = puVar9 + 4;
} while (puVar7 != param_1 + (ulong)(uVar4 >> 2) * 0x10);
uVar4 = uVar4 & 0xfffffffc;
}
lVar8 = (long)(int)uVar4;
puVar5[lVar8] = param_1[lVar8 * 4];
if ((((int)(uVar4 + 1) < param_2) &&
(puVar5[lVar8 + 1] = param_1[lVar8 * 4 + 4], (int)(uVar4 + 2) < param_2)) &&
(puVar5[lVar8 + 2] = param_1[lVar8 * 4 + 8], (int)(uVar4 + 3) < param_2)) {
puVar5[lVar8 + 3] = param_1[lVar8 * 4 + 0xc];
}
}
return puVar5;
} |
7,228 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int **func0(int n) {
if (n <= 0) return NULL;
int **matrix = (int **)malloc(n * sizeof(int *));
for (int i = 0; i < n; i++) {
matrix[i] = (int *)calloc(n, sizeof(int));
}
int row_st = 0, row_ed = n - 1;
int col_st = 0, col_ed = n - 1;
int current = 1;
while (1) {
if (current > n * n) break;
for (int c = col_st; c <= col_ed; c++) {
matrix[row_st][c] = current++;
}
row_st++;
for (int r = row_st; r <= row_ed; r++) {
matrix[r][col_ed] = current++;
}
col_ed--;
for (int c = col_ed; c >= col_st; c--) {
matrix[row_ed][c] = current++;
}
row_ed--;
for (int r = row_ed; r >= row_st; r--) {
matrix[r][col_st] = current++;
}
col_st++;
}
return matrix;
}
| int main() {
int n1 = 3, n2 = 2, n7 = 7;
int expected1[3][3] = {{1, 2, 3}, {8, 9, 4}, {7, 6, 5}};
int expected2[2][2] = {{1,2}, {4,3}};
int expected7[7][7] = {{1, 2, 3, 4, 5, 6, 7}, {24, 25, 26, 27, 28, 29, 8}, {23, 40, 41, 42, 43, 30, 9}, {22, 39, 48, 49, 44, 31, 10}, {21, 38, 47, 46, 45, 32, 11}, {20, 37, 36, 35, 34, 33, 12}, {19, 18, 17, 16, 15, 14, 13}};
int **result1 = func0(n1);
int **result2 = func0(n2);
int **result7 = func0(n7);
for (int i = 0; i < n1; i++) {
for (int j = 0; j < n1; j++) {
assert(result1[i][j] == expected1[i][j]);
}
}
for (int i = 0; i < n2; i++) {
for (int j = 0; j < n2; j++) {
assert(result2[i][j] == expected2[i][j]);
}
}
for (int i = 0; i < n7; i++) {
for (int j = 0; j < n7; j++) {
assert(result7[i][j] == expected7[i][j]);
}
}
for (int i = 0; i < n1; i++) free(result1[i]);
free(result1);
for (int i = 0; i < n2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < n7; i++) free(result7[i]);
free(result7);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
cmpl $0x0,-0x44(%rbp)
jg 11e9 <func0+0x20>
mov $0x0,%eax
jmpq 139e <func0+0x1d5>
mov -0x44(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x40(%rbp)
jmp 1236 <func0+0x6d>
mov -0x44(%rbp),%eax
cltq
mov -0x40(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov $0x4,%esi
mov %rax,%rdi
callq 10c0 <calloc@plt>
mov %rax,(%rbx)
addl $0x1,-0x40(%rbp)
mov -0x40(%rbp),%eax
cmp -0x44(%rbp),%eax
jl 1207 <func0+0x3e>
movl $0x0,-0x3c(%rbp)
mov -0x44(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x38(%rbp)
movl $0x0,-0x34(%rbp)
mov -0x44(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x30(%rbp)
movl $0x1,-0x2c(%rbp)
mov -0x44(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x2c(%rbp)
jg 1399 <func0+0x1d0>
mov -0x34(%rbp),%eax
mov %eax,-0x28(%rbp)
jmp 12b0 <func0+0xe7>
mov -0x2c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x2c(%rbp)
mov -0x3c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rdx
mov -0x28(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rdx
mov %eax,(%rdx)
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x30(%rbp),%eax
jle 127c <func0+0xb3>
addl $0x1,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
mov %eax,-0x24(%rbp)
jmp 12f8 <func0+0x12f>
mov -0x2c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x2c(%rbp)
mov -0x24(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rdx
mov -0x30(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rdx
mov %eax,(%rdx)
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x38(%rbp),%eax
jle 12c4 <func0+0xfb>
subl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
mov %eax,-0x20(%rbp)
jmp 1340 <func0+0x177>
mov -0x2c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x2c(%rbp)
mov -0x38(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rdx
mov -0x20(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rdx
mov %eax,(%rdx)
subl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x34(%rbp),%eax
jge 130c <func0+0x143>
subl $0x1,-0x38(%rbp)
mov -0x38(%rbp),%eax
mov %eax,-0x1c(%rbp)
jmp 1388 <func0+0x1bf>
mov -0x2c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x2c(%rbp)
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rdx),%rdx
mov -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rdx
mov %eax,(%rdx)
subl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x3c(%rbp),%eax
jge 1354 <func0+0x18b>
addl $0x1,-0x34(%rbp)
jmpq 1265 <func0+0x9c>
mov -0x18(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_44], edi
cmp [rbp+var_44], 0
jg short loc_11E9
mov eax, 0
jmp loc_139E
loc_11E9:
mov eax, [rbp+var_44]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_40], 0
jmp short loc_1236
loc_1207:
mov eax, [rbp+var_44]
cdqe
mov edx, [rbp+var_40]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
lea rbx, [rcx+rdx]
mov esi, 4; size
mov rdi, rax; nmemb
call _calloc
mov [rbx], rax
add [rbp+var_40], 1
loc_1236:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_44]
jl short loc_1207
mov [rbp+var_3C], 0
mov eax, [rbp+var_44]
sub eax, 1
mov [rbp+var_38], eax
mov [rbp+var_34], 0
mov eax, [rbp+var_44]
sub eax, 1
mov [rbp+var_30], eax
mov [rbp+var_2C], 1
loc_1265:
mov eax, [rbp+var_44]
imul eax, eax
cmp [rbp+var_2C], eax
jg loc_1399
mov eax, [rbp+var_34]
mov [rbp+var_28], eax
jmp short loc_12B0
loc_127C:
mov eax, [rbp+var_2C]
lea edx, [rax+1]
mov [rbp+var_2C], edx
mov edx, [rbp+var_3C]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
add rdx, rcx
mov rdx, [rdx]
mov ecx, [rbp+var_28]
movsxd rcx, ecx
shl rcx, 2
add rdx, rcx
mov [rdx], eax
add [rbp+var_28], 1
loc_12B0:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_30]
jle short loc_127C
add [rbp+var_3C], 1
mov eax, [rbp+var_3C]
mov [rbp+var_24], eax
jmp short loc_12F8
loc_12C4:
mov eax, [rbp+var_2C]
lea edx, [rax+1]
mov [rbp+var_2C], edx
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
add rdx, rcx
mov rdx, [rdx]
mov ecx, [rbp+var_30]
movsxd rcx, ecx
shl rcx, 2
add rdx, rcx
mov [rdx], eax
add [rbp+var_24], 1
loc_12F8:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_38]
jle short loc_12C4
sub [rbp+var_30], 1
mov eax, [rbp+var_30]
mov [rbp+var_20], eax
jmp short loc_1340
loc_130C:
mov eax, [rbp+var_2C]
lea edx, [rax+1]
mov [rbp+var_2C], edx
mov edx, [rbp+var_38]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
add rdx, rcx
mov rdx, [rdx]
mov ecx, [rbp+var_20]
movsxd rcx, ecx
shl rcx, 2
add rdx, rcx
mov [rdx], eax
sub [rbp+var_20], 1
loc_1340:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_34]
jge short loc_130C
sub [rbp+var_38], 1
mov eax, [rbp+var_38]
mov [rbp+var_1C], eax
jmp short loc_1388
loc_1354:
mov eax, [rbp+var_2C]
lea edx, [rax+1]
mov [rbp+var_2C], edx
mov edx, [rbp+var_1C]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
add rdx, rcx
mov rdx, [rdx]
mov ecx, [rbp+var_34]
movsxd rcx, ecx
shl rcx, 2
add rdx, rcx
mov [rdx], eax
sub [rbp+var_1C], 1
loc_1388:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_3C]
jge short loc_1354
add [rbp+var_34], 1
jmp loc_1265
loc_1399:
nop
mov rax, [rbp+var_18]
loc_139E:
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(int a1)
{
int v2; // eax
int v3; // eax
int v4; // eax
int v5; // eax
int i; // [rsp+10h] [rbp-40h]
int v7; // [rsp+14h] [rbp-3Ch]
int v8; // [rsp+18h] [rbp-38h]
int v9; // [rsp+1Ch] [rbp-34h]
int v10; // [rsp+20h] [rbp-30h]
int v11; // [rsp+24h] [rbp-2Ch]
int j; // [rsp+28h] [rbp-28h]
int k; // [rsp+2Ch] [rbp-24h]
int m; // [rsp+30h] [rbp-20h]
int n; // [rsp+34h] [rbp-1Ch]
_QWORD *v16; // [rsp+38h] [rbp-18h]
if ( a1 <= 0 )
return 0LL;
v16 = malloc(8LL * a1);
for ( i = 0; i < a1; ++i )
v16[i] = calloc(a1, 4uLL);
v7 = 0;
v8 = a1 - 1;
v9 = 0;
v10 = a1 - 1;
v11 = 1;
while ( v11 <= a1 * a1 )
{
for ( j = v9; j <= v10; ++j )
{
v2 = v11++;
*(_DWORD *)(4LL * j + v16[v7]) = v2;
}
for ( k = ++v7; k <= v8; ++k )
{
v3 = v11++;
*(_DWORD *)(4LL * v10 + v16[k]) = v3;
}
for ( m = --v10; m >= v9; --m )
{
v4 = v11++;
*(_DWORD *)(4LL * m + v16[v8]) = v4;
}
for ( n = --v8; n >= v7; --n )
{
v5 = v11++;
*(_DWORD *)(4LL * v9 + v16[n]) = v5;
}
++v9;
}
return v16;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x44],EDI
CMP dword ptr [RBP + -0x44],0x0
JG 0x001011e9
MOV EAX,0x0
JMP 0x0010139e
LAB_001011e9:
MOV EAX,dword ptr [RBP + -0x44]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x40],0x0
JMP 0x00101236
LAB_00101207:
MOV EAX,dword ptr [RBP + -0x44]
CDQE
MOV EDX,dword ptr [RBP + -0x40]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
LEA RBX,[RCX + RDX*0x1]
MOV ESI,0x4
MOV RDI,RAX
CALL 0x001010c0
MOV qword ptr [RBX],RAX
ADD dword ptr [RBP + -0x40],0x1
LAB_00101236:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x00101207
MOV dword ptr [RBP + -0x3c],0x0
MOV EAX,dword ptr [RBP + -0x44]
SUB EAX,0x1
MOV dword ptr [RBP + -0x38],EAX
MOV dword ptr [RBP + -0x34],0x0
MOV EAX,dword ptr [RBP + -0x44]
SUB EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
MOV dword ptr [RBP + -0x2c],0x1
LAB_00101265:
MOV EAX,dword ptr [RBP + -0x44]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x2c],EAX
JG 0x00101399
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001012b0
LAB_0010127c:
MOV EAX,dword ptr [RBP + -0x2c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x2c],EDX
MOV EDX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RBP + -0x28]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RDX,RCX
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x28],0x1
LAB_001012b0:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x30]
JLE 0x0010127c
ADD dword ptr [RBP + -0x3c],0x1
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001012f8
LAB_001012c4:
MOV EAX,dword ptr [RBP + -0x2c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x2c],EDX
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RBP + -0x30]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RDX,RCX
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x24],0x1
LAB_001012f8:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x38]
JLE 0x001012c4
SUB dword ptr [RBP + -0x30],0x1
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00101340
LAB_0010130c:
MOV EAX,dword ptr [RBP + -0x2c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x2c],EDX
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RBP + -0x20]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RDX,RCX
MOV dword ptr [RDX],EAX
SUB dword ptr [RBP + -0x20],0x1
LAB_00101340:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x34]
JGE 0x0010130c
SUB dword ptr [RBP + -0x38],0x1
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00101388
LAB_00101354:
MOV EAX,dword ptr [RBP + -0x2c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x2c],EDX
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RBP + -0x34]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RDX,RCX
MOV dword ptr [RDX],EAX
SUB dword ptr [RBP + -0x1c],0x1
LAB_00101388:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x3c]
JGE 0x00101354
ADD dword ptr [RBP + -0x34],0x1
JMP 0x00101265
LAB_00101399:
NOP
MOV RAX,qword ptr [RBP + -0x18]
LAB_0010139e:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(int param_1)
{
void *pvVar1;
void *pvVar2;
int4 local_48;
int4 local_44;
int4 local_40;
int4 local_3c;
int4 local_38;
int4 local_34;
int4 local_30;
int4 local_2c;
int4 local_28;
int4 local_24;
if (param_1 < 1) {
pvVar1 = (void *)0x0;
}
else {
pvVar1 = malloc((long)param_1 << 3);
for (local_48 = 0; local_48 < param_1; local_48 = local_48 + 1) {
pvVar2 = calloc((long)param_1,4);
*(void **)((long)local_48 * 8 + (long)pvVar1) = pvVar2;
}
local_44 = 0;
local_40 = param_1 + -1;
local_3c = 0;
local_38 = param_1 + -1;
local_34 = 1;
while (local_34 <= param_1 * param_1) {
for (local_30 = local_3c; local_30 <= local_38; local_30 = local_30 + 1) {
*(int *)(*(long *)((long)pvVar1 + (long)local_44 * 8) + (long)local_30 * 4) = local_34;
local_34 = local_34 + 1;
}
local_44 = local_44 + 1;
for (local_2c = local_44; local_2c <= local_40; local_2c = local_2c + 1) {
*(int *)(*(long *)((long)pvVar1 + (long)local_2c * 8) + (long)local_38 * 4) = local_34;
local_34 = local_34 + 1;
}
local_38 = local_38 + -1;
for (local_28 = local_38; local_3c <= local_28; local_28 = local_28 + -1) {
*(int *)(*(long *)((long)pvVar1 + (long)local_40 * 8) + (long)local_28 * 4) = local_34;
local_34 = local_34 + 1;
}
local_40 = local_40 + -1;
for (local_24 = local_40; local_44 <= local_24; local_24 = local_24 + -1) {
*(int *)(*(long *)((long)pvVar1 + (long)local_24 * 8) + (long)local_3c * 4) = local_34;
local_34 = local_34 + 1;
}
local_3c = local_3c + 1;
}
}
return pvVar1;
} |
7,229 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int **func0(int n) {
if (n <= 0) return NULL;
int **matrix = (int **)malloc(n * sizeof(int *));
for (int i = 0; i < n; i++) {
matrix[i] = (int *)calloc(n, sizeof(int));
}
int row_st = 0, row_ed = n - 1;
int col_st = 0, col_ed = n - 1;
int current = 1;
while (1) {
if (current > n * n) break;
for (int c = col_st; c <= col_ed; c++) {
matrix[row_st][c] = current++;
}
row_st++;
for (int r = row_st; r <= row_ed; r++) {
matrix[r][col_ed] = current++;
}
col_ed--;
for (int c = col_ed; c >= col_st; c--) {
matrix[row_ed][c] = current++;
}
row_ed--;
for (int r = row_ed; r >= row_st; r--) {
matrix[r][col_st] = current++;
}
col_st++;
}
return matrix;
}
| int main() {
int n1 = 3, n2 = 2, n7 = 7;
int expected1[3][3] = {{1, 2, 3}, {8, 9, 4}, {7, 6, 5}};
int expected2[2][2] = {{1,2}, {4,3}};
int expected7[7][7] = {{1, 2, 3, 4, 5, 6, 7}, {24, 25, 26, 27, 28, 29, 8}, {23, 40, 41, 42, 43, 30, 9}, {22, 39, 48, 49, 44, 31, 10}, {21, 38, 47, 46, 45, 32, 11}, {20, 37, 36, 35, 34, 33, 12}, {19, 18, 17, 16, 15, 14, 13}};
int **result1 = func0(n1);
int **result2 = func0(n2);
int **result7 = func0(n7);
for (int i = 0; i < n1; i++) {
for (int j = 0; j < n1; j++) {
assert(result1[i][j] == expected1[i][j]);
}
}
for (int i = 0; i < n2; i++) {
for (int j = 0; j < n2; j++) {
assert(result2[i][j] == expected2[i][j]);
}
}
for (int i = 0; i < n7; i++) {
for (int j = 0; j < n7; j++) {
assert(result7[i][j] == expected7[i][j]);
}
}
for (int i = 0; i < n1; i++) free(result1[i]);
free(result1);
for (int i = 0; i < n2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < n7; i++) free(result7[i]);
free(result7);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov $0x0,%ebp
test %edi,%edi
jle 1363 <func0+0x19a>
mov %edi,%r14d
movslq %edi,%r13
lea 0x0(,%r13,8),%rax
mov %rax,0x8(%rsp)
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,%rbp
mov %rax,%rbx
lea -0x1(%r14),%eax
lea 0x8(%rbp,%rax,8),%r15
mov %rbp,%r12
mov $0x4,%esi
mov %r13,%rdi
callq 10c0 <calloc@plt>
mov %rax,(%r12)
add $0x8,%r12
cmp %r15,%r12
jne 1215 <func0+0x4c>
lea -0x1(%r14),%r10d
mov %r14d,%r15d
imul %r14d,%r15d
movslq %r10d,%r14
mov %r10d,%r13d
mov 0x8(%rsp),%rax
lea -0x8(%rbp,%rax,1),%r9
mov $0x0,%r12d
mov $0x1,%eax
mov $0x0,%edi
jmpq 1324 <func0+0x15b>
add $0x1,%edi
cmp %r10d,%edi
jg 12a5 <func0+0xdc>
lea 0x0(,%r14,4),%r11
movslq %edi,%rdx
lea 0x0(%rbp,%rdx,8),%rdx
mov %r10d,%r8d
sub %r12d,%r8d
add %eax,%r8d
mov %edi,%esi
mov %eax,0x8(%rsp)
mov %eax,%edi
add $0x1,%eax
mov (%rdx),%rcx
mov %edi,(%rcx,%r11,1)
add $0x8,%rdx
cmp %r8d,%eax
jne 1286 <func0+0xbd>
mov %esi,%edi
mov 0x8(%rsp),%ecx
lea (%rcx,%r13,1),%eax
sub $0x1,%r10d
cmp %r12d,%r10d
jl 12d9 <func0+0x110>
movslq %r10d,%rdx
shl $0x2,%rdx
mov %eax,%r11d
mov %r14d,%r8d
sub %r12d,%r8d
add %eax,%r8d
mov %eax,%esi
add $0x1,%eax
mov (%r9),%rcx
mov %esi,(%rcx,%rdx,1)
sub $0x4,%rdx
cmp %r8d,%eax
jne 12c1 <func0+0xf8>
lea (%r11,%r13,1),%eax
cmp %r10d,%edi
jg 130b <func0+0x142>
lea 0x0(,%r12,4),%rsi
movslq %r10d,%rdx
mov %eax,%r8d
lea -0x1(%rax,%r14,1),%r11d
mov 0x0(%rbp,%rdx,8),%rax
mov %r11d,%ecx
sub %edx,%ecx
mov %ecx,(%rax,%rsi,1)
sub $0x1,%rdx
cmp %edx,%edi
jle 12f1 <func0+0x128>
lea -0x1(%r8,%r13,1),%eax
add $0x1,%r12
sub $0x1,%r14
sub $0x2,%r13d
sub $0x8,%r9
add $0x8,%rbx
cmp %eax,%r15d
jl 1363 <func0+0x19a>
cmp %r10d,%edi
jg 125f <func0+0x96>
lea 0x0(,%r12,4),%rdx
mov %r13d,%ecx
lea 0x1(%r12,%rcx,1),%r11
shl $0x2,%r11
mov %eax,%ecx
mov %ecx,%r8d
add $0x1,%ecx
mov (%rbx),%rsi
mov %r8d,(%rsi,%rdx,1)
add $0x4,%rdx
cmp %r11,%rdx
jne 1343 <func0+0x17a>
lea 0x1(%rax,%r13,1),%eax
jmpq 125f <func0+0x96>
mov %rbp,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebx, 0
test edi, edi
jle loc_1321
mov ebp, edi
movsxd r13, edi
lea rdi, ds:0[r13*8]
call _malloc
mov rbx, rax
mov r12, rax
mov eax, ebp
lea r14, [rbx+rax*8]
loc_1206:
mov esi, 4
mov rdi, r13
call _calloc
mov [r12], rax
add r12, 8
cmp r12, r14
jnz short loc_1206
lea r8d, [rbp-1]
imul ebp, ebp
movsxd r10, r8d
mov r9d, r8d
mov edi, 0
mov eax, 1
mov r11d, 0
mov esi, 0
loc_1242:
cmp esi, r8d
jg short loc_126E
mov rdx, rdi
add rdx, [rbx+rdi*2]
mov r13d, eax
lea r12d, [r8+rax+1]
sub r12d, esi
loc_1259:
mov ecx, eax
add eax, 1
mov [rdx], ecx
add rdx, 4
cmp eax, r12d
jnz short loc_1259
lea eax, [r13+r9+1]
loc_126E:
add esi, 1
cmp esi, r8d
jg short loc_12AB
lea r14, ds:0[r10*4]
movsxd rdx, esi
lea rdx, [rbx+rdx*8]
mov r15d, eax
mov r13d, r8d
sub r13d, r11d
add r13d, eax
loc_1291:
mov r12d, eax
add eax, 1
mov rcx, [rdx]
mov [rcx+r14], r12d
add rdx, 8
cmp eax, r13d
jnz short loc_1291
lea eax, [r15+r9]
loc_12AB:
sub r8d, 1
cmp r8d, r11d
jl short loc_12E0
movsxd rdx, r8d
mov rcx, [rbx+r10*8]
lea rdx, [rcx+rdx*4]
mov r13d, eax
mov r12d, r10d
sub r12d, r11d
add r12d, eax
loc_12CB:
mov ecx, eax
add eax, 1
mov [rdx], ecx
sub rdx, 4
cmp eax, r12d
jnz short loc_12CB
lea eax, [r13+r9+0]
loc_12E0:
cmp esi, r8d
jg short loc_1309
movsxd rdx, r8d
mov r13d, eax
lea r12d, [rax+r10-1]
loc_12F0:
mov rax, [rbx+rdx*8]
mov ecx, r12d
sub ecx, edx
mov [rax+rdi], ecx
sub rdx, 1
cmp esi, edx
jle short loc_12F0
lea eax, [r13+r9-1]
loc_1309:
add r11d, 1
sub r10, 1
sub r9d, 2
add rdi, 4
cmp ebp, eax
jge loc_1242
loc_1321:
mov rax, rbx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(int a1)
{
long long v1; // rbx
_QWORD *v2; // r12
int v3; // r8d
int v4; // ebp
long long v5; // r10
int v6; // r9d
long long v7; // rdi
int v8; // eax
int v9; // r11d
int v10; // esi
int *v11; // rdx
int v12; // r13d
int v13; // r12d
int v14; // ecx
_QWORD *v15; // rdx
int v16; // r15d
int v17; // r13d
int v18; // r12d
int *v19; // rdx
int v20; // r13d
int v21; // r12d
int v22; // ecx
long long v23; // rdx
v1 = 0LL;
if ( a1 > 0 )
{
v1 = malloc(8LL * a1);
v2 = (_QWORD *)v1;
do
*v2++ = calloc(a1, 4LL);
while ( v2 != (_QWORD *)(v1 + 8LL * (unsigned int)a1) );
v3 = a1 - 1;
v4 = a1 * a1;
v5 = a1 - 1;
v6 = a1 - 1;
v7 = 0LL;
v8 = 1;
v9 = 0;
v10 = 0;
do
{
if ( v10 <= v3 )
{
v11 = (int *)(*(_QWORD *)(v1 + 2 * v7) + v7);
v12 = v8;
v13 = v3 + v8 + 1 - v10;
do
{
v14 = v8++;
*v11++ = v14;
}
while ( v8 != v13 );
v8 = v12 + v6 + 1;
}
if ( ++v10 <= v3 )
{
v15 = (_QWORD *)(v1 + 8LL * v10);
v16 = v8;
v17 = v8 + v3 - v9;
do
{
v18 = v8++;
*(_DWORD *)(*v15++ + 4 * v5) = v18;
}
while ( v8 != v17 );
v8 = v16 + v6;
}
if ( --v3 >= v9 )
{
v19 = (int *)(*(_QWORD *)(v1 + 8 * v5) + 4LL * v3);
v20 = v8;
v21 = v8 + v5 - v9;
do
{
v22 = v8++;
*v19-- = v22;
}
while ( v8 != v21 );
v8 = v20 + v6;
}
if ( v10 <= v3 )
{
v23 = v3;
do
{
*(_DWORD *)(*(_QWORD *)(v1 + 8 * v23) + v7) = v8 + v5 - 1 - v23;
--v23;
}
while ( v10 <= (int)v23 );
v8 = v8 + v6 - 1;
}
++v9;
--v5;
v6 -= 2;
v7 += 4LL;
}
while ( v4 >= v8 );
}
return v1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,0x0
TEST EDI,EDI
JLE 0x00101321
MOV EBP,EDI
MOVSXD R13,EDI
LEA RDI,[R13*0x8]
CALL 0x001010d0
MOV RBX,RAX
MOV R12,RAX
MOV EAX,EBP
LEA R14,[RBX + RAX*0x8]
LAB_00101206:
MOV ESI,0x4
MOV RDI,R13
CALL 0x001010c0
MOV qword ptr [R12],RAX
ADD R12,0x8
CMP R12,R14
JNZ 0x00101206
LEA R8D,[RBP + -0x1]
IMUL EBP,EBP
MOVSXD R10,R8D
MOV R9D,R8D
MOV EDI,0x0
MOV EAX,0x1
MOV R11D,0x0
MOV ESI,0x0
LAB_00101242:
CMP ESI,R8D
JG 0x0010126e
MOV RDX,RDI
ADD RDX,qword ptr [RBX + RDI*0x2]
MOV R13D,EAX
LEA R12D,[R8 + RAX*0x1 + 0x1]
SUB R12D,ESI
LAB_00101259:
MOV ECX,EAX
ADD EAX,0x1
MOV dword ptr [RDX],ECX
ADD RDX,0x4
CMP EAX,R12D
JNZ 0x00101259
LEA EAX,[R13 + R9*0x1 + 0x1]
LAB_0010126e:
ADD ESI,0x1
CMP ESI,R8D
JG 0x001012ab
LEA R14,[R10*0x4]
MOVSXD RDX,ESI
LEA RDX,[RBX + RDX*0x8]
MOV R15D,EAX
MOV R13D,R8D
SUB R13D,R11D
ADD R13D,EAX
LAB_00101291:
MOV R12D,EAX
ADD EAX,0x1
MOV RCX,qword ptr [RDX]
MOV dword ptr [RCX + R14*0x1],R12D
ADD RDX,0x8
CMP EAX,R13D
JNZ 0x00101291
LEA EAX,[R15 + R9*0x1]
LAB_001012ab:
SUB R8D,0x1
CMP R8D,R11D
JL 0x001012e0
MOVSXD RDX,R8D
MOV RCX,qword ptr [RBX + R10*0x8]
LEA RDX,[RCX + RDX*0x4]
MOV R13D,EAX
MOV R12D,R10D
SUB R12D,R11D
ADD R12D,EAX
LAB_001012cb:
MOV ECX,EAX
ADD EAX,0x1
MOV dword ptr [RDX],ECX
SUB RDX,0x4
CMP EAX,R12D
JNZ 0x001012cb
LEA EAX,[R13 + R9*0x1]
LAB_001012e0:
CMP ESI,R8D
JG 0x00101309
MOVSXD RDX,R8D
MOV R13D,EAX
LEA R12D,[RAX + R10*0x1 + -0x1]
LAB_001012f0:
MOV RAX,qword ptr [RBX + RDX*0x8]
MOV ECX,R12D
SUB ECX,EDX
MOV dword ptr [RAX + RDI*0x1],ECX
SUB RDX,0x1
CMP ESI,EDX
JLE 0x001012f0
LEA EAX,[R13 + R9*0x1 + -0x1]
LAB_00101309:
ADD R11D,0x1
SUB R10,0x1
SUB R9D,0x2
ADD RDI,0x4
CMP EBP,EAX
JGE 0x00101242
LAB_00101321:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(uint param_1)
{
int iVar1;
int iVar2;
int iVar3;
void *pvVar4;
int *piVar5;
long *plVar6;
long lVar7;
int8 *puVar8;
int iVar9;
long lVar10;
int iVar11;
int iVar12;
long lVar13;
int iVar14;
int8 *puVar15;
puVar8 = (int8 *)0x0;
if (0 < (int)param_1) {
puVar8 = (int8 *)malloc((long)(int)param_1 * 8);
puVar15 = puVar8;
do {
pvVar4 = calloc((long)(int)param_1,4);
*puVar15 = pvVar4;
puVar15 = puVar15 + 1;
} while (puVar15 != puVar8 + param_1);
iVar11 = param_1 - 1;
lVar13 = (long)iVar11;
lVar10 = 0;
iVar1 = 1;
iVar14 = 0;
iVar9 = 0;
iVar12 = iVar11;
do {
if (iVar9 <= iVar12) {
piVar5 = (int *)(lVar10 + *(long *)((long)puVar8 + lVar10 * 2));
iVar2 = iVar1;
do {
iVar3 = iVar2 + 1;
*piVar5 = iVar2;
piVar5 = piVar5 + 1;
iVar2 = iVar3;
} while (iVar3 != (iVar12 + 1 + iVar1) - iVar9);
iVar1 = iVar1 + 1 + iVar11;
}
iVar9 = iVar9 + 1;
if (iVar9 <= iVar12) {
plVar6 = puVar8 + iVar9;
iVar2 = iVar1;
do {
iVar3 = iVar2 + 1;
*(int *)(*plVar6 + lVar13 * 4) = iVar2;
plVar6 = plVar6 + 1;
iVar2 = iVar3;
} while (iVar3 != (iVar12 - iVar14) + iVar1);
iVar1 = iVar1 + iVar11;
}
iVar12 = iVar12 + -1;
if (iVar14 <= iVar12) {
piVar5 = (int *)(puVar8[lVar13] + (long)iVar12 * 4);
iVar2 = iVar1;
do {
iVar3 = iVar2 + 1;
*piVar5 = iVar2;
piVar5 = piVar5 + -1;
iVar2 = iVar3;
} while (iVar3 != ((int)lVar13 - iVar14) + iVar1);
iVar1 = iVar1 + iVar11;
}
if (iVar9 <= iVar12) {
lVar7 = (long)iVar12;
do {
*(int *)(puVar8[lVar7] + lVar10) = (iVar1 + -1 + (int)lVar13) - (int)lVar7;
lVar7 = lVar7 + -1;
} while (iVar9 <= (int)lVar7);
iVar1 = iVar1 + -1 + iVar11;
}
iVar14 = iVar14 + 1;
lVar13 = lVar13 + -1;
iVar11 = iVar11 + -2;
lVar10 = lVar10 + 4;
} while (iVar1 <= (int)(param_1 * param_1));
}
return puVar8;
} |
7,230 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int **func0(int n) {
if (n <= 0) return NULL;
int **matrix = (int **)malloc(n * sizeof(int *));
for (int i = 0; i < n; i++) {
matrix[i] = (int *)calloc(n, sizeof(int));
}
int row_st = 0, row_ed = n - 1;
int col_st = 0, col_ed = n - 1;
int current = 1;
while (1) {
if (current > n * n) break;
for (int c = col_st; c <= col_ed; c++) {
matrix[row_st][c] = current++;
}
row_st++;
for (int r = row_st; r <= row_ed; r++) {
matrix[r][col_ed] = current++;
}
col_ed--;
for (int c = col_ed; c >= col_st; c--) {
matrix[row_ed][c] = current++;
}
row_ed--;
for (int r = row_ed; r >= row_st; r--) {
matrix[r][col_st] = current++;
}
col_st++;
}
return matrix;
}
| int main() {
int n1 = 3, n2 = 2, n7 = 7;
int expected1[3][3] = {{1, 2, 3}, {8, 9, 4}, {7, 6, 5}};
int expected2[2][2] = {{1,2}, {4,3}};
int expected7[7][7] = {{1, 2, 3, 4, 5, 6, 7}, {24, 25, 26, 27, 28, 29, 8}, {23, 40, 41, 42, 43, 30, 9}, {22, 39, 48, 49, 44, 31, 10}, {21, 38, 47, 46, 45, 32, 11}, {20, 37, 36, 35, 34, 33, 12}, {19, 18, 17, 16, 15, 14, 13}};
int **result1 = func0(n1);
int **result2 = func0(n2);
int **result7 = func0(n7);
for (int i = 0; i < n1; i++) {
for (int j = 0; j < n1; j++) {
assert(result1[i][j] == expected1[i][j]);
}
}
for (int i = 0; i < n2; i++) {
for (int j = 0; j < n2; j++) {
assert(result2[i][j] == expected2[i][j]);
}
}
for (int i = 0; i < n7; i++) {
for (int j = 0; j < n7; j++) {
assert(result7[i][j] == expected7[i][j]);
}
}
for (int i = 0; i < n1; i++) free(result1[i]);
free(result1);
for (int i = 0; i < n2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < n7; i++) free(result7[i]);
free(result7);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
sub $0x8,%rsp
test %edi,%edi
jle 16fd <func0+0x16d>
movslq %edi,%r13
mov %edi,%ebx
lea 0x0(,%r13,8),%rdi
callq 10d0 <malloc@plt>
mov %rax,%r12
mov %rax,%rbp
lea -0x1(%rbx),%eax
mov %rax,%r15
lea 0x8(%r12,%rax,8),%r14
mov $0x4,%esi
mov %r13,%rdi
add $0x8,%rbp
callq 10c0 <calloc@plt>
mov %rax,-0x8(%rbp)
cmp %r14,%rbp
jne 15d0 <func0+0x40>
imul %ebx,%ebx
movslq %r15d,%r11
xor %r9d,%r9d
mov $0x1,%eax
mov %r11,%r8
mov %r11d,%r10d
xor %edi,%edi
cmp %r8d,%edi
jg 1637 <func0+0xa7>
mov (%r12,%r9,8),%rdx
lea 0x1(%rax),%ecx
mov %eax,%r13d
lea (%rcx,%r8,1),%ebp
lea (%rdx,%r9,4),%rdx
sub %edi,%ebp
jmp 1623 <func0+0x93>
nopl 0x0(%rax,%rax,1)
add $0x1,%ecx
mov %eax,%esi
add $0x4,%rdx
mov %ecx,%eax
mov %esi,-0x4(%rdx)
cmp %ebp,%ecx
jne 1620 <func0+0x90>
lea 0x1(%r13,%r10,1),%eax
add $0x1,%edi
cmp %r8d,%edi
jg 1678 <func0+0xe8>
mov %r8d,%ebp
movslq %edi,%rdx
lea 0x0(,%r11,4),%r13
mov %eax,%r14d
sub %r9d,%ebp
lea (%r12,%rdx,8),%rdx
add %eax,%ebp
nopl 0x0(%rax)
mov (%rdx),%rcx
mov %eax,%esi
add $0x1,%eax
add $0x8,%rdx
mov %esi,(%rcx,%r13,1)
cmp %ebp,%eax
jne 1660 <func0+0xd0>
lea (%r14,%r10,1),%eax
sub $0x1,%r8d
cmp %r9d,%r8d
jl 16b5 <func0+0x125>
mov (%r12,%r11,8),%rcx
mov %r11d,%esi
movslq %r8d,%rdx
mov %eax,%ebp
sub %r9d,%esi
lea (%rcx,%rdx,4),%rdx
add %eax,%esi
nopw %cs:0x0(%rax,%rax,1)
mov %eax,%ecx
add $0x1,%eax
sub $0x4,%rdx
mov %ecx,0x4(%rdx)
cmp %esi,%eax
jne 16a0 <func0+0x110>
lea 0x0(%rbp,%r10,1),%eax
cmp %r8d,%edi
jg 16e9 <func0+0x159>
lea 0x0(,%r9,4),%r13
movslq %r8d,%rdx
lea -0x1(%rax,%r11,1),%ebp
nopw 0x0(%rax,%rax,1)
mov (%r12,%rdx,8),%rcx
mov %ebp,%esi
sub %edx,%esi
sub $0x1,%rdx
mov %esi,(%rcx,%r13,1)
cmp %edx,%edi
jle 16d0 <func0+0x140>
lea -0x1(%rax,%r10,1),%eax
add $0x1,%r9
sub $0x1,%r11
sub $0x2,%r10d
cmp %eax,%ebx
jge 1600 <func0+0x70>
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
xor r12d, r12d
push rbp
push rbx
sub rsp, 18h
test edi, edi
jle loc_1708
movsxd rbp, edi
mov r13d, edi
lea rdi, ds:0[rbp*8]
call _malloc
mov r12, rax
mov r15, rax
lea eax, [r13-1]
mov [rsp+48h+var_3C], eax
mov ebx, eax
mov eax, r13d
lea r14, [r12+rax*8]
nop word ptr [rax+rax+00000000h]
loc_15E0:
mov esi, 4
mov rdi, rbp
add r15, 8
call _calloc
mov [r15-8], rax
cmp r15, r14
jnz short loc_15E0
mov r11d, r13d
movsxd r10, [rsp+48h+var_3C]
xor edi, edi
xor r9d, r9d
imul r11d, r13d
mov eax, 1
xor esi, esi
mov r8, r10
nop dword ptr [rax]
loc_1618:
cmp esi, r8d
jg short loc_1650
mov rdx, [r12+r9*8]
lea ecx, [rax+1]
mov r14d, eax
lea r13d, [rcx+r8]
add rdx, rdi
sub r13d, esi
jmp short loc_163B
loc_1638:
add ecx, 1
loc_163B:
mov ebp, eax
add rdx, 4
mov eax, ecx
mov [rdx-4], ebp
cmp ecx, r13d
jnz short loc_1638
lea eax, [r14+rbx+1]
loc_1650:
add esi, 1
cmp esi, r8d
jg short loc_1691
mov r13d, r8d
movsxd rdx, esi
lea r14, ds:0[r10*4]
mov r15d, eax
sub r13d, r9d
lea rdx, [r12+rdx*8]
add r13d, eax
nop dword ptr [rax+rax+00h]
loc_1678:
mov rcx, [rdx]
mov ebp, eax
add eax, 1
add rdx, 8
mov [rcx+r14], ebp
cmp eax, r13d
jnz short loc_1678
lea eax, [r15+rbx]
loc_1691:
sub r8d, 1
cmp r8d, r9d
jl short loc_16C5
mov rcx, [r12+r10*8]
mov ebp, r10d
movsxd rdx, r8d
mov r13d, eax
sub ebp, r9d
lea rdx, [rcx+rdx*4]
add ebp, eax
loc_16B0:
mov ecx, eax
add eax, 1
sub rdx, 4
mov [rdx+4], ecx
cmp eax, ebp
jnz short loc_16B0
lea eax, [r13+rbx+0]
loc_16C5:
cmp esi, r8d
jg short loc_16F0
movsxd rdx, r8d
lea r13d, [rax+r10-1]
nop word ptr [rax+rax+00h]
loc_16D8:
mov rcx, [r12+rdx*8]
mov ebp, r13d
sub ebp, edx
sub rdx, 1
mov [rcx+rdi], ebp
cmp esi, edx
jle short loc_16D8
lea eax, [rax+rbx-1]
loc_16F0:
add r9, 1
sub r10, 1
sub ebx, 2
add rdi, 4
cmp r11d, eax
jge loc_1618
loc_1708:
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(int a1)
{
long long v1; // r12
long long v3; // r15
int v4; // ebx
long long v5; // r10
long long v6; // rdi
long long v7; // r9
int v8; // r11d
int v9; // eax
int v10; // esi
int v11; // r8d
int v12; // ecx
int v13; // r14d
long long v14; // rdx
int v15; // r13d
int v16; // ebp
int v17; // r15d
long long *v18; // rdx
int v19; // r13d
long long v20; // rcx
int v21; // ebp
int v22; // r13d
long long v23; // rdx
int v24; // ebp
int v25; // ecx
long long v26; // rdx
long long v27; // rcx
int v28; // ebp
int v30; // [rsp+Ch] [rbp-3Ch]
v1 = 0LL;
if ( a1 > 0 )
{
v1 = malloc(8LL * a1);
v3 = v1;
v30 = a1 - 1;
v4 = a1 - 1;
do
{
v3 += 8LL;
*(_QWORD *)(v3 - 8) = calloc(a1, 4LL);
}
while ( v3 != v1 + 8LL * (unsigned int)a1 );
v5 = v30;
v6 = 0LL;
v7 = 0LL;
v8 = a1 * a1;
v9 = 1;
v10 = 0;
v11 = v30;
do
{
if ( v10 <= v11 )
{
v12 = v9 + 1;
v13 = v9;
v14 = v6 + *(_QWORD *)(v1 + 8 * v7);
v15 = v9 + 1 + v11 - v10;
while ( 1 )
{
v16 = v9;
v14 += 4LL;
v9 = v12;
*(_DWORD *)(v14 - 4) = v16;
if ( v12 == v15 )
break;
++v12;
}
v9 = v13 + v4 + 1;
}
if ( ++v10 <= v11 )
{
v17 = v9;
v18 = (long long *)(v1 + 8LL * v10);
v19 = v9 + v11 - v7;
do
{
v20 = *v18;
v21 = v9++;
++v18;
*(_DWORD *)(v20 + 4 * v5) = v21;
}
while ( v9 != v19 );
v9 = v17 + v4;
}
if ( --v11 >= (int)v7 )
{
v22 = v9;
v23 = *(_QWORD *)(v1 + 8 * v5) + 4LL * v11;
v24 = v9 + v5 - v7;
do
{
v25 = v9++;
v23 -= 4LL;
*(_DWORD *)(v23 + 4) = v25;
}
while ( v9 != v24 );
v9 = v22 + v4;
}
if ( v10 <= v11 )
{
v26 = v11;
do
{
v27 = *(_QWORD *)(v1 + 8 * v26);
v28 = v9 + v5 - 1 - v26--;
*(_DWORD *)(v27 + v6) = v28;
}
while ( v10 <= (int)v26 );
v9 = v9 + v4 - 1;
}
++v7;
--v5;
v4 -= 2;
v6 += 4LL;
}
while ( v8 >= v9 );
}
return v1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST EDI,EDI
JLE 0x00101708
MOVSXD RBP,EDI
MOV R13D,EDI
LEA RDI,[RBP*0x8]
CALL 0x001010d0
MOV R12,RAX
MOV R15,RAX
LEA EAX,[R13 + -0x1]
MOV dword ptr [RSP + 0xc],EAX
MOV EBX,EAX
MOV EAX,R13D
LEA R14,[R12 + RAX*0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_001015e0:
MOV ESI,0x4
MOV RDI,RBP
ADD R15,0x8
CALL 0x001010c0
MOV qword ptr [R15 + -0x8],RAX
CMP R15,R14
JNZ 0x001015e0
MOV R11D,R13D
MOVSXD R10,dword ptr [RSP + 0xc]
XOR EDI,EDI
XOR R9D,R9D
IMUL R11D,R13D
MOV EAX,0x1
XOR ESI,ESI
MOV R8,R10
NOP dword ptr [RAX]
LAB_00101618:
CMP ESI,R8D
JG 0x00101650
MOV RDX,qword ptr [R12 + R9*0x8]
LEA ECX,[RAX + 0x1]
MOV R14D,EAX
LEA R13D,[RCX + R8*0x1]
ADD RDX,RDI
SUB R13D,ESI
JMP 0x0010163b
LAB_00101638:
ADD ECX,0x1
LAB_0010163b:
MOV EBP,EAX
ADD RDX,0x4
MOV EAX,ECX
MOV dword ptr [RDX + -0x4],EBP
CMP ECX,R13D
JNZ 0x00101638
LEA EAX,[R14 + RBX*0x1 + 0x1]
LAB_00101650:
ADD ESI,0x1
CMP ESI,R8D
JG 0x00101691
MOV R13D,R8D
MOVSXD RDX,ESI
LEA R14,[R10*0x4]
MOV R15D,EAX
SUB R13D,R9D
LEA RDX,[R12 + RDX*0x8]
ADD R13D,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101678:
MOV RCX,qword ptr [RDX]
MOV EBP,EAX
ADD EAX,0x1
ADD RDX,0x8
MOV dword ptr [RCX + R14*0x1],EBP
CMP EAX,R13D
JNZ 0x00101678
LEA EAX,[R15 + RBX*0x1]
LAB_00101691:
SUB R8D,0x1
CMP R8D,R9D
JL 0x001016c5
MOV RCX,qword ptr [R12 + R10*0x8]
MOV EBP,R10D
MOVSXD RDX,R8D
MOV R13D,EAX
SUB EBP,R9D
LEA RDX,[RCX + RDX*0x4]
ADD EBP,EAX
LAB_001016b0:
MOV ECX,EAX
ADD EAX,0x1
SUB RDX,0x4
MOV dword ptr [RDX + 0x4],ECX
CMP EAX,EBP
JNZ 0x001016b0
LEA EAX,[R13 + RBX*0x1]
LAB_001016c5:
CMP ESI,R8D
JG 0x001016f0
MOVSXD RDX,R8D
LEA R13D,[RAX + R10*0x1 + -0x1]
NOP word ptr [RAX + RAX*0x1]
LAB_001016d8:
MOV RCX,qword ptr [R12 + RDX*0x8]
MOV EBP,R13D
SUB EBP,EDX
SUB RDX,0x1
MOV dword ptr [RCX + RDI*0x1],EBP
CMP ESI,EDX
JLE 0x001016d8
LEA EAX,[RAX + RBX*0x1 + -0x1]
LAB_001016f0:
ADD R9,0x1
SUB R10,0x1
SUB EBX,0x2
ADD RDI,0x4
CMP R11D,EAX
JGE 0x00101618
LAB_00101708:
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(uint param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int8 *puVar5;
void *pvVar6;
int iVar7;
long *plVar8;
int *piVar9;
long lVar10;
int iVar11;
long lVar12;
uint uVar13;
int iVar14;
long lVar15;
ulong uVar16;
ulong uVar17;
int8 *puVar18;
int8 *puVar19;
puVar5 = (int8 *)0x0;
if (0 < (int)param_1) {
puVar5 = (int8 *)malloc((long)(int)param_1 * 8);
iVar1 = param_1 - 1;
puVar18 = puVar5;
do {
puVar19 = puVar18 + 1;
pvVar6 = calloc((long)(int)param_1,4);
*puVar18 = pvVar6;
puVar18 = puVar19;
} while (puVar19 != puVar5 + param_1);
uVar16 = (ulong)iVar1;
lVar12 = 0;
lVar15 = 0;
iVar2 = 1;
iVar11 = 0;
uVar17 = uVar16;
do {
iVar7 = (int)uVar16;
if (iVar11 <= iVar7) {
piVar9 = (int *)(puVar5[lVar15] + lVar12);
iVar14 = iVar2 + 1;
iVar4 = iVar2;
while( true ) {
iVar3 = iVar14;
*piVar9 = iVar4;
if (iVar3 == (iVar2 + 1 + iVar7) - iVar11) break;
piVar9 = piVar9 + 1;
iVar14 = iVar3 + 1;
iVar4 = iVar3;
}
iVar2 = iVar2 + 1 + iVar1;
}
iVar11 = iVar11 + 1;
iVar14 = (int)lVar15;
if (iVar11 <= iVar7) {
plVar8 = puVar5 + iVar11;
iVar4 = iVar2;
do {
lVar10 = *plVar8;
iVar3 = iVar4 + 1;
plVar8 = plVar8 + 1;
*(int *)(lVar10 + uVar17 * 4) = iVar4;
iVar4 = iVar3;
} while (iVar3 != (iVar7 - iVar14) + iVar2);
iVar2 = iVar2 + iVar1;
}
uVar13 = iVar7 - 1;
uVar16 = (ulong)uVar13;
if (iVar14 <= (int)uVar13) {
piVar9 = (int *)(puVar5[uVar17] + (long)(int)uVar13 * 4);
iVar7 = iVar2;
do {
iVar4 = iVar7 + 1;
*piVar9 = iVar7;
piVar9 = piVar9 + -1;
iVar7 = iVar4;
} while (iVar4 != ((int)uVar17 - iVar14) + iVar2);
iVar2 = iVar2 + iVar1;
}
if (iVar11 <= (int)uVar13) {
lVar10 = (long)(int)uVar13;
do {
plVar8 = puVar5 + lVar10;
iVar7 = (int)lVar10;
lVar10 = lVar10 + -1;
*(int *)(*plVar8 + lVar12) = (iVar2 + -1 + (int)uVar17) - iVar7;
} while (iVar11 <= (int)lVar10);
iVar2 = iVar2 + -1 + iVar1;
}
lVar15 = lVar15 + 1;
uVar17 = uVar17 - 1;
iVar1 = iVar1 + -2;
lVar12 = lVar12 + 4;
} while (iVar2 <= (int)(param_1 * param_1));
}
return puVar5;
} |
7,231 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int **func0(int n) {
if (n <= 0) return NULL;
int **matrix = (int **)malloc(n * sizeof(int *));
for (int i = 0; i < n; i++) {
matrix[i] = (int *)calloc(n, sizeof(int));
}
int row_st = 0, row_ed = n - 1;
int col_st = 0, col_ed = n - 1;
int current = 1;
while (1) {
if (current > n * n) break;
for (int c = col_st; c <= col_ed; c++) {
matrix[row_st][c] = current++;
}
row_st++;
for (int r = row_st; r <= row_ed; r++) {
matrix[r][col_ed] = current++;
}
col_ed--;
for (int c = col_ed; c >= col_st; c--) {
matrix[row_ed][c] = current++;
}
row_ed--;
for (int r = row_ed; r >= row_st; r--) {
matrix[r][col_st] = current++;
}
col_st++;
}
return matrix;
}
| int main() {
int n1 = 3, n2 = 2, n7 = 7;
int expected1[3][3] = {{1, 2, 3}, {8, 9, 4}, {7, 6, 5}};
int expected2[2][2] = {{1,2}, {4,3}};
int expected7[7][7] = {{1, 2, 3, 4, 5, 6, 7}, {24, 25, 26, 27, 28, 29, 8}, {23, 40, 41, 42, 43, 30, 9}, {22, 39, 48, 49, 44, 31, 10}, {21, 38, 47, 46, 45, 32, 11}, {20, 37, 36, 35, 34, 33, 12}, {19, 18, 17, 16, 15, 14, 13}};
int **result1 = func0(n1);
int **result2 = func0(n2);
int **result7 = func0(n7);
for (int i = 0; i < n1; i++) {
for (int j = 0; j < n1; j++) {
assert(result1[i][j] == expected1[i][j]);
}
}
for (int i = 0; i < n2; i++) {
for (int j = 0; j < n2; j++) {
assert(result2[i][j] == expected2[i][j]);
}
}
for (int i = 0; i < n7; i++) {
for (int j = 0; j < n7; j++) {
assert(result7[i][j] == expected7[i][j]);
}
}
for (int i = 0; i < n1; i++) free(result1[i]);
free(result1);
for (int i = 0; i < n2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < n7; i++) free(result7[i]);
free(result7);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
sub $0x18,%rsp
test %edi,%edi
jle 1782 <func0+0x272>
movslq %edi,%rbx
mov %edi,%r14d
lea 0x0(,%rbx,8),%rdi
callq 10d0 <malloc@plt>
mov %rax,%r12
mov %rax,%rbp
lea -0x1(%r14),%eax
mov %rax,%r15
lea 0x8(%r12,%rax,8),%r13
nopw 0x0(%rax,%rax,1)
mov $0x4,%esi
mov %rbx,%rdi
add $0x8,%rbp
callq 10c0 <calloc@plt>
mov %rax,-0x8(%rbp)
cmp %r13,%rbp
jne 1558 <func0+0x48>
lea -0x14(,%rbx,4),%rbx
movslq %r15d,%r13
xor %r8d,%r8d
xor %ebp,%ebp
movdqa 0xb36(%rip),%xmm4
mov %r13,%r11
mov %r13d,%r10d
xor %edi,%edi
imul %r14d,%r14d
mov %rbx,0x8(%rsp)
mov $0x1,%eax
movdqa 0xb28(%rip),%xmm2
movdqa %xmm4,%xmm5
movdqa %xmm2,%xmm3
cmp %r11d,%edi
jg 164b <func0+0x13b>
mov (%r12,%r8,2),%rsi
lea 0x1(%r10),%r9d
cmp $0x2,%r10d
jbe 179e <func0+0x28e>
mov %r9d,%ecx
movd %eax,%xmm6
lea (%rsi,%r8,1),%rdx
shr $0x2,%ecx
pshufd $0x0,%xmm6,%xmm0
shl $0x4,%rcx
paddd %xmm4,%xmm0
add %rdx,%rcx
nopl 0x0(%rax)
movdqa %xmm0,%xmm1
add $0x10,%rdx
paddd %xmm2,%xmm0
movups %xmm1,-0x10(%rdx)
cmp %rcx,%rdx
jne 15f0 <func0+0xe0>
mov %r9d,%ebx
and $0xfffffffc,%ebx
lea (%rax,%rbx,1),%ecx
lea (%rdi,%rbx,1),%edx
cmp %ebx,%r9d
je 1646 <func0+0x136>
movslq %edx,%r9
lea 0x1(%rcx),%r15d
mov %ecx,(%rsi,%r9,4)
lea 0x0(,%r9,4),%rbx
lea 0x1(%rdx),%r9d
cmp %r9d,%r11d
jl 1646 <func0+0x136>
add $0x2,%edx
mov %r15d,0x4(%rsi,%rbx,1)
add $0x2,%ecx
cmp %edx,%r11d
jl 1646 <func0+0x136>
mov %ecx,0x8(%rsi,%rbx,1)
lea 0x1(%rax,%r10,1),%eax
add $0x1,%edi
cmp %r11d,%edi
jg 1688 <func0+0x178>
mov %r11d,%r9d
movslq %edi,%rdx
lea 0x0(,%r13,4),%rbx
mov %eax,%r15d
sub %ebp,%r9d
lea (%r12,%rdx,8),%rdx
add %eax,%r9d
xchg %ax,%ax
mov (%rdx),%rcx
mov %eax,%esi
add $0x1,%eax
add $0x8,%rdx
mov %esi,(%rcx,%rbx,1)
cmp %r9d,%eax
jne 1670 <func0+0x160>
lea (%r15,%r10,1),%eax
sub $0x1,%r11d
cmp %ebp,%r11d
jl 173a <func0+0x22a>
lea -0x1(%r10),%edx
mov (%r12,%r13,8),%rsi
cmp $0x2,%edx
jbe 1794 <func0+0x284>
mov 0x8(%rsp),%rdx
mov %r10d,%ecx
movd %eax,%xmm7
shr $0x2,%ecx
pshufd $0x0,%xmm7,%xmm1
sub %r8,%rdx
shl $0x4,%rcx
paddd %xmm5,%xmm1
add %rsi,%rdx
mov %rdx,%rbx
sub %rcx,%rbx
mov %rbx,%rcx
nopl 0x0(%rax)
movdqa %xmm1,%xmm0
sub $0x10,%rdx
paddd %xmm3,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movups %xmm0,0x10(%rdx)
cmp %rcx,%rdx
jne 16d8 <func0+0x1c8>
mov %r10d,%r9d
mov %r11d,%edx
and $0xfffffffc,%r9d
lea (%rax,%r9,1),%ecx
sub %r9d,%edx
cmp %r10d,%r9d
je 1737 <func0+0x227>
movslq %edx,%r9
lea 0x1(%rcx),%r15d
mov %ecx,(%rsi,%r9,4)
lea 0x0(,%r9,4),%rbx
lea -0x1(%rdx),%r9d
cmp %ebp,%r9d
jl 1737 <func0+0x227>
sub $0x2,%edx
mov %r15d,-0x4(%rsi,%rbx,1)
add $0x2,%ecx
cmp %ebp,%edx
jl 1737 <func0+0x227>
mov %ecx,-0x8(%rsi,%rbx,1)
add %r10d,%eax
cmp %r11d,%edi
jg 176a <func0+0x25a>
movslq %r11d,%rdx
lea -0x1(%rax,%r13,1),%r9d
nopw 0x0(%rax,%rax,1)
mov (%r12,%rdx,8),%rcx
mov %r9d,%esi
sub %edx,%esi
sub $0x1,%rdx
mov %esi,(%rcx,%r8,1)
cmp %edx,%edi
jle 1750 <func0+0x240>
lea -0x1(%rax,%r10,1),%eax
add $0x1,%ebp
sub $0x1,%r13
sub $0x2,%r10d
add $0x4,%r8
cmp %eax,%r14d
jge 15b0 <func0+0xa0>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %r11d,%edx
mov %eax,%ecx
jmpq 1708 <func0+0x1f8>
mov %edi,%edx
mov %eax,%ecx
jmpq 1616 <func0+0x106>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
xor ebx, ebx
sub rsp, 18h
test edi, edi
jle loc_1724
movsxd rbp, edi
mov r14d, edi
lea r13, ds:0[rbp*8]
mov rdi, r13; size
call _malloc
mov rbx, rax
mov r12, rax
add r13, rax
nop dword ptr [rax+rax+00h]
loc_1500:
mov esi, 4; size
mov rdi, rbp; nmemb
add r12, 8
call _calloc
mov [r12-8], rax
cmp r13, r12
jnz short loc_1500
lea rcx, ds:0FFFFFFFFFFFFFFECh[rbp*4]
lea r10d, [r14-1]
xor edi, edi
xor esi, esi
imul r14d, r14d
mov [rsp+48h+var_40], rcx
movsxd r13, r10d
mov r9d, r10d
movdqa xmm3, cs:xmmword_20A0
movdqa xmm2, cs:xmmword_20B0
xor r12d, r12d
mov eax, 1
nop word ptr [rax+rax+00h]
loc_1558:
cmp esi, r10d
jg loc_15EC
mov r8, [rbx+rdi*2]
lea edx, [r9+1]
cmp r9d, 2
jbe loc_1740
mov r11d, edx
movd xmm4, eax
lea rcx, [r8+rdi]
shr r11d, 2
pshufd xmm0, xmm4, 0
shl r11, 4
paddd xmm0, xmm3
add r11, rcx
nop word ptr [rax+rax+00h]
loc_1598:
movdqa xmm1, xmm0
add rcx, 10h
paddd xmm0, xmm2
movups xmmword ptr [rcx-10h], xmm1
cmp r11, rcx
jnz short loc_1598
test dl, 3
jz short loc_15E7
and edx, 0FFFFFFFCh
lea ecx, [rax+rdx]
add edx, esi
loc_15BA:
movsxd r11, edx
lea r15d, [rcx+1]
mov [r8+r11*4], ecx
lea rbp, ds:0[r11*4]
cmp r10d, edx
jle short loc_15E7
add edx, 2
mov [r8+rbp+4], r15d
add ecx, 2
cmp r10d, edx
jl short loc_15E7
mov [r8+rbp+8], ecx
loc_15E7:
lea eax, [r9+rax+1]
loc_15EC:
add esi, 1
cmp esi, r10d
jg short loc_162A
mov r11d, r10d
movsxd rdx, esi
lea rbp, ds:0[r13*4]
mov r8d, eax
sub r11d, r12d
lea rdx, [rbx+rdx*8]
add r11d, eax
nop
loc_1610:
mov rcx, [rdx]
mov r15d, eax
add eax, 1
add rdx, 8
mov [rcx+rbp], r15d
cmp eax, r11d
jnz short loc_1610
lea eax, [r9+r8]
loc_162A:
sub r10d, 1
cmp r10d, r12d
jl loc_16D9
lea edx, [r9-1]
mov r8, [rbx+r13*8]
cmp edx, 2
jbe loc_1736
mov rdx, [rsp+48h+var_40]
mov r11d, r9d
movd xmm5, eax
shr r11d, 2
pshufd xmm1, xmm5, 0
sub rdx, rdi
shl r11, 4
paddd xmm1, xmm3
add rdx, r8
mov rcx, rdx
sub rcx, r11
nop dword ptr [rax+00000000h]
loc_1678:
movdqa xmm0, xmm1
sub rdx, 10h
paddd xmm1, xmm2
pshufd xmm0, xmm0, 1Bh
movups xmmword ptr [rdx+10h], xmm0
cmp rcx, rdx
jnz short loc_1678
test r9b, 3
jz short loc_16D6
mov r11d, r9d
mov edx, r10d
and r11d, 0FFFFFFFCh
lea ecx, [rax+r11]
sub edx, r11d
loc_16A9:
movsxd r11, edx
lea r15d, [rcx+1]
mov [r8+r11*4], ecx
lea rbp, ds:0[r11*4]
cmp r12d, edx
jge short loc_16D6
sub edx, 2
mov [r8+rbp-4], r15d
add ecx, 2
cmp edx, r12d
jl short loc_16D6
mov [r8+rbp-8], ecx
loc_16D6:
add eax, r9d
loc_16D9:
cmp esi, r10d
jg short loc_170B
movsxd rdx, r10d
lea r11d, [rax+r13-1]
nop word ptr [rax+rax+00000000h]
loc_16F0:
mov rcx, [rbx+rdx*8]
mov r8d, r11d
sub r8d, edx
sub rdx, 1
mov [rcx+rdi], r8d
cmp esi, edx
jle short loc_16F0
lea eax, [r9+rax-1]
loc_170B:
add r12d, 1
sub r13, 1
sub r9d, 2
add rdi, 4
cmp r14d, eax
jge loc_1558
loc_1724:
add rsp, 18h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1736:
mov edx, r10d
mov ecx, eax
jmp loc_16A9
loc_1740:
mov edx, esi
mov ecx, eax
jmp loc_15BA | _QWORD * func0(int a1)
{
_QWORD *v1; // rbx
long long v2; // rbp
_QWORD *v4; // r12
signed int v5; // r10d
unsigned long long v6; // rdi
int v7; // esi
int v8; // r14d
long long v9; // r13
unsigned int v10; // r9d
__m128i si128; // xmm3
__m128i v12; // xmm2
signed int v13; // r12d
signed int v14; // eax
long long v15; // r8
unsigned int v16; // edx
long long v17; // rcx
__m128i v18; // xmm0
__m128i v19; // xmm1
unsigned int v20; // edx
signed int v21; // ecx
int v22; // edx
long long v23; // rbp
int v24; // ecx
signed int v25; // r8d
long long *v26; // rdx
int v27; // r11d
long long v28; // rcx
signed int v29; // r15d
long long v30; // r8
__m128i v31; // xmm1
__m128i *v32; // rdx
__m128i v33; // xmm0
signed int v34; // ecx
signed int v35; // edx
long long v36; // rbp
int v37; // ecx
long long v38; // rdx
long long v39; // rcx
int v40; // r8d
long long v42; // [rsp+8h] [rbp-40h]
v1 = 0LL;
if ( a1 > 0 )
{
v2 = a1;
v1 = malloc(8LL * a1);
v4 = v1;
do
*v4++ = calloc(a1, 4uLL);
while ( &v1[a1] != v4 );
v5 = a1 - 1;
v6 = 0LL;
v7 = 0;
v8 = a1 * a1;
v42 = 4 * v2 - 20;
v9 = v5;
v10 = v5;
si128 = _mm_load_si128((const __m128i *)&xmmword_20A0);
v12 = _mm_load_si128((const __m128i *)&xmmword_20B0);
v13 = 0;
v14 = 1;
while ( 1 )
{
if ( v7 > v5 )
goto LABEL_15;
v15 = v1[v6 / 4];
v16 = v10 + 1;
if ( v10 <= 2 )
break;
v17 = v15 + v6;
v18 = _mm_add_epi32(_mm_shuffle_epi32(_mm_cvtsi32_si128(v14), 0), si128);
do
{
v19 = v18;
v17 += 16LL;
v18 = _mm_add_epi32(v18, v12);
*(__m128i *)(v17 - 16) = v19;
}
while ( v15 + v6 + 16LL * (v16 >> 2) != v17 );
if ( (v16 & 3) != 0 )
{
v20 = v16 & 0xFFFFFFFC;
v21 = v14 + v20;
v22 = v7 + v20;
LABEL_11:
*(_DWORD *)(v15 + 4LL * v22) = v21;
v23 = 4LL * v22;
if ( v5 > v22 )
{
*(_DWORD *)(v15 + v23 + 4) = v21 + 1;
v24 = v21 + 2;
if ( v5 >= v22 + 2 )
*(_DWORD *)(v15 + v23 + 8) = v24;
}
}
v14 += v10 + 1;
LABEL_15:
if ( ++v7 <= v5 )
{
v25 = v14;
v26 = &v1[v7];
v27 = v14 + v5 - v13;
do
{
v28 = *v26;
v29 = v14++;
++v26;
*(_DWORD *)(v28 + 4 * v9) = v29;
}
while ( v14 != v27 );
v14 = v10 + v25;
}
if ( --v5 < v13 )
goto LABEL_29;
v30 = v1[v9];
if ( v10 - 1 <= 2 )
{
v35 = v5;
v34 = v14;
goto LABEL_25;
}
v31 = _mm_add_epi32(_mm_shuffle_epi32(_mm_cvtsi32_si128(v14), 0), si128);
v32 = (__m128i *)(v30 + v42 - v6);
do
{
v33 = v31;
--v32;
v31 = _mm_add_epi32(v31, v12);
v32[1] = _mm_shuffle_epi32(v33, 27);
}
while ( (__m128i *)(v30 + v42 - v6 - 16LL * (v10 >> 2)) != v32 );
if ( (v10 & 3) != 0 )
{
v34 = v14 + (v10 & 0xFFFFFFFC);
v35 = v5 - (v10 & 0xFFFFFFFC);
LABEL_25:
*(_DWORD *)(v30 + 4LL * v35) = v34;
v36 = 4LL * v35;
if ( v13 < v35 )
{
*(_DWORD *)(v30 + v36 - 4) = v34 + 1;
v37 = v34 + 2;
if ( v35 - 2 >= v13 )
*(_DWORD *)(v30 + v36 - 8) = v37;
}
}
v14 += v10;
LABEL_29:
if ( v7 <= v5 )
{
v38 = v5;
do
{
v39 = v1[v38];
v40 = v14 + v9 - 1 - v38--;
*(_DWORD *)(v39 + v6) = v40;
}
while ( v7 <= (int)v38 );
v14 = v10 + v14 - 1;
}
++v13;
--v9;
v10 -= 2;
v6 += 4LL;
if ( v8 < v14 )
return v1;
}
v22 = v7;
v21 = v14;
goto LABEL_11;
}
return v1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
XOR EBX,EBX
SUB RSP,0x18
TEST EDI,EDI
JLE 0x00101724
MOVSXD RBP,EDI
MOV R14D,EDI
LEA R13,[RBP*0x8]
MOV RDI,R13
CALL 0x001010d0
MOV RBX,RAX
MOV R12,RAX
ADD R13,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101500:
MOV ESI,0x4
MOV RDI,RBP
ADD R12,0x8
CALL 0x001010c0
MOV qword ptr [R12 + -0x8],RAX
CMP R13,R12
JNZ 0x00101500
LEA RCX,[-0x14 + RBP*0x4]
LEA R10D,[R14 + -0x1]
XOR EDI,EDI
XOR ESI,ESI
IMUL R14D,R14D
MOV qword ptr [RSP + 0x8],RCX
MOVSXD R13,R10D
MOV R9D,R10D
MOVDQA XMM3,xmmword ptr [0x001020a0]
MOVDQA XMM2,xmmword ptr [0x001020b0]
XOR R12D,R12D
MOV EAX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101558:
CMP ESI,R10D
JG 0x001015ec
MOV R8,qword ptr [RBX + RDI*0x2]
LEA EDX,[R9 + 0x1]
CMP R9D,0x2
JBE 0x00101740
MOV R11D,EDX
MOVD XMM4,EAX
LEA RCX,[R8 + RDI*0x1]
SHR R11D,0x2
PSHUFD XMM0,XMM4,0x0
SHL R11,0x4
PADDD XMM0,XMM3
ADD R11,RCX
NOP word ptr [RAX + RAX*0x1]
LAB_00101598:
MOVDQA XMM1,XMM0
ADD RCX,0x10
PADDD XMM0,XMM2
MOVUPS xmmword ptr [RCX + -0x10],XMM1
CMP R11,RCX
JNZ 0x00101598
TEST DL,0x3
JZ 0x001015e7
AND EDX,0xfffffffc
LEA ECX,[RAX + RDX*0x1]
ADD EDX,ESI
LAB_001015ba:
MOVSXD R11,EDX
LEA R15D,[RCX + 0x1]
MOV dword ptr [R8 + R11*0x4],ECX
LEA RBP,[R11*0x4]
CMP R10D,EDX
JLE 0x001015e7
ADD EDX,0x2
MOV dword ptr [R8 + RBP*0x1 + 0x4],R15D
ADD ECX,0x2
CMP R10D,EDX
JL 0x001015e7
MOV dword ptr [R8 + RBP*0x1 + 0x8],ECX
LAB_001015e7:
LEA EAX,[R9 + RAX*0x1 + 0x1]
LAB_001015ec:
ADD ESI,0x1
CMP ESI,R10D
JG 0x0010162a
MOV R11D,R10D
MOVSXD RDX,ESI
LEA RBP,[R13*0x4]
MOV R8D,EAX
SUB R11D,R12D
LEA RDX,[RBX + RDX*0x8]
ADD R11D,EAX
NOP
LAB_00101610:
MOV RCX,qword ptr [RDX]
MOV R15D,EAX
ADD EAX,0x1
ADD RDX,0x8
MOV dword ptr [RCX + RBP*0x1],R15D
CMP EAX,R11D
JNZ 0x00101610
LEA EAX,[R9 + R8*0x1]
LAB_0010162a:
SUB R10D,0x1
CMP R10D,R12D
JL 0x001016d9
LEA EDX,[R9 + -0x1]
MOV R8,qword ptr [RBX + R13*0x8]
CMP EDX,0x2
JBE 0x00101736
MOV RDX,qword ptr [RSP + 0x8]
MOV R11D,R9D
MOVD XMM5,EAX
SHR R11D,0x2
PSHUFD XMM1,XMM5,0x0
SUB RDX,RDI
SHL R11,0x4
PADDD XMM1,XMM3
ADD RDX,R8
MOV RCX,RDX
SUB RCX,R11
NOP dword ptr [RAX]
LAB_00101678:
MOVDQA XMM0,XMM1
SUB RDX,0x10
PADDD XMM1,XMM2
PSHUFD XMM0,XMM0,0x1b
MOVUPS xmmword ptr [RDX + 0x10],XMM0
CMP RCX,RDX
JNZ 0x00101678
TEST R9B,0x3
JZ 0x001016d6
MOV R11D,R9D
MOV EDX,R10D
AND R11D,0xfffffffc
LEA ECX,[RAX + R11*0x1]
SUB EDX,R11D
LAB_001016a9:
MOVSXD R11,EDX
LEA R15D,[RCX + 0x1]
MOV dword ptr [R8 + R11*0x4],ECX
LEA RBP,[R11*0x4]
CMP R12D,EDX
JGE 0x001016d6
SUB EDX,0x2
MOV dword ptr [R8 + RBP*0x1 + -0x4],R15D
ADD ECX,0x2
CMP EDX,R12D
JL 0x001016d6
MOV dword ptr [R8 + RBP*0x1 + -0x8],ECX
LAB_001016d6:
ADD EAX,R9D
LAB_001016d9:
CMP ESI,R10D
JG 0x0010170b
MOVSXD RDX,R10D
LEA R11D,[RAX + R13*0x1 + -0x1]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001016f0:
MOV RCX,qword ptr [RBX + RDX*0x8]
MOV R8D,R11D
SUB R8D,EDX
SUB RDX,0x1
MOV dword ptr [RCX + RDI*0x1],R8D
CMP ESI,EDX
JLE 0x001016f0
LEA EAX,[R9 + RAX*0x1 + -0x1]
LAB_0010170b:
ADD R12D,0x1
SUB R13,0x1
SUB R9D,0x2
ADD RDI,0x4
CMP R14D,EAX
JGE 0x00101558
LAB_00101724:
ADD RSP,0x18
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101736:
MOV EDX,R10D
MOV ECX,EAX
JMP 0x001016a9
LAB_00101740:
MOV EDX,ESI
MOV ECX,EAX
JMP 0x001015ba | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 * func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int8 *puVar12;
void *pvVar13;
int *piVar14;
uint uVar15;
int iVar16;
long *plVar17;
int *piVar18;
int *piVar19;
long lVar20;
size_t __nmemb;
int iVar21;
long lVar22;
uint uVar23;
uint uVar24;
int iVar25;
int8 *puVar26;
int8 *puVar27;
long lVar28;
int iVar29;
int iVar30;
puVar12 = (int8 *)0x0;
if (0 < param_1) {
__nmemb = (size_t)param_1;
puVar12 = (int8 *)malloc(__nmemb * 8);
puVar26 = puVar12;
do {
puVar27 = puVar26 + 1;
pvVar13 = calloc(__nmemb,4);
*puVar26 = pvVar13;
iVar9 = _UNK_001020bc;
iVar8 = _UNK_001020b8;
iVar7 = _UNK_001020b4;
iVar6 = _DAT_001020b0;
iVar5 = _UNK_001020ac;
iVar4 = _UNK_001020a8;
iVar3 = _UNK_001020a4;
iVar2 = _DAT_001020a0;
puVar26 = puVar27;
} while (puVar12 + __nmemb != puVar27);
uVar24 = param_1 - 1;
lVar22 = 0;
iVar21 = 0;
lVar28 = (long)(int)uVar24;
iVar25 = 0;
iVar10 = 1;
uVar23 = uVar24;
do {
if (iVar21 <= (int)uVar24) {
lVar20 = *(long *)((long)puVar12 + lVar22 * 2);
uVar15 = uVar23 + 1;
iVar16 = iVar10;
iVar11 = iVar21;
if (uVar23 < 3) {
LAB_001015ba:
*(int *)(lVar20 + (long)iVar11 * 4) = iVar16;
lVar1 = (long)iVar11 * 4;
if (iVar11 < (int)uVar24) {
*(int *)(lVar20 + 4 + lVar1) = iVar16 + 1;
if (iVar11 + 2 <= (int)uVar24) {
*(int *)(lVar20 + 8 + lVar1) = iVar16 + 2;
}
}
}
else {
piVar14 = (int *)(lVar20 + lVar22);
iVar16 = iVar10 + iVar2;
iVar11 = iVar10 + iVar3;
iVar29 = iVar10 + iVar4;
iVar30 = iVar10 + iVar5;
do {
piVar18 = piVar14 + 4;
*piVar14 = iVar16;
piVar14[1] = iVar11;
piVar14[2] = iVar29;
piVar14[3] = iVar30;
piVar14 = piVar18;
iVar16 = iVar16 + iVar6;
iVar11 = iVar11 + iVar7;
iVar29 = iVar29 + iVar8;
iVar30 = iVar30 + iVar9;
} while ((int *)(lVar20 + lVar22) + (ulong)(uVar15 >> 2) * 4 != piVar18);
if ((uVar15 & 3) != 0) {
iVar16 = iVar10 + (uVar15 & 0xfffffffc);
iVar11 = (uVar15 & 0xfffffffc) + iVar21;
goto LAB_001015ba;
}
}
iVar10 = uVar23 + 1 + iVar10;
}
iVar21 = iVar21 + 1;
if (iVar21 <= (int)uVar24) {
plVar17 = puVar12 + iVar21;
iVar16 = iVar10;
do {
lVar20 = *plVar17;
iVar11 = iVar16 + 1;
plVar17 = plVar17 + 1;
*(int *)(lVar20 + lVar28 * 4) = iVar16;
iVar16 = iVar11;
} while (iVar11 != (uVar24 - iVar25) + iVar10);
iVar10 = uVar23 + iVar10;
}
uVar24 = uVar24 - 1;
if (iVar25 <= (int)uVar24) {
lVar20 = puVar12[lVar28];
iVar16 = iVar10;
uVar15 = uVar24;
if (uVar23 - 1 < 3) {
LAB_001016a9:
*(int *)(lVar20 + (long)(int)uVar15 * 4) = iVar16;
lVar1 = (long)(int)uVar15 * 4;
if (iVar25 < (int)uVar15) {
*(int *)(lVar20 + -4 + lVar1) = iVar16 + 1;
if (iVar25 <= (int)(uVar15 - 2)) {
*(int *)(lVar20 + -8 + lVar1) = iVar16 + 2;
}
}
}
else {
piVar18 = (int *)(((__nmemb * 4 + -0x14) - lVar22) + lVar20);
piVar14 = piVar18;
iVar16 = iVar10 + iVar2;
iVar11 = iVar10 + iVar3;
iVar29 = iVar10 + iVar4;
iVar30 = iVar10 + iVar5;
do {
piVar19 = piVar14 + -4;
*piVar14 = iVar30;
piVar14[1] = iVar29;
piVar14[2] = iVar11;
piVar14[3] = iVar16;
piVar14 = piVar19;
iVar16 = iVar16 + iVar6;
iVar11 = iVar11 + iVar7;
iVar29 = iVar29 + iVar8;
iVar30 = iVar30 + iVar9;
} while (piVar18 + (ulong)(uVar23 >> 2) * -4 != piVar19);
if ((uVar23 & 3) != 0) {
iVar16 = iVar10 + (uVar23 & 0xfffffffc);
uVar15 = uVar24 - (uVar23 & 0xfffffffc);
goto LAB_001016a9;
}
}
iVar10 = iVar10 + uVar23;
}
if (iVar21 <= (int)uVar24) {
lVar20 = (long)(int)uVar24;
do {
plVar17 = puVar12 + lVar20;
iVar16 = (int)lVar20;
lVar20 = lVar20 + -1;
*(int *)(*plVar17 + lVar22) = (iVar10 + -1 + (int)lVar28) - iVar16;
} while (iVar21 <= (int)lVar20);
iVar10 = (uVar23 - 1) + iVar10;
}
iVar25 = iVar25 + 1;
lVar28 = lVar28 + -1;
uVar23 = uVar23 - 2;
lVar22 = lVar22 + 4;
} while (iVar10 <= param_1 * param_1);
}
return puVar12;
} |
7,232 | func0 |
#include <assert.h>
| float func0(int x1, int y1, int x2, int y2) {
return (float)(y2 - y1) / (x2 - x1);
}
| int main() {
assert(func0(4, 2, 2, 5) == -1.5);
assert(func0(2, 4, 4, 6) == 1.0);
assert(func0(1, 2, 4, 2) == 0.0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
mov %ecx,-0x10(%rbp)
mov -0x10(%rbp),%eax
sub -0x8(%rbp),%eax
cvtsi2ss %eax,%xmm0
mov -0xc(%rbp),%eax
sub -0x4(%rbp),%eax
cvtsi2ss %eax,%xmm1
divss %xmm1,%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
mov [rbp+var_10], ecx
mov eax, [rbp+var_10]
sub eax, [rbp+var_8]
pxor xmm0, xmm0
cvtsi2ss xmm0, eax
mov eax, [rbp+var_C]
sub eax, [rbp+var_4]
pxor xmm1, xmm1
cvtsi2ss xmm1, eax
divss xmm0, xmm1
pop rbp
retn | float func0(int a1, int a2, int a3, int a4)
{
return (float)(a4 - a2) / (float)(a3 - a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV dword ptr [RBP + -0x10],ECX
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,dword ptr [RBP + -0x8]
PXOR XMM0,XMM0
CVTSI2SS XMM0,EAX
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x4]
PXOR XMM1,XMM1
CVTSI2SS XMM1,EAX
DIVSS XMM0,XMM1
POP RBP
RET | int8 func0(int param_1,int param_2,int param_3,int param_4)
{
int auVar1 [16];
auVar1._4_12_ = SUB1612((int [16])0x0,4);
auVar1._0_4_ = (float)(param_4 - param_2) / (float)(param_3 - param_1);
return auVar1._0_8_;
} |
7,233 | func0 |
#include <assert.h>
| float func0(int x1, int y1, int x2, int y2) {
return (float)(y2 - y1) / (x2 - x1);
}
| int main() {
assert(func0(4, 2, 2, 5) == -1.5);
assert(func0(2, 4, 4, 6) == 1.0);
assert(func0(1, 2, 4, 2) == 0.0);
return 0;
}
| O1 | c | func0:
endbr64
sub %esi,%ecx
pxor %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
sub %edi,%edx
pxor %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
divss %xmm1,%xmm0
retq
| func0:
endbr64
sub ecx, esi
pxor xmm0, xmm0
cvtsi2ss xmm0, ecx
sub edx, edi
pxor xmm1, xmm1
cvtsi2ss xmm1, edx
divss xmm0, xmm1
retn | float func0(int a1, int a2, int a3, int a4)
{
return (float)(a4 - a2) / (float)(a3 - a1);
} | func0:
ENDBR64
SUB ECX,ESI
PXOR XMM0,XMM0
CVTSI2SS XMM0,ECX
SUB EDX,EDI
PXOR XMM1,XMM1
CVTSI2SS XMM1,EDX
DIVSS XMM0,XMM1
RET | int8 func0(int param_1,int param_2,int param_3,int param_4)
{
int1 auVar1 [16];
auVar1._4_12_ = SUB1612((int1 [16])0x0,4);
auVar1._0_4_ = (float)(param_4 - param_2) / (float)(param_3 - param_1);
return auVar1._0_8_;
} |
7,234 | func0 |
#include <assert.h>
| float func0(int x1, int y1, int x2, int y2) {
return (float)(y2 - y1) / (x2 - x1);
}
| int main() {
assert(func0(4, 2, 2, 5) == -1.5);
assert(func0(2, 4, 4, 6) == 1.0);
assert(func0(1, 2, 4, 2) == 0.0);
return 0;
}
| O2 | c | func0:
endbr64
sub %esi,%ecx
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
sub %edi,%edx
cvtsi2ss %ecx,%xmm0
cvtsi2ss %edx,%xmm1
divss %xmm1,%xmm0
retq
nopl (%rax)
| func0:
endbr64
sub ecx, esi
pxor xmm0, xmm0
pxor xmm1, xmm1
sub edx, edi
cvtsi2ss xmm0, ecx
cvtsi2ss xmm1, edx
divss xmm0, xmm1
retn | float func0(int a1, int a2, int a3, int a4)
{
return (float)(a4 - a2) / (float)(a3 - a1);
} | func0:
ENDBR64
SUB ECX,ESI
PXOR XMM0,XMM0
PXOR XMM1,XMM1
SUB EDX,EDI
CVTSI2SS XMM0,ECX
CVTSI2SS XMM1,EDX
DIVSS XMM0,XMM1
RET | int8 func0(int param_1,int param_2,int param_3,int param_4)
{
int1 auVar1 [16];
auVar1._4_12_ = SUB1612((int1 [16])0x0,4);
auVar1._0_4_ = (float)(param_4 - param_2) / (float)(param_3 - param_1);
return auVar1._0_8_;
} |
7,235 | func0 |
#include <assert.h>
| float func0(int x1, int y1, int x2, int y2) {
return (float)(y2 - y1) / (x2 - x1);
}
| int main() {
assert(func0(4, 2, 2, 5) == -1.5);
assert(func0(2, 4, 4, 6) == 1.0);
assert(func0(1, 2, 4, 2) == 0.0);
return 0;
}
| O3 | c | func0:
endbr64
sub %esi,%ecx
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
sub %edi,%edx
cvtsi2ss %ecx,%xmm0
cvtsi2ss %edx,%xmm1
divss %xmm1,%xmm0
retq
nopl (%rax)
| func0:
endbr64
sub ecx, esi
pxor xmm0, xmm0
pxor xmm1, xmm1
sub edx, edi
cvtsi2ss xmm0, ecx
cvtsi2ss xmm1, edx
divss xmm0, xmm1
retn | float func0(int a1, int a2, int a3, int a4)
{
return (float)(a4 - a2) / (float)(a3 - a1);
} | func0:
ENDBR64
SUB ECX,ESI
PXOR XMM0,XMM0
PXOR XMM1,XMM1
SUB EDX,EDI
CVTSI2SS XMM0,ECX
CVTSI2SS XMM1,EDX
DIVSS XMM0,XMM1
RET | int8 func0(int param_1,int param_2,int param_3,int param_4)
{
int auVar1 [16];
auVar1._4_12_ = SUB1612((int [16])0x0,4);
auVar1._0_4_ = (float)(param_4 - param_2) / (float)(param_3 - param_1);
return auVar1._0_8_;
} |
7,236 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int a[], int size) {
int max_so_far = INT_MIN;
int max_ending_here = 0;
int start = 0;
int end = 0;
int s = 0;
for (int i = 0; i < size; i++) {
max_ending_here += a[i];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
start = s;
end = i;
}
if (max_ending_here < 0) {
max_ending_here = 0;
s = i + 1;
}
}
return (end - start + 1);
}
| int main() {
assert(func0((int[]){-2, -3, 4, -1, -2, 1, 5, -3}, 8) == 5);
assert(func0((int[]){1, -2, 1, 1, -2, 1}, 6) == 2);
assert(func0((int[]){-1, -2, 3, 4, 5}, 5) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x80000000,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11f1 <func0+0x88>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x14(%rbp)
mov -0x18(%rbp),%eax
cmp -0x14(%rbp),%eax
jge 11d7 <func0+0x6e>
mov -0x14(%rbp),%eax
mov %eax,-0x18(%rbp)
mov -0x8(%rbp),%eax
mov %eax,-0x10(%rbp)
mov -0x4(%rbp),%eax
mov %eax,-0xc(%rbp)
cmpl $0x0,-0x14(%rbp)
jns 11ed <func0+0x84>
movl $0x0,-0x14(%rbp)
mov -0x4(%rbp),%eax
add $0x1,%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11a4 <func0+0x3b>
mov -0xc(%rbp),%eax
sub -0x10(%rbp),%eax
add $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_18], 80000000h
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11F1
loc_11A4:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
add [rbp+var_14], eax
mov eax, [rbp+var_18]
cmp eax, [rbp+var_14]
jge short loc_11D7
mov eax, [rbp+var_14]
mov [rbp+var_18], eax
mov eax, [rbp+var_8]
mov [rbp+var_10], eax
mov eax, [rbp+var_4]
mov [rbp+var_C], eax
loc_11D7:
cmp [rbp+var_14], 0
jns short loc_11ED
mov [rbp+var_14], 0
mov eax, [rbp+var_4]
add eax, 1
mov [rbp+var_8], eax
loc_11ED:
add [rbp+var_4], 1
loc_11F1:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_2C]
jl short loc_11A4
mov eax, [rbp+var_C]
sub eax, [rbp+var_10]
add eax, 1
pop rbp
retn | long long func0(long long a1, int a2)
{
signed int v3; // [rsp+14h] [rbp-18h]
int v4; // [rsp+18h] [rbp-14h]
int v5; // [rsp+1Ch] [rbp-10h]
int v6; // [rsp+20h] [rbp-Ch]
int v7; // [rsp+24h] [rbp-8h]
int i; // [rsp+28h] [rbp-4h]
v3 = 0x80000000;
v4 = 0;
v5 = 0;
v6 = 0;
v7 = 0;
for ( i = 0; i < a2; ++i )
{
v4 += *(_DWORD *)(4LL * i + a1);
if ( v3 < v4 )
{
v3 = v4;
v5 = v7;
v6 = i;
}
if ( v4 < 0 )
{
v4 = 0;
v7 = i + 1;
}
}
return (unsigned int)(v6 - v5 + 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x18],0x80000000
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011f1
LAB_001011a4:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x14]
JGE 0x001011d7
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0xc],EAX
LAB_001011d7:
CMP dword ptr [RBP + -0x14],0x0
JNS 0x001011ed
MOV dword ptr [RBP + -0x14],0x0
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
LAB_001011ed:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011f1:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011a4
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
local_20 = -0x80000000;
local_1c = 0;
local_18 = 0;
local_14 = 0;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_1c = local_1c + *(int *)(param_1 + (long)local_c * 4);
if (local_20 < local_1c) {
local_18 = local_10;
local_14 = local_c;
local_20 = local_1c;
}
if (local_1c < 0) {
local_1c = 0;
local_10 = local_c + 1;
}
}
return (local_14 - local_18) + 1;
} |
7,237 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int a[], int size) {
int max_so_far = INT_MIN;
int max_ending_here = 0;
int start = 0;
int end = 0;
int s = 0;
for (int i = 0; i < size; i++) {
max_ending_here += a[i];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
start = s;
end = i;
}
if (max_ending_here < 0) {
max_ending_here = 0;
s = i + 1;
}
}
return (end - start + 1);
}
| int main() {
assert(func0((int[]){-2, -3, 4, -1, -2, 1, 5, -3}, 8) == 5);
assert(func0((int[]){1, -2, 1, 1, -2, 1}, 6) == 2);
assert(func0((int[]){-1, -2, 3, 4, 5}, 5) == 3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
test %esi,%esi
jle 11cd <func0+0x64>
lea -0x1(%rsi),%r10d
mov $0x0,%edx
mov $0x0,%r11d
mov $0x0,%eax
mov $0x0,%ebx
mov $0x0,%esi
mov $0x80000000,%r8d
mov $0x0,%ebp
jmp 11ae <func0+0x45>
test %ecx,%ecx
js 11c5 <func0+0x5c>
lea 0x1(%rdx),%rcx
cmp %r10,%rdx
je 11d7 <func0+0x6e>
mov %rcx,%rdx
mov %edx,%r9d
add (%rdi,%rdx,4),%esi
mov %esi,%ecx
cmp %r8d,%esi
jle 119e <func0+0x35>
mov %edx,%eax
mov %r11d,%ebx
mov %esi,%r8d
jmp 119e <func0+0x35>
lea 0x1(%r9),%r11d
mov %ebp,%esi
jmp 11a2 <func0+0x39>
mov $0x0,%eax
mov $0x0,%ebx
sub %ebx,%eax
add $0x1,%eax
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
test esi, esi
jle short loc_11CE
mov esi, esi
mov edx, 0
mov r11d, 0
mov eax, 0
mov ebx, 0
mov r8d, 0
mov r9d, 80000000h
mov ebp, 0
jmp short loc_11AA
loc_119D:
test ecx, ecx
js short loc_11C5
loc_11A1:
add rdx, 1
cmp rdx, rsi
jz short loc_11D8
loc_11AA:
mov r10d, edx
mov ecx, r8d
add ecx, [rdi+rdx*4]
mov r8d, ecx
cmp ecx, r9d
jle short loc_119D
mov eax, edx
mov ebx, r11d
mov r9d, ecx
jmp short loc_119D
loc_11C5:
lea r11d, [r10+1]
mov r8d, ebp
jmp short loc_11A1
loc_11CE:
mov eax, 0
mov ebx, 0
loc_11D8:
sub eax, ebx
add eax, 1
pop rbx
pop rbp
retn | long long func0(long long a1, int a2)
{
long long v2; // rdx
int v3; // r11d
int v4; // eax
int v5; // ebx
int v6; // r8d
signed int v7; // r9d
int v8; // ecx
if ( a2 <= 0 )
{
v4 = 0;
v5 = 0;
}
else
{
v2 = 0LL;
v3 = 0;
v4 = 0;
v5 = 0;
v6 = 0;
v7 = 0x80000000;
do
{
v8 = *(_DWORD *)(a1 + 4 * v2) + v6;
v6 = v8;
if ( v8 > v7 )
{
v4 = v2;
v5 = v3;
v7 = v8;
}
if ( v8 < 0 )
{
v3 = v2 + 1;
v6 = 0;
}
++v2;
}
while ( v2 != a2 );
}
return (unsigned int)(v4 - v5 + 1);
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x001011ce
MOV ESI,ESI
MOV EDX,0x0
MOV R11D,0x0
MOV EAX,0x0
MOV EBX,0x0
MOV R8D,0x0
MOV R9D,0x80000000
MOV EBP,0x0
JMP 0x001011aa
LAB_0010119d:
TEST ECX,ECX
JS 0x001011c5
LAB_001011a1:
ADD RDX,0x1
CMP RDX,RSI
JZ 0x001011d8
LAB_001011aa:
MOV R10D,EDX
MOV ECX,R8D
ADD ECX,dword ptr [RDI + RDX*0x4]
MOV R8D,ECX
CMP ECX,R9D
JLE 0x0010119d
MOV EAX,EDX
MOV EBX,R11D
MOV R9D,ECX
JMP 0x0010119d
LAB_001011c5:
LEA R11D,[R10 + 0x1]
MOV R8D,EBP
JMP 0x001011a1
LAB_001011ce:
MOV EAX,0x0
MOV EBX,0x0
LAB_001011d8:
SUB EAX,EBX
ADD EAX,0x1
POP RBX
POP RBP
RET | int func0(long param_1,uint param_2)
{
int iVar1;
ulong uVar2;
int iVar3;
ulong uVar4;
int iVar5;
int iVar6;
int iVar7;
if ((int)param_2 < 1) {
iVar1 = 0;
iVar5 = 0;
}
else {
uVar4 = 0;
iVar7 = 0;
uVar2 = 0;
iVar5 = 0;
iVar3 = 0;
iVar6 = -0x80000000;
do {
iVar3 = iVar3 + *(int *)(param_1 + uVar4 * 4);
if (iVar6 < iVar3) {
uVar2 = uVar4 & 0xffffffff;
iVar6 = iVar3;
iVar5 = iVar7;
}
iVar1 = (int)uVar2;
if (iVar3 < 0) {
iVar7 = (int)uVar4 + 1;
iVar3 = 0;
}
uVar4 = uVar4 + 1;
} while (uVar4 != param_2);
}
return (iVar1 - iVar5) + 1;
} |
7,238 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int a[], int size) {
int max_so_far = INT_MIN;
int max_ending_here = 0;
int start = 0;
int end = 0;
int s = 0;
for (int i = 0; i < size; i++) {
max_ending_here += a[i];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
start = s;
end = i;
}
if (max_ending_here < 0) {
max_ending_here = 0;
s = i + 1;
}
}
return (end - start + 1);
}
| int main() {
assert(func0((int[]){-2, -3, 4, -1, -2, 1, 5, -3}, 8) == 5);
assert(func0((int[]){1, -2, 1, 1, -2, 1}, 6) == 2);
assert(func0((int[]){-1, -2, 3, 4, 5}, 5) == 3);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 13d8 <func0+0x58>
push %rbx
xor %r8d,%r8d
xor %r9d,%r9d
xor %eax,%eax
xor %ebx,%ebx
xor %ecx,%ecx
mov $0x80000000,%r10d
xor %r11d,%r11d
xchg %ax,%ax
add (%rdi),%ecx
mov %ecx,%edx
cmp %r10d,%ecx
jle 13b2 <func0+0x32>
mov %r8d,%eax
mov %r9d,%ebx
mov %ecx,%r10d
add $0x1,%r8d
test %edx,%edx
cmovs %r11d,%edx
cmovs %r8d,%r9d
add $0x4,%rdi
mov %edx,%ecx
cmp %r8d,%esi
jne 13a0 <func0+0x20>
sub %ebx,%eax
pop %rbx
add $0x1,%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle short loc_1310
xor ecx, ecx
xor r8d, r8d
xor eax, eax
xor r11d, r11d
xor edx, edx
mov r9d, 80000000h
xor r10d, r10d
nop dword ptr [rax]
loc_12E0:
add edx, [rdi]
cmp edx, r9d
jle short loc_12EF
mov eax, ecx
mov r11d, r8d
mov r9d, edx
loc_12EF:
add ecx, 1
test edx, edx
cmovs r8d, ecx
cmovs edx, r10d
add rdi, 4
cmp esi, ecx
jnz short loc_12E0
sub eax, r11d
add eax, 1
retn
loc_1310:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2)
{
int v2; // ecx
int v3; // r8d
int v4; // eax
int v5; // r11d
int v6; // edx
signed int v7; // r9d
if ( a2 <= 0 )
return 1LL;
v2 = 0;
v3 = 0;
v4 = 0;
v5 = 0;
v6 = 0;
v7 = 0x80000000;
do
{
v6 += *a1;
if ( v6 > v7 )
{
v4 = v2;
v5 = v3;
v7 = v6;
}
++v2;
if ( v6 < 0 )
{
v3 = v2;
v6 = 0;
}
++a1;
}
while ( a2 != v2 );
return (unsigned int)(v4 - v5 + 1);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101310
XOR ECX,ECX
XOR R8D,R8D
XOR EAX,EAX
XOR R11D,R11D
XOR EDX,EDX
MOV R9D,0x80000000
XOR R10D,R10D
NOP dword ptr [RAX]
LAB_001012e0:
ADD EDX,dword ptr [RDI]
CMP EDX,R9D
JLE 0x001012ef
MOV EAX,ECX
MOV R11D,R8D
MOV R9D,EDX
LAB_001012ef:
ADD ECX,0x1
TEST EDX,EDX
CMOVS R8D,ECX
CMOVS EDX,R10D
ADD RDI,0x4
CMP ESI,ECX
JNZ 0x001012e0
SUB EAX,R11D
ADD EAX,0x1
RET
LAB_00101310:
MOV EAX,0x1
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
if (param_2 < 1) {
return 1;
}
iVar2 = 0;
iVar4 = 0;
iVar1 = 0;
iVar6 = 0;
iVar3 = 0;
iVar5 = -0x80000000;
do {
iVar3 = iVar3 + *param_1;
if (iVar5 < iVar3) {
iVar5 = iVar3;
iVar1 = iVar2;
iVar6 = iVar4;
}
iVar2 = iVar2 + 1;
if (iVar3 < 0) {
iVar3 = 0;
iVar4 = iVar2;
}
param_1 = param_1 + 1;
} while (param_2 != iVar2);
return (iVar1 - iVar6) + 1;
} |
7,239 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int a[], int size) {
int max_so_far = INT_MIN;
int max_ending_here = 0;
int start = 0;
int end = 0;
int s = 0;
for (int i = 0; i < size; i++) {
max_ending_here += a[i];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
start = s;
end = i;
}
if (max_ending_here < 0) {
max_ending_here = 0;
s = i + 1;
}
}
return (end - start + 1);
}
| int main() {
assert(func0((int[]){-2, -3, 4, -1, -2, 1, 5, -3}, 8) == 5);
assert(func0((int[]){1, -2, 1, 1, -2, 1}, 6) == 2);
assert(func0((int[]){-1, -2, 3, 4, 5}, 5) == 3);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1458 <func0+0x58>
push %rbx
xor %r8d,%r8d
xor %r9d,%r9d
xor %eax,%eax
xor %ebx,%ebx
xor %ecx,%ecx
mov $0x80000000,%r10d
xor %r11d,%r11d
xchg %ax,%ax
add (%rdi),%ecx
mov %ecx,%edx
cmp %ecx,%r10d
jge 1432 <func0+0x32>
mov %r8d,%eax
mov %r9d,%ebx
mov %ecx,%r10d
add $0x1,%r8d
test %edx,%edx
cmovs %r11d,%edx
cmovs %r8d,%r9d
add $0x4,%rdi
mov %edx,%ecx
cmp %r8d,%esi
jne 1420 <func0+0x20>
sub %ebx,%eax
pop %rbx
add $0x1,%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle short loc_1190
xor ecx, ecx
xor r8d, r8d
xor eax, eax
xor r11d, r11d
xor edx, edx
mov r9d, 80000000h
xor r10d, r10d
nop dword ptr [rax]
loc_1160:
add edx, [rdi]
cmp r9d, edx
jge short loc_116F
mov eax, ecx
mov r11d, r8d
mov r9d, edx
loc_116F:
add ecx, 1
test edx, edx
cmovs r8d, ecx
cmovs edx, r10d
add rdi, 4
cmp esi, ecx
jnz short loc_1160
sub eax, r11d
add eax, 1
retn
loc_1190:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2)
{
int v2; // ecx
int v3; // r8d
int v4; // eax
int v5; // r11d
int v6; // edx
signed int v7; // r9d
if ( a2 <= 0 )
return 1LL;
v2 = 0;
v3 = 0;
v4 = 0;
v5 = 0;
v6 = 0;
v7 = 0x80000000;
do
{
v6 += *a1;
if ( v7 < v6 )
{
v4 = v2;
v5 = v3;
v7 = v6;
}
++v2;
if ( v6 < 0 )
{
v3 = v2;
v6 = 0;
}
++a1;
}
while ( a2 != v2 );
return (unsigned int)(v4 - v5 + 1);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101190
XOR ECX,ECX
XOR R8D,R8D
XOR EAX,EAX
XOR R11D,R11D
XOR EDX,EDX
MOV R9D,0x80000000
XOR R10D,R10D
NOP dword ptr [RAX]
LAB_00101160:
ADD EDX,dword ptr [RDI]
CMP R9D,EDX
JGE 0x0010116f
MOV EAX,ECX
MOV R11D,R8D
MOV R9D,EDX
LAB_0010116f:
ADD ECX,0x1
TEST EDX,EDX
CMOVS R8D,ECX
CMOVS EDX,R10D
ADD RDI,0x4
CMP ESI,ECX
JNZ 0x00101160
SUB EAX,R11D
ADD EAX,0x1
RET
LAB_00101190:
MOV EAX,0x1
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
if (param_2 < 1) {
return 1;
}
iVar2 = 0;
iVar4 = 0;
iVar1 = 0;
iVar6 = 0;
iVar3 = 0;
iVar5 = -0x80000000;
do {
iVar3 = iVar3 + *param_1;
if (iVar5 < iVar3) {
iVar5 = iVar3;
iVar1 = iVar2;
iVar6 = iVar4;
}
iVar2 = iVar2 + 1;
if (iVar3 < 0) {
iVar3 = 0;
iVar4 = iVar2;
}
param_1 = param_1 + 1;
} while (param_2 != iVar2);
return (iVar1 - iVar6) + 1;
} |
7,240 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += (2 * i + 1) * (2 * i + 1) * (2 * i + 1);
}
return sum;
}
| int main() {
assert(func0(2) == 28);
assert(func0(3) == 153);
assert(func0(4) == 496);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1189 <func0+0x40>
mov -0x4(%rbp),%eax
add %eax,%eax
lea 0x1(%rax),%edx
mov -0x4(%rbp),%eax
add %eax,%eax
add $0x1,%eax
imul %edx,%eax
mov -0x4(%rbp),%edx
add %edx,%edx
add $0x1,%edx
imul %edx,%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 1164 <func0+0x1b>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_1189
loc_1164:
mov eax, [rbp+var_4]
add eax, eax
lea edx, [rax+1]
mov eax, [rbp+var_4]
add eax, eax
add eax, 1
imul eax, edx
mov edx, [rbp+var_4]
add edx, edx
add edx, 1
imul eax, edx
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_1189:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_14]
jl short loc_1164
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 0; i < a1; ++i )
v2 += (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 + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101189
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
ADD EAX,0x1
IMUL EAX,EDX
MOV EDX,dword ptr [RBP + -0x4]
ADD EDX,EDX
ADD EDX,0x1
IMUL EAX,EDX
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x00101164
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(int param_1)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_1; local_c = local_c + 1) {
local_10 = local_10 + (local_c * 2 + 1) * (local_c * 2 + 1) * (local_c * 2 + 1);
}
return local_10;
} |
7,241 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += (2 * i + 1) * (2 * i + 1) * (2 * i + 1);
}
return sum;
}
| int main() {
assert(func0(2) == 28);
assert(func0(3) == 153);
assert(func0(4) == 496);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1173 <func0+0x2a>
lea 0x1(%rdi,%rdi,1),%esi
mov $0x1,%eax
mov $0x0,%ecx
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add %edx,%ecx
add $0x2,%eax
cmp %esi,%eax
jne 115f <func0+0x16>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1170 <func0+0x27>
| func0:
endbr64
test edi, edi
jle short loc_1173
lea esi, [rdi+rdi+1]
mov eax, 1
mov ecx, 0
loc_115F:
mov edx, eax
imul edx, eax
imul edx, eax
add ecx, edx
add eax, 2
cmp eax, esi
jnz short loc_115F
loc_1170:
mov eax, ecx
retn
loc_1173:
mov ecx, 0
jmp short loc_1170 | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = 1;
v2 = 0;
do
{
v2 += v1 * v1 * v1;
v1 += 2;
}
while ( v1 != 2 * a1 + 1 );
}
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101173
LEA ESI,[RDI + RDI*0x1 + 0x1]
MOV EAX,0x1
MOV ECX,0x0
LAB_0010115f:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD ECX,EDX
ADD EAX,0x2
CMP EAX,ESI
JNZ 0x0010115f
LAB_00101170:
MOV EAX,ECX
RET
LAB_00101173:
MOV ECX,0x0
JMP 0x00101170 | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 2;
} while (iVar1 != param_1 * 2 + 1);
}
return iVar2;
} |
7,242 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += (2 * i + 1) * (2 * i + 1) * (2 * i + 1);
}
return sum;
}
| int main() {
assert(func0(2) == 28);
assert(func0(3) == 153);
assert(func0(4) == 496);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
lea 0x1(%rdi,%rdi,1),%ecx
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add $0x2,%eax
add %edx,%r8d
cmp %ecx,%eax
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test edi, edi
jle short loc_1170
lea ecx, [rdi+rdi+1]
mov eax, 1
xor r8d, r8d
nop dword ptr [rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
imul edx, eax
add eax, 2
add r8d, edx
cmp eax, ecx
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; // edx
if ( a1 <= 0 )
return 0LL;
v1 = 1;
v2 = 0;
do
{
v3 = v1 * v1 * v1;
v1 += 2;
v2 += v3;
}
while ( v1 != 2 * a1 + 1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
LEA ECX,[RDI + RDI*0x1 + 0x1]
MOV EAX,0x1
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD EAX,0x2
ADD R8D,EDX
CMP EAX,ECX
JNZ 0x00101158
MOV EAX,R8D
RET
LAB_00101170:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar3 = 0;
do {
iVar2 = iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 2;
iVar3 = iVar3 + iVar2;
} while (iVar1 != param_1 * 2 + 1);
return iVar3;
}
return 0;
} |
7,243 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += (2 * i + 1) * (2 * i + 1) * (2 * i + 1);
}
return sum;
}
| int main() {
assert(func0(2) == 28);
assert(func0(3) == 153);
assert(func0(4) == 496);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1230 <func0+0xf0>
lea -0x1(%rdi),%eax
cmp $0x15,%eax
jbe 1237 <func0+0xf7>
mov %edi,%edx
movdqa 0xeae(%rip),%xmm4
xor %eax,%eax
pxor %xmm3,%xmm3
movdqa 0xeb0(%rip),%xmm6
movdqa 0xeb8(%rip),%xmm5
shr $0x2,%edx
nopl 0x0(%rax,%rax,1)
movdqa %xmm4,%xmm0
add $0x1,%eax
paddd %xmm6,%xmm4
pslld $0x1,%xmm0
paddd %xmm5,%xmm0
movdqa %xmm0,%xmm7
movdqa %xmm0,%xmm2
psrlq $0x20,%xmm7
pmuludq %xmm0,%xmm2
movdqa %xmm7,%xmm8
pmuludq %xmm7,%xmm8
pshufd $0x8,%xmm2,%xmm1
pshufd $0x8,%xmm8,%xmm2
punpckldq %xmm2,%xmm1
pmuludq %xmm1,%xmm0
psrlq $0x20,%xmm1
pmuludq %xmm7,%xmm1
pshufd $0x8,%xmm0,%xmm0
pshufd $0x8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
paddd %xmm0,%xmm3
cmp %edx,%eax
jne 1180 <func0+0x40>
movdqa %xmm3,%xmm0
mov %edi,%ecx
psrldq $0x8,%xmm0
and $0xfffffffc,%ecx
paddd %xmm0,%xmm3
movdqa %xmm3,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm3
movd %xmm3,%r8d
test $0x3,%dil
je 1225 <func0+0xe5>
lea 0x1(%rcx,%rcx,1),%eax
mov %eax,%edx
add $0x1,%ecx
imul %eax,%edx
imul %eax,%edx
add $0x2,%eax
add %edx,%r8d
cmp %ecx,%edi
jg 1210 <func0+0xd0>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
xor %ecx,%ecx
xor %r8d,%r8d
jmp 120b <func0+0xcb>
xchg %ax,%ax
| func0:
endbr64
mov edx, edi
test edi, edi
jle loc_1378
lea eax, [rdi-1]
cmp eax, 0Dh
jbe loc_1381
mov ecx, edi
movdqa xmm3, cs:xmmword_2010
xor eax, eax
pxor xmm2, xmm2
movdqa xmm5, cs:xmmword_2020
movdqa xmm4, cs:xmmword_2030
shr ecx, 2
nop dword ptr [rax]
loc_1180:
movdqa xmm0, xmm3
add eax, 1
paddd xmm3, xmm5
pslld xmm0, 1
paddd xmm0, xmm4
movdqa xmm6, xmm0
movdqa xmm1, xmm0
psrlq xmm6, 20h ; ' '
pmuludq xmm1, xmm0
movdqa xmm7, xmm6
pmuludq xmm7, xmm6
pshufd xmm1, xmm1, 8
pshufd xmm7, xmm7, 8
punpckldq xmm1, xmm7
pmuludq xmm0, xmm1
psrlq xmm1, 20h ; ' '
pmuludq xmm1, xmm6
pshufd xmm0, xmm0, 8
pshufd xmm1, xmm1, 8
punpckldq xmm0, xmm1
paddd xmm2, xmm0
cmp eax, ecx
jnz short loc_1180
movdqa xmm0, xmm2
mov ecx, edx
psrldq xmm0, 8
and ecx, 0FFFFFFFCh
paddd xmm2, xmm0
movdqa xmm0, xmm2
psrldq xmm0, 4
paddd xmm2, xmm0
movd eax, xmm2
test dl, 3
jz locret_1380
loc_120A:
lea esi, [rcx+rcx]
lea r8d, [rsi+1]
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
lea edi, [rcx+1]
cmp edx, edi
jle locret_137A
lea r8d, [rsi+3]
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
lea edi, [rcx+2]
cmp edx, edi
jle locret_137A
lea r8d, [rsi+5]
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
lea edi, [rcx+3]
cmp edx, edi
jle locret_137A
lea r8d, [rsi+7]
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
lea edi, [rcx+4]
cmp edx, edi
jle locret_137A
lea r8d, [rsi+9]
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
lea edi, [rcx+5]
cmp edx, edi
jle locret_137A
lea r8d, [rsi+0Bh]
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
lea edi, [rcx+6]
cmp edx, edi
jle locret_137A
lea r8d, [rsi+0Dh]
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
lea edi, [rcx+7]
cmp edx, edi
jle locret_137A
lea r8d, [rsi+0Fh]
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
lea edi, [rcx+8]
cmp edx, edi
jle locret_137A
lea r8d, [rsi+11h]
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
lea edi, [rcx+9]
cmp edx, edi
jle short locret_137A
lea r8d, [rsi+13h]
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
lea edi, [rcx+0Ah]
cmp edx, edi
jle short locret_137A
lea r8d, [rsi+15h]
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
lea edi, [rcx+0Bh]
cmp edx, edi
jle short locret_137A
lea r8d, [rsi+17h]
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
lea edi, [rcx+0Ch]
cmp edx, edi
jle short locret_137A
lea r8d, [rsi+19h]
add ecx, 0Dh
mov edi, r8d
imul edi, r8d
imul edi, r8d
add eax, edi
cmp edx, ecx
jle short locret_137A
add esi, 1Bh
mov edx, esi
imul edx, esi
imul edx, esi
add eax, edx
retn
loc_1378:
xor eax, eax
locret_137A:
retn
locret_1380:
retn
loc_1381:
xor ecx, ecx
xor eax, eax
jmp loc_120A | long long func0(int a1)
{
__m128i si128; // xmm3
int v2; // eax
__m128i v3; // xmm2
__m128i v4; // xmm5
__m128i v5; // xmm4
__m128i v6; // xmm0
__m128i v7; // xmm0
__m128i v8; // xmm6
__m128i v9; // xmm1
unsigned int v10; // ecx
__m128i v11; // xmm2
long long result; // rax
int v13; // esi
if ( a1 <= 0 )
return 0LL;
if ( (unsigned int)(a1 - 1) <= 0xD )
{
v10 = 0;
LODWORD(result) = 0;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v2 = 0;
v3 = 0LL;
v4 = _mm_load_si128((const __m128i *)&xmmword_2020);
v5 = _mm_load_si128((const __m128i *)&xmmword_2030);
do
{
v6 = si128;
++v2;
si128 = _mm_add_epi32(si128, v4);
v7 = _mm_add_epi32(_mm_slli_epi32(v6, 1u), v5);
v8 = _mm_srli_epi64(v7, 0x20u);
v9 = _mm_unpacklo_epi32(_mm_shuffle_epi32(_mm_mul_epu32(v7, v7), 8), _mm_shuffle_epi32(_mm_mul_epu32(v8, v8), 8));
v3 = _mm_add_epi32(
v3,
_mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v7, v9), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v9, 0x20u), v8), 8)));
}
while ( v2 != (unsigned int)a1 >> 2 );
v10 = a1 & 0xFFFFFFFC;
v11 = _mm_add_epi32(v3, _mm_srli_si128(v3, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v11, _mm_srli_si128(v11, 4)));
if ( (a1 & 3) == 0 )
return result;
}
v13 = 2 * v10;
result = (unsigned int)((v13 + 1) * (v13 + 1) * (v13 + 1) + result);
if ( a1 > (int)(v10 + 1) )
{
result = (unsigned int)((v13 + 3) * (v13 + 3) * (v13 + 3) + result);
if ( a1 > (int)(v10 + 2) )
{
result = (unsigned int)((v13 + 5) * (v13 + 5) * (v13 + 5) + result);
if ( a1 > (int)(v10 + 3) )
{
result = (unsigned int)((v13 + 7) * (v13 + 7) * (v13 + 7) + result);
if ( a1 > (int)(v10 + 4) )
{
result = (unsigned int)((v13 + 9) * (v13 + 9) * (v13 + 9) + result);
if ( a1 > (int)(v10 + 5) )
{
result = (unsigned int)((v13 + 11) * (v13 + 11) * (v13 + 11) + result);
if ( a1 > (int)(v10 + 6) )
{
result = (unsigned int)((v13 + 13) * (v13 + 13) * (v13 + 13) + result);
if ( a1 > (int)(v10 + 7) )
{
result = (unsigned int)((v13 + 15) * (v13 + 15) * (v13 + 15) + result);
if ( a1 > (int)(v10 + 8) )
{
result = (unsigned int)((v13 + 17) * (v13 + 17) * (v13 + 17) + result);
if ( a1 > (int)(v10 + 9) )
{
result = (unsigned int)((v13 + 19) * (v13 + 19) * (v13 + 19) + result);
if ( a1 > (int)(v10 + 10) )
{
result = (unsigned int)((v13 + 21) * (v13 + 21) * (v13 + 21) + result);
if ( a1 > (int)(v10 + 11) )
{
result = (unsigned int)((v13 + 23) * (v13 + 23) * (v13 + 23) + result);
if ( a1 > (int)(v10 + 12) )
{
result = (unsigned int)((v13 + 25) * (v13 + 25) * (v13 + 25) + result);
if ( a1 > (int)(v10 + 13) )
return (unsigned int)((v13 + 27) * (v13 + 27) * (v13 + 27) + result);
}
}
}
}
}
}
}
}
}
}
}
}
return result;
} | func0:
ENDBR64
MOV EDX,EDI
TEST EDI,EDI
JLE 0x00101378
LEA EAX,[RDI + -0x1]
CMP EAX,0xd
JBE 0x00101381
MOV ECX,EDI
MOVDQA XMM3,xmmword ptr [0x00102010]
XOR EAX,EAX
PXOR XMM2,XMM2
MOVDQA XMM5,xmmword ptr [0x00102020]
MOVDQA XMM4,xmmword ptr [0x00102030]
SHR ECX,0x2
NOP dword ptr [RAX]
LAB_00101180:
MOVDQA XMM0,XMM3
ADD EAX,0x1
PADDD XMM3,XMM5
PSLLD XMM0,0x1
PADDD XMM0,XMM4
MOVDQA XMM6,XMM0
MOVDQA XMM1,XMM0
PSRLQ XMM6,0x20
PMULUDQ XMM1,XMM0
MOVDQA XMM7,XMM6
PMULUDQ XMM7,XMM6
PSHUFD XMM1,XMM1,0x8
PSHUFD XMM7,XMM7,0x8
PUNPCKLDQ XMM1,XMM7
PMULUDQ XMM0,XMM1
PSRLQ XMM1,0x20
PMULUDQ XMM1,XMM6
PSHUFD XMM0,XMM0,0x8
PSHUFD XMM1,XMM1,0x8
PUNPCKLDQ XMM0,XMM1
PADDD XMM2,XMM0
CMP EAX,ECX
JNZ 0x00101180
MOVDQA XMM0,XMM2
MOV ECX,EDX
PSRLDQ XMM0,0x8
AND ECX,0xfffffffc
PADDD XMM2,XMM0
MOVDQA XMM0,XMM2
PSRLDQ XMM0,0x4
PADDD XMM2,XMM0
MOVD EAX,XMM2
TEST DL,0x3
JZ 0x00101380
LAB_0010120a:
LEA ESI,[RCX + RCX*0x1]
LEA R8D,[RSI + 0x1]
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
LEA EDI,[RCX + 0x1]
CMP EDX,EDI
JLE 0x0010137a
LEA R8D,[RSI + 0x3]
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
LEA EDI,[RCX + 0x2]
CMP EDX,EDI
JLE 0x0010137a
LEA R8D,[RSI + 0x5]
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
LEA EDI,[RCX + 0x3]
CMP EDX,EDI
JLE 0x0010137a
LEA R8D,[RSI + 0x7]
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
LEA EDI,[RCX + 0x4]
CMP EDX,EDI
JLE 0x0010137a
LEA R8D,[RSI + 0x9]
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
LEA EDI,[RCX + 0x5]
CMP EDX,EDI
JLE 0x0010137a
LEA R8D,[RSI + 0xb]
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
LEA EDI,[RCX + 0x6]
CMP EDX,EDI
JLE 0x0010137a
LEA R8D,[RSI + 0xd]
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
LEA EDI,[RCX + 0x7]
CMP EDX,EDI
JLE 0x0010137a
LEA R8D,[RSI + 0xf]
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
LEA EDI,[RCX + 0x8]
CMP EDX,EDI
JLE 0x0010137a
LEA R8D,[RSI + 0x11]
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
LEA EDI,[RCX + 0x9]
CMP EDX,EDI
JLE 0x0010137a
LEA R8D,[RSI + 0x13]
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
LEA EDI,[RCX + 0xa]
CMP EDX,EDI
JLE 0x0010137a
LEA R8D,[RSI + 0x15]
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
LEA EDI,[RCX + 0xb]
CMP EDX,EDI
JLE 0x0010137a
LEA R8D,[RSI + 0x17]
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
LEA EDI,[RCX + 0xc]
CMP EDX,EDI
JLE 0x0010137a
LEA R8D,[RSI + 0x19]
ADD ECX,0xd
MOV EDI,R8D
IMUL EDI,R8D
IMUL EDI,R8D
ADD EAX,EDI
CMP EDX,ECX
JLE 0x0010137a
ADD ESI,0x1b
MOV EDX,ESI
IMUL EDX,ESI
IMUL EDX,ESI
ADD EAX,EDX
RET
LAB_00101378:
XOR EAX,EAX
LAB_0010137a:
RET
LAB_00101380:
RET
LAB_00101381:
XOR ECX,ECX
XOR EAX,EAX
JMP 0x0010120a | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint param_1)
{
uint uVar1;
int iVar2;
int iVar3;
int auVar4 [16];
long lVar6;
int auVar5 [16];
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
ulong uVar13;
if ((int)param_1 < 1) {
iVar8 = 0;
}
else {
if (param_1 - 1 < 0xe) {
uVar1 = 0;
iVar8 = 0;
}
else {
uVar1 = 0;
iVar7 = 0;
iVar9 = 0;
iVar10 = 0;
iVar11 = 0;
iVar8 = _DAT_00102010;
iVar2 = _UNK_00102014;
iVar3 = _UNK_00102018;
iVar12 = _UNK_0010201c;
do {
uVar1 = uVar1 + 1;
auVar4._0_4_ = iVar8 * 2 + _DAT_00102030;
auVar4._4_4_ = iVar2 * 2 + _UNK_00102034;
auVar4._8_4_ = iVar3 * 2 + _UNK_00102038;
auVar4._12_4_ = iVar12 * 2 + _UNK_0010203c;
uVar13 = auVar4._8_8_;
lVar6 = (uVar13 & 0xffffffff) * (ulong)auVar4._8_4_;
auVar5._8_4_ = (int4)lVar6;
auVar5._0_8_ = lVar6 << 0x20;
auVar5._12_4_ = (int)((uVar13 >> 0x20) * (ulong)auVar4._12_4_);
iVar7 = iVar7 + auVar4._0_4_ * auVar4._0_4_ * auVar4._0_4_;
iVar9 = iVar9 + auVar4._4_4_ * auVar4._4_4_ * auVar4._4_4_;
iVar10 = iVar10 + (int)((uVar13 & 0xffffffff) * (auVar5._8_8_ & 0xffffffff));
iVar11 = iVar11 + (int)((auVar5._8_8_ >> 0x20) * (ulong)auVar4._12_4_);
iVar8 = iVar8 + _DAT_00102020;
iVar2 = iVar2 + _UNK_00102024;
iVar3 = iVar3 + _UNK_00102028;
iVar12 = iVar12 + _UNK_0010202c;
} while (uVar1 != param_1 >> 2);
uVar1 = param_1 & 0xfffffffc;
iVar8 = iVar7 + iVar10 + iVar9 + iVar11;
if ((param_1 & 3) == 0) {
return iVar8;
}
}
iVar2 = uVar1 * 2;
iVar3 = iVar2 + 1;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 1) < (int)param_1) {
iVar3 = iVar2 + 3;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 2) < (int)param_1) {
iVar3 = iVar2 + 5;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 3) < (int)param_1) {
iVar3 = iVar2 + 7;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 4) < (int)param_1) {
iVar3 = iVar2 + 9;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 5) < (int)param_1) {
iVar3 = iVar2 + 0xb;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 6) < (int)param_1) {
iVar3 = iVar2 + 0xd;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 7) < (int)param_1) {
iVar3 = iVar2 + 0xf;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 8) < (int)param_1) {
iVar3 = iVar2 + 0x11;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 9) < (int)param_1) {
iVar3 = iVar2 + 0x13;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 10) < (int)param_1) {
iVar3 = iVar2 + 0x15;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 0xb) < (int)param_1) {
iVar3 = iVar2 + 0x17;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 0xc) < (int)param_1) {
iVar3 = iVar2 + 0x19;
iVar8 = iVar8 + iVar3 * iVar3 * iVar3;
if ((int)(uVar1 + 0xd) < (int)param_1) {
iVar2 = iVar2 + 0x1b;
return iVar8 + iVar2 * iVar2 * iVar2;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
return iVar8;
} |
7,244 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *s1, const char *s2) {
int c0 = 0;
int c1 = 0;
int length = strlen(s1);
for (int i = 0; i < length; i++) {
if (s1[i] == '0' && s2[i] == '1') {
c0++;
} else if (s1[i] == '1' && s2[i] == '0') {
c1++;
}
}
int result = c0 / 2 + c1 / 2;
if (c0 % 2 == 0 && c1 % 2 == 0) {
return result;
} else if ((c0 + c1) % 2 == 0) {
return result + 2;
} else {
return -1;
}
}
| int main() {
assert(func0("0011", "1111") == 1);
assert(func0("00011", "01001") == 2);
assert(func0("111", "111") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1201 <func0+0x98>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x30,%al
jne 11d1 <func0+0x68>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x31,%al
jne 11d1 <func0+0x68>
addl $0x1,-0x14(%rbp)
jmp 11fd <func0+0x94>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x31,%al
jne 11fd <func0+0x94>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x30,%al
jne 11fd <func0+0x94>
addl $0x1,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 11a3 <func0+0x3a>
mov -0x14(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,%ecx
mov -0x10(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
add %ecx,%eax
mov %eax,-0x4(%rbp)
mov -0x14(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 1241 <func0+0xd8>
mov -0x10(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 1241 <func0+0xd8>
mov -0x4(%rbp),%eax
jmp 125d <func0+0xf4>
mov -0x14(%rbp),%edx
mov -0x10(%rbp),%eax
add %edx,%eax
and $0x1,%eax
test %eax,%eax
jne 1258 <func0+0xef>
mov -0x4(%rbp),%eax
add $0x2,%eax
jmp 125d <func0+0xf4>
mov $0xffffffff,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_30], rsi
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
mov [rbp+var_C], 0
jmp short loc_1201
loc_11A3:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 30h ; '0'
jnz short loc_11D1
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 31h ; '1'
jnz short loc_11D1
add [rbp+var_14], 1
jmp short loc_11FD
loc_11D1:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 31h ; '1'
jnz short loc_11FD
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 30h ; '0'
jnz short loc_11FD
add [rbp+var_10], 1
loc_11FD:
add [rbp+var_C], 1
loc_1201:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_8]
jl short loc_11A3
mov eax, [rbp+var_14]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov ecx, eax
mov eax, [rbp+var_10]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
add eax, ecx
mov [rbp+var_4], eax
mov eax, [rbp+var_14]
and eax, 1
test eax, eax
jnz short loc_1241
mov eax, [rbp+var_10]
and eax, 1
test eax, eax
jnz short loc_1241
mov eax, [rbp+var_4]
jmp short locret_125D
loc_1241:
mov edx, [rbp+var_14]
mov eax, [rbp+var_10]
add eax, edx
and eax, 1
test eax, eax
jnz short loc_1258
mov eax, [rbp+var_4]
add eax, 2
jmp short locret_125D
loc_1258:
mov eax, 0FFFFFFFFh
locret_125D:
leave
retn | long long func0(const char *a1, long long a2)
{
int v3; // [rsp+1Ch] [rbp-14h]
int v4; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
int v6; // [rsp+28h] [rbp-8h]
unsigned int v7; // [rsp+2Ch] [rbp-4h]
v3 = 0;
v4 = 0;
v6 = strlen(a1);
for ( i = 0; i < v6; ++i )
{
if ( a1[i] == 48 && *(_BYTE *)(i + a2) == 49 )
{
++v3;
}
else if ( a1[i] == 49 && *(_BYTE *)(i + a2) == 48 )
{
++v4;
}
}
v7 = v3 / 2 + v4 / 2;
if ( (v3 & 1) == 0 && (v4 & 1) == 0 )
return v7;
if ( (((_BYTE)v3 + (_BYTE)v4) & 1) != 0 )
return 0xFFFFFFFFLL;
return v7 + 2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101201
LAB_001011a3:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x30
JNZ 0x001011d1
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x31
JNZ 0x001011d1
ADD dword ptr [RBP + -0x14],0x1
JMP 0x001011fd
LAB_001011d1:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x31
JNZ 0x001011fd
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x30
JNZ 0x001011fd
ADD dword ptr [RBP + -0x10],0x1
LAB_001011fd:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101201:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x8]
JL 0x001011a3
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x10]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
ADD EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101241
MOV EAX,dword ptr [RBP + -0x10]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101241
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x0010125d
LAB_00101241:
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,EDX
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101258
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x2
JMP 0x0010125d
LAB_00101258:
MOV EAX,0xffffffff
LAB_0010125d:
LEAVE
RET | int func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
uint local_1c;
uint local_18;
int local_14;
local_1c = 0;
local_18 = 0;
sVar2 = strlen(param_1);
for (local_14 = 0; local_14 < (int)sVar2; local_14 = local_14 + 1) {
if ((param_1[local_14] == '0') && (*(char *)(param_2 + local_14) == '1')) {
local_1c = local_1c + 1;
}
else if ((param_1[local_14] == '1') && (*(char *)(param_2 + local_14) == '0')) {
local_18 = local_18 + 1;
}
}
iVar1 = (int)local_18 / 2 + (int)local_1c / 2;
if (((local_1c & 1) != 0) || ((local_18 & 1) != 0)) {
if ((local_18 + local_1c & 1) == 0) {
iVar1 = iVar1 + 2;
}
else {
iVar1 = -1;
}
}
return iVar1;
} |
7,245 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *s1, const char *s2) {
int c0 = 0;
int c1 = 0;
int length = strlen(s1);
for (int i = 0; i < length; i++) {
if (s1[i] == '0' && s2[i] == '1') {
c0++;
} else if (s1[i] == '1' && s2[i] == '0') {
c1++;
}
}
int result = c0 / 2 + c1 / 2;
if (c0 % 2 == 0 && c1 % 2 == 0) {
return result;
} else if ((c0 + c1) % 2 == 0) {
return result + 2;
} else {
return -1;
}
}
| int main() {
assert(func0("0011", "1111") == 1);
assert(func0("00011", "01001") == 2);
assert(func0("111", "111") == 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 11dd <func0+0x94>
lea -0x1(%rcx),%r9d
mov $0x0,%eax
mov $0x0,%edi
mov $0x0,%ecx
jmp 1196 <func0+0x4d>
cmpb $0x31,(%rsi,%rax,1)
sete %dl
movzbl %dl,%edx
add %edx,%ecx
lea 0x1(%rax),%rdx
cmp %r9,%rax
je 11b3 <func0+0x6a>
mov %rdx,%rax
movzbl (%r8,%rax,1),%edx
cmp $0x30,%dl
je 117e <func0+0x35>
cmp $0x31,%dl
jne 118a <func0+0x41>
cmpb $0x30,(%rsi,%rax,1)
sete %dl
movzbl %dl,%edx
add %edx,%edi
jmp 118a <func0+0x41>
mov %ecx,%eax
shr $0x1f,%eax
add %ecx,%eax
sar %eax
mov %eax,%edx
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
add %edx,%eax
mov %ecx,%edx
or %edi,%edx
test $0x1,%dl
je 11e8 <func0+0x9f>
add %edi,%ecx
test $0x1,%cl
jne 11e3 <func0+0x9a>
add $0x2,%eax
retq
mov $0x0,%eax
retq
mov $0xffffffff,%eax
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov rbp, rsi
call _strlen
test eax, eax
jle short loc_11FA
lea edi, [rax-1]
mov eax, 0
mov esi, 0
mov ecx, 0
jmp short loc_11AF
loc_1196:
cmp byte ptr [rbp+rax+0], 31h ; '1'
setz dl
movzx edx, dl
add ecx, edx
loc_11A3:
lea rdx, [rax+1]
cmp rax, rdi
jz short loc_11CC
mov rax, rdx
loc_11AF:
movzx edx, byte ptr [rbx+rax]
cmp dl, 30h ; '0'
jz short loc_1196
cmp dl, 31h ; '1'
jnz short loc_11A3
cmp byte ptr [rbp+rax+0], 30h ; '0'
setz dl
movzx edx, dl
add esi, edx
jmp short loc_11A3
loc_11CC:
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
mov edx, esi
shr edx, 1Fh
add edx, esi
sar edx, 1
add eax, edx
mov edx, ecx
or edx, esi
test dl, 1
jz short loc_11F3
add ecx, esi
test cl, 1
jnz short loc_1201
add eax, 2
loc_11F3:
add rsp, 8
pop rbx
pop rbp
retn
loc_11FA:
mov eax, 0
jmp short loc_11F3
loc_1201:
mov eax, 0FFFFFFFFh
jmp short loc_11F3 | long long func0(long long a1, long long a2)
{
int v4; // eax
long long v5; // rdi
long long v6; // rax
int v7; // esi
int v8; // ecx
char v9; // dl
long long result; // rax
v4 = strlen();
if ( v4 <= 0 )
return 0LL;
v5 = (unsigned int)(v4 - 1);
v6 = 0LL;
v7 = 0;
v8 = 0;
while ( 1 )
{
v9 = *(_BYTE *)(a1 + v6);
if ( v9 == 48 )
{
v8 += *(_BYTE *)(a2 + v6) == 49;
}
else if ( v9 == 49 )
{
v7 += *(_BYTE *)(a2 + v6) == 48;
}
if ( v6 == v5 )
break;
++v6;
}
result = (unsigned int)(v7 / 2 + v8 / 2);
if ( (((unsigned __int8)v7 | (unsigned __int8)v8) & 1) != 0 )
{
if ( (((_BYTE)v7 + (_BYTE)v8) & 1) != 0 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(result + 2);
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV RBP,RSI
CALL 0x00101060
TEST EAX,EAX
JLE 0x001011fa
LEA EDI,[RAX + -0x1]
MOV EAX,0x0
MOV ESI,0x0
MOV ECX,0x0
JMP 0x001011af
LAB_00101196:
CMP byte ptr [RBP + RAX*0x1],0x31
SETZ DL
MOVZX EDX,DL
ADD ECX,EDX
LAB_001011a3:
LEA RDX,[RAX + 0x1]
CMP RAX,RDI
JZ 0x001011cc
MOV RAX,RDX
LAB_001011af:
MOVZX EDX,byte ptr [RBX + RAX*0x1]
CMP DL,0x30
JZ 0x00101196
CMP DL,0x31
JNZ 0x001011a3
CMP byte ptr [RBP + RAX*0x1],0x30
SETZ DL
MOVZX EDX,DL
ADD ESI,EDX
JMP 0x001011a3
LAB_001011cc:
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOV EDX,ESI
SHR EDX,0x1f
ADD EDX,ESI
SAR EDX,0x1
ADD EAX,EDX
MOV EDX,ECX
OR EDX,ESI
TEST DL,0x1
JZ 0x001011f3
ADD ECX,ESI
TEST CL,0x1
JNZ 0x00101201
ADD EAX,0x2
LAB_001011f3:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011fa:
MOV EAX,0x0
JMP 0x001011f3
LAB_00101201:
MOV EAX,0xffffffff
JMP 0x001011f3 | int func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
uint uVar4;
uint uVar5;
bool bVar6;
sVar2 = strlen(param_1);
if ((int)sVar2 < 1) {
iVar1 = 0;
}
else {
uVar5 = 0;
uVar4 = 0;
uVar3 = 0;
do {
if (param_1[uVar3] == '0') {
uVar4 = uVar4 + (*(char *)(param_2 + uVar3) == '1');
}
else if (param_1[uVar3] == '1') {
uVar5 = uVar5 + (*(char *)(param_2 + uVar3) == '0');
}
bVar6 = uVar3 != (int)sVar2 - 1;
uVar3 = uVar3 + 1;
} while (bVar6);
iVar1 = (int)uVar4 / 2 + (int)uVar5 / 2;
if (((uVar4 | uVar5) & 1) != 0) {
if ((uVar4 + uVar5 & 1) == 0) {
iVar1 = iVar1 + 2;
}
else {
iVar1 = -1;
}
}
}
return iVar1;
} |
7,246 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *s1, const char *s2) {
int c0 = 0;
int c1 = 0;
int length = strlen(s1);
for (int i = 0; i < length; i++) {
if (s1[i] == '0' && s2[i] == '1') {
c0++;
} else if (s1[i] == '1' && s2[i] == '0') {
c1++;
}
}
int result = c0 / 2 + c1 / 2;
if (c0 % 2 == 0 && c1 % 2 == 0) {
return result;
} else if ((c0 + c1) % 2 == 0) {
return result + 2;
} else {
return -1;
}
}
| int main() {
assert(func0("0011", "1111") == 1);
assert(func0("00011", "01001") == 2);
assert(func0("111", "111") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %eax,%eax
jle 12b0 <func0+0x90>
lea -0x1(%rax),%edi
xor %r8d,%r8d
xor %eax,%eax
xor %ecx,%ecx
jmp 1266 <func0+0x46>
nopl (%rax)
cmp $0x31,%dl
jne 125a <func0+0x3a>
xor %edx,%edx
cmpb $0x30,0x0(%rbp,%rax,1)
sete %dl
add %edx,%r8d
lea 0x1(%rax),%rdx
cmp %rax,%rdi
je 1284 <func0+0x64>
mov %rdx,%rax
movzbl (%rbx,%rax,1),%edx
cmp $0x30,%dl
jne 1248 <func0+0x28>
xor %edx,%edx
cmpb $0x31,0x0(%rbp,%rax,1)
sete %dl
add %edx,%ecx
lea 0x1(%rax),%rdx
cmp %rax,%rdi
jne 1263 <func0+0x43>
mov %ecx,%eax
mov %r8d,%edx
sar %edx
sar %eax
add %edx,%eax
mov %ecx,%edx
or %r8d,%edx
and $0x1,%edx
je 12a4 <func0+0x84>
add %r8d,%ecx
and $0x1,%ecx
jne 12b9 <func0+0x99>
add $0x2,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopl 0x0(%rax,%rax,1)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
mov $0xffffffff,%eax
jmp 12a4 <func0+0x84>
| func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test eax, eax
jle short loc_12B0
lea edi, [rax-1]
xor r8d, r8d
xor eax, eax
xor ecx, ecx
jmp short loc_1266
loc_1248:
cmp dl, 31h ; '1'
jnz short loc_125A
xor edx, edx
cmp byte ptr [rbp+rax+0], 30h ; '0'
setz dl
add r8d, edx
loc_125A:
lea rdx, [rax+1]
cmp rdi, rax
jz short loc_1284
loc_1263:
mov rax, rdx
loc_1266:
movzx edx, byte ptr [rbx+rax]
cmp dl, 30h ; '0'
jnz short loc_1248
xor edx, edx
cmp byte ptr [rbp+rax+0], 31h ; '1'
setz dl
add ecx, edx
lea rdx, [rax+1]
cmp rdi, rax
jnz short loc_1263
loc_1284:
mov eax, ecx
mov edx, r8d
sar edx, 1
sar eax, 1
add eax, edx
mov edx, ecx
or edx, r8d
and edx, 1
jz short loc_12A4
add ecx, r8d
and ecx, 1
jnz short loc_12B9
add eax, 2
loc_12A4:
add rsp, 8
pop rbx
pop rbp
retn
loc_12B0:
add rsp, 8
xor eax, eax
pop rbx
pop rbp
retn
loc_12B9:
mov eax, 0FFFFFFFFh
jmp short loc_12A4 | long long func0(long long a1, long long a2)
{
int v3; // eax
long long v4; // rdi
int v5; // r8d
long long v6; // rax
int v7; // ecx
long long v8; // rdx
char v9; // dl
long long result; // rax
v3 = strlen();
if ( v3 <= 0 )
return 0LL;
v4 = (unsigned int)(v3 - 1);
v5 = 0;
v6 = 0LL;
v7 = 0;
while ( 1 )
{
v9 = *(_BYTE *)(a1 + v6);
if ( v9 != 48 )
break;
v7 += *(_BYTE *)(a2 + v6) == 49;
v8 = v6 + 1;
if ( v4 == v6 )
goto LABEL_9;
LABEL_6:
v6 = v8;
}
if ( v9 == 49 )
v5 += *(_BYTE *)(a2 + v6) == 48;
v8 = v6 + 1;
if ( v4 != v6 )
goto LABEL_6;
LABEL_9:
result = (unsigned int)((v5 >> 1) + (v7 >> 1));
if ( (((unsigned __int8)v5 | (unsigned __int8)v7) & 1) != 0 )
{
if ( (((_BYTE)v5 + (_BYTE)v7) & 1) != 0 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(result + 2);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
TEST EAX,EAX
JLE 0x001012b0
LEA EDI,[RAX + -0x1]
XOR R8D,R8D
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00101266
LAB_00101248:
CMP DL,0x31
JNZ 0x0010125a
XOR EDX,EDX
CMP byte ptr [RBP + RAX*0x1],0x30
SETZ DL
ADD R8D,EDX
LAB_0010125a:
LEA RDX,[RAX + 0x1]
CMP RDI,RAX
JZ 0x00101284
LAB_00101263:
MOV RAX,RDX
LAB_00101266:
MOVZX EDX,byte ptr [RBX + RAX*0x1]
CMP DL,0x30
JNZ 0x00101248
XOR EDX,EDX
CMP byte ptr [RBP + RAX*0x1],0x31
SETZ DL
ADD ECX,EDX
LEA RDX,[RAX + 0x1]
CMP RDI,RAX
JNZ 0x00101263
LAB_00101284:
MOV EAX,ECX
MOV EDX,R8D
SAR EDX,0x1
SAR EAX,0x1
ADD EAX,EDX
MOV EDX,ECX
OR EDX,R8D
AND EDX,0x1
JZ 0x001012a4
ADD ECX,R8D
AND ECX,0x1
JNZ 0x001012b9
ADD EAX,0x2
LAB_001012a4:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001012b0:
ADD RSP,0x8
XOR EAX,EAX
POP RBX
POP RBP
RET
LAB_001012b9:
MOV EAX,0xffffffff
JMP 0x001012a4 | int func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
uint uVar3;
ulong uVar4;
uint uVar5;
sVar2 = strlen(param_1);
if ((int)sVar2 < 1) {
return 0;
}
uVar5 = 0;
uVar4 = 0;
uVar3 = 0;
while( true ) {
if (param_1[uVar4] == '0') {
uVar3 = uVar3 + (*(char *)(param_2 + uVar4) == '1');
}
else if (param_1[uVar4] == '1') {
uVar5 = uVar5 + (*(char *)(param_2 + uVar4) == '0');
}
if ((int)sVar2 - 1 == uVar4) break;
uVar4 = uVar4 + 1;
}
iVar1 = ((int)uVar3 >> 1) + ((int)uVar5 >> 1);
if (((uVar3 | uVar5) & 1) != 0) {
if ((uVar3 + uVar5 & 1) == 0) {
iVar1 = iVar1 + 2;
}
else {
iVar1 = -1;
}
}
return iVar1;
} |
7,247 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *s1, const char *s2) {
int c0 = 0;
int c1 = 0;
int length = strlen(s1);
for (int i = 0; i < length; i++) {
if (s1[i] == '0' && s2[i] == '1') {
c0++;
} else if (s1[i] == '1' && s2[i] == '0') {
c1++;
}
}
int result = c0 / 2 + c1 / 2;
if (c0 % 2 == 0 && c1 % 2 == 0) {
return result;
} else if ((c0 + c1) % 2 == 0) {
return result + 2;
} else {
return -1;
}
}
| int main() {
assert(func0("0011", "1111") == 1);
assert(func0("00011", "01001") == 2);
assert(func0("111", "111") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %eax,%eax
jle 12b0 <func0+0x90>
lea -0x1(%rax),%edi
xor %r8d,%r8d
xor %eax,%eax
xor %ecx,%ecx
jmp 1266 <func0+0x46>
nopl (%rax)
cmp $0x31,%dl
jne 125a <func0+0x3a>
xor %edx,%edx
cmpb $0x30,0x0(%rbp,%rax,1)
sete %dl
add %edx,%r8d
lea 0x1(%rax),%rdx
cmp %rax,%rdi
je 1284 <func0+0x64>
mov %rdx,%rax
movzbl (%rbx,%rax,1),%edx
cmp $0x30,%dl
jne 1248 <func0+0x28>
xor %edx,%edx
cmpb $0x31,0x0(%rbp,%rax,1)
sete %dl
add %edx,%ecx
lea 0x1(%rax),%rdx
cmp %rax,%rdi
jne 1263 <func0+0x43>
mov %ecx,%eax
mov %r8d,%edx
sar %edx
sar %eax
add %edx,%eax
mov %ecx,%edx
or %r8d,%edx
and $0x1,%edx
je 12a4 <func0+0x84>
add %r8d,%ecx
and $0x1,%ecx
jne 12b9 <func0+0x99>
add $0x2,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopl 0x0(%rax,%rax,1)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
mov $0xffffffff,%eax
jmp 12a4 <func0+0x84>
| func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test eax, eax
jle loc_12C0
lea ecx, [rax-1]
xor edi, edi
xor eax, eax
xor esi, esi
jmp short loc_126C
loc_1250:
cmp dl, 31h ; '1'
jnz short loc_1260
cmp byte ptr [rbp+rax+0], 30h ; '0'
jnz short loc_1260
add edi, 1
nop
loc_1260:
lea rdx, [rax+1]
cmp rax, rcx
jz short loc_1290
loc_1269:
mov rax, rdx
loc_126C:
movzx edx, byte ptr [rbx+rax]
cmp dl, 30h ; '0'
jnz short loc_1250
cmp byte ptr [rbp+rax+0], 31h ; '1'
jnz short loc_1260
add esi, 1
lea rdx, [rax+1]
cmp rax, rcx
jnz short loc_1269
nop dword ptr [rax+rax+00000000h]
loc_1290:
mov eax, esi
mov edx, edi
shr eax, 1Fh
shr edx, 1Fh
add eax, esi
add edx, edi
sar edx, 1
sar eax, 1
add eax, edx
mov edx, esi
or edx, edi
and edx, 1
jz short loc_12B7
add esi, edi
and esi, 1
jnz short loc_12C9
add eax, 2
loc_12B7:
add rsp, 8
pop rbx
pop rbp
retn
loc_12C0:
add rsp, 8
xor eax, eax
pop rbx
pop rbp
retn
loc_12C9:
mov eax, 0FFFFFFFFh
jmp short loc_12B7 | long long func0(const char *a1, long long a2)
{
int v4; // eax
long long v5; // rcx
int v6; // edi
long long v7; // rax
int v8; // esi
long long v9; // rdx
char v10; // dl
long long result; // rax
v4 = strlen(a1);
if ( v4 <= 0 )
return 0LL;
v5 = (unsigned int)(v4 - 1);
v6 = 0;
v7 = 0LL;
v8 = 0;
while ( 1 )
{
v10 = a1[v7];
if ( v10 == 48 )
break;
if ( v10 == 49 && *(_BYTE *)(a2 + v7) == 48 )
++v6;
LABEL_6:
v9 = v7 + 1;
if ( v7 == v5 )
goto LABEL_11;
LABEL_7:
v7 = v9;
}
if ( *(_BYTE *)(a2 + v7) != 49 )
goto LABEL_6;
++v8;
v9 = v7 + 1;
if ( v7 != v5 )
goto LABEL_7;
LABEL_11:
result = (unsigned int)(v6 / 2 + v8 / 2);
if ( (((unsigned __int8)v6 | (unsigned __int8)v8) & 1) != 0 )
{
if ( (((_BYTE)v6 + (_BYTE)v8) & 1) != 0 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(result + 2);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
TEST EAX,EAX
JLE 0x001012c0
LEA ECX,[RAX + -0x1]
XOR EDI,EDI
XOR EAX,EAX
XOR ESI,ESI
JMP 0x0010126c
LAB_00101250:
CMP DL,0x31
JNZ 0x00101260
CMP byte ptr [RBP + RAX*0x1],0x30
JNZ 0x00101260
ADD EDI,0x1
NOP
LAB_00101260:
LEA RDX,[RAX + 0x1]
CMP RAX,RCX
JZ 0x00101290
LAB_00101269:
MOV RAX,RDX
LAB_0010126c:
MOVZX EDX,byte ptr [RBX + RAX*0x1]
CMP DL,0x30
JNZ 0x00101250
CMP byte ptr [RBP + RAX*0x1],0x31
JNZ 0x00101260
ADD ESI,0x1
LEA RDX,[RAX + 0x1]
CMP RAX,RCX
JNZ 0x00101269
NOP dword ptr [RAX + RAX*0x1]
LAB_00101290:
MOV EAX,ESI
MOV EDX,EDI
SHR EAX,0x1f
SHR EDX,0x1f
ADD EAX,ESI
ADD EDX,EDI
SAR EDX,0x1
SAR EAX,0x1
ADD EAX,EDX
MOV EDX,ESI
OR EDX,EDI
AND EDX,0x1
JZ 0x001012b7
ADD ESI,EDI
AND ESI,0x1
JNZ 0x001012c9
ADD EAX,0x2
LAB_001012b7:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001012c0:
ADD RSP,0x8
XOR EAX,EAX
POP RBX
POP RBP
RET
LAB_001012c9:
MOV EAX,0xffffffff
JMP 0x001012b7 | int func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
uint uVar4;
uint uVar5;
sVar2 = strlen(param_1);
if (0 < (int)sVar2) {
uVar5 = 0;
uVar3 = 0;
uVar4 = 0;
while( true ) {
if (param_1[uVar3] == '0') {
if (*(char *)(param_2 + uVar3) == '1') {
uVar4 = uVar4 + 1;
}
}
else if ((param_1[uVar3] == '1') && (*(char *)(param_2 + uVar3) == '0')) {
uVar5 = uVar5 + 1;
}
if (uVar3 == (int)sVar2 - 1) break;
uVar3 = uVar3 + 1;
}
iVar1 = (int)uVar4 / 2 + (int)uVar5 / 2;
if (((uVar4 | uVar5) & 1) != 0) {
if ((uVar4 + uVar5 & 1) == 0) {
iVar1 = iVar1 + 2;
}
else {
iVar1 = -1;
}
}
return iVar1;
}
return 0;
} |
7,248 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char* first;
char* second;
} tuple;
| tuple* func0(tuple arr[], int n) {
for(int i = 0; i < n; i++) {
for(int j = 0; j < n - i -1; j++) {
if(strcmp(arr[j].first, arr[j +1].first) > 0) {
tuple temp = arr[j];
arr[j] = arr[j +1];
arr[j +1] = temp;
}
}
}
return arr;
}
| int main() {
// Test case 1
tuple test1[] = {{"Amana", "28"}, {"Zenat", "30"}, {"Abhishek", "29"}, {"Nikhil", "21"}, {"B", "C"}};
tuple expected1[] = {{"Abhishek", "29"}, {"Amana", "28"}, {"B", "C"}, {"Nikhil", "21"}, {"Zenat", "30"}};
func0(test1, 5);
for(int i = 0; i < 5; i++) {
assert(strcmp(test1[i].first, expected1[i].first) == 0);
assert(strcmp(test1[i].second, expected1[i].second) == 0);
}
// Test case 2
tuple test2[] = {{"aaaa", "28"}, {"aa", "30"}, {"bab", "29"}, {"bb", "21"}, {"csa", "C"}};
tuple expected2[] = {{"aa", "30"}, {"aaaa", "28"}, {"bab", "29"}, {"bb", "21"}, {"csa", "C"}};
func0(test2, 5);
for(int i = 0; i < 5; i++) {
assert(strcmp(test2[i].first, expected2[i].first) == 0);
assert(strcmp(test2[i].second, expected2[i].second) == 0);
}
// Test case 3
tuple test3[] = {{"Sarala", "28"}, {"Ayesha", "30"}, {"Suman", "29"}, {"Sai", "21"}, {"G", "H"}};
tuple expected3[] = {{"Ayesha", "30"}, {"G", "H"}, {"Sai", "21"}, {"Sarala", "28"}, {"Suman", "29"}};
func0(test3, 5);
for(int i = 0; i < 5; i++) {
assert(strcmp(test3[i].first, expected3[i].first) == 0);
assert(strcmp(test3[i].second, expected3[i].second) == 0);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x18(%rbp)
jmpq 1293 <func0+0x10a>
movl $0x0,-0x14(%rbp)
jmpq 127d <func0+0xf4>
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x14(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
jle 1279 <func0+0xf0>
mov -0x14(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%rdx
mov (%rax),%rax
mov %rax,-0x10(%rbp)
mov %rdx,-0x8(%rbp)
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
mov %rdx,%rcx
shl $0x4,%rcx
mov -0x28(%rbp),%rdx
add %rdx,%rcx
mov 0x8(%rax),%rdx
mov (%rax),%rax
mov %rax,(%rcx)
mov %rdx,0x8(%rcx)
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x10(%rbp),%rax
mov -0x8(%rbp),%rdx
mov %rax,(%rcx)
mov %rdx,0x8(%rcx)
addl $0x1,-0x14(%rbp)
mov -0x2c(%rbp),%eax
sub -0x18(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x14(%rbp)
jl 11b4 <func0+0x2b>
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11a8 <func0+0x1f>
mov -0x28(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_18], 0
jmp loc_1293
loc_11A8:
mov [rbp+var_14], 0
jmp loc_127D
loc_11B4:
mov eax, [rbp+var_14]
cdqe
add rax, 1
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_28]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_14]
cdqe
shl rax, 4
mov rcx, rax
mov rax, [rbp+var_28]
add rax, rcx
mov rax, [rax]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jle loc_1279
mov eax, [rbp+var_14]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_28]
add rax, rdx
mov rdx, [rax+8]
mov rax, [rax]
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
mov eax, [rbp+var_14]
cdqe
add rax, 1
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_14]
movsxd rdx, edx
mov rcx, rdx
shl rcx, 4
mov rdx, [rbp+var_28]
add rcx, rdx
mov rdx, [rax+8]
mov rax, [rax]
mov [rcx], rax
mov [rcx+8], rdx
mov eax, [rbp+var_14]
cdqe
add rax, 1
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_28]
lea rcx, [rdx+rax]
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
mov [rcx], rax
mov [rcx+8], rdx
loc_1279:
add [rbp+var_14], 1
loc_127D:
mov eax, [rbp+var_2C]
sub eax, [rbp+var_18]
sub eax, 1
cmp [rbp+var_14], eax
jl loc_11B4
add [rbp+var_18], 1
loc_1293:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl loc_11A8
mov rax, [rbp+var_28]
leave
retn | long long func0(long long a1, int a2)
{
long long *v2; // rax
_QWORD *v3; // rax
_QWORD *v4; // rcx
long long v5; // rdx
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
long long v9; // [rsp+20h] [rbp-10h]
long long v10; // [rsp+28h] [rbp-8h]
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j < a2 - i - 1; ++j )
{
if ( strcmp(*(const char **)(16LL * j + a1), *(const char **)(16 * (j + 1LL) + a1)) > 0 )
{
v2 = (long long *)(16LL * j + a1);
v9 = *v2;
v10 = v2[1];
v3 = (_QWORD *)(16 * (j + 1LL) + a1);
v4 = (_QWORD *)(a1 + 16LL * j);
v5 = v3[1];
*v4 = *v3;
v4[1] = v5;
*v3 = v9;
v3[1] = v10;
}
}
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101293
LAB_001011a8:
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010127d
LAB_001011b4:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
ADD RAX,0x1
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
SHL RAX,0x4
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101090
TEST EAX,EAX
JLE 0x00101279
MOV EAX,dword ptr [RBP + -0x14]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
ADD RAX,0x1
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
MOV RCX,RDX
SHL RCX,0x4
MOV RDX,qword ptr [RBP + -0x28]
ADD RCX,RDX
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RDX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
ADD RAX,0x1
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RDX
LAB_00101279:
ADD dword ptr [RBP + -0x14],0x1
LAB_0010127d:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
CMP dword ptr [RBP + -0x14],EAX
JL 0x001011b4
ADD dword ptr [RBP + -0x18],0x1
LAB_00101293:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011a8
MOV RAX,qword ptr [RBP + -0x28]
LEAVE
RET | long func0(long param_1,int param_2)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int iVar4;
int8 *puVar5;
int8 *puVar6;
int local_20;
int local_1c;
for (local_20 = 0; local_20 < param_2; local_20 = local_20 + 1) {
for (local_1c = 0; local_1c < (param_2 - local_20) + -1; local_1c = local_1c + 1) {
iVar4 = strcmp(*(char **)(param_1 + (long)local_1c * 0x10),
*(char **)(param_1 + ((long)local_1c + 1) * 0x10));
if (0 < iVar4) {
puVar5 = (int8 *)(param_1 + (long)local_1c * 0x10);
uVar1 = puVar5[1];
uVar2 = *puVar5;
puVar5 = (int8 *)(param_1 + ((long)local_1c + 1) * 0x10);
puVar6 = (int8 *)((long)local_1c * 0x10 + param_1);
uVar3 = puVar5[1];
*puVar6 = *puVar5;
puVar6[1] = uVar3;
puVar5 = (int8 *)(((long)local_1c + 1) * 0x10 + param_1);
*puVar5 = uVar2;
puVar5[1] = uVar1;
}
}
}
return param_1;
} |
7,249 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char* first;
char* second;
} tuple;
| tuple* func0(tuple arr[], int n) {
for(int i = 0; i < n; i++) {
for(int j = 0; j < n - i -1; j++) {
if(strcmp(arr[j].first, arr[j +1].first) > 0) {
tuple temp = arr[j];
arr[j] = arr[j +1];
arr[j +1] = temp;
}
}
}
return arr;
}
| int main() {
// Test case 1
tuple test1[] = {{"Amana", "28"}, {"Zenat", "30"}, {"Abhishek", "29"}, {"Nikhil", "21"}, {"B", "C"}};
tuple expected1[] = {{"Abhishek", "29"}, {"Amana", "28"}, {"B", "C"}, {"Nikhil", "21"}, {"Zenat", "30"}};
func0(test1, 5);
for(int i = 0; i < 5; i++) {
assert(strcmp(test1[i].first, expected1[i].first) == 0);
assert(strcmp(test1[i].second, expected1[i].second) == 0);
}
// Test case 2
tuple test2[] = {{"aaaa", "28"}, {"aa", "30"}, {"bab", "29"}, {"bb", "21"}, {"csa", "C"}};
tuple expected2[] = {{"aa", "30"}, {"aaaa", "28"}, {"bab", "29"}, {"bb", "21"}, {"csa", "C"}};
func0(test2, 5);
for(int i = 0; i < 5; i++) {
assert(strcmp(test2[i].first, expected2[i].first) == 0);
assert(strcmp(test2[i].second, expected2[i].second) == 0);
}
// Test case 3
tuple test3[] = {{"Sarala", "28"}, {"Ayesha", "30"}, {"Suman", "29"}, {"Sai", "21"}, {"G", "H"}};
tuple expected3[] = {{"Ayesha", "30"}, {"G", "H"}, {"Sai", "21"}, {"Sarala", "28"}, {"Suman", "29"}};
func0(test3, 5);
for(int i = 0; i < 5; i++) {
assert(strcmp(test3[i].first, expected3[i].first) == 0);
assert(strcmp(test3[i].second, expected3[i].second) == 0);
}
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r14
test %esi,%esi
jle 11e8 <func0+0x5f>
lea -0x1(%rsi),%r13d
lea 0x10(%rdi),%r15
jmp 11fe <func0+0x75>
add $0x10,%rbx
cmp %r12,%rbx
je 11fa <func0+0x71>
mov (%rbx),%rbp
mov 0x10(%rbx),%rsi
mov %rbp,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
jle 11ac <func0+0x23>
mov 0x8(%rbx),%rax
movdqu 0x10(%rbx),%xmm0
movups %xmm0,(%rbx)
mov %rbp,0x10(%rbx)
mov %rax,0x18(%rbx)
jmp 11ac <func0+0x23>
sub $0x1,%r13d
cmp $0xffffffff,%r13d
jne 11fe <func0+0x75>
mov %r14,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
sub $0x1,%r13d
test %r13d,%r13d
jle 11de <func0+0x55>
mov %r14,%rbx
lea -0x1(%r13),%r12d
shl $0x4,%r12
add %r15,%r12
jmp 11b5 <func0+0x2c>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r14, rdi
test esi, esi
jle short loc_11E8
lea r13d, [rsi-1]
lea r15, [rdi+10h]
jmp short loc_11FE
loc_11AC:
add rbx, 10h
cmp rbx, r12
jz short loc_11FA
loc_11B5:
mov rbp, [rbx]
mov rsi, [rbx+10h]
mov rdi, rbp
call _strcmp
test eax, eax
jle short loc_11AC
mov rax, [rbx+8]
movdqu xmm0, xmmword ptr [rbx+10h]
movups xmmword ptr [rbx], xmm0
mov [rbx+10h], rbp
mov [rbx+18h], rax
jmp short loc_11AC
loc_11DE:
sub r13d, 1
cmp r13d, 0FFFFFFFFh
jnz short loc_11FE
loc_11E8:
mov rax, r14
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_11FA:
sub r13d, 1
loc_11FE:
test r13d, r13d
jle short loc_11DE
mov rbx, r14
lea r12d, [r13-1]
shl r12, 4
add r12, r15
jmp short loc_11B5 | __m128i * func0(__m128i *a1, int a2)
{
int v2; // r13d
__m128i *v3; // rbx
long long v4; // rbp
long long v5; // rax
if ( a2 > 0 )
{
v2 = a2 - 1;
do
{
while ( v2 > 0 )
{
v3 = a1;
do
{
v4 = v3->m128i_i64[0];
if ( (int)strcmp(v3->m128i_i64[0], v3[1].m128i_i64[0]) > 0 )
{
v5 = v3->m128i_i64[1];
*v3 = _mm_loadu_si128(v3 + 1);
v3[1].m128i_i64[0] = v4;
v3[1].m128i_i64[1] = v5;
}
++v3;
}
while ( v3 != &a1[(unsigned int)(v2 - 1) + 1] );
--v2;
}
--v2;
}
while ( v2 != -1 );
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R14,RDI
TEST ESI,ESI
JLE 0x001011e8
LEA R13D,[RSI + -0x1]
LEA R15,[RDI + 0x10]
JMP 0x001011fe
LAB_001011ac:
ADD RBX,0x10
CMP RBX,R12
JZ 0x001011fa
LAB_001011b5:
MOV RBP,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x10]
MOV RDI,RBP
CALL 0x00101090
TEST EAX,EAX
JLE 0x001011ac
MOV RAX,qword ptr [RBX + 0x8]
MOVDQU XMM0,xmmword ptr [RBX + 0x10]
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RBX + 0x10],RBP
MOV qword ptr [RBX + 0x18],RAX
JMP 0x001011ac
LAB_001011de:
SUB R13D,0x1
CMP R13D,-0x1
JNZ 0x001011fe
LAB_001011e8:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001011fa:
SUB R13D,0x1
LAB_001011fe:
TEST R13D,R13D
JLE 0x001011de
MOV RBX,R14
LEA R12D,[R13 + -0x1]
SHL R12,0x4
ADD R12,R15
JMP 0x001011b5 | int8 * func0(int8 *param_1,int param_2)
{
char *__s1;
int8 uVar1;
int iVar2;
int8 *puVar3;
if (0 < param_2) {
param_2 = param_2 + -1;
do {
for (; 0 < param_2; param_2 = param_2 + -1) {
puVar3 = param_1;
do {
__s1 = (char *)*puVar3;
iVar2 = strcmp(__s1,(char *)puVar3[2]);
if (0 < iVar2) {
uVar1 = puVar3[1];
*puVar3 = puVar3[2];
puVar3[1] = puVar3[3];
puVar3[2] = __s1;
puVar3[3] = uVar1;
}
puVar3 = puVar3 + 2;
} while (puVar3 != param_1 + (ulong)(param_2 - 1) * 2 + 2);
}
param_2 = param_2 + -1;
} while (param_2 != -1);
}
return param_1;
} |
7,250 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char* first;
char* second;
} tuple;
| tuple* func0(tuple arr[], int n) {
for(int i = 0; i < n; i++) {
for(int j = 0; j < n - i -1; j++) {
if(strcmp(arr[j].first, arr[j +1].first) > 0) {
tuple temp = arr[j];
arr[j] = arr[j +1];
arr[j +1] = temp;
}
}
}
return arr;
}
| int main() {
// Test case 1
tuple test1[] = {{"Amana", "28"}, {"Zenat", "30"}, {"Abhishek", "29"}, {"Nikhil", "21"}, {"B", "C"}};
tuple expected1[] = {{"Abhishek", "29"}, {"Amana", "28"}, {"B", "C"}, {"Nikhil", "21"}, {"Zenat", "30"}};
func0(test1, 5);
for(int i = 0; i < 5; i++) {
assert(strcmp(test1[i].first, expected1[i].first) == 0);
assert(strcmp(test1[i].second, expected1[i].second) == 0);
}
// Test case 2
tuple test2[] = {{"aaaa", "28"}, {"aa", "30"}, {"bab", "29"}, {"bb", "21"}, {"csa", "C"}};
tuple expected2[] = {{"aa", "30"}, {"aaaa", "28"}, {"bab", "29"}, {"bb", "21"}, {"csa", "C"}};
func0(test2, 5);
for(int i = 0; i < 5; i++) {
assert(strcmp(test2[i].first, expected2[i].first) == 0);
assert(strcmp(test2[i].second, expected2[i].second) == 0);
}
// Test case 3
tuple test3[] = {{"Sarala", "28"}, {"Ayesha", "30"}, {"Suman", "29"}, {"Sai", "21"}, {"G", "H"}};
tuple expected3[] = {{"Ayesha", "30"}, {"G", "H"}, {"Sai", "21"}, {"Sarala", "28"}, {"Suman", "29"}};
func0(test3, 5);
for(int i = 0; i < 5; i++) {
assert(strcmp(test3[i].first, expected3[i].first) == 0);
assert(strcmp(test3[i].second, expected3[i].second) == 0);
}
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 167d <func0+0x7d>
mov %esi,%r13d
lea 0x10(%rdi),%r15
sub $0x1,%r13d
test %r13d,%r13d
je 167d <func0+0x7d>
nopl 0x0(%rax)
lea -0x1(%r13),%r12d
mov %r14,%rbx
mov %r12,%r13
shl $0x4,%r12
add %r15,%r12
nopl 0x0(%rax)
mov (%rbx),%rbp
mov 0x10(%rbx),%rsi
mov %rbp,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
jle 166f <func0+0x6f>
mov 0x8(%rbx),%rax
movdqu 0x10(%rbx),%xmm0
mov %rbp,0x10(%rbx)
mov %rax,0x18(%rbx)
movups %xmm0,(%rbx)
add $0x10,%rbx
cmp %r12,%rbx
jne 1648 <func0+0x48>
test %r13d,%r13d
jne 1630 <func0+0x30>
add $0x8,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_167D
mov r13d, esi
lea r15, [rdi+10h]
sub r13d, 1
test r13d, r13d
jz short loc_167D
nop dword ptr [rax+00000000h]
loc_1630:
lea r12d, [r13-1]
mov rbx, r14
mov r13, r12
shl r12, 4
add r12, r15
nop dword ptr [rax+00000000h]
loc_1648:
mov rbp, [rbx]
mov rsi, [rbx+10h]
mov rdi, rbp
call _strcmp
test eax, eax
jle short loc_166F
mov rax, [rbx+8]
movdqu xmm0, xmmword ptr [rbx+10h]
mov [rbx+10h], rbp
mov [rbx+18h], rax
movups xmmword ptr [rbx], xmm0
loc_166F:
add rbx, 10h
cmp rbx, r12
jnz short loc_1648
test r13d, r13d
jnz short loc_1630
loc_167D:
add rsp, 8
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | __m128i * func0(__m128i *a1, int a2)
{
long long v2; // r13
__m128i *v3; // rbx
long long v4; // rbp
long long v5; // rax
__m128i v6; // xmm0
if ( a2 > 0 )
{
LODWORD(v2) = a2 - 1;
if ( a2 != 1 )
{
do
{
v3 = a1;
v2 = (unsigned int)(v2 - 1);
do
{
v4 = v3->m128i_i64[0];
if ( (int)strcmp(v3->m128i_i64[0], v3[1].m128i_i64[0]) > 0 )
{
v5 = v3->m128i_i64[1];
v6 = _mm_loadu_si128(v3 + 1);
v3[1].m128i_i64[0] = v4;
v3[1].m128i_i64[1] = v5;
*v3 = v6;
}
++v3;
}
while ( v3 != &a1[v2 + 1] );
}
while ( (_DWORD)v2 );
}
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x0010167d
MOV R13D,ESI
LEA R15,[RDI + 0x10]
SUB R13D,0x1
TEST R13D,R13D
JZ 0x0010167d
NOP dword ptr [RAX]
LAB_00101630:
LEA R12D,[R13 + -0x1]
MOV RBX,R14
MOV R13,R12
SHL R12,0x4
ADD R12,R15
NOP dword ptr [RAX]
LAB_00101648:
MOV RBP,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x10]
MOV RDI,RBP
CALL 0x00101090
TEST EAX,EAX
JLE 0x0010166f
MOV RAX,qword ptr [RBX + 0x8]
MOVDQU XMM0,xmmword ptr [RBX + 0x10]
MOV qword ptr [RBX + 0x10],RBP
MOV qword ptr [RBX + 0x18],RAX
MOVUPS xmmword ptr [RBX],XMM0
LAB_0010166f:
ADD RBX,0x10
CMP RBX,R12
JNZ 0x00101648
TEST R13D,R13D
JNZ 0x00101630
LAB_0010167d:
ADD RSP,0x8
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(int8 *param_1,int param_2)
{
char *__s1;
int8 uVar1;
int8 uVar2;
int iVar3;
int8 *puVar4;
ulong uVar5;
uint uVar6;
if (0 < param_2) {
uVar6 = param_2 - 1;
uVar5 = (ulong)uVar6;
while (uVar6 != 0) {
uVar6 = (int)uVar5 - 1;
uVar5 = (ulong)uVar6;
puVar4 = param_1;
do {
__s1 = (char *)*puVar4;
iVar3 = strcmp(__s1,(char *)puVar4[2]);
if (0 < iVar3) {
uVar1 = puVar4[2];
uVar2 = puVar4[3];
puVar4[2] = __s1;
puVar4[3] = puVar4[1];
*puVar4 = uVar1;
puVar4[1] = uVar2;
}
puVar4 = puVar4 + 2;
} while (puVar4 != param_1 + uVar5 * 2 + 2);
}
}
return param_1;
} |
7,251 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char* first;
char* second;
} tuple;
| tuple* func0(tuple arr[], int n) {
for(int i = 0; i < n; i++) {
for(int j = 0; j < n - i -1; j++) {
if(strcmp(arr[j].first, arr[j +1].first) > 0) {
tuple temp = arr[j];
arr[j] = arr[j +1];
arr[j +1] = temp;
}
}
}
return arr;
}
| int main() {
// Test case 1
tuple test1[] = {{"Amana", "28"}, {"Zenat", "30"}, {"Abhishek", "29"}, {"Nikhil", "21"}, {"B", "C"}};
tuple expected1[] = {{"Abhishek", "29"}, {"Amana", "28"}, {"B", "C"}, {"Nikhil", "21"}, {"Zenat", "30"}};
func0(test1, 5);
for(int i = 0; i < 5; i++) {
assert(strcmp(test1[i].first, expected1[i].first) == 0);
assert(strcmp(test1[i].second, expected1[i].second) == 0);
}
// Test case 2
tuple test2[] = {{"aaaa", "28"}, {"aa", "30"}, {"bab", "29"}, {"bb", "21"}, {"csa", "C"}};
tuple expected2[] = {{"aa", "30"}, {"aaaa", "28"}, {"bab", "29"}, {"bb", "21"}, {"csa", "C"}};
func0(test2, 5);
for(int i = 0; i < 5; i++) {
assert(strcmp(test2[i].first, expected2[i].first) == 0);
assert(strcmp(test2[i].second, expected2[i].second) == 0);
}
// Test case 3
tuple test3[] = {{"Sarala", "28"}, {"Ayesha", "30"}, {"Suman", "29"}, {"Sai", "21"}, {"G", "H"}};
tuple expected3[] = {{"Ayesha", "30"}, {"G", "H"}, {"Sai", "21"}, {"Sarala", "28"}, {"Suman", "29"}};
func0(test3, 5);
for(int i = 0; i < 5; i++) {
assert(strcmp(test3[i].first, expected3[i].first) == 0);
assert(strcmp(test3[i].second, expected3[i].second) == 0);
}
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 1877 <func0+0x87>
mov %esi,%r13d
lea 0x10(%rdi),%r15
sub $0x1,%r13d
test %r13d,%r13d
je 1877 <func0+0x87>
nopl 0x0(%rax)
lea -0x1(%r13),%r12d
mov %r14,%rbx
mov %r12,%r13
shl $0x4,%r12
add %r15,%r12
nopl 0x0(%rax)
mov (%rbx),%rbp
mov 0x10(%rbx),%rsi
mov %rbp,%rdi
callq 1090 <strcmp@plt>
test %eax,%eax
jle 1869 <func0+0x79>
mov 0x8(%rbx),%rax
movdqu 0x10(%rbx),%xmm1
movq %rbp,%xmm0
movq %rax,%xmm2
movups %xmm1,(%rbx)
punpcklqdq %xmm2,%xmm0
movups %xmm0,0x10(%rbx)
add $0x10,%rbx
cmp %r12,%rbx
jne 1838 <func0+0x48>
test %r13d,%r13d
jne 1820 <func0+0x30>
add $0x8,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_1891
mov r13d, esi
lea r15, [rdi+10h]
loc_1830:
cmp r13d, 1
jle short loc_188B
nop word ptr [rax+rax+00000000h]
loc_1840:
lea r12d, [r13-2]
mov rbx, r14
shl r12, 4
add r12, r15
xchg ax, ax
loc_1850:
mov rbp, [rbx]
mov rsi, [rbx+10h]; s2
mov rdi, rbp; s1
call _strcmp
test eax, eax
jle short loc_1878
movdqu xmm1, xmmword ptr [rbx+10h]
movq xmm0, rbp
movhps xmm0, qword ptr [rbx+8]
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm1
loc_1878:
add rbx, 10h
cmp rbx, r12
jnz short loc_1850
sub r13d, 1
cmp r13d, 1
jg short loc_1840
loc_188B:
sub r13d, 1
jnz short loc_1830
loc_1891:
add rsp, 8
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, int a2)
{
int v2; // r13d
long long v3; // rbx
__m128i v4; // xmm1
if ( a2 > 0 )
{
v2 = a2;
do
{
for ( ; v2 > 1; --v2 )
{
v3 = a1;
do
{
if ( strcmp(*(const char **)v3, *(const char **)(v3 + 16)) > 0 )
{
v4 = _mm_loadu_si128((const __m128i *)(v3 + 16));
*(__m128 *)(v3 + 16) = _mm_loadh_ps((const double *)(v3 + 8));
*(__m128i *)v3 = v4;
}
v3 += 16LL;
}
while ( v3 != a1 + 16 + 16LL * (unsigned int)(v2 - 2) );
}
--v2;
}
while ( v2 );
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101891
MOV R13D,ESI
LEA R15,[RDI + 0x10]
LAB_00101830:
CMP R13D,0x1
JLE 0x0010188b
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101840:
LEA R12D,[R13 + -0x2]
MOV RBX,R14
SHL R12,0x4
ADD R12,R15
NOP
LAB_00101850:
MOV RBP,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x10]
MOV RDI,RBP
CALL 0x00101090
TEST EAX,EAX
JLE 0x00101878
MOVDQU XMM1,xmmword ptr [RBX + 0x10]
MOVQ XMM0,RBP
MOVHPS XMM0,qword ptr [RBX + 0x8]
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM1
LAB_00101878:
ADD RBX,0x10
CMP RBX,R12
JNZ 0x00101850
SUB R13D,0x1
CMP R13D,0x1
JG 0x00101840
LAB_0010188b:
SUB R13D,0x1
JNZ 0x00101830
LAB_00101891:
ADD RSP,0x8
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(int8 *param_1,int param_2)
{
char *__s1;
int8 uVar1;
int8 uVar2;
int iVar3;
int8 *puVar4;
if (0 < param_2) {
do {
for (; 1 < param_2; param_2 = param_2 + -1) {
puVar4 = param_1;
do {
__s1 = (char *)*puVar4;
iVar3 = strcmp(__s1,(char *)puVar4[2]);
if (0 < iVar3) {
uVar1 = puVar4[2];
uVar2 = puVar4[3];
puVar4[2] = __s1;
puVar4[3] = puVar4[1];
*puVar4 = uVar1;
puVar4[1] = uVar2;
}
puVar4 = puVar4 + 2;
} while (puVar4 != param_1 + (ulong)(param_2 - 2) * 2 + 2);
}
param_2 = param_2 + -1;
} while (param_2 != 0);
}
return param_1;
} |
7,252 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (b == 0) {
return "Yes";
}
else {
return "No";
}
}
| int main() {
assert(strcmp(func0(2, 0, -1), "Yes") == 0);
assert(strcmp(func0(1, -5, 6), "No") == 0);
assert(strcmp(func0(2, 0, 2), "Yes") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
cmpl $0x0,-0x8(%rbp)
jne 1189 <func0+0x20>
lea 0xe81(%rip),%rax
jmp 1190 <func0+0x27>
lea 0xe7c(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
cmp [rbp+var_8], 0
jnz short loc_1189
lea rax, s2; "Yes"
jmp short loc_1190
loc_1189:
lea rax, aNo; "No"
loc_1190:
pop rbp
retn | const char * func0(long long a1, int a2)
{
if ( a2 )
return "No";
else
return "Yes";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
CMP dword ptr [RBP + -0x8],0x0
JNZ 0x00101189
LEA RAX,[0x102008]
JMP 0x00101190
LAB_00101189:
LEA RAX,[0x10200c]
LAB_00101190:
POP RBP
RET | int * func0(int8 param_1,int param_2)
{
int *puVar1;
if (param_2 == 0) {
puVar1 = &DAT_00102008;
}
else {
puVar1 = &DAT_0010200c;
}
return puVar1;
} |
7,253 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (b == 0) {
return "Yes";
}
else {
return "No";
}
}
| int main() {
assert(strcmp(func0(2, 0, -1), "Yes") == 0);
assert(strcmp(func0(1, -5, 6), "No") == 0);
assert(strcmp(func0(2, 0, 2), "Yes") == 0);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
lea 0xece(%rip),%rax
lea 0xecb(%rip),%rdx
cmovne %rdx,%rax
retq
| func0:
endbr64
test esi, esi
lea rax, unk_2004
lea rdx, unk_2008
cmovnz rax, rdx
retn | void * func0(long long a1, int a2)
{
void *result; // rax
result = &unk_2004;
if ( a2 )
return &unk_2008;
return result;
} | func0:
ENDBR64
TEST ESI,ESI
LEA RAX,[0x102004]
LEA RDX,[0x102008]
CMOVNZ RAX,RDX
RET | int * func0(int8 param_1,int param_2)
{
int *puVar1;
puVar1 = &DAT_00102004;
if (param_2 != 0) {
puVar1 = &DAT_00102008;
}
return puVar1;
} |
7,254 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (b == 0) {
return "Yes";
}
else {
return "No";
}
}
| int main() {
assert(strcmp(func0(2, 0, -1), "Yes") == 0);
assert(strcmp(func0(1, -5, 6), "No") == 0);
assert(strcmp(func0(2, 0, 2), "Yes") == 0);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
lea 0xebb(%rip),%rdx
lea 0xeb0(%rip),%rax
cmovne %rdx,%rax
retq
nopl 0x0(%rax)
| func0:
endbr64
test esi, esi
lea rdx, unk_2008
lea rax, unk_2004
cmovnz rax, rdx
retn | void * func0(long long a1, int a2)
{
void *result; // rax
result = &unk_2004;
if ( a2 )
return &unk_2008;
return result;
} | func0:
ENDBR64
TEST ESI,ESI
LEA RDX,[0x102008]
LEA RAX,[0x102004]
CMOVNZ RAX,RDX
RET | int * func0(int8 param_1,int param_2)
{
int *puVar1;
puVar1 = &DAT_00102004;
if (param_2 != 0) {
puVar1 = &DAT_00102008;
}
return puVar1;
} |
7,255 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (b == 0) {
return "Yes";
}
else {
return "No";
}
}
| int main() {
assert(strcmp(func0(2, 0, -1), "Yes") == 0);
assert(strcmp(func0(1, -5, 6), "No") == 0);
assert(strcmp(func0(2, 0, 2), "Yes") == 0);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
lea 0xebb(%rip),%rdx
lea 0xeb0(%rip),%rax
cmovne %rdx,%rax
retq
nopl 0x0(%rax)
| func0:
endbr64
test esi, esi
lea rdx, unk_2004
lea rax, unk_2008
cmovz rax, rdx
retn | void * func0(long long a1, int a2)
{
void *result; // rax
result = &unk_2008;
if ( !a2 )
return &unk_2004;
return result;
} | func0:
ENDBR64
TEST ESI,ESI
LEA RDX,[0x102004]
LEA RAX,[0x102008]
CMOVZ RAX,RDX
RET | int * func0(int8 param_1,int param_2)
{
int *puVar1;
puVar1 = &DAT_00102008;
if (param_2 == 0) {
puVar1 = &DAT_00102004;
}
return puVar1;
} |
7,256 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int inv_count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) {
inv_count++;
}
}
}
return inv_count;
}
| int main() {
int arr1[] = {1, 20, 6, 4, 5};
assert(func0(arr1, 5) == 5);
int arr2[] = {8, 4, 2, 1};
assert(func0(arr2, 4) == 6);
int arr3[] = {3, 1, 2};
assert(func0(arr3, 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 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
jle 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
jle 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
JLE 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_c * 4) < *(int *)(param_1 + (long)local_10 * 4)) {
local_14 = local_14 + 1;
}
}
}
return local_14;
} |
7,257 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int inv_count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) {
inv_count++;
}
}
}
return inv_count;
}
| int main() {
int arr1[] = {1, 20, 6, 4, 5};
assert(func0(arr1, 5) == 5);
int arr2[] = {8, 4, 2, 1};
assert(func0(arr2, 4) == 6);
int arr3[] = {3, 1, 2};
assert(func0(arr3, 3) == 2);
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,%ecx
jmp 119c <func0+0x33>
add $0x1,%rax
cmp %eax,%esi
jle 1198 <func0+0x2f>
cmp (%rdi,%rax,4),%edx
jle 1186 <func0+0x1d>
add $0x1,%ecx
jmp 1186 <func0+0x1d>
add $0x1,%r8
cmp %r9,%r8
je 11b0 <func0+0x47>
mov -0x4(%rdi,%r8,4),%edx
mov %r8,%rax
jmp 118e <func0+0x25>
mov $0x0,%ecx
mov %ecx,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_11A6
mov r9d, esi
mov r8d, 1
mov ecx, 0
jmp short loc_1197
loc_1181:
add rax, 1
cmp esi, eax
jle short loc_1193
loc_1189:
cmp edx, [rdi+rax*4]
jle short loc_1181
add ecx, 1
jmp short loc_1181
loc_1193:
add r8, 1
loc_1197:
cmp r8, r9
jz short loc_11AB
mov edx, [rdi+r8*4-4]
mov rax, r8
jmp short loc_1189
loc_11A6:
mov ecx, 0
loc_11AB:
mov eax, ecx
retn | long long func0(long long a1, int a2)
{
long long v2; // r8
unsigned int v3; // ecx
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 ECX,0x0
JMP 0x00101197
LAB_00101181:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101193
LAB_00101189:
CMP EDX,dword ptr [RDI + RAX*0x4]
JLE 0x00101181
ADD ECX,0x1
JMP 0x00101181
LAB_00101193:
ADD R8,0x1
LAB_00101197:
CMP R8,R9
JZ 0x001011ab
MOV EDX,dword ptr [RDI + R8*0x4 + -0x4]
MOV RAX,R8
JMP 0x00101189
LAB_001011a6:
MOV ECX,0x0
LAB_001011ab:
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 {
if (*(int *)(param_1 + uVar1 * 4) < *(int *)(param_1 + -4 + uVar3 * 4)) {
iVar2 = iVar2 + 1;
}
uVar1 = uVar1 + 1;
} while ((int)uVar1 < (int)param_2);
}
}
return iVar2;
} |
7,258 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int inv_count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) {
inv_count++;
}
}
}
return inv_count;
}
| int main() {
int arr1[] = {1, 20, 6, 4, 5};
assert(func0(arr1, 5) == 5);
int arr2[] = {8, 4, 2, 1};
assert(func0(arr2, 4) == 6);
int arr3[] = {3, 1, 2};
assert(func0(arr3, 3) == 2);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 137e <func0+0x4e>
lea -0x1(%rsi),%r9d
mov $0x1,%ecx
xor %r8d,%r8d
add $0x1,%r9
cmp %r9,%rcx
je 137a <func0+0x4a>
nopl (%rax)
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
nopw 0x0(%rax,%rax,1)
cmp (%rdi,%rax,4),%edx
jle 1369 <func0+0x39>
add $0x1,%r8d
add $0x1,%rax
cmp %eax,%esi
jg 1360 <func0+0x30>
add $0x1,%rcx
cmp %r9,%rcx
jne 1350 <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_12EE
movsxd r9, esi
mov ecx, 1
xor r8d, r8d
cmp rcx, r9
jz short loc_12EA
nop dword ptr [rax+rax+00000000h]
loc_12C0:
mov edx, [rdi+rcx*4-4]
mov rax, rcx
nop word ptr [rax+rax+00000000h]
loc_12D0:
cmp edx, [rdi+rax*4]
jle short loc_12D9
add r8d, 1
loc_12D9:
add rax, 1
cmp esi, eax
jg short loc_12D0
add rcx, 1
cmp rcx, r9
jnz short loc_12C0
loc_12EA:
mov eax, r8d
retn
loc_12EE:
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 0x001012ee
MOVSXD R9,ESI
MOV ECX,0x1
XOR R8D,R8D
CMP RCX,R9
JZ 0x001012ea
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
NOP word ptr [RAX + RAX*0x1]
LAB_001012d0:
CMP EDX,dword ptr [RDI + RAX*0x4]
JLE 0x001012d9
ADD R8D,0x1
LAB_001012d9:
ADD RAX,0x1
CMP ESI,EAX
JG 0x001012d0
ADD RCX,0x1
CMP RCX,R9
JNZ 0x001012c0
LAB_001012ea:
MOV EAX,R8D
RET
LAB_001012ee:
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 + lVar1 * 4) < *(int *)(param_1 + -4 + lVar2 * 4)) {
iVar3 = iVar3 + 1;
}
lVar1 = lVar1 + 1;
} while ((int)lVar1 < param_2);
lVar2 = lVar2 + 1;
} while (lVar2 != param_2);
}
return iVar3;
} |
7,259 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int inv_count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) {
inv_count++;
}
}
}
return inv_count;
}
| int main() {
int arr1[] = {1, 20, 6, 4, 5};
assert(func0(arr1, 5) == 5);
int arr2[] = {8, 4, 2, 1};
assert(func0(arr2, 4) == 6);
int arr3[] = {3, 1, 2};
assert(func0(arr3, 3) == 2);
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 %r9d,%r9d
mov $0x1,%ecx
push %rbx
lea -0x1(%rsi),%ebp
mov $0x1,%ebx
nopl 0x0(%rax,%rax,1)
mov %esi,%r8d
mov %ebp,%eax
mov -0x4(%r10),%r11d
sub %ecx,%r8d
cmp %ecx,%esi
cmovle %ebx,%r8d
sub %ecx,%eax
cmp $0x3,%eax
jbe 1439 <func0+0x129>
cmp %ecx,%esi
jle 1439 <func0+0x129>
mov %r8d,%edx
movd %r11d,%xmm4
pxor %xmm0,%xmm0
mov %r10,%rax
shr $0x2,%edx
pshufd $0x0,%xmm4,%xmm2
shl $0x4,%rdx
add %r10,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm3
movdqa %xmm2,%xmm1
add $0x10,%rax
pcmpgtd %xmm3,%xmm1
psubd %xmm1,%xmm0
cmp %rax,%rdx
jne 1388 <func0+0x78>
movdqa %xmm0,%xmm1
mov %r8d,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
add %eax,%r9d
lea (%rdx,%rcx,1),%eax
cmp %edx,%r8d
je 1424 <func0+0x114>
movslq %eax,%r8
cmp (%rdi,%r8,4),%r11d
lea 0x0(,%r8,4),%rdx
setg %r8b
movzbl %r8b,%r8d
add %r8d,%r9d
lea 0x1(%rax),%r8d
cmp %r8d,%esi
jle 1424 <func0+0x114>
cmp 0x4(%rdi,%rdx,1),%r11d
jle 13fe <func0+0xee>
add $0x1,%r9d
lea 0x2(%rax),%r8d
cmp %r8d,%esi
jle 1424 <func0+0x114>
cmp 0x8(%rdi,%rdx,1),%r11d
jle 1412 <func0+0x102>
add $0x1,%r9d
add $0x3,%eax
cmp %esi,%eax
jge 1424 <func0+0x114>
cmp 0xc(%rdi,%rdx,1),%r11d
jle 1424 <func0+0x114>
add $0x1,%r9d
add $0x1,%ecx
add $0x4,%r10
cmp %ecx,%esi
jne 1340 <func0+0x30>
mov %r9d,%eax
pop %rbx
pop %rbp
retq
mov %ecx,%eax
jmp 13d0 <func0+0xc0>
xor %r9d,%r9d
mov %r9d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle loc_1248
cmp esi, 1
jz loc_1248
push rbp
mov r11, rdi
lea r8, [rdi+4]
xor r9d, r9d
push rbx
mov ecx, 1
lea ebp, [rsi-1]
mov ebx, 1
xchg ax, ax
loc_1170:
mov edi, esi
mov eax, ebp
mov r10d, [r8-4]
sub edi, ecx
cmp esi, ecx
cmovle edi, ebx
sub eax, ecx
cmp eax, 2
jbe loc_1244
cmp esi, ecx
jle loc_1244
mov edx, edi
movd xmm4, r10d
pxor xmm0, xmm0
mov rax, r8
shr edx, 2
pshufd xmm2, xmm4, 0
shl rdx, 4
add rdx, r8
nop
loc_11B0:
movdqu xmm3, xmmword ptr [rax]
movdqa xmm1, xmm2
add rax, 10h
pcmpgtd xmm1, xmm3
psubd xmm0, xmm1
cmp rax, rdx
jnz short loc_11B0
movdqa xmm1, xmm0
psrldq xmm1, 8
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
add r9d, eax
mov eax, edi
and eax, 0FFFFFFFCh
add eax, ecx
and edi, 3
jz short loc_122F
loc_11F6:
movsxd rdx, eax
lea rdi, ds:0[rdx*4]
cmp r10d, [r11+rdx*4]
jle short loc_120B
add r9d, 1
loc_120B:
lea edx, [rax+1]
cmp esi, edx
jle short loc_122F
cmp r10d, [r11+rdi+4]
jle short loc_121D
add r9d, 1
loc_121D:
add eax, 2
cmp esi, eax
jle short loc_122F
cmp r10d, [r11+rdi+8]
jle short loc_122F
add r9d, 1
loc_122F:
add ecx, 1
add r8, 4
cmp esi, ecx
jnz loc_1170
mov eax, r9d
pop rbx
pop rbp
retn
loc_1244:
mov eax, ecx
jmp short loc_11F6
loc_1248:
xor r9d, r9d
mov eax, r9d
retn | long long func0(long long a1, int a2)
{
const __m128i *v3; // r8
unsigned int v4; // r9d
int v5; // ecx
signed int v6; // r10d
unsigned int v7; // edi
__m128i v8; // xmm0
const __m128i *v9; // rax
__m128i v10; // xmm2
__m128i v11; // xmm3
__m128i v12; // xmm0
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_i32[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_cmpgt_epi32(v10, v11));
}
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 0x00101248
CMP ESI,0x1
JZ 0x00101248
PUSH RBP
MOV R11,RDI
LEA R8,[RDI + 0x4]
XOR R9D,R9D
PUSH RBX
MOV ECX,0x1
LEA EBP,[RSI + -0x1]
MOV EBX,0x1
NOP
LAB_00101170:
MOV EDI,ESI
MOV EAX,EBP
MOV R10D,dword ptr [R8 + -0x4]
SUB EDI,ECX
CMP ESI,ECX
CMOVLE EDI,EBX
SUB EAX,ECX
CMP EAX,0x2
JBE 0x00101244
CMP ESI,ECX
JLE 0x00101244
MOV EDX,EDI
MOVD XMM4,R10D
PXOR XMM0,XMM0
MOV RAX,R8
SHR EDX,0x2
PSHUFD XMM2,XMM4,0x0
SHL RDX,0x4
ADD RDX,R8
NOP
LAB_001011b0:
MOVDQU XMM3,xmmword ptr [RAX]
MOVDQA XMM1,XMM2
ADD RAX,0x10
PCMPGTD XMM1,XMM3
PSUBD XMM0,XMM1
CMP RAX,RDX
JNZ 0x001011b0
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
ADD R9D,EAX
MOV EAX,EDI
AND EAX,0xfffffffc
ADD EAX,ECX
AND EDI,0x3
JZ 0x0010122f
LAB_001011f6:
MOVSXD RDX,EAX
LEA RDI,[RDX*0x4]
CMP R10D,dword ptr [R11 + RDX*0x4]
JLE 0x0010120b
ADD R9D,0x1
LAB_0010120b:
LEA EDX,[RAX + 0x1]
CMP ESI,EDX
JLE 0x0010122f
CMP R10D,dword ptr [R11 + RDI*0x1 + 0x4]
JLE 0x0010121d
ADD R9D,0x1
LAB_0010121d:
ADD EAX,0x2
CMP ESI,EAX
JLE 0x0010122f
CMP R10D,dword ptr [R11 + RDI*0x1 + 0x8]
JLE 0x0010122f
ADD R9D,0x1
LAB_0010122f:
ADD ECX,0x1
ADD R8,0x4
CMP ESI,ECX
JNZ 0x00101170
MOV EAX,R9D
POP RBX
POP RBP
RET
LAB_00101244:
MOV EAX,ECX
JMP 0x001011f6
LAB_00101248:
XOR R9D,R9D
MOV EAX,R9D
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 *piVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
if ((param_2 < 1) || (param_2 == 1)) {
return 0;
}
piVar10 = (int *)(param_1 + 4);
iVar11 = 0;
iVar9 = 1;
do {
iVar2 = piVar10[-1];
uVar3 = param_2 - iVar9;
if (param_2 <= iVar9) {
uVar3 = 1;
}
iVar12 = iVar9;
if (((uint)((param_2 + -1) - iVar9) < 3) || (param_2 <= iVar9)) {
LAB_001011f6:
lVar1 = (long)iVar12 * 4;
if (*(int *)(param_1 + (long)iVar12 * 4) < iVar2) {
iVar11 = iVar11 + 1;
}
if (iVar12 + 1 < param_2) {
if (*(int *)(param_1 + 4 + lVar1) < iVar2) {
iVar11 = iVar11 + 1;
}
if ((iVar12 + 2 < param_2) && (*(int *)(param_1 + 8 + lVar1) < iVar2)) {
iVar11 = iVar11 + 1;
}
}
}
else {
iVar12 = 0;
iVar13 = 0;
iVar14 = 0;
iVar15 = 0;
piVar8 = piVar10;
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 != piVar10 + (ulong)(uVar3 >> 2) * 4);
iVar11 = iVar11 + iVar12 + iVar14 + iVar13 + iVar15;
iVar12 = (uVar3 & 0xfffffffc) + iVar9;
if ((uVar3 & 3) != 0) goto LAB_001011f6;
}
iVar9 = iVar9 + 1;
piVar10 = piVar10 + 1;
if (param_2 == iVar9) {
return iVar11;
}
} while( true );
} |
7,260 | func0 | #include <assert.h>
| int func0(int arr[], int arr_size) {
for (int i = 0; i < arr_size; i++) {
int count = 0;
for (int j = 0; j < arr_size; j++) {
if (arr[i] == arr[j]) {
count++;
}
}
if (count % 2 != 0) {
return arr[i];
}
}
return -1;
}
| int main() {
int arr1[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
int arr2[] = {1, 2, 3, 2, 3, 1, 3};
int arr3[] = {5, 7, 2, 7, 5, 2, 5};
assert(func0(arr1, 13) == 5);
assert(func0(arr2, 7) == 3);
assert(func0(arr3, 7) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11f7 <func0+0x8e>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c9 <func0+0x60>
mov -0xc(%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
jne 11c5 <func0+0x5c>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1191 <func0+0x28>
mov -0x8(%rbp),%eax
and $0x1,%eax
test %eax,%eax
je 11f3 <func0+0x8a>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
jmp 1204 <func0+0x9b>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
mov $0xffffffff,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
jmp short loc_11F7
loc_1181:
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11C9
loc_1191:
mov eax, [rbp+var_C]
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
jnz short loc_11C5
add [rbp+var_8], 1
loc_11C5:
add [rbp+var_4], 1
loc_11C9:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1191
mov eax, [rbp+var_8]
and eax, 1
test eax, eax
jz short loc_11F3
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
jmp short loc_1204
loc_11F3:
add [rbp+var_C], 1
loc_11F7:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_1181
mov eax, 0FFFFFFFFh
loc_1204:
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+10h] [rbp-Ch]
char v4; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
v4 = 0;
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * j + a1) )
++v4;
}
if ( (v4 & 1) != 0 )
return *(unsigned int *)(4LL * i + a1);
}
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011f7
LAB_00101181:
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c9
LAB_00101191:
MOV EAX,dword ptr [RBP + -0xc]
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
JNZ 0x001011c5
ADD dword ptr [RBP + -0x8],0x1
LAB_001011c5:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c9:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101191
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0x1
TEST EAX,EAX
JZ 0x001011f3
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
JMP 0x00101204
LAB_001011f3:
ADD dword ptr [RBP + -0xc],0x1
LAB_001011f7:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
MOV EAX,0xffffffff
LAB_00101204:
POP RBP
RET | int4 func0(long param_1,int param_2)
{
byte bVar1;
int local_14;
int local_c;
local_14 = 0;
while( true ) {
if (param_2 <= local_14) {
return 0xffffffff;
}
bVar1 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_14 * 4) == *(int *)(param_1 + (long)local_c * 4)) {
bVar1 = bVar1 + 1;
}
}
if ((bool)(bVar1 & 1)) break;
local_14 = local_14 + 1;
}
return *(int4 *)(param_1 + (long)local_14 * 4);
} |
7,261 | func0 | #include <assert.h>
| int func0(int arr[], int arr_size) {
for (int i = 0; i < arr_size; i++) {
int count = 0;
for (int j = 0; j < arr_size; j++) {
if (arr[i] == arr[j]) {
count++;
}
}
if (count % 2 != 0) {
return arr[i];
}
}
return -1;
}
| int main() {
int arr1[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
int arr2[] = {1, 2, 3, 2, 3, 1, 3};
int arr3[] = {5, 7, 2, 7, 5, 2, 5};
assert(func0(arr1, 13) == 5);
assert(func0(arr2, 7) == 3);
assert(func0(arr3, 7) == 5);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11c4 <func0+0x5b>
push %rbx
lea -0x1(%rsi),%r11d
mov %rdi,%rbx
lea 0x4(%rdi,%r11,4),%r8
mov $0x0,%r9d
jmp 1197 <func0+0x2e>
test $0x1,%dl
jne 11bb <func0+0x52>
lea 0x1(%r9),%rax
cmp %r11,%r9
je 11ca <func0+0x61>
mov %rax,%r9
mov %r9d,%r10d
mov (%rdi,%r9,4),%esi
mov %rbx,%rax
mov $0x0,%edx
cmp (%rax),%esi
sete %cl
movzbl %cl,%ecx
add %ecx,%edx
add $0x4,%rax
cmp %r8,%rax
jne 11a6 <func0+0x3d>
jmp 1186 <func0+0x1d>
movslq %r10d,%r10
mov (%rdi,%r10,4),%eax
pop %rbx
retq
mov $0xffffffff,%eax
retq
mov $0xffffffff,%eax
jmp 11c2 <func0+0x59>
| func0:
endbr64
test esi, esi
jle short loc_11BE
mov r11d, esi
lea eax, [rsi-1]
lea r8, [rdi+rax*4+4]
mov r9d, 0
jmp short loc_1192
loc_1184:
test dl, 1
jnz short loc_11B6
add r9, 1
cmp r9, r11
jz short loc_11C4
loc_1192:
mov r10d, r9d
mov esi, [rdi+r9*4]
mov rax, rdi
mov edx, 0
loc_11A1:
cmp esi, [rax]
setz cl
movzx ecx, cl
add edx, ecx
add rax, 4
cmp rax, r8
jnz short loc_11A1
jmp short loc_1184
loc_11B6:
movsxd r10, r10d
mov eax, [rdi+r10*4]
retn
loc_11BE:
mov eax, 0FFFFFFFFh
retn
loc_11C4:
mov eax, 0FFFFFFFFh
retn | long long func0(_DWORD *a1, int a2)
{
long long i; // r9
_DWORD *v3; // rax
char v4; // dl
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
for ( i = 0LL; i != a2; ++i )
{
v3 = a1;
v4 = 0;
do
v4 += a1[i] == *v3++;
while ( v3 != &a1[a2 - 1 + 1] );
if ( (v4 & 1) != 0 )
return (unsigned int)a1[(int)i];
}
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011be
MOV R11D,ESI
LEA EAX,[RSI + -0x1]
LEA R8,[RDI + RAX*0x4 + 0x4]
MOV R9D,0x0
JMP 0x00101192
LAB_00101184:
TEST DL,0x1
JNZ 0x001011b6
ADD R9,0x1
CMP R9,R11
JZ 0x001011c4
LAB_00101192:
MOV R10D,R9D
MOV ESI,dword ptr [RDI + R9*0x4]
MOV RAX,RDI
MOV EDX,0x0
LAB_001011a1:
CMP ESI,dword ptr [RAX]
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x4
CMP RAX,R8
JNZ 0x001011a1
JMP 0x00101184
LAB_001011b6:
MOVSXD R10,R10D
MOV EAX,dword ptr [RDI + R10*0x4]
RET
LAB_001011be:
MOV EAX,0xffffffff
RET
LAB_001011c4:
MOV EAX,0xffffffff
RET | int func0(int *param_1,uint param_2)
{
int *piVar1;
bool bVar2;
ulong uVar3;
if ((int)param_2 < 1) {
return -1;
}
uVar3 = 0;
while( true ) {
bVar2 = false;
piVar1 = param_1;
do {
bVar2 = (bool)(bVar2 ^ param_1[uVar3] == *piVar1);
piVar1 = piVar1 + 1;
} while (piVar1 != param_1 + (ulong)(param_2 - 1) + 1);
if (bVar2) break;
uVar3 = uVar3 + 1;
if (uVar3 == param_2) {
return -1;
}
}
return param_1[(int)uVar3];
} |
7,262 | func0 | #include <assert.h>
| int func0(int arr[], int arr_size) {
for (int i = 0; i < arr_size; i++) {
int count = 0;
for (int j = 0; j < arr_size; j++) {
if (arr[i] == arr[j]) {
count++;
}
}
if (count % 2 != 0) {
return arr[i];
}
}
return -1;
}
| int main() {
int arr1[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
int arr2[] = {1, 2, 3, 2, 3, 1, 3};
int arr3[] = {5, 7, 2, 7, 5, 2, 5};
assert(func0(arr1, 13) == 5);
assert(func0(arr2, 7) == 3);
assert(func0(arr3, 7) == 5);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1341 <func0+0x41>
lea -0x1(%rsi),%eax
mov %rdi,%r9
lea 0x4(%rdi,%rax,4),%rsi
nopl 0x0(%rax,%rax,1)
mov (%r9),%r8d
mov %rdi,%rax
xor %edx,%edx
xor %ecx,%ecx
cmp (%rax),%r8d
sete %cl
add $0x4,%rax
add %ecx,%edx
cmp %rsi,%rax
jne 1320 <func0+0x20>
and $0x1,%edx
jne 1347 <func0+0x47>
add $0x4,%r9
cmp %rax,%r9
jne 1318 <func0+0x18>
mov $0xffffffff,%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1341
lea eax, [rsi-1]
mov r9, rdi
lea rsi, [rdi+rax*4+4]
nop dword ptr [rax+rax+00h]
loc_1318:
mov r8d, [r9]
mov rax, rdi
xor edx, edx
loc_1320:
xor ecx, ecx
cmp r8d, [rax]
setz cl
add rax, 4
add edx, ecx
cmp rax, rsi
jnz short loc_1320
and edx, 1
jnz short loc_1347
add r9, 4
cmp r9, rax
jnz short loc_1318
loc_1341:
mov r8d, 0FFFFFFFFh
loc_1347:
mov eax, r8d
retn | long long func0(unsigned int *a1, int a2)
{
unsigned int *v2; // r9
long long v3; // rsi
unsigned int v4; // r8d
unsigned int *v5; // rax
char v6; // dl
char v7; // cl
if ( a2 <= 0 )
{
return (unsigned int)-1;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
while ( 1 )
{
v4 = *v2;
v5 = a1;
v6 = 0;
do
{
v7 = v4 == *v5++;
v6 += v7;
}
while ( v5 != (unsigned int *)v3 );
if ( (v6 & 1) != 0 )
break;
if ( ++v2 == v5 )
return (unsigned int)-1;
}
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101341
LEA EAX,[RSI + -0x1]
MOV R9,RDI
LEA RSI,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101318:
MOV R8D,dword ptr [R9]
MOV RAX,RDI
XOR EDX,EDX
LAB_00101320:
XOR ECX,ECX
CMP R8D,dword ptr [RAX]
SETZ CL
ADD RAX,0x4
ADD EDX,ECX
CMP RAX,RSI
JNZ 0x00101320
AND EDX,0x1
JNZ 0x00101347
ADD R9,0x4
CMP R9,RAX
JNZ 0x00101318
LAB_00101341:
MOV R8D,0xffffffff
LAB_00101347:
MOV EAX,R8D
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
bool bVar3;
int *piVar4;
if (0 < param_2) {
piVar4 = param_1;
do {
bVar3 = false;
piVar2 = param_1;
do {
iVar1 = *piVar2;
piVar2 = piVar2 + 1;
bVar3 = (bool)(bVar3 ^ *piVar4 == iVar1);
} while (piVar2 != param_1 + (ulong)(param_2 - 1) + 1);
if (bVar3) {
return *piVar4;
}
piVar4 = piVar4 + 1;
} while (piVar4 != piVar2);
}
return -1;
} |
7,263 | func0 | #include <assert.h>
| int func0(int arr[], int arr_size) {
for (int i = 0; i < arr_size; i++) {
int count = 0;
for (int j = 0; j < arr_size; j++) {
if (arr[i] == arr[j]) {
count++;
}
}
if (count % 2 != 0) {
return arr[i];
}
}
return -1;
}
| int main() {
int arr1[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
int arr2[] = {1, 2, 3, 2, 3, 1, 3};
int arr3[] = {5, 7, 2, 7, 5, 2, 5};
assert(func0(arr1, 13) == 5);
assert(func0(arr2, 7) == 3);
assert(func0(arr3, 7) == 5);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 13c6 <func0+0x106>
mov %esi,%edx
push %r12
lea -0x1(%rsi),%eax
mov %rdi,%r9
shr $0x2,%edx
push %rbp
lea 0x4(%rdi,%rax,4),%r12
mov %rax,%rbp
push %rbx
shl $0x4,%rdx
mov %esi,%ebx
add %rdi,%rdx
and $0xfffffffc,%ebx
mov (%r9),%r8d
cmp $0x3,%ebp
jbe 13c0 <func0+0x100>
movd %r8d,%xmm3
mov %rdi,%rax
pxor %xmm1,%xmm1
pshufd $0x0,%xmm3,%xmm2
nopl (%rax)
movdqu (%rax),%xmm0
add $0x10,%rax
pcmpeqd %xmm2,%xmm0
psubd %xmm0,%xmm1
cmp %rax,%rdx
jne 1310 <func0+0x50>
movdqa %xmm1,%xmm0
mov %ebx,%ecx
psrldq $0x8,%xmm0
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
cmp %esi,%ebx
je 13a0 <func0+0xe0>
movslq %ecx,%r11
cmp (%rdi,%r11,4),%r8d
lea 0x0(,%r11,4),%r10
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0x1(%rcx),%r11d
cmp %esi,%r11d
jge 13a0 <func0+0xe0>
cmp 0x4(%rdi,%r10,1),%r8d
jne 1376 <func0+0xb6>
add $0x1,%eax
lea 0x2(%rcx),%r11d
cmp %r11d,%esi
jle 13a0 <func0+0xe0>
cmp 0x8(%rdi,%r10,1),%r8d
jne 1389 <func0+0xc9>
add $0x1,%eax
add $0x3,%ecx
cmp %ecx,%esi
jle 13a0 <func0+0xe0>
cmp 0xc(%rdi,%r10,1),%r8d
jne 13a0 <func0+0xe0>
add $0x1,%eax
nopw 0x0(%rax,%rax,1)
test $0x1,%al
jne 13b7 <func0+0xf7>
add $0x4,%r9
cmp %r12,%r9
jne 12f0 <func0+0x30>
mov $0xffffffff,%r8d
pop %rbx
mov %r8d,%eax
pop %rbp
pop %r12
retq
xor %ecx,%ecx
xor %eax,%eax
jmp 1349 <func0+0x89>
mov $0xffffffff,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
test esi, esi
jle loc_13B6
mov edx, esi
push r12
movsxd rax, esi
mov r12d, esi
shr edx, 2
push rbp
mov r8, rdi
mov r9d, esi
shl rdx, 4
push rbx
lea r11d, [rsi-1]
lea rbx, [rdi+rax*4]
add rdx, rdi
and r12d, 0FFFFFFFCh
nop dword ptr [rax+00h]
loc_12F8:
mov esi, [rdi]
cmp r11d, 2
jbe loc_13B0
movd xmm3, esi
mov rax, r8
pxor xmm0, xmm0
pshufd xmm2, xmm3, 0
nop dword ptr [rax+00h]
loc_1318:
movdqu xmm1, xmmword ptr [rax]
add rax, 10h
pcmpeqd xmm1, xmm2
psubd xmm0, xmm1
cmp rdx, rax
jnz short loc_1318
movdqa xmm1, xmm0
mov ecx, r12d
psrldq xmm1, 8
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
cmp r9d, r12d
jz short loc_138C
loc_1353:
movsxd r10, ecx
lea rbp, ds:0[r10*4]
cmp esi, [r8+r10*4]
jnz short loc_1367
add eax, 1
loc_1367:
lea r10d, [rcx+1]
cmp r9d, r10d
jle short loc_138C
cmp esi, [r8+rbp+4]
jnz short loc_137A
add eax, 1
loc_137A:
add ecx, 2
cmp r9d, ecx
jle short loc_138C
cmp esi, [r8+rbp+8]
jnz short loc_138C
add eax, 1
loc_138C:
test al, 1
jnz short loc_13A2
add rdi, 4
cmp rbx, rdi
jnz loc_12F8
mov esi, 0FFFFFFFFh
loc_13A2:
pop rbx
mov eax, esi
pop rbp
pop r12
retn
loc_13B0:
xor ecx, ecx
xor eax, eax
jmp short loc_1353
loc_13B6:
mov eax, 0FFFFFFFFh
retn | long long func0(unsigned int *a1, int a2)
{
const __m128i *v2; // r8
unsigned int v4; // r11d
unsigned int *v5; // rbx
const __m128i *v6; // rdx
unsigned int v7; // r12d
unsigned int v8; // esi
const __m128i *v9; // rax
__m128i v10; // xmm0
__m128i v11; // xmm2
__m128i v12; // xmm1
signed int v13; // ecx
__m128i v14; // xmm0
char v15; // al
long long v16; // rbp
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v2 = (const __m128i *)a1;
v4 = a2 - 1;
v5 = &a1[a2];
v6 = (const __m128i *)&a1[4 * ((unsigned int)a2 >> 2)];
v7 = a2 & 0xFFFFFFFC;
do
{
v8 = *a1;
if ( v4 <= 2 )
{
v13 = 0;
v15 = 0;
}
else
{
v9 = v2;
v10 = 0LL;
v11 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v8), 0);
do
{
v12 = _mm_loadu_si128(v9++);
v10 = _mm_sub_epi32(v10, _mm_cmpeq_epi32(v12, v11));
}
while ( v6 != v9 );
v13 = v7;
v14 = _mm_add_epi32(v10, _mm_srli_si128(v10, 8));
v15 = _mm_cvtsi128_si32(_mm_add_epi32(v14, _mm_srli_si128(v14, 4)));
if ( a2 == v7 )
goto LABEL_15;
}
v16 = v13;
if ( v8 == v2->m128i_i32[v16] )
++v15;
if ( a2 > v13 + 1 )
{
if ( v8 == v2->m128i_i32[v16 + 1] )
++v15;
if ( a2 > v13 + 2 && v8 == v2->m128i_i32[v16 + 2] )
++v15;
}
LABEL_15:
if ( (v15 & 1) != 0 )
return v8;
++a1;
}
while ( v5 != a1 );
return (unsigned int)-1;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013b6
MOV EDX,ESI
PUSH R12
MOVSXD RAX,ESI
MOV R12D,ESI
SHR EDX,0x2
PUSH RBP
MOV R8,RDI
MOV R9D,ESI
SHL RDX,0x4
PUSH RBX
LEA R11D,[RSI + -0x1]
LEA RBX,[RDI + RAX*0x4]
ADD RDX,RDI
AND R12D,0xfffffffc
NOP dword ptr [RAX]
LAB_001012f8:
MOV ESI,dword ptr [RDI]
CMP R11D,0x2
JBE 0x001013b0
MOVD XMM3,ESI
MOV RAX,R8
PXOR XMM0,XMM0
PSHUFD XMM2,XMM3,0x0
NOP dword ptr [RAX]
LAB_00101318:
MOVDQU XMM1,xmmword ptr [RAX]
ADD RAX,0x10
PCMPEQD XMM1,XMM2
PSUBD XMM0,XMM1
CMP RDX,RAX
JNZ 0x00101318
MOVDQA XMM1,XMM0
MOV ECX,R12D
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
CMP R9D,R12D
JZ 0x0010138c
LAB_00101353:
MOVSXD R10,ECX
LEA RBP,[R10*0x4]
CMP ESI,dword ptr [R8 + R10*0x4]
JNZ 0x00101367
ADD EAX,0x1
LAB_00101367:
LEA R10D,[RCX + 0x1]
CMP R9D,R10D
JLE 0x0010138c
CMP ESI,dword ptr [R8 + RBP*0x1 + 0x4]
JNZ 0x0010137a
ADD EAX,0x1
LAB_0010137a:
ADD ECX,0x2
CMP R9D,ECX
JLE 0x0010138c
CMP ESI,dword ptr [R8 + RBP*0x1 + 0x8]
JNZ 0x0010138c
ADD EAX,0x1
LAB_0010138c:
TEST AL,0x1
JNZ 0x001013a2
ADD RDI,0x4
CMP RBX,RDI
JNZ 0x001012f8
MOV ESI,0xffffffff
LAB_001013a2:
POP RBX
MOV EAX,ESI
POP RBP
POP R12
RET
LAB_001013b0:
XOR ECX,ECX
XOR EAX,EAX
JMP 0x00101353
LAB_001013b6:
MOV EAX,0xffffffff
RET | int func0(int *param_1,uint param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
bool bVar6;
int *piVar7;
uint uVar8;
int *piVar9;
byte bVar10;
byte bVar11;
byte bVar12;
byte bVar13;
if ((int)param_2 < 1) {
return -1;
}
piVar9 = param_1;
do {
iVar1 = *piVar9;
if (param_2 - 1 < 3) {
uVar8 = 0;
bVar6 = false;
LAB_00101353:
if (iVar1 == param_1[(int)uVar8]) {
bVar6 = (bool)(bVar6 ^ 1);
}
if ((int)(uVar8 + 1) < (int)param_2) {
if (iVar1 == param_1[(long)(int)uVar8 + 1]) {
bVar6 = (bool)(bVar6 ^ 1);
}
if (((int)(uVar8 + 2) < (int)param_2) && (iVar1 == param_1[(long)(int)uVar8 + 2])) {
bVar6 = (bool)(bVar6 ^ 1);
}
}
}
else {
bVar10 = 0;
bVar11 = 0;
bVar12 = 0;
bVar13 = 0;
piVar7 = param_1;
do {
iVar2 = *piVar7;
piVar3 = piVar7 + 1;
piVar4 = piVar7 + 2;
piVar5 = piVar7 + 3;
piVar7 = piVar7 + 4;
bVar10 = bVar10 ^ iVar2 == iVar1;
bVar11 = bVar11 ^ *piVar3 == iVar1;
bVar12 = bVar12 ^ *piVar4 == iVar1;
bVar13 = bVar13 ^ *piVar5 == iVar1;
} while (param_1 + (ulong)(param_2 >> 2) * 4 != piVar7);
bVar6 = (bool)(bVar10 ^ bVar12 ^ bVar11 ^ bVar13);
uVar8 = param_2 & 0xfffffffc;
if (param_2 != (param_2 & 0xfffffffc)) goto LAB_00101353;
}
if (bVar6) {
return iVar1;
}
piVar9 = piVar9 + 1;
if (param_1 + (int)param_2 == piVar9) {
return -1;
}
} while( true );
} |
7,264 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int cmp(const void *a, const void *b) {
long long num1 = *(const long long*)a;
long long num2 = *(const long long*)b;
return (num1 > num2) - (num1 < num2);
}
| long long func0(int n, int* primes, int primesSize) {
long long* uglies = malloc(n * sizeof(long long));
int* indices = calloc(primesSize, sizeof(int));
long long* values = malloc(primesSize * sizeof(long long));
int i, j;
uglies[0] = 1;
for (i = 0; i < primesSize; i++) {
values[i] = primes[i];
}
for (i = 1; i < n; i++) {
long long next_ugly = values[0];
for (j = 1; j < primesSize; j++) {
if (values[j] < next_ugly)
next_ugly = values[j];
}
uglies[i] = next_ugly;
for (j = 0; j < primesSize; j++) {
if (values[j] == next_ugly)
values[j] = primes[j] * uglies[++indices[j]];
}
}
long long result = uglies[n - 1];
free(uglies);
free(indices);
free(values);
return result;
}
| int main() {
int primes1[] = {2, 7, 13, 19};
int primesSize1 = sizeof(primes1) / sizeof(primes1[0]);
assert(func0(12, primes1, primesSize1) == 32);
assert(func0(10, primes1, primesSize1) == 26);
assert(func0(100, primes1, primesSize1) == 5408);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %edi,-0x34(%rbp)
mov %rsi,-0x40(%rbp)
mov %edx,-0x38(%rbp)
mov -0x34(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x20(%rbp)
mov -0x38(%rbp),%eax
cltq
mov $0x4,%esi
mov %rax,%rdi
callq 10c0 <calloc@plt>
mov %rax,-0x18(%rbp)
mov -0x38(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x10(%rbp)
mov -0x20(%rbp),%rax
movq $0x1,(%rax)
movl $0x0,-0x30(%rbp)
jmp 12af <func0+0x9e>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x10(%rbp),%rdx
add %rcx,%rdx
cltq
mov %rax,(%rdx)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x38(%rbp),%eax
jl 127b <func0+0x6a>
movl $0x1,-0x30(%rbp)
jmpq 13d9 <func0+0x1c8>
mov -0x10(%rbp),%rax
mov (%rax),%rax
mov %rax,-0x28(%rbp)
movl $0x1,-0x2c(%rbp)
jmp 1313 <func0+0x102>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
cmp %rax,-0x28(%rbp)
jle 130f <func0+0xfe>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,-0x28(%rbp)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x38(%rbp),%eax
jl 12d7 <func0+0xc6>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
mov -0x28(%rbp),%rax
mov %rax,(%rdx)
movl $0x0,-0x2c(%rbp)
jmpq 13c9 <func0+0x1b8>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
cmp %rax,-0x28(%rbp)
jne 13c5 <func0+0x1b4>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
movslq %eax,%rcx
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
add $0x1,%edx
mov %edx,(%rax)
mov (%rax),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rsi
mov -0x10(%rbp),%rdx
add %rsi,%rdx
imul %rcx,%rax
mov %rax,(%rdx)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x38(%rbp),%eax
jl 1342 <func0+0x131>
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x34(%rbp),%eax
jl 12c3 <func0+0xb2>
mov -0x34(%rbp),%eax
cltq
shl $0x3,%rax
lea -0x8(%rax),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,-0x8(%rbp)
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1090 <free@plt>
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1090 <free@plt>
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 1090 <free@plt>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov [rbp+var_40], rsi
mov [rbp+var_38], edx
mov eax, [rbp+var_34]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov eax, [rbp+var_38]
cdqe
mov esi, 4; size
mov rdi, rax; nmemb
call _calloc
mov [rbp+var_18], rax
mov eax, [rbp+var_38]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_10], rax
mov rax, [rbp+ptr]
mov qword ptr [rax], 1
mov [rbp+var_30], 0
jmp short loc_12AF
loc_127B:
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_30]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_10]
add rdx, rcx
cdqe
mov [rdx], rax
add [rbp+var_30], 1
loc_12AF:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_38]
jl short loc_127B
mov [rbp+var_30], 1
jmp loc_13D9
loc_12C3:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov [rbp+var_2C], 1
jmp short loc_1313
loc_12D7:
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_10]
add rax, rdx
mov rax, [rax]
cmp [rbp+var_28], rax
jle short loc_130F
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_10]
add rax, rdx
mov rax, [rax]
mov [rbp+var_28], rax
loc_130F:
add [rbp+var_2C], 1
loc_1313:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_38]
jl short loc_12D7
mov eax, [rbp+var_30]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rdx, rax
mov rax, [rbp+var_28]
mov [rdx], rax
mov [rbp+var_2C], 0
jmp loc_13C9
loc_1342:
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_10]
add rax, rdx
mov rax, [rax]
cmp [rbp+var_28], rax
jnz short loc_13C5
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rdx
mov eax, [rax]
movsxd rdx, eax
mov eax, [rbp+var_2C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov ecx, [rax]
add ecx, 1
mov [rax], ecx
mov eax, [rax]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rcx
mov rax, [rax]
mov ecx, [rbp+var_2C]
movsxd rcx, ecx
lea rsi, ds:0[rcx*8]
mov rcx, [rbp+var_10]
add rcx, rsi
imul rax, rdx
mov [rcx], rax
loc_13C5:
add [rbp+var_2C], 1
loc_13C9:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_38]
jl loc_1342
add [rbp+var_30], 1
loc_13D9:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_34]
jl loc_12C3
mov eax, [rbp+var_34]
cdqe
shl rax, 3
lea rdx, [rax-8]
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov [rbp+var_8], rax
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_18]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_10]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_8]
leave
retn | long long func0(int a1, long long a2, int a3)
{
long long v3; // rdx
char *v4; // rax
int i; // [rsp+10h] [rbp-30h]
int j; // [rsp+10h] [rbp-30h]
int k; // [rsp+14h] [rbp-2Ch]
int m; // [rsp+14h] [rbp-2Ch]
long long v11; // [rsp+18h] [rbp-28h]
_QWORD *ptr; // [rsp+20h] [rbp-20h]
char *v13; // [rsp+28h] [rbp-18h]
long long *v14; // [rsp+30h] [rbp-10h]
long long v15; // [rsp+38h] [rbp-8h]
ptr = malloc(8LL * a1);
v13 = (char *)calloc(a3, 4uLL);
v14 = (long long *)malloc(8LL * a3);
*ptr = 1LL;
for ( i = 0; i < a3; ++i )
v14[i] = *(int *)(4LL * i + a2);
for ( j = 1; j < a1; ++j )
{
v11 = *v14;
for ( k = 1; k < a3; ++k )
{
if ( v11 > v14[k] )
v11 = v14[k];
}
ptr[j] = v11;
for ( m = 0; m < a3; ++m )
{
if ( v11 == v14[m] )
{
v3 = *(int *)(4LL * m + a2);
v4 = &v13[4 * m];
v14[m] = v3 * ptr[++*(_DWORD *)v4];
}
}
}
v15 = ptr[a1 - 1];
free(ptr);
free(v13);
free(v14);
return v15;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV qword ptr [RBP + -0x40],RSI
MOV dword ptr [RBP + -0x38],EDX
MOV EAX,dword ptr [RBP + -0x34]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x38]
CDQE
MOV ESI,0x4
MOV RDI,RAX
CALL 0x001010c0
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x38]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],0x1
MOV dword ptr [RBP + -0x30],0x0
JMP 0x001012af
LAB_0010127b:
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,RCX
CDQE
MOV qword ptr [RDX],RAX
ADD dword ptr [RBP + -0x30],0x1
LAB_001012af:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x38]
JL 0x0010127b
MOV dword ptr [RBP + -0x30],0x1
JMP 0x001013d9
LAB_001012c3:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV dword ptr [RBP + -0x2c],0x1
JMP 0x00101313
LAB_001012d7:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
CMP qword ptr [RBP + -0x28],RAX
JLE 0x0010130f
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
LAB_0010130f:
ADD dword ptr [RBP + -0x2c],0x1
LAB_00101313:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x38]
JL 0x001012d7
MOV EAX,dword ptr [RBP + -0x30]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RDX],RAX
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x001013c9
LAB_00101342:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
CMP qword ptr [RBP + -0x28],RAX
JNZ 0x001013c5
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RAX]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x2c]
MOVSXD RCX,ECX
LEA RSI,[RCX*0x8]
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,RSI
IMUL RAX,RDX
MOV qword ptr [RCX],RAX
LAB_001013c5:
ADD dword ptr [RBP + -0x2c],0x1
LAB_001013c9:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x38]
JL 0x00101342
ADD dword ptr [RBP + -0x30],0x1
LAB_001013d9:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x34]
JL 0x001012c3
MOV EAX,dword ptr [RBP + -0x34]
CDQE
SHL RAX,0x3
LEA RDX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101090
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101090
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x00101090
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | int8 func0(int param_1,long param_2,int param_3)
{
int iVar1;
int8 uVar2;
int8 *__ptr;
void *__ptr_00;
long *__ptr_01;
int *piVar3;
int local_38;
int local_34;
long local_30;
__ptr = (int8 *)malloc((long)param_1 << 3);
__ptr_00 = calloc((long)param_3,4);
__ptr_01 = (long *)malloc((long)param_3 << 3);
*__ptr = 1;
for (local_38 = 0; local_38 < param_3; local_38 = local_38 + 1) {
__ptr_01[local_38] = (long)*(int *)(param_2 + (long)local_38 * 4);
}
for (local_38 = 1; local_38 < param_1; local_38 = local_38 + 1) {
local_30 = *__ptr_01;
for (local_34 = 1; local_34 < param_3; local_34 = local_34 + 1) {
if (__ptr_01[local_34] < local_30) {
local_30 = __ptr_01[local_34];
}
}
__ptr[local_38] = local_30;
for (local_34 = 0; local_34 < param_3; local_34 = local_34 + 1) {
if (local_30 == __ptr_01[local_34]) {
iVar1 = *(int *)(param_2 + (long)local_34 * 4);
piVar3 = (int *)((long)__ptr_00 + (long)local_34 * 4);
*piVar3 = *piVar3 + 1;
__ptr_01[local_34] = __ptr[*piVar3] * (long)iVar1;
}
}
}
uVar2 = __ptr[(long)param_1 + -1];
free(__ptr);
free(__ptr_00);
free(__ptr_01);
return uVar2;
} |
7,265 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int cmp(const void *a, const void *b) {
long long num1 = *(const long long*)a;
long long num2 = *(const long long*)b;
return (num1 > num2) - (num1 < num2);
}
| long long func0(int n, int* primes, int primesSize) {
long long* uglies = malloc(n * sizeof(long long));
int* indices = calloc(primesSize, sizeof(int));
long long* values = malloc(primesSize * sizeof(long long));
int i, j;
uglies[0] = 1;
for (i = 0; i < primesSize; i++) {
values[i] = primes[i];
}
for (i = 1; i < n; i++) {
long long next_ugly = values[0];
for (j = 1; j < primesSize; j++) {
if (values[j] < next_ugly)
next_ugly = values[j];
}
uglies[i] = next_ugly;
for (j = 0; j < primesSize; j++) {
if (values[j] == next_ugly)
values[j] = primes[j] * uglies[++indices[j]];
}
}
long long result = uglies[n - 1];
free(uglies);
free(indices);
free(values);
return result;
}
| int main() {
int primes1[] = {2, 7, 13, 19};
int primesSize1 = sizeof(primes1) / sizeof(primes1[0]);
assert(func0(12, primes1, primesSize1) == 32);
assert(func0(10, primes1, primesSize1) == 26);
assert(func0(100, primes1, primesSize1) == 5408);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,%r15d
mov %rsi,%r13
mov %edx,%ebp
movslq %edi,%rax
shl $0x3,%rax
mov %rax,0x8(%rsp)
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r14
movslq %ebp,%rbx
mov $0x4,%esi
mov %rbx,%rdi
callq 10c0 <calloc@plt>
mov %rax,%r12
lea 0x0(,%rbx,8),%rdi
callq 10d0 <malloc@plt>
mov %rax,%rbx
movq $0x1,(%r14)
test %ebp,%ebp
jle 1261 <func0+0x7c>
lea -0x1(%rbp),%ecx
mov $0x0,%eax
movslq 0x0(%r13,%rax,4),%rdx
mov %rdx,(%rbx,%rax,8)
mov %rax,%rdx
add $0x1,%rax
cmp %rcx,%rdx
jne 124c <func0+0x67>
cmp $0x1,%r15d
jle 12e1 <func0+0xfc>
lea 0x8(%r14),%rdi
lea -0x2(%r15),%eax
lea 0x10(%r14,%rax,8),%r8
lea -0x2(%rbp),%eax
lea 0x10(%rbx,%rax,8),%rsi
jmp 128c <func0+0xa7>
mov %rdx,(%rdi)
je 12ae <func0+0xc9>
add $0x8,%rdi
cmp %r8,%rdi
je 12e1 <func0+0xfc>
mov (%rbx),%rdx
cmp $0x1,%ebp
jle 127e <func0+0x99>
lea 0x8(%rbx),%rax
mov (%rax),%rcx
cmp %rcx,%rdx
cmovg %rcx,%rdx
add $0x8,%rax
cmp %rsi,%rax
jne 1298 <func0+0xb3>
mov %rdx,(%rdi)
mov $0x0,%eax
jmp 12bd <func0+0xd8>
add $0x1,%rax
cmp %eax,%ebp
jle 1283 <func0+0x9e>
cmp %rdx,(%rbx,%rax,8)
jne 12b5 <func0+0xd0>
movslq 0x0(%r13,%rax,4),%r9
mov (%r12,%rax,4),%ecx
add $0x1,%ecx
mov %ecx,(%r12,%rax,4)
movslq %ecx,%rcx
imul (%r14,%rcx,8),%r9
mov %r9,(%rbx,%rax,8)
jmp 12b5 <func0+0xd0>
mov 0x8(%rsp),%rax
mov -0x8(%r14,%rax,1),%rbp
mov %r14,%rdi
callq 1090 <free@plt>
mov %r12,%rdi
callq 1090 <free@plt>
mov %rbx,%rdi
callq 1090 <free@plt>
mov %rbp,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r15d, edi
mov r13, rsi
mov ebp, edx
movsxd rax, edi
shl rax, 3
mov [rsp+48h+var_40], rax
mov rdi, rax
call _malloc
mov r14, rax
movsxd rbx, ebp
mov esi, 4
mov rdi, rbx
call _calloc
mov r12, rax
lea rdi, ds:0[rbx*8]
call _malloc
mov rbx, rax
mov qword ptr [r14], 1
test ebp, ebp
jle short loc_125A
mov ecx, ebp
mov eax, 0
loc_1248:
movsxd rdx, dword ptr [r13+rax*4+0]
mov [rbx+rax*8], rdx
add rax, 1
cmp rax, rcx
jnz short loc_1248
loc_125A:
cmp r15d, 1
jle short loc_12DA
lea rdi, [r14+8]
lea eax, [r15-2]
lea r8, [r14+rax*8+10h]
lea eax, [rbp-2]
lea rsi, [rbx+rax*8+10h]
jmp short loc_1285
loc_1277:
mov [rdi], rdx
jz short loc_12A7
loc_127C:
add rdi, 8
cmp rdi, r8
jz short loc_12DA
loc_1285:
mov rdx, [rbx]
cmp ebp, 1
jle short loc_1277
lea rax, [rbx+8]
loc_1291:
mov rcx, [rax]
cmp rdx, rcx
cmovg rdx, rcx
add rax, 8
cmp rax, rsi
jnz short loc_1291
mov [rdi], rdx
loc_12A7:
mov eax, 0
jmp short loc_12B6
loc_12AE:
add rax, 1
cmp ebp, eax
jle short loc_127C
loc_12B6:
cmp [rbx+rax*8], rdx
jnz short loc_12AE
movsxd r9, dword ptr [r13+rax*4+0]
mov ecx, [r12+rax*4]
add ecx, 1
mov [r12+rax*4], ecx
movsxd rcx, ecx
imul r9, [r14+rcx*8]
mov [rbx+rax*8], r9
jmp short loc_12AE
loc_12DA:
mov rax, [rsp+48h+var_40]
mov rbp, [r14+rax-8]
mov rdi, r14
call _free
mov rdi, r12
call _free
mov rdi, rbx
call _free
mov rax, rbp
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(int a1, long long a2, int a3)
{
_QWORD *v5; // r14
long long v6; // r12
long long *v7; // rbx
long long v8; // rax
_QWORD *v9; // rdi
long long v10; // rdx
long long *v11; // rax
long long v12; // rax
long long v13; // r9
int v14; // ecx
long long v15; // rbp
long long v17; // [rsp+8h] [rbp-40h]
v17 = a1;
v5 = (_QWORD *)malloc(v17 * 8);
v6 = calloc(a3, 4LL);
v7 = (long long *)malloc(8LL * a3);
*v5 = 1LL;
if ( a3 > 0 )
{
v8 = 0LL;
do
{
v7[v8] = *(int *)(a2 + 4 * v8);
++v8;
}
while ( v8 != a3 );
}
if ( a1 > 1 )
{
v9 = v5 + 1;
while ( 1 )
{
v10 = *v7;
if ( a3 > 1 )
break;
*v9 = v10;
if ( a3 == 1 )
goto LABEL_14;
LABEL_7:
if ( ++v9 == &v5[(unsigned int)(a1 - 2) + 2] )
goto LABEL_18;
}
v11 = v7 + 1;
do
{
if ( v10 > *v11 )
v10 = *v11;
++v11;
}
while ( v11 != &v7[(unsigned int)(a3 - 2) + 2] );
*v9 = v10;
LABEL_14:
v12 = 0LL;
do
{
if ( v7[v12] == v10 )
{
v13 = *(int *)(a2 + 4 * v12);
v14 = *(_DWORD *)(v6 + 4 * v12) + 1;
*(_DWORD *)(v6 + 4 * v12) = v14;
v7[v12] = v5[v14] * v13;
}
++v12;
}
while ( a3 > (int)v12 );
goto LABEL_7;
}
LABEL_18:
v15 = v5[v17 - 1];
free(v5);
free(v6);
free(v7);
return v15;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R15D,EDI
MOV R13,RSI
MOV EBP,EDX
MOVSXD RAX,EDI
SHL RAX,0x3
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,RAX
CALL 0x001010d0
MOV R14,RAX
MOVSXD RBX,EBP
MOV ESI,0x4
MOV RDI,RBX
CALL 0x001010c0
MOV R12,RAX
LEA RDI,[RBX*0x8]
CALL 0x001010d0
MOV RBX,RAX
MOV qword ptr [R14],0x1
TEST EBP,EBP
JLE 0x0010125a
MOV ECX,EBP
MOV EAX,0x0
LAB_00101248:
MOVSXD RDX,dword ptr [R13 + RAX*0x4]
MOV qword ptr [RBX + RAX*0x8],RDX
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101248
LAB_0010125a:
CMP R15D,0x1
JLE 0x001012da
LEA RDI,[R14 + 0x8]
LEA EAX,[R15 + -0x2]
LEA R8,[R14 + RAX*0x8 + 0x10]
LEA EAX,[RBP + -0x2]
LEA RSI,[RBX + RAX*0x8 + 0x10]
JMP 0x00101285
LAB_00101277:
MOV qword ptr [RDI],RDX
JZ 0x001012a7
LAB_0010127c:
ADD RDI,0x8
CMP RDI,R8
JZ 0x001012da
LAB_00101285:
MOV RDX,qword ptr [RBX]
CMP EBP,0x1
JLE 0x00101277
LEA RAX,[RBX + 0x8]
LAB_00101291:
MOV RCX,qword ptr [RAX]
CMP RDX,RCX
CMOVG RDX,RCX
ADD RAX,0x8
CMP RAX,RSI
JNZ 0x00101291
MOV qword ptr [RDI],RDX
LAB_001012a7:
MOV EAX,0x0
JMP 0x001012b6
LAB_001012ae:
ADD RAX,0x1
CMP EBP,EAX
JLE 0x0010127c
LAB_001012b6:
CMP qword ptr [RBX + RAX*0x8],RDX
JNZ 0x001012ae
MOVSXD R9,dword ptr [R13 + RAX*0x4]
MOV ECX,dword ptr [R12 + RAX*0x4]
ADD ECX,0x1
MOV dword ptr [R12 + RAX*0x4],ECX
MOVSXD RCX,ECX
IMUL R9,qword ptr [R14 + RCX*0x8]
MOV qword ptr [RBX + RAX*0x8],R9
JMP 0x001012ae
LAB_001012da:
MOV RAX,qword ptr [RSP + 0x8]
MOV RBP,qword ptr [R14 + RAX*0x1 + -0x8]
MOV RDI,R14
CALL 0x00101090
MOV RDI,R12
CALL 0x00101090
MOV RDI,RBX
CALL 0x00101090
MOV RAX,RBP
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 func0(int param_1,long param_2,uint param_3)
{
int iVar1;
int8 uVar2;
int8 *__ptr;
void *__ptr_00;
long *__ptr_01;
ulong uVar3;
long *plVar4;
long lVar5;
int iVar6;
long lVar7;
long *plVar8;
__ptr = (int8 *)malloc((long)param_1 * 8);
__ptr_00 = calloc((long)(int)param_3,4);
__ptr_01 = (long *)malloc((long)(int)param_3 * 8);
*__ptr = 1;
if (0 < (int)param_3) {
uVar3 = 0;
do {
__ptr_01[uVar3] = (long)*(int *)(param_2 + uVar3 * 4);
uVar3 = uVar3 + 1;
} while (uVar3 != param_3);
}
if (1 < param_1) {
plVar8 = __ptr + 1;
do {
lVar7 = *__ptr_01;
if ((int)param_3 < 2) {
*plVar8 = lVar7;
if (param_3 == 1) goto LAB_001012a7;
}
else {
plVar4 = __ptr_01 + 1;
do {
if (*plVar4 < lVar7) {
lVar7 = *plVar4;
}
plVar4 = plVar4 + 1;
} while (plVar4 != __ptr_01 + (ulong)(param_3 - 2) + 2);
*plVar8 = lVar7;
LAB_001012a7:
lVar5 = 0;
do {
if (__ptr_01[lVar5] == lVar7) {
iVar1 = *(int *)(param_2 + lVar5 * 4);
iVar6 = *(int *)((long)__ptr_00 + lVar5 * 4) + 1;
*(int *)((long)__ptr_00 + lVar5 * 4) = iVar6;
__ptr_01[lVar5] = (long)iVar1 * __ptr[iVar6];
}
lVar5 = lVar5 + 1;
} while ((int)lVar5 < (int)param_3);
}
plVar8 = plVar8 + 1;
} while (plVar8 != __ptr + (ulong)(param_1 - 2) + 2);
}
uVar2 = __ptr[(long)param_1 + -1];
free(__ptr);
free(__ptr_00);
free(__ptr_01);
return uVar2;
} |
7,266 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int cmp(const void *a, const void *b) {
long long num1 = *(const long long*)a;
long long num2 = *(const long long*)b;
return (num1 > num2) - (num1 < num2);
}
| long long func0(int n, int* primes, int primesSize) {
long long* uglies = malloc(n * sizeof(long long));
int* indices = calloc(primesSize, sizeof(int));
long long* values = malloc(primesSize * sizeof(long long));
int i, j;
uglies[0] = 1;
for (i = 0; i < primesSize; i++) {
values[i] = primes[i];
}
for (i = 1; i < n; i++) {
long long next_ugly = values[0];
for (j = 1; j < primesSize; j++) {
if (values[j] < next_ugly)
next_ugly = values[j];
}
uglies[i] = next_ugly;
for (j = 0; j < primesSize; j++) {
if (values[j] == next_ugly)
values[j] = primes[j] * uglies[++indices[j]];
}
}
long long result = uglies[n - 1];
free(uglies);
free(indices);
free(values);
return result;
}
| int main() {
int primes1[] = {2, 7, 13, 19};
int primesSize1 = sizeof(primes1) / sizeof(primes1[0]);
assert(func0(12, primes1, primesSize1) == 32);
assert(func0(10, primes1, primesSize1) == 26);
assert(func0(100, primes1, primesSize1) == 5408);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
movslq %edi,%r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
movslq %edx,%rbp
push %rbx
mov %rbp,%rbx
sub $0x18,%rsp
mov %r14d,0xc(%rsp)
shl $0x3,%r14
mov %r14,%rdi
callq 10d0 <malloc@plt>
mov $0x4,%esi
mov %rbp,%rdi
mov %rax,%r13
callq 10c0 <calloc@plt>
lea 0x0(,%rbp,8),%rdi
mov %rax,%r15
callq 10d0 <malloc@plt>
movq $0x1,0x0(%r13)
mov 0xc(%rsp),%ecx
lea -0x1(%rbx),%esi
mov %rax,%rbp
xor %eax,%eax
test %ebx,%ebx
jle 1375 <func0+0x85>
nopw 0x0(%rax,%rax,1)
movslq (%r12,%rax,4),%rdx
mov %rdx,0x0(%rbp,%rax,8)
mov %rax,%rdx
add $0x1,%rax
cmp %rdx,%rsi
jne 1360 <func0+0x70>
cmp $0x1,%ecx
jle 1408 <func0+0x118>
lea -0x2(%rcx),%eax
lea 0x8(%r13),%rdx
lea 0x10(%r13,%rax,8),%r8
lea -0x2(%rbx),%eax
lea 0x10(%rbp,%rax,8),%rax
nopw 0x0(%rax,%rax,1)
mov 0x0(%rbp),%r9
cmp $0x1,%ebx
jle 1440 <func0+0x150>
lea 0x8(%rbp),%rcx
mov %r9,%rsi
nopl 0x0(%rax)
mov (%rcx),%rdi
cmp %rdi,%rsi
cmovg %rdi,%rsi
add $0x8,%rcx
cmp %rcx,%rax
jne 13b0 <func0+0xc0>
mov %rsi,(%rdx)
xor %ecx,%ecx
jmp 13d5 <func0+0xe5>
nopw 0x0(%rax,%rax,1)
mov 0x0(%rbp,%rcx,8),%r9
cmp %r9,%rsi
jne 13f7 <func0+0x107>
mov (%r15,%rcx,4),%edi
movslq (%r12,%rcx,4),%r9
add $0x1,%edi
mov %edi,(%r15,%rcx,4)
movslq %edi,%rdi
imul 0x0(%r13,%rdi,8),%r9
mov %r9,0x0(%rbp,%rcx,8)
add $0x1,%rcx
cmp %ecx,%ebx
jg 13d0 <func0+0xe0>
add $0x8,%rdx
cmp %r8,%rdx
jne 1398 <func0+0xa8>
mov %r13,%rdi
mov -0x8(%r13,%r14,1),%r12
callq 1090 <free@plt>
mov %r15,%rdi
callq 1090 <free@plt>
mov %rbp,%rdi
callq 1090 <free@plt>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov %r9,(%rdx)
jne 13ff <func0+0x10f>
mov %r9,%rsi
jmpq 13c6 <func0+0xd6>
nopl (%rax)
| func0:
endbr64
push r15
push r14
movsxd r14, edi
push r13
lea r10, ds:0[r14*8]
push r12
mov rdi, r10
mov r12, rsi
push rbp
push rbx
mov ebx, edx
sub rsp, 18h
mov [rsp+48h+var_3C], r14d
movsxd r14, ebx
mov [rsp+48h+var_48], r10
call _malloc
mov esi, 4
mov rdi, r14
mov r13, rax
call _calloc
lea rdi, ds:0[r14*8]
mov r15, rax
call _malloc
mov r10, [rsp+48h+var_48]
mov r8d, [rsp+48h+var_3C]
mov qword ptr [r13+0], 1
mov rbp, rax
xor eax, eax
test ebx, ebx
jle short loc_1372
loc_1360:
movsxd rdx, dword ptr [r12+rax*4]
mov [rbp+rax*8+0], rdx
add rax, 1
cmp rax, r14
jnz short loc_1360
loc_1372:
cmp r8d, 1
jle loc_1408
lea eax, [r8-2]
lea rdi, [r13+8]
lea r8, [r13+rax*8+10h]
lea eax, [rbx-2]
lea rsi, [rbp+rax*8+10h]
nop dword ptr [rax+00000000h]
loc_1398:
mov r9, [rbp+0]
cmp ebx, 1
jle loc_1440
lea rax, [rbp+8]
mov rdx, r9
nop dword ptr [rax+00h]
loc_13B0:
mov rcx, [rax]
cmp rdx, rcx
cmovg rdx, rcx
add rax, 8
cmp rsi, rax
jnz short loc_13B0
mov [rdi], rdx
loc_13C6:
xor eax, eax
jmp short loc_13D5
loc_13D0:
mov r9, [rbp+rax*8+0]
loc_13D5:
cmp rdx, r9
jnz short loc_13F7
mov ecx, [r15+rax*4]
movsxd r9, dword ptr [r12+rax*4]
add ecx, 1
mov [r15+rax*4], ecx
movsxd rcx, ecx
imul r9, [r13+rcx*8+0]
mov [rbp+rax*8+0], r9
loc_13F7:
add rax, 1
cmp ebx, eax
jg short loc_13D0
loc_13FF:
add rdi, 8
cmp r8, rdi
jnz short loc_1398
loc_1408:
mov rdi, r13
mov r12, [r13+r10-8]
call _free
mov rdi, r15
call _free
mov rdi, rbp
call _free
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1440:
mov [rdi], r9
jnz short loc_13FF
mov rdx, r9
jmp loc_13C6 | long long func0(int a1, long long a2, int a3)
{
long long v4; // r14
_QWORD *v5; // r13
long long v6; // r15
long long v7; // rax
long long v8; // r10
long long *v10; // rbp
long long v11; // rax
_QWORD *v12; // rdi
long long v13; // r8
long long v14; // r9
long long *v15; // rax
long long v16; // rdx
long long i; // rax
long long v18; // r9
int v19; // ecx
long long v20; // r12
v4 = a3;
v5 = (_QWORD *)malloc(8LL * a1);
v6 = calloc(v4, 4LL);
v7 = malloc(8 * v4);
v8 = a1;
*v5 = 1LL;
v10 = (long long *)v7;
v11 = 0LL;
if ( a3 > 0 )
{
do
{
v10[v11] = *(int *)(a2 + 4 * v11);
++v11;
}
while ( v11 != v4 );
}
if ( a1 > 1 )
{
v12 = v5 + 1;
v13 = (long long)&v5[(unsigned int)(a1 - 2) + 2];
while ( 1 )
{
v14 = *v10;
if ( a3 > 1 )
break;
*v12 = v14;
if ( a3 == 1 )
{
v16 = v14;
LABEL_11:
for ( i = 0LL; ; v14 = v10[i] )
{
if ( v16 == v14 )
{
v18 = *(int *)(a2 + 4 * i);
v19 = *(_DWORD *)(v6 + 4 * i) + 1;
*(_DWORD *)(v6 + 4 * i) = v19;
v10[i] = v5[v19] * v18;
}
if ( a3 <= (int)++i )
break;
}
}
if ( (_QWORD *)v13 == ++v12 )
goto LABEL_17;
}
v15 = v10 + 1;
v16 = *v10;
do
{
if ( v16 > *v15 )
v16 = *v15;
++v15;
}
while ( &v10[(unsigned int)(a3 - 2) + 2] != v15 );
*v12 = v16;
goto LABEL_11;
}
LABEL_17:
v20 = v5[v8 - 1];
free(v5);
free(v6);
free(v10);
return v20;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOVSXD R14,EDI
PUSH R13
LEA R10,[R14*0x8]
PUSH R12
MOV RDI,R10
MOV R12,RSI
PUSH RBP
PUSH RBX
MOV EBX,EDX
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],R14D
MOVSXD R14,EBX
MOV qword ptr [RSP],R10
CALL 0x001010d0
MOV ESI,0x4
MOV RDI,R14
MOV R13,RAX
CALL 0x001010c0
LEA RDI,[R14*0x8]
MOV R15,RAX
CALL 0x001010d0
MOV R10,qword ptr [RSP]
MOV R8D,dword ptr [RSP + 0xc]
MOV qword ptr [R13],0x1
MOV RBP,RAX
XOR EAX,EAX
TEST EBX,EBX
JLE 0x00101372
LAB_00101360:
MOVSXD RDX,dword ptr [R12 + RAX*0x4]
MOV qword ptr [RBP + RAX*0x8],RDX
ADD RAX,0x1
CMP RAX,R14
JNZ 0x00101360
LAB_00101372:
CMP R8D,0x1
JLE 0x00101408
LEA EAX,[R8 + -0x2]
LEA RDI,[R13 + 0x8]
LEA R8,[R13 + RAX*0x8 + 0x10]
LEA EAX,[RBX + -0x2]
LEA RSI,[RBP + RAX*0x8 + 0x10]
NOP dword ptr [RAX]
LAB_00101398:
MOV R9,qword ptr [RBP]
CMP EBX,0x1
JLE 0x00101440
LEA RAX,[RBP + 0x8]
MOV RDX,R9
NOP dword ptr [RAX]
LAB_001013b0:
MOV RCX,qword ptr [RAX]
CMP RDX,RCX
CMOVG RDX,RCX
ADD RAX,0x8
CMP RSI,RAX
JNZ 0x001013b0
MOV qword ptr [RDI],RDX
LAB_001013c6:
XOR EAX,EAX
JMP 0x001013d5
LAB_001013d0:
MOV R9,qword ptr [RBP + RAX*0x8]
LAB_001013d5:
CMP RDX,R9
JNZ 0x001013f7
MOV ECX,dword ptr [R15 + RAX*0x4]
MOVSXD R9,dword ptr [R12 + RAX*0x4]
ADD ECX,0x1
MOV dword ptr [R15 + RAX*0x4],ECX
MOVSXD RCX,ECX
IMUL R9,qword ptr [R13 + RCX*0x8]
MOV qword ptr [RBP + RAX*0x8],R9
LAB_001013f7:
ADD RAX,0x1
CMP EBX,EAX
JG 0x001013d0
LAB_001013ff:
ADD RDI,0x8
CMP R8,RDI
JNZ 0x00101398
LAB_00101408:
MOV RDI,R13
MOV R12,qword ptr [R13 + R10*0x1 + -0x8]
CALL 0x00101090
MOV RDI,R15
CALL 0x00101090
MOV RDI,RBP
CALL 0x00101090
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101440:
MOV qword ptr [RDI],R9
JNZ 0x001013ff
MOV RDX,R9
JMP 0x001013c6 | int8 func0(int param_1,long param_2,int param_3)
{
int iVar1;
int8 uVar2;
int8 *__ptr;
void *__ptr_00;
long *__ptr_01;
size_t sVar3;
long *plVar4;
long lVar5;
int iVar6;
long lVar7;
long *plVar8;
long lVar9;
size_t __nmemb;
__nmemb = (size_t)param_3;
__ptr = (int8 *)malloc((long)param_1 * 8);
__ptr_00 = calloc(__nmemb,4);
__ptr_01 = (long *)malloc(__nmemb * 8);
*__ptr = 1;
sVar3 = 0;
if (0 < param_3) {
do {
__ptr_01[sVar3] = (long)*(int *)(param_2 + sVar3 * 4);
sVar3 = sVar3 + 1;
} while (sVar3 != __nmemb);
}
if (1 < param_1) {
plVar8 = __ptr + 1;
do {
lVar9 = *__ptr_01;
lVar7 = lVar9;
if (param_3 < 2) {
*plVar8 = lVar9;
if (param_3 == 1) goto LAB_001013c6;
}
else {
plVar4 = __ptr_01 + 1;
do {
if (*plVar4 < lVar7) {
lVar7 = *plVar4;
}
plVar4 = plVar4 + 1;
} while (__ptr_01 + (ulong)(param_3 - 2) + 2 != plVar4);
*plVar8 = lVar7;
LAB_001013c6:
lVar5 = 0;
while( true ) {
if (lVar7 == lVar9) {
iVar1 = *(int *)(param_2 + lVar5 * 4);
iVar6 = *(int *)((long)__ptr_00 + lVar5 * 4) + 1;
*(int *)((long)__ptr_00 + lVar5 * 4) = iVar6;
__ptr_01[lVar5] = (long)iVar1 * __ptr[iVar6];
}
lVar5 = lVar5 + 1;
if (param_3 <= (int)lVar5) break;
lVar9 = __ptr_01[lVar5];
}
}
plVar8 = plVar8 + 1;
} while (__ptr + (ulong)(param_1 - 2) + 2 != plVar8);
}
uVar2 = __ptr[(long)param_1 + -1];
free(__ptr);
free(__ptr_00);
free(__ptr_01);
return uVar2;
} |
7,267 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int cmp(const void *a, const void *b) {
long long num1 = *(const long long*)a;
long long num2 = *(const long long*)b;
return (num1 > num2) - (num1 < num2);
}
| long long func0(int n, int* primes, int primesSize) {
long long* uglies = malloc(n * sizeof(long long));
int* indices = calloc(primesSize, sizeof(int));
long long* values = malloc(primesSize * sizeof(long long));
int i, j;
uglies[0] = 1;
for (i = 0; i < primesSize; i++) {
values[i] = primes[i];
}
for (i = 1; i < n; i++) {
long long next_ugly = values[0];
for (j = 1; j < primesSize; j++) {
if (values[j] < next_ugly)
next_ugly = values[j];
}
uglies[i] = next_ugly;
for (j = 0; j < primesSize; j++) {
if (values[j] == next_ugly)
values[j] = primes[j] * uglies[++indices[j]];
}
}
long long result = uglies[n - 1];
free(uglies);
free(indices);
free(values);
return result;
}
| int main() {
int primes1[] = {2, 7, 13, 19};
int primesSize1 = sizeof(primes1) / sizeof(primes1[0]);
assert(func0(12, primes1, primesSize1) == 32);
assert(func0(10, primes1, primesSize1) == 26);
assert(func0(100, primes1, primesSize1) == 5408);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
movslq %edi,%r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
movslq %edx,%rbp
push %rbx
mov %rbp,%rbx
sub $0x18,%rsp
mov %r14d,0xc(%rsp)
shl $0x3,%r14
mov %r14,%rdi
callq 10d0 <malloc@plt>
mov %rbp,%rdi
mov $0x4,%esi
mov %rax,%r13
callq 10c0 <calloc@plt>
lea 0x0(,%rbp,8),%rdi
mov %rax,%r15
callq 10d0 <malloc@plt>
test %ebx,%ebx
mov 0xc(%rsp),%ecx
movq $0x1,0x0(%r13)
mov %rax,%rbp
jle 13d0 <func0+0xf0>
lea -0x1(%rbx),%eax
cmp $0x2,%eax
jbe 149c <func0+0x1bc>
mov %ebx,%edx
xor %eax,%eax
pxor %xmm3,%xmm3
shr $0x2,%edx
shl $0x4,%rdx
nopl 0x0(%rax)
movdqu (%r12,%rax,1),%xmm0
movdqa %xmm3,%xmm1
pcmpgtd %xmm0,%xmm1
movdqa %xmm0,%xmm2
punpckldq %xmm1,%xmm2
punpckhdq %xmm1,%xmm0
movups %xmm2,0x0(%rbp,%rax,2)
movups %xmm0,0x10(%rbp,%rax,2)
add $0x10,%rax
cmp %rdx,%rax
jne 1368 <func0+0x88>
mov %ebx,%eax
and $0xfffffffc,%eax
test $0x3,%bl
je 13d0 <func0+0xf0>
movslq %eax,%rdx
movslq (%r12,%rdx,4),%rsi
mov %rsi,0x0(%rbp,%rdx,8)
lea 0x1(%rax),%edx
cmp %edx,%ebx
jle 13d0 <func0+0xf0>
movslq %edx,%rdx
add $0x2,%eax
movslq (%r12,%rdx,4),%rsi
mov %rsi,0x0(%rbp,%rdx,8)
cmp %eax,%ebx
jle 13d0 <func0+0xf0>
cltq
movslq (%r12,%rax,4),%rdx
mov %rdx,0x0(%rbp,%rax,8)
cmp $0x1,%ecx
jle 1455 <func0+0x175>
lea -0x2(%rcx),%eax
lea 0x8(%r13),%rdx
lea 0x10(%r13,%rax,8),%r8
lea -0x2(%rbx),%eax
lea 0x10(%rbp,%rax,8),%rax
nopl (%rax)
mov 0x0(%rbp),%rsi
cmp $0x1,%ebx
jle 1488 <func0+0x1a8>
lea 0x8(%rbp),%rcx
nopl 0x0(%rax)
mov (%rcx),%rdi
cmp %rdi,%rsi
cmovg %rdi,%rsi
add $0x8,%rcx
cmp %rcx,%rax
jne 1408 <func0+0x128>
mov %rsi,(%rdx)
xor %ecx,%ecx
cmp %rsi,0x0(%rbp,%rcx,8)
jne 1444 <func0+0x164>
mov (%r15,%rcx,4),%edi
movslq (%r12,%rcx,4),%r9
add $0x1,%edi
mov %edi,(%r15,%rcx,4)
movslq %edi,%rdi
imul 0x0(%r13,%rdi,8),%r9
mov %r9,0x0(%rbp,%rcx,8)
add $0x1,%rcx
cmp %ecx,%ebx
jg 1420 <func0+0x140>
add $0x8,%rdx
cmp %r8,%rdx
jne 13f0 <func0+0x110>
mov %r13,%rdi
mov -0x8(%r13,%r14,1),%r12
callq 1090 <free@plt>
mov %r15,%rdi
callq 1090 <free@plt>
mov %rbp,%rdi
callq 1090 <free@plt>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %rsi,(%rdx)
je 141e <func0+0x13e>
add $0x8,%rdx
cmp %r8,%rdx
jne 13f0 <func0+0x110>
jmp 1455 <func0+0x175>
xor %eax,%eax
jmpq 139f <func0+0xbf>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r15
movsxd r8, edi
push r14
push r13
mov r13, rsi
push r12
push rbp
movsxd rbp, edx
push rbx
mov r15, rbp
sub rsp, 18h
mov [rsp+48h+var_3C], r8d
shl r8, 3
mov rdi, r8; size
mov [rsp+48h+var_48], r8
call _malloc
mov esi, 4; size
mov rdi, rbp; nmemb
mov r14, rax
call _calloc
lea rdi, ds:0[rbp*8]; size
mov r12, rax
call _malloc
test ebp, ebp
mov r8, [rsp+48h+var_48]
mov ecx, [rsp+48h+var_3C]
mov qword ptr [r14], 1
mov rbx, rax
jle loc_13E9
lea eax, [rbp-1]
cmp eax, 2
jbe loc_14CF
mov edx, ebp
xor eax, eax
pxor xmm3, xmm3
shr edx, 2
shl rdx, 4
nop dword ptr [rax+rax+00000000h]
loc_1370:
movdqu xmm0, xmmword ptr [r13+rax+0]
movdqa xmm1, xmm3
pcmpgtd xmm1, xmm0
movdqa xmm2, xmm0
punpckldq xmm2, xmm1
punpckhdq xmm0, xmm1
movups xmmword ptr [rbx+rax*2], xmm2
movups xmmword ptr [rbx+rax*2+10h], xmm0
add rax, 10h
cmp rax, rdx
jnz short loc_1370
mov eax, r15d
and eax, 0FFFFFFFCh
test r15b, 3
jz short loc_13E9
loc_13A9:
movsxd rdx, eax
movsxd r9, dword ptr [r13+rdx*4+0]
lea rdi, ds:0[rdx*4]
lea rsi, ds:0[rdx*8]
mov [rbx+rdx*8], r9
lea edx, [rax+1]
cmp r15d, edx
jle short loc_13E9
movsxd rdx, dword ptr [r13+rdi+4]
add eax, 2
mov [rbx+rsi+8], rdx
cmp r15d, eax
jle short loc_13E9
movsxd rax, dword ptr [r13+rdi+8]
mov [rbx+rsi+10h], rax
loc_13E9:
cmp ecx, 1
jle loc_14A0
lea eax, [rcx-2]
lea rdi, [r14+8]
shl rbp, 2
lea r9, [r14+rax*8+10h]
lea eax, [r15-2]
lea rsi, [rbx+rax*8+10h]
nop dword ptr [rax+rax+00h]
loc_1410:
mov rdx, [rbx]
cmp r15d, 1
jle loc_14D6
lea rax, [rbx+8]
mov rcx, rsi
sub rcx, rax
and ecx, 8
jz short loc_1440
mov rax, [rbx+8]
cmp rdx, rax
cmovg rdx, rax
lea rax, [rbx+10h]
cmp rax, rsi
jz short loc_145E
loc_1440:
mov rcx, [rax]
cmp rdx, rcx
cmovg rdx, rcx
mov rcx, [rax+8]
cmp rdx, rcx
cmovg rdx, rcx
add rax, 10h
cmp rax, rsi
jnz short loc_1440
loc_145E:
mov [rdi], rdx
loc_1461:
xor eax, eax
nop dword ptr [rax+rax+00h]
loc_1468:
cmp [rbx+rax*2], rdx
jnz short loc_148A
mov ecx, [r12+rax]
movsxd r10, dword ptr [r13+rax+0]
add ecx, 1
mov [r12+rax], ecx
movsxd rcx, ecx
imul r10, [r14+rcx*8]
mov [rbx+rax*2], r10
loc_148A:
add rax, 4
cmp rax, rbp
jnz short loc_1468
add rdi, 8
cmp rdi, r9
jnz loc_1410
loc_14A0:
mov rdi, r14; ptr
mov rbp, [r14+r8-8]
call _free
mov rdi, r12; ptr
call _free
mov rdi, rbx; ptr
call _free
add rsp, 18h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_14CF:
xor eax, eax
jmp loc_13A9
loc_14D6:
mov [rdi], rdx
jz short loc_1461
mov rax, r9
sub rax, rdi
test al, 8
jnz short loc_14FC
add rdi, 8
mov [rdi], rdx
jmp short loc_14FC
loc_14F0:
mov [rdi+8], rdx
add rdi, 10h
mov [rax+8], rdx
loc_14FC:
lea rax, [rdi+8]
cmp rax, r9
jnz short loc_14F0
jmp short loc_14A0 | long long func0(int a1, long long a2, int a3)
{
size_t v4; // rbp
_QWORD *v6; // r14
char *v7; // r12
long long *v8; // rax
long long v9; // r8
long long *v11; // rbx
long long v12; // rax
__m128i v13; // xmm0
__m128i v14; // xmm1
signed int v15; // eax
long long v16; // rdi
long long v17; // rsi
_QWORD *v18; // rdi
long long v19; // rbp
long long v20; // r9
long long v21; // rsi
long long v22; // rdx
long long *v23; // rax
unsigned long long v24; // rax
long long v25; // r10
int v26; // ecx
long long v27; // rbp
_QWORD *v29; // rax
v4 = a3;
v6 = malloc(8LL * a1);
v7 = (char *)calloc(v4, 4uLL);
v8 = (long long *)malloc(8 * v4);
v9 = a1;
*v6 = 1LL;
v11 = v8;
if ( (int)v4 > 0 )
{
if ( (unsigned int)(v4 - 1) <= 2 )
{
v15 = 0;
goto LABEL_6;
}
v12 = 0LL;
do
{
v13 = _mm_loadu_si128((const __m128i *)(a2 + v12 * 4));
v14 = _mm_cmpgt_epi32((__m128i)0LL, v13);
*(__m128i *)&v11[v12] = _mm_unpacklo_epi32(v13, v14);
*(__m128i *)&v11[v12 + 2] = _mm_unpackhi_epi32(v13, v14);
v12 += 4LL;
}
while ( v12 != 4LL * ((unsigned int)v4 >> 2) );
v15 = a3 & 0xFFFFFFFC;
if ( (a3 & 3) != 0 )
{
LABEL_6:
v16 = 4LL * v15;
v17 = v15;
v11[v17] = *(int *)(a2 + v16);
if ( a3 > v15 + 1 )
{
v11[v17 + 1] = *(int *)(a2 + v16 + 4);
if ( a3 > v15 + 2 )
v11[v17 + 2] = *(int *)(a2 + v16 + 8);
}
}
}
if ( a1 <= 1 )
goto LABEL_27;
v18 = v6 + 1;
v19 = 4 * v4;
v20 = (long long)&v6[(unsigned int)(a1 - 2) + 2];
v21 = (long long)&v11[(unsigned int)(a3 - 2) + 2];
while ( 1 )
{
v22 = *v11;
if ( a3 > 1 )
{
v23 = v11 + 1;
if ( ((8 * ((_BYTE)a3 - 2) + 8) & 8) == 0 )
goto LABEL_37;
if ( v22 > v11[1] )
v22 = v11[1];
v23 = v11 + 2;
if ( v11 + 2 != (long long *)v21 )
{
LABEL_37:
do
{
if ( v22 > *v23 )
v22 = *v23;
if ( v22 > v23[1] )
v22 = v23[1];
v23 += 2;
}
while ( v23 != (long long *)v21 );
}
*v18 = v22;
goto LABEL_22;
}
*v18 = v22;
if ( a3 != 1 )
break;
LABEL_22:
v24 = 0LL;
do
{
if ( v11[v24 / 4] == v22 )
{
v25 = *(int *)(a2 + v24);
v26 = *(_DWORD *)&v7[v24] + 1;
*(_DWORD *)&v7[v24] = v26;
v11[v24 / 4] = v6[v26] * v25;
}
v24 += 4LL;
}
while ( v24 != v19 );
if ( ++v18 == (_QWORD *)v20 )
goto LABEL_27;
}
if ( (((_BYTE)v20 - (_BYTE)v18) & 8) == 0 )
*++v18 = v22;
while ( 1 )
{
v29 = v18 + 1;
if ( v18 + 1 == (_QWORD *)v20 )
break;
v18[1] = v22;
v18 += 2;
v29[1] = v22;
}
LABEL_27:
v27 = v6[v9 - 1];
free(v6);
free(v7);
free(v11);
return v27;
} | func0:
ENDBR64
PUSH R15
MOVSXD R8,EDI
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
MOVSXD RBP,EDX
PUSH RBX
MOV R15,RBP
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],R8D
SHL R8,0x3
MOV RDI,R8
MOV qword ptr [RSP],R8
CALL 0x001010d0
MOV ESI,0x4
MOV RDI,RBP
MOV R14,RAX
CALL 0x001010c0
LEA RDI,[RBP*0x8]
MOV R12,RAX
CALL 0x001010d0
TEST EBP,EBP
MOV R8,qword ptr [RSP]
MOV ECX,dword ptr [RSP + 0xc]
MOV qword ptr [R14],0x1
MOV RBX,RAX
JLE 0x001013e9
LEA EAX,[RBP + -0x1]
CMP EAX,0x2
JBE 0x001014cf
MOV EDX,EBP
XOR EAX,EAX
PXOR XMM3,XMM3
SHR EDX,0x2
SHL RDX,0x4
NOP dword ptr [RAX + RAX*0x1]
LAB_00101370:
MOVDQU XMM0,xmmword ptr [R13 + RAX*0x1]
MOVDQA XMM1,XMM3
PCMPGTD XMM1,XMM0
MOVDQA XMM2,XMM0
PUNPCKLDQ XMM2,XMM1
PUNPCKHDQ XMM0,XMM1
MOVUPS xmmword ptr [RBX + RAX*0x2],XMM2
MOVUPS xmmword ptr [RBX + RAX*0x2 + 0x10],XMM0
ADD RAX,0x10
CMP RAX,RDX
JNZ 0x00101370
MOV EAX,R15D
AND EAX,0xfffffffc
TEST R15B,0x3
JZ 0x001013e9
LAB_001013a9:
MOVSXD RDX,EAX
MOVSXD R9,dword ptr [R13 + RDX*0x4]
LEA RDI,[RDX*0x4]
LEA RSI,[RDX*0x8]
MOV qword ptr [RBX + RDX*0x8],R9
LEA EDX,[RAX + 0x1]
CMP R15D,EDX
JLE 0x001013e9
MOVSXD RDX,dword ptr [R13 + RDI*0x1 + 0x4]
ADD EAX,0x2
MOV qword ptr [RBX + RSI*0x1 + 0x8],RDX
CMP R15D,EAX
JLE 0x001013e9
MOVSXD RAX,dword ptr [R13 + RDI*0x1 + 0x8]
MOV qword ptr [RBX + RSI*0x1 + 0x10],RAX
LAB_001013e9:
CMP ECX,0x1
JLE 0x001014a0
LEA EAX,[RCX + -0x2]
LEA RDI,[R14 + 0x8]
SHL RBP,0x2
LEA R9,[R14 + RAX*0x8 + 0x10]
LEA EAX,[R15 + -0x2]
LEA RSI,[RBX + RAX*0x8 + 0x10]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101410:
MOV RDX,qword ptr [RBX]
CMP R15D,0x1
JLE 0x001014d6
LEA RAX,[RBX + 0x8]
MOV RCX,RSI
SUB RCX,RAX
AND ECX,0x8
JZ 0x00101440
MOV RAX,qword ptr [RBX + 0x8]
CMP RDX,RAX
CMOVG RDX,RAX
LEA RAX,[RBX + 0x10]
CMP RAX,RSI
JZ 0x0010145e
LAB_00101440:
MOV RCX,qword ptr [RAX]
CMP RDX,RCX
CMOVG RDX,RCX
MOV RCX,qword ptr [RAX + 0x8]
CMP RDX,RCX
CMOVG RDX,RCX
ADD RAX,0x10
CMP RAX,RSI
JNZ 0x00101440
LAB_0010145e:
MOV qword ptr [RDI],RDX
LAB_00101461:
XOR EAX,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101468:
CMP qword ptr [RBX + RAX*0x2],RDX
JNZ 0x0010148a
MOV ECX,dword ptr [R12 + RAX*0x1]
MOVSXD R10,dword ptr [R13 + RAX*0x1]
ADD ECX,0x1
MOV dword ptr [R12 + RAX*0x1],ECX
MOVSXD RCX,ECX
IMUL R10,qword ptr [R14 + RCX*0x8]
MOV qword ptr [RBX + RAX*0x2],R10
LAB_0010148a:
ADD RAX,0x4
CMP RAX,RBP
JNZ 0x00101468
ADD RDI,0x8
CMP RDI,R9
JNZ 0x00101410
LAB_001014a0:
MOV RDI,R14
MOV RBP,qword ptr [R14 + R8*0x1 + -0x8]
CALL 0x00101090
MOV RDI,R12
CALL 0x00101090
MOV RDI,RBX
CALL 0x00101090
ADD RSP,0x18
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001014cf:
XOR EAX,EAX
JMP 0x001013a9
LAB_001014d6:
MOV qword ptr [RDI],RDX
JZ 0x00101461
MOV RAX,R9
SUB RAX,RDI
TEST AL,0x8
JNZ 0x001014fc
ADD RDI,0x8
MOV qword ptr [RDI],RDX
JMP 0x001014fc
LAB_001014f0:
MOV qword ptr [RDI + 0x8],RDX
ADD RDI,0x10
MOV qword ptr [RAX + 0x8],RDX
LAB_001014fc:
LEA RAX,[RDI + 0x8]
CMP RAX,R9
JNZ 0x001014f0
JMP 0x001014a0 | int8 func0(int param_1,long param_2,uint param_3)
{
long *plVar1;
int *piVar2;
int iVar3;
int8 uVar4;
int iVar5;
int iVar6;
uint uVar7;
int8 *__ptr;
void *__ptr_00;
long *__ptr_01;
long lVar8;
long *plVar9;
long lVar10;
int iVar11;
size_t __nmemb;
long *plVar12;
__nmemb = (size_t)(int)param_3;
__ptr = (int8 *)malloc((long)param_1 * 8);
__ptr_00 = calloc(__nmemb,4);
__ptr_01 = (long *)malloc(__nmemb * 8);
*__ptr = 1;
if (0 < (int)param_3) {
if (param_3 - 1 < 3) {
uVar7 = 0;
}
else {
lVar8 = 0;
do {
piVar2 = (int *)(param_2 + lVar8);
iVar3 = *piVar2;
iVar11 = piVar2[1];
iVar5 = piVar2[2];
iVar6 = piVar2[3];
piVar2 = (int *)((long)__ptr_01 + lVar8 * 2);
*piVar2 = iVar3;
piVar2[1] = -(uint)(iVar3 < 0);
piVar2[2] = iVar11;
piVar2[3] = -(uint)(iVar11 < 0);
piVar2 = (int *)((long)__ptr_01 + lVar8 * 2 + 0x10);
*piVar2 = iVar5;
piVar2[1] = -(uint)(iVar5 < 0);
piVar2[2] = iVar6;
piVar2[3] = -(uint)(iVar6 < 0);
lVar8 = lVar8 + 0x10;
} while (lVar8 != (ulong)(param_3 >> 2) << 4);
uVar7 = param_3 & 0xfffffffc;
if ((__nmemb & 3) == 0) goto LAB_001013e9;
}
lVar8 = (long)(int)uVar7;
__ptr_01[lVar8] = (long)*(int *)(param_2 + lVar8 * 4);
if (((int)(uVar7 + 1) < (int)param_3) &&
(__ptr_01[lVar8 + 1] = (long)*(int *)(param_2 + 4 + lVar8 * 4),
(int)(uVar7 + 2) < (int)param_3)) {
__ptr_01[lVar8 + 2] = (long)*(int *)(param_2 + 8 + lVar8 * 4);
}
}
LAB_001013e9:
if (1 < param_1) {
plVar12 = __ptr + 1;
plVar1 = __ptr + (ulong)(param_1 - 2) + 2;
do {
lVar8 = *__ptr_01;
if ((int)param_3 < 2) {
*plVar12 = lVar8;
if (param_3 != 1) {
if (((long)plVar1 - (long)plVar12 & 8U) == 0) {
plVar12 = plVar12 + 1;
*plVar12 = lVar8;
}
for (; plVar12 + 1 != plVar1; plVar12 = plVar12 + 2) {
plVar12[1] = lVar8;
plVar12[2] = lVar8;
}
break;
}
}
else {
plVar9 = __ptr_01 + 1;
if (((int)(__ptr_01 + (ulong)(param_3 - 2) + 2) - (int)plVar9 & 8U) == 0) goto LAB_00101440;
plVar9 = __ptr_01;
if (__ptr_01[1] < lVar8) {
lVar8 = __ptr_01[1];
}
while (plVar9 = plVar9 + 2, plVar9 != __ptr_01 + (ulong)(param_3 - 2) + 2) {
LAB_00101440:
if (*plVar9 < lVar8) {
lVar8 = *plVar9;
}
if (plVar9[1] < lVar8) {
lVar8 = plVar9[1];
}
}
*plVar12 = lVar8;
}
lVar10 = 0;
do {
if (*(long *)((long)__ptr_01 + lVar10 * 2) == lVar8) {
iVar3 = *(int *)(param_2 + lVar10);
iVar11 = *(int *)((long)__ptr_00 + lVar10) + 1;
*(int *)((long)__ptr_00 + lVar10) = iVar11;
*(long *)((long)__ptr_01 + lVar10 * 2) = (long)iVar3 * __ptr[iVar11];
}
lVar10 = lVar10 + 4;
} while (lVar10 != __nmemb * 4);
plVar12 = plVar12 + 1;
} while (plVar12 != plVar1);
}
uVar4 = __ptr[(long)param_1 + -1];
free(__ptr);
free(__ptr_00);
free(__ptr_01);
return uVar4;
} |
7,268 | func0 |
#include <assert.h>
| int func0(int n, int k) {
int arr[n];
int i = 0;
int odd = 1;
while (odd <= n) {
arr[i] = odd;
i += 1;
odd += 2;
}
int even = 2;
while (even <= n) {
arr[i] = even;
i += 1;
even += 2;
}
return arr[k - 1];
}
| int main() {
assert(func0(8,5) == 2);
assert(func0(7,2) == 3);
assert(func0(5,2) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %esi,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x44(%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 1207 <func0+0x9e>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11f0 <func0+0x87>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1231 <func0+0xc8>
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,-0x2c(%rbp)
movl $0x1,-0x30(%rbp)
jmp 126c <func0+0x103>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov -0x30(%rbp),%ecx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x2c(%rbp)
addl $0x2,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x44(%rbp),%eax
jle 1254 <func0+0xeb>
movl $0x2,-0x34(%rbp)
jmp 1295 <func0+0x12c>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov -0x34(%rbp),%ecx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x2c(%rbp)
addl $0x2,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x44(%rbp),%eax
jle 127d <func0+0x114>
mov -0x48(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %rsi,%rsp
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
je 12c4 <func0+0x15b>
callq 1060 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov [rbp+var_38], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_34]
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_11D5:
cmp rsp, rdx
jz short loc_11EC
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11D5
loc_11EC:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1216
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1216:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_24], 0
mov [rbp+var_20], 1
jmp short loc_1251
loc_1239:
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov ecx, [rbp+var_20]
mov [rax+rdx*4], ecx
add [rbp+var_24], 1
add [rbp+var_20], 2
loc_1251:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_34]
jle short loc_1239
mov [rbp+var_1C], 2
jmp short loc_127A
loc_1262:
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov ecx, [rbp+var_1C]
mov [rax+rdx*4], ecx
add [rbp+var_24], 1
add [rbp+var_1C], 2
loc_127A:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_34]
jle short loc_1262
mov eax, [rbp+var_38]
lea edx, [rax-1]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12A9
call ___stack_chk_fail
locret_12A9:
leave
retn | long long func0(int a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
_BYTE v5[8]; // [rsp+8h] [rbp-40h] BYREF
int v6; // [rsp+10h] [rbp-38h]
int v7; // [rsp+14h] [rbp-34h]
int v8; // [rsp+24h] [rbp-24h]
int i; // [rsp+28h] [rbp-20h]
int j; // [rsp+2Ch] [rbp-1Ch]
long long v11; // [rsp+30h] [rbp-18h]
_BYTE *v12; // [rsp+38h] [rbp-10h]
unsigned long long v13; // [rsp+40h] [rbp-8h]
v7 = a1;
v6 = a2;
v13 = __readfsqword(0x28u);
v11 = a1 - 1LL;
v2 = 16 * ((4LL * a1 + 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];
v12 = v5;
v8 = 0;
for ( i = 1; i <= v7; i += 2 )
*(_DWORD *)&v12[4 * v8++] = i;
for ( j = 2; j <= v7; j += 2 )
*(_DWORD *)&v12[4 * v8++] = j;
return *(unsigned int *)&v12[4 * v6 - 4];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV dword ptr [RBP + -0x38],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 + -0x34]
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_001011d5:
CMP RSP,RDX
JZ 0x001011ec
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011d5
LAB_001011ec:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101216
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101216:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x1
JMP 0x00101251
LAB_00101239:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x24],0x1
ADD dword ptr [RBP + -0x20],0x2
LAB_00101251:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x00101239
MOV dword ptr [RBP + -0x1c],0x2
JMP 0x0010127a
LAB_00101262:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RBP + -0x1c]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x24],0x1
ADD dword ptr [RBP + -0x1c],0x2
LAB_0010127a:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x00101262
MOV EAX,dword ptr [RBP + -0x38]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012a9
CALL 0x00101060
LAB_001012a9:
LEAVE
RET | int4 func0(int param_1,int param_2)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [8];
int local_40;
int local_3c;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_3c = param_1;
local_40 = param_2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)param_1 + -1;
uVar2 = (((long)param_1 * 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);
}
local_2c = 0;
for (local_28 = 1; local_28 <= local_3c; local_28 = local_28 + 2) {
*(int *)(puVar3 + (long)local_2c * 4 + lVar1) = local_28;
local_2c = local_2c + 1;
}
for (local_24 = 2; local_24 <= local_3c; local_24 = local_24 + 2) {
*(int *)(puVar3 + (long)local_2c * 4 + lVar1) = local_24;
local_2c = local_2c + 1;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)(puVar3 + (long)(local_40 + -1) * 4 + lVar1);
} |
7,269 | func0 |
#include <assert.h>
| int func0(int n, int k) {
int arr[n];
int i = 0;
int odd = 1;
while (odd <= n) {
arr[i] = odd;
i += 1;
odd += 2;
}
int even = 2;
while (even <= n) {
arr[i] = even;
i += 1;
even += 2;
}
return arr[k - 1];
}
| int main() {
assert(func0(8,5) == 2);
assert(func0(7,2) == 3);
assert(func0(5,2) == 3);
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 %edi,%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 11bc <func0+0x53>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11a5 <func0+0x3c>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11d2 <func0+0x69>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%rcx
test %edi,%edi
jle 122c <func0+0xc3>
mov %rcx,%rdx
mov $0x1,%eax
mov %eax,(%rdx)
add $0x2,%eax
add $0x4,%rdx
cmp %eax,%edi
jge 11e1 <func0+0x78>
lea -0x1(%rdi),%eax
shr %eax
add $0x1,%eax
cmp $0x1,%edi
jle 1213 <func0+0xaa>
cltq
lea (%rcx,%rax,4),%rdx
mov $0x2,%eax
mov %eax,(%rdx)
add $0x2,%eax
add $0x4,%rdx
cmp %eax,%edi
jge 1206 <func0+0x9d>
lea -0x1(%rsi),%eax
cltq
mov (%rcx,%rax,4),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
jne 1233 <func0+0xca>
leaveq
retq
mov $0x0,%eax
jmp 11f6 <func0+0x8d>
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov ecx, edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, edi
lea rax, ds:0Fh[rax*4]
mov rdi, rax
and rdi, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11A4:
cmp rsp, rdx
jz short loc_11BB
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11A4
loc_11BB:
mov rax, rdi
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11D1
or [rsp+rax+10h+var_18], 0
loc_11D1:
mov rdi, rsp
test ecx, ecx
jle short loc_122B
mov rdx, rdi
mov eax, 1
loc_11E0:
mov [rdx], eax
add eax, 2
add rdx, 4
cmp ecx, eax
jge short loc_11E0
lea eax, [rcx-1]
shr eax, 1
add eax, 1
loc_11F5:
cmp ecx, 1
jle short loc_1212
cdqe
lea rdx, [rdi+rax*4]
mov eax, 2
loc_1205:
mov [rdx], eax
add eax, 2
add rdx, 4
cmp ecx, eax
jge short loc_1205
loc_1212:
lea eax, [rsi-1]
cdqe
mov eax, [rdi+rax*4]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_1232
leave
retn
loc_122B:
mov eax, 0
jmp short loc_11F5
loc_1232:
call ___stack_chk_fail | long long func0(int a1, int a2)
{
long long v3; // rax
__int16 v4; // di
signed long long v5; // rax
void *v6; // rsp
int *v7; // rdx
int v8; // eax
unsigned int v9; // eax
int *v10; // rdx
int v11; // eax
_DWORD v14[2]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v15; // [rsp+10h] [rbp-8h]
v15 = __readfsqword(0x28u);
v3 = 4LL * a1 + 15;
v4 = (4 * a1 + 15) & 0xFFF0;
while ( v14 != (_DWORD *)((char *)v14 - (v3 & 0xFFFFFFFFFFFFF000LL)) )
;
v5 = v4 & 0xFFF;
v6 = alloca(v5);
if ( (v4 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v14[-2] + v5) = *(_QWORD *)((char *)&v14[-2] + v5);
if ( a1 <= 0 )
{
v9 = 0;
}
else
{
v7 = v14;
v8 = 1;
do
{
*v7 = v8;
v8 += 2;
++v7;
}
while ( a1 >= v8 );
v9 = ((unsigned int)(a1 - 1) >> 1) + 1;
}
if ( a1 > 1 )
{
v10 = &v14[v9];
v11 = 2;
do
{
*v10 = v11;
v11 += 2;
++v10;
}
while ( a1 >= v11 );
}
return (unsigned int)v14[a2 - 1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV ECX,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,EDI
LEA RAX,[0xf + RAX*0x4]
MOV RDI,RAX
AND RDI,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011a4:
CMP RSP,RDX
JZ 0x001011bb
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011a4
LAB_001011bb:
MOV RAX,RDI
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011d1
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011d1:
MOV RDI,RSP
TEST ECX,ECX
JLE 0x0010122b
MOV RDX,RDI
MOV EAX,0x1
LAB_001011e0:
MOV dword ptr [RDX],EAX
ADD EAX,0x2
ADD RDX,0x4
CMP ECX,EAX
JGE 0x001011e0
LEA EAX,[RCX + -0x1]
SHR EAX,0x1
ADD EAX,0x1
LAB_001011f5:
CMP ECX,0x1
JLE 0x00101212
CDQE
LEA RDX,[RDI + RAX*0x4]
MOV EAX,0x2
LAB_00101205:
MOV dword ptr [RDX],EAX
ADD EAX,0x2
ADD RDX,0x4
CMP ECX,EAX
JGE 0x00101205
LAB_00101212:
LEA EAX,[RSI + -0x1]
CDQE
MOV EAX,dword ptr [RDI + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101232
LEAVE
RET
LAB_0010122b:
MOV EAX,0x0
JMP 0x001011f5
LAB_00101232:
CALL 0x00101060 | int4 func0(int param_1,int param_2)
{
long lVar1;
int iVar2;
ulong uVar3;
int *piVar4;
int1 *puVar5;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (long)param_1 * 4 + 0xf;
for (puVar5 = auStack_18; puVar5 != auStack_18 + -(uVar3 & 0xfffffffffffff000);
puVar5 = puVar5 + -0x1000) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
uVar3 = (ulong)((uint)uVar3 & 0xff0);
lVar1 = -uVar3;
piVar4 = (int *)(puVar5 + lVar1);
if (uVar3 != 0) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar2 = 1;
do {
*piVar4 = iVar2;
iVar2 = iVar2 + 2;
piVar4 = piVar4 + 1;
} while (iVar2 <= param_1);
iVar2 = (param_1 - 1U >> 1) + 1;
}
if (1 < param_1) {
piVar4 = (int *)(puVar5 + (long)iVar2 * 4 + lVar1);
iVar2 = 2;
do {
*piVar4 = iVar2;
iVar2 = iVar2 + 2;
piVar4 = piVar4 + 1;
} while (iVar2 <= param_1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar5 + (long)(param_2 + -1) * 4 + lVar1);
}
/* WARNING: Subroutine does not return */
*(code **)(puVar5 + lVar1 + -8) = main;
__stack_chk_fail();
} |
7,270 | func0 |
#include <assert.h>
| int func0(int n, int k) {
int arr[n];
int i = 0;
int odd = 1;
while (odd <= n) {
arr[i] = odd;
i += 1;
odd += 2;
}
int even = 2;
while (even <= n) {
arr[i] = even;
i += 1;
even += 2;
}
return arr[k - 1];
}
| int main() {
assert(func0(8,5) == 2);
assert(func0(7,2) == 3);
assert(func0(5,2) == 3);
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 %edi,%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 11b6 <func0+0x56>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 11a1 <func0+0x41>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1230 <func0+0xd0>
mov %rsp,%rcx
test %edi,%edi
jle 120d <func0+0xad>
mov %rcx,%rdx
mov $0x1,%eax
nopl 0x0(%rax,%rax,1)
mov %eax,(%rdx)
add $0x2,%eax
add $0x4,%rdx
cmp %eax,%edi
jge 11d8 <func0+0x78>
lea -0x1(%rdi),%eax
shr %eax
add $0x1,%eax
cmp $0x1,%edi
jle 120d <func0+0xad>
cltq
lea (%rcx,%rax,4),%rdx
mov $0x2,%eax
nopl (%rax)
mov %eax,(%rdx)
add $0x2,%eax
add $0x4,%rdx
cmp %eax,%edi
jge 1200 <func0+0xa0>
lea -0x1(%rsi),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
cltq
mov (%rcx,%rax,4),%eax
jne 1238 <func0+0xd8>
leaveq
retq
nopw %cs:0x0(%rax,%rax,1)
orq $0x0,-0x8(%rsp,%rdx,1)
jmp 11c4 <func0+0x64>
callq 1050 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
push rbp
mov ecx, edi
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, edi
mov rdi, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rdi, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rdi
jz short loc_1275
loc_1260:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rdi
jnz short loc_1260
loc_1275:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz short loc_12F0
loc_1283:
mov rdi, rsp
test ecx, ecx
jle short loc_12CD
mov rdx, rdi
mov eax, 1
nop word ptr [rax+rax+00h]
loc_1298:
mov [rdx], eax
add eax, 2
add rdx, 4
cmp ecx, eax
jge short loc_1298
lea eax, [rcx-1]
shr eax, 1
add eax, 1
cmp ecx, 1
jle short loc_12CD
cdqe
lea rdx, [rdi+rax*4]
mov eax, 2
nop dword ptr [rax]
loc_12C0:
mov [rdx], eax
add eax, 2
add rdx, 4
cmp ecx, eax
jge short loc_12C0
loc_12CD:
lea eax, [rsi-1]
cdqe
mov eax, [rdi+rax*4]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_12F8
leave
retn
loc_12F0:
or [rsp+rdx+1010h+var_1018], 0
jmp short loc_1283
loc_12F8:
call ___stack_chk_fail | long long func0(int a1, int a2)
{
long long v3; // rdx
_DWORD *v4; // rdi
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
int *v8; // rdx
int v9; // eax
int *v10; // rdx
int v11; // eax
_DWORD v14[1022]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v15[2]; // [rsp+1008h] [rbp-10h] BYREF
v15[1] = __readfsqword(0x28u);
v3 = 4LL * a1 + 15;
v4 = (_DWORD *)((char *)v15 - (v3 & 0xFFFFFFFFFFFFF000LL));
v5 = v3 & 0xFFF0;
if ( v15 != (_QWORD *)v4 )
{
while ( v14 != v4 )
;
}
v6 = v5 & 0xFFF;
v7 = alloca(v6);
if ( v6 )
*(_QWORD *)((char *)&v14[-2] + v6) = *(_QWORD *)((char *)&v14[-2] + v6);
if ( a1 > 0 )
{
v8 = v14;
v9 = 1;
do
{
*v8 = v9;
v9 += 2;
++v8;
}
while ( a1 >= v9 );
if ( a1 > 1 )
{
v10 = &v14[((unsigned int)(a1 - 1) >> 1) + 1];
v11 = 2;
do
{
*v10 = v11;
v11 += 2;
++v10;
}
while ( a1 >= v11 );
}
}
return (unsigned int)v14[a2 - 1];
} | func0:
ENDBR64
PUSH RBP
MOV ECX,EDI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,EDI
MOV RDI,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RDI,RAX
AND RDX,-0x10
CMP RSP,RDI
JZ 0x00101275
LAB_00101260:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RDI
JNZ 0x00101260
LAB_00101275:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001012f0
LAB_00101283:
MOV RDI,RSP
TEST ECX,ECX
JLE 0x001012cd
MOV RDX,RDI
MOV EAX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101298:
MOV dword ptr [RDX],EAX
ADD EAX,0x2
ADD RDX,0x4
CMP ECX,EAX
JGE 0x00101298
LEA EAX,[RCX + -0x1]
SHR EAX,0x1
ADD EAX,0x1
CMP ECX,0x1
JLE 0x001012cd
CDQE
LEA RDX,[RDI + RAX*0x4]
MOV EAX,0x2
NOP dword ptr [RAX]
LAB_001012c0:
MOV dword ptr [RDX],EAX
ADD EAX,0x2
ADD RDX,0x4
CMP ECX,EAX
JGE 0x001012c0
LAB_001012cd:
LEA EAX,[RSI + -0x1]
CDQE
MOV EAX,dword ptr [RDI + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012f8
LEAVE
RET
LAB_001012f0:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101283
LAB_001012f8:
CALL 0x00101060 | int4 func0(int param_1,int param_2)
{
long lVar1;
int1 *puVar2;
int iVar3;
ulong uVar4;
int *piVar5;
int1 *puVar6;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar7;
puVar6 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)param_1 * 4 + 0xf;
puVar7 = auStack_18;
puVar2 = auStack_18;
while (puVar7 != auStack_18 + -(uVar4 & 0xfffffffffffff000)) {
puVar6 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar7 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar1 = -uVar4;
piVar5 = (int *)(puVar6 + lVar1);
if (uVar4 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (0 < param_1) {
iVar3 = 1;
do {
*piVar5 = iVar3;
iVar3 = iVar3 + 2;
piVar5 = piVar5 + 1;
} while (iVar3 <= param_1);
if (1 < param_1) {
piVar5 = (int *)(puVar6 + (long)(int)((param_1 - 1U >> 1) + 1) * 4 + lVar1);
iVar3 = 2;
do {
*piVar5 = iVar3;
iVar3 = iVar3 + 2;
piVar5 = piVar5 + 1;
} while (iVar3 <= param_1);
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar6 + lVar1 + -8) = 0x1012fd;
__stack_chk_fail();
}
return *(int4 *)(puVar6 + (long)(param_2 + -1) * 4 + lVar1);
} |
7,271 | func0 |
#include <assert.h>
| int func0(int n, int k) {
int arr[n];
int i = 0;
int odd = 1;
while (odd <= n) {
arr[i] = odd;
i += 1;
odd += 2;
}
int even = 2;
while (even <= n) {
arr[i] = even;
i += 1;
even += 2;
}
return arr[k - 1];
}
| int main() {
assert(func0(8,5) == 2);
assert(func0(7,2) == 3);
assert(func0(5,2) == 3);
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 %edi,%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 11b6 <func0+0x56>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 11a1 <func0+0x41>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1310 <func0+0x1b0>
mov %rsp,%r8
test %edi,%edi
jle 12f4 <func0+0x194>
lea -0x1(%rdi),%eax
mov %eax,%ecx
shr %ecx
add $0x1,%ecx
cmp $0x5,%eax
jbe 1322 <func0+0x1c2>
mov %ecx,%edx
movdqa 0xe20(%rip),%xmm0
movdqa 0xe38(%rip),%xmm1
mov %r8,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %r8,%rdx
nopl (%rax)
movdqa %xmm0,%xmm2
add $0x10,%rax
paddd %xmm1,%xmm0
movups %xmm2,-0x10(%rax)
cmp %rdx,%rax
jne 1208 <func0+0xa8>
mov %ecx,%eax
and $0xfffffffc,%eax
lea 0x1(%rax,%rax,1),%edx
cmp %eax,%ecx
je 1255 <func0+0xf5>
movslq %eax,%r9
lea 0x2(%rdx),%r10d
mov %edx,(%r8,%r9,4)
lea 0x1(%rax),%r9d
cmp %r10d,%edi
jl 1255 <func0+0xf5>
movslq %r9d,%r9
add $0x4,%edx
add $0x2,%eax
mov %r10d,(%r8,%r9,4)
cmp %edx,%edi
jl 1255 <func0+0xf5>
cltq
mov %edx,(%r8,%rax,4)
mov %ecx,%eax
cmp $0x1,%edi
jle 12f4 <func0+0x194>
lea -0x2(%rdi),%edx
mov %edx,%r9d
shr %r9d
add $0x1,%r9d
cmp $0x5,%edx
jbe 131b <func0+0x1bb>
mov %r9d,%edx
movslq %ecx,%rax
movdqa 0xd9c(%rip),%xmm0
movdqa 0xda4(%rip),%xmm1
shr $0x2,%edx
lea (%r8,%rax,4),%rax
shl $0x4,%rdx
add %rax,%rdx
nopw 0x0(%rax,%rax,1)
movdqa %xmm0,%xmm2
add $0x10,%rax
paddd %xmm1,%xmm0
movups %xmm2,-0x10(%rax)
cmp %rdx,%rax
jne 12a0 <func0+0x140>
mov %r9d,%r10d
and $0xfffffffc,%r10d
lea 0x2(%r10,%r10,1),%edx
lea (%rcx,%r10,1),%eax
cmp %r10d,%r9d
je 12f4 <func0+0x194>
movslq %eax,%rcx
lea 0x2(%rdx),%r9d
mov %edx,(%r8,%rcx,4)
lea 0x1(%rax),%ecx
cmp %r9d,%edi
jl 12f4 <func0+0x194>
movslq %ecx,%rcx
add $0x4,%edx
add $0x2,%eax
mov %r9d,(%r8,%rcx,4)
cmp %edi,%edx
jg 12f4 <func0+0x194>
cltq
mov %edx,(%r8,%rax,4)
sub $0x1,%esi
movslq %esi,%rsi
mov (%r8,%rsi,4),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
jne 132e <func0+0x1ce>
leaveq
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 11c8 <func0+0x68>
mov $0x2,%edx
jmp 12ca <func0+0x16a>
xor %eax,%eax
mov $0x1,%edx
jmpq 122a <func0+0xca>
callq 1050 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push rbp
mov ecx, edi
mov edi, esi
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, ecx
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_11B7
loc_11A2:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rsi
jnz short loc_11A2
loc_11B7:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1310
loc_11C9:
lea r8, [rsp+1010h+var_100D]
mov rdx, r8
and r8, 0FFFFFFFFFFFFFFFCh
shr rdx, 2
test ecx, ecx
jle loc_12F4
lea eax, [rcx-1]
mov r9d, eax
shr r9d, 1
lea esi, [r9+1]
cmp eax, 5
jbe loc_131B
mov edx, esi
movdqa xmm0, cs:xmmword_2010
movdqa xmm1, cs:xmmword_2030
mov rax, r8
shr edx, 2
shl rdx, 4
add rdx, r8
nop word ptr [rax+rax+00000000h]
loc_1220:
movdqa xmm2, xmm0
add rax, 10h
paddd xmm0, xmm1
movups xmmword ptr [rax-10h], xmm2
cmp rdx, rax
jnz short loc_1220
test sil, 3
jz short loc_1269
mov r10d, esi
and r10d, 0FFFFFFFCh
lea eax, [r10+r10]
movsxd r10, r10d
lea edx, [rax+1]
lea r10, [r8+r10*4]
add eax, 3
mov [r10], edx
cmp ecx, eax
jl short loc_1269
loc_125A:
add edx, 4
mov [r10+4], eax
cmp ecx, edx
jl short loc_1269
mov [r10+8], edx
loc_1269:
lea eax, [rcx-2]
mov r10d, eax
shr r10d, 1
add r10d, 1
cmp eax, 5
jbe loc_133D
add r9d, 1
mov edx, r10d
movdqa xmm0, cs:xmmword_2020
movdqa xmm1, cs:xmmword_2030
movsxd r9, r9d
shr edx, 2
lea rax, [r8+r9*4]
shl rdx, 4
add rdx, rax
nop word ptr [rax+rax+00000000h]
loc_12B0:
movdqa xmm2, xmm0
add rax, 10h
paddd xmm0, xmm1
movups xmmword ptr [rax-10h], xmm2
cmp rax, rdx
jnz short loc_12B0
mov eax, r10d
and eax, 0FFFFFFFCh
add esi, eax
and r10d, 3
lea eax, [rax+rax+2]
jz short loc_12F4
loc_12D7:
movsxd rsi, esi
lea rdx, [r8+rsi*4]
lea esi, [rax+2]
mov [rdx], eax
cmp ecx, esi
jl short loc_12F4
add eax, 4
mov [rdx+4], esi
cmp ecx, eax
jl short loc_12F4
mov [rdx+8], eax
loc_12F4:
sub edi, 1
movsxd rdi, edi
mov eax, [r8+rdi*4]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_1353
leave
retn
loc_1310:
or [rsp+rdx+1010h+var_1018], 0
jmp loc_11C9
loc_131B:
mov ds:dword_0[rdx*4], 1
cmp ecx, 2
jle short loc_1344
mov r10, r8
mov eax, 3
mov edx, 1
jmp loc_125A
loc_133D:
mov eax, 2
jmp short loc_12D7
loc_1344:
jnz short loc_12F4
mov esi, 1
xor r9d, r9d
jmp loc_1269
loc_1353:
call ___stack_chk_fail | long long func0(int a1, int a2)
{
long long v4; // rdx
_DWORD *v5; // rsi
__int16 v6; // dx
signed long long v7; // rdx
void *v8; // rsp
unsigned int v9; // r9d
unsigned int v10; // esi
__m128i si128; // xmm0
__m128i v12; // xmm1
__m128i *v13; // rax
__m128i v14; // xmm2
unsigned int v15; // eax
int v16; // edx
int *v17; // r10
int v18; // eax
int v19; // edx
unsigned int v20; // r10d
__m128i v21; // xmm0
__m128i v22; // xmm1
__m128i *v23; // rax
__m128i *v24; // rdx
__m128i v25; // xmm2
unsigned int v26; // eax
unsigned int *v27; // rdx
unsigned int v28; // esi
int v29; // eax
_DWORD v32[1022]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v33[2]; // [rsp+1008h] [rbp-10h] BYREF
v33[1] = __readfsqword(0x28u);
v4 = 4LL * a1 + 15;
v5 = (_DWORD *)((char *)v33 - (v4 & 0xFFFFFFFFFFFFF000LL));
v6 = v4 & 0xFFF0;
if ( v33 != (_QWORD *)v5 )
{
while ( v32 != v5 )
;
}
v7 = v6 & 0xFFF;
v8 = alloca(v7);
if ( v7 )
*(_QWORD *)((char *)&v32[-2] + v7) = *(_QWORD *)((char *)&v32[-2] + v7);
if ( a1 <= 0 )
return (unsigned int)v32[a2 - 1];
v9 = (unsigned int)(a1 - 1) >> 1;
v10 = v9 + 1;
if ( (unsigned int)(a1 - 1) <= 5 )
{
v32[0] = 1;
if ( a1 <= 2 )
{
if ( a1 != 2 )
return (unsigned int)v32[a2 - 1];
v10 = 1;
v9 = 0;
goto LABEL_13;
}
v17 = v32;
v18 = 3;
v16 = 1;
goto LABEL_11;
}
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v12 = _mm_load_si128((const __m128i *)&xmmword_2030);
v13 = (__m128i *)v32;
do
{
v14 = si128;
++v13;
si128 = _mm_add_epi32(si128, v12);
v13[-1] = v14;
}
while ( &v32[4 * (v10 >> 2)] != (_DWORD *)v13 );
if ( (v10 & 3) != 0 )
{
v15 = 2 * (v10 & 0xFFFFFFFC);
v16 = v15 + 1;
v17 = &v32[v10 & 0xFFFFFFFC];
v18 = v15 + 3;
*v17 = v16;
if ( a1 >= v18 )
{
LABEL_11:
v19 = v16 + 4;
v17[1] = v18;
if ( a1 >= v19 )
v17[2] = v19;
}
}
LABEL_13:
v20 = ((unsigned int)(a1 - 2) >> 1) + 1;
if ( (unsigned int)(a1 - 2) <= 5 )
{
v26 = 2;
}
else
{
v21 = _mm_load_si128((const __m128i *)&xmmword_2020);
v22 = _mm_load_si128((const __m128i *)&xmmword_2030);
v23 = (__m128i *)&v32[v9 + 1];
v24 = &v23[v20 >> 2];
do
{
v25 = v21;
++v23;
v21 = _mm_add_epi32(v21, v22);
v23[-1] = v25;
}
while ( v23 != v24 );
v10 += v20 & 0xFFFFFFFC;
v26 = 2 * (v20 & 0xFFFFFFFC) + 2;
if ( (v20 & 3) == 0 )
return (unsigned int)v32[a2 - 1];
}
v27 = &v32[v10];
v28 = v26 + 2;
*v27 = v26;
if ( a1 >= (int)(v26 + 2) )
{
v29 = v26 + 4;
v27[1] = v28;
if ( a1 >= v29 )
v27[2] = v29;
}
return (unsigned int)v32[a2 - 1];
} | func0:
ENDBR64
PUSH RBP
MOV ECX,EDI
MOV EDI,ESI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,ECX
MOV RSI,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RSI,RAX
AND RDX,-0x10
CMP RSP,RSI
JZ 0x001011b7
LAB_001011a2:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x001011a2
LAB_001011b7:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101310
LAB_001011c9:
LEA R8,[RSP + 0x3]
MOV RDX,R8
AND R8,-0x4
SHR RDX,0x2
TEST ECX,ECX
JLE 0x001012f4
LEA EAX,[RCX + -0x1]
MOV R9D,EAX
SHR R9D,0x1
LEA ESI,[R9 + 0x1]
CMP EAX,0x5
JBE 0x0010131b
MOV EDX,ESI
MOVDQA XMM0,xmmword ptr [0x00102010]
MOVDQA XMM1,xmmword ptr [0x00102030]
MOV RAX,R8
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,R8
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101220:
MOVDQA XMM2,XMM0
ADD RAX,0x10
PADDD XMM0,XMM1
MOVUPS xmmword ptr [RAX + -0x10],XMM2
CMP RDX,RAX
JNZ 0x00101220
TEST SIL,0x3
JZ 0x00101269
MOV R10D,ESI
AND R10D,0xfffffffc
LEA EAX,[R10 + R10*0x1]
MOVSXD R10,R10D
LEA EDX,[RAX + 0x1]
LEA R10,[R8 + R10*0x4]
ADD EAX,0x3
MOV dword ptr [R10],EDX
CMP ECX,EAX
JL 0x00101269
LAB_0010125a:
ADD EDX,0x4
MOV dword ptr [R10 + 0x4],EAX
CMP ECX,EDX
JL 0x00101269
MOV dword ptr [R10 + 0x8],EDX
LAB_00101269:
LEA EAX,[RCX + -0x2]
MOV R10D,EAX
SHR R10D,0x1
ADD R10D,0x1
CMP EAX,0x5
JBE 0x0010133d
ADD R9D,0x1
MOV EDX,R10D
MOVDQA XMM0,xmmword ptr [0x00102020]
MOVDQA XMM1,xmmword ptr [0x00102030]
MOVSXD R9,R9D
SHR EDX,0x2
LEA RAX,[R8 + R9*0x4]
SHL RDX,0x4
ADD RDX,RAX
NOP word ptr [RAX + RAX*0x1]
LAB_001012b0:
MOVDQA XMM2,XMM0
ADD RAX,0x10
PADDD XMM0,XMM1
MOVUPS xmmword ptr [RAX + -0x10],XMM2
CMP RAX,RDX
JNZ 0x001012b0
MOV EAX,R10D
AND EAX,0xfffffffc
ADD ESI,EAX
AND R10D,0x3
LEA EAX,[RAX + RAX*0x1 + 0x2]
JZ 0x001012f4
LAB_001012d7:
MOVSXD RSI,ESI
LEA RDX,[R8 + RSI*0x4]
LEA ESI,[RAX + 0x2]
MOV dword ptr [RDX],EAX
CMP ECX,ESI
JL 0x001012f4
ADD EAX,0x4
MOV dword ptr [RDX + 0x4],ESI
CMP ECX,EAX
JL 0x001012f4
MOV dword ptr [RDX + 0x8],EAX
LAB_001012f4:
SUB EDI,0x1
MOVSXD RDI,EDI
MOV EAX,dword ptr [R8 + RDI*0x4]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101353
LEAVE
RET
LAB_00101310:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001011c9
LAB_0010131b:
MOV dword ptr [RDX*0x4],0x1
CMP ECX,0x2
JLE 0x00101344
MOV R10,R8
MOV EAX,0x3
MOV EDX,0x1
JMP 0x0010125a
LAB_0010133d:
MOV EAX,0x2
JMP 0x001012d7
LAB_00101344:
JNZ 0x001012f4
MOV ESI,0x1
XOR R9D,R9D
JMP 0x00101269
LAB_00101353:
CALL 0x00101050 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int4 func0(int param_1,int param_2)
{
long lVar1;
int *puVar2;
int iVar3;
int iVar4;
int iVar5;
int *piVar6;
int *piVar7;
int iVar8;
ulong uVar9;
int *puVar10;
uint uVar12;
uint uVar13;
uint uVar14;
long in_FS_OFFSET;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int auStack_18 [8];
long local_10;
int *puVar11;
iVar4 = _UNK_0010203c;
iVar3 = _UNK_00102038;
iVar8 = _UNK_00102034;
iVar5 = _DAT_00102030;
puVar10 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar9 = (long)param_1 * 4 + 0xf;
puVar11 = auStack_18;
puVar2 = auStack_18;
while (puVar11 != auStack_18 + -(uVar9 & 0xfffffffffffff000)) {
puVar10 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar11 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar9 = (ulong)((uint)uVar9 & 0xff0);
lVar1 = -uVar9;
piVar7 = (int *)(puVar10 + lVar1);
if (uVar9 != 0) {
*(int8 *)(puVar10 + -8) = *(int8 *)(puVar10 + -8);
}
if (param_1 < 1) goto LAB_001012f4;
uVar13 = param_1 - 1U >> 1;
uVar12 = uVar13 + 1;
if (param_1 - 1U < 6) {
*(int4 *)(puVar10 + lVar1) = 1;
if (param_1 < 3) {
if (param_1 != 2) goto LAB_001012f4;
uVar12 = 1;
uVar13 = 0;
}
else {
iVar5 = 3;
iVar8 = 1;
LAB_0010125a:
piVar7[1] = iVar5;
if (iVar8 + 4 <= param_1) {
piVar7[2] = iVar8 + 4;
}
}
}
else {
piVar7 = (int *)(puVar10 + lVar1);
iVar15 = _DAT_00102010;
iVar16 = _UNK_00102014;
iVar17 = _UNK_00102018;
iVar18 = _UNK_0010201c;
do {
piVar6 = piVar7 + 4;
*piVar7 = iVar15;
piVar7[1] = iVar16;
piVar7[2] = iVar17;
piVar7[3] = iVar18;
piVar7 = piVar6;
iVar15 = iVar15 + iVar5;
iVar16 = iVar16 + iVar8;
iVar17 = iVar17 + iVar3;
iVar18 = iVar18 + iVar4;
} while ((int *)(puVar10 + (ulong)(uVar12 >> 2) * 0x10 + lVar1) != piVar6);
if ((uVar12 & 3) != 0) {
iVar5 = (uVar12 & 0xfffffffc) * 2;
iVar8 = iVar5 + 1;
piVar7 = (int *)(puVar10 + (long)(int)(uVar12 & 0xfffffffc) * 4 + lVar1);
iVar5 = iVar5 + 3;
*piVar7 = iVar8;
if (iVar5 <= param_1) goto LAB_0010125a;
}
}
iVar4 = _UNK_0010203c;
iVar3 = _UNK_00102038;
iVar8 = _UNK_00102034;
iVar5 = _DAT_00102030;
uVar14 = (param_1 - 2U >> 1) + 1;
if (param_1 - 2U < 6) {
iVar5 = 2;
}
else {
piVar7 = (int *)(puVar10 + (long)(int)(uVar13 + 1) * 4 + lVar1);
iVar15 = _DAT_00102020;
iVar16 = _UNK_00102024;
iVar17 = _UNK_00102028;
iVar18 = _UNK_0010202c;
do {
piVar6 = piVar7 + 4;
*piVar7 = iVar15;
piVar7[1] = iVar16;
piVar7[2] = iVar17;
piVar7[3] = iVar18;
piVar7 = piVar6;
iVar15 = iVar15 + iVar5;
iVar16 = iVar16 + iVar8;
iVar17 = iVar17 + iVar3;
iVar18 = iVar18 + iVar4;
} while (piVar6 != (int *)((long)(puVar10 + (long)(int)(uVar13 + 1) * 4 + lVar1) +
(ulong)(uVar14 >> 2) * 4 * 4));
uVar12 = uVar12 + (uVar14 & 0xfffffffc);
iVar5 = (uVar14 & 0xfffffffc) * 2 + 2;
if ((uVar14 & 3) == 0) goto LAB_001012f4;
}
piVar7 = (int *)(puVar10 + (long)(int)uVar12 * 4 + lVar1);
*piVar7 = iVar5;
if (iVar5 + 2 <= param_1) {
piVar7[1] = iVar5 + 2;
if (iVar5 + 4 <= param_1) {
piVar7[2] = iVar5 + 4;
}
}
LAB_001012f4:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar10 + lVar1 + -8) = _fini;
__stack_chk_fail();
}
return *(int4 *)(puVar10 + (long)(param_2 + -1) * 4 + lVar1);
} |
7,272 | func0 |
#include <assert.h>
#include <math.h>
| int func0(int n) {
if (n < 0) {
return 0;
}
if (n <= 1) {
return 1;
}
double x = (n * log10((double)n / M_E) + log10(2 * M_PI * n) / 2.0);
return (int)floor(x) + 1;
}
| int main() {
assert(func0(7) == 4);
assert(func0(5) == 3);
assert(func0(4) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jns 11a5 <func0+0x1c>
mov $0x0,%eax
jmp 121d <func0+0x94>
cmpl $0x1,-0x14(%rbp)
jg 11b2 <func0+0x29>
mov $0x1,%eax
jmp 121d <func0+0x94>
cvtsi2sdl -0x14(%rbp),%xmm3
movsd %xmm3,-0x20(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd 0xeaf(%rip),%xmm1
divsd %xmm1,%xmm0
callq 1080 <log10@plt>
mulsd -0x20(%rbp),%xmm0
movsd %xmm0,-0x20(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm1
movsd 0xe97(%rip),%xmm0
mulsd %xmm1,%xmm0
callq 1080 <log10@plt>
movsd 0xe8e(%rip),%xmm1
divsd %xmm1,%xmm0
addsd -0x20(%rbp),%xmm0
movsd %xmm0,-0x8(%rbp)
mov -0x8(%rbp),%rax
movq %rax,%xmm0
callq 1090 <floor@plt>
cvttsd2si %xmm0,%eax
add $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jns short loc_11A8
mov eax, 0
jmp locret_1251
loc_11A8:
cmp [rbp+var_14], 1
jg short loc_11B8
mov eax, 1
jmp locret_1251
loc_11B8:
pxor xmm4, xmm4
cvtsi2sd xmm4, [rbp+var_14]
movsd [rbp+var_20], xmm4
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_14]
movsd xmm1, cs:qword_2058
divsd xmm0, xmm1
movq rax, xmm0
movq xmm0, rax; x
call _log10
mulsd xmm0, [rbp+var_20]
movsd [rbp+var_20], xmm0
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_14]
movsd xmm0, cs:qword_2060
mulsd xmm1, xmm0
movq rax, xmm1
movq xmm0, rax; x
call _log10
movq rax, xmm0
movsd xmm1, cs:qword_2068
movq xmm3, rax
divsd xmm3, xmm1
movapd xmm0, xmm3
addsd xmm0, [rbp+var_20]
movsd [rbp+x], xmm0
mov rax, [rbp+x]
movq xmm0, rax; x
call _floor
cvttsd2si eax, xmm0
add eax, 1
locret_1251:
leave
retn | long long func0(int a1)
{
double v2; // [rsp+0h] [rbp-20h]
double x; // [rsp+18h] [rbp-8h]
if ( a1 < 0 )
return 0LL;
if ( a1 <= 1 )
return 1LL;
v2 = log10((double)a1 / 2.718281828459045) * (double)a1;
x = log10((double)a1 * 6.283185307179586) / 2.0 + v2;
return (unsigned int)((int)floor(x) + 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JNS 0x001011a8
MOV EAX,0x0
JMP 0x00101251
LAB_001011a8:
CMP dword ptr [RBP + -0x14],0x1
JG 0x001011b8
MOV EAX,0x1
JMP 0x00101251
LAB_001011b8:
PXOR XMM4,XMM4
CVTSI2SD XMM4,dword ptr [RBP + -0x14]
MOVSD qword ptr [RBP + -0x20],XMM4
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x14]
MOVSD XMM1,qword ptr [0x00102058]
DIVSD XMM0,XMM1
MOVQ RAX,XMM0
MOVQ XMM0,RAX
CALL 0x00101080
MULSD XMM0,qword ptr [RBP + -0x20]
MOVSD qword ptr [RBP + -0x20],XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x14]
MOVSD XMM0,qword ptr [0x00102060]
MULSD XMM1,XMM0
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101080
MOVQ RAX,XMM0
MOVSD XMM1,qword ptr [0x00102068]
MOVQ XMM3,RAX
DIVSD XMM3,XMM1
MOVAPD XMM0,XMM3
ADDSD XMM0,qword ptr [RBP + -0x20]
MOVSD qword ptr [RBP + -0x8],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOVQ XMM0,RAX
CALL 0x00101090
CVTTSD2SI EAX,XMM0
ADD EAX,0x1
LAB_00101251:
LEAVE
RET | int func0(int param_1)
{
int iVar1;
double dVar2;
double dVar3;
if (param_1 < 0) {
iVar1 = 0;
}
else if (param_1 < 2) {
iVar1 = 1;
}
else {
dVar2 = log10((double)param_1 / DAT_00102058);
dVar3 = log10((double)param_1 * DAT_00102060);
dVar2 = floor(dVar3 / DAT_00102068 + dVar2 * (double)param_1);
iVar1 = (int)dVar2 + 1;
}
return iVar1;
} |
7,273 | func0 |
#include <assert.h>
#include <math.h>
| int func0(int n) {
if (n < 0) {
return 0;
}
if (n <= 1) {
return 1;
}
double x = (n * log10((double)n / M_E) + log10(2 * M_PI * n) / 2.0);
return (int)floor(x) + 1;
}
| int main() {
assert(func0(7) == 4);
assert(func0(5) == 3);
assert(func0(4) == 2);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
test %edi,%edi
js 1246 <func0+0xdd>
mov $0x1,%eax
cmp $0x1,%edi
jle 1246 <func0+0xdd>
sub $0x18,%rsp
pxor %xmm5,%xmm5
cvtsi2sd %edi,%xmm5
movsd %xmm5,(%rsp)
movapd %xmm5,%xmm0
divsd 0xed3(%rip),%xmm0
callq 1070 <log10@plt>
movsd %xmm0,0x8(%rsp)
movsd (%rsp),%xmm6
mulsd 0xec3(%rip),%xmm6
movapd %xmm6,%xmm0
callq 1070 <log10@plt>
movapd %xmm0,%xmm1
movsd (%rsp),%xmm5
mulsd 0x8(%rsp),%xmm5
movapd %xmm5,%xmm0
mulsd 0xea7(%rip),%xmm1
addsd %xmm1,%xmm0
movapd %xmm0,%xmm1
movsd 0xeaf(%rip),%xmm3
movapd %xmm0,%xmm2
andpd %xmm3,%xmm2
movsd 0xe8f(%rip),%xmm4
ucomisd %xmm2,%xmm4
jbe 123a <func0+0xd1>
cvttsd2si %xmm0,%rax
pxor %xmm2,%xmm2
cvtsi2sd %rax,%xmm2
movapd %xmm2,%xmm1
cmpnlesd %xmm0,%xmm1
movsd 0xe72(%rip),%xmm4
andpd %xmm4,%xmm1
subsd %xmm1,%xmm2
andnpd %xmm0,%xmm3
movapd %xmm3,%xmm1
orpd %xmm2,%xmm1
cvttsd2si %xmm1,%eax
add $0x1,%eax
add $0x18,%rsp
retq
retq
| func0:
endbr64
mov eax, 0
test edi, edi
js locret_1241
mov eax, 1
cmp edi, 1
jle locret_1241
push rbx
sub rsp, 10h
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
movsd [rsp+18h+var_10], xmm0
divsd xmm0, cs:qword_2050
call _log10
movq rbx, xmm0
movsd xmm0, [rsp+18h+var_10]
mulsd xmm0, cs:qword_2058
call _log10
movapd xmm1, xmm0
movsd xmm0, [rsp+18h+var_10]
movq xmm5, rbx
mulsd xmm0, xmm5
mulsd xmm1, cs:qword_2060
addsd xmm0, xmm1
movapd xmm3, xmm0
movsd xmm2, cs:qword_2080
movapd xmm1, xmm0
andpd xmm1, xmm2
movsd xmm4, cs:qword_2068
ucomisd xmm4, xmm1
jbe short loc_1234
cvttsd2si rax, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm1, rax
movapd xmm3, xmm1
cmpnlesd xmm3, xmm0
movsd xmm4, cs:qword_2070
andpd xmm3, xmm4
subsd xmm1, xmm3
andnpd xmm2, xmm0
movapd xmm3, xmm1
orpd xmm3, xmm2
loc_1234:
cvttsd2si eax, xmm3
add eax, 1
add rsp, 10h
pop rbx
retn
locret_1241:
retn | long long func0(int a1)
{
long long result; // rax
double v2; // rbx
__m128d v3; // xmm0
double v4; // xmm3_8
__m128d v5; // xmm1
result = 0LL;
if ( a1 >= 0 )
{
result = 1LL;
if ( a1 > 1 )
{
v2 = log10((double)a1 / 2.718281828459045);
v3.m128d_f64[0] = (double)a1 * v2 + log10((double)a1 * 6.283185307179586) * 0.5;
v4 = v3.m128d_f64[0];
if ( fabs(v3.m128d_f64[0]) < 4.503599627370496e15 )
{
v5 = 0LL;
v5.m128d_f64[0] = (double)(int)v3.m128d_f64[0];
*(_QWORD *)&v4 = COERCE_UNSIGNED_INT64(v5.m128d_f64[0] - COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(v5, v3) & 0x3FF0000000000000LL)) | *(_QWORD *)&v3.m128d_f64[0] & 0x8000000000000000LL;
}
return (unsigned int)((int)v4 + 1);
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x0
TEST EDI,EDI
JS 0x00101241
MOV EAX,0x1
CMP EDI,0x1
JLE 0x00101241
PUSH RBX
SUB RSP,0x10
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MOVSD qword ptr [RSP + 0x8],XMM0
DIVSD XMM0,qword ptr [0x00102050]
CALL 0x00101070
MOVQ RBX,XMM0
MOVSD XMM0,qword ptr [RSP + 0x8]
MULSD XMM0,qword ptr [0x00102058]
CALL 0x00101070
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVQ XMM5,RBX
MULSD XMM0,XMM5
MULSD XMM1,qword ptr [0x00102060]
ADDSD XMM0,XMM1
MOVAPD XMM3,XMM0
MOVSD XMM2,qword ptr [0x00102080]
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
MOVSD XMM4,qword ptr [0x00102068]
UCOMISD XMM4,XMM1
JBE 0x00101234
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM1,RAX
MOVAPD XMM3,XMM1
CMPNLESD XMM3,XMM0
MOVSD XMM4,qword ptr [0x00102070]
ANDPD XMM3,XMM4
SUBSD XMM1,XMM3
ANDNPD XMM2,XMM0
MOVAPD XMM3,XMM1
ORPD XMM3,XMM2
LAB_00101234:
CVTTSD2SI EAX,XMM3
ADD EAX,0x1
ADD RSP,0x10
POP RBX
RET
LAB_00101241:
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(int param_1)
{
int iVar1;
double dVar2;
double dVar3;
double dVar4;
iVar1 = 0;
if ((-1 < param_1) && (iVar1 = 1, 1 < param_1)) {
dVar2 = (double)param_1;
dVar3 = log10(dVar2 / _DAT_00102050);
dVar4 = log10(dVar2 * _DAT_00102058);
dVar2 = dVar2 * dVar3 + dVar4 * _DAT_00102060;
if ((double)((ulong)dVar2 & DAT_00102080) < DAT_00102068) {
dVar2 = (double)((ulong)((double)(long)dVar2 -
(double)(-(ulong)(dVar2 < (double)(long)dVar2) & DAT_00102070)) |
~DAT_00102080 & (ulong)dVar2);
}
return (int)dVar2 + 1;
}
return iVar1;
} |
7,274 | func0 |
#include <assert.h>
#include <math.h>
| int func0(int n) {
if (n < 0) {
return 0;
}
if (n <= 1) {
return 1;
}
double x = (n * log10((double)n / M_E) + log10(2 * M_PI * n) / 2.0);
return (int)floor(x) + 1;
}
| int main() {
assert(func0(7) == 4);
assert(func0(5) == 3);
assert(func0(4) == 2);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
js 12f0 <func0+0x20>
cmp $0x1,%edi
jle 12e8 <func0+0x18>
jmpq 1210 <func0.part.0>
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
xchg %ax,%ax
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
pxor xmm5, xmm5
sub rsp, 18h
cvtsi2sd xmm5, edi
movapd xmm0, xmm5
movsd [rsp+18h+var_18], xmm5
divsd xmm0, cs:qword_2050
call _log10
movsd xmm6, [rsp+18h+var_18]
mulsd xmm6, cs:qword_2058
movsd [rsp+18h+var_10], xmm0
movapd xmm0, xmm6
call _log10
movsd xmm5, [rsp+18h+var_18]
mulsd xmm5, [rsp+18h+var_10]
movapd xmm1, xmm0
movsd xmm2, cs:qword_2080
movsd xmm3, cs:qword_2068
mulsd xmm1, cs:qword_2060
movapd xmm0, xmm5
addsd xmm0, xmm1
movapd xmm1, xmm0
andpd xmm1, xmm2
ucomisd xmm3, xmm1
jbe short loc_12BE
cvttsd2si rax, xmm0
pxor xmm1, xmm1
movsd xmm4, cs:qword_2070
andnpd xmm2, xmm0
cvtsi2sd xmm1, rax
movapd xmm3, xmm1
cmpnlesd xmm3, xmm0
andpd xmm3, xmm4
subsd xmm1, xmm3
orpd xmm1, xmm2
movapd xmm0, xmm1
loc_12BE:
cvttsd2si eax, xmm0
add rsp, 18h
add eax, 1
retn | long long func0_part_0(int a1)
{
__m128d v1; // xmm0
__m128d v2; // xmm1
double v4; // [rsp+8h] [rbp-10h]
v4 = log10((double)a1 / 2.718281828459045);
v1.m128d_f64[0] = (double)a1 * v4 + log10((double)a1 * 6.283185307179586) * 0.5;
if ( fabs(v1.m128d_f64[0]) < 4.503599627370496e15 )
{
v2 = 0LL;
v2.m128d_f64[0] = (double)(int)v1.m128d_f64[0];
*(_QWORD *)&v1.m128d_f64[0] = COERCE_UNSIGNED_INT64(
v2.m128d_f64[0]
- COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(v2, v1) & 0x3FF0000000000000LL)) | *(_QWORD *)&v1.m128d_f64[0] & 0x8000000000000000LL;
}
return (unsigned int)((int)v1.m128d_f64[0] + 1);
} | func0.part.0:
PXOR XMM5,XMM5
SUB RSP,0x18
CVTSI2SD XMM5,EDI
MOVAPD XMM0,XMM5
MOVSD qword ptr [RSP],XMM5
DIVSD XMM0,qword ptr [0x00102050]
CALL 0x00101070
MOVSD XMM6,qword ptr [RSP]
MULSD XMM6,qword ptr [0x00102058]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVAPD XMM0,XMM6
CALL 0x00101070
MOVSD XMM5,qword ptr [RSP]
MULSD XMM5,qword ptr [RSP + 0x8]
MOVAPD XMM1,XMM0
MOVSD XMM2,qword ptr [0x00102080]
MOVSD XMM3,qword ptr [0x00102068]
MULSD XMM1,qword ptr [0x00102060]
MOVAPD XMM0,XMM5
ADDSD XMM0,XMM1
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
UCOMISD XMM3,XMM1
JBE 0x001012be
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
MOVSD XMM4,qword ptr [0x00102070]
ANDNPD XMM2,XMM0
CVTSI2SD XMM1,RAX
MOVAPD XMM3,XMM1
CMPNLESD XMM3,XMM0
ANDPD XMM3,XMM4
SUBSD XMM1,XMM3
ORPD XMM1,XMM2
MOVAPD XMM0,XMM1
LAB_001012be:
CVTTSD2SI EAX,XMM0
ADD RSP,0x18
ADD EAX,0x1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0_part_0(int param_1)
{
double dVar1;
double dVar2;
double dVar3;
dVar3 = (double)param_1;
dVar1 = log10(dVar3 / _DAT_00102050);
dVar2 = log10(dVar3 * _DAT_00102058);
dVar1 = dVar3 * dVar1 + dVar2 * _DAT_00102060;
if ((double)((ulong)dVar1 & DAT_00102080) < DAT_00102068) {
dVar1 = (double)((ulong)((double)(long)dVar1 -
(double)(-(ulong)(dVar1 < (double)(long)dVar1) & DAT_00102070)) |
~DAT_00102080 & (ulong)dVar1);
}
return (int)dVar1 + 1;
} |
7,275 | func0 |
#include <assert.h>
#include <math.h>
| int func0(int n) {
if (n < 0) {
return 0;
}
if (n <= 1) {
return 1;
}
double x = (n * log10((double)n / M_E) + log10(2 * M_PI * n) / 2.0);
return (int)floor(x) + 1;
}
| int main() {
assert(func0(7) == 4);
assert(func0(5) == 3);
assert(func0(4) == 2);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
test %edi,%edi
js 13b0 <func0+0xe0>
mov $0x1,%eax
cmp $0x1,%edi
jle 13b0 <func0+0xe0>
pxor %xmm5,%xmm5
sub $0x18,%rsp
cvtsi2sd %edi,%xmm5
movapd %xmm5,%xmm0
movsd %xmm5,(%rsp)
divsd 0xd6f(%rip),%xmm0
callq 1070 <log10@plt>
movsd (%rsp),%xmm6
mulsd 0xd65(%rip),%xmm6
movsd %xmm0,0x8(%rsp)
movapd %xmm6,%xmm0
callq 1070 <log10@plt>
movsd (%rsp),%xmm5
mulsd 0x8(%rsp),%xmm5
movapd %xmm0,%xmm1
movsd 0xd5f(%rip),%xmm2
movsd 0xd47(%rip),%xmm3
mulsd 0xd37(%rip),%xmm1
movapd %xmm5,%xmm0
addsd %xmm1,%xmm0
movapd %xmm0,%xmm1
andpd %xmm2,%xmm1
ucomisd %xmm1,%xmm3
jbe 139a <func0+0xca>
cvttsd2si %xmm0,%rax
pxor %xmm1,%xmm1
movsd 0xd20(%rip),%xmm4
andnpd %xmm0,%xmm2
cvtsi2sd %rax,%xmm1
movapd %xmm1,%xmm3
cmpnlesd %xmm0,%xmm3
movapd %xmm2,%xmm0
andpd %xmm4,%xmm3
subsd %xmm3,%xmm1
orpd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
add $0x18,%rsp
add $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0_part_0:
pxor xmm5, xmm5
sub rsp, 18h
cvtsi2sd xmm5, edi
movapd xmm0, xmm5
movsd [rsp+18h+var_18], xmm5
divsd xmm0, cs:qword_2058; x
call _log10
movsd xmm6, [rsp+18h+var_18]
mulsd xmm6, cs:qword_2060
movsd [rsp+18h+var_10], xmm0
movapd xmm0, xmm6; x
call _log10
movsd xmm5, [rsp+18h+var_18]
mulsd xmm5, [rsp+18h+var_10]
movapd xmm1, xmm0
movsd xmm2, cs:qword_2080
movsd xmm3, cs:qword_2070
mulsd xmm1, cs:qword_2068
movapd xmm0, xmm5
addsd xmm0, xmm1
movapd xmm1, xmm0
andpd xmm1, xmm2
ucomisd xmm3, xmm1
jbe short loc_12BE
cvttsd2si rax, xmm0
pxor xmm1, xmm1
movsd xmm4, cs:qword_2078
andnpd xmm2, xmm0
cvtsi2sd xmm1, rax
movapd xmm3, xmm1
cmpnlesd xmm3, xmm0
andpd xmm3, xmm4
subsd xmm1, xmm3
orpd xmm1, xmm2
movapd xmm0, xmm1
loc_12BE:
cvttsd2si eax, xmm0
add rsp, 18h
add eax, 1
retn | long long func0_part_0(int a1)
{
__m128d v1; // xmm0
__m128d v2; // xmm1
double v4; // [rsp+8h] [rbp-10h]
v4 = log10((double)a1 / 2.718281828459045);
v1.m128d_f64[0] = (double)a1 * v4 + log10((double)a1 * 6.283185307179586) * 0.5;
if ( fabs(v1.m128d_f64[0]) < 4.503599627370496e15 )
{
v2 = 0LL;
v2.m128d_f64[0] = (double)(int)v1.m128d_f64[0];
*(_QWORD *)&v1.m128d_f64[0] = COERCE_UNSIGNED_INT64(
v2.m128d_f64[0]
- COERCE_DOUBLE(*(_OWORD *)&_mm_cmpgt_sd(v2, v1) & 0x3FF0000000000000LL)) | *(_QWORD *)&v1.m128d_f64[0] & 0x8000000000000000LL;
}
return (unsigned int)((int)v1.m128d_f64[0] + 1);
} | func0.part.0:
PXOR XMM5,XMM5
SUB RSP,0x18
CVTSI2SD XMM5,EDI
MOVAPD XMM0,XMM5
MOVSD qword ptr [RSP],XMM5
DIVSD XMM0,qword ptr [0x00102058]
CALL 0x00101070
MOVSD XMM6,qword ptr [RSP]
MULSD XMM6,qword ptr [0x00102060]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVAPD XMM0,XMM6
CALL 0x00101070
MOVSD XMM5,qword ptr [RSP]
MULSD XMM5,qword ptr [RSP + 0x8]
MOVAPD XMM1,XMM0
MOVSD XMM2,qword ptr [0x00102080]
MOVSD XMM3,qword ptr [0x00102070]
MULSD XMM1,qword ptr [0x00102068]
MOVAPD XMM0,XMM5
ADDSD XMM0,XMM1
MOVAPD XMM1,XMM0
ANDPD XMM1,XMM2
UCOMISD XMM3,XMM1
JBE 0x001012be
CVTTSD2SI RAX,XMM0
PXOR XMM1,XMM1
MOVSD XMM4,qword ptr [0x00102078]
ANDNPD XMM2,XMM0
CVTSI2SD XMM1,RAX
MOVAPD XMM3,XMM1
CMPNLESD XMM3,XMM0
ANDPD XMM3,XMM4
SUBSD XMM1,XMM3
ORPD XMM1,XMM2
MOVAPD XMM0,XMM1
LAB_001012be:
CVTTSD2SI EAX,XMM0
ADD RSP,0x18
ADD EAX,0x1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0_part_0(int param_1)
{
double dVar1;
double dVar2;
double dVar3;
dVar3 = (double)param_1;
dVar1 = log10(dVar3 / _DAT_00102058);
dVar2 = log10(dVar3 * _DAT_00102060);
dVar1 = dVar3 * dVar1 + dVar2 * _DAT_00102068;
if ((double)((ulong)dVar1 & DAT_00102080) < DAT_00102070) {
dVar1 = (double)((ulong)((double)(long)dVar1 -
(double)(-(ulong)(dVar1 < (double)(long)dVar1) & DAT_00102078)) |
~DAT_00102080 & (ulong)dVar1);
}
return (int)dVar1 + 1;
} |
7,276 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| int func0(int arr[], int dep[], int n) {
qsort(arr, n, sizeof(int), compare);
qsort(dep, n, sizeof(int), compare);
int plat_needed = 1, result = 1;
int i = 1, j = 0;
while (i < n && j < n) {
if (arr[i] <= dep[j]) {
plat_needed++;
i++;
if (plat_needed > result) {
result = plat_needed;
}
} else {
plat_needed--;
j++;
}
}
return result;
}
| int main() {
int arr1[] = {900, 940, 950, 1100, 1500, 1800};
int dep1[] = {910, 1200, 1120, 1130, 1900, 2000};
assert(func0(arr1, dep1, 6) == 3);
int arr2[] = {100, 200, 300, 400};
int dep2[] = {700, 800, 900, 1000};
assert(func0(arr2, dep2, 4) == 4);
int arr3[] = {5, 6, 7, 8};
int dep3[] = {4, 3, 2, 1};
assert(func0(arr3, dep3, 4) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov -0x24(%rbp),%eax
movslq %eax,%rsi
mov -0x18(%rbp),%rax
lea -0x4a(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 1070 <qsort@plt>
mov -0x24(%rbp),%eax
movslq %eax,%rsi
mov -0x20(%rbp),%rax
lea -0x68(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 1070 <qsort@plt>
movl $0x1,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 126c <func0+0xc1>
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 -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jg 1264 <func0+0xb9>
addl $0x1,-0x10(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x10(%rbp),%eax
cmp -0xc(%rbp),%eax
jle 126c <func0+0xc1>
mov -0x10(%rbp),%eax
mov %eax,-0xc(%rbp)
jmp 126c <func0+0xc1>
subl $0x1,-0x10(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x8(%rbp),%eax
cmp -0x24(%rbp),%eax
jge 127c <func0+0xd1>
mov -0x4(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 121c <func0+0x71>
mov -0xc(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+base], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov eax, [rbp+var_24]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
mov eax, [rbp+var_24]
movsxd rsi, eax; nmemb
mov rax, [rbp+var_20]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
mov [rbp+var_10], 1
mov [rbp+var_C], 1
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_1272
loc_1222:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jg short loc_126A
add [rbp+var_10], 1
add [rbp+var_8], 1
mov eax, [rbp+var_10]
cmp eax, [rbp+var_C]
jle short loc_1272
mov eax, [rbp+var_10]
mov [rbp+var_C], eax
jmp short loc_1272
loc_126A:
sub [rbp+var_10], 1
add [rbp+var_4], 1
loc_1272:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_24]
jge short loc_1282
mov eax, [rbp+var_4]
cmp eax, [rbp+var_24]
jl short loc_1222
loc_1282:
mov eax, [rbp+var_C]
leave
retn | long long func0(void *a1, void *a2, int a3)
{
int v5; // [rsp+20h] [rbp-10h]
int v6; // [rsp+24h] [rbp-Ch]
int v7; // [rsp+28h] [rbp-8h]
int v8; // [rsp+2Ch] [rbp-4h]
qsort(a1, a3, 4uLL, compare);
qsort(a2, a3, 4uLL, compare);
v5 = 1;
v6 = 1;
v7 = 1;
v8 = 0;
while ( v7 < a3 && v8 < a3 )
{
if ( *((_DWORD *)a1 + v7) > *((_DWORD *)a2 + v8) )
{
--v5;
++v8;
}
else
{
++v5;
++v7;
if ( v5 > v6 )
v6 = v5;
}
}
return (unsigned int)v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x101189]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x00101070
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x101189]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x10],0x1
MOV dword ptr [RBP + -0xc],0x1
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101272
LAB_00101222:
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 + -0x20]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JG 0x0010126a
ADD dword ptr [RBP + -0x10],0x1
ADD dword ptr [RBP + -0x8],0x1
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0xc]
JLE 0x00101272
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00101272
LAB_0010126a:
SUB dword ptr [RBP + -0x10],0x1
ADD dword ptr [RBP + -0x4],0x1
LAB_00101272:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x24]
JGE 0x00101282
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00101222
LAB_00101282:
MOV EAX,dword ptr [RBP + -0xc]
LEAVE
RET | int func0(void *param_1,void *param_2,int param_3)
{
int local_18;
int local_14;
int local_10;
int local_c;
qsort(param_1,(long)param_3,4,compare);
qsort(param_2,(long)param_3,4,compare);
local_18 = 1;
local_14 = 1;
local_10 = 1;
local_c = 0;
while ((local_10 < param_3 && (local_c < param_3))) {
if (*(int *)((long)param_2 + (long)local_c * 4) < *(int *)((long)param_1 + (long)local_10 * 4))
{
local_18 = local_18 + -1;
local_c = local_c + 1;
}
else {
local_18 = local_18 + 1;
local_10 = local_10 + 1;
if (local_14 < local_18) {
local_14 = local_18;
}
}
}
return local_14;
} |
7,277 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| int func0(int arr[], int dep[], int n) {
qsort(arr, n, sizeof(int), compare);
qsort(dep, n, sizeof(int), compare);
int plat_needed = 1, result = 1;
int i = 1, j = 0;
while (i < n && j < n) {
if (arr[i] <= dep[j]) {
plat_needed++;
i++;
if (plat_needed > result) {
result = plat_needed;
}
} else {
plat_needed--;
j++;
}
}
return result;
}
| int main() {
int arr1[] = {900, 940, 950, 1100, 1500, 1800};
int dep1[] = {910, 1200, 1120, 1130, 1900, 2000};
assert(func0(arr1, dep1, 6) == 3);
int arr2[] = {100, 200, 300, 400};
int dep2[] = {700, 800, 900, 1000};
assert(func0(arr2, dep2, 4) == 4);
int arr3[] = {5, 6, 7, 8};
int dep3[] = {4, 3, 2, 1};
assert(func0(arr3, dep3, 4) == 1);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%r12
mov %edx,%ebx
movslq %edx,%r13
lea -0x29(%rip),%rcx
mov $0x4,%edx
mov %r13,%rsi
callq 1070 <qsort@plt>
lea -0x3d(%rip),%rcx
mov $0x4,%edx
mov %r13,%rsi
mov %r12,%rdi
callq 1070 <qsort@plt>
cmp $0x1,%ebx
jle 1222 <func0+0x90>
mov $0x0,%edx
mov $0x1,%eax
mov $0x1,%r8d
mov $0x1,%esi
jmp 1203 <func0+0x71>
sub $0x1,%esi
add $0x1,%edx
cmp %eax,%edx
mov %eax,%ecx
cmovge %edx,%ecx
cmp %ecx,%ebx
jle 1228 <func0+0x96>
movslq %eax,%rcx
movslq %edx,%rdi
mov (%r12,%rdi,4),%edi
cmp %edi,0x0(%rbp,%rcx,4)
jg 11f2 <func0+0x60>
add $0x1,%esi
add $0x1,%eax
cmp %esi,%r8d
cmovl %esi,%r8d
jmp 11f8 <func0+0x66>
mov $0x1,%r8d
mov %r8d,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbp, rdi
mov r12, rsi
mov ebx, edx
movsxd r13, edx
lea r14, compare
mov rcx, r14
mov edx, 4
mov rsi, r13
call _qsort
mov rcx, r14
mov edx, 4
mov rsi, r13
mov rdi, r12
call _qsort
cmp ebx, 1
jle short loc_121F
mov edx, 0
mov eax, 1
mov r8d, 1
mov esi, 1
jmp short loc_1200
loc_11EF:
sub esi, 1
add edx, 1
loc_11F5:
cmp eax, edx
mov ecx, edx
cmovge ecx, eax
cmp ebx, ecx
jle short loc_1225
loc_1200:
movsxd rcx, eax
movsxd rdi, edx
mov edi, [r12+rdi*4]
cmp [rbp+rcx*4+0], edi
jg short loc_11EF
add esi, 1
add eax, 1
cmp r8d, esi
cmovl r8d, esi
jmp short loc_11F5
loc_121F:
mov r8d, 1
loc_1225:
mov eax, r8d
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, long long a2, int a3)
{
long long v5; // r13
int v6; // edx
int v7; // eax
int v8; // r8d
int v9; // esi
int v10; // ecx
v5 = a3;
qsort(a1, a3, 4LL, compare);
qsort(a2, v5, 4LL, compare);
if ( a3 <= 1 )
{
return 1;
}
else
{
v6 = 0;
v7 = 1;
v8 = 1;
v9 = 1;
do
{
if ( *(_DWORD *)(a1 + 4LL * v7) > *(_DWORD *)(a2 + 4LL * v6) )
{
--v9;
++v6;
}
else
{
++v9;
++v7;
if ( v8 < v9 )
v8 = v9;
}
v10 = v6;
if ( v7 >= v6 )
v10 = v7;
}
while ( a3 > v10 );
}
return (unsigned int)v8;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV R12,RSI
MOV EBX,EDX
MOVSXD R13,EDX
LEA R14,[0x101189]
MOV RCX,R14
MOV EDX,0x4
MOV RSI,R13
CALL 0x00101070
MOV RCX,R14
MOV EDX,0x4
MOV RSI,R13
MOV RDI,R12
CALL 0x00101070
CMP EBX,0x1
JLE 0x0010121f
MOV EDX,0x0
MOV EAX,0x1
MOV R8D,0x1
MOV ESI,0x1
JMP 0x00101200
LAB_001011ef:
SUB ESI,0x1
ADD EDX,0x1
LAB_001011f5:
CMP EAX,EDX
MOV ECX,EDX
CMOVGE ECX,EAX
CMP EBX,ECX
JLE 0x00101225
LAB_00101200:
MOVSXD RCX,EAX
MOVSXD RDI,EDX
MOV EDI,dword ptr [R12 + RDI*0x4]
CMP dword ptr [RBP + RCX*0x4],EDI
JG 0x001011ef
ADD ESI,0x1
ADD EAX,0x1
CMP R8D,ESI
CMOVL R8D,ESI
JMP 0x001011f5
LAB_0010121f:
MOV R8D,0x1
LAB_00101225:
MOV EAX,R8D
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | int func0(void *param_1,void *param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
qsort(param_1,(long)param_3,4,compare);
qsort(param_2,(long)param_3,4,compare);
if (param_3 < 2) {
iVar5 = 1;
}
else {
iVar3 = 0;
iVar1 = 1;
iVar5 = 1;
iVar4 = 1;
do {
if (*(int *)((long)param_2 + (long)iVar3 * 4) < *(int *)((long)param_1 + (long)iVar1 * 4)) {
iVar4 = iVar4 + -1;
iVar3 = iVar3 + 1;
}
else {
iVar4 = iVar4 + 1;
iVar1 = iVar1 + 1;
if (iVar5 < iVar4) {
iVar5 = iVar4;
}
}
iVar2 = iVar3;
if (iVar3 <= iVar1) {
iVar2 = iVar1;
}
} while (iVar2 < param_3);
}
return iVar5;
} |
7,278 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| int func0(int arr[], int dep[], int n) {
qsort(arr, n, sizeof(int), compare);
qsort(dep, n, sizeof(int), compare);
int plat_needed = 1, result = 1;
int i = 1, j = 0;
while (i < n && j < n) {
if (arr[i] <= dep[j]) {
plat_needed++;
i++;
if (plat_needed > result) {
result = plat_needed;
}
} else {
plat_needed--;
j++;
}
}
return result;
}
| int main() {
int arr1[] = {900, 940, 950, 1100, 1500, 1800};
int dep1[] = {910, 1200, 1120, 1130, 1900, 2000};
assert(func0(arr1, dep1, 6) == 3);
int arr2[] = {100, 200, 300, 400};
int dep2[] = {700, 800, 900, 1000};
assert(func0(arr2, dep2, 4) == 4);
int arr3[] = {5, 6, 7, 8};
int dep3[] = {4, 3, 2, 1};
assert(func0(arr3, dep3, 4) == 1);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
movslq %edx,%r13
lea -0x20(%rip),%rcx
mov $0x4,%edx
push %r12
mov %rsi,%r12
mov %r13,%rsi
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <qsort@plt>
mov $0x4,%edx
mov %r13,%rsi
mov %r12,%rdi
lea -0x4d(%rip),%rcx
callq 1070 <qsort@plt>
cmp $0x1,%r13d
jle 1410 <func0+0xb0>
mov %r13,%rbx
xor %edx,%edx
mov $0x1,%eax
mov $0x1,%r8d
mov $0x1,%esi
jmp 13d8 <func0+0x78>
add $0x1,%esi
add $0x1,%eax
cmp %esi,%r8d
mov %eax,%ecx
cmovl %esi,%r8d
cmp %eax,%edx
cmovge %edx,%ecx
cmp %ecx,%ebx
jle 13f9 <func0+0x99>
movslq %edx,%rdi
movslq %eax,%rcx
mov (%r12,%rdi,4),%edi
cmp %edi,0x0(%rbp,%rcx,4)
jle 13c0 <func0+0x60>
add $0x1,%edx
sub $0x1,%esi
mov %eax,%ecx
cmp %eax,%edx
cmovge %edx,%ecx
cmp %ecx,%ebx
jg 13d8 <func0+0x78>
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
add $0x8,%rsp
mov $0x1,%r8d
pop %rbx
mov %r8d,%eax
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r14
lea r14, compare
push r13
movsxd r13, edx
mov rcx, r14
mov edx, 4
push r12
mov r12, rsi
mov rsi, r13
push rbp
mov rbp, rdi
push rbx
call _qsort
mov rcx, r14
mov edx, 4
mov rsi, r13
mov rdi, r12
call _qsort
cmp r13d, 1
jle short loc_1408
mov rbx, r13
xor edx, edx
mov eax, 1
mov r8d, 1
mov esi, 1
jmp short loc_13D8
loc_13C0:
add esi, 1
add eax, 1
cmp r8d, esi
mov ecx, eax
cmovl r8d, esi
cmp edx, eax
cmovge ecx, edx
cmp ebx, ecx
jle short loc_13F9
loc_13D8:
movsxd rdi, edx
movsxd rcx, eax
mov edi, [r12+rdi*4]
cmp [rbp+rcx*4+0], edi
jle short loc_13C0
add edx, 1
sub esi, 1
mov ecx, eax
cmp edx, eax
cmovge ecx, edx
cmp ebx, ecx
jg short loc_13D8
loc_13F9:
pop rbx
mov eax, r8d
pop rbp
pop r12
pop r13
pop r14
retn
loc_1408:
mov r8d, 1
pop rbx
pop rbp
mov eax, r8d
pop r12
pop r13
pop r14
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // r13
int v5; // edx
int v6; // eax
unsigned int v7; // r8d
int v8; // esi
int v9; // ecx
int v10; // ecx
v3 = a3;
qsort(a1, a3, 4LL, compare);
qsort(a2, v3, 4LL, compare);
if ( (int)v3 <= 1 )
return 1LL;
v5 = 0;
v6 = 1;
v7 = 1;
v8 = 1;
do
{
while ( *(_DWORD *)(a1 + 4LL * v6) > *(_DWORD *)(a2 + 4LL * v5) )
{
++v5;
--v8;
v10 = v6;
if ( v5 >= v6 )
v10 = v5;
if ( (int)v3 <= v10 )
return v7;
}
++v8;
v9 = ++v6;
if ( (int)v7 < v8 )
v7 = v8;
if ( v5 >= v6 )
v9 = v5;
}
while ( (int)v3 > v9 );
return v7;
} | func0:
ENDBR64
PUSH R14
LEA R14,[0x101350]
PUSH R13
MOVSXD R13,EDX
MOV RCX,R14
MOV EDX,0x4
PUSH R12
MOV R12,RSI
MOV RSI,R13
PUSH RBP
MOV RBP,RDI
PUSH RBX
CALL 0x00101070
MOV RCX,R14
MOV EDX,0x4
MOV RSI,R13
MOV RDI,R12
CALL 0x00101070
CMP R13D,0x1
JLE 0x00101408
MOV RBX,R13
XOR EDX,EDX
MOV EAX,0x1
MOV R8D,0x1
MOV ESI,0x1
JMP 0x001013d8
LAB_001013c0:
ADD ESI,0x1
ADD EAX,0x1
CMP R8D,ESI
MOV ECX,EAX
CMOVL R8D,ESI
CMP EDX,EAX
CMOVGE ECX,EDX
CMP EBX,ECX
JLE 0x001013f9
LAB_001013d8:
MOVSXD RDI,EDX
MOVSXD RCX,EAX
MOV EDI,dword ptr [R12 + RDI*0x4]
CMP dword ptr [RBP + RCX*0x4],EDI
JLE 0x001013c0
ADD EDX,0x1
SUB ESI,0x1
MOV ECX,EAX
CMP EDX,EAX
CMOVGE ECX,EDX
CMP EBX,ECX
JG 0x001013d8
LAB_001013f9:
POP RBX
MOV EAX,R8D
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101408:
MOV R8D,0x1
POP RBX
POP RBP
MOV EAX,R8D
POP R12
POP R13
POP R14
RET | int func0(void *param_1,void *param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
qsort(param_1,(long)param_3,4,compare);
qsort(param_2,(long)param_3,4,compare);
if (param_3 < 2) {
return 1;
}
iVar3 = 0;
iVar1 = 1;
iVar5 = 1;
iVar4 = 1;
do {
while (*(int *)((long)param_2 + (long)iVar3 * 4) < *(int *)((long)param_1 + (long)iVar1 * 4)) {
iVar3 = iVar3 + 1;
iVar4 = iVar4 + -1;
iVar2 = iVar1;
if (iVar1 <= iVar3) {
iVar2 = iVar3;
}
if (param_3 <= iVar2) {
return iVar5;
}
}
iVar4 = iVar4 + 1;
iVar1 = iVar1 + 1;
if (iVar5 < iVar4) {
iVar5 = iVar4;
}
iVar2 = iVar1;
if (iVar1 <= iVar3) {
iVar2 = iVar3;
}
} while (iVar2 < param_3);
return iVar5;
} |
7,279 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| int func0(int arr[], int dep[], int n) {
qsort(arr, n, sizeof(int), compare);
qsort(dep, n, sizeof(int), compare);
int plat_needed = 1, result = 1;
int i = 1, j = 0;
while (i < n && j < n) {
if (arr[i] <= dep[j]) {
plat_needed++;
i++;
if (plat_needed > result) {
result = plat_needed;
}
} else {
plat_needed--;
j++;
}
}
return result;
}
| int main() {
int arr1[] = {900, 940, 950, 1100, 1500, 1800};
int dep1[] = {910, 1200, 1120, 1130, 1900, 2000};
assert(func0(arr1, dep1, 6) == 3);
int arr2[] = {100, 200, 300, 400};
int dep2[] = {700, 800, 900, 1000};
assert(func0(arr2, dep2, 4) == 4);
int arr3[] = {5, 6, 7, 8};
int dep3[] = {4, 3, 2, 1};
assert(func0(arr3, dep3, 4) == 1);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
movslq %edx,%r13
lea -0x20(%rip),%rcx
mov $0x4,%edx
push %r12
mov %rsi,%r12
mov %r13,%rsi
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <qsort@plt>
mov $0x4,%edx
mov %r13,%rsi
mov %r12,%rdi
lea -0x4d(%rip),%rcx
callq 1070 <qsort@plt>
mov $0x1,%r8d
cmp $0x1,%r13d
jle 13c0 <func0+0xc0>
mov %r13,%rbx
xor %edx,%edx
mov $0x1,%eax
mov $0x1,%r8d
mov $0x1,%ecx
xor %edi,%edi
mov $0x1,%esi
nopw 0x0(%rax,%rax,1)
mov 0x0(%rbp,%rsi,4),%r9d
cmp %r9d,(%r12,%rdi,4)
jl 13a1 <func0+0xa1>
add $0x1,%ecx
add $0x1,%eax
mov %edx,%esi
cmp %ecx,%r8d
cmovl %ecx,%r8d
cmp %edx,%eax
cmovge %eax,%esi
cmp %esi,%ebx
jle 13c0 <func0+0xc0>
movslq %eax,%rsi
mov 0x0(%rbp,%rsi,4),%r9d
cmp %r9d,(%r12,%rdi,4)
jge 137b <func0+0x7b>
add $0x1,%edx
sub $0x1,%ecx
mov %eax,%edi
cmp %eax,%edx
cmovge %edx,%edi
cmp %edi,%ebx
jle 13c0 <func0+0xc0>
movslq %edx,%rdi
jmp 1370 <func0+0x70>
nopw 0x0(%rax,%rax,1)
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xchg %ax,%ax
| func0:
endbr64
push r14
lea r14, compare
push r13
movsxd r13, edx
mov rcx, r14; compar
mov edx, 4; size
push r12
mov r12, rsi
mov rsi, r13; nmemb
push rbp
mov rbp, rdi
push rbx
call _qsort
mov rcx, r14; compar
mov edx, 4; size
mov rsi, r13; nmemb
mov rdi, r12; base
call _qsort
cmp r13d, 1
jle short loc_13A0
mov rbx, r13
xor edx, edx
mov eax, 1
mov esi, 1
mov ecx, 1
xor r8d, r8d
mov edi, 1
nop dword ptr [rax+00000000h]
loc_1358:
mov r9d, [rbp+rdi*4+0]
cmp [r12+r8*4], r9d
jl short loc_1387
loc_1363:
add ecx, 1
add eax, 1
cmp esi, ecx
mov edi, eax
cmovl esi, ecx
cmp edx, eax
cmovge edi, edx
cmp ebx, edi
jle short loc_13A5
movsxd rdi, eax
mov r9d, [rbp+rdi*4+0]
cmp [r12+r8*4], r9d
jge short loc_1363
loc_1387:
add edx, 1
sub ecx, 1
mov r8d, edx
cmp eax, edx
cmovge r8d, eax
cmp ebx, r8d
jle short loc_13A5
movsxd r8, edx
jmp short loc_1358
loc_13A0:
mov esi, 1
loc_13A5:
pop rbx
mov eax, esi
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(void *a1, void *a2, int a3)
{
size_t v3; // r13
int v6; // edx
int v7; // eax
unsigned int v8; // esi
int v9; // ecx
long long v10; // r8
long long v11; // rdi
int v12; // edi
int v13; // r8d
v3 = a3;
qsort(a1, a3, 4uLL, compare);
qsort(a2, v3, 4uLL, compare);
if ( (int)v3 <= 1 )
{
return 1;
}
else
{
v6 = 0;
v7 = 1;
v8 = 1;
v9 = 1;
v10 = 0LL;
v11 = 1LL;
while ( *((_DWORD *)a2 + v10) < *((_DWORD *)a1 + v11) )
{
LABEL_10:
++v6;
--v9;
v13 = v6;
if ( v7 >= v6 )
v13 = v7;
if ( (int)v3 <= v13 )
return v8;
v10 = v6;
}
while ( 1 )
{
++v9;
v12 = ++v7;
if ( (int)v8 < v9 )
v8 = v9;
if ( v6 >= v7 )
v12 = v6;
if ( (int)v3 <= v12 )
break;
v11 = v7;
if ( *((_DWORD *)a2 + v10) < *((_DWORD *)a1 + v7) )
goto LABEL_10;
}
}
return v8;
} | func0:
ENDBR64
PUSH R14
LEA R14,[0x1012e0]
PUSH R13
MOVSXD R13,EDX
MOV RCX,R14
MOV EDX,0x4
PUSH R12
MOV R12,RSI
MOV RSI,R13
PUSH RBP
MOV RBP,RDI
PUSH RBX
CALL 0x00101070
MOV RCX,R14
MOV EDX,0x4
MOV RSI,R13
MOV RDI,R12
CALL 0x00101070
CMP R13D,0x1
JLE 0x001013a0
MOV RBX,R13
XOR EDX,EDX
MOV EAX,0x1
MOV ESI,0x1
MOV ECX,0x1
XOR R8D,R8D
MOV EDI,0x1
NOP dword ptr [RAX]
LAB_00101358:
MOV R9D,dword ptr [RBP + RDI*0x4]
CMP dword ptr [R12 + R8*0x4],R9D
JL 0x00101387
LAB_00101363:
ADD ECX,0x1
ADD EAX,0x1
CMP ESI,ECX
MOV EDI,EAX
CMOVL ESI,ECX
CMP EDX,EAX
CMOVGE EDI,EDX
CMP EBX,EDI
JLE 0x001013a5
MOVSXD RDI,EAX
MOV R9D,dword ptr [RBP + RDI*0x4]
CMP dword ptr [R12 + R8*0x4],R9D
JGE 0x00101363
LAB_00101387:
ADD EDX,0x1
SUB ECX,0x1
MOV R8D,EDX
CMP EAX,EDX
CMOVGE R8D,EAX
CMP EBX,R8D
JLE 0x001013a5
MOVSXD R8,EDX
JMP 0x00101358
LAB_001013a0:
MOV ESI,0x1
LAB_001013a5:
POP RBX
MOV EAX,ESI
POP RBP
POP R12
POP R13
POP R14
RET | int func0(void *param_1,void *param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
long lVar6;
long lVar7;
qsort(param_1,(long)param_3,4,compare);
qsort(param_2,(long)param_3,4,compare);
if (param_3 < 2) {
iVar4 = 1;
}
else {
iVar3 = 0;
iVar1 = 1;
iVar4 = 1;
iVar2 = 1;
lVar7 = 0;
lVar6 = 1;
while( true ) {
if (*(int *)((long)param_1 + lVar6 * 4) <= *(int *)((long)param_2 + lVar7 * 4)) {
do {
iVar2 = iVar2 + 1;
iVar1 = iVar1 + 1;
if (iVar4 < iVar2) {
iVar4 = iVar2;
}
iVar5 = iVar1;
if (iVar1 <= iVar3) {
iVar5 = iVar3;
}
if (param_3 <= iVar5) {
return iVar4;
}
lVar6 = (long)iVar1;
} while (*(int *)((long)param_1 + lVar6 * 4) <= *(int *)((long)param_2 + lVar7 * 4));
}
iVar3 = iVar3 + 1;
iVar2 = iVar2 + -1;
iVar5 = iVar3;
if (iVar3 <= iVar1) {
iVar5 = iVar1;
}
if (param_3 <= iVar5) break;
lVar7 = (long)iVar3;
}
}
return iVar4;
} |
7,280 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare_arrays(int* arr1, int* arr2, int len) {
for (int i = 0; i < len; i++) {
if (arr1[i] != arr2[i]) {
return 0;
}
}
return 1;
}
| int* func0(int* xs, int length) {
int* copy = malloc(length * sizeof(int));
for (int i = 0; i < length; i++) {
copy[i] = xs[i];
}
return copy;
}
| int main() {
int xs1[] = {1, 2, 3};
int* result1 = func0(xs1, 3);
assert(compare_arrays(result1, xs1, 3));
int xs2[] = {4, 8, 2, 10, 15, 18};
int* result2 = func0(xs2, 6);
assert(compare_arrays(result2, xs2, 6));
int xs3[] = {4, 5, 6};
int* result3 = func0(xs3, 3);
assert(compare_arrays(result3, xs3, 3));
free(result1);
free(result2);
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 -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1271 <func0+0x62>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
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 1240 <func0+0x31>
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 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_1271
loc_1240:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
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_1271:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_1240
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v4; // [rsp+18h] [rbp-8h]
v4 = malloc(4LL * a2);
for ( i = 0; i < a2; ++i )
v4[i] = *(_DWORD *)(4LL * i + a1);
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
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 0x00101271
LAB_00101240:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
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_00101271:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101240
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2)
{
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 *)(param_1 + (long)local_14 * 4);
}
return pvVar1;
} |
7,281 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare_arrays(int* arr1, int* arr2, int len) {
for (int i = 0; i < len; i++) {
if (arr1[i] != arr2[i]) {
return 0;
}
}
return 1;
}
| int* func0(int* xs, int length) {
int* copy = malloc(length * sizeof(int));
for (int i = 0; i < length; i++) {
copy[i] = xs[i];
}
return copy;
}
| int main() {
int xs1[] = {1, 2, 3};
int* result1 = func0(xs1, 3);
assert(compare_arrays(result1, xs1, 3));
int xs2[] = {4, 8, 2, 10, 15, 18};
int* result2 = func0(xs2, 6);
assert(compare_arrays(result2, xs2, 6));
int xs3[] = {4, 5, 6};
int* result3 = func0(xs3, 3);
assert(compare_arrays(result3, xs3, 3));
free(result1);
free(result2);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 121a <func0+0x39>
lea -0x1(%rbp),%esi
mov $0x0,%edx
mov (%rbx,%rdx,4),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rsi,%rcx
jne 1208 <func0+0x27>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, esi
movsxd rdi, esi
shl rdi, 2
call _malloc
test ebx, ebx
jle short loc_1211
mov esi, ebx
mov edx, 0
loc_1201:
mov ecx, [rbp+rdx*4+0]
mov [rax+rdx*4], ecx
add rdx, 1
cmp rdx, rsi
jnz short loc_1201
loc_1211:
add rsp, 8
pop rbx
pop rbp
retn | long long func0(long long a1, int a2)
{
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 *)(a1 + 4 * i);
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,ESI
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x00101211
MOV ESI,EBX
MOV EDX,0x0
LAB_00101201:
MOV ECX,dword ptr [RBP + RDX*0x4]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP RDX,RSI
JNZ 0x00101201
LAB_00101211:
ADD RSP,0x8
POP RBX
POP RBP
RET | void func0(long param_1,uint param_2)
{
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 *)(param_1 + uVar2 * 4);
uVar2 = uVar2 + 1;
} while (uVar2 != param_2);
}
return;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.