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,482 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
| bool func0(const char* sentence, const char* word) {
char* token;
char* toFree;
char* sentenceCopy = strdup(sentence);
if (!sentenceCopy) return false;
toFree = sentenceCopy;
token = strtok(sentenceCopy, " ");
while (token != NULL) {
if (strcmp(token, word) == 0) {
free(toFree);
return true;
}
token = strtok(NULL, " ");
}
free(toFree);
return false;
}
| int main() {
assert(func0("machine learning", "machine") == true);
assert(func0("easy", "fun") == false);
assert(func0("python language", "code") == false);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rsi,%rbx
callq 10d0 <strdup@plt>
test %rax,%rax
je 130f <func0+0x7f>
mov %rax,%rdi
lea 0xd55(%rip),%rsi
mov %rax,%rbp
callq 10c0 <strtok@plt>
mov %rax,%rdi
test %rax,%rax
je 1300 <func0+0x70>
lea 0xd3e(%rip),%r12
jmp 12e2 <func0+0x52>
nopl 0x0(%rax,%rax,1)
xor %edi,%edi
mov %r12,%rsi
callq 10c0 <strtok@plt>
mov %rax,%rdi
test %rax,%rax
je 1300 <func0+0x70>
mov %rbx,%rsi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 12d0 <func0+0x40>
mov %rbp,%rdi
callq 1090 <free@plt>
pop %rbx
mov $0x1,%eax
pop %rbp
pop %r12
retq
mov %rbp,%rdi
callq 1090 <free@plt>
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
retq
xor %eax,%eax
jmp 130a <func0+0x7a>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rsi
call _strdup
test rax, rax
jz short loc_130F
lea rbp, unk_2004
mov rdi, rax
mov r12, rax
mov rsi, rbp
call _strtok
mov rdi, rax
test rax, rax
jnz short loc_12DA
jmp short loc_1300
loc_12C8:
xor edi, edi
mov rsi, rbp
call _strtok
mov rdi, rax
test rax, rax
jz short loc_1300
loc_12DA:
mov rsi, rbx
call _strcmp
test eax, eax
jnz short loc_12C8
mov rdi, r12
call _free
pop rbx
mov eax, 1
pop rbp
pop r12
retn
loc_1300:
mov rdi, r12
call _free
xor eax, eax
loc_130A:
pop rbx
pop rbp
pop r12
retn
loc_130F:
xor eax, eax
jmp short loc_130A | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // r12
long long v4; // rdi
v2 = strdup();
if ( !v2 )
return 0LL;
v3 = v2;
v4 = strtok(v2, &unk_2004);
if ( v4 )
{
while ( (unsigned int)strcmp(v4, a2) )
{
v4 = strtok(0LL, &unk_2004);
if ( !v4 )
goto LABEL_7;
}
free(v3);
return 1LL;
}
else
{
LABEL_7:
free(v3);
return 0LL;
}
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
CALL 0x001010d0
TEST RAX,RAX
JZ 0x0010130f
LEA RBP,[0x102004]
MOV RDI,RAX
MOV R12,RAX
MOV RSI,RBP
CALL 0x001010c0
MOV RDI,RAX
TEST RAX,RAX
JNZ 0x001012da
JMP 0x00101300
LAB_001012c8:
XOR EDI,EDI
MOV RSI,RBP
CALL 0x001010c0
MOV RDI,RAX
TEST RAX,RAX
JZ 0x00101300
LAB_001012da:
MOV RSI,RBX
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x001012c8
MOV RDI,R12
CALL 0x00101090
POP RBX
MOV EAX,0x1
POP RBP
POP R12
RET
LAB_00101300:
MOV RDI,R12
CALL 0x00101090
XOR EAX,EAX
LAB_0010130a:
POP RBX
POP RBP
POP R12
RET
LAB_0010130f:
XOR EAX,EAX
JMP 0x0010130a | int8 func0(char *param_1,char *param_2)
{
int iVar1;
char *__s;
char *__s1;
__s = strdup(param_1);
if (__s != (char *)0x0) {
__s1 = strtok(__s," ");
while (__s1 != (char *)0x0) {
iVar1 = strcmp(__s1,param_2);
if (iVar1 == 0) {
free(__s);
return 1;
}
__s1 = strtok((char *)0x0," ");
}
free(__s);
}
return 0;
} |
7,483 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
| bool func0(const char* sentence, const char* word) {
char* token;
char* toFree;
char* sentenceCopy = strdup(sentence);
if (!sentenceCopy) return false;
toFree = sentenceCopy;
token = strtok(sentenceCopy, " ");
while (token != NULL) {
if (strcmp(token, word) == 0) {
free(toFree);
return true;
}
token = strtok(NULL, " ");
}
free(toFree);
return false;
}
| int main() {
assert(func0("machine learning", "machine") == true);
assert(func0("easy", "fun") == false);
assert(func0("python language", "code") == false);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rsi,%rbx
callq 10d0 <strdup@plt>
test %rax,%rax
je 130f <func0+0x7f>
mov %rax,%rdi
lea 0xd55(%rip),%rsi
mov %rax,%rbp
callq 10c0 <strtok@plt>
mov %rax,%rdi
test %rax,%rax
je 1300 <func0+0x70>
lea 0xd3e(%rip),%r12
jmp 12e2 <func0+0x52>
nopl 0x0(%rax,%rax,1)
xor %edi,%edi
mov %r12,%rsi
callq 10c0 <strtok@plt>
mov %rax,%rdi
test %rax,%rax
je 1300 <func0+0x70>
mov %rbx,%rsi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 12d0 <func0+0x40>
mov %rbp,%rdi
callq 1090 <free@plt>
pop %rbx
mov $0x1,%eax
pop %rbp
pop %r12
retq
mov %rbp,%rdi
callq 1090 <free@plt>
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
retq
xor %eax,%eax
jmp 130a <func0+0x7a>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rsi
call _strdup
test rax, rax
jz short loc_1308
lea rbp, delim; " "
mov rdi, rax; s
mov r12, rax
mov rsi, rbp; delim
call _strtok
mov rdi, rax
test rax, rax
jnz short loc_12DA
jmp short loc_1300
loc_12C8:
xor edi, edi; s
mov rsi, rbp; delim
call _strtok
mov rdi, rax; s1
test rax, rax
jz short loc_1300
loc_12DA:
mov rsi, rbx; s2
call _strcmp
test eax, eax
jnz short loc_12C8
mov rdi, r12; ptr
call _free
pop rbx
mov eax, 1
pop rbp
pop r12
retn
loc_1300:
mov rdi, r12; ptr
call _free
loc_1308:
pop rbx
xor eax, eax
pop rbp
pop r12
retn | long long func0(const char *a1, const char *a2)
{
char *v2; // rax
char *v3; // r12
char *v4; // rdi
v2 = strdup(a1);
if ( !v2 )
return 0LL;
v3 = v2;
v4 = strtok(v2, " ");
if ( !v4 )
{
LABEL_7:
free(v3);
return 0LL;
}
while ( strcmp(v4, a2) )
{
v4 = strtok(0LL, " ");
if ( !v4 )
goto LABEL_7;
}
free(v3);
return 1LL;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
CALL 0x001010d0
TEST RAX,RAX
JZ 0x00101308
LEA RBP,[0x102004]
MOV RDI,RAX
MOV R12,RAX
MOV RSI,RBP
CALL 0x001010c0
MOV RDI,RAX
TEST RAX,RAX
JNZ 0x001012da
JMP 0x00101300
LAB_001012c8:
XOR EDI,EDI
MOV RSI,RBP
CALL 0x001010c0
MOV RDI,RAX
TEST RAX,RAX
JZ 0x00101300
LAB_001012da:
MOV RSI,RBX
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x001012c8
MOV RDI,R12
CALL 0x00101090
POP RBX
MOV EAX,0x1
POP RBP
POP R12
RET
LAB_00101300:
MOV RDI,R12
CALL 0x00101090
LAB_00101308:
POP RBX
XOR EAX,EAX
POP RBP
POP R12
RET | int8 func0(char *param_1,char *param_2)
{
int iVar1;
char *__s;
char *__s1;
__s = strdup(param_1);
if (__s != (char *)0x0) {
__s1 = strtok(__s," ");
while (__s1 != (char *)0x0) {
iVar1 = strcmp(__s1,param_2);
if (iVar1 == 0) {
free(__s);
return 1;
}
__s1 = strtok((char *)0x0," ");
}
free(__s);
}
return 0;
} |
7,484 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int* func0(const int numbers[], int length, int n, int* result_size) {
int* result = malloc(length * sizeof(int));
*result_size = 0;
int count = 1;
int current = numbers[0];
for (int i = 1; i < length; i++) {
if (numbers[i] == current) {
count++;
} else {
if (count == n) {
result[*result_size] = current;
(*result_size)++;
}
current = numbers[i];
count = 1;
}
}
if (count == n) {
result[*result_size] = current;
(*result_size)++;
}
return result;
}
| int main() {
// Test Case 1
int numbers1[] = {1, 1, 3, 4, 4, 5, 6, 7};
int result1_size = 0;
int* result1 = func0(numbers1, 8, 2, &result1_size);
int expected1[] = {1, 4};
assert(result1_size == 2 && result1[0] == expected1[0] && result1[1] == expected1[1]);
// Test Case 2
int numbers2[] = {0, 1, 2, 3, 4, 4, 4, 4, 5, 7};
int result2_size = 0;
int* result2 = func0(numbers2, 10, 4, &result2_size);
int expected2[] = {4};
assert(result2_size == 1 && result2[0] == expected2[0]);
// Test Case 3
int numbers3[] = {0, 0, 0, 0, 0};
int result3_size = 0;
int* result3 = func0(numbers3, 5, 5, &result3_size);
int expected3[] = {0};
assert(result3_size == 1 && result3[0] == expected3[0]);
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %rcx,-0x38(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x38(%rbp),%rax
movl $0x0,(%rax)
movl $0x1,-0x14(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 1293 <func0+0xca>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x10(%rbp)
jne 123c <func0+0x73>
addl $0x1,-0x14(%rbp)
jmp 128f <func0+0xc6>
mov -0x14(%rbp),%eax
cmp -0x30(%rbp),%eax
jne 126f <func0+0xa6>
mov -0x38(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x10(%rbp),%eax
mov %eax,(%rdx)
mov -0x38(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x38(%rbp),%rax
mov %edx,(%rax)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
movl $0x1,-0x14(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 121b <func0+0x52>
mov -0x14(%rbp),%eax
cmp -0x30(%rbp),%eax
jne 12ce <func0+0x105>
mov -0x38(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x10(%rbp),%eax
mov %eax,(%rdx)
mov -0x38(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x38(%rbp),%rax
mov %edx,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov [rbp+var_38], rcx
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov [rbp+var_14], 1
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_10], eax
mov [rbp+var_C], 1
jmp short loc_1293
loc_121B:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_10], eax
jnz short loc_123C
add [rbp+var_14], 1
jmp short loc_128F
loc_123C:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_30]
jnz short loc_126F
mov rax, [rbp+var_38]
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_10]
mov [rdx], eax
mov rax, [rbp+var_38]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_38]
mov [rax], edx
loc_126F:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_10], eax
mov [rbp+var_14], 1
loc_128F:
add [rbp+var_C], 1
loc_1293:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_2C]
jl short loc_121B
mov eax, [rbp+var_14]
cmp eax, [rbp+var_30]
jnz short loc_12CE
mov rax, [rbp+var_38]
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_10]
mov [rdx], eax
mov rax, [rbp+var_38]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_38]
mov [rax], edx
loc_12CE:
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(int *a1, int a2, int a3, _DWORD *a4)
{
int v7; // [rsp+2Ch] [rbp-14h]
int v8; // [rsp+30h] [rbp-10h]
int i; // [rsp+34h] [rbp-Ch]
_DWORD *v10; // [rsp+38h] [rbp-8h]
v10 = malloc(4LL * a2);
*a4 = 0;
v7 = 1;
v8 = *a1;
for ( i = 1; i < a2; ++i )
{
if ( v8 == a1[i] )
{
++v7;
}
else
{
if ( v7 == a3 )
v10[(*a4)++] = v8;
v8 = a1[i];
v7 = 1;
}
}
if ( v7 == a3 )
v10[(*a4)++] = v8;
return v10;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV qword ptr [RBP + -0x38],RCX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x14],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
MOV dword ptr [RBP + -0xc],0x1
JMP 0x00101293
LAB_0010121b:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x10],EAX
JNZ 0x0010123c
ADD dword ptr [RBP + -0x14],0x1
JMP 0x0010128f
LAB_0010123c:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x30]
JNZ 0x0010126f
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],EDX
LAB_0010126f:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
MOV dword ptr [RBP + -0x14],0x1
LAB_0010128f:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101293:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x0010121b
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x30]
JNZ 0x001012ce
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],EDX
LAB_001012ce:
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(int *param_1,int param_2,int param_3,int *param_4)
{
void *pvVar1;
int local_1c;
int local_18;
int local_14;
pvVar1 = malloc((long)param_2 << 2);
*param_4 = 0;
local_1c = 1;
local_18 = *param_1;
for (local_14 = 1; local_14 < param_2; local_14 = local_14 + 1) {
if (local_18 == param_1[local_14]) {
local_1c = local_1c + 1;
}
else {
if (local_1c == param_3) {
*(int *)((long)*param_4 * 4 + (long)pvVar1) = local_18;
*param_4 = *param_4 + 1;
}
local_18 = param_1[local_14];
local_1c = 1;
}
}
if (local_1c == param_3) {
*(int *)((long)*param_4 * 4 + (long)pvVar1) = local_18;
*param_4 = *param_4 + 1;
}
return pvVar1;
} |
7,485 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int* func0(const int numbers[], int length, int n, int* result_size) {
int* result = malloc(length * sizeof(int));
*result_size = 0;
int count = 1;
int current = numbers[0];
for (int i = 1; i < length; i++) {
if (numbers[i] == current) {
count++;
} else {
if (count == n) {
result[*result_size] = current;
(*result_size)++;
}
current = numbers[i];
count = 1;
}
}
if (count == n) {
result[*result_size] = current;
(*result_size)++;
}
return result;
}
| int main() {
// Test Case 1
int numbers1[] = {1, 1, 3, 4, 4, 5, 6, 7};
int result1_size = 0;
int* result1 = func0(numbers1, 8, 2, &result1_size);
int expected1[] = {1, 4};
assert(result1_size == 2 && result1[0] == expected1[0] && result1[1] == expected1[1]);
// Test Case 2
int numbers2[] = {0, 1, 2, 3, 4, 4, 4, 4, 5, 7};
int result2_size = 0;
int* result2 = func0(numbers2, 10, 4, &result2_size);
int expected2[] = {4};
assert(result2_size == 1 && result2[0] == expected2[0]);
// Test Case 3
int numbers3[] = {0, 0, 0, 0, 0};
int result3_size = 0;
int* result3 = func0(numbers3, 5, 5, &result3_size);
int expected3[] = {0};
assert(result3_size == 1 && result3[0] == expected3[0]);
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%r12d
mov %edx,%ebx
mov %rcx,%rbp
movslq %esi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
movl $0x0,0x0(%rbp)
mov 0x0(%r13),%esi
cmp $0x1,%r12d
jle 1246 <func0+0x7d>
lea 0x4(%r13),%rdx
lea -0x2(%r12),%ecx
lea 0x8(%r13,%rcx,4),%r8
mov $0x1,%ecx
jmp 1229 <func0+0x60>
add $0x1,%ecx
jmp 1220 <func0+0x57>
mov (%rdi),%esi
mov $0x1,%ecx
add $0x4,%rdx
cmp %r8,%rdx
je 124b <func0+0x82>
mov %rdx,%rdi
cmp %esi,(%rdx)
je 1214 <func0+0x4b>
cmp %ecx,%ebx
jne 1219 <func0+0x50>
mov 0x0(%rbp),%ecx
movslq %ecx,%r9
mov %esi,(%rax,%r9,4)
add $0x1,%ecx
mov %ecx,0x0(%rbp)
jmp 1219 <func0+0x50>
mov $0x1,%ecx
cmp %ecx,%ebx
je 125a <func0+0x91>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov 0x0(%rbp),%edx
movslq %edx,%rcx
mov %esi,(%rax,%rcx,4)
add $0x1,%edx
mov %edx,0x0(%rbp)
jmp 124f <func0+0x86>
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rdi
mov r12d, esi
mov ebx, edx
mov rbp, rcx
movsxd rdi, esi
shl rdi, 2
call _malloc
mov r8, rax
mov dword ptr [rbp+0], 0
mov ecx, [r13+0]
cmp r12d, 1
jle short loc_1249
lea rax, [r13+4]
lea edx, [r12-2]
lea rdi, [r13+rdx*4+8]
mov edx, 1
jmp short loc_122C
loc_1217:
add edx, 1
jmp short loc_1223
loc_121C:
mov ecx, [rsi]
mov edx, 1
loc_1223:
add rax, 4
cmp rax, rdi
jz short loc_124E
loc_122C:
mov rsi, rax
cmp [rax], ecx
jz short loc_1217
cmp ebx, edx
jnz short loc_121C
mov edx, [rbp+0]
movsxd r9, edx
mov [r8+r9*4], ecx
add edx, 1
mov [rbp+0], edx
jmp short loc_121C
loc_1249:
mov edx, 1
loc_124E:
cmp ebx, edx
jz short loc_1260
loc_1252:
mov rax, r8
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1260:
mov eax, [rbp+0]
movsxd rdx, eax
mov [r8+rdx*4], ecx
add eax, 1
mov [rbp+0], eax
jmp short loc_1252 | long long func0(int *a1, int a2, int a3, int *a4)
{
long long v6; // r8
int v7; // ecx
int *v8; // rax
int v9; // edx
int v10; // edx
int v12; // eax
v6 = malloc(4LL * a2);
*a4 = 0;
v7 = *a1;
if ( a2 <= 1 )
{
v9 = 1;
}
else
{
v8 = a1 + 1;
v9 = 1;
do
{
if ( *v8 == v7 )
{
++v9;
}
else
{
if ( a3 == v9 )
{
v10 = *a4;
*(_DWORD *)(v6 + 4LL * *a4) = v7;
*a4 = v10 + 1;
}
v7 = *v8;
v9 = 1;
}
++v8;
}
while ( v8 != &a1[a2 - 2 + 2] );
}
if ( a3 == v9 )
{
v12 = *a4;
*(_DWORD *)(v6 + 4LL * *a4) = v7;
*a4 = v12 + 1;
}
return v6;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV R12D,ESI
MOV EBX,EDX
MOV RBP,RCX
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010d0
MOV R8,RAX
MOV dword ptr [RBP],0x0
MOV ECX,dword ptr [R13]
CMP R12D,0x1
JLE 0x00101249
LEA RAX,[R13 + 0x4]
LEA EDX,[R12 + -0x2]
LEA RDI,[R13 + RDX*0x4 + 0x8]
MOV EDX,0x1
JMP 0x0010122c
LAB_00101217:
ADD EDX,0x1
JMP 0x00101223
LAB_0010121c:
MOV ECX,dword ptr [RSI]
MOV EDX,0x1
LAB_00101223:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x0010124e
LAB_0010122c:
MOV RSI,RAX
CMP dword ptr [RAX],ECX
JZ 0x00101217
CMP EBX,EDX
JNZ 0x0010121c
MOV EDX,dword ptr [RBP]
MOVSXD R9,EDX
MOV dword ptr [R8 + R9*0x4],ECX
ADD EDX,0x1
MOV dword ptr [RBP],EDX
JMP 0x0010121c
LAB_00101249:
MOV EDX,0x1
LAB_0010124e:
CMP EBX,EDX
JZ 0x00101260
LAB_00101252:
MOV RAX,R8
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101260:
MOV EAX,dword ptr [RBP]
MOVSXD RDX,EAX
MOV dword ptr [R8 + RDX*0x4],ECX
ADD EAX,0x1
MOV dword ptr [RBP],EAX
JMP 0x00101252 | void * func0(int *param_1,int param_2,int param_3,int *param_4)
{
void *pvVar1;
int *piVar2;
int iVar3;
int iVar4;
pvVar1 = malloc((long)param_2 << 2);
*param_4 = 0;
iVar3 = *param_1;
if (param_2 < 2) {
iVar4 = 1;
}
else {
piVar2 = param_1 + 1;
iVar4 = 1;
do {
if (*piVar2 == iVar3) {
iVar4 = iVar4 + 1;
}
else {
if (param_3 == iVar4) {
iVar4 = *param_4;
*(int *)((long)pvVar1 + (long)iVar4 * 4) = iVar3;
*param_4 = iVar4 + 1;
}
iVar3 = *piVar2;
iVar4 = 1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(param_2 - 2) + 2);
}
if (param_3 == iVar4) {
iVar4 = *param_4;
*(int *)((long)pvVar1 + (long)iVar4 * 4) = iVar3;
*param_4 = iVar4 + 1;
}
return pvVar1;
} |
7,486 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int* func0(const int numbers[], int length, int n, int* result_size) {
int* result = malloc(length * sizeof(int));
*result_size = 0;
int count = 1;
int current = numbers[0];
for (int i = 1; i < length; i++) {
if (numbers[i] == current) {
count++;
} else {
if (count == n) {
result[*result_size] = current;
(*result_size)++;
}
current = numbers[i];
count = 1;
}
}
if (count == n) {
result[*result_size] = current;
(*result_size)++;
}
return result;
}
| int main() {
// Test Case 1
int numbers1[] = {1, 1, 3, 4, 4, 5, 6, 7};
int result1_size = 0;
int* result1 = func0(numbers1, 8, 2, &result1_size);
int expected1[] = {1, 4};
assert(result1_size == 2 && result1[0] == expected1[0] && result1[1] == expected1[1]);
// Test Case 2
int numbers2[] = {0, 1, 2, 3, 4, 4, 4, 4, 5, 7};
int result2_size = 0;
int* result2 = func0(numbers2, 10, 4, &result2_size);
int expected2[] = {4};
assert(result2_size == 1 && result2[0] == expected2[0]);
// Test Case 3
int numbers3[] = {0, 0, 0, 0, 0};
int result3_size = 0;
int* result3 = func0(numbers3, 5, 5, &result3_size);
int expected3[] = {0};
assert(result3_size == 1 && result3[0] == expected3[0]);
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %rdi,%r13
movslq %esi,%rdi
push %r12
mov %rdi,%r12
shl $0x2,%rdi
push %rbp
mov %rcx,%rbp
push %rbx
mov %edx,%ebx
sub $0x8,%rsp
callq 10d0 <malloc@plt>
movl $0x0,0x0(%rbp)
mov 0x0(%r13),%r9d
cmp $0x1,%r12d
jle 1490 <func0+0xb0>
lea -0x2(%r12),%edx
lea 0x4(%r13),%rdi
mov $0x1,%r8d
lea 0x8(%r13,%rdx,4),%r10
jmp 145a <func0+0x7a>
nopl 0x0(%rax)
cmp %r8d,%ebx
jne 1448 <func0+0x68>
movslq 0x0(%rbp),%rcx
mov %rcx,%rdx
mov %r9d,(%rax,%rcx,4)
add $0x1,%edx
mov %edx,0x0(%rbp)
mov (%rdi),%esi
add $0x4,%rdi
mov %esi,%r9d
mov $0x1,%r8d
cmp %r10,%rdi
je 146e <func0+0x8e>
mov (%rdi),%esi
cmp %r9d,%esi
jne 1430 <func0+0x50>
add $0x4,%rdi
add $0x1,%r8d
cmp %r10,%rdi
jne 145a <func0+0x7a>
cmp %r8d,%ebx
jne 1484 <func0+0xa4>
movslq 0x0(%rbp),%rcx
mov %rcx,%rdx
mov %r9d,(%rax,%rcx,4)
add $0x1,%edx
mov %edx,0x0(%rbp)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x1,%r8d
jmp 146e <func0+0x8e>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
mov r13, rdi
movsxd rdi, esi
push r12
mov r12, rdi
shl rdi, 2
push rbp
mov rbp, rcx
push rbx
mov ebx, edx
sub rsp, 8
call _malloc
mov dword ptr [rbp+0], 0
mov esi, [r13+0]
mov r8, rax
cmp r12d, 1
jle short loc_1480
lea edx, [r12-2]
lea rax, [r13+4]
mov ecx, 1
lea rdi, [r13+rdx*4+8]
jmp short loc_1447
loc_1420:
cmp ebx, ecx
jnz short loc_1437
movsxd rcx, dword ptr [rbp+0]
mov rdx, rcx
mov [r8+rcx*4], esi
add edx, 1
mov [rbp+0], edx
mov edx, [rax]
loc_1437:
add rax, 4
mov esi, edx
mov ecx, 1
cmp rax, rdi
jz short loc_1459
loc_1447:
mov edx, [rax]
cmp edx, esi
jnz short loc_1420
add rax, 4
add ecx, 1
cmp rax, rdi
jnz short loc_1447
loc_1459:
cmp ebx, ecx
jnz short loc_146E
movsxd rdx, dword ptr [rbp+0]
mov rax, rdx
mov [r8+rdx*4], esi
add eax, 1
mov [rbp+0], eax
loc_146E:
add rsp, 8
mov rax, r8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1480:
mov ecx, 1
jmp short loc_1459 | long long func0(int *a1, int a2, int a3, int *a4)
{
long long v7; // rax
int v8; // esi
long long v9; // r8
int *v10; // rax
int v11; // ecx
long long v12; // rdi
int v13; // edx
int v14; // edx
int v15; // eax
v7 = malloc(4LL * a2);
*a4 = 0;
v8 = *a1;
v9 = v7;
if ( a2 <= 1 )
{
v11 = 1;
}
else
{
v10 = a1 + 1;
v11 = 1;
v12 = (long long)&a1[a2 - 2 + 2];
do
{
while ( 1 )
{
v14 = *v10;
if ( *v10 != v8 )
break;
++v10;
++v11;
if ( v10 == (int *)v12 )
goto LABEL_8;
}
if ( a3 == v11 )
{
v13 = *a4;
*(_DWORD *)(v9 + 4LL * *a4) = v8;
*a4 = v13 + 1;
v14 = *v10;
}
++v10;
v8 = v14;
v11 = 1;
}
while ( v10 != (int *)v12 );
}
LABEL_8:
if ( a3 == v11 )
{
v15 = *a4;
*(_DWORD *)(v9 + 4LL * *a4) = v8;
*a4 = v15 + 1;
}
return v9;
} | func0:
ENDBR64
PUSH R13
MOV R13,RDI
MOVSXD RDI,ESI
PUSH R12
MOV R12,RDI
SHL RDI,0x2
PUSH RBP
MOV RBP,RCX
PUSH RBX
MOV EBX,EDX
SUB RSP,0x8
CALL 0x001010d0
MOV dword ptr [RBP],0x0
MOV ESI,dword ptr [R13]
MOV R8,RAX
CMP R12D,0x1
JLE 0x00101480
LEA EDX,[R12 + -0x2]
LEA RAX,[R13 + 0x4]
MOV ECX,0x1
LEA RDI,[R13 + RDX*0x4 + 0x8]
JMP 0x00101447
LAB_00101420:
CMP EBX,ECX
JNZ 0x00101437
MOVSXD RCX,dword ptr [RBP]
MOV RDX,RCX
MOV dword ptr [R8 + RCX*0x4],ESI
ADD EDX,0x1
MOV dword ptr [RBP],EDX
MOV EDX,dword ptr [RAX]
LAB_00101437:
ADD RAX,0x4
MOV ESI,EDX
MOV ECX,0x1
CMP RAX,RDI
JZ 0x00101459
LAB_00101447:
MOV EDX,dword ptr [RAX]
CMP EDX,ESI
JNZ 0x00101420
ADD RAX,0x4
ADD ECX,0x1
CMP RAX,RDI
JNZ 0x00101447
LAB_00101459:
CMP EBX,ECX
JNZ 0x0010146e
MOVSXD RDX,dword ptr [RBP]
MOV RAX,RDX
MOV dword ptr [R8 + RDX*0x4],ESI
ADD EAX,0x1
MOV dword ptr [RBP],EAX
LAB_0010146e:
ADD RSP,0x8
MOV RAX,R8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101480:
MOV ECX,0x1
JMP 0x00101459 | void * func0(int *param_1,int param_2,int param_3,int *param_4)
{
int iVar1;
void *pvVar2;
int *piVar3;
int iVar4;
int iVar5;
pvVar2 = malloc((long)param_2 << 2);
*param_4 = 0;
iVar5 = *param_1;
if (param_2 < 2) {
iVar4 = 1;
}
else {
piVar3 = param_1 + 1;
iVar4 = 1;
do {
while (*piVar3 == iVar5) {
piVar3 = piVar3 + 1;
iVar4 = iVar4 + 1;
if (piVar3 == param_1 + (ulong)(param_2 - 2) + 2) goto LAB_00101459;
}
iVar1 = *piVar3;
if (param_3 == iVar4) {
iVar4 = *param_4;
*(int *)((long)pvVar2 + (long)iVar4 * 4) = iVar5;
*param_4 = iVar4 + 1;
iVar1 = *piVar3;
}
iVar5 = iVar1;
piVar3 = piVar3 + 1;
iVar4 = 1;
} while (piVar3 != param_1 + (ulong)(param_2 - 2) + 2);
}
LAB_00101459:
if (param_3 == iVar4) {
iVar4 = *param_4;
*(int *)((long)pvVar2 + (long)iVar4 * 4) = iVar5;
*param_4 = iVar4 + 1;
}
return pvVar2;
} |
7,487 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int* func0(const int numbers[], int length, int n, int* result_size) {
int* result = malloc(length * sizeof(int));
*result_size = 0;
int count = 1;
int current = numbers[0];
for (int i = 1; i < length; i++) {
if (numbers[i] == current) {
count++;
} else {
if (count == n) {
result[*result_size] = current;
(*result_size)++;
}
current = numbers[i];
count = 1;
}
}
if (count == n) {
result[*result_size] = current;
(*result_size)++;
}
return result;
}
| int main() {
// Test Case 1
int numbers1[] = {1, 1, 3, 4, 4, 5, 6, 7};
int result1_size = 0;
int* result1 = func0(numbers1, 8, 2, &result1_size);
int expected1[] = {1, 4};
assert(result1_size == 2 && result1[0] == expected1[0] && result1[1] == expected1[1]);
// Test Case 2
int numbers2[] = {0, 1, 2, 3, 4, 4, 4, 4, 5, 7};
int result2_size = 0;
int* result2 = func0(numbers2, 10, 4, &result2_size);
int expected2[] = {4};
assert(result2_size == 1 && result2[0] == expected2[0]);
// Test Case 3
int numbers3[] = {0, 0, 0, 0, 0};
int result3_size = 0;
int* result3 = func0(numbers3, 5, 5, &result3_size);
int expected3[] = {0};
assert(result3_size == 1 && result3[0] == expected3[0]);
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r13
mov %rdi,%r13
movslq %esi,%rdi
push %r12
mov %rdi,%r12
shl $0x2,%rdi
push %rbp
mov %rcx,%rbp
push %rbx
mov %edx,%ebx
sub $0x8,%rsp
callq 10d0 <malloc@plt>
movl $0x0,0x0(%rbp)
mov 0x0(%r13),%r9d
cmp $0x1,%r12d
jle 1440 <func0+0xb0>
lea -0x2(%r12),%edx
lea 0x4(%r13),%rdi
mov $0x1,%r8d
lea 0x8(%r13,%rdx,4),%r10
jmp 140a <func0+0x7a>
nopl 0x0(%rax)
cmp %r8d,%ebx
jne 13f8 <func0+0x68>
movslq 0x0(%rbp),%rcx
mov %rcx,%rdx
mov %r9d,(%rax,%rcx,4)
add $0x1,%edx
mov %edx,0x0(%rbp)
mov (%rdi),%esi
add $0x4,%rdi
mov %esi,%r9d
mov $0x1,%r8d
cmp %r10,%rdi
je 141e <func0+0x8e>
mov (%rdi),%esi
cmp %r9d,%esi
jne 13e0 <func0+0x50>
add $0x4,%rdi
add $0x1,%r8d
cmp %r10,%rdi
jne 140a <func0+0x7a>
cmp %r8d,%ebx
jne 1434 <func0+0xa4>
movslq 0x0(%rbp),%rcx
mov %rcx,%rdx
mov %r9d,(%rax,%rcx,4)
add $0x1,%edx
mov %edx,0x0(%rbp)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x1,%r8d
jmp 141e <func0+0x8e>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
mov r13, rdi
movsxd rdi, esi
push r12
mov r12, rdi
shl rdi, 2; size
push rbp
mov rbp, rcx
push rbx
mov ebx, edx
sub rsp, 8
call _malloc
mov dword ptr [rbp+0], 0
mov esi, [r13+0]
mov r8, rax
cmp r12d, 1
jle short loc_1440
lea edx, [r12-2]
lea rax, [r13+4]
mov ecx, 1
lea rdi, [r13+rdx*4+8]
jmp short loc_1407
loc_13E0:
cmp ebx, ecx
jnz short loc_13F7
movsxd rcx, dword ptr [rbp+0]
mov rdx, rcx
mov [r8+rcx*4], esi
add edx, 1
mov [rbp+0], edx
mov edx, [rax]
loc_13F7:
add rax, 4
mov esi, edx
mov ecx, 1
cmp rax, rdi
jz short loc_1419
loc_1407:
mov edx, [rax]
cmp edx, esi
jnz short loc_13E0
add rax, 4
add ecx, 1
cmp rax, rdi
jnz short loc_1407
loc_1419:
cmp ebx, ecx
jnz short loc_142E
movsxd rdx, dword ptr [rbp+0]
mov rax, rdx
mov [r8+rdx*4], esi
add eax, 1
mov [rbp+0], eax
loc_142E:
add rsp, 8
mov rax, r8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1440:
mov ecx, 1
jmp short loc_1419 | _DWORD * func0(int *a1, int a2, int a3, int *a4)
{
_DWORD *v7; // rax
int v8; // esi
_DWORD *v9; // r8
int *v10; // rax
int v11; // ecx
long long v12; // rdi
int v13; // edx
int v14; // edx
int v15; // eax
v7 = malloc(4LL * a2);
*a4 = 0;
v8 = *a1;
v9 = v7;
if ( a2 <= 1 )
{
v11 = 1;
}
else
{
v10 = a1 + 1;
v11 = 1;
v12 = (long long)&a1[a2 - 2 + 2];
do
{
while ( 1 )
{
v14 = *v10;
if ( *v10 != v8 )
break;
++v10;
++v11;
if ( v10 == (int *)v12 )
goto LABEL_8;
}
if ( a3 == v11 )
{
v13 = *a4;
v9[*a4] = v8;
*a4 = v13 + 1;
v14 = *v10;
}
++v10;
v8 = v14;
v11 = 1;
}
while ( v10 != (int *)v12 );
}
LABEL_8:
if ( a3 == v11 )
{
v15 = *a4;
v9[*a4] = v8;
*a4 = v15 + 1;
}
return v9;
} | func0:
ENDBR64
PUSH R13
MOV R13,RDI
MOVSXD RDI,ESI
PUSH R12
MOV R12,RDI
SHL RDI,0x2
PUSH RBP
MOV RBP,RCX
PUSH RBX
MOV EBX,EDX
SUB RSP,0x8
CALL 0x001010d0
MOV dword ptr [RBP],0x0
MOV ESI,dword ptr [R13]
MOV R8,RAX
CMP R12D,0x1
JLE 0x00101440
LEA EDX,[R12 + -0x2]
LEA RAX,[R13 + 0x4]
MOV ECX,0x1
LEA RDI,[R13 + RDX*0x4 + 0x8]
JMP 0x00101407
LAB_001013e0:
CMP EBX,ECX
JNZ 0x001013f7
MOVSXD RCX,dword ptr [RBP]
MOV RDX,RCX
MOV dword ptr [R8 + RCX*0x4],ESI
ADD EDX,0x1
MOV dword ptr [RBP],EDX
MOV EDX,dword ptr [RAX]
LAB_001013f7:
ADD RAX,0x4
MOV ESI,EDX
MOV ECX,0x1
CMP RAX,RDI
JZ 0x00101419
LAB_00101407:
MOV EDX,dword ptr [RAX]
CMP EDX,ESI
JNZ 0x001013e0
ADD RAX,0x4
ADD ECX,0x1
CMP RAX,RDI
JNZ 0x00101407
LAB_00101419:
CMP EBX,ECX
JNZ 0x0010142e
MOVSXD RDX,dword ptr [RBP]
MOV RAX,RDX
MOV dword ptr [R8 + RDX*0x4],ESI
ADD EAX,0x1
MOV dword ptr [RBP],EAX
LAB_0010142e:
ADD RSP,0x8
MOV RAX,R8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101440:
MOV ECX,0x1
JMP 0x00101419 | void * func0(int *param_1,int param_2,int param_3,int *param_4)
{
int iVar1;
void *pvVar2;
int *piVar3;
int iVar4;
int iVar5;
pvVar2 = malloc((long)param_2 << 2);
*param_4 = 0;
iVar5 = *param_1;
if (param_2 < 2) {
iVar4 = 1;
}
else {
piVar3 = param_1 + 1;
iVar4 = 1;
do {
while (*piVar3 == iVar5) {
piVar3 = piVar3 + 1;
iVar4 = iVar4 + 1;
if (piVar3 == param_1 + (ulong)(param_2 - 2) + 2) goto LAB_00101419;
}
iVar1 = *piVar3;
if (param_3 == iVar4) {
iVar4 = *param_4;
*(int *)((long)pvVar2 + (long)iVar4 * 4) = iVar5;
*param_4 = iVar4 + 1;
iVar1 = *piVar3;
}
iVar5 = iVar1;
piVar3 = piVar3 + 1;
iVar4 = 1;
} while (piVar3 != param_1 + (ulong)(param_2 - 2) + 2);
}
LAB_00101419:
if (param_3 == iVar4) {
iVar4 = *param_4;
*(int *)((long)pvVar2 + (long)iVar4 * 4) = iVar5;
*param_4 = iVar4 + 1;
}
return pvVar2;
} |
7,488 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int arr[], int n) {
int g = 0;
for(int i = 1; i < n; i++) {
if((arr[i] - arr[i - 1] > 0) && (g == 1)) {
return false;
}
if((arr[i] - arr[i] < 0)) {
g = 1;
}
}
return true;
}
| int main() {
assert(func0((int[]){3,2,1,2,3,4}, 6) == true);
assert(func0((int[]){2,1,4,5,1}, 5) == true);
assert(func0((int[]){1,2,2,1,2,3}, 6) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
movl $0x1,-0x8(%rbp)
jmp 11cd <func0+0x64>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
sub %eax,%edx
mov %edx,%eax
test %eax,%eax
jle 11c9 <func0+0x60>
cmpl $0x1,-0x4(%rbp)
jne 11c9 <func0+0x60>
mov $0x0,%eax
jmp 11da <func0+0x71>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
mov [rbp+var_8], 1
jmp short loc_11CB
loc_1188:
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_8]
cdqe
shl rax, 2
lea rcx, [rax-4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
sub edx, eax
test edx, edx
jle short loc_11C7
cmp [rbp+var_4], 1
jnz short loc_11C7
mov eax, 0
jmp short loc_11D8
loc_11C7:
add [rbp+var_8], 1
loc_11CB:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, 1
loc_11D8:
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-8h]
for ( i = 1; i < a2; ++i )
;
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0x8],0x1
JMP 0x001011cb
LAB_00101188:
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 + -0x8]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
SUB EDX,EAX
TEST EDX,EDX
JLE 0x001011c7
CMP dword ptr [RBP + -0x4],0x1
JNZ 0x001011c7
MOV EAX,0x0
JMP 0x001011d8
LAB_001011c7:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011cb:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,0x1
LAB_001011d8:
POP RBP
RET | /* WARNING: Removing unreachable block (ram,0x001011c0) */
int8 func0(int8 param_1,int param_2)
{
int local_10;
for (local_10 = 1; local_10 < param_2; local_10 = local_10 + 1) {
}
return 1;
} |
7,489 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int arr[], int n) {
int g = 0;
for(int i = 1; i < n; i++) {
if((arr[i] - arr[i - 1] > 0) && (g == 1)) {
return false;
}
if((arr[i] - arr[i] < 0)) {
g = 1;
}
}
return true;
}
| int main() {
assert(func0((int[]){3,2,1,2,3,4}, 6) == true);
assert(func0((int[]){2,1,4,5,1}, 5) == true);
assert(func0((int[]){1,2,2,1,2,3}, 6) == true);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 113e <func0+0x15>
mov $0x1,%eax
add $0x1,%eax
cmp %eax,%esi
jne 1137 <func0+0xe>
mov $0x1,%eax
retq
| func0:
endbr64
cmp esi, 1
jle short loc_113E
mov eax, 1
loc_1137:
add eax, 1
cmp esi, eax
jnz short loc_1137
loc_113E:
mov eax, 1
retn | long long func0(long long a1, int a2)
{
int i; // eax
if ( a2 > 1 )
{
for ( i = 1; i != a2; ++i )
;
}
return 1LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x0010113e
MOV EAX,0x1
LAB_00101137:
ADD EAX,0x1
CMP ESI,EAX
JNZ 0x00101137
LAB_0010113e:
MOV EAX,0x1
RET | int8 func0(int8 param_1,int param_2)
{
int iVar1;
if (1 < param_2) {
iVar1 = 1;
do {
iVar1 = iVar1 + 1;
} while (param_2 != iVar1);
}
return 1;
} |
7,490 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int arr[], int n) {
int g = 0;
for(int i = 1; i < n; i++) {
if((arr[i] - arr[i - 1] > 0) && (g == 1)) {
return false;
}
if((arr[i] - arr[i] < 0)) {
g = 1;
}
}
return true;
}
| int main() {
assert(func0((int[]){3,2,1,2,3,4}, 6) == true);
assert(func0((int[]){2,1,4,5,1}, 5) == true);
assert(func0((int[]){1,2,2,1,2,3}, 6) == true);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x1,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, 1
retn | long long func0()
{
return 1LL;
} | func0:
ENDBR64
MOV EAX,0x1
RET | int8 func0(void)
{
return 1;
} |
7,491 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int arr[], int n) {
int g = 0;
for(int i = 1; i < n; i++) {
if((arr[i] - arr[i - 1] > 0) && (g == 1)) {
return false;
}
if((arr[i] - arr[i] < 0)) {
g = 1;
}
}
return true;
}
| int main() {
assert(func0((int[]){3,2,1,2,3,4}, 6) == true);
assert(func0((int[]){2,1,4,5,1}, 5) == true);
assert(func0((int[]){1,2,2,1,2,3}, 6) == true);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, 1
retn | long long func0()
{
return 1LL;
} | func0:
ENDBR64
MOV EAX,0x1
RET | int8 func0(void)
{
return 1;
} |
7,492 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#include <regex.h>
| bool func0(const char *string) {
regex_t regex;
int result;
result = regcomp(®ex, "^5", 0);
if (result) {
fprintf(stderr, "Could not compile regex\n");
return false;
}
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0("5-2345861") == true);
assert(func0("6-2345861") == false);
assert(func0("78910") == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x50(%rbp),%rax
mov $0x0,%edx
lea 0xdf0(%rip),%rsi
mov %rax,%rdi
callq 10d0 <regcomp@plt>
mov %eax,-0x54(%rbp)
cmpl $0x0,-0x54(%rbp)
je 1250 <func0+0x67>
mov 0x2df0(%rip),%rax
mov %rax,%rcx
mov $0x18,%edx
mov $0x1,%esi
lea 0xdc7(%rip),%rdi
callq 10f0 <fwrite@plt>
mov $0x0,%eax
jmp 1291 <func0+0xa8>
mov -0x68(%rbp),%rsi
lea -0x50(%rbp),%rax
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 10e0 <regexec@plt>
mov %eax,-0x54(%rbp)
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 10a0 <regfree@plt>
cmpl $0x0,-0x54(%rbp)
jne 128c <func0+0xa3>
mov $0x1,%eax
jmp 1291 <func0+0xa8>
mov $0x0,%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 12a5 <func0+0xbc>
callq 10b0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+preg]
mov edx, 0; cflags
lea rcx, pattern; "^5"
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov [rbp+var_54], eax
cmp [rbp+var_54], 0
jz short loc_1256
mov rax, cs:__bss_start
mov rcx, rax; s
mov edx, 18h; n
mov esi, 1; size
lea rax, aCouldNotCompil; "Could not compile regex\n"
mov rdi, rax; ptr
call _fwrite
mov eax, 0
jmp short loc_1297
loc_1256:
mov rsi, [rbp+string]; 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_54], eax
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
cmp [rbp+var_54], 0
jnz short loc_1292
mov eax, 1
jmp short loc_1297
loc_1292:
mov eax, 0
loc_1297:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12AB
call ___stack_chk_fail
locret_12AB:
leave
retn | _BOOL8 func0(const char *a1)
{
int v2; // [rsp+1Ch] [rbp-54h]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
if ( regcomp(&preg, "^5", 0) )
{
fwrite("Could not compile regex\n", 1uLL, 0x18uLL, _bss_start);
return 0LL;
}
else
{
v2 = regexec(&preg, a1, 0LL, 0LL, 0);
regfree(&preg);
return v2 == 0;
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV EDX,0x0
LEA RCX,[0x102004]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x54],EAX
CMP dword ptr [RBP + -0x54],0x0
JZ 0x00101256
MOV RAX,qword ptr [0x00104020]
MOV RCX,RAX
MOV EDX,0x18
MOV ESI,0x1
LEA RAX,[0x102007]
MOV RDI,RAX
CALL 0x001010f0
MOV EAX,0x0
JMP 0x00101297
LAB_00101256:
MOV RSI,qword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x50]
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x001010e0
MOV dword ptr [RBP + -0x54],EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x001010a0
CMP dword ptr [RBP + -0x54],0x0
JNZ 0x00101292
MOV EAX,0x1
JMP 0x00101297
LAB_00101292:
MOV EAX,0x0
LAB_00101297:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012ab
CALL 0x001010b0
LAB_001012ab:
LEAVE
RET | int8 func0(char *param_1)
{
int iVar1;
int8 uVar2;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_58,"^5",0);
if (iVar1 == 0) {
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_58);
if (iVar1 == 0) {
uVar2 = 1;
}
else {
uVar2 = 0;
}
}
else {
fwrite("Could not compile regex\n",1,0x18,stderr);
uVar2 = 0;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar2;
} |
7,493 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#include <regex.h>
| bool func0(const char *string) {
regex_t regex;
int result;
result = regcomp(®ex, "^5", 0);
if (result) {
fprintf(stderr, "Could not compile regex\n");
return false;
}
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0("5-2345861") == true);
assert(func0("6-2345861") == false);
assert(func0("78910") == false);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x0,%edx
lea 0xdef(%rip),%rsi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 1262 <func0+0x79>
mov %rsp,%rbp
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 10e0 <regexec@plt>
mov %eax,%ebx
mov %rbp,%rdi
callq 10a0 <regfree@plt>
test %ebx,%ebx
sete %al
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 1286 <func0+0x9d>
add $0x58,%rsp
pop %rbx
pop %rbp
retq
mov 0x2db7(%rip),%rcx
mov $0x18,%edx
mov $0x1,%esi
lea 0xd8d(%rip),%rdi
callq 10f0 <fwrite@plt>
mov $0x0,%eax
jmp 124b <func0+0x62>
callq 10b0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov rdi, rsp
mov edx, 0
lea rsi, unk_2004
call _regcomp
test eax, eax
jnz short loc_1262
mov rbp, rsp
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
setz al
loc_124B:
mov rdx, [rsp+68h+var_20]
sub rdx, fs:28h
jnz short loc_1286
add rsp, 58h
pop rbx
pop rbp
retn
loc_1262:
mov rcx, cs:stderr@GLIBC_2_2_5
mov edx, 18h
mov esi, 1
lea rdi, aCouldNotCompil; "Could not compile regex\n"
call _fwrite
mov eax, 0
jmp short loc_124B
loc_1286:
call ___stack_chk_fail | bool func0(long long a1)
{
int v1; // ebx
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
v3[9] = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v3, &unk_2004, 0LL) )
{
fwrite("Could not compile regex\n", 1LL, 24LL, stderr);
return 0;
}
else
{
v1 = regexec(v3, a1, 0LL, 0LL, 0LL);
regfree(v3);
return v1 == 0;
}
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x0
LEA RSI,[0x102004]
CALL 0x001010d0
TEST EAX,EAX
JNZ 0x00101262
MOV RBP,RSP
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010e0
MOV EBX,EAX
MOV RDI,RBP
CALL 0x001010a0
TEST EBX,EBX
SETZ AL
LAB_0010124b:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101286
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_00101262:
MOV RCX,qword ptr [0x00104020]
MOV EDX,0x18
MOV ESI,0x1
LEA RDI,[0x102007]
CALL 0x001010f0
MOV EAX,0x0
JMP 0x0010124b
LAB_00101286:
CALL 0x001010b0 | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"^5",0);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
bVar2 = iVar1 == 0;
}
else {
fwrite("Could not compile regex\n",1,0x18,stderr);
bVar2 = false;
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,494 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#include <regex.h>
| bool func0(const char *string) {
regex_t regex;
int result;
result = regcomp(®ex, "^5", 0);
if (result) {
fprintf(stderr, "Could not compile regex\n");
return false;
}
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0("5-2345861") == true);
assert(func0("6-2345861") == false);
assert(func0("78910") == false);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
xor %edx,%edx
lea 0xd65(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 1300 <func0+0x70>
xor %r8d,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %rbp,%rsi
mov %r12,%rdi
callq 10e0 <regexec@plt>
mov %r12,%rdi
mov %eax,%ebp
callq 10a0 <regfree@plt>
test %ebp,%ebp
sete %al
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 1321 <func0+0x91>
add $0x58,%rsp
pop %rbp
pop %r12
retq
mov 0x2d19(%rip),%rcx
mov $0x18,%edx
mov $0x1,%esi
lea 0xcef(%rip),%rdi
callq 10f0 <fwrite@plt>
xor %eax,%eax
jmp 12e7 <func0+0x57>
callq 10b0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r12
xor edx, edx
lea rsi, unk_2004
push rbp
mov rbp, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov r12, rsp
mov rdi, r12
call _regcomp
test eax, eax
jnz short loc_1300
xor r8d, r8d
xor ecx, ecx
xor edx, edx
mov rsi, rbp
mov rdi, r12
call _regexec
mov rdi, r12
mov ebp, eax
call _regfree
test ebp, ebp
setz al
loc_12E7:
mov rdx, [rsp+68h+var_20]
sub rdx, fs:28h
jnz short loc_1321
add rsp, 58h
pop rbp
pop r12
retn
loc_1300:
mov rcx, cs:stderr@GLIBC_2_2_5
mov edx, 18h
mov esi, 1
lea rdi, aCouldNotCompil; "Could not compile regex\n"
call _fwrite
xor eax, eax
jmp short loc_12E7
loc_1321:
call ___stack_chk_fail | bool func0(long long a1)
{
int v1; // ebp
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
v3[9] = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v3, &unk_2004, 0LL) )
{
fwrite("Could not compile regex\n", 1LL, 24LL, stderr);
return 0;
}
else
{
v1 = regexec(v3, a1, 0LL, 0LL, 0LL);
regfree(v3);
return v1 == 0;
}
} | func0:
ENDBR64
PUSH R12
XOR EDX,EDX
LEA RSI,[0x102004]
PUSH RBP
MOV RBP,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV R12,RSP
MOV RDI,R12
CALL 0x001010d0
TEST EAX,EAX
JNZ 0x00101300
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,RBP
MOV RDI,R12
CALL 0x001010e0
MOV RDI,R12
MOV EBP,EAX
CALL 0x001010a0
TEST EBP,EBP
SETZ AL
LAB_001012e7:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101321
ADD RSP,0x58
POP RBP
POP R12
RET
LAB_00101300:
MOV RCX,qword ptr [0x00104020]
MOV EDX,0x18
MOV ESI,0x1
LEA RDI,[0x102007]
CALL 0x001010f0
XOR EAX,EAX
JMP 0x001012e7
LAB_00101321:
CALL 0x001010b0 | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"^5",0);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
bVar2 = iVar1 == 0;
}
else {
fwrite("Could not compile regex\n",1,0x18,stderr);
bVar2 = false;
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,495 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#include <regex.h>
| bool func0(const char *string) {
regex_t regex;
int result;
result = regcomp(®ex, "^5", 0);
if (result) {
fprintf(stderr, "Could not compile regex\n");
return false;
}
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0("5-2345861") == true);
assert(func0("6-2345861") == false);
assert(func0("78910") == false);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
xor %edx,%edx
lea 0xd65(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 1300 <func0+0x70>
xor %r8d,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %rbp,%rsi
mov %r12,%rdi
callq 10e0 <regexec@plt>
mov %r12,%rdi
mov %eax,%ebp
callq 10a0 <regfree@plt>
test %ebp,%ebp
sete %al
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 1321 <func0+0x91>
add $0x58,%rsp
pop %rbp
pop %r12
retq
mov 0x2d19(%rip),%rcx
mov $0x18,%edx
mov $0x1,%esi
lea 0xcef(%rip),%rdi
callq 10f0 <fwrite@plt>
xor %eax,%eax
jmp 12e7 <func0+0x57>
callq 10b0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
xor edx, edx; cflags
lea rsi, pattern; "^5"
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
test eax, eax
jnz short loc_1300
xor r8d, r8d; eflags
xor ecx, ecx; pmatch
xor edx, edx; nmatch
mov rsi, rbx; string
mov rdi, rbp; preg
call _regexec
mov rdi, rbp; preg
mov ebx, eax
call _regfree
test ebx, ebx
setz al
loc_12E6:
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_1321
add rsp, 58h
pop rbx
pop rbp
retn
loc_1300:
mov rcx, cs:__bss_start; s
mov edx, 18h; n
mov esi, 1; size
lea rdi, aCouldNotCompil; "Could not compile regex\n"
call _fwrite
xor eax, eax
jmp short loc_12E6
loc_1321:
call ___stack_chk_fail | bool func0(char *string)
{
int v1; // ebx
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
if ( regcomp(&_0, "^5", 0) )
{
fwrite("Could not compile regex\n", 1uLL, 0x18uLL, _bss_start);
return 0;
}
else
{
v1 = regexec(&_0, string, 0LL, 0LL, 0);
regfree(&_0);
return v1 == 0;
}
} | func0:
ENDBR64
PUSH RBP
XOR EDX,EDX
LEA RSI,[0x102004]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010d0
TEST EAX,EAX
JNZ 0x00101300
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010e0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x001010a0
TEST EBX,EBX
SETZ AL
LAB_001012e6:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101321
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_00101300:
MOV RCX,qword ptr [0x00104020]
MOV EDX,0x18
MOV ESI,0x1
LEA RDI,[0x102007]
CALL 0x001010f0
XOR EAX,EAX
JMP 0x001012e6
LAB_00101321:
CALL 0x001010b0 | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"^5",0);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
bVar2 = iVar1 == 0;
}
else {
fwrite("Could not compile regex\n",1,0x18,stderr);
bVar2 = false;
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,496 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
if (n <= 2) {
return n;
}
int i = n * 2;
int factors[100];
int factor_count = 0;
for (int number = n; number > 1; number--) {
if (number * 2 > n) {
factors[factor_count++] = number;
}
}
while (1) {
for (int j = 0; j < factor_count; j++) {
if (i % factors[j] != 0) {
i += n;
break;
}
if (j == factor_count - 1 && i % factors[j] == 0) {
return i;
}
}
}
}
| int main() {
assert(func0(13) == 360360);
assert(func0(2) == 2);
assert(func0(1) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x1c0,%rsp
mov %edi,-0x1b4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
cmpl $0x2,-0x1b4(%rbp)
jg 11a1 <func0+0x38>
mov -0x1b4(%rbp),%eax
jmpq 128e <func0+0x125>
mov -0x1b4(%rbp),%eax
add %eax,%eax
mov %eax,-0x1b0(%rbp)
movl $0x0,-0x1ac(%rbp)
mov -0x1b4(%rbp),%eax
mov %eax,-0x1a8(%rbp)
jmp 11fc <func0+0x93>
mov -0x1a8(%rbp),%eax
add %eax,%eax
cmp %eax,-0x1b4(%rbp)
jge 11f5 <func0+0x8c>
mov -0x1ac(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1ac(%rbp)
cltq
mov -0x1a8(%rbp),%edx
mov %edx,-0x1a0(%rbp,%rax,4)
subl $0x1,-0x1a8(%rbp)
cmpl $0x1,-0x1a8(%rbp)
jg 11c7 <func0+0x5e>
movl $0x0,-0x1a4(%rbp)
jmp 127b <func0+0x112>
mov -0x1a4(%rbp),%eax
cltq
mov -0x1a0(%rbp,%rax,4),%ecx
mov -0x1b0(%rbp),%eax
cltd
idiv %ecx
mov %edx,%eax
test %eax,%eax
je 123d <func0+0xd4>
mov -0x1b4(%rbp),%eax
add %eax,-0x1b0(%rbp)
jmp 1289 <func0+0x120>
mov -0x1ac(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x1a4(%rbp)
jne 1274 <func0+0x10b>
mov -0x1a4(%rbp),%eax
cltq
mov -0x1a0(%rbp,%rax,4),%ecx
mov -0x1b0(%rbp),%eax
cltd
idiv %ecx
mov %edx,%eax
test %eax,%eax
jne 1274 <func0+0x10b>
mov -0x1b0(%rbp),%eax
jmp 128e <func0+0x125>
addl $0x1,-0x1a4(%rbp)
mov -0x1a4(%rbp),%eax
cmp -0x1ac(%rbp),%eax
jl 1211 <func0+0xa8>
jmpq 1205 <func0+0x9c>
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 12a2 <func0+0x139>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 1C0h
mov [rbp+var_1B4], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
cmp [rbp+var_1B4], 2
jg short loc_11A1
mov eax, [rbp+var_1B4]
jmp loc_1292
loc_11A1:
mov eax, [rbp+var_1B4]
add eax, eax
mov [rbp+var_1B0], eax
mov [rbp+var_1AC], 0
mov eax, [rbp+var_1B4]
mov [rbp+var_1A8], eax
jmp short loc_11FC
loc_11C7:
mov eax, [rbp+var_1A8]
add eax, eax
cmp [rbp+var_1B4], eax
jge short loc_11F5
mov eax, [rbp+var_1AC]
lea edx, [rax+1]
mov [rbp+var_1AC], edx
cdqe
mov edx, [rbp+var_1A8]
mov [rbp+rax*4+var_1A0], edx
loc_11F5:
sub [rbp+var_1A8], 1
loc_11FC:
cmp [rbp+var_1A8], 1
jg short loc_11C7
loc_1205:
mov [rbp+var_1A4], 0
jmp short loc_127F
loc_1211:
mov eax, [rbp+var_1A4]
cdqe
mov esi, [rbp+rax*4+var_1A0]
mov eax, [rbp+var_1B0]
cdq
idiv esi
mov ecx, edx
mov eax, ecx
test eax, eax
jz short loc_123F
mov eax, [rbp+var_1B4]
add [rbp+var_1B0], eax
jmp short loc_128D
loc_123F:
mov eax, [rbp+var_1AC]
sub eax, 1
cmp [rbp+var_1A4], eax
jnz short loc_1278
mov eax, [rbp+var_1A4]
cdqe
mov edi, [rbp+rax*4+var_1A0]
mov eax, [rbp+var_1B0]
cdq
idiv edi
mov ecx, edx
mov eax, ecx
test eax, eax
jnz short loc_1278
mov eax, [rbp+var_1B0]
jmp short loc_1292
loc_1278:
add [rbp+var_1A4], 1
loc_127F:
mov eax, [rbp+var_1A4]
cmp eax, [rbp+var_1AC]
jl short loc_1211
loc_128D:
jmp loc_1205
loc_1292:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12A6
call ___stack_chk_fail
locret_12A6:
leave
retn | long long func0(int a1)
{
int v2; // eax
int v3; // [rsp+10h] [rbp-1B0h]
int v4; // [rsp+14h] [rbp-1ACh]
int i; // [rsp+18h] [rbp-1A8h]
int j; // [rsp+1Ch] [rbp-1A4h]
_DWORD v7[102]; // [rsp+20h] [rbp-1A0h]
unsigned long long v8; // [rsp+1B8h] [rbp-8h]
v8 = __readfsqword(0x28u);
if ( a1 <= 2 )
return (unsigned int)a1;
v3 = 2 * a1;
v4 = 0;
for ( i = a1; i > 1; --i )
{
if ( a1 < 2 * i )
{
v2 = v4++;
v7[v2] = i;
}
}
LABEL_8:
for ( j = 0; ; ++j )
{
if ( j >= v4 )
goto LABEL_8;
if ( v3 % v7[j] )
{
v3 += a1;
goto LABEL_8;
}
if ( j == v4 - 1 && !(v3 % v7[j]) )
break;
}
return (unsigned int)v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1c0
MOV dword ptr [RBP + -0x1b4],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
CMP dword ptr [RBP + -0x1b4],0x2
JG 0x001011a1
MOV EAX,dword ptr [RBP + -0x1b4]
JMP 0x00101292
LAB_001011a1:
MOV EAX,dword ptr [RBP + -0x1b4]
ADD EAX,EAX
MOV dword ptr [RBP + -0x1b0],EAX
MOV dword ptr [RBP + -0x1ac],0x0
MOV EAX,dword ptr [RBP + -0x1b4]
MOV dword ptr [RBP + -0x1a8],EAX
JMP 0x001011fc
LAB_001011c7:
MOV EAX,dword ptr [RBP + -0x1a8]
ADD EAX,EAX
CMP dword ptr [RBP + -0x1b4],EAX
JGE 0x001011f5
MOV EAX,dword ptr [RBP + -0x1ac]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1ac],EDX
CDQE
MOV EDX,dword ptr [RBP + -0x1a8]
MOV dword ptr [RBP + RAX*0x4 + -0x1a0],EDX
LAB_001011f5:
SUB dword ptr [RBP + -0x1a8],0x1
LAB_001011fc:
CMP dword ptr [RBP + -0x1a8],0x1
JG 0x001011c7
LAB_00101205:
MOV dword ptr [RBP + -0x1a4],0x0
JMP 0x0010127f
LAB_00101211:
MOV EAX,dword ptr [RBP + -0x1a4]
CDQE
MOV ESI,dword ptr [RBP + RAX*0x4 + -0x1a0]
MOV EAX,dword ptr [RBP + -0x1b0]
CDQ
IDIV ESI
MOV ECX,EDX
MOV EAX,ECX
TEST EAX,EAX
JZ 0x0010123f
MOV EAX,dword ptr [RBP + -0x1b4]
ADD dword ptr [RBP + -0x1b0],EAX
JMP 0x0010128d
LAB_0010123f:
MOV EAX,dword ptr [RBP + -0x1ac]
SUB EAX,0x1
CMP dword ptr [RBP + -0x1a4],EAX
JNZ 0x00101278
MOV EAX,dword ptr [RBP + -0x1a4]
CDQE
MOV EDI,dword ptr [RBP + RAX*0x4 + -0x1a0]
MOV EAX,dword ptr [RBP + -0x1b0]
CDQ
IDIV EDI
MOV ECX,EDX
MOV EAX,ECX
TEST EAX,EAX
JNZ 0x00101278
MOV EAX,dword ptr [RBP + -0x1b0]
JMP 0x00101292
LAB_00101278:
ADD dword ptr [RBP + -0x1a4],0x1
LAB_0010127f:
MOV EAX,dword ptr [RBP + -0x1a4]
CMP EAX,dword ptr [RBP + -0x1ac]
JL 0x00101211
LAB_0010128d:
JMP 0x00101205
LAB_00101292:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012a6
CALL 0x00101060
LAB_001012a6:
LEAVE
RET | int func0(int param_1)
{
long in_FS_OFFSET;
int local_1b8;
int local_1b4;
int local_1b0;
int local_1ac;
int aiStack_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1b8 = param_1;
if (param_1 < 3) {
LAB_00101292:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_1b8;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
local_1b8 = param_1 * 2;
local_1b4 = 0;
for (local_1b0 = param_1; 1 < local_1b0; local_1b0 = local_1b0 + -1) {
if (param_1 < local_1b0 * 2) {
aiStack_1a8[local_1b4] = local_1b0;
local_1b4 = local_1b4 + 1;
}
}
do {
for (local_1ac = 0; local_1ac < local_1b4; local_1ac = local_1ac + 1) {
if (local_1b8 % aiStack_1a8[local_1ac] != 0) {
local_1b8 = local_1b8 + param_1;
break;
}
if ((local_1ac == local_1b4 + -1) && (local_1b8 % aiStack_1a8[local_1ac] == 0))
goto LAB_00101292;
}
} while( true );
} |
7,497 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
if (n <= 2) {
return n;
}
int i = n * 2;
int factors[100];
int factor_count = 0;
for (int number = n; number > 1; number--) {
if (number * 2 > n) {
factors[factor_count++] = number;
}
}
while (1) {
for (int j = 0; j < factor_count; j++) {
if (i % factors[j] != 0) {
i += n;
break;
}
if (j == factor_count - 1 && i % factors[j] == 0) {
return i;
}
}
}
}
| int main() {
assert(func0(13) == 360360);
assert(func0(2) == 2);
assert(func0(1) == 1);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
cmp $0x2,%edi
jle 11ee <func0+0x85>
lea (%rdi,%rdi,1),%esi
mov %edi,%eax
mov $0x0,%r10d
jmp 11a1 <func0+0x38>
sub $0x1,%eax
cmp $0x1,%eax
je 11b4 <func0+0x4b>
lea (%rax,%rax,1),%edx
cmp %edx,%edi
jge 1199 <func0+0x30>
movslq %r10d,%rdx
mov %eax,(%rsp,%rdx,4)
lea 0x1(%r10),%r10d
jmp 1199 <func0+0x30>
mov %rsp,%r11
lea -0x1(%r10),%r8d
shl $0x2,%r8
lea 0x4(%rsp,%r8,1),%r9
add %r11,%r8
jmp 11cb <func0+0x62>
add %edi,%esi
test %r10d,%r10d
jle 11cb <func0+0x62>
mov %r11,%rcx
mov %esi,%eax
cltd
idivl (%rcx)
test %edx,%edx
jne 11c9 <func0+0x60>
cmp %r8,%rcx
je 11ec <func0+0x83>
add $0x4,%rcx
cmp %r9,%rcx
jne 11d3 <func0+0x6a>
jmp 11cb <func0+0x62>
mov %esi,%edi
mov 0x198(%rsp),%rax
xor %fs:0x28,%rax
jne 120b <func0+0xa2>
mov %edi,%eax
add $0x1a8,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
sub rsp, 1A8h
mov r9d, edi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
cmp edi, 2
jle short loc_11F4
lea esi, [rdi+rdi]
mov eax, edi
mov r10d, 0
jmp short loc_11A4
loc_119C:
sub eax, 1
cmp eax, 1
jz short loc_11B8
loc_11A4:
lea edx, [rax+rax]
cmp r9d, edx
jge short loc_119C
movsxd rdx, r10d
mov [rsp+rdx*4+1A8h+var_1A8], eax
lea r10d, [r10+1]
jmp short loc_119C
loc_11B8:
mov r11, rsp
lea edi, [r10-1]
shl rdi, 2
lea r8, [rsp+rdi+1A8h+var_1A4]
add rdi, r11
jmp short loc_11D0
loc_11CD:
add esi, r9d
loc_11D0:
test r10d, r10d
jle short loc_11D0
mov rcx, r11
loc_11D8:
mov eax, esi
cdq
idiv dword ptr [rcx]
test edx, edx
jnz short loc_11CD
cmp rcx, rdi
jz short loc_11F1
add rcx, 4
cmp rcx, r8
jnz short loc_11D8
jmp short loc_11D0
loc_11F1:
mov r9d, esi
loc_11F4:
mov rax, [rsp+1A8h+var_10]
sub rax, fs:28h
jnz short loc_1212
mov eax, r9d
add rsp, 1A8h
retn
loc_1212:
call ___stack_chk_fail | long long func0(int a1)
{
unsigned int v1; // r9d
int v2; // esi
int v3; // eax
int v4; // r10d
long long v5; // rdi
_DWORD *v6; // r8
_DWORD *v7; // rdi
_DWORD *v8; // rcx
_DWORD v10[102]; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v11; // [rsp+198h] [rbp-10h]
v1 = a1;
v11 = __readfsqword(0x28u);
if ( a1 > 2 )
{
v2 = 2 * a1;
v3 = a1;
v4 = 0;
do
{
if ( a1 < 2 * v3 )
v10[v4++] = v3;
--v3;
}
while ( v3 != 1 );
v5 = (unsigned int)(v4 - 1);
v6 = &v10[v5 + 1];
v7 = &v10[v5];
LABEL_8:
while ( v4 <= 0 )
;
v8 = v10;
while ( 1 )
{
if ( v2 % *v8 )
{
v2 += v1;
goto LABEL_8;
}
if ( v8 == v7 )
return (unsigned int)v2;
if ( ++v8 == v6 )
goto LABEL_8;
}
}
return v1;
} | func0:
ENDBR64
SUB RSP,0x1a8
MOV R9D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
CMP EDI,0x2
JLE 0x001011f4
LEA ESI,[RDI + RDI*0x1]
MOV EAX,EDI
MOV R10D,0x0
JMP 0x001011a4
LAB_0010119c:
SUB EAX,0x1
CMP EAX,0x1
JZ 0x001011b8
LAB_001011a4:
LEA EDX,[RAX + RAX*0x1]
CMP R9D,EDX
JGE 0x0010119c
MOVSXD RDX,R10D
MOV dword ptr [RSP + RDX*0x4],EAX
LEA R10D,[R10 + 0x1]
JMP 0x0010119c
LAB_001011b8:
MOV R11,RSP
LEA EDI,[R10 + -0x1]
SHL RDI,0x2
LEA R8,[RSP + RDI*0x1 + 0x4]
ADD RDI,R11
JMP 0x001011d0
LAB_001011cd:
ADD ESI,R9D
LAB_001011d0:
TEST R10D,R10D
JLE 0x001011d0
MOV RCX,R11
LAB_001011d8:
MOV EAX,ESI
CDQ
IDIV dword ptr [RCX]
TEST EDX,EDX
JNZ 0x001011cd
CMP RCX,RDI
JZ 0x001011f1
ADD RCX,0x4
CMP RCX,R8
JNZ 0x001011d8
JMP 0x001011d0
LAB_001011f1:
MOV R9D,ESI
LAB_001011f4:
MOV RAX,qword ptr [RSP + 0x198]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101212
MOV EAX,R9D
ADD RSP,0x1a8
RET
LAB_00101212:
CALL 0x00101060 | int func0(int param_1)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar3 = param_1;
if (param_1 < 3) {
LAB_001011f4:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar3;
}
iVar3 = param_1 * 2;
iVar4 = 0;
iVar1 = param_1;
do {
if (SBORROW4(param_1,iVar1 * 2) != param_1 + iVar1 * -2 < 0) {
local_1a8[iVar4] = iVar1;
iVar4 = iVar4 + 1;
}
iVar1 = iVar1 + -1;
} while (iVar1 != 1);
do {
do {
piVar2 = local_1a8;
} while (iVar4 < 1);
do {
if (iVar3 % *piVar2 != 0) {
iVar3 = iVar3 + param_1;
break;
}
if (piVar2 == local_1a8 + (iVar4 - 1)) goto LAB_001011f4;
piVar2 = piVar2 + 1;
} while (piVar2 != local_1a8 + (ulong)(iVar4 - 1) + 1);
} while( true );
} |
7,498 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
if (n <= 2) {
return n;
}
int i = n * 2;
int factors[100];
int factor_count = 0;
for (int number = n; number > 1; number--) {
if (number * 2 > n) {
factors[factor_count++] = number;
}
}
while (1) {
for (int j = 0; j < factor_count; j++) {
if (i % factors[j] != 0) {
i += n;
break;
}
if (j == factor_count - 1 && i % factors[j] == 0) {
return i;
}
}
}
}
| int main() {
assert(func0(13) == 360360);
assert(func0(2) == 2);
assert(func0(1) == 1);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x2,%edi
jle 1290 <func0+0x10>
jmpq 11b0 <func0.part.0>
xchg %ax,%ax
mov %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
sub rsp, 1A8h
mov r9d, edi
lea r8d, [rdi+rdi]
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
cmp edi, 1
jz loc_1266
mov eax, edi
xor r10d, r10d
nop
loc_11E0:
lea edx, [rax+rax]
cmp r9d, edx
jge short loc_11F2
movsxd rdx, r10d
add r10d, 1
mov [rsp+rdx*4+1A8h+var_1A8], eax
loc_11F2:
sub eax, 1
cmp eax, 1
jnz short loc_11E0
lea eax, [r10-1]
mov edx, eax
loc_1200:
mov r11, rsp
lea rdi, [rsp+rax*4+1A8h+var_1A4]
mov eax, edx
lea rsi, [r11+rax*4]
loc_120E:
test r10d, r10d
jz short loc_1240
loc_1213:
mov rcx, r11
jmp short loc_122E
loc_1220:
cmp rcx, rsi
jz short loc_1248
add rcx, 4
cmp rcx, rdi
jz short loc_120E
loc_122E:
mov eax, r8d
cdq
idiv dword ptr [rcx]
test edx, edx
jz short loc_1220
add r8d, r9d
test r10d, r10d
jnz short loc_1213
loc_1240:
jmp short loc_1240
loc_1248:
mov rax, [rsp+1A8h+var_10]
sub rax, fs:28h
jnz short loc_1275
mov eax, r8d
add rsp, 1A8h
retn
loc_1266:
mov edx, 0FFFFFFFFh
xor r10d, r10d
mov eax, 0FFFFFFFFh
jmp short loc_1200
loc_1275:
call ___stack_chk_fail | long long func0_part_0(int a1)
{
int v1; // r8d
int v2; // eax
int v3; // r10d
long long v4; // rdx
long long v5; // rax
int v6; // edx
_DWORD *v7; // rcx
_DWORD v9[102]; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v10; // [rsp+198h] [rbp-10h]
v1 = 2 * a1;
v10 = __readfsqword(0x28u);
if ( a1 == 1 )
{
v6 = -1;
v3 = 0;
v5 = 0xFFFFFFFFLL;
}
else
{
v2 = a1;
v3 = 0;
do
{
if ( a1 < 2 * v2 )
{
v4 = v3++;
v9[v4] = v2;
}
--v2;
}
while ( v2 != 1 );
v5 = (unsigned int)(v3 - 1);
v6 = v3 - 1;
}
LABEL_7:
if ( !v3 )
{
while ( 1 )
;
}
LABEL_8:
v7 = v9;
while ( 1 )
{
if ( v1 % *v7 )
{
v1 += a1;
goto LABEL_8;
}
if ( v7 == &v9[v6] )
return (unsigned int)v1;
if ( ++v7 == &v9[v5 + 1] )
goto LABEL_7;
}
} | func0.part.0:
SUB RSP,0x1a8
MOV R9D,EDI
LEA R8D,[RDI + RDI*0x1]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
CMP EDI,0x1
JZ 0x00101266
MOV EAX,EDI
XOR R10D,R10D
NOP
LAB_001011e0:
LEA EDX,[RAX + RAX*0x1]
CMP R9D,EDX
JGE 0x001011f2
MOVSXD RDX,R10D
ADD R10D,0x1
MOV dword ptr [RSP + RDX*0x4],EAX
LAB_001011f2:
SUB EAX,0x1
CMP EAX,0x1
JNZ 0x001011e0
LEA EAX,[R10 + -0x1]
MOV EDX,EAX
LAB_00101200:
MOV R11,RSP
LEA RDI,[RSP + RAX*0x4 + 0x4]
MOV EAX,EDX
LEA RSI,[R11 + RAX*0x4]
LAB_0010120e:
TEST R10D,R10D
JZ 0x00101240
LAB_00101213:
MOV RCX,R11
JMP 0x0010122e
LAB_00101220:
CMP RCX,RSI
JZ 0x00101248
ADD RCX,0x4
CMP RCX,RDI
JZ 0x0010120e
LAB_0010122e:
MOV EAX,R8D
CDQ
IDIV dword ptr [RCX]
TEST EDX,EDX
JZ 0x00101220
ADD R8D,R9D
TEST R10D,R10D
JNZ 0x00101213
LAB_00101240:
JMP 0x00101240
LAB_00101248:
MOV RAX,qword ptr [RSP + 0x198]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101275
MOV EAX,R8D
ADD RSP,0x1a8
RET
LAB_00101266:
MOV EDX,0xffffffff
XOR R10D,R10D
MOV EAX,0xffffffff
JMP 0x00101200
LAB_00101275:
CALL 0x00101060 | int func0_part_0(int param_1)
{
int iVar1;
ulong uVar2;
int *piVar3;
long lVar4;
ulong uVar5;
int iVar6;
int iVar7;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
iVar6 = param_1 * 2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 == 1) {
uVar5 = 0xffffffff;
iVar7 = 0;
uVar2 = 0xffffffff;
}
else {
iVar7 = 0;
iVar1 = param_1;
do {
if (SBORROW4(param_1,iVar1 * 2) != param_1 + iVar1 * -2 < 0) {
lVar4 = (long)iVar7;
iVar7 = iVar7 + 1;
local_1a8[lVar4] = iVar1;
}
iVar1 = iVar1 + -1;
} while (iVar1 != 1);
uVar2 = (ulong)(iVar7 - 1U);
uVar5 = (ulong)(iVar7 - 1U);
}
do {
piVar3 = local_1a8;
if (iVar7 == 0) {
do {
/* WARNING: Do nothing block with infinite loop */
} while( true );
}
do {
if (iVar6 % *piVar3 != 0) {
iVar6 = iVar6 + param_1;
break;
}
if (piVar3 == local_1a8 + uVar5) {
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar6;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
piVar3 = piVar3 + 1;
} while (piVar3 != local_1a8 + uVar2 + 1);
} while( true );
} |
7,499 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
if (n <= 2) {
return n;
}
int i = n * 2;
int factors[100];
int factor_count = 0;
for (int number = n; number > 1; number--) {
if (number * 2 > n) {
factors[factor_count++] = number;
}
}
while (1) {
for (int j = 0; j < factor_count; j++) {
if (i % factors[j] != 0) {
i += n;
break;
}
if (j == factor_count - 1 && i % factors[j] == 0) {
return i;
}
}
}
}
| int main() {
assert(func0(13) == 360360);
assert(func0(2) == 2);
assert(func0(1) == 1);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x2,%edi
jle 1290 <func0+0x10>
jmpq 11b0 <func0.part.0>
xchg %ax,%ax
mov %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
sub rsp, 1A8h
mov r9d, edi
lea esi, [rdi+rdi]
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
cmp edi, 1
jz loc_1265
mov eax, edi
xor r10d, r10d
xchg ax, ax
loc_11E0:
lea edx, [rax+rax]
cmp r9d, edx
jge short loc_11F2
movsxd rdx, r10d
add r10d, 1
mov [rsp+rdx*4+1A8h+var_1A8], eax
loc_11F2:
sub eax, 1
cmp eax, 1
jnz short loc_11E0
lea eax, [r10-1]
loc_11FE:
mov r11, rsp
movsxd rdx, r10d
lea r8, [r11+rdx*4]
lea rdi, [r11+rax*4]
test r10d, r10d
jle short loc_123F
loc_1211:
mov rcx, r11
jmp short loc_122E
loc_1220:
cmp rcx, rdi
jz short loc_1248
add rcx, 4
cmp rcx, r8
jz short loc_1211
loc_122E:
mov eax, esi
cdq
idiv dword ptr [rcx]
test edx, edx
jz short loc_1220
add esi, r9d
test r10d, r10d
jg short loc_1211
loc_123F:
jmp short loc_123F
loc_1248:
mov rax, [rsp+1A8h+var_10]
sub rax, fs:28h
jnz short loc_126F
mov eax, esi
add rsp, 1A8h
retn
loc_1265:
mov eax, 0FFFFFFFFh
xor r10d, r10d
jmp short loc_11FE
loc_126F:
call ___stack_chk_fail | long long func0_part_0(int a1)
{
int v1; // esi
int v2; // eax
int v3; // r10d
long long v4; // rdx
long long v5; // rax
_DWORD *v6; // rcx
_DWORD v8[102]; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v9; // [rsp+198h] [rbp-10h]
v1 = 2 * a1;
v9 = __readfsqword(0x28u);
if ( a1 == 1 )
{
v5 = 0xFFFFFFFFLL;
v3 = 0;
}
else
{
v2 = a1;
v3 = 0;
do
{
if ( a1 < 2 * v2 )
{
v4 = v3++;
v8[v4] = v2;
}
--v2;
}
while ( v2 != 1 );
v5 = (unsigned int)(v3 - 1);
}
if ( v3 <= 0 )
{
while ( 1 )
;
}
LABEL_8:
v6 = v8;
while ( 1 )
{
if ( v1 % *v6 )
{
v1 += a1;
goto LABEL_8;
}
if ( v6 == &v8[v5] )
return (unsigned int)v1;
if ( ++v6 == &v8[v3] )
goto LABEL_8;
}
} | func0.part.0:
SUB RSP,0x1a8
MOV R9D,EDI
LEA ESI,[RDI + RDI*0x1]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
CMP EDI,0x1
JZ 0x00101265
MOV EAX,EDI
XOR R10D,R10D
NOP
LAB_001011e0:
LEA EDX,[RAX + RAX*0x1]
CMP R9D,EDX
JGE 0x001011f2
MOVSXD RDX,R10D
ADD R10D,0x1
MOV dword ptr [RSP + RDX*0x4],EAX
LAB_001011f2:
SUB EAX,0x1
CMP EAX,0x1
JNZ 0x001011e0
LEA EAX,[R10 + -0x1]
LAB_001011fe:
MOV R11,RSP
MOVSXD RDX,R10D
LEA R8,[R11 + RDX*0x4]
LEA RDI,[R11 + RAX*0x4]
TEST R10D,R10D
JLE 0x0010123f
LAB_00101211:
MOV RCX,R11
JMP 0x0010122e
LAB_00101220:
CMP RCX,RDI
JZ 0x00101248
ADD RCX,0x4
CMP RCX,R8
JZ 0x00101211
LAB_0010122e:
MOV EAX,ESI
CDQ
IDIV dword ptr [RCX]
TEST EDX,EDX
JZ 0x00101220
ADD ESI,R9D
TEST R10D,R10D
JG 0x00101211
LAB_0010123f:
JMP 0x0010123f
LAB_00101248:
MOV RAX,qword ptr [RSP + 0x198]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010126f
MOV EAX,ESI
ADD RSP,0x1a8
RET
LAB_00101265:
MOV EAX,0xffffffff
XOR R10D,R10D
JMP 0x001011fe
LAB_0010126f:
CALL 0x00101060 | int func0_part_0(int param_1)
{
int iVar1;
ulong uVar2;
int *piVar3;
long lVar4;
int iVar5;
int iVar6;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
iVar5 = param_1 * 2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 == 1) {
uVar2 = 0xffffffff;
iVar6 = 0;
}
else {
iVar6 = 0;
iVar1 = param_1;
do {
if (param_1 < iVar1 * 2) {
lVar4 = (long)iVar6;
iVar6 = iVar6 + 1;
local_1a8[lVar4] = iVar1;
}
iVar1 = iVar1 + -1;
} while (iVar1 != 1);
uVar2 = (ulong)(iVar6 - 1);
}
joined_r0x0010120f:
if (iVar6 < 1) {
do {
/* WARNING: Do nothing block with infinite loop */
} while( true );
}
do {
piVar3 = local_1a8;
do {
if (iVar5 % *piVar3 != 0) {
iVar5 = iVar5 + param_1;
goto joined_r0x0010120f;
}
if (piVar3 == local_1a8 + uVar2) {
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar5;
}
piVar3 = piVar3 + 1;
} while (piVar3 != local_1a8 + iVar6);
} while( true );
} |
7,500 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
char key;
int value;
} KeyValue;
| KeyValue *func0(KeyValue d1[], int size1, KeyValue d2[], int size2) {
KeyValue *result = malloc((size1 + size2) * sizeof(KeyValue));
int sizeResult = 0;
for (int i = 0; i < size1; i++) {
int found = 0;
for (int j = 0; j < sizeResult; j++) {
if (result[j].key == d1[i].key) {
result[j].value += d1[i].value;
found = 1;
break;
}
}
if (!found) {
result[sizeResult].key = d1[i].key;
result[sizeResult].value = d1[i].value;
sizeResult++;
}
}
for (int i = 0; i < size2; i++) {
int found = 0;
for (int j = 0; j < sizeResult; j++) {
if (result[j].key == d2[i].key) {
result[j].value += d2[i].value;
found = 1;
break;
}
}
if (!found) {
result[sizeResult].key = d2[i].key;
result[sizeResult].value = d2[i].value;
sizeResult++;
}
}
return result;
}
| int main() {
KeyValue d1[] = { {'a', 100}, {'b', 200}, {'c', 300} };
KeyValue d2[] = { {'a', 300}, {'b', 200}, {'d', 400} };
KeyValue *result1 = func0(d1, 3, d2, 3);
assert(result1[0].value == 400 && result1[1].value == 400 && result1[2].value == 300 && result1[3].value == 400); // Since order may vary, checks are grouped by values only
KeyValue d3[] = { {'a', 500}, {'b', 700}, {'c', 900} };
KeyValue d4[] = { {'a', 500}, {'b', 600}, {'d', 900} };
KeyValue *result2 = func0(d3, 3, d4, 3);
assert(result2[0].value == 1000 && result2[1].value == 1300 && result2[2].value == 900 && result2[3].value == 900); // Since order may vary, checks are grouped by values only
KeyValue d5[] = { {'a', 900}, {'b', 900}, {'d', 900} };
KeyValue d6[] = { {'a', 900}, {'b', 900}, {'d', 900} };
KeyValue *result3 = func0(d5, 3, d6, 3);
assert(result3[0].value == 1800 && result3[1].value == 1800 && result3[2].value == 1800); // Since order may vary, checks are grouped by values only
free(result1);
free(result2);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %rdx,-0x48(%rbp)
mov %ecx,-0x40(%rbp)
mov -0x3c(%rbp),%edx
mov -0x40(%rbp),%eax
add %edx,%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
jmpq 1300 <func0+0x157>
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
jmpq 1289 <func0+0xe0>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 1285 <func0+0xdc>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%ecx
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%edx
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rsi
mov -0x8(%rbp),%rax
add %rsi,%rax
add %ecx,%edx
mov %edx,0x4(%rax)
movl $0x1,-0x1c(%rbp)
jmp 1295 <func0+0xec>
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 1203 <func0+0x5a>
cmpl $0x0,-0x1c(%rbp)
jne 12fc <func0+0x153>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
movzbl (%rax),%eax
mov %al,(%rdx)
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov 0x4(%rax),%eax
mov %eax,0x4(%rdx)
addl $0x1,-0x24(%rbp)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 11f0 <func0+0x47>
movl $0x0,-0x14(%rbp)
jmpq 1428 <func0+0x27f>
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 13b1 <func0+0x208>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x48(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 13ad <func0+0x204>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%ecx
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%edx
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rsi
mov -0x8(%rbp),%rax
add %rsi,%rax
add %ecx,%edx
mov %edx,0x4(%rax)
movl $0x1,-0x10(%rbp)
jmp 13bd <func0+0x214>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 132b <func0+0x182>
cmpl $0x0,-0x10(%rbp)
jne 1424 <func0+0x27b>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
movzbl (%rax),%eax
mov %al,(%rdx)
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov 0x4(%rax),%eax
mov %eax,0x4(%rdx)
addl $0x1,-0x24(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x40(%rbp),%eax
jl 1318 <func0+0x16f>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_48], rdx
mov [rbp+var_40], ecx
mov edx, [rbp+var_3C]
mov eax, [rbp+var_40]
add eax, edx
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_24], 0
mov [rbp+var_20], 0
jmp loc_1300
loc_11F0:
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
jmp loc_1289
loc_1203:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_20]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_1285
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
mov ecx, [rax+4]
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rax+4]
mov eax, [rbp+var_18]
cdqe
lea rsi, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rsi
add edx, ecx
mov [rax+4], edx
mov [rbp+var_1C], 1
jmp short loc_1295
loc_1285:
add [rbp+var_18], 1
loc_1289:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_24]
jl loc_1203
loc_1295:
cmp [rbp+var_1C], 0
jnz short loc_12FC
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_8]
add rdx, rcx
movzx eax, byte ptr [rax]
mov [rdx], al
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_8]
add rdx, rcx
mov eax, [rax+4]
mov [rdx+4], eax
add [rbp+var_24], 1
loc_12FC:
add [rbp+var_20], 1
loc_1300:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_3C]
jl loc_11F0
mov [rbp+var_14], 0
jmp loc_1428
loc_1318:
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp loc_13B1
loc_132B:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_14]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_48]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_13AD
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
mov ecx, [rax+4]
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rax+4]
mov eax, [rbp+var_C]
cdqe
lea rsi, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rsi
add edx, ecx
mov [rax+4], edx
mov [rbp+var_10], 1
jmp short loc_13BD
loc_13AD:
add [rbp+var_C], 1
loc_13B1:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_24]
jl loc_132B
loc_13BD:
cmp [rbp+var_10], 0
jnz short loc_1424
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_8]
add rdx, rcx
movzx eax, byte ptr [rax]
mov [rdx], al
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_8]
add rdx, rcx
mov eax, [rax+4]
mov [rdx+4], eax
add [rbp+var_24], 1
loc_1424:
add [rbp+var_14], 1
loc_1428:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_40]
jl loc_1318
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2, long long a3, int a4)
{
int v7; // [rsp+2Ch] [rbp-24h]
int i; // [rsp+30h] [rbp-20h]
int v9; // [rsp+34h] [rbp-1Ch]
int j; // [rsp+38h] [rbp-18h]
int k; // [rsp+3Ch] [rbp-14h]
int v12; // [rsp+40h] [rbp-10h]
int m; // [rsp+44h] [rbp-Ch]
_DWORD *v14; // [rsp+48h] [rbp-8h]
v14 = malloc(8LL * (a2 + a4));
v7 = 0;
for ( i = 0; i < a2; ++i )
{
v9 = 0;
for ( j = 0; j < v7; ++j )
{
if ( LOBYTE(v14[2 * j]) == *(_BYTE *)(8LL * i + a1) )
{
v14[2 * j + 1] += *(_DWORD *)(8LL * i + a1 + 4);
v9 = 1;
break;
}
}
if ( !v9 )
{
LOBYTE(v14[2 * v7]) = *(_BYTE *)(8LL * i + a1);
v14[2 * v7++ + 1] = *(_DWORD *)(8LL * i + a1 + 4);
}
}
for ( k = 0; k < a4; ++k )
{
v12 = 0;
for ( m = 0; m < v7; ++m )
{
if ( LOBYTE(v14[2 * m]) == *(_BYTE *)(8LL * k + a3) )
{
v14[2 * m + 1] += *(_DWORD *)(8LL * k + a3 + 4);
v12 = 1;
break;
}
}
if ( !v12 )
{
LOBYTE(v14[2 * v7]) = *(_BYTE *)(8LL * k + a3);
v14[2 * v7++ + 1] = *(_DWORD *)(8LL * k + a3 + 4);
}
}
return v14;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV dword ptr [RBP + -0x40],ECX
MOV EDX,dword ptr [RBP + -0x3c]
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,EDX
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101300
LAB_001011f0:
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101289
LAB_00101203:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x00101285
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV ECX,dword ptr [RAX + 0x4]
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0x4]
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RSI,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RSI
ADD EDX,ECX
MOV dword ptr [RAX + 0x4],EDX
MOV dword ptr [RBP + -0x1c],0x1
JMP 0x00101295
LAB_00101285:
ADD dword ptr [RBP + -0x18],0x1
LAB_00101289:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00101203
LAB_00101295:
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x001012fc
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RDX],AL
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RDX + 0x4],EAX
ADD dword ptr [RBP + -0x24],0x1
LAB_001012fc:
ADD dword ptr [RBP + -0x20],0x1
LAB_00101300:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x001011f0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101428
LAB_00101318:
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001013b1
LAB_0010132b:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x001013ad
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV ECX,dword ptr [RAX + 0x4]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0x4]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RSI,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RSI
ADD EDX,ECX
MOV dword ptr [RAX + 0x4],EDX
MOV dword ptr [RBP + -0x10],0x1
JMP 0x001013bd
LAB_001013ad:
ADD dword ptr [RBP + -0xc],0x1
LAB_001013b1:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x0010132b
LAB_001013bd:
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x00101424
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RDX],AL
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RDX + 0x4],EAX
ADD dword ptr [RBP + -0x24],0x1
LAB_00101424:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101428:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x40]
JL 0x00101318
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,long param_3,int param_4)
{
bool bVar1;
void *pvVar2;
int local_2c;
int local_28;
int local_20;
int local_1c;
int local_14;
pvVar2 = malloc((long)(param_4 + param_2) << 3);
local_2c = 0;
for (local_28 = 0; local_28 < param_2; local_28 = local_28 + 1) {
bVar1 = false;
for (local_20 = 0; local_20 < local_2c; local_20 = local_20 + 1) {
if (*(char *)((long)pvVar2 + (long)local_20 * 8) == *(char *)(param_1 + (long)local_28 * 8)) {
*(int *)((long)pvVar2 + (long)local_20 * 8 + 4) =
*(int *)(param_1 + (long)local_28 * 8 + 4) +
*(int *)((long)pvVar2 + (long)local_20 * 8 + 4);
bVar1 = true;
break;
}
}
if (!bVar1) {
*(int *)((long)pvVar2 + (long)local_2c * 8) =
*(int *)(param_1 + (long)local_28 * 8);
*(int4 *)((long)pvVar2 + (long)local_2c * 8 + 4) =
*(int4 *)(param_1 + (long)local_28 * 8 + 4);
local_2c = local_2c + 1;
}
}
local_1c = 0;
do {
if (param_4 <= local_1c) {
return pvVar2;
}
bVar1 = false;
for (local_14 = 0; local_14 < local_2c; local_14 = local_14 + 1) {
if (*(char *)((long)pvVar2 + (long)local_14 * 8) == *(char *)(param_3 + (long)local_1c * 8)) {
*(int *)((long)pvVar2 + (long)local_14 * 8 + 4) =
*(int *)(param_3 + (long)local_1c * 8 + 4) +
*(int *)((long)pvVar2 + (long)local_14 * 8 + 4);
bVar1 = true;
break;
}
}
if (!bVar1) {
*(int *)((long)pvVar2 + (long)local_2c * 8) =
*(int *)(param_3 + (long)local_1c * 8);
*(int4 *)((long)pvVar2 + (long)local_2c * 8 + 4) =
*(int4 *)(param_3 + (long)local_1c * 8 + 4);
local_2c = local_2c + 1;
}
local_1c = local_1c + 1;
} while( true );
} |
7,501 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
char key;
int value;
} KeyValue;
| KeyValue *func0(KeyValue d1[], int size1, KeyValue d2[], int size2) {
KeyValue *result = malloc((size1 + size2) * sizeof(KeyValue));
int sizeResult = 0;
for (int i = 0; i < size1; i++) {
int found = 0;
for (int j = 0; j < sizeResult; j++) {
if (result[j].key == d1[i].key) {
result[j].value += d1[i].value;
found = 1;
break;
}
}
if (!found) {
result[sizeResult].key = d1[i].key;
result[sizeResult].value = d1[i].value;
sizeResult++;
}
}
for (int i = 0; i < size2; i++) {
int found = 0;
for (int j = 0; j < sizeResult; j++) {
if (result[j].key == d2[i].key) {
result[j].value += d2[i].value;
found = 1;
break;
}
}
if (!found) {
result[sizeResult].key = d2[i].key;
result[sizeResult].value = d2[i].value;
sizeResult++;
}
}
return result;
}
| int main() {
KeyValue d1[] = { {'a', 100}, {'b', 200}, {'c', 300} };
KeyValue d2[] = { {'a', 300}, {'b', 200}, {'d', 400} };
KeyValue *result1 = func0(d1, 3, d2, 3);
assert(result1[0].value == 400 && result1[1].value == 400 && result1[2].value == 300 && result1[3].value == 400); // Since order may vary, checks are grouped by values only
KeyValue d3[] = { {'a', 500}, {'b', 700}, {'c', 900} };
KeyValue d4[] = { {'a', 500}, {'b', 600}, {'d', 900} };
KeyValue *result2 = func0(d3, 3, d4, 3);
assert(result2[0].value == 1000 && result2[1].value == 1300 && result2[2].value == 900 && result2[3].value == 900); // Since order may vary, checks are grouped by values only
KeyValue d5[] = { {'a', 900}, {'b', 900}, {'d', 900} };
KeyValue d6[] = { {'a', 900}, {'b', 900}, {'d', 900} };
KeyValue *result3 = func0(d5, 3, d6, 3);
assert(result3[0].value == 1800 && result3[1].value == 1800 && result3[2].value == 1800); // Since order may vary, checks are grouped by values only
free(result1);
free(result2);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%r12d
mov %rdx,%rbp
mov %ecx,%ebx
lea (%rsi,%rcx,1),%edi
movslq %edi,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 1243 <func0+0x9a>
mov %r13,%r9
lea -0x1(%r12),%edx
lea 0x8(%r13,%rdx,8),%r11
mov $0x0,%r8d
lea 0x8(%rax),%r12
jmp 1219 <func0+0x70>
mov 0x4(%r10),%edx
add %edx,0x4(%rcx)
jmp 1210 <func0+0x67>
movslq %r8d,%rdx
lea (%rax,%rdx,8),%rdx
movzbl (%r9),%ecx
mov %cl,(%rdx)
mov 0x4(%r9),%ecx
mov %ecx,0x4(%rdx)
add $0x1,%r8d
add $0x8,%r9
cmp %r11,%r9
je 1249 <func0+0xa0>
test %r8d,%r8d
jle 11f8 <func0+0x4f>
mov %r9,%r10
movzbl (%r9),%esi
mov %rax,%rdx
lea -0x1(%r8),%ecx
lea (%r12,%rcx,8),%rdi
mov %rdx,%rcx
cmp %sil,(%rdx)
je 11ef <func0+0x46>
add $0x8,%rdx
cmp %rdi,%rdx
jne 1230 <func0+0x87>
jmp 11f8 <func0+0x4f>
mov $0x0,%r8d
test %ebx,%ebx
jle 12b2 <func0+0x109>
mov %rbp,%r9
lea -0x1(%rbx),%edx
lea 0x8(%rbp,%rdx,8),%r11
lea 0x8(%rax),%rbx
jmp 1288 <func0+0xdf>
mov 0x4(%r10),%edx
add %edx,0x4(%rcx)
jmp 127f <func0+0xd6>
movslq %r8d,%rdx
lea (%rax,%rdx,8),%rdx
movzbl (%r9),%ecx
mov %cl,(%rdx)
mov 0x4(%r9),%ecx
mov %ecx,0x4(%rdx)
add $0x1,%r8d
add $0x8,%r9
cmp %r11,%r9
je 12b2 <func0+0x109>
test %r8d,%r8d
jle 1267 <func0+0xbe>
mov %r9,%r10
movzbl (%r9),%esi
mov %rax,%rdx
lea -0x1(%r8),%ecx
lea (%rbx,%rcx,8),%rdi
mov %rdx,%rcx
cmp %sil,(%rdx)
je 125e <func0+0xb5>
add $0x8,%rdx
cmp %rdi,%rdx
jne 129f <func0+0xf6>
jmp 1267 <func0+0xbe>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rdi
mov r12d, esi
mov rbp, rdx
mov ebx, ecx
lea edi, [rsi+rcx]
movsxd rdi, edi
shl rdi, 3
call _malloc
mov r9, rax
test r12d, r12d
jle short loc_1241
mov r8, r13
lea eax, [r12-1]
lea r11, [r13+rax*8+8]
mov edi, 0
lea r12, [r9+8]
jmp short loc_121A
loc_11F1:
mov eax, [r10+4]
add [rdx+4], eax
jmp short loc_1211
loc_11FA:
movsxd rax, edi
lea rax, [r9+rax*8]
movzx edx, byte ptr [r8]
mov [rax], dl
mov edx, [r8+4]
mov [rax+4], edx
add edi, 1
loc_1211:
add r8, 8
cmp r8, r11
jz short loc_1246
loc_121A:
test edi, edi
jle short loc_11FA
mov r10, r8
movzx ecx, byte ptr [r8]
mov rax, r9
lea edx, [rdi-1]
lea rsi, [r12+rdx*8]
loc_122F:
mov rdx, rax
cmp [rax], cl
jz short loc_11F1
add rax, 8
cmp rax, rsi
jnz short loc_122F
jmp short loc_11FA
loc_1241:
mov edi, 0
loc_1246:
test ebx, ebx
jle short loc_12AB
mov r8, rbp
lea eax, [rbx-1]
lea r11, [rbp+rax*8+8]
lea rbx, [r9+8]
jmp short loc_1284
loc_125B:
mov eax, [r10+4]
add [rdx+4], eax
jmp short loc_127B
loc_1264:
movsxd rax, edi
lea rax, [r9+rax*8]
movzx edx, byte ptr [r8]
mov [rax], dl
mov edx, [r8+4]
mov [rax+4], edx
add edi, 1
loc_127B:
add r8, 8
cmp r8, r11
jz short loc_12AB
loc_1284:
test edi, edi
jle short loc_1264
mov r10, r8
movzx ecx, byte ptr [r8]
mov rax, r9
lea edx, [rdi-1]
lea rsi, [rbx+rdx*8]
loc_1299:
mov rdx, rax
cmp [rax], cl
jz short loc_125B
add rax, 8
cmp rax, rsi
jnz short loc_1299
jmp short loc_1264
loc_12AB:
mov rax, r9
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(long long a1, int a2, long long a3, int a4)
{
long long v7; // r9
long long v8; // r8
int v9; // edi
long long v10; // rax
long long v11; // rax
long long v12; // r8
long long v13; // rax
long long v14; // rax
v7 = malloc(8LL * (a2 + a4));
if ( a2 <= 0 )
{
v9 = 0;
}
else
{
v8 = a1;
v9 = 0;
do
{
if ( v9 <= 0 )
{
LABEL_4:
v10 = v7 + 8LL * v9;
*(_BYTE *)v10 = *(_BYTE *)v8;
*(_DWORD *)(v10 + 4) = *(_DWORD *)(v8 + 4);
++v9;
}
else
{
v11 = v7;
while ( *(_BYTE *)v11 != *(_BYTE *)v8 )
{
v11 += 8LL;
if ( v11 == v7 + 8 + 8LL * (unsigned int)(v9 - 1) )
goto LABEL_4;
}
*(_DWORD *)(v11 + 4) += *(_DWORD *)(v8 + 4);
}
v8 += 8LL;
}
while ( v8 != a1 + 8LL * (unsigned int)(a2 - 1) + 8 );
}
if ( a4 > 0 )
{
v12 = a3;
do
{
if ( v9 <= 0 )
{
LABEL_15:
v13 = v7 + 8LL * v9;
*(_BYTE *)v13 = *(_BYTE *)v12;
*(_DWORD *)(v13 + 4) = *(_DWORD *)(v12 + 4);
++v9;
}
else
{
v14 = v7;
while ( *(_BYTE *)v14 != *(_BYTE *)v12 )
{
v14 += 8LL;
if ( v14 == v7 + 8 + 8LL * (unsigned int)(v9 - 1) )
goto LABEL_15;
}
*(_DWORD *)(v14 + 4) += *(_DWORD *)(v12 + 4);
}
v12 += 8LL;
}
while ( v12 != a3 + 8LL * (unsigned int)(a4 - 1) + 8 );
}
return v7;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV R12D,ESI
MOV RBP,RDX
MOV EBX,ECX
LEA EDI,[RSI + RCX*0x1]
MOVSXD RDI,EDI
SHL RDI,0x3
CALL 0x001010b0
MOV R9,RAX
TEST R12D,R12D
JLE 0x00101241
MOV R8,R13
LEA EAX,[R12 + -0x1]
LEA R11,[R13 + RAX*0x8 + 0x8]
MOV EDI,0x0
LEA R12,[R9 + 0x8]
JMP 0x0010121a
LAB_001011f1:
MOV EAX,dword ptr [R10 + 0x4]
ADD dword ptr [RDX + 0x4],EAX
JMP 0x00101211
LAB_001011fa:
MOVSXD RAX,EDI
LEA RAX,[R9 + RAX*0x8]
MOVZX EDX,byte ptr [R8]
MOV byte ptr [RAX],DL
MOV EDX,dword ptr [R8 + 0x4]
MOV dword ptr [RAX + 0x4],EDX
ADD EDI,0x1
LAB_00101211:
ADD R8,0x8
CMP R8,R11
JZ 0x00101246
LAB_0010121a:
TEST EDI,EDI
JLE 0x001011fa
MOV R10,R8
MOVZX ECX,byte ptr [R8]
MOV RAX,R9
LEA EDX,[RDI + -0x1]
LEA RSI,[R12 + RDX*0x8]
LAB_0010122f:
MOV RDX,RAX
CMP byte ptr [RAX],CL
JZ 0x001011f1
ADD RAX,0x8
CMP RAX,RSI
JNZ 0x0010122f
JMP 0x001011fa
LAB_00101241:
MOV EDI,0x0
LAB_00101246:
TEST EBX,EBX
JLE 0x001012ab
MOV R8,RBP
LEA EAX,[RBX + -0x1]
LEA R11,[RBP + RAX*0x8 + 0x8]
LEA RBX,[R9 + 0x8]
JMP 0x00101284
LAB_0010125b:
MOV EAX,dword ptr [R10 + 0x4]
ADD dword ptr [RDX + 0x4],EAX
JMP 0x0010127b
LAB_00101264:
MOVSXD RAX,EDI
LEA RAX,[R9 + RAX*0x8]
MOVZX EDX,byte ptr [R8]
MOV byte ptr [RAX],DL
MOV EDX,dword ptr [R8 + 0x4]
MOV dword ptr [RAX + 0x4],EDX
ADD EDI,0x1
LAB_0010127b:
ADD R8,0x8
CMP R8,R11
JZ 0x001012ab
LAB_00101284:
TEST EDI,EDI
JLE 0x00101264
MOV R10,R8
MOVZX ECX,byte ptr [R8]
MOV RAX,R9
LEA EDX,[RDI + -0x1]
LEA RSI,[RBX + RDX*0x8]
LAB_00101299:
MOV RDX,RAX
CMP byte ptr [RAX],CL
JZ 0x0010125b
ADD RAX,0x8
CMP RAX,RSI
JNZ 0x00101299
JMP 0x00101264
LAB_001012ab:
MOV RAX,R9
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | char * func0(char *param_1,int param_2,char *param_3,int param_4)
{
char *pcVar1;
char *pcVar2;
char *pcVar3;
int iVar4;
pcVar2 = (char *)malloc((long)(param_2 + param_4) << 3);
if (param_2 < 1) {
iVar4 = 0;
}
else {
pcVar1 = param_1 + (ulong)(param_2 - 1) * 8 + 8;
iVar4 = 0;
do {
if (0 < iVar4) {
pcVar3 = pcVar2;
do {
if (*pcVar3 == *param_1) {
*(int *)(pcVar3 + 4) = *(int *)(pcVar3 + 4) + *(int *)(param_1 + 4);
goto LAB_00101211;
}
pcVar3 = pcVar3 + 8;
} while (pcVar3 != pcVar2 + (ulong)(iVar4 - 1) * 8 + 8);
}
pcVar2[(long)iVar4 * 8] = *param_1;
*(int4 *)(pcVar2 + (long)iVar4 * 8 + 4) = *(int4 *)(param_1 + 4);
iVar4 = iVar4 + 1;
LAB_00101211:
param_1 = param_1 + 8;
} while (param_1 != pcVar1);
}
if (0 < param_4) {
pcVar1 = param_3 + (ulong)(param_4 - 1) * 8 + 8;
do {
if (0 < iVar4) {
pcVar3 = pcVar2;
do {
if (*pcVar3 == *param_3) {
*(int *)(pcVar3 + 4) = *(int *)(pcVar3 + 4) + *(int *)(param_3 + 4);
goto LAB_0010127b;
}
pcVar3 = pcVar3 + 8;
} while (pcVar3 != pcVar2 + (ulong)(iVar4 - 1) * 8 + 8);
}
pcVar2[(long)iVar4 * 8] = *param_3;
*(int4 *)(pcVar2 + (long)iVar4 * 8 + 4) = *(int4 *)(param_3 + 4);
iVar4 = iVar4 + 1;
LAB_0010127b:
param_3 = param_3 + 8;
} while (param_3 != pcVar1);
}
return pcVar2;
} |
7,502 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
char key;
int value;
} KeyValue;
| KeyValue *func0(KeyValue d1[], int size1, KeyValue d2[], int size2) {
KeyValue *result = malloc((size1 + size2) * sizeof(KeyValue));
int sizeResult = 0;
for (int i = 0; i < size1; i++) {
int found = 0;
for (int j = 0; j < sizeResult; j++) {
if (result[j].key == d1[i].key) {
result[j].value += d1[i].value;
found = 1;
break;
}
}
if (!found) {
result[sizeResult].key = d1[i].key;
result[sizeResult].value = d1[i].value;
sizeResult++;
}
}
for (int i = 0; i < size2; i++) {
int found = 0;
for (int j = 0; j < sizeResult; j++) {
if (result[j].key == d2[i].key) {
result[j].value += d2[i].value;
found = 1;
break;
}
}
if (!found) {
result[sizeResult].key = d2[i].key;
result[sizeResult].value = d2[i].value;
sizeResult++;
}
}
return result;
}
| int main() {
KeyValue d1[] = { {'a', 100}, {'b', 200}, {'c', 300} };
KeyValue d2[] = { {'a', 300}, {'b', 200}, {'d', 400} };
KeyValue *result1 = func0(d1, 3, d2, 3);
assert(result1[0].value == 400 && result1[1].value == 400 && result1[2].value == 300 && result1[3].value == 400); // Since order may vary, checks are grouped by values only
KeyValue d3[] = { {'a', 500}, {'b', 700}, {'c', 900} };
KeyValue d4[] = { {'a', 500}, {'b', 600}, {'d', 900} };
KeyValue *result2 = func0(d3, 3, d4, 3);
assert(result2[0].value == 1000 && result2[1].value == 1300 && result2[2].value == 900 && result2[3].value == 900); // Since order may vary, checks are grouped by values only
KeyValue d5[] = { {'a', 900}, {'b', 900}, {'d', 900} };
KeyValue d6[] = { {'a', 900}, {'b', 900}, {'d', 900} };
KeyValue *result3 = func0(d5, 3, d6, 3);
assert(result3[0].value == 1800 && result3[1].value == 1800 && result3[2].value == 1800); // Since order may vary, checks are grouped by values only
free(result1);
free(result2);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %esi,%r13d
push %r12
mov %ecx,%r12d
push %rbp
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
lea (%rsi,%rcx,1),%edi
movslq %edi,%rdi
shl $0x3,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %r13d,%r13d
jle 1584 <func0+0x124>
lea -0x1(%r13),%edx
mov %rbx,%r10
xor %r9d,%r9d
lea 0x8(%rbx,%rdx,8),%r11
lea 0x8(%rax),%rdx
nopl (%rax)
movzbl (%r10),%edi
test %r9d,%r9d
je 1550 <func0+0xf0>
lea -0x1(%r9),%r8d
mov %rax,%rsi
lea (%rdx,%r8,8),%r8
jmp 14d1 <func0+0x71>
nopw 0x0(%rax,%rax,1)
add $0x8,%rsi
cmp %rsi,%r8
je 1550 <func0+0xf0>
cmp %dil,(%rsi)
jne 14c8 <func0+0x68>
mov 0x4(%r10),%ecx
add %ecx,0x4(%rsi)
add $0x8,%r10
cmp %r11,%r10
jne 14a8 <func0+0x48>
test %r12d,%r12d
jle 153b <func0+0xdb>
lea -0x1(%r12),%edx
lea 0x4(%rbp),%rdi
lea 0xc(%rbp,%rdx,8),%r8
lea 0x8(%rax),%r10
nopl (%rax)
movzbl -0x4(%rdi),%ecx
test %r9d,%r9d
je 1570 <func0+0x110>
lea -0x1(%r9),%esi
mov %rax,%rdx
lea (%r10,%rsi,8),%rsi
jmp 1529 <func0+0xc9>
nopw %cs:0x0(%rax,%rax,1)
add $0x8,%rdx
cmp %rdx,%rsi
je 1570 <func0+0x110>
cmp %cl,(%rdx)
jne 1520 <func0+0xc0>
mov (%rdi),%ecx
add %ecx,0x4(%rdx)
add $0x8,%rdi
cmp %r8,%rdi
jne 1500 <func0+0xa0>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
movslq %r9d,%rcx
add $0x1,%r9d
lea (%rax,%rcx,8),%rsi
mov 0x4(%r10),%ecx
mov %dil,(%rsi)
mov %ecx,0x4(%rsi)
jmpq 14dd <func0+0x7d>
nopw 0x0(%rax,%rax,1)
movslq %r9d,%rdx
add $0x1,%r9d
lea (%rax,%rdx,8),%rdx
mov %cl,(%rdx)
mov (%rdi),%ecx
mov %ecx,0x4(%rdx)
jmp 1532 <func0+0xd2>
xor %r9d,%r9d
jmpq 14e6 <func0+0x86>
nopl 0x0(%rax)
| func0:
endbr64
push r13
mov r13d, esi
push r12
mov r12d, ecx
push rbp
mov rbp, rdx
push rbx
mov rbx, rdi
lea edi, [rsi+rcx]
movsxd rdi, edi
shl rdi, 3
sub rsp, 8
call _malloc
mov r8, rax
test r13d, r13d
jle loc_1583
lea eax, [r13-1]
mov rdi, rbx
lea r10, [r8+8]
xor esi, esi
lea r9, [rbx+rax*8+8]
nop word ptr [rax+rax+00000000h]
loc_14B0:
movzx edx, byte ptr [rdi]
test esi, esi
jz loc_1550
lea ecx, [rsi-1]
mov rax, r8
lea rcx, [r10+rcx*8]
jmp short loc_14D9
loc_14D0:
add rax, 8
cmp rax, rcx
jz short loc_1550
loc_14D9:
cmp [rax], dl
jnz short loc_14D0
mov edx, [rdi+4]
add [rax+4], edx
loc_14E3:
add rdi, 8
cmp rdi, r9
jnz short loc_14B0
loc_14EC:
test r12d, r12d
jle short loc_153B
lea eax, [r12-1]
lea rdi, [rbp+4]
lea r9, [rbp+rax*8+0Ch]
lea r10, [r8+8]
nop dword ptr [rax+rax+00h]
loc_1508:
movzx edx, byte ptr [rdi-4]
test esi, esi
jz short loc_1570
lea ecx, [rsi-1]
mov rax, r8
lea rcx, [r10+rcx*8]
jmp short loc_1529
loc_1520:
add rax, 8
cmp rcx, rax
jz short loc_1570
loc_1529:
cmp [rax], dl
jnz short loc_1520
mov edx, [rdi]
add [rax+4], edx
loc_1532:
add rdi, 8
cmp rdi, r9
jnz short loc_1508
loc_153B:
add rsp, 8
mov rax, r8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1550:
movsxd rax, esi
add esi, 1
lea rax, [r8+rax*8]
mov [rax], dl
mov edx, [rdi+4]
mov [rax+4], edx
jmp loc_14E3
loc_1570:
movsxd rax, esi
add esi, 1
lea rax, [r8+rax*8]
mov [rax], dl
mov edx, [rdi]
mov [rax+4], edx
jmp short loc_1532
loc_1583:
xor esi, esi
jmp loc_14EC | long long func0(char *a1, int a2, long long a3, int a4)
{
char *v7; // rbx
long long v8; // r8
int v9; // esi
char v10; // dl
long long v11; // rax
_DWORD *v12; // rdi
char v13; // dl
long long v14; // rax
long long v16; // rax
long long v17; // rax
long long v18; // rax
long long v19; // rax
v7 = a1;
v8 = malloc(8LL * (a2 + a4));
if ( a2 <= 0 )
{
v9 = 0;
}
else
{
v9 = 0;
do
{
v10 = *a1;
if ( v9 )
{
v11 = v8;
while ( *(_BYTE *)v11 != v10 )
{
v11 += 8LL;
if ( v11 == v8 + 8 + 8LL * (unsigned int)(v9 - 1) )
goto LABEL_18;
}
*(_DWORD *)(v11 + 4) += *((_DWORD *)a1 + 1);
}
else
{
LABEL_18:
v16 = v9++;
v17 = v8 + 8 * v16;
*(_BYTE *)v17 = v10;
*(_DWORD *)(v17 + 4) = *((_DWORD *)a1 + 1);
}
a1 += 8;
}
while ( a1 != &v7[8 * (a2 - 1) + 8] );
}
if ( a4 > 0 )
{
v12 = (_DWORD *)(a3 + 4);
do
{
v13 = *((_BYTE *)v12 - 4);
if ( v9 )
{
v14 = v8;
while ( *(_BYTE *)v14 != v13 )
{
v14 += 8LL;
if ( v8 + 8 + 8LL * (unsigned int)(v9 - 1) == v14 )
goto LABEL_19;
}
*(_DWORD *)(v14 + 4) += *v12;
}
else
{
LABEL_19:
v18 = v9++;
v19 = v8 + 8 * v18;
*(_BYTE *)v19 = v13;
*(_DWORD *)(v19 + 4) = *v12;
}
v12 += 2;
}
while ( v12 != (_DWORD *)(a3 + 8LL * (unsigned int)(a4 - 1) + 12) );
}
return v8;
} | func0:
ENDBR64
PUSH R13
MOV R13D,ESI
PUSH R12
MOV R12D,ECX
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
LEA EDI,[RSI + RCX*0x1]
MOVSXD RDI,EDI
SHL RDI,0x3
SUB RSP,0x8
CALL 0x001010b0
MOV R8,RAX
TEST R13D,R13D
JLE 0x00101583
LEA EAX,[R13 + -0x1]
MOV RDI,RBX
LEA R10,[R8 + 0x8]
XOR ESI,ESI
LEA R9,[RBX + RAX*0x8 + 0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_001014b0:
MOVZX EDX,byte ptr [RDI]
TEST ESI,ESI
JZ 0x00101550
LEA ECX,[RSI + -0x1]
MOV RAX,R8
LEA RCX,[R10 + RCX*0x8]
JMP 0x001014d9
LAB_001014d0:
ADD RAX,0x8
CMP RAX,RCX
JZ 0x00101550
LAB_001014d9:
CMP byte ptr [RAX],DL
JNZ 0x001014d0
MOV EDX,dword ptr [RDI + 0x4]
ADD dword ptr [RAX + 0x4],EDX
LAB_001014e3:
ADD RDI,0x8
CMP RDI,R9
JNZ 0x001014b0
LAB_001014ec:
TEST R12D,R12D
JLE 0x0010153b
LEA EAX,[R12 + -0x1]
LEA RDI,[RBP + 0x4]
LEA R9,[RBP + RAX*0x8 + 0xc]
LEA R10,[R8 + 0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101508:
MOVZX EDX,byte ptr [RDI + -0x4]
TEST ESI,ESI
JZ 0x00101570
LEA ECX,[RSI + -0x1]
MOV RAX,R8
LEA RCX,[R10 + RCX*0x8]
JMP 0x00101529
LAB_00101520:
ADD RAX,0x8
CMP RCX,RAX
JZ 0x00101570
LAB_00101529:
CMP byte ptr [RAX],DL
JNZ 0x00101520
MOV EDX,dword ptr [RDI]
ADD dword ptr [RAX + 0x4],EDX
LAB_00101532:
ADD RDI,0x8
CMP RDI,R9
JNZ 0x00101508
LAB_0010153b:
ADD RSP,0x8
MOV RAX,R8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101550:
MOVSXD RAX,ESI
ADD ESI,0x1
LEA RAX,[R8 + RAX*0x8]
MOV byte ptr [RAX],DL
MOV EDX,dword ptr [RDI + 0x4]
MOV dword ptr [RAX + 0x4],EDX
JMP 0x001014e3
LAB_00101570:
MOVSXD RAX,ESI
ADD ESI,0x1
LEA RAX,[R8 + RAX*0x8]
MOV byte ptr [RAX],DL
MOV EDX,dword ptr [RDI]
MOV dword ptr [RAX + 0x4],EDX
JMP 0x00101532
LAB_00101583:
XOR ESI,ESI
JMP 0x001014ec | char * func0(char *param_1,int param_2,long param_3,int param_4)
{
char *pcVar1;
char *pcVar2;
char *pcVar3;
long lVar4;
int iVar5;
int *piVar6;
pcVar1 = (char *)malloc((long)(param_2 + param_4) << 3);
if (param_2 < 1) {
iVar5 = 0;
}
else {
iVar5 = 0;
pcVar3 = param_1 + (ulong)(param_2 - 1) * 8 + 8;
do {
if (iVar5 != 0) {
pcVar2 = pcVar1;
do {
if (*pcVar2 == *param_1) {
*(int *)(pcVar2 + 4) = *(int *)(pcVar2 + 4) + *(int *)(param_1 + 4);
goto LAB_001014e3;
}
pcVar2 = pcVar2 + 8;
} while (pcVar2 != pcVar1 + (ulong)(iVar5 - 1) * 8 + 8);
}
lVar4 = (long)iVar5;
iVar5 = iVar5 + 1;
pcVar1[lVar4 * 8] = *param_1;
*(int4 *)(pcVar1 + lVar4 * 8 + 4) = *(int4 *)(param_1 + 4);
LAB_001014e3:
param_1 = param_1 + 8;
} while (param_1 != pcVar3);
}
if (0 < param_4) {
piVar6 = (int *)(param_3 + 4);
do {
if (iVar5 != 0) {
pcVar3 = pcVar1;
do {
if (*pcVar3 == (char)piVar6[-1]) {
*(int *)(pcVar3 + 4) = *(int *)(pcVar3 + 4) + *piVar6;
goto LAB_00101532;
}
pcVar3 = pcVar3 + 8;
} while (pcVar1 + (ulong)(iVar5 - 1) * 8 + 8 != pcVar3);
}
lVar4 = (long)iVar5;
iVar5 = iVar5 + 1;
pcVar1[lVar4 * 8] = (char)piVar6[-1];
*(int *)(pcVar1 + lVar4 * 8 + 4) = *piVar6;
LAB_00101532:
piVar6 = piVar6 + 2;
} while (piVar6 != (int *)(param_3 + 0xc + (ulong)(param_4 - 1) * 8));
}
return pcVar1;
} |
7,503 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
char key;
int value;
} KeyValue;
| KeyValue *func0(KeyValue d1[], int size1, KeyValue d2[], int size2) {
KeyValue *result = malloc((size1 + size2) * sizeof(KeyValue));
int sizeResult = 0;
for (int i = 0; i < size1; i++) {
int found = 0;
for (int j = 0; j < sizeResult; j++) {
if (result[j].key == d1[i].key) {
result[j].value += d1[i].value;
found = 1;
break;
}
}
if (!found) {
result[sizeResult].key = d1[i].key;
result[sizeResult].value = d1[i].value;
sizeResult++;
}
}
for (int i = 0; i < size2; i++) {
int found = 0;
for (int j = 0; j < sizeResult; j++) {
if (result[j].key == d2[i].key) {
result[j].value += d2[i].value;
found = 1;
break;
}
}
if (!found) {
result[sizeResult].key = d2[i].key;
result[sizeResult].value = d2[i].value;
sizeResult++;
}
}
return result;
}
| int main() {
KeyValue d1[] = { {'a', 100}, {'b', 200}, {'c', 300} };
KeyValue d2[] = { {'a', 300}, {'b', 200}, {'d', 400} };
KeyValue *result1 = func0(d1, 3, d2, 3);
assert(result1[0].value == 400 && result1[1].value == 400 && result1[2].value == 300 && result1[3].value == 400); // Since order may vary, checks are grouped by values only
KeyValue d3[] = { {'a', 500}, {'b', 700}, {'c', 900} };
KeyValue d4[] = { {'a', 500}, {'b', 600}, {'d', 900} };
KeyValue *result2 = func0(d3, 3, d4, 3);
assert(result2[0].value == 1000 && result2[1].value == 1300 && result2[2].value == 900 && result2[3].value == 900); // Since order may vary, checks are grouped by values only
KeyValue d5[] = { {'a', 900}, {'b', 900}, {'d', 900} };
KeyValue d6[] = { {'a', 900}, {'b', 900}, {'d', 900} };
KeyValue *result3 = func0(d5, 3, d6, 3);
assert(result3[0].value == 1800 && result3[1].value == 1800 && result3[2].value == 1800); // Since order may vary, checks are grouped by values only
free(result1);
free(result2);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
mov %esi,%r13d
push %r12
mov %ecx,%r12d
push %rbp
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
lea (%rsi,%rcx,1),%edi
movslq %edi,%rdi
shl $0x3,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %r13d,%r13d
jle 1584 <func0+0x124>
lea -0x1(%r13),%edx
mov %rbx,%r10
xor %r9d,%r9d
lea 0x8(%rbx,%rdx,8),%r11
lea 0x8(%rax),%rdx
nopl (%rax)
movzbl (%r10),%edi
test %r9d,%r9d
je 1550 <func0+0xf0>
lea -0x1(%r9),%r8d
mov %rax,%rsi
lea (%rdx,%r8,8),%r8
jmp 14d1 <func0+0x71>
nopw 0x0(%rax,%rax,1)
add $0x8,%rsi
cmp %rsi,%r8
je 1550 <func0+0xf0>
cmp %dil,(%rsi)
jne 14c8 <func0+0x68>
mov 0x4(%r10),%ecx
add %ecx,0x4(%rsi)
add $0x8,%r10
cmp %r11,%r10
jne 14a8 <func0+0x48>
test %r12d,%r12d
jle 153b <func0+0xdb>
lea -0x1(%r12),%edx
lea 0x4(%rbp),%rdi
lea 0xc(%rbp,%rdx,8),%r8
lea 0x8(%rax),%r10
nopl (%rax)
movzbl -0x4(%rdi),%ecx
test %r9d,%r9d
je 1570 <func0+0x110>
lea -0x1(%r9),%esi
mov %rax,%rdx
lea (%r10,%rsi,8),%rsi
jmp 1529 <func0+0xc9>
nopw %cs:0x0(%rax,%rax,1)
add $0x8,%rdx
cmp %rdx,%rsi
je 1570 <func0+0x110>
cmp %cl,(%rdx)
jne 1520 <func0+0xc0>
mov (%rdi),%ecx
add %ecx,0x4(%rdx)
add $0x8,%rdi
cmp %r8,%rdi
jne 1500 <func0+0xa0>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
movslq %r9d,%rcx
add $0x1,%r9d
lea (%rax,%rcx,8),%rsi
mov 0x4(%r10),%ecx
mov %dil,(%rsi)
mov %ecx,0x4(%rsi)
jmpq 14dd <func0+0x7d>
nopw 0x0(%rax,%rax,1)
movslq %r9d,%rdx
add $0x1,%r9d
lea (%rax,%rdx,8),%rdx
mov %cl,(%rdx)
mov (%rdi),%ecx
mov %ecx,0x4(%rdx)
jmp 1532 <func0+0xd2>
xor %r9d,%r9d
jmpq 14e6 <func0+0x86>
nopl 0x0(%rax)
| func0:
endbr64
push r13
movsxd r13, esi
push r12
movsxd r12, ecx
push rbp
mov rbp, rdi
lea edi, [r13+r12+0]
push rbx
movsxd rdi, edi
mov rbx, rdx
shl rdi, 3; size
sub rsp, 8
call _malloc
mov rdi, rax
test r13d, r13d
jle loc_1577
mov rsi, rbp
lea r10, [rbp+r13*8+0]
xor r8d, r8d
nop word ptr [rax+rax+00h]
loc_14A8:
movsxd r9, r8d
movzx edx, byte ptr [rsi]
lea rcx, [rdi+r9*8]
test r8d, r8d
jle short loc_14E8
loc_14B7:
mov rax, rdi
jmp short loc_14C9
loc_14C0:
add rax, 8
cmp rcx, rax
jz short loc_14E8
loc_14C9:
cmp [rax], dl
jnz short loc_14C0
mov edx, [rsi+4]
add rsi, 8
add [rax+4], edx
cmp r10, rsi
jz short loc_1501
movzx edx, byte ptr [rsi]
jmp short loc_14B7
loc_14E8:
lea rax, [rdi+r9*8]
add rsi, 8
add r8d, 1
mov [rax], dl
mov edx, [rsi-4]
mov [rax+4], edx
cmp rsi, r10
jnz short loc_14A8
loc_1501:
test r12d, r12d
jle short loc_1569
mov rsi, rbx
lea r10, [rbx+r12*8]
nop dword ptr [rax]
loc_1510:
movsxd r9, r8d
movzx edx, byte ptr [rsi]
lea rcx, [rdi+r9*8]
test r8d, r8d
jle short loc_1550
loc_151F:
mov rax, rdi
jmp short loc_1531
loc_1528:
add rax, 8
cmp rcx, rax
jz short loc_1550
loc_1531:
cmp [rax], dl
jnz short loc_1528
mov edx, [rsi+4]
add rsi, 8
add [rax+4], edx
cmp rsi, r10
jz short loc_1569
movzx edx, byte ptr [rsi]
jmp short loc_151F
loc_1550:
lea rax, [rdi+r9*8]
add rsi, 8
add r8d, 1
mov [rax], dl
mov edx, [rsi-4]
mov [rax+4], edx
cmp r10, rsi
jnz short loc_1510
loc_1569:
add rsp, 8
mov rax, rdi
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1577:
xor r8d, r8d
jmp short loc_1501 | char * func0(char *a1, int a2, char *a3, int a4)
{
long long v4; // r13
long long v5; // r12
char *v8; // rdi
char *v9; // rsi
char *v10; // r10
int v11; // r8d
char v12; // dl
char *v13; // rax
int v14; // edx
char *v15; // rax
char *v16; // rsi
char *v17; // r10
char v18; // dl
char *v19; // rax
int v20; // edx
char *v21; // rax
v4 = a2;
v5 = a4;
v8 = (char *)malloc(8LL * (a2 + a4));
if ( a2 <= 0 )
{
v11 = 0;
}
else
{
v9 = a1;
v10 = &a1[8 * v4];
v11 = 0;
while ( 1 )
{
v12 = *v9;
if ( v11 > 0 )
break;
LABEL_9:
v15 = &v8[8 * v11];
v9 += 8;
++v11;
*v15 = v12;
*((_DWORD *)v15 + 1) = *((_DWORD *)v9 - 1);
if ( v9 == v10 )
goto LABEL_10;
}
while ( 1 )
{
v13 = v8;
while ( *v13 != v12 )
{
v13 += 8;
if ( &v8[8 * v11] == v13 )
goto LABEL_9;
}
v14 = *((_DWORD *)v9 + 1);
v9 += 8;
*((_DWORD *)v13 + 1) += v14;
if ( v10 == v9 )
break;
v12 = *v9;
}
}
LABEL_10:
if ( (int)v5 > 0 )
{
v16 = a3;
v17 = &a3[8 * v5];
while ( 1 )
{
v18 = *v16;
if ( v11 > 0 )
break;
LABEL_18:
v21 = &v8[8 * v11];
v16 += 8;
++v11;
*v21 = v18;
*((_DWORD *)v21 + 1) = *((_DWORD *)v16 - 1);
if ( v17 == v16 )
return v8;
}
while ( 1 )
{
v19 = v8;
while ( *v19 != v18 )
{
v19 += 8;
if ( &v8[8 * v11] == v19 )
goto LABEL_18;
}
v20 = *((_DWORD *)v16 + 1);
v16 += 8;
*((_DWORD *)v19 + 1) += v20;
if ( v16 == v17 )
break;
v18 = *v16;
}
}
return v8;
} | func0:
ENDBR64
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOVSXD R12,ECX
PUSH RBP
MOV RBP,RDI
LEA EDI,[R13 + R12*0x1]
PUSH RBX
MOVSXD RDI,EDI
MOV RBX,RDX
SHL RDI,0x3
SUB RSP,0x8
CALL 0x001010b0
MOV RDI,RAX
TEST R13D,R13D
JLE 0x00101577
MOV RSI,RBP
LEA R10,[RBP + R13*0x8]
XOR R8D,R8D
NOP word ptr [RAX + RAX*0x1]
LAB_001014a8:
MOVSXD R9,R8D
MOVZX EDX,byte ptr [RSI]
LEA RCX,[RDI + R9*0x8]
TEST R8D,R8D
JLE 0x001014e8
LAB_001014b7:
MOV RAX,RDI
JMP 0x001014c9
LAB_001014c0:
ADD RAX,0x8
CMP RCX,RAX
JZ 0x001014e8
LAB_001014c9:
CMP byte ptr [RAX],DL
JNZ 0x001014c0
MOV EDX,dword ptr [RSI + 0x4]
ADD RSI,0x8
ADD dword ptr [RAX + 0x4],EDX
CMP R10,RSI
JZ 0x00101501
MOVZX EDX,byte ptr [RSI]
JMP 0x001014b7
LAB_001014e8:
LEA RAX,[RDI + R9*0x8]
ADD RSI,0x8
ADD R8D,0x1
MOV byte ptr [RAX],DL
MOV EDX,dword ptr [RSI + -0x4]
MOV dword ptr [RAX + 0x4],EDX
CMP RSI,R10
JNZ 0x001014a8
LAB_00101501:
TEST R12D,R12D
JLE 0x00101569
MOV RSI,RBX
LEA R10,[RBX + R12*0x8]
NOP dword ptr [RAX]
LAB_00101510:
MOVSXD R9,R8D
MOVZX EDX,byte ptr [RSI]
LEA RCX,[RDI + R9*0x8]
TEST R8D,R8D
JLE 0x00101550
LAB_0010151f:
MOV RAX,RDI
JMP 0x00101531
LAB_00101528:
ADD RAX,0x8
CMP RCX,RAX
JZ 0x00101550
LAB_00101531:
CMP byte ptr [RAX],DL
JNZ 0x00101528
MOV EDX,dword ptr [RSI + 0x4]
ADD RSI,0x8
ADD dword ptr [RAX + 0x4],EDX
CMP RSI,R10
JZ 0x00101569
MOVZX EDX,byte ptr [RSI]
JMP 0x0010151f
LAB_00101550:
LEA RAX,[RDI + R9*0x8]
ADD RSI,0x8
ADD R8D,0x1
MOV byte ptr [RAX],DL
MOV EDX,dword ptr [RSI + -0x4]
MOV dword ptr [RAX + 0x4],EDX
CMP R10,RSI
JNZ 0x00101510
LAB_00101569:
ADD RSP,0x8
MOV RAX,RDI
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101577:
XOR R8D,R8D
JMP 0x00101501 | char * func0(char *param_1,int param_2,char *param_3,int param_4)
{
int *piVar1;
char *pcVar2;
char *pcVar3;
char cVar4;
char *pcVar5;
int iVar6;
long lVar7;
pcVar2 = (char *)malloc((long)(param_2 + param_4) << 3);
if (param_2 < 1) {
iVar6 = 0;
}
else {
iVar6 = 0;
pcVar5 = param_1;
do {
lVar7 = (long)iVar6;
cVar4 = *pcVar5;
pcVar3 = pcVar2;
if (0 < iVar6) {
do {
while (*pcVar3 == cVar4) {
piVar1 = (int *)(pcVar5 + 4);
pcVar5 = pcVar5 + 8;
*(int *)(pcVar3 + 4) = *(int *)(pcVar3 + 4) + *piVar1;
if (param_1 + (long)param_2 * 8 == pcVar5) goto LAB_00101501;
pcVar3 = pcVar2;
cVar4 = *pcVar5;
}
pcVar3 = pcVar3 + 8;
} while (pcVar2 + lVar7 * 8 != pcVar3);
}
pcVar3 = pcVar5 + 8;
iVar6 = iVar6 + 1;
pcVar2[lVar7 * 8] = cVar4;
*(int4 *)(pcVar2 + lVar7 * 8 + 4) = *(int4 *)(pcVar5 + 4);
pcVar5 = pcVar3;
} while (pcVar3 != param_1 + (long)param_2 * 8);
}
LAB_00101501:
if (0 < param_4) {
pcVar5 = param_3;
do {
lVar7 = (long)iVar6;
cVar4 = *pcVar5;
pcVar3 = pcVar2;
if (0 < iVar6) {
do {
while (*pcVar3 == cVar4) {
piVar1 = (int *)(pcVar5 + 4);
pcVar5 = pcVar5 + 8;
*(int *)(pcVar3 + 4) = *(int *)(pcVar3 + 4) + *piVar1;
if (pcVar5 == param_3 + (long)param_4 * 8) {
return pcVar2;
}
pcVar3 = pcVar2;
cVar4 = *pcVar5;
}
pcVar3 = pcVar3 + 8;
} while (pcVar2 + lVar7 * 8 != pcVar3);
}
pcVar3 = pcVar5 + 8;
iVar6 = iVar6 + 1;
pcVar2[lVar7 * 8] = cVar4;
*(int4 *)(pcVar2 + lVar7 * 8 + 4) = *(int4 *)(pcVar5 + 4);
pcVar5 = pcVar3;
} while (param_3 + (long)param_4 * 8 != pcVar3);
}
return pcVar2;
} |
7,504 | func0 |
#include <assert.h>
| int func0(int n) {
int cnt = 0;
for (int i = 1; i <= n; i++) {
int temp = i;
while (temp) {
if (temp % 2 == 0) {
cnt++;
}
temp = temp / 2;
}
}
return cnt;
}
| int main() {
assert(func0(2) == 1);
assert(func0(5) == 4);
assert(func0(14) == 17);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
jmp 1193 <func0+0x4a>
mov -0x8(%rbp),%eax
mov %eax,-0x4(%rbp)
jmp 1189 <func0+0x40>
mov -0x4(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 117a <func0+0x31>
addl $0x1,-0xc(%rbp)
mov -0x4(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jne 116c <func0+0x23>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 1164 <func0+0x1b>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
mov [rbp+var_8], 1
jmp short loc_1193
loc_1164:
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
jmp short loc_1189
loc_116C:
mov eax, [rbp+var_4]
and eax, 1
test eax, eax
jnz short loc_117A
add [rbp+var_C], 1
loc_117A:
mov eax, [rbp+var_4]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_4], eax
loc_1189:
cmp [rbp+var_4], 0
jnz short loc_116C
add [rbp+var_8], 1
loc_1193:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_14]
jle short loc_1164
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(int a1)
{
unsigned int v2; // [rsp+8h] [rbp-Ch]
int i; // [rsp+Ch] [rbp-8h]
int j; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 1; i <= a1; ++i )
{
for ( j = i; j; j /= 2 )
{
if ( (j & 1) == 0 )
++v2;
}
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x1
JMP 0x00101193
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101189
LAB_0010116c:
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x0010117a
ADD dword ptr [RBP + -0xc],0x1
LAB_0010117a:
MOV EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
LAB_00101189:
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x0010116c
ADD dword ptr [RBP + -0x8],0x1
LAB_00101193:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x00101164
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(int param_1)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 1; (int)local_10 <= param_1; local_10 = local_10 + 1) {
for (local_c = local_10; local_c != 0; local_c = (int)local_c / 2) {
if ((local_c & 1) == 0) {
local_14 = local_14 + 1;
}
}
}
return local_14;
} |
7,505 | func0 |
#include <assert.h>
| int func0(int n) {
int cnt = 0;
for (int i = 1; i <= n; i++) {
int temp = i;
while (temp) {
if (temp % 2 == 0) {
cnt++;
}
temp = temp / 2;
}
}
return cnt;
}
| int main() {
assert(func0(2) == 1);
assert(func0(5) == 4);
assert(func0(14) == 17);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%esi
mov $0x0,%ecx
test %edi,%edi
jg 1160 <func0+0x17>
jmp 1185 <func0+0x3c>
add $0x1,%esi
mov %esi,%edx
test %esi,%esi
je 115d <func0+0x14>
mov %edx,%eax
and $0x1,%eax
cmp $0x1,%eax
adc $0x0,%ecx
mov %edx,%eax
shr $0x1f,%eax
add %edx,%eax
sar %eax
mov %eax,%edx
jne 1166 <func0+0x1d>
lea 0x1(%rsi),%eax
cmp %eax,%edi
jge 115d <func0+0x14>
mov %ecx,%eax
retq
| func0:
endbr64
mov r8d, 2
mov esi, 1
mov ecx, 0
test edi, edi
jg short loc_116A
jmp short loc_118D
loc_1163:
add esi, 1
add r8d, 1
loc_116A:
mov edx, esi
test esi, esi
jz short loc_1163
loc_1170:
mov eax, edx
and eax, 1
cmp eax, 1
adc ecx, 0
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
mov edx, eax
jnz short loc_1170
cmp edi, r8d
jge short loc_1163
loc_118D:
mov eax, ecx
retn | long long func0(int a1)
{
int v1; // r8d
int v2; // esi
unsigned int v3; // ecx
int v4; // edx
v1 = 2;
v2 = 1;
v3 = 0;
if ( a1 > 0 )
{
while ( 1 )
{
v4 = v2;
if ( v2 )
{
do
{
v3 += (v4 & 1) == 0;
v4 /= 2;
}
while ( v4 );
if ( a1 < v1 )
break;
}
++v2;
++v1;
}
}
return v3;
} | func0:
ENDBR64
MOV R8D,0x2
MOV ESI,0x1
MOV ECX,0x0
TEST EDI,EDI
JG 0x0010116a
JMP 0x0010118d
LAB_00101163:
ADD ESI,0x1
ADD R8D,0x1
LAB_0010116a:
MOV EDX,ESI
TEST ESI,ESI
JZ 0x00101163
LAB_00101170:
MOV EAX,EDX
AND EAX,0x1
CMP EAX,0x1
ADC ECX,0x0
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV EDX,EAX
JNZ 0x00101170
CMP EDI,R8D
JGE 0x00101163
LAB_0010118d:
MOV EAX,ECX
RET | int func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
int iVar4;
iVar4 = 2;
uVar3 = 1;
iVar2 = 0;
if (param_1 < 1) {
return 0;
}
do {
uVar1 = uVar3;
if (uVar3 != 0) {
do {
iVar2 = iVar2 + (uint)((uVar1 & 1) == 0);
uVar1 = (int)uVar1 / 2;
} while (uVar1 != 0);
if (param_1 < iVar4) {
return iVar2;
}
}
uVar3 = uVar3 + 1;
iVar4 = iVar4 + 1;
} while( true );
} |
7,506 | func0 |
#include <assert.h>
| int func0(int n) {
int cnt = 0;
for (int i = 1; i <= n; i++) {
int temp = i;
while (temp) {
if (temp % 2 == 0) {
cnt++;
}
temp = temp / 2;
}
}
return cnt;
}
| int main() {
assert(func0(2) == 1);
assert(func0(5) == 4);
assert(func0(14) == 17);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 123b <func0+0x3b>
lea 0x1(%rdi),%esi
mov $0x1,%ecx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %ecx,%eax
nopw 0x0(%rax,%rax,1)
mov %eax,%edx
and $0x1,%edx
cmp $0x1,%edx
adc $0x0,%r8d
sar %eax
jne 1220 <func0+0x20>
add $0x1,%ecx
cmp %esi,%ecx
jne 1218 <func0+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
test edi, edi
jle short loc_122B
lea esi, [rdi+1]
mov ecx, 1
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_1208:
mov eax, ecx
nop word ptr [rax+rax+00h]
loc_1210:
mov edx, eax
and edx, 1
cmp edx, 1
adc r8d, 0
sar eax, 1
jnz short loc_1210
add ecx, 1
cmp esi, ecx
jnz short loc_1208
mov eax, r8d
retn
loc_122B:
xor r8d, r8d
mov eax, r8d
retn | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // r8d
int v3; // eax
if ( a1 <= 0 )
return 0LL;
v1 = 1;
v2 = 0;
do
{
v3 = v1;
do
{
v2 += (v3 & 1) == 0;
v3 >>= 1;
}
while ( v3 );
++v1;
}
while ( a1 + 1 != v1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x0010122b
LEA ESI,[RDI + 0x1]
MOV ECX,0x1
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101208:
MOV EAX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101210:
MOV EDX,EAX
AND EDX,0x1
CMP EDX,0x1
ADC R8D,0x0
SAR EAX,0x1
JNZ 0x00101210
ADD ECX,0x1
CMP ESI,ECX
JNZ 0x00101208
MOV EAX,R8D
RET
LAB_0010122b:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1)
{
uint uVar1;
uint uVar2;
int iVar3;
if (param_1 < 1) {
return 0;
}
uVar1 = 1;
iVar3 = 0;
uVar2 = uVar1;
do {
do {
iVar3 = iVar3 + (uint)((uVar1 & 1) == 0);
uVar1 = (int)uVar1 >> 1;
} while (uVar1 != 0);
uVar1 = uVar2 + 1;
uVar2 = uVar1;
} while (param_1 + 1U != uVar1);
return iVar3;
} |
7,507 | func0 |
#include <assert.h>
| int func0(int n) {
int cnt = 0;
for (int i = 1; i <= n; i++) {
int temp = i;
while (temp) {
if (temp % 2 == 0) {
cnt++;
}
temp = temp / 2;
}
}
return cnt;
}
| int main() {
assert(func0(2) == 1);
assert(func0(5) == 4);
assert(func0(14) == 17);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 123b <func0+0x3b>
lea 0x1(%rdi),%esi
mov $0x1,%ecx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %ecx,%eax
nopw 0x0(%rax,%rax,1)
mov %eax,%edx
and $0x1,%edx
cmp $0x1,%edx
adc $0x0,%r8d
sar %eax
jne 1220 <func0+0x20>
add $0x1,%ecx
cmp %ecx,%esi
jne 1218 <func0+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
test edi, edi
jle short loc_1260
add edi, 1
mov esi, 1
xor edx, edx
nop word ptr [rax+rax+00h]
loc_1238:
mov eax, esi
nop word ptr [rax+rax+00h]
loc_1240:
mov ecx, eax
and ecx, 1
cmp ecx, 1
mov ecx, eax
adc edx, 0
shr ecx, 1Fh
add eax, ecx
sar eax, 1
jnz short loc_1240
add esi, 1
cmp edi, esi
jnz short loc_1238
mov eax, edx
retn
loc_1260:
xor edx, edx
mov eax, edx
retn | long long func0(int a1)
{
int v1; // edi
int v2; // esi
unsigned int v3; // edx
int v4; // eax
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2;
do
{
v3 += (v4 & 1) == 0;
v4 /= 2;
}
while ( v4 );
++v2;
}
while ( v1 != v2 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101260
ADD EDI,0x1
MOV ESI,0x1
XOR EDX,EDX
NOP word ptr [RAX + RAX*0x1]
LAB_00101238:
MOV EAX,ESI
NOP word ptr [RAX + RAX*0x1]
LAB_00101240:
MOV ECX,EAX
AND ECX,0x1
CMP ECX,0x1
MOV ECX,EAX
ADC EDX,0x0
SHR ECX,0x1f
ADD EAX,ECX
SAR EAX,0x1
JNZ 0x00101240
ADD ESI,0x1
CMP EDI,ESI
JNZ 0x00101238
MOV EAX,EDX
RET
LAB_00101260:
XOR EDX,EDX
MOV EAX,EDX
RET | int func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
if (param_1 < 1) {
return 0;
}
uVar1 = 1;
iVar2 = 0;
uVar3 = uVar1;
do {
do {
iVar2 = iVar2 + (uint)((uVar1 & 1) == 0);
uVar1 = (int)uVar1 / 2;
} while (uVar1 != 0);
uVar1 = uVar3 + 1;
uVar3 = uVar1;
} while (param_1 + 1U != uVar1);
return iVar2;
} |
7,508 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x) {
if (x % 2 == 0)
return true;
else
return false;
}
| int main() {
assert(func0(13) == false);
assert(func0(0) == true);
assert(func0(-9) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 1165 <func0+0x1c>
mov $0x1,%eax
jmp 116a <func0+0x21>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
and eax, 1
test eax, eax
jnz short loc_1165
mov eax, 1
jmp short loc_116A
loc_1165:
mov eax, 0
loc_116A:
pop rbp
retn | _BOOL8 func0(char a1)
{
return (a1 & 1) == 0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101165
MOV EAX,0x1
JMP 0x0010116a
LAB_00101165:
MOV EAX,0x0
LAB_0010116a:
POP RBP
RET | bool func0(uint param_1)
{
return (param_1 & 1) == 0;
} |
7,509 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x) {
if (x % 2 == 0)
return true;
else
return false;
}
| int main() {
assert(func0(13) == false);
assert(func0(0) == true);
assert(func0(-9) == false);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
xor $0x1,%eax
and $0x1,%eax
retq
| func0:
endbr64
mov eax, edi
xor eax, 1
and eax, 1
retn | long long func0(unsigned __int8 a1)
{
return (a1 ^ 1) & 1;
} | func0:
ENDBR64
MOV EAX,EDI
XOR EAX,0x1
AND EAX,0x1
RET | uint func0(uint param_1)
{
return (param_1 ^ 1) & 1;
} |
7,510 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x) {
if (x % 2 == 0)
return true;
else
return false;
}
| int main() {
assert(func0(13) == false);
assert(func0(0) == true);
assert(func0(-9) == false);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
not %eax
and $0x1,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
mov eax, edi
not eax
and eax, 1
retn | _BOOL8 func0(char a1)
{
return (a1 & 1) == 0;
} | func0:
ENDBR64
MOV EAX,EDI
NOT EAX
AND EAX,0x1
RET | uint func0(uint param_1)
{
return ~param_1 & 1;
} |
7,511 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int x) {
if (x % 2 == 0)
return true;
else
return false;
}
| int main() {
assert(func0(13) == false);
assert(func0(0) == true);
assert(func0(-9) == false);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
not %eax
and $0x1,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
mov eax, edi
not eax
and eax, 1
retn | _BOOL8 func0(char a1)
{
return (a1 & 1) == 0;
} | func0:
ENDBR64
MOV EAX,EDI
NOT EAX
AND EAX,0x1
RET | uint func0(uint param_1)
{
return ~param_1 & 1;
} |
7,512 | func0 |
#include <assert.h>
int factorial(int start, int end) {
int res = 1;
for (int i = start; i <= end; i++) {
res *= i;
}
return res;
}
| int func0(int n) {
return factorial(n + 1, 2 * n) / factorial(1, n);
}
| int main() {
assert(func0(4) == 70);
assert(func0(5) == 252);
assert(func0(2) == 6);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x8,%rsp
mov %edi,-0xc(%rbp)
mov -0xc(%rbp),%eax
lea (%rax,%rax,1),%edx
mov -0xc(%rbp),%eax
add $0x1,%eax
mov %edx,%esi
mov %eax,%edi
callq 1149 <factorial>
mov %eax,%ebx
mov -0xc(%rbp),%eax
mov %eax,%esi
mov $0x1,%edi
callq 1149 <factorial>
mov %eax,%ecx
mov %ebx,%eax
cltd
idiv %ecx
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 8
mov [rbp+var_C], edi
mov eax, [rbp+var_C]
lea edx, [rax+rax]
mov eax, [rbp+var_C]
add eax, 1
mov esi, edx
mov edi, eax
call factorial
mov ebx, eax
mov eax, [rbp+var_C]
mov esi, eax
mov edi, 1
call factorial
mov ecx, eax
mov eax, ebx
cdq
idiv ecx
mov rbx, [rbp+var_8]
leave
retn | long long func0(unsigned int a1)
{
int v1; // ebx
v1 = factorial(a1 + 1, 2 * a1);
return (unsigned int)(v1 / (int)factorial(1LL, a1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x8
MOV dword ptr [RBP + -0xc],EDI
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101149
MOV EBX,EAX
MOV EAX,dword ptr [RBP + -0xc]
MOV ESI,EAX
MOV EDI,0x1
CALL 0x00101149
MOV ECX,EAX
MOV EAX,EBX
CDQ
IDIV ECX
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int [16] func0(int param_1)
{
int iVar1;
int iVar2;
int auVar3 [16];
iVar1 = factorial(param_1 + 1,param_1 * 2);
iVar2 = factorial(1,param_1);
auVar3._0_8_ = (long)iVar1 / (long)iVar2 & 0xffffffff;
auVar3._8_8_ = (long)iVar1 % (long)iVar2 & 0xffffffff;
return auVar3;
} |
7,513 | func0 |
#include <assert.h>
int factorial(int start, int end) {
int res = 1;
for (int i = start; i <= end; i++) {
res *= i;
}
return res;
}
| int func0(int n) {
return factorial(n + 1, 2 * n) / factorial(1, n);
}
| int main() {
assert(func0(4) == 70);
assert(func0(5) == 252);
assert(func0(2) == 6);
return 0;
}
| O1 | c | func0:
endbr64
lea (%rdi,%rdi,1),%eax
lea 0x1(%rdi),%edx
cmp %edx,%eax
jl 11a9 <func0+0x3f>
lea 0x1(%rax),%ecx
mov $0x1,%eax
imul %edx,%eax
add $0x1,%edx
cmp %edx,%ecx
jne 1180 <func0+0x16>
test %edi,%edi
jle 11b0 <func0+0x46>
add $0x1,%edi
mov $0x1,%edx
mov $0x1,%ecx
imul %edx,%ecx
add $0x1,%edx
cmp %edx,%edi
jne 119b <func0+0x31>
cltd
idiv %ecx
retq
mov $0x1,%eax
jmp 118a <func0+0x20>
mov $0x1,%ecx
jmp 11a5 <func0+0x3b>
| func0:
endbr64
lea ecx, [rdi+rdi]
lea edx, [rdi+1]
cmp ecx, edx
jl short loc_11A9
add ecx, 1
mov eax, 1
loc_1180:
imul eax, edx
add edx, 1
cmp ecx, edx
jnz short loc_1180
loc_118A:
test edi, edi
jle short loc_11B0
add edi, 1
mov edx, 1
mov ecx, 1
loc_119B:
imul ecx, edx
add edx, 1
cmp edi, edx
jnz short loc_119B
loc_11A5:
cdq
idiv ecx
retn
loc_11A9:
mov eax, 1
jmp short loc_118A
loc_11B0:
mov ecx, 1
jmp short loc_11A5 | long long func0(int a1)
{
int v1; // edx
int v2; // eax
int v3; // edi
int v4; // edx
int v5; // ecx
v1 = a1 + 1;
if ( 2 * a1 < a1 + 1 )
{
v2 = 1;
}
else
{
v2 = 1;
do
v2 *= v1++;
while ( 2 * a1 + 1 != v1 );
}
if ( a1 <= 0 )
{
v5 = 1;
}
else
{
v3 = a1 + 1;
v4 = 1;
v5 = 1;
do
v5 *= v4++;
while ( v3 != v4 );
}
return (unsigned int)(v2 / v5);
} | func0:
ENDBR64
LEA ECX,[RDI + RDI*0x1]
LEA EDX,[RDI + 0x1]
CMP ECX,EDX
JL 0x001011a9
ADD ECX,0x1
MOV EAX,0x1
LAB_00101180:
IMUL EAX,EDX
ADD EDX,0x1
CMP ECX,EDX
JNZ 0x00101180
LAB_0010118a:
TEST EDI,EDI
JLE 0x001011b0
ADD EDI,0x1
MOV EDX,0x1
MOV ECX,0x1
LAB_0010119b:
IMUL ECX,EDX
ADD EDX,0x1
CMP EDI,EDX
JNZ 0x0010119b
LAB_001011a5:
CDQ
IDIV ECX
RET
LAB_001011a9:
MOV EAX,0x1
JMP 0x0010118a
LAB_001011b0:
MOV ECX,0x1
JMP 0x001011a5 | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar2 = param_1 + 1;
if (param_1 * 2 < iVar2) {
iVar1 = 1;
}
else {
iVar1 = 1;
do {
iVar1 = iVar1 * iVar2;
iVar2 = iVar2 + 1;
} while (param_1 * 2 + 1 != iVar2);
}
if (param_1 < 1) {
iVar2 = 1;
}
else {
iVar3 = 1;
iVar2 = 1;
do {
iVar2 = iVar2 * iVar3;
iVar3 = iVar3 + 1;
} while (param_1 + 1 != iVar3);
}
return iVar1 / iVar2;
} |
7,514 | func0 |
#include <assert.h>
int factorial(int start, int end) {
int res = 1;
for (int i = start; i <= end; i++) {
res *= i;
}
return res;
}
| int func0(int n) {
return factorial(n + 1, 2 * n) / factorial(1, n);
}
| int main() {
assert(func0(4) == 70);
assert(func0(5) == 252);
assert(func0(2) == 6);
return 0;
}
| O2 | c | func0:
endbr64
lea 0x1(%rdi),%esi
lea (%rdi,%rdi,1),%ecx
mov %esi,%edx
cmp %esi,%ecx
jl 11c0 <func0+0x50>
add $0x1,%ecx
mov $0x1,%eax
nopl 0x0(%rax,%rax,1)
imul %edx,%eax
add $0x1,%edx
cmp %ecx,%edx
jne 1190 <func0+0x20>
test %edi,%edi
jle 11bd <func0+0x4d>
mov $0x1,%ecx
mov $0x1,%edx
nopl 0x0(%rax,%rax,1)
imul %edx,%ecx
add $0x1,%edx
cmp %edx,%esi
jne 11b0 <func0+0x40>
cltd
idiv %ecx
retq
xchg %ax,%ax
mov $0x1,%eax
jmp 119a <func0+0x2a>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
lea ecx, [rdi+rdi]
lea edx, [rdi+1]
cmp ecx, edx
jl short loc_11C0
add ecx, 1
mov eax, 1
nop word ptr [rax+rax+00000000h]
loc_1190:
imul eax, edx
add edx, 1
cmp edx, ecx
jnz short loc_1190
loc_119A:
test edi, edi
jle short locret_11BF
mov ecx, 1
mov edx, 1
nop dword ptr [rax+rax+00000000h]
loc_11B0:
mov esi, edx
imul ecx, edx
add edx, 1
cmp edi, esi
jnz short loc_11B0
cdq
idiv ecx
locret_11BF:
retn
loc_11C0:
mov eax, 1
jmp short loc_119A | long long func0(int a1)
{
int v1; // edx
long long result; // rax
int v3; // ecx
int v4; // edx
int v5; // esi
v1 = a1 + 1;
if ( 2 * a1 < a1 + 1 )
{
result = 1LL;
}
else
{
LODWORD(result) = 1;
do
{
result = (unsigned int)(v1 * result);
++v1;
}
while ( v1 != 2 * a1 + 1 );
}
if ( a1 > 0 )
{
v3 = 1;
v4 = 1;
do
{
v5 = v4;
v3 *= v4++;
}
while ( a1 != v5 );
return (unsigned int)((int)result / v3);
}
return result;
} | func0:
ENDBR64
LEA ECX,[RDI + RDI*0x1]
LEA EDX,[RDI + 0x1]
CMP ECX,EDX
JL 0x001011c0
ADD ECX,0x1
MOV EAX,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101190:
IMUL EAX,EDX
ADD EDX,0x1
CMP EDX,ECX
JNZ 0x00101190
LAB_0010119a:
TEST EDI,EDI
JLE 0x001011bf
MOV ECX,0x1
MOV EDX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_001011b0:
MOV ESI,EDX
IMUL ECX,EDX
ADD EDX,0x1
CMP EDI,ESI
JNZ 0x001011b0
CDQ
IDIV ECX
LAB_001011bf:
RET
LAB_001011c0:
MOV EAX,0x1
JMP 0x0010119a | int1 [16] func0(int param_1)
{
int iVar1;
ulong uVar2;
int iVar3;
uint uVar4;
ulong uVar5;
bool bVar6;
int1 auVar7 [16];
uVar5 = (ulong)(param_1 + 1U);
if (param_1 * 2 < (int)(param_1 + 1U)) {
uVar2 = 1;
}
else {
uVar2 = 1;
do {
uVar2 = (ulong)(uint)((int)uVar2 * (int)uVar5);
uVar4 = (int)uVar5 + 1;
uVar5 = (ulong)uVar4;
} while (uVar4 != param_1 * 2 + 1U);
}
if (0 < param_1) {
iVar3 = 1;
iVar1 = 1;
do {
iVar3 = iVar3 * iVar1;
bVar6 = param_1 != iVar1;
iVar1 = iVar1 + 1;
} while (bVar6);
iVar1 = (int)uVar2;
uVar2 = (long)iVar1 / (long)iVar3 & 0xffffffff;
uVar5 = (long)iVar1 % (long)iVar3 & 0xffffffff;
}
auVar7._8_8_ = uVar5;
auVar7._0_8_ = uVar2;
return auVar7;
} |
7,515 | func0 |
#include <assert.h>
int factorial(int start, int end) {
int res = 1;
for (int i = start; i <= end; i++) {
res *= i;
}
return res;
}
| int func0(int n) {
return factorial(n + 1, 2 * n) / factorial(1, n);
}
| int main() {
assert(func0(4) == 70);
assert(func0(5) == 252);
assert(func0(2) == 6);
return 0;
}
| O3 | c | func0:
endbr64
lea 0x1(%rdi),%esi
lea (%rdi,%rdi,1),%ecx
mov %esi,%edx
cmp %esi,%ecx
jl 11c0 <func0+0x50>
add $0x1,%ecx
mov $0x1,%eax
nopl 0x0(%rax,%rax,1)
imul %edx,%eax
add $0x1,%edx
cmp %ecx,%edx
jne 1190 <func0+0x20>
test %edi,%edi
jle 11bd <func0+0x4d>
mov $0x1,%ecx
mov $0x1,%edx
nopl 0x0(%rax,%rax,1)
imul %edx,%ecx
add $0x1,%edx
cmp %esi,%edx
jne 11b0 <func0+0x40>
cltd
idiv %ecx
retq
xchg %ax,%ax
mov $0x1,%eax
jmp 119a <func0+0x2a>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
lea edx, [rdi+1]
lea ecx, [rdi+rdi]
mov eax, 1
cmp ecx, edx
jl short loc_11B8
lea esi, [rcx+1]
test dl, 1
jnz short loc_11A8
mov eax, edx
lea edx, [rdi+2]
cmp edx, esi
jz short loc_11B8
nop dword ptr [rax+00h]
loc_11A8:
imul eax, edx
lea ecx, [rdx+1]
add edx, 2
imul eax, ecx
cmp edx, esi
jnz short loc_11A8
loc_11B8:
test edi, edi
jle short locret_11DF
mov ecx, 1
mov edx, 1
nop word ptr [rax+rax+00000000h]
loc_11D0:
mov esi, edx
imul ecx, edx
add edx, 1
cmp edi, esi
jnz short loc_11D0
cdq
idiv ecx
locret_11DF:
retn | long long func0(int a1)
{
unsigned int v1; // edx
long long result; // rax
int v3; // esi
int v4; // eax
unsigned int v5; // ecx
int v6; // ecx
int v7; // edx
int v8; // esi
v1 = a1 + 1;
result = 1LL;
if ( 2 * a1 >= a1 + 1 )
{
v3 = 2 * a1 + 1;
if ( (v1 & 1) != 0 || (result = v1, v1 = a1 + 2, a1 + 2 != v3) )
{
do
{
v4 = v1 * result;
v5 = v1 + 1;
v1 += 2;
result = v5 * v4;
}
while ( v1 != v3 );
}
}
if ( a1 > 0 )
{
v6 = 1;
v7 = 1;
do
{
v8 = v7;
v6 *= v7++;
}
while ( a1 != v8 );
return (unsigned int)((int)result / v6);
}
return result;
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
LEA ECX,[RDI + RDI*0x1]
MOV EAX,0x1
CMP ECX,EDX
JL 0x001011b8
LEA ESI,[RCX + 0x1]
TEST DL,0x1
JNZ 0x001011a8
MOV EAX,EDX
LEA EDX,[RDI + 0x2]
CMP EDX,ESI
JZ 0x001011b8
NOP dword ptr [RAX]
LAB_001011a8:
IMUL EAX,EDX
LEA ECX,[RDX + 0x1]
ADD EDX,0x2
IMUL EAX,ECX
CMP EDX,ESI
JNZ 0x001011a8
LAB_001011b8:
TEST EDI,EDI
JLE 0x001011df
MOV ECX,0x1
MOV EDX,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001011d0:
MOV ESI,EDX
IMUL ECX,EDX
ADD EDX,0x1
CMP EDI,ESI
JNZ 0x001011d0
CDQ
IDIV ECX
LAB_001011df:
RET | int [16] func0(int param_1)
{
int iVar1;
ulong uVar2;
int iVar3;
uint uVar4;
bool bVar6;
int auVar7 [16];
ulong uVar5;
uVar4 = param_1 + 1;
uVar5 = (ulong)uVar4;
uVar2 = 1;
iVar1 = 1;
if ((int)uVar4 <= param_1 * 2) {
if ((uVar4 & 1) != 0) goto LAB_001011a8;
uVar4 = param_1 + 2;
uVar2 = uVar5;
while( true ) {
iVar1 = (int)uVar2;
uVar5 = (ulong)uVar4;
if (uVar4 == param_1 * 2 + 1U) break;
LAB_001011a8:
iVar1 = iVar1 * uVar4;
iVar3 = uVar4 + 1;
uVar4 = uVar4 + 2;
uVar2 = (ulong)(uint)(iVar1 * iVar3);
}
}
if (0 < param_1) {
iVar3 = 1;
iVar1 = 1;
do {
iVar3 = iVar3 * iVar1;
bVar6 = param_1 != iVar1;
iVar1 = iVar1 + 1;
} while (bVar6);
iVar1 = (int)uVar2;
uVar2 = (long)iVar1 / (long)iVar3 & 0xffffffff;
uVar5 = (long)iVar1 % (long)iVar3 & 0xffffffff;
}
auVar7._8_8_ = uVar5;
auVar7._0_8_ = uVar2;
return auVar7;
} |
7,516 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
typedef struct {
char year[5];
char month[3];
char day[3];
} Date;
| Date func0(const char* url) {
regex_t regex;
regmatch_t matches[4];
Date date = {"", "", ""};
const char* pattern = "/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/";
if (regcomp(®ex, pattern, REG_EXTENDED)) {
return date;
}
if (!regexec(®ex, url, 4, matches, 0)) {
int start, end;
// Year
start = matches[1].rm_so;
end = matches[1].rm_eo;
snprintf(date.year, sizeof(date.year), "%.*s", end - start, url + start);
// Month
start = matches[2].rm_so;
end = matches[2].rm_eo;
snprintf(date.month, sizeof(date.month), "%.*s", end - start, url + start);
// Day
start = matches[3].rm_so;
end = matches[3].rm_eo;
snprintf(date.day, sizeof(date.day), "%.*s", end - start, url + start);
}
regfree(®ex);
return date;
}
| int main() {
Date d1 = func0("https://www.washingtonpost.com/news/football-insider/wp/2016/09/02/odell-beckhams-fame-rests-on-one-stupid-little-ball-josh-norman-tells-author/");
assert(strcmp(d1.year, "2016") == 0 && strcmp(d1.month, "09") == 0 && strcmp(d1.day, "02") == 0);
Date d2 = func0("https://www.indiatoday.in/movies/celebrities/story/wp/2020/11/03/odeof-sushant-singh-rajput-s-death-his-brother-in-law-shares-advice-for-fans-1749646/");
assert(strcmp(d2.year, "2020") == 0 && strcmp(d2.month, "11") == 0 && strcmp(d2.day, "03") == 0);
Date d3 = func0("https://economictimes.indiatimes.com/news/economy/2020/12/29/finance/pension-assets-under-pfrda-touch-rs-5-32-lakh-crore/articleshow/79736619.cms");
assert(strcmp(d3.year, "2020") == 0 && strcmp(d3.month, "12") == 0 && strcmp(d3.day, "29") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xc0,%rsp
mov %rdi,-0xa8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x46(%rbp)
movb $0x0,-0x42(%rbp)
movw $0x0,-0x41(%rbp)
movb $0x0,-0x3f(%rbp)
movw $0x0,-0x3e(%rbp)
movb $0x0,-0x3c(%rbp)
lea 0xdb4(%rip),%rax
mov %rax,-0x98(%rbp)
mov -0x98(%rbp),%rcx
lea -0x90(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10f0 <regcomp@plt>
test %eax,%eax
je 1299 <func0+0x90>
mov -0x46(%rbp),%rax
mov %rax,-0x3b(%rbp)
movzwl -0x3e(%rbp),%eax
mov %ax,-0x33(%rbp)
movzbl -0x3c(%rbp),%eax
mov %al,-0x31(%rbp)
jmpq 13ef <func0+0x1e6>
lea -0x30(%rbp),%rdx
mov -0xa8(%rbp),%rsi
lea -0x90(%rbp),%rax
mov $0x0,%r8d
mov %rdx,%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 1110 <regexec@plt>
test %eax,%eax
jne 13c9 <func0+0x1c0>
mov -0x28(%rbp),%eax
mov %eax,-0xa0(%rbp)
mov -0x24(%rbp),%eax
mov %eax,-0x9c(%rbp)
mov -0xa0(%rbp),%eax
movslq %eax,%rdx
mov -0xa8(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x9c(%rbp),%eax
sub -0xa0(%rbp),%eax
mov %eax,%edx
lea -0x46(%rbp),%rax
mov %rcx,%r8
mov %edx,%ecx
lea 0xd22(%rip),%rdx
mov $0x5,%esi
mov %rax,%rdi
mov $0x0,%eax
callq 10d0 <snprintf@plt>
mov -0x20(%rbp),%eax
mov %eax,-0xa0(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,-0x9c(%rbp)
mov -0xa0(%rbp),%eax
movslq %eax,%rdx
mov -0xa8(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x9c(%rbp),%eax
sub -0xa0(%rbp),%eax
lea -0x46(%rbp),%rdx
lea 0x5(%rdx),%rdi
mov %rcx,%r8
mov %eax,%ecx
lea 0xcca(%rip),%rdx
mov $0x3,%esi
mov $0x0,%eax
callq 10d0 <snprintf@plt>
mov -0x18(%rbp),%eax
mov %eax,-0xa0(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x9c(%rbp)
mov -0xa0(%rbp),%eax
movslq %eax,%rdx
mov -0xa8(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x9c(%rbp),%eax
sub -0xa0(%rbp),%eax
lea -0x46(%rbp),%rdx
lea 0x8(%rdx),%rdi
mov %rcx,%r8
mov %eax,%ecx
lea 0xc75(%rip),%rdx
mov $0x3,%esi
mov $0x0,%eax
callq 10d0 <snprintf@plt>
lea -0x90(%rbp),%rax
mov %rax,%rdi
callq 10b0 <regfree@plt>
mov -0x46(%rbp),%rax
mov %rax,-0x3b(%rbp)
movzwl -0x3e(%rbp),%eax
mov %ax,-0x33(%rbp)
movzbl -0x3c(%rbp),%eax
mov %al,-0x31(%rbp)
mov -0x3b(%rbp),%rax
movzbl -0x33(%rbp),%ecx
movzbl -0x32(%rbp),%esi
shl $0x8,%rsi
or %rcx,%rsi
movzbl -0x31(%rbp),%ecx
shl $0x10,%rcx
or %rsi,%rcx
mov %rcx,%rdx
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
je 1424 <func0+0x21b>
callq 10c0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov dword ptr [rbp+s], 0
mov [rbp+s+4], 0
mov word ptr [rbp+s+5], 0
mov [rbp+s+7], 0
mov [rbp+var_3E], 0
mov [rbp+var_3C], 0
lea rax, a09409120912; "/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
test eax, eax
jz short loc_1290
mov rax, qword ptr [rbp+s]
mov [rbp+var_3B], rax
mov eax, dword ptr [rbp+s+7]
mov dword ptr [rbp+var_3B+7], eax
jmp loc_13E3
loc_1290:
lea rdx, [rbp+pmatch]
mov rsi, [rbp+string]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov rcx, rdx; pmatch
mov edx, 4; nmatch
mov rdi, rax; preg
call _regexec
test eax, eax
jnz loc_13C6
mov eax, [rbp+var_28]
mov [rbp+var_A0], eax
mov eax, [rbp+var_24]
mov [rbp+var_9C], eax
mov eax, [rbp+var_A0]
movsxd rdx, eax
mov rax, [rbp+string]
lea rcx, [rdx+rax]
mov eax, [rbp+var_9C]
sub eax, [rbp+var_A0]
mov edx, eax
lea rax, [rbp+s]
mov r8, rcx
mov ecx, edx
lea rdx, format; "%.*s"
mov esi, 5; maxlen
mov rdi, rax; s
mov eax, 0
call _snprintf
mov eax, [rbp+var_20]
mov [rbp+var_A0], eax
mov eax, [rbp+var_1C]
mov [rbp+var_9C], eax
mov eax, [rbp+var_A0]
movsxd rdx, eax
mov rax, [rbp+string]
lea rcx, [rdx+rax]
mov eax, [rbp+var_9C]
sub eax, [rbp+var_A0]
lea rdx, [rbp+s]
lea rdi, [rdx+5]; s
mov r8, rcx
mov ecx, eax
lea rax, format; "%.*s"
mov rdx, rax; format
mov esi, 3; maxlen
mov eax, 0
call _snprintf
mov eax, [rbp+var_18]
mov [rbp+var_A0], eax
mov eax, [rbp+var_14]
mov [rbp+var_9C], eax
mov eax, [rbp+var_A0]
movsxd rdx, eax
mov rax, [rbp+string]
lea rcx, [rdx+rax]
mov eax, [rbp+var_9C]
sub eax, [rbp+var_A0]
lea rdx, [rbp+s]
lea rdi, [rdx+8]; s
mov r8, rcx
mov ecx, eax
lea rax, format; "%.*s"
mov rdx, rax; format
mov esi, 3; maxlen
mov eax, 0
call _snprintf
loc_13C6:
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
mov rax, qword ptr [rbp+s]
mov [rbp+var_3B], rax
mov eax, dword ptr [rbp+s+7]
mov dword ptr [rbp+var_3B+7], eax
loc_13E3:
mov rax, [rbp+var_3B]
movzx ecx, [rbp+var_33]
movzx esi, [rbp+var_32]
shl rsi, 8
or rsi, rcx
movzx ecx, [rbp+var_31]
shl rcx, 10h
or rcx, rsi
mov rdx, rcx
mov rcx, [rbp+var_8]
sub rcx, fs:28h
jz short locret_1418
call ___stack_chk_fail
locret_1418:
leave
retn | long long func0(const char *a1)
{
regex_t preg; // [rsp+30h] [rbp-90h] BYREF
char s[11]; // [rsp+7Ah] [rbp-46h] BYREF
_BYTE v4[11]; // [rsp+85h] [rbp-3Bh]
regmatch_t pmatch; // [rsp+90h] [rbp-30h] BYREF
int v6; // [rsp+98h] [rbp-28h]
int v7; // [rsp+9Ch] [rbp-24h]
int v8; // [rsp+A0h] [rbp-20h]
int v9; // [rsp+A4h] [rbp-1Ch]
int v10; // [rsp+A8h] [rbp-18h]
int v11; // [rsp+ACh] [rbp-14h]
unsigned long long v12; // [rsp+B8h] [rbp-8h]
v12 = __readfsqword(0x28u);
memset(s, 0, sizeof(s));
if ( regcomp(&preg, "/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/", 1) )
{
*(_QWORD *)v4 = *(_QWORD *)s;
*(_DWORD *)&v4[7] = *(_DWORD *)&s[7];
}
else
{
if ( !regexec(&preg, a1, 4uLL, &pmatch, 0) )
{
snprintf(s, 5uLL, "%.*s", v7 - v6, &a1[v6]);
snprintf(&s[5], 3uLL, "%.*s", v9 - v8, &a1[v8]);
snprintf(&s[8], 3uLL, "%.*s", v11 - v10, &a1[v10]);
}
regfree(&preg);
*(_QWORD *)v4 = *(_QWORD *)s;
*(_DWORD *)&v4[7] = *(_DWORD *)&s[7];
}
return *(_QWORD *)v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV qword ptr [RBP + -0xa8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x46],0x0
MOV byte ptr [RBP + -0x42],0x0
MOV word ptr [RBP + -0x41],0x0
MOV byte ptr [RBP + -0x3f],0x0
MOV word ptr [RBP + -0x3e],0x0
MOV byte ptr [RBP + -0x3c],0x0
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x98],RAX
MOV RCX,qword ptr [RBP + -0x98]
LEA RAX,[RBP + -0x90]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010f0
TEST EAX,EAX
JZ 0x00101290
MOV RAX,qword ptr [RBP + -0x46]
MOV qword ptr [RBP + -0x3b],RAX
MOV EAX,dword ptr [RBP + -0x3f]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x001013e3
LAB_00101290:
LEA RDX,[RBP + -0x30]
MOV RSI,qword ptr [RBP + -0xa8]
LEA RAX,[RBP + -0x90]
MOV R8D,0x0
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x00101110
TEST EAX,EAX
JNZ 0x001013c6
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0xa0],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x9c],EAX
MOV EAX,dword ptr [RBP + -0xa0]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x9c]
SUB EAX,dword ptr [RBP + -0xa0]
MOV EDX,EAX
LEA RAX,[RBP + -0x46]
MOV R8,RCX
MOV ECX,EDX
LEA RDX,[0x10202f]
MOV ESI,0x5
MOV RDI,RAX
MOV EAX,0x0
CALL 0x001010d0
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0xa0],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x9c],EAX
MOV EAX,dword ptr [RBP + -0xa0]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x9c]
SUB EAX,dword ptr [RBP + -0xa0]
LEA RDX,[RBP + -0x46]
LEA RDI,[RDX + 0x5]
MOV R8,RCX
MOV ECX,EAX
LEA RAX,[0x10202f]
MOV RDX,RAX
MOV ESI,0x3
MOV EAX,0x0
CALL 0x001010d0
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0xa0],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x9c],EAX
MOV EAX,dword ptr [RBP + -0xa0]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x9c]
SUB EAX,dword ptr [RBP + -0xa0]
LEA RDX,[RBP + -0x46]
LEA RDI,[RDX + 0x8]
MOV R8,RCX
MOV ECX,EAX
LEA RAX,[0x10202f]
MOV RDX,RAX
MOV ESI,0x3
MOV EAX,0x0
CALL 0x001010d0
LAB_001013c6:
LEA RAX,[RBP + -0x90]
MOV RDI,RAX
CALL 0x001010b0
MOV RAX,qword ptr [RBP + -0x46]
MOV qword ptr [RBP + -0x3b],RAX
MOV EAX,dword ptr [RBP + -0x3f]
MOV dword ptr [RBP + -0x34],EAX
LAB_001013e3:
MOV RAX,qword ptr [RBP + -0x3b]
MOVZX ECX,byte ptr [RBP + -0x33]
MOVZX ESI,byte ptr [RBP + -0x32]
SHL RSI,0x8
OR RSI,RCX
MOVZX ECX,byte ptr [RBP + -0x31]
SHL RCX,0x10
OR RCX,RSI
MOV RDX,RCX
MOV RCX,qword ptr [RBP + -0x8]
SUB RCX,qword ptr FS:[0x28]
JZ 0x00101418
CALL 0x001010c0
LAB_00101418:
LEAVE
RET | int8 func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t local_98;
int4 local_4e;
int uStack_4a;
int2 uStack_49;
int uStack_47;
int2 uStack_46;
int uStack_44;
int7 local_43;
int uStack_3c;
int2 uStack_3b;
int uStack_39;
regmatch_t local_38;
int local_30;
int local_2c;
int local_28;
int local_24;
int local_20;
int local_1c;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_4e = 0;
uStack_4a = 0;
uStack_49 = 0;
uStack_47 = 0;
uStack_46 = 0;
uStack_44 = 0;
iVar1 = regcomp(&local_98,"/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_98,param_1,4,&local_38,0);
if (iVar1 == 0) {
snprintf((char *)&local_4e,5,"%.*s",(ulong)(uint)(local_2c - local_30),param_1 + local_30);
snprintf((char *)&uStack_49,3,"%.*s",(ulong)(uint)(local_24 - local_28),param_1 + local_28);
snprintf((char *)&uStack_46,3,"%.*s",(ulong)(uint)(local_1c - local_20),param_1 + local_20);
}
regfree(&local_98);
local_43 = CONCAT25(uStack_49,CONCAT14(uStack_4a,local_4e));
}
else {
local_43 = CONCAT25(uStack_49,CONCAT14(uStack_4a,local_4e));
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
uStack_3c = uStack_47;
uStack_3b = uStack_46;
uStack_39 = uStack_44;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return CONCAT17(uStack_47,local_43);
} |
7,517 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
typedef struct {
char year[5];
char month[3];
char day[3];
} Date;
| Date func0(const char* url) {
regex_t regex;
regmatch_t matches[4];
Date date = {"", "", ""};
const char* pattern = "/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/";
if (regcomp(®ex, pattern, REG_EXTENDED)) {
return date;
}
if (!regexec(®ex, url, 4, matches, 0)) {
int start, end;
// Year
start = matches[1].rm_so;
end = matches[1].rm_eo;
snprintf(date.year, sizeof(date.year), "%.*s", end - start, url + start);
// Month
start = matches[2].rm_so;
end = matches[2].rm_eo;
snprintf(date.month, sizeof(date.month), "%.*s", end - start, url + start);
// Day
start = matches[3].rm_so;
end = matches[3].rm_eo;
snprintf(date.day, sizeof(date.day), "%.*s", end - start, url + start);
}
regfree(®ex);
return date;
}
| int main() {
Date d1 = func0("https://www.washingtonpost.com/news/football-insider/wp/2016/09/02/odell-beckhams-fame-rests-on-one-stupid-little-ball-josh-norman-tells-author/");
assert(strcmp(d1.year, "2016") == 0 && strcmp(d1.month, "09") == 0 && strcmp(d1.day, "02") == 0);
Date d2 = func0("https://www.indiatoday.in/movies/celebrities/story/wp/2020/11/03/odeof-sushant-singh-rajput-s-death-his-brother-in-law-shares-advice-for-fans-1749646/");
assert(strcmp(d2.year, "2020") == 0 && strcmp(d2.month, "11") == 0 && strcmp(d2.day, "03") == 0);
Date d3 = func0("https://economictimes.indiatimes.com/news/economy/2020/12/29/finance/pension-assets-under-pfrda-touch-rs-5-32-lakh-crore/articleshow/79736619.cms");
assert(strcmp(d3.year, "2020") == 0 && strcmp(d3.month, "12") == 0 && strcmp(d3.day, "29") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
sub $0xa0,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
movl $0x0,0x5a(%rsp)
movb $0x0,0x5e(%rsp)
movw $0x0,0x5f(%rsp)
movb $0x0,0x61(%rsp)
movw $0x0,0x62(%rsp)
movb $0x0,0x64(%rsp)
lea 0x10(%rsp),%rdi
mov $0x1,%edx
lea 0xdc7(%rip),%rsi
callq 10e0 <regcomp@plt>
test %eax,%eax
je 12ac <func0+0xc3>
mov 0x5a(%rsp),%rax
mov %rax,0x65(%rsp)
movzwl 0x62(%rsp),%eax
mov %ax,0x6d(%rsp)
movzbl 0x64(%rsp),%eax
mov %al,0x6f(%rsp)
mov 0x65(%rsp),%rcx
movzbl 0x6d(%rsp),%eax
movzbl 0x6e(%rsp),%edx
shl $0x8,%rdx
or %rax,%rdx
movzbl 0x6f(%rsp),%eax
shl $0x10,%rax
or %rax,%rdx
mov 0x98(%rsp),%rax
xor %fs:0x28,%rax
jne 13c6 <func0+0x1dd>
mov %rcx,%rax
add $0xa0,%rsp
pop %rbx
retq
lea 0x70(%rsp),%rcx
lea 0x10(%rsp),%rdi
mov $0x0,%r8d
mov $0x4,%edx
mov %rbx,%rsi
callq 10f0 <regexec@plt>
test %eax,%eax
je 12f9 <func0+0x110>
lea 0x10(%rsp),%rdi
callq 10b0 <regfree@plt>
mov 0x5a(%rsp),%rax
mov %rax,0x65(%rsp)
movzwl 0x62(%rsp),%eax
mov %ax,0x6d(%rsp)
movzbl 0x64(%rsp),%eax
mov %al,0x6f(%rsp)
jmpq 1267 <func0+0x7e>
mov 0x78(%rsp),%edx
lea 0x5a(%rsp),%rdi
sub $0x8,%rsp
movslq %edx,%rax
add %rbx,%rax
push %rax
mov 0x8c(%rsp),%r9d
sub %edx,%r9d
lea 0x1032(%rip),%r8
mov $0x5,%ecx
mov $0x1,%edx
mov $0x5,%esi
mov $0x0,%eax
callq 10a0 <__snprintf_chk@plt>
mov 0x90(%rsp),%edx
lea 0x6f(%rsp),%rdi
movslq %edx,%rax
add %rbx,%rax
mov %rax,(%rsp)
mov 0x94(%rsp),%r9d
sub %edx,%r9d
lea 0xff1(%rip),%r8
mov $0x3,%ecx
mov $0x1,%edx
mov $0x3,%esi
mov $0x0,%eax
callq 10a0 <__snprintf_chk@plt>
mov 0x98(%rsp),%eax
lea 0x72(%rsp),%r10
movslq %eax,%rdi
add %rbx,%rdi
mov %rdi,(%rsp)
mov 0x9c(%rsp),%r9d
sub %eax,%r9d
lea 0xfb0(%rip),%r8
mov $0x3,%ecx
mov $0x1,%edx
mov $0x3,%esi
mov %r10,%rdi
mov $0x0,%eax
callq 10a0 <__snprintf_chk@plt>
add $0x10,%rsp
jmpq 12cd <func0+0xe4>
callq 10c0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbx
sub rsp, 0A0h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+0A8h+var_10], rax
xor eax, eax
mov dword ptr [rsp+0A8h+var_4E], 0
mov byte ptr [rsp+0A8h+var_4E+4], 0
mov word ptr [rsp+0A8h+var_4E+5], 0
mov byte ptr [rsp+0A8h+var_4E+7], 0
mov [rsp+0A8h+var_46], 0
mov [rsp+0A8h+var_44], 0
lea rdi, [rsp+0A8h+var_98]
mov edx, 1
lea rsi, a09409120912; "/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/"
call _regcomp
test eax, eax
jz short loc_12B3
loc_126A:
mov rcx, [rsp+0A8h+var_4E]
movzx edx, [rsp+0A8h+var_46]
movzx eax, dh
movzx edx, dl
movzx eax, al
shl rax, 8
or rax, rdx
movzx edx, [rsp+0A8h+var_44]
shl rdx, 10h
or rdx, rax
mov rax, [rsp+0A8h+var_10]
sub rax, fs:28h
jnz loc_13AA
mov rax, rcx
add rsp, 0A0h
pop rbx
retn
loc_12B3:
lea rcx, [rsp+0A8h+var_38]
lea rdi, [rsp+0A8h+var_98]
mov r8d, 0
mov edx, 4
mov rsi, rbx
call _regexec
test eax, eax
jz short loc_12E0
loc_12D4:
lea rdi, [rsp+0A8h+var_98]
call _regfree
jmp short loc_126A
loc_12E0:
mov edx, [rsp+0A8h+var_30]
lea rdi, [rsp+0A8h+var_4E]
sub rsp, 8
movsxd rax, edx
add rax, rbx
push rax
mov r9d, [rsp+0B8h+var_2C]
sub r9d, edx
lea r8, aS; "%.*s"
mov ecx, 5
mov edx, 1
mov esi, 5
mov eax, 0
call ___snprintf_chk
mov edx, [rsp+0B8h+var_28]
lea rdi, [rsp+0B8h+var_4E+5]
movsxd rax, edx
add rax, rbx
mov [rsp+0B8h+var_B8], rax
mov r9d, [rsp+0B8h+var_24]
sub r9d, edx
lea r8, aS; "%.*s"
mov ecx, 3
mov edx, 1
mov esi, 3
mov eax, 0
call ___snprintf_chk
mov edx, [rsp+0B8h+var_20]
lea rdi, [rsp+0B8h+var_46]
movsxd rax, edx
add rax, rbx
mov [rsp+0B8h+var_B8], rax
mov r9d, [rsp+0B8h+var_1C]
sub r9d, edx
lea r8, aS; "%.*s"
mov ecx, 3
mov edx, 1
mov esi, 3
mov eax, 0
call ___snprintf_chk
add rsp, 10h
jmp loc_12D4
loc_13AA:
call ___stack_chk_fail | long long func0(long long a1)
{
_BYTE v2[74]; // [rsp+20h] [rbp-98h] BYREF
long long v3; // [rsp+6Ah] [rbp-4Eh] BYREF
__int16 v4; // [rsp+72h] [rbp-46h] BYREF
char v5; // [rsp+74h] [rbp-44h]
_BYTE v6[8]; // [rsp+80h] [rbp-38h] BYREF
int v7; // [rsp+88h] [rbp-30h]
int v8; // [rsp+8Ch] [rbp-2Ch]
int v9; // [rsp+90h] [rbp-28h]
int v10; // [rsp+94h] [rbp-24h]
int v11; // [rsp+98h] [rbp-20h]
int v12; // [rsp+9Ch] [rbp-1Ch]
unsigned long long v13; // [rsp+A8h] [rbp-10h]
v13 = __readfsqword(0x28u);
v3 = 0LL;
v4 = 0;
v5 = 0;
if ( !(unsigned int)regcomp(v2, "/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/", 1LL) )
{
if ( !(unsigned int)regexec(v2, a1, 4LL, v6, 0LL) )
{
__snprintf_chk(&v3, 5LL, 1LL, 5LL, "%.*s", v8 - v7, (const char *)(a1 + v7));
__snprintf_chk((char *)&v3 + 5, 3LL, 1LL, 3LL, "%.*s", v10 - v9, (const char *)(a1 + v9));
__snprintf_chk(&v4, 3LL, 1LL, 3LL, "%.*s", v12 - v11, (const char *)(a1 + v11));
}
regfree(v2);
}
return v3;
} | func0:
ENDBR64
PUSH RBX
SUB RSP,0xa0
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x5a],0x0
MOV byte ptr [RSP + 0x5e],0x0
MOV word ptr [RSP + 0x5f],0x0
MOV byte ptr [RSP + 0x61],0x0
MOV word ptr [RSP + 0x62],0x0
MOV byte ptr [RSP + 0x64],0x0
LEA RDI,[RSP + 0x10]
MOV EDX,0x1
LEA RSI,[0x102008]
CALL 0x001010f0
TEST EAX,EAX
JZ 0x001012b3
LAB_0010126a:
MOV RCX,qword ptr [RSP + 0x5a]
MOVZX EDX,word ptr [RSP + 0x62]
MOVZX EAX,DH
MOVZX EDX,DL
MOVZX EAX,AL
SHL RAX,0x8
OR RAX,RDX
MOVZX EDX,byte ptr [RSP + 0x64]
SHL RDX,0x10
OR RDX,RAX
MOV RAX,qword ptr [RSP + 0x98]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013aa
MOV RAX,RCX
ADD RSP,0xa0
POP RBX
RET
LAB_001012b3:
LEA RCX,[RSP + 0x70]
LEA RDI,[RSP + 0x10]
MOV R8D,0x0
MOV EDX,0x4
MOV RSI,RBX
CALL 0x00101110
TEST EAX,EAX
JZ 0x001012e0
LAB_001012d4:
LEA RDI,[RSP + 0x10]
CALL 0x001010c0
JMP 0x0010126a
LAB_001012e0:
MOV EDX,dword ptr [RSP + 0x78]
LEA RDI,[RSP + 0x5a]
SUB RSP,0x8
MOVSXD RAX,EDX
ADD RAX,RBX
PUSH RAX
MOV R9D,dword ptr [RSP + 0x8c]
SUB R9D,EDX
LEA R8,[0x102311]
MOV ECX,0x5
MOV EDX,0x1
MOV ESI,0x5
MOV EAX,0x0
CALL 0x001010b0
MOV EDX,dword ptr [RSP + 0x90]
LEA RDI,[RSP + 0x6f]
MOVSXD RAX,EDX
ADD RAX,RBX
MOV qword ptr [RSP],RAX
MOV R9D,dword ptr [RSP + 0x94]
SUB R9D,EDX
LEA R8,[0x102311]
MOV ECX,0x3
MOV EDX,0x1
MOV ESI,0x3
MOV EAX,0x0
CALL 0x001010b0
MOV EDX,dword ptr [RSP + 0x98]
LEA RDI,[RSP + 0x72]
MOVSXD RAX,EDX
ADD RAX,RBX
MOV qword ptr [RSP],RAX
MOV R9D,dword ptr [RSP + 0x9c]
SUB R9D,EDX
LEA R8,[0x102311]
MOV ECX,0x3
MOV EDX,0x1
MOV ESI,0x3
MOV EAX,0x0
CALL 0x001010b0
ADD RSP,0x10
JMP 0x001012d4
LAB_001013aa:
CALL 0x001010d0 | int8 func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t local_98;
int4 local_4e;
int1 uStack_4a;
int2 uStack_49;
int1 uStack_47;
int3 local_46 [3];
regmatch_t local_38;
int local_30;
int local_2c;
int local_28;
int local_24;
int local_20;
int local_1c;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_4e = 0;
uStack_4a = 0;
uStack_49 = 0;
uStack_47 = 0;
local_46[0] = 0;
iVar1 = regcomp(&local_98,"/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_98,param_1,4,&local_38,0);
if (iVar1 == 0) {
__snprintf_chk(&local_4e,5,1,5,&DAT_00102311,local_2c - local_30,param_1 + local_30);
__snprintf_chk(&uStack_49,3,1,3,&DAT_00102311,local_24 - local_28,param_1 + local_28);
__snprintf_chk(local_46,3,1,3,&DAT_00102311,local_1c - local_20,param_1 + local_20);
}
regfree(&local_98);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return CONCAT17(uStack_47,CONCAT25(uStack_49,CONCAT14(uStack_4a,local_4e)));
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,518 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
typedef struct {
char year[5];
char month[3];
char day[3];
} Date;
| Date func0(const char* url) {
regex_t regex;
regmatch_t matches[4];
Date date = {"", "", ""};
const char* pattern = "/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/";
if (regcomp(®ex, pattern, REG_EXTENDED)) {
return date;
}
if (!regexec(®ex, url, 4, matches, 0)) {
int start, end;
// Year
start = matches[1].rm_so;
end = matches[1].rm_eo;
snprintf(date.year, sizeof(date.year), "%.*s", end - start, url + start);
// Month
start = matches[2].rm_so;
end = matches[2].rm_eo;
snprintf(date.month, sizeof(date.month), "%.*s", end - start, url + start);
// Day
start = matches[3].rm_so;
end = matches[3].rm_eo;
snprintf(date.day, sizeof(date.day), "%.*s", end - start, url + start);
}
regfree(®ex);
return date;
}
| int main() {
Date d1 = func0("https://www.washingtonpost.com/news/football-insider/wp/2016/09/02/odell-beckhams-fame-rests-on-one-stupid-little-ball-josh-norman-tells-author/");
assert(strcmp(d1.year, "2016") == 0 && strcmp(d1.month, "09") == 0 && strcmp(d1.day, "02") == 0);
Date d2 = func0("https://www.indiatoday.in/movies/celebrities/story/wp/2020/11/03/odeof-sushant-singh-rajput-s-death-his-brother-in-law-shares-advice-for-fans-1749646/");
assert(strcmp(d2.year, "2020") == 0 && strcmp(d2.month, "11") == 0 && strcmp(d2.day, "03") == 0);
Date d3 = func0("https://economictimes.indiatimes.com/news/economy/2020/12/29/finance/pension-assets-under-pfrda-touch-rs-5-32-lakh-crore/articleshow/79736619.cms");
assert(strcmp(d3.year, "2020") == 0 && strcmp(d3.month, "12") == 0 && strcmp(d3.day, "29") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
xor %esi,%esi
xor %ecx,%ecx
mov $0x1,%edx
push %rbx
mov %rdi,%rbx
sub $0xa8,%rsp
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rbp
mov %si,0x62(%rsp)
lea 0xc4b(%rip),%rsi
mov %rbp,%rdi
movl $0x0,0x5a(%rsp)
movb $0x0,0x5e(%rsp)
mov %cx,0x5f(%rsp)
movb $0x0,0x61(%rsp)
movb $0x0,0x64(%rsp)
callq 10e0 <regcomp@plt>
test %eax,%eax
je 1450 <func0+0xd0>
mov 0x5a(%rsp),%rax
mov %rax,0x65(%rsp)
movzwl 0x62(%rsp),%eax
mov 0x65(%rsp),%r8
mov %ax,0x6d(%rsp)
movzbl 0x64(%rsp),%eax
movzbl 0x6e(%rsp),%edx
mov %al,0x6f(%rsp)
movzbl 0x6d(%rsp),%eax
shl $0x8,%rdx
or %rax,%rdx
movzbl 0x6f(%rsp),%eax
shl $0x10,%rax
or %rax,%rdx
mov 0x98(%rsp),%rax
xor %fs:0x28,%rax
jne 1545 <func0+0x1c5>
add $0xa8,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
retq
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
lea 0x70(%rsp),%rcx
mov $0x4,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 10f0 <regexec@plt>
test %eax,%eax
je 1480 <func0+0x100>
mov %rbp,%rdi
callq 10b0 <regfree@plt>
jmpq 13e5 <func0+0x65>
nopl 0x0(%rax)
movslq 0x78(%rsp),%rax
lea 0x5a(%rsp),%rdi
sub $0x8,%rsp
lea 0xebc(%rip),%r8
mov $0x5,%ecx
mov $0x5,%esi
mov %rax,%rdx
add %rbx,%rax
push %rax
mov 0x8c(%rsp),%r9d
xor %eax,%eax
sub %edx,%r9d
mov $0x1,%edx
callq 10a0 <__snprintf_chk@plt>
lea 0x6f(%rsp),%rdi
movslq 0x90(%rsp),%rax
mov 0x94(%rsp),%r9d
lea 0xe78(%rip),%r8
mov $0x3,%ecx
mov $0x3,%esi
mov %rax,%rdx
add %rbx,%rax
mov %rax,(%rsp)
sub %edx,%r9d
xor %eax,%eax
mov $0x1,%edx
callq 10a0 <__snprintf_chk@plt>
lea 0x72(%rsp),%r10
mov $0x1,%edx
movslq 0x98(%rsp),%rdi
mov 0x9c(%rsp),%r9d
mov $0x3,%ecx
mov $0x3,%esi
lea 0xe2a(%rip),%r8
mov %rdi,%rax
add %rbx,%rdi
mov %rdi,(%rsp)
sub %eax,%r9d
mov %r10,%rdi
xor %eax,%eax
callq 10a0 <__snprintf_chk@plt>
pop %rax
pop %rdx
jmpq 146c <func0+0xec>
callq 10c0 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
xor ecx, ecx
mov edx, 1
lea rsi, a09409120912; "/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/"
push rbx
mov rbx, rdi
sub rsp, 0A8h
mov rax, fs:28h
mov [rsp+0B8h+var_20], rax
xor eax, eax
lea rbp, [rsp+0B8h+var_A8]
mov [rsp+0B8h+var_56], cx
mov rdi, rbp
mov [rsp+0B8h+var_54], 0
mov [rsp+0B8h+var_5E], 0
call _regcomp
test eax, eax
jz short loc_1460
loc_1415:
movzx edx, [rsp+0B8h+var_56]
mov r8, [rsp+0B8h+var_5E]
movzx eax, dh
movzx edx, dl
movzx eax, al
shl rax, 8
or rax, rdx
movzx edx, [rsp+0B8h+var_54]
shl rdx, 10h
or rdx, rax
mov rax, [rsp+0B8h+var_20]
sub rax, fs:28h
jnz loc_1552
add rsp, 0A8h
mov rax, r8
pop rbx
pop rbp
retn
loc_1460:
xor r8d, r8d
lea rcx, [rsp+0B8h+var_48]
mov edx, 4
mov rsi, rbx
mov rdi, rbp
call _regexec
test eax, eax
jz short loc_1490
loc_147C:
mov rdi, rbp
call _regfree
jmp short loc_1415
loc_1490:
movsxd rax, [rsp+0B8h+var_40]
lea rdi, [rsp+0B8h+var_5E]
sub rsp, 8
lea r8, aS; "%.*s"
mov ecx, 5
mov esi, 5
mov rdx, rax
add rax, rbx
push rax
mov r9d, [rsp+0C8h+var_3C]
xor eax, eax
sub r9d, edx
mov edx, 1
call ___snprintf_chk
lea rdi, [rsp+0C8h+var_5E+5]
movsxd rax, [rsp+0C8h+var_38]
mov r9d, [rsp+0C8h+var_34]
lea r8, aS; "%.*s"
mov ecx, 3
mov esi, 3
mov rdx, rax
add rax, rbx
mov [rsp+0C8h+var_C8], rax
sub r9d, edx
xor eax, eax
mov edx, 1
call ___snprintf_chk
lea rdi, [rsp+0C8h+var_56]
movsxd rax, [rsp+0C8h+var_30]
mov r9d, [rsp+0C8h+var_2C]
lea r8, aS; "%.*s"
mov ecx, 3
mov esi, 3
mov rdx, rax
add rax, rbx
mov [rsp+0C8h+var_C8], rax
sub r9d, edx
xor eax, eax
mov edx, 1
call ___snprintf_chk
pop rax
pop rdx
jmp loc_147C
loc_1552:
call ___stack_chk_fail | long long func0(long long a1)
{
_BYTE v2[74]; // [rsp+20h] [rbp-A8h] BYREF
long long v3; // [rsp+6Ah] [rbp-5Eh] BYREF
__int16 v4; // [rsp+72h] [rbp-56h] BYREF
char v5; // [rsp+74h] [rbp-54h]
_BYTE v6[8]; // [rsp+80h] [rbp-48h] BYREF
int v7; // [rsp+88h] [rbp-40h]
int v8; // [rsp+8Ch] [rbp-3Ch]
int v9; // [rsp+90h] [rbp-38h]
int v10; // [rsp+94h] [rbp-34h]
int v11; // [rsp+98h] [rbp-30h]
int v12; // [rsp+9Ch] [rbp-2Ch]
unsigned long long v13; // [rsp+A8h] [rbp-20h]
v13 = __readfsqword(0x28u);
v4 = 0;
v5 = 0;
v3 = 0LL;
if ( !(unsigned int)regcomp(v2, "/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/", 1LL) )
{
if ( !(unsigned int)regexec(v2, a1, 4LL, v6, 0LL) )
{
__snprintf_chk(&v3, 5LL, 1LL, 5LL, "%.*s", v8 - v7, (const char *)(a1 + v7));
__snprintf_chk((char *)&v3 + 5, 3LL, 1LL, 3LL, "%.*s", v10 - v9, (const char *)(a1 + v9));
__snprintf_chk(&v4, 3LL, 1LL, 3LL, "%.*s", v12 - v11, (const char *)(a1 + v11));
}
regfree(v2);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
XOR ECX,ECX
MOV EDX,0x1
LEA RSI,[0x102008]
PUSH RBX
MOV RBX,RDI
SUB RSP,0xa8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
LEA RBP,[RSP + 0x10]
MOV word ptr [RSP + 0x62],CX
MOV RDI,RBP
MOV byte ptr [RSP + 0x64],0x0
MOV qword ptr [RSP + 0x5a],0x0
CALL 0x001010f0
TEST EAX,EAX
JZ 0x00101460
LAB_00101415:
MOVZX EDX,word ptr [RSP + 0x62]
MOV R8,qword ptr [RSP + 0x5a]
MOVZX EAX,DH
MOVZX EDX,DL
MOVZX EAX,AL
SHL RAX,0x8
OR RAX,RDX
MOVZX EDX,byte ptr [RSP + 0x64]
SHL RDX,0x10
OR RDX,RAX
MOV RAX,qword ptr [RSP + 0x98]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101552
ADD RSP,0xa8
MOV RAX,R8
POP RBX
POP RBP
RET
LAB_00101460:
XOR R8D,R8D
LEA RCX,[RSP + 0x70]
MOV EDX,0x4
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101110
TEST EAX,EAX
JZ 0x00101490
LAB_0010147c:
MOV RDI,RBP
CALL 0x001010c0
JMP 0x00101415
LAB_00101490:
MOVSXD RAX,dword ptr [RSP + 0x78]
LEA RDI,[RSP + 0x5a]
SUB RSP,0x8
LEA R8,[0x102311]
MOV ECX,0x5
MOV ESI,0x5
MOV RDX,RAX
ADD RAX,RBX
PUSH RAX
MOV R9D,dword ptr [RSP + 0x8c]
XOR EAX,EAX
SUB R9D,EDX
MOV EDX,0x1
CALL 0x001010b0
LEA RDI,[RSP + 0x6f]
MOVSXD RAX,dword ptr [RSP + 0x90]
MOV R9D,dword ptr [RSP + 0x94]
LEA R8,[0x102311]
MOV ECX,0x3
MOV ESI,0x3
MOV RDX,RAX
ADD RAX,RBX
MOV qword ptr [RSP],RAX
SUB R9D,EDX
XOR EAX,EAX
MOV EDX,0x1
CALL 0x001010b0
LEA RDI,[RSP + 0x72]
MOVSXD RAX,dword ptr [RSP + 0x98]
MOV R9D,dword ptr [RSP + 0x9c]
LEA R8,[0x102311]
MOV ECX,0x3
MOV ESI,0x3
MOV RDX,RAX
ADD RAX,RBX
MOV qword ptr [RSP],RAX
SUB R9D,EDX
XOR EAX,EAX
MOV EDX,0x1
CALL 0x001010b0
POP RAX
POP RDX
JMP 0x0010147c
LAB_00101552:
CALL 0x001010d0 | int8 func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t local_a8;
int8 local_5e;
int3 local_56 [3];
regmatch_t local_48;
int local_40;
int local_3c;
int local_38;
int local_34;
int local_30;
int local_2c;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_56[0] = 0;
local_5e = 0;
iVar1 = regcomp(&local_a8,"/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_a8,param_1,4,&local_48,0);
if (iVar1 == 0) {
__snprintf_chk(&local_5e,5,1,5,&DAT_00102311,local_3c - local_40,param_1 + local_40);
__snprintf_chk((long)&local_5e + 5,3,1,3,&DAT_00102311,local_34 - local_38,param_1 + local_38)
;
__snprintf_chk(local_56,3,1,3,&DAT_00102311,local_2c - local_30,param_1 + local_30);
}
regfree(&local_a8);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_5e;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,519 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
typedef struct {
char year[5];
char month[3];
char day[3];
} Date;
| Date func0(const char* url) {
regex_t regex;
regmatch_t matches[4];
Date date = {"", "", ""};
const char* pattern = "/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/";
if (regcomp(®ex, pattern, REG_EXTENDED)) {
return date;
}
if (!regexec(®ex, url, 4, matches, 0)) {
int start, end;
// Year
start = matches[1].rm_so;
end = matches[1].rm_eo;
snprintf(date.year, sizeof(date.year), "%.*s", end - start, url + start);
// Month
start = matches[2].rm_so;
end = matches[2].rm_eo;
snprintf(date.month, sizeof(date.month), "%.*s", end - start, url + start);
// Day
start = matches[3].rm_so;
end = matches[3].rm_eo;
snprintf(date.day, sizeof(date.day), "%.*s", end - start, url + start);
}
regfree(®ex);
return date;
}
| int main() {
Date d1 = func0("https://www.washingtonpost.com/news/football-insider/wp/2016/09/02/odell-beckhams-fame-rests-on-one-stupid-little-ball-josh-norman-tells-author/");
assert(strcmp(d1.year, "2016") == 0 && strcmp(d1.month, "09") == 0 && strcmp(d1.day, "02") == 0);
Date d2 = func0("https://www.indiatoday.in/movies/celebrities/story/wp/2020/11/03/odeof-sushant-singh-rajput-s-death-his-brother-in-law-shares-advice-for-fans-1749646/");
assert(strcmp(d2.year, "2020") == 0 && strcmp(d2.month, "11") == 0 && strcmp(d2.day, "03") == 0);
Date d3 = func0("https://economictimes.indiatimes.com/news/economy/2020/12/29/finance/pension-assets-under-pfrda-touch-rs-5-32-lakh-crore/articleshow/79736619.cms");
assert(strcmp(d3.year, "2020") == 0 && strcmp(d3.month, "12") == 0 && strcmp(d3.day, "29") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
xor %esi,%esi
xor %ecx,%ecx
mov $0x1,%edx
push %rbx
mov %rdi,%rbx
sub $0xa8,%rsp
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rbp
mov %si,0x62(%rsp)
lea 0xc4b(%rip),%rsi
mov %rbp,%rdi
movl $0x0,0x5a(%rsp)
movb $0x0,0x5e(%rsp)
mov %cx,0x5f(%rsp)
movb $0x0,0x61(%rsp)
movb $0x0,0x64(%rsp)
callq 10e0 <regcomp@plt>
test %eax,%eax
je 1450 <func0+0xd0>
mov 0x5a(%rsp),%rax
mov %rax,0x65(%rsp)
movzwl 0x62(%rsp),%eax
mov 0x65(%rsp),%r8
mov %ax,0x6d(%rsp)
movzbl 0x64(%rsp),%eax
movzbl 0x6e(%rsp),%edx
mov %al,0x6f(%rsp)
movzbl 0x6d(%rsp),%eax
shl $0x8,%rdx
or %rax,%rdx
movzbl 0x6f(%rsp),%eax
shl $0x10,%rax
or %rax,%rdx
mov 0x98(%rsp),%rax
xor %fs:0x28,%rax
jne 1545 <func0+0x1c5>
add $0xa8,%rsp
mov %r8,%rax
pop %rbx
pop %rbp
retq
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
lea 0x70(%rsp),%rcx
mov $0x4,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 10f0 <regexec@plt>
test %eax,%eax
je 1480 <func0+0x100>
mov %rbp,%rdi
callq 10b0 <regfree@plt>
jmpq 13e5 <func0+0x65>
nopl 0x0(%rax)
movslq 0x78(%rsp),%rax
lea 0x5a(%rsp),%rdi
sub $0x8,%rsp
lea 0xebc(%rip),%r8
mov $0x5,%ecx
mov $0x5,%esi
mov %rax,%rdx
add %rbx,%rax
push %rax
mov 0x8c(%rsp),%r9d
xor %eax,%eax
sub %edx,%r9d
mov $0x1,%edx
callq 10a0 <__snprintf_chk@plt>
lea 0x6f(%rsp),%rdi
movslq 0x90(%rsp),%rax
mov 0x94(%rsp),%r9d
lea 0xe78(%rip),%r8
mov $0x3,%ecx
mov $0x3,%esi
mov %rax,%rdx
add %rbx,%rax
mov %rax,(%rsp)
sub %edx,%r9d
xor %eax,%eax
mov $0x1,%edx
callq 10a0 <__snprintf_chk@plt>
lea 0x72(%rsp),%r10
mov $0x1,%edx
movslq 0x98(%rsp),%rdi
mov 0x9c(%rsp),%r9d
mov $0x3,%ecx
mov $0x3,%esi
lea 0xe2a(%rip),%r8
mov %rdi,%rax
add %rbx,%rdi
mov %rdi,(%rsp)
sub %eax,%r9d
mov %r10,%rdi
xor %eax,%eax
callq 10a0 <__snprintf_chk@plt>
pop %rax
pop %rdx
jmpq 146c <func0+0xec>
callq 10c0 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
xor ecx, ecx
mov rbp, rdi
mov edx, 1; cflags
push rbx
lea rsi, pattern; "/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/"
sub rsp, 0A8h
mov rax, fs:28h
mov [rsp+0B8h+var_20], rax
xor eax, eax
lea rbx, [rsp+0B8h+preg]
mov [rsp+0B8h+var_56], cx
mov rdi, rbx; preg
mov [rsp+0B8h+var_54], 0
mov [rsp+0B8h+var_5E], 0
call _regcomp
test eax, eax
jz short loc_1470
loc_1415:
mov rax, [rsp+0B8h+var_5E]
mov [rsp+0B8h+var_53], rax
mov eax, dword ptr [rsp+0B8h+var_5E+7]
mov dword ptr [rsp+0B8h+var_53+7], eax
movzx eax, [rsp+0B8h+var_4A]
movzx edx, [rsp+0B8h+var_4B]
mov rcx, [rsp+0B8h+var_53]
shl rax, 8
or rax, rdx
movzx edx, [rsp+0B8h+var_49]
shl rdx, 10h
or rdx, rax
mov rax, [rsp+0B8h+var_20]
sub rax, fs:28h
jnz loc_1562
add rsp, 0A8h
mov rax, rcx
pop rbx
pop rbp
retn
loc_1470:
xor r8d, r8d; eflags
lea rcx, [rsp+0B8h+pmatch]; pmatch
mov edx, 4; nmatch
mov rsi, rbp; string
mov rdi, rbx; preg
call _regexec
test eax, eax
jz short loc_14A0
loc_148C:
mov rdi, rbx; preg
call _regfree
jmp loc_1415
loc_14A0:
movsxd rax, [rsp+0B8h+var_40]
lea rdi, [rsp+0B8h+var_5E]
sub rsp, 8
lea r8, aS; "%.*s"
mov ecx, 5
mov esi, 5
mov rdx, rax
add rax, rbp
push rax
mov r9d, [rsp+0C8h+var_3C]
xor eax, eax
sub r9d, edx
mov edx, 2
call ___snprintf_chk
lea rdi, [rsp+0C8h+var_5E+5]
movsxd rax, [rsp+0C8h+var_38]
mov r9d, [rsp+0C8h+var_34]
lea r8, aS; "%.*s"
mov ecx, 3
mov esi, 3
mov rdx, rax
add rax, rbp
mov [rsp+0C8h+var_C8], rax
sub r9d, edx
xor eax, eax
mov edx, 2
call ___snprintf_chk
lea rdi, [rsp+0C8h+var_56]
movsxd rax, [rsp+0C8h+var_30]
mov r9d, [rsp+0C8h+var_2C]
lea r8, aS; "%.*s"
mov ecx, 3
mov esi, 3
mov rdx, rax
add rax, rbp
mov [rsp+0C8h+var_C8], rax
sub r9d, edx
xor eax, eax
mov edx, 2
call ___snprintf_chk
pop rax
pop rdx
jmp loc_148C
loc_1562:
call ___stack_chk_fail | long long func0(char *string)
{
regex_t preg; // [rsp+20h] [rbp-A8h] BYREF
_BYTE v3[11]; // [rsp+6Ah] [rbp-5Eh] BYREF
_BYTE v4[11]; // [rsp+75h] [rbp-53h]
regmatch_t pmatch; // [rsp+80h] [rbp-48h] BYREF
int v6; // [rsp+88h] [rbp-40h]
int v7; // [rsp+8Ch] [rbp-3Ch]
int v8; // [rsp+90h] [rbp-38h]
int v9; // [rsp+94h] [rbp-34h]
int v10; // [rsp+98h] [rbp-30h]
int v11; // [rsp+9Ch] [rbp-2Ch]
unsigned long long v12; // [rsp+A8h] [rbp-20h]
v12 = __readfsqword(0x28u);
memset(v3, 0, sizeof(v3));
if ( !regcomp(&preg, "/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/", 1) )
{
if ( !regexec(&preg, string, 4uLL, &pmatch, 0) )
{
__snprintf_chk(v3, 5LL, 2LL, 5LL, "%.*s", v7 - v6, &string[v6]);
__snprintf_chk(&v3[5], 3LL, 2LL, 3LL, "%.*s", v9 - v8, &string[v8]);
__snprintf_chk(&v3[8], 3LL, 2LL, 3LL, "%.*s", v11 - v10, &string[v10]);
}
regfree(&preg);
}
*(_QWORD *)v4 = *(_QWORD *)v3;
*(_DWORD *)&v4[7] = *(_DWORD *)&v3[7];
return *(_QWORD *)v4;
} | func0:
ENDBR64
PUSH RBP
XOR ECX,ECX
MOV RBP,RDI
MOV EDX,0x1
PUSH RBX
LEA RSI,[0x102008]
SUB RSP,0xa8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
LEA RBX,[RSP + 0x10]
MOV word ptr [RSP + 0x62],CX
MOV RDI,RBX
MOV byte ptr [RSP + 0x64],0x0
MOV qword ptr [RSP + 0x5a],0x0
CALL 0x001010f0
TEST EAX,EAX
JZ 0x00101470
LAB_00101415:
MOV RAX,qword ptr [RSP + 0x5a]
MOV qword ptr [RSP + 0x65],RAX
MOV EAX,dword ptr [RSP + 0x61]
MOV dword ptr [RSP + 0x6c],EAX
MOVZX EAX,byte ptr [RSP + 0x6e]
MOVZX EDX,byte ptr [RSP + 0x6d]
MOV RCX,qword ptr [RSP + 0x65]
SHL RAX,0x8
OR RAX,RDX
MOVZX EDX,byte ptr [RSP + 0x6f]
SHL RDX,0x10
OR RDX,RAX
MOV RAX,qword ptr [RSP + 0x98]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101562
ADD RSP,0xa8
MOV RAX,RCX
POP RBX
POP RBP
RET
LAB_00101470:
XOR R8D,R8D
LEA RCX,[RSP + 0x70]
MOV EDX,0x4
MOV RSI,RBP
MOV RDI,RBX
CALL 0x00101110
TEST EAX,EAX
JZ 0x001014a0
LAB_0010148c:
MOV RDI,RBX
CALL 0x001010c0
JMP 0x00101415
LAB_001014a0:
MOVSXD RAX,dword ptr [RSP + 0x78]
LEA RDI,[RSP + 0x5a]
SUB RSP,0x8
LEA R8,[0x102319]
MOV ECX,0x5
MOV ESI,0x5
MOV RDX,RAX
ADD RAX,RBP
PUSH RAX
MOV R9D,dword ptr [RSP + 0x8c]
XOR EAX,EAX
SUB R9D,EDX
MOV EDX,0x2
CALL 0x001010b0
LEA RDI,[RSP + 0x6f]
MOVSXD RAX,dword ptr [RSP + 0x90]
MOV R9D,dword ptr [RSP + 0x94]
LEA R8,[0x102319]
MOV ECX,0x3
MOV ESI,0x3
MOV RDX,RAX
ADD RAX,RBP
MOV qword ptr [RSP],RAX
SUB R9D,EDX
XOR EAX,EAX
MOV EDX,0x2
CALL 0x001010b0
LEA RDI,[RSP + 0x72]
MOVSXD RAX,dword ptr [RSP + 0x98]
MOV R9D,dword ptr [RSP + 0x9c]
LEA R8,[0x102319]
MOV ECX,0x3
MOV ESI,0x3
MOV RDX,RAX
ADD RAX,RBP
MOV qword ptr [RSP],RAX
SUB R9D,EDX
XOR EAX,EAX
MOV EDX,0x2
CALL 0x001010b0
POP RAX
POP RDX
JMP 0x0010148c
LAB_00101562:
CALL 0x001010d0 | int8 func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t local_a8;
int local_5e [7];
int uStack_57;
int2 uStack_56;
int uStack_54;
int7 local_53;
int4 uStack_4c;
regmatch_t local_48;
int local_40;
int local_3c;
int local_38;
int local_34;
int local_30;
int local_2c;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
uStack_56 = 0;
uStack_54 = 0;
local_5e = (int [7])0x0;
uStack_57 = 0;
iVar1 = regcomp(&local_a8,"/([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_a8,param_1,4,&local_48,0);
if (iVar1 == 0) {
__snprintf_chk(local_5e,5,2,5,&DAT_00102319,local_3c - local_40,param_1 + local_40);
__snprintf_chk(local_5e + 5,3,2,3,&DAT_00102319,local_34 - local_38,param_1 + local_38);
__snprintf_chk(&uStack_56,3,2,3,&DAT_00102319,local_2c - local_30,param_1 + local_30);
}
regfree(&local_a8);
}
local_53 = local_5e;
uStack_4c = CONCAT13(uStack_54,CONCAT21(uStack_56,uStack_57));
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return CONCAT17(uStack_57,local_5e);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,520 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
| int* func0(int n) {
int size = n * n + 9;
int capacity = (size + 1) / 2;
int* list = malloc(capacity * sizeof(int));
if (!list) return NULL;
int index = 0;
for(int num = -1; num < size; num += 2){
list[index++] = num;
}
int current_size = index;
int i = 2;
while(i < current_size){
if(i >= current_size) break;
int step = list[i];
if(step <= 0) break;
int* new_list = malloc(current_size * sizeof(int));
int new_index = 0;
for(int j = 0; j < current_size; j++){
if((j < step) || ((j - step) % step != 0)){
new_list[new_index++] = list[j];
}
}
free(list);
list = new_list;
current_size = new_index;
i++;
}
int* result = malloc(n * sizeof(int));
for(int k = 0; k < n; k++){
if(k+1 < current_size){
result[k] = list[k+1];
} else {
result[k] = 0;
}
}
free(list);
return result;
}
| int main() {
int expected1[10] = {1, 3, 7, 9, 13, 15, 21, 25, 31, 33};
int expected2[5] = {1, 3, 7, 9, 13};
int expected3[8] = {1, 3, 7, 9, 13, 15, 21, 25};
int* result1 = func0(10);
for(int i = 0; i < 10; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
int* result2 = func0(5);
for(int i = 0; i < 5; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
int* result3 = func0(8);
for(int i = 0; i < 8; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %edi,-0x44(%rbp)
mov -0x44(%rbp),%eax
imul %eax,%eax
add $0x9,%eax
mov %eax,-0x24(%rbp)
mov -0x24(%rbp),%eax
add $0x1,%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x20(%rbp)
mov -0x20(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
cmpq $0x0,-0x18(%rbp)
jne 11fc <func0+0x53>
mov $0x0,%eax
jmpq 13b6 <func0+0x20d>
movl $0x0,-0x40(%rbp)
movl $0xffffffff,-0x3c(%rbp)
jmp 122f <func0+0x86>
mov -0x40(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x40(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x3c(%rbp),%eax
mov %eax,(%rdx)
addl $0x2,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 120c <func0+0x63>
mov -0x40(%rbp),%eax
mov %eax,-0x38(%rbp)
movl $0x2,-0x34(%rbp)
jmpq 1312 <func0+0x169>
mov -0x34(%rbp),%eax
cmp -0x38(%rbp),%eax
jge 1320 <func0+0x177>
mov -0x34(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x1c(%rbp)
cmpl $0x0,-0x1c(%rbp)
jle 1323 <func0+0x17a>
mov -0x38(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x10(%rbp)
movl $0x0,-0x30(%rbp)
movl $0x0,-0x2c(%rbp)
jmp 12ec <func0+0x143>
mov -0x2c(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 12b5 <func0+0x10c>
mov -0x2c(%rbp),%eax
sub -0x1c(%rbp),%eax
cltd
idivl -0x1c(%rbp)
mov %edx,%eax
test %eax,%eax
je 12e8 <func0+0x13f>
mov -0x2c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x30(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x30(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x10(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x38(%rbp),%eax
jl 129d <func0+0xf4>
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
mov -0x10(%rbp),%rax
mov %rax,-0x18(%rbp)
mov -0x30(%rbp),%eax
mov %eax,-0x38(%rbp)
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x38(%rbp),%eax
jl 1249 <func0+0xa0>
jmp 1324 <func0+0x17b>
jmp 1324 <func0+0x17b>
mov -0x44(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x28(%rbp)
jmp 139e <func0+0x1f5>
mov -0x28(%rbp),%eax
add $0x1,%eax
cmp %eax,-0x38(%rbp)
jle 1380 <func0+0x1d7>
mov -0x28(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x28(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
jmp 139a <func0+0x1f1>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movl $0x0,(%rax)
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x44(%rbp),%eax
jl 1342 <func0+0x199>
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <free@plt>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_44], edi
mov eax, [rbp+var_44]
imul eax, eax
add eax, 9
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
add eax, 1
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
cmp [rbp+ptr], 0
jnz short loc_11FC
mov eax, 0
jmp locret_13B6
loc_11FC:
mov [rbp+var_40], 0
mov [rbp+var_3C], 0FFFFFFFFh
jmp short loc_122F
loc_120C:
mov eax, [rbp+var_40]
lea edx, [rax+1]
mov [rbp+var_40], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_3C]
mov [rdx], eax
add [rbp+var_3C], 2
loc_122F:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_24]
jl short loc_120C
mov eax, [rbp+var_40]
mov [rbp+var_38], eax
mov [rbp+var_34], 2
jmp loc_1312
loc_1249:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_38]
jge loc_1320
mov eax, [rbp+var_34]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jle loc_1323
mov eax, [rbp+var_38]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_10], rax
mov [rbp+var_30], 0
mov [rbp+var_2C], 0
jmp short loc_12EC
loc_129D:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_1C]
jl short loc_12B5
mov eax, [rbp+var_2C]
sub eax, [rbp+var_1C]
cdq
idiv [rbp+var_1C]
mov eax, edx
test eax, eax
jz short loc_12E8
loc_12B5:
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
lea rcx, [rdx+rax]
mov eax, [rbp+var_30]
lea edx, [rax+1]
mov [rbp+var_30], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_10]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_12E8:
add [rbp+var_2C], 1
loc_12EC:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_38]
jl short loc_129D
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_10]
mov [rbp+ptr], rax
mov eax, [rbp+var_30]
mov [rbp+var_38], eax
add [rbp+var_34], 1
loc_1312:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_38]
jl loc_1249
jmp short loc_1324
loc_1320:
nop
jmp short loc_1324
loc_1323:
nop
loc_1324:
mov eax, [rbp+var_44]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_28], 0
jmp short loc_139E
loc_1342:
mov eax, [rbp+var_28]
add eax, 1
cmp [rbp+var_38], eax
jle short loc_1380
mov eax, [rbp+var_28]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rbp+var_28]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_8]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
jmp short loc_139A
loc_1380:
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov dword ptr [rax], 0
loc_139A:
add [rbp+var_28], 1
loc_139E:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_44]
jl short loc_1342
mov rax, [rbp+ptr]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_8]
locret_13B6:
leave
retn | _DWORD * func0(int a1)
{
int v2; // eax
int v3; // eax
int v4; // [rsp+10h] [rbp-40h]
int i; // [rsp+14h] [rbp-3Ch]
int v6; // [rsp+18h] [rbp-38h]
int j; // [rsp+1Ch] [rbp-34h]
int v8; // [rsp+20h] [rbp-30h]
int k; // [rsp+24h] [rbp-2Ch]
int m; // [rsp+28h] [rbp-28h]
int v11; // [rsp+34h] [rbp-1Ch]
_DWORD *ptr; // [rsp+38h] [rbp-18h]
_DWORD *v13; // [rsp+40h] [rbp-10h]
_DWORD *v14; // [rsp+48h] [rbp-8h]
ptr = malloc(4LL * ((a1 * a1 + 10) / 2));
if ( !ptr )
return 0LL;
v4 = 0;
for ( i = -1; i < a1 * a1 + 9; i += 2 )
{
v2 = v4++;
ptr[v2] = i;
}
v6 = v4;
for ( j = 2; j < v6; ++j )
{
v11 = ptr[j];
if ( v11 <= 0 )
break;
v13 = malloc(4LL * v6);
v8 = 0;
for ( k = 0; k < v6; ++k )
{
if ( k < v11 || (k - v11) % v11 )
{
v3 = v8++;
v13[v3] = ptr[k];
}
}
free(ptr);
ptr = v13;
v6 = v8;
}
v14 = malloc(4LL * a1);
for ( m = 0; m < a1; ++m )
{
if ( v6 <= m + 1 )
v14[m] = 0;
else
v14[m] = ptr[m + 1];
}
free(ptr);
return v14;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV dword ptr [RBP + -0x44],EDI
MOV EAX,dword ptr [RBP + -0x44]
IMUL EAX,EAX
ADD EAX,0x9
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x001011fc
MOV EAX,0x0
JMP 0x001013b6
LAB_001011fc:
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x3c],0xffffffff
JMP 0x0010122f
LAB_0010120c:
MOV EAX,dword ptr [RBP + -0x40]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x40],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x3c],0x2
LAB_0010122f:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x0010120c
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x38],EAX
MOV dword ptr [RBP + -0x34],0x2
JMP 0x00101312
LAB_00101249:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x38]
JGE 0x00101320
MOV EAX,dword ptr [RBP + -0x34]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x00101323
MOV EAX,dword ptr [RBP + -0x38]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x001012ec
LAB_0010129d:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001012b5
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,dword ptr [RBP + -0x1c]
CDQ
IDIV dword ptr [RBP + -0x1c]
MOV EAX,EDX
TEST EAX,EAX
JZ 0x001012e8
LAB_001012b5:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x30]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x30],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_001012e8:
ADD dword ptr [RBP + -0x2c],0x1
LAB_001012ec:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x38]
JL 0x0010129d
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x38],EAX
ADD dword ptr [RBP + -0x34],0x1
LAB_00101312:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x38]
JL 0x00101249
JMP 0x00101324
LAB_00101320:
NOP
JMP 0x00101324
LAB_00101323:
NOP
LAB_00101324:
MOV EAX,dword ptr [RBP + -0x44]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x28],0x0
JMP 0x0010139e
LAB_00101342:
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
CMP dword ptr [RBP + -0x38],EAX
JLE 0x00101380
MOV EAX,dword ptr [RBP + -0x28]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x28]
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
JMP 0x0010139a
LAB_00101380:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV dword ptr [RAX],0x0
LAB_0010139a:
ADD dword ptr [RBP + -0x28],0x1
LAB_0010139e:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x00101342
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV RAX,qword ptr [RBP + -0x8]
LAB_001013b6:
LEAVE
RET | void * func0(int param_1)
{
int iVar1;
void *pvVar2;
int local_48;
int local_44;
int local_40;
int local_3c;
int local_38;
int local_34;
int local_30;
void *local_20;
local_20 = malloc((long)((param_1 * param_1 + 10) / 2) << 2);
if (local_20 == (void *)0x0) {
pvVar2 = (void *)0x0;
}
else {
local_48 = 0;
for (local_44 = -1; local_44 < param_1 * param_1 + 9; local_44 = local_44 + 2) {
*(int *)((long)local_48 * 4 + (long)local_20) = local_44;
local_48 = local_48 + 1;
}
local_40 = local_48;
local_3c = 2;
while (((local_3c < local_40 && (local_3c < local_40)) &&
(iVar1 = *(int *)((long)local_20 + (long)local_3c * 4), 0 < iVar1))) {
pvVar2 = malloc((long)local_40 << 2);
local_38 = 0;
for (local_34 = 0; local_34 < local_40; local_34 = local_34 + 1) {
if ((local_34 < iVar1) || ((local_34 - iVar1) % iVar1 != 0)) {
*(int4 *)((long)local_38 * 4 + (long)pvVar2) =
*(int4 *)((long)local_34 * 4 + (long)local_20);
local_38 = local_38 + 1;
}
}
free(local_20);
local_40 = local_38;
local_3c = local_3c + 1;
local_20 = pvVar2;
}
pvVar2 = malloc((long)param_1 << 2);
for (local_30 = 0; local_30 < param_1; local_30 = local_30 + 1) {
if (local_30 + 1 < local_40) {
*(int4 *)((long)pvVar2 + (long)local_30 * 4) =
*(int4 *)((long)local_20 + ((long)local_30 + 1) * 4);
}
else {
*(int4 *)((long)pvVar2 + (long)local_30 * 4) = 0;
}
}
free(local_20);
}
return pvVar2;
} |
7,521 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
| int* func0(int n) {
int size = n * n + 9;
int capacity = (size + 1) / 2;
int* list = malloc(capacity * sizeof(int));
if (!list) return NULL;
int index = 0;
for(int num = -1; num < size; num += 2){
list[index++] = num;
}
int current_size = index;
int i = 2;
while(i < current_size){
if(i >= current_size) break;
int step = list[i];
if(step <= 0) break;
int* new_list = malloc(current_size * sizeof(int));
int new_index = 0;
for(int j = 0; j < current_size; j++){
if((j < step) || ((j - step) % step != 0)){
new_list[new_index++] = list[j];
}
}
free(list);
list = new_list;
current_size = new_index;
i++;
}
int* result = malloc(n * sizeof(int));
for(int k = 0; k < n; k++){
if(k+1 < current_size){
result[k] = list[k+1];
} else {
result[k] = 0;
}
}
free(list);
return result;
}
| int main() {
int expected1[10] = {1, 3, 7, 9, 13, 15, 21, 25, 31, 33};
int expected2[5] = {1, 3, 7, 9, 13};
int expected3[8] = {1, 3, 7, 9, 13, 15, 21, 25};
int* result1 = func0(10);
for(int i = 0; i < 10; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
int* result2 = func0(5);
for(int i = 0; i < 5; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
int* result3 = func0(8);
for(int i = 0; i < 8; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,0xc(%rsp)
mov %edi,%ebp
imul %edi,%ebp
lea 0xa(%rbp),%eax
mov %eax,%edi
shr $0x1f,%edi
add %eax,%edi
sar %edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 12ed <func0+0x144>
lea 0x9(%rbp),%ebx
mov %rax,%rdx
mov $0xffffffff,%eax
mov %eax,(%rdx)
add $0x2,%eax
add $0x4,%rdx
cmp %eax,%ebx
jg 11f3 <func0+0x4a>
add $0x9,%ebp
shr %ebp
lea 0x1(%rbp),%ebx
mov $0x8,%r14d
mov $0x2,%r15d
jmp 125f <func0+0xb6>
mov (%r12,%rcx,4),%edx
movslq %ebx,%rax
mov %edx,0x0(%r13,%rax,4)
lea 0x1(%rbx),%ebx
lea 0x1(%rcx),%rax
cmp %rsi,%rcx
je 1247 <func0+0x9e>
mov %rax,%rcx
cmp %ecx,%ebp
jg 1216 <func0+0x6d>
mov %ecx,%eax
sub %ebp,%eax
cltd
idiv %ebp
test %edx,%edx
je 1225 <func0+0x7c>
jmp 1216 <func0+0x6d>
mov $0x0,%ebx
mov %r12,%rdi
callq 1080 <free@plt>
add $0x1,%r15d
add $0x4,%r14
cmp %ebx,%r15d
jge 1289 <func0+0xe0>
mov %r13,%r12
mov (%r12,%r14,1),%ebp
test %ebp,%ebp
jle 128c <func0+0xe3>
movslq %ebx,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r13
test %ebx,%ebx
jle 1242 <func0+0x99>
lea -0x1(%rbx),%esi
mov $0x0,%ecx
mov $0x0,%ebx
jmp 1231 <func0+0x88>
mov %r13,%r12
mov 0xc(%rsp),%r15d
movslq %r15d,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rbp
test %r15d,%r15d
jle 12d3 <func0+0x12a>
lea -0x1(%r15),%edx
add $0x2,%rdx
mov $0x1,%eax
jmp 12c5 <func0+0x11c>
movl $0x0,-0x4(%rbp,%rax,4)
add $0x1,%rax
cmp %rdx,%rax
je 12d3 <func0+0x12a>
cmp %eax,%ebx
jle 12b4 <func0+0x10b>
mov (%r12,%rax,4),%ecx
mov %ecx,-0x4(%rbp,%rax,4)
jmp 12bc <func0+0x113>
mov %r12,%rdi
callq 1080 <free@plt>
mov %rbp,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %rax,%rbp
jmp 12db <func0+0x132>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_3C], edi
mov ebp, edi
imul ebp, edi
lea eax, [rbp+0Ah]
mov edi, eax
shr edi, 1Fh
add edi, eax
sar edi, 1
movsxd rdi, edi
shl rdi, 2
call _malloc
mov r12, rax
test rax, rax
jz loc_12EB
lea ebx, [rbp+9]
mov rdx, rax
mov eax, 0FFFFFFFFh
loc_11F3:
mov [rdx], eax
add eax, 2
add rdx, 4
cmp ebx, eax
jg short loc_11F3
add ebp, 9
shr ebp, 1
lea ebx, [rbp+1]
mov r14d, 8
mov r15d, 2
jmp short loc_125C
loc_1216:
mov edx, [r12+rsi*4]
movsxd rax, ebx
mov [r13+rax*4+0], edx
lea ebx, [rbx+1]
loc_1225:
add rsi, 1
add ecx, 1
cmp ecx, edi
jz short loc_1244
loc_1230:
cmp ebp, esi
jg short loc_1216
mov eax, ecx
cdq
idiv ebp
test edx, edx
jz short loc_1225
jmp short loc_1216
loc_123F:
mov ebx, 0
loc_1244:
mov rdi, r12
call _free
add r15d, 1
add r14, 4
cmp r15d, ebx
jge short loc_128B
mov r12, r13
loc_125C:
mov ebp, [r12+r14]
test ebp, ebp
jle short loc_128E
movsxd rdi, ebx
shl rdi, 2
call _malloc
mov r13, rax
test ebx, ebx
jle short loc_123F
mov ecx, ebp
neg ecx
mov edi, ebx
sub edi, ebp
mov esi, 0
mov ebx, 0
jmp short loc_1230
loc_128B:
mov r12, r13
loc_128E:
mov r15d, [rsp+48h+var_3C]
movsxd rdi, r15d
shl rdi, 2
call _malloc
mov rbp, rax
test r15d, r15d
jle short loc_12D1
lea edx, [r15+1]
mov eax, 1
jmp short loc_12C3
loc_12B2:
mov dword ptr [rbp+rax*4-4], 0
loc_12BA:
add rax, 1
cmp rax, rdx
jz short loc_12D1
loc_12C3:
cmp ebx, eax
jle short loc_12B2
mov ecx, [r12+rax*4]
mov [rbp+rax*4-4], ecx
jmp short loc_12BA
loc_12D1:
mov rdi, r12
call _free
loc_12D9:
mov rax, rbp
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12EB:
mov rbp, rax
jmp short loc_12D9 | long long func0(int a1, long long a2)
{
int v2; // ebp
long long v3; // rax
long long v4; // r12
_DWORD *v5; // rdx
int v6; // eax
signed int v7; // ebx
long long v8; // r14
int v9; // r15d
int v10; // ecx
int v11; // ebp
long long v12; // r13
int v13; // edi
long long v14; // rbp
long long v15; // rax
v2 = a1 * a1;
v3 = malloc(4LL * ((a1 * a1 + 10) / 2));
v4 = v3;
if ( !v3 )
return 0LL;
v5 = (_DWORD *)v3;
v6 = -1;
do
{
*v5 = v6;
v6 += 2;
++v5;
}
while ( v2 + 9 > v6 );
v7 = ((unsigned int)(v2 + 9) >> 1) + 1;
v8 = 8LL;
v9 = 2;
while ( 1 )
{
v11 = *(_DWORD *)(v4 + v8);
if ( v11 <= 0 )
break;
v12 = malloc(4LL * v7);
if ( v7 <= 0 )
{
v7 = 0;
}
else
{
v10 = -v11;
v13 = v7 - v11;
a2 = 0LL;
v7 = 0;
do
{
if ( v11 > (int)a2 || v10 % v11 )
*(_DWORD *)(v12 + 4LL * v7++) = *(_DWORD *)(v4 + 4 * a2);
++a2;
++v10;
}
while ( v10 != v13 );
}
free(v4, a2);
++v9;
v8 += 4LL;
if ( v9 >= v7 )
{
v4 = v12;
break;
}
v4 = v12;
}
v14 = malloc(4LL * a1);
if ( a1 > 0 )
{
v15 = 1LL;
do
{
if ( v7 <= (int)v15 )
*(_DWORD *)(v14 + 4 * v15 - 4) = 0;
else
*(_DWORD *)(v14 + 4 * v15 - 4) = *(_DWORD *)(v4 + 4 * v15);
++v15;
}
while ( v15 != a1 + 1 );
}
free(v4, a2);
return v14;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],EDI
MOV EBP,EDI
IMUL EBP,EDI
LEA EAX,[RBP + 0xa]
MOV EDI,EAX
SHR EDI,0x1f
ADD EDI,EAX
SAR EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV R12,RAX
TEST RAX,RAX
JZ 0x001012eb
LEA EBX,[RBP + 0x9]
MOV RDX,RAX
MOV EAX,0xffffffff
LAB_001011f3:
MOV dword ptr [RDX],EAX
ADD EAX,0x2
ADD RDX,0x4
CMP EBX,EAX
JG 0x001011f3
ADD EBP,0x9
SHR EBP,0x1
LEA EBX,[RBP + 0x1]
MOV R14D,0x8
MOV R15D,0x2
JMP 0x0010125c
LAB_00101216:
MOV EDX,dword ptr [R12 + RSI*0x4]
MOVSXD RAX,EBX
MOV dword ptr [R13 + RAX*0x4],EDX
LEA EBX,[RBX + 0x1]
LAB_00101225:
ADD RSI,0x1
ADD ECX,0x1
CMP ECX,EDI
JZ 0x00101244
LAB_00101230:
CMP EBP,ESI
JG 0x00101216
MOV EAX,ECX
CDQ
IDIV EBP
TEST EDX,EDX
JZ 0x00101225
JMP 0x00101216
LAB_0010123f:
MOV EBX,0x0
LAB_00101244:
MOV RDI,R12
CALL 0x00101080
ADD R15D,0x1
ADD R14,0x4
CMP R15D,EBX
JGE 0x0010128b
MOV R12,R13
LAB_0010125c:
MOV EBP,dword ptr [R12 + R14*0x1]
TEST EBP,EBP
JLE 0x0010128e
MOVSXD RDI,EBX
SHL RDI,0x2
CALL 0x001010b0
MOV R13,RAX
TEST EBX,EBX
JLE 0x0010123f
MOV ECX,EBP
NEG ECX
MOV EDI,EBX
SUB EDI,EBP
MOV ESI,0x0
MOV EBX,0x0
JMP 0x00101230
LAB_0010128b:
MOV R12,R13
LAB_0010128e:
MOV R15D,dword ptr [RSP + 0xc]
MOVSXD RDI,R15D
SHL RDI,0x2
CALL 0x001010b0
MOV RBP,RAX
TEST R15D,R15D
JLE 0x001012d1
LEA EDX,[R15 + 0x1]
MOV EAX,0x1
JMP 0x001012c3
LAB_001012b2:
MOV dword ptr [RBP + RAX*0x4 + -0x4],0x0
LAB_001012ba:
ADD RAX,0x1
CMP RAX,RDX
JZ 0x001012d1
LAB_001012c3:
CMP EBX,EAX
JLE 0x001012b2
MOV ECX,dword ptr [R12 + RAX*0x4]
MOV dword ptr [RBP + RAX*0x4 + -0x4],ECX
JMP 0x001012ba
LAB_001012d1:
MOV RDI,R12
CALL 0x00101080
LAB_001012d9:
MOV RAX,RBP
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001012eb:
MOV RBP,RAX
JMP 0x001012d9 | void * func0(int param_1)
{
int iVar1;
int iVar2;
int *__ptr;
int *piVar3;
void *pvVar4;
ulong uVar5;
int iVar6;
int iVar7;
long lVar8;
int iVar9;
long lVar10;
iVar7 = param_1 * param_1;
__ptr = (int *)malloc((long)((iVar7 + 10) / 2) << 2);
if (__ptr == (int *)0x0) {
pvVar4 = (void *)0x0;
}
else {
iVar2 = -1;
piVar3 = __ptr;
do {
*piVar3 = iVar2;
iVar2 = iVar2 + 2;
piVar3 = piVar3 + 1;
} while (iVar2 < iVar7 + 9);
iVar7 = (iVar7 + 9U >> 1) + 1;
lVar10 = 8;
iVar2 = 2;
do {
iVar1 = *(int *)((long)__ptr + lVar10);
piVar3 = __ptr;
if (iVar1 < 1) break;
piVar3 = (int *)malloc((long)iVar7 << 2);
if (iVar7 < 1) {
iVar7 = 0;
}
else {
iVar6 = -iVar1;
iVar9 = iVar7 - iVar1;
lVar8 = 0;
iVar7 = 0;
do {
if (((int)lVar8 < iVar1) || (iVar6 % iVar1 != 0)) {
piVar3[iVar7] = __ptr[lVar8];
iVar7 = iVar7 + 1;
}
lVar8 = lVar8 + 1;
iVar6 = iVar6 + 1;
} while (iVar6 != iVar9);
}
free(__ptr);
iVar2 = iVar2 + 1;
lVar10 = lVar10 + 4;
__ptr = piVar3;
} while (iVar2 < iVar7);
pvVar4 = malloc((long)param_1 << 2);
if (0 < param_1) {
uVar5 = 1;
do {
if ((int)uVar5 < iVar7) {
*(int *)((long)pvVar4 + uVar5 * 4 + -4) = piVar3[uVar5];
}
else {
*(int4 *)((long)pvVar4 + uVar5 * 4 + -4) = 0;
}
uVar5 = uVar5 + 1;
} while (uVar5 != param_1 + 1);
}
free(piVar3);
}
return pvVar4;
} |
7,522 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
| int* func0(int n) {
int size = n * n + 9;
int capacity = (size + 1) / 2;
int* list = malloc(capacity * sizeof(int));
if (!list) return NULL;
int index = 0;
for(int num = -1; num < size; num += 2){
list[index++] = num;
}
int current_size = index;
int i = 2;
while(i < current_size){
if(i >= current_size) break;
int step = list[i];
if(step <= 0) break;
int* new_list = malloc(current_size * sizeof(int));
int new_index = 0;
for(int j = 0; j < current_size; j++){
if((j < step) || ((j - step) % step != 0)){
new_list[new_index++] = list[j];
}
}
free(list);
list = new_list;
current_size = new_index;
i++;
}
int* result = malloc(n * sizeof(int));
for(int k = 0; k < n; k++){
if(k+1 < current_size){
result[k] = list[k+1];
} else {
result[k] = 0;
}
}
free(list);
return result;
}
| int main() {
int expected1[10] = {1, 3, 7, 9, 13, 15, 21, 25, 31, 33};
int expected2[5] = {1, 3, 7, 9, 13};
int expected3[8] = {1, 3, 7, 9, 13, 15, 21, 25};
int* result1 = func0(10);
for(int i = 0; i < 10; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
int* result2 = func0(5);
for(int i = 0; i < 5; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
int* result3 = func0(8);
for(int i = 0; i < 8; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
mov %edi,%eax
push %r14
imul %edi,%eax
push %r13
push %r12
push %rbp
lea 0x9(%rax),%r15d
push %rbx
sub $0x18,%rsp
mov %edi,0xc(%rsp)
lea 0xa(%rax),%edi
mov %edi,%eax
sar %eax
movslq %eax,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 14c3 <func0+0x153>
mov %rax,%r14
mov %rax,%rdx
mov $0xffffffff,%eax
nopw %cs:0x0(%rax,%rax,1)
mov %eax,(%rdx)
add $0x2,%eax
add $0x4,%rdx
cmp %eax,%r15d
jg 13c0 <func0+0x50>
shr %r15d
mov $0x8,%r12d
mov $0x2,%r13d
add $0x1,%r15d
nopl 0x0(%rax)
mov (%r14,%r12,1),%ebx
test %ebx,%ebx
jle 1450 <func0+0xe0>
movslq %r15d,%rdi
xor %ebp,%ebp
shl $0x2,%rdi
callq 10b0 <malloc@plt>
xor %ecx,%ecx
mov %rax,%rsi
nopl 0x0(%rax,%rax,1)
cmp %ecx,%ebx
jg 1417 <func0+0xa7>
mov %ecx,%eax
sub %ebx,%eax
cltd
idiv %ebx
test %edx,%edx
je 1424 <func0+0xb4>
mov (%r14,%rcx,4),%edx
movslq %ebp,%rax
add $0x1,%ebp
mov %edx,(%rsi,%rax,4)
add $0x1,%rcx
cmp %ecx,%r15d
jg 1408 <func0+0x98>
mov %r14,%rdi
mov %rsi,(%rsp)
add $0x1,%r13d
add $0x4,%r12
callq 1080 <free@plt>
mov (%rsp),%rsi
cmp %r13d,%ebp
mov %ebp,%r15d
mov %rsi,%r14
jg 13e8 <func0+0x78>
movslq 0xc(%rsp),%rdi
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 14a9 <func0+0x139>
mov 0xc(%rsp),%eax
mov $0x1,%edx
sub $0x1,%eax
add $0x2,%rax
jmp 1492 <func0+0x122>
nopw 0x0(%rax,%rax,1)
mov (%r14,%rdx,4),%ecx
mov %ecx,-0x4(%r12,%rdx,4)
add $0x1,%rdx
cmp %rdx,%rax
je 14a9 <func0+0x139>
cmp %edx,%r15d
jg 1480 <func0+0x110>
movl $0x0,-0x4(%r12,%rdx,4)
add $0x1,%rdx
cmp %rdx,%rax
jne 1492 <func0+0x122>
mov %r14,%rdi
callq 1080 <free@plt>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xor %r12d,%r12d
jmp 14b1 <func0+0x141>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
mov eax, edi
push r14
imul eax, edi
push r13
push r12
push rbp
lea r15d, [rax+9]
push rbx
sub rsp, 18h
mov [rsp+48h+var_3C], edi
lea edi, [rax+0Ah]
mov eax, edi
sar eax, 1
movsxd rdi, eax
shl rdi, 2
call _malloc
test rax, rax
jz loc_14AC
mov r13, rax
mov rdx, rax
mov eax, 0FFFFFFFFh
nop word ptr [rax+rax+00000000h]
loc_13C0:
mov [rdx], eax
add eax, 2
add rdx, 4
cmp r15d, eax
jg short loc_13C0
shr r15d, 1
mov ebp, 8
mov r12d, 2
add r15d, 1
loc_13E0:
mov r14d, [r13+rbp+0]
test r14d, r14d
jle short loc_1452
movsxd rdi, r15d
xor ebx, ebx
shl rdi, 2
call _malloc
mov esi, r14d
xor ecx, ecx
mov r9, rax
neg esi
nop word ptr [rax+rax+00h]
loc_1408:
cmp r14d, ecx
jg short loc_1417
mov eax, esi
cdq
idiv r14d
test edx, edx
jz short loc_1426
loc_1417:
mov edx, [r13+rcx*4+0]
movsxd rax, ebx
add ebx, 1
mov [r9+rax*4], edx
loc_1426:
add rcx, 1
add esi, 1
cmp r15d, ecx
jg short loc_1408
mov rdi, r13
add r12d, 1
mov [rsp+48h+var_48], r9
add rbp, 4
call _free
cmp ebx, r12d
mov r13, [rsp+48h+var_48]
mov r15d, ebx
jg short loc_13E0
loc_1452:
movsxd rdi, [rsp+48h+var_3C]
mov rbx, rdi
shl rdi, 2
call _malloc
mov edx, 1
mov r12, rax
lea eax, [rbx+1]
test ebx, ebx
jle short loc_1492
nop word ptr [rax+rax+00h]
loc_1478:
xor ecx, ecx
cmp r15d, edx
jle short loc_1484
mov ecx, [r13+rdx*4+0]
loc_1484:
mov [r12+rdx*4-4], ecx
add rdx, 1
cmp rax, rdx
jnz short loc_1478
loc_1492:
mov rdi, r13
call _free
loc_149A:
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_14AC:
xor r12d, r12d
jmp short loc_149A | long long func0(int a1, long long a2)
{
int v2; // r15d
long long v3; // rax
long long v4; // r13
_DWORD *v5; // rdx
int v6; // eax
long long v7; // rbp
int v8; // r12d
int v9; // r15d
int v10; // r14d
int v11; // ebx
long long v12; // rax
long long v13; // rcx
long long v14; // r9
long long v15; // rax
long long v16; // rax
long long v17; // rdx
long long v18; // r12
int v19; // ecx
long long v21; // [rsp+0h] [rbp-48h]
v2 = a1 * a1 + 9;
v3 = malloc(4LL * ((a1 * a1 + 10) >> 1));
if ( !v3 )
return 0LL;
v4 = v3;
v5 = (_DWORD *)v3;
v6 = -1;
do
{
*v5 = v6;
v6 += 2;
++v5;
}
while ( v2 > v6 );
v7 = 8LL;
v8 = 2;
v9 = ((unsigned int)v2 >> 1) + 1;
do
{
v10 = *(_DWORD *)(v4 + v7);
if ( v10 <= 0 )
break;
v11 = 0;
v12 = malloc(4LL * v9);
v13 = 0LL;
v14 = v12;
LODWORD(a2) = -v10;
do
{
if ( v10 > (int)v13 || (int)a2 % v10 )
{
v15 = v11++;
*(_DWORD *)(v14 + 4 * v15) = *(_DWORD *)(v4 + 4 * v13);
}
++v13;
a2 = (unsigned int)(a2 + 1);
}
while ( v9 > (int)v13 );
++v8;
v21 = v14;
v7 += 4LL;
free(v4, a2);
v4 = v21;
v9 = v11;
}
while ( v11 > v8 );
v16 = malloc(4LL * a1);
v17 = 1LL;
v18 = v16;
if ( a1 > 0 )
{
do
{
v19 = 0;
if ( v9 > (int)v17 )
v19 = *(_DWORD *)(v4 + 4 * v17);
*(_DWORD *)(v16 + 4 * v17++ - 4) = v19;
}
while ( a1 + 1 != v17 );
}
free(v4, a2);
return v18;
} | func0:
ENDBR64
PUSH R15
MOV EAX,EDI
PUSH R14
IMUL EAX,EDI
PUSH R13
PUSH R12
PUSH RBP
LEA R15D,[RAX + 0x9]
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],EDI
LEA EDI,[RAX + 0xa]
MOV EAX,EDI
SAR EAX,0x1
MOVSXD RDI,EAX
SHL RDI,0x2
CALL 0x001010b0
TEST RAX,RAX
JZ 0x001014ac
MOV R13,RAX
MOV RDX,RAX
MOV EAX,0xffffffff
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013c0:
MOV dword ptr [RDX],EAX
ADD EAX,0x2
ADD RDX,0x4
CMP R15D,EAX
JG 0x001013c0
SHR R15D,0x1
MOV EBP,0x8
MOV R12D,0x2
ADD R15D,0x1
LAB_001013e0:
MOV R14D,dword ptr [R13 + RBP*0x1]
TEST R14D,R14D
JLE 0x00101452
MOVSXD RDI,R15D
XOR EBX,EBX
SHL RDI,0x2
CALL 0x001010b0
MOV ESI,R14D
XOR ECX,ECX
MOV R9,RAX
NEG ESI
NOP word ptr [RAX + RAX*0x1]
LAB_00101408:
CMP R14D,ECX
JG 0x00101417
MOV EAX,ESI
CDQ
IDIV R14D
TEST EDX,EDX
JZ 0x00101426
LAB_00101417:
MOV EDX,dword ptr [R13 + RCX*0x4]
MOVSXD RAX,EBX
ADD EBX,0x1
MOV dword ptr [R9 + RAX*0x4],EDX
LAB_00101426:
ADD RCX,0x1
ADD ESI,0x1
CMP R15D,ECX
JG 0x00101408
MOV RDI,R13
ADD R12D,0x1
MOV qword ptr [RSP],R9
ADD RBP,0x4
CALL 0x00101080
CMP EBX,R12D
MOV R13,qword ptr [RSP]
MOV R15D,EBX
JG 0x001013e0
LAB_00101452:
MOVSXD RDI,dword ptr [RSP + 0xc]
MOV RBX,RDI
SHL RDI,0x2
CALL 0x001010b0
MOV EDX,0x1
MOV R12,RAX
LEA EAX,[RBX + 0x1]
TEST EBX,EBX
JLE 0x00101492
NOP word ptr [RAX + RAX*0x1]
LAB_00101478:
XOR ECX,ECX
CMP R15D,EDX
JLE 0x00101484
MOV ECX,dword ptr [R13 + RDX*0x4]
LAB_00101484:
MOV dword ptr [R12 + RDX*0x4 + -0x4],ECX
ADD RDX,0x1
CMP RAX,RDX
JNZ 0x00101478
LAB_00101492:
MOV RDI,R13
CALL 0x00101080
LAB_0010149a:
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001014ac:
XOR R12D,R12D
JMP 0x0010149a | void * func0(int param_1)
{
uint uVar1;
int iVar2;
int iVar3;
int *__ptr;
int *piVar4;
long lVar5;
void *pvVar6;
long lVar7;
ulong uVar8;
int iVar9;
long lVar10;
int iVar11;
int iVar12;
uVar1 = param_1 * param_1 + 9;
__ptr = (int *)malloc((long)(param_1 * param_1 + 10 >> 1) << 2);
if (__ptr == (int *)0x0) {
pvVar6 = (void *)0x0;
}
else {
iVar3 = -1;
piVar4 = __ptr;
do {
*piVar4 = iVar3;
iVar3 = iVar3 + 2;
piVar4 = piVar4 + 1;
} while (iVar3 < (int)uVar1);
lVar10 = 8;
iVar12 = 2;
iVar3 = (uVar1 >> 1) + 1;
do {
iVar2 = *(int *)((long)__ptr + lVar10);
piVar4 = __ptr;
iVar9 = iVar3;
if (iVar2 < 1) break;
iVar9 = 0;
piVar4 = (int *)malloc((long)iVar3 << 2);
lVar7 = 0;
iVar11 = -iVar2;
do {
if (((int)lVar7 < iVar2) || (iVar11 % iVar2 != 0)) {
lVar5 = (long)iVar9;
iVar9 = iVar9 + 1;
piVar4[lVar5] = __ptr[lVar7];
}
lVar7 = lVar7 + 1;
iVar11 = iVar11 + 1;
} while ((int)lVar7 < iVar3);
iVar12 = iVar12 + 1;
lVar10 = lVar10 + 4;
free(__ptr);
__ptr = piVar4;
iVar3 = iVar9;
} while (iVar12 < iVar9);
pvVar6 = malloc((long)param_1 << 2);
uVar8 = 1;
if (0 < param_1) {
do {
iVar3 = 0;
if ((int)uVar8 < iVar9) {
iVar3 = piVar4[uVar8];
}
*(int *)((long)pvVar6 + uVar8 * 4 + -4) = iVar3;
uVar8 = uVar8 + 1;
} while (param_1 + 1 != uVar8);
}
free(piVar4);
}
return pvVar6;
} |
7,523 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
| int* func0(int n) {
int size = n * n + 9;
int capacity = (size + 1) / 2;
int* list = malloc(capacity * sizeof(int));
if (!list) return NULL;
int index = 0;
for(int num = -1; num < size; num += 2){
list[index++] = num;
}
int current_size = index;
int i = 2;
while(i < current_size){
if(i >= current_size) break;
int step = list[i];
if(step <= 0) break;
int* new_list = malloc(current_size * sizeof(int));
int new_index = 0;
for(int j = 0; j < current_size; j++){
if((j < step) || ((j - step) % step != 0)){
new_list[new_index++] = list[j];
}
}
free(list);
list = new_list;
current_size = new_index;
i++;
}
int* result = malloc(n * sizeof(int));
for(int k = 0; k < n; k++){
if(k+1 < current_size){
result[k] = list[k+1];
} else {
result[k] = 0;
}
}
free(list);
return result;
}
| int main() {
int expected1[10] = {1, 3, 7, 9, 13, 15, 21, 25, 31, 33};
int expected2[5] = {1, 3, 7, 9, 13};
int expected3[8] = {1, 3, 7, 9, 13, 15, 21, 25};
int* result1 = func0(10);
for(int i = 0; i < 10; i++) {
assert(result1[i] == expected1[i]);
}
free(result1);
int* result2 = func0(5);
for(int i = 0; i < 5; i++) {
assert(result2[i] == expected2[i]);
}
free(result2);
int* result3 = func0(8);
for(int i = 0; i < 8; i++) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
mov %edi,%eax
push %r14
imul %edi,%eax
push %r13
push %r12
push %rbp
lea 0x9(%rax),%ebp
push %rbx
sub $0x18,%rsp
mov %edi,0xc(%rsp)
lea 0xa(%rax),%edi
mov %edi,%eax
sar %eax
movslq %eax,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 1680 <func0+0x2d0>
mov %ebp,%ebx
movdqa 0xcac(%rip),%xmm0
movdqa 0xcc4(%rip),%xmm2
mov %rax,%r13
shr %ebx
add $0x1,%ebx
mov %ebx,%edx
shr $0x2,%edx
shl $0x4,%rdx
add %rax,%rdx
movdqa %xmm0,%xmm1
add $0x10,%rax
paddd %xmm2,%xmm0
movups %xmm1,-0x10(%rax)
cmp %rdx,%rax
jne 1410 <func0+0x60>
mov %ebx,%eax
and $0xfffffffc,%eax
lea (%rax,%rax,1),%edx
lea -0x1(%rdx),%esi
cmp %eax,%ebx
je 145f <func0+0xaf>
mov %esi,0x0(%r13,%rax,4)
lea 0x1(%rdx),%esi
lea 0x1(%rax),%ecx
cmp %esi,%ebp
jle 145f <func0+0xaf>
movslq %ecx,%rax
add $0x3,%edx
mov %esi,0x0(%r13,%rax,4)
lea 0x0(,%rax,4),%rcx
cmp %edx,%ebp
jle 145f <func0+0xaf>
mov %edx,0x4(%r13,%rcx,1)
mov $0x8,%ebp
mov $0x2,%r12d
nopw 0x0(%rax,%rax,1)
mov 0x0(%r13,%rbp,1),%r15d
test %r15d,%r15d
jle 15d6 <func0+0x226>
movslq %ebx,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
cmp %r15d,%ebx
mov %r15d,%ecx
movdqa 0xc38(%rip),%xmm5
mov %rax,%r14
lea 0xf(%rax),%rax
cmovle %ebx,%ecx
movdqa 0xc36(%rip),%xmm4
sub %r13,%rax
cmp $0x1e,%rax
jbe 1650 <func0+0x2a0>
cmp $0x5,%ecx
jle 1650 <func0+0x2a0>
test %ecx,%ecx
mov $0x1,%edi
movdqa 0xbe1(%rip),%xmm2
cmovg %ecx,%edi
xor %eax,%eax
movdqa %xmm2,%xmm3
mov %edi,%edx
shr $0x2,%edx
shl $0x4,%rdx
nopl 0x0(%rax)
movdqu 0x0(%r13,%rax,1),%xmm6
movdqa %xmm2,%xmm0
movdqa %xmm3,%xmm1
paddd %xmm5,%xmm2
paddd %xmm5,%xmm3
paddd %xmm4,%xmm1
movups %xmm6,(%r14,%rax,1)
add $0x10,%rax
paddd %xmm4,%xmm0
cmp %rdx,%rax
jne 14e8 <func0+0x138>
mov %edi,%r9d
pshufd $0xff,%xmm0,%xmm0
pshufd $0xff,%xmm1,%xmm1
and $0xfffffffc,%r9d
movd %xmm0,%eax
movd %xmm1,%edx
and $0x3,%edi
je 1579 <func0+0x1c9>
mov %r9d,%edi
lea 0x1(%r9),%edx
mov 0x0(%r13,%rdi,4),%r10d
lea 0x0(,%rdi,4),%rax
mov %r10d,(%r14,%rdi,4)
cmp %edx,%ecx
jle 166f <func0+0x2bf>
mov 0x4(%r13,%rax,1),%edi
lea 0x2(%r9),%edx
mov %edi,0x4(%r14,%rax,1)
cmp %edx,%ecx
jle 166f <func0+0x2bf>
mov 0x8(%r13,%rax,1),%ecx
lea 0x3(%r9),%edx
mov %ecx,0x8(%r14,%rax,1)
mov %edx,%eax
cmp %ebx,%eax
jge 1679 <func0+0x2c9>
mov %eax,%ecx
sub %r15d,%ebx
cltq
mov %ebx,%r9d
sub %r15d,%ecx
lea 0x0(%r13,%rax,4),%rdi
mov %edx,%ebx
nopl (%rax)
mov %ecx,%eax
cltd
idiv %r15d
test %edx,%edx
je 15ae <func0+0x1fe>
mov (%rdi),%edx
movslq %ebx,%rax
add $0x1,%ebx
mov %edx,(%r14,%rax,4)
add $0x1,%ecx
add $0x4,%rdi
cmp %r9d,%ecx
jne 1598 <func0+0x1e8>
mov %r13,%rdi
add $0x1,%r12d
add $0x4,%rbp
mov %r14,%r13
callq 1080 <free@plt>
cmp %ebx,%r12d
jl 1470 <func0+0xc0>
movslq 0xc(%rsp),%rdi
mov %rdi,%r15
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r12
test %r15d,%r15d
jle 1631 <func0+0x281>
mov 0xc(%rsp),%eax
mov $0x1,%edx
sub $0x1,%eax
add $0x2,%rax
jmp 161b <func0+0x26b>
nopl 0x0(%rax)
mov 0x0(%r13,%rdx,4),%ecx
mov %ecx,-0x4(%r12,%rdx,4)
add $0x1,%rdx
cmp %rax,%rdx
je 1631 <func0+0x281>
cmp %edx,%ebx
jg 1608 <func0+0x258>
movl $0x0,-0x4(%r12,%rdx,4)
add $0x1,%rdx
cmp %rax,%rdx
jne 161b <func0+0x26b>
mov %r13,%rdi
callq 1080 <free@plt>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
nopl (%rax)
mov -0x4(%r13,%rax,4),%edi
mov %eax,%edx
mov %edi,-0x4(%r14,%rax,4)
add $0x1,%rax
lea -0x1(%rax),%edi
cmp %edi,%ecx
jg 1658 <func0+0x2a8>
mov %edx,%eax
cmp %ebx,%eax
jl 1581 <func0+0x1d1>
mov %edx,%ebx
jmpq 15ba <func0+0x20a>
xor %r12d,%r12d
jmp 1639 <func0+0x289>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
mov eax, edi
push r14
imul eax, edi
push r13
push r12
push rbp
push rbx
lea ebx, [rax+9]
sub rsp, 18h
mov [rsp+48h+var_3C], edi
lea edi, [rax+0Ah]
mov eax, edi
sar eax, 1
movsxd rdi, eax
shl rdi, 2; size
call _malloc
test rax, rax
jz loc_15E7
mov r13d, ebx
movdqa xmm0, cs:xmmword_2080
movdqa xmm2, cs:xmmword_20A0
mov r12, rax
shr r13d, 1
add r13d, 1
mov edx, r13d
shr edx, 2
shl rdx, 4
add rdx, rax
nop dword ptr [rax+00h]
loc_1368:
movdqa xmm1, xmm0
add rax, 10h
paddd xmm0, xmm2
movups xmmword ptr [rax-10h], xmm1
cmp rax, rdx
jnz short loc_1368
mov edx, r13d
and edx, 0FFFFFFFCh
lea eax, [rdx+rdx]
lea esi, [rax-1]
test r13b, 3
jz short loc_13B3
mov [r12+rdx*4], esi
lea rcx, ds:0[rdx*4]
lea edx, [rax+1]
cmp ebx, edx
jle short loc_13B3
add eax, 3
mov [r12+rcx+4], edx
cmp ebx, eax
jle short loc_13B3
mov [r12+rcx+8], eax
loc_13B3:
mov ebx, 8
mov ebp, 2
nop dword ptr [rax]
loc_13C0:
mov r14d, [r12+rbx]
test r14d, r14d
jle loc_1485
movsxd rdi, r13d
shl rdi, 2; size
call _malloc
cmp r14d, r13d
mov ecx, r13d
cmovle ecx, r14d
mov r15, rax
cmp ecx, 4
jle loc_1500
lea rax, [r12+4]
mov rdx, r15
sub rdx, rax
mov eax, 1
cmp rdx, 8
ja loc_1510
nop dword ptr [rax+00000000h]
loc_1410:
mov edx, [r12+rax*4-4]
mov [r15+rax*4-4], edx
lea rdx, [rax+1]
cmp ecx, eax
jg loc_14F0
mov edx, eax
loc_1428:
cmp eax, r13d
jge loc_15B8
loc_1431:
mov ecx, eax
mov edi, r13d
cdqe
mov r13d, edx
sub ecx, r14d
lea rsi, [r12+rax*4]
sub edi, r14d
nop dword ptr [rax]
loc_1448:
mov eax, ecx
cdq
idiv r14d
test edx, edx
jz short loc_145F
mov edx, [rsi]
movsxd rax, r13d
add r13d, 1
mov [r15+rax*4], edx
loc_145F:
add ecx, 1
add rsi, 4
cmp edi, ecx
jnz short loc_1448
loc_146A:
mov rdi, r12; ptr
add ebp, 1
add rbx, 4
mov r12, r15
call _free
cmp ebp, r13d
jl loc_13C0
loc_1485:
movsxd rbp, [rsp+48h+var_3C]
lea rdi, ds:0[rbp*4]; size
call _malloc
mov edx, 1
mov rbx, rax
test ebp, ebp
jg short loc_14BC
jmp short loc_14D2
loc_14A8:
mov eax, [r12+rdx*4]
mov [rbx+rdx*4-4], eax
lea rax, [rdx+1]
cmp rbp, rdx
jz short loc_14D2
loc_14B9:
mov rdx, rax
loc_14BC:
cmp r13d, edx
jg short loc_14A8
mov dword ptr [rbx+rdx*4-4], 0
lea rax, [rdx+1]
cmp rbp, rdx
jnz short loc_14B9
loc_14D2:
mov rdi, r12; ptr
call _free
loc_14DA:
add rsp, 18h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_14F0:
mov rax, rdx
jmp loc_1410
loc_1500:
mov eax, 1
jmp loc_1410
loc_1510:
movdqa xmm1, cs:xmmword_2090
mov edx, ecx
xor eax, eax
shr edx, 2
shl rdx, 4
movdqa xmm2, xmm1
nop word ptr [rax+rax+00000000h]
loc_1530:
movdqu xmm4, xmmword ptr [r12+rax]
movdqa xmm0, xmm1
movdqa xmm3, xmm2
paddd xmm1, cs:xmmword_20B0
paddd xmm2, cs:xmmword_20B0
movups xmmword ptr [r15+rax], xmm4
add rax, 10h
cmp rax, rdx
jnz short loc_1530
mov esi, ecx
and esi, 0FFFFFFFCh
test cl, 3
jz short loc_15C0
mov eax, esi
lea edx, [rsi+1]
mov r9d, [r12+rax*4]
lea rdi, ds:0[rax*4]
mov [r15+rax*4], r9d
mov eax, edx
cmp edx, ecx
jge loc_1428
mov eax, [r12+rdi+4]
lea edx, [rsi+2]
mov [r15+rdi+4], eax
mov eax, edx
cmp ecx, edx
jle loc_1428
mov eax, [r12+rdi+8]
lea edx, [rsi+3]
mov [r15+rdi+8], eax
mov eax, edx
cmp eax, r13d
jl loc_1431
nop dword ptr [rax+00h]
loc_15B8:
mov r13d, edx
jmp loc_146A
loc_15C0:
movdqa xmm1, cs:xmmword_20C0
paddd xmm0, xmm1
paddd xmm3, xmm1
pshufd xmm0, xmm0, 0FFh
movd eax, xmm0
pshufd xmm0, xmm3, 0FFh
movd edx, xmm0
jmp loc_1428
loc_15E7:
xor ebx, ebx
jmp loc_14DA | _DWORD * func0(int a1)
{
int v1; // ebx
__m128i *v2; // rax
__m128i si128; // xmm0
__m128i v4; // xmm2
__m128i *v5; // r12
int v6; // r13d
char *m128i_i8; // rdx
__m128i v8; // xmm1
long long v9; // rdx
int v10; // eax
long long v11; // rcx
int v12; // edx
int v13; // eax
long long v14; // rbx
int v15; // ebp
int v16; // r14d
__m128i *v17; // rax
int v18; // ecx
__m128i *v19; // r15
unsigned long long v20; // rdx
long long v21; // rax
int v22; // edx
int v23; // edi
int v24; // ecx
__int32 *v25; // rsi
int v26; // edi
long long v27; // rax
__m128i *v28; // rdi
_DWORD *v29; // rax
long long v30; // rdx
_DWORD *v31; // rbx
long long v32; // rax
__m128i v34; // xmm1
unsigned long long v35; // rax
__m128i v36; // xmm2
__m128i v37; // xmm0
__m128i v38; // xmm3
unsigned int v39; // esi
long long v40; // rdi
__m128i v41; // xmm1
v1 = a1 * a1 + 9;
v2 = (__m128i *)malloc(4LL * ((a1 * a1 + 10) >> 1));
if ( !v2 )
return 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_2080);
v4 = _mm_load_si128((const __m128i *)&xmmword_20A0);
v5 = v2;
v6 = ((unsigned int)v1 >> 1) + 1;
m128i_i8 = v2[(unsigned int)v6 >> 2].m128i_i8;
do
{
v8 = si128;
++v2;
si128 = _mm_add_epi32(si128, v4);
v2[-1] = v8;
}
while ( v2 != (__m128i *)m128i_i8 );
v9 = v6 & 0xFFFFFFFC;
v10 = 2 * v9;
if ( (v6 & 3) != 0 )
{
v5->m128i_i32[v9] = 2 * v9 - 1;
v11 = v9;
v12 = v10 + 1;
if ( v1 > v10 + 1 )
{
v13 = v10 + 3;
v5->m128i_i32[v11 + 1] = v12;
if ( v1 > v13 )
v5->m128i_i32[v11 + 2] = v13;
}
}
v14 = 2LL;
v15 = 2;
do
{
v16 = v5->m128i_i32[v14];
if ( v16 <= 0 )
break;
v17 = (__m128i *)malloc(4LL * v6);
v18 = v6;
if ( v16 <= v6 )
v18 = v16;
v19 = v17;
if ( v18 <= 4 )
{
v21 = 1LL;
LABEL_14:
while ( 1 )
{
v19->m128i_i32[v21 - 1] = v5->m128i_i32[v21 - 1];
if ( v18 <= (int)v21 )
break;
++v21;
}
v22 = v21;
LABEL_16:
if ( (int)v21 < v6 )
goto LABEL_17;
goto LABEL_38;
}
v20 = (char *)v17 - ((char *)v5->m128i_i64 + 4);
v21 = 1LL;
if ( v20 <= 8 )
goto LABEL_14;
v34 = _mm_load_si128((const __m128i *)&xmmword_2090);
v35 = 0LL;
v36 = v34;
do
{
v37 = v34;
v38 = v36;
v34 = _mm_add_epi32(v34, (__m128i)xmmword_20B0);
v36 = _mm_add_epi32(v36, (__m128i)xmmword_20B0);
v19[v35] = _mm_loadu_si128(&v5[v35]);
++v35;
}
while ( v35 != (unsigned int)v18 >> 2 );
v39 = v18 & 0x7FFFFFFC;
if ( (v18 & 3) == 0 )
{
v41 = _mm_load_si128((const __m128i *)&xmmword_20C0);
LODWORD(v21) = _mm_cvtsi128_si32(_mm_shuffle_epi32(_mm_add_epi32(v37, v41), 255));
v22 = _mm_cvtsi128_si32(_mm_shuffle_epi32(_mm_add_epi32(v38, v41), 255));
goto LABEL_16;
}
v22 = v39 + 1;
v40 = v39;
v19->m128i_i32[v40] = v5->m128i_i32[v40];
LODWORD(v21) = v39 + 1;
if ( (int)(v39 + 1) >= v18 )
goto LABEL_16;
v22 = v39 + 2;
v19->m128i_i32[v40 + 1] = v5->m128i_i32[v40 + 1];
LODWORD(v21) = v39 + 2;
if ( v18 <= (int)(v39 + 2) )
goto LABEL_16;
v22 = v39 + 3;
v19->m128i_i32[v40 + 2] = v5->m128i_i32[v40 + 2];
LODWORD(v21) = v39 + 3;
if ( (int)(v39 + 3) < v6 )
{
LABEL_17:
v23 = v6;
v6 = v22;
v24 = v21 - v16;
v25 = &v5->m128i_i32[(int)v21];
v26 = v23 - v16;
do
{
if ( v24 % v16 )
{
v27 = v6++;
v19->m128i_i32[v27] = *v25;
}
++v24;
++v25;
}
while ( v26 != v24 );
goto LABEL_21;
}
LABEL_38:
v6 = v22;
LABEL_21:
v28 = v5;
++v15;
++v14;
v5 = v19;
free(v28);
}
while ( v15 < v6 );
v29 = malloc(4LL * a1);
v30 = 1LL;
v31 = v29;
if ( a1 > 0 )
{
while ( 1 )
{
if ( v6 > (int)v30 )
{
v31[v30 - 1] = v5->m128i_i32[v30];
v32 = v30 + 1;
if ( a1 == v30 )
break;
}
else
{
v31[v30 - 1] = 0;
v32 = v30 + 1;
if ( a1 == v30 )
break;
}
v30 = v32;
}
}
free(v5);
return v31;
} | func0:
ENDBR64
PUSH R15
MOV EAX,EDI
PUSH R14
IMUL EAX,EDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA EBX,[RAX + 0x9]
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],EDI
LEA EDI,[RAX + 0xa]
MOV EAX,EDI
SAR EAX,0x1
MOVSXD RDI,EAX
SHL RDI,0x2
CALL 0x00101090
TEST RAX,RAX
JZ 0x001015e7
MOV R13D,EBX
MOVDQA XMM0,xmmword ptr [0x00102080]
MOVDQA XMM2,xmmword ptr [0x001020a0]
MOV R12,RAX
SHR R13D,0x1
ADD R13D,0x1
MOV EDX,R13D
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RAX
NOP dword ptr [RAX]
LAB_00101368:
MOVDQA XMM1,XMM0
ADD RAX,0x10
PADDD XMM0,XMM2
MOVUPS xmmword ptr [RAX + -0x10],XMM1
CMP RAX,RDX
JNZ 0x00101368
MOV EDX,R13D
AND EDX,0xfffffffc
LEA EAX,[RDX + RDX*0x1]
LEA ESI,[RAX + -0x1]
TEST R13B,0x3
JZ 0x001013b3
MOV dword ptr [R12 + RDX*0x4],ESI
LEA RCX,[RDX*0x4]
LEA EDX,[RAX + 0x1]
CMP EBX,EDX
JLE 0x001013b3
ADD EAX,0x3
MOV dword ptr [R12 + RCX*0x1 + 0x4],EDX
CMP EBX,EAX
JLE 0x001013b3
MOV dword ptr [R12 + RCX*0x1 + 0x8],EAX
LAB_001013b3:
MOV EBX,0x8
MOV EBP,0x2
NOP dword ptr [RAX]
LAB_001013c0:
MOV R14D,dword ptr [R12 + RBX*0x1]
TEST R14D,R14D
JLE 0x00101485
MOVSXD RDI,R13D
SHL RDI,0x2
CALL 0x00101090
CMP R14D,R13D
MOV ECX,R13D
CMOVLE ECX,R14D
MOV R15,RAX
CMP ECX,0x4
JLE 0x00101500
LEA RAX,[R12 + 0x4]
MOV RDX,R15
SUB RDX,RAX
MOV EAX,0x1
CMP RDX,0x8
JA 0x00101510
NOP dword ptr [RAX]
LAB_00101410:
MOV EDX,dword ptr [R12 + RAX*0x4 + -0x4]
MOV dword ptr [R15 + RAX*0x4 + -0x4],EDX
LEA RDX,[RAX + 0x1]
CMP ECX,EAX
JG 0x001014f0
MOV EDX,EAX
LAB_00101428:
CMP EAX,R13D
JGE 0x001015b8
LAB_00101431:
MOV ECX,EAX
MOV EDI,R13D
CDQE
MOV R13D,EDX
SUB ECX,R14D
LEA RSI,[R12 + RAX*0x4]
SUB EDI,R14D
NOP dword ptr [RAX]
LAB_00101448:
MOV EAX,ECX
CDQ
IDIV R14D
TEST EDX,EDX
JZ 0x0010145f
MOV EDX,dword ptr [RSI]
MOVSXD RAX,R13D
ADD R13D,0x1
MOV dword ptr [R15 + RAX*0x4],EDX
LAB_0010145f:
ADD ECX,0x1
ADD RSI,0x4
CMP EDI,ECX
JNZ 0x00101448
LAB_0010146a:
MOV RDI,R12
ADD EBP,0x1
ADD RBX,0x4
MOV R12,R15
CALL 0x00101070
CMP EBP,R13D
JL 0x001013c0
LAB_00101485:
MOVSXD RBP,dword ptr [RSP + 0xc]
LEA RDI,[RBP*0x4]
CALL 0x00101090
MOV EDX,0x1
MOV RBX,RAX
TEST EBP,EBP
JG 0x001014bc
JMP 0x001014d2
LAB_001014a8:
MOV EAX,dword ptr [R12 + RDX*0x4]
MOV dword ptr [RBX + RDX*0x4 + -0x4],EAX
LEA RAX,[RDX + 0x1]
CMP RBP,RDX
JZ 0x001014d2
LAB_001014b9:
MOV RDX,RAX
LAB_001014bc:
CMP R13D,EDX
JG 0x001014a8
MOV dword ptr [RBX + RDX*0x4 + -0x4],0x0
LEA RAX,[RDX + 0x1]
CMP RBP,RDX
JNZ 0x001014b9
LAB_001014d2:
MOV RDI,R12
CALL 0x00101070
LAB_001014da:
ADD RSP,0x18
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001014f0:
MOV RAX,RDX
JMP 0x00101410
LAB_00101500:
MOV EAX,0x1
JMP 0x00101410
LAB_00101510:
MOVDQA XMM1,xmmword ptr [0x00102090]
MOV EDX,ECX
XOR EAX,EAX
SHR EDX,0x2
SHL RDX,0x4
MOVDQA XMM2,XMM1
NOP word ptr [RAX + RAX*0x1]
LAB_00101530:
MOVDQU XMM4,xmmword ptr [R12 + RAX*0x1]
MOVDQA XMM0,XMM1
MOVDQA XMM3,XMM2
PADDD XMM1,xmmword ptr [0x001020b0]
PADDD XMM2,xmmword ptr [0x001020b0]
MOVUPS xmmword ptr [R15 + RAX*0x1],XMM4
ADD RAX,0x10
CMP RAX,RDX
JNZ 0x00101530
MOV ESI,ECX
AND ESI,0xfffffffc
TEST CL,0x3
JZ 0x001015c0
MOV EAX,ESI
LEA EDX,[RSI + 0x1]
MOV R9D,dword ptr [R12 + RAX*0x4]
LEA RDI,[RAX*0x4]
MOV dword ptr [R15 + RAX*0x4],R9D
MOV EAX,EDX
CMP EDX,ECX
JGE 0x00101428
MOV EAX,dword ptr [R12 + RDI*0x1 + 0x4]
LEA EDX,[RSI + 0x2]
MOV dword ptr [R15 + RDI*0x1 + 0x4],EAX
MOV EAX,EDX
CMP ECX,EDX
JLE 0x00101428
MOV EAX,dword ptr [R12 + RDI*0x1 + 0x8]
LEA EDX,[RSI + 0x3]
MOV dword ptr [R15 + RDI*0x1 + 0x8],EAX
MOV EAX,EDX
CMP EAX,R13D
JL 0x00101431
NOP dword ptr [RAX]
LAB_001015b8:
MOV R13D,EDX
JMP 0x0010146a
LAB_001015c0:
MOVDQA XMM1,xmmword ptr [0x001020c0]
PADDD XMM0,XMM1
PADDD XMM3,XMM1
PSHUFD XMM0,XMM0,0xff
MOVD EAX,XMM0
PSHUFD XMM0,XMM3,0xff
MOVD EDX,XMM0
JMP 0x00101428
LAB_001015e7:
XOR EBX,EBX
JMP 0x001014da | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void * func0(int param_1)
{
uint uVar1;
int8 uVar2;
ulong uVar3;
int *__ptr;
int *piVar4;
ulong uVar5;
long lVar6;
void *pvVar7;
int iVar8;
uint uVar9;
long lVar10;
int iVar11;
uint uVar12;
int *piVar13;
uint uVar14;
uint uVar15;
int iVar16;
int iVar17;
int iVar18;
int iVar19;
int iVar20;
int iVar21;
uVar1 = param_1 * param_1 + 9;
__ptr = (int *)malloc((long)(param_1 * param_1 + 10 >> 1) << 2);
iVar20 = _UNK_001020ac;
iVar21 = _UNK_001020a8;
iVar8 = _UNK_001020a4;
iVar11 = _DAT_001020a0;
if (__ptr == (int *)0x0) {
pvVar7 = (void *)0x0;
}
else {
uVar14 = (uVar1 >> 1) + 1;
piVar4 = __ptr;
iVar16 = _DAT_00102080;
iVar17 = _UNK_00102084;
iVar18 = _UNK_00102088;
iVar19 = _UNK_0010208c;
do {
piVar13 = piVar4 + 4;
*piVar4 = iVar16;
piVar4[1] = iVar17;
piVar4[2] = iVar18;
piVar4[3] = iVar19;
piVar4 = piVar13;
iVar16 = iVar16 + iVar11;
iVar17 = iVar17 + iVar8;
iVar18 = iVar18 + iVar21;
iVar19 = iVar19 + iVar20;
} while (piVar13 != __ptr + (ulong)(uVar14 >> 2) * 4);
uVar9 = uVar14 & 0xfffffffc;
iVar11 = uVar9 * 2;
if ((uVar14 & 3) != 0) {
__ptr[uVar9] = iVar11 + -1;
if (iVar11 + 1 < (int)uVar1) {
__ptr[(ulong)uVar9 + 1] = iVar11 + 1;
if (iVar11 + 3 < (int)uVar1) {
__ptr[(ulong)uVar9 + 2] = iVar11 + 3;
}
}
}
lVar10 = 8;
iVar11 = 2;
do {
uVar1 = *(uint *)((long)__ptr + lVar10);
piVar4 = __ptr;
if ((int)uVar1 < 1) break;
piVar4 = (int *)malloc((long)(int)uVar14 << 2);
uVar9 = uVar14;
if ((int)uVar1 <= (int)uVar14) {
uVar9 = uVar1;
}
if ((int)uVar9 < 5) {
uVar3 = 1;
LAB_00101410:
do {
uVar5 = uVar3;
piVar4[uVar5 - 1] = __ptr[uVar5 - 1];
uVar15 = (uint)uVar5;
uVar3 = uVar5 + 1;
} while ((int)uVar15 < (int)uVar9);
LAB_00101428:
uVar9 = (uint)uVar5;
}
else {
uVar3 = 1;
if ((ulong)((long)piVar4 - (long)(__ptr + 1)) < 9) goto LAB_00101410;
lVar6 = 0;
iVar8 = _UNK_0010209c;
iVar21 = _UNK_0010209c;
do {
iVar16 = iVar21;
iVar20 = iVar8;
uVar2 = ((int8 *)((long)__ptr + lVar6))[1];
iVar8 = iVar20 + _UNK_001020bc;
iVar21 = iVar16 + _UNK_001020bc;
*(int8 *)((long)piVar4 + lVar6) = *(int8 *)((long)__ptr + lVar6);
((int8 *)((long)piVar4 + lVar6))[1] = uVar2;
lVar6 = lVar6 + 0x10;
} while (lVar6 != (ulong)(uVar9 >> 2) << 4);
uVar12 = uVar9 & 0xfffffffc;
if ((uVar9 & 3) == 0) {
uVar15 = iVar16 + _UNK_001020cc;
uVar5 = (ulong)(uint)(iVar20 + _UNK_001020cc);
goto LAB_00101428;
}
uVar15 = uVar12 + 1;
uVar5 = (ulong)uVar15;
piVar4[uVar12] = __ptr[uVar12];
if ((int)uVar9 <= (int)uVar15) goto LAB_00101428;
uVar15 = uVar12 + 2;
uVar5 = (ulong)uVar15;
piVar4[(ulong)uVar12 + 1] = __ptr[(ulong)uVar12 + 1];
if ((int)uVar9 <= (int)uVar15) goto LAB_00101428;
uVar9 = uVar12 + 3;
piVar4[(ulong)uVar12 + 2] = __ptr[(ulong)uVar12 + 2];
uVar15 = uVar9;
}
if ((int)uVar9 < (int)uVar14) {
iVar8 = uVar9 - uVar1;
piVar13 = __ptr + (int)uVar9;
do {
if (iVar8 % (int)uVar1 != 0) {
lVar6 = (long)(int)uVar15;
uVar15 = uVar15 + 1;
piVar4[lVar6] = *piVar13;
}
iVar8 = iVar8 + 1;
piVar13 = piVar13 + 1;
} while (uVar14 - uVar1 != iVar8);
}
uVar14 = uVar15;
iVar11 = iVar11 + 1;
lVar10 = lVar10 + 4;
free(__ptr);
__ptr = piVar4;
} while (iVar11 < (int)uVar14);
pvVar7 = malloc((long)param_1 * 4);
lVar10 = 1;
if (0 < param_1) {
while( true ) {
if ((int)lVar10 < (int)uVar14) {
*(int *)((long)pvVar7 + lVar10 * 4 + -4) = piVar4[lVar10];
}
else {
*(int4 *)((long)pvVar7 + lVar10 * 4 + -4) = 0;
}
if (param_1 == lVar10) break;
lVar10 = lVar10 + 1;
}
}
free(piVar4);
}
return pvVar7;
} |
7,524 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
for (int i = 0; i < n; i++) {
if (arr[i] == i) {
return i;
}
}
return -1;
}
| int main() {
int arr1[] = {-10, -1, 0, 3, 10, 11, 30, 50, 100};
int arr2[] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr3[] = {0, 2, 5, 8, 17};
assert(func0(arr1, 9) == 3);
assert(func0(arr2, 8) == -1);
assert(func0(arr3, 5) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a5 <func0+0x3c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x4(%rbp)
jne 11a1 <func0+0x38>
mov -0x4(%rbp),%eax
jmp 11b2 <func0+0x49>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
mov $0xffffffff,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_11A5
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_4], eax
jnz short loc_11A1
mov eax, [rbp+var_4]
jmp short loc_11B2
loc_11A1:
add [rbp+var_4], 1
loc_11A5:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1181
mov eax, 0FFFFFFFFh
loc_11B2:
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int i; // [rsp+18h] [rbp-4h]
for ( i = 0; (int)i < a2; ++i )
{
if ( i == *(_DWORD *)(4LL * (int)i + a1) )
return i;
}
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a5
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x4],EAX
JNZ 0x001011a1
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x001011b2
LAB_001011a1:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a5:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
MOV EAX,0xffffffff
LAB_001011b2:
POP RBP
RET | int func0(long param_1,int param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return -1;
}
if (local_c == *(int *)(param_1 + (long)local_c * 4)) break;
local_c = local_c + 1;
}
return local_c;
} |
7,525 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
for (int i = 0; i < n; i++) {
if (arr[i] == i) {
return i;
}
}
return -1;
}
| int main() {
int arr1[] = {-10, -1, 0, 3, 10, 11, 30, 50, 100};
int arr2[] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr3[] = {0, 2, 5, 8, 17};
assert(func0(arr1, 9) == 3);
assert(func0(arr2, 8) == -1);
assert(func0(arr3, 5) == 0);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1196 <func0+0x2d>
lea -0x1(%rsi),%ecx
mov $0x0,%eax
jmp 117e <func0+0x15>
mov %rdx,%rax
mov %eax,%edx
cmp %eax,(%rdi,%rax,4)
je 1193 <func0+0x2a>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
jne 117b <func0+0x12>
mov $0xffffffff,%edx
mov %edx,%eax
retq
mov $0xffffffff,%edx
jmp 1193 <func0+0x2a>
| func0:
endbr64
test esi, esi
jle short loc_1190
mov esi, esi
mov eax, 0
loc_1178:
mov edx, eax
cmp [rdi+rax*4], eax
jz short loc_118D
add rax, 1
cmp rax, rsi
jnz short loc_1178
mov edx, 0FFFFFFFFh
loc_118D:
mov eax, edx
retn
loc_1190:
mov edx, 0FFFFFFFFh
jmp short loc_118D | long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return (unsigned int)-1;
}
else
{
v2 = 0LL;
while ( 1 )
{
v3 = v2;
if ( *(_DWORD *)(a1 + 4 * v2) == (_DWORD)v2 )
break;
if ( ++v2 == a2 )
return (unsigned int)-1;
}
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101190
MOV ESI,ESI
MOV EAX,0x0
LAB_00101178:
MOV EDX,EAX
CMP dword ptr [RDI + RAX*0x4],EAX
JZ 0x0010118d
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101178
MOV EDX,0xffffffff
LAB_0010118d:
MOV EAX,EDX
RET
LAB_00101190:
MOV EDX,0xffffffff
JMP 0x0010118d | ulong func0(long param_1,uint param_2)
{
ulong uVar1;
if (0 < (int)param_2) {
uVar1 = 0;
do {
if (*(int *)(param_1 + uVar1 * 4) == (int)uVar1) {
return uVar1 & 0xffffffff;
}
uVar1 = uVar1 + 1;
} while (uVar1 != param_2);
}
return 0xffffffff;
} |
7,526 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
for (int i = 0; i < n; i++) {
if (arr[i] == i) {
return i;
}
}
return -1;
}
| int main() {
int arr1[] = {-10, -1, 0, 3, 10, 11, 30, 50, 100};
int arr2[] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr3[] = {0, 2, 5, 8, 17};
assert(func0(arr1, 9) == 3);
assert(func0(arr2, 8) == -1);
assert(func0(arr3, 5) == 0);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 12d0 <func0+0x30>
lea -0x1(%rsi),%ecx
xor %eax,%eax
jmp 12bc <func0+0x1c>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 12d0 <func0+0x30>
mov %rdx,%rax
mov %eax,%r8d
cmp %eax,(%rdi,%rax,4)
jne 12b0 <func0+0x10>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_12C8
movsxd rsi, esi
xor eax, eax
jmp short loc_12B9
loc_12B0:
add rax, 1
cmp rax, rsi
jz short loc_12C8
loc_12B9:
mov r8d, eax
cmp [rdi+rax*4], eax
jnz short loc_12B0
mov eax, r8d
retn
loc_12C8:
mov r8d, 0FFFFFFFFh
mov eax, r8d
retn | long long func0(long long a1, int a2)
{
long long result; // rax
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
result = 0LL;
while ( *(_DWORD *)(a1 + 4 * result) != (_DWORD)result )
{
if ( ++result == a2 )
return 0xFFFFFFFFLL;
}
return (unsigned int)result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012c8
MOVSXD RSI,ESI
XOR EAX,EAX
JMP 0x001012b9
LAB_001012b0:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x001012c8
LAB_001012b9:
MOV R8D,EAX
CMP dword ptr [RDI + RAX*0x4],EAX
JNZ 0x001012b0
MOV EAX,R8D
RET
LAB_001012c8:
MOV R8D,0xffffffff
MOV EAX,R8D
RET | ulong func0(long param_1,int param_2)
{
ulong uVar1;
if (0 < param_2) {
uVar1 = 0;
do {
if (*(int *)(param_1 + uVar1 * 4) == (int)uVar1) {
return uVar1 & 0xffffffff;
}
uVar1 = uVar1 + 1;
} while (uVar1 != (long)param_2);
}
return 0xffffffff;
} |
7,527 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
for (int i = 0; i < n; i++) {
if (arr[i] == i) {
return i;
}
}
return -1;
}
| int main() {
int arr1[] = {-10, -1, 0, 3, 10, 11, 30, 50, 100};
int arr2[] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr3[] = {0, 2, 5, 8, 17};
assert(func0(arr1, 9) == 3);
assert(func0(arr2, 8) == -1);
assert(func0(arr3, 5) == 0);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1290 <func0+0x30>
lea -0x1(%rsi),%ecx
xor %eax,%eax
jmp 127c <func0+0x1c>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1290 <func0+0x30>
mov %rdx,%rax
mov %eax,%r8d
cmp %eax,(%rdi,%rax,4)
jne 1270 <func0+0x10>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1160
movsxd rsi, esi
xor eax, eax
jmp short loc_1159
loc_1150:
add rax, 1
cmp rax, rsi
jz short loc_1160
loc_1159:
cmp [rdi+rax*4], eax
jnz short loc_1150
retn
loc_1160:
mov eax, 0FFFFFFFFh
retn | long long func0(long long a1, int a2)
{
long long result; // rax
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
result = 0LL;
while ( *(_DWORD *)(a1 + 4 * result) != (_DWORD)result )
{
if ( ++result == a2 )
return 0xFFFFFFFFLL;
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101160
MOVSXD RSI,ESI
XOR EAX,EAX
JMP 0x00101159
LAB_00101150:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x00101160
LAB_00101159:
CMP dword ptr [RDI + RAX*0x4],EAX
JNZ 0x00101150
RET
LAB_00101160:
MOV EAX,0xffffffff
RET | long func0(long param_1,int param_2)
{
long lVar1;
if (0 < param_2) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1 * 4) == (int)lVar1) {
return lVar1;
}
lVar1 = lVar1 + 1;
} while (lVar1 != param_2);
}
return 0xffffffff;
} |
7,528 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(int num) {
char num_str[12], rev_str[12];
for (int x = num-1; x > 0; x--) {
sprintf(num_str, "%d", x);
strcpy(rev_str, num_str);
int len = strlen(rev_str);
char temp;
for(int i = 0;i<len/2;i++){
temp = rev_str[i];
rev_str[i] = rev_str[len-1-i];
rev_str[len-1-i] = temp;
}
// strrev(rev_str);
if (strcmp(num_str, rev_str) == 0) {
return x;
}
}
return 0;
}
| int main() {
assert(func0(99) == 88);
assert(func0(1221) == 1111);
assert(func0(120) == 111);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %edi,-0x34(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x34(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x2c(%rbp)
jmpq 12c9 <func0+0xe0>
mov -0x2c(%rbp),%edx
lea -0x20(%rbp),%rax
lea 0xde5(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 10f0 <sprintf@plt>
lea -0x20(%rbp),%rdx
lea -0x14(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10a0 <strcpy@plt>
lea -0x14(%rbp),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %eax,-0x24(%rbp)
movl $0x0,-0x28(%rbp)
jmp 1298 <func0+0xaf>
mov -0x28(%rbp),%eax
cltq
movzbl -0x14(%rbp,%rax,1),%eax
mov %al,-0x2d(%rbp)
mov -0x24(%rbp),%eax
sub $0x1,%eax
sub -0x28(%rbp),%eax
cltq
movzbl -0x14(%rbp,%rax,1),%edx
mov -0x28(%rbp),%eax
cltq
mov %dl,-0x14(%rbp,%rax,1)
mov -0x24(%rbp),%eax
sub $0x1,%eax
sub -0x28(%rbp),%eax
cltq
movzbl -0x2d(%rbp),%edx
mov %dl,-0x14(%rbp,%rax,1)
addl $0x1,-0x28(%rbp)
mov -0x24(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x28(%rbp)
jl 125b <func0+0x72>
lea -0x14(%rbp),%rdx
lea -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10e0 <strcmp@plt>
test %eax,%eax
jne 12c5 <func0+0xdc>
mov -0x2c(%rbp),%eax
jmp 12d8 <func0+0xef>
subl $0x1,-0x2c(%rbp)
cmpl $0x0,-0x2c(%rbp)
jg 1215 <func0+0x2c>
mov $0x0,%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 12ec <func0+0x103>
callq 10c0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_34]
sub eax, 1
mov [rbp+var_2C], eax
jmp loc_12CC
loc_1215:
mov edx, [rbp+var_2C]
lea rax, [rbp+s]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
lea rdx, [rbp+s]
lea rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
lea rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov [rbp+var_24], eax
mov [rbp+var_28], 0
jmp short loc_129B
loc_125E:
mov eax, [rbp+var_28]
cdqe
movzx eax, [rbp+rax+dest]
mov [rbp+var_2D], al
mov eax, [rbp+var_24]
sub eax, 1
sub eax, [rbp+var_28]
cdqe
movzx edx, [rbp+rax+dest]
mov eax, [rbp+var_28]
cdqe
mov [rbp+rax+dest], dl
mov eax, [rbp+var_24]
sub eax, 1
sub eax, [rbp+var_28]
cdqe
movzx edx, [rbp+var_2D]
mov [rbp+rax+dest], dl
add [rbp+var_28], 1
loc_129B:
mov eax, [rbp+var_24]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_28], eax
jl short loc_125E
lea rdx, [rbp+dest]
lea rax, [rbp+s]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_12C8
mov eax, [rbp+var_2C]
jmp short loc_12DB
loc_12C8:
sub [rbp+var_2C], 1
loc_12CC:
cmp [rbp+var_2C], 0
jg loc_1215
mov eax, 0
loc_12DB:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12EF
call ___stack_chk_fail
locret_12EF:
leave
retn | long long func0(int a1)
{
char v2; // [rsp+13h] [rbp-2Dh]
int i; // [rsp+14h] [rbp-2Ch]
int j; // [rsp+18h] [rbp-28h]
int v5; // [rsp+1Ch] [rbp-24h]
char s[12]; // [rsp+20h] [rbp-20h] BYREF
char dest[12]; // [rsp+2Ch] [rbp-14h] BYREF
unsigned long long v8; // [rsp+38h] [rbp-8h]
v8 = __readfsqword(0x28u);
for ( i = a1 - 1; i > 0; --i )
{
sprintf(s, "%d", i);
strcpy(dest, s);
v5 = strlen(dest);
for ( j = 0; j < v5 / 2; ++j )
{
v2 = dest[j];
dest[j] = dest[v5 - 1 - j];
dest[v5 - 1 - j] = v2;
}
if ( !strcmp(s, dest) )
return (unsigned int)i;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001012cc
LAB_00101215:
MOV EDX,dword ptr [RBP + -0x2c]
LEA RAX,[RBP + -0x20]
LEA RCX,[0x102004]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x001010f0
LEA RDX,[RBP + -0x20]
LEA RAX,[RBP + -0x14]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010a0
LEA RAX,[RBP + -0x14]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x24],EAX
MOV dword ptr [RBP + -0x28],0x0
JMP 0x0010129b
LAB_0010125e:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x14]
MOV byte ptr [RBP + -0x2d],AL
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x1
SUB EAX,dword ptr [RBP + -0x28]
CDQE
MOVZX EDX,byte ptr [RBP + RAX*0x1 + -0x14]
MOV EAX,dword ptr [RBP + -0x28]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x14],DL
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x1
SUB EAX,dword ptr [RBP + -0x28]
CDQE
MOVZX EDX,byte ptr [RBP + -0x2d]
MOV byte ptr [RBP + RAX*0x1 + -0x14],DL
ADD dword ptr [RBP + -0x28],0x1
LAB_0010129b:
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x28],EAX
JL 0x0010125e
LEA RDX,[RBP + -0x14]
LEA RAX,[RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x001012c8
MOV EAX,dword ptr [RBP + -0x2c]
JMP 0x001012db
LAB_001012c8:
SUB dword ptr [RBP + -0x2c],0x1
LAB_001012cc:
CMP dword ptr [RBP + -0x2c],0x0
JG 0x00101215
MOV EAX,0x0
LAB_001012db:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012ef
CALL 0x001010c0
LAB_001012ef:
LEAVE
RET | uint func0(int param_1)
{
char cVar1;
int iVar2;
size_t sVar3;
long in_FS_OFFSET;
uint local_34;
int local_30;
char local_28 [12];
char local_1c [12];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
for (local_34 = param_1 - 1; 0 < (int)local_34; local_34 = local_34 - 1) {
sprintf(local_28,"%d",(ulong)local_34);
strcpy(local_1c,local_28);
sVar3 = strlen(local_1c);
iVar2 = (int)sVar3;
for (local_30 = 0; local_30 < iVar2 / 2; local_30 = local_30 + 1) {
cVar1 = local_1c[local_30];
local_1c[local_30] = local_1c[(iVar2 + -1) - local_30];
local_1c[(iVar2 + -1) - local_30] = cVar1;
}
iVar2 = strcmp(local_28,local_1c);
if (iVar2 == 0) goto LAB_001012db;
}
local_34 = 0;
LAB_001012db:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_34;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,529 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(int num) {
char num_str[12], rev_str[12];
for (int x = num-1; x > 0; x--) {
sprintf(num_str, "%d", x);
strcpy(rev_str, num_str);
int len = strlen(rev_str);
char temp;
for(int i = 0;i<len/2;i++){
temp = rev_str[i];
rev_str[i] = rev_str[len-1-i];
rev_str[len-1-i] = temp;
}
// strrev(rev_str);
if (strcmp(num_str, rev_str) == 0) {
return x;
}
}
return 0;
}
| int main() {
assert(func0(99) == 88);
assert(func0(1221) == 1111);
assert(func0(120) == 111);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea -0x1(%rdi),%ebx
test %ebx,%ebx
jle 12ab <func0+0xe2>
mov %rsp,%r12
lea 0xc(%rsp),%rbp
mov $0xffffffffffffffff,%r13
jmp 121f <func0+0x56>
mov %rbp,%rsi
mov %r12,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 12b0 <func0+0xe7>
sub $0x1,%ebx
je 12b0 <func0+0xe7>
mov %ebx,%r8d
lea 0xddb(%rip),%rcx
mov $0xc,%edx
mov $0x1,%esi
mov %r12,%rdi
mov $0x0,%eax
callq 10d0 <__sprintf_chk@plt>
mov $0xc,%edx
mov %r12,%rsi
mov %rbp,%rdi
callq 10c0 <__strcpy_chk@plt>
mov $0x0,%eax
mov %r13,%rcx
mov %rbp,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
mov %eax,%r8d
shr $0x1f,%r8d
add %eax,%r8d
sar %r8d
cmp $0x1,%eax
jle 1203 <func0+0x3a>
lea 0xc(%rsp),%rdx
cltq
add %rdx,%rax
mov $0x0,%ecx
movzbl (%rdx),%esi
movzbl -0x1(%rax),%edi
mov %dil,(%rdx)
mov %sil,-0x1(%rax)
add $0x1,%ecx
add $0x1,%rdx
sub $0x1,%rax
cmp %r8d,%ecx
jl 1288 <func0+0xbf>
jmpq 1203 <func0+0x3a>
mov $0x0,%ebx
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 12cd <func0+0x104>
mov %ebx,%eax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1090 <__stack_chk_fail@plt>
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
lea ebx, [rdi-1]
test ebx, ebx
jle loc_12B4
mov r12, rsp
lea r13, unk_2004
lea rbp, [rsp+48h+var_3C]
jmp short loc_123B
loc_1223:
mov rsi, rbp
mov rdi, r12
call _strcmp
test eax, eax
jz loc_12B9
sub ebx, 1
jz short loc_12B9
loc_123B:
mov r8d, ebx
mov rcx, r13
mov edx, 0Ch
mov esi, 1
mov rdi, r12
mov eax, 0
call ___sprintf_chk
mov edx, 0Ch
mov rsi, r12
mov rdi, rbp
call ___strcpy_chk
mov rdi, rbp
call _strlen
mov r8d, eax
shr r8d, 1Fh
add r8d, eax
sar r8d, 1
cmp eax, 1
jle short loc_1223
lea rdx, [rsp+48h+var_3C]
cdqe
add rax, rdx
mov ecx, 0
loc_1291:
movzx esi, byte ptr [rdx]
movzx edi, byte ptr [rax-1]
mov [rdx], dil
mov [rax-1], sil
add ecx, 1
add rdx, 1
sub rax, 1
cmp ecx, r8d
jl short loc_1291
jmp loc_1223
loc_12B4:
mov ebx, 0
loc_12B9:
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jnz short loc_12D6
mov eax, ebx
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_12D6:
call ___stack_chk_fail | long long func0(int a1)
{
unsigned int v1; // ebx
int v2; // eax
int v3; // r8d
char *v4; // rdx
_BYTE *v5; // rax
int v6; // ecx
char v7; // si
_BYTE v9[12]; // [rsp+0h] [rbp-48h] BYREF
_BYTE v10[12]; // [rsp+Ch] [rbp-3Ch] BYREF
unsigned long long v11; // [rsp+18h] [rbp-30h]
v11 = __readfsqword(0x28u);
v1 = a1 - 1;
if ( a1 - 1 <= 0 )
{
return 0;
}
else
{
do
{
__sprintf_chk(v9, 1LL, 12LL, &unk_2004, v1);
__strcpy_chk(v10, v9, 12LL);
v2 = strlen(v10);
v3 = v2 / 2;
if ( v2 > 1 )
{
v4 = v10;
v5 = &v10[v2];
v6 = 0;
do
{
v7 = *v4;
*v4 = *(v5 - 1);
*(v5 - 1) = v7;
++v6;
++v4;
--v5;
}
while ( v6 < v3 );
}
if ( !(unsigned int)strcmp(v9, v10) )
break;
--v1;
}
while ( v1 );
}
return v1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA EBX,[RDI + -0x1]
TEST EBX,EBX
JLE 0x001012b4
MOV R12,RSP
LEA R13,[0x102004]
LEA RBP,[RSP + 0xc]
JMP 0x0010123b
LAB_00101223:
MOV RSI,RBP
MOV RDI,R12
CALL 0x001010d0
TEST EAX,EAX
JZ 0x001012b9
SUB EBX,0x1
JZ 0x001012b9
LAB_0010123b:
MOV R8D,EBX
MOV RCX,R13
MOV EDX,0xc
MOV ESI,0x1
MOV RDI,R12
MOV EAX,0x0
CALL 0x001010f0
MOV EDX,0xc
MOV RSI,R12
MOV RDI,RBP
CALL 0x001010e0
MOV RDI,RBP
CALL 0x001010a0
MOV R8D,EAX
SHR R8D,0x1f
ADD R8D,EAX
SAR R8D,0x1
CMP EAX,0x1
JLE 0x00101223
LEA RDX,[RSP + 0xc]
CDQE
ADD RAX,RDX
MOV ECX,0x0
LAB_00101291:
MOVZX ESI,byte ptr [RDX]
MOVZX EDI,byte ptr [RAX + -0x1]
MOV byte ptr [RDX],DIL
MOV byte ptr [RAX + -0x1],SIL
ADD ECX,0x1
ADD RDX,0x1
SUB RAX,0x1
CMP ECX,R8D
JL 0x00101291
JMP 0x00101223
LAB_001012b4:
MOV EBX,0x0
LAB_001012b9:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012d6
MOV EAX,EBX
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001012d6:
CALL 0x001010b0 | int func0(int param_1)
{
char cVar1;
int iVar2;
size_t sVar3;
char *pcVar4;
int iVar5;
char *pcVar6;
long in_FS_OFFSET;
char acStack_48 [12];
char local_3c [12];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
param_1 = param_1 + -1;
if (param_1 < 1) {
param_1 = 0;
}
else {
do {
__sprintf_chk(acStack_48,1,0xc,&DAT_00102004,param_1);
__strcpy_chk(local_3c,acStack_48,0xc);
sVar3 = strlen(local_3c);
iVar2 = (int)sVar3;
if (1 < iVar2) {
pcVar6 = local_3c;
pcVar4 = pcVar6 + iVar2;
iVar5 = 0;
do {
cVar1 = *pcVar6;
*pcVar6 = pcVar4[-1];
pcVar4[-1] = cVar1;
iVar5 = iVar5 + 1;
pcVar6 = pcVar6 + 1;
pcVar4 = pcVar4 + -1;
} while (iVar5 < (int)(((uint)(sVar3 >> 0x1f) & 1) + iVar2) >> 1);
}
iVar2 = strcmp(acStack_48,local_3c);
} while ((iVar2 != 0) && (param_1 = param_1 + -1, param_1 != 0));
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
7,530 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(int num) {
char num_str[12], rev_str[12];
for (int x = num-1; x > 0; x--) {
sprintf(num_str, "%d", x);
strcpy(rev_str, num_str);
int len = strlen(rev_str);
char temp;
for(int i = 0;i<len/2;i++){
temp = rev_str[i];
rev_str[i] = rev_str[len-1-i];
rev_str[len-1-i] = temp;
}
// strrev(rev_str);
if (strcmp(num_str, rev_str) == 0) {
return x;
}
}
return 0;
}
| int main() {
assert(func0(99) == 88);
assert(func0(1221) == 1111);
assert(func0(120) == 111);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
lea -0x1(%rdi),%r13d
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov %rsp,%rbp
lea 0xc(%rsp),%rbx
lea 0xd(%rsp),%r12
test %r13d,%r13d
jle 131f <func0+0xaf>
nopl 0x0(%rax)
lea 0xd55(%rip),%rcx
mov %r13d,%r8d
mov %rbp,%rdi
xor %eax,%eax
mov $0xc,%edx
mov $0x1,%esi
callq 10d0 <__sprintf_chk@plt>
mov $0xc,%edx
mov %rbp,%rsi
mov %rbx,%rdi
callq 10c0 <__stpcpy_chk@plt>
sub %rbx,%rax
mov %eax,%ecx
sar %ecx
je 130a <func0+0x9a>
cltq
lea -0x1(%rcx),%edi
mov %rbx,%rdx
lea -0x1(%rbx,%rax,1),%rax
add %r12,%rdi
movzbl (%rax),%esi
movzbl (%rdx),%ecx
add $0x1,%rdx
sub $0x1,%rax
mov %sil,-0x1(%rdx)
mov %cl,0x1(%rax)
cmp %rdi,%rdx
jne 12f0 <func0+0x80>
mov %rbx,%rsi
mov %rbp,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
je 1322 <func0+0xb2>
sub $0x1,%r13d
jne 12a8 <func0+0x38>
xor %r13d,%r13d
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 1340 <func0+0xd0>
add $0x28,%rsp
mov %r13d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1090 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r14
lea r14d, [rdi-1]
push r13
push r12
push rbp
push rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
test r14d, r14d
jle loc_132F
mov rbp, rsp
lea rbx, [rsp+48h+var_3C]
lea r13, [rsp+48h+var_3B]
lea r12, unk_2004
nop dword ptr [rax+00000000h]
loc_12B8:
mov rcx, r12
mov r8d, r14d
mov edx, 0Ch
mov esi, 1
mov rdi, rbp
xor eax, eax
call ___sprintf_chk
mov edx, 0Ch
mov rsi, rbp
mov rdi, rbx
call ___stpcpy_chk
sub rax, rbx
mov ecx, eax
sar ecx, 1
jz short loc_131A
cdqe
lea edi, [rcx-1]
mov rdx, rbx
lea rax, [rbx+rax-1]
add rdi, r13
nop dword ptr [rax+rax+00h]
loc_1300:
movzx esi, byte ptr [rax]
movzx ecx, byte ptr [rdx]
add rdx, 1
sub rax, 1
mov [rdx-1], sil
mov [rax+1], cl
cmp rdx, rdi
jnz short loc_1300
loc_131A:
mov rsi, rbx
mov rdi, rbp
call _strcmp
test eax, eax
jz short loc_1332
sub r14d, 1
jnz short loc_12B8
loc_132F:
xor r14d, r14d
loc_1332:
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jnz short loc_1352
add rsp, 20h
mov eax, r14d
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1352:
call ___stack_chk_fail | long long func0(int a1)
{
unsigned int v1; // r14d
long long v2; // rax
unsigned __int8 *v3; // rdx
long long v4; // rcx
unsigned __int8 *v5; // rax
unsigned __int8 *v6; // rdi
unsigned __int8 v7; // si
_BYTE v9[12]; // [rsp+0h] [rbp-48h] BYREF
_BYTE v10[12]; // [rsp+Ch] [rbp-3Ch] BYREF
unsigned long long v11; // [rsp+18h] [rbp-30h]
v1 = a1 - 1;
v11 = __readfsqword(0x28u);
if ( a1 - 1 <= 0 )
{
return 0;
}
else
{
while ( 1 )
{
__sprintf_chk(v9, 1LL, 12LL, &unk_2004, v1);
v2 = __stpcpy_chk(v10, v9, 12LL) - (_QWORD)v10;
v4 = (unsigned int)((int)v2 >> 1);
if ( (int)v2 >> 1 )
{
v3 = v10;
v5 = &v10[(int)v2 - 1];
v6 = &v10[(unsigned int)(v4 - 1) + 1];
do
{
v7 = *v5;
v4 = *v3++;
--v5;
*(v3 - 1) = v7;
v5[1] = v4;
}
while ( v3 != v6 );
}
if ( !(unsigned int)strcmp(v9, v10, v3, v4) )
break;
if ( !--v1 )
return 0;
}
}
return v1;
} | func0:
ENDBR64
PUSH R14
LEA R14D,[RDI + -0x1]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
TEST R14D,R14D
JLE 0x0010132f
MOV RBP,RSP
LEA RBX,[RSP + 0xc]
LEA R13,[RSP + 0xd]
LEA R12,[0x102004]
NOP dword ptr [RAX]
LAB_001012b8:
MOV RCX,R12
MOV R8D,R14D
MOV EDX,0xc
MOV ESI,0x1
MOV RDI,RBP
XOR EAX,EAX
CALL 0x001010d0
MOV EDX,0xc
MOV RSI,RBP
MOV RDI,RBX
CALL 0x001010c0
SUB RAX,RBX
MOV ECX,EAX
SAR ECX,0x1
JZ 0x0010131a
CDQE
LEA EDI,[RCX + -0x1]
MOV RDX,RBX
LEA RAX,[RBX + RAX*0x1 + -0x1]
ADD RDI,R13
NOP dword ptr [RAX + RAX*0x1]
LAB_00101300:
MOVZX ESI,byte ptr [RAX]
MOVZX ECX,byte ptr [RDX]
ADD RDX,0x1
SUB RAX,0x1
MOV byte ptr [RDX + -0x1],SIL
MOV byte ptr [RAX + 0x1],CL
CMP RDX,RDI
JNZ 0x00101300
LAB_0010131a:
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010b0
TEST EAX,EAX
JZ 0x00101332
SUB R14D,0x1
JNZ 0x001012b8
LAB_0010132f:
XOR R14D,R14D
LAB_00101332:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101352
ADD RSP,0x20
MOV EAX,R14D
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101352:
CALL 0x00101090 | int func0(int param_1)
{
char *__s2;
char cVar1;
int iVar2;
char *pcVar3;
int iVar4;
char *pcVar5;
char *pcVar6;
long in_FS_OFFSET;
char acStack_48 [11];
char acStack_3d [13];
long local_30;
param_1 = param_1 + -1;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (0 < param_1) {
__s2 = acStack_3d + 1;
do {
__sprintf_chk(acStack_48,1,0xc,&DAT_00102004,param_1);
iVar2 = __stpcpy_chk(__s2,acStack_48,0xc);
iVar2 = iVar2 - (int)__s2;
iVar4 = iVar2 >> 1;
if (iVar4 != 0) {
pcVar3 = acStack_3d + iVar2;
pcVar5 = __s2;
do {
cVar1 = *pcVar5;
pcVar6 = pcVar5 + 1;
*pcVar5 = *pcVar3;
*pcVar3 = cVar1;
pcVar3 = pcVar3 + -1;
pcVar5 = pcVar6;
} while (pcVar6 != acStack_3d + (ulong)(iVar4 - 1) + 2);
}
iVar2 = strcmp(acStack_48,__s2);
if (iVar2 == 0) goto LAB_00101332;
param_1 = param_1 + -1;
} while (param_1 != 0);
}
param_1 = 0;
LAB_00101332:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,531 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(int num) {
char num_str[12], rev_str[12];
for (int x = num-1; x > 0; x--) {
sprintf(num_str, "%d", x);
strcpy(rev_str, num_str);
int len = strlen(rev_str);
char temp;
for(int i = 0;i<len/2;i++){
temp = rev_str[i];
rev_str[i] = rev_str[len-1-i];
rev_str[len-1-i] = temp;
}
// strrev(rev_str);
if (strcmp(num_str, rev_str) == 0) {
return x;
}
}
return 0;
}
| int main() {
assert(func0(99) == 88);
assert(func0(1221) == 1111);
assert(func0(120) == 111);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
lea -0x1(%rdi),%r13d
push %r12
lea 0xd81(%rip),%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov %rsp,%rbp
lea 0xc(%rsp),%rbx
test %r13d,%r13d
jg 12ba <func0+0x4a>
jmpq 13b5 <func0+0x145>
nopl 0x0(%rax,%rax,1)
sub $0x1,%r13d
je 13b5 <func0+0x145>
mov %r12,%rcx
mov %r13d,%r8d
mov $0xc,%edx
mov $0x1,%esi
mov %rbp,%rdi
xor %eax,%eax
callq 10d0 <__sprintf_chk@plt>
mov $0xc,%edx
mov %rbp,%rsi
mov %rbx,%rdi
callq 10c0 <__stpcpy_chk@plt>
sub %rbx,%rax
mov %eax,%ecx
sar %ecx
je 1384 <func0+0x114>
lea -0x1(%rax),%edx
movzbl 0xc(%rsp),%esi
movslq %edx,%rdx
movzbl 0xc(%rsp,%rdx,1),%edi
mov %dil,0xc(%rsp)
mov %sil,0xc(%rsp,%rdx,1)
cmp $0x1,%ecx
je 1384 <func0+0x114>
lea -0x2(%rax),%edx
movzbl 0xd(%rsp),%esi
movslq %edx,%rdx
movzbl 0xc(%rsp,%rdx,1),%edi
mov %dil,0xd(%rsp)
mov %sil,0xc(%rsp,%rdx,1)
cmp $0x2,%ecx
je 1384 <func0+0x114>
lea -0x3(%rax),%edx
movzbl 0xe(%rsp),%esi
movslq %edx,%rdx
movzbl 0xc(%rsp,%rdx,1),%edi
mov %dil,0xe(%rsp)
mov %sil,0xc(%rsp,%rdx,1)
cmp $0x3,%ecx
je 1384 <func0+0x114>
lea -0x4(%rax),%edx
movzbl 0xf(%rsp),%esi
movslq %edx,%rdx
movzbl 0xc(%rsp,%rdx,1),%edi
mov %dil,0xf(%rsp)
mov %sil,0xc(%rsp,%rdx,1)
cmp $0x5,%ecx
jne 1384 <func0+0x114>
sub $0x5,%eax
movzbl 0x10(%rsp),%edx
cltq
movzbl 0xc(%rsp,%rax,1),%ecx
mov %cl,0x10(%rsp)
mov %dl,0xc(%rsp,%rax,1)
mov %rbx,%rsi
mov %rbp,%rdi
callq 10b0 <strcmp@plt>
test %eax,%eax
jne 12b0 <func0+0x40>
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 13ba <func0+0x14a>
add $0x28,%rsp
mov %r13d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xor %r13d,%r13d
jmp 1397 <func0+0x127>
callq 1090 <__stack_chk_fail@plt>
| func0:
endbr64
push r13
lea r13, unk_2004
push r12
push rbp
push rbx
lea ebx, [rdi-1]
sub rsp, 28h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov r12, rsp
lea rbp, [rsp+48h+s2]
test ebx, ebx
jg short loc_12B9
jmp loc_13B3
loc_12B0:
sub ebx, 1
jz loc_13B3
loc_12B9:
mov rcx, r13
mov r8d, ebx
mov edx, 0Ch
mov esi, 2
mov rdi, r12
xor eax, eax
call ___sprintf_chk
mov edx, 0Ch
mov rsi, r12
mov rdi, rbp
call ___stpcpy_chk
sub rax, rbp
mov ecx, eax
sar ecx, 1
jz loc_1383
lea edx, [rax-1]
movzx esi, [rsp+48h+s2]
movsxd rdx, edx
movzx edi, [rsp+rdx+48h+s2]
mov [rsp+rdx+48h+s2], sil
mov [rsp+48h+s2], dil
cmp ecx, 1
jz short loc_1383
lea edx, [rax-2]
movzx esi, [rsp+48h+var_3B]
movsxd rdx, edx
movzx edi, [rsp+rdx+48h+s2]
mov [rsp+rdx+48h+s2], sil
mov [rsp+48h+var_3B], dil
cmp ecx, 2
jz short loc_1383
lea edx, [rax-3]
movzx esi, [rsp+48h+var_3A]
movsxd rdx, edx
movzx edi, [rsp+rdx+48h+s2]
mov [rsp+rdx+48h+s2], sil
mov [rsp+48h+var_3A], dil
cmp ecx, 3
jz short loc_1383
lea edx, [rax-4]
movzx esi, [rsp+48h+var_39]
movsxd rdx, edx
movzx edi, [rsp+rdx+48h+s2]
mov [rsp+rdx+48h+s2], sil
mov [rsp+48h+var_39], dil
cmp ecx, 5
jnz short loc_1383
sub eax, 5
movzx edx, [rsp+48h+var_38]
cdqe
movzx ecx, [rsp+rax+48h+s2]
mov [rsp+rax+48h+s2], dl
mov [rsp+48h+var_38], cl
loc_1383:
mov rsi, rbp; s2
mov rdi, r12; s1
call _strcmp
test eax, eax
jnz loc_12B0
loc_1396:
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jnz short loc_13B7
add rsp, 28h
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_13B3:
xor ebx, ebx
jmp short loc_1396
loc_13B7:
call ___stack_chk_fail | long long func0(int a1)
{
unsigned int v1; // ebx
long long v2; // rax
int v3; // ecx
char v4; // di
char v5; // di
char v6; // di
char v7; // di
int v8; // eax
char v9; // cl
char v11[12]; // [rsp+0h] [rbp-48h] BYREF
char s2; // [rsp+Ch] [rbp-3Ch] BYREF
char v13; // [rsp+Dh] [rbp-3Bh]
char v14; // [rsp+Eh] [rbp-3Ah]
char v15; // [rsp+Fh] [rbp-39h]
char v16; // [rsp+10h] [rbp-38h]
unsigned long long v17; // [rsp+18h] [rbp-30h]
v1 = a1 - 1;
v17 = __readfsqword(0x28u);
if ( a1 - 1 > 0 )
{
while ( 1 )
{
__sprintf_chk(v11, 2LL, 12LL, &unk_2004, v1);
v2 = __stpcpy_chk(&s2, v11, 12LL) - (_QWORD)&s2;
v3 = (int)v2 >> 1;
if ( (int)v2 >> 1 )
{
v4 = *(&s2 + (int)v2 - 1);
*(&s2 + (int)v2 - 1) = s2;
s2 = v4;
if ( v3 != 1 )
{
v5 = *(&s2 + (int)v2 - 2);
*(&s2 + (int)v2 - 2) = v13;
v13 = v5;
if ( v3 != 2 )
{
v6 = *(&s2 + (int)v2 - 3);
*(&s2 + (int)v2 - 3) = v14;
v14 = v6;
if ( v3 != 3 )
{
v7 = *(&s2 + (int)v2 - 4);
*(&s2 + (int)v2 - 4) = v15;
v15 = v7;
if ( v3 == 5 )
{
v8 = v2 - 5;
v9 = *(&s2 + v8);
*(&s2 + v8) = v16;
v16 = v9;
}
}
}
}
}
if ( !strcmp(v11, &s2) )
break;
if ( !--v1 )
return 0;
}
}
else
{
return 0;
}
return v1;
} | func0:
ENDBR64
PUSH R13
LEA R13,[0x102004]
PUSH R12
PUSH RBP
PUSH RBX
LEA EBX,[RDI + -0x1]
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV R12,RSP
LEA RBP,[RSP + 0xc]
TEST EBX,EBX
JG 0x001012b9
JMP 0x001013b3
LAB_001012b0:
SUB EBX,0x1
JZ 0x001013b3
LAB_001012b9:
MOV RCX,R13
MOV R8D,EBX
MOV EDX,0xc
MOV ESI,0x2
MOV RDI,R12
XOR EAX,EAX
CALL 0x001010d0
MOV EDX,0xc
MOV RSI,R12
MOV RDI,RBP
CALL 0x001010c0
SUB RAX,RBP
MOV ECX,EAX
SAR ECX,0x1
JZ 0x00101383
LEA EDX,[RAX + -0x1]
MOVZX ESI,byte ptr [RSP + 0xc]
MOVSXD RDX,EDX
MOVZX EDI,byte ptr [RSP + RDX*0x1 + 0xc]
MOV byte ptr [RSP + RDX*0x1 + 0xc],SIL
MOV byte ptr [RSP + 0xc],DIL
CMP ECX,0x1
JZ 0x00101383
LEA EDX,[RAX + -0x2]
MOVZX ESI,byte ptr [RSP + 0xd]
MOVSXD RDX,EDX
MOVZX EDI,byte ptr [RSP + RDX*0x1 + 0xc]
MOV byte ptr [RSP + RDX*0x1 + 0xc],SIL
MOV byte ptr [RSP + 0xd],DIL
CMP ECX,0x2
JZ 0x00101383
LEA EDX,[RAX + -0x3]
MOVZX ESI,byte ptr [RSP + 0xe]
MOVSXD RDX,EDX
MOVZX EDI,byte ptr [RSP + RDX*0x1 + 0xc]
MOV byte ptr [RSP + RDX*0x1 + 0xc],SIL
MOV byte ptr [RSP + 0xe],DIL
CMP ECX,0x3
JZ 0x00101383
LEA EDX,[RAX + -0x4]
MOVZX ESI,byte ptr [RSP + 0xf]
MOVSXD RDX,EDX
MOVZX EDI,byte ptr [RSP + RDX*0x1 + 0xc]
MOV byte ptr [RSP + RDX*0x1 + 0xc],SIL
MOV byte ptr [RSP + 0xf],DIL
CMP ECX,0x5
JNZ 0x00101383
SUB EAX,0x5
MOVZX EDX,byte ptr [RSP + 0x10]
CDQE
MOVZX ECX,byte ptr [RSP + RAX*0x1 + 0xc]
MOV byte ptr [RSP + RAX*0x1 + 0xc],DL
MOV byte ptr [RSP + 0x10],CL
LAB_00101383:
MOV RSI,RBP
MOV RDI,R12
CALL 0x001010b0
TEST EAX,EAX
JNZ 0x001012b0
LAB_00101396:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013b7
ADD RSP,0x28
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001013b3:
XOR EBX,EBX
JMP 0x00101396
LAB_001013b7:
CALL 0x00101090 | int func0(int param_1)
{
char cVar1;
int iVar2;
int iVar3;
long in_FS_OFFSET;
char acStack_48 [12];
char local_3c [4];
char local_38;
long local_30;
param_1 = param_1 + -1;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (0 < param_1) {
do {
__sprintf_chk(acStack_48,2,0xc,&DAT_00102004,param_1);
iVar2 = __stpcpy_chk(local_3c,acStack_48,0xc);
iVar2 = iVar2 - (int)local_3c;
iVar3 = iVar2 >> 1;
if (iVar3 != 0) {
cVar1 = local_3c[iVar2 + -1];
local_3c[iVar2 + -1] = local_3c[0];
local_3c[0] = cVar1;
if (iVar3 != 1) {
cVar1 = local_3c[iVar2 + -2];
local_3c[iVar2 + -2] = local_3c[1];
local_3c[1] = cVar1;
if (iVar3 != 2) {
cVar1 = local_3c[iVar2 + -3];
local_3c[iVar2 + -3] = local_3c[2];
local_3c[2] = cVar1;
if (iVar3 != 3) {
cVar1 = local_3c[iVar2 + -4];
local_3c[iVar2 + -4] = local_3c[3];
local_3c[3] = cVar1;
if (iVar3 == 5) {
cVar1 = local_3c[iVar2 + -5];
local_3c[iVar2 + -5] = local_38;
local_38 = cVar1;
}
}
}
}
}
iVar2 = strcmp(acStack_48,local_3c);
if (iVar2 == 0) goto LAB_00101396;
param_1 = param_1 + -1;
} while (param_1 != 0);
}
param_1 = 0;
LAB_00101396:
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
7,532 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <time.h>
| bool func0(int m, int d, int y) {
struct tm time;
time.tm_year = y - 1900; // Year since 1900
time.tm_mon = m - 1; // Month since January, [0, 11]
time.tm_mday = d; // Day of the month, [1, 31]
time.tm_hour = 0;
time.tm_min = 0;
time.tm_sec = 0;
time.tm_isdst = -1; // Not using Daylight Saving Time
if (mktime(&time) == -1) {
return false;
} else {
// Check for the values after mktime adjustment
if (time.tm_year + 1900 != y || time.tm_mon + 1 != m || time.tm_mday != d) {
return false;
}
return true;
}
}
| int main() {
assert(func0(11,11,2002) == true);
assert(func0(13,11,2002) == false);
assert(func0(11,11,2002) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %edi,-0x44(%rbp)
mov %esi,-0x48(%rbp)
mov %edx,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x4c(%rbp),%eax
sub $0x76c,%eax
mov %eax,-0x2c(%rbp)
mov -0x44(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x30(%rbp)
mov -0x48(%rbp),%eax
mov %eax,-0x34(%rbp)
movl $0x0,-0x38(%rbp)
movl $0x0,-0x3c(%rbp)
movl $0x0,-0x40(%rbp)
movl $0xffffffff,-0x20(%rbp)
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 1090 <mktime@plt>
cmp $0xffffffffffffffff,%rax
jne 11fc <func0+0x73>
mov $0x0,%eax
jmp 1228 <func0+0x9f>
mov -0x2c(%rbp),%eax
add $0x76c,%eax
cmp %eax,-0x4c(%rbp)
jne 121c <func0+0x93>
mov -0x30(%rbp),%eax
add $0x1,%eax
cmp %eax,-0x44(%rbp)
jne 121c <func0+0x93>
mov -0x34(%rbp),%eax
cmp %eax,-0x48(%rbp)
je 1223 <func0+0x9a>
mov $0x0,%eax
jmp 1228 <func0+0x9f>
mov $0x1,%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 123c <func0+0xb3>
callq 1070 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_44], edi
mov [rbp+var_48], esi
mov [rbp+var_4C], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_4C]
sub eax, 76Ch
mov [rbp+tp.tm_year], eax
mov eax, [rbp+var_44]
sub eax, 1
mov [rbp+tp.tm_mon], eax
mov eax, [rbp+var_48]
mov [rbp+tp.tm_mday], eax
mov [rbp+tp.tm_hour], 0
mov [rbp+tp.tm_min], 0
mov [rbp+tp.tm_sec], 0
mov [rbp+tp.tm_isdst], 0FFFFFFFFh
lea rax, [rbp+tp]
mov rdi, rax; tp
call _mktime
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_11FC
mov eax, 0
jmp short loc_1228
loc_11FC:
mov eax, [rbp+tp.tm_year]
add eax, 76Ch
cmp [rbp+var_4C], eax
jnz short loc_121C
mov eax, [rbp+tp.tm_mon]
add eax, 1
cmp [rbp+var_44], eax
jnz short loc_121C
mov eax, [rbp+tp.tm_mday]
cmp [rbp+var_48], eax
jz short loc_1223
loc_121C:
mov eax, 0
jmp short loc_1228
loc_1223:
mov eax, 1
loc_1228:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_123C
call ___stack_chk_fail
locret_123C:
leave
retn | _BOOL8 func0(int a1, int a2, int a3)
{
tm tp; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v6; // [rsp+48h] [rbp-8h]
v6 = __readfsqword(0x28u);
tp.tm_year = a3 - 1900;
tp.tm_mon = a1 - 1;
tp.tm_mday = a2;
tp.tm_hour = 0;
tp.tm_min = 0;
tp.tm_sec = 0;
tp.tm_isdst = -1;
if ( mktime(&tp) == -1 )
return 0LL;
return a3 == tp.tm_year + 1900 && a1 == tp.tm_mon + 1 && a2 == tp.tm_mday;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV dword ptr [RBP + -0x44],EDI
MOV dword ptr [RBP + -0x48],ESI
MOV dword ptr [RBP + -0x4c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0x76c
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x44]
SUB EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x34],EAX
MOV dword ptr [RBP + -0x38],0x0
MOV dword ptr [RBP + -0x3c],0x0
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x20],0xffffffff
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x00101090
CMP RAX,-0x1
JNZ 0x001011fc
MOV EAX,0x0
JMP 0x00101228
LAB_001011fc:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x76c
CMP dword ptr [RBP + -0x4c],EAX
JNZ 0x0010121c
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,0x1
CMP dword ptr [RBP + -0x44],EAX
JNZ 0x0010121c
MOV EAX,dword ptr [RBP + -0x34]
CMP dword ptr [RBP + -0x48],EAX
JZ 0x00101223
LAB_0010121c:
MOV EAX,0x0
JMP 0x00101228
LAB_00101223:
MOV EAX,0x1
LAB_00101228:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010123c
CALL 0x00101070
LAB_0010123c:
LEAVE
RET | int8 func0(int param_1,int param_2,int param_3)
{
time_t tVar1;
int8 uVar2;
long in_FS_OFFSET;
tm local_48;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_48.tm_year = param_3 + -0x76c;
local_48.tm_mon = param_1 + -1;
local_48.tm_hour = 0;
local_48.tm_min = 0;
local_48.tm_sec = 0;
local_48.tm_isdst = -1;
local_48.tm_mday = param_2;
tVar1 = mktime(&local_48);
if (tVar1 == -1) {
uVar2 = 0;
}
else if (((param_3 == local_48.tm_year + 0x76c) && (param_1 == local_48.tm_mon + 1)) &&
(param_2 == local_48.tm_mday)) {
uVar2 = 1;
}
else {
uVar2 = 0;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar2;
} |
7,533 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <time.h>
| bool func0(int m, int d, int y) {
struct tm time;
time.tm_year = y - 1900; // Year since 1900
time.tm_mon = m - 1; // Month since January, [0, 11]
time.tm_mday = d; // Day of the month, [1, 31]
time.tm_hour = 0;
time.tm_min = 0;
time.tm_sec = 0;
time.tm_isdst = -1; // Not using Daylight Saving Time
if (mktime(&time) == -1) {
return false;
} else {
// Check for the values after mktime adjustment
if (time.tm_year + 1900 != y || time.tm_mon + 1 != m || time.tm_mday != d) {
return false;
}
return true;
}
}
| int main() {
assert(func0(11,11,2002) == true);
assert(func0(13,11,2002) == false);
assert(func0(11,11,2002) == true);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x40,%rsp
mov %edi,%ebp
mov %esi,%r12d
mov %edx,%ebx
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea -0x76c(%rdx),%eax
mov %eax,0x14(%rsp)
lea -0x1(%rdi),%eax
mov %eax,0x10(%rsp)
mov %esi,0xc(%rsp)
movl $0x0,0x8(%rsp)
movl $0x0,0x4(%rsp)
movl $0x0,(%rsp)
movl $0xffffffff,0x20(%rsp)
mov %rsp,%rdi
callq 1090 <mktime@plt>
mov %rax,%rdx
mov $0x0,%eax
cmp $0xffffffffffffffff,%rdx
je 1221 <func0+0x98>
mov 0x14(%rsp),%eax
lea 0x76c(%rax),%edx
mov $0x0,%eax
cmp %ebx,%edx
jne 1221 <func0+0x98>
mov 0x10(%rsp),%eax
lea 0x1(%rax),%edx
mov $0x0,%eax
cmp %ebp,%edx
jne 1221 <func0+0x98>
cmp %r12d,0xc(%rsp)
sete %al
mov 0x38(%rsp),%rcx
xor %fs:0x28,%rcx
jne 123a <func0+0xb1>
add $0x40,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 1070 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 40h
mov ebp, edi
mov r12d, esi
mov ebx, edx
mov rax, fs:28h
mov [rsp+58h+var_20], rax
xor eax, eax
lea eax, [rdx-76Ch]
mov [rsp+58h+var_44], eax
lea eax, [rdi-1]
mov [rsp+58h+var_48], eax
mov [rsp+58h+var_4C], esi
mov [rsp+58h+var_50], 0
mov [rsp+58h+var_54], 0
mov [rsp+58h+var_58], 0
mov [rsp+58h+var_38], 0FFFFFFFFh
mov rdi, rsp
call _mktime
mov rdx, rax
mov eax, 0
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz short loc_1221
mov eax, [rsp+58h+var_44]
lea edx, [rax+76Ch]
mov eax, 0
cmp edx, ebx
jnz short loc_1221
mov eax, [rsp+58h+var_48]
lea edx, [rax+1]
mov eax, 0
cmp edx, ebp
jnz short loc_1221
cmp [rsp+58h+var_4C], r12d
setz al
loc_1221:
mov rdx, [rsp+58h+var_20]
sub rdx, fs:28h
jnz short loc_123A
add rsp, 40h
pop rbx
pop rbp
pop r12
retn
loc_123A:
call ___stack_chk_fail | bool func0(int a1, int a2, int a3)
{
long long v4; // rdx
bool result; // al
_DWORD v6[3]; // [rsp+0h] [rbp-58h] BYREF
int v7; // [rsp+Ch] [rbp-4Ch]
int v8; // [rsp+10h] [rbp-48h]
int v9; // [rsp+14h] [rbp-44h]
int v10; // [rsp+20h] [rbp-38h]
unsigned long long v11; // [rsp+38h] [rbp-20h]
v11 = __readfsqword(0x28u);
v9 = a3 - 1900;
v8 = a1 - 1;
v7 = a2;
v6[2] = 0;
v6[1] = 0;
v6[0] = 0;
v10 = -1;
v4 = mktime(v6);
result = 0;
if ( v4 != -1 )
{
result = 0;
if ( v9 + 1900 == a3 )
{
result = 0;
if ( v8 + 1 == a1 )
return v7 == a2;
}
}
return result;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x40
MOV EBP,EDI
MOV R12D,ESI
MOV EBX,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA EAX,[RDX + -0x76c]
MOV dword ptr [RSP + 0x14],EAX
LEA EAX,[RDI + -0x1]
MOV dword ptr [RSP + 0x10],EAX
MOV dword ptr [RSP + 0xc],ESI
MOV dword ptr [RSP + 0x8],0x0
MOV dword ptr [RSP + 0x4],0x0
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x20],0xffffffff
MOV RDI,RSP
CALL 0x00101090
MOV RDX,RAX
MOV EAX,0x0
CMP RDX,-0x1
JZ 0x00101221
MOV EAX,dword ptr [RSP + 0x14]
LEA EDX,[RAX + 0x76c]
MOV EAX,0x0
CMP EDX,EBX
JNZ 0x00101221
MOV EAX,dword ptr [RSP + 0x10]
LEA EDX,[RAX + 0x1]
MOV EAX,0x0
CMP EDX,EBP
JNZ 0x00101221
CMP dword ptr [RSP + 0xc],R12D
SETZ AL
LAB_00101221:
MOV RDX,qword ptr [RSP + 0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010123a
ADD RSP,0x40
POP RBX
POP RBP
POP R12
RET
LAB_0010123a:
CALL 0x00101070 | bool func0(int param_1,int param_2,int param_3)
{
time_t tVar1;
long in_FS_OFFSET;
bool bVar2;
tm local_58;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_58.tm_year = param_3 + -0x76c;
local_58.tm_mon = param_1 + -1;
local_58.tm_hour = 0;
local_58.tm_min = 0;
local_58.tm_sec = 0;
local_58.tm_isdst = -1;
local_58.tm_mday = param_2;
tVar1 = mktime(&local_58);
bVar2 = false;
if (((tVar1 != -1) && (bVar2 = false, local_58.tm_year + 0x76c == param_3)) &&
(bVar2 = false, local_58.tm_mon + 1 == param_1)) {
bVar2 = local_58.tm_mday == param_2;
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,534 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <time.h>
| bool func0(int m, int d, int y) {
struct tm time;
time.tm_year = y - 1900; // Year since 1900
time.tm_mon = m - 1; // Month since January, [0, 11]
time.tm_mday = d; // Day of the month, [1, 31]
time.tm_hour = 0;
time.tm_min = 0;
time.tm_sec = 0;
time.tm_isdst = -1; // Not using Daylight Saving Time
if (mktime(&time) == -1) {
return false;
} else {
// Check for the values after mktime adjustment
if (time.tm_year + 1900 != y || time.tm_mon + 1 != m || time.tm_mday != d) {
return false;
}
return true;
}
}
| int main() {
assert(func0(11,11,2002) == true);
assert(func0(13,11,2002) == false);
assert(func0(11,11,2002) == true);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %esi,%r12d
push %rbp
mov %edi,%ebp
push %rbx
mov %edx,%ebx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea -0x76c(%rdx),%eax
mov %esi,0xc(%rsp)
mov %eax,0x14(%rsp)
lea -0x1(%rdi),%eax
mov %rsp,%rdi
mov %eax,0x10(%rsp)
movq $0x0,(%rsp)
movl $0x0,0x8(%rsp)
movl $0xffffffff,0x20(%rsp)
callq 1090 <mktime@plt>
xor %r8d,%r8d
cmp $0xffffffffffffffff,%rax
je 12be <func0+0x6e>
mov 0x14(%rsp),%eax
add $0x76c,%eax
cmp %ebx,%eax
je 12e0 <func0+0x90>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 12f6 <func0+0xa6>
add $0x40,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
mov 0x10(%rsp),%eax
add $0x1,%eax
cmp %ebp,%eax
jne 12be <func0+0x6e>
cmp %r12d,0xc(%rsp)
sete %r8b
jmp 12be <func0+0x6e>
callq 1070 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
mov r12d, esi
push rbp
mov ebp, edi
push rbx
mov ebx, edx
sub rsp, 40h
mov rax, fs:28h
mov [rsp+58h+var_20], rax
xor eax, eax
lea eax, [rdx-76Ch]
mov [rsp+58h+var_4C], esi
mov [rsp+58h+var_44], eax
lea eax, [rdi-1]
mov rdi, rsp
mov [rsp+58h+var_48], eax
mov [rsp+58h+var_58], 0
mov [rsp+58h+var_50], 0
mov [rsp+58h+var_38], 0FFFFFFFFh
call _mktime
xor r8d, r8d
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_12BE
mov eax, [rsp+58h+var_44]
add eax, 76Ch
cmp eax, ebx
jz short loc_12E0
loc_12BE:
mov rax, [rsp+58h+var_20]
sub rax, fs:28h
jnz short loc_12F6
add rsp, 40h
mov eax, r8d
pop rbx
pop rbp
pop r12
retn
loc_12E0:
mov eax, [rsp+58h+var_48]
add eax, 1
cmp eax, ebp
jnz short loc_12BE
cmp [rsp+58h+var_4C], r12d
setz r8b
jmp short loc_12BE
loc_12F6:
call ___stack_chk_fail | long long func0(int a1, int a2, int a3)
{
long long v4; // rax
unsigned int v5; // r8d
long long v7; // [rsp+0h] [rbp-58h] BYREF
int v8; // [rsp+8h] [rbp-50h]
int v9; // [rsp+Ch] [rbp-4Ch]
int v10; // [rsp+10h] [rbp-48h]
int v11; // [rsp+14h] [rbp-44h]
int v12; // [rsp+20h] [rbp-38h]
unsigned long long v13; // [rsp+38h] [rbp-20h]
v13 = __readfsqword(0x28u);
v9 = a2;
v11 = a3 - 1900;
v10 = a1 - 1;
v7 = 0LL;
v8 = 0;
v12 = -1;
v4 = mktime(&v7);
v5 = 0;
if ( v4 != -1 && v11 + 1900 == a3 && v10 + 1 == a1 )
LOBYTE(v5) = v9 == a2;
return v5;
} | func0:
ENDBR64
PUSH R12
MOV R12D,ESI
PUSH RBP
MOV EBP,EDI
PUSH RBX
MOV EBX,EDX
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA EAX,[RDX + -0x76c]
MOV dword ptr [RSP + 0xc],ESI
MOV dword ptr [RSP + 0x14],EAX
LEA EAX,[RDI + -0x1]
MOV RDI,RSP
MOV dword ptr [RSP + 0x10],EAX
MOV qword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
MOV dword ptr [RSP + 0x20],0xffffffff
CALL 0x00101090
XOR R8D,R8D
CMP RAX,-0x1
JZ 0x001012be
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x76c
CMP EAX,EBX
JZ 0x001012e0
LAB_001012be:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012f6
ADD RSP,0x40
MOV EAX,R8D
POP RBX
POP RBP
POP R12
RET
LAB_001012e0:
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,0x1
CMP EAX,EBP
JNZ 0x001012be
CMP dword ptr [RSP + 0xc],R12D
SETZ R8B
JMP 0x001012be
LAB_001012f6:
CALL 0x00101070 | bool func0(int param_1,int param_2,int param_3)
{
time_t tVar1;
long in_FS_OFFSET;
bool bVar2;
tm local_58;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_58.tm_year = param_3 + -0x76c;
local_58.tm_mon = param_1 + -1;
local_58.tm_sec = 0;
local_58.tm_min = 0;
local_58.tm_hour = 0;
local_58.tm_isdst = -1;
local_58.tm_mday = param_2;
tVar1 = mktime(&local_58);
bVar2 = false;
if (((tVar1 != -1) && (local_58.tm_year + 0x76c == param_3)) && (local_58.tm_mon + 1 == param_1))
{
bVar2 = local_58.tm_mday == param_2;
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,535 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <time.h>
| bool func0(int m, int d, int y) {
struct tm time;
time.tm_year = y - 1900; // Year since 1900
time.tm_mon = m - 1; // Month since January, [0, 11]
time.tm_mday = d; // Day of the month, [1, 31]
time.tm_hour = 0;
time.tm_min = 0;
time.tm_sec = 0;
time.tm_isdst = -1; // Not using Daylight Saving Time
if (mktime(&time) == -1) {
return false;
} else {
// Check for the values after mktime adjustment
if (time.tm_year + 1900 != y || time.tm_mon + 1 != m || time.tm_mday != d) {
return false;
}
return true;
}
}
| int main() {
assert(func0(11,11,2002) == true);
assert(func0(13,11,2002) == false);
assert(func0(11,11,2002) == true);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %esi,%r12d
push %rbp
mov %edi,%ebp
push %rbx
mov %edx,%ebx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea -0x76c(%rdx),%eax
mov %esi,0xc(%rsp)
mov %eax,0x14(%rsp)
lea -0x1(%rdi),%eax
mov %rsp,%rdi
mov %eax,0x10(%rsp)
movq $0x0,(%rsp)
movl $0x0,0x8(%rsp)
movl $0xffffffff,0x20(%rsp)
callq 1090 <mktime@plt>
xor %r8d,%r8d
cmp $0xffffffffffffffff,%rax
je 12be <func0+0x6e>
mov 0x14(%rsp),%eax
add $0x76c,%eax
cmp %ebx,%eax
je 12e0 <func0+0x90>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 12f6 <func0+0xa6>
add $0x40,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
mov 0x10(%rsp),%eax
add $0x1,%eax
cmp %ebp,%eax
jne 12be <func0+0x6e>
cmp %r12d,0xc(%rsp)
sete %r8b
jmp 12be <func0+0x6e>
callq 1070 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
mov r12d, esi
push rbp
mov ebp, edi
push rbx
mov ebx, edx
sub rsp, 40h
mov rax, fs:28h
mov [rsp+58h+var_20], rax
xor eax, eax
lea eax, [rdx-76Ch]
mov [rsp+58h+var_4C], esi
mov [rsp+58h+var_44], eax
lea eax, [rdi-1]
mov rdi, rsp; tp
mov [rsp+58h+var_48], eax
mov [rsp+58h+var_50], 0
mov [rsp+58h+var_58], 0
mov [rsp+58h+var_38], 0FFFFFFFFh
call _mktime
xor edx, edx
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_12BD
mov eax, [rsp+58h+var_44]
add eax, 76Ch
cmp eax, ebx
jz short loc_12E0
loc_12BD:
mov rax, [rsp+58h+var_20]
sub rax, fs:28h
jnz short loc_12F5
add rsp, 40h
mov eax, edx
pop rbx
pop rbp
pop r12
retn
loc_12E0:
mov eax, [rsp+58h+var_48]
add eax, 1
cmp eax, ebp
jnz short loc_12BD
cmp [rsp+58h+var_4C], r12d
setz dl
jmp short loc_12BD
loc_12F5:
call ___stack_chk_fail | long long func0(int a1, int a2, int a3)
{
time_t v4; // rax
unsigned int v5; // edx
struct tm v7; // [rsp+0h] [rbp-58h] BYREF
unsigned long long v8; // [rsp+38h] [rbp-20h]
v8 = __readfsqword(0x28u);
v7.tm_mday = a2;
v7.tm_year = a3 - 1900;
v7.tm_mon = a1 - 1;
v7.tm_hour = 0;
*(_QWORD *)&v7.tm_sec = 0LL;
v7.tm_isdst = -1;
v4 = mktime(&v7);
v5 = 0;
if ( v4 != -1 && v7.tm_year + 1900 == a3 && v7.tm_mon + 1 == a1 )
LOBYTE(v5) = v7.tm_mday == a2;
return v5;
} | func0:
ENDBR64
PUSH R12
MOV R12D,ESI
PUSH RBP
MOV EBP,EDI
PUSH RBX
MOV EBX,EDX
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA EAX,[RDX + -0x76c]
MOV dword ptr [RSP + 0xc],ESI
MOV dword ptr [RSP + 0x14],EAX
LEA EAX,[RDI + -0x1]
MOV RDI,RSP
MOV dword ptr [RSP + 0x10],EAX
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP],0x0
MOV dword ptr [RSP + 0x20],0xffffffff
CALL 0x00101090
XOR EDX,EDX
CMP RAX,-0x1
JZ 0x001012bd
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x76c
CMP EAX,EBX
JZ 0x001012e0
LAB_001012bd:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012f5
ADD RSP,0x40
MOV EAX,EDX
POP RBX
POP RBP
POP R12
RET
LAB_001012e0:
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,0x1
CMP EAX,EBP
JNZ 0x001012bd
CMP dword ptr [RSP + 0xc],R12D
SETZ DL
JMP 0x001012bd
LAB_001012f5:
CALL 0x00101070 | bool func0(int param_1,int param_2,int param_3)
{
time_t tVar1;
long in_FS_OFFSET;
bool bVar2;
tm local_58;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_58.tm_year = param_3 + -0x76c;
local_58.tm_mon = param_1 + -1;
local_58.tm_hour = 0;
local_58.tm_sec = 0;
local_58.tm_min = 0;
local_58.tm_isdst = -1;
local_58.tm_mday = param_2;
tVar1 = mktime(&local_58);
bVar2 = false;
if (((tVar1 != -1) && (local_58.tm_year + 0x76c == param_3)) && (local_58.tm_mon + 1 == param_1))
{
bVar2 = local_58.tm_mday == param_2;
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,536 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int i, j, temp;
if (size < 3) { return -1; }
// Sorting nums array descending
for (i = 0; i < size - 1; i++) {
for (j = i + 1; j < size; j++) {
if (nums[i] < nums[j]) {
temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
}
int highest = nums[0];
int second_highest = nums[1];
int third_highest = nums[2];
int lowest = nums[size - 1];
int second_lowest = nums[size - 2];
int product1 = highest * second_highest * third_highest;
int product2 = highest * lowest * second_lowest;
return (product1 > product2) ? product1 : product2;
}
| int main() {
int arr1[] = {12, 74, 9, 50, 61, 41};
int size1 = sizeof(arr1) / sizeof(arr1[0]);
assert(func0(arr1, size1) == 225700);
int arr2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int size2 = sizeof(arr2) / sizeof(arr2[0]);
assert(func0(arr2, size2) == 414375);
int arr3[] = {18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1};
int size3 = sizeof(arr3) / sizeof(arr3[0]);
assert(func0(arr3, size3) == 2520);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
cmpl $0x2,-0x3c(%rbp)
jg 1188 <func0+0x1f>
mov $0xffffffff,%eax
jmpq 12cd <func0+0x164>
movl $0x0,-0x28(%rbp)
jmpq 1245 <func0+0xdc>
mov -0x28(%rbp),%eax
add $0x1,%eax
mov %eax,-0x24(%rbp)
jmpq 1235 <func0+0xcc>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 1231 <func0+0xc8>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov -0x28(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x38(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 11a2 <func0+0x39>
addl $0x1,-0x28(%rbp)
mov -0x3c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x28(%rbp)
jl 1194 <func0+0x2b>
mov -0x38(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x20(%rbp)
mov -0x38(%rbp),%rax
mov 0x4(%rax),%eax
mov %eax,-0x1c(%rbp)
mov -0x38(%rbp),%rax
mov 0x8(%rax),%eax
mov %eax,-0x18(%rbp)
mov -0x3c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x14(%rbp)
mov -0x3c(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x8(%rax),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
mov -0x20(%rbp),%eax
imul -0x1c(%rbp),%eax
mov -0x18(%rbp),%edx
imul %edx,%eax
mov %eax,-0xc(%rbp)
mov -0x20(%rbp),%eax
imul -0x14(%rbp),%eax
mov -0x10(%rbp),%edx
imul %edx,%eax
mov %eax,-0x8(%rbp)
mov -0xc(%rbp),%eax
cmp %eax,-0x8(%rbp)
cmovge -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
cmp [rbp+var_3C], 2
jg short loc_1188
mov eax, 0FFFFFFFFh
jmp loc_12CE
loc_1188:
mov [rbp+var_28], 0
jmp loc_1245
loc_1194:
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_24], eax
jmp loc_1235
loc_11A2:
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_24]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_1231
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rbp+var_28]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_38]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
loc_1231:
add [rbp+var_24], 1
loc_1235:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_3C]
jl loc_11A2
add [rbp+var_28], 1
loc_1245:
mov eax, [rbp+var_3C]
sub eax, 1
cmp [rbp+var_28], eax
jl loc_1194
mov rax, [rbp+var_38]
mov eax, [rax]
mov [rbp+var_20], eax
mov rax, [rbp+var_38]
mov eax, [rax+4]
mov [rbp+var_1C], eax
mov rax, [rbp+var_38]
mov eax, [rax+8]
mov [rbp+var_18], eax
mov eax, [rbp+var_3C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
mov [rbp+var_14], eax
mov eax, [rbp+var_3C]
cdqe
shl rax, 2
lea rdx, [rax-8]
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
mov [rbp+var_10], eax
mov eax, [rbp+var_20]
imul eax, [rbp+var_1C]
mov edx, [rbp+var_18]
imul eax, edx
mov [rbp+var_C], eax
mov eax, [rbp+var_20]
imul eax, [rbp+var_14]
mov edx, [rbp+var_10]
imul eax, edx
mov [rbp+var_8], eax
mov edx, [rbp+var_8]
mov eax, [rbp+var_C]
cmp edx, eax
cmovge eax, edx
loc_12CE:
pop rbp
retn | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
int v3; // edx
int i; // [rsp+14h] [rbp-28h]
int j; // [rsp+18h] [rbp-24h]
int v6; // [rsp+38h] [rbp-4h]
if ( a2 <= 2 )
return 0xFFFFFFFFLL;
for ( i = 0; i < a2 - 1; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( a1[i] < a1[j] )
{
v6 = a1[i];
a1[i] = a1[j];
a1[j] = v6;
}
}
}
v3 = a1[a2 - 2] * a1[a2 - 1] * *a1;
result = (unsigned int)(a1[2] * a1[1] * *a1);
if ( v3 >= (int)result )
return (unsigned int)v3;
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
CMP dword ptr [RBP + -0x3c],0x2
JG 0x00101188
MOV EAX,0xffffffff
JMP 0x001012ce
LAB_00101188:
MOV dword ptr [RBP + -0x28],0x0
JMP 0x00101245
LAB_00101194:
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00101235
LAB_001011a2:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x00101231
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x28]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
LAB_00101231:
ADD dword ptr [RBP + -0x24],0x1
LAB_00101235:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x001011a2
ADD dword ptr [RBP + -0x28],0x1
LAB_00101245:
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x28],EAX
JL 0x00101194
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x20]
IMUL EAX,dword ptr [RBP + -0x1c]
MOV EDX,dword ptr [RBP + -0x18]
IMUL EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x20]
IMUL EAX,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x10]
IMUL EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,dword ptr [RBP + -0xc]
CMP EDX,EAX
CMOVGE EAX,EDX
LAB_001012ce:
POP RBP
RET | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int local_30;
int local_2c;
if (param_2 < 3) {
iVar1 = -1;
}
else {
for (local_30 = 0; local_2c = local_30, local_30 < param_2 + -1; local_30 = local_30 + 1) {
while (local_2c = local_2c + 1, local_2c < param_2) {
if (param_1[local_30] < param_1[local_2c]) {
iVar1 = param_1[local_30];
param_1[local_30] = param_1[local_2c];
param_1[local_2c] = iVar1;
}
}
}
iVar1 = *param_1 * param_1[1] * param_1[2];
iVar2 = *param_1 * param_1[(long)param_2 + -1] * param_1[(long)param_2 + -2];
if (iVar1 <= iVar2) {
iVar1 = iVar2;
}
}
return iVar1;
} |
7,537 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int i, j, temp;
if (size < 3) { return -1; }
// Sorting nums array descending
for (i = 0; i < size - 1; i++) {
for (j = i + 1; j < size; j++) {
if (nums[i] < nums[j]) {
temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
}
int highest = nums[0];
int second_highest = nums[1];
int third_highest = nums[2];
int lowest = nums[size - 1];
int second_lowest = nums[size - 2];
int product1 = highest * second_highest * third_highest;
int product2 = highest * lowest * second_lowest;
return (product1 > product2) ? product1 : product2;
}
| int main() {
int arr1[] = {12, 74, 9, 50, 61, 41};
int size1 = sizeof(arr1) / sizeof(arr1[0]);
assert(func0(arr1, size1) == 225700);
int arr2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int size2 = sizeof(arr2) / sizeof(arr2[0]);
assert(func0(arr2, size2) == 414375);
int arr3[] = {18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1};
int size3 = sizeof(arr3) / sizeof(arr3[0]);
assert(func0(arr3, size3) == 2520);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x2,%esi
jle 11d5 <func0+0x6c>
mov %rdi,%r8
lea -0x2(%rsi),%r10d
add $0x2,%r10
mov $0x1,%r9d
jmp 11ac <func0+0x43>
add $0x1,%rax
cmp %eax,%esi
jle 119f <func0+0x36>
mov (%r8),%edx
mov (%rdi,%rax,4),%ecx
cmp %ecx,%edx
jge 1185 <func0+0x1c>
mov %ecx,(%r8)
mov %edx,(%rdi,%rax,4)
jmp 1185 <func0+0x1c>
add $0x1,%r9
add $0x4,%r8
cmp %r10,%r9
je 11b6 <func0+0x4d>
cmp %r9d,%esi
jle 119f <func0+0x36>
mov %r9,%rax
jmp 118d <func0+0x24>
mov (%rdi),%eax
movslq %esi,%rsi
mov %eax,%edx
imul -0x4(%rdi,%rsi,4),%edx
imul -0x8(%rdi,%rsi,4),%edx
imul 0x4(%rdi),%eax
imul 0x8(%rdi),%eax
cmp %eax,%edx
cmovge %edx,%eax
retq
mov $0xffffffff,%eax
retq
| func0:
endbr64
cmp esi, 2
jle short loc_11F1
push rbp
push rbx
mov r10, rdi
lea rdi, [rdi+4]
mov r11d, esi
mov r9d, 1
lea ebp, [rsi-1]
lea rbx, [r10+8]
jmp short loc_11B3
loc_118D:
add rax, 4
cmp rax, r8
jz short loc_11A6
loc_1196:
mov edx, [rdi-4]
mov ecx, [rax]
cmp edx, ecx
jge short loc_118D
mov [rdi-4], ecx
mov [rax], edx
jmp short loc_118D
loc_11A6:
add r9, 1
add rdi, 4
cmp r9, r11
jz short loc_11CB
loc_11B3:
cmp esi, r9d
jle short loc_11A6
mov eax, ebp
sub eax, r9d
lea rax, [r9+rax-1]
lea r8, [rbx+rax*4]
mov rax, rdi
jmp short loc_1196
loc_11CB:
mov eax, [r10]
movsxd rsi, esi
mov edx, eax
imul edx, [r10+rsi*4-4]
imul edx, [r10+rsi*4-8]
imul eax, [r10+4]
imul eax, [r10+8]
cmp edx, eax
cmovge eax, edx
pop rbx
pop rbp
retn
loc_11F1:
mov eax, 0FFFFFFFFh
retn | long long func0(_DWORD *a1, int a2)
{
_DWORD *v3; // rdi
long long i; // r9
_DWORD *v5; // rax
int v6; // edx
int v7; // edx
long long result; // rax
if ( a2 <= 2 )
return 0xFFFFFFFFLL;
v3 = a1 + 1;
for ( i = 1LL; i != a2; ++i )
{
if ( a2 > (int)i )
{
v5 = v3;
do
{
v6 = *(v3 - 1);
if ( v6 < *v5 )
{
*(v3 - 1) = *v5;
*v5 = v6;
}
++v5;
}
while ( v5 != &a1[i + 1 + (unsigned int)(a2 - 1 - i)] );
}
++v3;
}
v7 = a1[a2 - 2] * a1[a2 - 1] * *a1;
result = (unsigned int)(a1[2] * a1[1] * *a1);
if ( v7 >= (int)result )
return (unsigned int)v7;
return result;
} | func0:
ENDBR64
CMP ESI,0x2
JLE 0x001011f1
PUSH RBP
PUSH RBX
MOV R10,RDI
LEA RDI,[RDI + 0x4]
MOV R11D,ESI
MOV R9D,0x1
LEA EBP,[RSI + -0x1]
LEA RBX,[R10 + 0x8]
JMP 0x001011b3
LAB_0010118d:
ADD RAX,0x4
CMP RAX,R8
JZ 0x001011a6
LAB_00101196:
MOV EDX,dword ptr [RDI + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JGE 0x0010118d
MOV dword ptr [RDI + -0x4],ECX
MOV dword ptr [RAX],EDX
JMP 0x0010118d
LAB_001011a6:
ADD R9,0x1
ADD RDI,0x4
CMP R9,R11
JZ 0x001011cb
LAB_001011b3:
CMP ESI,R9D
JLE 0x001011a6
MOV EAX,EBP
SUB EAX,R9D
LEA RAX,[R9 + RAX*0x1 + -0x1]
LEA R8,[RBX + RAX*0x4]
MOV RAX,RDI
JMP 0x00101196
LAB_001011cb:
MOV EAX,dword ptr [R10]
MOVSXD RSI,ESI
MOV EDX,EAX
IMUL EDX,dword ptr [R10 + RSI*0x4 + -0x4]
IMUL EDX,dword ptr [R10 + RSI*0x4 + -0x8]
IMUL EAX,dword ptr [R10 + 0x4]
IMUL EAX,dword ptr [R10 + 0x8]
CMP EDX,EAX
CMOVGE EAX,EDX
POP RBX
POP RBP
RET
LAB_001011f1:
MOV EAX,0xffffffff
RET | int func0(int *param_1,uint param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int *piVar4;
ulong uVar5;
if (2 < (int)param_2) {
piVar4 = param_1 + 1;
uVar5 = 1;
do {
if ((int)uVar5 < (int)param_2) {
piVar2 = piVar4;
do {
iVar1 = piVar4[-1];
if (iVar1 < *piVar2) {
piVar4[-1] = *piVar2;
*piVar2 = iVar1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + uVar5 + ((param_2 - 1) - (int)uVar5) + 1);
}
uVar5 = uVar5 + 1;
piVar4 = piVar4 + 1;
} while (uVar5 != param_2);
iVar3 = *param_1 * param_1[(long)(int)param_2 + -1] * param_1[(long)(int)param_2 + -2];
iVar1 = *param_1 * param_1[1] * param_1[2];
if (iVar1 <= iVar3) {
iVar1 = iVar3;
}
return iVar1;
}
return -1;
} |
7,538 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int i, j, temp;
if (size < 3) { return -1; }
// Sorting nums array descending
for (i = 0; i < size - 1; i++) {
for (j = i + 1; j < size; j++) {
if (nums[i] < nums[j]) {
temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
}
int highest = nums[0];
int second_highest = nums[1];
int third_highest = nums[2];
int lowest = nums[size - 1];
int second_lowest = nums[size - 2];
int product1 = highest * second_highest * third_highest;
int product2 = highest * lowest * second_lowest;
return (product1 > product2) ? product1 : product2;
}
| int main() {
int arr1[] = {12, 74, 9, 50, 61, 41};
int size1 = sizeof(arr1) / sizeof(arr1[0]);
assert(func0(arr1, size1) == 225700);
int arr2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int size2 = sizeof(arr2) / sizeof(arr2[0]);
assert(func0(arr2, size2) == 414375);
int arr3[] = {18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1};
int size3 = sizeof(arr3) / sizeof(arr3[0]);
assert(func0(arr3, size3) == 2520);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x2,%esi
jle 13a0 <func0+0x10>
jmp 1320 <func0.part.0>
nopl 0x0(%rax,%rax,1)
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0_part_0:
push rbp
lea r11d, [rsi-1]
xor r10d, r10d
xor r9d, r9d
push rbx
mov rbx, rdi
lea rdi, [rdi+4]
lea rbp, [rbx+8]
nop word ptr [rax+rax+00000000h]
loc_1340:
add r9d, 1
cmp r9d, esi
jge short loc_1377
mov eax, r11d
sub eax, r9d
add rax, r10
lea r8, [rbp+rax*4+0]
mov rax, rdi
nop word ptr [rax+rax+00h]
loc_1360:
mov edx, [rdi-4]
mov ecx, [rax]
cmp edx, ecx
jge short loc_136E
mov [rdi-4], ecx
mov [rax], edx
loc_136E:
add rax, 4
cmp r8, rax
jnz short loc_1360
loc_1377:
add r10, 1
add rdi, 4
cmp r9d, r11d
jl short loc_1340
movsxd rsi, esi
mov eax, [rbx]
mov edx, [rbx+rsi*4-4]
imul edx, eax
imul eax, [rbx+4]
imul edx, [rbx+rsi*4-8]
imul eax, [rbx+8]
pop rbx
pop rbp
cmp edx, eax
cmovge eax, edx
retn | long long func0_part_0(_DWORD *a1, int a2)
{
int v2; // r11d
long long v3; // r10
int v4; // r9d
_DWORD *v6; // rdi
_DWORD *v7; // rax
int v8; // edx
int v9; // edx
long long result; // rax
v2 = a2 - 1;
v3 = 0LL;
v4 = 0;
v6 = a1 + 1;
do
{
if ( ++v4 < a2 )
{
v7 = v6;
do
{
v8 = *(v6 - 1);
if ( v8 < *v7 )
{
*(v6 - 1) = *v7;
*v7 = v8;
}
++v7;
}
while ( &a1[v3 + 2 + (unsigned int)(v2 - v4)] != v7 );
}
++v3;
++v6;
}
while ( v4 < v2 );
v9 = a1[a2 - 2] * *a1 * a1[a2 - 1];
result = (unsigned int)(a1[2] * a1[1] * *a1);
if ( v9 >= (int)result )
return (unsigned int)v9;
return result;
} | func0.part.0:
PUSH RBP
LEA R11D,[RSI + -0x1]
XOR R10D,R10D
XOR R9D,R9D
PUSH RBX
MOV RBX,RDI
LEA RDI,[RDI + 0x4]
LEA RBP,[RBX + 0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_00101340:
ADD R9D,0x1
CMP R9D,ESI
JGE 0x00101377
MOV EAX,R11D
SUB EAX,R9D
ADD RAX,R10
LEA R8,[RBP + RAX*0x4]
MOV RAX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101360:
MOV EDX,dword ptr [RDI + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JGE 0x0010136e
MOV dword ptr [RDI + -0x4],ECX
MOV dword ptr [RAX],EDX
LAB_0010136e:
ADD RAX,0x4
CMP R8,RAX
JNZ 0x00101360
LAB_00101377:
ADD R10,0x1
ADD RDI,0x4
CMP R9D,R11D
JL 0x00101340
MOVSXD RSI,ESI
MOV EAX,dword ptr [RBX]
MOV EDX,dword ptr [RBX + RSI*0x4 + -0x4]
IMUL EDX,EAX
IMUL EAX,dword ptr [RBX + 0x4]
IMUL EDX,dword ptr [RBX + RSI*0x4 + -0x8]
IMUL EAX,dword ptr [RBX + 0x8]
POP RBX
POP RBP
CMP EDX,EAX
CMOVGE EAX,EDX
RET | int func0_part_0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int iVar4;
long lVar5;
lVar5 = 0;
iVar4 = 0;
piVar3 = param_1 + 1;
do {
iVar4 = iVar4 + 1;
if (iVar4 < param_2) {
piVar1 = piVar3;
do {
iVar2 = piVar3[-1];
if (iVar2 < *piVar1) {
piVar3[-1] = *piVar1;
*piVar1 = iVar2;
}
piVar1 = piVar1 + 1;
} while (param_1 + (ulong)(uint)((param_2 + -1) - iVar4) + lVar5 + 2 != piVar1);
}
lVar5 = lVar5 + 1;
piVar3 = piVar3 + 1;
} while (iVar4 < param_2 + -1);
iVar2 = param_1[(long)param_2 + -1] * *param_1 * param_1[(long)param_2 + -2];
iVar4 = *param_1 * param_1[1] * param_1[2];
if (iVar4 <= iVar2) {
iVar4 = iVar2;
}
return iVar4;
} |
7,539 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int nums[], int size) {
int i, j, temp;
if (size < 3) { return -1; }
// Sorting nums array descending
for (i = 0; i < size - 1; i++) {
for (j = i + 1; j < size; j++) {
if (nums[i] < nums[j]) {
temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
}
int highest = nums[0];
int second_highest = nums[1];
int third_highest = nums[2];
int lowest = nums[size - 1];
int second_lowest = nums[size - 2];
int product1 = highest * second_highest * third_highest;
int product2 = highest * lowest * second_lowest;
return (product1 > product2) ? product1 : product2;
}
| int main() {
int arr1[] = {12, 74, 9, 50, 61, 41};
int size1 = sizeof(arr1) / sizeof(arr1[0]);
assert(func0(arr1, size1) == 225700);
int arr2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int size2 = sizeof(arr2) / sizeof(arr2[0]);
assert(func0(arr2, size2) == 414375);
int arr3[] = {18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1};
int size3 = sizeof(arr3) / sizeof(arr3[0]);
assert(func0(arr3, size3) == 2520);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x2,%esi
jle 13b4 <func0+0x74>
lea -0x2(%rsi),%r10d
mov %rdi,%r8
mov $0x1,%r9d
add $0x2,%r10
nopw 0x0(%rax,%rax,1)
cmp %r9d,%esi
jle 1388 <func0+0x48>
mov %r9,%rax
nopl 0x0(%rax,%rax,1)
mov (%r8),%edx
mov (%rdi,%rax,4),%ecx
cmp %ecx,%edx
jge 1380 <func0+0x40>
mov %ecx,(%r8)
mov %edx,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%esi
jg 1370 <func0+0x30>
add $0x1,%r9
add $0x4,%r8
cmp %r9,%r10
jne 1360 <func0+0x20>
movslq %esi,%rsi
mov (%rdi),%eax
mov -0x4(%rdi,%rsi,4),%edx
imul %eax,%edx
imul 0x4(%rdi),%eax
imul -0x8(%rdi,%rsi,4),%edx
imul 0x8(%rdi),%eax
cmp %eax,%edx
cmovge %edx,%eax
retq
mov $0xffffffff,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0_part_0:
push rbp
mov r10, rdi
push rbx
cmp esi, 1
jle short loc_1324
lea rdi, [rdi+4]
mov r11d, esi
lea ebp, [rsi-1]
mov r9d, 1
lea rbx, [r10+8]
xchg ax, ax
loc_12E0:
cmp esi, r9d
jle short loc_1317
mov eax, ebp
sub eax, r9d
lea rax, [r9+rax-1]
lea r8, [rbx+rax*4]
mov rax, rdi
nop word ptr [rax+rax+00000000h]
loc_1300:
mov edx, [rdi-4]
mov ecx, [rax]
cmp edx, ecx
jge short loc_130E
mov [rdi-4], ecx
mov [rax], edx
loc_130E:
add rax, 4
cmp r8, rax
jnz short loc_1300
loc_1317:
add r9, 1
add rdi, 4
cmp r11, r9
jnz short loc_12E0
loc_1324:
movsxd rsi, esi
mov eax, [r10]
pop rbx
mov edx, [r10+rsi*4-4]
pop rbp
imul edx, eax
imul eax, [r10+4]
imul edx, [r10+rsi*4-8]
imul eax, [r10+8]
cmp edx, eax
cmovge eax, edx
retn | long long func0_part_0(_DWORD *a1, int a2)
{
_DWORD *v3; // rdi
long long i; // r9
_DWORD *v5; // rax
int v6; // edx
int v7; // edx
long long result; // rax
if ( a2 > 1 )
{
v3 = a1 + 1;
for ( i = 1LL; i != a2; ++i )
{
if ( a2 > (int)i )
{
v5 = v3;
do
{
v6 = *(v3 - 1);
if ( v6 < *v5 )
{
*(v3 - 1) = *v5;
*v5 = v6;
}
++v5;
}
while ( &a1[i + 1 + (unsigned int)(a2 - 1 - i)] != v5 );
}
++v3;
}
}
v7 = a1[a2 - 2] * *a1 * a1[a2 - 1];
result = (unsigned int)(a1[2] * a1[1] * *a1);
if ( v7 >= (int)result )
return (unsigned int)v7;
return result;
} | func0.part.0:
PUSH RBP
MOV R10,RDI
PUSH RBX
CMP ESI,0x1
JLE 0x00101324
LEA RDI,[RDI + 0x4]
MOV R11D,ESI
LEA EBP,[RSI + -0x1]
MOV R9D,0x1
LEA RBX,[R10 + 0x8]
NOP
LAB_001012e0:
CMP ESI,R9D
JLE 0x00101317
MOV EAX,EBP
SUB EAX,R9D
LEA RAX,[R9 + RAX*0x1 + -0x1]
LEA R8,[RBX + RAX*0x4]
MOV RAX,RDI
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101300:
MOV EDX,dword ptr [RDI + -0x4]
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
JGE 0x0010130e
MOV dword ptr [RDI + -0x4],ECX
MOV dword ptr [RAX],EDX
LAB_0010130e:
ADD RAX,0x4
CMP R8,RAX
JNZ 0x00101300
LAB_00101317:
ADD R9,0x1
ADD RDI,0x4
CMP R11,R9
JNZ 0x001012e0
LAB_00101324:
MOVSXD RSI,ESI
MOV EAX,dword ptr [R10]
POP RBX
MOV EDX,dword ptr [R10 + RSI*0x4 + -0x4]
POP RBP
IMUL EDX,EAX
IMUL EAX,dword ptr [R10 + 0x4]
IMUL EDX,dword ptr [R10 + RSI*0x4 + -0x8]
IMUL EAX,dword ptr [R10 + 0x8]
CMP EDX,EAX
CMOVGE EAX,EDX
RET | int func0_part_0(int *param_1,uint param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int *piVar4;
ulong uVar5;
if (1 < (int)param_2) {
piVar4 = param_1 + 1;
uVar5 = 1;
do {
if ((int)uVar5 < (int)param_2) {
piVar2 = piVar4;
do {
iVar1 = piVar4[-1];
if (iVar1 < *piVar2) {
piVar4[-1] = *piVar2;
*piVar2 = iVar1;
}
piVar2 = piVar2 + 1;
} while (param_1 + uVar5 + ((param_2 - 1) - (int)uVar5) + 1 != piVar2);
}
uVar5 = uVar5 + 1;
piVar4 = piVar4 + 1;
} while (param_2 != uVar5);
}
iVar3 = param_1[(long)(int)param_2 + -1] * *param_1 * param_1[(long)(int)param_2 + -2];
iVar1 = *param_1 * param_1[1] * param_1[2];
if (iVar1 <= iVar3) {
iVar1 = iVar3;
}
return iVar1;
} |
7,540 | func0 |
#include <stdio.h>
#include <assert.h>
int binomial_coeff(int n, int k) {
int C[n + 1][k + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= (i < k ? i : k); j++) {
if (j == 0 || j == i) {
C[i][j] = 1;
} else {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
}
return C[n][k];
}
| int func0(int n, int m) {
int numerator = (2 * m + 1) * binomial_coeff(2 * n, m + n);
int denominator = m + n + 1;
return numerator / denominator;
}
| int main() {
assert(func0(5, 3) == 35);
assert(func0(3, 2) == 5);
assert(func0(4, 2) == 20);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %edi,-0x24(%rbp)
mov %esi,-0x28(%rbp)
mov -0x28(%rbp),%eax
add %eax,%eax
lea 0x1(%rax),%ebx
mov -0x28(%rbp),%edx
mov -0x24(%rbp),%eax
add %eax,%edx
mov -0x24(%rbp),%eax
add %eax,%eax
mov %edx,%esi
mov %eax,%edi
callq 1169 <binomial_coeff>
imul %ebx,%eax
mov %eax,-0x18(%rbp)
mov -0x28(%rbp),%edx
mov -0x24(%rbp),%eax
add %edx,%eax
add $0x1,%eax
mov %eax,-0x14(%rbp)
mov -0x18(%rbp),%eax
cltd
idivl -0x14(%rbp)
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_24], edi
mov [rbp+var_28], esi
mov eax, [rbp+var_28]
add eax, eax
lea ebx, [rax+1]
mov edx, [rbp+var_28]
mov eax, [rbp+var_24]
add edx, eax
mov eax, [rbp+var_24]
add eax, eax
mov esi, edx
mov edi, eax
call binomial_coeff
imul eax, ebx
mov [rbp+var_18], eax
mov edx, [rbp+var_28]
mov eax, [rbp+var_24]
add eax, edx
add eax, 1
mov [rbp+var_14], eax
mov eax, [rbp+var_18]
cdq
idiv [rbp+var_14]
mov rbx, [rbp+var_8]
leave
retn | long long func0(int a1, int a2)
{
return (unsigned int)((int)((2 * a2 + 1) * binomial_coeff((unsigned int)(2 * a1), (unsigned int)(a1 + a2)))
/ (a2 + a1 + 1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x28],ESI
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,EAX
LEA EBX,[RAX + 0x1]
MOV EDX,dword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x24]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,EAX
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101169
IMUL EAX,EBX
MOV dword ptr [RBP + -0x18],EAX
MOV EDX,dword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,EDX
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x18]
CDQ
IDIV dword ptr [RBP + -0x14]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int [16] func0(int param_1,int param_2)
{
long lVar1;
long lVar2;
int iVar3;
int auVar4 [16];
iVar3 = binomial_coeff(param_1 * 2,param_2 + param_1);
lVar1 = (long)(param_1 + param_2 + 1);
lVar2 = (long)(iVar3 * (param_2 * 2 + 1));
auVar4._0_8_ = lVar2 / lVar1 & 0xffffffff;
auVar4._8_8_ = lVar2 % lVar1 & 0xffffffff;
return auVar4;
} |
7,541 | func0 |
#include <stdio.h>
#include <assert.h>
int binomial_coeff(int n, int k) {
int C[n + 1][k + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= (i < k ? i : k); j++) {
if (j == 0 || j == i) {
C[i][j] = 1;
} else {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
}
return C[n][k];
}
| int func0(int n, int m) {
int numerator = (2 * m + 1) * binomial_coeff(2 * n, m + n);
int denominator = m + n + 1;
return numerator / denominator;
}
| int main() {
assert(func0(5, 3) == 35);
assert(func0(3, 2) == 5);
assert(func0(4, 2) == 20);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %esi,%ebp
lea (%rsi,%rdi,1),%ebx
add %edi,%edi
mov %ebx,%esi
callq 1169 <binomial_coeff>
mov %eax,%edx
lea 0x1(%rbp,%rbp,1),%eax
imul %edx,%eax
add $0x1,%ebx
cltd
idiv %ebx
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov ebp, esi
lea ebx, [rsi+rdi]
add edi, edi
mov esi, ebx
call binomial_coeff
mov edx, eax
lea eax, [rbp+rbp+1]
imul eax, edx
add ebx, 1
cdq
idiv ebx
add rsp, 8
pop rbx
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)((int)(binomial_coeff((unsigned int)(2 * a1), (unsigned int)(a2 + a1)) * (2 * a2 + 1))
/ (a2 + a1 + 1));
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBP,ESI
LEA EBX,[RSI + RDI*0x1]
ADD EDI,EDI
MOV ESI,EBX
CALL 0x00101169
MOV EDX,EAX
LEA EAX,[RBP + RBP*0x1 + 0x1]
IMUL EAX,EDX
ADD EBX,0x1
CDQ
IDIV EBX
ADD RSP,0x8
POP RBX
POP RBP
RET | int1 [16] func0(int param_1,int param_2)
{
long lVar1;
long lVar2;
int iVar3;
int1 auVar4 [16];
iVar3 = binomial_coeff(param_1 * 2,param_2 + param_1);
lVar1 = (long)(param_2 + param_1 + 1);
lVar2 = (long)((param_2 * 2 + 1) * iVar3);
auVar4._0_8_ = lVar2 / lVar1 & 0xffffffff;
auVar4._8_8_ = lVar2 % lVar1 & 0xffffffff;
return auVar4;
} |
7,542 | func0 |
#include <stdio.h>
#include <assert.h>
int binomial_coeff(int n, int k) {
int C[n + 1][k + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= (i < k ? i : k); j++) {
if (j == 0 || j == i) {
C[i][j] = 1;
} else {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
}
return C[n][k];
}
| int func0(int n, int m) {
int numerator = (2 * m + 1) * binomial_coeff(2 * n, m + n);
int denominator = m + n + 1;
return numerator / denominator;
}
| int main() {
assert(func0(5, 3) == 35);
assert(func0(3, 2) == 5);
assert(func0(4, 2) == 20);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
lea (%rsi,%rdi,1),%ebx
add %edi,%edi
mov %ebx,%esi
add $0x1,%ebx
sub $0x8,%rsp
callq 1240 <binomial_coeff>
add $0x8,%rsp
mov %eax,%r8d
lea 0x1(%rbp,%rbp,1),%eax
imul %r8d,%eax
cltd
idiv %ebx
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov ebp, esi
push rbx
lea ebx, [rsi+rdi]
add edi, edi
mov esi, ebx
add ebx, 1
sub rsp, 8
call binomial_coeff
add rsp, 8
mov r8d, eax
lea eax, [rbp+rbp+1]
imul eax, r8d
cdq
idiv ebx
pop rbx
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)((int)(binomial_coeff((unsigned int)(2 * a1), (unsigned int)(a2 + a1)) * (2 * a2 + 1))
/ (a2 + a1 + 1));
} | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
LEA EBX,[RSI + RDI*0x1]
ADD EDI,EDI
MOV ESI,EBX
ADD EBX,0x1
SUB RSP,0x8
CALL 0x00101240
ADD RSP,0x8
MOV R8D,EAX
LEA EAX,[RBP + RBP*0x1 + 0x1]
IMUL EAX,R8D
CDQ
IDIV EBX
POP RBX
POP RBP
RET | int1 [16] func0(int param_1,int param_2)
{
long lVar1;
long lVar2;
int iVar3;
int1 auVar4 [16];
iVar3 = binomial_coeff(param_1 * 2,param_2 + param_1);
lVar1 = (long)(param_2 + param_1 + 1);
lVar2 = (long)((param_2 * 2 + 1) * iVar3);
auVar4._0_8_ = lVar2 / lVar1 & 0xffffffff;
auVar4._8_8_ = lVar2 % lVar1 & 0xffffffff;
return auVar4;
} |
7,543 | func0 |
#include <stdio.h>
#include <assert.h>
int binomial_coeff(int n, int k) {
int C[n + 1][k + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= (i < k ? i : k); j++) {
if (j == 0 || j == i) {
C[i][j] = 1;
} else {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
}
return C[n][k];
}
| int func0(int n, int m) {
int numerator = (2 * m + 1) * binomial_coeff(2 * n, m + n);
int denominator = m + n + 1;
return numerator / denominator;
}
| int main() {
assert(func0(5, 3) == 35);
assert(func0(3, 2) == 5);
assert(func0(4, 2) == 20);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0x1(%rsi,%rsi,1),%eax
add %edi,%esi
add %edi,%edi
lea 0x1(%rsi),%r10d
lea 0x1(%rdi),%edx
mov %rsp,%rbx
movslq %r10d,%rcx
movslq %edx,%rdx
imul %rcx,%rdx
lea 0x0(,%rcx,4),%r14
lea 0xf(,%rdx,4),%rdx
mov %rdx,%rcx
and $0xfffffffffffff000,%rdx
sub %rdx,%rbx
and $0xfffffffffffffff0,%rcx
mov %rbx,%rdx
cmp %rdx,%rsp
je 13fe <func0+0x7e>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rdx,%rsp
jne 13e9 <func0+0x69>
and $0xfff,%ecx
sub %rcx,%rsp
test %rcx,%rcx
jne 14f0 <func0+0x170>
mov %r14,%r13
mov %rsp,%r15
shr $0x2,%r13
test %edi,%edi
js 14b0 <func0+0x130>
mov %r15,%r12
movslq %edi,%rdi
mov $0xffffffffffffffff,%rbx
xor %ecx,%ecx
nopl 0x0(%rax)
cmp %ecx,%esi
mov %ecx,%edx
cmovl %esi,%edx
test %edx,%edx
js 1494 <func0+0x114>
mov %rbx,%r9
add $0x1,%edx
mov %r12,%r8
sub %rcx,%r9
mov %edx,-0x44(%rbp)
xor %edx,%edx
imul %r13,%r9
jmp 1479 <func0+0xf9>
nopw 0x0(%rax,%rax,1)
mov (%r8,%r9,4),%r11d
add -0x4(%r8,%r9,4),%r11d
add $0x1,%edx
add $0x4,%r8
mov %r11d,-0x4(%r8)
cmp -0x44(%rbp),%edx
je 1494 <func0+0x114>
test %edx,%edx
je 1481 <func0+0x101>
cmp %ecx,%edx
jne 1460 <func0+0xe0>
movl $0x1,(%r8)
add $0x1,%edx
add $0x4,%r8
cmp -0x44(%rbp),%edx
jne 1479 <func0+0xf9>
lea 0x1(%rcx),%rdx
add $0x1,%rbx
add %r14,%r12
cmp %rdi,%rcx
je 14b8 <func0+0x138>
mov %rdx,%rcx
jmp 1438 <func0+0xb8>
nopl 0x0(%rax)
movslq %edi,%rdi
nopl 0x0(%rax,%rax,1)
imul %r13,%rdi
movslq %esi,%rsi
add %rsi,%rdi
imul (%r15,%rdi,4),%eax
cltd
idiv %r10d
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 14fb <func0+0x17b>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
nopl 0x0(%rax)
orq $0x0,-0x8(%rsp,%rcx,1)
jmpq 1410 <func0+0x90>
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov ebp, esi
push rbx
lea ebx, [rsi+rdi]
add edi, edi
mov esi, ebx
add ebx, 1
sub rsp, 8
call binomial_coeff
add rsp, 8
mov edx, eax
lea eax, [rbp+rbp+1]
imul eax, edx
cdq
idiv ebx
pop rbx
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)((int)(binomial_coeff((unsigned int)(2 * a1), (unsigned int)(a2 + a1)) * (2 * a2 + 1))
/ (a2 + a1 + 1));
} | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
LEA EBX,[RSI + RDI*0x1]
ADD EDI,EDI
MOV ESI,EBX
ADD EBX,0x1
SUB RSP,0x8
CALL 0x00101240
ADD RSP,0x8
MOV EDX,EAX
LEA EAX,[RBP + RBP*0x1 + 0x1]
IMUL EAX,EDX
CDQ
IDIV EBX
POP RBX
POP RBP
RET | int [16] func0(int param_1,int param_2)
{
long lVar1;
long lVar2;
int iVar3;
int auVar4 [16];
iVar3 = binomial_coeff(param_1 * 2,param_2 + param_1);
lVar1 = (long)(param_2 + param_1 + 1);
lVar2 = (long)((param_2 * 2 + 1) * iVar3);
auVar4._0_8_ = lVar2 / lVar1 & 0xffffffff;
auVar4._8_8_ = lVar2 % lVar1 & 0xffffffff;
return auVar4;
} |
7,544 | func0 |
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
#include <stdio.h>
| bool func0(const char *string) {
regex_t regex;
int result;
bool match_found;
regcomp(®ex, ".*[0-9]$", 0);
result = regexec(®ex, string, 0, NULL, 0);
match_found = (result == 0);
regfree(®ex);
return match_found;
}
| int main() {
assert(func0("abcdef") == false);
assert(func0("abcdef7") == true);
assert(func0("abc") == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x50(%rbp),%rax
mov $0x0,%edx
lea 0xe10(%rip),%rsi
mov %rax,%rdi
callq 10c0 <regcomp@plt>
mov -0x68(%rbp),%rsi
lea -0x50(%rbp),%rax
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 10d0 <regexec@plt>
mov %eax,-0x54(%rbp)
cmpl $0x0,-0x54(%rbp)
sete %al
mov %al,-0x55(%rbp)
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 1090 <regfree@plt>
movzbl -0x55(%rbp),%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1251 <func0+0x88>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+preg]
mov edx, 0; cflags
lea rcx, pattern; ".*[0-9]$"
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov rsi, [rbp+string]; 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_54], eax
cmp [rbp+var_54], 0
setz al
mov [rbp+var_55], al
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
movzx eax, [rbp+var_55]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1254
call ___stack_chk_fail
locret_1254:
leave
retn | _BOOL8 func0(const char *a1)
{
bool v2; // [rsp+1Bh] [rbp-55h]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
regcomp(&preg, ".*[0-9]$", 0);
v2 = regexec(&preg, a1, 0LL, 0LL, 0) == 0;
regfree(&preg);
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV EDX,0x0
LEA RCX,[0x102004]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010c0
MOV RSI,qword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x50]
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x54],EAX
CMP dword ptr [RBP + -0x54],0x0
SETZ AL
MOV byte ptr [RBP + -0x55],AL
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00101090
MOVZX EAX,byte ptr [RBP + -0x55]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101254
CALL 0x001010a0
LAB_00101254:
LEAVE
RET | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&local_58,".*[0-9]$",0);
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_58);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar1 == 0;
} |
7,545 | func0 |
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
#include <stdio.h>
| bool func0(const char *string) {
regex_t regex;
int result;
bool match_found;
regcomp(®ex, ".*[0-9]$", 0);
result = regexec(®ex, string, 0, NULL, 0);
match_found = (result == 0);
regfree(®ex);
return match_found;
}
| int main() {
assert(func0("abcdef") == false);
assert(func0("abcdef7") == true);
assert(func0("abc") == false);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %rdi,%rbx
mov $0x28,%r12d
mov %fs:(%r12),%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov $0x0,%edx
lea 0xe0b(%rip),%rsi
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %eax,%ebx
mov %rbp,%rdi
callq 1090 <regfree@plt>
test %ebx,%ebx
sete %al
mov 0x48(%rsp),%rcx
xor %fs:(%r12),%rcx
jne 1240 <func0+0x77>
add $0x50,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov edx, 0
lea rsi, a09; ".*[0-9]$"
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
setz al
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_123E
add rsp, 58h
pop rbx
pop rbp
retn
loc_123E:
call ___stack_chk_fail | bool func0(long long a1)
{
int v1; // ebx
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, ".*[0-9]$", 0LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
regfree(_0);
return v1 == 0;
} | ||
7,546 | func0 |
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
#include <stdio.h>
| bool func0(const char *string) {
regex_t regex;
int result;
bool match_found;
regcomp(®ex, ".*[0-9]$", 0);
result = regexec(®ex, string, 0, NULL, 0);
match_found = (result == 0);
regfree(®ex);
return match_found;
}
| int main() {
assert(func0("abcdef") == false);
assert(func0("abcdef7") == true);
assert(func0("abc") == false);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
xor %edx,%edx
mov %rdi,%r12
lea 0xd82(%rip),%rsi
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
xor %ecx,%ecx
xor %r8d,%r8d
xor %edx,%edx
mov %r12,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %rbp,%rdi
mov %eax,%ebx
callq 1090 <regfree@plt>
test %ebx,%ebx
sete %al
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 12dd <func0+0x6d>
add $0x50,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r12
xor edx, edx
mov r12, rdi
lea rsi, a09; ".*[0-9]$"
push rbp
push rbx
sub rsp, 50h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp
call _regcomp
xor r8d, r8d
xor ecx, ecx
xor edx, edx
mov rsi, r12
mov rdi, rbp
call _regexec
mov rdi, rbp
mov ebx, eax
call _regfree
test ebx, ebx
setz al
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_12DD
add rsp, 50h
pop rbx
pop rbp
pop r12
retn
loc_12DD:
call ___stack_chk_fail | bool func0(long long a1)
{
int v1; // ebx
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, ".*[0-9]$", 0LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
regfree(_0);
return v1 == 0;
} | func0:
ENDBR64
PUSH R12
XOR EDX,EDX
MOV R12,RDI
LEA RSI,[0x102004]
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010c0
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,R12
MOV RDI,RBP
CALL 0x001010d0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x00101090
TEST EBX,EBX
SETZ AL
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012dd
ADD RSP,0x50
POP RBX
POP RBP
POP R12
RET
LAB_001012dd:
CALL 0x001010a0 | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,".*[0-9]$",0);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar1 == 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,547 | func0 |
#include <stdbool.h>
#include <regex.h>
#include <assert.h>
#include <stdio.h>
| bool func0(const char *string) {
regex_t regex;
int result;
bool match_found;
regcomp(®ex, ".*[0-9]$", 0);
result = regexec(®ex, string, 0, NULL, 0);
match_found = (result == 0);
regfree(®ex);
return match_found;
}
| int main() {
assert(func0("abcdef") == false);
assert(func0("abcdef7") == true);
assert(func0("abc") == false);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
xor %edx,%edx
mov %rdi,%r12
lea 0xd82(%rip),%rsi
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
xor %ecx,%ecx
xor %r8d,%r8d
xor %edx,%edx
mov %r12,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %rbp,%rdi
mov %eax,%ebx
callq 1090 <regfree@plt>
test %ebx,%ebx
sete %al
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 12dd <func0+0x6d>
add $0x50,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push rbp
xor edx, edx; cflags
lea rsi, pattern; ".*[0-9]$"
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
xor r8d, r8d; eflags
xor ecx, ecx; pmatch
xor edx, edx; nmatch
mov rsi, rbx; string
mov rdi, rbp; preg
call _regexec
mov rdi, rbp; preg
mov ebx, eax
call _regfree
test ebx, ebx
setz al
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_12D9
add rsp, 58h
pop rbx
pop rbp
retn
loc_12D9:
call ___stack_chk_fail | bool func0(char *string)
{
int v1; // ebx
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
regcomp(&_0, ".*[0-9]$", 0);
v1 = regexec(&_0, string, 0LL, 0LL, 0);
regfree(&_0);
return v1 == 0;
} | func0:
ENDBR64
PUSH RBP
XOR EDX,EDX
LEA RSI,[0x102004]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010c0
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010d0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x00101090
TEST EBX,EBX
SETZ AL
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012d9
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_001012d9:
CALL 0x001010a0 | bool func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,".*[0-9]$",0);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar1 == 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,548 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char* s) {
int length = strlen(s);
for (int i = 0; i < length - 2; i++) {
if (s[i] != s[i + 2]) {
return false;
}
}
if (s[0] == s[1]) {
return false;
}
return true;
}
| int main() {
assert(func0("abab") == true);
assert(func0("aaaa") == false);
assert(func0("xyz") == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11c3 <func0+0x5a>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x8(%rbp),%eax
cltq
lea 0x2(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
je 11bf <func0+0x56>
mov $0x0,%eax
jmp 11f0 <func0+0x87>
addl $0x1,-0x8(%rbp)
mov -0x4(%rbp),%eax
sub $0x2,%eax
cmp %eax,-0x8(%rbp)
jl 1191 <func0+0x28>
mov -0x18(%rbp),%rax
movzbl (%rax),%edx
mov -0x18(%rbp),%rax
add $0x1,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 11eb <func0+0x82>
mov $0x0,%eax
jmp 11f0 <func0+0x87>
mov $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_8], 0
jmp short loc_11C3
loc_1191:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_8]
cdqe
lea rcx, [rax+2]
mov rax, [rbp+s]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jz short loc_11BF
mov eax, 0
jmp short locret_11F0
loc_11BF:
add [rbp+var_8], 1
loc_11C3:
mov eax, [rbp+var_4]
sub eax, 2
cmp [rbp+var_8], eax
jl short loc_1191
mov rax, [rbp+s]
movzx edx, byte ptr [rax]
mov rax, [rbp+s]
add rax, 1
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_11EB
mov eax, 0
jmp short locret_11F0
loc_11EB:
mov eax, 1
locret_11F0:
leave
retn | _BOOL8 func0(long long a1)
{
int i; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
v3 = strlen((const char *)a1);
for ( i = 0; i < v3 - 2; ++i )
{
if ( *(_BYTE *)(i + a1) != *(_BYTE *)(i + 2LL + a1) )
return 0LL;
}
return *(_BYTE *)a1 != *(_BYTE *)(a1 + 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011c3
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RCX,[RAX + 0x2]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JZ 0x001011bf
MOV EAX,0x0
JMP 0x001011f0
LAB_001011bf:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011c3:
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x2
CMP dword ptr [RBP + -0x8],EAX
JL 0x00101191
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EDX,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x001011eb
MOV EAX,0x0
JMP 0x001011f0
LAB_001011eb:
MOV EAX,0x1
LAB_001011f0:
LEAVE
RET | bool func0(char *param_1)
{
size_t sVar1;
int local_10;
sVar1 = strlen(param_1);
local_10 = 0;
while( true ) {
if ((int)sVar1 + -2 <= local_10) {
return *param_1 != param_1[1];
}
if (param_1[local_10] != param_1[(long)local_10 + 2]) break;
local_10 = local_10 + 1;
}
return false;
} |
7,549 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char* s) {
int length = strlen(s);
for (int i = 0; i < length - 2; i++) {
if (s[i] != s[i + 2]) {
return false;
}
}
if (s[0] == s[1]) {
return false;
}
return true;
}
| int main() {
assert(func0("abab") == true);
assert(func0("aaaa") == false);
assert(func0("xyz") == false);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rsi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp $0x2,%ecx
jle 1187 <func0+0x3e>
mov %rsi,%rax
lea -0x3(%rcx),%edx
lea 0x1(%rsi,%rdx,1),%rdx
movzbl 0x2(%rax),%edi
cmp %dil,(%rax)
jne 1191 <func0+0x48>
add $0x1,%rax
cmp %rdx,%rax
jne 1175 <func0+0x2c>
movzbl 0x1(%rsi),%eax
cmp %al,(%rsi)
setne %al
retq
mov $0x0,%eax
retq
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
cmp eax, 2
jle short loc_1197
mov rdx, rbx
lea eax, [rax-3]
lea rax, [rbx+rax+1]
loc_1186:
movzx ecx, byte ptr [rdx+2]
cmp [rdx], cl
jnz short loc_11A2
add rdx, 1
cmp rdx, rax
jnz short loc_1186
loc_1197:
movzx eax, byte ptr [rbx+1]
cmp [rbx], al
setnz al
loc_11A0:
pop rbx
retn
loc_11A2:
mov eax, 0
jmp short loc_11A0 | bool func0(_BYTE *a1)
{
int v1; // eax
_BYTE *v2; // rdx
long long v3; // rax
v1 = strlen();
if ( v1 <= 2 )
return *a1 != a1[1];
v2 = a1;
v3 = (long long)&a1[v1 - 3 + 1];
while ( *v2 == v2[2] )
{
if ( ++v2 == (_BYTE *)v3 )
return *a1 != a1[1];
}
return 0;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
CMP EAX,0x2
JLE 0x00101197
MOV RDX,RBX
LEA EAX,[RAX + -0x3]
LEA RAX,[RBX + RAX*0x1 + 0x1]
LAB_00101186:
MOVZX ECX,byte ptr [RDX + 0x2]
CMP byte ptr [RDX],CL
JNZ 0x001011a2
ADD RDX,0x1
CMP RDX,RAX
JNZ 0x00101186
LAB_00101197:
MOVZX EAX,byte ptr [RBX + 0x1]
CMP byte ptr [RBX],AL
SETNZ AL
LAB_001011a0:
POP RBX
RET
LAB_001011a2:
MOV EAX,0x0
JMP 0x001011a0 | bool func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
sVar1 = strlen(param_1);
if (2 < (int)sVar1) {
pcVar2 = param_1;
do {
if (*pcVar2 != pcVar2[2]) {
return false;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != param_1 + (ulong)((int)sVar1 - 3) + 1);
}
return *param_1 != param_1[1];
} |
7,550 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char* s) {
int length = strlen(s);
for (int i = 0; i < length - 2; i++) {
if (s[i] != s[i + 2]) {
return false;
}
}
if (s[0] == s[1]) {
return false;
}
return true;
}
| int main() {
assert(func0("abab") == true);
assert(func0("aaaa") == false);
assert(func0("xyz") == false);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
cmp $0x2,%eax
jle 1248 <func0+0x38>
sub $0x3,%eax
mov %rbx,%rdx
lea 0x1(%rbx,%rax,1),%rax
jmp 1239 <func0+0x29>
add $0x1,%rdx
cmp %rax,%rdx
je 1248 <func0+0x38>
movzbl 0x2(%rdx),%ecx
cmp %cl,(%rdx)
je 1230 <func0+0x20>
xor %eax,%eax
pop %rbx
retq
nopl (%rax)
movzbl 0x1(%rbx),%eax
cmp %al,(%rbx)
setne %al
pop %rbx
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
cmp eax, 2
jle short loc_1248
sub eax, 3
mov rdx, rbx
lea rax, [rbx+rax+1]
jmp short loc_1239
loc_1230:
add rdx, 1
cmp rdx, rax
jz short loc_1248
loc_1239:
movzx ecx, byte ptr [rdx+2]
cmp [rdx], cl
jz short loc_1230
xor eax, eax
pop rbx
retn
loc_1248:
movzx eax, byte ptr [rbx+1]
cmp [rbx], al
setnz al
pop rbx
retn | bool func0(_BYTE *a1)
{
int v1; // eax
_BYTE *v2; // rdx
long long v3; // rax
v1 = strlen();
if ( v1 <= 2 )
return *a1 != a1[1];
v2 = a1;
v3 = (long long)&a1[v1 - 3 + 1];
while ( *v2 == v2[2] )
{
if ( ++v2 == (_BYTE *)v3 )
return *a1 != a1[1];
}
return 0;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
CMP EAX,0x2
JLE 0x00101248
SUB EAX,0x3
MOV RDX,RBX
LEA RAX,[RBX + RAX*0x1 + 0x1]
JMP 0x00101239
LAB_00101230:
ADD RDX,0x1
CMP RDX,RAX
JZ 0x00101248
LAB_00101239:
MOVZX ECX,byte ptr [RDX + 0x2]
CMP byte ptr [RDX],CL
JZ 0x00101230
XOR EAX,EAX
POP RBX
RET
LAB_00101248:
MOVZX EAX,byte ptr [RBX + 0x1]
CMP byte ptr [RBX],AL
SETNZ AL
POP RBX
RET | bool func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
sVar1 = strlen(param_1);
if (2 < (int)sVar1) {
pcVar2 = param_1;
do {
if (*pcVar2 != pcVar2[2]) {
return false;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != param_1 + (ulong)((int)sVar1 - 3) + 1);
}
return *param_1 != param_1[1];
} |
7,551 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| bool func0(const char* s) {
int length = strlen(s);
for (int i = 0; i < length - 2; i++) {
if (s[i] != s[i + 2]) {
return false;
}
}
if (s[0] == s[1]) {
return false;
}
return true;
}
| int main() {
assert(func0("abab") == true);
assert(func0("aaaa") == false);
assert(func0("xyz") == false);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
movzbl (%rbx),%edi
cmp $0x2,%eax
jle 1260 <func0+0x50>
sub $0x3,%eax
movzbl 0x1(%rbx),%esi
mov %edi,%ecx
lea 0x2(%rbx),%rdx
lea 0x3(%rbx,%rax,1),%r8
jmp 124f <func0+0x3f>
nopl 0x0(%rax)
add $0x1,%rdx
mov %esi,%eax
mov %ecx,%esi
cmp %r8,%rdx
je 1260 <func0+0x50>
mov %eax,%ecx
cmp %cl,(%rdx)
je 1240 <func0+0x30>
xor %eax,%eax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
cmp 0x1(%rbx),%dil
pop %rbx
setne %al
retq
nopl 0x0(%rax)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
movzx edi, byte ptr [rbx]
cmp eax, 2
jle short loc_1260
sub eax, 3
movzx ecx, byte ptr [rbx+1]
mov esi, edi
lea rdx, [rbx+2]
lea r8, [rbx+rax+3]
jmp short loc_124B
loc_1240:
add rdx, 1
mov esi, eax
cmp rdx, r8
jz short loc_1260
loc_124B:
mov eax, ecx
movzx ecx, byte ptr [rdx]
cmp cl, sil
jz short loc_1240
xor eax, eax
pop rbx
retn
loc_1260:
cmp dil, [rbx+1]
pop rbx
setnz al
retn | bool func0(long long a1)
{
int v2; // eax
char v3; // di
char v4; // cl
char v5; // si
char *v6; // rdx
long long v7; // r8
char v8; // al
v2 = strlen((const char *)a1);
v3 = *(_BYTE *)a1;
if ( v2 <= 2 )
return v3 != *(_BYTE *)(a1 + 1);
v4 = *(_BYTE *)(a1 + 1);
v5 = v3;
v6 = (char *)(a1 + 2);
v7 = a1 + (unsigned int)(v2 - 3) + 3;
while ( 1 )
{
v8 = v4;
v4 = *v6;
if ( *v6 != v5 )
break;
++v6;
v5 = v8;
if ( v6 == (char *)v7 )
return v3 != *(_BYTE *)(a1 + 1);
}
return 0;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOVZX EDI,byte ptr [RBX]
CMP EAX,0x2
JLE 0x00101260
SUB EAX,0x3
MOVZX ECX,byte ptr [RBX + 0x1]
MOV ESI,EDI
LEA RDX,[RBX + 0x2]
LEA R8,[RBX + RAX*0x1 + 0x3]
JMP 0x0010124b
LAB_00101240:
ADD RDX,0x1
MOV ESI,EAX
CMP RDX,R8
JZ 0x00101260
LAB_0010124b:
MOV EAX,ECX
MOVZX ECX,byte ptr [RDX]
CMP CL,SIL
JZ 0x00101240
XOR EAX,EAX
POP RBX
RET
LAB_00101260:
CMP DIL,byte ptr [RBX + 0x1]
POP RBX
SETNZ AL
RET | bool func0(char *param_1)
{
char cVar1;
char cVar2;
size_t sVar3;
char *pcVar4;
char cVar5;
sVar3 = strlen(param_1);
if (2 < (int)sVar3) {
pcVar4 = param_1 + 2;
cVar2 = param_1[1];
cVar5 = *param_1;
do {
cVar1 = cVar2;
cVar2 = *pcVar4;
if (cVar2 != cVar5) {
return false;
}
pcVar4 = pcVar4 + 1;
cVar5 = cVar1;
} while (pcVar4 != param_1 + (ulong)((int)sVar3 - 3) + 3);
}
return *param_1 != param_1[1];
} |
7,552 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to rearrange numbers based on the specified key
int comparator(const void* a, const void* b) {
int ia = *(int*)a;
int ib = *(int*)b;
double key_a = (ia == 0) ? 0.0 : (-1.0 / ia);
double key_b = (ib == 0) ? 0.0 : (-1.0 / ib);
if (key_a < key_b) return -1;
if (key_a > key_b) return 1;
return 0;
}
| int* func0(int array_nums[], int size) {
// Comparator function for qsort
qsort(array_nums, size, sizeof(int), comparator);
return array_nums;
}
| int main() {
// Test case 1
int array1[] = {-1, 2, -3, 5, 7, 8, 9, -10};
int expected1[] = {2, 5, 7, 8, 9, -10, -3, -1};
int size1 = sizeof(array1) / sizeof(array1[0]);
func0(array1, size1);
for(int i = 0; i < size1; i++) {
assert(array1[i] == expected1[i]);
}
// Test case 2
int array2[] = {10, 15, 14, 13, -18, 12, -20};
int expected2[] = {10, 12, 13, 14, 15, -20, -18};
int size2 = sizeof(array2) / sizeof(array2[0]);
func0(array2, size2);
for(int i = 0; i < size2; i++) {
assert(array2[i] == expected2[i]);
}
// Test case 3
int array3[] = {-20, 20, -10, 10, -30, 30};
int expected3[] = {10, 20, 30, -30, -20, -10};
int size3 = sizeof(array3) / sizeof(array3[0]);
func0(array3, size3);
for(int i = 0; i < size3; i++) {
assert(array3[i] == expected3[i]);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov -0xc(%rbp),%eax
movslq %eax,%rsi
mov -0x8(%rbp),%rax
lea -0xb7(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 1070 <qsort@plt>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+base], rdi
mov [rbp+var_C], esi
mov eax, [rbp+var_C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, comparator
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
mov rax, [rbp+base]
leave
retn | void * func0(void *a1, int a2)
{
qsort(a1, a2, 4uLL, comparator);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x101189]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x00101070
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,4,comparator);
return param_1;
} |
7,553 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to rearrange numbers based on the specified key
int comparator(const void* a, const void* b) {
int ia = *(int*)a;
int ib = *(int*)b;
double key_a = (ia == 0) ? 0.0 : (-1.0 / ia);
double key_b = (ib == 0) ? 0.0 : (-1.0 / ib);
if (key_a < key_b) return -1;
if (key_a > key_b) return 1;
return 0;
}
| int* func0(int array_nums[], int size) {
// Comparator function for qsort
qsort(array_nums, size, sizeof(int), comparator);
return array_nums;
}
| int main() {
// Test case 1
int array1[] = {-1, 2, -3, 5, 7, 8, 9, -10};
int expected1[] = {2, 5, 7, 8, 9, -10, -3, -1};
int size1 = sizeof(array1) / sizeof(array1[0]);
func0(array1, size1);
for(int i = 0; i < size1; i++) {
assert(array1[i] == expected1[i]);
}
// Test case 2
int array2[] = {10, 15, 14, 13, -18, 12, -20};
int expected2[] = {10, 12, 13, 14, 15, -20, -18};
int size2 = sizeof(array2) / sizeof(array2[0]);
func0(array2, size2);
for(int i = 0; i < size2; i++) {
assert(array2[i] == expected2[i]);
}
// Test case 3
int array3[] = {-20, 20, -10, 10, -30, 30};
int expected3[] = {10, 20, 30, -30, -20, -10};
int size3 = sizeof(array3) / sizeof(array3[0]);
func0(array3, size3);
for(int i = 0; i < size3; i++) {
assert(array3[i] == expected3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
movslq %esi,%rsi
lea -0x79(%rip),%rcx
mov $0x4,%edx
callq 1070 <qsort@plt>
mov %rbx,%rax
pop %rbx
retq
| func0:
endbr64
push rbx
mov rbx, rdi
movsxd rsi, esi
lea rcx, comparator
mov edx, 4
call _qsort
mov rax, rbx
pop rbx
retn | long long func0(long long a1, int a2)
{
qsort(a1, a2, 4LL, comparator);
return a1;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
MOVSXD RSI,ESI
LEA RCX,[0x101189]
MOV EDX,0x4
CALL 0x00101070
MOV RAX,RBX
POP RBX
RET | void * func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,4,comparator);
return param_1;
} |
7,554 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to rearrange numbers based on the specified key
int comparator(const void* a, const void* b) {
int ia = *(int*)a;
int ib = *(int*)b;
double key_a = (ia == 0) ? 0.0 : (-1.0 / ia);
double key_b = (ib == 0) ? 0.0 : (-1.0 / ib);
if (key_a < key_b) return -1;
if (key_a > key_b) return 1;
return 0;
}
| int* func0(int array_nums[], int size) {
// Comparator function for qsort
qsort(array_nums, size, sizeof(int), comparator);
return array_nums;
}
| int main() {
// Test case 1
int array1[] = {-1, 2, -3, 5, 7, 8, 9, -10};
int expected1[] = {2, 5, 7, 8, 9, -10, -3, -1};
int size1 = sizeof(array1) / sizeof(array1[0]);
func0(array1, size1);
for(int i = 0; i < size1; i++) {
assert(array1[i] == expected1[i]);
}
// Test case 2
int array2[] = {10, 15, 14, 13, -18, 12, -20};
int expected2[] = {10, 12, 13, 14, 15, -20, -18};
int size2 = sizeof(array2) / sizeof(array2[0]);
func0(array2, size2);
for(int i = 0; i < size2; i++) {
assert(array2[i] == expected2[i]);
}
// Test case 3
int array3[] = {-20, 20, -10, 10, -30, 30};
int expected3[] = {10, 20, 30, -30, -20, -10};
int size3 = sizeof(array3) / sizeof(array3[0]);
func0(array3, size3);
for(int i = 0; i < size3; i++) {
assert(array3[i] == expected3[i]);
}
return 0;
}
| O2 | c | func0:
endbr64
push %r12
movslq %esi,%rsi
mov %rdi,%r12
mov $0x4,%edx
lea -0x98(%rip),%rcx
callq 1070 <qsort@plt>
mov %r12,%rax
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r12
movsxd rsi, esi
mov r12, rdi
mov edx, 4
lea rcx, comparator
call _qsort
mov rax, r12
pop r12
retn | long long func0(long long a1, int a2)
{
qsort(a1, a2, 4LL, comparator);
return a1;
} | func0:
ENDBR64
PUSH R12
MOVSXD RSI,ESI
MOV R12,RDI
MOV EDX,0x4
LEA RCX,[0x101410]
CALL 0x00101070
MOV RAX,R12
POP R12
RET | void * func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,4,comparator);
return param_1;
} |
7,555 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// Function to rearrange numbers based on the specified key
int comparator(const void* a, const void* b) {
int ia = *(int*)a;
int ib = *(int*)b;
double key_a = (ia == 0) ? 0.0 : (-1.0 / ia);
double key_b = (ib == 0) ? 0.0 : (-1.0 / ib);
if (key_a < key_b) return -1;
if (key_a > key_b) return 1;
return 0;
}
| int* func0(int array_nums[], int size) {
// Comparator function for qsort
qsort(array_nums, size, sizeof(int), comparator);
return array_nums;
}
| int main() {
// Test case 1
int array1[] = {-1, 2, -3, 5, 7, 8, 9, -10};
int expected1[] = {2, 5, 7, 8, 9, -10, -3, -1};
int size1 = sizeof(array1) / sizeof(array1[0]);
func0(array1, size1);
for(int i = 0; i < size1; i++) {
assert(array1[i] == expected1[i]);
}
// Test case 2
int array2[] = {10, 15, 14, 13, -18, 12, -20};
int expected2[] = {10, 12, 13, 14, 15, -20, -18};
int size2 = sizeof(array2) / sizeof(array2[0]);
func0(array2, size2);
for(int i = 0; i < size2; i++) {
assert(array2[i] == expected2[i]);
}
// Test case 3
int array3[] = {-20, 20, -10, 10, -30, 30};
int expected3[] = {10, 20, 30, -30, -20, -10};
int size3 = sizeof(array3) / sizeof(array3[0]);
func0(array3, size3);
for(int i = 0; i < size3; i++) {
assert(array3[i] == expected3[i]);
}
return 0;
}
| O3 | c | func0:
endbr64
push %r12
movslq %esi,%rsi
mov %rdi,%r12
mov $0x4,%edx
lea -0x98(%rip),%rcx
callq 1070 <qsort@plt>
mov %r12,%rax
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push rbx
movsxd rsi, esi; nmemb
mov rbx, rdi
lea rcx, comparator; compar
mov edx, 4; size
call _qsort
mov rax, rbx
pop rbx
retn | void * func0(void *a1, int a2)
{
qsort(a1, a2, 4uLL, comparator);
return a1;
} | func0:
ENDBR64
PUSH RBX
MOVSXD RSI,ESI
MOV RBX,RDI
LEA RCX,[0x101390]
MOV EDX,0x4
CALL 0x00101070
MOV RAX,RBX
POP RBX
RET | void * func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,4,comparator);
return param_1;
} |
7,556 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int A[], int arr_size, int sum, int * triplet) {
for (int i = 0; i < arr_size - 2; i++) {
for (int j = i + 1; j < arr_size - 1; j++) {
for (int k = j + 1; k < arr_size; k++) {
if (A[i] + A[j] + A[k] == sum) {
triplet[0] = A[i];
triplet[1] = A[j];
triplet[2] = A[k];
return true;
}
}
}
}
return false;
}
| int main() {
int triplet[3];
assert(func0((int[]){1, 4, 45, 6, 10, 8}, 6, 22, triplet) && triplet[0] == 4 && triplet[1] == 10 && triplet[2] == 8);
assert(func0((int[]){12, 3, 5, 2, 6, 9}, 6, 24, triplet) && triplet[0] == 12 && triplet[1] == 3 && triplet[2] == 9);
assert(func0((int[]){1, 2, 3, 4, 5}, 5, 9, triplet) && triplet[0] == 1 && triplet[1] == 3 && triplet[2] == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 127c <func0+0x113>
mov -0xc(%rbp),%eax
add $0x1,%eax
mov %eax,-0x8(%rbp)
jmpq 1269 <func0+0x100>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmpq 1259 <func0+0xf0>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
add %eax,%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
add %edx,%eax
cmp %eax,-0x20(%rbp)
jne 1255 <func0+0xec>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x28(%rbp),%rax
mov %edx,(%rax)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x28(%rbp),%rdx
add $0x4,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x28(%rbp),%rdx
add $0x8,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov $0x1,%eax
jmp 1290 <func0+0x127>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11a7 <func0+0x3e>
addl $0x1,-0x8(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x8(%rbp)
jl 1199 <func0+0x30>
addl $0x1,-0xc(%rbp)
mov -0x1c(%rbp),%eax
sub $0x2,%eax
cmp %eax,-0xc(%rbp)
jl 118b <func0+0x22>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_28], rcx
mov [rbp+var_C], 0
jmp loc_127C
loc_118B:
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_8], eax
jmp loc_1269
loc_1199:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp loc_1259
loc_11A7:
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_8]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
add edx, eax
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
add eax, edx
cmp [rbp+var_20], eax
jnz short loc_1255
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_28]
mov [rax], edx
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov rdx, [rbp+var_28]
add rdx, 4
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov rdx, [rbp+var_28]
add rdx, 8
mov eax, [rax]
mov [rdx], eax
mov eax, 1
jmp short loc_1290
loc_1255:
add [rbp+var_4], 1
loc_1259:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl loc_11A7
add [rbp+var_8], 1
loc_1269:
mov eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_8], eax
jl loc_1199
add [rbp+var_C], 1
loc_127C:
mov eax, [rbp+var_1C]
sub eax, 2
cmp [rbp+var_C], eax
jl loc_118B
mov eax, 0
loc_1290:
pop rbp
retn | long long func0(long long a1, int a2, int a3, _DWORD *a4)
{
int i; // [rsp+1Ch] [rbp-Ch]
int j; // [rsp+20h] [rbp-8h]
int k; // [rsp+24h] [rbp-4h]
for ( i = 0; i < a2 - 2; ++i )
{
for ( j = i + 1; j < a2 - 1; ++j )
{
for ( k = j + 1; k < a2; ++k )
{
if ( a3 == *(_DWORD *)(4LL * j + a1) + *(_DWORD *)(4LL * i + a1) + *(_DWORD *)(4LL * k + a1) )
{
*a4 = *(_DWORD *)(4LL * i + a1);
a4[1] = *(_DWORD *)(4LL * j + a1);
a4[2] = *(_DWORD *)(4LL * k + a1);
return 1LL;
}
}
}
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010127c
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101269
LAB_00101199:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101259
LAB_001011a7:
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 + -0x8]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EAX,EDX
CMP dword ptr [RBP + -0x20],EAX
JNZ 0x00101255
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 RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,0x4
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,0x8
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,0x1
JMP 0x00101290
LAB_00101255:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101259:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011a7
ADD dword ptr [RBP + -0x8],0x1
LAB_00101269:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x8],EAX
JL 0x00101199
ADD dword ptr [RBP + -0xc],0x1
LAB_0010127c:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x2
CMP dword ptr [RBP + -0xc],EAX
JL 0x0010118b
MOV EAX,0x0
LAB_00101290:
POP RBP
RET | int8 func0(long param_1,int param_2,int param_3,int4 *param_4)
{
int local_14;
int local_10;
int local_c;
local_14 = 0;
do {
local_10 = local_14;
if (param_2 + -2 <= local_14) {
return 0;
}
while (local_10 = local_10 + 1, local_c = local_10, local_10 < param_2 + -1) {
while (local_c = local_c + 1, local_c < param_2) {
if (param_3 ==
*(int *)(param_1 + (long)local_c * 4) +
*(int *)(param_1 + (long)local_14 * 4) + *(int *)(param_1 + (long)local_10 * 4)) {
*param_4 = *(int4 *)(param_1 + (long)local_14 * 4);
param_4[1] = *(int4 *)(param_1 + (long)local_10 * 4);
param_4[2] = *(int4 *)(param_1 + (long)local_c * 4);
return 1;
}
}
}
local_14 = local_14 + 1;
} while( true );
} |
7,557 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int A[], int arr_size, int sum, int * triplet) {
for (int i = 0; i < arr_size - 2; i++) {
for (int j = i + 1; j < arr_size - 1; j++) {
for (int k = j + 1; k < arr_size; k++) {
if (A[i] + A[j] + A[k] == sum) {
triplet[0] = A[i];
triplet[1] = A[j];
triplet[2] = A[k];
return true;
}
}
}
}
return false;
}
| int main() {
int triplet[3];
assert(func0((int[]){1, 4, 45, 6, 10, 8}, 6, 22, triplet) && triplet[0] == 4 && triplet[1] == 10 && triplet[2] == 8);
assert(func0((int[]){12, 3, 5, 2, 6, 9}, 6, 24, triplet) && triplet[0] == 12 && triplet[1] == 3 && triplet[2] == 9);
assert(func0((int[]){1, 2, 3, 4, 5}, 5, 9, triplet) && triplet[0] == 1 && triplet[1] == 3 && triplet[2] == 5);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x2,%esi
jle 125d <func0+0xf4>
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rcx,%rbp
lea 0x4(%rdi),%r14
mov %esi,%eax
lea -0x3(%rsi),%ecx
lea 0x2(%rcx),%rbx
mov %rbx,-0x8(%rsp)
mov $0x1,%r12d
lea -0x1(%rsi),%ebx
mov %ebx,-0x10(%rsp)
lea -0x2(%rsi),%ebx
mov %ebx,-0xc(%rsp)
sub $0x1,%eax
mov %eax,-0x1c(%rsp)
lea 0x8(%rdi),%r15
cmp %r12d,-0x10(%rsp)
jle 1223 <func0+0xba>
lea 0x1(%r12),%r11
mov -0xc(%rsp),%eax
sub %r12d,%eax
lea 0x2(%r12,%rax,1),%rax
mov %rax,-0x18(%rsp)
mov %r14,%rbx
cmp %r11d,%esi
jle 1214 <func0+0xab>
mov -0x4(%r14),%r13d
mov %rbx,-0x28(%rsp)
mov %r13d,%r8d
add (%rbx),%r8d
movslq %r11d,%rax
lea (%rdi,%rax,4),%rax
mov -0x1c(%rsp),%ecx
sub %r11d,%ecx
lea -0x1(%r11,%rcx,1),%rcx
lea (%r15,%rcx,4),%r9
mov %rax,%r10
mov %r8d,%ecx
add (%rax),%ecx
cmp %edx,%ecx
je 1239 <func0+0xd0>
add $0x4,%rax
cmp %r9,%rax
jne 11ff <func0+0x96>
add $0x1,%r11
add $0x4,%rbx
cmp -0x18(%rsp),%r11
jne 11d4 <func0+0x6b>
add $0x1,%r12
add $0x4,%r14
cmp -0x8(%rsp),%r12
jne 11b4 <func0+0x4b>
mov $0x0,%eax
jmp 1252 <func0+0xe9>
mov %r13d,0x0(%rbp)
mov -0x28(%rsp),%rax
mov (%rax),%eax
mov %eax,0x4(%rbp)
mov (%r10),%eax
mov %eax,0x8(%rbp)
mov $0x1,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x0,%eax
retq
| func0:
endbr64
mov r10d, esi
cmp esi, 2
jle loc_1250
push r15
push r14
push r13
push r12
push rbp
push rbx
mov r11, rdi
mov esi, edx
mov r12, rcx
lea r15, [rdi+4]
lea eax, [r10-3]
add rax, 2
mov [rsp+30h+var_38], rax
mov r14d, 1
lea ebp, [r10-1]
lea rax, [rdi+8]
mov [rsp+30h+var_40], rax
loc_11AF:
mov r9d, r14d
cmp ebp, r14d
jle short loc_1213
mov rbx, r15
mov [rsp+30h+var_50], r14
loc_11BF:
add r9d, 1
cmp r10d, r9d
jle short loc_1204
mov r13d, [r15-4]
mov [rsp+30h+var_48], rbx
mov ecx, r13d
add ecx, [rbx]
movsxd rax, r9d
lea rax, [r11+rax*4]
mov edx, ebp
sub edx, r9d
add rdx, [rsp+30h+var_50]
mov rdi, [rsp+30h+var_40]
lea r8, [rdi+rdx*4]
loc_11F0:
mov rdi, rax
mov edx, ecx
add edx, [rax]
cmp edx, esi
jz short loc_1229
add rax, 4
cmp rax, r8
jnz short loc_11F0
loc_1204:
add [rsp+30h+var_50], 1
add rbx, 4
cmp r9d, ebp
jnz short loc_11BF
loc_1213:
add r14, 1
add r15, 4
cmp r14, [rsp+30h+var_38]
jnz short loc_11AF
mov eax, 0
jmp short loc_1245
loc_1229:
mov [r12], r13d
mov rax, [rsp+30h+var_48]
mov eax, [rax]
mov [r12+4], eax
mov eax, [rdi]
mov [r12+8], eax
mov eax, 1
loc_1245:
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1250:
mov eax, 0
retn | long long func0(long long a1, int a2, int a3, _DWORD *a4)
{
_DWORD *v4; // r15
long long v5; // r14
int v6; // ebp
int v7; // r9d
_DWORD *v8; // rbx
int v9; // r13d
_DWORD *v10; // rax
long long v12; // [rsp+0h] [rbp-50h]
if ( a2 <= 2 )
return 0LL;
v4 = (_DWORD *)(a1 + 4);
v5 = 1LL;
v6 = a2 - 1;
while ( 1 )
{
v7 = v5;
if ( v6 > (int)v5 )
break;
LABEL_10:
++v5;
++v4;
if ( v5 == (unsigned int)(a2 - 3) + 2LL )
return 0LL;
}
v8 = v4;
v12 = v5;
while ( a2 <= ++v7 )
{
LABEL_9:
++v12;
++v8;
if ( v7 == v6 )
goto LABEL_10;
}
v9 = *(v4 - 1);
v10 = (_DWORD *)(a1 + 4LL * v7);
while ( *v10 + *v8 + v9 != a3 )
{
if ( ++v10 == (_DWORD *)(a1 + 8 + 4 * (v12 + (unsigned int)(v6 - v7))) )
goto LABEL_9;
}
*a4 = v9;
a4[1] = *v8;
a4[2] = *v10;
return 1LL;
} | func0:
ENDBR64
MOV R10D,ESI
CMP ESI,0x2
JLE 0x00101250
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R11,RDI
MOV ESI,EDX
MOV R12,RCX
LEA R15,[RDI + 0x4]
LEA EAX,[R10 + -0x3]
ADD RAX,0x2
MOV qword ptr [RSP + -0x8],RAX
MOV R14D,0x1
LEA EBP,[R10 + -0x1]
LEA RAX,[RDI + 0x8]
MOV qword ptr [RSP + -0x10],RAX
LAB_001011af:
MOV R9D,R14D
CMP EBP,R14D
JLE 0x00101213
MOV RBX,R15
MOV qword ptr [RSP + -0x20],R14
LAB_001011bf:
ADD R9D,0x1
CMP R10D,R9D
JLE 0x00101204
MOV R13D,dword ptr [R15 + -0x4]
MOV qword ptr [RSP + -0x18],RBX
MOV ECX,R13D
ADD ECX,dword ptr [RBX]
MOVSXD RAX,R9D
LEA RAX,[R11 + RAX*0x4]
MOV EDX,EBP
SUB EDX,R9D
ADD RDX,qword ptr [RSP + -0x20]
MOV RDI,qword ptr [RSP + -0x10]
LEA R8,[RDI + RDX*0x4]
LAB_001011f0:
MOV RDI,RAX
MOV EDX,ECX
ADD EDX,dword ptr [RAX]
CMP EDX,ESI
JZ 0x00101229
ADD RAX,0x4
CMP RAX,R8
JNZ 0x001011f0
LAB_00101204:
ADD qword ptr [RSP + -0x20],0x1
ADD RBX,0x4
CMP R9D,EBP
JNZ 0x001011bf
LAB_00101213:
ADD R14,0x1
ADD R15,0x4
CMP R14,qword ptr [RSP + -0x8]
JNZ 0x001011af
MOV EAX,0x0
JMP 0x00101245
LAB_00101229:
MOV dword ptr [R12],R13D
MOV RAX,qword ptr [RSP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [R12 + 0x4],EAX
MOV EAX,dword ptr [RDI]
MOV dword ptr [R12 + 0x8],EAX
MOV EAX,0x1
LAB_00101245:
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101250:
MOV EAX,0x0
RET | int8 func0(long param_1,int param_2,int param_3,int *param_4)
{
int *piVar1;
int *piVar2;
uint uVar3;
uint uVar4;
ulong uVar5;
ulong uVar6;
int *piVar7;
ulong local_50;
if (param_2 < 3) {
return 0;
}
piVar7 = (int *)(param_1 + 4);
uVar6 = 1;
uVar3 = param_2 - 1;
do {
uVar5 = uVar6 & 0xffffffff;
piVar2 = piVar7;
local_50 = uVar6;
if ((int)uVar6 < (int)uVar3) {
do {
uVar4 = (int)uVar5 + 1;
uVar5 = (ulong)uVar4;
if ((int)uVar4 < param_2) {
piVar1 = (int *)(param_1 + (long)(int)uVar4 * 4);
do {
if (piVar7[-1] + *piVar2 + *piVar1 == param_3) {
*param_4 = piVar7[-1];
param_4[1] = *piVar2;
param_4[2] = *piVar1;
return 1;
}
piVar1 = piVar1 + 1;
} while (piVar1 != (int *)(param_1 + 8 + ((uVar3 - uVar4) + local_50) * 4));
}
piVar2 = piVar2 + 1;
local_50 = local_50 + 1;
} while (uVar4 != uVar3);
}
uVar6 = uVar6 + 1;
piVar7 = piVar7 + 1;
} while (uVar6 != (ulong)(param_2 - 3) + 2);
return 0;
} |
7,558 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int A[], int arr_size, int sum, int * triplet) {
for (int i = 0; i < arr_size - 2; i++) {
for (int j = i + 1; j < arr_size - 1; j++) {
for (int k = j + 1; k < arr_size; k++) {
if (A[i] + A[j] + A[k] == sum) {
triplet[0] = A[i];
triplet[1] = A[j];
triplet[2] = A[k];
return true;
}
}
}
}
return false;
}
| int main() {
int triplet[3];
assert(func0((int[]){1, 4, 45, 6, 10, 8}, 6, 22, triplet) && triplet[0] == 4 && triplet[1] == 10 && triplet[2] == 8);
assert(func0((int[]){12, 3, 5, 2, 6, 9}, 6, 24, triplet) && triplet[0] == 12 && triplet[1] == 3 && triplet[2] == 9);
assert(func0((int[]){1, 2, 3, 4, 5}, 5, 9, triplet) && triplet[0] == 1 && triplet[1] == 3 && triplet[2] == 5);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x2,%esi
jle 1415 <func0+0xe5>
push %r15
lea -0x3(%rsi),%eax
lea 0x8(%rdi),%r15
push %r14
add $0x2,%rax
push %r13
lea -0x1(%rsi),%r13d
push %r12
lea 0x4(%rdi),%r12
push %rbp
push %rbx
lea -0x2(%rsi),%ebx
mov %ebx,-0xc(%rsp)
mov %rax,-0x8(%rsp)
mov $0x1,%eax
lea 0x1(%rax),%r14
cmp %eax,%r13d
jle 13ff <func0+0xcf>
mov -0xc(%rsp),%r8d
mov %r14,%r11
mov %r12,%rbx
sub %eax,%r8d
lea 0x2(%rax,%r8,1),%rax
mov %rax,-0x18(%rsp)
cmp %r11d,%esi
jle 13f0 <func0+0xc0>
mov %r13d,%r8d
mov -0x4(%r12),%ebp
mov (%rbx),%r9d
movslq %r11d,%rax
sub %r11d,%r8d
lea (%rdi,%rax,4),%rax
lea -0x1(%r11,%r8,1),%r8
add %ebp,%r9d
lea (%r15,%r8,4),%r10
jmp 13c9 <func0+0x99>
nopl 0x0(%rax,%rax,1)
add $0x4,%rax
cmp %rax,%r10
je 13f0 <func0+0xc0>
mov (%rax),%r8d
add %r9d,%r8d
cmp %edx,%r8d
jne 13c0 <func0+0x90>
mov %ebp,(%rcx)
mov (%rbx),%edx
mov %edx,0x4(%rcx)
mov (%rax),%eax
mov %eax,0x8(%rcx)
mov $0x1,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
add $0x1,%r11
add $0x4,%rbx
cmp -0x18(%rsp),%r11
jne 1390 <func0+0x60>
mov %r14,%rax
add $0x4,%r12
cmp -0x8(%rsp),%r14
jne 136b <func0+0x3b>
xor %eax,%eax
jmp 13e5 <func0+0xb5>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov r9d, esi
cmp esi, 2
jle loc_1414
push r15
lea eax, [r9-3]
mov r10, rdi
mov esi, edx
push r14
add rax, 2
mov r11, rcx
lea r15, [rdi+4]
push r13
mov r14d, 1
push r12
push rbp
lea ebp, [r9-1]
push rbx
mov [rsp+30h+var_38], rax
lea rax, [rdi+8]
mov [rsp+30h+var_40], rax
loc_1386:
mov r8d, r14d
cmp ebp, r14d
jle short loc_13FD
mov rbx, r15
mov r12, r14
loc_1394:
add r8d, 1
cmp r9d, r8d
jle short loc_13F0
mov edx, ebp
mov r13d, [r15-4]
mov ecx, [rbx]
movsxd rax, r8d
mov rdi, [rsp+30h+var_40]
sub edx, r8d
lea rax, [r10+rax*4]
add rdx, r12
add ecx, r13d
lea rdi, [rdi+rdx*4]
jmp short loc_13C9
loc_13C0:
add rax, 4
cmp rdi, rax
jz short loc_13F0
loc_13C9:
mov edx, [rax]
add edx, ecx
cmp edx, esi
jnz short loc_13C0
mov [r11], r13d
mov edx, [rbx]
mov [r11+4], edx
mov eax, [rax]
mov [r11+8], eax
mov eax, 1
loc_13E5:
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_13F0:
add r12, 1
add rbx, 4
cmp r8d, ebp
jnz short loc_1394
loc_13FD:
add r14, 1
add r15, 4
cmp r14, [rsp+30h+var_38]
jnz loc_1386
xor eax, eax
jmp short loc_13E5
loc_1414:
xor eax, eax
retn | long long func0(long long a1, int a2, int a3, _DWORD *a4)
{
_DWORD *v4; // r15
long long v5; // r14
int v6; // ebp
int v7; // r8d
_DWORD *v8; // rbx
long long v9; // r12
int v10; // r13d
_DWORD *v11; // rax
if ( a2 <= 2 )
return 0LL;
v4 = (_DWORD *)(a1 + 4);
v5 = 1LL;
v6 = a2 - 1;
while ( 1 )
{
v7 = v5;
if ( v6 > (int)v5 )
break;
LABEL_12:
++v5;
++v4;
if ( v5 == (unsigned int)(a2 - 3) + 2LL )
return 0LL;
}
v8 = v4;
v9 = v5;
while ( a2 <= ++v7 )
{
LABEL_11:
++v9;
++v8;
if ( v7 == v6 )
goto LABEL_12;
}
v10 = *(v4 - 1);
v11 = (_DWORD *)(a1 + 4LL * v7);
while ( v10 + *v8 + *v11 != a3 )
{
if ( (_DWORD *)(a1 + 8 + 4 * (v9 + (unsigned int)(v6 - v7))) == ++v11 )
goto LABEL_11;
}
*a4 = v10;
a4[1] = *v8;
a4[2] = *v11;
return 1LL;
} | func0:
ENDBR64
MOV R9D,ESI
CMP ESI,0x2
JLE 0x00101414
PUSH R15
LEA EAX,[R9 + -0x3]
MOV R10,RDI
MOV ESI,EDX
PUSH R14
ADD RAX,0x2
MOV R11,RCX
LEA R15,[RDI + 0x4]
PUSH R13
MOV R14D,0x1
PUSH R12
PUSH RBP
LEA EBP,[R9 + -0x1]
PUSH RBX
MOV qword ptr [RSP + -0x8],RAX
LEA RAX,[RDI + 0x8]
MOV qword ptr [RSP + -0x10],RAX
LAB_00101386:
MOV R8D,R14D
CMP EBP,R14D
JLE 0x001013fd
MOV RBX,R15
MOV R12,R14
LAB_00101394:
ADD R8D,0x1
CMP R9D,R8D
JLE 0x001013f0
MOV EDX,EBP
MOV R13D,dword ptr [R15 + -0x4]
MOV ECX,dword ptr [RBX]
MOVSXD RAX,R8D
MOV RDI,qword ptr [RSP + -0x10]
SUB EDX,R8D
LEA RAX,[R10 + RAX*0x4]
ADD RDX,R12
ADD ECX,R13D
LEA RDI,[RDI + RDX*0x4]
JMP 0x001013c9
LAB_001013c0:
ADD RAX,0x4
CMP RDI,RAX
JZ 0x001013f0
LAB_001013c9:
MOV EDX,dword ptr [RAX]
ADD EDX,ECX
CMP EDX,ESI
JNZ 0x001013c0
MOV dword ptr [R11],R13D
MOV EDX,dword ptr [RBX]
MOV dword ptr [R11 + 0x4],EDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [R11 + 0x8],EAX
MOV EAX,0x1
LAB_001013e5:
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001013f0:
ADD R12,0x1
ADD RBX,0x4
CMP R8D,EBP
JNZ 0x00101394
LAB_001013fd:
ADD R14,0x1
ADD R15,0x4
CMP R14,qword ptr [RSP + -0x8]
JNZ 0x00101386
XOR EAX,EAX
JMP 0x001013e5
LAB_00101414:
XOR EAX,EAX
RET | int8 func0(long param_1,int param_2,int param_3,int *param_4)
{
int *piVar1;
int *piVar2;
uint uVar3;
uint uVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
int *piVar8;
if (param_2 < 3) {
return 0;
}
piVar8 = (int *)(param_1 + 4);
uVar7 = 1;
uVar3 = param_2 - 1;
do {
uVar5 = uVar7 & 0xffffffff;
piVar2 = piVar8;
uVar6 = uVar7;
if ((int)uVar7 < (int)uVar3) {
do {
uVar4 = (int)uVar5 + 1;
uVar5 = (ulong)uVar4;
if ((int)uVar4 < param_2) {
piVar1 = (int *)(param_1 + (long)(int)uVar4 * 4);
do {
if (*piVar1 + *piVar2 + piVar8[-1] == param_3) {
*param_4 = piVar8[-1];
param_4[1] = *piVar2;
param_4[2] = *piVar1;
return 1;
}
piVar1 = piVar1 + 1;
} while ((int *)(param_1 + 8 + ((uVar3 - uVar4) + uVar6) * 4) != piVar1);
}
piVar2 = piVar2 + 1;
uVar6 = uVar6 + 1;
} while (uVar4 != uVar3);
}
uVar7 = uVar7 + 1;
piVar8 = piVar8 + 1;
} while (uVar7 != (ulong)(param_2 - 3) + 2);
return 0;
} |
7,559 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int A[], int arr_size, int sum, int * triplet) {
for (int i = 0; i < arr_size - 2; i++) {
for (int j = i + 1; j < arr_size - 1; j++) {
for (int k = j + 1; k < arr_size; k++) {
if (A[i] + A[j] + A[k] == sum) {
triplet[0] = A[i];
triplet[1] = A[j];
triplet[2] = A[k];
return true;
}
}
}
}
return false;
}
| int main() {
int triplet[3];
assert(func0((int[]){1, 4, 45, 6, 10, 8}, 6, 22, triplet) && triplet[0] == 4 && triplet[1] == 10 && triplet[2] == 8);
assert(func0((int[]){12, 3, 5, 2, 6, 9}, 6, 24, triplet) && triplet[0] == 12 && triplet[1] == 3 && triplet[2] == 9);
assert(func0((int[]){1, 2, 3, 4, 5}, 5, 9, triplet) && triplet[0] == 1 && triplet[1] == 3 && triplet[2] == 5);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x2,%esi
jle 13d5 <func0+0xe5>
push %r15
lea -0x3(%rsi),%eax
lea 0x8(%rdi),%r15
push %r14
add $0x2,%rax
push %r13
lea -0x1(%rsi),%r13d
push %r12
lea 0x4(%rdi),%r12
push %rbp
push %rbx
lea -0x2(%rsi),%ebx
mov %ebx,-0xc(%rsp)
mov %rax,-0x8(%rsp)
mov $0x1,%eax
lea 0x1(%rax),%r14
cmp %eax,%r13d
jle 13bf <func0+0xcf>
mov -0xc(%rsp),%r8d
mov %r14,%r11
mov %r12,%rbx
sub %eax,%r8d
lea 0x2(%rax,%r8,1),%rax
mov %rax,-0x18(%rsp)
cmp %r11d,%esi
jle 13b0 <func0+0xc0>
mov %r13d,%r8d
mov -0x4(%r12),%ebp
mov (%rbx),%r9d
movslq %r11d,%rax
sub %r11d,%r8d
lea (%rdi,%rax,4),%rax
lea -0x1(%r11,%r8,1),%r8
add %ebp,%r9d
lea (%r15,%r8,4),%r10
jmp 1389 <func0+0x99>
nopl 0x0(%rax,%rax,1)
add $0x4,%rax
cmp %rax,%r10
je 13b0 <func0+0xc0>
mov (%rax),%r8d
add %r9d,%r8d
cmp %edx,%r8d
jne 1380 <func0+0x90>
mov %ebp,(%rcx)
mov (%rbx),%edx
mov %edx,0x4(%rcx)
mov (%rax),%eax
mov %eax,0x8(%rcx)
mov $0x1,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
add $0x1,%r11
add $0x4,%rbx
cmp -0x18(%rsp),%r11
jne 1350 <func0+0x60>
mov %r14,%rax
add $0x4,%r12
cmp -0x8(%rsp),%r14
jne 132b <func0+0x3b>
xor %eax,%eax
jmp 13a5 <func0+0xb5>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov r9d, esi
cmp esi, 2
jle loc_13E3
push r15
lea r15d, [r9-1]
mov esi, edx
mov rdx, rcx
push r14
mov ecx, 1
mov r10, rdi
lea r14, [rdi+8]
push r13
mov r8, rcx
lea r13, [rdi+4]
mov rcx, rdx
push r12
mov edx, r9d
push rbp
push rbx
mov rbx, r15
mov [rsp+30h+var_40], r15
loc_1344:
mov ebp, r8d
cmp ebx, r8d
jle short loc_13C9
mov [rsp+30h+var_38], r8
mov r11, r13
mov r15, r8
loc_1357:
add ebp, 1
cmp edx, ebp
jle short loc_13B8
mov edi, ebx
mov r12d, [r13-4]
mov r8d, [r11]
movsxd rax, ebp
sub edi, ebp
lea rax, [r10+rax*4]
add rdi, r15
add r8d, r12d
lea r9, [r14+rdi*4]
jmp short loc_1389
loc_1380:
add rax, 4
cmp r9, rax
jz short loc_13B8
loc_1389:
mov edi, [rax]
add edi, r8d
cmp edi, esi
jnz short loc_1380
mov [rcx], r12d
mov rdx, rcx
mov ecx, [r11]
mov [rdx+4], ecx
mov eax, [rax]
mov [rdx+8], eax
mov eax, 1
loc_13A8:
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_13B8:
add r15, 1
add r11, 4
cmp ebp, ebx
jnz short loc_1357
mov r8, [rsp+30h+var_38]
loc_13C9:
mov rax, [rsp+30h+var_40]
add r8, 1
add r13, 4
cmp r8, rax
jnz loc_1344
xor eax, eax
jmp short loc_13A8
loc_13E3:
xor eax, eax
retn | long long func0(long long a1, int a2, int a3, _DWORD *a4)
{
long long v4; // r8
_DWORD *v5; // r13
int v6; // ebx
int v7; // ebp
_DWORD *v8; // r11
long long v9; // r15
int v10; // r12d
_DWORD *v11; // rax
if ( a2 <= 2 )
return 0LL;
v4 = 1LL;
v5 = (_DWORD *)(a1 + 4);
v6 = a2 - 1;
while ( 1 )
{
v7 = v4;
if ( v6 > (int)v4 )
break;
LABEL_11:
++v4;
++v5;
if ( v4 == a2 - 1 )
return 0LL;
}
v8 = v5;
v9 = v4;
while ( a2 <= ++v7 )
{
LABEL_10:
++v9;
++v8;
if ( v7 == v6 )
goto LABEL_11;
}
v10 = *(v5 - 1);
v11 = (_DWORD *)(a1 + 4LL * v7);
while ( v10 + *v8 + *v11 != a3 )
{
if ( (_DWORD *)(a1 + 8 + 4 * (v9 + (unsigned int)(v6 - v7))) == ++v11 )
goto LABEL_10;
}
*a4 = v10;
a4[1] = *v8;
a4[2] = *v11;
return 1LL;
} | func0:
ENDBR64
MOV R9D,ESI
CMP ESI,0x2
JLE 0x001013e3
PUSH R15
LEA R15D,[R9 + -0x1]
MOV ESI,EDX
MOV RDX,RCX
PUSH R14
MOV ECX,0x1
MOV R10,RDI
LEA R14,[RDI + 0x8]
PUSH R13
MOV R8,RCX
LEA R13,[RDI + 0x4]
MOV RCX,RDX
PUSH R12
MOV EDX,R9D
PUSH RBP
PUSH RBX
MOV RBX,R15
MOV qword ptr [RSP + -0x10],R15
LAB_00101344:
MOV EBP,R8D
CMP EBX,R8D
JLE 0x001013c9
MOV qword ptr [RSP + -0x8],R8
MOV R11,R13
MOV R15,R8
LAB_00101357:
ADD EBP,0x1
CMP EDX,EBP
JLE 0x001013b8
MOV EDI,EBX
MOV R12D,dword ptr [R13 + -0x4]
MOV R8D,dword ptr [R11]
MOVSXD RAX,EBP
SUB EDI,EBP
LEA RAX,[R10 + RAX*0x4]
ADD RDI,R15
ADD R8D,R12D
LEA R9,[R14 + RDI*0x4]
JMP 0x00101389
LAB_00101380:
ADD RAX,0x4
CMP R9,RAX
JZ 0x001013b8
LAB_00101389:
MOV EDI,dword ptr [RAX]
ADD EDI,R8D
CMP EDI,ESI
JNZ 0x00101380
MOV dword ptr [RCX],R12D
MOV RDX,RCX
MOV ECX,dword ptr [R11]
MOV dword ptr [RDX + 0x4],ECX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX + 0x8],EAX
MOV EAX,0x1
LAB_001013a8:
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001013b8:
ADD R15,0x1
ADD R11,0x4
CMP EBP,EBX
JNZ 0x00101357
MOV R8,qword ptr [RSP + -0x8]
LAB_001013c9:
MOV RAX,qword ptr [RSP + -0x10]
ADD R8,0x1
ADD R13,0x4
CMP R8,RAX
JNZ 0x00101344
XOR EAX,EAX
JMP 0x001013a8
LAB_001013e3:
XOR EAX,EAX
RET | int8 func0(long param_1,int param_2,int param_3,int *param_4)
{
int *piVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
int *piVar5;
int *piVar6;
uint uVar7;
ulong uVar8;
if (param_2 < 3) {
return 0;
}
uVar7 = param_2 - 1;
uVar4 = 1;
piVar6 = (int *)(param_1 + 4);
do {
uVar3 = uVar4 & 0xffffffff;
piVar5 = piVar6;
uVar8 = uVar4;
if ((int)uVar4 < (int)uVar7) {
do {
uVar2 = (int)uVar3 + 1;
uVar3 = (ulong)uVar2;
if ((int)uVar2 < param_2) {
piVar1 = (int *)(param_1 + (long)(int)uVar2 * 4);
do {
if (*piVar1 + *piVar5 + piVar6[-1] == param_3) {
*param_4 = piVar6[-1];
param_4[1] = *piVar5;
param_4[2] = *piVar1;
return 1;
}
piVar1 = piVar1 + 1;
} while ((int *)(param_1 + 8 + ((uVar7 - uVar2) + uVar8) * 4) != piVar1);
}
piVar5 = piVar5 + 1;
uVar8 = uVar8 + 1;
} while (uVar2 != uVar7);
}
uVar4 = uVar4 + 1;
piVar6 = piVar6 + 1;
} while (uVar4 != uVar7);
return 0;
} |
7,560 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
| char* func0(char* text) {
regex_t regex;
int reti;
char* patterns = "[A-Z]+[a-z]+$";
regcomp(®ex, patterns, REG_EXTENDED);
reti = regexec(®ex, text, 0, NULL, 0);
if (!reti) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(strcmp(func0("AaBbGg"), "Found a match!") == 0);
assert(strcmp(func0("aA"), "Not matched!") == 0);
assert(strcmp(func0("PYTHON"), "Not matched!") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe19(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10b0 <regcomp@plt>
mov -0x68(%rbp),%rsi
lea -0x50(%rbp),%rax
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 10d0 <regexec@plt>
mov %eax,-0x5c(%rbp)
cmpl $0x0,-0x5c(%rbp)
jne 123d <func0+0x74>
lea 0xddb(%rip),%rax
jmp 1244 <func0+0x7b>
lea 0xde1(%rip),%rax
mov -0x8(%rbp),%rdx
xor %fs:0x28,%rdx
je 1258 <func0+0x8f>
callq 1090 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aAZAZ; "[A-Z]+[a-z]+$"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov rsi, [rbp+string]; 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_5C], eax
cmp [rbp+var_5C], 0
jnz short loc_123D
lea rax, s2; "Found a match!"
jmp short loc_1244
loc_123D:
lea rax, aNotMatched; "Not matched!"
loc_1244:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1258
call ___stack_chk_fail
locret_1258:
leave
retn | const char * func0(const char *a1)
{
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v3; // [rsp+68h] [rbp-8h]
v3 = __readfsqword(0x28u);
regcomp(&preg, "[A-Z]+[a-z]+$", 1);
if ( regexec(&preg, a1, 0LL, 0LL, 0) )
return "Not matched!";
else
return "Found a match!";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010b0
MOV RSI,qword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x50]
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x5c],EAX
CMP dword ptr [RBP + -0x5c],0x0
JNZ 0x0010123d
LEA RAX,[0x102016]
JMP 0x00101244
LAB_0010123d:
LEA RAX,[0x102025]
LAB_00101244:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101258
CALL 0x00101090
LAB_00101258:
LEAVE
RET | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&local_58,"[A-Z]+[a-z]+$",1);
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
if (iVar1 == 0) {
pcVar2 = "Found a match!";
}
else {
pcVar2 = "Not matched!";
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
7,561 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
| char* func0(char* text) {
regex_t regex;
int reti;
char* patterns = "[A-Z]+[a-z]+$";
regcomp(®ex, patterns, REG_EXTENDED);
reti = regexec(®ex, text, 0, NULL, 0);
if (!reti) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(strcmp(func0("AaBbGg"), "Found a match!") == 0);
assert(strcmp(func0("aA"), "Not matched!") == 0);
assert(strcmp(func0("PYTHON"), "Not matched!") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov $0x1,%edx
lea 0xe4b(%rip),%rsi
mov %rbp,%rdi
callq 10a0 <regcomp@plt>
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 10b0 <regexec@plt>
test %eax,%eax
lea 0xe03(%rip),%rax
lea 0xe0b(%rip),%rdx
cmovne %rdx,%rax
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 1223 <func0+0x7a>
add $0x58,%rsp
pop %rbx
pop %rbp
retq
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov edx, 1
lea rsi, aAZAZ; "[A-Z]+[a-z]+$"
mov rdi, rbp
call _regcomp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
mov rdi, rbp
call _regexec
test eax, eax
lea rax, aFoundAMatch; "Found a match!"
lea rdx, aNotMatched; "Not matched!"
cmovnz rax, rdx
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_1243
add rsp, 58h
pop rbx
pop rbp
retn
loc_1243:
call ___stack_chk_fail | const char * func0(long long a1)
{
bool v1; // zf
const char *result; // rax
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "[A-Z]+[a-z]+$", 1LL);
v1 = (unsigned int)regexec(_0, a1, 0LL, 0LL, 0LL) == 0;
result = "Found a match!";
if ( !v1 )
return "Not matched!";
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV EDX,0x1
LEA RSI,[0x102020]
MOV RDI,RBP
CALL 0x001010b0
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010d0
TEST EAX,EAX
LEA RAX,[0x102004]
LEA RDX,[0x102013]
CMOVNZ RAX,RDX
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101243
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_00101243:
CALL 0x00101090 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"[A-Z]+[a-z]+$",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
pcVar2 = "Found a match!";
if (iVar1 != 0) {
pcVar2 = "Not matched!";
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,562 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
| char* func0(char* text) {
regex_t regex;
int reti;
char* patterns = "[A-Z]+[a-z]+$";
regcomp(®ex, patterns, REG_EXTENDED);
reti = regexec(®ex, text, 0, NULL, 0);
if (!reti) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(strcmp(func0("AaBbGg"), "Found a match!") == 0);
assert(strcmp(func0("aA"), "Not matched!") == 0);
assert(strcmp(func0("PYTHON"), "Not matched!") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xd7e(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10a0 <regcomp@plt>
xor %ecx,%ecx
xor %edx,%edx
xor %r8d,%r8d
mov %rbp,%rsi
mov %r12,%rdi
callq 10b0 <regexec@plt>
lea 0xd35(%rip),%rdx
test %eax,%eax
lea 0xd1d(%rip),%rax
cmovne %rdx,%rax
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 1303 <func0+0x73>
add $0x58,%rsp
pop %rbp
pop %r12
retq
callq 1080 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
mov edx, 1
lea rsi, aAZAZ; "[A-Z]+[a-z]+$"
push rbp
mov rbp, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov r12, rsp
mov rdi, r12
call _regcomp
xor edx, edx
xor r8d, r8d
xor ecx, ecx
mov rsi, rbp
mov rdi, r12
call _regexec
lea rdx, aNotMatched; "Not matched!"
test eax, eax
lea rax, aFoundAMatch; "Found a match!"
cmovnz rax, rdx
mov rdx, [rsp+68h+var_20]
sub rdx, fs:28h
jnz short loc_1313
add rsp, 58h
pop rbp
pop r12
retn
loc_1313:
call ___stack_chk_fail | const char * func0(long long a1)
{
bool v1; // zf
const char *result; // rax
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
v3[9] = __readfsqword(0x28u);
regcomp(v3, "[A-Z]+[a-z]+$", 1LL);
v1 = (unsigned int)regexec(v3, a1, 0LL, 0LL, 0LL) == 0;
result = "Found a match!";
if ( !v1 )
return "Not matched!";
return result;
} | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
LEA RSI,[0x102020]
PUSH RBP
MOV RBP,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV R12,RSP
MOV RDI,R12
CALL 0x001010b0
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBP
MOV RDI,R12
CALL 0x001010d0
LEA RDX,[0x102013]
TEST EAX,EAX
LEA RAX,[0x102004]
CMOVNZ RAX,RDX
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101313
ADD RSP,0x58
POP RBP
POP R12
RET
LAB_00101313:
CALL 0x00101090 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"[A-Z]+[a-z]+$",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
pcVar2 = "Found a match!";
if (iVar1 != 0) {
pcVar2 = "Not matched!";
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,563 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
| char* func0(char* text) {
regex_t regex;
int reti;
char* patterns = "[A-Z]+[a-z]+$";
regcomp(®ex, patterns, REG_EXTENDED);
reti = regexec(®ex, text, 0, NULL, 0);
if (!reti) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(strcmp(func0("AaBbGg"), "Found a match!") == 0);
assert(strcmp(func0("aA"), "Not matched!") == 0);
assert(strcmp(func0("PYTHON"), "Not matched!") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xd7e(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10a0 <regcomp@plt>
xor %ecx,%ecx
xor %edx,%edx
xor %r8d,%r8d
mov %rbp,%rsi
mov %r12,%rdi
callq 10b0 <regexec@plt>
lea 0xd35(%rip),%rdx
test %eax,%eax
lea 0xd1d(%rip),%rax
cmovne %rdx,%rax
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 1303 <func0+0x73>
add $0x58,%rsp
pop %rbp
pop %r12
retq
callq 1080 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov edx, 1; cflags
lea rsi, pattern; "[A-Z]+[a-z]+$"
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
xor edx, edx; nmatch
xor r8d, r8d; eflags
xor ecx, ecx; pmatch
mov rsi, rbx; string
mov rdi, rbp; preg
call _regexec
lea rdx, s2; "Found a match!"
test eax, eax
lea rax, aNotMatched; "Not matched!"
cmovz rax, rdx
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_1311
add rsp, 58h
pop rbx
pop rbp
retn
loc_1311:
call ___stack_chk_fail | const char * func0(char *string)
{
bool v1; // zf
const char *result; // rax
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
regcomp(&_0, "[A-Z]+[a-z]+$", 1);
v1 = regexec(&_0, string, 0LL, 0LL, 0) == 0;
result = "Not matched!";
if ( v1 )
return "Found a match!";
return result;
} | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
LEA RSI,[0x102020]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010b0
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010d0
LEA RDX,[0x102004]
TEST EAX,EAX
LEA RAX,[0x102013]
CMOVZ RAX,RDX
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101311
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_00101311:
CALL 0x00101090 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"[A-Z]+[a-z]+$",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
pcVar2 = "Not matched!";
if (iVar1 == 0) {
pcVar2 = "Found a match!";
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,564 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int S[], int m, int n) {
int table[n + 1][m];
for (int i = 0; i < m; i++) {
table[0][i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) {
int x = (i - S[j] >= 0) ? table[i - S[j]][j] : 0;
int y = (j >= 1) ? table[i][j-1] : 0;
table[i][j] = x + y;
}
}
return table[n][m-1];
}
| int main() {
int S1[] = {1, 2, 3};
int m1 = 3;
int n1 = 4;
assert(func0(S1, m1, n1) == 4);
int S2[] = {4, 5, 6, 7, 8, 9};
int m2 = 6;
int n2 = 9;
assert(func0(S2, m2, n2) == 2);
int S3[] = {4, 5, 6, 7, 8, 9};
int m3 = 6;
int n3 = 4;
assert(func0(S3, m3, n3) == 1);
printf("All test cases passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %edx,-0x80(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,-0x98(%rbp)
mov -0x7c(%rbp),%ecx
mov -0x80(%rbp),%eax
lea 0x1(%rax),%edi
movslq %ecx,%rax
sub $0x1,%rax
mov %rax,-0x50(%rbp)
movslq %ecx,%rax
mov %rax,-0x90(%rbp)
movq $0x0,-0x88(%rbp)
movslq %ecx,%rax
lea 0x0(,%rax,4),%rsi
movslq %edi,%rax
sub $0x1,%rax
mov %rax,-0x48(%rbp)
movslq %ecx,%rax
mov %rax,%r14
mov $0x0,%r15d
movslq %edi,%rax
mov %rax,%r12
mov $0x0,%r13d
mov %r15,%rdx
imul %r12,%rdx
mov %r13,%rax
imul %r14,%rax
lea (%rdx,%rax,1),%rbx
mov %r14,%rax
mul %r12
add %rdx,%rbx
mov %rbx,%rdx
movslq %ecx,%rax
mov %rax,%r10
mov $0x0,%r11d
movslq %edi,%rax
mov %rax,%r8
mov $0x0,%r9d
mov %r11,%rdx
imul %r8,%rdx
mov %r9,%rax
imul %r10,%rax
lea (%rdx,%rax,1),%rbx
mov %r10,%rax
mul %r8
lea (%rbx,%rdx,1),%r8
mov %r8,%rdx
movslq %ecx,%rdx
movslq %edi,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%ebx
mov $0x0,%edx
div %rbx
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 12c6 <func0+0x13d>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 12af <func0+0x126>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 12f0 <func0+0x167>
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,-0x40(%rbp)
movl $0x0,-0x5c(%rbp)
jmp 1321 <func0+0x198>
mov -0x40(%rbp),%rax
mov -0x5c(%rbp),%edx
movslq %edx,%rdx
movl $0x1,(%rax,%rdx,4)
addl $0x1,-0x5c(%rbp)
mov -0x5c(%rbp),%eax
cmp -0x7c(%rbp),%eax
jl 130c <func0+0x183>
movl $0x1,-0x60(%rbp)
jmpq 141a <func0+0x291>
movl $0x0,-0x64(%rbp)
jmpq 140a <func0+0x281>
mov -0x64(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x60(%rbp),%edx
sub %eax,%edx
mov %edx,%eax
test %eax,%eax
js 13a0 <func0+0x217>
mov %rsi,%rdi
shr $0x2,%rdi
mov -0x64(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x60(%rbp),%edx
sub %eax,%edx
mov %edx,%r8d
mov -0x40(%rbp),%rax
mov -0x64(%rbp),%edx
movslq %edx,%rcx
movslq %r8d,%rdx
imul %rdi,%rdx
add %rcx,%rdx
mov (%rax,%rdx,4),%eax
jmp 13a5 <func0+0x21c>
mov $0x0,%eax
mov %eax,-0x58(%rbp)
cmpl $0x0,-0x64(%rbp)
jle 13d4 <func0+0x24b>
mov %rsi,%rdi
shr $0x2,%rdi
mov -0x64(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x40(%rbp),%rax
movslq %edx,%rcx
mov -0x60(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rcx,%rdx
mov (%rax,%rdx,4),%eax
jmp 13d9 <func0+0x250>
mov $0x0,%eax
mov %eax,-0x54(%rbp)
mov %rsi,%r8
shr $0x2,%r8
mov -0x58(%rbp),%edx
mov -0x54(%rbp),%eax
lea (%rdx,%rax,1),%ecx
mov -0x40(%rbp),%rax
mov -0x64(%rbp),%edx
movslq %edx,%rdi
mov -0x60(%rbp),%edx
movslq %edx,%rdx
imul %r8,%rdx
add %rdi,%rdx
mov %ecx,(%rax,%rdx,4)
addl $0x1,-0x64(%rbp)
mov -0x64(%rbp),%eax
cmp -0x7c(%rbp),%eax
jl 1341 <func0+0x1b8>
addl $0x1,-0x60(%rbp)
mov -0x60(%rbp),%eax
cmp -0x80(%rbp),%eax
jle 1335 <func0+0x1ac>
shr $0x2,%rsi
mov -0x7c(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x40(%rbp),%rax
movslq %edx,%rcx
mov -0x80(%rbp),%edx
movslq %edx,%rdx
imul %rsi,%rdx
add %rcx,%rdx
mov (%rax,%rdx,4),%eax
mov -0x98(%rbp),%rsp
mov -0x38(%rbp),%rsi
xor %fs:0x28,%rsi
je 1462 <func0+0x2d9>
callq 1080 <__stack_chk_fail@plt>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov [rbp+var_60], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov r11, rax
mov esi, [rbp+var_5C]
mov eax, [rbp+var_60]
lea r8d, [rax+1]
movsxd rax, esi
sub rax, 1
mov [rbp+var_30], rax
movsxd rax, esi
lea rdi, ds:0[rax*4]
movsxd rax, r8d
sub rax, 1
mov [rbp+var_28], rax
movsxd rax, esi
mov rcx, rax
mov ebx, 0
movsxd rax, r8d
mov rax, rax
mov edx, 0
mov r10, rbx
imul r10, rax
mov r9, rdx
imul r9, rcx
add r9, r10
mul rcx
lea rcx, [r9+rdx]
mov rdx, rcx
movsxd rax, esi
mov rcx, rax
mov ebx, 0
movsxd rax, r8d
mov rax, rax
mov edx, 0
mov r10, rbx
imul r10, rax
mov r9, rdx
imul r9, rcx
add r9, r10
mul rcx
lea rcx, [r9+rdx]
mov rdx, rcx
movsxd rdx, esi
movsxd rax, r8d
imul rax, rdx
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov ebx, 10h
mov edx, 0
div rbx
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_1281:
cmp rsp, rdx
jz short loc_1298
sub rsp, 1000h
or [rsp+1060h+var_68], 0
jmp short loc_1281
loc_1298:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_12C2
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_12C2:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov [rbp+var_44], 0
jmp short loc_12F3
loc_12DE:
mov rax, [rbp+var_20]
mov edx, [rbp+var_44]
movsxd rdx, edx
mov dword ptr [rax+rdx*4], 1
add [rbp+var_44], 1
loc_12F3:
mov eax, [rbp+var_44]
cmp eax, [rbp+var_5C]
jl short loc_12DE
mov [rbp+var_40], 1
jmp loc_13EA
loc_1307:
mov [rbp+var_3C], 0
jmp loc_13DA
loc_1313:
mov eax, [rbp+var_3C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_40]
sub edx, eax
test edx, edx
js short loc_1370
mov rsi, rdi
shr rsi, 2
mov eax, [rbp+var_3C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_58]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_40]
sub edx, eax
mov r8d, edx
mov rax, [rbp+var_20]
mov edx, [rbp+var_3C]
movsxd rcx, edx
movsxd rdx, r8d
imul rdx, rsi
add rdx, rcx
mov eax, [rax+rdx*4]
jmp short loc_1375
loc_1370:
mov eax, 0
loc_1375:
mov [rbp+var_38], eax
cmp [rbp+var_3C], 0
jle short loc_13A4
mov rsi, rdi
shr rsi, 2
mov eax, [rbp+var_3C]
lea edx, [rax-1]
mov rax, [rbp+var_20]
movsxd rcx, edx
mov edx, [rbp+var_40]
movsxd rdx, edx
imul rdx, rsi
add rdx, rcx
mov eax, [rax+rdx*4]
jmp short loc_13A9
loc_13A4:
mov eax, 0
loc_13A9:
mov [rbp+var_34], eax
mov r8, rdi
shr r8, 2
mov edx, [rbp+var_38]
mov eax, [rbp+var_34]
lea ecx, [rdx+rax]
mov rax, [rbp+var_20]
mov edx, [rbp+var_3C]
movsxd rsi, edx
mov edx, [rbp+var_40]
movsxd rdx, edx
imul rdx, r8
add rdx, rsi
mov [rax+rdx*4], ecx
add [rbp+var_3C], 1
loc_13DA:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_5C]
jl loc_1313
add [rbp+var_40], 1
loc_13EA:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_60]
jle loc_1307
shr rdi, 2
mov rsi, rdi
mov eax, [rbp+var_5C]
lea edx, [rax-1]
mov rax, [rbp+var_20]
movsxd rcx, edx
mov edx, [rbp+var_60]
movsxd rdx, edx
imul rdx, rsi
add rdx, rcx
mov eax, [rax+rdx*4]
mov rsp, r11
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1431
call ___stack_chk_fail
loc_1431:
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2, int a3)
{
unsigned long long v3; // rdi
unsigned long long v4; // rax
void *v5; // rsp
int v6; // eax
int v7; // eax
int v9; // [rsp+8h] [rbp-60h] BYREF
int v10; // [rsp+Ch] [rbp-5Ch]
long long v11; // [rsp+10h] [rbp-58h]
int i; // [rsp+24h] [rbp-44h]
int j; // [rsp+28h] [rbp-40h]
int k; // [rsp+2Ch] [rbp-3Ch]
int v15; // [rsp+30h] [rbp-38h]
int v16; // [rsp+34h] [rbp-34h]
long long v17; // [rsp+38h] [rbp-30h]
long long v18; // [rsp+40h] [rbp-28h]
int *v19; // [rsp+48h] [rbp-20h]
unsigned long long v20; // [rsp+50h] [rbp-18h]
v11 = a1;
v10 = a2;
v9 = a3;
v20 = __readfsqword(0x28u);
v17 = a2 - 1LL;
v3 = 4LL * a2;
v18 = a3 + 1 - 1LL;
v4 = 16 * ((4 * a2 * (long long)(a3 + 1) + 15) / 0x10uLL);
while ( &v9 != (int *)((char *)&v9 - (v4 & 0xFFFFFFFFFFFFF000LL)) )
;
v5 = alloca(v4 & 0xFFF);
if ( (v4 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v9 + (v4 & 0xFFF) - 8) = *(_QWORD *)((char *)&v9 + (v4 & 0xFFF) - 8);
v19 = &v9;
for ( i = 0; i < v10; ++i )
v19[i] = 1;
for ( j = 1; j <= v9; ++j )
{
for ( k = 0; k < v10; ++k )
{
if ( j - *(_DWORD *)(4LL * k + v11) < 0 )
v6 = 0;
else
v6 = v19[k + (v3 >> 2) * (j - *(_DWORD *)(4LL * k + v11))];
v15 = v6;
if ( k <= 0 )
v7 = 0;
else
v7 = v19[k - 1 + (v3 >> 2) * j];
v16 = v7;
v19[k + (v3 >> 2) * j] = v15 + v7;
}
}
return (unsigned int)v19[v10 - 1 + (v3 >> 2) * v9];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV dword ptr [RBP + -0x60],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV R11,RAX
MOV ESI,dword ptr [RBP + -0x5c]
MOV EAX,dword ptr [RBP + -0x60]
LEA R8D,[RAX + 0x1]
MOVSXD RAX,ESI
SUB RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOVSXD RAX,ESI
LEA RDI,[RAX*0x4]
MOVSXD RAX,R8D
SUB RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOVSXD RAX,ESI
MOV RCX,RAX
MOV EBX,0x0
MOVSXD RAX,R8D
MOV RAX,RAX
MOV EDX,0x0
MOV R10,RBX
IMUL R10,RAX
MOV R9,RDX
IMUL R9,RCX
ADD R9,R10
MUL RCX
LEA RCX,[R9 + RDX*0x1]
MOV RDX,RCX
MOVSXD RAX,ESI
MOV RCX,RAX
MOV EBX,0x0
MOVSXD RAX,R8D
MOV RAX,RAX
MOV EDX,0x0
MOV R10,RBX
IMUL R10,RAX
MOV R9,RDX
IMUL R9,RCX
ADD R9,R10
MUL RCX
LEA RCX,[R9 + RDX*0x1]
MOV RDX,RCX
MOVSXD RDX,ESI
MOVSXD RAX,R8D
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EBX,0x10
MOV EDX,0x0
DIV RBX
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_00101281:
CMP RSP,RDX
JZ 0x00101298
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101281
LAB_00101298:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x001012c2
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_001012c2:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x44],0x0
JMP 0x001012f3
LAB_001012de:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x44]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],0x1
ADD dword ptr [RBP + -0x44],0x1
LAB_001012f3:
MOV EAX,dword ptr [RBP + -0x44]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x001012de
MOV dword ptr [RBP + -0x40],0x1
JMP 0x001013ea
LAB_00101307:
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x001013da
LAB_00101313:
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x40]
SUB EDX,EAX
TEST EDX,EDX
JS 0x00101370
MOV RSI,RDI
SHR RSI,0x2
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x40]
SUB EDX,EAX
MOV R8D,EDX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x3c]
MOVSXD RCX,EDX
MOVSXD RDX,R8D
IMUL RDX,RSI
ADD RDX,RCX
MOV EAX,dword ptr [RAX + RDX*0x4]
JMP 0x00101375
LAB_00101370:
MOV EAX,0x0
LAB_00101375:
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x3c],0x0
JLE 0x001013a4
MOV RSI,RDI
SHR RSI,0x2
MOV EAX,dword ptr [RBP + -0x3c]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,EDX
MOV EDX,dword ptr [RBP + -0x40]
MOVSXD RDX,EDX
IMUL RDX,RSI
ADD RDX,RCX
MOV EAX,dword ptr [RAX + RDX*0x4]
JMP 0x001013a9
LAB_001013a4:
MOV EAX,0x0
LAB_001013a9:
MOV dword ptr [RBP + -0x34],EAX
MOV R8,RDI
SHR R8,0x2
MOV EDX,dword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x34]
LEA ECX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x3c]
MOVSXD RSI,EDX
MOV EDX,dword ptr [RBP + -0x40]
MOVSXD RDX,EDX
IMUL RDX,R8
ADD RDX,RSI
MOV dword ptr [RAX + RDX*0x4],ECX
ADD dword ptr [RBP + -0x3c],0x1
LAB_001013da:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x00101313
ADD dword ptr [RBP + -0x40],0x1
LAB_001013ea:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x60]
JLE 0x00101307
SHR RDI,0x2
MOV RSI,RDI
MOV EAX,dword ptr [RBP + -0x5c]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,EDX
MOV EDX,dword ptr [RBP + -0x60]
MOVSXD RDX,EDX
IMUL RDX,RSI
ADD RDX,RCX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,R11
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101431
CALL 0x00101080
LAB_00101431:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int4 func0(long param_1,int param_2,int param_3)
{
long lVar1;
ulong uVar2;
ulong uVar3;
int *piVar4;
long in_FS_OFFSET;
int local_68;
int local_64;
long local_60;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
long local_38;
long local_30;
int *local_28;
long local_20;
local_60 = param_1;
local_64 = param_2;
local_68 = param_3;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_38 = (long)param_2 + -1;
uVar2 = (ulong)param_2;
local_30 = (long)(param_3 + 1) + -1;
uVar3 = (((long)(param_3 + 1) * (long)param_2 * 4 + 0xfU) / 0x10) * 0x10;
for (piVar4 = &local_68; piVar4 != (int *)((long)&local_68 - (uVar3 & 0xfffffffffffff000));
piVar4 = (int *)((long)piVar4 + -0x1000)) {
*(int8 *)((long)piVar4 + -8) = *(int8 *)((long)piVar4 + -8);
}
lVar1 = -(ulong)((uint)uVar3 & 0xfff);
if ((uVar3 & 0xfff) != 0) {
*(int8 *)((long)piVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1) =
*(int8 *)((long)piVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1);
}
for (local_4c = 0; local_4c < local_64; local_4c = local_4c + 1) {
*(int4 *)((long)piVar4 + (long)local_4c * 4 + lVar1) = 1;
}
for (local_48 = 1; local_48 <= local_68; local_48 = local_48 + 1) {
for (local_44 = 0; local_44 < local_64; local_44 = local_44 + 1) {
if (local_48 - *(int *)(local_60 + (long)local_44 * 4) < 0) {
local_40 = 0;
}
else {
local_40 = *(int *)((long)piVar4 +
((long)(local_48 - *(int *)(local_60 + (long)local_44 * 4)) *
(uVar2 & 0x3fffffffffffffff) + (long)local_44) * 4 + lVar1);
}
if (local_44 < 1) {
local_3c = 0;
}
else {
local_3c = *(int *)((long)piVar4 +
((long)local_48 * (uVar2 & 0x3fffffffffffffff) + (long)(local_44 + -1)) *
4 + lVar1);
}
*(int *)((long)piVar4 +
((long)local_48 * (uVar2 & 0x3fffffffffffffff) + (long)local_44) * 4 + lVar1) =
local_40 + local_3c;
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
local_28 = (int *)((long)piVar4 + lVar1);
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)
((long)piVar4 +
((long)local_68 * (uVar2 & 0x3fffffffffffffff) + (long)(local_64 + -1)) * 4 + lVar1);
} |
7,565 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int S[], int m, int n) {
int table[n + 1][m];
for (int i = 0; i < m; i++) {
table[0][i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) {
int x = (i - S[j] >= 0) ? table[i - S[j]][j] : 0;
int y = (j >= 1) ? table[i][j-1] : 0;
table[i][j] = x + y;
}
}
return table[n][m-1];
}
| int main() {
int S1[] = {1, 2, 3};
int m1 = 3;
int n1 = 4;
assert(func0(S1, m1, n1) == 4);
int S2[] = {4, 5, 6, 7, 8, 9};
int m2 = 6;
int n2 = 9;
assert(func0(S2, m2, n2) == 2);
int S3[] = {4, 5, 6, 7, 8, 9};
int m3 = 6;
int n3 = 4;
assert(func0(S3, m3, n3) == 1);
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x28,%rsp
mov %esi,%r14d
mov %edx,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %esi,%rcx
lea 0x0(,%rcx,4),%r13
add $0x1,%edx
movslq %edx,%rax
imul %rcx,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 11fd <func0+0x74>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11e6 <func0+0x5d>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 1213 <func0+0x8a>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%rbx
mov %rbx,-0x50(%rbp)
mov %rbx,%r12
test %r14d,%r14d
jle 123d <func0+0xb4>
mov %rbx,%rax
lea -0x1(%r14),%edx
lea 0x4(%rbx,%rdx,4),%rdx
movl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 122e <func0+0xa5>
mov -0x44(%rbp),%eax
test %eax,%eax
jle 12c2 <func0+0x139>
mov %r13,%rbx
shr $0x2,%rbx
mov -0x50(%rbp),%rsi
lea (%rsi,%r13,1),%r10
lea 0x1(%rax),%r15d
mov %r10,%rsi
mov $0x1,%r8d
lea -0x1(%r14),%r11d
mov $0x0,%r9d
jmp 12b6 <func0+0x12d>
mov %r9d,%edx
test %eax,%eax
jle 1277 <func0+0xee>
mov -0x4(%rsi,%rax,4),%edx
add %ecx,%edx
mov %edx,(%r10,%rax,4)
lea 0x1(%rax),%rdx
cmp %r11,%rax
je 12a7 <func0+0x11e>
mov %rdx,%rax
mov %r9d,%ecx
mov %r8d,%edx
sub (%rdi,%rax,4),%edx
js 126c <func0+0xe3>
movslq %eax,%rcx
movslq %edx,%rdx
imul %rbx,%rdx
add %rcx,%rdx
mov (%r12,%rdx,4),%ecx
jmp 126c <func0+0xe3>
add $0x1,%r8d
add %r13,%r10
add %r13,%rsi
cmp %r15d,%r8d
je 12c2 <func0+0x139>
mov $0x0,%eax
test %r14d,%r14d
jg 1289 <func0+0x100>
jmp 12a7 <func0+0x11e>
lea -0x1(%r14),%eax
movslq %eax,%rdx
movslq -0x44(%rbp),%rax
shr $0x2,%r13
imul %rax,%r13
lea (%rdx,%r13,1),%rax
mov -0x50(%rbp),%rbx
mov (%rbx,%rax,4),%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 12fe <func0+0x175>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14d, esi
mov ebx, edx
mov [rbp+var_44], edx
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rdx, esi
lea r13, ds:0[rdx*4]
lea eax, [rbx+1]
cdqe
imul rax, rdx
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11E4:
cmp rsp, rdx
jz short loc_11FB
sub rsp, 1000h
or [rsp+1050h+var_58], 0
jmp short loc_11E4
loc_11FB:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_1211
or [rsp+rax+50h+var_58], 0
loc_1211:
mov rbx, rsp
test r14d, r14d
jle short loc_1232
mov rax, rbx
mov edx, r14d
lea rdx, [rbx+rdx*4]
loc_1223:
mov dword ptr [rax], 1
add rax, 4
cmp rax, rdx
jnz short loc_1223
loc_1232:
mov eax, [rbp+var_44]
test eax, eax
jle short loc_12AC
mov r12, r13
shr r12, 2
lea r9, [rbx+r13]
lea r15d, [rax+1]
mov r11, r9
mov esi, 1
mov r10d, r14d
mov r8d, 0
jmp short loc_12A0
loc_125B:
mov ecx, r8d
test eax, eax
jle short loc_1267
mov ecx, [r11+rax*4-4]
loc_1267:
add edx, ecx
mov [r9+rax*4], edx
add rax, 1
cmp rax, r10
jz short loc_1292
loc_1276:
mov edx, r8d
mov ecx, esi
sub ecx, [rdi+rax*4]
js short loc_125B
movsxd rdx, eax
movsxd rcx, ecx
imul rcx, r12
add rdx, rcx
mov edx, [rbx+rdx*4]
jmp short loc_125B
loc_1292:
add esi, 1
add r9, r13
add r11, r13
cmp esi, r15d
jz short loc_12AC
loc_12A0:
mov eax, 0
test r14d, r14d
jg short loc_1276
jmp short loc_1292
loc_12AC:
lea eax, [r14-1]
cdqe
movsxd rdx, [rbp+var_44]
shr r13, 2
imul rdx, r13
add rax, rdx
mov eax, [rbx+rax*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_12E2
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_12E2:
call ___stack_chk_fail | long long func0(long long a1, int a2, int a3)
{
unsigned long long v4; // r13
__int16 v5; // cx
_BYTE *v6; // rdx
signed long long v7; // rax
void *v8; // rsp
_BYTE *v9; // rax
_BYTE *v10; // r9
int v11; // r15d
_BYTE *v12; // r11
int v13; // esi
int v14; // ecx
long long v15; // rax
int v16; // edx
_BYTE v19[12]; // [rsp+8h] [rbp-50h] BYREF
int v20; // [rsp+14h] [rbp-44h]
unsigned long long v21; // [rsp+20h] [rbp-38h]
v20 = a3;
v21 = __readfsqword(0x28u);
v4 = 4LL * a2;
v5 = (4 * a2 * (a3 + 1) + 15) & 0xFFF0;
v6 = &v19[-((4 * a2 * (long long)(a3 + 1) + 15) & 0xFFFFFFFFFFFFF000LL)];
while ( v19 != v6 )
;
v7 = v5 & 0xFFF;
v8 = alloca(v7);
if ( (v5 & 0xFFF) != 0 )
*(_QWORD *)&v19[v7 - 8] = *(_QWORD *)&v19[v7 - 8];
if ( a2 > 0 )
{
v9 = v19;
do
{
*(_DWORD *)v9 = 1;
v9 += 4;
}
while ( v9 != &v19[4 * a2] );
}
if ( v20 > 0 )
{
v10 = &v19[v4];
v11 = v20 + 1;
v12 = &v19[v4];
v13 = 1;
do
{
v15 = 0LL;
if ( a2 > 0 )
{
do
{
v16 = 0;
if ( v13 - *(_DWORD *)(a1 + 4 * v15) >= 0 )
v16 = *(_DWORD *)&v19[4 * (v4 >> 2) * (v13 - *(_DWORD *)(a1 + 4 * v15)) + 4 * (int)v15];
v14 = 0;
if ( (int)v15 > 0 )
v14 = *(_DWORD *)&v12[4 * v15 - 4];
*(_DWORD *)&v10[4 * v15++] = v14 + v16;
}
while ( v15 != a2 );
}
++v13;
v10 += v4;
v12 += v4;
}
while ( v13 != v11 );
}
return *(unsigned int *)&v19[4 * (v4 >> 2) * v20 - 4 + 4 * a2];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14D,ESI
MOV EBX,EDX
MOV dword ptr [RBP + -0x44],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RDX,ESI
LEA R13,[RDX*0x4]
LEA EAX,[RBX + 0x1]
CDQE
IMUL RAX,RDX
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011e4:
CMP RSP,RDX
JZ 0x001011fb
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011e4
LAB_001011fb:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x00101211
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_00101211:
MOV RBX,RSP
TEST R14D,R14D
JLE 0x00101232
MOV RAX,RBX
MOV EDX,R14D
LEA RDX,[RBX + RDX*0x4]
LAB_00101223:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101223
LAB_00101232:
MOV EAX,dword ptr [RBP + -0x44]
TEST EAX,EAX
JLE 0x001012ac
MOV R12,R13
SHR R12,0x2
LEA R9,[RBX + R13*0x1]
LEA R15D,[RAX + 0x1]
MOV R11,R9
MOV ESI,0x1
MOV R10D,R14D
MOV R8D,0x0
JMP 0x001012a0
LAB_0010125b:
MOV ECX,R8D
TEST EAX,EAX
JLE 0x00101267
MOV ECX,dword ptr [R11 + RAX*0x4 + -0x4]
LAB_00101267:
ADD EDX,ECX
MOV dword ptr [R9 + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,R10
JZ 0x00101292
LAB_00101276:
MOV EDX,R8D
MOV ECX,ESI
SUB ECX,dword ptr [RDI + RAX*0x4]
JS 0x0010125b
MOVSXD RDX,EAX
MOVSXD RCX,ECX
IMUL RCX,R12
ADD RDX,RCX
MOV EDX,dword ptr [RBX + RDX*0x4]
JMP 0x0010125b
LAB_00101292:
ADD ESI,0x1
ADD R9,R13
ADD R11,R13
CMP ESI,R15D
JZ 0x001012ac
LAB_001012a0:
MOV EAX,0x0
TEST R14D,R14D
JG 0x00101276
JMP 0x00101292
LAB_001012ac:
LEA EAX,[R14 + -0x1]
CDQE
MOVSXD RDX,dword ptr [RBP + -0x44]
SHR R13,0x2
IMUL RDX,R13
ADD RAX,RDX
MOV EAX,dword ptr [RBX + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012e2
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001012e2:
CALL 0x00101080 | int4 func0(long param_1,uint param_2,int param_3)
{
int iVar1;
long lVar2;
long lVar3;
int4 *puVar4;
ulong uVar5;
int iVar6;
ulong uVar7;
int1 *puVar8;
int iVar9;
int iVar10;
int1 *puVar11;
int1 *puVar12;
long in_FS_OFFSET;
int1 auStack_58 [12];
int local_4c;
long local_40;
local_4c = param_3;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar7 = (ulong)(int)param_2;
lVar2 = uVar7 * 4;
uVar5 = (long)(param_3 + 1) * uVar7 * 4 + 0xf;
for (puVar8 = auStack_58; puVar8 != auStack_58 + -(uVar5 & 0xfffffffffffff000);
puVar8 = puVar8 + -0x1000) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
uVar5 = (ulong)((uint)uVar5 & 0xff0);
lVar3 = -uVar5;
puVar4 = (int4 *)(puVar8 + lVar3);
if (uVar5 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
if (0 < (int)param_2) {
do {
*puVar4 = 1;
puVar4 = puVar4 + 1;
} while (puVar4 != (int4 *)(puVar8 + (ulong)param_2 * 4 + lVar3));
}
if (0 < local_4c) {
puVar11 = puVar8 + lVar2 + lVar3;
iVar1 = local_4c + 1;
iVar9 = 1;
puVar12 = puVar11;
do {
uVar5 = 0;
if (0 < (int)param_2) {
do {
iVar10 = 0;
iVar6 = iVar9 - *(int *)(param_1 + uVar5 * 4);
if (-1 < iVar6) {
iVar10 = *(int *)(puVar8 + ((long)(int)uVar5 +
(long)iVar6 * (uVar7 & 0x3fffffffffffffff)) * 4 + lVar3);
}
iVar6 = 0;
if (0 < (int)uVar5) {
iVar6 = *(int *)(puVar12 + uVar5 * 4 + -4);
}
*(int *)(puVar11 + uVar5 * 4) = iVar10 + iVar6;
uVar5 = uVar5 + 1;
} while (uVar5 != param_2);
}
iVar9 = iVar9 + 1;
puVar11 = puVar11 + lVar2;
puVar12 = puVar12 + lVar2;
} while (iVar9 != iVar1);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar8 + lVar3 + -8) = main;
__stack_chk_fail();
}
return *(int4 *)
(puVar8 + ((long)(int)(param_2 - 1) + (long)local_4c * (uVar7 & 0x3fffffffffffffff)) * 4 +
lVar3);
} |
7,566 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int S[], int m, int n) {
int table[n + 1][m];
for (int i = 0; i < m; i++) {
table[0][i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) {
int x = (i - S[j] >= 0) ? table[i - S[j]][j] : 0;
int y = (j >= 1) ? table[i][j-1] : 0;
table[i][j] = x + y;
}
}
return table[n][m-1];
}
| int main() {
int S1[] = {1, 2, 3};
int m1 = 3;
int n1 = 4;
assert(func0(S1, m1, n1) == 4);
int S2[] = {4, 5, 6, 7, 8, 9};
int m2 = 6;
int n2 = 9;
assert(func0(S2, m2, n2) == 2);
int S3[] = {4, 5, 6, 7, 8, 9};
int m3 = 6;
int n3 = 4;
assert(func0(S3, m3, n3) == 1);
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
movslq %edx,%r14
movslq %esi,%rdx
push %r13
lea 0x1(%r14),%r13d
push %r12
lea 0x0(,%rdx,4),%r12
push %rbx
mov %esi,%ebx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %r13d,%rax
mov %rsp,%rsi
imul %rdx,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rsi
and $0xfffffffffffffff0,%rdx
mov %rsi,%rax
cmp %rax,%rsp
je 1357 <func0+0x77>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1342 <func0+0x62>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 142d <func0+0x14d>
mov %r12,%rsi
mov %rsp,%rdx
shr $0x2,%rsi
test %ebx,%ebx
jle 1438 <func0+0x158>
lea -0x1(%rbx),%ecx
mov %rdx,%rax
mov %rcx,%r15
lea 0x4(%rdx,%rcx,4),%rcx
nopl 0x0(%rax)
movl $0x1,(%rax)
add $0x4,%rax
cmp %rcx,%rax
jne 1390 <func0+0xb0>
test %r14d,%r14d
jle 1402 <func0+0x122>
lea (%rdx,%r12,1),%r10
mov $0x1,%r9d
mov %r15d,%r11d
nopl 0x0(%rax)
xor %eax,%eax
test %ebx,%ebx
jg 13c3 <func0+0xe3>
jmp 13f6 <func0+0x116>
mov %rcx,%rax
xor %r8d,%r8d
mov %r9d,%ecx
sub (%rdi,%rax,4),%ecx
js 13df <func0+0xff>
movslq %ecx,%rcx
movslq %eax,%r8
imul %rsi,%rcx
add %r8,%rcx
mov (%rdx,%rcx,4),%r8d
test %rax,%rax
je 13e9 <func0+0x109>
add -0x4(%r10,%rax,4),%r8d
mov %r8d,(%r10,%rax,4)
lea 0x1(%rax),%rcx
cmp %rax,%r11
jne 13c0 <func0+0xe0>
add $0x1,%r9d
add %r12,%r10
cmp %r13d,%r9d
jne 13b8 <func0+0xd8>
imul %r14,%rsi
movslq %r15d,%r15
add %r15,%rsi
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
mov (%rdx,%rsi,4),%eax
jne 1441 <func0+0x161>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1369 <func0+0x89>
lea -0x1(%rbx),%r15d
jmpq 139f <func0+0xbf>
callq 1080 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
movsxd r9, esi
mov rbp, rsp
push r13
lea r13, ds:0[r9*4]
push r12
movsxd r12, edx
push rbx
mov rbx, r9
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea eax, [r12+1]
mov rcx, rsp
cdqe
imul rax, r9
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1351
loc_133C:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rcx
jnz short loc_133C
loc_1351:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_141A
loc_1363:
mov r11, r13
mov r10, rsp
shr r11, 2
test ebx, ebx
jle short loc_138F
mov edx, ebx
mov rax, r10
lea rdx, [r10+rdx*4]
nop word ptr [rax+rax+00h]
loc_1380:
mov dword ptr [rax], 1
add rax, 4
cmp rax, rdx
jnz short loc_1380
loc_138F:
test r12d, r12d
jle short loc_13F0
lea r8, [r10+r13]
mov esi, 1
nop dword ptr [rax]
loc_13A0:
xor eax, eax
test ebx, ebx
jle short loc_13E1
nop word ptr [rax+rax+00000000h]
loc_13B0:
xor ecx, ecx
mov edx, esi
sub edx, [rdi+rax*4]
js short loc_13CA
movsxd rdx, edx
movsxd rcx, eax
imul rdx, r11
add rdx, rcx
mov ecx, [r10+rdx*4]
loc_13CA:
test rax, rax
jz short loc_13D4
add ecx, [r8+rax*4-4]
loc_13D4:
mov [r8+rax*4], ecx
add rax, 1
cmp r9, rax
jnz short loc_13B0
loc_13E1:
lea eax, [rsi+1]
add r8, r13
cmp r12d, esi
jz short loc_13F0
mov esi, eax
jmp short loc_13A0
loc_13F0:
imul r12, r11
lea eax, [rbx-1]
cdqe
add rax, r12
mov eax, [r10+rax*4]
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz short loc_1425
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn
loc_141A:
or [rsp+rdx+1030h+var_1038], 0
jmp loc_1363
loc_1425:
call ___stack_chk_fail | long long func0(long long a1, int a2, int a3)
{
long long v3; // r9
unsigned long long v4; // r13
long long v5; // r12
long long v7; // rdx
_BYTE *v8; // rcx
__int16 v9; // dx
signed long long v10; // rdx
void *v11; // rsp
unsigned long long v12; // r11
_BYTE *v13; // rax
_BYTE *v14; // r8
int i; // esi
long long v16; // rax
int v17; // ecx
_BYTE v20[4088]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v21[6]; // [rsp+1008h] [rbp-30h] BYREF
v3 = a2;
v4 = 4LL * a2;
v5 = a3;
v21[1] = __readfsqword(0x28u);
v7 = 4 * a2 * (long long)(a3 + 1) + 15;
v8 = (char *)v21 - (v7 & 0xFFFFFFFFFFFFF000LL);
v9 = v7 & 0xFFF0;
if ( v21 != (_QWORD *)v8 )
{
while ( v20 != v8 )
;
}
v10 = v9 & 0xFFF;
v11 = alloca(v10);
if ( v10 )
*(_QWORD *)&v20[v10 - 8] = *(_QWORD *)&v20[v10 - 8];
v12 = v4 >> 2;
if ( a2 > 0 )
{
v13 = v20;
do
{
*(_DWORD *)v13 = 1;
v13 += 4;
}
while ( v13 != &v20[4 * a2] );
}
if ( (int)v5 > 0 )
{
v14 = &v20[v4];
for ( i = 1; ; ++i )
{
v16 = 0LL;
if ( a2 > 0 )
{
do
{
v17 = 0;
if ( i - *(_DWORD *)(a1 + 4 * v16) >= 0 )
v17 = *(_DWORD *)&v20[4 * (int)v16 + 4 * v12 * (i - *(_DWORD *)(a1 + 4 * v16))];
if ( v16 )
v17 += *(_DWORD *)&v14[4 * v16 - 4];
*(_DWORD *)&v14[4 * v16++] = v17;
}
while ( v3 != v16 );
}
v14 += v4;
if ( (_DWORD)v5 == i )
break;
}
}
return *(unsigned int *)&v20[4 * v12 * v5 - 4 + 4 * a2];
} | func0:
ENDBR64
PUSH RBP
MOVSXD R9,ESI
MOV RBP,RSP
PUSH R13
LEA R13,[R9*0x4]
PUSH R12
MOVSXD R12,EDX
PUSH RBX
MOV RBX,R9
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA EAX,[R12 + 0x1]
MOV RCX,RSP
CDQE
IMUL RAX,R9
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101351
LAB_0010133c:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x0010133c
LAB_00101351:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x0010141a
LAB_00101363:
MOV R11,R13
MOV R10,RSP
SHR R11,0x2
TEST EBX,EBX
JLE 0x0010138f
MOV EDX,EBX
MOV RAX,R10
LEA RDX,[R10 + RDX*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101380:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101380
LAB_0010138f:
TEST R12D,R12D
JLE 0x001013f0
LEA R8,[R10 + R13*0x1]
MOV ESI,0x1
NOP dword ptr [RAX]
LAB_001013a0:
XOR EAX,EAX
TEST EBX,EBX
JLE 0x001013e1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013b0:
XOR ECX,ECX
MOV EDX,ESI
SUB EDX,dword ptr [RDI + RAX*0x4]
JS 0x001013ca
MOVSXD RDX,EDX
MOVSXD RCX,EAX
IMUL RDX,R11
ADD RDX,RCX
MOV ECX,dword ptr [R10 + RDX*0x4]
LAB_001013ca:
TEST RAX,RAX
JZ 0x001013d4
ADD ECX,dword ptr [R8 + RAX*0x4 + -0x4]
LAB_001013d4:
MOV dword ptr [R8 + RAX*0x4],ECX
ADD RAX,0x1
CMP R9,RAX
JNZ 0x001013b0
LAB_001013e1:
LEA EAX,[RSI + 0x1]
ADD R8,R13
CMP R12D,ESI
JZ 0x001013f0
MOV ESI,EAX
JMP 0x001013a0
LAB_001013f0:
IMUL R12,R11
LEA EAX,[RBX + -0x1]
CDQE
ADD RAX,R12
MOV EAX,dword ptr [R10 + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101425
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_0010141a:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101363
LAB_00101425:
CALL 0x00101080 | int4 func0(long param_1,uint param_2,int param_3)
{
long lVar1;
int4 *puVar2;
ulong uVar3;
int iVar4;
int iVar5;
int1 *puVar6;
int iVar8;
int1 *puVar9;
ulong uVar10;
long in_FS_OFFSET;
bool bVar11;
int1 auStack_38 [8];
long local_30;
int1 *puVar7;
uVar10 = (ulong)(int)param_2;
puVar6 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (long)(param_3 + 1) * uVar10 * 4 + 0xf;
puVar7 = auStack_38;
puVar9 = auStack_38;
while (puVar7 != auStack_38 + -(uVar3 & 0xfffffffffffff000)) {
puVar6 = puVar9 + -0x1000;
*(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8);
puVar7 = puVar9 + -0x1000;
puVar9 = puVar9 + -0x1000;
}
uVar3 = (ulong)((uint)uVar3 & 0xff0);
lVar1 = -uVar3;
puVar2 = (int4 *)(puVar6 + lVar1);
puVar9 = puVar6 + lVar1;
if (uVar3 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (0 < (int)param_2) {
do {
*puVar2 = 1;
puVar2 = puVar2 + 1;
} while (puVar2 != (int4 *)(puVar6 + (ulong)param_2 * 4 + lVar1));
}
if (0 < param_3) {
iVar8 = 1;
do {
puVar9 = puVar9 + uVar10 * 4;
uVar3 = 0;
if (0 < (int)param_2) {
do {
iVar4 = 0;
iVar5 = iVar8 - *(int *)(param_1 + uVar3 * 4);
if (-1 < iVar5) {
iVar4 = *(int *)(puVar6 + ((long)iVar5 * (uVar10 & 0x3fffffffffffffff) +
(long)(int)uVar3) * 4 + lVar1);
}
if (uVar3 != 0) {
iVar4 = iVar4 + *(int *)(puVar9 + uVar3 * 4 + -4);
}
*(int *)(puVar9 + uVar3 * 4) = iVar4;
uVar3 = uVar3 + 1;
} while (uVar10 != uVar3);
}
bVar11 = param_3 != iVar8;
iVar8 = iVar8 + 1;
} while (bVar11);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)
(puVar6 + ((long)(int)(param_2 - 1) + (long)param_3 * (uVar10 & 0x3fffffffffffffff)) * 4
+ lVar1);
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar6 + lVar1 + -8) = 0x10142a;
__stack_chk_fail();
} |
7,567 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int S[], int m, int n) {
int table[n + 1][m];
for (int i = 0; i < m; i++) {
table[0][i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) {
int x = (i - S[j] >= 0) ? table[i - S[j]][j] : 0;
int y = (j >= 1) ? table[i][j-1] : 0;
table[i][j] = x + y;
}
}
return table[n][m-1];
}
| int main() {
int S1[] = {1, 2, 3};
int m1 = 3;
int n1 = 4;
assert(func0(S1, m1, n1) == 4);
int S2[] = {4, 5, 6, 7, 8, 9};
int m2 = 6;
int n2 = 9;
assert(func0(S2, m2, n2) == 2);
int S3[] = {4, 5, 6, 7, 8, 9};
int m3 = 6;
int n3 = 4;
assert(func0(S3, m3, n3) == 1);
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r14
push %r13
push %r12
push %rbx
movslq %edx,%rbx
movslq %esi,%rdx
lea 0x1(%rbx),%r13d
lea 0x0(,%rdx,4),%r12
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movslq %r13d,%rax
mov %rsp,%rcx
imul %rdx,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je 1343 <func0+0x73>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 132e <func0+0x5e>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1470 <func0+0x1a0>
mov %r12,%rdx
mov %rsp,%r11
lea -0x1(%rsi),%r14d
shr $0x2,%rdx
test %esi,%esi
jle 1446 <func0+0x176>
cmp $0x2,%r14d
jbe 147b <func0+0x1ab>
mov %esi,%ecx
movdqa 0xd31(%rip),%xmm0
mov %r11,%rax
shr $0x2,%ecx
shl $0x4,%rcx
add %r11,%rcx
nopl 0x0(%rax)
movups %xmm0,(%rax)
add $0x10,%rax
cmp %rcx,%rax
jne 1390 <func0+0xc0>
mov %esi,%eax
and $0xfffffffc,%eax
test $0x3,%sil
je 13d5 <func0+0x105>
movslq %eax,%rcx
movl $0x1,(%r11,%rcx,4)
lea 0x1(%rax),%ecx
cmp %ecx,%esi
jle 13d5 <func0+0x105>
movslq %ecx,%rcx
add $0x2,%eax
movl $0x1,(%r11,%rcx,4)
cmp %eax,%esi
jle 13d5 <func0+0x105>
cltq
movl $0x1,(%r11,%rax,4)
lea (%r11,%r12,1),%r9
mov $0x1,%r8d
mov %r14d,%r10d
test %ebx,%ebx
jle 1446 <func0+0x176>
nopw %cs:0x0(%rax,%rax,1)
xor %eax,%eax
jmp 140d <func0+0x13d>
nopl 0x0(%rax)
add -0x4(%r9,%rax,4),%esi
lea 0x1(%rax),%rcx
mov %esi,(%r9,%rax,4)
cmp %r10,%rax
je 143a <func0+0x16a>
mov %rcx,%rax
xor %esi,%esi
mov %r8d,%ecx
sub (%rdi,%rax,4),%ecx
js 1428 <func0+0x158>
movslq %ecx,%rcx
movslq %eax,%rsi
imul %rdx,%rcx
add %rsi,%rcx
mov (%r11,%rcx,4),%esi
test %rax,%rax
jne 13f8 <func0+0x128>
mov %esi,(%r9)
mov $0x1,%ecx
cmp %r10,%rax
jne 140a <func0+0x13a>
add $0x1,%r8d
add %r12,%r9
cmp %r13d,%r8d
jne 13f0 <func0+0x120>
imul %rbx,%rdx
movslq %r14d,%r14
add %r14,%rdx
mov -0x28(%rbp),%rbx
xor %fs:0x28,%rbx
mov (%r11,%rdx,4),%eax
jne 1482 <func0+0x1b2>
lea -0x20(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1355 <func0+0x85>
xor %eax,%eax
jmpq 13a7 <func0+0xd7>
callq 1080 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
movsxd r9, esi
mov rcx, r9
mov rbp, rsp
push r13
push r12
lea r12, ds:0[r9*4]
push rbx
movsxd rbx, edx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea eax, [rbx+1]
mov rsi, rsp
cdqe
imul rax, r9
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rsi, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rsi
jz short loc_132F
loc_131A:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rsi
jnz short loc_131A
loc_132F:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1473
loc_1341:
mov r11, r12
mov r10, rsp
lea r13d, [rcx-1]
shr r11, 2
test ecx, ecx
jle loc_1430
cmp r13d, 2
jbe loc_147E
mov edx, ecx
movdqa xmm0, cs:xmmword_2090
mov rax, r10
shr edx, 2
shl rdx, 4
lea rsi, [r10+rdx]
and edx, 10h
jz short loc_1390
lea rax, [r10+10h]
movups xmmword ptr [r10], xmm0
cmp rax, rsi
jz short loc_13A0
nop dword ptr [rax+rax+00h]
loc_1390:
movups xmmword ptr [rax], xmm0
add rax, 20h ; ' '
movups xmmword ptr [rax-10h], xmm0
cmp rax, rsi
jnz short loc_1390
loc_13A0:
test cl, 3
jz short loc_13D3
mov eax, ecx
and eax, 0FFFFFFFCh
loc_13AA:
movsxd rdx, eax
lea esi, [rax+1]
lea rdx, [r10+rdx*4]
mov dword ptr [rdx], 1
cmp esi, ecx
jge short loc_13D3
add eax, 2
mov dword ptr [rdx+4], 1
cmp eax, ecx
jge short loc_13D3
mov dword ptr [rdx+8], 1
loc_13D3:
lea r8, [r10+r12]
mov esi, 1
test ebx, ebx
jle short loc_1430
loc_13E0:
xor eax, eax
nop word ptr [rax+rax+00h]
loc_13E8:
xor ecx, ecx
mov edx, esi
sub edx, [rdi+rax*4]
js short loc_1402
movsxd rdx, edx
movsxd rcx, eax
imul rdx, r11
add rdx, rcx
mov ecx, [r10+rdx*4]
loc_1402:
test rax, rax
jz short loc_1460
add ecx, [r8+rax*4-4]
mov [r8+rax*4], ecx
add rax, 1
cmp r9, rax
jnz short loc_13E8
loc_1419:
lea eax, [rsi+1]
add r8, r12
cmp ebx, esi
jz short loc_1430
mov esi, eax
jmp short loc_13E0
loc_1430:
imul rbx, r11
movsxd rax, r13d
add rax, rbx
mov eax, [r10+rax*4]
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz short loc_1485
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn
loc_1460:
mov [r8], ecx
cmp r9, 1
jz short loc_1419
mov eax, 1
jmp loc_13E8
loc_1473:
or [rsp+rdx+1030h+var_1038], 0
jmp loc_1341
loc_147E:
xor eax, eax
jmp loc_13AA
loc_1485:
call ___stack_chk_fail | long long func0(long long a1, int a2, int a3)
{
long long v3; // r9
unsigned long long v5; // r12
long long v6; // rbx
long long v7; // rdx
__m128i *v8; // rsi
__int16 v9; // dx
signed long long v10; // rdx
void *v11; // rsp
unsigned int v12; // r13d
unsigned long long v13; // r11
__m128i si128; // xmm0
__m128i *v15; // rax
long long v16; // rdx
__m128i *v17; // rsi
int v18; // eax
__int32 *v19; // rdx
__int32 *v20; // r8
int v21; // esi
long long i; // rax
__int32 v23; // ecx
long long v25; // [rsp+0h] [rbp-1038h]
__m128i v26; // [rsp+8h] [rbp-1030h] BYREF
_BYTE v27[4072]; // [rsp+18h] [rbp-1020h] BYREF
_QWORD v28[6]; // [rsp+1008h] [rbp-30h] BYREF
v3 = a2;
v5 = 4LL * a2;
v6 = a3;
v28[1] = __readfsqword(0x28u);
v7 = 4 * a2 * (long long)(a3 + 1) + 15;
v8 = (__m128i *)((char *)v28 - (v7 & 0xFFFFFFFFFFFFF000LL));
v9 = v7 & 0xFFF0;
if ( v28 != (_QWORD *)v8 )
{
while ( &v26 != v8 )
;
}
v10 = v9 & 0xFFF;
v11 = alloca(v10);
if ( v10 )
*(long long *)((char *)&v25 + v10) = *(long long *)((char *)&v25 + v10);
v12 = a2 - 1;
v13 = v5 >> 2;
if ( a2 <= 0 )
return v26.m128i_u32[v13 * v6 + (int)v12];
if ( v12 <= 2 )
{
v18 = 0;
goto LABEL_12;
}
si128 = _mm_load_si128((const __m128i *)&xmmword_2090);
v15 = &v26;
v16 = 16LL * ((unsigned int)a2 >> 2);
v17 = (__m128i *)((char *)&v26 + v16);
if ( (v16 & 0x10) == 0 || (v15 = (__m128i *)v27, v26 = si128, v27 != (_BYTE *)v17) )
{
do
{
*v15 = si128;
v15 += 2;
v15[-1] = si128;
}
while ( v15 != v17 );
}
if ( (a2 & 3) != 0 )
{
v18 = a2 & 0x7FFFFFFC;
LABEL_12:
v19 = &v26.m128i_i32[v18];
*v19 = 1;
if ( v18 + 1 < a2 )
{
v19[1] = 1;
if ( v18 + 2 < a2 )
v19[2] = 1;
}
}
v20 = &v26.m128i_i32[v5 / 4];
v21 = 1;
if ( (int)v6 > 0 )
{
while ( 1 )
{
for ( i = 0LL; ; i = 1LL )
{
while ( 1 )
{
v23 = 0;
if ( v21 - *(_DWORD *)(a1 + 4 * i) >= 0 )
v23 = v26.m128i_i32[(int)i + v13 * (v21 - *(_DWORD *)(a1 + 4 * i))];
if ( !i )
break;
v20[i] = v20[i - 1] + v23;
if ( v3 == ++i )
goto LABEL_21;
}
*v20 = v23;
if ( v3 == 1 )
break;
}
LABEL_21:
v20 = (__int32 *)((char *)v20 + v5);
if ( (_DWORD)v6 == v21 )
break;
++v21;
}
}
return v26.m128i_u32[v13 * v6 + (int)v12];
} | func0:
ENDBR64
PUSH RBP
MOVSXD R9,ESI
MOV RCX,R9
MOV RBP,RSP
PUSH R13
PUSH R12
LEA R12,[R9*0x4]
PUSH RBX
MOVSXD RBX,EDX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA EAX,[RBX + 0x1]
MOV RSI,RSP
CDQE
IMUL RAX,R9
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RSI,RAX
AND RDX,-0x10
CMP RSP,RSI
JZ 0x0010132f
LAB_0010131a:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x0010131a
LAB_0010132f:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101473
LAB_00101341:
MOV R11,R12
MOV R10,RSP
LEA R13D,[RCX + -0x1]
SHR R11,0x2
TEST ECX,ECX
JLE 0x00101430
CMP R13D,0x2
JBE 0x0010147e
MOV EDX,ECX
MOVDQA XMM0,xmmword ptr [0x00102090]
MOV RAX,R10
SHR EDX,0x2
SHL RDX,0x4
LEA RSI,[R10 + RDX*0x1]
AND EDX,0x10
JZ 0x00101390
LEA RAX,[R10 + 0x10]
MOVUPS xmmword ptr [R10],XMM0
CMP RAX,RSI
JZ 0x001013a0
NOP dword ptr [RAX + RAX*0x1]
LAB_00101390:
MOVUPS xmmword ptr [RAX],XMM0
ADD RAX,0x20
MOVUPS xmmword ptr [RAX + -0x10],XMM0
CMP RAX,RSI
JNZ 0x00101390
LAB_001013a0:
TEST CL,0x3
JZ 0x001013d3
MOV EAX,ECX
AND EAX,0xfffffffc
LAB_001013aa:
MOVSXD RDX,EAX
LEA ESI,[RAX + 0x1]
LEA RDX,[R10 + RDX*0x4]
MOV dword ptr [RDX],0x1
CMP ESI,ECX
JGE 0x001013d3
ADD EAX,0x2
MOV dword ptr [RDX + 0x4],0x1
CMP EAX,ECX
JGE 0x001013d3
MOV dword ptr [RDX + 0x8],0x1
LAB_001013d3:
LEA R8,[R10 + R12*0x1]
MOV ESI,0x1
TEST EBX,EBX
JLE 0x00101430
LAB_001013e0:
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_001013e8:
XOR ECX,ECX
MOV EDX,ESI
SUB EDX,dword ptr [RDI + RAX*0x4]
JS 0x00101402
MOVSXD RDX,EDX
MOVSXD RCX,EAX
IMUL RDX,R11
ADD RDX,RCX
MOV ECX,dword ptr [R10 + RDX*0x4]
LAB_00101402:
TEST RAX,RAX
JZ 0x00101460
ADD ECX,dword ptr [R8 + RAX*0x4 + -0x4]
MOV dword ptr [R8 + RAX*0x4],ECX
ADD RAX,0x1
CMP R9,RAX
JNZ 0x001013e8
LAB_00101419:
LEA EAX,[RSI + 0x1]
ADD R8,R12
CMP EBX,ESI
JZ 0x00101430
MOV ESI,EAX
JMP 0x001013e0
LAB_00101430:
IMUL RBX,R11
MOVSXD RAX,R13D
ADD RAX,RBX
MOV EAX,dword ptr [R10 + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101485
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_00101460:
MOV dword ptr [R8],ECX
CMP R9,0x1
JZ 0x00101419
MOV EAX,0x1
JMP 0x001013e8
LAB_00101473:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101341
LAB_0010147e:
XOR EAX,EAX
JMP 0x001013aa
LAB_00101485:
CALL 0x00101080 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int4 func0(long param_1,uint param_2,int param_3)
{
int4 *puVar1;
long lVar2;
int *puVar3;
uint uVar4;
int8 *puVar5;
int iVar6;
int iVar7;
ulong uVar8;
int *puVar9;
int *piVar11;
int iVar12;
ulong uVar13;
long in_FS_OFFSET;
bool bVar14;
int auStack_38 [8];
long local_30;
int *puVar10;
uVar13 = (ulong)(int)param_2;
puVar9 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar8 = (long)(param_3 + 1) * uVar13 * 4 + 0xf;
puVar10 = auStack_38;
puVar3 = auStack_38;
while (puVar10 != auStack_38 + -(uVar8 & 0xfffffffffffff000)) {
puVar9 = puVar3 + -0x1000;
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
puVar10 = puVar3 + -0x1000;
puVar3 = puVar3 + -0x1000;
}
uVar8 = (ulong)((uint)uVar8 & 0xff0);
lVar2 = -uVar8;
puVar5 = (int8 *)(puVar9 + lVar2);
piVar11 = (int *)(puVar9 + lVar2);
if (uVar8 != 0) {
*(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8);
}
if ((int)param_2 < 1) goto LAB_00101430;
if (param_2 - 1 < 3) {
uVar4 = 0;
LAB_001013aa:
puVar1 = (int4 *)(puVar9 + (long)(int)uVar4 * 4 + lVar2);
*puVar1 = 1;
if (((int)(uVar4 + 1) < (int)param_2) && (puVar1[1] = 1, (int)(uVar4 + 2) < (int)param_2)) {
puVar1[2] = 1;
}
}
else {
uVar8 = (uVar13 >> 2 & 0x3fffffff) * 0x10;
if ((uVar8 & 0x10) == 0) goto LAB_00101390;
*(int8 *)(puVar9 + lVar2) = _DAT_00102090;
*(int8 *)(puVar9 + lVar2 + 8) = _UNK_00102098;
for (puVar5 = (int8 *)(puVar9 + lVar2 + 0x10);
puVar5 != (int8 *)(puVar9 + uVar8 + lVar2); puVar5 = puVar5 + 4) {
LAB_00101390:
*puVar5 = _DAT_00102090;
puVar5[1] = _UNK_00102098;
puVar5[2] = _DAT_00102090;
puVar5[3] = _UNK_00102098;
}
if ((uVar13 & 3) != 0) {
uVar4 = param_2 & 0xfffffffc;
goto LAB_001013aa;
}
}
iVar12 = 1;
if (0 < param_3) {
do {
piVar11 = piVar11 + uVar13;
uVar8 = 0;
do {
while( true ) {
iVar6 = 0;
iVar7 = iVar12 - *(int *)(param_1 + uVar8 * 4);
if (-1 < iVar7) {
iVar6 = *(int *)(puVar9 + ((long)iVar7 * (uVar13 & 0x3fffffffffffffff) +
(long)(int)uVar8) * 4 + lVar2);
}
if (uVar8 != 0) break;
*piVar11 = iVar6;
if (uVar13 == 1) goto LAB_00101419;
uVar8 = 1;
}
piVar11[uVar8] = iVar6 + piVar11[uVar8 - 1];
uVar8 = uVar8 + 1;
} while (uVar13 != uVar8);
LAB_00101419:
bVar14 = param_3 != iVar12;
iVar12 = iVar12 + 1;
} while (bVar14);
}
LAB_00101430:
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar9 + lVar2 + -8) = 0x10148a;
__stack_chk_fail();
}
return *(int4 *)
(puVar9 + ((long)(int)(param_2 - 1) + (long)param_3 * (uVar13 & 0x3fffffffffffffff)) * 4 +
lVar2);
} |
7,568 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int items[], int length) {
int tot = 1;
for (int i = 0; i < length; i++) {
tot *= items[i];
}
return tot;
}
| int main() {
int list1[] = {1, -2, 3};
int list2[] = {1, 2, 3, 4};
int list3[] = {3, 1, 2, 3};
assert(func0(list1, 3) == -6);
assert(func0(list2, 4) == 24);
assert(func0(list3, 4) == 18);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ab <func0+0x42>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x8(%rbp),%edx
imul %edx,%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_11AB
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_8]
imul eax, edx
mov [rbp+var_8], eax
add [rbp+var_4], 1
loc_11AB:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 1;
for ( i = 0; i < a2; ++i )
v3 *= *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ab
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
IMUL EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ab:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 1;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = *(int *)(param_1 + (long)local_c * 4) * local_10;
}
return local_10;
} |
7,569 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int items[], int length) {
int tot = 1;
for (int i = 0; i < length; i++) {
tot *= items[i];
}
return tot;
}
| int main() {
int list1[] = {1, -2, 3};
int list2[] = {1, 2, 3, 4};
int list3[] = {3, 1, 2, 3};
assert(func0(list1, 3) == -6);
assert(func0(list2, 4) == 24);
assert(func0(list3, 4) == 18);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1190 <func0+0x27>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x1,%edx
imul (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x1,%edx
jmp 118d <func0+0x24>
| func0:
endbr64
test esi, esi
jle short loc_1190
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 1
loc_1181:
imul edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1181
loc_118D:
mov eax, edx
retn
loc_1190:
mov edx, 1
jmp short loc_118D | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return 1;
}
else
{
v2 = a1;
v3 = 1;
do
v3 *= *v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101190
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x1
LAB_00101181:
IMUL EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101181
LAB_0010118d:
MOV EAX,EDX
RET
LAB_00101190:
MOV EDX,0x1
JMP 0x0010118d | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 1;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 1;
do {
iVar2 = iVar2 * *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
7,570 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int items[], int length) {
int tot = 1;
for (int i = 0; i < length; i++) {
tot *= items[i];
}
return tot;
}
| int main() {
int list1[] = {1, -2, 3};
int list2[] = {1, 2, 3, 4};
int list3[] = {3, 1, 2, 3};
assert(func0(list1, 3) == -6);
assert(func0(list2, 4) == 24);
assert(func0(list3, 4) == 18);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1168 <func0+0x28>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
mov $0x1,%eax
nopl (%rax)
imul (%rdi),%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 1158 <func0+0x18>
retq
nopl (%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle short loc_1168
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
mov eax, 1
nop dword ptr [rax]
loc_1158:
imul eax, [rdi]
add rdi, 4
cmp rdi, rdx
jnz short loc_1158
retn
loc_1168:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rdx
long long result; // rax
if ( a2 <= 0 )
return 1LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 1;
do
result = (unsigned int)(*a1++ * result);
while ( a1 != (_DWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101168
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00101158:
IMUL EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x00101158
RET
LAB_00101168:
MOV EAX,0x1
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 1;
do {
iVar2 = iVar2 * *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
}
return 1;
} |
7,571 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int items[], int length) {
int tot = 1;
for (int i = 0; i < length; i++) {
tot *= items[i];
}
return tot;
}
| int main() {
int list1[] = {1, -2, 3};
int list2[] = {1, 2, 3, 4};
int list3[] = {3, 1, 2, 3};
assert(func0(list1, 3) == -6);
assert(func0(list2, 4) == 24);
assert(func0(list3, 4) == 18);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1208 <func0+0xc8>
lea -0x1(%rsi),%eax
cmp $0x1c,%eax
jbe 1212 <func0+0xd2>
mov %esi,%edx
movdqa 0xeae(%rip),%xmm1
mov %rdi,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
movdqu (%rax),%xmm2
movdqu (%rax),%xmm0
add $0x10,%rax
pmuludq %xmm1,%xmm2
psrlq $0x20,%xmm0
psrlq $0x20,%xmm1
pmuludq %xmm1,%xmm0
pshufd $0x8,%xmm2,%xmm1
pshufd $0x8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
cmp %rdx,%rax
jne 1170 <func0+0x30>
movdqa %xmm1,%xmm2
movdqa %xmm1,%xmm0
mov %esi,%eax
psrldq $0x8,%xmm2
psrlq $0x20,%xmm1
and $0xfffffffc,%eax
pmuludq %xmm2,%xmm0
psrlq $0x20,%xmm2
pmuludq %xmm2,%xmm1
pshufd $0x8,%xmm0,%xmm0
pshufd $0x8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
pmuludq %xmm1,%xmm0
movd %xmm0,%r8d
test $0x3,%sil
je 11fd <func0+0xbd>
cltq
nopl (%rax)
imul (%rdi,%rax,4),%r8d
add $0x1,%rax
cmp %eax,%esi
jg 11f0 <func0+0xb0>
mov %r8d,%eax
retq
nopl 0x0(%rax)
mov $0x1,%r8d
mov %r8d,%eax
retq
xor %eax,%eax
mov $0x1,%r8d
jmp 11eb <func0+0xab>
nopl 0x0(%rax)
| func0:
endbr64
mov rcx, rdi
test esi, esi
jle loc_1238
lea eax, [rsi-1]
cmp eax, 1Ah
jbe loc_1240
mov edx, esi
movdqa xmm1, cs:xmmword_2010
mov rax, rdi
shr edx, 2
shl rdx, 4
add rdx, rdi
nop word ptr [rax+rax+00h]
loc_1178:
movdqu xmm2, xmmword ptr [rax]
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pmuludq xmm2, xmm1
psrlq xmm0, 20h ; ' '
psrlq xmm1, 20h ; ' '
pmuludq xmm0, xmm1
pshufd xmm1, xmm2, 8
pshufd xmm0, xmm0, 8
punpckldq xmm1, xmm0
cmp rax, rdx
jnz short loc_1178
movdqa xmm0, xmm1
mov eax, esi
psrldq xmm0, 8
and eax, 0FFFFFFFCh
movdqa xmm2, xmm0
psrlq xmm0, 20h ; ' '
pmuludq xmm2, xmm1
psrlq xmm1, 20h ; ' '
pmuludq xmm0, xmm1
pshufd xmm1, xmm2, 8
pshufd xmm0, xmm0, 8
punpckldq xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
pmuludq xmm0, xmm1
movd edx, xmm0
test sil, 3
jz short loc_1231
loc_11F2:
cdqe
mov rdi, rax
imul edx, [rcx+rax*4]
add rax, 1
not rdi
add edi, esi
and edi, 1
cmp esi, eax
jle short loc_1231
test edi, edi
jz short loc_1220
imul edx, [rcx+rax*4]
add rax, 1
cmp esi, eax
jle short loc_1231
nop dword ptr [rax+rax+00h]
loc_1220:
imul edx, [rcx+rax*4]
imul edx, [rcx+rax*4+4]
add rax, 2
cmp esi, eax
jg short loc_1220
loc_1231:
mov eax, edx
retn
loc_1238:
mov edx, 1
mov eax, edx
retn
loc_1240:
xor eax, eax
mov edx, 1
jmp short loc_11F2 | long long func0(const __m128i *a1, int a2)
{
__m128i si128; // xmm1
const __m128i *v4; // rax
__m128i v5; // xmm2
int v6; // eax
__m128i v7; // xmm2
__m128i v8; // xmm1
unsigned int v9; // edx
char v10; // di
long long v11; // rax
int v12; // edi
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) <= 0x1A )
{
v6 = 0;
v9 = 1;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v4 = a1;
do
{
v5 = _mm_loadu_si128(v4++);
si128 = _mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v5, si128), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v5, 0x20u), _mm_srli_epi64(si128, 0x20u)), 8));
}
while ( v4 != &a1[(unsigned int)a2 >> 2] );
v6 = a2 & 0x7FFFFFFC;
v7 = _mm_srli_si128(si128, 8);
v8 = _mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v7, si128), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v7, 0x20u), _mm_srli_epi64(si128, 0x20u)), 8));
v9 = _mm_cvtsi128_si32(_mm_mul_epu32(_mm_srli_si128(v8, 4), v8));
if ( (a2 & 3) == 0 )
return v9;
}
v10 = v6;
v9 *= a1->m128i_i32[v6];
v11 = v6 + 1LL;
v12 = ((_BYTE)a2 + ~v10) & 1;
if ( a2 > (int)v11 )
{
if ( !v12 || (v9 *= a1->m128i_i32[v11], ++v11, a2 > (int)v11) )
{
do
{
v9 *= a1->m128i_i32[v11 + 1] * a1->m128i_i32[v11];
v11 += 2LL;
}
while ( a2 > (int)v11 );
}
}
return v9;
}
return 1LL;
} | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x00101238
LEA EAX,[RSI + -0x1]
CMP EAX,0x1a
JBE 0x00101240
MOV EDX,ESI
MOVDQA XMM1,xmmword ptr [0x00102010]
MOV RAX,RDI
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101178:
MOVDQU XMM2,xmmword ptr [RAX]
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PMULUDQ XMM2,XMM1
PSRLQ XMM0,0x20
PSRLQ XMM1,0x20
PMULUDQ XMM0,XMM1
PSHUFD XMM1,XMM2,0x8
PSHUFD XMM0,XMM0,0x8
PUNPCKLDQ XMM1,XMM0
CMP RAX,RDX
JNZ 0x00101178
MOVDQA XMM0,XMM1
MOV EAX,ESI
PSRLDQ XMM0,0x8
AND EAX,0xfffffffc
MOVDQA XMM2,XMM0
PSRLQ XMM0,0x20
PMULUDQ XMM2,XMM1
PSRLQ XMM1,0x20
PMULUDQ XMM0,XMM1
PSHUFD XMM1,XMM2,0x8
PSHUFD XMM0,XMM0,0x8
PUNPCKLDQ XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PMULUDQ XMM0,XMM1
MOVD EDX,XMM0
TEST SIL,0x3
JZ 0x00101231
LAB_001011f2:
CDQE
MOV RDI,RAX
IMUL EDX,dword ptr [RCX + RAX*0x4]
ADD RAX,0x1
NOT RDI
ADD EDI,ESI
AND EDI,0x1
CMP ESI,EAX
JLE 0x00101231
TEST EDI,EDI
JZ 0x00101220
IMUL EDX,dword ptr [RCX + RAX*0x4]
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101231
NOP dword ptr [RAX + RAX*0x1]
LAB_00101220:
IMUL EDX,dword ptr [RCX + RAX*0x4]
IMUL EDX,dword ptr [RCX + RAX*0x4 + 0x4]
ADD RAX,0x2
CMP ESI,EAX
JG 0x00101220
LAB_00101231:
MOV EAX,EDX
RET
LAB_00101238:
MOV EDX,0x1
MOV EAX,EDX
RET
LAB_00101240:
XOR EAX,EAX
MOV EDX,0x1
JMP 0x001011f2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong func0(ulong *param_1,uint param_2)
{
ulong *puVar1;
ulong *puVar2;
uint uVar3;
ulong *puVar4;
long lVar5;
long lVar6;
int iVar7;
uint uVar8;
ulong uVar9;
ulong uVar10;
int auVar11 [16];
int4 uVar13;
ulong uVar14;
int4 uVar15;
ulong uVar12;
if ((int)param_2 < 1) {
return 1;
}
if (param_2 - 1 < 0x1b) {
uVar3 = 0;
iVar7 = 1;
}
else {
puVar4 = param_1;
uVar10 = _DAT_00102010;
uVar12 = _UNK_00102018;
do {
uVar14 = *puVar4;
puVar2 = puVar4 + 1;
uVar9 = *puVar4;
puVar1 = puVar4 + 1;
puVar4 = puVar4 + 2;
uVar14 = (uVar14 & 0xffffffff) * (uVar10 & 0xffffffff);
uVar9 = (uVar9 >> 0x20) * (uVar10 >> 0x20);
uVar13 = (int4)uVar14;
uVar15 = (int4)((*puVar2 & 0xffffffff) * (uVar12 & 0xffffffff));
auVar11._4_4_ = uVar15;
auVar11._0_4_ = uVar13;
auVar11._8_4_ = uVar15;
auVar11._12_4_ = (int)((*puVar1 >> 0x20) * (uVar12 >> 0x20));
uVar12 = auVar11._8_8_;
uVar10 = CONCAT44((int)uVar9,uVar13);
} while (puVar4 != param_1 + (ulong)(param_2 >> 2) * 2);
uVar3 = param_2 & 0xfffffffc;
uVar10 = ((uVar12 >> 0x20) * (uVar9 & 0xffffffff) & 0xffffffff) *
((uVar12 & 0xffffffff) * (uVar14 & 0xffffffff) & 0xffffffff);
iVar7 = (int)uVar10;
if ((param_2 & 3) == 0) {
return uVar10 & 0xffffffff;
}
}
lVar5 = (long)(int)uVar3;
uVar8 = iVar7 * *(int *)((long)param_1 + lVar5 * 4);
uVar10 = (ulong)uVar8;
lVar6 = lVar5 + 1;
if ((int)lVar6 < (int)param_2) {
if ((~uVar3 + param_2 & 1) != 0) {
uVar10 = (ulong)(uVar8 * *(int *)((long)param_1 + lVar6 * 4));
lVar6 = lVar5 + 2;
if ((int)param_2 <= (int)lVar6) {
return uVar10;
}
}
do {
uVar10 = (ulong)(uint)((int)uVar10 * *(int *)((long)param_1 + lVar6 * 4) *
*(int *)((long)param_1 + lVar6 * 4 + 4));
lVar6 = lVar6 + 2;
} while ((int)lVar6 < (int)param_2);
}
return uVar10;
} |
7,572 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int has_first;
int first;
int has_second;
int second;
} tuple_t;
| char* func0(tuple_t* test_list, int size) {
// Allocate sufficient memory for the result
char* res = malloc(1024);
if (!res) return NULL;
strcpy(res, "[");
int first = 1;
for(int i = 0; i < size; i++) {
int all_null = 1;
if (test_list[i].has_first) all_null = 0;
if (test_list[i].has_second) all_null = 0;
if (!all_null) {
if (!first) strcat(res, ", ");
first = 0;
strcat(res, "(");
if(test_list[i].has_first) {
char num[20];
sprintf(num, "%d", test_list[i].first);
strcat(res, num);
} else {
strcat(res, "None");
}
strcat(res, ", ");
if(test_list[i].has_second) {
char num[20];
sprintf(num, "%d", test_list[i].second);
strcat(res, num);
} else {
strcat(res, "None");
}
strcat(res, ")");
}
}
strcat(res, "]");
return res;
}
| int main() {
// First test case
tuple_t test1[] = {
{0, 0, 1, 2},
{0, 0, 0, 0},
{1, 3, 1, 4},
{1, 12, 1, 3},
{0, 0, 0, 0}
};
char* result1 = func0(test1, 5);
assert(strcmp(result1, "[(None, 2), (3, 4), (12, 3)]") == 0);
free(result1);
// Second test case
tuple_t test2[] = {
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 3, 1, 6},
{1, 17, 1, 3},
{0, 0, 1, 1}
};
char* result2 = func0(test2, 5);
assert(strcmp(result2, "[(3, 6), (17, 3), (None, 1)]") == 0);
free(result2);
// Third test case
tuple_t test3[] = {
{1, 1, 1, 2},
{1, 2, 0, 0},
{1, 3, 0, 0},
{1, 24, 1, 3},
{0, 0, 0, 0}
};
char* result3 = func0(test3, 5);
assert(strcmp(result3, "[(1, 2), (2, None), (3, None), (24, 3)]") == 0);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov $0x400,%edi
callq 10f0 <malloc@plt>
mov %rax,-0x28(%rbp)
cmpq $0x0,-0x28(%rbp)
jne 124a <func0+0x41>
mov $0x0,%eax
jmpq 14e6 <func0+0x2dd>
mov -0x28(%rbp),%rax
movw $0x5b,(%rax)
movl $0x1,-0x34(%rbp)
movl $0x0,-0x30(%rbp)
jmpq 14a8 <func0+0x29f>
movl $0x1,-0x2c(%rbp)
mov -0x30(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
je 128d <func0+0x84>
movl $0x0,-0x2c(%rbp)
mov -0x30(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%eax
test %eax,%eax
je 12ae <func0+0xa5>
movl $0x0,-0x2c(%rbp)
cmpl $0x0,-0x2c(%rbp)
jne 14a4 <func0+0x29b>
cmpl $0x0,-0x34(%rbp)
jne 12f0 <func0+0xe7>
mov -0x28(%rbp),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movw $0x202c,(%rax)
movb $0x0,0x2(%rax)
movl $0x0,-0x34(%rbp)
mov -0x28(%rbp),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movw $0x28,(%rax)
mov -0x30(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
je 1381 <func0+0x178>
mov -0x30(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%edx
lea -0x20(%rbp),%rax
lea 0xca9(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1110 <sprintf@plt>
lea -0x20(%rbp),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1100 <strcat@plt>
jmp 13b4 <func0+0x1ab>
mov -0x28(%rbp),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movl $0x656e6f4e,(%rax)
movb $0x0,0x4(%rax)
mov -0x28(%rbp),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movw $0x202c,(%rax)
movb $0x0,0x2(%rax)
mov -0x30(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%eax
test %eax,%eax
je 1443 <func0+0x23a>
mov -0x30(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
mov 0xc(%rax),%edx
lea -0x20(%rbp),%rax
lea 0xbe7(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1110 <sprintf@plt>
lea -0x20(%rbp),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1100 <strcat@plt>
jmp 1476 <func0+0x26d>
mov -0x28(%rbp),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movl $0x656e6f4e,(%rax)
movb $0x0,0x4(%rax)
mov -0x28(%rbp),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movw $0x29,(%rax)
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x4c(%rbp),%eax
jl 1266 <func0+0x5d>
mov -0x28(%rbp),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movw $0x5d,(%rax)
mov -0x28(%rbp),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 14fa <func0+0x2f1>
callq 10c0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov edi, 400h; size
call _malloc
mov [rbp+s], rax
cmp [rbp+s], 0
jnz short loc_126A
mov eax, 0
jmp loc_1487
loc_126A:
mov rax, [rbp+s]
mov word ptr [rax], 5Bh ; '['
mov [rbp+var_34], 1
mov [rbp+var_30], 0
jmp loc_145C
loc_1286:
mov [rbp+var_2C], 1
mov eax, [rbp+var_30]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
test eax, eax
jz short loc_12AD
mov [rbp+var_2C], 0
loc_12AD:
mov eax, [rbp+var_30]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax+8]
test eax, eax
jz short loc_12CE
mov [rbp+var_2C], 0
loc_12CE:
cmp [rbp+var_2C], 0
jnz loc_1458
cmp [rbp+var_34], 0
jnz short loc_12FD
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+s]
add rax, rdx
mov word ptr [rax], 202Ch
mov byte ptr [rax+2], 0
loc_12FD:
mov [rbp+var_34], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+s]
add rax, rdx
mov word ptr [rax], 28h ; '('
mov eax, [rbp+var_30]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax]
test eax, eax
jz short loc_137E
mov eax, [rbp+var_30]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rax+4]
lea rax, [rbp+src]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
lea rdx, [rbp+src]
mov rax, [rbp+s]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcat
jmp short loc_139E
loc_137E:
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+s]
add rax, rdx
mov dword ptr [rax], 656E6F4Eh
mov byte ptr [rax+4], 0
loc_139E:
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+s]
add rax, rdx
mov word ptr [rax], 202Ch
mov byte ptr [rax+2], 0
mov eax, [rbp+var_30]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_48]
add rax, rdx
mov eax, [rax+8]
test eax, eax
jz short loc_141D
mov eax, [rbp+var_30]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_48]
add rax, rdx
mov edx, [rax+0Ch]
lea rax, [rbp+src]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
lea rdx, [rbp+src]
mov rax, [rbp+s]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcat
jmp short loc_143D
loc_141D:
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+s]
add rax, rdx
mov dword ptr [rax], 656E6F4Eh
mov byte ptr [rax+4], 0
loc_143D:
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+s]
add rax, rdx
mov word ptr [rax], 29h ; ')'
loc_1458:
add [rbp+var_30], 1
loc_145C:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_4C]
jl loc_1286
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+s]
add rax, rdx
mov word ptr [rax], 5Dh ; ']'
mov rax, [rbp+s]
loc_1487:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_149B
call ___stack_chk_fail
locret_149B:
leave
retn | char * func0(long long a1, int a2)
{
int v3; // [rsp+1Ch] [rbp-34h]
int i; // [rsp+20h] [rbp-30h]
_BOOL4 v5; // [rsp+24h] [rbp-2Ch]
char *s; // [rsp+28h] [rbp-28h]
char src[24]; // [rsp+30h] [rbp-20h] BYREF
unsigned long long v8; // [rsp+48h] [rbp-8h]
v8 = __readfsqword(0x28u);
s = (char *)malloc(0x400uLL);
if ( !s )
return 0LL;
*(_WORD *)s = 91;
v3 = 1;
for ( i = 0; i < a2; ++i )
{
v5 = *(_DWORD *)(16LL * i + a1) == 0;
if ( *(_DWORD *)(16LL * i + a1 + 8) )
v5 = 0;
if ( !v5 )
{
if ( !v3 )
strcpy(&s[strlen(s)], ", ");
v3 = 0;
*(_WORD *)&s[strlen(s)] = 40;
if ( *(_DWORD *)(16LL * i + a1) )
{
sprintf(src, "%d", *(_DWORD *)(16LL * i + a1 + 4));
strcat(s, src);
}
else
{
strcpy(&s[strlen(s)], "None");
}
strcpy(&s[strlen(s)], ", ");
if ( *(_DWORD *)(16LL * i + a1 + 8) )
{
sprintf(src, "%d", *(_DWORD *)(16LL * i + a1 + 12));
strcat(s, src);
}
else
{
strcpy(&s[strlen(s)], "None");
}
*(_WORD *)&s[strlen(s)] = 41;
}
}
*(_WORD *)&s[strlen(s)] = 93;
return s;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EDI,0x400
CALL 0x00101110
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x0010126a
MOV EAX,0x0
JMP 0x00101487
LAB_0010126a:
MOV RAX,qword ptr [RBP + -0x28]
MOV word ptr [RAX],0x5b
MOV dword ptr [RBP + -0x34],0x1
MOV dword ptr [RBP + -0x30],0x0
JMP 0x0010145c
LAB_00101286:
MOV dword ptr [RBP + -0x2c],0x1
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JZ 0x001012ad
MOV dword ptr [RBP + -0x2c],0x0
LAB_001012ad:
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX + 0x8]
TEST EAX,EAX
JZ 0x001012ce
MOV dword ptr [RBP + -0x2c],0x0
LAB_001012ce:
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x00101458
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x001012fd
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010d0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV word ptr [RAX],0x202c
MOV byte ptr [RAX + 0x2],0x0
LAB_001012fd:
MOV dword ptr [RBP + -0x34],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010d0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV word ptr [RAX],0x28
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JZ 0x0010137e
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0x4]
LEA RAX,[RBP + -0x20]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101130
LEA RDX,[RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101120
JMP 0x0010139e
LAB_0010137e:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010d0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV dword ptr [RAX],0x656e6f4e
MOV byte ptr [RAX + 0x4],0x0
LAB_0010139e:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010d0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV word ptr [RAX],0x202c
MOV byte ptr [RAX + 0x2],0x0
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EAX,dword ptr [RAX + 0x8]
TEST EAX,EAX
JZ 0x0010141d
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0xc]
LEA RAX,[RBP + -0x20]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101130
LEA RDX,[RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101120
JMP 0x0010143d
LAB_0010141d:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010d0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV dword ptr [RAX],0x656e6f4e
MOV byte ptr [RAX + 0x4],0x0
LAB_0010143d:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010d0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV word ptr [RAX],0x29
LAB_00101458:
ADD dword ptr [RBP + -0x30],0x1
LAB_0010145c:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x4c]
JL 0x00101286
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010d0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV word ptr [RAX],0x5d
MOV RAX,qword ptr [RBP + -0x28]
LAB_00101487:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010149b
CALL 0x001010e0
LAB_0010149b:
LEAVE
RET | char * func0(long param_1,int param_2)
{
bool bVar1;
char *__s;
char *pcVar2;
size_t sVar3;
long in_FS_OFFSET;
int local_38;
char local_28 [24];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__s = (char *)malloc(0x400);
if (__s == (char *)0x0) {
__s = (char *)0x0;
}
else {
__s[0] = '[';
__s[1] = '\0';
bVar1 = true;
for (local_38 = 0; local_38 < param_2; local_38 = local_38 + 1) {
if (*(int *)(param_1 + (long)local_38 * 0x10 + 8) != 0 ||
*(int *)(param_1 + (long)local_38 * 0x10) != 0) {
if (!bVar1) {
sVar3 = strlen(__s);
pcVar2 = __s + sVar3;
pcVar2[0] = ',';
pcVar2[1] = ' ';
pcVar2[2] = '\0';
}
bVar1 = false;
sVar3 = strlen(__s);
(__s + sVar3)[0] = '(';
(__s + sVar3)[1] = '\0';
if (*(int *)(param_1 + (long)local_38 * 0x10) == 0) {
sVar3 = strlen(__s);
builtin_strncpy(__s + sVar3,"None",5);
}
else {
sprintf(local_28,"%d",(ulong)*(uint *)(param_1 + (long)local_38 * 0x10 + 4));
strcat(__s,local_28);
}
sVar3 = strlen(__s);
pcVar2 = __s + sVar3;
pcVar2[0] = ',';
pcVar2[1] = ' ';
pcVar2[2] = '\0';
if (*(int *)(param_1 + (long)local_38 * 0x10 + 8) == 0) {
sVar3 = strlen(__s);
builtin_strncpy(__s + sVar3,"None",5);
}
else {
sprintf(local_28,"%d",(ulong)*(uint *)(param_1 + (long)local_38 * 0x10 + 0xc));
strcat(__s,local_28);
}
sVar3 = strlen(__s);
(__s + sVar3)[0] = ')';
(__s + sVar3)[1] = '\0';
}
}
sVar3 = strlen(__s);
(__s + sVar3)[0] = ']';
(__s + sVar3)[1] = '\0';
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __s;
} |
7,573 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int has_first;
int first;
int has_second;
int second;
} tuple_t;
| char* func0(tuple_t* test_list, int size) {
// Allocate sufficient memory for the result
char* res = malloc(1024);
if (!res) return NULL;
strcpy(res, "[");
int first = 1;
for(int i = 0; i < size; i++) {
int all_null = 1;
if (test_list[i].has_first) all_null = 0;
if (test_list[i].has_second) all_null = 0;
if (!all_null) {
if (!first) strcat(res, ", ");
first = 0;
strcat(res, "(");
if(test_list[i].has_first) {
char num[20];
sprintf(num, "%d", test_list[i].first);
strcat(res, num);
} else {
strcat(res, "None");
}
strcat(res, ", ");
if(test_list[i].has_second) {
char num[20];
sprintf(num, "%d", test_list[i].second);
strcat(res, num);
} else {
strcat(res, "None");
}
strcat(res, ")");
}
}
strcat(res, "]");
return res;
}
| int main() {
// First test case
tuple_t test1[] = {
{0, 0, 1, 2},
{0, 0, 0, 0},
{1, 3, 1, 4},
{1, 12, 1, 3},
{0, 0, 0, 0}
};
char* result1 = func0(test1, 5);
assert(strcmp(result1, "[(None, 2), (3, 4), (12, 3)]") == 0);
free(result1);
// Second test case
tuple_t test2[] = {
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 3, 1, 6},
{1, 17, 1, 3},
{0, 0, 1, 1}
};
char* result2 = func0(test2, 5);
assert(strcmp(result2, "[(3, 6), (17, 3), (None, 1)]") == 0);
free(result2);
// Third test case
tuple_t test3[] = {
{1, 1, 1, 2},
{1, 2, 0, 0},
{1, 3, 0, 0},
{1, 24, 1, 3},
{0, 0, 0, 0}
};
char* result3 = func0(test3, 5);
assert(strcmp(result3, "[(1, 2), (2, None), (3, None), (24, 3)]") == 0);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r13
mov %esi,%r12d
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov $0x400,%edi
callq 10e0 <malloc@plt>
mov %rax,%rbp
test %rax,%rax
je 1387 <func0+0x19e>
movw $0x5b,(%rax)
test %r12d,%r12d
jle 1373 <func0+0x18a>
mov %r13,%rbx
lea -0x1(%r12),%eax
shl $0x4,%rax
lea 0x10(%r13,%rax,1),%r14
mov $0x1,%eax
mov $0x0,%r15d
jmp 12ba <func0+0xd1>
mov $0x400,%edx
lea 0xda5(%rip),%rsi
mov %rbp,%rdi
callq 10a0 <__strcat_chk@plt>
jmp 12cc <func0+0xe3>
mov $0x400,%edx
lea 0xd97(%rip),%rsi
mov %rbp,%rdi
callq 10a0 <__strcat_chk@plt>
jmpq 131a <func0+0x131>
mov $0x400,%edx
lea 0xd7e(%rip),%rsi
mov %rbp,%rdi
callq 10a0 <__strcat_chk@plt>
mov $0x400,%edx
lea 0xd6f(%rip),%rsi
mov %rbp,%rdi
callq 10a0 <__strcat_chk@plt>
mov %r15d,%eax
add $0x10,%rbx
cmp %r14,%rbx
je 1373 <func0+0x18a>
mov %rbx,%r13
mov (%rbx),%r12d
mov %r12d,%ecx
or 0x8(%rbx),%ecx
je 12ad <func0+0xc4>
test %eax,%eax
je 1253 <func0+0x6a>
mov $0x400,%edx
lea 0xd2f(%rip),%rsi
mov %rbp,%rdi
callq 10a0 <__strcat_chk@plt>
test %r12d,%r12d
je 1269 <func0+0x80>
mov %rsp,%r12
mov 0x4(%r13),%r8d
lea 0xd16(%rip),%rcx
mov $0x14,%edx
mov $0x1,%esi
mov %r12,%rdi
mov $0x0,%eax
callq 10f0 <__sprintf_chk@plt>
mov $0x400,%edx
mov %r12,%rsi
mov %rbp,%rdi
callq 10a0 <__strcat_chk@plt>
mov $0x400,%edx
lea 0xcde(%rip),%rsi
mov %rbp,%rdi
callq 10a0 <__strcat_chk@plt>
cmpl $0x0,0x8(%r13)
je 1282 <func0+0x99>
mov %rsp,%r12
mov 0xc(%r13),%r8d
lea 0xcc2(%rip),%rcx
mov $0x14,%edx
mov $0x1,%esi
mov %r12,%rdi
mov $0x0,%eax
callq 10f0 <__sprintf_chk@plt>
mov $0x400,%edx
mov %r12,%rsi
mov %rbp,%rdi
callq 10a0 <__strcat_chk@plt>
jmpq 1296 <func0+0xad>
mov $0x400,%edx
lea 0xccc(%rip),%rsi
mov %rbp,%rdi
callq 10a0 <__strcat_chk@plt>
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 13a9 <func0+0x1c0>
mov %rbp,%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10c0 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r13, rdi
mov r12d, esi
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov edi, 400h
call _malloc
mov rbp, rax
test rax, rax
jz loc_13A2
mov word ptr [rax], 5Bh ; '['
test r12d, r12d
jle loc_138E
mov rbx, r13
lea eax, [r12-1]
shl rax, 4
lea r14, [r13+rax+10h]
mov eax, 1
lea r15, unk_2004
jmp short loc_12D9
loc_1274:
mov edx, 400h
mov rsi, r15
mov rdi, rbp
call ___strcat_chk
jmp short loc_12EB
loc_1286:
mov edx, 400h
lea rsi, aNone; "None"
mov rdi, rbp
call ___strcat_chk
jmp loc_1339
loc_129F:
mov edx, 400h
lea rsi, aNone; "None"
mov rdi, rbp
call ___strcat_chk
loc_12B3:
mov edx, 400h
lea rsi, asc_2011; ")"
mov rdi, rbp
call ___strcat_chk
mov eax, 0
loc_12CC:
add rbx, 10h
cmp rbx, r14
jz loc_138E
loc_12D9:
mov r13, rbx
mov r12d, [rbx]
mov ecx, r12d
or ecx, [rbx+8]
jz short loc_12CC
test eax, eax
jz short loc_1274
loc_12EB:
mov edx, 400h
lea rsi, unk_2007
mov rdi, rbp
call ___strcat_chk
test r12d, r12d
jz short loc_1286
mov r12, rsp
mov r8d, [r13+4]
lea rcx, unk_2009
mov edx, 14h
mov esi, 1
mov rdi, r12
mov eax, 0
call ___sprintf_chk
mov edx, 400h
mov rsi, r12
mov rdi, rbp
call ___strcat_chk
loc_1339:
mov edx, 400h
mov rsi, r15
mov rdi, rbp
call ___strcat_chk
cmp dword ptr [r13+8], 0
jz loc_129F
mov r12, rsp
mov r8d, [r13+0Ch]
lea rcx, unk_2009
mov edx, 14h
mov esi, 1
mov rdi, r12
mov eax, 0
call ___sprintf_chk
mov edx, 400h
mov rsi, r12
mov rdi, rbp
call ___strcat_chk
jmp loc_12B3
loc_138E:
mov edx, 400h
lea rsi, a36173None1+1Bh; "]"
mov rdi, rbp
call ___strcat_chk
loc_13A2:
mov rax, [rsp+58h+var_40]
sub rax, fs:28h
jnz short loc_13C4
mov rax, rbp
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_13C4:
call ___stack_chk_fail | _WORD * func0(int *a1, int a2)
{
_WORD *v2; // rax
_WORD *v3; // rbp
int *v4; // rbx
int v5; // eax
int v6; // r12d
_QWORD v8[11]; // [rsp+0h] [rbp-58h] BYREF
v8[3] = __readfsqword(0x28u);
v2 = (_WORD *)malloc(1024LL);
v3 = v2;
if ( v2 )
{
*v2 = 91;
if ( a2 > 0 )
{
v4 = a1;
v5 = 1;
do
{
v6 = *v4;
if ( v4[2] | *v4 )
{
if ( !v5 )
__strcat_chk(v3, &unk_2004, 1024LL);
__strcat_chk(v3, &unk_2007, 1024LL);
if ( v6 )
{
__sprintf_chk(v8, 1LL, 20LL, &unk_2009, (unsigned int)v4[1]);
__strcat_chk(v3, v8, 1024LL);
}
else
{
__strcat_chk(v3, "None", 1024LL);
}
__strcat_chk(v3, &unk_2004, 1024LL);
if ( v4[2] )
{
__sprintf_chk(v8, 1LL, 20LL, &unk_2009, (unsigned int)v4[3]);
__strcat_chk(v3, v8, 1024LL);
}
else
{
__strcat_chk(v3, "None", 1024LL);
}
__strcat_chk(v3, ")", 1024LL);
v5 = 0;
}
v4 += 4;
}
while ( v4 != &a1[4 * (a2 - 1) + 4] );
}
__strcat_chk(v3, "]", 1024LL);
}
return v3;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R13,RDI
MOV R12D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV EDI,0x400
CALL 0x00101100
MOV RBP,RAX
TEST RAX,RAX
JZ 0x001013a2
MOV word ptr [RAX],0x5b
TEST R12D,R12D
JLE 0x0010138e
MOV RBX,R13
LEA EAX,[R12 + -0x1]
SHL RAX,0x4
LEA R14,[R13 + RAX*0x1 + 0x10]
MOV EAX,0x1
LEA R15,[0x102004]
JMP 0x001012d9
LAB_00101274:
MOV EDX,0x400
MOV RSI,R15
MOV RDI,RBP
CALL 0x001010b0
JMP 0x001012eb
LAB_00101286:
MOV EDX,0x400
LEA RSI,[0x10200c]
MOV RDI,RBP
CALL 0x001010b0
JMP 0x00101339
LAB_0010129f:
MOV EDX,0x400
LEA RSI,[0x10200c]
MOV RDI,RBP
CALL 0x001010b0
LAB_001012b3:
MOV EDX,0x400
LEA RSI,[0x102011]
MOV RDI,RBP
CALL 0x001010b0
MOV EAX,0x0
LAB_001012cc:
ADD RBX,0x10
CMP RBX,R14
JZ 0x0010138e
LAB_001012d9:
MOV R13,RBX
MOV R12D,dword ptr [RBX]
MOV ECX,R12D
OR ECX,dword ptr [RBX + 0x8]
JZ 0x001012cc
TEST EAX,EAX
JZ 0x00101274
LAB_001012eb:
MOV EDX,0x400
LEA RSI,[0x102007]
MOV RDI,RBP
CALL 0x001010b0
TEST R12D,R12D
JZ 0x00101286
MOV R12,RSP
MOV R8D,dword ptr [R13 + 0x4]
LEA RCX,[0x102009]
MOV EDX,0x14
MOV ESI,0x1
MOV RDI,R12
MOV EAX,0x0
CALL 0x00101110
MOV EDX,0x400
MOV RSI,R12
MOV RDI,RBP
CALL 0x001010b0
LAB_00101339:
MOV EDX,0x400
MOV RSI,R15
MOV RDI,RBP
CALL 0x001010b0
CMP dword ptr [R13 + 0x8],0x0
JZ 0x0010129f
MOV R12,RSP
MOV R8D,dword ptr [R13 + 0xc]
LEA RCX,[0x102009]
MOV EDX,0x14
MOV ESI,0x1
MOV RDI,R12
MOV EAX,0x0
CALL 0x00101110
MOV EDX,0x400
MOV RSI,R12
MOV RDI,RBP
CALL 0x001010b0
JMP 0x001012b3
LAB_0010138e:
MOV EDX,0x400
LEA RSI,[0x102068]
MOV RDI,RBP
CALL 0x001010b0
LAB_001013a2:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013c4
MOV RAX,RBP
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001013c4:
CALL 0x001010d0 | int2 * func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
bool bVar3;
int2 *puVar4;
long in_FS_OFFSET;
int1 auStack_58 [24];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
puVar4 = (int2 *)malloc(0x400);
if (puVar4 != (int2 *)0x0) {
*puVar4 = 0x5b;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
bVar3 = true;
do {
iVar2 = *param_1;
if (iVar2 != 0 || param_1[2] != 0) {
if (!bVar3) {
__strcat_chk(puVar4,&DAT_00102004,0x400);
}
__strcat_chk(puVar4,&DAT_00102007,0x400);
if (iVar2 == 0) {
__strcat_chk(puVar4,&DAT_0010200c,0x400);
}
else {
__sprintf_chk(auStack_58,1,0x14,&DAT_00102009,param_1[1]);
__strcat_chk(puVar4,auStack_58,0x400);
}
__strcat_chk(puVar4,&DAT_00102004,0x400);
if (param_1[2] == 0) {
__strcat_chk(puVar4,&DAT_0010200c,0x400);
}
else {
__sprintf_chk(auStack_58,1,0x14,&DAT_00102009,param_1[3]);
__strcat_chk(puVar4,auStack_58,0x400);
}
__strcat_chk(puVar4,&DAT_00102011,0x400);
bVar3 = false;
}
param_1 = param_1 + 4;
} while (param_1 != piVar1);
}
__strcat_chk(puVar4,"]",0x400);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,574 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int has_first;
int first;
int has_second;
int second;
} tuple_t;
| char* func0(tuple_t* test_list, int size) {
// Allocate sufficient memory for the result
char* res = malloc(1024);
if (!res) return NULL;
strcpy(res, "[");
int first = 1;
for(int i = 0; i < size; i++) {
int all_null = 1;
if (test_list[i].has_first) all_null = 0;
if (test_list[i].has_second) all_null = 0;
if (!all_null) {
if (!first) strcat(res, ", ");
first = 0;
strcat(res, "(");
if(test_list[i].has_first) {
char num[20];
sprintf(num, "%d", test_list[i].first);
strcat(res, num);
} else {
strcat(res, "None");
}
strcat(res, ", ");
if(test_list[i].has_second) {
char num[20];
sprintf(num, "%d", test_list[i].second);
strcat(res, num);
} else {
strcat(res, "None");
}
strcat(res, ")");
}
}
strcat(res, "]");
return res;
}
| int main() {
// First test case
tuple_t test1[] = {
{0, 0, 1, 2},
{0, 0, 0, 0},
{1, 3, 1, 4},
{1, 12, 1, 3},
{0, 0, 0, 0}
};
char* result1 = func0(test1, 5);
assert(strcmp(result1, "[(None, 2), (3, 4), (12, 3)]") == 0);
free(result1);
// Second test case
tuple_t test2[] = {
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 3, 1, 6},
{1, 17, 1, 3},
{0, 0, 1, 1}
};
char* result2 = func0(test2, 5);
assert(strcmp(result2, "[(3, 6), (17, 3), (None, 1)]") == 0);
free(result2);
// Third test case
tuple_t test3[] = {
{1, 1, 1, 2},
{1, 2, 0, 0},
{1, 3, 0, 0},
{1, 24, 1, 3},
{0, 0, 0, 0}
};
char* result3 = func0(test3, 5);
assert(strcmp(result3, "[(1, 2), (2, None), (3, None), (24, 3)]") == 0);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
mov $0x400,%edi
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 1100 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 1771 <func0+0x2c1>
mov $0x5b,%r11d
mov %r11w,(%rax)
test %ebp,%ebp
jle 175d <func0+0x2ad>
lea -0x1(%rbp),%eax
mov %rsp,%rbp
shl $0x4,%rax
lea 0x10(%rbx,%rax,1),%r13
mov $0x1,%eax
mov (%rbx),%r10d
test %r10d,%r10d
jne 1798 <func0+0x2e8>
mov 0x8(%rbx),%r9d
test %r9d,%r9d
je 1750 <func0+0x2a0>
test %eax,%eax
je 16e7 <func0+0x237>
mov $0x400,%edx
lea 0xac6(%rip),%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
mov $0x400,%edx
lea 0xab7(%rip),%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 155d <func0+0xad>
mov %eax,%edx
mov $0x202c,%ecx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov %eax,%esi
add %al,%sil
sbb $0x3,%rdi
mov %cx,(%rdi)
add $0x2,%rdi
movb $0x0,(%rdi)
mov 0x8(%rbx),%esi
test %esi,%esi
je 16b8 <func0+0x208>
mov 0xc(%rbx),%r8d
mov $0x14,%edx
mov $0x1,%esi
xor %eax,%eax
mov %rbp,%rdi
lea 0xa40(%rip),%rcx
callq 1110 <__sprintf_chk@plt>
mov $0x400,%edx
mov %rbp,%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
mov $0x400,%edx
lea 0xa27(%rip),%rsi
mov %r12,%rdi
add $0x10,%rbx
callq 10b0 <__strcat_chk@plt>
cmp %r13,%rbx
je 175d <func0+0x2ad>
mov (%rbx),%r14d
test %r14d,%r14d
je 16e0 <func0+0x230>
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 160b <func0+0x15b>
mov %eax,%edx
mov $0x202c,%r8d
mov %r12,%rcx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x2,%edx
mov %eax,%esi
add %al,%sil
lea 0x9b3(%rip),%rsi
sbb $0x3,%rdi
mov %r8w,(%rdi)
add $0x2,%rdi
movb $0x0,(%rdi)
sub %rdi,%rcx
add $0x400,%rcx
callq 10f0 <__memcpy_chk@plt>
test %r14d,%r14d
je 1546 <func0+0x96>
nopl 0x0(%rax,%rax,1)
mov 0x4(%rbx),%r8d
mov %rbp,%rdi
lea 0x978(%rip),%rcx
xor %eax,%eax
mov $0x14,%edx
mov $0x1,%esi
callq 1110 <__sprintf_chk@plt>
mov $0x400,%edx
mov %rbp,%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
jmpq 155a <func0+0xaa>
nopl 0x0(%rax)
mov %r12,%rcx
mov $0x5,%edx
lea 0x942(%rip),%rsi
sub %rdi,%rcx
add $0x400,%rcx
callq 10f0 <__memcpy_chk@plt>
jmpq 15db <func0+0x12b>
nopl 0x0(%rax,%rax,1)
mov 0x8(%rbx),%eax
test %eax,%eax
je 1750 <func0+0x2a0>
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 16ea <func0+0x23a>
mov %eax,%edx
lea 0x8fa(%rip),%rsi
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x2,%edx
mov %eax,%ecx
add %al,%cl
mov $0x202c,%eax
mov %r12,%rcx
sbb $0x3,%rdi
mov %ax,(%rdi)
add $0x2,%rdi
movb $0x0,(%rdi)
sub %rdi,%rcx
add $0x400,%rcx
callq 10f0 <__memcpy_chk@plt>
jmpq 1546 <func0+0x96>
add $0x10,%rbx
cmp %r13,%rbx
jne 1511 <func0+0x61>
mov $0x400,%edx
lea 0x8df(%rip),%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 1822 <func0+0x372>
add $0x20,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl (%rax)
test %eax,%eax
je 17b8 <func0+0x308>
mov $0x400,%edx
lea 0x85c(%rip),%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
jmpq 1680 <func0+0x1d0>
nopl (%rax)
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 17bb <func0+0x30b>
mov %eax,%edx
mov %r12,%rcx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x202c,%edx
mov %eax,%esi
add %al,%sil
lea 0x809(%rip),%rsi
sbb $0x3,%rdi
mov %dx,(%rdi)
add $0x2,%rdi
mov $0x2,%edx
movb $0x0,(%rdi)
sub %rdi,%rcx
add $0x400,%rcx
callq 10f0 <__memcpy_chk@plt>
jmpq 1680 <func0+0x1d0>
callq 10d0 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
mov edi, 400h
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
call _malloc
mov r12, rax
test rax, rax
jz loc_171A
mov r13d, 5Bh ; '['
mov [rax], r13w
test ebp, ebp
jle loc_1706
lea eax, [rbp-1]
lea r15, unk_2004
shl rax, 4
lea rbp, asc_200E; ")"
lea r14, aNone; "None"
lea rax, [rbx+rax+10h]
lea r13, unk_2006
mov [rsp+68h+var_68], rax
mov eax, 1
loc_1550:
mov r11d, [rbx]
test r11d, r11d
jnz loc_1740
mov r10d, [rbx+8]
test r10d, r10d
jz loc_16F8
test eax, eax
jz loc_16B7
mov edx, 400h
mov rsi, r15
mov rdi, r12
call ___strcat_chk
loc_1581:
mov edx, 400h
mov rsi, r14
mov rdi, r12
call ___strcat_chk
loc_1591:
mov rdi, r12
call _strlen
mov esi, 202Ch
add rax, r12
mov [rax], si
lea rdi, [rax+2]
mov byte ptr [rax+2], 0
mov r8d, [rbx+8]
test r8d, r8d
jz loc_1690
lea r9, [rsp+68h+var_58]
mov r8d, [rbx+0Ch]
mov edx, 14h
xor eax, eax
mov esi, 1
mov rdi, r9
mov rcx, r13
mov [rsp+68h+var_60], r9
call ___sprintf_chk
mov rsi, [rsp+68h+var_60]
mov edx, 400h
mov rdi, r12
call ___strcat_chk
loc_15F0:
mov edx, 400h
mov rsi, rbp
mov rdi, r12
add rbx, 10h
call ___strcat_chk
cmp [rsp+68h+var_68], rbx
jz loc_1706
mov ecx, [rbx]
test ecx, ecx
jz loc_16B0
loc_1618:
mov rdi, r12
call _strlen
mov rcx, r12
mov edx, 2
mov rsi, r15
add rax, r12
mov r9d, 202Ch
lea rdi, [rax+2]
mov [rax], r9w
mov byte ptr [rax+2], 0
sub rcx, rdi
add rcx, 400h
call ___memcpy_chk
nop
loc_1650:
lea r9, [rsp+68h+var_58]
mov r8d, [rbx+4]
mov rcx, r13
xor eax, eax
mov rdi, r9
mov edx, 14h
mov esi, 1
mov [rsp+68h+var_60], r9
call ___sprintf_chk
mov rsi, [rsp+68h+var_60]
mov edx, 400h
mov rdi, r12
call ___strcat_chk
jmp loc_1591
loc_1690:
mov rcx, r12
mov edx, 5
mov rsi, r14
sub rcx, rdi
add rcx, 400h
call ___memcpy_chk
jmp loc_15F0
loc_16B0:
mov eax, [rbx+8]
test eax, eax
jz short loc_16F8
loc_16B7:
mov rdi, r12
call _strlen
mov edx, 202Ch
mov rcx, r12
mov rsi, r15
add rax, r12
lea rdi, [rax+2]
mov [rax], dx
mov edx, 2
mov byte ptr [rax+2], 0
sub rcx, rdi
add rcx, 400h
call ___memcpy_chk
jmp loc_1581
loc_16F8:
add rbx, 10h
cmp rbx, [rsp+68h+var_68]
jnz loc_1550
loc_1706:
mov edx, 400h
lea rsi, a36173None1+1Bh; "]"
mov rdi, r12
call ___strcat_chk
loc_171A:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_175D
add rsp, 38h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1740:
test eax, eax
jz loc_1618
mov edx, 400h
mov rsi, r15
mov rdi, r12
call ___strcat_chk
jmp loc_1650
loc_175D:
call ___stack_chk_fail | char * func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rbx
char *v3; // rax
char *v4; // r12
int v5; // eax
char *v6; // rax
char *v7; // rax
char *v8; // rax
long long v10; // [rsp+0h] [rbp-68h]
_BYTE v11[24]; // [rsp+10h] [rbp-58h] BYREF
unsigned long long v12; // [rsp+28h] [rbp-40h]
v2 = a1;
v12 = __readfsqword(0x28u);
v3 = (char *)malloc(1024LL);
v4 = v3;
if ( v3 )
{
*(_WORD *)v3 = 91;
if ( a2 > 0 )
{
v10 = (long long)&a1[4 * (a2 - 1) + 4];
v5 = 1;
do
{
if ( *v2 )
{
if ( v5 )
{
__strcat_chk(v4, &unk_2004, 1024LL);
goto LABEL_14;
}
do
{
v7 = &v4[strlen(v4)];
strcpy(v7, ", ");
__memcpy_chk(v7 + 2, &unk_2004, 2LL, v4 - (v7 + 2) + 1024);
LABEL_14:
__sprintf_chk(v11, 1LL, 20LL, &unk_2006, (unsigned int)v2[1]);
__strcat_chk(v4, v11, 1024LL);
LABEL_9:
v6 = &v4[strlen(v4)];
strcpy(v6, ", ");
if ( v2[2] )
{
__sprintf_chk(v11, 1LL, 20LL, &unk_2006, (unsigned int)v2[3]);
__strcat_chk(v4, v11, 1024LL);
}
else
{
__memcpy_chk(v6 + 2, "None", 5LL, v4 - (v6 + 2) + 1024);
}
v2 += 4;
__strcat_chk(v4, ")", 1024LL);
if ( (_DWORD *)v10 == v2 )
goto LABEL_19;
}
while ( *v2 );
v5 = v2[2];
if ( v5 )
goto LABEL_17;
}
else if ( v2[2] )
{
if ( v5 )
{
__strcat_chk(v4, &unk_2004, 1024LL);
}
else
{
LABEL_17:
v8 = &v4[strlen(v4)];
strcpy(v8, ", ");
__memcpy_chk(v8 + 2, &unk_2004, 2LL, v4 - (v8 + 2) + 1024);
}
__strcat_chk(v4, "None", 1024LL);
goto LABEL_9;
}
v2 += 4;
}
while ( v2 != (_DWORD *)v10 );
}
LABEL_19:
__strcat_chk(v4, "]", 1024LL);
}
return v4;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
MOV EDI,0x400
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CALL 0x00101140
MOV R12,RAX
TEST RAX,RAX
JZ 0x0010171a
MOV R13D,0x5b
MOV word ptr [RAX],R13W
TEST EBP,EBP
JLE 0x00101706
LEA EAX,[RBP + -0x1]
LEA R15,[0x102004]
SHL RAX,0x4
LEA RBP,[0x10200e]
LEA R14,[0x102009]
LEA RAX,[RBX + RAX*0x1 + 0x10]
LEA R13,[0x102006]
MOV qword ptr [RSP],RAX
MOV EAX,0x1
LAB_00101550:
MOV R11D,dword ptr [RBX]
TEST R11D,R11D
JNZ 0x00101740
MOV R10D,dword ptr [RBX + 0x8]
TEST R10D,R10D
JZ 0x001016f8
TEST EAX,EAX
JZ 0x001016b7
MOV EDX,0x400
MOV RSI,R15
MOV RDI,R12
CALL 0x001010d0
LAB_00101581:
MOV EDX,0x400
MOV RSI,R14
MOV RDI,R12
CALL 0x001010d0
LAB_00101591:
MOV RDI,R12
CALL 0x001010f0
MOV ESI,0x202c
ADD RAX,R12
MOV word ptr [RAX],SI
LEA RDI,[RAX + 0x2]
MOV byte ptr [RAX + 0x2],0x0
MOV R8D,dword ptr [RBX + 0x8]
TEST R8D,R8D
JZ 0x00101690
LEA R9,[RSP + 0x10]
MOV R8D,dword ptr [RBX + 0xc]
MOV EDX,0x14
XOR EAX,EAX
MOV ESI,0x1
MOV RDI,R9
MOV RCX,R13
MOV qword ptr [RSP + 0x8],R9
CALL 0x00101150
MOV RSI,qword ptr [RSP + 0x8]
MOV EDX,0x400
MOV RDI,R12
CALL 0x001010d0
LAB_001015f0:
MOV EDX,0x400
MOV RSI,RBP
MOV RDI,R12
ADD RBX,0x10
CALL 0x001010d0
CMP qword ptr [RSP],RBX
JZ 0x00101706
MOV ECX,dword ptr [RBX]
TEST ECX,ECX
JZ 0x001016b0
LAB_00101618:
MOV RDI,R12
CALL 0x001010f0
MOV RCX,R12
MOV EDX,0x2
MOV RSI,R15
ADD RAX,R12
MOV R9D,0x202c
LEA RDI,[RAX + 0x2]
MOV word ptr [RAX],R9W
MOV byte ptr [RAX + 0x2],0x0
SUB RCX,RDI
ADD RCX,0x400
CALL 0x00101130
NOP
LAB_00101650:
LEA R9,[RSP + 0x10]
MOV R8D,dword ptr [RBX + 0x4]
MOV RCX,R13
XOR EAX,EAX
MOV RDI,R9
MOV EDX,0x14
MOV ESI,0x1
MOV qword ptr [RSP + 0x8],R9
CALL 0x00101150
MOV RSI,qword ptr [RSP + 0x8]
MOV EDX,0x400
MOV RDI,R12
CALL 0x001010d0
JMP 0x00101591
LAB_00101690:
MOV RCX,R12
MOV EDX,0x5
MOV RSI,R14
SUB RCX,RDI
ADD RCX,0x400
CALL 0x00101130
JMP 0x001015f0
LAB_001016b0:
MOV EAX,dword ptr [RBX + 0x8]
TEST EAX,EAX
JZ 0x001016f8
LAB_001016b7:
MOV RDI,R12
CALL 0x001010f0
MOV EDX,0x202c
MOV RCX,R12
MOV RSI,R15
ADD RAX,R12
LEA RDI,[RAX + 0x2]
MOV word ptr [RAX],DX
MOV EDX,0x2
MOV byte ptr [RAX + 0x2],0x0
SUB RCX,RDI
ADD RCX,0x400
CALL 0x00101130
JMP 0x00101581
LAB_001016f8:
ADD RBX,0x10
CMP RBX,qword ptr [RSP]
JNZ 0x00101550
LAB_00101706:
MOV EDX,0x400
LEA RSI,[0x102065]
MOV RDI,R12
CALL 0x001010d0
LAB_0010171a:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010175d
ADD RSP,0x38
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101740:
TEST EAX,EAX
JZ 0x00101618
MOV EDX,0x400
MOV RSI,R15
MOV RDI,R12
CALL 0x001010d0
JMP 0x00101650
LAB_0010175d:
CALL 0x00101100 | char * func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
char *__s;
size_t sVar3;
char *pcVar4;
int *piVar5;
long in_FS_OFFSET;
int1 local_58 [24];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__s = (char *)malloc(0x400);
if (__s != (char *)0x0) {
__s[0] = '[';
__s[1] = '\0';
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
iVar2 = 1;
do {
if (*param_1 != 0) {
if (iVar2 == 0) goto LAB_00101618;
__strcat_chk(__s,&DAT_00102004,0x400);
piVar5 = param_1;
goto LAB_00101650;
}
if (param_1[2] != 0) {
if (iVar2 == 0) goto LAB_001016b7;
__strcat_chk(__s,&DAT_00102004,0x400);
while( true ) {
__strcat_chk(__s,&DAT_00102009,0x400);
piVar5 = param_1;
while( true ) {
sVar3 = strlen(__s);
pcVar4 = __s + sVar3;
pcVar4[0] = ',';
pcVar4[1] = ' ';
pcVar4[2] = '\0';
if (piVar5[2] == 0) {
__memcpy_chk(pcVar4 + 2,&DAT_00102009,5,__s + (0x400 - (long)(pcVar4 + 2)));
}
else {
__sprintf_chk(local_58,1,0x14,&DAT_00102006,piVar5[3]);
__strcat_chk(__s,local_58,0x400);
}
param_1 = piVar5 + 4;
__strcat_chk(__s,&DAT_0010200e,0x400);
if (piVar1 == param_1) goto LAB_00101706;
if (*param_1 == 0) break;
LAB_00101618:
sVar3 = strlen(__s);
pcVar4 = __s + sVar3;
pcVar4[0] = ',';
pcVar4[1] = ' ';
pcVar4[2] = '\0';
__memcpy_chk(pcVar4 + 2,&DAT_00102004,2,__s + (0x400 - (long)(pcVar4 + 2)));
piVar5 = param_1;
LAB_00101650:
__sprintf_chk(local_58,1,0x14,&DAT_00102006,piVar5[1]);
__strcat_chk(__s,local_58,0x400);
}
iVar2 = piVar5[6];
if (iVar2 == 0) break;
LAB_001016b7:
sVar3 = strlen(__s);
pcVar4 = __s + sVar3;
pcVar4[0] = ',';
pcVar4[1] = ' ';
pcVar4[2] = '\0';
__memcpy_chk(pcVar4 + 2,&DAT_00102004,2,__s + (0x400 - (long)(pcVar4 + 2)));
}
}
param_1 = param_1 + 4;
} while (param_1 != piVar1);
}
LAB_00101706:
__strcat_chk(__s,"]",0x400);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return __s;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,575 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
int has_first;
int first;
int has_second;
int second;
} tuple_t;
| char* func0(tuple_t* test_list, int size) {
// Allocate sufficient memory for the result
char* res = malloc(1024);
if (!res) return NULL;
strcpy(res, "[");
int first = 1;
for(int i = 0; i < size; i++) {
int all_null = 1;
if (test_list[i].has_first) all_null = 0;
if (test_list[i].has_second) all_null = 0;
if (!all_null) {
if (!first) strcat(res, ", ");
first = 0;
strcat(res, "(");
if(test_list[i].has_first) {
char num[20];
sprintf(num, "%d", test_list[i].first);
strcat(res, num);
} else {
strcat(res, "None");
}
strcat(res, ", ");
if(test_list[i].has_second) {
char num[20];
sprintf(num, "%d", test_list[i].second);
strcat(res, num);
} else {
strcat(res, "None");
}
strcat(res, ")");
}
}
strcat(res, "]");
return res;
}
| int main() {
// First test case
tuple_t test1[] = {
{0, 0, 1, 2},
{0, 0, 0, 0},
{1, 3, 1, 4},
{1, 12, 1, 3},
{0, 0, 0, 0}
};
char* result1 = func0(test1, 5);
assert(strcmp(result1, "[(None, 2), (3, 4), (12, 3)]") == 0);
free(result1);
// Second test case
tuple_t test2[] = {
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 3, 1, 6},
{1, 17, 1, 3},
{0, 0, 1, 1}
};
char* result2 = func0(test2, 5);
assert(strcmp(result2, "[(3, 6), (17, 3), (None, 1)]") == 0);
free(result2);
// Third test case
tuple_t test3[] = {
{1, 1, 1, 2},
{1, 2, 0, 0},
{1, 3, 0, 0},
{1, 24, 1, 3},
{0, 0, 0, 0}
};
char* result3 = func0(test3, 5);
assert(strcmp(result3, "[(1, 2), (2, None), (3, None), (24, 3)]") == 0);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
mov $0x400,%edi
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 1100 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 16d1 <func0+0x2c1>
mov $0x5b,%r11d
mov %r11w,(%rax)
test %ebp,%ebp
jle 16bd <func0+0x2ad>
lea -0x1(%rbp),%eax
mov %rsp,%rbp
shl $0x4,%rax
lea 0x10(%rbx,%rax,1),%r13
mov $0x1,%eax
mov (%rbx),%r10d
test %r10d,%r10d
jne 16f8 <func0+0x2e8>
mov 0x8(%rbx),%r9d
test %r9d,%r9d
je 16b0 <func0+0x2a0>
test %eax,%eax
je 1647 <func0+0x237>
mov $0x400,%edx
lea 0xb66(%rip),%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
mov $0x400,%edx
lea 0xb57(%rip),%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 14bd <func0+0xad>
mov %eax,%edx
mov $0x202c,%ecx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov %eax,%esi
add %al,%sil
sbb $0x3,%rdi
mov %cx,(%rdi)
add $0x2,%rdi
movb $0x0,(%rdi)
mov 0x8(%rbx),%esi
test %esi,%esi
je 1618 <func0+0x208>
mov 0xc(%rbx),%r8d
mov $0x14,%edx
mov $0x1,%esi
xor %eax,%eax
mov %rbp,%rdi
lea 0xae0(%rip),%rcx
callq 1110 <__sprintf_chk@plt>
mov $0x400,%edx
mov %rbp,%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
mov $0x400,%edx
lea 0xac7(%rip),%rsi
mov %r12,%rdi
add $0x10,%rbx
callq 10b0 <__strcat_chk@plt>
cmp %r13,%rbx
je 16bd <func0+0x2ad>
mov (%rbx),%r14d
test %r14d,%r14d
je 1640 <func0+0x230>
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 156b <func0+0x15b>
mov %eax,%edx
mov $0x202c,%r8d
mov %r12,%rcx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x2,%edx
mov %eax,%esi
add %al,%sil
lea 0xa53(%rip),%rsi
sbb $0x3,%rdi
mov %r8w,(%rdi)
add $0x2,%rdi
movb $0x0,(%rdi)
sub %rdi,%rcx
add $0x400,%rcx
callq 10f0 <__memcpy_chk@plt>
test %r14d,%r14d
je 14a6 <func0+0x96>
nopl 0x0(%rax,%rax,1)
mov 0x4(%rbx),%r8d
mov %rbp,%rdi
lea 0xa18(%rip),%rcx
xor %eax,%eax
mov $0x14,%edx
mov $0x1,%esi
callq 1110 <__sprintf_chk@plt>
mov $0x400,%edx
mov %rbp,%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
jmpq 14ba <func0+0xaa>
nopl 0x0(%rax)
mov %r12,%rcx
mov $0x5,%edx
lea 0x9e2(%rip),%rsi
sub %rdi,%rcx
add $0x400,%rcx
callq 10f0 <__memcpy_chk@plt>
jmpq 153b <func0+0x12b>
nopl 0x0(%rax,%rax,1)
mov 0x8(%rbx),%eax
test %eax,%eax
je 16b0 <func0+0x2a0>
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 164a <func0+0x23a>
mov %eax,%edx
lea 0x99a(%rip),%rsi
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x2,%edx
mov %eax,%ecx
add %al,%cl
mov $0x202c,%eax
mov %r12,%rcx
sbb $0x3,%rdi
mov %ax,(%rdi)
add $0x2,%rdi
movb $0x0,(%rdi)
sub %rdi,%rcx
add $0x400,%rcx
callq 10f0 <__memcpy_chk@plt>
jmpq 14a6 <func0+0x96>
add $0x10,%rbx
cmp %r13,%rbx
jne 1471 <func0+0x61>
mov $0x400,%edx
lea 0x97f(%rip),%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 1782 <func0+0x372>
add $0x20,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl (%rax)
test %eax,%eax
je 1718 <func0+0x308>
mov $0x400,%edx
lea 0x8fc(%rip),%rsi
mov %r12,%rdi
callq 10b0 <__strcat_chk@plt>
jmpq 15e0 <func0+0x1d0>
nopl (%rax)
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 171b <func0+0x30b>
mov %eax,%edx
mov %r12,%rcx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x202c,%edx
mov %eax,%esi
add %al,%sil
lea 0x8a9(%rip),%rsi
sbb $0x3,%rdi
mov %dx,(%rdi)
add $0x2,%rdi
mov $0x2,%edx
movb $0x0,(%rdi)
sub %rdi,%rcx
add $0x400,%rcx
callq 10f0 <__memcpy_chk@plt>
jmpq 15e0 <func0+0x1d0>
callq 10d0 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
mov r14, rdi
mov edi, 400h; size
push r13
push r12
push rbp
push rbx
movsxd rbx, esi
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
call _malloc
mov r13, rax
test rax, rax
jz loc_164D
mov r10d, 5Bh ; '['
mov [rax], r10w
test ebx, ebx
jle loc_1639
shl rbx, 4
mov eax, 1
lea r12, unk_2004
add rbx, r14
loc_14A3:
mov r9d, [r14]
test r9d, r9d
jz loc_1678
test eax, eax
jz loc_16A8
mov edx, 400h
mov rsi, r12
mov rdi, r13
mov [rsp+68h+var_68], r12
call ___strcat_chk
lea rbp, asc_200E; ")"
loc_14D2:
lea r15, [rsp+68h+var_58]
mov r8d, [r14+4]
mov edx, 14h
xor eax, eax
mov esi, 2
mov rdi, r15
lea rcx, unk_2006
call ___sprintf_chk
mov edx, 400h
mov rsi, r15
mov rdi, r13
call ___strcat_chk
loc_1506:
mov rdi, r13; s
call _strlen
mov ecx, 202Ch
add rax, r13
mov [rax], cx
mov byte ptr [rax+2], 0
mov esi, [r14+8]
test esi, esi
jz loc_15F0
lea r15, [rsp+68h+var_58]
mov r8d, [r14+0Ch]
mov edx, 14h
xor eax, eax
mov esi, 2
mov rdi, r15
lea rcx, unk_2006
call ___sprintf_chk
mov edx, 400h
mov rsi, r15
mov rdi, r13
call ___strcat_chk
loc_155D:
mov edx, 400h
mov rsi, rbp
mov rdi, r13
add r14, 10h
call ___strcat_chk
cmp r14, rbx
jz loc_1639
mov r8d, [r14]
test r8d, r8d
jz loc_1620
loc_1586:
mov rdi, r13; s
mov [rsp+68h+var_5C], r8d
call _strlen
mov edi, 202Ch
mov rcx, r13
mov rsi, [rsp+68h+var_68]
add rax, r13
mov edx, 2
mov [rax], di
lea rdi, [rax+2]
mov byte ptr [rax+2], 0
sub rcx, rdi
add rcx, 400h
call ___memcpy_chk
mov r8d, [rsp+68h+var_5C]
test r8d, r8d
jnz loc_14D2
loc_15CF:
mov edx, 400h
lea rsi, aNone; "None"
mov rdi, r13
call ___strcat_chk
jmp loc_1506
loc_15F0:
lea rdi, [rax+2]
mov rcx, r13
mov edx, 5
sub rcx, rdi
lea rsi, aNone; "None"
add rcx, 400h
call ___memcpy_chk
jmp loc_155D
loc_1620:
mov eax, [r14+8]
test eax, eax
jnz loc_1586
loc_162C:
add r14, 10h
cmp r14, rbx
jnz loc_14A3
loc_1639:
mov edx, 400h
lea rsi, a36173None1+1Bh; "]"
mov rdi, r13
call ___strcat_chk
loc_164D:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz loc_170E
add rsp, 38h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1678:
mov r8d, [r14+8]
test r8d, r8d
jz short loc_162C
test eax, eax
jz short loc_16F4
mov edx, 400h
mov rsi, r12
mov rdi, r13
mov [rsp+68h+var_68], r12
call ___strcat_chk
lea rbp, asc_200E; ")"
jmp loc_15CF
loc_16A8:
mov rdi, r13; s
lea rbp, asc_200E; ")"
call _strlen
mov edx, 202Ch
mov rcx, r13
add rax, r13
mov [rax], dx
lea rdi, [rax+2]
mov edx, 2
mov byte ptr [rax+2], 0
sub rcx, rdi
lea rax, unk_2004
add rcx, 400h
mov rsi, rax
mov [rsp+68h+var_68], rax
call ___memcpy_chk
jmp loc_14D2
loc_16F4:
lea rax, unk_2004
xor r8d, r8d
lea rbp, asc_200E; ")"
mov [rsp+68h+var_68], rax
jmp loc_1586
loc_170E:
call ___stack_chk_fail | const char * func0(int *a1, int a2)
{
int *v2; // r14
char *v3; // rax
const char *v4; // r13
int v5; // eax
int *v6; // rbx
char *v7; // rax
int v8; // r8d
char *v9; // rax
char *v11; // rax
int v12; // [rsp+Ch] [rbp-5Ch]
_BYTE v13[24]; // [rsp+10h] [rbp-58h] BYREF
unsigned long long v14; // [rsp+28h] [rbp-40h]
v2 = a1;
v14 = __readfsqword(0x28u);
v3 = (char *)malloc(0x400uLL);
v4 = v3;
if ( v3 )
{
*(_WORD *)v3 = 91;
if ( a2 > 0 )
{
v5 = 1;
v6 = &a1[4 * a2];
while ( !*v2 )
{
if ( v2[2] )
{
if ( v5 )
{
__strcat_chk(v4, &unk_2004, 1024LL);
goto LABEL_13;
}
v8 = 0;
while ( 1 )
{
v12 = v8;
v9 = (char *)&v4[strlen(v4)];
strcpy(v9, ", ");
__memcpy_chk(v9 + 2, &unk_2004, 2LL, v4 - (v9 + 2) + 1024);
if ( v12 )
break;
LABEL_13:
__strcat_chk(v4, "None", 1024LL);
LABEL_8:
v7 = (char *)&v4[strlen(v4)];
strcpy(v7, ", ");
if ( v2[2] )
{
__sprintf_chk(v13, 2LL, 20LL, &unk_2006, (unsigned int)v2[3]);
__strcat_chk(v4, v13, 1024LL);
}
else
{
__memcpy_chk(v7 + 2, "None", 5LL, v4 - (v7 + 2) + 1024);
}
v2 += 4;
__strcat_chk(v4, ")", 1024LL);
if ( v2 == v6 )
goto LABEL_17;
v8 = *v2;
if ( !*v2 )
{
v5 = v2[2];
if ( !v5 )
goto LABEL_16;
}
}
LABEL_7:
__sprintf_chk(v13, 2LL, 20LL, &unk_2006, (unsigned int)v2[1]);
__strcat_chk(v4, v13, 1024LL);
goto LABEL_8;
}
LABEL_16:
v2 += 4;
if ( v2 == v6 )
goto LABEL_17;
}
if ( v5 )
{
__strcat_chk(v4, &unk_2004, 1024LL);
}
else
{
v11 = (char *)&v4[strlen(v4)];
strcpy(v11, ", ");
__memcpy_chk(v11 + 2, &unk_2004, 2LL, v4 - (v11 + 2) + 1024);
}
goto LABEL_7;
}
LABEL_17:
__strcat_chk(v4, "]", 1024LL);
}
return v4;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
MOV EDI,0x400
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOVSXD RBX,ESI
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CALL 0x00101140
MOV R13,RAX
TEST RAX,RAX
JZ 0x0010164d
MOV R10D,0x5b
MOV word ptr [RAX],R10W
TEST EBX,EBX
JLE 0x00101639
SHL RBX,0x4
MOV EAX,0x1
LEA R12,[0x102004]
ADD RBX,R14
LAB_001014a3:
MOV R9D,dword ptr [R14]
TEST R9D,R9D
JZ 0x00101678
TEST EAX,EAX
JZ 0x001016a8
MOV EDX,0x400
MOV RSI,R12
MOV RDI,R13
MOV qword ptr [RSP],R12
CALL 0x001010d0
LEA RBP,[0x10200e]
LAB_001014d2:
LEA R15,[RSP + 0x10]
MOV R8D,dword ptr [R14 + 0x4]
MOV EDX,0x14
XOR EAX,EAX
MOV ESI,0x2
MOV RDI,R15
LEA RCX,[0x102006]
CALL 0x00101150
MOV EDX,0x400
MOV RSI,R15
MOV RDI,R13
CALL 0x001010d0
LAB_00101506:
MOV RDI,R13
CALL 0x001010f0
MOV ECX,0x202c
ADD RAX,R13
MOV word ptr [RAX],CX
MOV byte ptr [RAX + 0x2],0x0
MOV ESI,dword ptr [R14 + 0x8]
TEST ESI,ESI
JZ 0x001015f0
LEA R15,[RSP + 0x10]
MOV R8D,dword ptr [R14 + 0xc]
MOV EDX,0x14
XOR EAX,EAX
MOV ESI,0x2
MOV RDI,R15
LEA RCX,[0x102006]
CALL 0x00101150
MOV EDX,0x400
MOV RSI,R15
MOV RDI,R13
CALL 0x001010d0
LAB_0010155d:
MOV EDX,0x400
MOV RSI,RBP
MOV RDI,R13
ADD R14,0x10
CALL 0x001010d0
CMP R14,RBX
JZ 0x00101639
MOV R8D,dword ptr [R14]
TEST R8D,R8D
JZ 0x00101620
LAB_00101586:
MOV RDI,R13
MOV dword ptr [RSP + 0xc],R8D
CALL 0x001010f0
MOV EDI,0x202c
MOV RCX,R13
MOV RSI,qword ptr [RSP]
ADD RAX,R13
MOV EDX,0x2
MOV word ptr [RAX],DI
LEA RDI,[RAX + 0x2]
MOV byte ptr [RAX + 0x2],0x0
SUB RCX,RDI
ADD RCX,0x400
CALL 0x00101130
MOV R8D,dword ptr [RSP + 0xc]
TEST R8D,R8D
JNZ 0x001014d2
LAB_001015cf:
MOV EDX,0x400
LEA RSI,[0x102009]
MOV RDI,R13
CALL 0x001010d0
JMP 0x00101506
LAB_001015f0:
LEA RDI,[RAX + 0x2]
MOV RCX,R13
MOV EDX,0x5
SUB RCX,RDI
LEA RSI,[0x102009]
ADD RCX,0x400
CALL 0x00101130
JMP 0x0010155d
LAB_00101620:
MOV EAX,dword ptr [R14 + 0x8]
TEST EAX,EAX
JNZ 0x00101586
LAB_0010162c:
ADD R14,0x10
CMP R14,RBX
JNZ 0x001014a3
LAB_00101639:
MOV EDX,0x400
LEA RSI,[0x102066]
MOV RDI,R13
CALL 0x001010d0
LAB_0010164d:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010170e
ADD RSP,0x38
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101678:
MOV R8D,dword ptr [R14 + 0x8]
TEST R8D,R8D
JZ 0x0010162c
TEST EAX,EAX
JZ 0x001016f4
MOV EDX,0x400
MOV RSI,R12
MOV RDI,R13
MOV qword ptr [RSP],R12
CALL 0x001010d0
LEA RBP,[0x10200e]
JMP 0x001015cf
LAB_001016a8:
MOV RDI,R13
LEA RBP,[0x10200e]
CALL 0x001010f0
MOV EDX,0x202c
MOV RCX,R13
ADD RAX,R13
MOV word ptr [RAX],DX
LEA RDI,[RAX + 0x2]
MOV EDX,0x2
MOV byte ptr [RAX + 0x2],0x0
SUB RCX,RDI
LEA RAX,[0x102004]
ADD RCX,0x400
MOV RSI,RAX
MOV qword ptr [RSP],RAX
CALL 0x00101130
JMP 0x001014d2
LAB_001016f4:
LEA RAX,[0x102004]
XOR R8D,R8D
LEA RBP,[0x10200e]
MOV qword ptr [RSP],RAX
JMP 0x00101586
LAB_0010170e:
CALL 0x00101100 | char * func0(int *param_1,int param_2)
{
int iVar1;
char *__s;
size_t sVar2;
char *pcVar3;
int *piVar4;
int iVar5;
int *piVar6;
long in_FS_OFFSET;
int local_58 [24];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__s = (char *)malloc(0x400);
if (__s != (char *)0x0) {
__s[0] = '[';
__s[1] = '\0';
if (0 < param_2) {
iVar1 = 1;
piVar4 = param_1 + (long)param_2 * 4;
do {
if (*param_1 != 0) {
if (iVar1 == 0) {
sVar2 = strlen(__s);
pcVar3 = __s + sVar2;
pcVar3[0] = ',';
pcVar3[1] = ' ';
pcVar3[2] = '\0';
__memcpy_chk(pcVar3 + 2,&DAT_00102004,2,__s + (0x400 - (long)(pcVar3 + 2)));
}
else {
__strcat_chk(__s,&DAT_00102004,0x400);
}
do {
__sprintf_chk(local_58,2,0x14,&DAT_00102006,param_1[1]);
__strcat_chk(__s,local_58,0x400);
piVar6 = param_1;
while( true ) {
sVar2 = strlen(__s);
pcVar3 = __s + sVar2;
pcVar3[0] = ',';
pcVar3[1] = ' ';
pcVar3[2] = '\0';
if (piVar6[2] == 0) {
__memcpy_chk(pcVar3 + 2,&DAT_00102009,5,__s + (0x400 - (long)(pcVar3 + 2)));
}
else {
__sprintf_chk(local_58,2,0x14,&DAT_00102006,piVar6[3]);
__strcat_chk(__s,local_58,0x400);
}
param_1 = piVar6 + 4;
__strcat_chk(__s,&DAT_0010200e,0x400);
if (param_1 == piVar4) goto LAB_00101639;
iVar5 = *param_1;
if (iVar5 == 0) {
iVar1 = piVar6[6];
if (iVar1 == 0) goto LAB_0010162c;
}
LAB_00101586:
sVar2 = strlen(__s);
pcVar3 = __s + sVar2;
pcVar3[0] = ',';
pcVar3[1] = ' ';
pcVar3[2] = '\0';
__memcpy_chk(pcVar3 + 2,&DAT_00102004,2,__s + (0x400 - (long)(pcVar3 + 2)));
if (iVar5 != 0) break;
LAB_001015cf:
__strcat_chk(__s,&DAT_00102009,0x400);
piVar6 = param_1;
}
} while( true );
}
if (param_1[2] != 0) {
if (iVar1 != 0) {
__strcat_chk(__s,&DAT_00102004,0x400);
goto LAB_001015cf;
}
iVar5 = 0;
goto LAB_00101586;
}
LAB_0010162c:
param_1 = param_1 + 4;
} while (param_1 != piVar4);
}
LAB_00101639:
__strcat_chk(__s,"]",0x400);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return __s;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,576 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct
{
int *elements;
int size;
} tuple;
| tuple *func0(const int *test_tup, int tup_size, int N, int *num_chunks)
{
*num_chunks = (tup_size + N - 1) / N;
tuple *res = malloc(*num_chunks * sizeof(tuple));
for (int i = 0; i < *num_chunks; i++)
{
int start = i * N;
int end = start + N < tup_size ? start + N : tup_size;
int chunk_size = end - start;
res[i].elements = malloc(chunk_size * sizeof(int));
res[i].size = chunk_size;
for (int j = start; j < end; j++)
{
res[i].elements[j - start] = test_tup[j];
}
}
return res;
}
| int main()
{
int test1[] = {10, 4, 5, 6, 7, 6, 8, 3, 4};
int num_chunks1;
tuple *chunks1 = func0(test1, sizeof(test1) / sizeof(test1[0]), 3, &num_chunks1);
assert(num_chunks1 == 3 && chunks1[0].size == 3 && chunks1[1].size == 3 && chunks1[2].size == 3);
free(chunks1);
int test2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int num_chunks2;
tuple *chunks2 = func0(test2, sizeof(test2) / sizeof(test2[0]), 2, &num_chunks2);
assert(num_chunks2 == 5 && chunks2[0].size == 2 && chunks2[4].size == 1);
free(chunks2);
int test3[] = {11, 14, 16, 17, 19, 21, 22, 25};
int num_chunks3;
tuple *chunks3 = func0(test3, sizeof(test3) / sizeof(test3[0]), 4, &num_chunks3);
assert(num_chunks3 == 2 && chunks3[0].size == 4 && chunks3[1].size == 4);
free(chunks3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %edx,-0x40(%rbp)
mov %rcx,-0x48(%rbp)
mov -0x3c(%rbp),%edx
mov -0x40(%rbp),%eax
add %edx,%eax
sub $0x1,%eax
cltd
idivl -0x40(%rbp)
mov %eax,%edx
mov -0x48(%rbp),%rax
mov %edx,(%rax)
mov -0x48(%rbp),%rax
mov (%rax),%eax
cltq
shl $0x4,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x2c(%rbp)
jmpq 12bc <func0+0x113>
mov -0x2c(%rbp),%eax
imul -0x40(%rbp),%eax
mov %eax,-0x24(%rbp)
mov -0x24(%rbp),%edx
mov -0x40(%rbp),%eax
add %edx,%eax
cmp %eax,-0x3c(%rbp)
cmovle -0x3c(%rbp),%eax
mov %eax,-0x20(%rbp)
mov -0x20(%rbp),%eax
sub -0x24(%rbp),%eax
mov %eax,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov %rdx,%rcx
shl $0x4,%rcx
mov -0x18(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,(%rbx)
mov -0x2c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x1c(%rbp),%eax
mov %eax,0x8(%rdx)
mov -0x24(%rbp),%eax
mov %eax,-0x28(%rbp)
jmp 12b0 <func0+0x107>
mov -0x28(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x2c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x28(%rbp),%eax
sub -0x24(%rbp),%eax
cltq
shl $0x2,%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 126e <func0+0xc5>
addl $0x1,-0x2c(%rbp)
mov -0x48(%rbp),%rax
mov (%rax),%eax
cmp %eax,-0x2c(%rbp)
jl 11ff <func0+0x56>
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_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_40], edx
mov [rbp+var_48], rcx
mov edx, [rbp+var_3C]
mov eax, [rbp+var_40]
add eax, edx
sub eax, 1
cdq
idiv [rbp+var_40]
mov edx, eax
mov rax, [rbp+var_48]
mov [rax], edx
mov rax, [rbp+var_48]
mov eax, [rax]
cdqe
shl rax, 4
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_2C], 0
jmp loc_12BD
loc_11FF:
mov eax, [rbp+var_2C]
imul eax, [rbp+var_40]
mov [rbp+var_24], eax
mov edx, [rbp+var_24]
mov eax, [rbp+var_40]
add eax, edx
mov edx, [rbp+var_3C]
cmp edx, eax
cmovle eax, edx
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
sub eax, [rbp+var_24]
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov edx, [rbp+var_2C]
movsxd rdx, edx
mov rcx, rdx
shl rcx, 4
mov rdx, [rbp+var_18]
lea rbx, [rcx+rdx]
mov rdi, rax; size
call _malloc
mov [rbx], rax
mov eax, [rbp+var_2C]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_1C]
mov [rdx+8], eax
mov eax, [rbp+var_24]
mov [rbp+var_28], eax
jmp short loc_12B1
loc_126F:
mov eax, [rbp+var_28]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_38]
lea rcx, [rdx+rax]
mov eax, [rbp+var_2C]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_28]
sub eax, [rbp+var_24]
cdqe
shl rax, 2
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
add [rbp+var_28], 1
loc_12B1:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_20]
jl short loc_126F
add [rbp+var_2C], 1
loc_12BD:
mov rax, [rbp+var_48]
mov eax, [rax]
cmp [rbp+var_2C], eax
jl loc_11FF
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | _QWORD * func0(long long a1, int a2, int a3, int *a4)
{
int v4; // eax
int i; // [rsp+24h] [rbp-2Ch]
int j; // [rsp+28h] [rbp-28h]
int v10; // [rsp+2Ch] [rbp-24h]
int v11; // [rsp+30h] [rbp-20h]
int v12; // [rsp+34h] [rbp-1Ch]
_QWORD *v13; // [rsp+38h] [rbp-18h]
*a4 = (a2 + a3 - 1) / a3;
v13 = malloc(16LL * *a4);
for ( i = 0; i < *a4; ++i )
{
v10 = a3 * i;
v4 = a3 * i + a3;
if ( a2 <= v4 )
v4 = a2;
v11 = v4;
v12 = v4 - v10;
v13[2 * i] = malloc(4LL * (v4 - v10));
LODWORD(v13[2 * i + 1]) = v12;
for ( j = a3 * i; j < v11; ++j )
*(_DWORD *)(4LL * (j - v10) + v13[2 * i]) = *(_DWORD *)(4LL * j + a1);
}
return v13;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x40],EDX
MOV qword ptr [RBP + -0x48],RCX
MOV EDX,dword ptr [RBP + -0x3c]
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,EDX
SUB EAX,0x1
CDQ
IDIV dword ptr [RBP + -0x40]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
CDQE
SHL RAX,0x4
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x001012bd
LAB_001011ff:
MOV EAX,dword ptr [RBP + -0x2c]
IMUL EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x24],EAX
MOV EDX,dword ptr [RBP + -0x24]
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,EDX
MOV EDX,dword ptr [RBP + -0x3c]
CMP EDX,EAX
CMOVLE EAX,EDX
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV EDX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EDX
MOV RCX,RDX
SHL RCX,0x4
MOV RDX,qword ptr [RBP + -0x18]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RDX + 0x8],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001012b1
LAB_0010126f:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x28]
SUB EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x2
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x28],0x1
LAB_001012b1:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x0010126f
ADD dword ptr [RBP + -0x2c],0x1
LAB_001012bd:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x2c],EAX
JL 0x001011ff
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int param_3,int *param_4)
{
int iVar1;
int iVar2;
void *pvVar3;
void *pvVar4;
int local_34;
int local_30;
*param_4 = (param_3 + param_2 + -1) / param_3;
pvVar3 = malloc((long)*param_4 << 4);
for (local_34 = 0; local_34 < *param_4; local_34 = local_34 + 1) {
iVar1 = local_34 * param_3;
iVar2 = param_3 + iVar1;
if (param_2 <= param_3 + iVar1) {
iVar2 = param_2;
}
pvVar4 = malloc((long)(iVar2 - iVar1) << 2);
*(void **)((long)local_34 * 0x10 + (long)pvVar3) = pvVar4;
*(int *)((long)pvVar3 + (long)local_34 * 0x10 + 8) = iVar2 - iVar1;
for (local_30 = iVar1; local_30 < iVar2; local_30 = local_30 + 1) {
*(int4 *)
(*(long *)((long)pvVar3 + (long)local_34 * 0x10) + (long)(local_30 - iVar1) * 4) =
*(int4 *)((long)local_30 * 4 + param_1);
}
}
return pvVar3;
} |
7,577 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct
{
int *elements;
int size;
} tuple;
| tuple *func0(const int *test_tup, int tup_size, int N, int *num_chunks)
{
*num_chunks = (tup_size + N - 1) / N;
tuple *res = malloc(*num_chunks * sizeof(tuple));
for (int i = 0; i < *num_chunks; i++)
{
int start = i * N;
int end = start + N < tup_size ? start + N : tup_size;
int chunk_size = end - start;
res[i].elements = malloc(chunk_size * sizeof(int));
res[i].size = chunk_size;
for (int j = start; j < end; j++)
{
res[i].elements[j - start] = test_tup[j];
}
}
return res;
}
| int main()
{
int test1[] = {10, 4, 5, 6, 7, 6, 8, 3, 4};
int num_chunks1;
tuple *chunks1 = func0(test1, sizeof(test1) / sizeof(test1[0]), 3, &num_chunks1);
assert(num_chunks1 == 3 && chunks1[0].size == 3 && chunks1[1].size == 3 && chunks1[2].size == 3);
free(chunks1);
int test2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int num_chunks2;
tuple *chunks2 = func0(test2, sizeof(test2) / sizeof(test2[0]), 2, &num_chunks2);
assert(num_chunks2 == 5 && chunks2[0].size == 2 && chunks2[4].size == 1);
free(chunks2);
int test3[] = {11, 14, 16, 17, 19, 21, 22, 25};
int num_chunks3;
tuple *chunks3 = func0(test3, sizeof(test3) / sizeof(test3[0]), 4, &num_chunks3);
assert(num_chunks3 == 2 && chunks3[0].size == 4 && chunks3[1].size == 4);
free(chunks3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%rbp
mov %esi,0x18(%rsp)
mov %edx,%ebx
mov %rcx,%r14
mov %rcx,0x10(%rsp)
lea -0x1(%rsi,%rdx,1),%eax
cltd
idiv %ebx
mov %eax,(%rcx)
movslq %eax,%rdi
shl $0x4,%rdi
callq 10b0 <malloc@plt>
mov %rax,0x28(%rsp)
cmpl $0x0,(%r14)
jle 129c <func0+0xf3>
mov %ebx,0x1c(%rsp)
mov %rax,%r12
movslq %ebx,%rbx
lea 0x0(,%rbx,4),%rax
mov %rax,0x20(%rsp)
mov %rbp,%rbx
mov $0x0,%ebp
mov $0x0,%r14d
jmp 122e <func0+0x85>
add $0x1,%r14d
add $0x10,%r12
add 0x20(%rsp),%rbx
mov 0x10(%rsp),%rax
cmp %r14d,(%rax)
jle 129c <func0+0xf3>
mov %ebp,%esi
mov %ebp,0xc(%rsp)
add 0x1c(%rsp),%ebp
mov 0x18(%rsp),%eax
cmp %eax,%ebp
mov %eax,%r13d
cmovle %ebp,%r13d
mov %r13d,%r15d
mov %esi,0x8(%rsp)
sub %esi,%r15d
movslq %r15d,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %r12,%rsi
mov %rax,(%r12)
mov %r15d,0x8(%r12)
cmp %r13d,0x8(%rsp)
jge 1217 <func0+0x6e>
mov 0xc(%rsp),%eax
not %eax
lea (%rax,%r13,1),%eax
lea 0x4(,%rax,4),%rdi
mov $0x0,%eax
mov (%rbx,%rax,1),%ecx
mov (%rsi),%rdx
mov %ecx,(%rdx,%rax,1)
add $0x4,%rax
cmp %rdi,%rax
jne 1285 <func0+0xdc>
jmpq 1217 <func0+0x6e>
mov 0x28(%rsp),%rax
add $0x38,%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, 48h
mov rbp, rdi
mov [rsp+78h+var_60], esi
mov ebx, edx
mov [rsp+78h+var_5C], edx
mov r14, rcx
mov [rsp+78h+var_58], rcx
lea eax, [rsi+rdx-1]
cdq
idiv ebx
mov [rcx], eax
movsxd rdi, eax
shl rdi, 4
call _malloc
mov [rsp+78h+var_40], rax
cmp dword ptr [r14], 0
jle loc_12A1
mov r13, rax
movsxd rax, ebx
mov [rsp+78h+var_50], rax
neg rax
shl rax, 2
mov [rsp+78h+var_48], rax
mov [rsp+78h+var_68], 0
mov [rsp+78h+var_70], 0
mov r12d, 0
mov r14d, 0
loc_1229:
mov esi, r12d
add r12d, [rsp+78h+var_5C]
mov eax, [rsp+78h+var_60]
cmp r12d, eax
mov ebx, eax
cmovle ebx, r12d
mov r15d, ebx
mov [rsp+78h+var_74], esi
sub r15d, esi
movsxd rdi, r15d
shl rdi, 2
call _malloc
mov [r13+0], rax
mov [r13+8], r15d
cmp [rsp+78h+var_74], ebx
jge short loc_127B
mov rdx, [rsp+78h+var_70]
add rax, [rsp+78h+var_68]
loc_126C:
mov ecx, [rbp+rdx*4+0]
mov [rax+rdx*4], ecx
add rdx, 1
cmp ebx, edx
jg short loc_126C
loc_127B:
add r14d, 1
add r13, 10h
mov rsi, [rsp+78h+var_50]
add [rsp+78h+var_70], rsi
mov rdi, [rsp+78h+var_48]
add [rsp+78h+var_68], rdi
mov rax, [rsp+78h+var_58]
cmp [rax], r14d
jg short loc_1229
loc_12A1:
mov rax, [rsp+78h+var_40]
add rsp, 48h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, long long a2, int a3, int *a4)
{
long long v6; // rdx
int v7; // kr00_4
long long v8; // rax
long long v9; // rdx
long long v10; // r13
int v11; // r12d
int v12; // r14d
long long v13; // rsi
int v14; // ebx
long long v15; // rax
long long v16; // rax
long long v18; // [rsp+8h] [rbp-70h]
long long v19; // [rsp+10h] [rbp-68h]
int v20; // [rsp+18h] [rbp-60h]
long long v23; // [rsp+28h] [rbp-50h]
long long v24; // [rsp+30h] [rbp-48h]
long long v25; // [rsp+38h] [rbp-40h]
v20 = a2;
v7 = a2 + a3 - 1;
v6 = (unsigned int)(v7 >> 31);
LODWORD(v6) = v7 % a3;
*a4 = v7 / a3;
v8 = malloc(16LL * (v7 / a3), a2, v6);
v25 = v8;
if ( *a4 > 0 )
{
v10 = v8;
v23 = a3;
v24 = -4LL * a3;
v19 = 0LL;
v18 = 0LL;
v11 = 0;
v12 = 0;
do
{
v13 = (unsigned int)v11;
v11 += a3;
v14 = v20;
if ( v11 <= v20 )
v14 = v11;
v15 = malloc(4LL * (v14 - (int)v13), v13, v9);
*(_QWORD *)v10 = v15;
*(_DWORD *)(v10 + 8) = v14 - v13;
if ( (int)v13 < v14 )
{
v9 = v18;
v16 = v19 + v15;
do
{
*(_DWORD *)(v16 + 4 * v9) = *(_DWORD *)(a1 + 4 * v9);
++v9;
}
while ( v14 > (int)v9 );
}
++v12;
v10 += 16LL;
v18 += v23;
v19 += v24;
}
while ( *a4 > v12 );
}
return v25;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RBP,RDI
MOV dword ptr [RSP + 0x18],ESI
MOV EBX,EDX
MOV dword ptr [RSP + 0x1c],EDX
MOV R14,RCX
MOV qword ptr [RSP + 0x20],RCX
LEA EAX,[RSI + RDX*0x1 + -0x1]
CDQ
IDIV EBX
MOV dword ptr [RCX],EAX
MOVSXD RDI,EAX
SHL RDI,0x4
CALL 0x001010b0
MOV qword ptr [RSP + 0x38],RAX
CMP dword ptr [R14],0x0
JLE 0x001012a1
MOV R13,RAX
MOVSXD RAX,EBX
MOV qword ptr [RSP + 0x28],RAX
NEG RAX
SHL RAX,0x2
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV R12D,0x0
MOV R14D,0x0
LAB_00101229:
MOV ESI,R12D
ADD R12D,dword ptr [RSP + 0x1c]
MOV EAX,dword ptr [RSP + 0x18]
CMP R12D,EAX
MOV EBX,EAX
CMOVLE EBX,R12D
MOV R15D,EBX
MOV dword ptr [RSP + 0x4],ESI
SUB R15D,ESI
MOVSXD RDI,R15D
SHL RDI,0x2
CALL 0x001010b0
MOV qword ptr [R13],RAX
MOV dword ptr [R13 + 0x8],R15D
CMP dword ptr [RSP + 0x4],EBX
JGE 0x0010127b
MOV RDX,qword ptr [RSP + 0x8]
ADD RAX,qword ptr [RSP + 0x10]
LAB_0010126c:
MOV ECX,dword ptr [RBP + RDX*0x4]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP EBX,EDX
JG 0x0010126c
LAB_0010127b:
ADD R14D,0x1
ADD R13,0x10
MOV RSI,qword ptr [RSP + 0x28]
ADD qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x30]
ADD qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX],R14D
JG 0x00101229
LAB_001012a1:
MOV RAX,qword ptr [RSP + 0x38]
ADD RSP,0x48
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(long param_1,int param_2,int param_3,int *param_4)
{
int iVar1;
int8 *puVar2;
void *pvVar3;
long lVar4;
int iVar5;
int iVar6;
int8 *puVar7;
int iVar8;
long local_70;
long local_68;
iVar1 = (param_2 + -1 + param_3) / param_3;
*param_4 = iVar1;
puVar2 = (int8 *)malloc((long)iVar1 << 4);
if (0 < *param_4) {
local_68 = 0;
local_70 = 0;
iVar8 = 0;
puVar7 = puVar2;
iVar1 = 0;
do {
iVar6 = iVar1 + param_3;
iVar5 = param_2;
if (iVar6 <= param_2) {
iVar5 = iVar6;
}
pvVar3 = malloc((long)(iVar5 - iVar1) << 2);
*puVar7 = pvVar3;
*(int *)(puVar7 + 1) = iVar5 - iVar1;
lVar4 = local_70;
while (iVar1 < iVar5) {
*(int4 *)((long)pvVar3 + lVar4 * 4 + local_68) = *(int4 *)(param_1 + lVar4 * 4);
lVar4 = lVar4 + 1;
iVar1 = (int)lVar4;
}
iVar8 = iVar8 + 1;
puVar7 = puVar7 + 2;
local_70 = local_70 + param_3;
local_68 = local_68 + (long)param_3 * -4;
iVar1 = iVar6;
} while (iVar8 < *param_4);
}
return puVar2;
} |
7,578 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct
{
int *elements;
int size;
} tuple;
| tuple *func0(const int *test_tup, int tup_size, int N, int *num_chunks)
{
*num_chunks = (tup_size + N - 1) / N;
tuple *res = malloc(*num_chunks * sizeof(tuple));
for (int i = 0; i < *num_chunks; i++)
{
int start = i * N;
int end = start + N < tup_size ? start + N : tup_size;
int chunk_size = end - start;
res[i].elements = malloc(chunk_size * sizeof(int));
res[i].size = chunk_size;
for (int j = start; j < end; j++)
{
res[i].elements[j - start] = test_tup[j];
}
}
return res;
}
| int main()
{
int test1[] = {10, 4, 5, 6, 7, 6, 8, 3, 4};
int num_chunks1;
tuple *chunks1 = func0(test1, sizeof(test1) / sizeof(test1[0]), 3, &num_chunks1);
assert(num_chunks1 == 3 && chunks1[0].size == 3 && chunks1[1].size == 3 && chunks1[2].size == 3);
free(chunks1);
int test2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int num_chunks2;
tuple *chunks2 = func0(test2, sizeof(test2) / sizeof(test2[0]), 2, &num_chunks2);
assert(num_chunks2 == 5 && chunks2[0].size == 2 && chunks2[4].size == 1);
free(chunks2);
int test3[] = {11, 14, 16, 17, 19, 21, 22, 25};
int num_chunks3;
tuple *chunks3 = func0(test3, sizeof(test3) / sizeof(test3[0]), 4, &num_chunks3);
assert(num_chunks3 == 2 && chunks3[0].size == 4 && chunks3[1].size == 4);
free(chunks3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
lea -0x1(%rsi,%rdx,1),%eax
push %r14
mov %rcx,%r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %edx,%ebx
sub $0x48,%rsp
mov %edx,0x1c(%rsp)
cltd
idiv %ebx
mov %esi,0x18(%rsp)
mov %rcx,0x20(%rsp)
mov %eax,(%rcx)
movslq %eax,%rdi
shl $0x4,%rdi
callq 10b0 <malloc@plt>
mov (%r14),%edx
mov %rax,0x38(%rsp)
test %edx,%edx
jle 14d8 <func0+0x108>
mov %rax,%rcx
movslq %ebx,%rax
xor %r12d,%r12d
xor %r13d,%r13d
mov %rax,0x28(%rsp)
neg %rax
mov %r13d,%edx
xor %r14d,%r14d
shl $0x2,%rax
mov %r12,%r13
xor %r15d,%r15d
mov %rcx,%r12
mov %rax,0x30(%rsp)
nopl 0x0(%rax,%rax,1)
mov 0x18(%rsp),%ebx
mov %edx,%r8d
add 0x1c(%rsp),%edx
mov %edx,0x14(%rsp)
cmp %ebx,%edx
mov %r8d,0x10(%rsp)
cmovle %edx,%ebx
mov %ebx,%r9d
sub %r8d,%r9d
movslq %r9d,%rdi
mov %r9d,0xc(%rsp)
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov 0x10(%rsp),%r8d
mov 0xc(%rsp),%r9d
mov %rax,(%r12)
mov 0x14(%rsp),%edx
cmp %ebx,%r8d
mov %r9d,0x8(%r12)
jge 14b8 <func0+0xe8>
mov %r14,%rdi
lea (%rax,%r13,1),%r8
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp,%rdi,4),%eax
mov %eax,(%r8,%rdi,4)
add $0x1,%rdi
cmp %edi,%ebx
jg 14a8 <func0+0xd8>
mov 0x20(%rsp),%rax
add $0x1,%r15d
add $0x10,%r12
add 0x28(%rsp),%r14
add 0x30(%rsp),%r13
cmp %r15d,(%rax)
jg 1450 <func0+0x80>
mov 0x38(%rsp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
| func0:
endbr64
push r15
movsxd r15, edx
push r14
lea eax, [rsi+r15-1]
push r13
push r12
push rbp
mov rbp, rcx
push rbx
mov rbx, rdi
sub rsp, 38h
mov [rsp+68h+var_54], edx
cdq
idiv r15d
mov [rsp+68h+var_58], esi
mov [rsp+68h+var_50], rcx
mov [rcx], eax
movsxd rdi, eax
shl rdi, 4
call _malloc
mov edx, [rbp+0]
mov [rsp+68h+var_40], rax
test edx, edx
jle short loc_14BA
mov r14, rax
lea rax, ds:0[r15*4]
xor ebp, ebp
xor r15d, r15d
mov [rsp+68h+var_48], rax
loc_1450:
mov eax, [rsp+68h+var_58]
mov r9d, r15d
add r15d, [rsp+68h+var_54]
mov [rsp+68h+var_5C], r9d
cmp r15d, eax
mov r12d, eax
cmovle r12d, r15d
mov r13d, r12d
sub r13d, r9d
movsxd rdi, r13d
shl rdi, 2
call _malloc
mov r9d, [rsp+68h+var_5C]
mov [r14+8], r13d
mov [r14], rax
mov rdi, rax
cmp r9d, r12d
jge short loc_14A5
lea eax, [r13-1]
mov rsi, rbx
lea rdx, ds:4[rax*4]
call _memcpy
loc_14A5:
mov rax, [rsp+68h+var_50]
add ebp, 1
add r14, 10h
add rbx, [rsp+68h+var_48]
cmp [rax], ebp
jg short loc_1450
loc_14BA:
mov rax, [rsp+68h+var_40]
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, long long a2, int a3, int *a4)
{
long long v4; // r15
long long v7; // rdx
int v8; // kr00_4
long long v9; // rax
long long v10; // rdx
long long v11; // r14
long long v12; // rax
int v13; // ebp
int v14; // r15d
int v15; // r9d
int v16; // r12d
int v17; // r13d
long long v18; // rax
int v20; // [rsp+Ch] [rbp-5Ch]
int v21; // [rsp+10h] [rbp-58h]
long long v24; // [rsp+20h] [rbp-48h]
long long v25; // [rsp+28h] [rbp-40h]
v4 = a3;
v8 = a2 + a3 - 1;
v7 = (unsigned int)(v8 >> 31);
LODWORD(v7) = v8 % (int)v4;
v21 = a2;
*a4 = v8 / (int)v4;
v9 = malloc(16LL * (v8 / (int)v4), a2, v7);
v10 = (unsigned int)*a4;
v25 = v9;
if ( (int)v10 > 0 )
{
v11 = v9;
v12 = 4 * v4;
v13 = 0;
v14 = 0;
v24 = v12;
do
{
v15 = v14;
v14 += a3;
v20 = v15;
v16 = v21;
if ( v14 <= v21 )
v16 = v14;
v17 = v16 - v15;
v18 = malloc(4LL * (v16 - v15), a2, v10);
*(_DWORD *)(v11 + 8) = v17;
*(_QWORD *)v11 = v18;
if ( v20 < v16 )
{
a2 = a1;
memcpy(v18, a1, 4LL * (unsigned int)(v17 - 1) + 4);
}
++v13;
v11 += 16LL;
a1 += v24;
}
while ( *a4 > v13 );
}
return v25;
} | func0:
ENDBR64
PUSH R15
MOVSXD R15,EDX
PUSH R14
LEA EAX,[RSI + R15*0x1 + -0x1]
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RCX
PUSH RBX
MOV RBX,RDI
SUB RSP,0x38
MOV dword ptr [RSP + 0x14],EDX
CDQ
IDIV R15D
MOV dword ptr [RSP + 0x10],ESI
MOV qword ptr [RSP + 0x18],RCX
MOV dword ptr [RCX],EAX
MOVSXD RDI,EAX
SHL RDI,0x4
CALL 0x001010d0
MOV EDX,dword ptr [RBP]
MOV qword ptr [RSP + 0x28],RAX
TEST EDX,EDX
JLE 0x001014ba
MOV R14,RAX
LEA RAX,[R15*0x4]
XOR EBP,EBP
XOR R15D,R15D
MOV qword ptr [RSP + 0x20],RAX
LAB_00101450:
MOV EAX,dword ptr [RSP + 0x10]
MOV R9D,R15D
ADD R15D,dword ptr [RSP + 0x14]
MOV dword ptr [RSP + 0xc],R9D
CMP R15D,EAX
MOV R12D,EAX
CMOVLE R12D,R15D
MOV R13D,R12D
SUB R13D,R9D
MOVSXD RDI,R13D
SHL RDI,0x2
CALL 0x001010d0
MOV R9D,dword ptr [RSP + 0xc]
MOV dword ptr [R14 + 0x8],R13D
MOV qword ptr [R14],RAX
MOV RDI,RAX
CMP R9D,R12D
JGE 0x001014a5
LEA EAX,[R13 + -0x1]
MOV RSI,RBX
LEA RDX,[0x4 + RAX*0x4]
CALL 0x001010c0
LAB_001014a5:
MOV RAX,qword ptr [RSP + 0x18]
ADD EBP,0x1
ADD R14,0x10
ADD RBX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX],EBP
JG 0x00101450
LAB_001014ba:
MOV RAX,qword ptr [RSP + 0x28]
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(void *param_1,int param_2,int param_3,int *param_4)
{
int iVar1;
int8 *puVar2;
void *__dest;
int iVar3;
int iVar4;
int iVar5;
int8 *puVar6;
int iVar7;
iVar1 = (param_2 + -1 + param_3) / param_3;
*param_4 = iVar1;
puVar2 = (int8 *)malloc((long)iVar1 << 4);
if (0 < *param_4) {
iVar3 = 0;
puVar6 = puVar2;
iVar1 = 0;
do {
iVar7 = iVar1 + param_3;
iVar4 = param_2;
if (iVar7 <= param_2) {
iVar4 = iVar7;
}
iVar5 = iVar4 - iVar1;
__dest = malloc((long)iVar5 << 2);
*(int *)(puVar6 + 1) = iVar5;
*puVar6 = __dest;
if (iVar1 < iVar4) {
memcpy(__dest,param_1,(ulong)(iVar5 - 1) * 4 + 4);
}
iVar3 = iVar3 + 1;
puVar6 = puVar6 + 2;
param_1 = (void *)((long)param_1 + (long)param_3 * 4);
iVar1 = iVar7;
} while (iVar3 < *param_4);
}
return puVar2;
} |
7,579 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct
{
int *elements;
int size;
} tuple;
| tuple *func0(const int *test_tup, int tup_size, int N, int *num_chunks)
{
*num_chunks = (tup_size + N - 1) / N;
tuple *res = malloc(*num_chunks * sizeof(tuple));
for (int i = 0; i < *num_chunks; i++)
{
int start = i * N;
int end = start + N < tup_size ? start + N : tup_size;
int chunk_size = end - start;
res[i].elements = malloc(chunk_size * sizeof(int));
res[i].size = chunk_size;
for (int j = start; j < end; j++)
{
res[i].elements[j - start] = test_tup[j];
}
}
return res;
}
| int main()
{
int test1[] = {10, 4, 5, 6, 7, 6, 8, 3, 4};
int num_chunks1;
tuple *chunks1 = func0(test1, sizeof(test1) / sizeof(test1[0]), 3, &num_chunks1);
assert(num_chunks1 == 3 && chunks1[0].size == 3 && chunks1[1].size == 3 && chunks1[2].size == 3);
free(chunks1);
int test2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int num_chunks2;
tuple *chunks2 = func0(test2, sizeof(test2) / sizeof(test2[0]), 2, &num_chunks2);
assert(num_chunks2 == 5 && chunks2[0].size == 2 && chunks2[4].size == 1);
free(chunks2);
int test3[] = {11, 14, 16, 17, 19, 21, 22, 25};
int num_chunks3;
tuple *chunks3 = func0(test3, sizeof(test3) / sizeof(test3[0]), 4, &num_chunks3);
assert(num_chunks3 == 2 && chunks3[0].size == 4 && chunks3[1].size == 4);
free(chunks3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
lea -0x1(%rsi,%rdx,1),%eax
mov %edx,%r15d
push %r14
push %r13
push %r12
mov %rcx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x28,%rsp
mov %edx,0x14(%rsp)
cltd
idiv %r15d
mov %esi,0x10(%rsp)
mov %eax,(%rcx)
movslq %eax,%rdi
shl $0x4,%rdi
callq 10d0 <malloc@plt>
mov (%r12),%edx
mov %rax,0x18(%rsp)
test %edx,%edx
jle 148b <func0+0xfb>
movslq %r15d,%r13
mov %rax,%rbp
xor %r14d,%r14d
xor %r15d,%r15d
lea 0x0(,%r13,4),%rax
mov %rbx,%r13
mov %rax,0x8(%rsp)
jmp 142f <func0+0x9f>
nopl 0x0(%rax,%rax,1)
mov %r14d,%edx
mov %r13,%rsi
add $0x1,%r15d
add $0x10,%rbp
not %edx
lea (%rdx,%r9,1),%eax
lea 0x4(,%rax,4),%rdx
callq 10c0 <memcpy@plt>
add 0x8(%rsp),%r13
cmp (%r12),%r15d
jge 148b <func0+0xfb>
mov %ebx,%r14d
mov 0x14(%rsp),%eax
lea (%rax,%r14,1),%ebx
mov 0x10(%rsp),%eax
cmp %eax,%ebx
mov %eax,%r9d
cmovle %ebx,%r9d
mov %r9d,%r10d
mov %r9d,0x4(%rsp)
sub %r14d,%r10d
movslq %r10d,%rdi
mov %r10d,(%rsp)
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov (%rsp),%r10d
mov 0x4(%rsp),%r9d
mov %rax,0x0(%rbp)
mov %rax,%rdi
mov %r10d,0x8(%rbp)
cmp %r9d,%r14d
jl 1400 <func0+0x70>
add $0x1,%r15d
add $0x10,%rbp
add 0x8(%rsp),%r13
cmp %r15d,(%r12)
jg 142c <func0+0x9c>
mov 0x18(%rsp),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
lea eax, [rsi+rdx-1]
mov r15d, edx
push r14
mov r14d, esi
push r13
push r12
mov r12, rdi
push rbp
mov rbp, rcx
push rbx
sub rsp, 38h
mov [rsp+68h+var_54], edx
cdq
idiv r15d
mov [rsp+68h+var_50], rcx
mov [rcx], eax
movsxd rdi, eax
shl rdi, 4; size
call _malloc
mov edx, [rbp+0]
mov [rsp+68h+var_40], rax
test edx, edx
jle loc_1482
mov rbx, rax
movsxd rax, r15d
xor r13d, r13d
xor r15d, r15d
shl rax, 2
mov [rsp+68h+var_48], rax
jmp short loc_1428
loc_13F8:
lea eax, [rcx-1]
mov rsi, r12; src
add r13d, 1
add rbx, 10h
lea rdx, ds:4[rax*4]; n
call _memcpy
mov rax, [rsp+68h+var_48]
add r12, rax
mov rax, [rsp+68h+var_50]
cmp r13d, [rax]
jge short loc_1482
loc_1425:
mov r15d, ebp
loc_1428:
mov eax, [rsp+68h+var_54]
mov esi, r14d
lea ebp, [rax+r15]
cmp ebp, r14d
cmovle esi, ebp
mov ecx, esi
mov [rsp+68h+var_58], esi
sub ecx, r15d
movsxd rdi, ecx
mov [rsp+68h+var_5C], ecx
shl rdi, 2; size
call _malloc
mov ecx, [rsp+68h+var_5C]
mov esi, [rsp+68h+var_58]
mov [rbx], rax
mov rdi, rax; dest
mov [rbx+8], ecx
cmp r15d, esi
jl short loc_13F8
mov rax, [rsp+68h+var_48]
add r13d, 1
add rbx, 10h
add r12, rax
mov rax, [rsp+68h+var_50]
cmp [rax], r13d
jg short loc_1425
loc_1482:
mov rax, [rsp+68h+var_40]
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | void * func0(char *src, int a2, int a3, int *a4)
{
int v8; // eax
void *v9; // rax
_DWORD *v10; // rbx
long long v11; // rax
int v12; // r13d
int v13; // r15d
int v14; // esi
void *v15; // rax
long long v19; // [rsp+20h] [rbp-48h]
void *v20; // [rsp+28h] [rbp-40h]
v8 = (a2 + a3 - 1) / a3;
*a4 = v8;
v9 = malloc(16LL * v8);
v20 = v9;
if ( *a4 > 0 )
{
v10 = v9;
v11 = a3;
v12 = 0;
v13 = 0;
v19 = 4 * v11;
while ( 1 )
{
v14 = a2;
if ( a3 + v13 <= a2 )
v14 = a3 + v13;
v15 = malloc(4LL * (v14 - v13));
*(_QWORD *)v10 = v15;
v10[2] = v14 - v13;
if ( v13 < v14 )
{
++v12;
v10 += 4;
memcpy(v15, src, 4LL * (unsigned int)(v14 - v13 - 1) + 4);
src += v19;
if ( v12 >= *a4 )
return v20;
}
else
{
++v12;
v10 += 4;
src += v19;
if ( *a4 <= v12 )
return v20;
}
v13 += a3;
}
}
return v20;
} | func0:
ENDBR64
PUSH R15
LEA EAX,[RSI + RDX*0x1 + -0x1]
MOV R15D,EDX
PUSH R14
MOV R14D,ESI
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,RCX
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RSP + 0x14],EDX
CDQ
IDIV R15D
MOV qword ptr [RSP + 0x18],RCX
MOV dword ptr [RCX],EAX
MOVSXD RDI,EAX
SHL RDI,0x4
CALL 0x001010d0
MOV EDX,dword ptr [RBP]
MOV qword ptr [RSP + 0x28],RAX
TEST EDX,EDX
JLE 0x00101482
MOV RBX,RAX
MOVSXD RAX,R15D
XOR R13D,R13D
XOR R15D,R15D
SHL RAX,0x2
MOV qword ptr [RSP + 0x20],RAX
JMP 0x00101428
LAB_001013f8:
LEA EAX,[RCX + -0x1]
MOV RSI,R12
ADD R13D,0x1
ADD RBX,0x10
LEA RDX,[0x4 + RAX*0x4]
CALL 0x001010c0
MOV RAX,qword ptr [RSP + 0x20]
ADD R12,RAX
MOV RAX,qword ptr [RSP + 0x18]
CMP R13D,dword ptr [RAX]
JGE 0x00101482
LAB_00101425:
MOV R15D,EBP
LAB_00101428:
MOV EAX,dword ptr [RSP + 0x14]
MOV ESI,R14D
LEA EBP,[RAX + R15*0x1]
CMP EBP,R14D
CMOVLE ESI,EBP
MOV ECX,ESI
MOV dword ptr [RSP + 0x10],ESI
SUB ECX,R15D
MOVSXD RDI,ECX
MOV dword ptr [RSP + 0xc],ECX
SHL RDI,0x2
CALL 0x001010d0
MOV ECX,dword ptr [RSP + 0xc]
MOV ESI,dword ptr [RSP + 0x10]
MOV qword ptr [RBX],RAX
MOV RDI,RAX
MOV dword ptr [RBX + 0x8],ECX
CMP R15D,ESI
JL 0x001013f8
MOV RAX,qword ptr [RSP + 0x20]
ADD R13D,0x1
ADD RBX,0x10
ADD R12,RAX
MOV RAX,qword ptr [RSP + 0x18]
CMP dword ptr [RAX],R13D
JG 0x00101425
LAB_00101482:
MOV RAX,qword ptr [RSP + 0x28]
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | int8 * func0(void *param_1,int param_2,int param_3,int *param_4)
{
int iVar1;
int iVar2;
int8 *puVar3;
void *__dest;
int iVar4;
int8 *puVar5;
int iVar6;
int iVar7;
iVar2 = (param_2 + -1 + param_3) / param_3;
*param_4 = iVar2;
puVar3 = (int8 *)malloc((long)iVar2 << 4);
if (*param_4 < 1) {
return puVar3;
}
iVar7 = 0;
puVar5 = puVar3;
iVar2 = 0;
do {
iVar1 = param_3 + iVar2;
iVar6 = param_2;
if (iVar1 <= param_2) {
iVar6 = iVar1;
}
iVar4 = iVar6 - iVar2;
__dest = malloc((long)iVar4 << 2);
*puVar5 = __dest;
*(int *)(puVar5 + 1) = iVar4;
if (iVar2 < iVar6) {
memcpy(__dest,param_1,(ulong)(iVar4 - 1) * 4 + 4);
if (*param_4 <= iVar7 + 1) {
return puVar3;
}
}
else if (*param_4 <= iVar7 + 1) {
return puVar3;
}
iVar7 = iVar7 + 1;
param_1 = (void *)((long)param_1 + (long)param_3 * 4);
puVar5 = puVar5 + 2;
iVar2 = iVar1;
} while( true );
} |
7,580 | func0 | #include <assert.h>
// Function to find max product pairs in an array
| void func0(int arr[], int arr_len, int *x, int *y) {
if (arr_len < 2) {
*x = 0;
*y = 0;
return;
}
*x = arr[0];
*y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > (*x) * (*y)) {
*x = arr[i];
*y = arr[j];
}
}
}
}
| int main() {
int x, y;
// Test Case 1
int arr1[] = {1, 2, 3, 4, 7, 0, 8, 4};
func0(arr1, 8, &x, &y);
assert(x == 7 && y == 8);
// Test Case 2
int arr2[] = {0, -1, -2, -4, 5, 0, -6};
func0(arr2, 7, &x, &y);
assert(x == -4 && y == -6);
// Test Case 3
int arr3[] = {1, 3, 5, 6, 8, 9};
func0(arr3, 6, &x, &y);
assert(x == 8 && y == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
cmpl $0x1,-0x1c(%rbp)
jg 119f <func0+0x36>
mov -0x28(%rbp),%rax
movl $0x0,(%rax)
mov -0x30(%rbp),%rax
movl $0x0,(%rax)
jmpq 1269 <func0+0x100>
mov -0x18(%rbp),%rax
mov (%rax),%edx
mov -0x28(%rbp),%rax
mov %edx,(%rax)
mov -0x18(%rbp),%rax
mov 0x4(%rax),%edx
mov -0x30(%rbp),%rax
mov %edx,(%rax)
movl $0x0,-0x8(%rbp)
jmpq 125d <func0+0xf4>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 124d <func0+0xe4>
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
imul %eax,%edx
mov -0x28(%rbp),%rax
mov (%rax),%ecx
mov -0x30(%rbp),%rax
mov (%rax),%eax
imul %ecx,%eax
cmp %eax,%edx
jle 1249 <func0+0xe0>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x28(%rbp),%rax
mov %edx,(%rax)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x30(%rbp),%rax
mov %edx,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11cf <func0+0x66>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11c4 <func0+0x5b>
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_30], rcx
cmp [rbp+var_1C], 1
jg short loc_119F
mov rax, [rbp+var_28]
mov dword ptr [rax], 0
mov rax, [rbp+var_30]
mov dword ptr [rax], 0
jmp loc_126E
loc_119F:
mov rax, [rbp+var_18]
mov edx, [rax]
mov rax, [rbp+var_28]
mov [rax], edx
mov rax, [rbp+var_18]
mov edx, [rax+4]
mov rax, [rbp+var_30]
mov [rax], edx
mov [rbp+var_8], 0
jmp loc_1262
loc_11C4:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp loc_1252
loc_11D2:
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]
mov ecx, edx
imul ecx, eax
mov rax, [rbp+var_28]
mov edx, [rax]
mov rax, [rbp+var_30]
mov eax, [rax]
imul eax, edx
cmp ecx, eax
jle short loc_124E
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_28]
mov [rax], edx
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov rax, [rbp+var_30]
mov [rax], edx
loc_124E:
add [rbp+var_4], 1
loc_1252:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl loc_11D2
add [rbp+var_8], 1
loc_1262:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl loc_11C4
loc_126E:
pop rbp
retn | unsigned long long func0(_DWORD *a1, int a2, _DWORD *a3, _DWORD *a4)
{
unsigned long long result; // rax
int i; // [rsp+28h] [rbp-8h]
int j; // [rsp+2Ch] [rbp-4h]
if ( a2 > 1 )
{
*a3 = *a1;
*a4 = a1[1];
for ( i = 0; ; ++i )
{
result = (unsigned int)i;
if ( i >= a2 )
break;
for ( j = i + 1; j < a2; ++j )
{
if ( a1[j] * a1[i] > *a3 * *a4 )
{
*a3 = a1[i];
*a4 = a1[j];
}
}
}
}
else
{
*a3 = 0;
result = (unsigned long long)a4;
*a4 = 0;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
CMP dword ptr [RBP + -0x1c],0x1
JG 0x0010119f
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x0
JMP 0x0010126e
LAB_0010119f:
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],EDX
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101262
LAB_001011c4:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101252
LAB_001011d2:
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]
MOV ECX,EDX
IMUL ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
IMUL EAX,EDX
CMP ECX,EAX
JLE 0x0010124e
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 RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],EDX
LAB_0010124e:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101252:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011d2
ADD dword ptr [RBP + -0x8],0x1
LAB_00101262:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011c4
LAB_0010126e:
POP RBP
RET | void func0(int *param_1,int param_2,int *param_3,int *param_4)
{
int local_10;
int local_c;
if (param_2 < 2) {
*param_3 = 0;
*param_4 = 0;
}
else {
*param_3 = *param_1;
*param_4 = param_1[1];
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 (*param_4 * *param_3 < param_1[local_10] * param_1[local_c]) {
*param_3 = param_1[local_10];
*param_4 = param_1[local_c];
}
}
}
}
return;
} |
7,581 | func0 | #include <assert.h>
// Function to find max product pairs in an array
| void func0(int arr[], int arr_len, int *x, int *y) {
if (arr_len < 2) {
*x = 0;
*y = 0;
return;
}
*x = arr[0];
*y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > (*x) * (*y)) {
*x = arr[i];
*y = arr[j];
}
}
}
}
| int main() {
int x, y;
// Test Case 1
int arr1[] = {1, 2, 3, 4, 7, 0, 8, 4};
func0(arr1, 8, &x, &y);
assert(x == 7 && y == 8);
// Test Case 2
int arr2[] = {0, -1, -2, -4, 5, 0, -6};
func0(arr2, 7, &x, &y);
assert(x == -4 && y == -6);
// Test Case 3
int arr3[] = {1, 3, 5, 6, 8, 9};
func0(arr3, 6, &x, &y);
assert(x == 8 && y == 9);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 118e <func0+0x25>
push %rbp
push %rbx
mov (%rdi),%eax
mov %eax,(%rdx)
mov 0x4(%rdi),%eax
mov %eax,(%rcx)
mov $0x0,%ebx
mov $0x1,%ebp
mov $0x1,%eax
jmp 11a2 <func0+0x39>
movl $0x0,(%rdx)
movl $0x0,(%rcx)
retq
add $0x1,%eax
cmp %eax,%esi
jle 11ce <func0+0x65>
movslq %ebx,%r8
mov (%rdi,%r8,4),%r10d
movslq %eax,%r8
lea (%rdi,%r8,4),%r9
mov %r10d,%r11d
imul (%r9),%r11d
mov (%rdx),%r8d
imul (%rcx),%r8d
cmp %r8d,%r11d
jle 119b <func0+0x32>
mov %r10d,(%rdx)
mov (%r9),%r8d
mov %r8d,(%rcx)
jmp 119b <func0+0x32>
lea 0x1(%rbp),%eax
cmp %eax,%esi
jle 11db <func0+0x72>
mov %ebp,%ebx
mov %eax,%ebp
jmp 11a2 <func0+0x39>
pop %rbx
pop %rbp
retq
| func0:
endbr64
mov r10, rdx
mov r9, rcx
cmp esi, 1
jle short loc_1197
push rbp
push rbx
mov r11d, esi
mov eax, [rdi]
mov [rdx], eax
mov eax, [rdi+4]
mov [rcx], eax
mov ebx, 0
mov ebp, 1
mov eax, 1
jmp short loc_11AC
loc_1197:
mov dword ptr [rdx], 0
mov dword ptr [rcx], 0
retn
loc_11A4:
add eax, 1
cmp r11d, eax
jle short loc_11D6
loc_11AC:
movsxd rdx, ebx
mov esi, [rdi+rdx*4]
movsxd rdx, eax
lea rcx, [rdi+rdx*4]
mov r8d, esi
imul r8d, [rcx]
mov edx, [r10]
imul edx, [r9]
cmp r8d, edx
jle short loc_11A4
mov [r10], esi
mov edx, [rcx]
mov [r9], edx
jmp short loc_11A4
loc_11D6:
lea eax, [rbp+1]
cmp r11d, eax
jle short loc_11E4
mov ebx, ebp
mov ebp, eax
jmp short loc_11AC
loc_11E4:
pop rbx
pop rbp
retn | void func0(_DWORD *a1, int a2, _DWORD *a3, _DWORD *a4)
{
int v5; // ebx
int v6; // ebp
int v7; // eax
_DWORD *v8; // rcx
if ( a2 <= 1 )
{
*a3 = 0;
*a4 = 0;
}
else
{
*a3 = *a1;
*a4 = a1[1];
v5 = 0;
v6 = 1;
v7 = 1;
while ( 1 )
{
do
{
v8 = &a1[v7];
if ( *v8 * a1[v5] > *a4 * *a3 )
{
*a3 = a1[v5];
*a4 = *v8;
}
++v7;
}
while ( a2 > v7 );
v7 = v6 + 1;
if ( a2 <= v6 + 1 )
break;
v5 = v6++;
}
}
} | func0:
ENDBR64
MOV R10,RDX
MOV R9,RCX
CMP ESI,0x1
JLE 0x00101197
PUSH RBP
PUSH RBX
MOV R11D,ESI
MOV EAX,dword ptr [RDI]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RDI + 0x4]
MOV dword ptr [RCX],EAX
MOV EBX,0x0
MOV EBP,0x1
MOV EAX,0x1
JMP 0x001011ac
LAB_00101197:
MOV dword ptr [RDX],0x0
MOV dword ptr [RCX],0x0
RET
LAB_001011a4:
ADD EAX,0x1
CMP R11D,EAX
JLE 0x001011d6
LAB_001011ac:
MOVSXD RDX,EBX
MOV ESI,dword ptr [RDI + RDX*0x4]
MOVSXD RDX,EAX
LEA RCX,[RDI + RDX*0x4]
MOV R8D,ESI
IMUL R8D,dword ptr [RCX]
MOV EDX,dword ptr [R10]
IMUL EDX,dword ptr [R9]
CMP R8D,EDX
JLE 0x001011a4
MOV dword ptr [R10],ESI
MOV EDX,dword ptr [RCX]
MOV dword ptr [R9],EDX
JMP 0x001011a4
LAB_001011d6:
LEA EAX,[RBP + 0x1]
CMP R11D,EAX
JLE 0x001011e4
MOV EBX,EBP
MOV EBP,EAX
JMP 0x001011ac
LAB_001011e4:
POP RBX
POP RBP
RET | void func0(int *param_1,int param_2,int *param_3,int *param_4)
{
int iVar1;
int iVar2;
int iVar3;
if (param_2 < 2) {
*param_3 = 0;
*param_4 = 0;
return;
}
*param_3 = *param_1;
*param_4 = param_1[1];
iVar1 = 1;
iVar2 = 0;
iVar3 = 1;
do {
if (*param_3 * *param_4 < param_1[iVar2] * param_1[iVar1]) {
*param_3 = param_1[iVar2];
*param_4 = param_1[iVar1];
}
iVar1 = iVar1 + 1;
} while ((iVar1 < param_2) || (iVar1 = iVar3 + 1, iVar2 = iVar3, iVar3 = iVar1, iVar1 < param_2));
return;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.