index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
6,582 | func0 | #include <assert.h>
| int func0(int num1, int num2, int num3) {
int lnum;
if ((num1 >= num2) && (num1 >= num3)) {
lnum = num1;
} else if ((num2 >= num1) && (num2 >= num3)) {
lnum = num2;
} else {
lnum = num3;
}
return lnum;
}
| int main() {
assert(func0(10, 20, 30) == 30);
assert(func0(55, 47, 39) == 55);
assert(func0(10, 49, 30) == 49);
return 0;
}
| O2 | c | func0:
endbr64
cmp %edx,%esi
mov %edx,%ecx
mov %edi,%eax
cmovge %esi,%ecx
cmp %ecx,%edi
jge 115d <func0+0x1d>
cmp %edx,%edi
cmovl %edx,%eax
cmp %eax,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
xchg %ax,%ax
| func0:
endbr64
cmp esi, edx
mov ecx, edx
mov eax, edi
cmovge ecx, esi
cmp edi, ecx
jge short locret_115D
cmp edi, edx
cmovl eax, edx
cmp esi, eax
mov eax, edx
cmovge eax, esi
locret_115D:
retn | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
bool v5; // cc
v3 = a3;
result = (unsigned int)a1;
if ( a2 >= a3 )
v3 = a2;
if ( a1 < v3 )
{
if ( a1 < a3 )
LODWORD(result) = a3;
v5 = a2 < (int)result;
result = (unsigned int)a3;
if ( !v5 )
return (unsigned int)a2;
}
return result;
} | func0:
ENDBR64
CMP ESI,EDX
MOV ECX,EDX
MOV EAX,EDI
CMOVGE ECX,ESI
CMP EDI,ECX
JGE 0x0010115d
CMP EDI,EDX
CMOVL EAX,EDX
CMP ESI,EAX
MOV EAX,EDX
CMOVGE EAX,ESI
LAB_0010115d:
RET | int func0(int param_1,int param_2,int param_3)
{
int iVar1;
iVar1 = param_3;
if (param_3 <= param_2) {
iVar1 = param_2;
}
if (param_1 < iVar1) {
iVar1 = param_1;
if (param_1 < param_3) {
iVar1 = param_3;
}
param_1 = param_3;
if (iVar1 <= param_2) {
param_1 = param_2;
}
}
return param_1;
} |
6,583 | func0 | #include <assert.h>
| int func0(int num1, int num2, int num3) {
int lnum;
if ((num1 >= num2) && (num1 >= num3)) {
lnum = num1;
} else if ((num2 >= num1) && (num2 >= num3)) {
lnum = num2;
} else {
lnum = num3;
}
return lnum;
}
| int main() {
assert(func0(10, 20, 30) == 30);
assert(func0(55, 47, 39) == 55);
assert(func0(10, 49, 30) == 49);
return 0;
}
| O3 | c | func0:
endbr64
cmp %edx,%esi
mov %edx,%ecx
mov %edi,%eax
cmovge %esi,%ecx
cmp %ecx,%edi
jge 115d <func0+0x1d>
cmp %edx,%edi
cmovl %edx,%eax
cmp %eax,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
xchg %ax,%ax
| func0:
endbr64
cmp esi, edx
mov ecx, edx
mov eax, edi
cmovge ecx, esi
cmp edi, ecx
jge short locret_115D
cmp edi, edx
cmovl eax, edx
cmp esi, eax
mov eax, esi
cmovl eax, edx
locret_115D:
retn | long long func0(int a1, int a2, int a3)
{
int v3; // ecx
long long result; // rax
bool v5; // cc
v3 = a3;
result = (unsigned int)a1;
if ( a2 >= a3 )
v3 = a2;
if ( a1 < v3 )
{
if ( a1 < a3 )
LODWORD(result) = a3;
v5 = a2 < (int)result;
result = (unsigned int)a2;
if ( v5 )
return (unsigned int)a3;
}
return result;
} | func0:
ENDBR64
CMP ESI,EDX
MOV ECX,EDX
MOV EAX,EDI
CMOVGE ECX,ESI
CMP EDI,ECX
JGE 0x0010115d
CMP EDI,EDX
CMOVL EAX,EDX
CMP ESI,EAX
MOV EAX,ESI
CMOVL EAX,EDX
LAB_0010115d:
RET | int func0(int param_1,int param_2,int param_3)
{
int iVar1;
iVar1 = param_3;
if (param_3 <= param_2) {
iVar1 = param_2;
}
if (param_1 < iVar1) {
iVar1 = param_1;
if (param_1 < param_3) {
iVar1 = param_3;
}
param_1 = param_2;
if (param_2 < iVar1) {
param_1 = param_3;
}
}
return param_1;
} |
6,584 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int list[], int size) {
int res = 0;
for (int i = 0; i < size; i++) {
res = res * 10 + list[i];
}
return res;
}
| int main() {
int list1[] = {1, 2, 3};
int size1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, size1) == 123);
int list2[] = {4, 5, 6};
int size2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, size2) == 456);
int list3[] = {7, 8, 9};
int size3 = sizeof(list3) / sizeof(list3[0]);
assert(func0(list3, size3) == 789);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11b5 <func0+0x4c>
mov -0x8(%rbp),%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
mov %eax,%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %ecx,%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], 0
mov [rbp+var_4], 0
jmp short loc_11B5
loc_1188:
mov edx, [rbp+var_8]
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
mov ecx, eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add eax, ecx
mov [rbp+var_8], eax
add [rbp+var_4], 1
loc_11B5:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 = 10 * v3 + *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011b5
LAB_00101188:
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD EAX,ECX
MOV dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011b5:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = *(int *)(param_1 + (long)local_c * 4) + local_10 * 10;
}
return local_10;
} |
6,585 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int list[], int size) {
int res = 0;
for (int i = 0; i < size; i++) {
res = res * 10 + list[i];
}
return res;
}
| int main() {
int list1[] = {1, 2, 3};
int size1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, size1) == 123);
int list2[] = {4, 5, 6};
int size2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, size2) == 456);
int list3[] = {7, 8, 9};
int size3 = sizeof(list3) / sizeof(list3[0]);
assert(func0(list3, size3) == 789);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1195 <func0+0x2c>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rsi
mov $0x0,%edx
lea (%rdx,%rdx,4),%ecx
mov (%rax),%edx
lea (%rdx,%rcx,2),%edx
add $0x4,%rax
cmp %rsi,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1192 <func0+0x29>
| func0:
endbr64
test esi, esi
jle short loc_1195
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
lea ecx, [rdx+rdx*4]
mov edx, [rax]
lea edx, [rdx+rcx*2]
add rax, 4
cmp rax, rsi
jnz short loc_1181
loc_1192:
mov eax, edx
retn
loc_1195:
mov edx, 0
jmp short loc_1192 | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
long long v3; // rsi
unsigned int v4; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
v4 = *v2++ + 10 * v4;
while ( v2 != (_DWORD *)v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101195
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
LEA ECX,[RDX + RDX*0x4]
MOV EDX,dword ptr [RAX]
LEA EDX,[RDX + RCX*0x2]
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101181
LAB_00101192:
MOV EAX,EDX
RET
LAB_00101195:
MOV EDX,0x0
JMP 0x00101192 | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = *param_1 + iVar2 * 10;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
6,586 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int list[], int size) {
int res = 0;
for (int i = 0; i < size; i++) {
res = res * 10 + list[i];
}
return res;
}
| int main() {
int list1[] = {1, 2, 3};
int size1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, size1) == 123);
int list2[] = {4, 5, 6};
int size2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, size2) == 456);
int list3[] = {7, 8, 9};
int size3 = sizeof(list3) / sizeof(list3[0]);
assert(func0(list3, size3) == 789);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea (%rax,%rax,4),%edx
mov (%rdi),%eax
add $0x4,%rdi
lea (%rax,%rdx,2),%eax
cmp %rcx,%rdi
jne 1158 <func0+0x18>
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1170
lea eax, [rsi-1]
lea rcx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1158:
lea edx, [rax+rax*4]
mov eax, [rdi]
add rdi, 4
lea eax, [rax+rdx*2]
cmp rdi, rcx
jnz short loc_1158
retn
loc_1170:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
long long v2; // rcx
long long result; // rax
int v4; // edx
int v5; // eax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
{
v4 = 5 * result;
v5 = *a1++;
result = (unsigned int)(v5 + 2 * v4);
}
while ( a1 != (int *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
LEA EAX,[RSI + -0x1]
LEA RCX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
LEA EDX,[RAX + RAX*0x4]
MOV EAX,dword ptr [RDI]
ADD RDI,0x4
LEA EAX,[RAX + RDX*0x2]
CMP RDI,RCX
JNZ 0x00101158
RET
LAB_00101170:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar2 + iVar3 * 10;
} while (param_1 != piVar1);
return iVar3;
}
return 0;
} |
6,587 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int list[], int size) {
int res = 0;
for (int i = 0; i < size; i++) {
res = res * 10 + list[i];
}
return res;
}
| int main() {
int list1[] = {1, 2, 3};
int size1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, size1) == 123);
int list2[] = {4, 5, 6};
int size2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, size2) == 456);
int list3[] = {7, 8, 9};
int size3 = sizeof(list3) / sizeof(list3[0]);
assert(func0(list3, size3) == 789);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea (%rax,%rax,4),%edx
mov (%rdi),%eax
add $0x4,%rdi
lea (%rax,%rdx,2),%eax
cmp %rdi,%rcx
jne 1158 <func0+0x18>
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
xor eax, eax
lea rcx, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_1158:
lea edx, [rax+rax*4]
mov eax, [rdi]
add rdi, 4
lea eax, [rax+rdx*2]
cmp rcx, rdi
jnz short loc_1158
retn
loc_1170:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
long long result; // rax
int *v3; // rcx
int v4; // edx
int v5; // eax
if ( a2 <= 0 )
return 0LL;
LODWORD(result) = 0;
v3 = &a1[a2];
do
{
v4 = 5 * result;
v5 = *a1++;
result = (unsigned int)(v5 + 2 * v4);
}
while ( v3 != a1 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
XOR EAX,EAX
LEA RCX,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101158:
LEA EDX,[RAX + RAX*0x4]
MOV EAX,dword ptr [RDI]
ADD RDI,0x4
LEA EAX,[RAX + RDX*0x2]
CMP RCX,RDI
JNZ 0x00101158
RET
LAB_00101170:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
iVar3 = 0;
piVar1 = param_1 + param_2;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar2 + iVar3 * 10;
} while (piVar1 != param_1);
return iVar3;
}
return 0;
} |
6,588 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* string) {
// Duplicate the string to modify it
char* str = strdup(string);
if (!str) return NULL;
// Array to hold unique words
char* unique[100];
int unique_count = 0;
// Split the string into words
char* token = strtok(str, " ");
while(token != NULL){
int found = 0;
for(int i=0;i<unique_count;i++){
if(strcmp(token, unique[i]) == 0){
found = 1;
break;
}
}
if(!found){
unique[unique_count++] = token;
}
token = strtok(NULL, " ");
}
// Calculate the total length needed
int total_length = 0;
for(int i=0;i<unique_count;i++){
total_length += strlen(unique[i]) + 1; // +1 for space or null
}
// Allocate result string
char* result = malloc(total_length);
if(!result){
free(str);
return NULL;
}
result[0] = '\0';
for(int i=0;i<unique_count;i++){
strcat(result, unique[i]);
if(i < unique_count -1){
strcat(result, " ");
}
}
free(str);
return result;
}
| int main(){
assert(strcmp(func0("Python Exercises Practice Solution Exercises"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Python"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Practice"), "Python Exercises Practice Solution") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x370,%rsp
mov %rdi,-0x368(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x368(%rbp),%rax
mov %rax,%rdi
callq 1150 <strdup@plt>
mov %rax,-0x340(%rbp)
cmpq $0x0,-0x340(%rbp)
jne 1298 <func0+0x4f>
mov $0x0,%eax
jmpq 14a8 <func0+0x25f>
movl $0x0,-0x360(%rbp)
mov -0x340(%rbp),%rax
lea 0xd58(%rip),%rsi
mov %rax,%rdi
callq 1130 <strtok@plt>
mov %rax,-0x348(%rbp)
jmpq 1362 <func0+0x119>
movl $0x0,-0x35c(%rbp)
movl $0x0,-0x358(%rbp)
jmp 1313 <func0+0xca>
mov -0x358(%rbp),%eax
cltq
mov -0x330(%rbp,%rax,8),%rdx
mov -0x348(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1110 <strcmp@plt>
test %eax,%eax
jne 130c <func0+0xc3>
movl $0x1,-0x35c(%rbp)
jmp 1321 <func0+0xd8>
addl $0x1,-0x358(%rbp)
mov -0x358(%rbp),%eax
cmp -0x360(%rbp),%eax
jl 12da <func0+0x91>
cmpl $0x0,-0x35c(%rbp)
jne 134a <func0+0x101>
mov -0x360(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x360(%rbp)
cltq
mov -0x348(%rbp),%rdx
mov %rdx,-0x330(%rbp,%rax,8)
lea 0xcb7(%rip),%rsi
mov $0x0,%edi
callq 1130 <strtok@plt>
mov %rax,-0x348(%rbp)
cmpq $0x0,-0x348(%rbp)
jne 12c4 <func0+0x7b>
movl $0x0,-0x354(%rbp)
movl $0x0,-0x350(%rbp)
jmp 13b8 <func0+0x16f>
mov -0x350(%rbp),%eax
cltq
mov -0x330(%rbp,%rax,8),%rax
mov %rax,%rdi
callq 10e0 <strlen@plt>
mov %eax,%edx
mov -0x354(%rbp),%eax
add %edx,%eax
add $0x1,%eax
mov %eax,-0x354(%rbp)
addl $0x1,-0x350(%rbp)
mov -0x350(%rbp),%eax
cmp -0x360(%rbp),%eax
jl 1386 <func0+0x13d>
mov -0x354(%rbp),%eax
cltq
mov %rax,%rdi
callq 1120 <malloc@plt>
mov %rax,-0x338(%rbp)
cmpq $0x0,-0x338(%rbp)
jne 1400 <func0+0x1b7>
mov -0x340(%rbp),%rax
mov %rax,%rdi
callq 10d0 <free@plt>
mov $0x0,%eax
jmpq 14a8 <func0+0x25f>
mov -0x338(%rbp),%rax
movb $0x0,(%rax)
movl $0x0,-0x34c(%rbp)
jmp 1484 <func0+0x23b>
mov -0x34c(%rbp),%eax
cltq
mov -0x330(%rbp,%rax,8),%rdx
mov -0x338(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1140 <strcat@plt>
mov -0x360(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x34c(%rbp)
jge 147d <func0+0x234>
mov -0x338(%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 -0x338(%rbp),%rax
add %rdx,%rax
movw $0x20,(%rax)
addl $0x1,-0x34c(%rbp)
mov -0x34c(%rbp),%eax
cmp -0x360(%rbp),%eax
jl 1416 <func0+0x1cd>
mov -0x340(%rbp),%rax
mov %rax,%rdi
callq 10d0 <free@plt>
mov -0x338(%rbp),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 14bc <func0+0x273>
callq 10f0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 370h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strdup
mov [rbp+var_340], rax
cmp [rbp+var_340], 0
jnz short loc_1298
mov eax, 0
jmp loc_149B
loc_1298:
mov [rbp+var_360], 0
mov rax, [rbp+var_340]
lea rdx, delim; " "
mov rsi, rdx; delim
mov rdi, rax; s
call _strtok
mov [rbp+s1], rax
jmp loc_1368
loc_12C7:
mov [rbp+var_35C], 0
mov [rbp+var_358], 0
jmp short loc_1316
loc_12DD:
mov eax, [rbp+var_358]
cdqe
mov rdx, [rbp+rax*8+s2]
mov rax, [rbp+s1]
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jnz short loc_130F
mov [rbp+var_35C], 1
jmp short loc_1324
loc_130F:
add [rbp+var_358], 1
loc_1316:
mov eax, [rbp+var_358]
cmp eax, [rbp+var_360]
jl short loc_12DD
loc_1324:
cmp [rbp+var_35C], 0
jnz short loc_134D
mov eax, [rbp+var_360]
lea edx, [rax+1]
mov [rbp+var_360], edx
cdqe
mov rdx, [rbp+s1]
mov [rbp+rax*8+s2], rdx
loc_134D:
lea rax, delim; " "
mov rsi, rax; delim
mov edi, 0; s
call _strtok
mov [rbp+s1], rax
loc_1368:
cmp [rbp+s1], 0
jnz loc_12C7
mov [rbp+var_354], 0
mov [rbp+var_350], 0
jmp short loc_13BE
loc_138C:
mov eax, [rbp+var_350]
cdqe
mov rax, [rbp+rax*8+s2]
mov rdi, rax; s
call _strlen
mov edx, eax
mov eax, [rbp+var_354]
add eax, edx
add eax, 1
mov [rbp+var_354], eax
add [rbp+var_350], 1
loc_13BE:
mov eax, [rbp+var_350]
cmp eax, [rbp+var_360]
jl short loc_138C
mov eax, [rbp+var_354]
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
cmp [rbp+dest], 0
jnz short loc_1406
mov rax, [rbp+var_340]
mov rdi, rax; ptr
call _free
mov eax, 0
jmp loc_149B
loc_1406:
mov rax, [rbp+dest]
mov byte ptr [rax], 0
mov [rbp+var_34C], 0
jmp short loc_1477
loc_141C:
mov eax, [rbp+var_34C]
cdqe
mov rdx, [rbp+rax*8+s2]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcat
mov eax, [rbp+var_360]
sub eax, 1
cmp [rbp+var_34C], eax
jge short loc_1470
mov rax, [rbp+dest]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+dest]
add rax, rdx
mov word ptr [rax], 20h ; ' '
loc_1470:
add [rbp+var_34C], 1
loc_1477:
mov eax, [rbp+var_34C]
cmp eax, [rbp+var_360]
jl short loc_141C
mov rax, [rbp+var_340]
mov rdi, rax; ptr
call _free
mov rax, [rbp+dest]
loc_149B:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_14AF
call ___stack_chk_fail
locret_14AF:
leave
retn | char * func0(const char *a1)
{
int v2; // eax
int v3; // [rsp+10h] [rbp-360h]
int v4; // [rsp+14h] [rbp-35Ch]
int i; // [rsp+18h] [rbp-358h]
int v6; // [rsp+1Ch] [rbp-354h]
int j; // [rsp+20h] [rbp-350h]
int k; // [rsp+24h] [rbp-34Ch]
const char *s1; // [rsp+28h] [rbp-348h]
char *v10; // [rsp+30h] [rbp-340h]
char *dest; // [rsp+38h] [rbp-338h]
char *s2[102]; // [rsp+40h] [rbp-330h]
s2[101] = (char *)__readfsqword(0x28u);
v10 = strdup(a1);
if ( !v10 )
return 0LL;
v3 = 0;
for ( s1 = strtok(v10, " "); s1; s1 = strtok(0LL, " ") )
{
v4 = 0;
for ( i = 0; i < v3; ++i )
{
if ( !strcmp(s1, s2[i]) )
{
v4 = 1;
break;
}
}
if ( !v4 )
{
v2 = v3++;
s2[v2] = (char *)s1;
}
}
v6 = 0;
for ( j = 0; j < v3; ++j )
v6 += strlen(s2[j]) + 1;
dest = (char *)malloc(v6);
if ( dest )
{
*dest = 0;
for ( k = 0; k < v3; ++k )
{
strcat(dest, s2[k]);
if ( k < v3 - 1 )
*(_WORD *)&dest[strlen(dest)] = 32;
}
free(v10);
return dest;
}
else
{
free(v10);
return 0LL;
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x370
MOV qword ptr [RBP + -0x368],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x368]
MOV RDI,RAX
CALL 0x00101150
MOV qword ptr [RBP + -0x340],RAX
CMP qword ptr [RBP + -0x340],0x0
JNZ 0x00101298
MOV EAX,0x0
JMP 0x0010149b
LAB_00101298:
MOV dword ptr [RBP + -0x360],0x0
MOV RAX,qword ptr [RBP + -0x340]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBP + -0x348],RAX
JMP 0x00101368
LAB_001012c7:
MOV dword ptr [RBP + -0x35c],0x0
MOV dword ptr [RBP + -0x358],0x0
JMP 0x00101316
LAB_001012dd:
MOV EAX,dword ptr [RBP + -0x358]
CDQE
MOV RDX,qword ptr [RBP + RAX*0x8 + -0x330]
MOV RAX,qword ptr [RBP + -0x348]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101110
TEST EAX,EAX
JNZ 0x0010130f
MOV dword ptr [RBP + -0x35c],0x1
JMP 0x00101324
LAB_0010130f:
ADD dword ptr [RBP + -0x358],0x1
LAB_00101316:
MOV EAX,dword ptr [RBP + -0x358]
CMP EAX,dword ptr [RBP + -0x360]
JL 0x001012dd
LAB_00101324:
CMP dword ptr [RBP + -0x35c],0x0
JNZ 0x0010134d
MOV EAX,dword ptr [RBP + -0x360]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x360],EDX
CDQE
MOV RDX,qword ptr [RBP + -0x348]
MOV qword ptr [RBP + RAX*0x8 + -0x330],RDX
LAB_0010134d:
LEA RAX,[0x102008]
MOV RSI,RAX
MOV EDI,0x0
CALL 0x00101130
MOV qword ptr [RBP + -0x348],RAX
LAB_00101368:
CMP qword ptr [RBP + -0x348],0x0
JNZ 0x001012c7
MOV dword ptr [RBP + -0x354],0x0
MOV dword ptr [RBP + -0x350],0x0
JMP 0x001013be
LAB_0010138c:
MOV EAX,dword ptr [RBP + -0x350]
CDQE
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x330]
MOV RDI,RAX
CALL 0x001010e0
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x354]
ADD EAX,EDX
ADD EAX,0x1
MOV dword ptr [RBP + -0x354],EAX
ADD dword ptr [RBP + -0x350],0x1
LAB_001013be:
MOV EAX,dword ptr [RBP + -0x350]
CMP EAX,dword ptr [RBP + -0x360]
JL 0x0010138c
MOV EAX,dword ptr [RBP + -0x354]
CDQE
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBP + -0x338],RAX
CMP qword ptr [RBP + -0x338],0x0
JNZ 0x00101406
MOV RAX,qword ptr [RBP + -0x340]
MOV RDI,RAX
CALL 0x001010d0
MOV EAX,0x0
JMP 0x0010149b
LAB_00101406:
MOV RAX,qword ptr [RBP + -0x338]
MOV byte ptr [RAX],0x0
MOV dword ptr [RBP + -0x34c],0x0
JMP 0x00101477
LAB_0010141c:
MOV EAX,dword ptr [RBP + -0x34c]
CDQE
MOV RDX,qword ptr [RBP + RAX*0x8 + -0x330]
MOV RAX,qword ptr [RBP + -0x338]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101140
MOV EAX,dword ptr [RBP + -0x360]
SUB EAX,0x1
CMP dword ptr [RBP + -0x34c],EAX
JGE 0x00101470
MOV RAX,qword ptr [RBP + -0x338]
MOV RDI,RAX
CALL 0x001010e0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x338]
ADD RAX,RDX
MOV word ptr [RAX],0x20
LAB_00101470:
ADD dword ptr [RBP + -0x34c],0x1
LAB_00101477:
MOV EAX,dword ptr [RBP + -0x34c]
CMP EAX,dword ptr [RBP + -0x360]
JL 0x0010141c
MOV RAX,qword ptr [RBP + -0x340]
MOV RDI,RAX
CALL 0x001010d0
MOV RAX,qword ptr [RBP + -0x338]
LAB_0010149b:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001014af
CALL 0x001010f0
LAB_001014af:
LEAVE
RET | char * func0(char *param_1)
{
bool bVar1;
int iVar2;
char *__s;
char *__dest;
size_t sVar3;
long in_FS_OFFSET;
int local_368;
int local_360;
int local_35c;
int local_358;
int local_354;
char *local_350;
int8 auStack_338 [101];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__s = strdup(param_1);
if (__s == (char *)0x0) {
__dest = (char *)0x0;
}
else {
local_368 = 0;
local_350 = strtok(__s," ");
while (local_350 != (char *)0x0) {
bVar1 = false;
for (local_360 = 0; local_360 < local_368; local_360 = local_360 + 1) {
iVar2 = strcmp(local_350,(char *)auStack_338[local_360]);
if (iVar2 == 0) {
bVar1 = true;
break;
}
}
if (!bVar1) {
auStack_338[local_368] = local_350;
local_368 = local_368 + 1;
}
local_350 = strtok((char *)0x0," ");
}
local_35c = 0;
for (local_358 = 0; local_358 < local_368; local_358 = local_358 + 1) {
sVar3 = strlen((char *)auStack_338[local_358]);
local_35c = local_35c + (int)sVar3 + 1;
}
__dest = (char *)malloc((long)local_35c);
if (__dest == (char *)0x0) {
free(__s);
__dest = (char *)0x0;
}
else {
*__dest = '\0';
for (local_354 = 0; local_354 < local_368; local_354 = local_354 + 1) {
strcat(__dest,(char *)auStack_338[local_354]);
if (local_354 < local_368 + -1) {
sVar3 = strlen(__dest);
(__dest + sVar3)[0] = ' ';
(__dest + sVar3)[1] = '\0';
}
}
free(__s);
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __dest;
} |
6,589 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* string) {
// Duplicate the string to modify it
char* str = strdup(string);
if (!str) return NULL;
// Array to hold unique words
char* unique[100];
int unique_count = 0;
// Split the string into words
char* token = strtok(str, " ");
while(token != NULL){
int found = 0;
for(int i=0;i<unique_count;i++){
if(strcmp(token, unique[i]) == 0){
found = 1;
break;
}
}
if(!found){
unique[unique_count++] = token;
}
token = strtok(NULL, " ");
}
// Calculate the total length needed
int total_length = 0;
for(int i=0;i<unique_count;i++){
total_length += strlen(unique[i]) + 1; // +1 for space or null
}
// Allocate result string
char* result = malloc(total_length);
if(!result){
free(str);
return NULL;
}
result[0] = '\0';
for(int i=0;i<unique_count;i++){
strcat(result, unique[i]);
if(i < unique_count -1){
strcat(result, " ");
}
}
free(str);
return result;
}
| int main(){
assert(strcmp(func0("Python Exercises Practice Solution Exercises"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Python"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Practice"), "Python Exercises Practice Solution") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x338,%rsp
mov %fs:0x28,%rax
mov %rax,0x328(%rsp)
xor %eax,%eax
callq 1130 <strdup@plt>
mov %rax,%r15
test %rax,%rax
je 1382 <func0+0x159>
lea 0xd9b(%rip),%rsi
mov %rax,%rdi
callq 1110 <strtok@plt>
mov %rax,%rbp
mov $0x0,%r13d
lea 0x8(%rsp),%r14
test %rax,%rax
jne 13b2 <func0+0x189>
mov $0x0,%edi
callq 1100 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 1330 <func0+0x107>
movb $0x0,(%r12)
mov %r15,%rdi
callq 10c0 <free@plt>
mov 0x328(%rsp),%rax
xor %fs:0x28,%rax
jne 13dc <func0+0x1b3>
mov %r12,%rax
add $0x338,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
test %r13d,%r13d
jle 1288 <func0+0x5f>
mov %rsp,%rdx
lea -0x1(%r13),%ebp
lea 0x8(%rsp,%rbp,8),%r9
mov $0x0,%esi
mov $0xffffffffffffffff,%r8
mov $0x0,%eax
mov (%rdx),%rdi
mov %r8,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea (%rsi,%rcx,1),%esi
add $0x8,%rdx
cmp %r9,%rdx
jne 12f9 <func0+0xd0>
movslq %esi,%rdi
callq 1100 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 1330 <func0+0x107>
movb $0x0,(%r12)
mov $0x0,%ebx
sub $0x1,%r13d
jmp 1353 <func0+0x12a>
mov %r15,%rdi
callq 10c0 <free@plt>
mov $0x0,%r12d
jmpq 12ab <func0+0x82>
lea 0x1(%rbx),%rax
cmp %rbx,%rbp
je 12a3 <func0+0x7a>
mov %rax,%rbx
mov (%rsp,%rbx,8),%rsi
mov %r12,%rdi
callq 1120 <strcat@plt>
cmp %ebx,%r13d
jle 1343 <func0+0x11a>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %r12,%rdi
repnz scas %es:(%rdi),%al
not %rcx
movw $0x20,-0x1(%r12,%rcx,1)
jmp 1343 <func0+0x11a>
mov %rax,%r12
jmpq 12ab <func0+0x82>
movslq %r13d,%rax
mov %rbp,(%rsp,%rax,8)
lea 0x1(%r13),%r13d
lea 0xc68(%rip),%rsi
mov $0x0,%edi
callq 1110 <strtok@plt>
mov %rax,%rbp
test %rax,%rax
je 12d7 <func0+0xae>
test %r13d,%r13d
jle 138a <func0+0x161>
mov %rsp,%rbx
lea -0x1(%r13),%eax
lea (%r14,%rax,8),%r12
mov (%rbx),%rsi
mov %rbp,%rdi
callq 10f0 <strcmp@plt>
test %eax,%eax
je 1395 <func0+0x16c>
add $0x8,%rbx
cmp %r12,%rbx
jne 13c2 <func0+0x199>
jmp 138a <func0+0x161>
callq 10d0 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 338h
mov rax, fs:28h
mov [rsp+368h+var_40], rax
xor eax, eax
call _strdup
mov r15, rax
test rax, rax
jz loc_1389
lea rsi, unk_2004
mov rdi, rax
call _strtok
mov rbp, rax
mov r13d, 0
lea r14, unk_2004
test rax, rax
jnz loc_13B5
loc_12AA:
mov edi, 0
call _malloc
mov rbp, rax
test rax, rax
jz loc_1348
mov byte ptr [rbp+0], 0
loc_12C4:
mov rdi, r15
call _free
loc_12CC:
mov rax, [rsp+368h+var_40]
sub rax, fs:28h
jnz loc_13E0
mov rax, rbp
add rsp, 338h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_12F8:
test r13d, r13d
jle short loc_12AA
mov rbx, rsp
mov r12d, r13d
lea eax, [r13-1]
lea r14, [rsp+rax*8+368h+var_360]
mov ebp, 0
loc_1311:
mov rdi, [rbx]
call _strlen
lea ebp, [rbp+rax+1]
add rbx, 8
cmp rbx, r14
jnz short loc_1311
movsxd rdi, ebp
call _malloc
mov rbp, rax
test rax, rax
jz short loc_1348
mov byte ptr [rbp+0], 0
mov r12d, r12d
mov ebx, 0
sub r13d, 1
jmp short loc_1367
loc_1348:
mov rdi, r15
call _free
mov ebp, 0
jmp loc_12CC
loc_135A:
add rbx, 1
cmp rbx, r12
jz loc_12C4
loc_1367:
mov rsi, [rsp+rbx*8+368h+var_368]
mov rdi, rbp
call _strcat
cmp r13d, ebx
jle short loc_135A
mov rdi, rbp
call _strlen
mov word ptr [rbp+rax+0], 20h ; ' '
jmp short loc_135A
loc_1389:
mov rbp, rax
jmp loc_12CC
loc_1391:
movsxd rax, r13d
mov [rsp+rax*8+368h+var_368], rbp
lea r13d, [r13+1]
loc_139C:
mov rsi, r14
mov edi, 0
call _strtok
mov rbp, rax
test rax, rax
jz loc_12F8
loc_13B5:
test r13d, r13d
jle short loc_1391
mov rbx, rsp
lea eax, [r13-1]
lea r12, [rsp+rax*8+368h+var_360]
loc_13C6:
mov rsi, [rbx]
mov rdi, rbp
call _strcmp
test eax, eax
jz short loc_139C
add rbx, 8
cmp rbx, r12
jnz short loc_13C6
jmp short loc_1391
loc_13E0:
call ___stack_chk_fail | _BYTE *func0()
{
long long v0; // rax
long long v1; // r15
long long v2; // rbp
int v3; // r13d
_BYTE *v4; // rax
_BYTE *v5; // rbp
_QWORD *v7; // rbx
int v8; // r12d
int v9; // ebp
_BYTE *v10; // rax
long long v11; // rbx
int v12; // r13d
_QWORD *v13; // rbx
_QWORD v14[109]; // [rsp+0h] [rbp-368h] BYREF
v14[101] = __readfsqword(0x28u);
v0 = strdup();
v1 = v0;
if ( !v0 )
return 0LL;
v2 = strtok(v0, &unk_2004);
v3 = 0;
if ( v2 )
{
do
{
if ( v3 <= 0 )
{
LABEL_17:
v14[v3++] = v2;
}
else
{
v13 = v14;
while ( (unsigned int)strcmp(v2, *v13) )
{
if ( ++v13 == &v14[(unsigned int)(v3 - 1) + 1] )
goto LABEL_17;
}
}
v2 = strtok(0LL, &unk_2004);
}
while ( v2 );
if ( v3 > 0 )
{
v7 = v14;
v8 = v3;
v9 = 0;
do
v9 += strlen(*v7++) + 1;
while ( v7 != &v14[(unsigned int)(v3 - 1) + 1] );
v10 = (_BYTE *)malloc(v9);
v5 = v10;
if ( v10 )
{
*v10 = 0;
v11 = 0LL;
v12 = v3 - 1;
do
{
strcat(v5, v14[v11]);
if ( v12 > (int)v11 )
*(_WORD *)&v5[strlen(v5)] = 32;
++v11;
}
while ( v11 != v8 );
goto LABEL_5;
}
LABEL_12:
free(v1);
return 0LL;
}
}
v4 = (_BYTE *)malloc(0LL);
v5 = v4;
if ( !v4 )
goto LABEL_12;
*v4 = 0;
LABEL_5:
free(v1);
return v5;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x338
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x328],RAX
XOR EAX,EAX
CALL 0x00101150
MOV R15,RAX
TEST RAX,RAX
JZ 0x00101389
LEA RSI,[0x102004]
MOV RDI,RAX
CALL 0x00101130
MOV RBP,RAX
MOV R13D,0x0
LEA R14,[0x102004]
TEST RAX,RAX
JNZ 0x001013b5
LAB_001012aa:
MOV EDI,0x0
CALL 0x00101120
MOV RBP,RAX
TEST RAX,RAX
JZ 0x00101348
MOV byte ptr [RBP],0x0
LAB_001012c4:
MOV RDI,R15
CALL 0x001010d0
LAB_001012cc:
MOV RAX,qword ptr [RSP + 0x328]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013e0
MOV RAX,RBP
ADD RSP,0x338
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001012f8:
TEST R13D,R13D
JLE 0x001012aa
MOV RBX,RSP
MOV R12D,R13D
LEA EAX,[R13 + -0x1]
LEA R14,[RSP + RAX*0x8 + 0x8]
MOV EBP,0x0
LAB_00101311:
MOV RDI,qword ptr [RBX]
CALL 0x001010e0
LEA EBP,[RBP + RAX*0x1 + 0x1]
ADD RBX,0x8
CMP RBX,R14
JNZ 0x00101311
MOVSXD RDI,EBP
CALL 0x00101120
MOV RBP,RAX
TEST RAX,RAX
JZ 0x00101348
MOV byte ptr [RBP],0x0
MOV R12D,R12D
MOV EBX,0x0
SUB R13D,0x1
JMP 0x00101367
LAB_00101348:
MOV RDI,R15
CALL 0x001010d0
MOV EBP,0x0
JMP 0x001012cc
LAB_0010135a:
ADD RBX,0x1
CMP RBX,R12
JZ 0x001012c4
LAB_00101367:
MOV RSI,qword ptr [RSP + RBX*0x8]
MOV RDI,RBP
CALL 0x00101140
CMP R13D,EBX
JLE 0x0010135a
MOV RDI,RBP
CALL 0x001010e0
MOV word ptr [RBP + RAX*0x1],0x20
JMP 0x0010135a
LAB_00101389:
MOV RBP,RAX
JMP 0x001012cc
LAB_00101391:
MOVSXD RAX,R13D
MOV qword ptr [RSP + RAX*0x8],RBP
LEA R13D,[R13 + 0x1]
LAB_0010139c:
MOV RSI,R14
MOV EDI,0x0
CALL 0x00101130
MOV RBP,RAX
TEST RAX,RAX
JZ 0x001012f8
LAB_001013b5:
TEST R13D,R13D
JLE 0x00101391
MOV RBX,RSP
LEA EAX,[R13 + -0x1]
LEA R12,[RSP + RAX*0x8 + 0x8]
LAB_001013c6:
MOV RSI,qword ptr [RBX]
MOV RDI,RBP
CALL 0x00101110
TEST EAX,EAX
JZ 0x0010139c
ADD RBX,0x8
CMP RBX,R12
JNZ 0x001013c6
JMP 0x00101391
LAB_001013e0:
CALL 0x001010f0 | char * func0(char *param_1)
{
int iVar1;
char *__s;
char *pcVar2;
size_t sVar3;
int8 *puVar4;
ulong uVar5;
int8 *puVar6;
uint uVar7;
long in_FS_OFFSET;
int8 local_368 [101];
long local_40;
puVar4 = local_368;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__s = strdup(param_1);
if (__s == (char *)0x0) {
pcVar2 = (char *)0x0;
goto LAB_001012cc;
}
pcVar2 = strtok(__s," ");
uVar7 = 0;
if (pcVar2 == (char *)0x0) {
LAB_001012aa:
pcVar2 = (char *)malloc(0);
if (pcVar2 == (char *)0x0) {
LAB_00101348:
free(__s);
pcVar2 = (char *)0x0;
goto LAB_001012cc;
}
*pcVar2 = '\0';
}
else {
do {
if (0 < (int)uVar7) {
puVar6 = local_368;
do {
iVar1 = strcmp(pcVar2,(char *)*puVar6);
if (iVar1 == 0) goto LAB_0010139c;
puVar6 = puVar6 + 1;
} while (puVar6 != local_368 + (ulong)(uVar7 - 1) + 1);
}
local_368[(int)uVar7] = pcVar2;
uVar7 = uVar7 + 1;
LAB_0010139c:
pcVar2 = strtok((char *)0x0," ");
} while (pcVar2 != (char *)0x0);
if ((int)uVar7 < 1) goto LAB_001012aa;
iVar1 = 0;
do {
sVar3 = strlen((char *)*puVar4);
iVar1 = iVar1 + 1 + (int)sVar3;
puVar4 = puVar4 + 1;
} while (puVar4 != local_368 + (ulong)(uVar7 - 1) + 1);
pcVar2 = (char *)malloc((long)iVar1);
if (pcVar2 == (char *)0x0) goto LAB_00101348;
*pcVar2 = '\0';
uVar5 = 0;
do {
strcat(pcVar2,(char *)local_368[uVar5]);
if ((int)uVar5 < (int)(uVar7 - 1)) {
sVar3 = strlen(pcVar2);
(pcVar2 + sVar3)[0] = ' ';
(pcVar2 + sVar3)[1] = '\0';
}
uVar5 = uVar5 + 1;
} while (uVar5 != uVar7);
}
free(__s);
LAB_001012cc:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
6,590 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* string) {
// Duplicate the string to modify it
char* str = strdup(string);
if (!str) return NULL;
// Array to hold unique words
char* unique[100];
int unique_count = 0;
// Split the string into words
char* token = strtok(str, " ");
while(token != NULL){
int found = 0;
for(int i=0;i<unique_count;i++){
if(strcmp(token, unique[i]) == 0){
found = 1;
break;
}
}
if(!found){
unique[unique_count++] = token;
}
token = strtok(NULL, " ");
}
// Calculate the total length needed
int total_length = 0;
for(int i=0;i<unique_count;i++){
total_length += strlen(unique[i]) + 1; // +1 for space or null
}
// Allocate result string
char* result = malloc(total_length);
if(!result){
free(str);
return NULL;
}
result[0] = '\0';
for(int i=0;i<unique_count;i++){
strcat(result, unique[i]);
if(i < unique_count -1){
strcat(result, " ");
}
}
free(str);
return result;
}
| int main(){
assert(strcmp(func0("Python Exercises Practice Solution Exercises"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Python"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Practice"), "Python Exercises Practice Solution") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x348,%rsp
mov %fs:0x28,%rax
mov %rax,0x338(%rsp)
xor %eax,%eax
callq 1150 <strdup@plt>
mov %rax,0x8(%rsp)
test %rax,%rax
je 1505 <func0+0x1d5>
lea 0xc92(%rip),%rsi
mov %rax,%rdi
lea 0x10(%rsp),%r13
xor %r12d,%r12d
callq 1140 <strtok@plt>
lea 0xc7b(%rip),%r15
mov %rax,%rbx
lea 0x18(%rsp),%rax
mov %rax,(%rsp)
test %rbx,%rbx
je 14e1 <func0+0x1b1>
xchg %ax,%ax
test %r12d,%r12d
je 14d0 <func0+0x1a0>
mov (%rsp),%rcx
lea -0x1(%r12),%eax
mov %r13,%r14
lea (%rcx,%rax,8),%rbp
jmp 13cd <func0+0x9d>
nopl 0x0(%rax,%rax,1)
add $0x8,%r14
cmp %rbp,%r14
je 14d0 <func0+0x1a0>
mov (%r14),%rsi
mov %rbx,%rdi
callq 1120 <strcmp@plt>
test %eax,%eax
jne 13c0 <func0+0x90>
mov %r15,%rsi
xor %edi,%edi
callq 1140 <strtok@plt>
mov %rax,%rbx
test %rax,%rax
jne 13a0 <func0+0x70>
mov (%rsp),%rax
lea -0x1(%r12),%ebx
mov %r13,%rbp
xor %r15d,%r15d
mov %rbx,%r12
lea (%rax,%rbx,8),%r14
nopl 0x0(%rax)
mov 0x0(%rbp),%rdi
add $0x8,%rbp
callq 10f0 <strlen@plt>
lea 0x1(%r15,%rax,1),%r15d
cmp %rbp,%r14
jne 1408 <func0+0xd8>
movslq %r15d,%rdi
callq 1130 <malloc@plt>
mov %rax,%r14
test %rax,%rax
je 14f6 <func0+0x1c6>
movb $0x0,(%r14)
xor %ebp,%ebp
jmp 1443 <func0+0x113>
nopl 0x0(%rax,%rax,1)
mov %rax,%rbp
mov %r14,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 1446 <func0+0x116>
mov %eax,%edx
mov 0x0(%r13,%rbp,8),%rsi
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov %eax,%ecx
add %al,%cl
sbb $0x3,%rdi
callq 10e0 <stpcpy@plt>
cmp %ebp,%r12d
jle 1491 <func0+0x161>
mov $0x20,%edx
mov %dx,(%rax)
lea 0x1(%rbp),%rax
cmp %rbp,%rbx
jne 1440 <func0+0x110>
mov 0x8(%rsp),%rdi
callq 10d0 <free@plt>
mov 0x338(%rsp),%rax
xor %fs:0x28,%rax
jne 150a <func0+0x1da>
add $0x348,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
movslq %r12d,%rax
add $0x1,%r12d
mov %rbx,0x10(%rsp,%rax,8)
jmpq 13dc <func0+0xac>
xor %edi,%edi
callq 1130 <malloc@plt>
mov %rax,%r14
test %rax,%rax
je 14f6 <func0+0x1c6>
movb $0x0,(%r14)
jmp 149a <func0+0x16a>
mov 0x8(%rsp),%rdi
xor %r14d,%r14d
callq 10d0 <free@plt>
jmp 14a4 <func0+0x174>
xor %r14d,%r14d
jmp 14a4 <func0+0x174>
callq 1100 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 348h
mov rax, fs:28h
mov [rsp+378h+var_40], rax
xor eax, eax
call _strdup
mov [rsp+378h+var_370], rax
test rax, rax
jz loc_14B5
lea r14, unk_2004
mov rdi, rax
lea r13, [rsp+378h+var_368]
xor r12d, r12d
mov rsi, r14
call _strtok
mov rbx, rax
lea rax, [rsp+378h+var_360]
mov [rsp+378h+var_378], rax
test rbx, rbx
jz loc_1491
nop word ptr [rax+rax+00h]
loc_1380:
test r12d, r12d
jz loc_1480
mov rdx, [rsp+378h+var_378]
lea eax, [r12-1]
mov r15, r13
lea rbp, [rdx+rax*8]
jmp short loc_13AD
loc_13A0:
add r15, 8
cmp r15, rbp
jz loc_1480
loc_13AD:
mov rsi, [r15]
mov rdi, rbx
call _strcmp
test eax, eax
jnz short loc_13A0
loc_13BC:
mov rsi, r14
xor edi, edi
call _strtok
mov rbx, rax
test rax, rax
jnz short loc_1380
mov rcx, [rsp+378h+var_378]
lea eax, [r12-1]
mov rbx, r13
xor r15d, r15d
mov rbp, rax
lea r14, [rcx+rax*8]
nop dword ptr [rax+00h]
loc_13E8:
mov rdi, [rbx]
add rbx, 8
call _strlen
lea r15d, [r15+rax+1]
cmp rbx, r14
jnz short loc_13E8
movsxd rdi, r15d
call _malloc
mov r14, rax
test rax, rax
jz loc_14A6
mov byte ptr [r14], 0
mov r12d, r12d
xor ebx, ebx
nop dword ptr [rax+rax+00h]
loc_1420:
mov rdi, r14
call _strlen
mov rsi, [r13+rbx*8+0]
lea rdi, [r14+rax]
call _stpcpy
cmp ebp, ebx
jle short loc_1442
mov edx, 20h ; ' '
mov [rax], dx
loc_1442:
add rbx, 1
cmp r12, rbx
jnz short loc_1420
loc_144B:
mov rdi, [rsp+378h+var_370]
call _free
loc_1455:
mov rax, [rsp+378h+var_40]
sub rax, fs:28h
jnz short loc_14BA
add rsp, 348h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1480:
movsxd rax, r12d
add r12d, 1
mov [rsp+rax*8+378h+var_368], rbx
jmp loc_13BC
loc_1491:
xor edi, edi
call _malloc
mov r14, rax
test rax, rax
jz short loc_14A6
mov byte ptr [r14], 0
jmp short loc_144B
loc_14A6:
mov rdi, [rsp+378h+var_370]
xor r14d, r14d
call _free
jmp short loc_1455
loc_14B5:
xor r14d, r14d
jmp short loc_1455
loc_14BA:
call ___stack_chk_fail | _BYTE *func0()
{
long long v0; // rax
int v1; // r12d
long long v2; // rbx
_QWORD *v3; // r15
long long *v4; // rbx
int v5; // r15d
long long v6; // rbp
long long v7; // rdi
_BYTE *v8; // rax
_BYTE *v9; // r14
long long v10; // rbx
long long v11; // rax
_WORD *v12; // rax
long long v14; // rax
_BYTE *v15; // rax
long long v16; // [rsp+8h] [rbp-370h]
_QWORD v17[109]; // [rsp+10h] [rbp-368h] BYREF
v17[101] = __readfsqword(0x28u);
v0 = strdup();
v16 = v0;
if ( !v0 )
return 0LL;
v1 = 0;
v2 = strtok(v0, &unk_2004);
if ( v2 )
{
do
{
if ( v1 )
{
v3 = v17;
while ( (unsigned int)strcmp(v2, *v3) )
{
if ( ++v3 == &v17[(unsigned int)(v1 - 1) + 1] )
goto LABEL_17;
}
}
else
{
LABEL_17:
v14 = v1++;
v17[v14] = v2;
}
v2 = strtok(0LL, &unk_2004);
}
while ( v2 );
v4 = v17;
v5 = 0;
v6 = (unsigned int)(v1 - 1);
do
{
v7 = *v4++;
v5 += strlen(v7) + 1;
}
while ( v4 != &v17[v6 + 1] );
v8 = (_BYTE *)malloc(v5);
v9 = v8;
if ( v8 )
{
*v8 = 0;
v10 = 0LL;
do
{
v11 = strlen(v9);
v12 = (_WORD *)stpcpy(&v9[v11], v17[v10]);
if ( (int)v6 > (int)v10 )
*v12 = 32;
++v10;
}
while ( v1 != v10 );
goto LABEL_15;
}
LABEL_20:
v9 = 0LL;
free(v16);
return v9;
}
v15 = (_BYTE *)malloc(0LL);
v9 = v15;
if ( !v15 )
goto LABEL_20;
*v15 = 0;
LABEL_15:
free(v16);
return v9;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x348
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x338],RAX
XOR EAX,EAX
CALL 0x00101150
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JZ 0x001014b5
LEA R14,[0x102004]
MOV RDI,RAX
LEA R13,[RSP + 0x10]
XOR R12D,R12D
MOV RSI,R14
CALL 0x00101140
MOV RBX,RAX
LEA RAX,[RSP + 0x18]
MOV qword ptr [RSP],RAX
TEST RBX,RBX
JZ 0x00101491
NOP word ptr [RAX + RAX*0x1]
LAB_00101380:
TEST R12D,R12D
JZ 0x00101480
MOV RDX,qword ptr [RSP]
LEA EAX,[R12 + -0x1]
MOV R15,R13
LEA RBP,[RDX + RAX*0x8]
JMP 0x001013ad
LAB_001013a0:
ADD R15,0x8
CMP R15,RBP
JZ 0x00101480
LAB_001013ad:
MOV RSI,qword ptr [R15]
MOV RDI,RBX
CALL 0x00101120
TEST EAX,EAX
JNZ 0x001013a0
LAB_001013bc:
MOV RSI,R14
XOR EDI,EDI
CALL 0x00101140
MOV RBX,RAX
TEST RAX,RAX
JNZ 0x00101380
MOV RCX,qword ptr [RSP]
LEA EAX,[R12 + -0x1]
MOV RBX,R13
XOR R15D,R15D
MOV RBP,RAX
LEA R14,[RCX + RAX*0x8]
NOP dword ptr [RAX]
LAB_001013e8:
MOV RDI,qword ptr [RBX]
ADD RBX,0x8
CALL 0x001010f0
LEA R15D,[R15 + RAX*0x1 + 0x1]
CMP RBX,R14
JNZ 0x001013e8
MOVSXD RDI,R15D
CALL 0x00101130
MOV R14,RAX
TEST RAX,RAX
JZ 0x001014a6
MOV byte ptr [R14],0x0
MOV R12D,R12D
XOR EBX,EBX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101420:
MOV RDI,R14
CALL 0x001010f0
MOV RSI,qword ptr [R13 + RBX*0x8]
LEA RDI,[R14 + RAX*0x1]
CALL 0x001010e0
CMP EBP,EBX
JLE 0x00101442
MOV EDX,0x20
MOV word ptr [RAX],DX
LAB_00101442:
ADD RBX,0x1
CMP R12,RBX
JNZ 0x00101420
LAB_0010144b:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001010d0
LAB_00101455:
MOV RAX,qword ptr [RSP + 0x338]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014ba
ADD RSP,0x348
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101480:
MOVSXD RAX,R12D
ADD R12D,0x1
MOV qword ptr [RSP + RAX*0x8 + 0x10],RBX
JMP 0x001013bc
LAB_00101491:
XOR EDI,EDI
CALL 0x00101130
MOV R14,RAX
TEST RAX,RAX
JZ 0x001014a6
MOV byte ptr [R14],0x0
JMP 0x0010144b
LAB_001014a6:
MOV RDI,qword ptr [RSP + 0x8]
XOR R14D,R14D
CALL 0x001010d0
JMP 0x00101455
LAB_001014b5:
XOR R14D,R14D
JMP 0x00101455
LAB_001014ba:
CALL 0x00101100 | char * func0(char *param_1)
{
int iVar1;
char *__s;
char *pcVar2;
size_t sVar3;
char *pcVar4;
long lVar5;
int8 *puVar6;
ulong uVar7;
uint uVar8;
long in_FS_OFFSET;
int8 local_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__s = strdup(param_1);
if (__s == (char *)0x0) {
pcVar2 = (char *)0x0;
goto LAB_00101455;
}
uVar8 = 0;
pcVar2 = strtok(__s," ");
if (pcVar2 == (char *)0x0) {
pcVar2 = (char *)malloc(0);
if (pcVar2 == (char *)0x0) goto LAB_001014a6;
*pcVar2 = '\0';
}
else {
do {
if (uVar8 != 0) {
puVar6 = local_368;
do {
iVar1 = strcmp(pcVar2,(char *)*puVar6);
if (iVar1 == 0) goto LAB_001013bc;
puVar6 = puVar6 + 1;
} while (puVar6 != local_368 + (ulong)(uVar8 - 1) + 1);
}
lVar5 = (long)(int)uVar8;
uVar8 = uVar8 + 1;
local_368[lVar5] = pcVar2;
LAB_001013bc:
pcVar2 = strtok((char *)0x0," ");
} while (pcVar2 != (char *)0x0);
iVar1 = 0;
puVar6 = local_368;
do {
pcVar2 = (char *)*puVar6;
puVar6 = puVar6 + 1;
sVar3 = strlen(pcVar2);
iVar1 = iVar1 + 1 + (int)sVar3;
} while (puVar6 != local_368 + (ulong)(uVar8 - 1) + 1);
pcVar2 = (char *)malloc((long)iVar1);
if (pcVar2 == (char *)0x0) {
LAB_001014a6:
pcVar2 = (char *)0x0;
free(__s);
goto LAB_00101455;
}
*pcVar2 = '\0';
uVar7 = 0;
do {
sVar3 = strlen(pcVar2);
pcVar4 = stpcpy(pcVar2 + sVar3,(char *)local_368[uVar7]);
if ((int)uVar7 < (int)(uVar8 - 1)) {
pcVar4[0] = ' ';
pcVar4[1] = '\0';
}
uVar7 = uVar7 + 1;
} while (uVar8 != uVar7);
}
free(__s);
LAB_00101455:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
6,591 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* string) {
// Duplicate the string to modify it
char* str = strdup(string);
if (!str) return NULL;
// Array to hold unique words
char* unique[100];
int unique_count = 0;
// Split the string into words
char* token = strtok(str, " ");
while(token != NULL){
int found = 0;
for(int i=0;i<unique_count;i++){
if(strcmp(token, unique[i]) == 0){
found = 1;
break;
}
}
if(!found){
unique[unique_count++] = token;
}
token = strtok(NULL, " ");
}
// Calculate the total length needed
int total_length = 0;
for(int i=0;i<unique_count;i++){
total_length += strlen(unique[i]) + 1; // +1 for space or null
}
// Allocate result string
char* result = malloc(total_length);
if(!result){
free(str);
return NULL;
}
result[0] = '\0';
for(int i=0;i<unique_count;i++){
strcat(result, unique[i]);
if(i < unique_count -1){
strcat(result, " ");
}
}
free(str);
return result;
}
| int main(){
assert(strcmp(func0("Python Exercises Practice Solution Exercises"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Python"), "Python Exercises Practice Solution") == 0);
assert(strcmp(func0("Python Exercises Practice Solution Practice"), "Python Exercises Practice Solution") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x348,%rsp
mov %fs:0x28,%rax
mov %rax,0x338(%rsp)
xor %eax,%eax
callq 1170 <strdup@plt>
mov %rax,0x8(%rsp)
test %rax,%rax
je 155c <func0+0x20c>
lea 0xc72(%rip),%rsi
mov %rax,%rdi
lea 0x10(%rsp),%r13
xor %r12d,%r12d
callq 1150 <strtok@plt>
lea 0xc5b(%rip),%r15
mov %rax,%rbx
lea 0x18(%rsp),%rax
mov %rax,(%rsp)
test %rbx,%rbx
je 1532 <func0+0x1e2>
xchg %ax,%ax
test %r12d,%r12d
je 14b0 <func0+0x160>
mov (%rsp),%rcx
lea -0x1(%r12),%eax
mov %r13,%r14
lea (%rcx,%rax,8),%rbp
jmp 13ed <func0+0x9d>
nopl 0x0(%rax,%rax,1)
add $0x8,%r14
cmp %rbp,%r14
je 14b0 <func0+0x160>
mov (%r14),%rsi
mov %rbx,%rdi
callq 1130 <strcmp@plt>
test %eax,%eax
jne 13e0 <func0+0x90>
mov %r15,%rsi
xor %edi,%edi
callq 1150 <strtok@plt>
mov %rax,%rbx
test %rax,%rax
jne 13c0 <func0+0x70>
mov (%rsp),%rcx
lea -0x1(%r12),%eax
mov %r13,%rbp
xor %r15d,%r15d
mov %rax,%rbx
lea (%rcx,%rax,8),%r14
nopl 0x0(%rax)
mov 0x0(%rbp),%rdi
add $0x8,%rbp
callq 1100 <strlen@plt>
lea 0x1(%r15,%rax,1),%r15d
cmp %r14,%rbp
jne 1428 <func0+0xd8>
movslq %r15d,%rdi
callq 1140 <malloc@plt>
mov %rax,%r14
test %rax,%rax
je 154a <func0+0x1fa>
movb $0x0,(%r14)
test %ebx,%ebx
jg 14c8 <func0+0x178>
xor %eax,%eax
movslq %eax,%rbx
mov 0x0(%r13,%rbx,8),%rsi
mov %r14,%rdi
add $0x1,%rbx
callq 1160 <strcat@plt>
cmp %ebx,%r12d
jg 1460 <func0+0x110>
mov 0x8(%rsp),%rdi
callq 10e0 <free@plt>
mov 0x338(%rsp),%rax
xor %fs:0x28,%rax
jne 1564 <func0+0x214>
add $0x348,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
movslq %r12d,%rax
add $0x1,%r12d
mov %rbx,0x10(%rsp,%rax,8)
jmpq 13fc <func0+0xac>
nopl 0x0(%rax)
xor %ebp,%ebp
nopw 0x0(%rax,%rax,1)
mov %r14,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 14d3 <func0+0x183>
mov %eax,%edx
mov 0x0(%r13,%rbp,8),%rsi
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov %eax,%ecx
add %al,%cl
sbb $0x3,%rdi
callq 10f0 <stpcpy@plt>
mov $0x20,%edx
mov %dx,(%rax)
lea 0x1(%rbp),%eax
add $0x1,%rbp
cmp %ebp,%ebx
jg 14d0 <func0+0x180>
cmp %eax,%r12d
jg 145d <func0+0x10d>
jmpq 1476 <func0+0x126>
xor %edi,%edi
callq 1140 <malloc@plt>
mov %rax,%r14
test %rax,%rax
je 154a <func0+0x1fa>
movb $0x0,(%r14)
jmpq 1476 <func0+0x126>
mov 0x8(%rsp),%rdi
xor %r14d,%r14d
callq 10e0 <free@plt>
jmpq 1480 <func0+0x130>
xor %r14d,%r14d
jmpq 1480 <func0+0x130>
callq 1110 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 348h
mov rax, fs:28h
mov [rsp+378h+var_40], rax
xor eax, eax
call _strdup
mov [rsp+378h+ptr], rax
test rax, rax
jz loc_155B
lea rsi, delim; " "
mov rdi, rax; s
lea r13, [rsp+378h+var_368]
xor ebx, ebx
call _strtok
mov rbp, rax
test rax, rax
jz loc_1535
nop dword ptr [rax]
loc_13B0:
movsxd r14, ebx
lea r12, [r13+r14*8+0]
test ebx, ebx
jle loc_14B0
loc_13C0:
mov r15, r13
jmp short loc_13D5
loc_13C8:
add r15, 8
cmp r15, r12
jz loc_14B0
loc_13D5:
mov rsi, [r15]; s2
mov rdi, rbp; s1
call _strcmp
test eax, eax
jnz short loc_13C8
lea rsi, delim; " "
xor edi, edi; s
call _strtok
mov rbp, rax
test rax, rax
jnz short loc_13C0
loc_13FA:
test ebx, ebx
jle loc_1535
lea r13, [rsp+378h+var_368]
movsxd rax, ebx
xor ebp, ebp
mov r12, r13
lea r14, [r13+rax*8+0]
nop dword ptr [rax+00h]
loc_1418:
mov rdi, [r12]; s
add r12, 8
call _strlen
lea ebp, [rbp+rax+1]
cmp r12, r14
jnz short loc_1418
movsxd rbp, ebp
mov rdi, rbp; size
call _malloc
mov r14, rax
test rax, rax
jz loc_1551
mov byte ptr [rax], 0
lea eax, [rbx-1]
xor r12d, r12d
mov r15d, eax
test eax, eax
jg loc_14D7
loc_1459:
movsxd r12, r12d
nop dword ptr [rax+00h]
loc_1460:
mov rsi, [r13+r12*8+0]
mov rdx, rbp
mov rdi, r14
add r12, 1
call ___strcat_chk
cmp ebx, r12d
jg short loc_1460
loc_1479:
mov rdi, [rsp+378h+ptr]; ptr
call _free
loc_1483:
mov rax, [rsp+378h+var_40]
sub rax, fs:28h
jnz loc_154C
add rsp, 348h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_14B0:
lea rsi, delim; " "
xor edi, edi; s
mov [rsp+r14*8+378h+var_368], rbp
add ebx, 1
call _strtok
mov rbp, rax
test rax, rax
jnz loc_13B0
jmp loc_13FA
loc_14D7:
xor r12d, r12d
loc_14DA:
mov rdi, r14; s
call _strlen
mov rsi, [r13+r12*8+0]
mov rdx, rbp
lea rdi, [r14+rax]
call ___stpcpy_chk
mov rcx, r14
mov edx, 2
lea rsi, delim; " "
sub rcx, rax
mov rdi, rax
add rcx, rbp
call ___memcpy_chk
lea rax, [r12+1]
cmp r15d, eax
jg short loc_1530
add r12d, 1
cmp r12d, ebx
jl loc_1459
jmp loc_1479
loc_1530:
mov r12, rax
jmp short loc_14DA
loc_1535:
xor edi, edi; size
call _malloc
mov r14, rax
test rax, rax
jz short loc_1551
mov byte ptr [rax], 0
jmp loc_1479
loc_154C:
call ___stack_chk_fail
loc_1551:
mov rdi, [rsp+378h+ptr]; ptr
call _free
loc_155B:
xor r14d, r14d
jmp loc_1483 | const char * func0(const char *a1)
{
char *v1; // rax
int v2; // ebx
char *v3; // rbp
const char **v4; // r15
int v5; // ebp
const char **v6; // r12
const char *v7; // rdi
const char *v8; // rax
const char *v9; // r14
long long i; // r12
long long v11; // rsi
size_t v13; // rax
long long v14; // rax
const char *v15; // rax
char *ptr; // [rsp+8h] [rbp-370h]
_QWORD v17[109]; // [rsp+10h] [rbp-368h] BYREF
v17[101] = __readfsqword(0x28u);
v1 = strdup(a1);
ptr = v1;
if ( !v1 )
return 0LL;
v2 = 0;
v3 = strtok(v1, " ");
if ( v3 )
{
while ( v2 <= 0 )
{
LABEL_17:
v17[v2++] = v3;
v3 = strtok(0LL, " ");
if ( !v3 )
goto LABEL_8;
}
do
{
v4 = (const char **)v17;
while ( strcmp(v3, *v4) )
{
if ( ++v4 == &v17[v2] )
goto LABEL_17;
}
v3 = strtok(0LL, " ");
}
while ( v3 );
LABEL_8:
if ( v2 > 0 )
{
v5 = 0;
v6 = (const char **)v17;
do
{
v7 = *v6++;
v5 += strlen(v7) + 1;
}
while ( v6 != &v17[v2] );
v8 = (const char *)malloc(v5);
v9 = v8;
if ( v8 )
{
*v8 = 0;
LODWORD(i) = 0;
if ( v2 - 1 <= 0 )
goto LABEL_13;
for ( i = 0LL; ; ++i )
{
v13 = strlen(v9);
v14 = __stpcpy_chk(&v9[v13], v17[i], v5);
__memcpy_chk(v14, " ", 2LL, &v9[v5 - v14]);
if ( v2 - 1 <= (int)i + 1 )
break;
}
LODWORD(i) = i + 1;
if ( (int)i < v2 )
{
LABEL_13:
i = (int)i;
do
{
v11 = v17[i++];
__strcat_chk(v9, v11, v5);
}
while ( v2 > (int)i );
}
goto LABEL_15;
}
goto LABEL_26;
}
}
v15 = (const char *)malloc(0LL);
v9 = v15;
if ( !v15 )
{
LABEL_26:
free(ptr);
return 0LL;
}
*v15 = 0;
LABEL_15:
free(ptr);
return v9;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x348
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x338],RAX
XOR EAX,EAX
CALL 0x00101190
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JZ 0x0010155b
LEA RSI,[0x102004]
MOV RDI,RAX
LEA R13,[RSP + 0x10]
XOR EBX,EBX
CALL 0x00101180
MOV RBP,RAX
TEST RAX,RAX
JZ 0x00101535
NOP dword ptr [RAX]
LAB_001013b0:
MOVSXD R14,EBX
LEA R12,[R13 + R14*0x8]
TEST EBX,EBX
JLE 0x001014b0
LAB_001013c0:
MOV R15,R13
JMP 0x001013d5
LAB_001013c8:
ADD R15,0x8
CMP R15,R12
JZ 0x001014b0
LAB_001013d5:
MOV RSI,qword ptr [R15]
MOV RDI,RBP
CALL 0x00101140
TEST EAX,EAX
JNZ 0x001013c8
LEA RSI,[0x102004]
XOR EDI,EDI
CALL 0x00101180
MOV RBP,RAX
TEST RAX,RAX
JNZ 0x001013c0
LAB_001013fa:
TEST EBX,EBX
JLE 0x00101535
LEA R13,[RSP + 0x10]
MOVSXD RAX,EBX
XOR EBP,EBP
MOV R12,R13
LEA R14,[R13 + RAX*0x8]
NOP dword ptr [RAX]
LAB_00101418:
MOV RDI,qword ptr [R12]
ADD R12,0x8
CALL 0x00101110
LEA EBP,[RBP + RAX*0x1 + 0x1]
CMP R12,R14
JNZ 0x00101418
MOVSXD RBP,EBP
MOV RDI,RBP
CALL 0x00101170
MOV R14,RAX
TEST RAX,RAX
JZ 0x00101551
MOV byte ptr [RAX],0x0
LEA EAX,[RBX + -0x1]
XOR R12D,R12D
MOV R15D,EAX
TEST EAX,EAX
JG 0x001014d7
LAB_00101459:
MOVSXD R12,R12D
NOP dword ptr [RAX]
LAB_00101460:
MOV RSI,qword ptr [R13 + R12*0x8]
MOV RDX,RBP
MOV RDI,R14
ADD R12,0x1
CALL 0x001010f0
CMP EBX,R12D
JG 0x00101460
LAB_00101479:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00101100
LAB_00101483:
MOV RAX,qword ptr [RSP + 0x338]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010154c
ADD RSP,0x348
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001014b0:
LEA RSI,[0x102004]
XOR EDI,EDI
MOV qword ptr [RSP + R14*0x8 + 0x10],RBP
ADD EBX,0x1
CALL 0x00101180
MOV RBP,RAX
TEST RAX,RAX
JNZ 0x001013b0
JMP 0x001013fa
LAB_001014d7:
XOR R12D,R12D
LAB_001014da:
MOV RDI,R14
CALL 0x00101110
MOV RSI,qword ptr [R13 + R12*0x8]
MOV RDX,RBP
LEA RDI,[R14 + RAX*0x1]
CALL 0x00101160
MOV RCX,R14
MOV EDX,0x2
LEA RSI,[0x102004]
SUB RCX,RAX
MOV RDI,RAX
ADD RCX,RBP
CALL 0x00101150
LEA RAX,[R12 + 0x1]
CMP R15D,EAX
JG 0x00101530
ADD R12D,0x1
CMP R12D,EBX
JL 0x00101459
JMP 0x00101479
LAB_00101530:
MOV R12,RAX
JMP 0x001014da
LAB_00101535:
XOR EDI,EDI
CALL 0x00101170
MOV R14,RAX
TEST RAX,RAX
JZ 0x00101551
MOV byte ptr [RAX],0x0
JMP 0x00101479
LAB_0010154c:
CALL 0x00101120
LAB_00101551:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00101100
LAB_0010155b:
XOR R14D,R14D
JMP 0x00101483 | char * func0(char *param_1)
{
int iVar1;
char *__s;
char *pcVar2;
size_t sVar3;
size_t sVar4;
int iVar5;
int8 *puVar6;
long lVar7;
long lVar8;
long in_FS_OFFSET;
int8 local_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
__s = strdup(param_1);
if (__s == (char *)0x0) {
LAB_0010155b:
pcVar2 = (char *)0x0;
}
else {
iVar5 = 0;
pcVar2 = strtok(__s," ");
if (pcVar2 == (char *)0x0) {
LAB_00101535:
pcVar2 = (char *)malloc(0);
if (pcVar2 == (char *)0x0) {
LAB_00101551:
free(__s);
goto LAB_0010155b;
}
*pcVar2 = '\0';
}
else {
do {
puVar6 = local_368;
if (0 < iVar5) {
do {
while (iVar1 = strcmp(pcVar2,(char *)*puVar6), iVar1 == 0) {
pcVar2 = strtok((char *)0x0," ");
puVar6 = local_368;
if (pcVar2 == (char *)0x0) goto LAB_001013fa;
}
puVar6 = puVar6 + 1;
} while (puVar6 != local_368 + iVar5);
}
local_368[iVar5] = pcVar2;
iVar5 = iVar5 + 1;
pcVar2 = strtok((char *)0x0," ");
} while (pcVar2 != (char *)0x0);
LAB_001013fa:
if (iVar5 < 1) goto LAB_00101535;
iVar1 = 0;
puVar6 = local_368;
do {
pcVar2 = (char *)*puVar6;
puVar6 = puVar6 + 1;
sVar3 = strlen(pcVar2);
iVar1 = iVar1 + 1 + (int)sVar3;
} while (puVar6 != local_368 + iVar5);
sVar3 = (size_t)iVar1;
pcVar2 = (char *)malloc(sVar3);
if (pcVar2 == (char *)0x0) goto LAB_00101551;
*pcVar2 = '\0';
iVar1 = 0;
if (iVar5 + -1 < 1) {
LAB_00101459:
lVar7 = (long)iVar1;
do {
puVar6 = local_368 + lVar7;
lVar7 = lVar7 + 1;
__strcat_chk(pcVar2,*puVar6,sVar3);
} while ((int)lVar7 < iVar5);
}
else {
lVar7 = 0;
do {
lVar8 = lVar7;
sVar4 = strlen(pcVar2);
lVar7 = __stpcpy_chk(pcVar2 + sVar4,local_368[lVar8],sVar3);
__memcpy_chk(lVar7,&DAT_00102004,2,pcVar2 + (sVar3 - lVar7));
lVar7 = lVar8 + 1;
} while ((int)(lVar8 + 1) < iVar5 + -1);
iVar1 = (int)lVar8 + 1;
if (iVar1 < iVar5) goto LAB_00101459;
}
}
free(__s);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
6,592 | func0 |
#include <assert.h>
| int func0(int x, int y, int m, int n) {
int sum_nums = x + y;
if (sum_nums >= m && sum_nums <= n) {
return 20;
} else {
return sum_nums;
}
}
| int main() {
assert(func0(2, 10, 11, 20) == 20);
assert(func0(15, 17, 1, 10) == 32);
assert(func0(10, 15, 5, 30) == 20);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov %ecx,-0x20(%rbp)
mov -0x14(%rbp),%edx
mov -0x18(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 117f <func0+0x36>
mov -0x4(%rbp),%eax
cmp -0x20(%rbp),%eax
jg 117f <func0+0x36>
mov $0x14,%eax
jmp 1182 <func0+0x39>
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov edx, [rbp+var_14]
mov eax, [rbp+var_18]
add eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_117F
mov eax, [rbp+var_4]
cmp eax, [rbp+var_20]
jg short loc_117F
mov eax, 14h
jmp short loc_1182
loc_117F:
mov eax, [rbp+var_4]
loc_1182:
pop rbp
retn | long long func0(int a1, int a2, int a3, int a4)
{
unsigned int v5; // [rsp+1Ch] [rbp-4h]
v5 = a1 + a2;
if ( a1 + a2 < a3 || (int)v5 > a4 )
return v5;
else
return 20LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x20],ECX
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010117f
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x20]
JG 0x0010117f
MOV EAX,0x14
JMP 0x00101182
LAB_0010117f:
MOV EAX,dword ptr [RBP + -0x4]
LAB_00101182:
POP RBP
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
param_2 = param_2 + param_1;
if ((param_3 <= param_2) && (param_2 <= param_4)) {
param_2 = 0x14;
}
return param_2;
} |
6,593 | func0 |
#include <assert.h>
| int func0(int x, int y, int m, int n) {
int sum_nums = x + y;
if (sum_nums >= m && sum_nums <= n) {
return 20;
} else {
return sum_nums;
}
}
| int main() {
assert(func0(2, 10, 11, 20) == 20);
assert(func0(15, 17, 1, 10) == 32);
assert(func0(10, 15, 5, 30) == 20);
return 0;
}
| O1 | c | func0:
endbr64
lea (%rdi,%rsi,1),%eax
cmp %edx,%eax
jl 113e <func0+0x15>
cmp %ecx,%eax
mov $0x14,%edx
cmovle %edx,%eax
retq
| func0:
endbr64
lea eax, [rdi+rsi]
cmp eax, edx
jl short locret_113E
cmp eax, ecx
mov edx, 14h
cmovle eax, edx
locret_113E:
retn | long long func0(int a1, int a2, int a3, int a4)
{
long long result; // rax
result = (unsigned int)(a1 + a2);
if ( (int)result >= a3 && (int)result <= a4 )
return 20LL;
return result;
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
CMP EAX,EDX
JL 0x0010113e
CMP EAX,ECX
MOV EDX,0x14
CMOVLE EAX,EDX
LAB_0010113e:
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
param_1 = param_1 + param_2;
if ((param_3 <= param_1) && (param_1 <= param_4)) {
param_1 = 0x14;
}
return param_1;
} |
6,594 | func0 |
#include <assert.h>
| int func0(int x, int y, int m, int n) {
int sum_nums = x + y;
if (sum_nums >= m && sum_nums <= n) {
return 20;
} else {
return sum_nums;
}
}
| int main() {
assert(func0(2, 10, 11, 20) == 20);
assert(func0(15, 17, 1, 10) == 32);
assert(func0(10, 15, 5, 30) == 20);
return 0;
}
| O2 | c | func0:
endbr64
lea (%rdi,%rsi,1),%eax
cmp %edx,%eax
jl 1155 <func0+0x15>
cmp %ecx,%eax
mov $0x14,%edx
cmovle %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi+rsi]
cmp eax, edx
jl short locret_1155
cmp eax, ecx
mov edx, 14h
cmovle eax, edx
locret_1155:
retn | long long func0(int a1, int a2, int a3, int a4)
{
long long result; // rax
result = (unsigned int)(a1 + a2);
if ( (int)result >= a3 && (int)result <= a4 )
return 20LL;
return result;
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
CMP EAX,EDX
JL 0x00101155
CMP EAX,ECX
MOV EDX,0x14
CMOVLE EAX,EDX
LAB_00101155:
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
param_1 = param_1 + param_2;
if ((param_3 <= param_1) && (param_1 <= param_4)) {
param_1 = 0x14;
}
return param_1;
} |
6,595 | func0 |
#include <assert.h>
| int func0(int x, int y, int m, int n) {
int sum_nums = x + y;
if (sum_nums >= m && sum_nums <= n) {
return 20;
} else {
return sum_nums;
}
}
| int main() {
assert(func0(2, 10, 11, 20) == 20);
assert(func0(15, 17, 1, 10) == 32);
assert(func0(10, 15, 5, 30) == 20);
return 0;
}
| O3 | c | func0:
endbr64
lea (%rdi,%rsi,1),%eax
cmp %edx,%eax
jl 1155 <func0+0x15>
cmp %ecx,%eax
mov $0x14,%edx
cmovle %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi+rsi]
cmp eax, edx
jl short locret_1155
cmp eax, ecx
mov edx, 14h
cmovle eax, edx
locret_1155:
retn | long long func0(int a1, int a2, int a3, int a4)
{
long long result; // rax
result = (unsigned int)(a1 + a2);
if ( (int)result >= a3 && (int)result <= a4 )
return 20LL;
return result;
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
CMP EAX,EDX
JL 0x00101155
CMP EAX,ECX
MOV EDX,0x14
CMOVLE EAX,EDX
LAB_00101155:
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
param_1 = param_1 + param_2;
if ((param_3 <= param_1) && (param_1 <= param_4)) {
param_1 = 0x14;
}
return param_1;
} |
6,596 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(const char* text1) {
size_t len = strlen(text1);
char* result = (char*)malloc(len + 1);
if (!result) return NULL;
size_t j = 0;
for (size_t i = 0; i < len; ++i) {
if (isalnum((unsigned char)text1[i])) {
result[j++] = text1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
char* res1 = func0("**//Google Android// - 12. ");
assert(res1 != NULL);
assert(strcmp(res1, "GoogleAndroid12") == 0);
free(res1);
char* res2 = func0("****//Google Flutter//*** - 36. ");
assert(res2 != NULL);
assert(strcmp(res2, "GoogleFlutter36") == 0);
free(res2);
char* res3 = func0("**//Google Firebase// - 478. ");
assert(res3 != NULL);
assert(strcmp(res3, "GoogleFirebase478") == 0);
free(res3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10b0 <strlen@plt>
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
add $0x1,%rax
mov %rax,%rdi
callq 10e0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 122e <func0+0x45>
mov $0x0,%eax
jmpq 12b1 <func0+0xc8>
movq $0x0,-0x20(%rbp)
movq $0x0,-0x18(%rbp)
jmp 1295 <func0+0xac>
callq 10f0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x28(%rbp),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movzbl %dl,%edx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x8,%eax
test %eax,%eax
je 1290 <func0+0xa7>
mov -0x28(%rbp),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x20(%rbp),%rax
lea 0x1(%rax),%rdx
mov %rdx,-0x20(%rbp)
mov -0x8(%rbp),%rdx
add %rax,%rdx
movzbl (%rcx),%eax
mov %al,(%rdx)
addq $0x1,-0x18(%rbp)
mov -0x18(%rbp),%rax
cmp -0x10(%rbp),%rax
jb 1240 <func0+0x57>
mov -0x8(%rbp),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
add rax, 1
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jnz short loc_122E
mov eax, 0
jmp locret_12B1
loc_122E:
mov [rbp+var_20], 0
mov [rbp+var_18], 0
jmp short loc_1295
loc_1240:
call ___ctype_b_loc
mov rax, [rax]
mov rcx, [rbp+s]
mov rdx, [rbp+var_18]
add rdx, rcx
movzx edx, byte ptr [rdx]
movzx edx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 8
test eax, eax
jz short loc_1290
mov rdx, [rbp+s]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov rax, [rbp+var_20]
lea rdx, [rax+1]
mov [rbp+var_20], rdx
mov rdx, [rbp+var_8]
add rdx, rax
movzx eax, byte ptr [rcx]
mov [rdx], al
loc_1290:
add [rbp+var_18], 1
loc_1295:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_10]
jb short loc_1240
mov rdx, [rbp+var_8]
mov rax, [rbp+var_20]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
locret_12B1:
leave
retn | _BYTE * func0(const char *a1)
{
long long v2; // rax
long long v3; // [rsp+10h] [rbp-20h]
size_t i; // [rsp+18h] [rbp-18h]
size_t v5; // [rsp+20h] [rbp-10h]
_BYTE *v6; // [rsp+28h] [rbp-8h]
v5 = strlen(a1);
v6 = malloc(v5 + 1);
if ( !v6 )
return 0LL;
v3 = 0LL;
for ( i = 0LL; i < v5; ++i )
{
if ( ((*__ctype_b_loc())[(unsigned __int8)a1[i]] & 8) != 0 )
{
v2 = v3++;
v6[v2] = a1[i];
}
}
v6[v3] = 0;
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0010122e
MOV EAX,0x0
JMP 0x001012b1
LAB_0010122e:
MOV qword ptr [RBP + -0x20],0x0
MOV qword ptr [RBP + -0x18],0x0
JMP 0x00101295
LAB_00101240:
CALL 0x001010f0
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVZX EDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x8
TEST EAX,EAX
JZ 0x00101290
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[RAX + 0x1]
MOV qword ptr [RBP + -0x20],RDX
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOVZX EAX,byte ptr [RCX]
MOV byte ptr [RDX],AL
LAB_00101290:
ADD qword ptr [RBP + -0x18],0x1
LAB_00101295:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x10]
JC 0x00101240
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
LAB_001012b1:
LEAVE
RET | void * func0(char *param_1)
{
size_t sVar1;
void *pvVar2;
ushort **ppuVar3;
long local_28;
ulong local_20;
sVar1 = strlen(param_1);
pvVar2 = malloc(sVar1 + 1);
if (pvVar2 == (void *)0x0) {
pvVar2 = (void *)0x0;
}
else {
local_28 = 0;
for (local_20 = 0; local_20 < sVar1; local_20 = local_20 + 1) {
ppuVar3 = __ctype_b_loc();
if (((*ppuVar3)[(byte)param_1[local_20]] & 8) != 0) {
*(char *)((long)pvVar2 + local_28) = param_1[local_20];
local_28 = local_28 + 1;
}
}
*(int *)(local_28 + (long)pvVar2) = 0;
}
return pvVar2;
} |
6,597 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(const char* text1) {
size_t len = strlen(text1);
char* result = (char*)malloc(len + 1);
if (!result) return NULL;
size_t j = 0;
for (size_t i = 0; i < len; ++i) {
if (isalnum((unsigned char)text1[i])) {
result[j++] = text1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
char* res1 = func0("**//Google Android// - 12. ");
assert(res1 != NULL);
assert(strcmp(res1, "GoogleAndroid12") == 0);
free(res1);
char* res2 = func0("****//Google Flutter//*** - 36. ");
assert(res2 != NULL);
assert(strcmp(res2, "GoogleFlutter36") == 0);
free(res2);
char* res3 = func0("**//Google Firebase// - 478. ");
assert(res3 != NULL);
assert(strcmp(res3, "GoogleFirebase478") == 0);
free(res3);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rdi
not %rdi
lea -0x1(%rdi),%rbx
callq 10a0 <malloc@plt>
mov %rax,%rbp
test %rax,%rax
je 1218 <func0+0x6f>
test %rbx,%rbx
je 1213 <func0+0x6a>
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rsi
mov %r12,%rax
lea (%r12,%rbx,1),%rdi
mov $0x0,%ebx
jmp 11fd <func0+0x54>
add $0x1,%rax
cmp %rdi,%rax
je 1213 <func0+0x6a>
movzbl (%rax),%edx
movzbl %dl,%ecx
testb $0x8,(%rsi,%rcx,2)
je 11f4 <func0+0x4b>
mov %dl,0x0(%rbp,%rbx,1)
lea 0x1(%rbx),%rbx
jmp 11f4 <func0+0x4b>
movb $0x0,0x0(%rbp,%rbx,1)
mov %rbp,%rax
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
call _strlen
mov r13, rax
mov rbx, rax
lea rdi, [rax+1]
call _malloc
mov rbp, rax
test rax, rax
jz short loc_1255
test r13, r13
jz short loc_1250
call ___ctype_b_loc
mov rdi, [rax]
mov rax, r12
lea rsi, [r12+r13]
mov ebx, 0
jmp short loc_123A
loc_1231:
add rax, 1
cmp rax, rsi
jz short loc_1250
loc_123A:
movzx edx, byte ptr [rax]
movzx ecx, dl
test byte ptr [rdi+rcx*2], 8
jz short loc_1231
mov [rbp+rbx+0], dl
lea rbx, [rbx+1]
jmp short loc_1231
loc_1250:
mov byte ptr [rbp+rbx+0], 0
loc_1255:
mov rax, rbp
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(_BYTE *a1)
{
long long v2; // r13
long long v3; // rbx
long long v4; // rbp
long long v5; // rdi
_BYTE *v6; // rax
v2 = strlen();
v3 = v2;
v4 = malloc(v2 + 1);
if ( v4 )
{
if ( v2 )
{
v5 = *(_QWORD *)__ctype_b_loc();
v6 = a1;
v3 = 0LL;
do
{
if ( (*(_BYTE *)(v5 + 2LL * (unsigned __int8)*v6) & 8) != 0 )
*(_BYTE *)(v4 + v3++) = *v6;
++v6;
}
while ( v6 != &a1[v2] );
}
*(_BYTE *)(v4 + v3) = 0;
}
return v4;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
CALL 0x001010b0
MOV R13,RAX
MOV RBX,RAX
LEA RDI,[RAX + 0x1]
CALL 0x001010e0
MOV RBP,RAX
TEST RAX,RAX
JZ 0x00101255
TEST R13,R13
JZ 0x00101250
CALL 0x001010f0
MOV RDI,qword ptr [RAX]
MOV RAX,R12
LEA RSI,[R12 + R13*0x1]
MOV EBX,0x0
JMP 0x0010123a
LAB_00101231:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x00101250
LAB_0010123a:
MOVZX EDX,byte ptr [RAX]
MOVZX ECX,DL
TEST byte ptr [RDI + RCX*0x2],0x8
JZ 0x00101231
MOV byte ptr [RBP + RBX*0x1],DL
LEA RBX,[RBX + 0x1]
JMP 0x00101231
LAB_00101250:
MOV byte ptr [RBP + RBX*0x1],0x0
LAB_00101255:
MOV RAX,RBP
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void * func0(byte *param_1)
{
byte *pbVar1;
ushort *puVar2;
size_t sVar3;
void *pvVar4;
ushort **ppuVar5;
sVar3 = strlen((char *)param_1);
pvVar4 = malloc(sVar3 + 1);
if (pvVar4 != (void *)0x0) {
if (sVar3 != 0) {
ppuVar5 = __ctype_b_loc();
puVar2 = *ppuVar5;
pbVar1 = param_1 + sVar3;
sVar3 = 0;
do {
if ((puVar2[*param_1] & 8) != 0) {
*(byte *)((long)pvVar4 + sVar3) = *param_1;
sVar3 = sVar3 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != pbVar1);
}
*(int1 *)((long)pvVar4 + sVar3) = 0;
}
return pvVar4;
} |
6,598 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(const char* text1) {
size_t len = strlen(text1);
char* result = (char*)malloc(len + 1);
if (!result) return NULL;
size_t j = 0;
for (size_t i = 0; i < len; ++i) {
if (isalnum((unsigned char)text1[i])) {
result[j++] = text1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
char* res1 = func0("**//Google Android// - 12. ");
assert(res1 != NULL);
assert(strcmp(res1, "GoogleAndroid12") == 0);
free(res1);
char* res2 = func0("****//Google Flutter//*** - 36. ");
assert(res2 != NULL);
assert(strcmp(res2, "GoogleFlutter36") == 0);
free(res2);
char* res3 = func0("**//Google Firebase// - 478. ");
assert(res3 != NULL);
assert(strcmp(res3, "GoogleFirebase478") == 0);
free(res3);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
callq 10a0 <strlen@plt>
lea 0x1(%rax),%rdi
mov %rax,%rbp
callq 10c0 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 13b6 <func0+0x66>
test %rbp,%rbp
je 13c0 <func0+0x70>
callq 10d0 <__ctype_b_loc@plt>
mov %rbx,%rdi
lea (%rbx,%rbp,1),%r9
xor %r8d,%r8d
mov (%rax),%r10
mov %r12,%rax
xchg %ax,%ax
movzbl (%rdi),%ecx
mov %rax,%rsi
testb $0x8,(%r10,%rcx,2)
je 13aa <func0+0x5a>
add $0x1,%r8
mov %cl,(%rax)
lea (%r12,%r8,1),%rax
mov %rax,%rsi
add $0x1,%rdi
cmp %rdi,%r9
jne 1390 <func0+0x40>
movb $0x0,(%rsi)
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
xchg %ax,%ax
mov %rax,%rsi
jmp 13b3 <func0+0x63>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
call _strlen
lea rdi, [rax+1]
mov rbp, rax
call _malloc
mov r12, rax
test rax, rax
jz short loc_13B1
test rbp, rbp
jz short loc_13C0
call ___ctype_b_loc
lea rdi, [rbx+rbp]
xor esi, esi
mov r8, [rax]
mov rax, rbx
nop word ptr [rax+rax+00h]
loc_1390:
movzx ecx, byte ptr [rax]
test byte ptr [r8+rcx*2], 8
jz short loc_13A2
mov [r12+rsi], cl
add rsi, 1
loc_13A2:
add rax, 1
cmp rdi, rax
jnz short loc_1390
add rsi, r12
loc_13AE:
mov byte ptr [rsi], 0
loc_13B1:
mov rax, r12
pop rbx
pop rbp
pop r12
retn
loc_13C0:
mov rsi, rax
jmp short loc_13AE | long long func0(unsigned __int8 *a1)
{
long long v2; // rbp
long long v3; // rax
long long v4; // r12
unsigned __int8 *v5; // rdi
long long v6; // rsi
long long v7; // r8
unsigned __int8 *v8; // rax
long long v9; // rcx
_BYTE *v10; // rsi
v2 = strlen();
v3 = malloc(v2 + 1);
v4 = v3;
if ( v3 )
{
if ( v2 )
{
v5 = &a1[v2];
v6 = 0LL;
v7 = *(_QWORD *)__ctype_b_loc();
v8 = a1;
do
{
v9 = *v8;
if ( (*(_BYTE *)(v7 + 2 * v9) & 8) != 0 )
*(_BYTE *)(v4 + v6++) = v9;
++v8;
}
while ( v5 != v8 );
v10 = (_BYTE *)(v4 + v6);
}
else
{
v10 = (_BYTE *)v3;
}
*v10 = 0;
}
return v4;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
CALL 0x001010b0
LEA RDI,[RAX + 0x1]
MOV RBP,RAX
CALL 0x001010e0
MOV R12,RAX
TEST RAX,RAX
JZ 0x001013b1
TEST RBP,RBP
JZ 0x001013c0
CALL 0x001010f0
LEA RDI,[RBX + RBP*0x1]
XOR ESI,ESI
MOV R8,qword ptr [RAX]
MOV RAX,RBX
NOP word ptr [RAX + RAX*0x1]
LAB_00101390:
MOVZX ECX,byte ptr [RAX]
TEST byte ptr [R8 + RCX*0x2],0x8
JZ 0x001013a2
MOV byte ptr [R12 + RSI*0x1],CL
ADD RSI,0x1
LAB_001013a2:
ADD RAX,0x1
CMP RDI,RAX
JNZ 0x00101390
ADD RSI,R12
LAB_001013ae:
MOV byte ptr [RSI],0x0
LAB_001013b1:
MOV RAX,R12
POP RBX
POP RBP
POP R12
RET
LAB_001013c0:
MOV RSI,RAX
JMP 0x001013ae | int1 * func0(byte *param_1)
{
byte *pbVar1;
ushort *puVar2;
size_t sVar3;
int1 *puVar4;
ushort **ppuVar5;
long lVar6;
int1 *puVar7;
sVar3 = strlen((char *)param_1);
puVar4 = (int1 *)malloc(sVar3 + 1);
if (puVar4 != (int1 *)0x0) {
puVar7 = puVar4;
if (sVar3 != 0) {
ppuVar5 = __ctype_b_loc();
pbVar1 = param_1 + sVar3;
lVar6 = 0;
puVar2 = *ppuVar5;
do {
if ((puVar2[*param_1] & 8) != 0) {
puVar4[lVar6] = *param_1;
lVar6 = lVar6 + 1;
}
param_1 = param_1 + 1;
} while (pbVar1 != param_1);
puVar7 = puVar4 + lVar6;
}
*puVar7 = 0;
}
return puVar4;
} |
6,599 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(const char* text1) {
size_t len = strlen(text1);
char* result = (char*)malloc(len + 1);
if (!result) return NULL;
size_t j = 0;
for (size_t i = 0; i < len; ++i) {
if (isalnum((unsigned char)text1[i])) {
result[j++] = text1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
char* res1 = func0("**//Google Android// - 12. ");
assert(res1 != NULL);
assert(strcmp(res1, "GoogleAndroid12") == 0);
free(res1);
char* res2 = func0("****//Google Flutter//*** - 36. ");
assert(res2 != NULL);
assert(strcmp(res2, "GoogleFlutter36") == 0);
free(res2);
char* res3 = func0("**//Google Firebase// - 478. ");
assert(res3 != NULL);
assert(strcmp(res3, "GoogleFirebase478") == 0);
free(res3);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
callq 10a0 <strlen@plt>
lea 0x1(%rax),%rdi
mov %rax,%rbp
callq 10c0 <malloc@plt>
mov %rax,%r12
test %rax,%rax
je 13b6 <func0+0x66>
test %rbp,%rbp
je 13c0 <func0+0x70>
callq 10d0 <__ctype_b_loc@plt>
mov %rbx,%rdi
lea (%rbx,%rbp,1),%r9
xor %r8d,%r8d
mov (%rax),%r10
mov %r12,%rax
xchg %ax,%ax
movzbl (%rdi),%ecx
mov %rax,%rsi
testb $0x8,(%r10,%rcx,2)
je 13aa <func0+0x5a>
add $0x1,%r8
mov %cl,(%rax)
lea (%r12,%r8,1),%rax
mov %rax,%rsi
add $0x1,%rdi
cmp %rdi,%r9
jne 1390 <func0+0x40>
movb $0x0,(%rsi)
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
xchg %ax,%ax
mov %rax,%rsi
jmp 13b3 <func0+0x63>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
call _strlen
lea rdi, [rax+1]; size
mov rbp, rax
call _malloc
mov r12, rax
test rax, rax
jz short loc_13B1
test rbp, rbp
jz short loc_13C0
call ___ctype_b_loc
lea rdi, [rbx+rbp]
xor esi, esi
mov r8, [rax]
mov rax, rbx
nop word ptr [rax+rax+00h]
loc_1390:
movzx ecx, byte ptr [rax]
test byte ptr [r8+rcx*2], 8
jz short loc_13A2
mov [r12+rsi], cl
add rsi, 1
loc_13A2:
add rax, 1
cmp rdi, rax
jnz short loc_1390
add rsi, r12
loc_13AE:
mov byte ptr [rsi], 0
loc_13B1:
mov rax, r12
pop rbx
pop rbp
pop r12
retn
loc_13C0:
mov rsi, rax
jmp short loc_13AE | _BYTE * func0(const char *a1)
{
size_t v2; // rbp
_BYTE *v3; // rax
_BYTE *v4; // r12
unsigned __int8 *v5; // rdi
long long v6; // rsi
const unsigned __int16 *v7; // r8
const char *v8; // rax
long long v9; // rcx
_BYTE *v10; // rsi
v2 = strlen(a1);
v3 = malloc(v2 + 1);
v4 = v3;
if ( v3 )
{
if ( v2 )
{
v5 = (unsigned __int8 *)&a1[v2];
v6 = 0LL;
v7 = *__ctype_b_loc();
v8 = a1;
do
{
v9 = *(unsigned __int8 *)v8;
if ( (v7[v9] & 8) != 0 )
v4[v6++] = v9;
++v8;
}
while ( v5 != (unsigned __int8 *)v8 );
v10 = &v4[v6];
}
else
{
v10 = v3;
}
*v10 = 0;
}
return v4;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
CALL 0x001010b0
LEA RDI,[RAX + 0x1]
MOV RBP,RAX
CALL 0x001010e0
MOV R12,RAX
TEST RAX,RAX
JZ 0x001013b1
TEST RBP,RBP
JZ 0x001013c0
CALL 0x001010f0
LEA RDI,[RBX + RBP*0x1]
XOR ESI,ESI
MOV R8,qword ptr [RAX]
MOV RAX,RBX
NOP word ptr [RAX + RAX*0x1]
LAB_00101390:
MOVZX ECX,byte ptr [RAX]
TEST byte ptr [R8 + RCX*0x2],0x8
JZ 0x001013a2
MOV byte ptr [R12 + RSI*0x1],CL
ADD RSI,0x1
LAB_001013a2:
ADD RAX,0x1
CMP RDI,RAX
JNZ 0x00101390
ADD RSI,R12
LAB_001013ae:
MOV byte ptr [RSI],0x0
LAB_001013b1:
MOV RAX,R12
POP RBX
POP RBP
POP R12
RET
LAB_001013c0:
MOV RSI,RAX
JMP 0x001013ae | int * func0(byte *param_1)
{
byte *pbVar1;
ushort *puVar2;
size_t sVar3;
int *puVar4;
ushort **ppuVar5;
long lVar6;
int *puVar7;
sVar3 = strlen((char *)param_1);
puVar4 = (int *)malloc(sVar3 + 1);
if (puVar4 != (int *)0x0) {
puVar7 = puVar4;
if (sVar3 != 0) {
ppuVar5 = __ctype_b_loc();
pbVar1 = param_1 + sVar3;
lVar6 = 0;
puVar2 = *ppuVar5;
do {
if ((*(byte *)(puVar2 + *param_1) & 8) != 0) {
puVar4[lVar6] = *param_1;
lVar6 = lVar6 + 1;
}
param_1 = param_1 + 1;
} while (pbVar1 != param_1);
puVar7 = puVar4 + lVar6;
}
*puVar7 = 0;
}
return puVar4;
} |
6,600 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int a, int b, int c) {
int total = a + b + c;
if (total == 180) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(60, 50, 90) == false);
assert(func0(45, 75, 60) == true);
assert(func0(30, 50, 100) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x14(%rbp),%edx
mov -0x18(%rbp),%eax
add %eax,%edx
mov -0x1c(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
cmpl $0xb4,-0x4(%rbp)
jne 117a <func0+0x31>
mov $0x1,%eax
jmp 117f <func0+0x36>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov edx, [rbp+var_14]
mov eax, [rbp+var_18]
add edx, eax
mov eax, [rbp+var_1C]
add eax, edx
mov [rbp+var_4], eax
cmp [rbp+var_4], 0B4h
jnz short loc_117A
mov eax, 1
jmp short loc_117F
loc_117A:
mov eax, 0
loc_117F:
pop rbp
retn | _BOOL8 func0(int a1, int a2, int a3)
{
return a2 + a1 + a3 == 180;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x18]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0xb4
JNZ 0x0010117a
MOV EAX,0x1
JMP 0x0010117f
LAB_0010117a:
MOV EAX,0x0
LAB_0010117f:
POP RBP
RET | bool func0(int param_1,int param_2,int param_3)
{
return param_3 + param_1 + param_2 == 0xb4;
} |
6,601 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int a, int b, int c) {
int total = a + b + c;
if (total == 180) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(60, 50, 90) == false);
assert(func0(45, 75, 60) == true);
assert(func0(30, 50, 100) == true);
return 0;
}
| O1 | c | func0:
endbr64
add %esi,%edi
add %edx,%edi
cmp $0xb4,%edi
sete %al
retq
| func0:
endbr64
add edi, esi
add edi, edx
cmp edi, 0B4h
setz al
retn | bool func0(int a1, int a2, int a3)
{
return a3 + a2 + a1 == 180;
} | func0:
ENDBR64
ADD EDI,ESI
ADD EDI,EDX
CMP EDI,0xb4
SETZ AL
RET | bool func0(int param_1,int param_2,int param_3)
{
return param_1 + param_2 + param_3 == 0xb4;
} |
6,602 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int a, int b, int c) {
int total = a + b + c;
if (total == 180) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(60, 50, 90) == false);
assert(func0(45, 75, 60) == true);
assert(func0(30, 50, 100) == true);
return 0;
}
| O2 | c | func0:
endbr64
add %esi,%edi
add %edx,%edi
cmp $0xb4,%edi
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
add edi, esi
add edi, edx
cmp edi, 0B4h
setz al
retn | bool func0(int a1, int a2, int a3)
{
return a3 + a2 + a1 == 180;
} | func0:
ENDBR64
ADD EDI,ESI
ADD EDI,EDX
CMP EDI,0xb4
SETZ AL
RET | bool func0(int param_1,int param_2,int param_3)
{
return param_1 + param_2 + param_3 == 0xb4;
} |
6,603 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int a, int b, int c) {
int total = a + b + c;
if (total == 180) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(60, 50, 90) == false);
assert(func0(45, 75, 60) == true);
assert(func0(30, 50, 100) == true);
return 0;
}
| O3 | c | func0:
endbr64
add %esi,%edi
add %edx,%edi
cmp $0xb4,%edi
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
add edi, esi
add edi, edx
cmp edi, 0B4h
setz al
retn | bool func0(int a1, int a2, int a3)
{
return a3 + a2 + a1 == 180;
} | func0:
ENDBR64
ADD EDI,ESI
ADD EDI,EDX
CMP EDI,0xb4
SETZ AL
RET | bool func0(int param_1,int param_2,int param_3)
{
return param_1 + param_2 + param_3 == 0xb4;
} |
6,604 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* str1) {
int i, j = 0;
int len = strlen(str1);
for (i = 0; i < len; i++) {
if (str1[i] != ' ') {
str1[j++] = str1[i];
}
}
str1[j] = '\0';
return str1;
}
| int main() {
char str1[100] = "a b c";
char str2[100] = "1 2 3";
char str3[100] = " b c";
assert(strcmp(func0(str1), "abc") == 0);
assert(strcmp(func0(str2), "123") == 0);
assert(strcmp(func0(str3), "bc") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1216 <func0+0x6d>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
je 1212 <func0+0x69>
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x8(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x8(%rbp)
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
movzbl (%rcx),%eax
mov %al,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 11d8 <func0+0x2f>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x18(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+var_8], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_C], 0
jmp short loc_1216
loc_11D8:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jz short loc_1212
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+s]
lea rcx, [rdx+rax]
mov eax, [rbp+var_8]
lea edx, [rax+1]
mov [rbp+var_8], edx
movsxd rdx, eax
mov rax, [rbp+s]
add rdx, rax
movzx eax, byte ptr [rcx]
mov [rdx], al
loc_1212:
add [rbp+var_C], 1
loc_1216:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_4]
jl short loc_11D8
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+s]
leave
retn | const char * func0(const char *a1)
{
int v1; // eax
int i; // [rsp+14h] [rbp-Ch]
int v4; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v4 = 0;
v5 = strlen(a1);
for ( i = 0; i < v5; ++i )
{
if ( a1[i] != 32 )
{
v1 = v4++;
a1[v1] = a1[i];
}
}
a1[v4] = 0;
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x8],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101216
LAB_001011d8:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JZ 0x00101212
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x8],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOVZX EAX,byte ptr [RCX]
MOV byte ptr [RDX],AL
LAB_00101212:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101216:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x001011d8
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
LEAVE
RET | char * func0(char *param_1)
{
size_t sVar1;
int local_14;
int local_10;
local_10 = 0;
sVar1 = strlen(param_1);
for (local_14 = 0; local_14 < (int)sVar1; local_14 = local_14 + 1) {
if (param_1[local_14] != ' ') {
param_1[local_10] = param_1[local_14];
local_10 = local_10 + 1;
}
}
param_1[local_10] = '\0';
return param_1;
} |
6,605 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* str1) {
int i, j = 0;
int len = strlen(str1);
for (i = 0; i < len; i++) {
if (str1[i] != ' ') {
str1[j++] = str1[i];
}
}
str1[j] = '\0';
return str1;
}
| int main() {
char str1[100] = "a b c";
char str2[100] = "1 2 3";
char str3[100] = " b c";
assert(strcmp(func0(str1), "abc") == 0);
assert(strcmp(func0(str2), "123") == 0);
assert(strcmp(func0(str3), "bc") == 0);
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
test %ecx,%ecx
jle 11b7 <func0+0x4e>
mov %rsi,%rax
lea -0x1(%rcx),%edx
lea 0x1(%rsi,%rdx,1),%r8
mov $0x0,%ecx
jmp 11ad <func0+0x44>
movslq %ecx,%rdi
mov %dl,(%rsi,%rdi,1)
lea 0x1(%rcx),%ecx
add $0x1,%rax
cmp %r8,%rax
je 11bc <func0+0x53>
movzbl (%rax),%edx
cmp $0x20,%dl
jne 119b <func0+0x32>
jmp 11a4 <func0+0x3b>
mov $0x0,%ecx
movslq %ecx,%rcx
movb $0x0,(%rsi,%rcx,1)
mov %rsi,%rax
retq
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle short loc_11E7
mov rdx, rbx
lea eax, [rax-1]
lea rdi, [rbx+rax+1]
mov ecx, 0
jmp short loc_11D5
loc_11CC:
add rdx, 1
cmp rdx, rdi
jz short loc_11EC
loc_11D5:
movzx eax, byte ptr [rdx]
cmp al, 20h ; ' '
jz short loc_11CC
movsxd rsi, ecx
mov [rbx+rsi], al
lea ecx, [rcx+1]
jmp short loc_11CC
loc_11E7:
mov ecx, 0
loc_11EC:
movsxd rcx, ecx
mov byte ptr [rbx+rcx], 0
mov rax, rbx
pop rbx
retn | _BYTE * func0(_BYTE *a1)
{
int v2; // eax
_BYTE *v3; // rdx
long long v4; // rdi
int v5; // ecx
v2 = strlen();
if ( v2 <= 0 )
{
v5 = 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[v2 - 1 + 1];
v5 = 0;
do
{
if ( *v3 != 32 )
a1[v5++] = *v3;
++v3;
}
while ( v3 != (_BYTE *)v4 );
}
a1[v5] = 0;
return a1;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101080
TEST EAX,EAX
JLE 0x001011e7
MOV RDX,RBX
LEA EAX,[RAX + -0x1]
LEA RDI,[RBX + RAX*0x1 + 0x1]
MOV ECX,0x0
JMP 0x001011d5
LAB_001011cc:
ADD RDX,0x1
CMP RDX,RDI
JZ 0x001011ec
LAB_001011d5:
MOVZX EAX,byte ptr [RDX]
CMP AL,0x20
JZ 0x001011cc
MOVSXD RSI,ECX
MOV byte ptr [RBX + RSI*0x1],AL
LEA ECX,[RCX + 0x1]
JMP 0x001011cc
LAB_001011e7:
MOV ECX,0x0
LAB_001011ec:
MOVSXD RCX,ECX
MOV byte ptr [RBX + RCX*0x1],0x0
MOV RAX,RBX
POP RBX
RET | char * func0(char *param_1)
{
size_t sVar1;
int iVar2;
char *pcVar3;
sVar1 = strlen(param_1);
if ((int)sVar1 < 1) {
iVar2 = 0;
}
else {
iVar2 = 0;
pcVar3 = param_1;
do {
if (*pcVar3 != ' ') {
param_1[iVar2] = *pcVar3;
iVar2 = iVar2 + 1;
}
pcVar3 = pcVar3 + 1;
} while (pcVar3 != param_1 + (ulong)((int)sVar1 - 1) + 1);
}
param_1[iVar2] = '\0';
return param_1;
} |
6,606 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* str1) {
int i, j = 0;
int len = strlen(str1);
for (i = 0; i < len; i++) {
if (str1[i] != ' ') {
str1[j++] = str1[i];
}
}
str1[j] = '\0';
return str1;
}
| int main() {
char str1[100] = "a b c";
char str2[100] = "1 2 3";
char str3[100] = " b c";
assert(strcmp(func0(str1), "abc") == 0);
assert(strcmp(func0(str2), "123") == 0);
assert(strcmp(func0(str3), "bc") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %rdi,%r12
callq 1070 <strlen@plt>
test %eax,%eax
jle 13c8 <func0+0x58>
sub $0x1,%eax
mov %r12,%rdx
xor %edi,%edi
xor %esi,%esi
lea 0x1(%r12,%rax,1),%r8
nopl 0x0(%rax)
movzbl (%rdx),%eax
lea (%r12,%rsi,1),%rcx
cmp $0x20,%al
je 13af <func0+0x3f>
add $0x1,%edi
mov %al,(%rcx)
movslq %edi,%rsi
lea (%r12,%rsi,1),%rcx
add $0x1,%rdx
cmp %r8,%rdx
jne 1398 <func0+0x28>
mov %r12,%rax
movb $0x0,(%rcx)
pop %r12
retq
nopl 0x0(%rax)
mov %r12,%rcx
mov %r12,%rax
movb $0x0,(%rcx)
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r12
mov r12, rdi
call _strlen
test eax, eax
jle short loc_13D0
sub eax, 1
mov rdx, r12
lea rdi, [r12+rax+1]
xor eax, eax
nop
loc_13A0:
movzx ecx, byte ptr [rdx]
cmp cl, 20h ; ' '
jz short loc_13B2
movsxd rsi, eax
add eax, 1
mov [r12+rsi], cl
loc_13B2:
add rdx, 1
cmp rdi, rdx
jnz short loc_13A0
cdqe
add rax, r12
mov byte ptr [rax], 0
mov rax, r12
pop r12
retn
loc_13D0:
mov rax, r12
mov byte ptr [rax], 0
mov rax, r12
pop r12
retn | _BYTE * func0(_BYTE *a1)
{
int v2; // eax
_BYTE *v3; // rdx
long long v4; // rdi
int v5; // eax
long long v6; // rsi
v2 = strlen();
if ( v2 <= 0 )
{
*a1 = 0;
return a1;
}
else
{
v3 = a1;
v4 = (long long)&a1[v2 - 1 + 1];
v5 = 0;
do
{
if ( *v3 != 32 )
{
v6 = v5++;
a1[v6] = *v3;
}
++v3;
}
while ( (_BYTE *)v4 != v3 );
a1[v5] = 0;
return a1;
}
} | func0:
ENDBR64
PUSH R12
MOV R12,RDI
CALL 0x00101080
TEST EAX,EAX
JLE 0x001013d0
SUB EAX,0x1
MOV RDX,R12
LEA RDI,[R12 + RAX*0x1 + 0x1]
XOR EAX,EAX
NOP
LAB_001013a0:
MOVZX ECX,byte ptr [RDX]
CMP CL,0x20
JZ 0x001013b2
MOVSXD RSI,EAX
ADD EAX,0x1
MOV byte ptr [R12 + RSI*0x1],CL
LAB_001013b2:
ADD RDX,0x1
CMP RDI,RDX
JNZ 0x001013a0
CDQE
ADD RAX,R12
MOV byte ptr [RAX],0x0
MOV RAX,R12
POP R12
RET
LAB_001013d0:
MOV RAX,R12
MOV byte ptr [RAX],0x0
MOV RAX,R12
POP R12
RET | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
sVar2 = strlen(param_1);
if (0 < (int)sVar2) {
iVar1 = 0;
pcVar3 = param_1;
do {
if (*pcVar3 != ' ') {
lVar4 = (long)iVar1;
iVar1 = iVar1 + 1;
param_1[lVar4] = *pcVar3;
}
pcVar3 = pcVar3 + 1;
} while (param_1 + (ulong)((int)sVar2 - 1) + 1 != pcVar3);
param_1[iVar1] = '\0';
return param_1;
}
*param_1 = '\0';
return param_1;
} |
6,607 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* str1) {
int i, j = 0;
int len = strlen(str1);
for (i = 0; i < len; i++) {
if (str1[i] != ' ') {
str1[j++] = str1[i];
}
}
str1[j] = '\0';
return str1;
}
| int main() {
char str1[100] = "a b c";
char str2[100] = "1 2 3";
char str3[100] = " b c";
assert(strcmp(func0(str1), "abc") == 0);
assert(strcmp(func0(str2), "123") == 0);
assert(strcmp(func0(str3), "bc") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %rdi,%r12
callq 1070 <strlen@plt>
test %eax,%eax
jle 13c8 <func0+0x58>
sub $0x1,%eax
mov %r12,%rdx
xor %edi,%edi
xor %esi,%esi
lea 0x1(%r12,%rax,1),%r8
nopl 0x0(%rax)
movzbl (%rdx),%eax
lea (%r12,%rsi,1),%rcx
cmp $0x20,%al
je 13af <func0+0x3f>
add $0x1,%edi
mov %al,(%rcx)
movslq %edi,%rsi
lea (%r12,%rsi,1),%rcx
add $0x1,%rdx
cmp %rdx,%r8
jne 1398 <func0+0x28>
mov %r12,%rax
movb $0x0,(%rcx)
pop %r12
retq
nopl 0x0(%rax)
mov %r12,%rcx
mov %r12,%rax
movb $0x0,(%rcx)
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
test eax, eax
jle short loc_13D0
sub eax, 1
mov rdx, rbx
lea rdi, [rbx+rax+1]
xor eax, eax
xchg ax, ax
loc_13A0:
movzx ecx, byte ptr [rdx]
cmp cl, 20h ; ' '
jz short loc_13B1
movsxd rsi, eax
add eax, 1
mov [rbx+rsi], cl
loc_13B1:
add rdx, 1
cmp rdi, rdx
jnz short loc_13A0
cdqe
add rax, rbx
mov byte ptr [rax], 0
mov rax, rbx
pop rbx
retn
loc_13D0:
mov rax, rbx
mov byte ptr [rax], 0
mov rax, rbx
pop rbx
retn | const char * func0(const char *a1)
{
int v2; // eax
const char *v3; // rdx
long long v4; // rdi
int v5; // eax
long long v6; // rsi
v2 = strlen(a1);
if ( v2 <= 0 )
{
*a1 = 0;
return a1;
}
else
{
v3 = a1;
v4 = (long long)&a1[v2 - 1 + 1];
v5 = 0;
do
{
if ( *v3 != 32 )
{
v6 = v5++;
a1[v6] = *v3;
}
++v3;
}
while ( (const char *)v4 != v3 );
a1[v5] = 0;
return a1;
}
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101080
TEST EAX,EAX
JLE 0x001013d0
SUB EAX,0x1
MOV RDX,RBX
LEA RDI,[RBX + RAX*0x1 + 0x1]
XOR EAX,EAX
NOP
LAB_001013a0:
MOVZX ECX,byte ptr [RDX]
CMP CL,0x20
JZ 0x001013b1
MOVSXD RSI,EAX
ADD EAX,0x1
MOV byte ptr [RBX + RSI*0x1],CL
LAB_001013b1:
ADD RDX,0x1
CMP RDI,RDX
JNZ 0x001013a0
CDQE
ADD RAX,RBX
MOV byte ptr [RAX],0x0
MOV RAX,RBX
POP RBX
RET
LAB_001013d0:
MOV RAX,RBX
MOV byte ptr [RAX],0x0
MOV RAX,RBX
POP RBX
RET | char * func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
sVar2 = strlen(param_1);
if (0 < (int)sVar2) {
iVar1 = 0;
pcVar3 = param_1;
do {
if (*pcVar3 != ' ') {
lVar4 = (long)iVar1;
iVar1 = iVar1 + 1;
param_1[lVar4] = *pcVar3;
}
pcVar3 = pcVar3 + 1;
} while (param_1 + (ulong)((int)sVar2 - 1) + 1 != pcVar3);
param_1[iVar1] = '\0';
return param_1;
}
*param_1 = '\0';
return param_1;
} |
6,608 | func0 |
#include <assert.h>
#include <stdlib.h>
#include <string.h>
| char* func0(char** keys, int index) {
return keys[index];
}
| int main() {
char* keys1[] = {"physics", "math", "chemistry"};
assert(strcmp(func0(keys1, 0), "physics") == 0);
char* keys2[] = {"python", "java", "C++"};
assert(strcmp(func0(keys2, 2), "C++") == 0);
char* keys3[] = {"program", "computer"};
assert(strcmp(func0(keys3, 1), "computer") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rax, rdx
mov rax, [rax]
pop rbp
retn | long long func0(long long a1, int a2)
{
return *(_QWORD *)(8LL * a2 + a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
POP RBP
RET | int8 func0(long param_1,int param_2)
{
return *(int8 *)(param_1 + (long)param_2 * 8);
} |
6,609 | func0 |
#include <assert.h>
#include <stdlib.h>
#include <string.h>
| char* func0(char** keys, int index) {
return keys[index];
}
| int main() {
char* keys1[] = {"physics", "math", "chemistry"};
assert(strcmp(func0(keys1, 0), "physics") == 0);
char* keys2[] = {"python", "java", "C++"};
assert(strcmp(func0(keys2, 2), "C++") == 0);
char* keys3[] = {"program", "computer"};
assert(strcmp(func0(keys3, 1), "computer") == 0);
return 0;
}
| O1 | c | func0:
endbr64
movslq %esi,%rsi
mov (%rdi,%rsi,8),%rax
retq
| func0:
endbr64
movsxd rsi, esi
mov rax, [rdi+rsi*8]
retn | long long func0(long long a1, int a2)
{
return *(_QWORD *)(a1 + 8LL * a2);
} | func0:
ENDBR64
MOVSXD RSI,ESI
MOV RAX,qword ptr [RDI + RSI*0x8]
RET | int8 func0(long param_1,int param_2)
{
return *(int8 *)(param_1 + (long)param_2 * 8);
} |
6,610 | func0 |
#include <assert.h>
#include <stdlib.h>
#include <string.h>
| char* func0(char** keys, int index) {
return keys[index];
}
| int main() {
char* keys1[] = {"physics", "math", "chemistry"};
assert(strcmp(func0(keys1, 0), "physics") == 0);
char* keys2[] = {"python", "java", "C++"};
assert(strcmp(func0(keys2, 2), "C++") == 0);
char* keys3[] = {"program", "computer"};
assert(strcmp(func0(keys3, 1), "computer") == 0);
return 0;
}
| O2 | c | func0:
endbr64
movslq %esi,%rsi
mov (%rdi,%rsi,8),%rax
retq
nopl 0x0(%rax)
| func0:
endbr64
movsxd rsi, esi
mov rax, [rdi+rsi*8]
retn | long long func0(long long a1, int a2)
{
return *(_QWORD *)(a1 + 8LL * a2);
} | func0:
ENDBR64
MOVSXD RSI,ESI
MOV RAX,qword ptr [RDI + RSI*0x8]
RET | int8 func0(long param_1,int param_2)
{
return *(int8 *)(param_1 + (long)param_2 * 8);
} |
6,611 | func0 |
#include <assert.h>
#include <stdlib.h>
#include <string.h>
| char* func0(char** keys, int index) {
return keys[index];
}
| int main() {
char* keys1[] = {"physics", "math", "chemistry"};
assert(strcmp(func0(keys1, 0), "physics") == 0);
char* keys2[] = {"python", "java", "C++"};
assert(strcmp(func0(keys2, 2), "C++") == 0);
char* keys3[] = {"program", "computer"};
assert(strcmp(func0(keys3, 1), "computer") == 0);
return 0;
}
| O3 | c | func0:
endbr64
movslq %esi,%rsi
mov (%rdi,%rsi,8),%rax
retq
nopl 0x0(%rax)
| func0:
endbr64
movsxd rsi, esi
mov rax, [rdi+rsi*8]
retn | long long func0(long long a1, int a2)
{
return *(_QWORD *)(a1 + 8LL * a2);
} | func0:
ENDBR64
MOVSXD RSI,ESI
MOV RAX,qword ptr [RDI + RSI*0x8]
RET | int8 func0(long param_1,int param_2)
{
return *(int8 *)(param_1 + (long)param_2 * 8);
} |
6,612 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int nums[], int size) {
for (int i = 0; i < size - 1; i++) {
if (nums[i] > nums[i + 1]) {
return false;
}
}
return true;
}
| int main() {
int array1[] = {1, 2, 3, 4};
int array2[] = {4, 3, 2, 1};
int array3[] = {0, 1, 4, 9};
assert(func0(array1, 4) == true);
assert(func0(array2, 4) == false);
assert(func0(array3, 4) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c0 <func0+0x57>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 11bc <func0+0x53>
mov $0x0,%eax
jmp 11d0 <func0+0x67>
addl $0x1,-0x4(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x4(%rbp)
jl 1181 <func0+0x18>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_11C0
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_11BC
mov eax, 0
jmp short loc_11D0
loc_11BC:
add [rbp+var_4], 1
loc_11C0:
mov eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_4], eax
jl short loc_1181
mov eax, 1
loc_11D0:
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2 - 1; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) > *(_DWORD *)(4 * (i + 1LL) + a1) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c0
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x001011bc
MOV EAX,0x0
JMP 0x001011d0
LAB_001011bc:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c0:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JL 0x00101181
MOV EAX,0x1
LAB_001011d0:
POP RBP
RET | int8 func0(long param_1,int param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 + -1 <= local_c) {
return 1;
}
if (*(int *)(param_1 + ((long)local_c + 1) * 4) < *(int *)(param_1 + (long)local_c * 4)) break;
local_c = local_c + 1;
}
return 0;
} |
6,613 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int nums[], int size) {
for (int i = 0; i < size - 1; i++) {
if (nums[i] > nums[i + 1]) {
return false;
}
}
return true;
}
| int main() {
int array1[] = {1, 2, 3, 4};
int array2[] = {4, 3, 2, 1};
int array3[] = {0, 1, 4, 9};
assert(func0(array1, 4) == true);
assert(func0(array2, 4) == false);
assert(func0(array3, 4) == true);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 1193 <func0+0x2a>
mov %rdi,%rax
lea -0x2(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdx
mov 0x4(%rax),%ecx
cmp %ecx,(%rax)
jg 1199 <func0+0x30>
add $0x4,%rax
cmp %rdx,%rax
jne 117d <func0+0x14>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
cmp esi, 1
jle short loc_1193
mov rax, rdi
lea edx, [rsi-2]
lea rdx, [rdi+rdx*4+4]
loc_117D:
mov ecx, [rax+4]
cmp [rax], ecx
jg short loc_1199
add rax, 4
cmp rax, rdx
jnz short loc_117D
mov eax, 1
retn
loc_1193:
mov eax, 1
retn
loc_1199:
mov eax, 0
retn | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
if ( a2 <= 1 )
return 1LL;
v2 = a1;
while ( *v2 <= v2[1] )
{
if ( ++v2 == &a1[a2 - 2 + 1] )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101193
MOV RAX,RDI
LEA EDX,[RSI + -0x2]
LEA RDX,[RDI + RDX*0x4 + 0x4]
LAB_0010117d:
MOV ECX,dword ptr [RAX + 0x4]
CMP dword ptr [RAX],ECX
JG 0x00101199
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x0010117d
MOV EAX,0x1
RET
LAB_00101193:
MOV EAX,0x1
RET
LAB_00101199:
MOV EAX,0x0
RET | int8 func0(int *param_1,int param_2)
{
int *piVar1;
if (param_2 < 2) {
return 1;
}
piVar1 = param_1 + (ulong)(param_2 - 2) + 1;
do {
if (param_1[1] < *param_1) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return 1;
} |
6,614 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int nums[], int size) {
for (int i = 0; i < size - 1; i++) {
if (nums[i] > nums[i + 1]) {
return false;
}
}
return true;
}
| int main() {
int array1[] = {1, 2, 3, 4};
int array2[] = {4, 3, 2, 1};
int array3[] = {0, 1, 4, 9};
assert(func0(array1, 4) == true);
assert(func0(array2, 4) == false);
assert(func0(array3, 4) == true);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 1170 <func0+0x30>
lea -0x2(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1161 <func0+0x21>
nopl 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1170 <func0+0x30>
mov 0x4(%rdi),%edx
cmp %edx,(%rdi)
jle 1158 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
cmp esi, 1
jle short loc_12C0
lea eax, [rsi-2]
lea rax, [rdi+rax*4+4]
jmp short loc_12B1
loc_12A8:
add rdi, 4
cmp rdi, rax
jz short loc_12C0
loc_12B1:
mov edx, [rdi+4]
cmp [rdi], edx
jle short loc_12A8
xor eax, eax
retn
loc_12C0:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rax
if ( a2 <= 1 )
return 1LL;
v2 = (long long)&a1[a2 - 2 + 1];
while ( *a1 <= a1[1] )
{
if ( ++a1 == (_DWORD *)v2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001012c0
LEA EAX,[RSI + -0x2]
LEA RAX,[RDI + RAX*0x4 + 0x4]
JMP 0x001012b1
LAB_001012a8:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x001012c0
LAB_001012b1:
MOV EDX,dword ptr [RDI + 0x4]
CMP dword ptr [RDI],EDX
JLE 0x001012a8
XOR EAX,EAX
RET
LAB_001012c0:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2)
{
int *piVar1;
if (1 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 2) + 1;
do {
if (param_1[1] < *param_1) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 1;
} |
6,615 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int nums[], int size) {
for (int i = 0; i < size - 1; i++) {
if (nums[i] > nums[i + 1]) {
return false;
}
}
return true;
}
| int main() {
int array1[] = {1, 2, 3, 4};
int array2[] = {4, 3, 2, 1};
int array3[] = {0, 1, 4, 9};
assert(func0(array1, 4) == true);
assert(func0(array2, 4) == false);
assert(func0(array3, 4) == true);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 1178 <func0+0x38>
lea -0x2(%rsi),%ecx
mov (%rdi),%edx
lea 0x4(%rdi),%rax
lea 0x8(%rdi,%rcx,4),%rsi
jmp 1169 <func0+0x29>
nopl 0x0(%rax)
add $0x4,%rax
cmp %rsi,%rax
je 1178 <func0+0x38>
mov %edx,%ecx
mov (%rax),%edx
cmp %ecx,%edx
jge 1160 <func0+0x20>
xor %eax,%eax
retq
nopl 0x0(%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
cmp esi, 1
jle short loc_1178
lea ecx, [rsi-2]
mov edx, [rdi]
lea rax, [rdi+4]
lea rsi, [rdi+rcx*4+8]
jmp short loc_1169
loc_1160:
add rax, 4
cmp rax, rsi
jz short loc_1178
loc_1169:
mov ecx, edx
mov edx, [rax]
cmp edx, ecx
jge short loc_1160
xor eax, eax
retn
loc_1178:
mov eax, 1
retn | long long func0(int *a1, int a2)
{
int v2; // edx
int *v3; // rax
long long v4; // rsi
int v5; // ecx
if ( a2 <= 1 )
return 1LL;
v2 = *a1;
v3 = a1 + 1;
v4 = (long long)&a1[a2 - 2 + 2];
while ( 1 )
{
v5 = v2;
v2 = *v3;
if ( *v3 < v5 )
break;
if ( ++v3 == (int *)v4 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101178
LEA ECX,[RSI + -0x2]
MOV EDX,dword ptr [RDI]
LEA RAX,[RDI + 0x4]
LEA RSI,[RDI + RCX*0x4 + 0x8]
JMP 0x00101169
LAB_00101160:
ADD RAX,0x4
CMP RAX,RSI
JZ 0x00101178
LAB_00101169:
MOV ECX,EDX
MOV EDX,dword ptr [RAX]
CMP EDX,ECX
JGE 0x00101160
XOR EAX,EAX
RET
LAB_00101178:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
if (1 < param_2) {
piVar2 = param_1 + 1;
iVar3 = *param_1;
do {
iVar1 = *piVar2;
if (iVar1 < iVar3) {
return 0;
}
piVar2 = piVar2 + 1;
iVar3 = iVar1;
} while (piVar2 != param_1 + (ulong)(param_2 - 2) + 2);
}
return 1;
} |
6,616 | func0 |
#include <assert.h>
| int func0(int n) {
if (n % 2 == 0) {
return 2;
}
int i = 3;
while (i * i <= n) {
if (n % i == 0) {
return i;
}
i += 2;
}
return n;
}
| int main() {
assert(func0(10) == 2);
assert(func0(25) == 5);
assert(func0(31) == 31);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 1165 <func0+0x1c>
mov $0x2,%eax
jmp 1192 <func0+0x49>
movl $0x3,-0x4(%rbp)
jmp 1184 <func0+0x3b>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1180 <func0+0x37>
mov -0x4(%rbp),%eax
jmp 1192 <func0+0x49>
addl $0x2,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jge 116e <func0+0x25>
mov -0x14(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
and eax, 1
test eax, eax
jnz short loc_1165
mov eax, 2
jmp short loc_1192
loc_1165:
mov [rbp+var_4], 3
jmp short loc_1184
loc_116E:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1180
mov eax, [rbp+var_4]
jmp short loc_1192
loc_1180:
add [rbp+var_4], 2
loc_1184:
mov eax, [rbp+var_4]
imul eax, eax
cmp [rbp+var_14], eax
jge short loc_116E
mov eax, [rbp+var_14]
loc_1192:
pop rbp
retn | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
if ( (a1 & 1) == 0 )
return 2LL;
for ( i = 3; a1 >= i * i; i += 2 )
{
if ( !(a1 % i) )
return (unsigned int)i;
}
return (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101165
MOV EAX,0x2
JMP 0x00101192
LAB_00101165:
MOV dword ptr [RBP + -0x4],0x3
JMP 0x00101184
LAB_0010116e:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101180
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x00101192
LAB_00101180:
ADD dword ptr [RBP + -0x4],0x2
LAB_00101184:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JGE 0x0010116e
MOV EAX,dword ptr [RBP + -0x14]
LAB_00101192:
POP RBP
RET | uint func0(uint param_1)
{
uint uVar1;
uint local_c;
if ((param_1 & 1) == 0) {
uVar1 = 2;
}
else {
for (local_c = 3;
(uVar1 = param_1, (int)(local_c * local_c) <= (int)param_1 &&
(uVar1 = local_c, (int)param_1 % (int)local_c != 0)); local_c = local_c + 2) {
}
}
return uVar1;
} |
6,617 | func0 |
#include <assert.h>
| int func0(int n) {
if (n % 2 == 0) {
return 2;
}
int i = 3;
while (i * i <= n) {
if (n % i == 0) {
return i;
}
i += 2;
}
return n;
}
| int main() {
assert(func0(10) == 2);
assert(func0(25) == 5);
assert(func0(31) == 31);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x2,%ecx
test $0x1,%dil
je 1197 <func0+0x4e>
cmp $0x8,%edi
jle 119a <func0+0x51>
movslq %edi,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,2),%eax
cmp %eax,%edi
je 119e <func0+0x55>
mov $0x3,%ecx
add $0x2,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg 1195 <func0+0x4c>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 117e <func0+0x35>
jmp 1197 <func0+0x4e>
mov %edi,%ecx
mov %ecx,%eax
retq
mov %edi,%ecx
jmp 1197 <func0+0x4e>
mov $0x3,%ecx
jmp 1197 <func0+0x4e>
| func0:
endbr64
mov ecx, 2
test dil, 1
jz short loc_1197
cmp edi, 8
jle short loc_119A
movsxd rax, edi
imul rax, 55555556h
shr rax, 20h
mov edx, edi
sar edx, 1Fh
sub eax, edx
lea eax, [rax+rax*2]
cmp edi, eax
jz short loc_119E
mov ecx, 3
loc_117E:
add ecx, 2
mov eax, ecx
imul eax, ecx
cmp eax, edi
jg short loc_1195
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_117E
jmp short loc_1197
loc_1195:
mov ecx, edi
loc_1197:
mov eax, ecx
retn
loc_119A:
mov ecx, edi
jmp short loc_1197
loc_119E:
mov ecx, 3
jmp short loc_1197 | long long func0(int a1)
{
unsigned int v1; // ecx
v1 = 2;
if ( (a1 & 1) != 0 )
{
if ( a1 <= 8 )
{
return (unsigned int)a1;
}
else if ( a1 == 3 * (a1 / 3) )
{
return 3;
}
else
{
v1 = 3;
while ( 1 )
{
v1 += 2;
if ( (int)(v1 * v1) > a1 )
break;
if ( !(a1 % (int)v1) )
return v1;
}
return (unsigned int)a1;
}
}
return v1;
} | func0:
ENDBR64
MOV ECX,0x2
TEST DIL,0x1
JZ 0x00101197
CMP EDI,0x8
JLE 0x0010119a
MOVSXD RAX,EDI
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV EDX,EDI
SAR EDX,0x1f
SUB EAX,EDX
LEA EAX,[RAX + RAX*0x2]
CMP EDI,EAX
JZ 0x0010119e
MOV ECX,0x3
LAB_0010117e:
ADD ECX,0x2
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x00101195
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010117e
JMP 0x00101197
LAB_00101195:
MOV ECX,EDI
LAB_00101197:
MOV EAX,ECX
RET
LAB_0010119a:
MOV ECX,EDI
JMP 0x00101197
LAB_0010119e:
MOV ECX,0x3
JMP 0x00101197 | uint func0(uint param_1)
{
uint uVar1;
uVar1 = 2;
if (((param_1 & 1) != 0) && (uVar1 = param_1, 8 < (int)param_1)) {
if (param_1 == ((int)param_1 / 3) * 3) {
uVar1 = 3;
}
else {
uVar1 = 3;
do {
uVar1 = uVar1 + 2;
if ((int)param_1 < (int)(uVar1 * uVar1)) {
return param_1;
}
} while ((int)param_1 % (int)uVar1 != 0);
}
}
return uVar1;
} |
6,618 | func0 |
#include <assert.h>
| int func0(int n) {
if (n % 2 == 0) {
return 2;
}
int i = 3;
while (i * i <= n) {
if (n % i == 0) {
return i;
}
i += 2;
}
return n;
}
| int main() {
assert(func0(10) == 2);
assert(func0(25) == 5);
assert(func0(31) == 31);
return 0;
}
| O2 | c | func0:
endbr64
test $0x1,%dil
je 1230 <func0+0x10>
jmp 11c0 <func0.part.0>
nopl 0x0(%rax)
mov $0x2,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov r8d, 2
test dil, 1
jz short loc_118C
cmp edi, 8
jle short loc_1189
imul eax, edi, 0AAAAAAABh
mov r8d, 3
add eax, 2AAAAAAAh
cmp eax, 55555554h
ja short loc_117A
jmp short loc_118C
loc_1170:
mov eax, edi
cdq
idiv r8d
test edx, edx
jz short loc_118C
loc_117A:
add r8d, 2
mov eax, r8d
imul eax, r8d
cmp edi, eax
jge short loc_1170
loc_1189:
mov r8d, edi
loc_118C:
mov eax, r8d
retn | long long func0(int a1)
{
unsigned int v1; // r8d
v1 = 2;
if ( (a1 & 1) != 0 )
{
if ( a1 > 8 )
{
v1 = 3;
if ( (unsigned int)(-1431655765 * a1 + 715827882) <= 0x55555554 )
return v1;
while ( 1 )
{
v1 += 2;
if ( a1 < (int)(v1 * v1) )
break;
if ( !(a1 % (int)v1) )
return v1;
}
}
return (unsigned int)a1;
}
return v1;
} | func0:
ENDBR64
MOV R8D,0x2
TEST DIL,0x1
JZ 0x0010118c
CMP EDI,0x8
JLE 0x00101189
IMUL EAX,EDI,-0x55555555
MOV R8D,0x3
ADD EAX,0x2aaaaaaa
CMP EAX,0x55555554
JA 0x0010117a
JMP 0x0010118c
LAB_00101170:
MOV EAX,EDI
CDQ
IDIV R8D
TEST EDX,EDX
JZ 0x0010118c
LAB_0010117a:
ADD R8D,0x2
MOV EAX,R8D
IMUL EAX,R8D
CMP EDI,EAX
JGE 0x00101170
LAB_00101189:
MOV R8D,EDI
LAB_0010118c:
MOV EAX,R8D
RET | uint func0(uint param_1)
{
uint uVar1;
uVar1 = 2;
if ((((param_1 & 1) != 0) && (uVar1 = param_1, 8 < (int)param_1)) &&
(uVar1 = 3, 0x55555554 < param_1 * -0x55555555 + 0x2aaaaaaa)) {
do {
uVar1 = uVar1 + 2;
if ((int)param_1 < (int)(uVar1 * uVar1)) {
return param_1;
}
} while ((int)param_1 % (int)uVar1 != 0);
}
return uVar1;
} |
6,619 | func0 |
#include <assert.h>
| int func0(int n) {
if (n % 2 == 0) {
return 2;
}
int i = 3;
while (i * i <= n) {
if (n % i == 0) {
return i;
}
i += 2;
}
return n;
}
| int main() {
assert(func0(10) == 2);
assert(func0(25) == 5);
assert(func0(31) == 31);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x2,%r8d
test $0x1,%dil
je 118c <func0+0x4c>
cmp $0x8,%edi
jle 1189 <func0+0x49>
imul $0xaaaaaaab,%edi,%eax
mov $0x3,%r8d
add $0x2aaaaaaa,%eax
cmp $0x55555554,%eax
ja 117a <func0+0x3a>
jmp 118c <func0+0x4c>
mov %edi,%eax
cltd
idiv %r8d
test %edx,%edx
je 118c <func0+0x4c>
add $0x2,%r8d
mov %r8d,%eax
imul %r8d,%eax
cmp %eax,%edi
jge 1170 <func0+0x30>
mov %edi,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
mov ecx, 2
test dil, 1
jz short loc_1187
cmp edi, 8
jle short loc_1185
imul eax, edi, 0AAAAAAABh
mov ecx, 3
add eax, 2AAAAAAAh
cmp eax, 55555554h
ja short loc_1179
jmp short loc_1187
loc_1170:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1187
loc_1179:
add ecx, 2
mov eax, ecx
imul eax, ecx
cmp edi, eax
jge short loc_1170
loc_1185:
mov ecx, edi
loc_1187:
mov eax, ecx
retn | long long func0(int a1)
{
unsigned int v1; // ecx
v1 = 2;
if ( (a1 & 1) != 0 )
{
if ( a1 > 8 )
{
v1 = 3;
if ( (unsigned int)(-1431655765 * a1 + 715827882) <= 0x55555554 )
return v1;
while ( 1 )
{
v1 += 2;
if ( a1 < (int)(v1 * v1) )
break;
if ( !(a1 % (int)v1) )
return v1;
}
}
return (unsigned int)a1;
}
return v1;
} | func0:
ENDBR64
MOV ECX,0x2
TEST DIL,0x1
JZ 0x00101187
CMP EDI,0x8
JLE 0x00101185
IMUL EAX,EDI,-0x55555555
MOV ECX,0x3
ADD EAX,0x2aaaaaaa
CMP EAX,0x55555554
JA 0x00101179
JMP 0x00101187
LAB_00101170:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101187
LAB_00101179:
ADD ECX,0x2
MOV EAX,ECX
IMUL EAX,ECX
CMP EDI,EAX
JGE 0x00101170
LAB_00101185:
MOV ECX,EDI
LAB_00101187:
MOV EAX,ECX
RET | uint func0(uint param_1)
{
uint uVar1;
uVar1 = 2;
if ((((param_1 & 1) != 0) && (uVar1 = param_1, 8 < (int)param_1)) &&
(uVar1 = 3, 0x55555554 < param_1 * -0x55555555 + 0x2aaaaaaa)) {
do {
uVar1 = uVar1 + 2;
if ((int)param_1 < (int)(uVar1 * uVar1)) {
return param_1;
}
} while ((int)param_1 % (int)uVar1 != 0);
}
return uVar1;
} |
6,620 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* nums1, int* nums2, int n, int* result) {
for (int i = 0; i < n; i++) {
result[i] = nums1[i] * nums2[i];
}
return result;
}
| int main() {
int result1[3], result2[2], result3[2];
int nums1a[] = {1, 2, 3};
int nums2a[] = {4, 5, 6};
int nums1b[] = {1, 2};
int nums2b[] = {3, 4};
int nums1c[] = {90, 120};
int nums2c[] = {50, 70};
func0(nums1a, nums2a, 3, result1);
func0(nums1b, nums2b, 2, result2);
func0(nums1c, nums2c, 2, result3);
assert(result1[0] == 4 && result1[1] == 10 && result1[2] == 18);
assert(result2[0] == 3 && result2[1] == 8);
assert(result3[0] == 4500 && result3[1] == 8400);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %rcx,-0x30(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d3 <func0+0x6a>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rsi
mov -0x30(%rbp),%rdx
add %rsi,%rdx
imul %ecx,%eax
mov %eax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 1189 <func0+0x20>
mov -0x30(%rbp),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_30], rcx
mov [rbp+var_4], 0
jmp short loc_11D3
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rcx
mov eax, [rax]
mov ecx, [rbp+var_4]
movsxd rcx, ecx
lea rsi, ds:0[rcx*4]
mov rcx, [rbp+var_30]
add rcx, rsi
imul eax, edx
mov [rcx], eax
add [rbp+var_4], 1
loc_11D3:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_24]
jl short loc_1189
mov rax, [rbp+var_30]
pop rbp
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; i < a3; ++i )
*(_DWORD *)(4LL * i + a4) = *(_DWORD *)(4LL * i + a1) * *(_DWORD *)(4LL * i + a2);
return a4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d3
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RCX,ECX
LEA RSI,[RCX*0x4]
MOV RCX,qword ptr [RBP + -0x30]
ADD RCX,RSI
IMUL EAX,EDX
MOV dword ptr [RCX],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d3:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00101189
MOV RAX,qword ptr [RBP + -0x30]
POP RBP
RET | long func0(long param_1,long param_2,int param_3,long param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
*(int *)(param_4 + (long)local_c * 4) =
*(int *)(param_2 + (long)local_c * 4) * *(int *)(param_1 + (long)local_c * 4);
}
return param_4;
} |
6,621 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* nums1, int* nums2, int n, int* result) {
for (int i = 0; i < n; i++) {
result[i] = nums1[i] * nums2[i];
}
return result;
}
| int main() {
int result1[3], result2[2], result3[2];
int nums1a[] = {1, 2, 3};
int nums2a[] = {4, 5, 6};
int nums1b[] = {1, 2};
int nums2b[] = {3, 4};
int nums1c[] = {90, 120};
int nums2c[] = {50, 70};
func0(nums1a, nums2a, 3, result1);
func0(nums1b, nums2b, 2, result2);
func0(nums1c, nums2c, 2, result3);
assert(result1[0] == 4 && result1[1] == 10 && result1[2] == 18);
assert(result2[0] == 3 && result2[1] == 8);
assert(result3[0] == 4500 && result3[1] == 8400);
return 0;
}
| O1 | c | func0:
endbr64
mov %rcx,%rax
test %edx,%edx
jle 1195 <func0+0x2c>
lea -0x1(%rdx),%ecx
mov $0x0,%edx
mov (%rdi,%rdx,4),%r8d
imul (%rsi,%rdx,4),%r8d
mov %r8d,(%rax,%rdx,4)
mov %rdx,%r8
add $0x1,%rdx
cmp %rcx,%r8
jne 117c <func0+0x13>
retq
| func0:
endbr64
mov rax, rcx
test edx, edx
jle short locret_1192
mov edx, edx
mov r8d, 0
loc_117C:
mov r9d, [rdi+r8*4]
imul r9d, [rsi+r8*4]
mov [rax+r8*4], r9d
add r8, 1
cmp r8, rdx
jnz short loc_117C
locret_1192:
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long result; // rax
long long i; // r8
result = a4;
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
*(_DWORD *)(a4 + 4 * i) = *(_DWORD *)(a2 + 4 * i) * *(_DWORD *)(a1 + 4 * i);
}
return result;
} | func0:
ENDBR64
MOV RAX,RCX
TEST EDX,EDX
JLE 0x00101192
MOV EDX,EDX
MOV R8D,0x0
LAB_0010117c:
MOV R9D,dword ptr [RDI + R8*0x4]
IMUL R9D,dword ptr [RSI + R8*0x4]
MOV dword ptr [RAX + R8*0x4],R9D
ADD R8,0x1
CMP R8,RDX
JNZ 0x0010117c
LAB_00101192:
RET | void func0(long param_1,long param_2,uint param_3,long param_4)
{
ulong uVar1;
if (0 < (int)param_3) {
uVar1 = 0;
do {
*(int *)(param_4 + uVar1 * 4) = *(int *)(param_1 + uVar1 * 4) * *(int *)(param_2 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
}
return;
} |
6,622 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* nums1, int* nums2, int n, int* result) {
for (int i = 0; i < n; i++) {
result[i] = nums1[i] * nums2[i];
}
return result;
}
| int main() {
int result1[3], result2[2], result3[2];
int nums1a[] = {1, 2, 3};
int nums2a[] = {4, 5, 6};
int nums1b[] = {1, 2};
int nums2b[] = {3, 4};
int nums1c[] = {90, 120};
int nums2c[] = {50, 70};
func0(nums1a, nums2a, 3, result1);
func0(nums1b, nums2b, 2, result2);
func0(nums1c, nums2c, 2, result3);
assert(result1[0] == 4 && result1[1] == 10 && result1[2] == 18);
assert(result2[0] == 3 && result2[1] == 8);
assert(result3[0] == 4500 && result3[1] == 8400);
return 0;
}
| O2 | c | func0:
endbr64
mov %rcx,%rax
test %edx,%edx
jle 1169 <func0+0x29>
lea -0x1(%rdx),%ecx
xor %edx,%edx
mov (%rdi,%rdx,4),%r8d
imul (%rsi,%rdx,4),%r8d
mov %r8d,(%rax,%rdx,4)
mov %rdx,%r8
add $0x1,%rdx
cmp %rcx,%r8
jne 1150 <func0+0x10>
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov rax, rcx
test edx, edx
jle short locret_116E
movsxd rdx, edx
xor r8d, r8d
nop dword ptr [rax+00000000h]
loc_1158:
mov r9d, [rdi+r8*4]
imul r9d, [rsi+r8*4]
mov [rax+r8*4], r9d
add r8, 1
cmp rdx, r8
jnz short loc_1158
locret_116E:
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long result; // rax
long long i; // r8
result = a4;
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
*(_DWORD *)(a4 + 4 * i) = *(_DWORD *)(a2 + 4 * i) * *(_DWORD *)(a1 + 4 * i);
}
return result;
} | func0:
ENDBR64
MOV RAX,RCX
TEST EDX,EDX
JLE 0x0010116e
MOVSXD RDX,EDX
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101158:
MOV R9D,dword ptr [RDI + R8*0x4]
IMUL R9D,dword ptr [RSI + R8*0x4]
MOV dword ptr [RAX + R8*0x4],R9D
ADD R8,0x1
CMP RDX,R8
JNZ 0x00101158
LAB_0010116e:
RET | void func0(long param_1,long param_2,int param_3,long param_4)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
*(int *)(param_4 + lVar1 * 4) = *(int *)(param_1 + lVar1 * 4) * *(int *)(param_2 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (param_3 != lVar1);
}
return;
} |
6,623 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int* nums1, int* nums2, int n, int* result) {
for (int i = 0; i < n; i++) {
result[i] = nums1[i] * nums2[i];
}
return result;
}
| int main() {
int result1[3], result2[2], result3[2];
int nums1a[] = {1, 2, 3};
int nums2a[] = {4, 5, 6};
int nums1b[] = {1, 2};
int nums2b[] = {3, 4};
int nums1c[] = {90, 120};
int nums2c[] = {50, 70};
func0(nums1a, nums2a, 3, result1);
func0(nums1b, nums2b, 2, result2);
func0(nums1c, nums2c, 2, result3);
assert(result1[0] == 4 && result1[1] == 10 && result1[2] == 18);
assert(result2[0] == 3 && result2[1] == 8);
assert(result3[0] == 4500 && result3[1] == 8400);
return 0;
}
| O3 | c | func0:
endbr64
mov %rcx,%rax
test %edx,%edx
jle 123e <func0+0xfe>
lea 0xf(%rcx),%rcx
lea -0x1(%rdx),%r8d
mov %rcx,%r9
sub %rdi,%r9
cmp $0x1e,%r9
seta %r10b
cmp $0x2,%r8d
seta %r9b
test %r9b,%r10b
je 1220 <func0+0xe0>
sub %rsi,%rcx
cmp $0x1e,%rcx
jbe 1220 <func0+0xe0>
mov %edx,%ecx
xor %r8d,%r8d
shr $0x2,%ecx
shl $0x4,%rcx
movdqu (%rdi,%r8,1),%xmm0
movdqu (%rsi,%r8,1),%xmm2
movdqu (%rdi,%r8,1),%xmm1
movdqu (%rsi,%r8,1),%xmm3
psrlq $0x20,%xmm0
psrlq $0x20,%xmm2
pmuludq %xmm3,%xmm1
pmuludq %xmm2,%xmm0
pshufd $0x8,%xmm1,%xmm1
pshufd $0x8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
movups %xmm1,(%rax,%r8,1)
add $0x10,%r8
cmp %rcx,%r8
jne 1190 <func0+0x50>
mov %edx,%ecx
and $0xfffffffc,%ecx
test $0x3,%dl
je 123e <func0+0xfe>
mov %ecx,%r8d
mov (%rdi,%r8,4),%r9d
imul (%rsi,%r8,4),%r9d
mov %r9d,(%rax,%r8,4)
lea 0x1(%rcx),%r8d
cmp %r8d,%edx
jle 123e <func0+0xfe>
movslq %r8d,%r8
add $0x2,%ecx
mov (%rdi,%r8,4),%r9d
imul (%rsi,%r8,4),%r9d
mov %r9d,(%rax,%r8,4)
cmp %ecx,%edx
jle 123e <func0+0xfe>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%edx
imul (%rsi,%rcx,4),%edx
mov %edx,(%rax,%rcx,4)
retq
xchg %ax,%ax
xor %edx,%edx
nopw 0x0(%rax,%rax,1)
mov (%rdi,%rdx,4),%ecx
imul (%rsi,%rdx,4),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %r8,%rcx
jne 1228 <func0+0xe8>
retq
| func0:
endbr64
mov r8, rsi
test edx, edx
jle loc_1223
lea eax, [rdx-1]
cmp eax, 2
jbe loc_1230
lea rsi, [rdi+4]
mov rax, rcx
sub rax, rsi
cmp rax, 8
jbe loc_1230
lea rsi, [r8+4]
mov rax, rcx
sub rax, rsi
cmp rax, 8
jbe loc_1230
mov esi, edx
xor eax, eax
shr esi, 2
shl rsi, 4
xchg ax, ax
loc_1190:
movdqu xmm0, xmmword ptr [rdi+rax]
movdqu xmm2, xmmword ptr [r8+rax]
movdqu xmm1, xmmword ptr [rdi+rax]
movdqu xmm3, xmmword ptr [r8+rax]
psrlq xmm0, 20h ; ' '
psrlq xmm2, 20h ; ' '
pmuludq xmm1, xmm3
pmuludq xmm0, xmm2
pshufd xmm1, xmm1, 8
pshufd xmm0, xmm0, 8
punpckldq xmm1, xmm0
movups xmmword ptr [rcx+rax], xmm1
add rax, 10h
cmp rax, rsi
jnz short loc_1190
mov esi, edx
and esi, 0FFFFFFFCh
test dl, 3
jz short loc_1223
mov r9d, esi
mov r10d, [rdi+r9*4]
imul r10d, [r8+r9*4]
lea rax, ds:0[r9*4]
mov [rcx+r9*4], r10d
lea r9d, [rsi+1]
cmp edx, r9d
jle short loc_1223
mov r9d, [rdi+rax+4]
imul r9d, [r8+rax+4]
add esi, 2
mov [rcx+rax+4], r9d
cmp edx, esi
jle short loc_1223
mov edx, [rdi+rax+8]
imul edx, [r8+rax+8]
mov [rcx+rax+8], edx
loc_1223:
mov rax, rcx
retn
loc_1230:
movsxd rdx, edx
xor eax, eax
lea rsi, ds:0[rdx*4]
nop dword ptr [rax]
loc_1240:
mov edx, [rdi+rax]
imul edx, [r8+rax]
mov [rcx+rax], edx
add rax, 4
cmp rsi, rax
jnz short loc_1240
mov rax, rcx
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long v5; // rax
unsigned int v6; // esi
long long v7; // rax
long long v9; // rax
if ( a3 <= 0 )
return a4;
if ( (unsigned int)(a3 - 1) > 2 && (unsigned long long)(a4 - (a1 + 4)) > 8 && (unsigned long long)(a4 - (a2 + 4)) > 8 )
{
v5 = 0LL;
do
{
*(__m128i *)(a4 + v5) = _mm_unpacklo_epi32(
_mm_shuffle_epi32(
_mm_mul_epu32(
_mm_loadu_si128((const __m128i *)(a1 + v5)),
_mm_loadu_si128((const __m128i *)(a2 + v5))),
8),
_mm_shuffle_epi32(
_mm_mul_epu32(
_mm_srli_epi64(_mm_loadu_si128((const __m128i *)(a1 + v5)), 0x20u),
_mm_srli_epi64(_mm_loadu_si128((const __m128i *)(a2 + v5)), 0x20u)),
8));
v5 += 16LL;
}
while ( v5 != 16LL * ((unsigned int)a3 >> 2) );
v6 = a3 & 0x7FFFFFFC;
if ( (a3 & 3) != 0 )
{
v7 = 4LL * v6;
*(_DWORD *)(a4 + v7) = *(_DWORD *)(a2 + v7) * *(_DWORD *)(a1 + v7);
if ( a3 > (int)(v6 + 1) )
{
*(_DWORD *)(a4 + v7 + 4) = *(_DWORD *)(a2 + v7 + 4) * *(_DWORD *)(a1 + v7 + 4);
if ( a3 > (int)(v6 + 2) )
*(_DWORD *)(a4 + v7 + 8) = *(_DWORD *)(a2 + v7 + 8) * *(_DWORD *)(a1 + v7 + 8);
}
}
return a4;
}
v9 = 0LL;
do
{
*(_DWORD *)(a4 + v9) = *(_DWORD *)(a2 + v9) * *(_DWORD *)(a1 + v9);
v9 += 4LL;
}
while ( 4LL * a3 != v9 );
return a4;
} | func0:
ENDBR64
MOV R8,RSI
TEST EDX,EDX
JLE 0x00101223
LEA EAX,[RDX + -0x1]
CMP EAX,0x2
JBE 0x00101230
LEA RSI,[RDI + 0x4]
MOV RAX,RCX
SUB RAX,RSI
CMP RAX,0x8
JBE 0x00101230
LEA RSI,[R8 + 0x4]
MOV RAX,RCX
SUB RAX,RSI
CMP RAX,0x8
JBE 0x00101230
MOV ESI,EDX
XOR EAX,EAX
SHR ESI,0x2
SHL RSI,0x4
NOP
LAB_00101190:
MOVDQU XMM0,xmmword ptr [RDI + RAX*0x1]
MOVDQU XMM2,xmmword ptr [R8 + RAX*0x1]
MOVDQU XMM1,xmmword ptr [RDI + RAX*0x1]
MOVDQU XMM3,xmmword ptr [R8 + RAX*0x1]
PSRLQ XMM0,0x20
PSRLQ XMM2,0x20
PMULUDQ XMM1,XMM3
PMULUDQ XMM0,XMM2
PSHUFD XMM1,XMM1,0x8
PSHUFD XMM0,XMM0,0x8
PUNPCKLDQ XMM1,XMM0
MOVUPS xmmword ptr [RCX + RAX*0x1],XMM1
ADD RAX,0x10
CMP RAX,RSI
JNZ 0x00101190
MOV ESI,EDX
AND ESI,0xfffffffc
TEST DL,0x3
JZ 0x00101223
MOV R9D,ESI
MOV R10D,dword ptr [RDI + R9*0x4]
IMUL R10D,dword ptr [R8 + R9*0x4]
LEA RAX,[R9*0x4]
MOV dword ptr [RCX + R9*0x4],R10D
LEA R9D,[RSI + 0x1]
CMP EDX,R9D
JLE 0x00101223
MOV R9D,dword ptr [RDI + RAX*0x1 + 0x4]
IMUL R9D,dword ptr [R8 + RAX*0x1 + 0x4]
ADD ESI,0x2
MOV dword ptr [RCX + RAX*0x1 + 0x4],R9D
CMP EDX,ESI
JLE 0x00101223
MOV EDX,dword ptr [RDI + RAX*0x1 + 0x8]
IMUL EDX,dword ptr [R8 + RAX*0x1 + 0x8]
MOV dword ptr [RCX + RAX*0x1 + 0x8],EDX
LAB_00101223:
MOV RAX,RCX
RET
LAB_00101230:
MOVSXD RDX,EDX
XOR EAX,EAX
LEA RSI,[RDX*0x4]
NOP dword ptr [RAX]
LAB_00101240:
MOV EDX,dword ptr [RDI + RAX*0x1]
IMUL EDX,dword ptr [R8 + RAX*0x1]
MOV dword ptr [RCX + RAX*0x1],EDX
ADD RAX,0x4
CMP RSI,RAX
JNZ 0x00101240
MOV RAX,RCX
RET | long func0(long param_1,long param_2,uint param_3,long param_4)
{
int8 *puVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
uint uVar5;
ulong uVar6;
if (0 < (int)param_3) {
if (((param_3 - 1 < 3) || ((ulong)(param_4 - (param_1 + 4)) < 9)) ||
((ulong)(param_4 - (param_2 + 4)) < 9)) {
lVar4 = 0;
do {
*(int *)(param_4 + lVar4) = *(int *)(param_1 + lVar4) * *(int *)(param_2 + lVar4);
lVar4 = lVar4 + 4;
} while ((long)(int)param_3 * 4 - lVar4 != 0);
return param_4;
}
lVar4 = 0;
do {
uVar6 = ((ulong *)(param_1 + lVar4))[1];
uVar2 = ((ulong *)(param_2 + lVar4))[1];
uVar3 = ((ulong *)(param_1 + lVar4))[1];
uVar5 = ((uint *)(param_2 + lVar4))[2];
puVar1 = (int8 *)(param_4 + lVar4);
*puVar1 = CONCAT44((int)((*(ulong *)(param_1 + lVar4) >> 0x20) *
(*(ulong *)(param_2 + lVar4) >> 0x20)),
(int)((*(ulong *)(param_1 + lVar4) & 0xffffffff) *
(ulong)*(uint *)(param_2 + lVar4)));
*(int *)(puVar1 + 2) = (int)((uVar3 & 0xffffffff) * (ulong)uVar5);
*(int *)((long)puVar1 + 0x14) = (int)((uVar6 >> 0x20) * (uVar2 >> 0x20));
lVar4 = lVar4 + 0x10;
} while (lVar4 != (ulong)(param_3 >> 2) << 4);
uVar5 = param_3 & 0xfffffffc;
if ((param_3 & 3) != 0) {
uVar6 = (ulong)uVar5;
lVar4 = uVar6 * 4;
*(int *)(param_4 + uVar6 * 4) = *(int *)(param_1 + uVar6 * 4) * *(int *)(param_2 + uVar6 * 4);
if (((int)(uVar5 + 1) < (int)param_3) &&
(*(int *)(param_4 + 4 + lVar4) =
*(int *)(param_1 + 4 + lVar4) * *(int *)(param_2 + 4 + lVar4),
(int)(uVar5 + 2) < (int)param_3)) {
*(int *)(param_4 + 8 + lVar4) =
*(int *)(param_1 + 8 + lVar4) * *(int *)(param_2 + 8 + lVar4);
}
}
}
return param_4;
} |
6,624 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
int j = 1;
while (j * j <= n) {
if ((i * i + j * j) == n) {
return true;
}
j++;
}
i++;
}
return false;
}
| int main() {
assert(func0(25) == true);
assert(func0(24) == false);
assert(func0(17) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x1,-0x8(%rbp)
jmp 1195 <func0+0x4c>
movl $0x1,-0x4(%rbp)
jmp 1186 <func0+0x3d>
mov -0x8(%rbp),%eax
imul %eax,%eax
mov %eax,%edx
mov -0x4(%rbp),%eax
imul %eax,%eax
add %edx,%eax
cmp %eax,-0x14(%rbp)
jne 1182 <func0+0x39>
mov $0x1,%eax
jmp 11a5 <func0+0x5c>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jge 1166 <func0+0x1d>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jge 115d <func0+0x14>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 1
jmp short loc_1195
loc_115D:
mov [rbp+var_4], 1
jmp short loc_1186
loc_1166:
mov eax, [rbp+var_8]
imul eax, eax
mov edx, eax
mov eax, [rbp+var_4]
imul eax, eax
add eax, edx
cmp [rbp+var_14], eax
jnz short loc_1182
mov eax, 1
jmp short loc_11A5
loc_1182:
add [rbp+var_4], 1
loc_1186:
mov eax, [rbp+var_4]
imul eax, eax
cmp [rbp+var_14], eax
jge short loc_1166
add [rbp+var_8], 1
loc_1195:
mov eax, [rbp+var_8]
imul eax, eax
cmp [rbp+var_14], eax
jge short loc_115D
mov eax, 0
loc_11A5:
pop rbp
retn | long long func0(int a1)
{
int i; // [rsp+Ch] [rbp-8h]
int j; // [rsp+10h] [rbp-4h]
for ( i = 1; a1 >= i * i; ++i )
{
for ( j = 1; a1 >= j * j; ++j )
{
if ( a1 == i * i + j * j )
return 1LL;
}
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x1
JMP 0x00101195
LAB_0010115d:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101186
LAB_00101166:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EAX
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
ADD EAX,EDX
CMP dword ptr [RBP + -0x14],EAX
JNZ 0x00101182
MOV EAX,0x1
JMP 0x001011a5
LAB_00101182:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101186:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JGE 0x00101166
ADD dword ptr [RBP + -0x8],0x1
LAB_00101195:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JGE 0x0010115d
MOV EAX,0x0
LAB_001011a5:
POP RBP
RET | int8 func0(int param_1)
{
int local_10;
int local_c;
local_10 = 1;
do {
if (param_1 < local_10 * local_10) {
return 0;
}
for (local_c = 1; local_c * local_c <= param_1; local_c = local_c + 1) {
if (param_1 == local_c * local_c + local_10 * local_10) {
return 1;
}
}
local_10 = local_10 + 1;
} while( true );
} |
6,625 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
int j = 1;
while (j * j <= n) {
if ((i * i + j * j) == n) {
return true;
}
j++;
}
i++;
}
return false;
}
| int main() {
assert(func0(25) == true);
assert(func0(24) == false);
assert(func0(17) == true);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%esi
mov $0x1,%ecx
test %edi,%edi
jle 117f <func0+0x36>
lea 0x1(%rcx),%eax
cmp %eax,%edi
je 1197 <func0+0x4e>
mov $0x1,%edx
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
cmp %edi,%eax
jg 1185 <func0+0x3c>
add %ecx,%eax
cmp %edi,%eax
jne 1167 <func0+0x1e>
mov $0x1,%eax
retq
mov $0x0,%eax
retq
add $0x1,%esi
mov %esi,%ecx
imul %esi,%ecx
cmp %edi,%ecx
jle 115b <func0+0x12>
mov $0x0,%eax
retq
mov $0x1,%eax
retq
| func0:
endbr64
mov esi, 1
mov ecx, 1
test edi, edi
jle short loc_117F
loc_115B:
lea eax, [rcx+1]
cmp edi, eax
jz short loc_1197
mov edx, 1
loc_1167:
add edx, 1
mov eax, edx
imul eax, edx
cmp eax, edi
jg short loc_1185
add eax, ecx
cmp eax, edi
jnz short loc_1167
mov eax, 1
retn
loc_117F:
mov eax, 0
retn
loc_1185:
add esi, 1
mov ecx, esi
imul ecx, esi
cmp ecx, edi
jle short loc_115B
mov eax, 0
retn
loc_1197:
mov eax, 1
retn | long long func0(int a1)
{
int v1; // esi
int v2; // ecx
int v3; // edx
v1 = 1;
v2 = 1;
if ( a1 <= 0 )
return 0LL;
while ( a1 != v2 + 1 )
{
v3 = 1;
while ( 1 )
{
++v3;
if ( v3 * v3 > a1 )
break;
if ( v2 + v3 * v3 == a1 )
return 1LL;
}
++v1;
v2 = v1 * v1;
if ( v1 * v1 > a1 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
MOV ESI,0x1
MOV ECX,0x1
TEST EDI,EDI
JLE 0x0010117f
LAB_0010115b:
LEA EAX,[RCX + 0x1]
CMP EDI,EAX
JZ 0x00101197
MOV EDX,0x1
LAB_00101167:
ADD EDX,0x1
MOV EAX,EDX
IMUL EAX,EDX
CMP EAX,EDI
JG 0x00101185
ADD EAX,ECX
CMP EAX,EDI
JNZ 0x00101167
MOV EAX,0x1
RET
LAB_0010117f:
MOV EAX,0x0
RET
LAB_00101185:
ADD ESI,0x1
MOV ECX,ESI
IMUL ECX,ESI
CMP ECX,EDI
JLE 0x0010115b
MOV EAX,0x0
RET
LAB_00101197:
MOV EAX,0x1
RET | int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 1;
iVar1 = 1;
if (param_1 < 1) {
return 0;
}
do {
if (param_1 == iVar1 + 1) {
return 1;
}
iVar2 = 1;
while( true ) {
iVar2 = iVar2 + 1;
if (param_1 < iVar2 * iVar2) break;
if (iVar2 * iVar2 + iVar1 == param_1) {
return 1;
}
}
iVar3 = iVar3 + 1;
iVar1 = iVar3 * iVar3;
if (param_1 < iVar1) {
return 0;
}
} while( true );
} |
6,626 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
int j = 1;
while (j * j <= n) {
if ((i * i + j * j) == n) {
return true;
}
j++;
}
i++;
}
return false;
}
| int main() {
assert(func0(25) == true);
assert(func0(24) == false);
assert(func0(17) == true);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x1,%esi
mov $0x1,%ecx
test %edi,%edi
jle 12ce <func0+0x3e>
lea 0x1(%rcx),%eax
cmp %eax,%edi
je 12d8 <func0+0x48>
mov $0x1,%edx
jmp 12b6 <func0+0x26>
add %ecx,%eax
cmp %edi,%eax
je 12d8 <func0+0x48>
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
cmp %edi,%eax
jle 12b0 <func0+0x20>
add $0x1,%esi
mov %esi,%ecx
imul %esi,%ecx
cmp %edi,%ecx
jle 12a2 <func0+0x12>
xor %eax,%eax
retq
nopl 0x0(%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
mov esi, 1
mov ecx, 1
test edi, edi
jle short loc_122E
loc_1202:
lea eax, [rcx+1]
cmp edi, eax
jz short loc_1238
mov edx, 1
jmp short loc_1216
loc_1210:
add eax, ecx
cmp eax, edi
jz short loc_1238
loc_1216:
add edx, 1
mov eax, edx
imul eax, edx
cmp eax, edi
jle short loc_1210
add esi, 1
mov ecx, esi
imul ecx, esi
cmp ecx, edi
jle short loc_1202
loc_122E:
xor eax, eax
retn
loc_1238:
mov eax, 1
retn | long long func0(int a1)
{
int v1; // esi
int v2; // ecx
int v3; // edx
v1 = 1;
v2 = 1;
if ( a1 <= 0 )
return 0LL;
while ( a1 != v2 + 1 )
{
v3 = 1;
while ( 1 )
{
++v3;
if ( v3 * v3 > a1 )
break;
if ( v2 + v3 * v3 == a1 )
return 1LL;
}
++v1;
v2 = v1 * v1;
if ( v1 * v1 > a1 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
MOV ESI,0x1
MOV ECX,0x1
TEST EDI,EDI
JLE 0x0010122e
LAB_00101202:
LEA EAX,[RCX + 0x1]
CMP EDI,EAX
JZ 0x00101238
MOV EDX,0x1
JMP 0x00101216
LAB_00101210:
ADD EAX,ECX
CMP EAX,EDI
JZ 0x00101238
LAB_00101216:
ADD EDX,0x1
MOV EAX,EDX
IMUL EAX,EDX
CMP EAX,EDI
JLE 0x00101210
ADD ESI,0x1
MOV ECX,ESI
IMUL ECX,ESI
CMP ECX,EDI
JLE 0x00101202
LAB_0010122e:
XOR EAX,EAX
RET
LAB_00101238:
MOV EAX,0x1
RET | int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 1;
iVar1 = 1;
if (0 < param_1) {
do {
if (param_1 == iVar1 + 1) {
return 1;
}
iVar2 = 1;
while( true ) {
iVar2 = iVar2 + 1;
if (param_1 < iVar2 * iVar2) break;
if (iVar2 * iVar2 + iVar1 == param_1) {
return 1;
}
}
iVar3 = iVar3 + 1;
iVar1 = iVar3 * iVar3;
} while (iVar1 <= param_1);
}
return 0;
} |
6,627 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
int i = 1;
while (i * i <= n) {
int j = 1;
while (j * j <= n) {
if ((i * i + j * j) == n) {
return true;
}
j++;
}
i++;
}
return false;
}
| int main() {
assert(func0(25) == true);
assert(func0(24) == false);
assert(func0(17) == true);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%esi
mov $0x1,%ecx
test %edi,%edi
jle 12ce <func0+0x3e>
lea 0x1(%rcx),%eax
cmp %eax,%edi
je 12d8 <func0+0x48>
mov $0x1,%edx
jmp 12b6 <func0+0x26>
add %ecx,%eax
cmp %edi,%eax
je 12d8 <func0+0x48>
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
cmp %edi,%eax
jle 12b0 <func0+0x20>
add $0x1,%esi
mov %esi,%ecx
imul %esi,%ecx
cmp %edi,%ecx
jle 12a2 <func0+0x12>
xor %eax,%eax
retq
nopl 0x0(%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
mov esi, 1
mov ecx, 1
test edi, edi
jle short loc_12DE
loc_12B2:
lea eax, [rcx+1]
cmp edi, eax
jz short loc_12E8
mov edx, 1
jmp short loc_12C6
loc_12C0:
add eax, ecx
cmp eax, edi
jz short loc_12E8
loc_12C6:
add edx, 1
mov eax, edx
imul eax, edx
cmp eax, edi
jle short loc_12C0
add esi, 1
mov ecx, esi
imul ecx, esi
cmp ecx, edi
jle short loc_12B2
loc_12DE:
xor eax, eax
retn
loc_12E8:
mov eax, 1
retn | long long func0(int a1)
{
int v1; // esi
int v2; // ecx
int v3; // edx
v1 = 1;
v2 = 1;
if ( a1 <= 0 )
return 0LL;
while ( a1 != v2 + 1 )
{
v3 = 1;
while ( 1 )
{
++v3;
if ( v3 * v3 > a1 )
break;
if ( v2 + v3 * v3 == a1 )
return 1LL;
}
++v1;
v2 = v1 * v1;
if ( v1 * v1 > a1 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
MOV ESI,0x1
MOV ECX,0x1
TEST EDI,EDI
JLE 0x001012de
LAB_001012b2:
LEA EAX,[RCX + 0x1]
CMP EDI,EAX
JZ 0x001012e8
MOV EDX,0x1
JMP 0x001012c6
LAB_001012c0:
ADD EAX,ECX
CMP EAX,EDI
JZ 0x001012e8
LAB_001012c6:
ADD EDX,0x1
MOV EAX,EDX
IMUL EAX,EDX
CMP EAX,EDI
JLE 0x001012c0
ADD ESI,0x1
MOV ECX,ESI
IMUL ECX,ESI
CMP ECX,EDI
JLE 0x001012b2
LAB_001012de:
XOR EAX,EAX
RET
LAB_001012e8:
MOV EAX,0x1
RET | int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 1;
iVar1 = 1;
if (0 < param_1) {
do {
if (param_1 == iVar1 + 1) {
return 1;
}
iVar2 = 1;
while( true ) {
iVar2 = iVar2 + 1;
if (param_1 < iVar2 * iVar2) break;
if (iVar2 * iVar2 + iVar1 == param_1) {
return 1;
}
}
iVar3 = iVar3 + 1;
iVar1 = iVar3 * iVar3;
} while (iVar1 <= param_1);
}
return 0;
} |
6,628 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str, char x) {
int count = 0;
int str_len = strlen(str);
for (int i = 0; i < str_len; i++) {
if (str[i] == x) {
count += 1;
}
}
int n = 10;
int repetitions = n / str_len;
count = count * repetitions;
int l = n % str_len;
for (int i = 0; i < l; i++) {
if (str[i] == x) {
count += 1;
}
}
return count;
}
| int main() {
assert(func0("abcac", 'a') == 4);
assert(func0("abca", 'c') == 2);
assert(func0("aba", 'a') == 7);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,%eax
mov %al,-0x2c(%rbp)
movl $0x0,-0x1c(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x10(%rbp)
movl $0x0,-0x18(%rbp)
jmp 11ba <func0+0x51>
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp %al,-0x2c(%rbp)
jne 11b6 <func0+0x4d>
addl $0x1,-0x1c(%rbp)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x10(%rbp),%eax
jl 119d <func0+0x34>
movl $0xa,-0xc(%rbp)
mov -0xc(%rbp),%eax
cltd
idivl -0x10(%rbp)
mov %eax,-0x8(%rbp)
mov -0x1c(%rbp),%eax
imul -0x8(%rbp),%eax
mov %eax,-0x1c(%rbp)
mov -0xc(%rbp),%eax
cltd
idivl -0x10(%rbp)
mov %edx,-0x4(%rbp)
movl $0x0,-0x14(%rbp)
jmp 120d <func0+0xa4>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp %al,-0x2c(%rbp)
jne 1209 <func0+0xa0>
addl $0x1,-0x1c(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 11f0 <func0+0x87>
mov -0x1c(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov eax, esi
mov [rbp+var_2C], al
mov [rbp+var_1C], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_10], eax
mov [rbp+var_18], 0
jmp short loc_11BA
loc_119D:
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp [rbp+var_2C], al
jnz short loc_11B6
add [rbp+var_1C], 1
loc_11B6:
add [rbp+var_18], 1
loc_11BA:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_10]
jl short loc_119D
mov [rbp+var_C], 0Ah
mov eax, [rbp+var_C]
cdq
idiv [rbp+var_10]
mov [rbp+var_8], eax
mov eax, [rbp+var_1C]
imul eax, [rbp+var_8]
mov [rbp+var_1C], eax
mov eax, [rbp+var_C]
cdq
idiv [rbp+var_10]
mov [rbp+var_4], edx
mov [rbp+var_14], 0
jmp short loc_120D
loc_11F0:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp [rbp+var_2C], al
jnz short loc_1209
add [rbp+var_1C], 1
loc_1209:
add [rbp+var_14], 1
loc_120D:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_4]
jl short loc_11F0
mov eax, [rbp+var_1C]
leave
retn | long long func0(const char *a1, char a2)
{
int v3; // [rsp+14h] [rbp-1Ch]
unsigned int v4; // [rsp+14h] [rbp-1Ch]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
int v7; // [rsp+20h] [rbp-10h]
v3 = 0;
v7 = strlen(a1);
for ( i = 0; i < v7; ++i )
{
if ( a2 == a1[i] )
++v3;
}
v4 = 10 / v7 * v3;
for ( j = 0; j < 10 % v7; ++j )
{
if ( a2 == a1[j] )
++v4;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV EAX,ESI
MOV byte ptr [RBP + -0x2c],AL
MOV dword ptr [RBP + -0x1c],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x10],EAX
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001011ba
LAB_0010119d:
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP byte ptr [RBP + -0x2c],AL
JNZ 0x001011b6
ADD dword ptr [RBP + -0x1c],0x1
LAB_001011b6:
ADD dword ptr [RBP + -0x18],0x1
LAB_001011ba:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x10]
JL 0x0010119d
MOV dword ptr [RBP + -0xc],0xa
MOV EAX,dword ptr [RBP + -0xc]
CDQ
IDIV dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x1c]
IMUL EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQ
IDIV dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x4],EDX
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010120d
LAB_001011f0:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP byte ptr [RBP + -0x2c],AL
JNZ 0x00101209
ADD dword ptr [RBP + -0x1c],0x1
LAB_00101209:
ADD dword ptr [RBP + -0x14],0x1
LAB_0010120d:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x001011f0
MOV EAX,dword ptr [RBP + -0x1c]
LEAVE
RET | int func0(char *param_1,char param_2)
{
int iVar1;
size_t sVar2;
int local_24;
int local_20;
int local_1c;
local_24 = 0;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
for (local_20 = 0; local_20 < iVar1; local_20 = local_20 + 1) {
if (param_2 == param_1[local_20]) {
local_24 = local_24 + 1;
}
}
local_24 = local_24 * (10 / iVar1);
for (local_1c = 0; local_1c < 10 % iVar1; local_1c = local_1c + 1) {
if (param_2 == param_1[local_1c]) {
local_24 = local_24 + 1;
}
}
return local_24;
} |
6,629 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str, char x) {
int count = 0;
int str_len = strlen(str);
for (int i = 0; i < str_len; i++) {
if (str[i] == x) {
count += 1;
}
}
int n = 10;
int repetitions = n / str_len;
count = count * repetitions;
int l = n % str_len;
for (int i = 0; i < l; i++) {
if (str[i] == x) {
count += 1;
}
}
return count;
}
| int main() {
assert(func0("abcac", 'a') == 4);
assert(func0("abca", 'c') == 2);
assert(func0("aba", 'a') == 7);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
mov %ecx,%r9d
test %ecx,%ecx
jle 11c0 <func0+0x77>
mov %r8,%rax
lea -0x1(%rcx),%edx
lea 0x1(%r8,%rdx,1),%rdi
mov $0x0,%ecx
cmp %sil,(%rax)
sete %dl
movzbl %dl,%edx
add %edx,%ecx
add $0x1,%rax
cmp %rdi,%rax
jne 117c <func0+0x33>
mov $0xa,%eax
cltd
idiv %r9d
imul %ecx,%eax
test %edx,%edx
jle 11bf <func0+0x76>
mov %r8,%rcx
lea -0x1(%rdx),%edx
lea 0x1(%r8,%rdx,1),%rdi
cmp %sil,(%rcx)
sete %dl
movzbl %dl,%edx
add %edx,%eax
add $0x1,%rcx
cmp %rdi,%rcx
jne 11ab <func0+0x62>
retq
mov $0x0,%ecx
jmp 1190 <func0+0x47>
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, esi
call _strlen
mov edi, eax
test eax, eax
jle short loc_11DA
mov rdx, rbp
lea eax, [rax-1]
lea rsi, [rbp+rax+1]
mov ecx, 0
loc_1193:
cmp [rdx], bl
setz al
movzx eax, al
add ecx, eax
add rdx, 1
cmp rdx, rsi
jnz short loc_1193
loc_11A6:
mov eax, 0Ah
cdq
idiv edi
imul eax, ecx
test edx, edx
jle short loc_11D3
mov rcx, rbp
lea edx, [rdx-1]
lea rsi, [rbp+rdx+1]
loc_11C0:
cmp [rcx], bl
setz dl
movzx edx, dl
add eax, edx
add rcx, 1
cmp rcx, rsi
jnz short loc_11C0
loc_11D3:
add rsp, 8
pop rbx
pop rbp
retn
loc_11DA:
mov ecx, 0
jmp short loc_11A6 | long long func0(_BYTE *a1, unsigned __int8 a2)
{
int v3; // eax
int v4; // edi
_BYTE *v5; // rdx
int v6; // ecx
long long result; // rax
_BYTE *v8; // rcx
v3 = strlen();
v4 = v3;
if ( v3 <= 0 )
{
v6 = 0;
}
else
{
v5 = a1;
v6 = 0;
do
v6 += *v5++ == a2;
while ( v5 != &a1[v3 - 1 + 1] );
}
result = (unsigned int)(v6 * (10 / v3));
if ( 10 % v4 > 0 )
{
v8 = a1;
do
result = (*v8++ == a2) + (unsigned int)result;
while ( v8 != &a1[10 % v4 - 1 + 1] );
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,ESI
CALL 0x00101060
MOV EDI,EAX
TEST EAX,EAX
JLE 0x001011da
MOV RDX,RBP
LEA EAX,[RAX + -0x1]
LEA RSI,[RBP + RAX*0x1 + 0x1]
MOV ECX,0x0
LAB_00101193:
CMP byte ptr [RDX],BL
SETZ AL
MOVZX EAX,AL
ADD ECX,EAX
ADD RDX,0x1
CMP RDX,RSI
JNZ 0x00101193
LAB_001011a6:
MOV EAX,0xa
CDQ
IDIV EDI
IMUL EAX,ECX
TEST EDX,EDX
JLE 0x001011d3
MOV RCX,RBP
LEA EDX,[RDX + -0x1]
LEA RSI,[RBP + RDX*0x1 + 0x1]
LAB_001011c0:
CMP byte ptr [RCX],BL
SETZ DL
MOVZX EDX,DL
ADD EAX,EDX
ADD RCX,0x1
CMP RCX,RSI
JNZ 0x001011c0
LAB_001011d3:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001011da:
MOV ECX,0x0
JMP 0x001011a6 | int func0(char *param_1,char param_2)
{
int iVar1;
size_t sVar2;
int iVar3;
char *pcVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (iVar1 < 1) {
iVar3 = 0;
}
else {
iVar3 = 0;
pcVar4 = param_1;
do {
iVar3 = iVar3 + (uint)(*pcVar4 == param_2);
pcVar4 = pcVar4 + 1;
} while (pcVar4 != param_1 + (ulong)(iVar1 - 1) + 1);
}
iVar3 = (int)(10 / (long)iVar1) * iVar3;
iVar1 = (int)(10 % (long)iVar1);
if (0 < iVar1) {
pcVar4 = param_1 + (ulong)(iVar1 - 1) + 1;
do {
iVar3 = iVar3 + (uint)(*param_1 == param_2);
param_1 = param_1 + 1;
} while (param_1 != pcVar4);
}
return iVar3;
} |
6,630 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str, char x) {
int count = 0;
int str_len = strlen(str);
for (int i = 0; i < str_len; i++) {
if (str[i] == x) {
count += 1;
}
}
int n = 10;
int repetitions = n / str_len;
count = count * repetitions;
int l = n % str_len;
for (int i = 0; i < l; i++) {
if (str[i] == x) {
count += 1;
}
}
return count;
}
| int main() {
assert(func0("abcac", 'a') == 4);
assert(func0("abca", 'c') == 2);
assert(func0("aba", 'a') == 7);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
mov %eax,%esi
test %eax,%eax
jle 12b0 <func0+0x90>
sub $0x1,%eax
mov %rbx,%rdx
xor %r8d,%r8d
lea 0x1(%rbx,%rax,1),%rcx
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
cmp %bpl,(%rdx)
sete %al
add $0x1,%rdx
add %eax,%r8d
cmp %rcx,%rdx
jne 1250 <func0+0x30>
mov $0xa,%eax
cltd
idiv %esi
imul %eax,%r8d
mov $0xa,%eax
cltd
idiv %esi
test %edx,%edx
je 12a4 <func0+0x84>
lea -0x1(%rdx),%eax
mov %rbx,%rdi
lea 0x1(%rbx,%rax,1),%rdx
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
cmp %bpl,(%rdi)
sete %al
add $0x1,%rdi
add %eax,%r8d
cmp %rdi,%rdx
jne 1290 <func0+0x70>
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
retq
xchg %ax,%ax
xor %r8d,%r8d
jmp 1270 <func0+0x50>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
mov edi, eax
test eax, eax
jle short loc_12B0
sub eax, 1
mov rdx, rbx
xor ecx, ecx
lea rsi, [rbx+rax+1]
nop word ptr [rax+rax+00000000h]
loc_1250:
xor eax, eax
cmp [rdx], bpl
setz al
add rdx, 1
add ecx, eax
cmp rdx, rsi
jnz short loc_1250
mov eax, 0Ah
cdq
idiv edi
imul eax, ecx
mov r8d, eax
loc_1271:
mov eax, 0Ah
cdq
idiv edi
test edx, edx
jz short loc_12A4
lea eax, [rdx-1]
mov rcx, rbx
lea rdx, [rbx+rax+1]
nop dword ptr [rax+rax+00000000h]
loc_1290:
xor eax, eax
cmp [rcx], bpl
setz al
add rcx, 1
add r8d, eax
cmp rcx, rdx
jnz short loc_1290
loc_12A4:
add rsp, 8
mov eax, r8d
pop rbx
pop rbp
retn
loc_12B0:
xor r8d, r8d
jmp short loc_1271 | long long func0(_BYTE *a1, unsigned __int8 a2)
{
int v4; // eax
int v5; // edi
_BYTE *v6; // rdx
int v7; // ecx
long long v8; // rsi
int v9; // eax
unsigned int v10; // r8d
_BYTE *v11; // rcx
int v12; // eax
v4 = strlen();
v5 = v4;
if ( v4 <= 0 )
{
v10 = 0;
}
else
{
v6 = a1;
v7 = 0;
v8 = (long long)&a1[v4 - 1 + 1];
do
{
v9 = *v6++ == a2;
v7 += v9;
}
while ( v6 != (_BYTE *)v8 );
v10 = v7 * (10 / v5);
}
if ( 10 % v5 )
{
v11 = a1;
do
{
v12 = *v11++ == a2;
v10 += v12;
}
while ( v11 != &a1[10 % v5 - 1 + 1] );
}
return v10;
} | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
MOV EDI,EAX
TEST EAX,EAX
JLE 0x001012b0
SUB EAX,0x1
MOV RDX,RBX
XOR ECX,ECX
LEA RSI,[RBX + RAX*0x1 + 0x1]
NOP word ptr [RAX + RAX*0x1]
LAB_00101250:
XOR EAX,EAX
CMP byte ptr [RDX],BPL
SETZ AL
ADD RDX,0x1
ADD ECX,EAX
CMP RDX,RSI
JNZ 0x00101250
MOV EAX,0xa
CDQ
IDIV EDI
IMUL EAX,ECX
MOV R8D,EAX
LAB_00101271:
MOV EAX,0xa
CDQ
IDIV EDI
TEST EDX,EDX
JZ 0x001012a4
LEA EAX,[RDX + -0x1]
MOV RCX,RBX
LEA RDX,[RBX + RAX*0x1 + 0x1]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101290:
XOR EAX,EAX
CMP byte ptr [RCX],BPL
SETZ AL
ADD RCX,0x1
ADD R8D,EAX
CMP RCX,RDX
JNZ 0x00101290
LAB_001012a4:
ADD RSP,0x8
MOV EAX,R8D
POP RBX
POP RBP
RET
LAB_001012b0:
XOR R8D,R8D
JMP 0x00101271 | int func0(char *param_1,char param_2)
{
char cVar1;
int iVar2;
size_t sVar3;
int iVar4;
char *pcVar5;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
if (iVar2 < 1) {
iVar4 = 0;
}
else {
iVar4 = 0;
pcVar5 = param_1;
do {
cVar1 = *pcVar5;
pcVar5 = pcVar5 + 1;
iVar4 = iVar4 + (uint)(cVar1 == param_2);
} while (pcVar5 != param_1 + (ulong)(iVar2 - 1) + 1);
iVar4 = (int)(10 / (long)iVar2) * iVar4;
}
iVar2 = (int)(10 % (long)iVar2);
if (iVar2 != 0) {
pcVar5 = param_1 + (ulong)(iVar2 - 1) + 1;
do {
cVar1 = *param_1;
param_1 = param_1 + 1;
iVar4 = iVar4 + (uint)(cVar1 == param_2);
} while (param_1 != pcVar5);
}
return iVar4;
} |
6,631 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *str, char x) {
int count = 0;
int str_len = strlen(str);
for (int i = 0; i < str_len; i++) {
if (str[i] == x) {
count += 1;
}
}
int n = 10;
int repetitions = n / str_len;
count = count * repetitions;
int l = n % str_len;
for (int i = 0; i < l; i++) {
if (str[i] == x) {
count += 1;
}
}
return count;
}
| int main() {
assert(func0("abcac", 'a') == 4);
assert(func0("abca", 'c') == 2);
assert(func0("aba", 'a') == 7);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
mov %eax,%esi
test %eax,%eax
jle 1570 <func0+0x350>
lea -0x1(%rax),%edx
cmp $0xe,%edx
jbe 1578 <func0+0x358>
movd %ebp,%xmm4
mov %eax,%ecx
movdqa 0xe58(%rip),%xmm7
mov %rbx,%rdx
punpcklbw %xmm4,%xmm4
shr $0x4,%ecx
pxor %xmm1,%xmm1
pxor %xmm6,%xmm6
punpcklwd %xmm4,%xmm4
shl $0x4,%rcx
pxor %xmm5,%xmm5
pshufd $0x0,%xmm4,%xmm4
add %rbx,%rcx
xchg %ax,%ax
movdqu (%rdx),%xmm0
movdqa %xmm6,%xmm3
add $0x10,%rdx
pcmpeqb %xmm4,%xmm0
pand %xmm7,%xmm0
pcmpgtb %xmm0,%xmm3
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
punpckhbw %xmm3,%xmm0
movdqa %xmm5,%xmm3
pcmpgtw %xmm2,%xmm3
movdqa %xmm2,%xmm8
punpcklwd %xmm3,%xmm8
punpckhwd %xmm3,%xmm2
movdqa %xmm0,%xmm3
paddd %xmm8,%xmm1
paddd %xmm2,%xmm1
movdqa %xmm5,%xmm2
pcmpgtw %xmm0,%xmm2
punpcklwd %xmm2,%xmm3
punpckhwd %xmm2,%xmm0
paddd %xmm3,%xmm1
paddd %xmm0,%xmm1
cmp %rcx,%rdx
jne 1280 <func0+0x60>
movdqa %xmm1,%xmm0
mov %eax,%edx
psrldq $0x8,%xmm0
and $0xfffffff0,%edx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%ecx
test $0xf,%al
je 1498 <func0+0x278>
movslq %edx,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x1(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x2(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x3(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x4(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x5(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x6(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x7(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x8(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0x9(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0xa(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0xb(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0xc(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
movzbl %dil,%edi
add %edi,%ecx
lea 0xd(%rdx),%edi
cmp %edi,%eax
jle 1498 <func0+0x278>
movslq %edi,%rdi
cmp %bpl,(%rbx,%rdi,1)
sete %dil
add $0xe,%edx
movzbl %dil,%edi
add %edi,%ecx
cmp %edx,%eax
jle 1498 <func0+0x278>
movslq %edx,%rdx
xor %eax,%eax
cmp %bpl,(%rbx,%rdx,1)
sete %al
add %eax,%ecx
nopl 0x0(%rax)
mov $0xa,%eax
cltd
idiv %esi
imul %ecx,%eax
mov %eax,%r8d
mov $0xa,%eax
cltd
idiv %esi
test %edx,%edx
je 1562 <func0+0x342>
xor %eax,%eax
cmp %bpl,(%rbx)
sete %al
add %eax,%r8d
cmp $0x1,%edx
je 1562 <func0+0x342>
xor %eax,%eax
cmp %bpl,0x1(%rbx)
sete %al
add %eax,%r8d
cmp $0x2,%edx
je 1562 <func0+0x342>
xor %eax,%eax
cmp %bpl,0x2(%rbx)
sete %al
add %eax,%r8d
cmp $0x3,%edx
je 1562 <func0+0x342>
xor %eax,%eax
cmp %bpl,0x3(%rbx)
sete %al
add %eax,%r8d
cmp $0x4,%edx
je 1562 <func0+0x342>
xor %eax,%eax
cmp %bpl,0x4(%rbx)
sete %al
add %eax,%r8d
cmp $0x5,%edx
je 1562 <func0+0x342>
xor %eax,%eax
cmp %bpl,0x5(%rbx)
sete %al
add %eax,%r8d
cmp $0x6,%edx
je 1562 <func0+0x342>
xor %eax,%eax
cmp %bpl,0x6(%rbx)
sete %al
add %eax,%r8d
cmp $0x7,%edx
je 1562 <func0+0x342>
xor %eax,%eax
cmp %bpl,0x7(%rbx)
sete %al
add %eax,%r8d
cmp $0x8,%edx
je 1562 <func0+0x342>
xor %eax,%eax
cmp %bpl,0x8(%rbx)
sete %al
add %eax,%r8d
cmp $0xa,%edx
jne 1562 <func0+0x342>
xor %eax,%eax
cmp %bpl,0x9(%rbx)
sete %al
add %eax,%r8d
add $0x8,%rsp
mov %r8d,%eax
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
xor %r8d,%r8d
jmpq 14a6 <func0+0x286>
xor %edx,%edx
xor %ecx,%ecx
jmpq 130f <func0+0xef>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
xor edx, edx
mov rdi, rax
mov esi, eax
mov eax, 0Ah
idiv edi
test edi, edi
jle loc_15E0
lea edx, [rdi-1]
cmp edx, 0Eh
jbe loc_15E7
movd xmm4, ebp
mov ecx, edi
pxor xmm1, xmm1
mov rdx, rbx
punpcklbw xmm4, xmm4
shr ecx, 4
pxor xmm6, xmm6
pxor xmm5, xmm5
punpcklwd xmm4, xmm4
shl rcx, 4
pshufd xmm4, xmm4, 0
add rcx, rbx
nop word ptr [rax+rax+00h]
loc_1288:
movdqu xmm0, xmmword ptr [rdx]
movdqa xmm3, xmm6
add rdx, 10h
pcmpeqb xmm0, xmm4
pcmpgtb xmm3, xmm0
movdqa xmm2, xmm0
punpcklbw xmm2, xmm3
punpckhbw xmm0, xmm3
movdqa xmm3, xmm5
pcmpgtw xmm3, xmm2
movdqa xmm7, xmm2
punpcklwd xmm7, xmm3
punpckhwd xmm2, xmm3
movdqa xmm3, xmm0
psubd xmm1, xmm7
psubd xmm1, xmm2
movdqa xmm2, xmm5
pcmpgtw xmm2, xmm0
punpcklwd xmm3, xmm2
punpckhwd xmm0, xmm2
psubd xmm1, xmm3
psubd xmm1, xmm0
cmp rcx, rdx
jnz short loc_1288
movdqa xmm0, xmm1
mov edx, edi
psrldq xmm0, 8
and edx, 0FFFFFFF0h
paddd xmm0, xmm1
mov r8d, edx
movdqa xmm2, xmm0
psrldq xmm2, 4
paddd xmm0, xmm2
movd ecx, xmm0
movdqa xmm0, xmm1
psrldq xmm1, 8
paddd xmm0, xmm1
test dil, 0Fh
jz loc_1455
loc_1322:
mov r9d, edi
sub r9d, edx
lea r10d, [r9-1]
cmp r10d, 6
jbe loc_13CB
movq xmm1, qword ptr [rbx+rdx]
movzx edx, bpl
mov dh, dl
movd xmm6, edx
pshuflw xmm2, xmm6, 0
pcmpeqb xmm1, xmm2
pxor xmm2, xmm2
pcmpgtb xmm2, xmm1
movdqa xmm3, xmm1
punpcklbw xmm3, xmm2
punpcklbw xmm1, xmm2
pxor xmm2, xmm2
movdqa xmm4, xmm2
movdqa xmm5, xmm3
pshufd xmm1, xmm1, 4Eh ; 'N'
pcmpgtw xmm4, xmm3
pcmpgtw xmm2, xmm1
punpcklwd xmm5, xmm4
punpcklwd xmm3, xmm4
psubd xmm0, xmm5
pshufd xmm3, xmm3, 4Eh ; 'N'
psubd xmm0, xmm3
movdqa xmm3, xmm1
punpcklwd xmm1, xmm2
punpcklwd xmm3, xmm2
pshufd xmm1, xmm1, 4Eh ; 'N'
psubd xmm0, xmm3
psubd xmm0, xmm1
movd ecx, xmm0
pshufd xmm6, xmm0, 0E5h
movd edx, xmm6
add ecx, edx
mov edx, r9d
and edx, 0FFFFFFF8h
add r8d, edx
and r9d, 7
jz loc_1455
loc_13CB:
movsxd rdx, r8d
cmp bpl, [rbx+rdx]
jz loc_1570
loc_13D8:
lea edx, [r8+1]
cmp edi, edx
jle short loc_1455
movsxd rdx, edx
cmp bpl, [rbx+rdx]
jz loc_1588
loc_13ED:
lea edx, [r8+2]
cmp edi, edx
jle short loc_1455
movsxd rdx, edx
cmp bpl, [rbx+rdx]
jz loc_1598
loc_1402:
lea edx, [r8+3]
cmp edi, edx
jle short loc_1455
movsxd rdx, edx
cmp bpl, [rbx+rdx]
jz loc_15B0
lea edx, [r8+4]
cmp edi, edx
jle short loc_1455
loc_141F:
movsxd rdx, edx
cmp bpl, [rbx+rdx]
jnz short loc_142B
add ecx, 1
loc_142B:
lea edx, [r8+5]
cmp edi, edx
jle short loc_1455
movsxd rdx, edx
cmp bpl, [rbx+rdx]
jnz short loc_143F
add ecx, 1
loc_143F:
add r8d, 6
cmp edi, r8d
jle short loc_1455
movsxd r8, r8d
cmp bpl, [rbx+r8]
jz loc_15D8
loc_1455:
imul ecx, eax
loc_1458:
mov eax, 0Ah
xor edx, edx
idiv esi
test edx, edx
jz loc_1565
lea eax, [rdx-1]
cmp eax, 6
jbe loc_15F7
movzx eax, bpl
movq xmm1, qword ptr [rbx]
pxor xmm2, xmm2
mov ah, al
movdqa xmm4, xmm2
movd xmm6, eax
pshuflw xmm0, xmm6, 0
pcmpeqb xmm1, xmm0
pxor xmm0, xmm0
pcmpgtb xmm0, xmm1
movdqa xmm3, xmm1
punpcklbw xmm3, xmm0
punpcklbw xmm1, xmm0
movq xmm0, cs:qword_2080
pcmpgtw xmm4, xmm3
movdqa xmm5, xmm3
pshufd xmm1, xmm1, 4Eh ; 'N'
pcmpgtw xmm2, xmm1
punpcklwd xmm5, xmm4
punpcklwd xmm3, xmm4
pshufd xmm3, xmm3, 4Eh ; 'N'
pand xmm0, xmm5
psubd xmm0, xmm3
movdqa xmm3, xmm1
punpcklwd xmm1, xmm2
punpcklwd xmm3, xmm2
pshufd xmm1, xmm1, 4Eh ; 'N'
psubd xmm0, xmm3
psubd xmm0, xmm1
movd esi, xmm0
pshufd xmm6, xmm0, 0E5h
movd eax, xmm6
add eax, esi
add ecx, eax
mov eax, 8
cmp edx, 8
jz short loc_1565
loc_150A:
movsxd rsi, eax
cmp [rbx+rsi], bpl
jnz short loc_1516
add ecx, 1
loc_1516:
lea esi, [rax+1]
cmp edx, esi
jle short loc_1565
movsxd rsi, esi
cmp bpl, [rbx+rsi]
jz short loc_1580
loc_1526:
add eax, 2
cmp eax, edx
jge short loc_1565
cmp bpl, [rbx+2]
jz short loc_1590
loc_1533:
cmp edx, 3
jz short loc_1565
cmp bpl, [rbx+3]
jz short loc_15A0
cmp edx, 4
jz short loc_1565
loc_1543:
cmp bpl, [rbx+4]
jnz short loc_154C
add ecx, 1
loc_154C:
cmp edx, 5
jz short loc_1565
cmp bpl, [rbx+5]
jnz short loc_155A
add ecx, 1
loc_155A:
cmp edx, 6
jz short loc_1565
cmp bpl, [rbx+6]
jz short loc_15C8
loc_1565:
add rsp, 8
mov eax, ecx
pop rbx
pop rbp
retn
loc_1570:
add ecx, 1
jmp loc_13D8
loc_1580:
add ecx, 1
jmp short loc_1526
loc_1588:
add ecx, 1
jmp loc_13ED
loc_1590:
add ecx, 1
jmp short loc_1533
loc_1598:
add ecx, 1
jmp loc_1402
loc_15A0:
add ecx, 1
cmp edx, 4
jnz short loc_1543
jmp short loc_1565
loc_15B0:
lea edx, [r8+4]
add ecx, 1
cmp edi, edx
jg loc_141F
jmp loc_1455
loc_15C8:
add rsp, 8
add ecx, 1
mov eax, ecx
pop rbx
pop rbp
retn
loc_15D8:
add ecx, 1
jmp loc_1455
loc_15E0:
xor ecx, ecx
jmp loc_1458
loc_15E7:
pxor xmm0, xmm0
xor edx, edx
xor r8d, r8d
xor ecx, ecx
jmp loc_1322
loc_15F7:
xor eax, eax
jmp loc_150A | long long func0(const __m128i *a1, unsigned __int8 a2)
{
int v3; // edi
__m128i v4; // xmm4
__m128i v5; // xmm1
const __m128i *v6; // rdx
__m128i v7; // xmm4
__m128i v8; // xmm4
__m128i v9; // xmm0
__m128i v10; // xmm0
__m128i v11; // xmm3
__m128i v12; // xmm2
__m128i v13; // xmm0
__m128i v14; // xmm3
__m128i v15; // xmm1
__m128i v16; // xmm2
long long v17; // rdx
__m128i v18; // xmm0
signed int v19; // r8d
int v20; // ecx
__m128i v21; // xmm0
int v22; // r9d
__m128i v23; // xmm1
unsigned int v24; // edx
__m128i v25; // xmm1
__m128i v26; // xmm3
__m128i v27; // xmm1
__m128i v28; // xmm2
__m128i v29; // xmm3
__m128i v30; // xmm0
int v31; // edx
int v32; // r8d
unsigned int v33; // ecx
int v34; // edx
unsigned int v35; // eax
__m128i v36; // xmm1
__m128i v37; // xmm3
__m128i v38; // xmm1
__m128i v39; // xmm2
__m128i v40; // xmm5
__m128i v41; // xmm0
int v42; // eax
v3 = strlen(a1->m128i_i8);
if ( v3 > 0 )
{
if ( (unsigned int)(v3 - 1) <= 0xE )
{
v21 = 0LL;
v17 = 0LL;
v19 = 0;
v20 = 0;
}
else
{
v4 = _mm_cvtsi32_si128(a2);
v5 = 0LL;
v6 = a1;
v7 = _mm_unpacklo_epi8(v4, v4);
v8 = _mm_shuffle_epi32(_mm_unpacklo_epi16(v7, v7), 0);
do
{
v9 = _mm_loadu_si128(v6++);
v10 = _mm_cmpeq_epi8(v9, v8);
v11 = _mm_cmpgt_epi8((__m128i)0LL, v10);
v12 = _mm_unpacklo_epi8(v10, v11);
v13 = _mm_unpackhi_epi8(v10, v11);
v14 = _mm_cmpgt_epi16((__m128i)0LL, v12);
v15 = _mm_sub_epi32(_mm_sub_epi32(v5, _mm_unpacklo_epi16(v12, v14)), _mm_unpackhi_epi16(v12, v14));
v16 = _mm_cmpgt_epi16((__m128i)0LL, v13);
v5 = _mm_sub_epi32(_mm_sub_epi32(v15, _mm_unpacklo_epi16(v13, v16)), _mm_unpackhi_epi16(v13, v16));
}
while ( &a1[(unsigned int)v3 >> 4] != v6 );
v17 = v3 & 0xFFFFFFF0;
v18 = _mm_add_epi32(_mm_srli_si128(v5, 8), v5);
v19 = v3 & 0xFFFFFFF0;
v20 = _mm_cvtsi128_si32(_mm_add_epi32(v18, _mm_srli_si128(v18, 4)));
v21 = _mm_add_epi32(v5, _mm_srli_si128(v5, 8));
if ( (v3 & 0xF) == 0 )
goto LABEL_27;
}
v22 = v3 - v17;
if ( (unsigned int)(v3 - v17 - 1) > 6 )
{
v23 = _mm_loadl_epi64((const __m128i *)((char *)a1 + v17));
v24 = a2;
BYTE1(v24) = a2;
v25 = _mm_cmpeq_epi8(v23, _mm_shufflelo_epi16(_mm_cvtsi32_si128(v24), 0));
v26 = _mm_unpacklo_epi8(v25, _mm_cmpgt_epi8((__m128i)0LL, v25));
v27 = _mm_shuffle_epi32(v26, 78);
v28 = _mm_cmpgt_epi16((__m128i)0LL, v27);
v29 = _mm_unpacklo_epi16(v26, _mm_cmpgt_epi16((__m128i)0LL, v26));
v30 = _mm_sub_epi32(
_mm_sub_epi32(
_mm_sub_epi32(_mm_sub_epi32(v21, v29), _mm_shuffle_epi32(v29, 78)),
_mm_unpacklo_epi16(v27, v28)),
_mm_shuffle_epi32(_mm_unpacklo_epi16(v27, v28), 78));
v20 = _mm_cvtsi128_si32(_mm_shuffle_epi32(v30, 229)) + _mm_cvtsi128_si32(v30);
v19 += v22 & 0xFFFFFFF8;
if ( (v22 & 7) == 0 )
goto LABEL_27;
}
if ( a2 == a1->m128i_i8[v19] )
++v20;
if ( v3 <= v19 + 1 )
goto LABEL_27;
if ( a2 == a1->m128i_i8[v19 + 1] )
++v20;
if ( v3 <= v19 + 2 )
goto LABEL_27;
if ( a2 == a1->m128i_i8[v19 + 2] )
++v20;
if ( v3 <= v19 + 3 )
goto LABEL_27;
if ( a2 == a1->m128i_i8[v19 + 3] )
{
v31 = v19 + 4;
++v20;
if ( v3 > v19 + 4 )
goto LABEL_19;
}
else
{
v31 = v19 + 4;
if ( v3 > v19 + 4 )
{
LABEL_19:
if ( a2 == a1->m128i_i8[v31] )
++v20;
if ( v3 > v19 + 5 )
{
if ( a2 == a1->m128i_i8[v19 + 5] )
++v20;
v32 = v19 + 6;
if ( v3 > v32 && a2 == a1->m128i_i8[v32] )
++v20;
}
}
}
LABEL_27:
v33 = 10 / v3 * v20;
goto LABEL_28;
}
v33 = 0;
LABEL_28:
v34 = 10 % v3;
if ( !(10 % v3) )
return v33;
if ( (unsigned int)(v34 - 1) <= 6 )
{
v42 = 0;
}
else
{
v35 = a2;
BYTE1(v35) = a2;
v36 = _mm_cmpeq_epi8(_mm_loadl_epi64(a1), _mm_shufflelo_epi16(_mm_cvtsi32_si128(v35), 0));
v37 = _mm_unpacklo_epi8(v36, _mm_cmpgt_epi8((__m128i)0LL, v36));
v38 = _mm_shuffle_epi32(v37, 78);
v39 = _mm_cmpgt_epi16((__m128i)0LL, v38);
v40 = _mm_unpacklo_epi16(v37, _mm_cmpgt_epi16((__m128i)0LL, v37));
v41 = _mm_sub_epi32(
_mm_sub_epi32(
_mm_sub_epi32(
_mm_and_si128(_mm_loadl_epi64((const __m128i *)&qword_2080), v40),
_mm_shuffle_epi32(v40, 78)),
_mm_unpacklo_epi16(v38, v39)),
_mm_shuffle_epi32(_mm_unpacklo_epi16(v38, v39), 78));
v33 += _mm_cvtsi128_si32(v41) + _mm_cvtsi128_si32(_mm_shuffle_epi32(v41, 229));
v42 = 8;
if ( v34 == 8 )
return v33;
}
if ( a1->m128i_i8[v42] == a2 )
++v33;
if ( v34 <= v42 + 1 )
return v33;
if ( a2 == a1->m128i_i8[v42 + 1] )
++v33;
if ( v42 + 2 >= v34 )
return v33;
if ( a2 == a1->m128i_i8[2] )
++v33;
if ( v34 == 3 )
return v33;
if ( a2 != a1->m128i_i8[3] )
{
if ( v34 != 4 )
goto LABEL_42;
return v33;
}
++v33;
if ( v34 == 4 )
return v33;
LABEL_42:
if ( a2 == a1->m128i_i8[4] )
++v33;
if ( v34 == 5 )
return v33;
if ( a2 == a1->m128i_i8[5] )
++v33;
if ( v34 == 6 || a2 != a1->m128i_i8[6] )
return v33;
return v33 + 1;
} | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
XOR EDX,EDX
MOV RDI,RAX
MOV ESI,EAX
MOV EAX,0xa
IDIV EDI
TEST EDI,EDI
JLE 0x001015e0
LEA EDX,[RDI + -0x1]
CMP EDX,0xe
JBE 0x001015e7
MOVD XMM4,EBP
MOV ECX,EDI
PXOR XMM1,XMM1
MOV RDX,RBX
PUNPCKLBW XMM4,XMM4
SHR ECX,0x4
PXOR XMM6,XMM6
PXOR XMM5,XMM5
PUNPCKLWD XMM4,XMM4
SHL RCX,0x4
PSHUFD XMM4,XMM4,0x0
ADD RCX,RBX
NOP word ptr [RAX + RAX*0x1]
LAB_00101288:
MOVDQU XMM0,xmmword ptr [RDX]
MOVDQA XMM3,XMM6
ADD RDX,0x10
PCMPEQB XMM0,XMM4
PCMPGTB XMM3,XMM0
MOVDQA XMM2,XMM0
PUNPCKLBW XMM2,XMM3
PUNPCKHBW XMM0,XMM3
MOVDQA XMM3,XMM5
PCMPGTW XMM3,XMM2
MOVDQA XMM7,XMM2
PUNPCKLWD XMM7,XMM3
PUNPCKHWD XMM2,XMM3
MOVDQA XMM3,XMM0
PSUBD XMM1,XMM7
PSUBD XMM1,XMM2
MOVDQA XMM2,XMM5
PCMPGTW XMM2,XMM0
PUNPCKLWD XMM3,XMM2
PUNPCKHWD XMM0,XMM2
PSUBD XMM1,XMM3
PSUBD XMM1,XMM0
CMP RCX,RDX
JNZ 0x00101288
MOVDQA XMM0,XMM1
MOV EDX,EDI
PSRLDQ XMM0,0x8
AND EDX,0xfffffff0
PADDD XMM0,XMM1
MOV R8D,EDX
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
PADDD XMM0,XMM2
MOVD ECX,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
TEST DIL,0xf
JZ 0x00101455
LAB_00101322:
MOV R9D,EDI
SUB R9D,EDX
LEA R10D,[R9 + -0x1]
CMP R10D,0x6
JBE 0x001013cb
MOVQ XMM1,qword ptr [RBX + RDX*0x1]
MOVZX EDX,BPL
MOV DH,DL
MOVD XMM6,EDX
PSHUFLW XMM2,XMM6,0x0
PCMPEQB XMM1,XMM2
PXOR XMM2,XMM2
PCMPGTB XMM2,XMM1
MOVDQA XMM3,XMM1
PUNPCKLBW XMM3,XMM2
PUNPCKLBW XMM1,XMM2
PXOR XMM2,XMM2
MOVDQA XMM4,XMM2
MOVDQA XMM5,XMM3
PSHUFD XMM1,XMM1,0x4e
PCMPGTW XMM4,XMM3
PCMPGTW XMM2,XMM1
PUNPCKLWD XMM5,XMM4
PUNPCKLWD XMM3,XMM4
PSUBD XMM0,XMM5
PSHUFD XMM3,XMM3,0x4e
PSUBD XMM0,XMM3
MOVDQA XMM3,XMM1
PUNPCKLWD XMM1,XMM2
PUNPCKLWD XMM3,XMM2
PSHUFD XMM1,XMM1,0x4e
PSUBD XMM0,XMM3
PSUBD XMM0,XMM1
MOVD ECX,XMM0
PSHUFD XMM6,XMM0,0xe5
MOVD EDX,XMM6
ADD ECX,EDX
MOV EDX,R9D
AND EDX,0xfffffff8
ADD R8D,EDX
AND R9D,0x7
JZ 0x00101455
LAB_001013cb:
MOVSXD RDX,R8D
CMP BPL,byte ptr [RBX + RDX*0x1]
JZ 0x00101570
LAB_001013d8:
LEA EDX,[R8 + 0x1]
CMP EDI,EDX
JLE 0x00101455
MOVSXD RDX,EDX
CMP BPL,byte ptr [RBX + RDX*0x1]
JZ 0x00101588
LAB_001013ed:
LEA EDX,[R8 + 0x2]
CMP EDI,EDX
JLE 0x00101455
MOVSXD RDX,EDX
CMP BPL,byte ptr [RBX + RDX*0x1]
JZ 0x00101598
LAB_00101402:
LEA EDX,[R8 + 0x3]
CMP EDI,EDX
JLE 0x00101455
MOVSXD RDX,EDX
CMP BPL,byte ptr [RBX + RDX*0x1]
JZ 0x001015b0
LEA EDX,[R8 + 0x4]
CMP EDI,EDX
JLE 0x00101455
LAB_0010141f:
MOVSXD RDX,EDX
CMP BPL,byte ptr [RBX + RDX*0x1]
JNZ 0x0010142b
ADD ECX,0x1
LAB_0010142b:
LEA EDX,[R8 + 0x5]
CMP EDI,EDX
JLE 0x00101455
MOVSXD RDX,EDX
CMP BPL,byte ptr [RBX + RDX*0x1]
JNZ 0x0010143f
ADD ECX,0x1
LAB_0010143f:
ADD R8D,0x6
CMP EDI,R8D
JLE 0x00101455
MOVSXD R8,R8D
CMP BPL,byte ptr [RBX + R8*0x1]
JZ 0x001015d8
LAB_00101455:
IMUL ECX,EAX
LAB_00101458:
MOV EAX,0xa
XOR EDX,EDX
IDIV ESI
TEST EDX,EDX
JZ 0x00101565
LEA EAX,[RDX + -0x1]
CMP EAX,0x6
JBE 0x001015f7
MOVZX EAX,BPL
MOVQ XMM1,qword ptr [RBX]
PXOR XMM2,XMM2
MOV AH,AL
MOVDQA XMM4,XMM2
MOVD XMM6,EAX
PSHUFLW XMM0,XMM6,0x0
PCMPEQB XMM1,XMM0
PXOR XMM0,XMM0
PCMPGTB XMM0,XMM1
MOVDQA XMM3,XMM1
PUNPCKLBW XMM3,XMM0
PUNPCKLBW XMM1,XMM0
MOVQ XMM0,qword ptr [0x00102080]
PCMPGTW XMM4,XMM3
MOVDQA XMM5,XMM3
PSHUFD XMM1,XMM1,0x4e
PCMPGTW XMM2,XMM1
PUNPCKLWD XMM5,XMM4
PUNPCKLWD XMM3,XMM4
PSHUFD XMM3,XMM3,0x4e
PAND XMM0,XMM5
PSUBD XMM0,XMM3
MOVDQA XMM3,XMM1
PUNPCKLWD XMM1,XMM2
PUNPCKLWD XMM3,XMM2
PSHUFD XMM1,XMM1,0x4e
PSUBD XMM0,XMM3
PSUBD XMM0,XMM1
MOVD ESI,XMM0
PSHUFD XMM6,XMM0,0xe5
MOVD EAX,XMM6
ADD EAX,ESI
ADD ECX,EAX
MOV EAX,0x8
CMP EDX,0x8
JZ 0x00101565
LAB_0010150a:
MOVSXD RSI,EAX
CMP byte ptr [RBX + RSI*0x1],BPL
JNZ 0x00101516
ADD ECX,0x1
LAB_00101516:
LEA ESI,[RAX + 0x1]
CMP EDX,ESI
JLE 0x00101565
MOVSXD RSI,ESI
CMP BPL,byte ptr [RBX + RSI*0x1]
JZ 0x00101580
LAB_00101526:
ADD EAX,0x2
CMP EAX,EDX
JGE 0x00101565
CMP BPL,byte ptr [RBX + 0x2]
JZ 0x00101590
LAB_00101533:
CMP EDX,0x3
JZ 0x00101565
CMP BPL,byte ptr [RBX + 0x3]
JZ 0x001015a0
CMP EDX,0x4
JZ 0x00101565
LAB_00101543:
CMP BPL,byte ptr [RBX + 0x4]
JNZ 0x0010154c
ADD ECX,0x1
LAB_0010154c:
CMP EDX,0x5
JZ 0x00101565
CMP BPL,byte ptr [RBX + 0x5]
JNZ 0x0010155a
ADD ECX,0x1
LAB_0010155a:
CMP EDX,0x6
JZ 0x00101565
CMP BPL,byte ptr [RBX + 0x6]
JZ 0x001015c8
LAB_00101565:
ADD RSP,0x8
MOV EAX,ECX
POP RBX
POP RBP
RET
LAB_00101570:
ADD ECX,0x1
JMP 0x001013d8
LAB_00101580:
ADD ECX,0x1
JMP 0x00101526
LAB_00101588:
ADD ECX,0x1
JMP 0x001013ed
LAB_00101590:
ADD ECX,0x1
JMP 0x00101533
LAB_00101598:
ADD ECX,0x1
JMP 0x00101402
LAB_001015a0:
ADD ECX,0x1
CMP EDX,0x4
JNZ 0x00101543
JMP 0x00101565
LAB_001015b0:
LEA EDX,[R8 + 0x4]
ADD ECX,0x1
CMP EDI,EDX
JG 0x0010141f
JMP 0x00101455
LAB_001015c8:
ADD RSP,0x8
ADD ECX,0x1
MOV EAX,ECX
POP RBX
POP RBP
RET
LAB_001015d8:
ADD ECX,0x1
JMP 0x00101455
LAB_001015e0:
XOR ECX,ECX
JMP 0x00101458
LAB_001015e7:
PXOR XMM0,XMM0
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
JMP 0x00101322
LAB_001015f7:
XOR EAX,EAX
JMP 0x0010150a | int func0(char *param_1,char param_2)
{
bool bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
char *pcVar9;
char *pcVar10;
char *pcVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pcVar16;
char *pcVar17;
char *pcVar18;
char *pcVar19;
char *pcVar20;
char *pcVar21;
char *pcVar22;
char *pcVar23;
int auVar24 [14];
int auVar25 [12];
unkbyte10 Var26;
int auVar27 [12];
int auVar28 [14];
int auVar29 [12];
int auVar30 [16];
int auVar31 [16];
int auVar32 [16];
int auVar33 [12];
int auVar34 [12];
int auVar35 [14];
int auVar36 [12];
int auVar37 [16];
int auVar38 [16];
int auVar39 [16];
unkbyte9 Var40;
int6 uVar41;
int4 uVar42;
int2 uVar43;
uint uVar44;
size_t sVar45;
uint uVar46;
char *pcVar47;
uint uVar48;
int4 uVar49;
int iVar50;
int auVar54 [12];
char cVar60;
short sVar61;
int extraout_XMM0 [16];
int auVar57 [16];
int auVar58 [16];
int auVar59 [16];
int iVar62;
int auVar63 [12];
int auVar64 [12];
char cVar75;
short sVar76;
char cVar79;
int iVar77;
char cVar78;
char cVar80;
int iVar81;
int iVar83;
int auVar65 [16];
int auVar66 [16];
int auVar70 [16];
int auVar71 [16];
int iVar84;
char cVar89;
char cVar90;
char cVar91;
char cVar92;
char cVar93;
char cVar94;
short sVar95;
short sVar96;
int in_XMM2 [16];
int auVar86 [16];
int auVar88 [16];
int2 uVar129;
short sVar118;
int auVar97 [16];
int auVar103 [16];
int auVar106 [16];
int auVar110 [16];
int auVar111 [16];
int auVar114 [16];
int auVar119 [16];
int auVar122 [16];
int auVar126 [16];
int6 uVar51;
int8 uVar52;
int auVar53 [12];
int auVar55 [14];
int auVar56 [16];
int auVar67 [16];
int auVar68 [16];
int auVar72 [16];
int auVar69 [16];
int auVar73 [16];
int2 uVar74;
long lVar82;
int auVar85 [12];
int auVar87 [16];
int auVar98 [16];
int auVar99 [16];
int auVar107 [16];
int auVar115 [16];
int auVar100 [16];
int auVar104 [16];
int auVar108 [16];
int auVar112 [16];
int auVar116 [16];
int auVar101 [16];
int auVar105 [16];
int auVar109 [16];
int auVar113 [16];
int auVar117 [16];
int auVar102 [16];
int auVar123 [16];
int auVar120 [16];
int auVar124 [16];
int auVar121 [16];
int auVar125 [16];
int auVar127 [16];
int auVar128 [16];
sVar45 = strlen(param_1);
uVar44 = (uint)sVar45;
if ((int)uVar44 < 1) {
iVar50 = 0;
auVar58 = extraout_XMM0;
goto LAB_00101458;
}
if (uVar44 - 1 < 0xf) {
auVar58 = (int [16])0x0;
uVar46 = 0;
iVar50 = 0;
LAB_00101322:
uVar48 = uVar44 - uVar46;
if (6 < uVar48 - 1) {
uVar52 = *(int8 *)(param_1 + uVar46);
auVar88 = pshuflw(in_XMM2,ZEXT216(CONCAT11(param_2,param_2)),0);
bVar1 = (char)uVar52 == auVar88[0];
auVar65[0] = -bVar1;
bVar5 = (char)((ulong)uVar52 >> 8) == auVar88[1];
cVar60 = -bVar5;
bVar6 = (char)((ulong)uVar52 >> 0x10) == auVar88[2];
bVar7 = (char)((ulong)uVar52 >> 0x18) == auVar88[3];
bVar8 = (char)((ulong)uVar52 >> 0x20) == auVar88[4];
cVar75 = -bVar8;
bVar2 = (char)((ulong)uVar52 >> 0x28) == auVar88[5];
cVar78 = -bVar2;
bVar3 = (char)((ulong)uVar52 >> 0x30) == auVar88[6];
cVar79 = -bVar3;
bVar4 = (char)((ulong)uVar52 >> 0x38) == auVar88[7];
cVar80 = -bVar4;
cVar89 = -bVar5;
cVar90 = -bVar7;
cVar91 = -bVar8;
cVar92 = -bVar2;
cVar93 = -bVar3;
cVar94 = -bVar4;
Var26 = CONCAT91(CONCAT81((long)(CONCAT72(CONCAT61(CONCAT51(CONCAT41(CONCAT31(CONCAT21(
CONCAT11(cVar94,cVar80),cVar93),cVar79),cVar92),
cVar78),cVar91),CONCAT11(cVar75,cVar80)) >> 8),
cVar90),-bVar7);
auVar29._2_10_ = Var26;
auVar29[1] = -bVar6;
auVar29[0] = -bVar6;
auVar28._2_12_ = auVar29;
auVar28[1] = cVar89;
auVar28[0] = cVar60;
uVar129 = CONCAT11(-bVar1,auVar65[0]);
auVar102._2_14_ = auVar28;
uVar43 = CONCAT11(cVar94,cVar80);
uVar42 = CONCAT31(CONCAT21(uVar43,cVar93),cVar79);
uVar41 = CONCAT51(CONCAT41(uVar42,cVar92),cVar78);
Var40 = CONCAT72(CONCAT61(uVar41,cVar91),CONCAT11(cVar75,cVar80));
lVar82 = (long)((unkuint9)Var40 >> 8);
auVar32._1_8_ = lVar82;
auVar32[0] = cVar90;
auVar32._9_7_ = 0;
auVar31._10_6_ = 0;
auVar31._0_10_ = SUB1610(auVar32 << 0x38,6);
auVar30._11_5_ = 0;
auVar30._0_11_ = SUB1611(auVar31 << 0x30,5);
auVar65._4_12_ = SUB1612(auVar30 << 0x28,4);
auVar65[3] = cVar89;
auVar65[2] = cVar60;
auVar65[1] = -bVar1;
iVar81 = (int)((unkuint9)Var40 >> 8);
auVar63._8_4_ = auVar65._0_4_;
auVar63._0_8_ = lVar82;
sVar95 = auVar28._0_2_;
sVar96 = auVar29._0_2_;
sVar118 = (short)Var26;
sVar61 = (short)((unkuint9)Var40 >> 8);
sVar76 = (short)uVar42;
auVar121._0_12_ = auVar102._0_12_;
auVar121._12_2_ = sVar118;
auVar121._14_2_ = -(ushort)(sVar118 < 0);
auVar120._12_4_ = auVar121._12_4_;
auVar120._0_10_ = auVar102._0_10_;
auVar120._10_2_ = -(ushort)(sVar96 < 0);
auVar119._10_6_ = auVar120._10_6_;
auVar119._0_8_ = auVar102._0_8_;
auVar119._8_2_ = sVar96;
auVar33._4_8_ = auVar119._8_8_;
auVar33._2_2_ = -(ushort)(sVar95 < 0);
auVar33._0_2_ = sVar95;
auVar105._12_2_ = sVar118;
auVar105._0_12_ = auVar121._0_12_;
auVar105._14_2_ = -(ushort)(sVar118 < 0);
auVar104._12_4_ = auVar105._12_4_;
auVar104._10_2_ = -(ushort)(sVar96 < 0);
auVar104._0_10_ = auVar120._0_10_;
auVar103._10_6_ = auVar104._10_6_;
auVar103._8_2_ = sVar96;
auVar103._0_8_ = auVar119._0_8_;
auVar34._4_8_ = auVar103._8_8_;
auVar34._2_2_ = -(ushort)(sVar95 < 0);
auVar34._0_2_ = sVar95;
iVar50 = auVar58._4_4_;
iVar62 = auVar58._8_4_;
iVar77 = auVar58._12_4_;
auVar69._12_2_ = uVar43;
auVar69._0_12_ = auVar63;
auVar69._14_2_ = -(ushort)(lVar82 < 0);
auVar68._12_4_ = auVar69._12_4_;
auVar68._0_10_ = auVar63._0_10_;
auVar68._10_2_ = -(ushort)(sVar76 < 0);
auVar67._10_6_ = auVar68._10_6_;
auVar67._8_2_ = sVar76;
auVar67._0_8_ = lVar82;
auVar66._8_8_ = auVar67._8_8_;
auVar66._6_2_ = -(ushort)(iVar81 < 0);
uVar74 = (int2)uVar41;
auVar66._4_2_ = uVar74;
auVar66._0_4_ = iVar81;
auVar109._12_2_ = uVar43;
auVar109._0_12_ = auVar63;
auVar109._14_2_ = -(ushort)(lVar82 < 0);
auVar108._12_4_ = auVar109._12_4_;
auVar108._10_2_ = -(ushort)(sVar76 < 0);
auVar108._0_10_ = auVar68._0_10_;
auVar107._10_6_ = auVar108._10_6_;
auVar107._8_2_ = sVar76;
auVar107._0_8_ = lVar82;
auVar106._8_8_ = auVar107._8_8_;
auVar106._6_2_ = -(ushort)(iVar81 < 0);
auVar106._4_2_ = uVar74;
auVar106._0_4_ = iVar81;
auVar58._0_4_ =
(((auVar58._0_4_ - CONCAT22(-(ushort)bVar1,uVar129)) - auVar103._8_4_) -
CONCAT22(-(ushort)(sVar61 < 0),sVar61)) - auVar67._8_4_;
auVar58._4_4_ =
(((iVar50 - auVar33._0_4_) - auVar104._12_4_) - auVar106._4_4_) - auVar68._12_4_;
auVar58._8_4_ =
(((iVar62 - auVar119._8_4_) - CONCAT22(-(ushort)bVar1,uVar129)) - auVar107._8_4_) -
CONCAT22(-(ushort)(sVar61 < 0),sVar61);
auVar58._12_4_ =
(((iVar77 - auVar120._12_4_) - auVar34._0_4_) - auVar108._12_4_) - auVar66._4_4_;
iVar50 = auVar58._0_4_ + auVar58._4_4_;
uVar46 = uVar46 + (uVar48 & 0xfffffff8);
if ((uVar48 & 7) == 0) goto LAB_00101455;
}
if (param_2 == param_1[(int)uVar46]) {
iVar50 = iVar50 + 1;
}
if ((int)(uVar46 + 1) < (int)uVar44) {
if (param_2 == param_1[(int)(uVar46 + 1)]) {
iVar50 = iVar50 + 1;
}
if ((int)(uVar46 + 2) < (int)uVar44) {
if (param_2 == param_1[(int)(uVar46 + 2)]) {
iVar50 = iVar50 + 1;
}
if ((int)(uVar46 + 3) < (int)uVar44) {
if (param_2 == param_1[(int)(uVar46 + 3)]) {
iVar50 = iVar50 + 1;
}
if ((int)(uVar46 + 4) < (int)uVar44) {
if (param_2 == param_1[(int)(uVar46 + 4)]) {
iVar50 = iVar50 + 1;
}
if ((int)(uVar46 + 5) < (int)uVar44) {
if (param_2 == param_1[(int)(uVar46 + 5)]) {
iVar50 = iVar50 + 1;
}
if (((int)(uVar46 + 6) < (int)uVar44) && (param_2 == param_1[(int)(uVar46 + 6)])) {
iVar50 = iVar50 + 1;
}
}
}
}
}
}
}
else {
iVar62 = 0;
iVar77 = 0;
iVar81 = 0;
iVar83 = 0;
pcVar47 = param_1;
do {
cVar60 = *pcVar47;
pcVar9 = pcVar47 + 1;
pcVar10 = pcVar47 + 2;
pcVar11 = pcVar47 + 3;
pcVar12 = pcVar47 + 4;
pcVar13 = pcVar47 + 5;
pcVar14 = pcVar47 + 6;
pcVar15 = pcVar47 + 7;
pcVar16 = pcVar47 + 8;
pcVar17 = pcVar47 + 9;
pcVar18 = pcVar47 + 10;
pcVar19 = pcVar47 + 0xb;
pcVar20 = pcVar47 + 0xc;
pcVar21 = pcVar47 + 0xd;
pcVar22 = pcVar47 + 0xe;
pcVar23 = pcVar47 + 0xf;
pcVar47 = pcVar47 + 0x10;
bVar1 = cVar60 == param_2;
cVar60 = -(*pcVar15 == param_2);
bVar5 = *pcVar16 == param_2;
bVar6 = *pcVar17 == param_2;
bVar7 = *pcVar18 == param_2;
bVar8 = *pcVar19 == param_2;
uVar43 = CONCAT11(-(*pcVar15 == param_2),cVar60);
uVar42 = CONCAT31(CONCAT21(uVar43,-(*pcVar14 == param_2)),-(*pcVar14 == param_2));
uVar41 = CONCAT51(CONCAT41(uVar42,-(*pcVar13 == param_2)),-(*pcVar13 == param_2));
Var40 = CONCAT72(CONCAT61(uVar41,-(*pcVar12 == param_2)),
CONCAT11(-(*pcVar12 == param_2),cVar60));
lVar82 = (long)((unkuint9)Var40 >> 8);
Var26 = CONCAT91(CONCAT81(lVar82,-(*pcVar11 == param_2)),-(*pcVar11 == param_2));
auVar25._2_10_ = Var26;
auVar25[1] = -(*pcVar10 == param_2);
auVar25[0] = -(*pcVar10 == param_2);
auVar24._2_12_ = auVar25;
auVar24[1] = -(*pcVar9 == param_2);
auVar24[0] = -(*pcVar9 == param_2);
auVar86._0_2_ = CONCAT11(-bVar1,-bVar1);
auVar86._2_14_ = auVar24;
uVar49 = CONCAT13(-bVar6,CONCAT12(-bVar6,CONCAT11(-bVar5,-bVar5)));
uVar51 = CONCAT15(-bVar7,CONCAT14(-bVar7,uVar49));
uVar52 = CONCAT17(-bVar8,CONCAT16(-bVar8,uVar51));
auVar53._0_10_ = CONCAT19(-(*pcVar20 == param_2),CONCAT18(-(*pcVar20 == param_2),uVar52));
auVar53[10] = -(*pcVar21 == param_2);
auVar53[0xb] = -(*pcVar21 == param_2);
auVar55[0xc] = -(*pcVar22 == param_2);
auVar55._0_12_ = auVar53;
auVar55[0xd] = -(*pcVar22 == param_2);
auVar88[0xe] = -(*pcVar23 == param_2);
auVar88._0_14_ = auVar55;
auVar88[0xf] = -(*pcVar23 == param_2);
sVar61 = (short)Var26;
sVar76 = (short)((unkuint9)Var40 >> 8);
sVar95 = (short)uVar41;
sVar96 = (short)uVar42;
auVar128._0_12_ = auVar86._0_12_;
auVar128._12_2_ = sVar61;
auVar128._14_2_ = -(ushort)(sVar61 < 0);
auVar127._12_4_ = auVar128._12_4_;
auVar127._0_10_ = auVar86._0_10_;
auVar127._10_2_ = -(ushort)(auVar25._0_2_ < 0);
auVar126._10_6_ = auVar127._10_6_;
auVar126._0_8_ = auVar86._0_8_;
auVar126._8_2_ = auVar25._0_2_;
auVar27._4_8_ = auVar126._8_8_;
auVar27._2_2_ = -(ushort)(auVar24._0_2_ < 0);
auVar27._0_2_ = auVar24._0_2_;
iVar84 = CONCAT22(-(ushort)(sVar76 < 0),sVar76);
auVar85._0_8_ = CONCAT26(-(ushort)(sVar95 < 0),CONCAT24(sVar95,iVar84));
auVar85._8_2_ = sVar96;
auVar85._10_2_ = -(ushort)(sVar96 < 0);
auVar87._12_2_ = uVar43;
auVar87._0_12_ = auVar85;
auVar87._14_2_ = -(ushort)(lVar82 < 0);
sVar61 = (short)((unkuint10)auVar53._0_10_ >> 0x40);
auVar101._12_2_ = (short)((ulong)uVar52 >> 0x30);
auVar101._0_12_ = auVar53;
auVar101._14_2_ = -(ushort)bVar8;
auVar100._12_4_ = auVar101._12_4_;
auVar100._10_2_ = -(ushort)bVar7;
auVar100._0_10_ = auVar53._0_10_;
auVar99._10_6_ = auVar100._10_6_;
auVar99._8_2_ = (short)((uint6)uVar51 >> 0x20);
auVar99._0_8_ = uVar52;
auVar98._8_8_ = auVar99._8_8_;
auVar98._6_2_ = -(ushort)bVar6;
auVar98._0_6_ = uVar51;
auVar97._6_10_ = auVar98._6_10_;
auVar97._4_2_ = (short)((uint)uVar49 >> 0x10);
auVar97._0_4_ = uVar49;
iVar50 = CONCAT22(-(ushort)(sVar61 < 0),sVar61);
auVar54._0_8_ = CONCAT26(-(ushort)(auVar53._10_2_ < 0),CONCAT24(auVar53._10_2_,iVar50));
auVar54._8_2_ = auVar55._12_2_;
auVar54._10_2_ = -(ushort)(auVar55._12_2_ < 0);
auVar56._12_2_ = auVar88._14_2_;
auVar56._0_12_ = auVar54;
auVar56._14_2_ = -(ushort)(auVar88._14_2_ < 0);
iVar62 = (((iVar62 - CONCAT22(-(ushort)bVar1,auVar86._0_2_)) - iVar84) -
CONCAT22(-(ushort)bVar5,CONCAT11(-bVar5,-bVar5))) - iVar50;
iVar77 = (((iVar77 - auVar27._0_4_) - (int)((ulong)auVar85._0_8_ >> 0x20)) - auVar97._4_4_) -
(int)((ulong)auVar54._0_8_ >> 0x20);
iVar81 = (((iVar81 - auVar126._8_4_) - auVar85._8_4_) - auVar99._8_4_) - auVar54._8_4_;
iVar83 = (((iVar83 - auVar127._12_4_) - auVar87._12_4_) - auVar100._12_4_) - auVar56._12_4_;
} while (param_1 + (sVar45 >> 4 & 0xfffffff) * 0x10 != pcVar47);
uVar46 = uVar44 & 0xfffffff0;
auVar57._0_4_ = iVar81 + iVar62;
auVar57._4_4_ = iVar83 + iVar77;
auVar57._8_4_ = iVar81;
auVar57._12_4_ = iVar83;
in_XMM2 = auVar57 >> 0x20;
iVar50 = auVar57._0_4_ + auVar57._4_4_;
auVar58._0_4_ = iVar62 + iVar81;
auVar58._4_4_ = iVar77 + iVar83;
auVar58._8_4_ = iVar81;
auVar58._12_4_ = iVar83;
if ((sVar45 & 0xf) != 0) goto LAB_00101322;
}
LAB_00101455:
iVar50 = iVar50 * (int)(10 / (long)(int)uVar44);
LAB_00101458:
iVar62 = (int)(10 % (long)(int)uVar44);
if (iVar62 != 0) {
if (iVar62 - 1U < 7) {
iVar77 = 0;
}
else {
uVar52 = *(int8 *)param_1;
auVar58 = pshuflw(auVar58,ZEXT216(CONCAT11(param_2,param_2)),0);
bVar1 = (char)uVar52 == auVar58[0];
auVar70[0] = -bVar1;
bVar5 = (char)((ulong)uVar52 >> 8) == auVar58[1];
cVar90 = -bVar5;
bVar6 = (char)((ulong)uVar52 >> 0x10) == auVar58[2];
bVar7 = (char)((ulong)uVar52 >> 0x18) == auVar58[3];
bVar8 = (char)((ulong)uVar52 >> 0x20) == auVar58[4];
cVar91 = -bVar8;
bVar2 = (char)((ulong)uVar52 >> 0x28) == auVar58[5];
cVar92 = -bVar2;
bVar3 = (char)((ulong)uVar52 >> 0x30) == auVar58[6];
cVar93 = -bVar3;
bVar4 = (char)((ulong)uVar52 >> 0x38) == auVar58[7];
cVar94 = -bVar4;
cVar60 = -bVar5;
cVar75 = -bVar7;
cVar78 = -bVar8;
cVar79 = -bVar2;
cVar80 = -bVar3;
cVar89 = -bVar4;
Var26 = CONCAT91(CONCAT81((long)(CONCAT72(CONCAT61(CONCAT51(CONCAT41(CONCAT31(CONCAT21(
CONCAT11(cVar89,cVar94),cVar80),cVar93),cVar79),
cVar92),cVar78),CONCAT11(cVar91,cVar94)) >> 8),
cVar75),-bVar7);
auVar36._2_10_ = Var26;
auVar36[1] = -bVar6;
auVar36[0] = -bVar6;
auVar35._2_12_ = auVar36;
auVar35[1] = cVar60;
auVar35[0] = cVar90;
auVar110._0_2_ = CONCAT11(-bVar1,auVar70[0]);
auVar110._2_14_ = auVar35;
uVar43 = CONCAT11(cVar89,cVar94);
uVar42 = CONCAT31(CONCAT21(uVar43,cVar80),cVar93);
uVar41 = CONCAT51(CONCAT41(uVar42,cVar79),cVar92);
Var40 = CONCAT72(CONCAT61(uVar41,cVar78),CONCAT11(cVar91,cVar94));
lVar82 = (long)((unkuint9)Var40 >> 8);
auVar39._1_8_ = lVar82;
auVar39[0] = cVar75;
auVar39._9_7_ = 0;
auVar38._10_6_ = 0;
auVar38._0_10_ = SUB1610(auVar39 << 0x38,6);
auVar37._11_5_ = 0;
auVar37._0_11_ = SUB1611(auVar38 << 0x30,5);
auVar70._4_12_ = SUB1612(auVar37 << 0x28,4);
auVar70[3] = cVar60;
auVar70[2] = cVar90;
auVar70[1] = -bVar1;
auVar59._8_8_ = 0;
auVar59._0_8_ = DAT_00102080;
sVar95 = auVar36._0_2_;
sVar96 = (short)Var26;
iVar77 = (int)((unkuint9)Var40 >> 8);
auVar64._8_4_ = auVar70._0_4_;
auVar64._0_8_ = lVar82;
sVar61 = (short)((unkuint9)Var40 >> 8);
sVar76 = (short)uVar42;
auVar125._0_12_ = auVar110._0_12_;
auVar125._12_2_ = sVar96;
auVar125._14_2_ = -(ushort)(sVar96 < 0);
auVar124._12_4_ = auVar125._12_4_;
auVar124._0_10_ = auVar110._0_10_;
auVar124._10_2_ = -(ushort)(sVar95 < 0);
auVar123._10_6_ = auVar124._10_6_;
auVar123._0_8_ = auVar110._0_8_;
auVar123._8_2_ = sVar95;
auVar122._8_8_ = auVar123._8_8_;
auVar122._6_2_ = -(ushort)(auVar35._0_2_ < 0);
auVar122._4_2_ = auVar35._0_2_;
auVar122._2_2_ = -(ushort)bVar1;
auVar122._0_2_ = auVar110._0_2_;
auVar113._12_2_ = sVar96;
auVar113._0_12_ = auVar125._0_12_;
auVar113._14_2_ = -(ushort)(sVar96 < 0);
auVar112._12_4_ = auVar113._12_4_;
auVar112._10_2_ = -(ushort)(sVar95 < 0);
auVar112._0_10_ = auVar124._0_10_;
auVar111._10_6_ = auVar112._10_6_;
auVar111._8_2_ = sVar95;
auVar111._0_8_ = auVar123._0_8_;
auVar73._12_2_ = uVar43;
auVar73._0_12_ = auVar64;
auVar73._14_2_ = -(ushort)(lVar82 < 0);
auVar72._12_4_ = auVar73._12_4_;
auVar72._0_10_ = auVar64._0_10_;
auVar72._10_2_ = -(ushort)(sVar76 < 0);
auVar71._10_6_ = auVar72._10_6_;
auVar71._8_2_ = sVar76;
auVar71._0_8_ = lVar82;
auVar117._12_2_ = uVar43;
auVar117._0_12_ = auVar64;
auVar117._14_2_ = -(ushort)(lVar82 < 0);
auVar116._12_4_ = auVar117._12_4_;
auVar116._10_2_ = -(ushort)(sVar76 < 0);
auVar116._0_10_ = auVar72._0_10_;
auVar115._10_6_ = auVar116._10_6_;
auVar115._8_2_ = sVar76;
auVar115._0_8_ = lVar82;
auVar114._8_8_ = auVar115._8_8_;
auVar114._6_2_ = -(ushort)(iVar77 < 0);
auVar114._4_2_ = (short)uVar41;
auVar114._0_4_ = iVar77;
iVar50 = iVar50 + (((SUB164(auVar59 & auVar122,4) - auVar112._12_4_) - auVar114._4_4_) -
auVar72._12_4_) +
(((SUB164(auVar59 & auVar122,0) - auVar111._8_4_) -
CONCAT22(-(ushort)(sVar61 < 0),sVar61)) - auVar71._8_4_);
iVar77 = 8;
if (iVar62 == 8) {
return iVar50;
}
}
if (param_1[iVar77] == param_2) {
iVar50 = iVar50 + 1;
}
if (iVar77 + 1 < iVar62) {
if (param_2 == param_1[iVar77 + 1]) {
iVar50 = iVar50 + 1;
}
if (iVar77 + 2 < iVar62) {
if (param_2 == param_1[2]) {
iVar50 = iVar50 + 1;
}
if (iVar62 != 3) {
if (param_2 == param_1[3]) {
iVar50 = iVar50 + 1;
}
if (iVar62 != 4) {
if (param_2 == param_1[4]) {
iVar50 = iVar50 + 1;
}
if (iVar62 != 5) {
if (param_2 == param_1[5]) {
iVar50 = iVar50 + 1;
}
if ((iVar62 != 6) && (param_2 == param_1[6])) {
return iVar50 + 1;
}
}
}
}
}
}
}
return iVar50;
} |
6,632 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
bool prime[n + 1];
for (int j = 0; j <= n; j++) {
prime[j] = true;
}
int p = 2;
while (p * p <= n) {
if (prime[p] == true) {
int i = p * 2;
while (i <= n) {
prime[i] = false;
i += p;
}
}
p += 1;
}
int sum = 0;
for (int i = 2; i <= n; i++) {
if (prime[i]) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(10) == 17);
assert(func0(20) == 77);
assert(func0(5) == 10);
printf("All tests passed!\n");
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 %rsp,%rax
mov %rax,%rcx
mov -0x34(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x18(%rbp)
movslq %eax,%rdx
mov %rdx,%r10
mov $0x0,%r11d
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
cltq
mov $0x10,%edx
sub $0x1,%rdx
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rsi
sub %rdx,%rsi
mov %rsi,%rdx
cmp %rdx,%rsp
je 121f <func0+0x96>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1208 <func0+0x7f>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1249 <func0+0xc0>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x0,%rax
mov %rax,-0x10(%rbp)
movl $0x0,-0x20(%rbp)
jmp 126e <func0+0xe5>
mov -0x10(%rbp),%rdx
mov -0x20(%rbp),%eax
cltq
movb $0x1,(%rdx,%rax,1)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x34(%rbp),%eax
jle 125d <func0+0xd4>
movl $0x2,-0x24(%rbp)
jmp 12b9 <func0+0x130>
mov -0x10(%rbp),%rdx
mov -0x24(%rbp),%eax
cltq
movzbl (%rdx,%rax,1),%eax
test %al,%al
je 12b5 <func0+0x12c>
mov -0x24(%rbp),%eax
add %eax,%eax
mov %eax,-0x28(%rbp)
jmp 12ad <func0+0x124>
mov -0x10(%rbp),%rdx
mov -0x28(%rbp),%eax
cltq
movb $0x0,(%rdx,%rax,1)
mov -0x24(%rbp),%eax
add %eax,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x34(%rbp),%eax
jle 129a <func0+0x111>
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x34(%rbp)
jge 127f <func0+0xf6>
movl $0x0,-0x2c(%rbp)
movl $0x2,-0x1c(%rbp)
jmp 12ef <func0+0x166>
mov -0x10(%rbp),%rdx
mov -0x1c(%rbp),%eax
cltq
movzbl (%rdx,%rax,1),%eax
test %al,%al
je 12eb <func0+0x162>
mov -0x1c(%rbp),%eax
add %eax,-0x2c(%rbp)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x34(%rbp),%eax
jle 12d4 <func0+0x14b>
mov -0x2c(%rbp),%eax
mov %rcx,%rsp
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
je 1311 <func0+0x188>
callq 1080 <__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 rax, rsp
mov rsi, rax
mov eax, [rbp+var_34]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
mov edx, 10h
sub rdx, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11ED:
cmp rsp, rdx
jz short loc_1204
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11ED
loc_1204:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_122E
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_122E:
mov rax, rsp
add rax, 0
mov [rbp+var_10], rax
mov [rbp+var_2C], 0
jmp short loc_1253
loc_1242:
mov rdx, [rbp+var_10]
mov eax, [rbp+var_2C]
cdqe
mov byte ptr [rdx+rax], 1
add [rbp+var_2C], 1
loc_1253:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_34]
jle short loc_1242
mov [rbp+var_28], 2
jmp short loc_129E
loc_1264:
mov rdx, [rbp+var_10]
mov eax, [rbp+var_28]
cdqe
movzx eax, byte ptr [rdx+rax]
test al, al
jz short loc_129A
mov eax, [rbp+var_28]
add eax, eax
mov [rbp+var_24], eax
jmp short loc_1292
loc_127F:
mov rdx, [rbp+var_10]
mov eax, [rbp+var_24]
cdqe
mov byte ptr [rdx+rax], 0
mov eax, [rbp+var_28]
add [rbp+var_24], eax
loc_1292:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_34]
jle short loc_127F
loc_129A:
add [rbp+var_28], 1
loc_129E:
mov eax, [rbp+var_28]
imul eax, eax
cmp [rbp+var_34], eax
jge short loc_1264
mov [rbp+var_20], 0
mov [rbp+var_1C], 2
jmp short loc_12D4
loc_12B9:
mov rdx, [rbp+var_10]
mov eax, [rbp+var_1C]
cdqe
movzx eax, byte ptr [rdx+rax]
test al, al
jz short loc_12D0
mov eax, [rbp+var_1C]
add [rbp+var_20], eax
loc_12D0:
add [rbp+var_1C], 1
loc_12D4:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_34]
jle short loc_12B9
mov eax, [rbp+var_20]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12F6
call ___stack_chk_fail
locret_12F6:
leave
retn | long long func0(int a1)
{
unsigned long long v1; // rax
void *v2; // rsp
_BYTE v4[12]; // [rsp+8h] [rbp-40h] BYREF
int v5; // [rsp+14h] [rbp-34h]
int i; // [rsp+1Ch] [rbp-2Ch]
int j; // [rsp+20h] [rbp-28h]
int k; // [rsp+24h] [rbp-24h]
unsigned int v9; // [rsp+28h] [rbp-20h]
int m; // [rsp+2Ch] [rbp-1Ch]
long long v11; // [rsp+30h] [rbp-18h]
_BYTE *v12; // [rsp+38h] [rbp-10h]
unsigned long long v13; // [rsp+40h] [rbp-8h]
v5 = a1;
v13 = __readfsqword(0x28u);
v11 = a1 + 1 - 1LL;
v1 = 16 * ((a1 + 1 + 15LL) / 0x10uLL);
while ( v4 != &v4[-(v1 & 0xFFFFFFFFFFFFF000LL)] )
;
v2 = alloca(v1 & 0xFFF);
if ( (v1 & 0xFFF) != 0 )
*(_QWORD *)&v4[(v1 & 0xFFF) - 8] = *(_QWORD *)&v4[(v1 & 0xFFF) - 8];
v12 = v4;
for ( i = 0; i <= v5; ++i )
v12[i] = 1;
for ( j = 2; v5 >= j * j; ++j )
{
if ( v12[j] )
{
for ( k = 2 * j; k <= v5; k += j )
v12[k] = 0;
}
}
v9 = 0;
for ( m = 2; m <= v5; ++m )
{
if ( v12[m] )
v9 += m;
}
return v9;
} | 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 RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
MOV EDX,0x10
SUB RDX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011ed:
CMP RSP,RDX
JZ 0x00101204
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011ed
LAB_00101204:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x0010122e
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_0010122e:
MOV RAX,RSP
ADD RAX,0x0
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x00101253
LAB_00101242:
MOV RDX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
MOV byte ptr [RDX + RAX*0x1],0x1
ADD dword ptr [RBP + -0x2c],0x1
LAB_00101253:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x00101242
MOV dword ptr [RBP + -0x28],0x2
JMP 0x0010129e
LAB_00101264:
MOV RDX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x28]
CDQE
MOVZX EAX,byte ptr [RDX + RAX*0x1]
TEST AL,AL
JZ 0x0010129a
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,EAX
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00101292
LAB_0010127f:
MOV RDX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x24]
CDQE
MOV byte ptr [RDX + RAX*0x1],0x0
MOV EAX,dword ptr [RBP + -0x28]
ADD dword ptr [RBP + -0x24],EAX
LAB_00101292:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x0010127f
LAB_0010129a:
ADD dword ptr [RBP + -0x28],0x1
LAB_0010129e:
MOV EAX,dword ptr [RBP + -0x28]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x34],EAX
JGE 0x00101264
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x2
JMP 0x001012d4
LAB_001012b9:
MOV RDX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
MOVZX EAX,byte ptr [RDX + RAX*0x1]
TEST AL,AL
JZ 0x001012d0
MOV EAX,dword ptr [RBP + -0x1c]
ADD dword ptr [RBP + -0x20],EAX
LAB_001012d0:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001012d4:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x001012b9
MOV EAX,dword ptr [RBP + -0x20]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012f6
CALL 0x00101080
LAB_001012f6:
LEAVE
RET | int func0(int param_1)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [12];
int local_3c;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_3c = param_1;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)(param_1 + 1) + -1;
uVar2 = (((long)(param_1 + 1) + 0xfU) / 0x10) * 0x10;
for (puVar3 = auStack_48; puVar3 != auStack_48 + -(uVar2 & 0xfffffffffffff000);
puVar3 = puVar3 + -0x1000) {
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
}
lVar1 = -(ulong)((uint)uVar2 & 0xfff);
if ((uVar2 & 0xfff) != 0) {
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar3 + ((ulong)((uint)uVar2 & 0xfff) - 8) + lVar1);
}
for (local_34 = 0; local_34 <= local_3c; local_34 = local_34 + 1) {
puVar3[local_34 + lVar1] = 1;
}
for (local_30 = 2; local_30 * local_30 <= local_3c; local_30 = local_30 + 1) {
if (puVar3[local_30 + lVar1] != '\0') {
for (local_2c = local_30 * 2; local_2c <= local_3c; local_2c = local_2c + local_30) {
puVar3[local_2c + lVar1] = 0;
}
}
}
local_28 = 0;
for (local_24 = 2; local_24 <= local_3c; local_24 = local_24 + 1) {
if (puVar3[local_24 + lVar1] != '\0') {
local_28 = local_28 + local_24;
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_28;
} |
6,633 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
bool prime[n + 1];
for (int j = 0; j <= n; j++) {
prime[j] = true;
}
int p = 2;
while (p * p <= n) {
if (prime[p] == true) {
int i = p * 2;
while (i <= n) {
prime[i] = false;
i += p;
}
}
p += 1;
}
int sum = 0;
for (int i = 2; i <= n; i++) {
if (prime[i]) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(10) == 17);
assert(func0(20) == 77);
assert(func0(5) == 10);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
cltq
add $0xf,%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rsi
sub %rax,%rsi
mov %rsi,%rax
cmp %rax,%rsp
je 11da <func0+0x51>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11c3 <func0+0x3a>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11f0 <func0+0x67>
orq $0x0,-0x8(%rsp,%rax,1)
mov %rsp,%rsi
test %edi,%edi
js 120d <func0+0x84>
mov %rsi,%rax
mov %edi,%edx
lea 0x1(%rsi,%rdx,1),%rdx
movb $0x1,(%rax)
add $0x1,%rax
cmp %rdx,%rax
jne 1201 <func0+0x78>
cmp $0x3,%edi
jle 1245 <func0+0xbc>
mov $0x2,%ecx
jmp 1227 <func0+0x9e>
lea 0x1(%rdx),%eax
add $0x1,%rcx
imul %eax,%eax
cmp %edi,%eax
jg 1262 <func0+0xd9>
mov %ecx,%edx
cmpb $0x0,(%rsi,%rcx,1)
je 1219 <func0+0x90>
lea (%rcx,%rcx,1),%eax
cmp %eax,%edi
jl 1219 <func0+0x90>
cltq
movb $0x0,(%rsi,%rax,1)
add %rcx,%rax
cmp %eax,%edi
jge 1238 <func0+0xaf>
jmp 1219 <func0+0x90>
cmp $0x1,%edi
jg 1262 <func0+0xd9>
mov $0x0,%edx
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 1280 <func0+0xf7>
mov %edx,%eax
leaveq
retq
mov $0x2,%eax
mov $0x0,%edx
jmp 1276 <func0+0xed>
add $0x1,%rax
cmp %eax,%edi
jl 124f <func0+0xc6>
cmpb $0x0,(%rsi,%rax,1)
je 126e <func0+0xe5>
add %eax,%edx
jmp 126e <func0+0xe5>
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov esi, edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea eax, [rdi+1]
cdqe
add rax, 0Fh
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11C2:
cmp rsp, rdx
jz short loc_11D9
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11C2
loc_11D9:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11EF
or [rsp+rax+10h+var_18], 0
loc_11EF:
mov rdi, rsp
test esi, esi
js short loc_120B
mov rax, rdi
lea edx, [rsi+1]
add rdx, rdi
loc_11FF:
mov byte ptr [rax], 1
add rax, 1
cmp rax, rdx
jnz short loc_11FF
loc_120B:
cmp esi, 3
jle short loc_124C
mov r8d, 4
mov ecx, 2
jmp short loc_122F
loc_121D:
lea eax, [rdx+1]
add rcx, 1
add r8d, 2
imul eax, eax
cmp eax, esi
jg short loc_1269
loc_122F:
mov edx, ecx
cmp byte ptr [rdi+rcx], 0
jz short loc_121D
cmp esi, r8d
jl short loc_121D
movsxd rax, r8d
loc_123F:
mov byte ptr [rdi+rax], 0
add rax, rcx
cmp esi, eax
jge short loc_123F
jmp short loc_121D
loc_124C:
cmp esi, 1
jg short loc_1269
mov edx, 0
loc_1256:
mov rax, [rbp+var_8]
sub rax, fs:28h
jnz short loc_1287
mov eax, edx
leave
retn
loc_1269:
mov eax, 2
mov edx, 0
jmp short loc_127D
loc_1275:
add rax, 1
cmp esi, eax
jl short loc_1256
loc_127D:
cmp byte ptr [rdi+rax], 0
jz short loc_1275
add edx, eax
jmp short loc_1275
loc_1287:
call ___stack_chk_fail | long long func0(int a1)
{
signed long long v1; // rax
void *v2; // rsp
_BYTE *v3; // rax
int v4; // r8d
long long v5; // rcx
int v6; // edx
long long v7; // rax
unsigned int v8; // edx
long long v10; // rax
_BYTE v12[8]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v13; // [rsp+10h] [rbp-8h]
v13 = __readfsqword(0x28u);
while ( v12 != &v12[-((a1 + 1 + 15LL) & 0xFFFFFFFFFFFFF000LL)] )
;
v1 = ((_WORD)a1 + 16) & 0xFF0;
v2 = alloca(v1);
if ( (((_WORD)a1 + 16) & 0xFF0) != 0 )
*(_QWORD *)&v12[v1 - 8] = *(_QWORD *)&v12[v1 - 8];
if ( a1 >= 0 )
{
v3 = v12;
do
*v3++ = 1;
while ( v3 != &v12[a1 + 1] );
}
if ( a1 <= 3 )
{
if ( a1 <= 1 )
return 0;
}
else
{
v4 = 4;
v5 = 2LL;
do
{
v6 = v5;
if ( v12[v5] && a1 >= v4 )
{
v7 = v4;
do
{
v12[v7] = 0;
v7 += v5;
}
while ( a1 >= (int)v7 );
}
++v5;
v4 += 2;
}
while ( (v6 + 1) * (v6 + 1) <= a1 );
}
v10 = 2LL;
v8 = 0;
do
{
if ( v12[v10] )
v8 += v10;
++v10;
}
while ( a1 >= (int)v10 );
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV ESI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
CDQE
ADD RAX,0xf
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011c2:
CMP RSP,RDX
JZ 0x001011d9
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011c2
LAB_001011d9:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011ef
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011ef:
MOV RDI,RSP
TEST ESI,ESI
JS 0x0010120b
MOV RAX,RDI
LEA EDX,[RSI + 0x1]
ADD RDX,RDI
LAB_001011ff:
MOV byte ptr [RAX],0x1
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x001011ff
LAB_0010120b:
CMP ESI,0x3
JLE 0x0010124c
MOV R8D,0x4
MOV ECX,0x2
JMP 0x0010122f
LAB_0010121d:
LEA EAX,[RDX + 0x1]
ADD RCX,0x1
ADD R8D,0x2
IMUL EAX,EAX
CMP EAX,ESI
JG 0x00101269
LAB_0010122f:
MOV EDX,ECX
CMP byte ptr [RDI + RCX*0x1],0x0
JZ 0x0010121d
CMP ESI,R8D
JL 0x0010121d
MOVSXD RAX,R8D
LAB_0010123f:
MOV byte ptr [RDI + RAX*0x1],0x0
ADD RAX,RCX
CMP ESI,EAX
JGE 0x0010123f
JMP 0x0010121d
LAB_0010124c:
CMP ESI,0x1
JG 0x00101269
MOV EDX,0x0
LAB_00101256:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101287
MOV EAX,EDX
LEAVE
RET
LAB_00101269:
MOV EAX,0x2
MOV EDX,0x0
JMP 0x0010127d
LAB_00101275:
ADD RAX,0x1
CMP ESI,EAX
JL 0x00101256
LAB_0010127d:
CMP byte ptr [RDI + RAX*0x1],0x0
JZ 0x00101275
ADD EDX,EAX
JMP 0x00101275
LAB_00101287:
CALL 0x00101080 | int func0(int param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
int1 *puVar4;
long lVar5;
long lVar6;
int1 *puVar7;
int iVar8;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (long)(param_1 + 1) + 0xf;
for (puVar7 = auStack_18; puVar7 != auStack_18 + -(uVar3 & 0xfffffffffffff000);
puVar7 = puVar7 + -0x1000) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
uVar3 = (ulong)((uint)uVar3 & 0xff0);
lVar1 = -uVar3;
puVar4 = puVar7 + lVar1;
if (uVar3 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if (-1 < param_1) {
do {
*puVar4 = 1;
puVar4 = puVar4 + 1;
} while (puVar4 != puVar7 + (ulong)(param_1 + 1) + lVar1);
}
if (param_1 < 4) {
if (param_1 < 2) {
iVar8 = 0;
goto LAB_00101256;
}
}
else {
iVar8 = 4;
lVar6 = 2;
do {
if ((puVar7[lVar6 + lVar1] != '\0') && (iVar8 <= param_1)) {
lVar5 = (long)iVar8;
do {
puVar7[lVar5 + lVar1] = 0;
lVar5 = lVar5 + lVar6;
} while ((int)lVar5 <= param_1);
}
iVar2 = (int)lVar6 + 1;
lVar6 = lVar6 + 1;
iVar8 = iVar8 + 2;
} while (iVar2 * iVar2 <= param_1);
}
lVar6 = 2;
iVar8 = 0;
do {
if (puVar7[lVar6 + lVar1] != '\0') {
iVar8 = iVar8 + (int)lVar6;
}
lVar6 = lVar6 + 1;
} while ((int)lVar6 <= param_1);
LAB_00101256:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(code **)(puVar7 + lVar1 + -8) = main;
__stack_chk_fail();
}
return iVar8;
} |
6,634 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
bool prime[n + 1];
for (int j = 0; j <= n; j++) {
prime[j] = true;
}
int p = 2;
while (p * p <= n) {
if (prime[p] == true) {
int i = p * 2;
while (i <= n) {
prime[i] = false;
i += p;
}
}
p += 1;
}
int sum = 0;
for (int i = 2; i <= n; i++) {
if (prime[i]) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(10) == 17);
assert(func0(20) == 77);
assert(func0(5) == 10);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
mov %rsp,%rsi
cltq
add $0xf,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rsi
and $0xfffffffffffffff0,%rdx
mov %rsi,%rax
cmp %rax,%rsp
je 1294 <func0+0x54>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 127f <func0+0x3f>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 134d <func0+0x10d>
mov %rsp,%rsi
test %edi,%edi
js 1358 <func0+0x118>
movslq %edi,%rdx
mov %rsp,%rax
lea 0x1(%rsp,%rdx,1),%rdx
nopl 0x0(%rax)
movb $0x1,(%rax)
add $0x1,%rax
cmp %rdx,%rax
jne 12c0 <func0+0x80>
cmp $0x3,%edi
jle 1358 <func0+0x118>
mov $0x2,%ecx
jmp 12ee <func0+0xae>
nopl 0x0(%rax)
lea 0x1(%rdx),%eax
add $0x1,%rcx
imul %eax,%eax
cmp %edi,%eax
jg 1319 <func0+0xd9>
cmpb $0x0,(%rsi,%rcx,1)
mov %ecx,%edx
je 12e0 <func0+0xa0>
lea (%rcx,%rcx,1),%eax
cmp %eax,%edi
jl 12e0 <func0+0xa0>
cltq
movb $0x0,(%rsi,%rax,1)
add %rcx,%rax
cmp %eax,%edi
jge 1300 <func0+0xc0>
lea 0x1(%rdx),%eax
add $0x1,%rcx
imul %eax,%eax
cmp %edi,%eax
jle 12ee <func0+0xae>
mov $0x2,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
cmpb $0x0,(%rsi,%rax,1)
je 1331 <func0+0xf1>
add %eax,%r8d
add $0x1,%rax
cmp %eax,%edi
jge 1328 <func0+0xe8>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
jne 1362 <func0+0x122>
leaveq
mov %r8d,%eax
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 12a6 <func0+0x66>
cmp $0x1,%edi
jg 1319 <func0+0xd9>
xor %r8d,%r8d
jmp 1339 <func0+0xf9>
callq 1080 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
mov ebx, edi
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea eax, [rdi+1]
mov rcx, rsp
cdqe
add rax, 0Fh
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_12B6
loc_12A1:
sub rsp, 1000h
or [rsp+1020h+var_28], 0
cmp rsp, rcx
jnz short loc_12A1
loc_12B6:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_137D
loc_12C8:
mov r12, rsp
test ebx, ebx
js loc_1388
movsxd rdx, ebx
mov esi, 1
mov rdi, rsp
add rdx, 1
call _memset
cmp ebx, 3
jle loc_1388
mov esi, 4
mov ecx, 2
jmp short loc_1311
loc_1300:
lea eax, [rdx+1]
add rcx, 1
add esi, 2
imul eax, eax
cmp eax, ebx
jg short loc_1340
loc_1311:
cmp byte ptr [r12+rcx], 0
mov edx, ecx
jz short loc_1300
cmp ebx, esi
jl short loc_1300
movsxd rax, esi
nop dword ptr [rax+00000000h]
loc_1328:
mov byte ptr [r12+rax], 0
add rax, rcx
cmp ebx, eax
jge short loc_1328
jmp short loc_1300
loc_1340:
mov eax, 2
xor r8d, r8d
nop dword ptr [rax+rax+00000000h]
loc_1350:
cmp byte ptr [r12+rax], 0
jz short loc_135A
add r8d, eax
loc_135A:
add rax, 1
cmp ebx, eax
jge short loc_1350
loc_1362:
mov rax, [rbp+var_18]
sub rax, fs:28h
jnz short loc_1392
lea rsp, [rbp-10h]
mov eax, r8d
pop rbx
pop r12
pop rbp
retn
loc_137D:
or [rsp+rdx+1020h+var_1028], 0
jmp loc_12C8
loc_1388:
cmp ebx, 1
jg short loc_1340
xor r8d, r8d
jmp short loc_1362
loc_1392:
call ___stack_chk_fail | long long func0(int a1)
{
_BYTE *v1; // rcx
signed long long v2; // rdx
void *v3; // rsp
int v4; // esi
long long v5; // rcx
int v6; // edx
long long v7; // rax
long long v8; // rax
unsigned int v9; // r8d
_BYTE v12[4088]; // [rsp+8h] [rbp-1020h] BYREF
_QWORD v13[4]; // [rsp+1008h] [rbp-20h] BYREF
v13[1] = __readfsqword(0x28u);
v1 = (char *)v13 - ((a1 + 1 + 15LL) & 0xFFFFFFFFFFFFF000LL);
if ( v13 != (_QWORD *)v1 )
{
while ( v12 != v1 )
;
}
v2 = ((_WORD)a1 + 16) & 0xFF0;
v3 = alloca(v2);
if ( (((_WORD)a1 + 16) & 0xFF0) != 0 )
*(_QWORD *)&v12[v2 - 8] = *(_QWORD *)&v12[v2 - 8];
if ( a1 < 0 || (memset(v12, 1LL, a1 + 1LL), a1 <= 3) )
{
if ( a1 <= 1 )
return 0;
}
else
{
v4 = 4;
v5 = 2LL;
do
{
v6 = v5;
if ( v12[v5] && a1 >= v4 )
{
v7 = v4;
do
{
v12[v7] = 0;
v7 += v5;
}
while ( a1 >= (int)v7 );
}
++v5;
v4 += 2;
}
while ( (v6 + 1) * (v6 + 1) <= a1 );
}
v8 = 2LL;
v9 = 0;
do
{
if ( v12[v8] )
v9 += v8;
++v8;
}
while ( a1 >= (int)v8 );
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
MOV EBX,EDI
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
MOV RCX,RSP
CDQE
ADD RAX,0xf
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012b6
LAB_001012a1:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001012a1
LAB_001012b6:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x0010137d
LAB_001012c8:
MOV R12,RSP
TEST EBX,EBX
JS 0x00101388
MOVSXD RDX,EBX
MOV ESI,0x1
MOV RDI,RSP
ADD RDX,0x1
CALL 0x001010b0
CMP EBX,0x3
JLE 0x00101388
MOV ESI,0x4
MOV ECX,0x2
JMP 0x00101311
LAB_00101300:
LEA EAX,[RDX + 0x1]
ADD RCX,0x1
ADD ESI,0x2
IMUL EAX,EAX
CMP EAX,EBX
JG 0x00101340
LAB_00101311:
CMP byte ptr [R12 + RCX*0x1],0x0
MOV EDX,ECX
JZ 0x00101300
CMP EBX,ESI
JL 0x00101300
MOVSXD RAX,ESI
NOP dword ptr [RAX]
LAB_00101328:
MOV byte ptr [R12 + RAX*0x1],0x0
ADD RAX,RCX
CMP EBX,EAX
JGE 0x00101328
JMP 0x00101300
LAB_00101340:
MOV EAX,0x2
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101350:
CMP byte ptr [R12 + RAX*0x1],0x0
JZ 0x0010135a
ADD R8D,EAX
LAB_0010135a:
ADD RAX,0x1
CMP EBX,EAX
JGE 0x00101350
LAB_00101362:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101392
LEA RSP,[RBP + -0x10]
MOV EAX,R8D
POP RBX
POP R12
POP RBP
RET
LAB_0010137d:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012c8
LAB_00101388:
CMP EBX,0x1
JG 0x00101340
XOR R8D,R8D
JMP 0x00101362
LAB_00101392:
CALL 0x00101090 | int func0(int param_1)
{
long lVar1;
int1 *puVar2;
int iVar3;
ulong uVar4;
long lVar5;
long lVar6;
int1 *puVar7;
int iVar9;
long in_FS_OFFSET;
int1 auStack_28 [8];
long local_20;
int1 *puVar8;
puVar7 = auStack_28;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(param_1 + 1) + 0xf;
puVar8 = auStack_28;
puVar2 = auStack_28;
while (puVar8 != auStack_28 + -(uVar4 & 0xfffffffffffff000)) {
puVar7 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar8 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar1 = -uVar4;
if (uVar4 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if (param_1 < 0) {
LAB_00101388:
if (param_1 < 2) {
iVar9 = 0;
goto LAB_00101362;
}
}
else {
*(int8 *)(puVar7 + lVar1 + -8) = 0x1012e7;
memset(puVar7 + lVar1,1,(long)param_1 + 1);
if (param_1 < 4) goto LAB_00101388;
iVar9 = 4;
lVar6 = 2;
do {
if ((puVar7[lVar6 + lVar1] != '\0') && (iVar9 <= param_1)) {
lVar5 = (long)iVar9;
do {
puVar7[lVar5 + lVar1] = 0;
lVar5 = lVar5 + lVar6;
} while ((int)lVar5 <= param_1);
}
iVar3 = (int)lVar6 + 1;
lVar6 = lVar6 + 1;
iVar9 = iVar9 + 2;
} while (iVar3 * iVar3 <= param_1);
}
lVar6 = 2;
iVar9 = 0;
do {
if (puVar7[lVar6 + lVar1] != '\0') {
iVar9 = iVar9 + (int)lVar6;
}
lVar6 = lVar6 + 1;
} while ((int)lVar6 <= param_1);
LAB_00101362:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar9;
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + lVar1 + -8) = 0x101397;
__stack_chk_fail();
} |
6,635 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
bool prime[n + 1];
for (int j = 0; j <= n; j++) {
prime[j] = true;
}
int p = 2;
while (p * p <= n) {
if (prime[p] == true) {
int i = p * 2;
while (i <= n) {
prime[i] = false;
i += p;
}
}
p += 1;
}
int sum = 0;
for (int i = 2; i <= n; i++) {
if (prime[i]) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(10) == 17);
assert(func0(20) == 77);
assert(func0(5) == 10);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
mov %edi,%ebx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
mov %rsp,%rsi
cltq
add $0xf,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rsi
and $0xfffffffffffffff0,%rdx
mov %rsi,%rax
cmp %rax,%rsp
je 12b9 <func0+0x59>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 12a4 <func0+0x44>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1375 <func0+0x115>
mov %rsp,%r12
test %ebx,%ebx
js 1380 <func0+0x120>
movslq %ebx,%rdx
mov $0x1,%esi
mov %rsp,%rdi
add $0x1,%rdx
callq 10b0 <memset@plt>
cmp $0x3,%ebx
jle 1380 <func0+0x120>
mov $0x2,%ecx
jmp 130e <func0+0xae>
nopw 0x0(%rax,%rax,1)
lea 0x1(%rdx),%eax
add $0x1,%rcx
imul %eax,%eax
cmp %ebx,%eax
jg 133a <func0+0xda>
cmpb $0x0,(%r12,%rcx,1)
mov %ecx,%edx
je 1300 <func0+0xa0>
lea (%rcx,%rcx,1),%eax
cmp %eax,%ebx
jl 1300 <func0+0xa0>
cltq
movb $0x0,(%r12,%rax,1)
add %rcx,%rax
cmp %eax,%ebx
jge 1320 <func0+0xc0>
lea 0x1(%rdx),%eax
add $0x1,%rcx
imul %eax,%eax
cmp %ebx,%eax
jle 130e <func0+0xae>
mov $0x2,%eax
xor %r8d,%r8d
nopw 0x0(%rax,%rax,1)
cmpb $0x0,(%r12,%rax,1)
je 1352 <func0+0xf2>
add %eax,%r8d
add $0x1,%rax
cmp %eax,%ebx
jge 1348 <func0+0xe8>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
jne 138a <func0+0x12a>
lea -0x10(%rbp),%rsp
mov %r8d,%eax
pop %rbx
pop %r12
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 12cb <func0+0x6b>
cmp $0x1,%ebx
jg 133a <func0+0xda>
xor %r8d,%r8d
jmp 135a <func0+0xfa>
callq 1090 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r13
lea r13d, [rdi+1]
push r12
mov r12d, edi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
movsxd rax, r13d
mov rcx, rsp
add rax, 0Fh
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_12BB
loc_12A6:
sub rsp, 1000h
or [rsp+1030h+var_38], 0
cmp rsp, rcx
jnz short loc_12A6
loc_12BB:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_137D
loc_12CD:
mov rbx, rsp
test r12d, r12d
js loc_1388
movsxd rdx, r12d
mov esi, 1; c
mov rdi, rsp; s
add rdx, 1; n
call _memset
cmp r12d, 3
jle short loc_1336
mov esi, 4
mov ecx, 2
jmp short loc_1312
loc_1300:
lea eax, [rdx+1]
add rcx, 1
add esi, 2
imul eax, eax
cmp eax, r12d
jg short loc_1340
loc_1312:
cmp byte ptr [rbx+rcx], 0
mov edx, ecx
jz short loc_1300
cmp r12d, esi
jl short loc_1300
mov eax, esi
nop dword ptr [rax+00000000h]
loc_1328:
mov byte ptr [rbx+rax], 0
add rax, rcx
cmp r12d, eax
jge short loc_1328
jmp short loc_1300
loc_1336:
cmp r12d, 1
jle short loc_1388
nop dword ptr [rax+00h]
loc_1340:
mov edx, r13d
mov eax, 2
xor ecx, ecx
nop word ptr [rax+rax+00h]
loc_1350:
cmp byte ptr [rbx+rax], 0
jz short loc_1358
add ecx, eax
loc_1358:
add rax, 1
cmp rdx, rax
jnz short loc_1350
loc_1361:
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz short loc_138C
lea rsp, [rbp-18h]
mov eax, ecx
pop rbx
pop r12
pop r13
pop rbp
retn
loc_137D:
or [rsp+rdx+1030h+var_1038], 0
jmp loc_12CD
loc_1388:
xor ecx, ecx
jmp short loc_1361
loc_138C:
call ___stack_chk_fail | long long func0(int a1)
{
_BYTE *v1; // rcx
signed long long v2; // rdx
void *v3; // rsp
int v4; // esi
long long v5; // rcx
int v6; // edx
long long v7; // rax
long long v8; // rax
unsigned int v9; // ecx
_BYTE v12[4088]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v13[6]; // [rsp+1008h] [rbp-30h] BYREF
v13[1] = __readfsqword(0x28u);
v1 = (char *)v13 - ((a1 + 1 + 15LL) & 0xFFFFFFFFFFFFF000LL);
if ( v13 != (_QWORD *)v1 )
{
while ( v12 != v1 )
;
}
v2 = ((_WORD)a1 + 16) & 0xFF0;
v3 = alloca(v2);
if ( (((_WORD)a1 + 16) & 0xFF0) != 0 )
*(_QWORD *)&v12[v2 - 8] = *(_QWORD *)&v12[v2 - 8];
if ( a1 < 0 )
return 0;
memset(v12, 1, a1 + 1LL);
if ( a1 > 3 )
{
v4 = 4;
v5 = 2LL;
do
{
v6 = v5;
if ( v12[v5] && a1 >= v4 )
{
v7 = (unsigned int)v4;
do
{
v12[v7] = 0;
v7 += v5;
}
while ( a1 >= (int)v7 );
}
++v5;
v4 += 2;
}
while ( (v6 + 1) * (v6 + 1) <= a1 );
goto LABEL_15;
}
if ( a1 <= 1 )
return 0;
LABEL_15:
v8 = 2LL;
v9 = 0;
do
{
if ( v12[v8] )
v9 += v8;
++v8;
}
while ( a1 + 1 != v8 );
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
LEA R13D,[RDI + 0x1]
PUSH R12
MOV R12D,EDI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOVSXD RAX,R13D
MOV RCX,RSP
ADD RAX,0xf
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012bb
LAB_001012a6:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001012a6
LAB_001012bb:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x0010137d
LAB_001012cd:
MOV RBX,RSP
TEST R12D,R12D
JS 0x00101388
MOVSXD RDX,R12D
MOV ESI,0x1
MOV RDI,RSP
ADD RDX,0x1
CALL 0x001010b0
CMP R12D,0x3
JLE 0x00101336
MOV ESI,0x4
MOV ECX,0x2
JMP 0x00101312
LAB_00101300:
LEA EAX,[RDX + 0x1]
ADD RCX,0x1
ADD ESI,0x2
IMUL EAX,EAX
CMP EAX,R12D
JG 0x00101340
LAB_00101312:
CMP byte ptr [RBX + RCX*0x1],0x0
MOV EDX,ECX
JZ 0x00101300
CMP R12D,ESI
JL 0x00101300
MOV EAX,ESI
NOP dword ptr [RAX]
LAB_00101328:
MOV byte ptr [RBX + RAX*0x1],0x0
ADD RAX,RCX
CMP R12D,EAX
JGE 0x00101328
JMP 0x00101300
LAB_00101336:
CMP R12D,0x1
JLE 0x00101388
NOP dword ptr [RAX]
LAB_00101340:
MOV EDX,R13D
MOV EAX,0x2
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101350:
CMP byte ptr [RBX + RAX*0x1],0x0
JZ 0x00101358
ADD ECX,EAX
LAB_00101358:
ADD RAX,0x1
CMP RDX,RAX
JNZ 0x00101350
LAB_00101361:
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010138c
LEA RSP,[RBP + -0x18]
MOV EAX,ECX
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_0010137d:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012cd
LAB_00101388:
XOR ECX,ECX
JMP 0x00101361
LAB_0010138c:
CALL 0x00101090 | int func0(int param_1)
{
long lVar1;
int *puVar2;
int iVar3;
ulong uVar4;
long lVar5;
int *puVar6;
uint uVar8;
long in_FS_OFFSET;
int auStack_38 [8];
long local_30;
int *puVar7;
puVar6 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(int)(param_1 + 1U) + 0xf;
puVar7 = auStack_38;
puVar2 = auStack_38;
while (puVar7 != auStack_38 + -(uVar4 & 0xfffffffffffff000)) {
puVar6 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar7 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar1 = -uVar4;
if (uVar4 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (param_1 < 0) {
LAB_00101388:
iVar3 = 0;
}
else {
*(int8 *)(puVar6 + lVar1 + -8) = 0x1012ed;
memset(puVar6 + lVar1,1,(long)param_1 + 1);
if (param_1 < 4) {
if (param_1 < 2) goto LAB_00101388;
}
else {
uVar8 = 4;
lVar5 = 2;
do {
if ((puVar6[lVar5 + lVar1] != '\0') && ((int)uVar8 <= param_1)) {
uVar4 = (ulong)uVar8;
do {
puVar6[uVar4 + lVar1] = 0;
uVar4 = uVar4 + lVar5;
} while ((int)uVar4 <= param_1);
}
iVar3 = (int)lVar5 + 1;
lVar5 = lVar5 + 1;
uVar8 = uVar8 + 2;
} while (iVar3 * iVar3 <= param_1);
}
uVar4 = 2;
iVar3 = 0;
do {
if (puVar6[uVar4 + lVar1] != '\0') {
iVar3 = iVar3 + (int)uVar4;
}
uVar4 = uVar4 + 1;
} while (param_1 + 1U != uVar4);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar3;
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar6 + lVar1 + -8) = 0x101391;
__stack_chk_fail();
} |
6,636 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
struct dict {
int key;
int value;
};
| char * func0(int test_tup[], int size) {
struct dict freq[100]; // Assuming maximum number of unique elements is 100.
int count = 0;
for (int i = 0; i < size; i++) {
int found = 0;
for (int j = 0; j < count; j++) {
if (freq[j].key == test_tup[i]) {
freq[j].value++;
found = 1;
break;
}
}
if (!found) {
freq[count].key = test_tup[i];
freq[count].value = 1;
count++;
}
}
char *result = (char*)malloc(1000 * sizeof(char)); // Allocating memory for the result string.
char buffer[50];
result[0] = '\0'; // Initialize empty string
strcat(result, "{");
for (int i = 0; i < count; i++) {
sprintf(buffer, "%d: %d", freq[i].key, freq[i].value);
strcat(result, buffer);
if (i < count - 1) strcat(result, ", ");
}
strcat(result, "}");
return result;
}
| int main() {
int tuple1[] = {4, 5, 4, 5, 6, 6, 5, 5, 4};
char *res1 = func0(tuple1, sizeof(tuple1)/sizeof(tuple1[0]));
assert(strcmp(res1, "{4: 3, 5: 4, 6: 2}") == 0);
free(res1);
int tuple2[] = {7, 8, 8, 9, 4, 7, 6, 5, 4};
char *res2 = func0(tuple2, sizeof(tuple2)/sizeof(tuple2[0]));
assert(strcmp(res2, "{7: 2, 8: 2, 9: 1, 4: 2, 6: 1, 5: 1}") == 0);
free(res2);
int tuple3[] = {1, 4, 3, 1, 4, 5, 2, 6, 2, 7};
char *res3 = func0(tuple3, sizeof(tuple3)/sizeof(tuple3[0]));
assert(strcmp(res3, "{1: 2, 4: 2, 3: 1, 5: 1, 2: 2, 6: 1, 7: 1}") == 0);
free(res3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x390,%rsp
mov %rdi,-0x388(%rbp)
mov %esi,-0x38c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x37c(%rbp)
movl $0x0,-0x378(%rbp)
jmpq 1329 <func0+0x120>
movl $0x0,-0x374(%rbp)
movl $0x0,-0x370(%rbp)
jmp 12c6 <func0+0xbd>
mov -0x370(%rbp),%eax
cltq
mov -0x360(%rbp,%rax,8),%edx
mov -0x378(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x388(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 12bf <func0+0xb6>
mov -0x370(%rbp),%eax
cltq
mov -0x35c(%rbp,%rax,8),%eax
lea 0x1(%rax),%edx
mov -0x370(%rbp),%eax
cltq
mov %edx,-0x35c(%rbp,%rax,8)
movl $0x1,-0x374(%rbp)
jmp 12d4 <func0+0xcb>
addl $0x1,-0x370(%rbp)
mov -0x370(%rbp),%eax
cmp -0x37c(%rbp),%eax
jl 1263 <func0+0x5a>
cmpl $0x0,-0x374(%rbp)
jne 1322 <func0+0x119>
mov -0x378(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x388(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x37c(%rbp),%eax
cltq
mov %edx,-0x360(%rbp,%rax,8)
mov -0x37c(%rbp),%eax
cltq
movl $0x1,-0x35c(%rbp,%rax,8)
addl $0x1,-0x37c(%rbp)
addl $0x1,-0x378(%rbp)
mov -0x378(%rbp),%eax
cmp -0x38c(%rbp),%eax
jl 124d <func0+0x44>
mov $0x3e8,%edi
callq 10f0 <malloc@plt>
mov %rax,-0x368(%rbp)
mov -0x368(%rbp),%rax
movb $0x0,(%rax)
mov -0x368(%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 -0x368(%rbp),%rax
add %rdx,%rax
movw $0x7b,(%rax)
movl $0x0,-0x36c(%rbp)
jmpq 1435 <func0+0x22c>
mov -0x36c(%rbp),%eax
cltq
mov -0x35c(%rbp,%rax,8),%ecx
mov -0x36c(%rbp),%eax
cltq
mov -0x360(%rbp,%rax,8),%edx
lea -0x40(%rbp),%rax
lea 0xc46(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1110 <sprintf@plt>
lea -0x40(%rbp),%rdx
mov -0x368(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1100 <strcat@plt>
mov -0x37c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x36c(%rbp)
jge 142e <func0+0x225>
mov -0x368(%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 -0x368(%rbp),%rax
add %rdx,%rax
movw $0x202c,(%rax)
movb $0x0,0x2(%rax)
addl $0x1,-0x36c(%rbp)
mov -0x36c(%rbp),%eax
cmp -0x37c(%rbp),%eax
jl 1399 <func0+0x190>
mov -0x368(%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 -0x368(%rbp),%rax
add %rdx,%rax
movw $0x7d,(%rax)
mov -0x368(%rbp),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1496 <func0+0x28d>
callq 10c0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 390h
mov [rbp+var_388], rdi
mov [rbp+var_38C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_37C], 0
mov [rbp+var_378], 0
jmp loc_1349
loc_126D:
mov [rbp+var_374], 0
mov [rbp+var_370], 0
jmp short loc_12E6
loc_1283:
mov eax, [rbp+var_370]
cdqe
mov edx, [rbp+rax*8+var_360]
mov eax, [rbp+var_378]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_388]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_12DF
mov eax, [rbp+var_370]
cdqe
mov eax, [rbp+rax*8+var_35C]
lea edx, [rax+1]
mov eax, [rbp+var_370]
cdqe
mov [rbp+rax*8+var_35C], edx
mov [rbp+var_374], 1
jmp short loc_12F4
loc_12DF:
add [rbp+var_370], 1
loc_12E6:
mov eax, [rbp+var_370]
cmp eax, [rbp+var_37C]
jl short loc_1283
loc_12F4:
cmp [rbp+var_374], 0
jnz short loc_1342
mov eax, [rbp+var_378]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_388]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_37C]
cdqe
mov [rbp+rax*8+var_360], edx
mov eax, [rbp+var_37C]
cdqe
mov [rbp+rax*8+var_35C], 1
add [rbp+var_37C], 1
loc_1342:
add [rbp+var_378], 1
loc_1349:
mov eax, [rbp+var_378]
cmp eax, [rbp+var_38C]
jl loc_126D
mov edi, 3E8h; size
call _malloc
mov [rbp+s], rax
mov rax, [rbp+s]
mov byte ptr [rax], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+s]
add rax, rdx
mov word ptr [rax], 7Bh ; '{'
mov [rbp+var_36C], 0
jmp loc_142F
loc_13A6:
mov eax, [rbp+var_36C]
cdqe
mov ecx, [rbp+rax*8+var_35C]
mov eax, [rbp+var_36C]
cdqe
mov edx, [rbp+rax*8+var_360]
lea rax, [rbp+src]
lea rsi, format; "%d: %d"
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
mov eax, [rbp+var_37C]
sub eax, 1
cmp [rbp+var_36C], eax
jge short loc_1428
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_1428:
add [rbp+var_36C], 1
loc_142F:
mov eax, [rbp+var_36C]
cmp eax, [rbp+var_37C]
jl loc_13A6
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov rdx, rax
mov rax, [rbp+s]
add rax, rdx
mov word ptr [rax], 7Dh ; '}'
mov rax, [rbp+s]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_147D
call ___stack_chk_fail
locret_147D:
leave
retn | char * func0(long long a1, int a2)
{
int v3; // [rsp+14h] [rbp-37Ch]
int i; // [rsp+18h] [rbp-378h]
int v5; // [rsp+1Ch] [rbp-374h]
int j; // [rsp+20h] [rbp-370h]
int k; // [rsp+24h] [rbp-36Ch]
char *s; // [rsp+28h] [rbp-368h]
_DWORD v9[200]; // [rsp+30h] [rbp-360h]
char src[56]; // [rsp+350h] [rbp-40h] BYREF
unsigned long long v11; // [rsp+388h] [rbp-8h]
v11 = __readfsqword(0x28u);
v3 = 0;
for ( i = 0; i < a2; ++i )
{
v5 = 0;
for ( j = 0; j < v3; ++j )
{
if ( v9[2 * j] == *(_DWORD *)(4LL * i + a1) )
{
++v9[2 * j + 1];
v5 = 1;
break;
}
}
if ( !v5 )
{
v9[2 * v3] = *(_DWORD *)(4LL * i + a1);
v9[2 * v3++ + 1] = 1;
}
}
s = (char *)malloc(0x3E8uLL);
*s = 0;
*(_WORD *)&s[strlen(s)] = 123;
for ( k = 0; k < v3; ++k )
{
sprintf(src, "%d: %d", v9[2 * k], v9[2 * k + 1]);
strcat(s, src);
if ( k < v3 - 1 )
strcpy(&s[strlen(s)], ", ");
}
*(_WORD *)&s[strlen(s)] = 125;
return s;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x390
MOV qword ptr [RBP + -0x388],RDI
MOV dword ptr [RBP + -0x38c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x37c],0x0
MOV dword ptr [RBP + -0x378],0x0
JMP 0x00101349
LAB_0010126d:
MOV dword ptr [RBP + -0x374],0x0
MOV dword ptr [RBP + -0x370],0x0
JMP 0x001012e6
LAB_00101283:
MOV EAX,dword ptr [RBP + -0x370]
CDQE
MOV EDX,dword ptr [RBP + RAX*0x8 + -0x360]
MOV EAX,dword ptr [RBP + -0x378]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x388]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001012df
MOV EAX,dword ptr [RBP + -0x370]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x8 + -0x35c]
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x370]
CDQE
MOV dword ptr [RBP + RAX*0x8 + -0x35c],EDX
MOV dword ptr [RBP + -0x374],0x1
JMP 0x001012f4
LAB_001012df:
ADD dword ptr [RBP + -0x370],0x1
LAB_001012e6:
MOV EAX,dword ptr [RBP + -0x370]
CMP EAX,dword ptr [RBP + -0x37c]
JL 0x00101283
LAB_001012f4:
CMP dword ptr [RBP + -0x374],0x0
JNZ 0x00101342
MOV EAX,dword ptr [RBP + -0x378]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x388]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x37c]
CDQE
MOV dword ptr [RBP + RAX*0x8 + -0x360],EDX
MOV EAX,dword ptr [RBP + -0x37c]
CDQE
MOV dword ptr [RBP + RAX*0x8 + -0x35c],0x1
ADD dword ptr [RBP + -0x37c],0x1
LAB_00101342:
ADD dword ptr [RBP + -0x378],0x1
LAB_00101349:
MOV EAX,dword ptr [RBP + -0x378]
CMP EAX,dword ptr [RBP + -0x38c]
JL 0x0010126d
MOV EDI,0x3e8
CALL 0x00101110
MOV qword ptr [RBP + -0x368],RAX
MOV RAX,qword ptr [RBP + -0x368]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x368]
MOV RDI,RAX
CALL 0x001010d0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x368]
ADD RAX,RDX
MOV word ptr [RAX],0x7b
MOV dword ptr [RBP + -0x36c],0x0
JMP 0x0010142f
LAB_001013a6:
MOV EAX,dword ptr [RBP + -0x36c]
CDQE
MOV ECX,dword ptr [RBP + RAX*0x8 + -0x35c]
MOV EAX,dword ptr [RBP + -0x36c]
CDQE
MOV EDX,dword ptr [RBP + RAX*0x8 + -0x360]
LEA RAX,[RBP + -0x40]
LEA RSI,[0x102008]
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101130
LEA RDX,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x368]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101120
MOV EAX,dword ptr [RBP + -0x37c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x36c],EAX
JGE 0x00101428
MOV RAX,qword ptr [RBP + -0x368]
MOV RDI,RAX
CALL 0x001010d0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x368]
ADD RAX,RDX
MOV word ptr [RAX],0x202c
MOV byte ptr [RAX + 0x2],0x0
LAB_00101428:
ADD dword ptr [RBP + -0x36c],0x1
LAB_0010142f:
MOV EAX,dword ptr [RBP + -0x36c]
CMP EAX,dword ptr [RBP + -0x37c]
JL 0x001013a6
MOV RAX,qword ptr [RBP + -0x368]
MOV RDI,RAX
CALL 0x001010d0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x368]
ADD RAX,RDX
MOV word ptr [RAX],0x7d
MOV RAX,qword ptr [RBP + -0x368]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010147d
CALL 0x001010e0
LAB_0010147d:
LEAVE
RET | char * func0(long param_1,int param_2)
{
bool bVar1;
char *__s;
size_t sVar2;
char *pcVar3;
long in_FS_OFFSET;
int local_384;
int local_380;
int local_378;
int local_374;
uint auStack_368 [200];
char local_48 [56];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_384 = 0;
local_380 = 0;
do {
if (param_2 <= local_380) {
__s = (char *)malloc(1000);
*__s = '\0';
sVar2 = strlen(__s);
(__s + sVar2)[0] = '{';
(__s + sVar2)[1] = '\0';
for (local_374 = 0; local_374 < local_384; local_374 = local_374 + 1) {
sprintf(local_48,"%d: %d",(ulong)auStack_368[(long)local_374 * 2],
(ulong)auStack_368[(long)local_374 * 2 + 1]);
strcat(__s,local_48);
if (local_374 < local_384 + -1) {
sVar2 = strlen(__s);
pcVar3 = __s + sVar2;
pcVar3[0] = ',';
pcVar3[1] = ' ';
pcVar3[2] = '\0';
}
}
sVar2 = strlen(__s);
(__s + sVar2)[0] = '}';
(__s + sVar2)[1] = '\0';
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __s;
}
bVar1 = false;
for (local_378 = 0; local_378 < local_384; local_378 = local_378 + 1) {
if (auStack_368[(long)local_378 * 2] == *(uint *)(param_1 + (long)local_380 * 4)) {
auStack_368[(long)local_378 * 2 + 1] = auStack_368[(long)local_378 * 2 + 1] + 1;
bVar1 = true;
break;
}
}
if (!bVar1) {
auStack_368[(long)local_384 * 2] = *(uint *)(param_1 + (long)local_380 * 4);
auStack_368[(long)local_384 * 2 + 1] = 1;
local_384 = local_384 + 1;
}
local_380 = local_380 + 1;
} while( true );
} |
6,637 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
struct dict {
int key;
int value;
};
| char * func0(int test_tup[], int size) {
struct dict freq[100]; // Assuming maximum number of unique elements is 100.
int count = 0;
for (int i = 0; i < size; i++) {
int found = 0;
for (int j = 0; j < count; j++) {
if (freq[j].key == test_tup[i]) {
freq[j].value++;
found = 1;
break;
}
}
if (!found) {
freq[count].key = test_tup[i];
freq[count].value = 1;
count++;
}
}
char *result = (char*)malloc(1000 * sizeof(char)); // Allocating memory for the result string.
char buffer[50];
result[0] = '\0'; // Initialize empty string
strcat(result, "{");
for (int i = 0; i < count; i++) {
sprintf(buffer, "%d: %d", freq[i].key, freq[i].value);
strcat(result, buffer);
if (i < count - 1) strcat(result, ", ");
}
strcat(result, "}");
return result;
}
| int main() {
int tuple1[] = {4, 5, 4, 5, 6, 6, 5, 5, 4};
char *res1 = func0(tuple1, sizeof(tuple1)/sizeof(tuple1[0]));
assert(strcmp(res1, "{4: 3, 5: 4, 6: 2}") == 0);
free(res1);
int tuple2[] = {7, 8, 8, 9, 4, 7, 6, 5, 4};
char *res2 = func0(tuple2, sizeof(tuple2)/sizeof(tuple2[0]));
assert(strcmp(res2, "{7: 2, 8: 2, 9: 1, 4: 2, 6: 1, 5: 1}") == 0);
free(res2);
int tuple3[] = {1, 4, 3, 1, 4, 5, 2, 6, 2, 7};
char *res3 = func0(tuple3, sizeof(tuple3)/sizeof(tuple3[0]));
assert(strcmp(res3, "{1: 2, 4: 2, 3: 1, 5: 1, 2: 2, 6: 1, 7: 1}") == 0);
free(res3);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x360,%rsp
mov %fs:0x28,%rax
mov %rax,0x358(%rsp)
xor %eax,%eax
test %esi,%esi
jle 1318 <func0+0x12f>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov $0x0,%ebx
mov $0x0,%r10d
mov %rsp,%rdi
jmp 1260 <func0+0x77>
mov %rdx,%rax
cmp %ecx,(%rdi,%rax,8)
je 126f <func0+0x86>
lea 0x1(%rax),%rdx
cmp %rsi,%rax
jne 1232 <func0+0x49>
movslq %ebx,%rax
mov (%r8),%edx
mov %edx,(%rsp,%rax,8)
movl $0x1,0x4(%rsp,%rax,8)
add $0x1,%ebx
add $0x4,%r8
cmp %r9,%r8
je 1279 <func0+0x90>
test %ebx,%ebx
jle 1243 <func0+0x5a>
mov (%r8),%ecx
lea -0x1(%rbx),%esi
mov %r10,%rax
jmp 1235 <func0+0x4c>
movslq %eax,%rdx
addl $0x1,0x4(%rsp,%rdx,8)
jmp 1257 <func0+0x6e>
mov $0x3e8,%edi
callq 10e0 <malloc@plt>
mov %rax,%r12
movb $0x0,(%rax)
mov $0x3e8,%edx
lea 0xd6f(%rip),%rsi
mov %rax,%rdi
callq 10a0 <__strcat_chk@plt>
test %ebx,%ebx
jle 133c <func0+0x153>
lea -0x1(%rbx),%r14d
mov $0x0,%ebp
lea 0x320(%rsp),%r13
jmp 12c4 <func0+0xdb>
lea 0x1(%rbp),%rax
cmp %r14,%rbp
je 133c <func0+0x153>
mov %rax,%rbp
mov 0x4(%rsp,%rbp,8),%r9d
mov (%rsp,%rbp,8),%r8d
lea 0xd32(%rip),%rcx
mov $0x32,%edx
mov $0x1,%esi
mov %r13,%rdi
mov $0x0,%eax
callq 10f0 <__sprintf_chk@plt>
mov $0x3e8,%edx
mov %r13,%rsi
mov %r12,%rdi
callq 10a0 <__strcat_chk@plt>
lea -0x1(%rbx),%eax
cmp %ebp,%eax
jle 12b8 <func0+0xcf>
mov $0x3e8,%edx
lea 0xcff(%rip),%rsi
mov %r12,%rdi
callq 10a0 <__strcat_chk@plt>
jmp 12b8 <func0+0xcf>
mov $0x3e8,%edi
callq 10e0 <malloc@plt>
mov %rax,%r12
movb $0x0,(%rax)
mov $0x3e8,%edx
lea 0xcd0(%rip),%rsi
mov %rax,%rdi
callq 10a0 <__strcat_chk@plt>
mov $0x3e8,%edx
lea 0xcd9(%rip),%rsi
mov %r12,%rdi
callq 10a0 <__strcat_chk@plt>
mov 0x358(%rsp),%rax
xor %fs:0x28,%rax
jne 1376 <func0+0x18d>
mov %r12,%rax
add $0x360,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 10c0 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 368h
mov rax, fs:28h
mov [rsp+398h+var_40], rax
xor eax, eax
test esi, esi
jle loc_1331
mov r8, rdi
lea eax, [rsi-1]
lea r9, [rdi+rax*4+4]
mov ebp, 0
mov rdi, rsp
jmp short loc_1275
loc_124E:
movsxd rdx, eax
add [rsp+rdx*8+398h+var_394], 1
jmp short loc_126C
loc_1258:
movsxd rax, ebp
mov edx, [r8]
mov [rsp+rax*8+398h+var_398], edx
mov [rsp+rax*8+398h+var_394], 1
add ebp, 1
loc_126C:
add r8, 4
cmp r8, r9
jz short loc_1293
loc_1275:
test ebp, ebp
jle short loc_1258
mov ecx, [r8]
mov esi, ebp
mov eax, 0
loc_1283:
cmp [rdi+rax*8], ecx
jz short loc_124E
add rax, 1
cmp rax, rsi
jnz short loc_1283
jmp short loc_1258
loc_1293:
mov edi, 3E8h
call _malloc
mov r12, rax
mov byte ptr [rax], 0
mov edx, 3E8h
lea rsi, unk_2004
mov rdi, rax
call ___strcat_chk
test ebp, ebp
jle loc_1355
mov r15d, ebp
mov ebx, 0
lea r13, [rsp+398h+var_78]
lea r14, aDD; "%d: %d"
sub ebp, 1
jmp short loc_12E4
loc_12DB:
add rbx, 1
cmp r15, rbx
jz short loc_1355
loc_12E4:
mov r9d, [rsp+rbx*8+398h+var_394]
mov r8d, [rsp+rbx*8+398h+var_398]
mov rcx, r14
mov edx, 32h ; '2'
mov esi, 1
mov rdi, r13
mov eax, 0
call ___sprintf_chk
mov edx, 3E8h
mov rsi, r13
mov rdi, r12
call ___strcat_chk
cmp ebp, ebx
jle short loc_12DB
mov edx, 3E8h
lea rsi, asc_200D; ", "
mov rdi, r12
call ___strcat_chk
jmp short loc_12DB
loc_1331:
mov edi, 3E8h
call _malloc
mov r12, rax
mov byte ptr [rax], 0
mov edx, 3E8h
lea rsi, unk_2004
mov rdi, rax
call ___strcat_chk
loc_1355:
mov edx, 3E8h
lea rsi, a435462+11h; "}"
mov rdi, r12
call ___strcat_chk
mov rax, [rsp+398h+var_40]
sub rax, fs:28h
jnz short loc_1391
mov rax, r12
add rsp, 368h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1391:
call ___stack_chk_fail | _BYTE * func0(_DWORD *a1, int a2)
{
_DWORD *v2; // r8
int v3; // ebp
long long v4; // rax
_BYTE *v5; // r12
long long v6; // r15
long long v7; // rbx
int v8; // ebp
_DWORD v10[200]; // [rsp+0h] [rbp-398h]
_BYTE v11[56]; // [rsp+320h] [rbp-78h] BYREF
unsigned long long v12; // [rsp+358h] [rbp-40h]
v12 = __readfsqword(0x28u);
if ( a2 <= 0 )
{
v5 = (_BYTE *)malloc(1000LL);
*v5 = 0;
__strcat_chk(v5, &unk_2004, 1000LL);
}
else
{
v2 = a1;
v3 = 0;
do
{
if ( v3 <= 0 )
{
LABEL_4:
v10[2 * v3] = *v2;
v10[2 * v3++ + 1] = 1;
}
else
{
v4 = 0LL;
while ( v10[2 * v4] != *v2 )
{
if ( ++v4 == v3 )
goto LABEL_4;
}
++v10[2 * (int)v4 + 1];
}
++v2;
}
while ( v2 != &a1[a2 - 1 + 1] );
v5 = (_BYTE *)malloc(1000LL);
*v5 = 0;
__strcat_chk(v5, &unk_2004, 1000LL);
if ( v3 > 0 )
{
v6 = (unsigned int)v3;
v7 = 0LL;
v8 = v3 - 1;
do
{
__sprintf_chk(v11, 1LL, 50LL, "%d: %d", v10[2 * v7], v10[2 * v7 + 1]);
__strcat_chk(v5, v11, 1000LL);
if ( v8 > (int)v7 )
__strcat_chk(v5, ", ", 1000LL);
++v7;
}
while ( v6 != v7 );
}
}
__strcat_chk(v5, "}", 1000LL);
return v5;
} | ||
6,638 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
struct dict {
int key;
int value;
};
| char * func0(int test_tup[], int size) {
struct dict freq[100]; // Assuming maximum number of unique elements is 100.
int count = 0;
for (int i = 0; i < size; i++) {
int found = 0;
for (int j = 0; j < count; j++) {
if (freq[j].key == test_tup[i]) {
freq[j].value++;
found = 1;
break;
}
}
if (!found) {
freq[count].key = test_tup[i];
freq[count].value = 1;
count++;
}
}
char *result = (char*)malloc(1000 * sizeof(char)); // Allocating memory for the result string.
char buffer[50];
result[0] = '\0'; // Initialize empty string
strcat(result, "{");
for (int i = 0; i < count; i++) {
sprintf(buffer, "%d: %d", freq[i].key, freq[i].value);
strcat(result, buffer);
if (i < count - 1) strcat(result, ", ");
}
strcat(result, "}");
return result;
}
| int main() {
int tuple1[] = {4, 5, 4, 5, 6, 6, 5, 5, 4};
char *res1 = func0(tuple1, sizeof(tuple1)/sizeof(tuple1[0]));
assert(strcmp(res1, "{4: 3, 5: 4, 6: 2}") == 0);
free(res1);
int tuple2[] = {7, 8, 8, 9, 4, 7, 6, 5, 4};
char *res2 = func0(tuple2, sizeof(tuple2)/sizeof(tuple2[0]));
assert(strcmp(res2, "{7: 2, 8: 2, 9: 1, 4: 2, 6: 1, 5: 1}") == 0);
free(res2);
int tuple3[] = {1, 4, 3, 1, 4, 5, 2, 6, 2, 7};
char *res3 = func0(tuple3, sizeof(tuple3)/sizeof(tuple3[0]));
assert(strcmp(res3, "{1: 2, 4: 2, 3: 1, 5: 1, 2: 2, 6: 1, 7: 1}") == 0);
free(res3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x378,%rsp
mov %fs:0x28,%rax
mov %rax,0x368(%rsp)
xor %eax,%eax
test %esi,%esi
jle 15e7 <func0+0x1a7>
lea -0x1(%rsi),%eax
xor %ebx,%ebx
lea 0x10(%rsp),%r15
lea 0x4(%rdi,%rax,4),%r8
mov (%rdi),%ecx
lea -0x1(%rbx),%esi
xor %eax,%eax
test %ebx,%ebx
jne 14a0 <func0+0x60>
jmpq 15d0 <func0+0x190>
lea 0x1(%rax),%rdx
cmp %rax,%rsi
je 15d0 <func0+0x190>
mov %rdx,%rax
movslq %eax,%rdx
cmp %ecx,(%r15,%rax,8)
jne 1490 <func0+0x50>
addl $0x1,0x14(%rsp,%rdx,8)
add $0x4,%rdi
cmp %r8,%rdi
jne 1480 <func0+0x40>
mov $0x3e8,%edi
xor %r14d,%r14d
lea 0x330(%rsp),%rbp
callq 1120 <malloc@plt>
mov $0x7b,%edx
lea 0xb2c(%rip),%r13
mov %dx,(%rax)
mov %rax,%r12
lea -0x1(%rbx),%eax
mov %rax,0x8(%rsp)
mov %rax,%rbx
jmp 14f3 <func0+0xb3>
nopl 0x0(%rax,%rax,1)
mov %rax,%r14
mov 0x4(%r15,%r14,8),%r9d
mov (%r15,%r14,8),%r8d
mov %rbp,%rdi
mov %r13,%rcx
mov $0x32,%edx
mov $0x1,%esi
xor %eax,%eax
callq 1130 <__sprintf_chk@plt>
mov %r12,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 1516 <func0+0xd6>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x3e8,%edx
mov %eax,%esi
add %al,%sil
mov %rbp,%rsi
sbb $0x3,%rdi
callq 1110 <__stpcpy_chk@plt>
cmp %r14d,%ebx
jle 157e <func0+0x13e>
mov %r12,%rcx
mov $0x3,%edx
lea 0xa9f(%rip),%rsi
mov %rax,%rdi
sub %rax,%rcx
add $0x3e8,%rcx
callq 1100 <__memcpy_chk@plt>
lea 0x1(%r14),%rax
cmp 0x8(%rsp),%r14
jne 14f0 <func0+0xb0>
mov $0x3e8,%edx
lea 0xa86(%rip),%rsi
mov %r12,%rdi
callq 10c0 <__strcat_chk@plt>
mov 0x368(%rsp),%rax
xor %fs:0x28,%rax
jne 1600 <func0+0x1c0>
add $0x378,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
movslq %ebx,%rax
add $0x1,%ebx
mov %ecx,0x10(%rsp,%rax,8)
movl $0x1,0x14(%rsp,%rax,8)
jmpq 14ae <func0+0x6e>
mov $0x3e8,%edi
callq 1120 <malloc@plt>
mov %rax,%r12
mov $0x7b,%eax
mov %ax,(%r12)
jmp 158d <func0+0x14d>
callq 10e0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 368h
mov rax, fs:28h
mov [rsp+398h+var_40], rax
xor eax, eax
test esi, esi
jle loc_15C6
lea eax, [rsi-1]
xor ebp, ebp
xor ebx, ebx
mov r14, rsp
lea rsi, [rdi+rax*4+4]
nop
loc_14A0:
mov ecx, [rdi]
xor eax, eax
test ebp, ebp
jnz short loc_14BD
jmp loc_15B0
loc_14B0:
add rax, 1
cmp rax, rbx
jz loc_15B0
loc_14BD:
movsxd rdx, eax
cmp [r14+rax*8], ecx
jnz short loc_14B0
add [rsp+rdx*8+398h+var_394], 1
loc_14CB:
add rdi, 4
cmp rdi, rsi
jnz short loc_14A0
mov edi, 3E8h
sub ebp, 1
xor r15d, r15d
call _malloc
mov edx, 7Bh ; '{'
lea r13, [rsp+398h+var_78]
mov [rax], dx
mov r12, rax
nop word ptr [rax+rax+00000000h]
loc_1500:
mov r9d, [r14+r15*8+4]
mov r8d, [r14+r15*8]
mov edx, 32h ; '2'
xor eax, eax
lea rcx, aDD; "%d: %d"
mov esi, 1
mov rdi, r13
call ___sprintf_chk
mov rdi, r12
call _strlen
mov edx, 3E8h
mov rsi, r13
lea rdi, [r12+rax]
call ___stpcpy_chk
mov rdi, rax
cmp ebp, r15d
jle short loc_1563
mov rcx, r12
mov edx, 3
lea rsi, asc_200B; ", "
sub rcx, rax
add rcx, 3E8h
call ___memcpy_chk
loc_1563:
add r15, 1
cmp r15, rbx
jnz short loc_1500
loc_156C:
mov edx, 3E8h
lea rsi, a435462+11h; "}"
mov rdi, r12
call ___strcat_chk
mov rax, [rsp+398h+var_40]
sub rax, fs:28h
jnz short loc_15DF
add rsp, 368h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15B0:
add ebp, 1
mov [rsp+rbx*8+398h+var_398], ecx
mov [rsp+rbx*8+398h+var_394], 1
movsxd rbx, ebp
jmp loc_14CB
loc_15C6:
mov edi, 3E8h
call _malloc
mov r12, rax
mov eax, 7Bh ; '{'
mov [r12], ax
jmp short loc_156C
loc_15DF:
call ___stack_chk_fail | _WORD * func0(int *a1, int a2)
{
int v2; // ebp
long long v3; // rbx
long long v4; // rsi
int v5; // ecx
long long v6; // rax
int v7; // ebp
long long v8; // r15
_WORD *v9; // rax
_WORD *v10; // r12
long long v11; // rax
long long v12; // rax
_DWORD v14[200]; // [rsp+0h] [rbp-398h] BYREF
_BYTE v15[56]; // [rsp+320h] [rbp-78h] BYREF
unsigned long long v16; // [rsp+358h] [rbp-40h]
v16 = __readfsqword(0x28u);
if ( a2 <= 0 )
{
v10 = (_WORD *)malloc(1000LL);
*v10 = 123;
}
else
{
v2 = 0;
v3 = 0LL;
v4 = (long long)&a1[a2 - 1 + 1];
do
{
v5 = *a1;
v6 = 0LL;
if ( v2 )
{
while ( v14[2 * v6] != v5 )
{
if ( ++v6 == v3 )
goto LABEL_14;
}
++v14[2 * (int)v6 + 1];
}
else
{
LABEL_14:
++v2;
v14[2 * v3] = v5;
v14[2 * v3 + 1] = 1;
v3 = v2;
}
++a1;
}
while ( a1 != (int *)v4 );
v7 = v2 - 1;
v8 = 0LL;
v9 = (_WORD *)malloc(1000LL);
*v9 = 123;
v10 = v9;
do
{
__sprintf_chk(v15, 1LL, 50LL, "%d: %d", v14[2 * v8], v14[2 * v8 + 1]);
v11 = strlen(v10);
v12 = __stpcpy_chk((char *)v10 + v11, v15, 1000LL);
if ( v7 > (int)v8 )
__memcpy_chk(v12, ", ", 3LL, (char *)v10 - v12 + 1000);
++v8;
}
while ( v8 != v3 );
}
__strcat_chk(v10, "}", 1000LL);
return v10;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x368
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x358],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x001015c6
LEA EAX,[RSI + -0x1]
XOR EBP,EBP
XOR EBX,EBX
MOV R14,RSP
LEA RSI,[RDI + RAX*0x4 + 0x4]
NOP
LAB_001014a0:
MOV ECX,dword ptr [RDI]
XOR EAX,EAX
TEST EBP,EBP
JNZ 0x001014bd
JMP 0x001015b0
LAB_001014b0:
ADD RAX,0x1
CMP RAX,RBX
JZ 0x001015b0
LAB_001014bd:
MOVSXD RDX,EAX
CMP dword ptr [R14 + RAX*0x8],ECX
JNZ 0x001014b0
ADD dword ptr [RSP + RDX*0x8 + 0x4],0x1
LAB_001014cb:
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x001014a0
MOV EDI,0x3e8
SUB EBP,0x1
XOR R15D,R15D
CALL 0x00101160
MOV EDX,0x7b
LEA R13,[RSP + 0x320]
MOV word ptr [RAX],DX
MOV R12,RAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101500:
MOV R9D,dword ptr [R14 + R15*0x8 + 0x4]
MOV R8D,dword ptr [R14 + R15*0x8]
MOV EDX,0x32
XOR EAX,EAX
LEA RCX,[0x102004]
MOV ESI,0x1
MOV RDI,R13
CALL 0x00101170
MOV RDI,R12
CALL 0x00101100
MOV EDX,0x3e8
MOV RSI,R13
LEA RDI,[R12 + RAX*0x1]
CALL 0x00101150
MOV RDI,RAX
CMP EBP,R15D
JLE 0x00101563
MOV RCX,R12
MOV EDX,0x3
LEA RSI,[0x10200b]
SUB RCX,RAX
ADD RCX,0x3e8
CALL 0x00101140
LAB_00101563:
ADD R15,0x1
CMP R15,RBX
JNZ 0x00101500
LAB_0010156c:
MOV EDX,0x3e8
LEA RSI,[0x10201f]
MOV RDI,R12
CALL 0x001010e0
MOV RAX,qword ptr [RSP + 0x358]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001015df
ADD RSP,0x368
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015b0:
ADD EBP,0x1
MOV dword ptr [RSP + RBX*0x8],ECX
MOV dword ptr [RSP + RBX*0x8 + 0x4],0x1
MOVSXD RBX,EBP
JMP 0x001014cb
LAB_001015c6:
MOV EDI,0x3e8
CALL 0x00101160
MOV R12,RAX
MOV EAX,0x7b
MOV word ptr [R12],AX
JMP 0x0010156c
LAB_001015df:
CALL 0x00101110 | char * func0(int *param_1,int param_2)
{
int *piVar1;
char *__s;
size_t sVar2;
long lVar3;
long lVar4;
int iVar5;
long lVar6;
long in_FS_OFFSET;
int local_398 [200];
int1 local_78 [56];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 < 1) {
__s = (char *)malloc(1000);
__s[0] = '{';
__s[1] = '\0';
}
else {
iVar5 = 0;
lVar4 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
lVar6 = 0;
if (iVar5 != 0) {
do {
if (local_398[lVar6 * 2] == *param_1) {
local_398[(long)(int)lVar6 * 2 + 1] = local_398[(long)(int)lVar6 * 2 + 1] + 1;
goto LAB_001014cb;
}
lVar6 = lVar6 + 1;
} while (lVar6 != lVar4);
}
iVar5 = iVar5 + 1;
local_398[lVar4 * 2] = *param_1;
local_398[lVar4 * 2 + 1] = 1;
lVar4 = (long)iVar5;
LAB_001014cb:
param_1 = param_1 + 1;
} while (param_1 != piVar1);
lVar6 = 0;
__s = (char *)malloc(1000);
__s[0] = '{';
__s[1] = '\0';
do {
__sprintf_chk(local_78,1,0x32,"%d: %d",local_398[lVar6 * 2],local_398[lVar6 * 2 + 1]);
sVar2 = strlen(__s);
lVar3 = __stpcpy_chk(__s + sVar2,local_78,1000);
if ((int)lVar6 < iVar5 + -1) {
__memcpy_chk(lVar3,&DAT_0010200b,3,__s + (1000 - lVar3));
}
lVar6 = lVar6 + 1;
} while (lVar6 != lVar4);
}
__strcat_chk(__s,&DAT_0010201f,1000);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __s;
} |
6,639 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
struct dict {
int key;
int value;
};
| char * func0(int test_tup[], int size) {
struct dict freq[100]; // Assuming maximum number of unique elements is 100.
int count = 0;
for (int i = 0; i < size; i++) {
int found = 0;
for (int j = 0; j < count; j++) {
if (freq[j].key == test_tup[i]) {
freq[j].value++;
found = 1;
break;
}
}
if (!found) {
freq[count].key = test_tup[i];
freq[count].value = 1;
count++;
}
}
char *result = (char*)malloc(1000 * sizeof(char)); // Allocating memory for the result string.
char buffer[50];
result[0] = '\0'; // Initialize empty string
strcat(result, "{");
for (int i = 0; i < count; i++) {
sprintf(buffer, "%d: %d", freq[i].key, freq[i].value);
strcat(result, buffer);
if (i < count - 1) strcat(result, ", ");
}
strcat(result, "}");
return result;
}
| int main() {
int tuple1[] = {4, 5, 4, 5, 6, 6, 5, 5, 4};
char *res1 = func0(tuple1, sizeof(tuple1)/sizeof(tuple1[0]));
assert(strcmp(res1, "{4: 3, 5: 4, 6: 2}") == 0);
free(res1);
int tuple2[] = {7, 8, 8, 9, 4, 7, 6, 5, 4};
char *res2 = func0(tuple2, sizeof(tuple2)/sizeof(tuple2[0]));
assert(strcmp(res2, "{7: 2, 8: 2, 9: 1, 4: 2, 6: 1, 5: 1}") == 0);
free(res2);
int tuple3[] = {1, 4, 3, 1, 4, 5, 2, 6, 2, 7};
char *res3 = func0(tuple3, sizeof(tuple3)/sizeof(tuple3[0]));
assert(strcmp(res3, "{1: 2, 4: 2, 3: 1, 5: 1, 2: 2, 6: 1, 7: 1}") == 0);
free(res3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x378,%rsp
mov %fs:0x28,%rax
mov %rax,0x368(%rsp)
xor %eax,%eax
test %esi,%esi
jle 15f8 <func0+0x218>
lea -0x1(%rsi),%eax
xor %r12d,%r12d
lea 0x10(%rsp),%r15
lea 0x4(%rdi,%rax,4),%r8
mov (%rdi),%ecx
lea -0x1(%r12),%esi
xor %eax,%eax
test %r12d,%r12d
jne 1448 <func0+0x68>
jmpq 1520 <func0+0x140>
nopl 0x0(%rax,%rax,1)
lea 0x1(%rax),%rdx
cmp %rsi,%rax
je 1520 <func0+0x140>
mov %rdx,%rax
movslq %eax,%rdx
cmp %ecx,(%r15,%rax,8)
jne 1438 <func0+0x58>
addl $0x1,0x14(%rsp,%rdx,8)
add $0x4,%rdi
cmp %r8,%rdi
jne 1420 <func0+0x40>
mov $0x3e8,%edi
callq 1120 <malloc@plt>
mov $0x7b,%edx
mov %dx,(%rax)
mov %rax,%r14
lea -0x1(%r12),%eax
mov %eax,0xc(%rsp)
test %eax,%eax
jg 1540 <func0+0x160>
xor %ebx,%ebx
lea 0x330(%rsp),%r13
movslq %ebx,%rbx
lea 0xb6b(%rip),%rbp
nopl 0x0(%rax)
mov 0x4(%r15,%rbx,8),%r9d
mov (%r15,%rbx,8),%r8d
mov %rbp,%rcx
mov %r13,%rdi
mov $0x32,%edx
mov $0x1,%esi
xor %eax,%eax
add $0x1,%rbx
callq 1130 <__sprintf_chk@plt>
mov $0x3e8,%edx
mov %r13,%rsi
mov %r14,%rdi
callq 10c0 <__strcat_chk@plt>
cmp %ebx,%r12d
jg 14a0 <func0+0xc0>
mov $0x3e8,%edx
lea 0xb3a(%rip),%rsi
mov %r14,%rdi
callq 10c0 <__strcat_chk@plt>
mov 0x368(%rsp),%rax
xor %fs:0x28,%rax
jne 1613 <func0+0x233>
add $0x378,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
movslq %r12d,%rax
add $0x1,%r12d
mov %ecx,0x10(%rsp,%rax,8)
movl $0x1,0x14(%rsp,%rax,8)
jmpq 1456 <func0+0x76>
nopl 0x0(%rax,%rax,1)
mov %r15,%rbp
xor %ebx,%ebx
lea 0x330(%rsp),%r13
nopl (%rax)
mov 0x4(%rbp),%r9d
mov 0x0(%rbp),%r8d
mov %r13,%rdi
mov $0x32,%edx
lea 0xa9d(%rip),%rcx
mov $0x1,%esi
xor %eax,%eax
callq 1130 <__sprintf_chk@plt>
mov %r14,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 1576 <func0+0x196>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x3e8,%edx
mov %eax,%esi
add %al,%sil
mov %r13,%rsi
sbb $0x3,%rdi
add $0x1,%ebx
add $0x8,%rbp
callq 1110 <__stpcpy_chk@plt>
mov %r14,%rcx
mov $0x3,%edx
lea 0xa3d(%rip),%rsi
sub %rax,%rcx
mov %rax,%rdi
add $0x3e8,%rcx
callq 1100 <__memcpy_chk@plt>
cmp 0xc(%rsp),%ebx
jl 1550 <func0+0x170>
cmp %ebx,%r12d
jg 148f <func0+0xaf>
jmpq 14d9 <func0+0xf9>
mov $0x3e8,%edi
callq 1120 <malloc@plt>
mov %rax,%r14
mov $0x7b,%eax
mov %ax,(%r14)
jmpq 14d9 <func0+0xf9>
callq 10e0 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 378h
mov rax, fs:28h
mov [rsp+3A8h+var_40], rax
xor eax, eax
test esi, esi
jle loc_1602
movsxd rsi, esi
xor r15d, r15d
lea rbx, [rsp+3A8h+var_398]
lea r8, [rdi+rsi*4]
nop
loc_1450:
mov edx, [rdi]
movsxd rcx, r15d
test r15d, r15d
jle short loc_1488
loc_145A:
xor eax, eax
jmp short loc_1469
loc_1460:
add rax, 1
cmp rax, rcx
jz short loc_1488
loc_1469:
cmp [rbx+rax*8], edx
jnz short loc_1460
cdqe
add rdi, 4
add [rsp+rax*8+3A8h+var_394], 1
cmp rdi, r8
jz short loc_14A1
mov edx, [rdi]
jmp short loc_145A
loc_1488:
add rdi, 4
mov [rsp+rcx*8+3A8h+var_398], edx
add r15d, 1
mov [rsp+rcx*8+3A8h+var_394], 1
cmp rdi, r8
jnz short loc_1450
loc_14A1:
mov edi, 3E8h; size
call _malloc
mov edx, 7Bh ; '{'
mov [rax], dx
mov r12, rax
test r15d, r15d
jle short loc_1519
lea edx, [r15-1]
test edx, edx
jg loc_1559
xor ebp, ebp
lea rbx, [rsp+3A8h+var_398]
lea r13, [rsp+3A8h+var_78]
lea r14, aDD; "%d: %d"
nop dword ptr [rax]
loc_14E0:
mov r9d, [rbx+rbp*8+4]
mov r8d, [rbx+rbp*8]
mov rcx, r14
mov rdi, r13
mov edx, 32h ; '2'
mov esi, 2
xor eax, eax
add rbp, 1
call ___sprintf_chk
mov edx, 3E8h
mov rsi, r13
mov rdi, r12
call ___strcat_chk
cmp r15d, ebp
jg short loc_14E0
loc_1519:
mov edx, 3E8h
lea rsi, s2+11h; "}"
mov rdi, r12
call ___strcat_chk
mov rax, [rsp+3A8h+var_40]
sub rax, fs:28h
jnz loc_161E
add rsp, 378h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1559:
lea rbx, [rsp+3A8h+var_398]
xor ebp, ebp
mov [rsp+3A8h+var_3A4], r15d
lea r13, [rsp+3A8h+var_78]
mov [rsp+3A8h+var_3A0], rbx
mov r15d, ebp
lea r14, aDD; "%d: %d"
mov rbp, rbx
mov ebx, edx
loc_1581:
mov r9d, [rbp+4]
mov r8d, [rbp+0]
mov rcx, r14
mov edx, 32h ; '2'
mov esi, 2
mov rdi, r13
xor eax, eax
add r15d, 1
call ___sprintf_chk
mov rdi, r12; s
add rbp, 8
call _strlen
mov edx, 3E8h
mov rsi, r13
lea rdi, [r12+rax]
call ___stpcpy_chk
mov rcx, r12
mov edx, 3
lea rsi, asc_200B; ", "
sub rcx, rax
mov rdi, rax
add rcx, 3E8h
call ___memcpy_chk
cmp r15d, ebx
jl short loc_1581
movsxd rbp, r15d
mov r15d, [rsp+3A8h+var_3A4]
mov rbx, [rsp+3A8h+var_3A0]
cmp ebp, r15d
jl loc_14E0
jmp loc_1519
loc_1602:
mov edi, 3E8h; size
call _malloc
mov r12, rax
mov eax, 7Bh ; '{'
mov [r12], ax
jmp loc_1519
loc_161E:
call ___stack_chk_fail | char * func0(int *a1, int a2)
{
int v2; // r15d
int *v3; // r8
int v4; // edx
long long v5; // rcx
long long v6; // rax
char *v7; // rax
char *v8; // r12
int v9; // edx
long long v10; // rbp
int v11; // r9d
int v12; // r8d
int v14; // r15d
_DWORD *v15; // rbp
int v16; // ebx
size_t v17; // rax
long long v18; // rax
int v19; // [rsp+4h] [rbp-3A4h]
_DWORD v20[200]; // [rsp+10h] [rbp-398h] BYREF
_BYTE v21[56]; // [rsp+330h] [rbp-78h] BYREF
unsigned long long v22; // [rsp+368h] [rbp-40h]
v22 = __readfsqword(0x28u);
if ( a2 <= 0 )
{
v8 = (char *)malloc(0x3E8uLL);
*(_WORD *)v8 = 123;
goto LABEL_14;
}
v2 = 0;
v3 = &a1[a2];
while ( 1 )
{
v4 = *a1;
v5 = v2;
if ( v2 > 0 )
break;
LABEL_9:
++a1;
v20[2 * v2++] = v4;
v20[2 * v5 + 1] = 1;
if ( a1 == v3 )
goto LABEL_10;
}
while ( 1 )
{
v6 = 0LL;
while ( v20[2 * v6] != v4 )
{
if ( ++v6 == v2 )
goto LABEL_9;
}
++a1;
++v20[2 * (int)v6 + 1];
if ( a1 == v3 )
break;
v4 = *a1;
}
LABEL_10:
v7 = (char *)malloc(0x3E8uLL);
*(_WORD *)v7 = 123;
v8 = v7;
if ( v2 > 0 )
{
v9 = v2 - 1;
if ( v2 - 1 <= 0 )
{
v10 = 0LL;
do
{
LABEL_13:
v11 = v20[2 * v10 + 1];
v12 = v20[2 * v10++];
__sprintf_chk(v21, 2LL, 50LL, "%d: %d", v12, v11);
__strcat_chk(v8, v21, 1000LL);
}
while ( v2 > (int)v10 );
goto LABEL_14;
}
v19 = v2;
v14 = 0;
v15 = v20;
v16 = v9;
do
{
++v14;
__sprintf_chk(v21, 2LL, 50LL, "%d: %d", *v15, v15[1]);
v15 += 2;
v17 = strlen(v8);
v18 = __stpcpy_chk(&v8[v17], v21, 1000LL);
__memcpy_chk(v18, ", ", 3LL, &v8[-v18 + 1000]);
}
while ( v14 < v16 );
v10 = v14;
v2 = v19;
if ( (int)v10 < v19 )
goto LABEL_13;
}
LABEL_14:
__strcat_chk(v8, "}", 1000LL);
return v8;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x378
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x368],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x00101602
MOVSXD RSI,ESI
XOR R15D,R15D
LEA RBX,[RSP + 0x10]
LEA R8,[RDI + RSI*0x4]
NOP
LAB_00101450:
MOV EDX,dword ptr [RDI]
MOVSXD RCX,R15D
TEST R15D,R15D
JLE 0x00101488
LAB_0010145a:
XOR EAX,EAX
JMP 0x00101469
LAB_00101460:
ADD RAX,0x1
CMP RAX,RCX
JZ 0x00101488
LAB_00101469:
CMP dword ptr [RBX + RAX*0x8],EDX
JNZ 0x00101460
CDQE
ADD RDI,0x4
ADD dword ptr [RSP + RAX*0x8 + 0x14],0x1
CMP RDI,R8
JZ 0x001014a1
MOV EDX,dword ptr [RDI]
JMP 0x0010145a
LAB_00101488:
ADD RDI,0x4
MOV dword ptr [RSP + RCX*0x8 + 0x10],EDX
ADD R15D,0x1
MOV dword ptr [RSP + RCX*0x8 + 0x14],0x1
CMP RDI,R8
JNZ 0x00101450
LAB_001014a1:
MOV EDI,0x3e8
CALL 0x00101160
MOV EDX,0x7b
MOV word ptr [RAX],DX
MOV R12,RAX
TEST R15D,R15D
JLE 0x00101519
LEA EDX,[R15 + -0x1]
TEST EDX,EDX
JG 0x00101559
XOR EBP,EBP
LEA RBX,[RSP + 0x10]
LEA R13,[RSP + 0x330]
LEA R14,[0x102004]
NOP dword ptr [RAX]
LAB_001014e0:
MOV R9D,dword ptr [RBX + RBP*0x8 + 0x4]
MOV R8D,dword ptr [RBX + RBP*0x8]
MOV RCX,R14
MOV RDI,R13
MOV EDX,0x32
MOV ESI,0x2
XOR EAX,EAX
ADD RBP,0x1
CALL 0x00101170
MOV EDX,0x3e8
MOV RSI,R13
MOV RDI,R12
CALL 0x001010e0
CMP R15D,EBP
JG 0x001014e0
LAB_00101519:
MOV EDX,0x3e8
LEA RSI,[0x10201f]
MOV RDI,R12
CALL 0x001010e0
MOV RAX,qword ptr [RSP + 0x368]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010161e
ADD RSP,0x378
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101559:
LEA RBX,[RSP + 0x10]
XOR EBP,EBP
MOV dword ptr [RSP + 0x4],R15D
LEA R13,[RSP + 0x330]
MOV qword ptr [RSP + 0x8],RBX
MOV R15D,EBP
LEA R14,[0x102004]
MOV RBP,RBX
MOV EBX,EDX
LAB_00101581:
MOV R9D,dword ptr [RBP + 0x4]
MOV R8D,dword ptr [RBP]
MOV RCX,R14
MOV EDX,0x32
MOV ESI,0x2
MOV RDI,R13
XOR EAX,EAX
ADD R15D,0x1
CALL 0x00101170
MOV RDI,R12
ADD RBP,0x8
CALL 0x00101100
MOV EDX,0x3e8
MOV RSI,R13
LEA RDI,[R12 + RAX*0x1]
CALL 0x00101150
MOV RCX,R12
MOV EDX,0x3
LEA RSI,[0x10200b]
SUB RCX,RAX
MOV RDI,RAX
ADD RCX,0x3e8
CALL 0x00101140
CMP R15D,EBX
JL 0x00101581
MOVSXD RBP,R15D
MOV R15D,dword ptr [RSP + 0x4]
MOV RBX,qword ptr [RSP + 0x8]
CMP EBP,R15D
JL 0x001014e0
JMP 0x00101519
LAB_00101602:
MOV EDI,0x3e8
CALL 0x00101160
MOV R12,RAX
MOV EAX,0x7b
MOV word ptr [R12],AX
JMP 0x00101519
LAB_0010161e:
CALL 0x00101110 | char * func0(int *param_1,int param_2)
{
long lVar1;
long lVar2;
char *__s;
size_t sVar3;
long lVar4;
int *piVar5;
int iVar6;
int iVar7;
long in_FS_OFFSET;
int local_398 [200];
int local_78 [56];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 < 1) {
__s = (char *)malloc(1000);
__s[0] = '{';
__s[1] = '\0';
}
else {
iVar6 = 0;
piVar5 = param_1 + param_2;
do {
iVar7 = *param_1;
lVar4 = (long)iVar6;
if (0 < iVar6) {
while( true ) {
lVar2 = 0;
while (local_398[lVar2 * 2] != iVar7) {
lVar2 = lVar2 + 1;
if (lVar2 == lVar4) goto LAB_00101488;
}
param_1 = param_1 + 1;
local_398[(long)(int)lVar2 * 2 + 1] = local_398[(long)(int)lVar2 * 2 + 1] + 1;
if (param_1 == piVar5) break;
iVar7 = *param_1;
}
break;
}
LAB_00101488:
param_1 = param_1 + 1;
local_398[lVar4 * 2] = iVar7;
iVar6 = iVar6 + 1;
local_398[lVar4 * 2 + 1] = 1;
} while (param_1 != piVar5);
__s = (char *)malloc(1000);
__s[0] = '{';
__s[1] = '\0';
if (0 < iVar6) {
if (iVar6 + -1 < 1) {
lVar4 = 0;
}
else {
piVar5 = local_398;
iVar7 = 0;
do {
iVar7 = iVar7 + 1;
__sprintf_chk(local_78,2,0x32,"%d: %d",*piVar5,piVar5[1]);
piVar5 = piVar5 + 2;
sVar3 = strlen(__s);
lVar4 = __stpcpy_chk(__s + sVar3,local_78,1000);
__memcpy_chk(lVar4,&DAT_0010200b,3,__s + (1000 - lVar4));
} while (iVar7 < iVar6 + -1);
lVar4 = (long)iVar7;
if (iVar6 <= iVar7) goto LAB_00101519;
}
do {
lVar2 = lVar4 * 2;
lVar1 = lVar4 * 2;
lVar4 = lVar4 + 1;
__sprintf_chk(local_78,2,0x32,"%d: %d",local_398[lVar1],local_398[lVar2 + 1]);
__strcat_chk(__s,local_78,1000);
} while ((int)lVar4 < iVar6);
}
}
LAB_00101519:
__strcat_chk(__s,&DAT_0010201f,1000);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __s;
} |
6,640 | func0 |
#include <assert.h>
| int func0(int a, int b) {
int low = a < b ? a : b;
int high = a > b ? a : b;
if (low == 0) {
return high;
} else if (low == 1) {
return 1;
} else {
return func0(low, high % low);
}
}
| int main() {
assert(func0(12, 14) == 2);
assert(func0(13, 17) == 1);
assert(func0(9, 3) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
cmp %eax,-0x18(%rbp)
cmovle -0x18(%rbp),%eax
mov %eax,-0x8(%rbp)
mov -0x14(%rbp),%eax
cmp %eax,-0x18(%rbp)
cmovge -0x18(%rbp),%eax
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x8(%rbp)
jne 1180 <func0+0x37>
mov -0x4(%rbp),%eax
jmp 11a0 <func0+0x57>
cmpl $0x1,-0x8(%rbp)
jne 118d <func0+0x44>
mov $0x1,%eax
jmp 11a0 <func0+0x57>
mov -0x4(%rbp),%eax
cltd
idivl -0x8(%rbp)
mov -0x8(%rbp),%eax
mov %edx,%esi
mov %eax,%edi
callq 1149 <func0>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov edx, [rbp+var_18]
mov eax, [rbp+var_14]
cmp edx, eax
cmovle eax, edx
mov [rbp+var_8], eax
mov edx, [rbp+var_18]
mov eax, [rbp+var_14]
cmp edx, eax
cmovge eax, edx
mov [rbp+var_4], eax
cmp [rbp+var_8], 0
jnz short loc_1182
mov eax, [rbp+var_4]
jmp short locret_11A2
loc_1182:
cmp [rbp+var_8], 1
jnz short loc_118F
mov eax, 1
jmp short locret_11A2
loc_118F:
mov eax, [rbp+var_4]
cdq
idiv [rbp+var_8]
mov eax, [rbp+var_8]
mov esi, edx
mov edi, eax
call func0
locret_11A2:
leave
retn | long long func0(int a1, int a2)
{
unsigned int v2; // eax
long long result; // rax
unsigned int v4; // [rsp+18h] [rbp-8h]
v2 = a1;
if ( a2 <= a1 )
v2 = a2;
v4 = v2;
LODWORD(result) = a1;
if ( a2 >= a1 )
LODWORD(result) = a2;
if ( !v4 )
return (unsigned int)result;
if ( v4 == 1 )
return 1LL;
return func0(v4, (unsigned int)((int)result % (int)v4));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x14]
CMP EDX,EAX
CMOVLE EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x14]
CMP EDX,EAX
CMOVGE EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x8],0x0
JNZ 0x00101182
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x001011a2
LAB_00101182:
CMP dword ptr [RBP + -0x8],0x1
JNZ 0x0010118f
MOV EAX,0x1
JMP 0x001011a2
LAB_0010118f:
MOV EAX,dword ptr [RBP + -0x4]
CDQ
IDIV dword ptr [RBP + -0x8]
MOV EAX,dword ptr [RBP + -0x8]
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101149
LAB_001011a2:
LEAVE
RET | ulong func0(uint param_1,uint param_2)
{
uint uVar1;
ulong uVar2;
uVar1 = param_1;
if ((int)param_2 <= (int)param_1) {
uVar1 = param_2;
}
if ((int)param_1 <= (int)param_2) {
param_1 = param_2;
}
if (uVar1 == 0) {
uVar2 = (ulong)param_1;
}
else if (uVar1 == 1) {
uVar2 = 1;
}
else {
uVar2 = func0(uVar1,(long)(int)param_1 % (long)(int)uVar1 & 0xffffffff);
}
return uVar2;
} |
6,641 | func0 |
#include <assert.h>
| int func0(int a, int b) {
int low = a < b ? a : b;
int high = a > b ? a : b;
if (low == 0) {
return high;
} else if (low == 1) {
return 1;
} else {
return func0(low, high % low);
}
}
| int main() {
assert(func0(12, 14) == 2);
assert(func0(13, 17) == 1);
assert(func0(9, 3) == 3);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
cmp %edi,%esi
cmovle %esi,%edi
cmovge %esi,%eax
test %edi,%edi
je 1176 <func0+0x2d>
cmp $0x1,%edi
jne 1163 <func0+0x1a>
mov %edi,%eax
retq
sub $0x8,%rsp
cltd
idiv %edi
mov %edx,%esi
callq 1149 <func0>
add $0x8,%rsp
retq
retq
| func0:
endbr64
cmp esi, edi
mov ecx, edi
cmovle ecx, esi
mov eax, edi
cmovge eax, esi
test ecx, ecx
jz short locret_117A
cmp ecx, 1
jnz short loc_1165
mov eax, ecx
retn
loc_1165:
sub rsp, 8
cdq
idiv ecx
mov esi, edx
mov edi, ecx
call func0
add rsp, 8
retn
locret_117A:
retn | long long func0(signed int a1, signed int a2)
{
unsigned int v2; // ecx
long long result; // rax
v2 = a1;
if ( a2 <= a1 )
v2 = a2;
result = (unsigned int)a1;
if ( a2 >= a1 )
result = (unsigned int)a2;
if ( v2 )
{
if ( v2 == 1 )
return 1LL;
else
return func0(v2, (unsigned int)((int)result % (int)v2));
}
return result;
} | func0:
ENDBR64
CMP ESI,EDI
MOV ECX,EDI
CMOVLE ECX,ESI
MOV EAX,EDI
CMOVGE EAX,ESI
TEST ECX,ECX
JZ 0x0010117a
CMP ECX,0x1
JNZ 0x00101165
MOV EAX,ECX
RET
LAB_00101165:
SUB RSP,0x8
CDQ
IDIV ECX
MOV ESI,EDX
MOV EDI,ECX
CALL 0x00101149
ADD RSP,0x8
RET
LAB_0010117a:
RET | ulong func0(uint param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
int iVar3;
uVar2 = (ulong)param_1;
if ((int)param_2 <= (int)param_1) {
uVar2 = (ulong)param_2;
}
uVar1 = (ulong)param_1;
if ((int)param_1 <= (int)param_2) {
uVar1 = (ulong)param_2;
}
iVar3 = (int)uVar2;
if (iVar3 != 0) {
if (iVar3 == 1) {
return uVar2;
}
uVar2 = func0(uVar2,(long)(int)uVar1 % (long)iVar3 & 0xffffffff);
return uVar2;
}
return uVar1;
} |
6,642 | func0 |
#include <assert.h>
| int func0(int a, int b) {
int low = a < b ? a : b;
int high = a > b ? a : b;
if (low == 0) {
return high;
} else if (low == 1) {
return 1;
} else {
return func0(low, high % low);
}
}
| int main() {
assert(func0(12, 14) == 2);
assert(func0(13, 17) == 1);
assert(func0(9, 3) == 3);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%ecx
mov %esi,%eax
cmovle %edi,%ecx
cmovge %edi,%eax
test %ecx,%ecx
jne 1173 <func0+0x33>
jmp 117d <func0+0x3d>
nopw %cs:0x0(%rax,%rax,1)
cltd
idiv %ecx
mov %ecx,%eax
cmp %edx,%ecx
cmovg %edx,%ecx
cmp %eax,%edx
cmovge %edx,%eax
test %ecx,%ecx
je 1180 <func0+0x40>
cmp $0x1,%ecx
jne 1160 <func0+0x20>
mov $0x1,%eax
retq
xchg %ax,%ax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, esi
mov ecx, esi
mov eax, esi
cmovle ecx, edi
cmovge eax, edi
test ecx, ecx
jnz short loc_1173
jmp short locret_117D
loc_1160:
cdq
idiv ecx
mov eax, ecx
cmp ecx, edx
cmovg ecx, edx
cmp edx, eax
cmovge eax, edx
test ecx, ecx
jz short locret_1180
loc_1173:
cmp ecx, 1
jnz short loc_1160
mov eax, 1
locret_117D:
retn
locret_1180:
retn | long long func0(int a1, int a2)
{
int v2; // ecx
long long result; // rax
int v4; // edx
v2 = a2;
result = (unsigned int)a2;
if ( a1 <= a2 )
v2 = a1;
if ( a1 >= a2 )
result = (unsigned int)a1;
if ( v2 )
{
while ( v2 != 1 )
{
v4 = (int)result % v2;
result = (unsigned int)v2;
if ( v2 > v4 )
v2 = v4;
if ( v4 >= (int)result )
result = (unsigned int)v4;
if ( !v2 )
return result;
}
return 1LL;
}
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV ECX,ESI
MOV EAX,ESI
CMOVLE ECX,EDI
CMOVGE EAX,EDI
TEST ECX,ECX
JNZ 0x00101173
JMP 0x0010117d
LAB_00101160:
CDQ
IDIV ECX
MOV EAX,ECX
CMP ECX,EDX
CMOVG ECX,EDX
CMP EDX,EAX
CMOVGE EAX,EDX
TEST ECX,ECX
JZ 0x00101180
LAB_00101173:
CMP ECX,0x1
JNZ 0x00101160
MOV EAX,0x1
LAB_0010117d:
RET
LAB_00101180:
RET | ulong func0(uint param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
ulong uVar5;
uVar5 = (ulong)param_2;
if ((int)param_1 <= (int)param_2) {
uVar5 = (ulong)param_1;
}
uVar3 = (ulong)param_2;
if ((int)param_2 <= (int)param_1) {
uVar3 = (ulong)param_1;
}
if ((int)uVar5 != 0) {
while (iVar4 = (int)uVar5, iVar4 != 1) {
uVar1 = (long)(int)uVar3 % (long)iVar4;
uVar3 = uVar5;
uVar2 = uVar1 & 0xffffffff;
if (iVar4 <= (int)uVar1) {
uVar3 = uVar1 & 0xffffffff;
uVar2 = uVar5;
}
uVar5 = uVar2;
if ((int)uVar5 == 0) {
return uVar3;
}
}
uVar3 = 1;
}
return uVar3;
} |
6,643 | func0 |
#include <assert.h>
| int func0(int a, int b) {
int low = a < b ? a : b;
int high = a > b ? a : b;
if (low == 0) {
return high;
} else if (low == 1) {
return 1;
} else {
return func0(low, high % low);
}
}
| int main() {
assert(func0(12, 14) == 2);
assert(func0(13, 17) == 1);
assert(func0(9, 3) == 3);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%ecx
mov %esi,%eax
cmovle %edi,%ecx
cmovge %edi,%eax
test %ecx,%ecx
jne 1173 <func0+0x33>
jmp 117d <func0+0x3d>
nopw %cs:0x0(%rax,%rax,1)
cltd
idiv %ecx
mov %ecx,%eax
cmp %edx,%ecx
cmovg %edx,%ecx
cmp %eax,%edx
cmovge %edx,%eax
test %ecx,%ecx
je 1180 <func0+0x40>
cmp $0x1,%ecx
jne 1160 <func0+0x20>
mov $0x1,%eax
retq
xchg %ax,%ax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, esi
mov ecx, esi
mov eax, esi
cmovle ecx, edi
cmovge eax, edi
test ecx, ecx
jnz short loc_122B
retn
loc_1218:
cdq
idiv ecx
mov eax, ecx
cmp ecx, edx
cmovg ecx, edx
cmp edx, eax
cmovge eax, edx
test ecx, ecx
jz short locret_1240
loc_122B:
cmp ecx, 1
jnz short loc_1218
mov eax, 1
retn
locret_1240:
retn | long long func0(int a1, int a2)
{
int v2; // ecx
long long result; // rax
int v4; // edx
v2 = a2;
result = (unsigned int)a2;
if ( a1 <= a2 )
v2 = a1;
if ( a1 >= a2 )
result = (unsigned int)a1;
if ( v2 )
{
while ( v2 != 1 )
{
v4 = (int)result % v2;
result = (unsigned int)v2;
if ( v2 > v4 )
v2 = v4;
if ( v4 >= (int)result )
result = (unsigned int)v4;
if ( !v2 )
return result;
}
return 1LL;
}
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV ECX,ESI
MOV EAX,ESI
CMOVLE ECX,EDI
CMOVGE EAX,EDI
TEST ECX,ECX
JNZ 0x0010122b
RET
LAB_00101218:
CDQ
IDIV ECX
MOV EAX,ECX
CMP ECX,EDX
CMOVG ECX,EDX
CMP EDX,EAX
CMOVGE EAX,EDX
TEST ECX,ECX
JZ 0x00101240
LAB_0010122b:
CMP ECX,0x1
JNZ 0x00101218
MOV EAX,0x1
RET
LAB_00101240:
RET | ulong func0(uint param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
ulong uVar5;
uVar5 = (ulong)param_2;
if ((int)param_1 <= (int)param_2) {
uVar5 = (ulong)param_1;
}
uVar3 = (ulong)param_2;
if ((int)param_2 <= (int)param_1) {
uVar3 = (ulong)param_1;
}
if ((int)uVar5 == 0) {
return uVar3;
}
do {
iVar4 = (int)uVar5;
if (iVar4 == 1) {
return 1;
}
uVar1 = (long)(int)uVar3 % (long)iVar4;
uVar3 = uVar5;
uVar2 = uVar1 & 0xffffffff;
if (iVar4 <= (int)uVar1) {
uVar3 = uVar1 & 0xffffffff;
uVar2 = uVar5;
}
uVar5 = uVar2;
} while ((int)uVar5 != 0);
return uVar3;
} |
6,644 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| double func0(double a, double b) {
return sqrt(a*a + b*b);
}
| int main() {
assert(func0(3, 4) == 5.0);
assert(fabs(func0(9, 10) - 13.45362404707371) < 0.000001);
assert(fabs(func0(7, 9) - 11.40175425099138) < 0.000001);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
movsd %xmm0,-0x8(%rbp)
movsd %xmm1,-0x10(%rbp)
movsd -0x8(%rbp),%xmm0
movapd %xmm0,%xmm1
mulsd %xmm0,%xmm1
movsd -0x10(%rbp),%xmm0
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
callq 1070 <sqrt@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
movsd [rbp+var_8], xmm0
movsd [rbp+var_10], xmm1
movsd xmm0, [rbp+var_8]
movapd xmm1, xmm0
mulsd xmm1, xmm0
movsd xmm0, [rbp+var_10]
mulsd xmm0, xmm0
addsd xmm1, xmm0
movq rax, xmm1
movq xmm0, rax; x
call _sqrt
leave
retn | double func0(double a1, double a2)
{
return sqrt(a1 * a1 + a2 * a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD qword ptr [RBP + -0x10],XMM1
MOVSD XMM0,qword ptr [RBP + -0x8]
MOVAPD XMM1,XMM0
MULSD XMM1,XMM0
MOVSD XMM0,qword ptr [RBP + -0x10]
MULSD XMM0,XMM0
ADDSD XMM1,XMM0
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101070
LEAVE
RET | void func0(double param_1,double param_2)
{
sqrt(param_1 * param_1 + param_2 * param_2);
return;
} |
6,645 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| double func0(double a, double b) {
return sqrt(a*a + b*b);
}
| int main() {
assert(func0(3, 4) == 5.0);
assert(fabs(func0(9, 10) - 13.45362404707371) < 0.000001);
assert(fabs(func0(7, 9) - 11.40175425099138) < 0.000001);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x18,%rsp
mulsd %xmm0,%xmm0
mulsd %xmm1,%xmm1
addsd %xmm1,%xmm0
movapd %xmm0,%xmm2
sqrtsd %xmm2,%xmm2
movsd %xmm2,0x8(%rsp)
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
ja 1180 <func0+0x37>
movsd 0x8(%rsp),%xmm0
add $0x18,%rsp
retq
callq 1050 <sqrt@plt>
jmp 1175 <func0+0x2c>
| func0:
endbr64
mulsd xmm0, xmm0
mulsd xmm1, xmm1
addsd xmm0, xmm1
pxor xmm1, xmm1
ucomisd xmm1, xmm0
ja short loc_1168
sqrtsd xmm0, xmm0
retn
loc_1168:
sub rsp, 8
call _sqrt
add rsp, 8
retn | double func0(double a1, double a2)
{
double v2; // xmm0_8
v2 = a1 * a1 + a2 * a2;
if ( v2 < 0.0 )
return sqrt(v2);
else
return sqrt(v2);
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM1,XMM1
ADDSD XMM0,XMM1
PXOR XMM1,XMM1
UCOMISD XMM1,XMM0
JA 0x00101168
SQRTSD XMM0,XMM0
RET
LAB_00101168:
SUB RSP,0x8
CALL 0x00101050
ADD RSP,0x8
RET | double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = param_1 * param_1 + param_2 * param_2;
if (0.0 <= dVar1) {
return SQRT(dVar1);
}
dVar1 = sqrt(dVar1);
return dVar1;
} |
6,646 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| double func0(double a, double b) {
return sqrt(a*a + b*b);
}
| int main() {
assert(func0(3, 4) == 5.0);
assert(fabs(func0(9, 10) - 13.45362404707371) < 0.000001);
assert(fabs(func0(7, 9) - 11.40175425099138) < 0.000001);
return 0;
}
| O2 | c | func0:
endbr64
mulsd %xmm1,%xmm1
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm2
sqrtsd %xmm2,%xmm2
ja 1187 <func0+0x27>
movapd %xmm2,%xmm0
retq
sub $0x18,%rsp
movsd %xmm2,0x8(%rsp)
callq 1050 <sqrt@plt>
movsd 0x8(%rsp),%xmm2
add $0x18,%rsp
movapd %xmm2,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mulsd xmm1, xmm1
mulsd xmm0, xmm0
addsd xmm0, xmm1
pxor xmm1, xmm1
ucomisd xmm1, xmm0
ja short loc_117F
sqrtsd xmm0, xmm0
retn
loc_117F:
jmp _sqrt | double func0(double a1, double a2)
{
double v2; // xmm0_8
v2 = a1 * a1 + a2 * a2;
if ( v2 < 0.0 )
return sqrt(v2);
else
return sqrt(v2);
} | func0:
ENDBR64
MULSD XMM1,XMM1
MULSD XMM0,XMM0
ADDSD XMM0,XMM1
PXOR XMM1,XMM1
UCOMISD XMM1,XMM0
JA 0x0010117f
SQRTSD XMM0,XMM0
RET
LAB_0010117f:
JMP 0x00101050 | double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = param_1 * param_1 + param_2 * param_2;
if (0.0 <= dVar1) {
return SQRT(dVar1);
}
dVar1 = sqrt(dVar1);
return dVar1;
} |
6,647 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| double func0(double a, double b) {
return sqrt(a*a + b*b);
}
| int main() {
assert(func0(3, 4) == 5.0);
assert(fabs(func0(9, 10) - 13.45362404707371) < 0.000001);
assert(fabs(func0(7, 9) - 11.40175425099138) < 0.000001);
return 0;
}
| O3 | c | func0:
endbr64
mulsd %xmm1,%xmm1
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm2
sqrtsd %xmm2,%xmm2
ja 1187 <func0+0x27>
movapd %xmm2,%xmm0
retq
sub $0x18,%rsp
movsd %xmm2,0x8(%rsp)
callq 1050 <sqrt@plt>
movsd 0x8(%rsp),%xmm2
add $0x18,%rsp
movapd %xmm2,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mulsd xmm1, xmm1
mulsd xmm0, xmm0
addsd xmm0, xmm1
sqrtsd xmm0, xmm0
retn | double func0(double a1, double a2)
{
return sqrt(a1 * a1 + a2 * a2);
} | func0:
ENDBR64
MULSD XMM1,XMM1
MULSD XMM0,XMM0
ADDSD XMM0,XMM1
SQRTSD XMM0,XMM0
RET | double func0(double param_1,double param_2)
{
return SQRT(param_1 * param_1 + param_2 * param_2);
} |
6,648 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int arr[], int n) {
int jumps[n];
if (n == 0 || arr[0] == 0) {
return INT_MAX;
}
jumps[0] = 0;
for (int i = 1; i < n; i++) {
jumps[i] = INT_MAX;
for (int j = 0; j < i; j++) {
if (i <= j + arr[j] && jumps[j] != INT_MAX) {
jumps[i] = (jumps[i] < jumps[j] + 1) ? jumps[i] : jumps[j] + 1;
break;
}
}
}
return jumps[n-1];
}
| int main() {
int arr1[] = {1, 3, 6, 1, 0, 9};
int arr2[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9};
int arr3[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
assert(func0(arr1, 6) == 3);
assert(func0(arr2, 11) == 3);
assert(func0(arr3, 11) == 10);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%edi
mov $0x0,%edx
div %rdi
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 1208 <func0+0x9f>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11f1 <func0+0x88>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1232 <func0+0xc9>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x20(%rbp)
cmpl $0x0,-0x3c(%rbp)
je 1255 <func0+0xec>
mov -0x38(%rbp),%rax
mov (%rax),%eax
test %eax,%eax
jne 125f <func0+0xf6>
mov $0x7fffffff,%eax
jmpq 1342 <func0+0x1d9>
mov -0x20(%rbp),%rax
movl $0x0,(%rax)
movl $0x1,-0x2c(%rbp)
jmpq 1326 <func0+0x1bd>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
movl $0x7fffffff,(%rax,%rdx,4)
movl $0x0,-0x30(%rbp)
jmpq 1316 <func0+0x1ad>
mov -0x30(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x30(%rbp),%eax
add %edx,%eax
cmp %eax,-0x2c(%rbp)
jg 1312 <func0+0x1a9>
mov -0x20(%rbp),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp $0x7fffffff,%eax
je 1312 <func0+0x1a9>
mov -0x20(%rbp),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,%ecx
jl 12f3 <func0+0x18a>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
jmp 1303 <func0+0x19a>
mov -0x20(%rbp),%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add $0x1,%eax
mov -0x20(%rbp),%rdx
mov -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov %eax,(%rdx,%rcx,4)
jmp 1322 <func0+0x1b9>
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1292 <func0+0x129>
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 1275 <func0+0x10c>
mov -0x3c(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %rsi,%rsp
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
je 1359 <func0+0x1f0>
callq 1060 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_2C]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11D6:
cmp rsp, rdx
jz short loc_11ED
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_11D6
loc_11ED:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1217
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1217:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
cmp [rbp+var_2C], 0
jz short loc_123A
mov rax, [rbp+var_28]
mov eax, [rax]
test eax, eax
jnz short loc_1244
loc_123A:
mov eax, 7FFFFFFFh
jmp loc_1327
loc_1244:
mov rax, [rbp+var_10]
mov dword ptr [rax], 0
mov [rbp+var_20], 1
jmp loc_130B
loc_125A:
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov dword ptr [rax+rdx*4], 7FFFFFFFh
mov [rbp+var_1C], 0
jmp loc_12FB
loc_1277:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_1C]
add eax, edx
cmp [rbp+var_20], eax
jg short loc_12F7
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp eax, 7FFFFFFFh
jz short loc_12F7
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp ecx, eax
jl short loc_12D8
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov eax, [rax+rdx*4]
jmp short loc_12E8
loc_12D8:
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add eax, 1
loc_12E8:
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_20]
movsxd rcx, ecx
mov [rdx+rcx*4], eax
jmp short loc_1307
loc_12F7:
add [rbp+var_1C], 1
loc_12FB:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_20]
jl loc_1277
loc_1307:
add [rbp+var_20], 1
loc_130B:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_2C]
jl loc_125A
mov eax, [rbp+var_2C]
lea edx, [rax-1]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
loc_1327:
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_133E
call ___stack_chk_fail
locret_133E:
leave
retn | long long func0(_DWORD *a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
int v5; // eax
_BYTE v6[4]; // [rsp+8h] [rbp-30h] BYREF
int v7; // [rsp+Ch] [rbp-2Ch]
_DWORD *v8; // [rsp+10h] [rbp-28h]
int i; // [rsp+18h] [rbp-20h]
int j; // [rsp+1Ch] [rbp-1Ch]
long long v11; // [rsp+20h] [rbp-18h]
_DWORD *v12; // [rsp+28h] [rbp-10h]
unsigned long long v13; // [rsp+30h] [rbp-8h]
v8 = a1;
v7 = a2;
v13 = __readfsqword(0x28u);
v11 = a2 - 1LL;
v2 = 16 * ((4LL * a2 + 15) / 0x10uLL);
while ( v6 != &v6[-(v2 & 0xFFFFFFFFFFFFF000LL)] )
;
v3 = alloca(v2 & 0xFFF);
if ( (v2 & 0xFFF) != 0 )
*(_QWORD *)&v6[(v2 & 0xFFF) - 8] = *(_QWORD *)&v6[(v2 & 0xFFF) - 8];
v12 = v6;
if ( !v7 || !*v8 )
return 0x7FFFFFFFLL;
*v12 = 0;
for ( i = 1; i < v7; ++i )
{
v12[i] = 0x7FFFFFFF;
for ( j = 0; j < i; ++j )
{
if ( i <= v8[j] + j && v12[j] != 0x7FFFFFFF )
{
if ( v12[j] < v12[i] )
v5 = v12[j] + 1;
else
v5 = v12[i];
v12[i] = v5;
break;
}
}
}
return (unsigned int)v12[v7 - 1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011d6:
CMP RSP,RDX
JZ 0x001011ed
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011d6
LAB_001011ed:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101217
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101217:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0010123a
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNZ 0x00101244
LAB_0010123a:
MOV EAX,0x7fffffff
JMP 0x00101327
LAB_00101244:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x20],0x1
JMP 0x0010130b
LAB_0010125a:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],0x7fffffff
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001012fb
LAB_00101277:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EDX
CMP dword ptr [RBP + -0x20],EAX
JG 0x001012f7
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP EAX,0x7fffffff
JZ 0x001012f7
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP ECX,EAX
JL 0x001012d8
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
JMP 0x001012e8
LAB_001012d8:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
ADD EAX,0x1
LAB_001012e8:
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x20]
MOVSXD RCX,ECX
MOV dword ptr [RDX + RCX*0x4],EAX
JMP 0x00101307
LAB_001012f7:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001012fb:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x00101277
LAB_00101307:
ADD dword ptr [RBP + -0x20],0x1
LAB_0010130b:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x0010125a
MOV EAX,dword ptr [RBP + -0x2c]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
LAB_00101327:
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010133e
CALL 0x00101060
LAB_0010133e:
LEAVE
RET | int4 func0(int *param_1,int param_2)
{
long lVar1;
int iVar2;
int4 uVar3;
ulong uVar4;
int *puVar5;
long in_FS_OFFSET;
int auStack_38 [4];
int local_34;
int *local_30;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_30 = param_1;
local_34 = param_2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)param_2 + -1;
uVar4 = (((long)param_2 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar5 = auStack_38; puVar5 != auStack_38 + -(uVar4 & 0xfffffffffffff000);
puVar5 = puVar5 + -0x1000) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
lVar1 = -(ulong)((uint)uVar4 & 0xfff);
if ((uVar4 & 0xfff) != 0) {
*(int8 *)(puVar5 + ((ulong)((uint)uVar4 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar5 + ((ulong)((uint)uVar4 & 0xfff) - 8) + lVar1);
}
if ((local_34 == 0) || (*local_30 == 0)) {
uVar3 = 0x7fffffff;
}
else {
*(int4 *)(puVar5 + lVar1) = 0;
for (local_28 = 1; local_28 < local_34; local_28 = local_28 + 1) {
*(int4 *)(puVar5 + (long)local_28 * 4 + lVar1) = 0x7fffffff;
for (local_24 = 0; local_24 < local_28; local_24 = local_24 + 1) {
if ((local_28 <= local_24 + local_30[local_24]) &&
(*(int *)(puVar5 + (long)local_24 * 4 + lVar1) != 0x7fffffff)) {
if (*(int *)(puVar5 + (long)local_24 * 4 + lVar1) <
*(int *)(puVar5 + (long)local_28 * 4 + lVar1)) {
iVar2 = *(int *)(puVar5 + (long)local_24 * 4 + lVar1) + 1;
}
else {
iVar2 = *(int *)(puVar5 + (long)local_28 * 4 + lVar1);
}
*(int *)(puVar5 + (long)local_28 * 4 + lVar1) = iVar2;
break;
}
}
}
uVar3 = *(int4 *)(puVar5 + (long)(local_34 + -1) * 4 + lVar1);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = puVar5 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
} |
6,649 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int arr[], int n) {
int jumps[n];
if (n == 0 || arr[0] == 0) {
return INT_MAX;
}
jumps[0] = 0;
for (int i = 1; i < n; i++) {
jumps[i] = INT_MAX;
for (int j = 0; j < i; j++) {
if (i <= j + arr[j] && jumps[j] != INT_MAX) {
jumps[i] = (jumps[i] < jumps[j] + 1) ? jumps[i] : jumps[j] + 1;
break;
}
}
}
return jumps[n-1];
}
| int main() {
int arr1[] = {1, 3, 6, 1, 0, 9};
int arr2[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9};
int arr3[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
assert(func0(arr1, 6) == 3);
assert(func0(arr2, 11) == 3);
assert(func0(arr3, 11) == 10);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %esi,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rcx
sub %rax,%rcx
mov %rcx,%rax
cmp %rax,%rsp
je 11bc <func0+0x53>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11a5 <func0+0x3c>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11d2 <func0+0x69>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r11
mov %r11,%rdx
shr $0x2,%rdx
and $0xfffffffffffffffc,%r11
mov %r11,%r9
mov $0x7fffffff,%eax
test %esi,%esi
je 1260 <func0+0xf7>
cmpl $0x0,(%rdi)
je 1260 <func0+0xf7>
movl $0x0,0x0(,%rdx,4)
cmp $0x1,%esi
jle 1257 <func0+0xee>
lea -0x2(%rsi),%r10d
add $0x2,%r10
mov $0x1,%ecx
jmp 1241 <func0+0xd8>
add $0x1,%rax
cmp %rcx,%rax
je 1238 <func0+0xcf>
mov %eax,%edx
add (%rdi,%rax,4),%edx
cmp %r8d,%edx
jl 1212 <func0+0xa9>
mov (%r9,%rax,4),%edx
cmp $0x7fffffff,%edx
je 1212 <func0+0xa9>
add $0x1,%edx
mov %edx,(%r9,%rcx,4)
add $0x1,%rcx
cmp %r10,%rcx
je 1257 <func0+0xee>
movl $0x7fffffff,(%r9,%rcx,4)
mov %ecx,%r8d
test %ecx,%ecx
jle 1238 <func0+0xcf>
mov $0x0,%eax
jmp 121b <func0+0xb2>
lea -0x1(%rsi),%eax
cltq
mov (%r11,%rax,4),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
jne 1271 <func0+0x108>
leaveq
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov r9d, esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, esi
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11A5:
cmp rsp, rdx
jz short loc_11BC
sub rsp, 1000h
or [rsp+1010h+var_18], 0
jmp short loc_11A5
loc_11BC:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11D2
or [rsp+rax+10h+var_18], 0
loc_11D2:
lea r8, [rsp+10h+var_D]
mov rdx, r8
shr rdx, 2
and r8, 0FFFFFFFFFFFFFFFCh
mov eax, 7FFFFFFFh
test r9d, r9d
jz short loc_1259
cmp dword ptr [rdi], 0
jz short loc_1259
mov ds:dword_0[rdx*4], 0
cmp r9d, 1
jle short loc_124F
mov r10d, r9d
mov ecx, 1
jmp short loc_123A
loc_120C:
add rax, 1
cmp rax, rcx
jz short loc_1231
loc_1215:
mov edx, eax
add edx, [rdi+rax*4]
cmp edx, esi
jl short loc_120C
mov edx, [r8+rax*4]
cmp edx, 7FFFFFFFh
jz short loc_120C
add edx, 1
mov [r8+rcx*4], edx
loc_1231:
add rcx, 1
cmp rcx, r10
jz short loc_124F
loc_123A:
mov dword ptr [r8+rcx*4], 7FFFFFFFh
mov esi, ecx
test ecx, ecx
jle short loc_1231
mov eax, 0
jmp short loc_1215
loc_124F:
lea eax, [r9-1]
cdqe
mov eax, [r8+rax*4]
loc_1259:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_126A
leave
retn
loc_126A:
call ___stack_chk_fail | long long func0(_DWORD *a1, int a2)
{
signed long long v2; // rax
void *v3; // rsp
long long result; // rax
long long i; // rcx
long long v6; // rax
int v7; // edx
_DWORD v9[2]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v10; // [rsp+10h] [rbp-8h]
v10 = __readfsqword(0x28u);
while ( v9 != (_DWORD *)((char *)v9 - ((4LL * a2 + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v2 = (4 * (_WORD)a2 + 15) & 0xFF0;
v3 = alloca(v2);
if ( ((4 * (_WORD)a2 + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v9[-2] + v2) = *(_QWORD *)((char *)&v9[-2] + v2);
result = 0x7FFFFFFFLL;
if ( a2 && *a1 )
{
v9[0] = 0;
if ( a2 > 1 )
{
for ( i = 1LL; i != a2; ++i )
{
v9[i] = 0x7FFFFFFF;
if ( (int)i > 0 )
{
v6 = 0LL;
while ( 1 )
{
if ( a1[v6] + (int)v6 >= (int)i )
{
v7 = v9[v6];
if ( v7 != 0x7FFFFFFF )
break;
}
if ( ++v6 == i )
goto LABEL_13;
}
v9[i] = v7 + 1;
}
LABEL_13:
;
}
}
return (unsigned int)v9[a2 - 1];
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV R9D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011a5:
CMP RSP,RDX
JZ 0x001011bc
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011a5
LAB_001011bc:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011d2
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011d2:
LEA R8,[RSP + 0x3]
MOV RDX,R8
SHR RDX,0x2
AND R8,-0x4
MOV EAX,0x7fffffff
TEST R9D,R9D
JZ 0x00101259
CMP dword ptr [RDI],0x0
JZ 0x00101259
MOV dword ptr [RDX*0x4],0x0
CMP R9D,0x1
JLE 0x0010124f
MOV R10D,R9D
MOV ECX,0x1
JMP 0x0010123a
LAB_0010120c:
ADD RAX,0x1
CMP RAX,RCX
JZ 0x00101231
LAB_00101215:
MOV EDX,EAX
ADD EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,ESI
JL 0x0010120c
MOV EDX,dword ptr [R8 + RAX*0x4]
CMP EDX,0x7fffffff
JZ 0x0010120c
ADD EDX,0x1
MOV dword ptr [R8 + RCX*0x4],EDX
LAB_00101231:
ADD RCX,0x1
CMP RCX,R10
JZ 0x0010124f
LAB_0010123a:
MOV dword ptr [R8 + RCX*0x4],0x7fffffff
MOV ESI,ECX
TEST ECX,ECX
JLE 0x00101231
MOV EAX,0x0
JMP 0x00101215
LAB_0010124f:
LEA EAX,[R9 + -0x1]
CDQE
MOV EAX,dword ptr [R8 + RAX*0x4]
LAB_00101259:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010126a
LEAVE
RET
LAB_0010126a:
CALL 0x00101060 | int4 func0(int *param_1,uint param_2)
{
long lVar1;
int4 uVar2;
ulong uVar3;
ulong uVar4;
int1 *puVar5;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)(int)param_2 * 4 + 0xf;
for (puVar5 = auStack_18; puVar5 != auStack_18 + -(uVar4 & 0xfffffffffffff000);
puVar5 = puVar5 + -0x1000) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar1 = -uVar4;
if (uVar4 != 0) {
*(int8 *)(puVar5 + -8) = *(int8 *)(puVar5 + -8);
}
uVar2 = 0x7fffffff;
if ((param_2 != 0) && (*param_1 != 0)) {
*(int4 *)(puVar5 + lVar1) = 0;
if (1 < (int)param_2) {
uVar4 = 1;
do {
*(int4 *)(puVar5 + uVar4 * 4 + lVar1) = 0x7fffffff;
if (0 < (int)uVar4) {
uVar3 = 0;
do {
if (((int)uVar4 <= (int)uVar3 + param_1[uVar3]) &&
(*(int *)(puVar5 + uVar3 * 4 + lVar1) != 0x7fffffff)) {
*(int *)(puVar5 + uVar4 * 4 + lVar1) = *(int *)(puVar5 + uVar3 * 4 + lVar1) + 1;
break;
}
uVar3 = uVar3 + 1;
} while (uVar3 != uVar4);
}
uVar4 = uVar4 + 1;
} while (uVar4 != param_2);
}
uVar2 = *(int4 *)(puVar5 + (long)(int)(param_2 - 1) * 4 + lVar1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
*(code **)(puVar5 + lVar1 + -8) = main;
__stack_chk_fail();
} |
6,650 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int arr[], int n) {
int jumps[n];
if (n == 0 || arr[0] == 0) {
return INT_MAX;
}
jumps[0] = 0;
for (int i = 1; i < n; i++) {
jumps[i] = INT_MAX;
for (int j = 0; j < i; j++) {
if (i <= j + arr[j] && jumps[j] != INT_MAX) {
jumps[i] = (jumps[i] < jumps[j] + 1) ? jumps[i] : jumps[j] + 1;
break;
}
}
}
return jumps[n-1];
}
| int main() {
int arr1[] = {1, 3, 6, 1, 0, 9};
int arr2[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9};
int arr3[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
assert(func0(arr1, 6) == 3);
assert(func0(arr2, 11) == 3);
assert(func0(arr3, 11) == 10);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rcx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je 1346 <func0+0x56>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1331 <func0+0x41>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 140a <func0+0x11a>
lea 0x3(%rsp),%r8
mov $0x7fffffff,%eax
mov %r8,%rdx
and $0xfffffffffffffffc,%r8
shr $0x2,%rdx
test %esi,%esi
je 13e0 <func0+0xf0>
mov (%rdi),%r10d
test %r10d,%r10d
je 13e0 <func0+0xf0>
movl $0x0,0x0(,%rdx,4)
cmp $0x1,%esi
jle 13d7 <func0+0xe7>
lea -0x2(%rsi),%r9d
mov $0x1,%ecx
add $0x2,%r9
nopw %cs:0x0(%rax,%rax,1)
movl $0x7fffffff,(%r8,%rcx,4)
mov %r10d,%edx
xor %eax,%eax
jmp 13b3 <func0+0xc3>
mov (%rdi,%rax,4),%edx
add %eax,%edx
cmp %ecx,%edx
jl 13c5 <func0+0xd5>
mov (%r8,%rax,4),%edx
cmp $0x7fffffff,%edx
jne 13f8 <func0+0x108>
add $0x1,%rax
cmp %rax,%rcx
jne 13b0 <func0+0xc0>
add $0x1,%rcx
cmp %r9,%rcx
jne 13a0 <func0+0xb0>
lea -0x1(%rsi),%eax
cltq
mov (%r8,%rax,4),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
jne 1415 <func0+0x125>
leaveq
retq
nopl 0x0(%rax)
add $0x1,%edx
mov %edx,(%r8,%rcx,4)
add $0x1,%rcx
cmp %r9,%rcx
jne 13a0 <func0+0xb0>
jmp 13d7 <func0+0xe7>
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1358 <func0+0x68>
callq 1060 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
movsxd r10, esi
mov r8, r10
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, ds:0Fh[r10*4]
mov rcx, rsp
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1346
loc_1331:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rcx
jnz short loc_1331
loc_1346:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_13F1
loc_1358:
lea rsi, [rsp+1010h+var_100D]
mov eax, 7FFFFFFFh
mov rdx, rsi
and rsi, 0FFFFFFFFFFFFFFFCh
shr rdx, 2
test r8d, r8d
jz short loc_13CF
mov r9d, [rdi]
test r9d, r9d
jz short loc_13CF
mov ds:dword_0[rdx*4], 0
mov ecx, 1
cmp r8d, 1
jle short loc_13C6
loc_1390:
mov dword ptr [rsi+rcx*4], 7FFFFFFFh
mov edx, r9d
xor eax, eax
jmp short loc_13A3
loc_13A0:
mov edx, [rdi+rax*4]
loc_13A3:
add edx, eax
cmp edx, ecx
jl short loc_13B4
mov edx, [rsi+rax*4]
cmp edx, 7FFFFFFFh
jnz short loc_13E0
loc_13B4:
add rax, 1
cmp rcx, rax
jnz short loc_13A0
add rcx, 1
cmp rcx, r10
jnz short loc_1390
loc_13C6:
lea eax, [r8-1]
cdqe
mov eax, [rsi+rax*4]
loc_13CF:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_13FC
leave
retn
loc_13E0:
add edx, 1
mov [rsi+rcx*4], edx
add rcx, 1
cmp rcx, r10
jnz short loc_1390
jmp short loc_13C6
loc_13F1:
or [rsp+rdx+1010h+var_1018], 0
jmp loc_1358
loc_13FC:
call ___stack_chk_fail | long long func0(int *a1, int a2)
{
long long v2; // rdx
_DWORD *v3; // rcx
__int16 v4; // dx
signed long long v5; // rdx
void *v6; // rsp
long long result; // rax
int v8; // r9d
long long v9; // rcx
int v10; // edx
long long i; // rax
int v12; // edx
_DWORD v14[1022]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v15[2]; // [rsp+1008h] [rbp-10h] BYREF
v15[1] = __readfsqword(0x28u);
v2 = 4LL * a2 + 15;
v3 = (_DWORD *)((char *)v15 - (v2 & 0xFFFFFFFFFFFFF000LL));
v4 = v2 & 0xFFF0;
if ( v15 != (_QWORD *)v3 )
{
while ( v14 != v3 )
;
}
v5 = v4 & 0xFFF;
v6 = alloca(v5);
if ( v5 )
*(_QWORD *)((char *)&v14[-2] + v5) = *(_QWORD *)((char *)&v14[-2] + v5);
result = 0x7FFFFFFFLL;
if ( a2 )
{
v8 = *a1;
if ( *a1 )
{
v14[0] = 0;
v9 = 1LL;
if ( a2 > 1 )
{
LABEL_8:
while ( 2 )
{
v14[v9] = 0x7FFFFFFF;
v10 = v8;
for ( i = 0LL; ; v10 = a1[i] )
{
if ( (int)i + v10 >= (int)v9 )
{
v12 = v14[i];
if ( v12 != 0x7FFFFFFF )
break;
}
if ( v9 == ++i )
{
if ( ++v9 != a2 )
goto LABEL_8;
return (unsigned int)v14[a2 - 1];
}
}
v14[v9++] = v12 + 1;
if ( v9 != a2 )
continue;
break;
}
}
return (unsigned int)v14[a2 - 1];
}
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOVSXD R10,ESI
MOV R8,R10
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0xf + R10*0x4]
MOV RCX,RSP
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101346
LAB_00101331:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101331
LAB_00101346:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001013f1
LAB_00101358:
LEA RSI,[RSP + 0x3]
MOV EAX,0x7fffffff
MOV RDX,RSI
AND RSI,-0x4
SHR RDX,0x2
TEST R8D,R8D
JZ 0x001013cf
MOV R9D,dword ptr [RDI]
TEST R9D,R9D
JZ 0x001013cf
MOV dword ptr [RDX*0x4],0x0
MOV ECX,0x1
CMP R8D,0x1
JLE 0x001013c6
LAB_00101390:
MOV dword ptr [RSI + RCX*0x4],0x7fffffff
MOV EDX,R9D
XOR EAX,EAX
JMP 0x001013a3
LAB_001013a0:
MOV EDX,dword ptr [RDI + RAX*0x4]
LAB_001013a3:
ADD EDX,EAX
CMP EDX,ECX
JL 0x001013b4
MOV EDX,dword ptr [RSI + RAX*0x4]
CMP EDX,0x7fffffff
JNZ 0x001013e0
LAB_001013b4:
ADD RAX,0x1
CMP RCX,RAX
JNZ 0x001013a0
ADD RCX,0x1
CMP RCX,R10
JNZ 0x00101390
LAB_001013c6:
LEA EAX,[R8 + -0x1]
CDQE
MOV EAX,dword ptr [RSI + RAX*0x4]
LAB_001013cf:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013fc
LEAVE
RET
LAB_001013e0:
ADD EDX,0x1
MOV dword ptr [RSI + RCX*0x4],EDX
ADD RCX,0x1
CMP RCX,R10
JNZ 0x00101390
JMP 0x001013c6
LAB_001013f1:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101358
LAB_001013fc:
CALL 0x00101060 | int4 func0(int *param_1,int param_2)
{
int iVar1;
long lVar2;
int1 *puVar3;
int4 uVar4;
long lVar5;
long lVar6;
int iVar7;
ulong uVar8;
int1 *puVar9;
long lVar11;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar10;
lVar11 = (long)param_2;
puVar9 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar8 = lVar11 * 4 + 0xf;
puVar10 = auStack_18;
puVar3 = auStack_18;
while (puVar10 != auStack_18 + -(uVar8 & 0xfffffffffffff000)) {
puVar9 = puVar3 + -0x1000;
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
puVar10 = puVar3 + -0x1000;
puVar3 = puVar3 + -0x1000;
}
uVar8 = (ulong)((uint)uVar8 & 0xff0);
lVar2 = -uVar8;
if (uVar8 != 0) {
*(int8 *)(puVar9 + -8) = *(int8 *)(puVar9 + -8);
}
uVar4 = 0x7fffffff;
if ((param_2 != 0) && (iVar1 = *param_1, iVar1 != 0)) {
*(int4 *)(puVar9 + lVar2) = 0;
lVar6 = 1;
if (1 < param_2) {
LAB_00101390:
do {
*(int4 *)(puVar9 + lVar6 * 4 + lVar2) = 0x7fffffff;
lVar5 = 0;
iVar7 = iVar1;
while( true ) {
if (((int)lVar6 <= iVar7 + (int)lVar5) &&
(*(int *)(puVar9 + lVar5 * 4 + lVar2) != 0x7fffffff)) {
*(int *)(puVar9 + lVar6 * 4 + lVar2) = *(int *)(puVar9 + lVar5 * 4 + lVar2) + 1;
lVar6 = lVar6 + 1;
if (lVar6 == lVar11) goto LAB_001013c6;
goto LAB_00101390;
}
lVar5 = lVar5 + 1;
if (lVar6 == lVar5) break;
iVar7 = param_1[lVar5];
}
lVar6 = lVar6 + 1;
} while (lVar6 != lVar11);
}
LAB_001013c6:
uVar4 = *(int4 *)(puVar9 + (long)(param_2 + -1) * 4 + lVar2);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar4;
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar9 + lVar2 + -8) = 0x101401;
__stack_chk_fail();
} |
6,651 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int arr[], int n) {
int jumps[n];
if (n == 0 || arr[0] == 0) {
return INT_MAX;
}
jumps[0] = 0;
for (int i = 1; i < n; i++) {
jumps[i] = INT_MAX;
for (int j = 0; j < i; j++) {
if (i <= j + arr[j] && jumps[j] != INT_MAX) {
jumps[i] = (jumps[i] < jumps[j] + 1) ? jumps[i] : jumps[j] + 1;
break;
}
}
}
return jumps[n-1];
}
| int main() {
int arr1[] = {1, 3, 6, 1, 0, 9};
int arr2[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9};
int arr3[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
assert(func0(arr1, 6) == 3);
assert(func0(arr2, 11) == 3);
assert(func0(arr3, 11) == 10);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %esi,%rax
mov %rsp,%rcx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je 1316 <func0+0x56>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1301 <func0+0x41>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 13d2 <func0+0x112>
lea 0x3(%rsp),%r8
mov $0x7fffffff,%eax
mov %r8,%rdx
and $0xfffffffffffffffc,%r8
shr $0x2,%rdx
test %esi,%esi
je 13a8 <func0+0xe8>
mov (%rdi),%ecx
test %ecx,%ecx
je 13a8 <func0+0xe8>
movl $0x0,0x0(,%rdx,4)
cmp $0x1,%esi
jle 139f <func0+0xdf>
lea -0x2(%rsi),%r9d
mov $0x1,%edx
add $0x2,%r9
nopl 0x0(%rax)
movl $0x7fffffff,(%r8,%rdx,4)
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%ecx
add %eax,%ecx
cmp %edx,%ecx
jl 138d <func0+0xcd>
mov (%r8,%rax,4),%ecx
cmp $0x7fffffff,%ecx
jne 13c0 <func0+0x100>
add $0x1,%rax
cmp %rdx,%rax
jne 1378 <func0+0xb8>
add $0x1,%rdx
cmp %r9,%rdx
jne 1368 <func0+0xa8>
lea -0x1(%rsi),%eax
cltq
mov (%r8,%rax,4),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
jne 13dd <func0+0x11d>
leaveq
retq
nopl 0x0(%rax)
add $0x1,%ecx
mov %ecx,(%r8,%rdx,4)
add $0x1,%rdx
cmp %r9,%rdx
jne 1368 <func0+0xa8>
jmp 139f <func0+0xdf>
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 1328 <func0+0x68>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push rbp
mov r8d, esi
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, esi
mov rcx, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_1316
loc_1301:
sub rsp, 1000h
or [rsp+1010h+var_18], 0
cmp rsp, rcx
jnz short loc_1301
loc_1316:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_13D1
loc_1328:
lea rsi, [rsp+1010h+var_100D]
mov eax, 7FFFFFFFh
mov rdx, rsi
and rsi, 0FFFFFFFFFFFFFFFCh
shr rdx, 2
test r8d, r8d
jz short loc_13A7
mov ecx, [rdi]
test ecx, ecx
jz short loc_13A7
mov ds:dword_0[rdx*4], 0
cmp r8d, 1
jle short loc_139E
mov r9d, r8d
mov edx, 1
nop dword ptr [rax+00000000h]
loc_1368:
mov dword ptr [rsi+rdx*4], 7FFFFFFFh
xor eax, eax
nop dword ptr [rax+00000000h]
loc_1378:
mov ecx, [rdi+rax*4]
add ecx, eax
cmp ecx, edx
jl short loc_138C
mov ecx, [rsi+rax*4]
cmp ecx, 7FFFFFFFh
jnz short loc_13C0
loc_138C:
add rax, 1
cmp rax, rdx
jnz short loc_1378
add rdx, 1
cmp rdx, r9
jnz short loc_1368
loc_139E:
lea eax, [r8-1]
cdqe
mov eax, [rsi+rax*4]
loc_13A7:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jnz short loc_13DC
leave
retn
loc_13C0:
add ecx, 1
mov [rsi+rdx*4], ecx
add rdx, 1
cmp rdx, r9
jnz short loc_1368
jmp short loc_139E
loc_13D1:
or [rsp+rdx+1010h+var_1018], 0
jmp loc_1328
loc_13DC:
call ___stack_chk_fail | long long func0(_DWORD *a1, int a2)
{
long long v2; // rdx
_DWORD *v3; // rcx
__int16 v4; // dx
signed long long v5; // rdx
void *v6; // rsp
long long result; // rax
long long v8; // rdx
long long v9; // rax
int v10; // ecx
_DWORD v12[1022]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v13[2]; // [rsp+1008h] [rbp-10h] BYREF
v13[1] = __readfsqword(0x28u);
v2 = 4LL * a2 + 15;
v3 = (_DWORD *)((char *)v13 - (v2 & 0xFFFFFFFFFFFFF000LL));
v4 = v2 & 0xFFF0;
if ( v13 != (_QWORD *)v3 )
{
while ( v12 != v3 )
;
}
v5 = v4 & 0xFFF;
v6 = alloca(v5);
if ( v5 )
*(_QWORD *)((char *)&v12[-2] + v5) = *(_QWORD *)((char *)&v12[-2] + v5);
result = 0x7FFFFFFFLL;
if ( a2 && *a1 )
{
v12[0] = 0;
if ( a2 > 1 )
{
v8 = 1LL;
LABEL_9:
while ( 2 )
{
v12[v8] = 0x7FFFFFFF;
v9 = 0LL;
while ( 1 )
{
if ( (int)v9 + a1[v9] >= (int)v8 )
{
v10 = v12[v9];
if ( v10 != 0x7FFFFFFF )
break;
}
if ( ++v9 == v8 )
{
if ( ++v8 != a2 )
goto LABEL_9;
return (unsigned int)v12[a2 - 1];
}
}
v12[v8++] = v10 + 1;
if ( v8 != a2 )
continue;
break;
}
}
return (unsigned int)v12[a2 - 1];
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV R8D,ESI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
MOV RCX,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x00101316
LAB_00101301:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x00101301
LAB_00101316:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x001013d1
LAB_00101328:
LEA RSI,[RSP + 0x3]
MOV EAX,0x7fffffff
MOV RDX,RSI
AND RSI,-0x4
SHR RDX,0x2
TEST R8D,R8D
JZ 0x001013a7
MOV ECX,dword ptr [RDI]
TEST ECX,ECX
JZ 0x001013a7
MOV dword ptr [RDX*0x4],0x0
CMP R8D,0x1
JLE 0x0010139e
MOV R9D,R8D
MOV EDX,0x1
NOP dword ptr [RAX]
LAB_00101368:
MOV dword ptr [RSI + RDX*0x4],0x7fffffff
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101378:
MOV ECX,dword ptr [RDI + RAX*0x4]
ADD ECX,EAX
CMP ECX,EDX
JL 0x0010138c
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP ECX,0x7fffffff
JNZ 0x001013c0
LAB_0010138c:
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x00101378
ADD RDX,0x1
CMP RDX,R9
JNZ 0x00101368
LAB_0010139e:
LEA EAX,[R8 + -0x1]
CDQE
MOV EAX,dword ptr [RSI + RAX*0x4]
LAB_001013a7:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013dc
LEAVE
RET
LAB_001013c0:
ADD ECX,0x1
MOV dword ptr [RSI + RDX*0x4],ECX
ADD RDX,0x1
CMP RDX,R9
JNZ 0x00101368
JMP 0x0010139e
LAB_001013d1:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x00101328
LAB_001013dc:
CALL 0x00101060 | int4 func0(int *param_1,uint param_2)
{
long lVar1;
int *puVar2;
int4 uVar3;
ulong uVar4;
ulong uVar5;
int *puVar6;
long in_FS_OFFSET;
int auStack_18 [8];
long local_10;
int *puVar7;
puVar6 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar5 = (long)(int)param_2 * 4 + 0xf;
puVar7 = auStack_18;
puVar2 = auStack_18;
while (puVar7 != auStack_18 + -(uVar5 & 0xfffffffffffff000)) {
puVar6 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar7 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar5 = (ulong)((uint)uVar5 & 0xff0);
lVar1 = -uVar5;
if (uVar5 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar3 = 0x7fffffff;
if ((param_2 != 0) && (*param_1 != 0)) {
*(int4 *)(puVar6 + lVar1) = 0;
if (1 < (int)param_2) {
uVar5 = 1;
LAB_00101368:
do {
*(int4 *)(puVar6 + uVar5 * 4 + lVar1) = 0x7fffffff;
uVar4 = 0;
do {
if (((int)uVar5 <= param_1[uVar4] + (int)uVar4) &&
(*(int *)(puVar6 + uVar4 * 4 + lVar1) != 0x7fffffff)) {
*(int *)(puVar6 + uVar5 * 4 + lVar1) = *(int *)(puVar6 + uVar4 * 4 + lVar1) + 1;
uVar5 = uVar5 + 1;
if (uVar5 == param_2) goto LAB_0010139e;
goto LAB_00101368;
}
uVar4 = uVar4 + 1;
} while (uVar4 != uVar5);
uVar5 = uVar5 + 1;
} while (uVar5 != param_2);
}
LAB_0010139e:
uVar3 = *(int4 *)(puVar6 + (long)(int)(param_2 - 1) * 4 + lVar1);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar3;
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar6 + lVar1 + -8) = 0x1013e1;
__stack_chk_fail();
} |
6,652 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int nums[], int length, int* result_length) {
*result_length = length - 1;
int* result = (int*) malloc((*result_length) * sizeof(int));
for (int i = 0; i < *result_length; i++) {
result[i] = nums[i] * nums[i + 1];
}
return result;
}
| int main() {
int result_length;
int test1[] = {1, 1, 3, 4, 4, 5, 6, 7};
int result1[] = {1, 3, 12, 16, 20, 30, 42};
int* computed_result1 = func0(test1, sizeof(test1) / sizeof(test1[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result1[i] == result1[i]);
}
free(computed_result1);
int test2[] = {4, 5, 8, 9, 6, 10};
int result2[] = {20, 40, 72, 54, 60};
int* computed_result2 = func0(test2, sizeof(test2) / sizeof(test2[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result2[i] == result2[i]);
}
free(computed_result2);
int test3[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int result3[] = {2, 6, 12, 20, 30, 42, 56, 72, 90};
int* computed_result3 = func0(test3, sizeof(test3) / sizeof(test3[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result3[i] == result3[i]);
}
free(computed_result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov -0x1c(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x28(%rbp),%rax
mov %edx,(%rax)
mov -0x28(%rbp),%rax
mov (%rax),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 123b <func0+0x92>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0xc(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rsi
mov -0x8(%rbp),%rdx
add %rsi,%rdx
imul %ecx,%eax
mov %eax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
jl 11ed <func0+0x44>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov eax, [rbp+var_1C]
lea edx, [rax-1]
mov rax, [rbp+var_28]
mov [rax], edx
mov rax, [rbp+var_28]
mov eax, [rax]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_123B
loc_11ED:
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_C]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
mov ecx, [rbp+var_C]
movsxd rcx, ecx
lea rsi, ds:0[rcx*4]
mov rcx, [rbp+var_8]
add rcx, rsi
imul eax, edx
mov [rcx], eax
add [rbp+var_C], 1
loc_123B:
mov rax, [rbp+var_28]
mov eax, [rax]
cmp [rbp+var_C], eax
jl short loc_11ED
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2, int *a3)
{
int i; // [rsp+24h] [rbp-Ch]
_DWORD *v6; // [rsp+28h] [rbp-8h]
*a3 = a2 - 1;
v6 = malloc(4LL * *a3);
for ( i = 0; i < *a3; ++i )
v6[i] = *(_DWORD *)(4LL * i + a1) * *(_DWORD *)(4 * (i + 1LL) + a1);
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010123b
LAB_001011ed:
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 + -0xc]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0xc]
MOVSXD RCX,ECX
LEA RSI,[RCX*0x4]
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,RSI
IMUL EAX,EDX
MOV dword ptr [RCX],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_0010123b:
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0xc],EAX
JL 0x001011ed
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int *param_3)
{
void *pvVar1;
int4 local_14;
*param_3 = param_2 + -1;
pvVar1 = malloc((long)*param_3 << 2);
for (local_14 = 0; local_14 < *param_3; local_14 = local_14 + 1) {
*(int *)((long)pvVar1 + (long)local_14 * 4) =
*(int *)(param_1 + ((long)local_14 + 1) * 4) * *(int *)(param_1 + (long)local_14 * 4);
}
return pvVar1;
} |
6,653 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int nums[], int length, int* result_length) {
*result_length = length - 1;
int* result = (int*) malloc((*result_length) * sizeof(int));
for (int i = 0; i < *result_length; i++) {
result[i] = nums[i] * nums[i + 1];
}
return result;
}
| int main() {
int result_length;
int test1[] = {1, 1, 3, 4, 4, 5, 6, 7};
int result1[] = {1, 3, 12, 16, 20, 30, 42};
int* computed_result1 = func0(test1, sizeof(test1) / sizeof(test1[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result1[i] == result1[i]);
}
free(computed_result1);
int test2[] = {4, 5, 8, 9, 6, 10};
int result2[] = {20, 40, 72, 54, 60};
int* computed_result2 = func0(test2, sizeof(test2) / sizeof(test2[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result2[i] == result2[i]);
}
free(computed_result2);
int test3[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int result3[] = {2, 6, 12, 20, 30, 42, 56, 72, 90};
int* computed_result3 = func0(test3, sizeof(test3) / sizeof(test3[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result3[i] == result3[i]);
}
free(computed_result3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %rdx,%rbp
sub $0x1,%esi
mov %esi,(%rdx)
movslq %esi,%rsi
lea 0x0(,%rsi,4),%rdi
callq 10b0 <malloc@plt>
mov 0x0(%rbp),%edx
test %edx,%edx
jle 11f4 <func0+0x4b>
lea -0x1(%rdx),%esi
mov $0x0,%edx
mov (%rbx,%rdx,4),%ecx
imul 0x4(%rbx,%rdx,4),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rsi,%rcx
jne 11dd <func0+0x34>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov rbp, rdx
sub esi, 1
mov [rdx], esi
movsxd rsi, esi
lea rdi, ds:0[rsi*4]
call _malloc
mov esi, [rbp+0]
test esi, esi
jle short loc_11F0
mov esi, esi
mov edx, 0
loc_11DC:
mov ecx, [rbx+rdx*4]
imul ecx, [rbx+rdx*4+4]
mov [rax+rdx*4], ecx
add rdx, 1
cmp rdx, rsi
jnz short loc_11DC
loc_11F0:
add rsp, 8
pop rbx
pop rbp
retn | long long func0(long long a1, int a2, int *a3)
{
int v4; // esi
long long result; // rax
int v6; // esi
long long v7; // rdx
v4 = a2 - 1;
*a3 = v4;
result = malloc(4LL * v4);
v6 = *a3;
if ( *a3 > 0 )
{
v7 = 0LL;
do
{
*(_DWORD *)(result + 4 * v7) = *(_DWORD *)(a1 + 4 * v7 + 4) * *(_DWORD *)(a1 + 4 * v7);
++v7;
}
while ( v7 != v6 );
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV RBP,RDX
SUB ESI,0x1
MOV dword ptr [RDX],ESI
MOVSXD RSI,ESI
LEA RDI,[RSI*0x4]
CALL 0x001010b0
MOV ESI,dword ptr [RBP]
TEST ESI,ESI
JLE 0x001011f0
MOV ESI,ESI
MOV EDX,0x0
LAB_001011dc:
MOV ECX,dword ptr [RBX + RDX*0x4]
IMUL ECX,dword ptr [RBX + RDX*0x4 + 0x4]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP RDX,RSI
JNZ 0x001011dc
LAB_001011f0:
ADD RSP,0x8
POP RBX
POP RBP
RET | void func0(long param_1,int param_2,uint *param_3)
{
uint uVar1;
void *pvVar2;
ulong uVar3;
*param_3 = param_2 - 1U;
pvVar2 = malloc((long)(int)(param_2 - 1U) * 4);
uVar1 = *param_3;
if (0 < (int)uVar1) {
uVar3 = 0;
do {
*(int *)((long)pvVar2 + uVar3 * 4) =
*(int *)(param_1 + uVar3 * 4) * *(int *)(param_1 + 4 + uVar3 * 4);
uVar3 = uVar3 + 1;
} while (uVar3 != uVar1);
}
return;
} |
6,654 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int nums[], int length, int* result_length) {
*result_length = length - 1;
int* result = (int*) malloc((*result_length) * sizeof(int));
for (int i = 0; i < *result_length; i++) {
result[i] = nums[i] * nums[i + 1];
}
return result;
}
| int main() {
int result_length;
int test1[] = {1, 1, 3, 4, 4, 5, 6, 7};
int result1[] = {1, 3, 12, 16, 20, 30, 42};
int* computed_result1 = func0(test1, sizeof(test1) / sizeof(test1[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result1[i] == result1[i]);
}
free(computed_result1);
int test2[] = {4, 5, 8, 9, 6, 10};
int result2[] = {20, 40, 72, 54, 60};
int* computed_result2 = func0(test2, sizeof(test2) / sizeof(test2[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result2[i] == result2[i]);
}
free(computed_result2);
int test3[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int result3[] = {2, 6, 12, 20, 30, 42, 56, 72, 90};
int* computed_result3 = func0(test3, sizeof(test3) / sizeof(test3[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result3[i] == result3[i]);
}
free(computed_result3);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
sub $0x1,%esi
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
mov %esi,(%rdx)
movslq %esi,%rsi
lea 0x0(,%rsi,4),%rdi
callq 10b0 <malloc@plt>
mov 0x0(%rbp),%edx
test %edx,%edx
jle 14df <func0+0x4f>
lea -0x1(%rdx),%esi
xor %edx,%edx
nopl 0x0(%rax)
mov (%rbx,%rdx,4),%ecx
imul 0x4(%rbx,%rdx,4),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rsi,%rcx
jne 14c8 <func0+0x38>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
sub esi, 1
mov rbp, rdx
push rbx
mov rbx, rdi
sub rsp, 8
mov [rdx], esi
movsxd rsi, esi
lea rdi, ds:0[rsi*4]
call _malloc
movsxd rsi, dword ptr [rbp+0]
test esi, esi
jle short loc_14D4
xor edx, edx
nop
loc_14C0:
mov ecx, [rbx+rdx*4]
imul ecx, [rbx+rdx*4+4]
mov [rax+rdx*4], ecx
add rdx, 1
cmp rsi, rdx
jnz short loc_14C0
loc_14D4:
add rsp, 8
pop rbx
pop rbp
retn | long long func0(long long a1, int a2, int *a3)
{
int v3; // esi
long long result; // rax
long long v6; // rsi
long long i; // rdx
v3 = a2 - 1;
*a3 = v3;
result = malloc(4LL * v3);
v6 = *a3;
if ( (int)v6 > 0 )
{
for ( i = 0LL; i != v6; ++i )
*(_DWORD *)(result + 4 * i) = *(_DWORD *)(a1 + 4 * i + 4) * *(_DWORD *)(a1 + 4 * i);
}
return result;
} | func0:
ENDBR64
PUSH RBP
SUB ESI,0x1
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV dword ptr [RDX],ESI
MOVSXD RSI,ESI
LEA RDI,[RSI*0x4]
CALL 0x001010b0
MOVSXD RSI,dword ptr [RBP]
TEST ESI,ESI
JLE 0x001014d4
XOR EDX,EDX
NOP
LAB_001014c0:
MOV ECX,dword ptr [RBX + RDX*0x4]
IMUL ECX,dword ptr [RBX + RDX*0x4 + 0x4]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP RSI,RDX
JNZ 0x001014c0
LAB_001014d4:
ADD RSP,0x8
POP RBX
POP RBP
RET | void func0(long param_1,int param_2,int *param_3)
{
int iVar1;
void *pvVar2;
long lVar3;
*param_3 = param_2 + -1;
pvVar2 = malloc((long)(param_2 + -1) * 4);
iVar1 = *param_3;
if (0 < iVar1) {
lVar3 = 0;
do {
*(int *)((long)pvVar2 + lVar3 * 4) =
*(int *)(param_1 + lVar3 * 4) * *(int *)(param_1 + 4 + lVar3 * 4);
lVar3 = lVar3 + 1;
} while (iVar1 != lVar3);
}
return;
} |
6,655 | func0 |
#include <assert.h>
#include <stdlib.h>
| int* func0(int nums[], int length, int* result_length) {
*result_length = length - 1;
int* result = (int*) malloc((*result_length) * sizeof(int));
for (int i = 0; i < *result_length; i++) {
result[i] = nums[i] * nums[i + 1];
}
return result;
}
| int main() {
int result_length;
int test1[] = {1, 1, 3, 4, 4, 5, 6, 7};
int result1[] = {1, 3, 12, 16, 20, 30, 42};
int* computed_result1 = func0(test1, sizeof(test1) / sizeof(test1[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result1[i] == result1[i]);
}
free(computed_result1);
int test2[] = {4, 5, 8, 9, 6, 10};
int result2[] = {20, 40, 72, 54, 60};
int* computed_result2 = func0(test2, sizeof(test2) / sizeof(test2[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result2[i] == result2[i]);
}
free(computed_result2);
int test3[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int result3[] = {2, 6, 12, 20, 30, 42, 56, 72, 90};
int* computed_result3 = func0(test3, sizeof(test3) / sizeof(test3[0]), &result_length);
for (int i = 0; i < result_length; i++) {
assert(computed_result3[i] == result3[i]);
}
free(computed_result3);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
sub $0x1,%esi
mov %rdx,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
mov %esi,(%rdx)
movslq %esi,%rsi
lea 0x0(,%rsi,4),%rdi
callq 10b0 <malloc@plt>
mov 0x0(%rbp),%esi
test %esi,%esi
jle 15bb <func0+0xdb>
lea -0x1(%rsi),%edx
cmp $0x2,%edx
jbe 15c2 <func0+0xe2>
mov %esi,%ecx
xor %edx,%edx
shr $0x2,%ecx
shl $0x4,%rcx
nopw 0x0(%rax,%rax,1)
movdqu (%rbx,%rdx,1),%xmm0
movdqu 0x4(%rbx,%rdx,1),%xmm2
movdqu (%rbx,%rdx,1),%xmm1
movdqu 0x4(%rbx,%rdx,1),%xmm3
psrlq $0x20,%xmm0
psrlq $0x20,%xmm2
pmuludq %xmm3,%xmm1
pmuludq %xmm2,%xmm0
pshufd $0x8,%xmm1,%xmm1
pshufd $0x8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
movups %xmm1,(%rax,%rdx,1)
add $0x10,%rdx
cmp %rcx,%rdx
jne 1530 <func0+0x50>
mov %esi,%edx
and $0xfffffffc,%edx
test $0x3,%sil
je 15bb <func0+0xdb>
movslq %edx,%rcx
mov 0x4(%rbx,%rcx,4),%edi
mov (%rbx,%rcx,4),%r8d
imul %edi,%r8d
mov %r8d,(%rax,%rcx,4)
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 15bb <func0+0xdb>
movslq %ecx,%rcx
add $0x2,%edx
mov 0x4(%rbx,%rcx,4),%r8d
imul %r8d,%edi
mov %edi,(%rax,%rcx,4)
cmp %edx,%esi
jle 15bb <func0+0xdb>
movslq %edx,%rdx
imul 0x4(%rbx,%rdx,4),%r8d
mov %r8d,(%rax,%rdx,4)
add $0x8,%rsp
pop %rbx
pop %rbp
retq
xor %edx,%edx
jmp 157e <func0+0x9e>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
sub esi, 1
mov rbp, rdx
push rbx
mov rbx, rdi
sub rsp, 8
mov [rdx], esi
movsxd rsi, esi
lea rdi, ds:0[rsi*4]; size
call _malloc
mov esi, [rbp+0]
mov rcx, rax
test esi, esi
jle loc_1501
lea eax, [rsi-1]
cmp eax, 2
jbe loc_150B
mov edx, esi
xor eax, eax
shr edx, 2
shl rdx, 4
nop word ptr [rax+rax+00h]
loc_1470:
movdqu xmm0, xmmword ptr [rbx+rax]
movdqu xmm2, xmmword ptr [rbx+rax+4]
movdqu xmm1, xmmword ptr [rbx+rax]
movdqu xmm3, xmmword ptr [rbx+rax+4]
psrlq xmm0, 20h ; ' '
psrlq xmm2, 20h ; ' '
pmuludq xmm1, xmm3
pmuludq xmm0, xmm2
pshufd xmm1, xmm1, 8
pshufd xmm0, xmm0, 8
punpckldq xmm1, xmm0
movups xmmword ptr [rcx+rax], xmm1
add rax, 10h
cmp rdx, rax
jnz short loc_1470
mov eax, esi
and eax, 0FFFFFFFCh
test sil, 3
jz short loc_1501
loc_14BE:
movsxd r8, eax
lea rdx, ds:0[r8*4]
mov r9d, [rbx+r8*4]
mov edi, [rbx+rdx+4]
imul r9d, edi
mov [rcx+r8*4], r9d
lea r8d, [rax+1]
cmp esi, r8d
jle short loc_1501
mov r8d, [rbx+rdx+8]
add eax, 2
imul edi, r8d
mov [rcx+rdx+4], edi
cmp esi, eax
jle short loc_1501
imul r8d, [rbx+rdx+0Ch]
mov [rcx+rdx+8], r8d
loc_1501:
add rsp, 8
mov rax, rcx
pop rbx
pop rbp
retn
loc_150B:
xor eax, eax
jmp short loc_14BE | char * func0(long long a1, int a2, int *a3)
{
int v3; // esi
char *v6; // rax
int v7; // esi
char *v8; // rcx
long long v9; // rax
signed int v10; // eax
long long v11; // rdx
int v12; // edi
int v13; // r8d
v3 = a2 - 1;
*a3 = v3;
v6 = (char *)malloc(4LL * v3);
v7 = *a3;
v8 = v6;
if ( *a3 > 0 )
{
if ( (unsigned int)(v7 - 1) <= 2 )
{
v10 = 0;
}
else
{
v9 = 0LL;
do
{
*(__m128i *)&v8[v9] = _mm_unpacklo_epi32(
_mm_shuffle_epi32(
_mm_mul_epu32(
_mm_loadu_si128((const __m128i *)(a1 + v9)),
_mm_loadu_si128((const __m128i *)(a1 + v9 + 4))),
8),
_mm_shuffle_epi32(
_mm_mul_epu32(
_mm_srli_epi64(_mm_loadu_si128((const __m128i *)(a1 + v9)), 0x20u),
_mm_srli_epi64(_mm_loadu_si128((const __m128i *)(a1 + v9 + 4)), 0x20u)),
8));
v9 += 16LL;
}
while ( 16LL * ((unsigned int)v7 >> 2) != v9 );
v10 = v7 & 0xFFFFFFFC;
if ( (v7 & 3) == 0 )
return v8;
}
v11 = 4LL * v10;
v12 = *(_DWORD *)(a1 + v11 + 4);
*(_DWORD *)&v8[v11] = v12 * *(_DWORD *)(a1 + v11);
if ( v7 > v10 + 1 )
{
v13 = *(_DWORD *)(a1 + v11 + 8);
*(_DWORD *)&v8[v11 + 4] = v13 * v12;
if ( v7 > v10 + 2 )
*(_DWORD *)&v8[v11 + 8] = *(_DWORD *)(a1 + v11 + 12) * v13;
}
}
return v8;
} | func0:
ENDBR64
PUSH RBP
SUB ESI,0x1
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV dword ptr [RDX],ESI
MOVSXD RSI,ESI
LEA RDI,[RSI*0x4]
CALL 0x001010b0
MOV ESI,dword ptr [RBP]
MOV RCX,RAX
TEST ESI,ESI
JLE 0x00101501
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x0010150b
MOV EDX,ESI
XOR EAX,EAX
SHR EDX,0x2
SHL RDX,0x4
NOP word ptr [RAX + RAX*0x1]
LAB_00101470:
MOVDQU XMM0,xmmword ptr [RBX + RAX*0x1]
MOVDQU XMM2,xmmword ptr [RBX + RAX*0x1 + 0x4]
MOVDQU XMM1,xmmword ptr [RBX + RAX*0x1]
MOVDQU XMM3,xmmword ptr [RBX + RAX*0x1 + 0x4]
PSRLQ XMM0,0x20
PSRLQ XMM2,0x20
PMULUDQ XMM1,XMM3
PMULUDQ XMM0,XMM2
PSHUFD XMM1,XMM1,0x8
PSHUFD XMM0,XMM0,0x8
PUNPCKLDQ XMM1,XMM0
MOVUPS xmmword ptr [RCX + RAX*0x1],XMM1
ADD RAX,0x10
CMP RDX,RAX
JNZ 0x00101470
MOV EAX,ESI
AND EAX,0xfffffffc
TEST SIL,0x3
JZ 0x00101501
LAB_001014be:
MOVSXD R8,EAX
LEA RDX,[R8*0x4]
MOV R9D,dword ptr [RBX + R8*0x4]
MOV EDI,dword ptr [RBX + RDX*0x1 + 0x4]
IMUL R9D,EDI
MOV dword ptr [RCX + R8*0x4],R9D
LEA R8D,[RAX + 0x1]
CMP ESI,R8D
JLE 0x00101501
MOV R8D,dword ptr [RBX + RDX*0x1 + 0x8]
ADD EAX,0x2
IMUL EDI,R8D
MOV dword ptr [RCX + RDX*0x1 + 0x4],EDI
CMP ESI,EAX
JLE 0x00101501
IMUL R8D,dword ptr [RBX + RDX*0x1 + 0xc]
MOV dword ptr [RCX + RDX*0x1 + 0x8],R8D
LAB_00101501:
ADD RSP,0x8
MOV RAX,RCX
POP RBX
POP RBP
RET
LAB_0010150b:
XOR EAX,EAX
JMP 0x001014be | void * func0(long param_1,int param_2,uint *param_3)
{
int8 *puVar1;
ulong *puVar2;
uint *puVar3;
uint uVar4;
int iVar5;
int iVar6;
ulong uVar7;
ulong uVar8;
ulong uVar9;
uint uVar10;
void *pvVar11;
long lVar12;
long lVar13;
*param_3 = param_2 - 1U;
pvVar11 = malloc((long)(int)(param_2 - 1U) * 4);
uVar4 = *param_3;
if (0 < (int)uVar4) {
if (uVar4 - 1 < 3) {
uVar10 = 0;
}
else {
lVar12 = 0;
do {
uVar7 = ((ulong *)(param_1 + lVar12))[1];
puVar2 = (ulong *)(param_1 + 4 + lVar12);
uVar8 = puVar2[1];
uVar9 = ((ulong *)(param_1 + lVar12))[1];
puVar3 = (uint *)(param_1 + 4 + lVar12);
uVar10 = puVar3[2];
puVar1 = (int8 *)((long)pvVar11 + lVar12);
*puVar1 = CONCAT44((int)((*(ulong *)(param_1 + lVar12) >> 0x20) * (*puVar2 >> 0x20)),
(int)((*(ulong *)(param_1 + lVar12) & 0xffffffff) * (ulong)*puVar3));
*(int *)(puVar1 + 2) = (int)((uVar9 & 0xffffffff) * (ulong)uVar10);
*(int *)((long)puVar1 + 0x14) = (int)((uVar7 >> 0x20) * (uVar8 >> 0x20));
lVar12 = lVar12 + 0x10;
} while ((ulong)(uVar4 >> 2) << 4 != lVar12);
uVar10 = uVar4 & 0xfffffffc;
if ((uVar4 & 3) == 0) {
return pvVar11;
}
}
lVar13 = (long)(int)uVar10;
lVar12 = lVar13 * 4;
iVar5 = *(int *)(param_1 + 4 + lVar12);
*(int *)((long)pvVar11 + lVar13 * 4) = *(int *)(param_1 + lVar13 * 4) * iVar5;
if ((int)(uVar10 + 1) < (int)uVar4) {
iVar6 = *(int *)(param_1 + 8 + lVar12);
*(int *)((long)pvVar11 + lVar12 + 4) = iVar5 * iVar6;
if ((int)(uVar10 + 2) < (int)uVar4) {
*(int *)((long)pvVar11 + lVar12 + 8) = iVar6 * *(int *)(param_1 + 0xc + lVar12);
}
}
}
return pvVar11;
} |
6,656 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct Pair {
int first;
int second;
} Pair;
typedef struct List {
int value;
struct List *next;
} List;
typedef struct Map {
int key;
List *values;
struct Map *next;
} Map;
int compare_pairs(const void *a, const void *b) {
Pair *pa = (Pair *)a;
Pair *pb = (Pair *)b;
return pa->second - pb->second;
}
void add_to_map(Map **map, int key, int value) {
Map *cursor = *map;
Map *prev = NULL;
List *newList = NULL;
while (cursor) {
if (cursor->key == key) {
newList = (List *)malloc(sizeof(List));
newList->value = value;
newList->next = cursor->values;
cursor->values = newList;
return;
}
prev = cursor;
cursor = cursor->next;
}
Map *newMap = (Map *)malloc(sizeof(Map));
newMap->key = key;
newMap->values = (List *)malloc(sizeof(List));
newMap->values->value = value;
newMap->values->next = NULL;
newMap->next = NULL;
if (prev) {
prev->next = newMap;
} else {
*map = newMap;
}
}
void free_map(Map *map) {
while (map != NULL) {
List *list = map->values;
while (list != NULL) {
List *tempList = list;
list = list->next;
free(tempList);
}
Map *tempMap = map;
map = map->next;
free(tempMap);
}
}
| Map *func0(Pair *test_list, int size) {
qsort(test_list, size, sizeof(Pair), compare_pairs);
Map *result = NULL;
for (int i = 0; i < size; ++i) {
add_to_map(&result, test_list[i].second, test_list[i].first);
}
return result;
}
| int main() {
Pair pairs1[] = {{6, 5}, {2, 7}, {2, 5}, {8, 7}, {9, 8}, {3, 7}};
Pair pairs2[] = {{7, 6}, {3, 8}, {3, 6}, {9, 8}, {10, 9}, {4, 8}};
Pair pairs3[] = {{8, 7}, {4, 9}, {4, 7}, {10, 9}, {11, 10}, {5, 9}};
Map *map_result;
map_result = func0(pairs1, 6);
assert(map_result && map_result->key == 5 && map_result->next->key == 7 && map_result->next->next->key == 8);
free_map(map_result);
map_result = func0(pairs2, 6);
assert(map_result && map_result->key == 6 && map_result->next->key == 8 && map_result->next->next->key == 9);
free_map(map_result);
map_result = func0(pairs3, 6);
assert(map_result && map_result->key == 7 && map_result->next->key == 9 && map_result->next->next->key == 10);
free_map(map_result);
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x2c(%rbp),%eax
movslq %eax,%rsi
mov -0x28(%rbp),%rax
lea -0x1e1(%rip),%rcx
mov $0x8,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
movq $0x0,-0x10(%rbp)
movl $0x0,-0x14(%rbp)
jmp 1407 <func0+0x90>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov 0x4(%rax),%ecx
lea -0x10(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 11fd <add_to_map>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 13c8 <func0+0x51>
mov -0x10(%rbp),%rax
mov -0x8(%rbp),%rdi
xor %fs:0x28,%rdi
je 1427 <func0+0xb0>
callq 10b0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+base], rdi
mov [rbp+var_2C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_2C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare_pairs
mov rcx, rdx; compar
mov edx, 8; size
mov rdi, rax; base
call _qsort
mov [rbp+var_10], 0
mov [rbp+var_14], 0
jmp short loc_140A
loc_13CB:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_14]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+base]
add rax, rcx
mov ecx, [rax+4]
lea rax, [rbp+var_10]
mov esi, ecx
mov rdi, rax
call add_to_map
add [rbp+var_14], 1
loc_140A:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl short loc_13CB
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_142A
call ___stack_chk_fail
locret_142A:
leave
retn | long long func0(unsigned int *a1, int a2)
{
int i; // [rsp+1Ch] [rbp-14h]
_QWORD v4[2]; // [rsp+20h] [rbp-10h] BYREF
v4[1] = __readfsqword(0x28u);
qsort(a1, a2, 8uLL, compare_pairs);
v4[0] = 0LL;
for ( i = 0; i < a2; ++i )
add_to_map(v4, a1[2 * i + 1], a1[2 * i]);
return v4[0];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x8
MOV RDI,RAX
CALL 0x001010a0
MOV qword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010140a
LAB_001013cb:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV ECX,dword ptr [RAX + 0x4]
LEA RAX,[RBP + -0x10]
MOV ESI,ECX
MOV RDI,RAX
CALL 0x001011fd
ADD dword ptr [RBP + -0x14],0x1
LAB_0010140a:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001013cb
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010142a
CALL 0x001010b0
LAB_0010142a:
LEAVE
RET | int8 func0(void *param_1,int param_2)
{
long in_FS_OFFSET;
int local_1c;
int8 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
qsort(param_1,(long)param_2,8,compare_pairs);
local_18 = 0;
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
add_to_map(&local_18,*(int4 *)((long)param_1 + (long)local_1c * 8 + 4),
*(int4 *)((long)param_1 + (long)local_1c * 8));
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_18;
} |
6,657 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct Pair {
int first;
int second;
} Pair;
typedef struct List {
int value;
struct List *next;
} List;
typedef struct Map {
int key;
List *values;
struct Map *next;
} Map;
int compare_pairs(const void *a, const void *b) {
Pair *pa = (Pair *)a;
Pair *pb = (Pair *)b;
return pa->second - pb->second;
}
void add_to_map(Map **map, int key, int value) {
Map *cursor = *map;
Map *prev = NULL;
List *newList = NULL;
while (cursor) {
if (cursor->key == key) {
newList = (List *)malloc(sizeof(List));
newList->value = value;
newList->next = cursor->values;
cursor->values = newList;
return;
}
prev = cursor;
cursor = cursor->next;
}
Map *newMap = (Map *)malloc(sizeof(Map));
newMap->key = key;
newMap->values = (List *)malloc(sizeof(List));
newMap->values->value = value;
newMap->values->next = NULL;
newMap->next = NULL;
if (prev) {
prev->next = newMap;
} else {
*map = newMap;
}
}
void free_map(Map *map) {
while (map != NULL) {
List *list = map->values;
while (list != NULL) {
List *tempList = list;
list = list->next;
free(tempList);
}
Map *tempMap = map;
map = map->next;
free(tempMap);
}
}
| Map *func0(Pair *test_list, int size) {
qsort(test_list, size, sizeof(Pair), compare_pairs);
Map *result = NULL;
for (int i = 0; i < size; ++i) {
add_to_map(&result, test_list[i].second, test_list[i].first);
}
return result;
}
| int main() {
Pair pairs1[] = {{6, 5}, {2, 7}, {2, 5}, {8, 7}, {9, 8}, {3, 7}};
Pair pairs2[] = {{7, 6}, {3, 8}, {3, 6}, {9, 8}, {10, 9}, {4, 8}};
Pair pairs3[] = {{8, 7}, {4, 9}, {4, 7}, {10, 9}, {11, 10}, {5, 9}};
Map *map_result;
map_result = func0(pairs1, 6);
assert(map_result && map_result->key == 5 && map_result->next->key == 7 && map_result->next->next->key == 8);
free_map(map_result);
map_result = func0(pairs2, 6);
assert(map_result && map_result->key == 6 && map_result->next->key == 8 && map_result->next->next->key == 9);
free_map(map_result);
map_result = func0(pairs3, 6);
assert(map_result && map_result->key == 7 && map_result->next->key == 9 && map_result->next->next->key == 10);
free_map(map_result);
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%r12
mov %esi,%ebp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movslq %esi,%rsi
lea -0x13f(%rip),%rcx
mov $0x8,%edx
callq 10a0 <qsort@plt>
movq $0x0,(%rsp)
test %ebp,%ebp
jle 1342 <func0+0x65>
mov %r12,%rbx
lea -0x1(%rbp),%eax
lea 0x8(%r12,%rax,8),%r12
mov %rsp,%rbp
mov 0x4(%rbx),%esi
mov (%rbx),%edx
mov %rbp,%rdi
callq 11d4 <add_to_map>
add $0x8,%rbx
cmp %r12,%rbx
jne 132c <func0+0x4f>
mov (%rsp),%rax
mov 0x8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 135f <func0+0x82>
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10b0 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
mov r12, rdi
mov ebp, esi
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
movsxd rsi, esi
lea rcx, compare_pairs
mov edx, 8
call _qsort
mov [rsp+28h+var_28], 0
test ebp, ebp
jle short loc_1342
mov rbx, r12
lea eax, [rbp-1]
lea r12, [r12+rax*8+8]
mov rbp, rsp
loc_132C:
mov esi, [rbx+4]
mov edx, [rbx]
mov rdi, rbp
call add_to_map
add rbx, 8
cmp rbx, r12
jnz short loc_132C
loc_1342:
mov rax, [rsp+28h+var_28]
mov rdx, [rsp+28h+var_20]
sub rdx, fs:28h
jnz short loc_135F
add rsp, 10h
pop rbx
pop rbp
pop r12
retn
loc_135F:
call ___stack_chk_fail | long long func0(unsigned int *a1, int a2)
{
unsigned int *v2; // rbx
_QWORD v4[5]; // [rsp+0h] [rbp-28h] BYREF
v4[1] = __readfsqword(0x28u);
qsort(a1, a2, 8LL, compare_pairs);
v4[0] = 0LL;
if ( a2 > 0 )
{
v2 = a1;
do
{
add_to_map(v4, v2[1], *v2);
v2 += 2;
}
while ( v2 != &a1[2 * (a2 - 1) + 2] );
}
return v4[0];
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV R12,RDI
MOV EBP,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVSXD RSI,ESI
LEA RCX,[0x1011c9]
MOV EDX,0x8
CALL 0x001010a0
MOV qword ptr [RSP],0x0
TEST EBP,EBP
JLE 0x00101342
MOV RBX,R12
LEA EAX,[RBP + -0x1]
LEA R12,[R12 + RAX*0x8 + 0x8]
MOV RBP,RSP
LAB_0010132c:
MOV ESI,dword ptr [RBX + 0x4]
MOV EDX,dword ptr [RBX]
MOV RDI,RBP
CALL 0x001011d4
ADD RBX,0x8
CMP RBX,R12
JNZ 0x0010132c
LAB_00101342:
MOV RAX,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010135f
ADD RSP,0x10
POP RBX
POP RBP
POP R12
RET
LAB_0010135f:
CALL 0x001010b0 | int8 func0(int4 *param_1,int param_2)
{
int4 *puVar1;
long in_FS_OFFSET;
int8 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
qsort(param_1,(long)param_2,8,compare_pairs);
local_28 = 0;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
do {
add_to_map(&local_28,param_1[1],*param_1);
param_1 = param_1 + 2;
} while (param_1 != puVar1);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_28;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,658 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct Pair {
int first;
int second;
} Pair;
typedef struct List {
int value;
struct List *next;
} List;
typedef struct Map {
int key;
List *values;
struct Map *next;
} Map;
int compare_pairs(const void *a, const void *b) {
Pair *pa = (Pair *)a;
Pair *pb = (Pair *)b;
return pa->second - pb->second;
}
void add_to_map(Map **map, int key, int value) {
Map *cursor = *map;
Map *prev = NULL;
List *newList = NULL;
while (cursor) {
if (cursor->key == key) {
newList = (List *)malloc(sizeof(List));
newList->value = value;
newList->next = cursor->values;
cursor->values = newList;
return;
}
prev = cursor;
cursor = cursor->next;
}
Map *newMap = (Map *)malloc(sizeof(Map));
newMap->key = key;
newMap->values = (List *)malloc(sizeof(List));
newMap->values->value = value;
newMap->values->next = NULL;
newMap->next = NULL;
if (prev) {
prev->next = newMap;
} else {
*map = newMap;
}
}
void free_map(Map *map) {
while (map != NULL) {
List *list = map->values;
while (list != NULL) {
List *tempList = list;
list = list->next;
free(tempList);
}
Map *tempMap = map;
map = map->next;
free(tempMap);
}
}
| Map *func0(Pair *test_list, int size) {
qsort(test_list, size, sizeof(Pair), compare_pairs);
Map *result = NULL;
for (int i = 0; i < size; ++i) {
add_to_map(&result, test_list[i].second, test_list[i].first);
}
return result;
}
| int main() {
Pair pairs1[] = {{6, 5}, {2, 7}, {2, 5}, {8, 7}, {9, 8}, {3, 7}};
Pair pairs2[] = {{7, 6}, {3, 8}, {3, 6}, {9, 8}, {10, 9}, {4, 8}};
Pair pairs3[] = {{8, 7}, {4, 9}, {4, 7}, {10, 9}, {11, 10}, {5, 9}};
Map *map_result;
map_result = func0(pairs1, 6);
assert(map_result && map_result->key == 5 && map_result->next->key == 7 && map_result->next->next->key == 8);
free_map(map_result);
map_result = func0(pairs2, 6);
assert(map_result && map_result->key == 6 && map_result->next->key == 8 && map_result->next->next->key == 9);
free_map(map_result);
map_result = func0(pairs3, 6);
assert(map_result && map_result->key == 7 && map_result->next->key == 9 && map_result->next->next->key == 10);
free_map(map_result);
}
| O2 | c | func0:
endbr64
push %r12
movslq %esi,%rsi
mov $0x8,%edx
lea -0x165(%rip),%rcx
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
callq 10a0 <qsort@plt>
movq $0x0,(%rsp)
test %ebp,%ebp
jle 15e8 <func0+0x88>
lea -0x1(%rbp),%eax
mov %rsp,%rbp
lea 0x8(%rbx,%rax,8),%r12
nopl (%rax)
mov 0x4(%rbx),%esi
mov (%rbx),%edx
mov %rbp,%rdi
add $0x8,%rbx
callq 1420 <add_to_map>
cmp %r12,%rbx
jne 15b0 <func0+0x50>
mov (%rsp),%rax
mov 0x8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 15ec <func0+0x8c>
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
jmp 15ca <func0+0x6a>
callq 10b0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r12
movsxd rsi, esi
mov edx, 8
lea rcx, compare_pairs
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 10h
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
call _qsort
mov [rsp+28h+var_28], 0
test ebp, ebp
jle short loc_15E8
lea eax, [rbp-1]
mov rbp, rsp
lea r12, [rbx+rax*8+8]
nop dword ptr [rax]
loc_15B0:
mov esi, [rbx+4]
mov edx, [rbx]
mov rdi, rbp
add rbx, 8
call add_to_map
cmp rbx, r12
jnz short loc_15B0
mov rax, [rsp+28h+var_28]
loc_15CA:
mov rdx, [rsp+28h+var_20]
sub rdx, fs:28h
jnz short loc_15EC
add rsp, 10h
pop rbx
pop rbp
pop r12
retn
loc_15E8:
xor eax, eax
jmp short loc_15CA
loc_15EC:
call ___stack_chk_fail | long long func0(unsigned int *a1, int a2)
{
unsigned int *v3; // rbx
long long v4; // rsi
long long v5; // rdx
_QWORD v7[5]; // [rsp+0h] [rbp-28h] BYREF
v3 = a1;
v7[1] = __readfsqword(0x28u);
qsort(a1, a2, 8LL, compare_pairs);
v7[0] = 0LL;
if ( a2 <= 0 )
return 0LL;
do
{
v4 = v3[1];
v5 = *v3;
v3 += 2;
add_to_map(v7, v4, v5);
}
while ( v3 != &a1[2 * (a2 - 1) + 2] );
return v7[0];
} | func0:
ENDBR64
PUSH R12
MOVSXD RSI,ESI
MOV EDX,0x8
LEA RCX,[0x101410]
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
CALL 0x001010a0
MOV qword ptr [RSP],0x0
TEST EBP,EBP
JLE 0x001015e8
LEA EAX,[RBP + -0x1]
MOV RBP,RSP
LEA R12,[RBX + RAX*0x8 + 0x8]
NOP dword ptr [RAX]
LAB_001015b0:
MOV ESI,dword ptr [RBX + 0x4]
MOV EDX,dword ptr [RBX]
MOV RDI,RBP
ADD RBX,0x8
CALL 0x00101420
CMP RBX,R12
JNZ 0x001015b0
MOV RAX,qword ptr [RSP]
LAB_001015ca:
MOV RDX,qword ptr [RSP + 0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001015ec
ADD RSP,0x10
POP RBX
POP RBP
POP R12
RET
LAB_001015e8:
XOR EAX,EAX
JMP 0x001015ca
LAB_001015ec:
CALL 0x001010b0 | int8 func0(int4 *param_1,int param_2)
{
int4 *puVar1;
int4 *puVar2;
int4 uVar3;
long in_FS_OFFSET;
int8 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
qsort(param_1,(long)param_2,8,compare_pairs);
local_28 = 0;
if (param_2 < 1) {
local_28 = 0;
}
else {
puVar2 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
do {
puVar1 = param_1 + 1;
uVar3 = *param_1;
param_1 = param_1 + 2;
add_to_map(&local_28,*puVar1,uVar3);
} while (param_1 != puVar2);
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_28;
} |
6,659 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct Pair {
int first;
int second;
} Pair;
typedef struct List {
int value;
struct List *next;
} List;
typedef struct Map {
int key;
List *values;
struct Map *next;
} Map;
int compare_pairs(const void *a, const void *b) {
Pair *pa = (Pair *)a;
Pair *pb = (Pair *)b;
return pa->second - pb->second;
}
void add_to_map(Map **map, int key, int value) {
Map *cursor = *map;
Map *prev = NULL;
List *newList = NULL;
while (cursor) {
if (cursor->key == key) {
newList = (List *)malloc(sizeof(List));
newList->value = value;
newList->next = cursor->values;
cursor->values = newList;
return;
}
prev = cursor;
cursor = cursor->next;
}
Map *newMap = (Map *)malloc(sizeof(Map));
newMap->key = key;
newMap->values = (List *)malloc(sizeof(List));
newMap->values->value = value;
newMap->values->next = NULL;
newMap->next = NULL;
if (prev) {
prev->next = newMap;
} else {
*map = newMap;
}
}
void free_map(Map *map) {
while (map != NULL) {
List *list = map->values;
while (list != NULL) {
List *tempList = list;
list = list->next;
free(tempList);
}
Map *tempMap = map;
map = map->next;
free(tempMap);
}
}
| Map *func0(Pair *test_list, int size) {
qsort(test_list, size, sizeof(Pair), compare_pairs);
Map *result = NULL;
for (int i = 0; i < size; ++i) {
add_to_map(&result, test_list[i].second, test_list[i].first);
}
return result;
}
| int main() {
Pair pairs1[] = {{6, 5}, {2, 7}, {2, 5}, {8, 7}, {9, 8}, {3, 7}};
Pair pairs2[] = {{7, 6}, {3, 8}, {3, 6}, {9, 8}, {10, 9}, {4, 8}};
Pair pairs3[] = {{8, 7}, {4, 9}, {4, 7}, {10, 9}, {11, 10}, {5, 9}};
Map *map_result;
map_result = func0(pairs1, 6);
assert(map_result && map_result->key == 5 && map_result->next->key == 7 && map_result->next->next->key == 8);
free_map(map_result);
map_result = func0(pairs2, 6);
assert(map_result && map_result->key == 6 && map_result->next->key == 8 && map_result->next->next->key == 9);
free_map(map_result);
map_result = func0(pairs3, 6);
assert(map_result && map_result->key == 7 && map_result->next->key == 9 && map_result->next->next->key == 10);
free_map(map_result);
}
| O3 | c | func0:
endbr64
push %r15
movslq %esi,%rsi
mov $0x8,%edx
lea -0x165(%rip),%rcx
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x18,%rsp
callq 10a0 <qsort@plt>
test %ebp,%ebp
jle 1620 <func0+0x130>
lea -0x1(%rbp),%eax
xor %r15d,%r15d
lea 0x8(%rbx,%rax,8),%rax
mov %rax,0x8(%rsp)
nopl 0x0(%rax)
mov (%rbx),%r12d
mov 0x4(%rbx),%r13d
test %r15,%r15
je 15e0 <func0+0xf0>
mov %r15,%rbp
jmp 155c <func0+0x6c>
nopl (%rax)
mov 0x10(%rbp),%rax
test %rax,%rax
je 15a0 <func0+0xb0>
mov %rax,%rbp
cmp 0x0(%rbp),%r13d
jne 1550 <func0+0x60>
mov $0x10,%edi
callq 10d0 <malloc@plt>
mov 0x8(%rbp),%rdx
mov %r12d,(%rax)
mov %rdx,0x8(%rax)
mov %rax,0x8(%rbp)
add $0x8,%rbx
cmp 0x8(%rsp),%rbx
jne 1538 <func0+0x48>
add $0x18,%rsp
mov %r15,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov $0x18,%edi
callq 10d0 <malloc@plt>
mov $0x10,%edi
mov %r13d,(%rax)
mov %rax,%r14
callq 10d0 <malloc@plt>
movq $0x0,0x10(%r14)
mov %rax,0x8(%r14)
mov %r12d,(%rax)
movq $0x0,0x8(%rax)
mov %r14,0x10(%rbp)
jmp 157b <func0+0x8b>
nopw 0x0(%rax,%rax,1)
mov $0x18,%edi
callq 10d0 <malloc@plt>
mov $0x10,%edi
mov %r13d,(%rax)
mov %rax,%r15
callq 10d0 <malloc@plt>
movq $0x0,0x10(%r15)
mov %rax,0x8(%r15)
mov %r12d,(%rax)
movq $0x0,0x8(%rax)
jmpq 157b <func0+0x8b>
nopw %cs:0x0(%rax,%rax,1)
xor %r15d,%r15d
jmpq 1586 <func0+0x96>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
lea rcx, compare_pairs; compar
mov edx, 8; size
push r14
push r13
push r12
movsxd r12, esi
push rbp
mov rsi, r12; nmemb
push rbx
mov rbx, rdi
sub rsp, 18h
call _qsort
test r12d, r12d
jle loc_1624
mov r14d, [rbx+4]
mov edi, 18h; size
mov ebp, [rbx]
shl r12, 3
call _malloc
mov edi, 10h; size
mov [rax], r14d
mov r13, rax
call _malloc
mov qword ptr [r13+10h], 0
mov [r13+8], rax
mov [rax], ebp
mov qword ptr [rax+8], 0
cmp r12, 8
jz loc_1612
lea rax, [rbx+r12]
mov ebp, [rbx+0Ch]
mov r12d, [rbx+8]
lea r15, [rbx+8]
mov [rsp+48h+var_40], rax
nop dword ptr [rax]
loc_1580:
mov rbx, r13
jmp short loc_1594
loc_1588:
mov rax, [rbx+10h]
test rax, rax
jz short loc_15D0
mov rbx, rax
loc_1594:
cmp [rbx], ebp
jnz short loc_1588
mov edi, 10h; size
add r15, 8
call _malloc
mov rdx, [rbx+8]
mov [rax], r12d
mov [rax+8], rdx
mov [rbx+8], rax
mov rax, [rsp+48h+var_40]
cmp r15, rax
jz short loc_1612
loc_15BF:
mov r12d, [r15]
mov ebp, [r15+4]
jmp short loc_1580
loc_15D0:
mov edi, 18h; size
add r15, 8
call _malloc
mov edi, 10h; size
mov [rax], ebp
mov r14, rax
call _malloc
mov qword ptr [r14+10h], 0
mov [r14+8], rax
mov [rax], r12d
mov qword ptr [rax+8], 0
mov rax, [rsp+48h+var_40]
mov [rbx+10h], r14
cmp r15, rax
jnz short loc_15BF
loc_1612:
add rsp, 18h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1624:
xor r13d, r13d
jmp short loc_1612 | _DWORD * func0(int *a1, int a2)
{
int v2; // r14d
int v3; // ebp
long long v4; // r12
_DWORD *v5; // rax
_DWORD *v6; // r13
_QWORD *v7; // rax
int *v8; // rax
int v9; // ebp
int v10; // r12d
int *v11; // r15
_DWORD *i; // rbx
_QWORD *v13; // rax
long long v14; // rdx
_DWORD *v15; // rax
_DWORD *v16; // r14
_QWORD *v17; // rax
int *v19; // [rsp+8h] [rbp-40h]
qsort(a1, a2, 8uLL, compare_pairs);
if ( a2 <= 0 )
return 0LL;
v2 = a1[1];
v3 = *a1;
v4 = 2LL * a2;
v5 = malloc(0x18uLL);
*v5 = v2;
v6 = v5;
v7 = malloc(0x10uLL);
*((_QWORD *)v6 + 2) = 0LL;
*((_QWORD *)v6 + 1) = v7;
*(_DWORD *)v7 = v3;
v7[1] = 0LL;
if ( v4 != 2 )
{
v8 = &a1[v4];
v9 = a1[3];
v10 = a1[2];
v11 = a1 + 2;
v19 = v8;
LABEL_4:
for ( i = v6; ; i = (_DWORD *)*((_QWORD *)i + 2) )
{
if ( *i == v9 )
{
v11 += 2;
v13 = malloc(0x10uLL);
v14 = *((_QWORD *)i + 1);
*(_DWORD *)v13 = v10;
v13[1] = v14;
*((_QWORD *)i + 1) = v13;
if ( v11 == v19 )
return v6;
LABEL_9:
v10 = *v11;
v9 = v11[1];
goto LABEL_4;
}
if ( !*((_QWORD *)i + 2) )
break;
}
v11 += 2;
v15 = malloc(0x18uLL);
*v15 = v9;
v16 = v15;
v17 = malloc(0x10uLL);
*((_QWORD *)v16 + 2) = 0LL;
*((_QWORD *)v16 + 1) = v17;
*(_DWORD *)v17 = v10;
v17[1] = 0LL;
*((_QWORD *)i + 2) = v16;
if ( v11 != v19 )
goto LABEL_9;
}
return v6;
} | func0:
ENDBR64
PUSH R15
LEA RCX,[0x1013a0]
MOV EDX,0x8
PUSH R14
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RSI,R12
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
CALL 0x001010a0
TEST R12D,R12D
JLE 0x00101624
MOV R14D,dword ptr [RBX + 0x4]
MOV EDI,0x18
MOV EBP,dword ptr [RBX]
SHL R12,0x3
CALL 0x001010d0
MOV EDI,0x10
MOV dword ptr [RAX],R14D
MOV R13,RAX
CALL 0x001010d0
MOV qword ptr [R13 + 0x10],0x0
MOV qword ptr [R13 + 0x8],RAX
MOV dword ptr [RAX],EBP
MOV qword ptr [RAX + 0x8],0x0
CMP R12,0x8
JZ 0x00101612
LEA RAX,[RBX + R12*0x1]
MOV EBP,dword ptr [RBX + 0xc]
MOV R12D,dword ptr [RBX + 0x8]
LEA R15,[RBX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
NOP dword ptr [RAX]
LAB_00101580:
MOV RBX,R13
JMP 0x00101594
LAB_00101588:
MOV RAX,qword ptr [RBX + 0x10]
TEST RAX,RAX
JZ 0x001015d0
MOV RBX,RAX
LAB_00101594:
CMP dword ptr [RBX],EBP
JNZ 0x00101588
MOV EDI,0x10
ADD R15,0x8
CALL 0x001010d0
MOV RDX,qword ptr [RBX + 0x8]
MOV dword ptr [RAX],R12D
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RBX + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP R15,RAX
JZ 0x00101612
LAB_001015bf:
MOV R12D,dword ptr [R15]
MOV EBP,dword ptr [R15 + 0x4]
JMP 0x00101580
LAB_001015d0:
MOV EDI,0x18
ADD R15,0x8
CALL 0x001010d0
MOV EDI,0x10
MOV dword ptr [RAX],EBP
MOV R14,RAX
CALL 0x001010d0
MOV qword ptr [R14 + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV dword ptr [RAX],R12D
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x10],R14
CMP R15,RAX
JNZ 0x001015bf
LAB_00101612:
ADD RSP,0x18
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101624:
XOR R13D,R13D
JMP 0x00101612 | int * func0(int4 *param_1,int param_2)
{
int8 uVar1;
int *piVar2;
int4 *puVar3;
int4 *puVar4;
int *piVar5;
int *piVar6;
int iVar7;
int4 uVar8;
size_t __nmemb;
__nmemb = (size_t)param_2;
qsort(param_1,__nmemb,8,compare_pairs);
if (param_2 < 1) {
piVar2 = (int *)0x0;
}
else {
iVar7 = param_1[1];
uVar8 = *param_1;
piVar2 = (int *)malloc(0x18);
*piVar2 = iVar7;
puVar3 = (int4 *)malloc(0x10);
piVar2[4] = 0;
piVar2[5] = 0;
*(int4 **)(piVar2 + 2) = puVar3;
*puVar3 = uVar8;
*(int8 *)(puVar3 + 2) = 0;
if ((__nmemb & 0x1fffffffffffffff) != 1) {
iVar7 = param_1[3];
uVar8 = param_1[2];
piVar5 = piVar2;
puVar3 = param_1 + 2;
LAB_00101594:
piVar6 = piVar5;
if (*piVar6 != iVar7) goto LAB_00101588;
puVar4 = (int4 *)malloc(0x10);
uVar1 = *(int8 *)(piVar6 + 2);
*puVar4 = uVar8;
*(int8 *)(puVar4 + 2) = uVar1;
*(int4 **)(piVar6 + 2) = puVar4;
goto joined_r0x00101610;
}
}
return piVar2;
LAB_00101588:
piVar5 = *(int **)(piVar6 + 4);
if (*(int **)(piVar6 + 4) == (int *)0x0) {
piVar5 = (int *)malloc(0x18);
*piVar5 = iVar7;
puVar4 = (int4 *)malloc(0x10);
piVar5[4] = 0;
piVar5[5] = 0;
*(int4 **)(piVar5 + 2) = puVar4;
*puVar4 = uVar8;
*(int8 *)(puVar4 + 2) = 0;
*(int **)(piVar6 + 4) = piVar5;
joined_r0x00101610:
if (puVar3 + 2 == param_1 + __nmemb * 2) {
return piVar2;
}
uVar8 = puVar3[2];
iVar7 = puVar3[3];
piVar5 = piVar2;
puVar3 = puVar3 + 2;
}
goto LAB_00101594;
} |
6,660 | func0 |
#include <assert.h>
| int func0(int N) {
if (N >= 10) {
return 0;
}
int fac = 1;
for (int i = 1; i <= N; i++) {
fac = (fac * i) % 100;
}
return fac;
}
| int main() {
assert(func0(7) == 40);
assert(func0(5) == 20);
assert(func0(2) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x9,-0x14(%rbp)
jle 1161 <func0+0x18>
mov $0x0,%eax
jmp 11ad <func0+0x64>
movl $0x1,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11a2 <func0+0x59>
mov -0x8(%rbp),%eax
imul -0x4(%rbp),%eax
movslq %eax,%rdx
imul $0x51eb851f,%rdx,%rdx
shr $0x20,%rdx
mov %edx,%ecx
sar $0x5,%ecx
cltd
sub %edx,%ecx
mov %ecx,%edx
mov %edx,-0x8(%rbp)
mov -0x8(%rbp),%edx
imul $0x64,%edx,%edx
sub %edx,%eax
mov %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 1171 <func0+0x28>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 9
jle short loc_1161
mov eax, 0
jmp short loc_11AD
loc_1161:
mov [rbp+var_8], 1
mov [rbp+var_4], 1
jmp short loc_11A2
loc_1171:
mov eax, [rbp+var_8]
imul eax, [rbp+var_4]
movsxd rdx, eax
imul rdx, 51EB851Fh
shr rdx, 20h
sar edx, 5
mov ecx, eax
sar ecx, 1Fh
sub edx, ecx
mov [rbp+var_8], edx
mov edx, [rbp+var_8]
imul edx, 64h ; 'd'
sub eax, edx
mov [rbp+var_8], eax
add [rbp+var_4], 1
loc_11A2:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_14]
jle short loc_1171
mov eax, [rbp+var_8]
loc_11AD:
pop rbp
retn | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
if ( a1 > 9 )
return 0LL;
v2 = 1;
for ( i = 1; i <= a1; ++i )
v2 = (int)(i * v2) % 100;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x9
JLE 0x00101161
MOV EAX,0x0
JMP 0x001011ad
LAB_00101161:
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011a2
LAB_00101171:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x51eb851f
SHR RDX,0x20
SAR EDX,0x5
MOV ECX,EAX
SAR ECX,0x1f
SUB EDX,ECX
MOV dword ptr [RBP + -0x8],EDX
MOV EDX,dword ptr [RBP + -0x8]
IMUL EDX,EDX,0x64
SUB EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a2:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x00101171
MOV EAX,dword ptr [RBP + -0x8]
LAB_001011ad:
POP RBP
RET | int func0(int param_1)
{
int4 local_10;
int4 local_c;
if (param_1 < 10) {
local_10 = 1;
for (local_c = 1; local_c <= param_1; local_c = local_c + 1) {
local_10 = (local_10 * local_c) % 100;
}
}
else {
local_10 = 0;
}
return local_10;
} |
6,661 | func0 |
#include <assert.h>
| int func0(int N) {
if (N >= 10) {
return 0;
}
int fac = 1;
for (int i = 1; i <= N; i++) {
fac = (fac * i) % 100;
}
return fac;
}
| int main() {
assert(func0(7) == 40);
assert(func0(5) == 20);
assert(func0(2) == 2);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
cmp $0x9,%edi
jg 1195 <func0+0x4c>
test %edi,%edi
jle 1190 <func0+0x47>
add $0x1,%edi
mov $0x1,%edx
mov $0x1,%eax
imul %edx,%eax
mov %eax,%ecx
cltq
imul $0x51eb851f,%rax,%rax
sar $0x25,%rax
mov %ecx,%esi
sar $0x1f,%esi
sub %esi,%eax
imul $0x64,%eax,%eax
sub %eax,%ecx
mov %ecx,%eax
add $0x1,%edx
cmp %edi,%edx
jne 1168 <func0+0x1f>
retq
mov $0x1,%eax
retq
| func0:
endbr64
mov eax, 0
cmp edi, 9
jg short locret_1195
test edi, edi
jle short loc_1190
add edi, 1
mov edx, 1
mov eax, 1
loc_1168:
imul eax, edx
mov ecx, eax
cdqe
imul rax, 51EB851Fh
sar rax, 25h
mov esi, ecx
sar esi, 1Fh
sub eax, esi
imul esi, eax, 64h ; 'd'
mov eax, ecx
sub eax, esi
add edx, 1
cmp edx, edi
jnz short loc_1168
retn
loc_1190:
mov eax, 1
locret_1195:
retn | long long func0(int a1)
{
long long result; // rax
int v2; // edi
int v3; // edx
result = 0LL;
if ( a1 <= 9 )
{
if ( a1 <= 0 )
{
return 1LL;
}
else
{
v2 = a1 + 1;
v3 = 1;
LODWORD(result) = 1;
do
{
result = (unsigned int)(v3 * (int)result % 100);
++v3;
}
while ( v3 != v2 );
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x0
CMP EDI,0x9
JG 0x00101195
TEST EDI,EDI
JLE 0x00101190
ADD EDI,0x1
MOV EDX,0x1
MOV EAX,0x1
LAB_00101168:
IMUL EAX,EDX
MOV ECX,EAX
CDQE
IMUL RAX,RAX,0x51eb851f
SAR RAX,0x25
MOV ESI,ECX
SAR ESI,0x1f
SUB EAX,ESI
IMUL ESI,EAX,0x64
MOV EAX,ECX
SUB EAX,ESI
ADD EDX,0x1
CMP EDX,EDI
JNZ 0x00101168
RET
LAB_00101190:
MOV EAX,0x1
LAB_00101195:
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
iVar1 = 0;
if (param_1 < 10) {
if (0 < param_1) {
iVar2 = 1;
iVar1 = 1;
do {
iVar1 = (iVar1 * iVar2) % 100;
iVar2 = iVar2 + 1;
} while (iVar2 != param_1 + 1);
return iVar1;
}
iVar1 = 1;
}
return iVar1;
} |
6,662 | func0 |
#include <assert.h>
| int func0(int N) {
if (N >= 10) {
return 0;
}
int fac = 1;
for (int i = 1; i <= N; i++) {
fac = (fac * i) % 100;
}
return fac;
}
| int main() {
assert(func0(7) == 40);
assert(func0(5) == 20);
assert(func0(2) == 2);
return 0;
}
| O2 | c | func0:
endbr64
xor %eax,%eax
cmp $0x9,%edi
jg 1205 <func0+0x55>
test %edi,%edi
jle 1200 <func0+0x50>
add $0x1,%edi
mov $0x1,%edx
mov $0x1,%eax
nopl 0x0(%rax)
imul %edx,%eax
add $0x1,%edx
mov %eax,%ecx
cltq
imul $0x51eb851f,%rax,%rax
mov %ecx,%esi
sar $0x1f,%esi
sar $0x25,%rax
sub %esi,%eax
imul $0x64,%eax,%eax
sub %eax,%ecx
mov %ecx,%eax
cmp %edi,%edx
jne 11d0 <func0+0x20>
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
xor eax, eax
cmp edi, 9
jg short locret_1205
test edi, edi
jle short loc_1200
add edi, 1
mov edx, 1
mov eax, 1
nop dword ptr [rax+00h]
loc_11D0:
imul eax, edx
add edx, 1
mov ecx, eax
cdqe
imul rax, 51EB851Fh
mov esi, ecx
sar esi, 1Fh
sar rax, 25h
sub eax, esi
imul esi, eax, 64h ; 'd'
mov eax, ecx
sub eax, esi
cmp edi, edx
jnz short loc_11D0
retn
loc_1200:
mov eax, 1
locret_1205:
retn | long long func0(int a1)
{
long long result; // rax
int v2; // edi
int v3; // edx
int v4; // eax
result = 0LL;
if ( a1 <= 9 )
{
if ( a1 <= 0 )
{
return 1LL;
}
else
{
v2 = a1 + 1;
v3 = 1;
LODWORD(result) = 1;
do
{
v4 = v3 * result;
++v3;
result = (unsigned int)(v4 % 100);
}
while ( v2 != v3 );
}
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP EDI,0x9
JG 0x00101205
TEST EDI,EDI
JLE 0x00101200
ADD EDI,0x1
MOV EDX,0x1
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_001011d0:
IMUL EAX,EDX
ADD EDX,0x1
MOV ECX,EAX
CDQE
IMUL RAX,RAX,0x51eb851f
MOV ESI,ECX
SAR ESI,0x1f
SAR RAX,0x25
SUB EAX,ESI
IMUL ESI,EAX,0x64
MOV EAX,ECX
SUB EAX,ESI
CMP EDI,EDX
JNZ 0x001011d0
RET
LAB_00101200:
MOV EAX,0x1
LAB_00101205:
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
iVar1 = 0;
if (param_1 < 10) {
if (0 < param_1) {
iVar2 = 1;
iVar1 = 1;
do {
iVar1 = iVar1 * iVar2;
iVar2 = iVar2 + 1;
iVar1 = iVar1 % 100;
} while (param_1 + 1 != iVar2);
return iVar1;
}
iVar1 = 1;
}
return iVar1;
} |
6,663 | func0 |
#include <assert.h>
| int func0(int N) {
if (N >= 10) {
return 0;
}
int fac = 1;
for (int i = 1; i <= N; i++) {
fac = (fac * i) % 100;
}
return fac;
}
| int main() {
assert(func0(7) == 40);
assert(func0(5) == 20);
assert(func0(2) == 2);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
cmp $0x9,%edi
jg 118d <func0+0x4d>
test %edi,%edi
jle 1188 <func0+0x48>
cmp $0x1,%edi
je 1188 <func0+0x48>
cmp $0x2,%edi
je 118e <func0+0x4e>
cmp $0x3,%edi
je 119e <func0+0x5e>
cmp $0x4,%edi
je 11a4 <func0+0x64>
cmp $0x5,%edi
je 1198 <func0+0x58>
cmp $0x6,%edi
je 1198 <func0+0x58>
cmp $0x7,%edi
je 11aa <func0+0x6a>
cmp $0x9,%edi
mov $0x14,%edx
mov $0x50,%eax
cmovne %edx,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
mov $0x2,%eax
retq
nopl 0x0(%rax)
mov $0x14,%eax
retq
mov $0x6,%eax
retq
mov $0x18,%eax
retq
mov $0x28,%eax
retq
| func0:
endbr64
xor eax, eax
cmp edi, 9
jg short locret_1185
test edi, edi
jle short loc_1180
cmp edi, 1
jz short loc_1180
cmp edi, 2
jz short loc_1186
cmp edi, 3
jz short loc_118C
cmp edi, 4
jz short loc_1192
cmp edi, 6
jle short loc_1198
cmp edi, 7
jz short loc_119E
cmp edi, 9
mov edx, 14h
mov eax, 50h ; 'P'
cmovnz eax, edx
retn
loc_1180:
mov eax, 1
locret_1185:
retn
loc_1186:
mov eax, 2
retn
loc_118C:
mov eax, 6
retn
loc_1192:
mov eax, 18h
retn
loc_1198:
mov eax, 14h
retn
loc_119E:
mov eax, 28h ; '('
retn | long long func0(int a1)
{
long long result; // rax
result = 0LL;
if ( a1 <= 9 )
{
if ( a1 < 2 )
{
return 1LL;
}
else
{
switch ( a1 )
{
case 2:
return 2LL;
case 3:
return 6LL;
case 4:
return 24LL;
default:
if ( a1 <= 6 )
{
return 20LL;
}
else if ( a1 == 7 )
{
return 40LL;
}
else
{
result = 80LL;
if ( a1 != 9 )
return 20LL;
}
break;
}
}
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP EDI,0x9
JG 0x00101185
TEST EDI,EDI
JLE 0x00101180
CMP EDI,0x1
JZ 0x00101180
CMP EDI,0x2
JZ 0x00101186
CMP EDI,0x3
JZ 0x0010118c
CMP EDI,0x4
JZ 0x00101192
CMP EDI,0x6
JLE 0x00101198
CMP EDI,0x7
JZ 0x0010119e
CMP EDI,0x9
MOV EDX,0x14
MOV EAX,0x50
CMOVNZ EAX,EDX
RET
LAB_00101180:
MOV EAX,0x1
LAB_00101185:
RET
LAB_00101186:
MOV EAX,0x2
RET
LAB_0010118c:
MOV EAX,0x6
RET
LAB_00101192:
MOV EAX,0x18
RET
LAB_00101198:
MOV EAX,0x14
RET
LAB_0010119e:
MOV EAX,0x28
RET | int8 func0(int param_1)
{
int8 uVar1;
uVar1 = 0;
if (param_1 < 10) {
if ((0 < param_1) && (param_1 != 1)) {
if (param_1 == 2) {
return 2;
}
if (param_1 == 3) {
return 6;
}
if (param_1 == 4) {
return 0x18;
}
if (6 < param_1) {
if (param_1 != 7) {
uVar1 = 0x50;
if (param_1 != 9) {
uVar1 = 0x14;
}
return uVar1;
}
return 0x28;
}
return 0x14;
}
uVar1 = 1;
}
return uVar1;
} |
6,664 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| char* func0(const char* text1) {
if (text1 == NULL) {
return NULL;
}
size_t len = strlen(text1);
char* result = malloc(len + 1);
if (result == NULL) {
return NULL;
}
size_t i = 0, j = 0;
int space_found = 0;
while (text1[i] != '\0') {
if (text1[i] != ' ') {
result[j++] = text1[i];
space_found = 0;
} else {
if (!space_found) {
result[j++] = ' ';
space_found = 1;
}
}
i++;
}
result[j] = '\0';
return result;
}
| int main() {
char* result;
result = func0("Google Assistant");
assert(result != NULL);
assert(strcmp(result, "Google Assistant") == 0);
free(result);
result = func0("Quad Core");
assert(result != NULL);
assert(strcmp(result, "Quad Core") == 0);
free(result);
result = func0("ChromeCast Built-in");
assert(result != NULL);
assert(strcmp(result, "ChromeCast Built-in") == 0);
free(result);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
cmpq $0x0,-0x38(%rbp)
jne 11ea <func0+0x21>
mov $0x0,%eax
jmpq 12c3 <func0+0xfa>
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 10a0 <strlen@plt>
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
add $0x1,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 121f <func0+0x56>
mov $0x0,%eax
jmpq 12c3 <func0+0xfa>
movq $0x0,-0x20(%rbp)
movq $0x0,-0x18(%rbp)
movl $0x0,-0x24(%rbp)
jmp 129f <func0+0xd6>
mov -0x38(%rbp),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
je 1277 <func0+0xae>
mov -0x38(%rbp),%rdx
mov -0x20(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x18(%rbp),%rax
lea 0x1(%rax),%rdx
mov %rdx,-0x18(%rbp)
mov -0x8(%rbp),%rdx
add %rax,%rdx
movzbl (%rcx),%eax
mov %al,(%rdx)
movl $0x0,-0x24(%rbp)
jmp 129a <func0+0xd1>
cmpl $0x0,-0x24(%rbp)
jne 129a <func0+0xd1>
mov -0x18(%rbp),%rax
lea 0x1(%rax),%rdx
mov %rdx,-0x18(%rbp)
mov -0x8(%rbp),%rdx
add %rdx,%rax
movb $0x20,(%rax)
movl $0x1,-0x24(%rbp)
addq $0x1,-0x20(%rbp)
mov -0x38(%rbp),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1238 <func0+0x6f>
mov -0x8(%rbp),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+s], rdi
cmp [rbp+s], 0
jnz short loc_11EA
mov eax, 0
jmp locret_12C3
loc_11EA:
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
add rax, 1
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jnz short loc_121F
mov eax, 0
jmp locret_12C3
loc_121F:
mov [rbp+var_20], 0
mov [rbp+var_18], 0
mov [rbp+var_24], 0
jmp short loc_129F
loc_1238:
mov rdx, [rbp+s]
mov rax, [rbp+var_20]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jz short loc_1277
mov rdx, [rbp+s]
mov rax, [rbp+var_20]
lea rcx, [rdx+rax]
mov rax, [rbp+var_18]
lea rdx, [rax+1]
mov [rbp+var_18], rdx
mov rdx, [rbp+var_8]
add rdx, rax
movzx eax, byte ptr [rcx]
mov [rdx], al
mov [rbp+var_24], 0
jmp short loc_129A
loc_1277:
cmp [rbp+var_24], 0
jnz short loc_129A
mov rax, [rbp+var_18]
lea rdx, [rax+1]
mov [rbp+var_18], rdx
mov rdx, [rbp+var_8]
add rax, rdx
mov byte ptr [rax], 20h ; ' '
mov [rbp+var_24], 1
loc_129A:
add [rbp+var_20], 1
loc_129F:
mov rdx, [rbp+s]
mov rax, [rbp+var_20]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1238
mov rdx, [rbp+var_8]
mov rax, [rbp+var_18]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
locret_12C3:
leave
retn | _BYTE * func0(const char *a1)
{
long long v2; // rax
long long v3; // rax
int v4; // [rsp+1Ch] [rbp-24h]
long long v5; // [rsp+20h] [rbp-20h]
long long v6; // [rsp+28h] [rbp-18h]
size_t v7; // [rsp+30h] [rbp-10h]
_BYTE *v8; // [rsp+38h] [rbp-8h]
if ( !a1 )
return 0LL;
v7 = strlen(a1);
v8 = malloc(v7 + 1);
if ( !v8 )
return 0LL;
v5 = 0LL;
v6 = 0LL;
v4 = 0;
while ( a1[v5] )
{
if ( a1[v5] == 32 )
{
if ( !v4 )
{
v3 = v6++;
v8[v3] = 32;
v4 = 1;
}
}
else
{
v2 = v6++;
v8[v2] = a1[v5];
v4 = 0;
}
++v5;
}
v8[v6] = 0;
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001011ea
MOV EAX,0x0
JMP 0x001012c3
LAB_001011ea:
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010a0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0010121f
MOV EAX,0x0
JMP 0x001012c3
LAB_0010121f:
MOV qword ptr [RBP + -0x20],0x0
MOV qword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0010129f
LAB_00101238:
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JZ 0x00101277
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[RDX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[RAX + 0x1]
MOV qword ptr [RBP + -0x18],RDX
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOVZX EAX,byte ptr [RCX]
MOV byte ptr [RDX],AL
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0010129a
LAB_00101277:
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x0010129a
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[RAX + 0x1]
MOV qword ptr [RBP + -0x18],RDX
MOV RDX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x20
MOV dword ptr [RBP + -0x24],0x1
LAB_0010129a:
ADD qword ptr [RBP + -0x20],0x1
LAB_0010129f:
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101238
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
LAB_001012c3:
LEAVE
RET | void * func0(char *param_1)
{
bool bVar1;
void *pvVar2;
size_t sVar3;
long local_28;
long local_20;
if (param_1 == (char *)0x0) {
pvVar2 = (void *)0x0;
}
else {
sVar3 = strlen(param_1);
pvVar2 = malloc(sVar3 + 1);
if (pvVar2 == (void *)0x0) {
pvVar2 = (void *)0x0;
}
else {
local_20 = 0;
bVar1 = false;
for (local_28 = 0; param_1[local_28] != '\0'; local_28 = local_28 + 1) {
if (param_1[local_28] == ' ') {
if (!bVar1) {
*(int *)(local_20 + (long)pvVar2) = 0x20;
bVar1 = true;
local_20 = local_20 + 1;
}
}
else {
*(char *)((long)pvVar2 + local_20) = param_1[local_28];
bVar1 = false;
local_20 = local_20 + 1;
}
}
*(int *)(local_20 + (long)pvVar2) = 0;
}
}
return pvVar2;
} |
6,665 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| char* func0(const char* text1) {
if (text1 == NULL) {
return NULL;
}
size_t len = strlen(text1);
char* result = malloc(len + 1);
if (result == NULL) {
return NULL;
}
size_t i = 0, j = 0;
int space_found = 0;
while (text1[i] != '\0') {
if (text1[i] != ' ') {
result[j++] = text1[i];
space_found = 0;
} else {
if (!space_found) {
result[j++] = ' ';
space_found = 1;
}
}
i++;
}
result[j] = '\0';
return result;
}
| int main() {
char* result;
result = func0("Google Assistant");
assert(result != NULL);
assert(strcmp(result, "Google Assistant") == 0);
free(result);
result = func0("Quad Core");
assert(result != NULL);
assert(strcmp(result, "Quad Core") == 0);
free(result);
result = func0("ChromeCast Built-in");
assert(result != NULL);
assert(strcmp(result, "ChromeCast Built-in") == 0);
free(result);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
test %rdi,%rdi
je 120e <func0+0x85>
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %rcx,%rdi
callq 1090 <malloc@plt>
test %rax,%rax
je 120c <func0+0x83>
movzbl (%rbx),%edx
test %dl,%dl
je 1203 <func0+0x7a>
lea 0x1(%rbx),%rdi
mov $0x0,%esi
mov $0x0,%ecx
mov $0x1,%r9d
mov $0x0,%r8d
jmp 11ed <func0+0x64>
mov %dl,(%rax,%rcx,1)
lea 0x1(%rcx),%rcx
mov %r8d,%esi
add $0x1,%rdi
movzbl -0x1(%rdi),%edx
test %dl,%dl
je 1208 <func0+0x7f>
cmp $0x20,%dl
jne 11d7 <func0+0x4e>
test %esi,%esi
jne 11e1 <func0+0x58>
movb $0x20,(%rax,%rcx,1)
lea 0x1(%rcx),%rcx
mov %r9d,%esi
jmp 11e1 <func0+0x58>
mov $0x0,%ecx
movb $0x0,(%rax,%rcx,1)
pop %rbx
retq
mov %rdi,%rax
jmp 120c <func0+0x83>
| func0:
endbr64
push rbx
mov rbx, rdi
test rdi, rdi
jz short loc_1243
call _strlen
lea rdi, [rax+1]
call _malloc
test rax, rax
jz short loc_1241
movzx edx, byte ptr [rbx]
test dl, dl
jz short loc_1238
lea rdi, [rbx+1]
mov esi, 0
mov ecx, 0
mov r9d, 1
mov r8d, 0
jmp short loc_1227
loc_120C:
test esi, esi
jnz short loc_121B
mov byte ptr [rax+rcx], 20h ; ' '
lea rcx, [rcx+1]
mov esi, r9d
loc_121B:
add rdi, 1
movzx edx, byte ptr [rdi-1]
test dl, dl
jz short loc_123D
loc_1227:
cmp dl, 20h ; ' '
jz short loc_120C
mov [rax+rcx], dl
lea rcx, [rcx+1]
mov esi, r8d
jmp short loc_121B
loc_1238:
mov ecx, 0
loc_123D:
mov byte ptr [rax+rcx], 0
loc_1241:
pop rbx
retn
loc_1243:
mov rax, rdi
jmp short loc_1241 | long long func0(char *a1)
{
long long v1; // rax
long long result; // rax
char v3; // dl
char *v4; // rdi
int v5; // esi
long long v6; // rcx
if ( !a1 )
return 0LL;
v1 = strlen();
result = malloc(v1 + 1);
if ( result )
{
v3 = *a1;
if ( *a1 )
{
v4 = a1 + 1;
v5 = 0;
v6 = 0LL;
do
{
if ( v3 == 32 )
{
if ( !v5 )
{
*(_BYTE *)(result + v6++) = 32;
v5 = 1;
}
}
else
{
*(_BYTE *)(result + v6++) = v3;
v5 = 0;
}
v3 = *v4++;
}
while ( v3 );
}
else
{
v6 = 0LL;
}
*(_BYTE *)(result + v6) = 0;
}
return result;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
TEST RDI,RDI
JZ 0x00101243
CALL 0x001010a0
LEA RDI,[RAX + 0x1]
CALL 0x001010d0
TEST RAX,RAX
JZ 0x00101241
MOVZX EDX,byte ptr [RBX]
TEST DL,DL
JZ 0x00101238
LEA RDI,[RBX + 0x1]
MOV ESI,0x0
MOV ECX,0x0
MOV R9D,0x1
MOV R8D,0x0
JMP 0x00101227
LAB_0010120c:
TEST ESI,ESI
JNZ 0x0010121b
MOV byte ptr [RAX + RCX*0x1],0x20
LEA RCX,[RCX + 0x1]
MOV ESI,R9D
LAB_0010121b:
ADD RDI,0x1
MOVZX EDX,byte ptr [RDI + -0x1]
TEST DL,DL
JZ 0x0010123d
LAB_00101227:
CMP DL,0x20
JZ 0x0010120c
MOV byte ptr [RAX + RCX*0x1],DL
LEA RCX,[RCX + 0x1]
MOV ESI,R8D
JMP 0x0010121b
LAB_00101238:
MOV ECX,0x0
LAB_0010123d:
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_00101241:
POP RBX
RET
LAB_00101243:
MOV RAX,RDI
JMP 0x00101241 | void * func0(char *param_1)
{
bool bVar1;
size_t sVar2;
void *pvVar3;
long lVar4;
char cVar5;
char *pcVar6;
if (param_1 == (char *)0x0) {
pvVar3 = (void *)0x0;
}
else {
sVar2 = strlen(param_1);
pvVar3 = malloc(sVar2 + 1);
if (pvVar3 != (void *)0x0) {
cVar5 = *param_1;
if (cVar5 == '\0') {
lVar4 = 0;
}
else {
bVar1 = false;
lVar4 = 0;
pcVar6 = param_1 + 1;
do {
if (cVar5 == ' ') {
if (!bVar1) {
*(int1 *)((long)pvVar3 + lVar4) = 0x20;
lVar4 = lVar4 + 1;
bVar1 = true;
}
}
else {
*(char *)((long)pvVar3 + lVar4) = cVar5;
lVar4 = lVar4 + 1;
bVar1 = false;
}
cVar5 = *pcVar6;
pcVar6 = pcVar6 + 1;
} while (cVar5 != '\0');
}
*(int1 *)((long)pvVar3 + lVar4) = 0;
}
}
return pvVar3;
} |
6,666 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| char* func0(const char* text1) {
if (text1 == NULL) {
return NULL;
}
size_t len = strlen(text1);
char* result = malloc(len + 1);
if (result == NULL) {
return NULL;
}
size_t i = 0, j = 0;
int space_found = 0;
while (text1[i] != '\0') {
if (text1[i] != ' ') {
result[j++] = text1[i];
space_found = 0;
} else {
if (!space_found) {
result[j++] = ' ';
space_found = 1;
}
}
i++;
}
result[j] = '\0';
return result;
}
| int main() {
char* result;
result = func0("Google Assistant");
assert(result != NULL);
assert(strcmp(result, "Google Assistant") == 0);
free(result);
result = func0("Quad Core");
assert(result != NULL);
assert(strcmp(result, "Quad Core") == 0);
free(result);
result = func0("ChromeCast Built-in");
assert(result != NULL);
assert(strcmp(result, "ChromeCast Built-in") == 0);
free(result);
return 0;
}
| O2 | c | func0:
endbr64
test %rdi,%rdi
je 13d0 <func0+0xa0>
push %rbx
mov %rdi,%rbx
callq 1090 <strlen@plt>
lea 0x1(%rax),%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 13bd <func0+0x8d>
movzbl (%rbx),%edx
test %dl,%dl
je 13c8 <func0+0x98>
lea 0x1(%rbx),%rdi
xor %r9d,%r9d
xor %esi,%esi
mov %rax,%rcx
jmp 138b <func0+0x5b>
nopl 0x0(%rax)
add $0x1,%rsi
mov %dl,(%rcx)
xor %r9d,%r9d
lea (%rax,%rsi,1),%rcx
mov %rcx,%r8
movzbl (%rdi),%edx
add $0x1,%rdi
test %dl,%dl
je 13b7 <func0+0x87>
mov %rcx,%r8
cmp $0x20,%dl
jne 1370 <func0+0x40>
test %r9d,%r9d
jne 1380 <func0+0x50>
add $0x1,%rsi
movzbl (%rdi),%edx
movb $0x20,(%rcx)
add $0x1,%rdi
lea (%rax,%rsi,1),%rcx
mov $0x1,%r9d
mov %rcx,%r8
test %dl,%dl
jne 138b <func0+0x5b>
movb $0x0,(%r8)
pop %rbx
retq
xor %eax,%eax
pop %rbx
retq
nopl 0x0(%rax)
mov %rax,%r8
jmp 13b7 <func0+0x87>
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test rdi, rdi
jz short loc_13B8
push rbx
mov rbx, rdi
call _strlen
lea rdi, [rax+1]
call _malloc
test rax, rax
jz short loc_13AB
movzx edx, byte ptr [rbx]
test dl, dl
jz short loc_13B0
lea rdi, [rbx+1]
xor r8d, r8d
xor ecx, ecx
mov rsi, rax
jmp short loc_1380
loc_1368:
add rcx, 1
mov [rsi], dl
xor r8d, r8d
lea rsi, [rax+rcx]
loc_1375:
movzx edx, byte ptr [rdi]
add rdi, 1
test dl, dl
jz short loc_13A6
loc_1380:
cmp dl, 20h ; ' '
jnz short loc_1368
test r8d, r8d
jnz short loc_1375
movzx edx, byte ptr [rdi]
add rcx, 1
mov byte ptr [rsi], 20h ; ' '
add rdi, 1
mov r8d, 1
lea rsi, [rax+rcx]
test dl, dl
jnz short loc_1380
loc_13A6:
mov byte ptr [rsi], 0
pop rbx
retn
loc_13AB:
xor eax, eax
pop rbx
retn
loc_13B0:
mov rsi, rax
jmp short loc_13A6
loc_13B8:
xor eax, eax
retn | long long func0(char *a1)
{
long long v1; // rax
long long result; // rax
char v3; // dl
char *v4; // rdi
int v5; // r8d
long long v6; // rcx
_BYTE *v7; // rsi
if ( !a1 )
return 0LL;
v1 = strlen();
result = malloc(v1 + 1);
if ( !result )
return 0LL;
v3 = *a1;
if ( *a1 )
{
v4 = a1 + 1;
v5 = 0;
v6 = 0LL;
v7 = (_BYTE *)result;
while ( 1 )
{
while ( v3 != 32 )
{
++v6;
*v7 = v3;
v5 = 0;
v7 = (_BYTE *)(result + v6);
LABEL_6:
v3 = *v4++;
if ( !v3 )
goto LABEL_10;
}
if ( v5 )
goto LABEL_6;
v3 = *v4;
++v6;
*v7 = 32;
++v4;
v5 = 1;
v7 = (_BYTE *)(result + v6);
if ( !v3 )
goto LABEL_10;
}
}
v7 = (_BYTE *)result;
LABEL_10:
*v7 = 0;
return result;
} | func0:
ENDBR64
TEST RDI,RDI
JZ 0x001013b8
PUSH RBX
MOV RBX,RDI
CALL 0x001010a0
LEA RDI,[RAX + 0x1]
CALL 0x001010d0
TEST RAX,RAX
JZ 0x001013ab
MOVZX EDX,byte ptr [RBX]
TEST DL,DL
JZ 0x001013b0
LEA RDI,[RBX + 0x1]
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RAX
JMP 0x00101380
LAB_00101368:
ADD RCX,0x1
MOV byte ptr [RSI],DL
XOR R8D,R8D
LEA RSI,[RAX + RCX*0x1]
LAB_00101375:
MOVZX EDX,byte ptr [RDI]
ADD RDI,0x1
TEST DL,DL
JZ 0x001013a6
LAB_00101380:
CMP DL,0x20
JNZ 0x00101368
TEST R8D,R8D
JNZ 0x00101375
MOVZX EDX,byte ptr [RDI]
ADD RCX,0x1
MOV byte ptr [RSI],0x20
ADD RDI,0x1
MOV R8D,0x1
LEA RSI,[RAX + RCX*0x1]
TEST DL,DL
JNZ 0x00101380
LAB_001013a6:
MOV byte ptr [RSI],0x0
POP RBX
RET
LAB_001013ab:
XOR EAX,EAX
POP RBX
RET
LAB_001013b0:
MOV RSI,RAX
JMP 0x001013a6
LAB_001013b8:
XOR EAX,EAX
RET | char * func0(char *param_1)
{
bool bVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
char cVar5;
char *pcVar6;
if (param_1 == (char *)0x0) {
return (char *)0x0;
}
sVar2 = strlen(param_1);
pcVar3 = (char *)malloc(sVar2 + 1);
if (pcVar3 == (char *)0x0) {
return (char *)0x0;
}
cVar5 = *param_1;
pcVar6 = pcVar3;
if (cVar5 != '\0') {
param_1 = param_1 + 1;
bVar1 = false;
lVar4 = 0;
do {
while (cVar5 != ' ') {
lVar4 = lVar4 + 1;
*pcVar6 = cVar5;
bVar1 = false;
pcVar6 = pcVar3 + lVar4;
LAB_00101375:
cVar5 = *param_1;
param_1 = param_1 + 1;
if (cVar5 == '\0') goto LAB_001013a6;
}
if (bVar1) goto LAB_00101375;
cVar5 = *param_1;
lVar4 = lVar4 + 1;
*pcVar6 = ' ';
param_1 = param_1 + 1;
bVar1 = true;
pcVar6 = pcVar3 + lVar4;
} while (cVar5 != '\0');
}
LAB_001013a6:
*pcVar6 = '\0';
return pcVar3;
} |
6,667 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
| char* func0(const char* text1) {
if (text1 == NULL) {
return NULL;
}
size_t len = strlen(text1);
char* result = malloc(len + 1);
if (result == NULL) {
return NULL;
}
size_t i = 0, j = 0;
int space_found = 0;
while (text1[i] != '\0') {
if (text1[i] != ' ') {
result[j++] = text1[i];
space_found = 0;
} else {
if (!space_found) {
result[j++] = ' ';
space_found = 1;
}
}
i++;
}
result[j] = '\0';
return result;
}
| int main() {
char* result;
result = func0("Google Assistant");
assert(result != NULL);
assert(strcmp(result, "Google Assistant") == 0);
free(result);
result = func0("Quad Core");
assert(result != NULL);
assert(strcmp(result, "Quad Core") == 0);
free(result);
result = func0("ChromeCast Built-in");
assert(result != NULL);
assert(strcmp(result, "ChromeCast Built-in") == 0);
free(result);
return 0;
}
| O3 | c | func0:
endbr64
test %rdi,%rdi
je 13d0 <func0+0xa0>
push %rbx
mov %rdi,%rbx
callq 1090 <strlen@plt>
lea 0x1(%rax),%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 13bd <func0+0x8d>
movzbl (%rbx),%edx
test %dl,%dl
je 13c8 <func0+0x98>
lea 0x1(%rbx),%rdi
xor %r9d,%r9d
xor %esi,%esi
mov %rax,%rcx
jmp 138b <func0+0x5b>
nopl 0x0(%rax)
add $0x1,%rsi
mov %dl,(%rcx)
xor %r9d,%r9d
lea (%rax,%rsi,1),%rcx
mov %rcx,%r8
movzbl (%rdi),%edx
add $0x1,%rdi
test %dl,%dl
je 13b7 <func0+0x87>
mov %rcx,%r8
cmp $0x20,%dl
jne 1370 <func0+0x40>
test %r9d,%r9d
jne 1380 <func0+0x50>
add $0x1,%rsi
movzbl (%rdi),%edx
movb $0x20,(%rcx)
add $0x1,%rdi
lea (%rax,%rsi,1),%rcx
mov $0x1,%r9d
mov %rcx,%r8
test %dl,%dl
jne 138b <func0+0x5b>
movb $0x0,(%r8)
pop %rbx
retq
xor %eax,%eax
pop %rbx
retq
nopl 0x0(%rax)
mov %rax,%r8
jmp 13b7 <func0+0x87>
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test rdi, rdi
jz short loc_13B8
push rbx
mov rbx, rdi
call _strlen
lea rdi, [rax+1]; size
call _malloc
test rax, rax
jz short loc_13AB
movzx edx, byte ptr [rbx]
test dl, dl
jz short loc_13B0
lea rdi, [rbx+1]
xor r8d, r8d
xor ecx, ecx
mov rsi, rax
jmp short loc_1380
loc_1368:
add rcx, 1
mov [rsi], dl
xor r8d, r8d
lea rsi, [rax+rcx]
loc_1375:
movzx edx, byte ptr [rdi]
add rdi, 1
test dl, dl
jz short loc_13A6
loc_1380:
cmp dl, 20h ; ' '
jnz short loc_1368
test r8d, r8d
jnz short loc_1375
movzx edx, byte ptr [rdi]
add rcx, 1
mov byte ptr [rsi], 20h ; ' '
add rdi, 1
mov r8d, 1
lea rsi, [rax+rcx]
test dl, dl
jnz short loc_1380
loc_13A6:
mov byte ptr [rsi], 0
pop rbx
retn
loc_13AB:
xor eax, eax
pop rbx
retn
loc_13B0:
mov rsi, rax
jmp short loc_13A6
loc_13B8:
xor eax, eax
retn | char * func0(const char *a1)
{
size_t v1; // rax
char *result; // rax
char v3; // dl
char *v4; // rdi
int v5; // r8d
long long v6; // rcx
char *v7; // rsi
if ( !a1 )
return 0LL;
v1 = strlen(a1);
result = (char *)malloc(v1 + 1);
if ( !result )
return 0LL;
v3 = *a1;
if ( *a1 )
{
v4 = (char *)(a1 + 1);
v5 = 0;
v6 = 0LL;
v7 = result;
while ( 1 )
{
while ( v3 != 32 )
{
++v6;
*v7 = v3;
v5 = 0;
v7 = &result[v6];
LABEL_6:
v3 = *v4++;
if ( !v3 )
goto LABEL_10;
}
if ( v5 )
goto LABEL_6;
v3 = *v4;
++v6;
*v7 = 32;
++v4;
v5 = 1;
v7 = &result[v6];
if ( !v3 )
goto LABEL_10;
}
}
v7 = result;
LABEL_10:
*v7 = 0;
return result;
} | func0:
ENDBR64
TEST RDI,RDI
JZ 0x001013b8
PUSH RBX
MOV RBX,RDI
CALL 0x001010a0
LEA RDI,[RAX + 0x1]
CALL 0x001010d0
TEST RAX,RAX
JZ 0x001013ab
MOVZX EDX,byte ptr [RBX]
TEST DL,DL
JZ 0x001013b0
LEA RDI,[RBX + 0x1]
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RAX
JMP 0x00101380
LAB_00101368:
ADD RCX,0x1
MOV byte ptr [RSI],DL
XOR R8D,R8D
LEA RSI,[RAX + RCX*0x1]
LAB_00101375:
MOVZX EDX,byte ptr [RDI]
ADD RDI,0x1
TEST DL,DL
JZ 0x001013a6
LAB_00101380:
CMP DL,0x20
JNZ 0x00101368
TEST R8D,R8D
JNZ 0x00101375
MOVZX EDX,byte ptr [RDI]
ADD RCX,0x1
MOV byte ptr [RSI],0x20
ADD RDI,0x1
MOV R8D,0x1
LEA RSI,[RAX + RCX*0x1]
TEST DL,DL
JNZ 0x00101380
LAB_001013a6:
MOV byte ptr [RSI],0x0
POP RBX
RET
LAB_001013ab:
XOR EAX,EAX
POP RBX
RET
LAB_001013b0:
MOV RSI,RAX
JMP 0x001013a6
LAB_001013b8:
XOR EAX,EAX
RET | char * func0(char *param_1)
{
bool bVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
char cVar5;
char *pcVar6;
if (param_1 == (char *)0x0) {
return (char *)0x0;
}
sVar2 = strlen(param_1);
pcVar3 = (char *)malloc(sVar2 + 1);
if (pcVar3 == (char *)0x0) {
return (char *)0x0;
}
cVar5 = *param_1;
pcVar6 = pcVar3;
if (cVar5 != '\0') {
param_1 = param_1 + 1;
bVar1 = false;
lVar4 = 0;
do {
while (cVar5 != ' ') {
lVar4 = lVar4 + 1;
*pcVar6 = cVar5;
bVar1 = false;
pcVar6 = pcVar3 + lVar4;
LAB_00101375:
cVar5 = *param_1;
param_1 = param_1 + 1;
if (cVar5 == '\0') goto LAB_001013a6;
}
if (bVar1) goto LAB_00101375;
cVar5 = *param_1;
lVar4 = lVar4 + 1;
*pcVar6 = ' ';
param_1 = param_1 + 1;
bVar1 = true;
pcVar6 = pcVar3 + lVar4;
} while (cVar5 != '\0');
}
LAB_001013a6:
*pcVar6 = '\0';
return pcVar3;
} |
6,668 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int cmpfunc(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
| int* func0(int** arrs, int sizes[], int n, int* res_size) {
int max_elements = 0;
for (int i = 0; i < n; ++i) {
max_elements += sizes[i];
}
int* buf = (int*)malloc(max_elements * sizeof(int));
int buf_len = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
int should_add = 1;
for (int k = 0; k < buf_len; ++k) {
if (buf[k] == arrs[i][j]) {
should_add = 0;
break;
}
}
if (should_add) {
buf[buf_len++] = arrs[i][j];
}
}
}
qsort(buf, buf_len, sizeof(int), cmpfunc);
*res_size = buf_len;
return buf;
}
| int main() {
int arr1_1[] = {5, 6, 7, 8};
int arr1_2[] = {10, 11, 7, 5};
int arr1_3[] = {6, 12, 10, 8};
int arr1_4[] = {1, 2, 5};
int* arrs1[] = {arr1_1, arr1_2, arr1_3, arr1_4};
int sizes1[] = {4, 4, 4, 3};
int res_size1;
int* result1 = func0(arrs1, sizes1, 4, &res_size1);
int expected1[] = {1, 2, 5, 6, 7, 8, 10, 11, 12};
assert(res_size1 == 9);
for (int i = 0; i < res_size1; ++i) {
assert(result1[i] == expected1[i]);
}
free(result1);
int arr2_1[] = {7, 1, 9, 4};
int arr2_2[] = {11, 21, 36, 14, 9};
int arr2_3[] = {4, 1, 21, 39, 47};
int arr2_4[] = {1, 32, 38};
int* arrs2[] = {arr2_1, arr2_2, arr2_3, arr2_4};
int sizes2[] = {4, 5, 5, 3};
int res_size2;
int* result2 = func0(arrs2, sizes2, 4, &res_size2);
int expected2[] = {1, 4, 7, 9, 11, 14, 21, 32, 36, 38, 39, 47};
assert(res_size2 == 12);
for (int i = 0; i < res_size2; ++i) {
assert(result2[i] == expected2[i]);
}
free(result2);
int arr3_1[] = {11, 13, 14, 17};
int arr3_2[] = {12, 11, 15, 18};
int arr3_3[] = {19, 21, 15, 36};
int arr3_4[] = {37, 36, 35};
int* arrs3[] = {arr3_1, arr3_2, arr3_3, arr3_4};
int sizes3[] = {4, 4, 4, 3};
int res_size3;
int* result3 = func0(arrs3, sizes3, 4, &res_size3);
int expected3[] = {11, 12, 13, 14, 15, 17, 18, 19, 21, 35, 36, 37};
assert(res_size3 == 12);
for (int i = 0; i < res_size3; ++i) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %edx,-0x44(%rbp)
mov %rcx,-0x50(%rbp)
movl $0x0,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
jmp 1233 <func0+0x48>
mov -0x20(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x24(%rbp)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x44(%rbp),%eax
jl 1216 <func0+0x2b>
mov -0x24(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
jmpq 1344 <func0+0x159>
movl $0x0,-0x14(%rbp)
jmpq 1321 <func0+0x136>
movl $0x1,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 12cc <func0+0xe1>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov (%rax),%rax
mov -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 12c8 <func0+0xdd>
movl $0x0,-0x10(%rbp)
jmp 12d4 <func0+0xe9>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 127f <func0+0x94>
cmpl $0x0,-0x10(%rbp)
je 131d <func0+0x132>
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
lea (%rax,%rdx,1),%rcx
mov -0x1c(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x1c(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
addl $0x1,-0x14(%rbp)
mov -0x18(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x14(%rbp)
jl 126f <func0+0x84>
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x44(%rbp),%eax
jl 1263 <func0+0x78>
mov -0x1c(%rbp),%eax
movslq %eax,%rsi
mov -0x8(%rbp),%rax
lea -0x198(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
mov -0x50(%rbp),%rax
mov -0x1c(%rbp),%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_44], edx
mov [rbp+var_50], rcx
mov [rbp+var_24], 0
mov [rbp+var_20], 0
jmp short loc_1233
loc_1216:
mov eax, [rbp+var_20]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rdx
mov eax, [rax]
add [rbp+var_24], eax
add [rbp+var_20], 1
loc_1233:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_44]
jl short loc_1216
mov eax, [rbp+var_24]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+base], rax
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
jmp loc_1344
loc_1263:
mov [rbp+var_14], 0
jmp loc_1321
loc_126F:
mov [rbp+var_10], 1
mov [rbp+var_C], 0
jmp short loc_12CC
loc_127F:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_18]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rcx
mov rax, [rax]
mov ecx, [rbp+var_14]
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_12C8
mov [rbp+var_10], 0
jmp short loc_12D4
loc_12C8:
add [rbp+var_C], 1
loc_12CC:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_127F
loc_12D4:
cmp [rbp+var_10], 0
jz short loc_131D
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_14]
movsxd rdx, edx
shl rdx, 2
lea rcx, [rax+rdx]
mov eax, [rbp+var_1C]
lea edx, [rax+1]
mov [rbp+var_1C], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+base]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
loc_131D:
add [rbp+var_14], 1
loc_1321:
mov eax, [rbp+var_18]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_40]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_14], eax
jl loc_126F
add [rbp+var_18], 1
loc_1344:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_44]
jl loc_1263
mov eax, [rbp+var_1C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, cmpfunc
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
mov rax, [rbp+var_50]
mov edx, [rbp+var_1C]
mov [rax], edx
mov rax, [rbp+base]
leave
retn | _DWORD * func0(long long a1, long long a2, int a3, _DWORD *a4)
{
int v4; // eax
int v8; // [rsp+2Ch] [rbp-24h]
int i; // [rsp+30h] [rbp-20h]
int v10; // [rsp+34h] [rbp-1Ch]
int j; // [rsp+38h] [rbp-18h]
int k; // [rsp+3Ch] [rbp-14h]
int v13; // [rsp+40h] [rbp-10h]
int m; // [rsp+44h] [rbp-Ch]
_DWORD *base; // [rsp+48h] [rbp-8h]
v8 = 0;
for ( i = 0; i < a3; ++i )
v8 += *(_DWORD *)(4LL * i + a2);
base = malloc(4LL * v8);
v10 = 0;
for ( j = 0; j < a3; ++j )
{
for ( k = 0; k < *(_DWORD *)(4LL * j + a2); ++k )
{
v13 = 1;
for ( m = 0; m < v10; ++m )
{
if ( base[m] == *(_DWORD *)(4LL * k + *(_QWORD *)(8LL * j + a1)) )
{
v13 = 0;
break;
}
}
if ( v13 )
{
v4 = v10++;
base[v4] = *(_DWORD *)(*(_QWORD *)(8LL * j + a1) + 4LL * k);
}
}
}
qsort(base, v10, 4uLL, cmpfunc);
*a4 = v10;
return base;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV dword ptr [RBP + -0x44],EDX
MOV qword ptr [RBP + -0x50],RCX
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101233
LAB_00101216:
MOV EAX,dword ptr [RBP + -0x20]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x24],EAX
ADD dword ptr [RBP + -0x20],0x1
LAB_00101233:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x00101216
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101344
LAB_00101263:
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101321
LAB_0010126f:
MOV dword ptr [RBP + -0x10],0x1
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012cc
LAB_0010127f:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x14]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001012c8
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001012d4
LAB_001012c8:
ADD dword ptr [RBP + -0xc],0x1
LAB_001012cc:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010127f
LAB_001012d4:
CMP dword ptr [RBP + -0x10],0x0
JZ 0x0010131d
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
SHL RDX,0x2
LEA RCX,[RAX + RDX*0x1]
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x1c],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
LAB_0010131d:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101321:
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x14],EAX
JL 0x0010126f
ADD dword ptr [RBP + -0x18],0x1
LAB_00101344:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x00101263
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x50]
MOV EDX,dword ptr [RBP + -0x1c]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,long param_2,int param_3,int *param_4)
{
bool bVar1;
void *__base;
int local_2c;
int local_28;
int local_24;
int local_20;
int local_1c;
int local_14;
local_2c = 0;
for (local_28 = 0; local_28 < param_3; local_28 = local_28 + 1) {
local_2c = local_2c + *(int *)(param_2 + (long)local_28 * 4);
}
__base = malloc((long)local_2c << 2);
local_24 = 0;
local_20 = 0;
do {
if (param_3 <= local_20) {
qsort(__base,(long)local_24,4,cmpfunc);
*param_4 = local_24;
return __base;
}
for (local_1c = 0; local_1c < *(int *)(param_2 + (long)local_20 * 4); local_1c = local_1c + 1) {
bVar1 = true;
for (local_14 = 0; local_14 < local_24; local_14 = local_14 + 1) {
if (*(int *)((long)__base + (long)local_14 * 4) ==
*(int *)(*(long *)(param_1 + (long)local_20 * 8) + (long)local_1c * 4)) {
bVar1 = false;
break;
}
}
if (bVar1) {
*(int4 *)((long)local_24 * 4 + (long)__base) =
*(int4 *)(*(long *)(param_1 + (long)local_20 * 8) + (long)local_1c * 4);
local_24 = local_24 + 1;
}
}
local_20 = local_20 + 1;
} while( true );
} |
6,669 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int cmpfunc(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
| int* func0(int** arrs, int sizes[], int n, int* res_size) {
int max_elements = 0;
for (int i = 0; i < n; ++i) {
max_elements += sizes[i];
}
int* buf = (int*)malloc(max_elements * sizeof(int));
int buf_len = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
int should_add = 1;
for (int k = 0; k < buf_len; ++k) {
if (buf[k] == arrs[i][j]) {
should_add = 0;
break;
}
}
if (should_add) {
buf[buf_len++] = arrs[i][j];
}
}
}
qsort(buf, buf_len, sizeof(int), cmpfunc);
*res_size = buf_len;
return buf;
}
| int main() {
int arr1_1[] = {5, 6, 7, 8};
int arr1_2[] = {10, 11, 7, 5};
int arr1_3[] = {6, 12, 10, 8};
int arr1_4[] = {1, 2, 5};
int* arrs1[] = {arr1_1, arr1_2, arr1_3, arr1_4};
int sizes1[] = {4, 4, 4, 3};
int res_size1;
int* result1 = func0(arrs1, sizes1, 4, &res_size1);
int expected1[] = {1, 2, 5, 6, 7, 8, 10, 11, 12};
assert(res_size1 == 9);
for (int i = 0; i < res_size1; ++i) {
assert(result1[i] == expected1[i]);
}
free(result1);
int arr2_1[] = {7, 1, 9, 4};
int arr2_2[] = {11, 21, 36, 14, 9};
int arr2_3[] = {4, 1, 21, 39, 47};
int arr2_4[] = {1, 32, 38};
int* arrs2[] = {arr2_1, arr2_2, arr2_3, arr2_4};
int sizes2[] = {4, 5, 5, 3};
int res_size2;
int* result2 = func0(arrs2, sizes2, 4, &res_size2);
int expected2[] = {1, 4, 7, 9, 11, 14, 21, 32, 36, 38, 39, 47};
assert(res_size2 == 12);
for (int i = 0; i < res_size2; ++i) {
assert(result2[i] == expected2[i]);
}
free(result2);
int arr3_1[] = {11, 13, 14, 17};
int arr3_2[] = {12, 11, 15, 18};
int arr3_3[] = {19, 21, 15, 36};
int arr3_4[] = {37, 36, 35};
int* arrs3[] = {arr3_1, arr3_2, arr3_3, arr3_4};
int sizes3[] = {4, 4, 4, 3};
int res_size3;
int* result3 = func0(arrs3, sizes3, 4, &res_size3);
int expected3[] = {11, 12, 13, 14, 15, 17, 18, 19, 21, 35, 36, 37};
assert(res_size3 == 12);
for (int i = 0; i < res_size3; ++i) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rcx,%r14
test %edx,%edx
jle 1294 <func0+0xc2>
mov %rdi,%rbx
mov %rsi,%rax
mov %rsi,%r12
lea -0x1(%rdx),%r13d
lea 0x4(%rsi,%r13,4),%rcx
mov $0x0,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1200 <func0+0x2e>
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rdi
callq 10d0 <malloc@plt>
mov %rax,%rbp
mov %rbx,%rdi
lea 0x8(%rbx,%r13,8),%r10
mov $0x0,%ebx
lea 0x4(%rax),%r9
jmp 123e <func0+0x6c>
add $0x4,%r12
add $0x8,%rdi
cmp %r10,%rdi
je 12a6 <func0+0xd4>
mov (%r12),%eax
test %eax,%eax
jle 1231 <func0+0x5f>
lea -0x1(%rax),%eax
lea 0x4(,%rax,4),%r8
mov $0x0,%esi
jmp 1271 <func0+0x9f>
mov (%rdi),%rax
mov (%rax,%rsi,1),%edx
movslq %ebx,%rax
mov %edx,0x0(%rbp,%rax,4)
lea 0x1(%rbx),%ebx
add $0x4,%rsi
cmp %r8,%rsi
je 1231 <func0+0x5f>
test %ebx,%ebx
jle 1258 <func0+0x86>
mov (%rdi),%rax
mov (%rax,%rsi,1),%edx
mov %rbp,%rax
lea -0x1(%rbx),%ecx
lea (%r9,%rcx,4),%rcx
cmp %edx,(%rax)
je 1268 <func0+0x96>
add $0x4,%rax
cmp %rax,%rcx
jne 1285 <func0+0xb3>
jmp 1258 <func0+0x86>
mov $0x0,%edi
callq 10d0 <malloc@plt>
mov %rax,%rbp
mov $0x0,%ebx
movslq %ebx,%rsi
lea -0xe7(%rip),%rcx
mov $0x4,%edx
mov %rbp,%rdi
callq 10a0 <qsort@plt>
mov %ebx,(%r14)
mov %rbp,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rcx
test edx, edx
jle loc_1293
mov r12, rdi
mov r13, rsi
mov ebx, edx
mov rax, rsi
lea edx, [rdx-1]
lea rcx, [rsi+rdx*4+4]
mov edx, 0
loc_1201:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1201
movsxd rdx, edx
lea rdi, ds:0[rdx*4]
call _malloc
mov rbp, rax
mov r10d, ebx
mov edi, 0
mov ebx, 0
lea r9, [rax+4]
jmp short loc_123B
loc_1232:
add rdi, 1
cmp rdi, r10
jz short loc_12A5
loc_123B:
mov eax, [r13+rdi*4+0]
test eax, eax
jle short loc_1232
mov eax, eax
lea r8, ds:0[rax*4]
mov esi, 0
jmp short loc_126F
loc_1255:
mov rax, [r12+rdi*8]
mov edx, [rax+rsi]
movsxd rax, ebx
mov [rbp+rax*4+0], edx
lea ebx, [rbx+1]
loc_1266:
add rsi, 4
cmp rsi, r8
jz short loc_1232
loc_126F:
test ebx, ebx
jle short loc_1255
mov rax, [r12+rdi*8]
mov edx, [rax+rsi]
mov rax, rbp
lea ecx, [rbx-1]
lea rcx, [r9+rcx*4]
loc_1284:
cmp [rax], edx
jz short loc_1266
add rax, 4
cmp rcx, rax
jnz short loc_1284
jmp short loc_1255
loc_1293:
mov edi, 0
call _malloc
mov rbp, rax
mov ebx, 0
loc_12A5:
movsxd rsi, ebx
lea rcx, cmpfunc
mov edx, 4
mov rdi, rbp
call _qsort
mov [r14], ebx
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, _DWORD *a2, int a3, int *a4)
{
_DWORD *v8; // rax
long long v9; // rcx
int v10; // edx
long long v11; // rbp
long long v12; // r8
long long v13; // r10
long long v14; // rdi
int v15; // ebx
long long v16; // r9
int v17; // eax
long long v18; // rsi
_DWORD *v19; // rax
if ( a3 <= 0 )
{
v11 = malloc(0LL);
v15 = 0;
}
else
{
v8 = a2;
v9 = (long long)&a2[a3 - 1 + 1];
v10 = 0;
do
v10 += *v8++;
while ( v8 != (_DWORD *)v9 );
v11 = malloc(4LL * v10);
v13 = (unsigned int)a3;
v14 = 0LL;
v15 = 0;
v16 = v11 + 4;
do
{
v17 = a2[v14];
if ( v17 > 0 )
{
v12 = 4LL * (unsigned int)v17;
v18 = 0LL;
do
{
if ( v15 <= 0 )
{
LABEL_8:
*(_DWORD *)(v11 + 4LL * v15++) = *(_DWORD *)(*(_QWORD *)(a1 + 8 * v14) + v18);
}
else
{
v19 = (_DWORD *)v11;
while ( *v19 != *(_DWORD *)(*(_QWORD *)(a1 + 8 * v14) + v18) )
{
if ( (_DWORD *)(v16 + 4LL * (unsigned int)(v15 - 1)) == ++v19 )
goto LABEL_8;
}
}
v18 += 4LL;
}
while ( v18 != v12 );
}
++v14;
}
while ( v14 != v13 );
}
qsort(v11, v15, 4LL, cmpfunc, v12, v16);
*a4 = v15;
return v11;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RCX
TEST EDX,EDX
JLE 0x00101293
MOV R12,RDI
MOV R13,RSI
MOV EBX,EDX
MOV RAX,RSI
LEA EDX,[RDX + -0x1]
LEA RCX,[RSI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101201:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101201
MOVSXD RDX,EDX
LEA RDI,[RDX*0x4]
CALL 0x001010d0
MOV RBP,RAX
MOV R10D,EBX
MOV EDI,0x0
MOV EBX,0x0
LEA R9,[RAX + 0x4]
JMP 0x0010123b
LAB_00101232:
ADD RDI,0x1
CMP RDI,R10
JZ 0x001012a5
LAB_0010123b:
MOV EAX,dword ptr [R13 + RDI*0x4]
TEST EAX,EAX
JLE 0x00101232
MOV EAX,EAX
LEA R8,[RAX*0x4]
MOV ESI,0x0
JMP 0x0010126f
LAB_00101255:
MOV RAX,qword ptr [R12 + RDI*0x8]
MOV EDX,dword ptr [RAX + RSI*0x1]
MOVSXD RAX,EBX
MOV dword ptr [RBP + RAX*0x4],EDX
LEA EBX,[RBX + 0x1]
LAB_00101266:
ADD RSI,0x4
CMP RSI,R8
JZ 0x00101232
LAB_0010126f:
TEST EBX,EBX
JLE 0x00101255
MOV RAX,qword ptr [R12 + RDI*0x8]
MOV EDX,dword ptr [RAX + RSI*0x1]
MOV RAX,RBP
LEA ECX,[RBX + -0x1]
LEA RCX,[R9 + RCX*0x4]
LAB_00101284:
CMP dword ptr [RAX],EDX
JZ 0x00101266
ADD RAX,0x4
CMP RCX,RAX
JNZ 0x00101284
JMP 0x00101255
LAB_00101293:
MOV EDI,0x0
CALL 0x001010d0
MOV RBP,RAX
MOV EBX,0x0
LAB_001012a5:
MOVSXD RSI,EBX
LEA RCX,[0x1011c9]
MOV EDX,0x4
MOV RDI,RBP
CALL 0x001010a0
MOV dword ptr [R14],EBX
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | int * func0(long param_1,int *param_2,uint param_3,int *param_4)
{
uint uVar1;
int *piVar2;
int *piVar3;
int iVar4;
long lVar5;
ulong uVar6;
if ((int)param_3 < 1) {
piVar2 = (int *)malloc(0);
iVar4 = 0;
}
else {
iVar4 = 0;
piVar2 = param_2;
do {
iVar4 = iVar4 + *piVar2;
piVar2 = piVar2 + 1;
} while (piVar2 != param_2 + (ulong)(param_3 - 1) + 1);
piVar2 = (int *)malloc((long)iVar4 * 4);
uVar6 = 0;
iVar4 = 0;
do {
uVar1 = param_2[uVar6];
if (0 < (int)uVar1) {
lVar5 = 0;
do {
if (0 < iVar4) {
piVar3 = piVar2;
do {
if (*piVar3 == *(int *)(*(long *)(param_1 + uVar6 * 8) + lVar5)) goto LAB_00101266;
piVar3 = piVar3 + 1;
} while (piVar2 + (ulong)(iVar4 - 1) + 1 != piVar3);
}
piVar2[iVar4] = *(int *)(*(long *)(param_1 + uVar6 * 8) + lVar5);
iVar4 = iVar4 + 1;
LAB_00101266:
lVar5 = lVar5 + 4;
} while (lVar5 != (ulong)uVar1 * 4);
}
uVar6 = uVar6 + 1;
} while (uVar6 != param_3);
}
qsort(piVar2,(long)iVar4,4,cmpfunc);
*param_4 = iVar4;
return piVar2;
} |
6,670 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int cmpfunc(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
| int* func0(int** arrs, int sizes[], int n, int* res_size) {
int max_elements = 0;
for (int i = 0; i < n; ++i) {
max_elements += sizes[i];
}
int* buf = (int*)malloc(max_elements * sizeof(int));
int buf_len = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
int should_add = 1;
for (int k = 0; k < buf_len; ++k) {
if (buf[k] == arrs[i][j]) {
should_add = 0;
break;
}
}
if (should_add) {
buf[buf_len++] = arrs[i][j];
}
}
}
qsort(buf, buf_len, sizeof(int), cmpfunc);
*res_size = buf_len;
return buf;
}
| int main() {
int arr1_1[] = {5, 6, 7, 8};
int arr1_2[] = {10, 11, 7, 5};
int arr1_3[] = {6, 12, 10, 8};
int arr1_4[] = {1, 2, 5};
int* arrs1[] = {arr1_1, arr1_2, arr1_3, arr1_4};
int sizes1[] = {4, 4, 4, 3};
int res_size1;
int* result1 = func0(arrs1, sizes1, 4, &res_size1);
int expected1[] = {1, 2, 5, 6, 7, 8, 10, 11, 12};
assert(res_size1 == 9);
for (int i = 0; i < res_size1; ++i) {
assert(result1[i] == expected1[i]);
}
free(result1);
int arr2_1[] = {7, 1, 9, 4};
int arr2_2[] = {11, 21, 36, 14, 9};
int arr2_3[] = {4, 1, 21, 39, 47};
int arr2_4[] = {1, 32, 38};
int* arrs2[] = {arr2_1, arr2_2, arr2_3, arr2_4};
int sizes2[] = {4, 5, 5, 3};
int res_size2;
int* result2 = func0(arrs2, sizes2, 4, &res_size2);
int expected2[] = {1, 4, 7, 9, 11, 14, 21, 32, 36, 38, 39, 47};
assert(res_size2 == 12);
for (int i = 0; i < res_size2; ++i) {
assert(result2[i] == expected2[i]);
}
free(result2);
int arr3_1[] = {11, 13, 14, 17};
int arr3_2[] = {12, 11, 15, 18};
int arr3_3[] = {19, 21, 15, 36};
int arr3_4[] = {37, 36, 35};
int* arrs3[] = {arr3_1, arr3_2, arr3_3, arr3_4};
int sizes3[] = {4, 4, 4, 3};
int res_size3;
int* result3 = func0(arrs3, sizes3, 4, &res_size3);
int expected3[] = {11, 12, 13, 14, 15, 17, 18, 19, 21, 35, 36, 37};
assert(res_size3 == 12);
for (int i = 0; i < res_size3; ++i) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
test %edx,%edx
jle 1890 <func0+0x100>
mov %edx,%eax
mov %rdi,%rbx
mov %rsi,%r13
xor %edx,%edx
sub $0x1,%eax
lea 0x4(%rsi,%rax,4),%r14
mov %rsi,%rax
nopl 0x0(%rax)
add (%rax),%edx
add $0x4,%rax
cmp %r14,%rax
jne 17c0 <func0+0x30>
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rdi
callq 10d0 <malloc@plt>
mov %rbx,%r10
xor %ebx,%ebx
mov %rax,%r12
lea 0x4(%rax),%r9
nopw 0x0(%rax,%rax,1)
mov 0x0(%r13),%eax
test %eax,%eax
jle 183e <func0+0xae>
sub $0x1,%eax
mov (%r10),%rdi
xor %esi,%esi
lea 0x4(,%rax,4),%r8
nopl 0x0(%rax,%rax,1)
test %ebx,%ebx
je 1878 <func0+0xe8>
lea -0x1(%rbx),%ecx
mov (%rdi,%rsi,1),%edx
mov %r12,%rax
lea (%r9,%rcx,4),%rcx
jmp 1831 <func0+0xa1>
nopl 0x0(%rax,%rax,1)
add $0x4,%rax
cmp %rax,%rcx
je 1878 <func0+0xe8>
cmp %edx,(%rax)
jne 1828 <func0+0x98>
add $0x4,%rsi
cmp %rsi,%r8
jne 1810 <func0+0x80>
add $0x4,%r13
add $0x8,%r10
cmp %r14,%r13
jne 17f0 <func0+0x60>
movslq %ebx,%rsi
mov %r12,%rdi
lea -0xd8(%rip),%rcx
mov $0x4,%edx
callq 10a0 <qsort@plt>
mov %ebx,0x0(%rbp)
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
mov (%rdi,%rsi,1),%edx
movslq %ebx,%rax
add $0x4,%rsi
add $0x1,%ebx
mov %edx,(%r12,%rax,4)
cmp %rsi,%r8
jne 1810 <func0+0x80>
jmp 183e <func0+0xae>
xor %edi,%edi
xor %ebx,%ebx
callq 10d0 <malloc@plt>
xor %esi,%esi
mov %rax,%r12
jmp 184e <func0+0xbe>
| func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rcx
push rbx
test edx, edx
jle loc_1889
mov ebx, edx
lea edx, [rdx-1]
mov r12, rdi
mov r13, rsi
lea rcx, [rsi+rdx*4+4]
mov rax, rsi
xor edx, edx
nop dword ptr [rax+00h]
loc_17C0:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_17C0
movsxd rdx, edx
lea rdi, ds:0[rdx*4]
call _malloc
mov r11d, ebx
xor r10d, r10d
xor ebx, ebx
mov r14, rax
lea r9, [rax+4]
nop word ptr [rax+rax+00h]
loc_17F0:
movsxd rax, dword ptr [r13+r10*4+0]
test eax, eax
jle short loc_183E
mov r8, [r12+r10*8]
lea rdi, ds:0[rax*4]
xor esi, esi
nop word ptr [rax+rax+00000000h]
loc_1810:
test ebx, ebx
jz short loc_1870
lea ecx, [rbx-1]
mov edx, [r8+rsi]
mov rax, r14
lea rcx, [r9+rcx*4]
jmp short loc_1831
loc_1828:
add rax, 4
cmp rcx, rax
jz short loc_1870
loc_1831:
cmp [rax], edx
jnz short loc_1828
add rsi, 4
cmp rdi, rsi
jnz short loc_1810
loc_183E:
add r10, 1
cmp r10, r11
jnz short loc_17F0
movsxd rsi, ebx
loc_184A:
mov rdi, r14
lea rcx, cmpfunc
mov edx, 4
call _qsort
mov [rbp+0], ebx
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1870:
mov edx, [r8+rsi]
movsxd rax, ebx
add rsi, 4
add ebx, 1
mov [r14+rax*4], edx
cmp rdi, rsi
jnz short loc_1810
jmp short loc_183E
loc_1889:
xor edi, edi
xor ebx, ebx
call _malloc
xor esi, esi
mov r14, rax
jmp short loc_184A | long long func0(long long a1, _DWORD *a2, int a3, _DWORD *a4)
{
long long v8; // rcx
_DWORD *v9; // rax
int v10; // edx
long long v11; // rax
long long v12; // r8
long long v13; // r11
long long v14; // r10
int v15; // ebx
long long v16; // r14
long long v17; // r9
long long v18; // rax
long long v19; // rdi
long long v20; // rsi
_DWORD *v21; // rax
long long v22; // rsi
int v24; // edx
long long v25; // rax
if ( a3 <= 0 )
{
v15 = 0;
v22 = 0LL;
v16 = malloc(0LL);
}
else
{
v8 = (long long)&a2[a3 - 1 + 1];
v9 = a2;
v10 = 0;
do
v10 += *v9++;
while ( v9 != (_DWORD *)v8 );
v11 = malloc(4LL * v10);
v13 = (unsigned int)a3;
v14 = 0LL;
v15 = 0;
v16 = v11;
v17 = v11 + 4;
do
{
v18 = (int)a2[v14];
if ( (int)v18 > 0 )
{
v12 = *(_QWORD *)(a1 + 8 * v14);
v19 = 4 * v18;
v20 = 0LL;
do
{
while ( !v15 )
{
LABEL_15:
v24 = *(_DWORD *)(v12 + v20);
v25 = v15;
v20 += 4LL;
++v15;
*(_DWORD *)(v16 + 4 * v25) = v24;
if ( v19 == v20 )
goto LABEL_12;
}
v21 = (_DWORD *)v16;
while ( *v21 != *(_DWORD *)(v12 + v20) )
{
if ( (_DWORD *)(v17 + 4LL * (unsigned int)(v15 - 1)) == ++v21 )
goto LABEL_15;
}
v20 += 4LL;
}
while ( v19 != v20 );
}
LABEL_12:
++v14;
}
while ( v14 != v13 );
v22 = v15;
}
qsort(v16, v22, 4LL, cmpfunc, v12, v17);
*a4 = v15;
return v16;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RCX
PUSH RBX
TEST EDX,EDX
JLE 0x00101889
MOV EBX,EDX
LEA EDX,[RDX + -0x1]
MOV R12,RDI
MOV R13,RSI
LEA RCX,[RSI + RDX*0x4 + 0x4]
MOV RAX,RSI
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_001017c0:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001017c0
MOVSXD RDX,EDX
LEA RDI,[RDX*0x4]
CALL 0x001010d0
MOV R11D,EBX
XOR R10D,R10D
XOR EBX,EBX
MOV R14,RAX
LEA R9,[RAX + 0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_001017f0:
MOVSXD RAX,dword ptr [R13 + R10*0x4]
TEST EAX,EAX
JLE 0x0010183e
MOV R8,qword ptr [R12 + R10*0x8]
LEA RDI,[RAX*0x4]
XOR ESI,ESI
NOP word ptr [RAX + RAX*0x1]
LAB_00101810:
TEST EBX,EBX
JZ 0x00101870
LEA ECX,[RBX + -0x1]
MOV EDX,dword ptr [R8 + RSI*0x1]
MOV RAX,R14
LEA RCX,[R9 + RCX*0x4]
JMP 0x00101831
LAB_00101828:
ADD RAX,0x4
CMP RCX,RAX
JZ 0x00101870
LAB_00101831:
CMP dword ptr [RAX],EDX
JNZ 0x00101828
ADD RSI,0x4
CMP RDI,RSI
JNZ 0x00101810
LAB_0010183e:
ADD R10,0x1
CMP R10,R11
JNZ 0x001017f0
MOVSXD RSI,EBX
LAB_0010184a:
MOV RDI,R14
LEA RCX,[0x101780]
MOV EDX,0x4
CALL 0x001010a0
MOV dword ptr [RBP],EBX
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101870:
MOV EDX,dword ptr [R8 + RSI*0x1]
MOVSXD RAX,EBX
ADD RSI,0x4
ADD EBX,0x1
MOV dword ptr [R14 + RAX*0x4],EDX
CMP RDI,RSI
JNZ 0x00101810
JMP 0x0010183e
LAB_00101889:
XOR EDI,EDI
XOR EBX,EBX
CALL 0x001010d0
XOR ESI,ESI
MOV R14,RAX
JMP 0x0010184a | int * func0(long param_1,int *param_2,uint param_3,int *param_4)
{
int iVar1;
long lVar2;
int *piVar3;
int *piVar4;
int iVar5;
long lVar6;
long lVar7;
size_t __nmemb;
ulong uVar8;
if ((int)param_3 < 1) {
iVar5 = 0;
piVar3 = (int *)malloc(0);
__nmemb = 0;
}
else {
iVar5 = 0;
piVar3 = param_2;
do {
iVar5 = iVar5 + *piVar3;
piVar3 = piVar3 + 1;
} while (piVar3 != param_2 + (ulong)(param_3 - 1) + 1);
piVar3 = (int *)malloc((long)iVar5 * 4);
uVar8 = 0;
iVar5 = 0;
do {
iVar1 = param_2[uVar8];
if (0 < iVar1) {
lVar2 = *(long *)(param_1 + uVar8 * 8);
lVar6 = 0;
do {
if (iVar5 != 0) {
piVar4 = piVar3;
do {
if (*piVar4 == *(int *)(lVar2 + lVar6)) goto joined_r0x0010183c;
piVar4 = piVar4 + 1;
} while (piVar3 + (ulong)(iVar5 - 1) + 1 != piVar4);
}
lVar7 = (long)iVar5;
iVar5 = iVar5 + 1;
piVar3[lVar7] = *(int *)(lVar2 + lVar6);
joined_r0x0010183c:
lVar7 = lVar6 + 4;
lVar6 = lVar6 + 4;
} while ((long)iVar1 * 4 - lVar7 != 0);
}
uVar8 = uVar8 + 1;
} while (uVar8 != param_3);
__nmemb = (size_t)iVar5;
}
qsort(piVar3,__nmemb,4,cmpfunc);
*param_4 = iVar5;
return piVar3;
} |
6,671 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int cmpfunc(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
| int* func0(int** arrs, int sizes[], int n, int* res_size) {
int max_elements = 0;
for (int i = 0; i < n; ++i) {
max_elements += sizes[i];
}
int* buf = (int*)malloc(max_elements * sizeof(int));
int buf_len = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
int should_add = 1;
for (int k = 0; k < buf_len; ++k) {
if (buf[k] == arrs[i][j]) {
should_add = 0;
break;
}
}
if (should_add) {
buf[buf_len++] = arrs[i][j];
}
}
}
qsort(buf, buf_len, sizeof(int), cmpfunc);
*res_size = buf_len;
return buf;
}
| int main() {
int arr1_1[] = {5, 6, 7, 8};
int arr1_2[] = {10, 11, 7, 5};
int arr1_3[] = {6, 12, 10, 8};
int arr1_4[] = {1, 2, 5};
int* arrs1[] = {arr1_1, arr1_2, arr1_3, arr1_4};
int sizes1[] = {4, 4, 4, 3};
int res_size1;
int* result1 = func0(arrs1, sizes1, 4, &res_size1);
int expected1[] = {1, 2, 5, 6, 7, 8, 10, 11, 12};
assert(res_size1 == 9);
for (int i = 0; i < res_size1; ++i) {
assert(result1[i] == expected1[i]);
}
free(result1);
int arr2_1[] = {7, 1, 9, 4};
int arr2_2[] = {11, 21, 36, 14, 9};
int arr2_3[] = {4, 1, 21, 39, 47};
int arr2_4[] = {1, 32, 38};
int* arrs2[] = {arr2_1, arr2_2, arr2_3, arr2_4};
int sizes2[] = {4, 5, 5, 3};
int res_size2;
int* result2 = func0(arrs2, sizes2, 4, &res_size2);
int expected2[] = {1, 4, 7, 9, 11, 14, 21, 32, 36, 38, 39, 47};
assert(res_size2 == 12);
for (int i = 0; i < res_size2; ++i) {
assert(result2[i] == expected2[i]);
}
free(result2);
int arr3_1[] = {11, 13, 14, 17};
int arr3_2[] = {12, 11, 15, 18};
int arr3_3[] = {19, 21, 15, 36};
int arr3_4[] = {37, 36, 35};
int* arrs3[] = {arr3_1, arr3_2, arr3_3, arr3_4};
int sizes3[] = {4, 4, 4, 3};
int res_size3;
int* result3 = func0(arrs3, sizes3, 4, &res_size3);
int expected3[] = {11, 12, 13, 14, 15, 17, 18, 19, 21, 35, 36, 37};
assert(res_size3 == 12);
for (int i = 0; i < res_size3; ++i) {
assert(result3[i] == expected3[i]);
}
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
test %edx,%edx
jle 1940 <func0+0x170>
lea -0x1(%rdx),%r14d
mov %rsi,%r13
mov %rdi,%rbx
mov %edx,%esi
cmp $0x3,%r14d
jbe 1950 <func0+0x180>
shr $0x2,%edx
mov %r13,%rax
pxor %xmm0,%xmm0
shl $0x4,%rdx
add %r13,%rdx
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rdx,%rax
jne 180e <func0+0x3e>
movdqa %xmm0,%xmm1
mov %esi,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
test $0x3,%sil
je 187d <func0+0xad>
movslq %edx,%rcx
add 0x0(%r13,%rcx,4),%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 187d <func0+0xad>
movslq %ecx,%rcx
add 0x0(%r13,%rcx,4),%eax
lea 0x2(%rdx),%ecx
cmp %esi,%ecx
jge 187d <func0+0xad>
movslq %ecx,%rcx
add $0x3,%edx
add 0x0(%r13,%rcx,4),%eax
cmp %esi,%edx
jge 187d <func0+0xad>
movslq %edx,%rdx
add 0x0(%r13,%rdx,4),%eax
cltq
mov %r14d,%r14d
lea 0x0(,%rax,4),%rdi
callq 10d0 <malloc@plt>
mov %r13,%r10
mov %rbx,%r11
lea 0x4(%r13,%r14,4),%r13
mov %rax,%r12
xor %ebx,%ebx
lea 0x4(%rax),%r9
nopl 0x0(%rax,%rax,1)
mov (%r10),%eax
test %eax,%eax
jle 18ee <func0+0x11e>
sub $0x1,%eax
mov (%r11),%rdi
xor %esi,%esi
lea 0x4(,%rax,4),%r8
test %ebx,%ebx
je 1928 <func0+0x158>
lea -0x1(%rbx),%ecx
mov (%rdi,%rsi,1),%edx
mov %r12,%rax
lea (%r9,%rcx,4),%rcx
jmp 18e1 <func0+0x111>
nopl 0x0(%rax,%rax,1)
add $0x4,%rax
cmp %rcx,%rax
je 1928 <func0+0x158>
cmp %edx,(%rax)
jne 18d8 <func0+0x108>
add $0x4,%rsi
cmp %r8,%rsi
jne 18c0 <func0+0xf0>
add $0x4,%r10
add $0x8,%r11
cmp %r13,%r10
jne 18a8 <func0+0xd8>
movslq %ebx,%rsi
mov %r12,%rdi
lea -0x148(%rip),%rcx
mov $0x4,%edx
callq 10a0 <qsort@plt>
mov %ebx,0x0(%rbp)
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
mov (%rdi,%rsi,1),%edx
movslq %ebx,%rax
add $0x4,%rsi
add $0x1,%ebx
mov %edx,(%r12,%rax,4)
cmp %r8,%rsi
jne 18c0 <func0+0xf0>
jmp 18ee <func0+0x11e>
xor %edi,%edi
xor %ebx,%ebx
callq 10d0 <malloc@plt>
xor %esi,%esi
mov %rax,%r12
jmp 18fe <func0+0x12e>
xor %edx,%edx
xor %eax,%eax
jmpq 1848 <func0+0x78>
nopl 0x0(%rax)
| func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rcx
push rbx
test edx, edx
jle loc_17FF
lea eax, [rdx-1]
mov r13, rdi
mov r14, rsi
mov ebx, edx
cmp eax, 2
jbe loc_180F
shr edx, 2
mov rax, rsi
pxor xmm0, xmm0
shl rdx, 4
add rdx, rsi
loc_16EC:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
cmp rax, rdx
jnz short loc_16EC
movdqa xmm1, xmm0
mov edx, ebx
psrldq xmm1, 8
and edx, 0FFFFFFFCh
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test bl, 3
jz short loc_174C
loc_1725:
movsxd rsi, edx
lea rcx, ds:0[rsi*4]
add eax, [r14+rsi*4]
lea esi, [rdx+1]
cmp ebx, esi
jle short loc_174C
add edx, 2
add eax, [r14+rcx+4]
cmp ebx, edx
jle short loc_174C
add eax, [r14+rcx+8]
loc_174C:
cdqe
lea rdi, ds:0[rax*4]; size
call _malloc
movsxd r10, ebx
xor r9d, r9d
xor ebx, ebx
mov r12, rax
nop word ptr [rax+rax+00000000h]
loc_1770:
movsxd rax, dword ptr [r14+r9*4]
test eax, eax
jle short loc_17B6
mov rsi, [r13+r9*8+0]
movsxd rdi, ebx
lea r8, [rsi+rax*4]
nop dword ptr [rax+00h]
loc_1788:
movsxd rax, ebx
lea rcx, [r12+rax*4]
test ebx, ebx
jle short loc_17E8
loc_1793:
mov edx, [rsi]
mov rax, r12
jmp short loc_17A9
loc_17A0:
add rax, 4
cmp rcx, rax
jz short loc_17E8
loc_17A9:
cmp [rax], edx
jnz short loc_17A0
add rsi, 4
cmp rsi, r8
jnz short loc_1793
loc_17B6:
add r9, 1
cmp r9, r10
jnz short loc_1770
movsxd rsi, ebx; nmemb
loc_17C2:
mov rdi, r12; base
lea rcx, cmpfunc; compar
mov edx, 4; size
call _qsort
mov [rbp+0], ebx
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_17E8:
mov eax, [rsi]
add rsi, 4
add ebx, 1
mov [r12+rdi*4], eax
cmp rsi, r8
jz short loc_17B6
movsxd rdi, ebx
jmp short loc_1788
loc_17FF:
xor edi, edi; size
xor ebx, ebx
call _malloc
xor esi, esi
mov r12, rax
jmp short loc_17C2
loc_180F:
xor edx, edx
xor eax, eax
jmp loc_1725 | _DWORD * func0(long long a1, const __m128i *a2, int a3, int *a4)
{
const __m128i *v8; // rax
__m128i v9; // xmm0
const __m128i *v10; // rdx
__m128i v11; // xmm2
int v12; // edx
__m128i v13; // xmm0
int v14; // eax
long long v15; // rcx
_DWORD *v16; // rax
long long v17; // r10
long long v18; // r9
int v19; // ebx
_DWORD *v20; // r12
long long v21; // rax
int *v22; // rsi
long long v23; // rdi
int *v24; // r8
_DWORD *v25; // rax
size_t v26; // rsi
int v28; // eax
if ( a3 <= 0 )
{
v19 = 0;
v26 = 0LL;
v20 = malloc(0LL);
goto LABEL_19;
}
if ( (unsigned int)(a3 - 1) <= 2 )
{
v12 = 0;
v14 = 0;
}
else
{
v8 = a2;
v9 = 0LL;
v10 = &a2[(unsigned int)a3 >> 2];
do
{
v11 = _mm_loadu_si128(v8++);
v9 = _mm_add_epi32(v9, v11);
}
while ( v8 != v10 );
v12 = a3 & 0x7FFFFFFC;
v13 = _mm_add_epi32(v9, _mm_srli_si128(v9, 8));
v14 = _mm_cvtsi128_si32(_mm_add_epi32(v13, _mm_srli_si128(v13, 4)));
if ( (a3 & 3) == 0 )
goto LABEL_9;
}
v15 = v12;
v14 += a2->m128i_i32[v15];
if ( a3 > v12 + 1 )
{
v14 += a2->m128i_i32[v15 + 1];
if ( a3 > v12 + 2 )
v14 += a2->m128i_i32[v15 + 2];
}
LABEL_9:
v16 = malloc(4LL * v14);
v17 = a3;
v18 = 0LL;
v19 = 0;
v20 = v16;
do
{
v21 = a2->m128i_i32[v18];
if ( (int)v21 > 0 )
{
v22 = *(int **)(a1 + 8 * v18);
v23 = v19;
v24 = &v22[v21];
while ( v19 <= 0 )
{
LABEL_20:
v28 = *v22++;
++v19;
v20[v23] = v28;
if ( v22 == v24 )
goto LABEL_17;
v23 = v19;
}
do
{
v25 = v20;
while ( *v25 != *v22 )
{
if ( &v20[v19] == ++v25 )
goto LABEL_20;
}
++v22;
}
while ( v22 != v24 );
}
LABEL_17:
++v18;
}
while ( v18 != v17 );
v26 = v19;
LABEL_19:
qsort(v20, v26, 4uLL, cmpfunc);
*a4 = v19;
return v20;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RCX
PUSH RBX
TEST EDX,EDX
JLE 0x001017ff
LEA EAX,[RDX + -0x1]
MOV R13,RDI
MOV R14,RSI
MOV EBX,EDX
CMP EAX,0x2
JBE 0x0010180f
SHR EDX,0x2
MOV RAX,RSI
PXOR XMM0,XMM0
SHL RDX,0x4
ADD RDX,RSI
LAB_001016ec:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
CMP RAX,RDX
JNZ 0x001016ec
MOVDQA XMM1,XMM0
MOV EDX,EBX
PSRLDQ XMM1,0x8
AND EDX,0xfffffffc
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST BL,0x3
JZ 0x0010174c
LAB_00101725:
MOVSXD RSI,EDX
LEA RCX,[RSI*0x4]
ADD EAX,dword ptr [R14 + RSI*0x4]
LEA ESI,[RDX + 0x1]
CMP EBX,ESI
JLE 0x0010174c
ADD EDX,0x2
ADD EAX,dword ptr [R14 + RCX*0x1 + 0x4]
CMP EBX,EDX
JLE 0x0010174c
ADD EAX,dword ptr [R14 + RCX*0x1 + 0x8]
LAB_0010174c:
CDQE
LEA RDI,[RAX*0x4]
CALL 0x001010d0
MOVSXD R10,EBX
XOR R9D,R9D
XOR EBX,EBX
MOV R12,RAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101770:
MOVSXD RAX,dword ptr [R14 + R9*0x4]
TEST EAX,EAX
JLE 0x001017b6
MOV RSI,qword ptr [R13 + R9*0x8]
MOVSXD RDI,EBX
LEA R8,[RSI + RAX*0x4]
NOP dword ptr [RAX]
LAB_00101788:
MOVSXD RAX,EBX
LEA RCX,[R12 + RAX*0x4]
TEST EBX,EBX
JLE 0x001017e8
LAB_00101793:
MOV EDX,dword ptr [RSI]
MOV RAX,R12
JMP 0x001017a9
LAB_001017a0:
ADD RAX,0x4
CMP RCX,RAX
JZ 0x001017e8
LAB_001017a9:
CMP dword ptr [RAX],EDX
JNZ 0x001017a0
ADD RSI,0x4
CMP RSI,R8
JNZ 0x00101793
LAB_001017b6:
ADD R9,0x1
CMP R9,R10
JNZ 0x00101770
MOVSXD RSI,EBX
LAB_001017c2:
MOV RDI,R12
LEA RCX,[0x1016a0]
MOV EDX,0x4
CALL 0x001010a0
MOV dword ptr [RBP],EBX
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001017e8:
MOV EAX,dword ptr [RSI]
ADD RSI,0x4
ADD EBX,0x1
MOV dword ptr [R12 + RDI*0x4],EAX
CMP RSI,R8
JZ 0x001017b6
MOVSXD RDI,EBX
JMP 0x00101788
LAB_001017ff:
XOR EDI,EDI
XOR EBX,EBX
CALL 0x001010d0
XOR ESI,ESI
MOV R12,RAX
JMP 0x001017c2
LAB_0010180f:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x00101725 | int * func0(long param_1,int *param_2,uint param_3,int *param_4)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
uint uVar5;
int *piVar6;
size_t __nmemb;
long lVar7;
long lVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
if ((int)param_3 < 1) {
iVar9 = 0;
piVar3 = (int *)malloc(0);
__nmemb = 0;
goto LAB_001017c2;
}
if (param_3 - 1 < 3) {
uVar5 = 0;
iVar9 = 0;
LAB_00101725:
iVar9 = iVar9 + param_2[(int)uVar5];
if (((int)(uVar5 + 1) < (int)param_3) &&
(iVar9 = iVar9 + param_2[(long)(int)uVar5 + 1], (int)(uVar5 + 2) < (int)param_3)) {
iVar9 = iVar9 + param_2[(long)(int)uVar5 + 2];
}
}
else {
iVar9 = 0;
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
piVar3 = param_2;
do {
iVar1 = *piVar3;
piVar2 = piVar3 + 1;
piVar6 = piVar3 + 2;
piVar4 = piVar3 + 3;
piVar3 = piVar3 + 4;
iVar9 = iVar9 + iVar1;
iVar10 = iVar10 + *piVar2;
iVar11 = iVar11 + *piVar6;
iVar12 = iVar12 + *piVar4;
} while (piVar3 != param_2 + (ulong)(param_3 >> 2) * 4);
uVar5 = param_3 & 0xfffffffc;
iVar9 = iVar9 + iVar11 + iVar10 + iVar12;
if ((param_3 & 3) != 0) goto LAB_00101725;
}
piVar3 = (int *)malloc((long)iVar9 * 4);
lVar8 = 0;
iVar9 = 0;
do {
if (0 < param_2[lVar8]) {
piVar6 = *(int **)(param_1 + lVar8 * 8);
piVar2 = piVar6 + param_2[lVar8];
do {
lVar7 = (long)iVar9;
if (0 < iVar9) {
do {
piVar4 = piVar3;
while (*piVar4 != *piVar6) {
piVar4 = piVar4 + 1;
if (piVar3 + iVar9 == piVar4) goto LAB_001017e8;
}
piVar6 = piVar6 + 1;
} while (piVar6 != piVar2);
break;
}
LAB_001017e8:
iVar10 = *piVar6;
piVar6 = piVar6 + 1;
iVar9 = iVar9 + 1;
piVar3[lVar7] = iVar10;
} while (piVar6 != piVar2);
}
lVar8 = lVar8 + 1;
} while (lVar8 != (int)param_3);
__nmemb = (size_t)iVar9;
LAB_001017c2:
qsort(piVar3,__nmemb,4,cmpfunc);
*param_4 = iVar9;
return piVar3;
} |
6,672 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int test_tup2[], int length) {
for (int i = 0; i < length; i++) {
if (!(test_tup1[i] < test_tup2[i])) {
return false;
}
}
return true;
}
| int main() {
int tuple1_1[] = {10, 4, 5};
int tuple2_1[] = {13, 5, 18};
assert(func0(tuple1_1, tuple2_1, 3) == true);
int tuple1_2[] = {1, 2, 3};
int tuple2_2[] = {2, 1, 4};
assert(func0(tuple1_2, tuple2_2, 3) == false);
int tuple1_3[] = {4, 5, 6};
int tuple2_3[] = {5, 6, 7};
assert(func0(tuple1_3, tuple2_3, 3) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c0 <func0+0x57>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jl 11bc <func0+0x53>
mov $0x0,%eax
jmp 11cd <func0+0x64>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 1185 <func0+0x1c>
mov $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_4], 0
jmp short loc_11C0
loc_1185:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jl short loc_11BC
mov eax, 0
jmp short loc_11CD
loc_11BC:
add [rbp+var_4], 1
loc_11C0:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_24]
jl short loc_1185
mov eax, 1
loc_11CD:
pop rbp
retn | long long func0(long long a1, long long a2, int a3)
{
int i; // [rsp+20h] [rbp-4h]
for ( i = 0; i < a3; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) >= *(_DWORD *)(4LL * i + a2) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c0
LAB_00101185:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JL 0x001011bc
MOV EAX,0x0
JMP 0x001011cd
LAB_001011bc:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c0:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00101185
MOV EAX,0x1
LAB_001011cd:
POP RBP
RET | int8 func0(long param_1,long param_2,int param_3)
{
int local_c;
local_c = 0;
while( true ) {
if (param_3 <= local_c) {
return 1;
}
if (*(int *)(param_2 + (long)local_c * 4) <= *(int *)(param_1 + (long)local_c * 4)) break;
local_c = local_c + 1;
}
return 0;
} |
6,673 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int test_tup2[], int length) {
for (int i = 0; i < length; i++) {
if (!(test_tup1[i] < test_tup2[i])) {
return false;
}
}
return true;
}
| int main() {
int tuple1_1[] = {10, 4, 5};
int tuple2_1[] = {13, 5, 18};
assert(func0(tuple1_1, tuple2_1, 3) == true);
int tuple1_2[] = {1, 2, 3};
int tuple2_2[] = {2, 1, 4};
assert(func0(tuple1_2, tuple2_2, 3) == false);
int tuple1_3[] = {4, 5, 6};
int tuple2_3[] = {5, 6, 7};
assert(func0(tuple1_3, tuple2_3, 3) == true);
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
jle 1195 <func0+0x2c>
lea -0x1(%rdx),%ecx
mov $0x0,%eax
jmp 117e <func0+0x15>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
jge 119b <func0+0x32>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
jne 117b <func0+0x12>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
test edx, edx
jle short loc_118F
mov edx, edx
mov eax, 0
loc_1178:
mov ecx, [rsi+rax*4]
cmp [rdi+rax*4], ecx
jge short loc_1195
add rax, 1
cmp rax, rdx
jnz short loc_1178
mov eax, 1
retn
loc_118F:
mov eax, 1
retn
loc_1195:
mov eax, 0
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
if ( a3 <= 0 )
return 1LL;
v3 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v3) < *(_DWORD *)(a2 + 4 * v3) )
{
if ( ++v3 == a3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x0010118f
MOV EDX,EDX
MOV EAX,0x0
LAB_00101178:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JGE 0x00101195
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x00101178
MOV EAX,0x1
RET
LAB_0010118f:
MOV EAX,0x1
RET
LAB_00101195:
MOV EAX,0x0
RET | int8 func0(long param_1,long param_2,uint param_3)
{
ulong uVar1;
if ((int)param_3 < 1) {
return 1;
}
uVar1 = 0;
do {
if (*(int *)(param_2 + uVar1 * 4) <= *(int *)(param_1 + uVar1 * 4)) {
return 0;
}
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
return 1;
} |
6,674 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int test_tup2[], int length) {
for (int i = 0; i < length; i++) {
if (!(test_tup1[i] < test_tup2[i])) {
return false;
}
}
return true;
}
| int main() {
int tuple1_1[] = {10, 4, 5};
int tuple2_1[] = {13, 5, 18};
assert(func0(tuple1_1, tuple2_1, 3) == true);
int tuple1_2[] = {1, 2, 3};
int tuple2_2[] = {2, 1, 4};
assert(func0(tuple1_2, tuple2_2, 3) == false);
int tuple1_3[] = {4, 5, 6};
int tuple2_3[] = {5, 6, 7};
assert(func0(tuple1_3, tuple2_3, 3) == true);
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
jle 1170 <func0+0x30>
lea -0x1(%rdx),%ecx
xor %eax,%eax
jmp 115c <func0+0x1c>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1170 <func0+0x30>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
jl 1150 <func0+0x10>
xor %eax,%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test edx, edx
jle short loc_1168
movsxd rdx, edx
xor eax, eax
jmp short loc_1159
loc_1150:
add rax, 1
cmp rax, rdx
jz short loc_1168
loc_1159:
mov ecx, [rsi+rax*4]
cmp [rdi+rax*4], ecx
jl short loc_1150
xor eax, eax
retn
loc_1168:
mov eax, 1
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
if ( a3 <= 0 )
return 1LL;
v3 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v3) < *(_DWORD *)(a2 + 4 * v3) )
{
if ( ++v3 == a3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x00101168
MOVSXD RDX,EDX
XOR EAX,EAX
JMP 0x00101159
LAB_00101150:
ADD RAX,0x1
CMP RAX,RDX
JZ 0x00101168
LAB_00101159:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JL 0x00101150
XOR EAX,EAX
RET
LAB_00101168:
MOV EAX,0x1
RET | int8 func0(long param_1,long param_2,int param_3)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
if (*(int *)(param_2 + lVar1 * 4) <= *(int *)(param_1 + lVar1 * 4)) {
return 0;
}
lVar1 = lVar1 + 1;
} while (lVar1 != param_3);
}
return 1;
} |
6,675 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup1[], int test_tup2[], int length) {
for (int i = 0; i < length; i++) {
if (!(test_tup1[i] < test_tup2[i])) {
return false;
}
}
return true;
}
| int main() {
int tuple1_1[] = {10, 4, 5};
int tuple2_1[] = {13, 5, 18};
assert(func0(tuple1_1, tuple2_1, 3) == true);
int tuple1_2[] = {1, 2, 3};
int tuple2_2[] = {2, 1, 4};
assert(func0(tuple1_2, tuple2_2, 3) == false);
int tuple1_3[] = {4, 5, 6};
int tuple2_3[] = {5, 6, 7};
assert(func0(tuple1_3, tuple2_3, 3) == true);
return 0;
}
| O3 | c | func0:
endbr64
test %edx,%edx
jle 1170 <func0+0x30>
lea -0x1(%rdx),%ecx
xor %eax,%eax
jmp 115c <func0+0x1c>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1170 <func0+0x30>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
jl 1150 <func0+0x10>
xor %eax,%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test edx, edx
jle short loc_1170
movsxd rdx, edx
xor eax, eax
shl rdx, 2
jmp short loc_1161
loc_1158:
add rax, 4
cmp rdx, rax
jz short loc_1170
loc_1161:
mov ecx, [rsi+rax]
cmp [rdi+rax], ecx
jl short loc_1158
xor eax, eax
retn
loc_1170:
mov eax, 1
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
long long v4; // rdx
if ( a3 <= 0 )
return 1LL;
v3 = 0LL;
v4 = 4LL * a3;
while ( *(_DWORD *)(a1 + v3) < *(_DWORD *)(a2 + v3) )
{
v3 += 4LL;
if ( v4 == v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x00101170
MOVSXD RDX,EDX
XOR EAX,EAX
SHL RDX,0x2
JMP 0x00101161
LAB_00101158:
ADD RAX,0x4
CMP RDX,RAX
JZ 0x00101170
LAB_00101161:
MOV ECX,dword ptr [RSI + RAX*0x1]
CMP dword ptr [RDI + RAX*0x1],ECX
JL 0x00101158
XOR EAX,EAX
RET
LAB_00101170:
MOV EAX,0x1
RET | int8 func0(long param_1,long param_2,int param_3)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
if (*(int *)(param_2 + lVar1) <= *(int *)(param_1 + lVar1)) {
return 0;
}
lVar1 = lVar1 + 4;
} while ((long)param_3 * 4 != lVar1);
}
return 1;
} |
6,676 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
// Function to zip integer lists
int** zip_list_int(int** list1, int* sizes1, int** list2, int* sizes2, int n) {
int** result = malloc(n * sizeof(int*));
for(int i = 0; i < n; i++) {
int new_size = sizes1[i] + sizes2[i];
result[i] = malloc(new_size * sizeof(int));
memcpy(result[i], list1[i], sizes1[i] * sizeof(int));
memcpy(result[i] + sizes1[i], list2[i], sizes2[i] * sizeof(int));
}
return result;
}
// Function to zip character lists
char** zip_list_char(char** list1, int* sizes1, char** list2, int* sizes2, int n) {
char** result = malloc(n * sizeof(char*));
for(int i = 0; i < n; i++) {
int new_size = sizes1[i] + sizes2[i];
result[i] = malloc((new_size + 1) * sizeof(char));
memcpy(result[i], list1[i], sizes1[i] * sizeof(char));
memcpy(result[i] + sizes1[i], list2[i], sizes2[i] * sizeof(char));
result[i][new_size] = '\0';
}
return result;
}
// Helper function to compare character lists
int compare_char_lists(char** a, int* sizes_a, char** b, int* sizes_b, int n) {
for(int i = 0; i < n; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
if(memcmp(a[i], b[i], sizes_a[i] * sizeof(char)) != 0) return 0;
}
return 1;
}
// Helper function to compare integer lists
| int func0(int** a, int* sizes_a, int** b, int* sizes_b, int n) {
for(int i = 0; i < n; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
if(memcmp(a[i], b[i], sizes_a[i] * sizeof(int)) != 0) return 0;
}
return 1;
}
| int main() {
// First assert
int n1 = 3;
int sizes1_a[] = {2, 2, 2};
int sizes1_b[] = {2, 2, 3};
int row1_a1[] = {1, 3};
int row1_a2[] = {5, 7};
int row1_a3[] = {9, 11};
int* list1_a[] = {row1_a1, row1_a2, row1_a3};
int row1_b1[] = {2, 4};
int row1_b2[] = {6, 8};
int row1_b3[] = {10, 12, 14};
int* list1_b[] = {row1_b1, row1_b2, row1_b3};
int** expected1 = malloc(n1 * sizeof(int*));
int expected_sizes1[] = {4, 4, 5};
int row1_e1[] = {1, 3, 2, 4};
int row1_e2[] = {5, 7, 6, 8};
int row1_e3[] = {9, 11, 10, 12, 14};
expected1[0] = row1_e1;
expected1[1] = row1_e2;
expected1[2] = row1_e3;
int** result1 = zip_list_int(list1_a, sizes1_a, list1_b, sizes1_b, n1);
assert(func0(result1, expected1 ? expected_sizes1 : NULL, expected1, expected_sizes1, n1));
// Second assert
int n2 = 3;
int sizes2_a[] = {2, 2, 2};
int sizes2_b2[] = {2, 2, 2};
int row2_a1[] = {1, 2};
int row2_a2[] = {3, 4};
int row2_a3[] = {5, 6};
int* list2_a[] = {row2_a1, row2_a2, row2_a3};
int row2_b1[] = {7, 8};
int row2_b2[] = {9, 10};
int row2_b3[] = {11, 12};
int* list2_b[] = {row2_b1, row2_b2, row2_b3};
int** expected2 = malloc(n2 * sizeof(int*));
int expected_sizes2[] = {4, 4, 4};
int row2_e1[] = {1, 2, 7, 8};
int row2_e2[] = {3, 4, 9, 10};
int row2_e3[] = {5, 6, 11, 12};
expected2[0] = row2_e1;
expected2[1] = row2_e2;
expected2[2] = row2_e3;
int** result2 = zip_list_int(list2_a, sizes2_a, list2_b, sizes2_b2, n2);
assert(func0(result2, expected2 ? expected_sizes2 : NULL, expected2, expected_sizes2, n2));
// Third assert
int n3 = 2;
int sizes3_a[] = {2, 2};
int sizes3_b3[] = {2, 2};
char row3_a1[] = {'a', 'b'};
char row3_a2[] = {'c', 'd'};
char* list3_a[] = {row3_a1, row3_a2};
char row3_b1[] = {'e', 'f'};
char row3_b2[] = {'g', 'h'};
char* list3_b[] = {row3_b1, row3_b2};
char** expected3 = malloc(n3 * sizeof(char*));
int expected_sizes3[] = {4, 4};
char row3_e1[] = {'a', 'b', 'e', 'f'};
char row3_e2[] = {'c', 'd', 'g', 'h'};
expected3[0] = row3_e1;
expected3[1] = row3_e2;
char** result3 = zip_list_char(list3_a, sizes3_a, list3_b, sizes3_b3, n3);
assert(compare_char_lists(result3, expected_sizes3, expected3, expected_sizes3, n3));
printf("All assertions passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
mov %r8d,-0x34(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 16b2 <func0+0xcb>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x30(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 164a <func0+0x63>
mov $0x0,%eax
jmp 16c3 <func0+0xdc>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%rcx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rsi
mov -0x18(%rbp),%rax
add %rsi,%rax
mov (%rax),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 10d0 <memcmp@plt>
test %eax,%eax
je 16ae <func0+0xc7>
mov $0x0,%eax
jmp 16c3 <func0+0xdc>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x34(%rbp),%eax
jl 1613 <func0+0x2c>
mov $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_34], r8d
mov [rbp+var_4], 0
jmp loc_16B0
loc_1611:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_30]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_1648
mov eax, 0
jmp short locret_16C1
loc_1648:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rdx
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*4]; n
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rcx
mov rcx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rsi, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rsi
mov rax, [rax]
mov rsi, rcx; s2
mov rdi, rax; s1
call _memcmp
test eax, eax
jz short loc_16AC
mov eax, 0
jmp short locret_16C1
loc_16AC:
add [rbp+var_4], 1
loc_16B0:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_34]
jl loc_1611
mov eax, 1
locret_16C1:
leave
retn | long long func0(long long a1, long long a2, long long a3, long long a4, int a5)
{
int i; // [rsp+3Ch] [rbp-4h]
for ( i = 0; i < a5; ++i )
{
if ( *(_DWORD *)(4LL * i + a2) != *(_DWORD *)(4LL * i + a4) )
return 0LL;
if ( memcmp(*(const void **)(8LL * i + a1), *(const void **)(8LL * i + a3), 4LL * *(int *)(4LL * i + a2)) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x34],R8D
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001016b0
LAB_00101611:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x00101648
MOV EAX,0x0
JMP 0x001016c1
LAB_00101648:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV RCX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RSI,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RSI
MOV RAX,qword ptr [RAX]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010d0
TEST EAX,EAX
JZ 0x001016ac
MOV EAX,0x0
JMP 0x001016c1
LAB_001016ac:
ADD dword ptr [RBP + -0x4],0x1
LAB_001016b0:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x34]
JL 0x00101611
MOV EAX,0x1
LAB_001016c1:
LEAVE
RET | int8 func0(long param_1,long param_2,long param_3,long param_4,int param_5)
{
int iVar1;
int local_c;
local_c = 0;
while( true ) {
if (param_5 <= local_c) {
return 1;
}
if (*(int *)(param_2 + (long)local_c * 4) != *(int *)(param_4 + (long)local_c * 4)) break;
iVar1 = memcmp(*(void **)(param_1 + (long)local_c * 8),*(void **)(param_3 + (long)local_c * 8),
(long)*(int *)(param_2 + (long)local_c * 4) * 4);
if (iVar1 != 0) {
return 0;
}
local_c = local_c + 1;
}
return 0;
} |
6,677 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
// Function to zip integer lists
int** zip_list_int(int** list1, int* sizes1, int** list2, int* sizes2, int n) {
int** result = malloc(n * sizeof(int*));
for(int i = 0; i < n; i++) {
int new_size = sizes1[i] + sizes2[i];
result[i] = malloc(new_size * sizeof(int));
memcpy(result[i], list1[i], sizes1[i] * sizeof(int));
memcpy(result[i] + sizes1[i], list2[i], sizes2[i] * sizeof(int));
}
return result;
}
// Function to zip character lists
char** zip_list_char(char** list1, int* sizes1, char** list2, int* sizes2, int n) {
char** result = malloc(n * sizeof(char*));
for(int i = 0; i < n; i++) {
int new_size = sizes1[i] + sizes2[i];
result[i] = malloc((new_size + 1) * sizeof(char));
memcpy(result[i], list1[i], sizes1[i] * sizeof(char));
memcpy(result[i] + sizes1[i], list2[i], sizes2[i] * sizeof(char));
result[i][new_size] = '\0';
}
return result;
}
// Helper function to compare character lists
int compare_char_lists(char** a, int* sizes_a, char** b, int* sizes_b, int n) {
for(int i = 0; i < n; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
if(memcmp(a[i], b[i], sizes_a[i] * sizeof(char)) != 0) return 0;
}
return 1;
}
// Helper function to compare integer lists
| int func0(int** a, int* sizes_a, int** b, int* sizes_b, int n) {
for(int i = 0; i < n; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
if(memcmp(a[i], b[i], sizes_a[i] * sizeof(int)) != 0) return 0;
}
return 1;
}
| int main() {
// First assert
int n1 = 3;
int sizes1_a[] = {2, 2, 2};
int sizes1_b[] = {2, 2, 3};
int row1_a1[] = {1, 3};
int row1_a2[] = {5, 7};
int row1_a3[] = {9, 11};
int* list1_a[] = {row1_a1, row1_a2, row1_a3};
int row1_b1[] = {2, 4};
int row1_b2[] = {6, 8};
int row1_b3[] = {10, 12, 14};
int* list1_b[] = {row1_b1, row1_b2, row1_b3};
int** expected1 = malloc(n1 * sizeof(int*));
int expected_sizes1[] = {4, 4, 5};
int row1_e1[] = {1, 3, 2, 4};
int row1_e2[] = {5, 7, 6, 8};
int row1_e3[] = {9, 11, 10, 12, 14};
expected1[0] = row1_e1;
expected1[1] = row1_e2;
expected1[2] = row1_e3;
int** result1 = zip_list_int(list1_a, sizes1_a, list1_b, sizes1_b, n1);
assert(func0(result1, expected1 ? expected_sizes1 : NULL, expected1, expected_sizes1, n1));
// Second assert
int n2 = 3;
int sizes2_a[] = {2, 2, 2};
int sizes2_b2[] = {2, 2, 2};
int row2_a1[] = {1, 2};
int row2_a2[] = {3, 4};
int row2_a3[] = {5, 6};
int* list2_a[] = {row2_a1, row2_a2, row2_a3};
int row2_b1[] = {7, 8};
int row2_b2[] = {9, 10};
int row2_b3[] = {11, 12};
int* list2_b[] = {row2_b1, row2_b2, row2_b3};
int** expected2 = malloc(n2 * sizeof(int*));
int expected_sizes2[] = {4, 4, 4};
int row2_e1[] = {1, 2, 7, 8};
int row2_e2[] = {3, 4, 9, 10};
int row2_e3[] = {5, 6, 11, 12};
expected2[0] = row2_e1;
expected2[1] = row2_e2;
expected2[2] = row2_e3;
int** result2 = zip_list_int(list2_a, sizes2_a, list2_b, sizes2_b2, n2);
assert(func0(result2, expected2 ? expected_sizes2 : NULL, expected2, expected_sizes2, n2));
// Third assert
int n3 = 2;
int sizes3_a[] = {2, 2};
int sizes3_b3[] = {2, 2};
char row3_a1[] = {'a', 'b'};
char row3_a2[] = {'c', 'd'};
char* list3_a[] = {row3_a1, row3_a2};
char row3_b1[] = {'e', 'f'};
char row3_b2[] = {'g', 'h'};
char* list3_b[] = {row3_b1, row3_b2};
char** expected3 = malloc(n3 * sizeof(char*));
int expected_sizes3[] = {4, 4};
char row3_e1[] = {'a', 'b', 'e', 'f'};
char row3_e2[] = {'c', 'd', 'g', 'h'};
expected3[0] = row3_e1;
expected3[1] = row3_e2;
char** result3 = zip_list_char(list3_a, sizes3_a, list3_b, sizes3_b3, n3);
assert(compare_char_lists(result3, expected_sizes3, expected3, expected_sizes3, n3));
printf("All assertions passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
test %r8d,%r8d
jle 1455 <func0+0x64>
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %rsi,%rbp
mov %rdx,%r14
mov %rcx,%r12
lea -0x1(%r8),%r15d
mov $0x0,%ebx
jmp 1422 <func0+0x31>
mov %rax,%rbx
mov 0x0(%rbp,%rbx,4),%edx
cmp (%r12,%rbx,4),%edx
jne 145b <func0+0x6a>
movslq %edx,%rdx
shl $0x2,%rdx
mov (%r14,%rbx,8),%rsi
mov 0x0(%r13,%rbx,8),%rdi
callq 10d0 <memcmp@plt>
test %eax,%eax
jne 146f <func0+0x7e>
lea 0x1(%rbx),%rax
cmp %r15,%rbx
jne 141f <func0+0x2e>
mov $0x1,%eax
jmp 1460 <func0+0x6f>
mov $0x1,%eax
retq
mov $0x0,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x0,%eax
jmp 1460 <func0+0x6f>
| func0:
endbr64
test r8d, r8d
jle short loc_1441
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r14, rdi
mov r12, rsi
mov r15, rdx
mov r13, rcx
mov ebp, r8d
mov ebx, 0
loc_140E:
mov edx, [r12+rbx*4]
cmp edx, [r13+rbx*4+0]
jnz short loc_1447
movsxd rdx, edx
shl rdx, 2
mov rsi, [r15+rbx*8]
mov rdi, [r14+rbx*8]
call _memcmp
test eax, eax
jnz short loc_145B
add rbx, 1
cmp rbx, rbp
jnz short loc_140E
mov eax, 1
jmp short loc_144C
loc_1441:
mov eax, 1
retn
loc_1447:
mov eax, 0
loc_144C:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_145B:
mov eax, 0
jmp short loc_144C | long long func0(long long a1, long long a2, long long a3, long long a4, int a5)
{
long long v7; // rbp
long long v8; // rbx
int v9; // edx
if ( a5 <= 0 )
return 1LL;
v7 = (unsigned int)a5;
v8 = 0LL;
while ( 1 )
{
v9 = *(_DWORD *)(a2 + 4 * v8);
if ( v9 != *(_DWORD *)(a4 + 4 * v8) )
return 0LL;
if ( (unsigned int)memcmp(*(_QWORD *)(a1 + 8 * v8), *(_QWORD *)(a3 + 8 * v8), 4LL * v9) )
break;
if ( ++v8 == v7 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST R8D,R8D
JLE 0x00101441
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R14,RDI
MOV R12,RSI
MOV R15,RDX
MOV R13,RCX
MOV EBP,R8D
MOV EBX,0x0
LAB_0010140e:
MOV EDX,dword ptr [R12 + RBX*0x4]
CMP EDX,dword ptr [R13 + RBX*0x4]
JNZ 0x00101447
MOVSXD RDX,EDX
SHL RDX,0x2
MOV RSI,qword ptr [R15 + RBX*0x8]
MOV RDI,qword ptr [R14 + RBX*0x8]
CALL 0x001010d0
TEST EAX,EAX
JNZ 0x0010145b
ADD RBX,0x1
CMP RBX,RBP
JNZ 0x0010140e
MOV EAX,0x1
JMP 0x0010144c
LAB_00101441:
MOV EAX,0x1
RET
LAB_00101447:
MOV EAX,0x0
LAB_0010144c:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010145b:
MOV EAX,0x0
JMP 0x0010144c | int8 func0(long param_1,long param_2,long param_3,long param_4,uint param_5)
{
int iVar1;
ulong uVar2;
if ((int)param_5 < 1) {
return 1;
}
uVar2 = 0;
while( true ) {
iVar1 = *(int *)(param_2 + uVar2 * 4);
if (iVar1 != *(int *)(param_4 + uVar2 * 4)) {
return 0;
}
iVar1 = memcmp(*(void **)(param_1 + uVar2 * 8),*(void **)(param_3 + uVar2 * 8),(long)iVar1 << 2)
;
if (iVar1 != 0) break;
uVar2 = uVar2 + 1;
if (uVar2 == param_5) {
return 1;
}
}
return 0;
} |
6,678 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
// Function to zip integer lists
int** zip_list_int(int** list1, int* sizes1, int** list2, int* sizes2, int n) {
int** result = malloc(n * sizeof(int*));
for(int i = 0; i < n; i++) {
int new_size = sizes1[i] + sizes2[i];
result[i] = malloc(new_size * sizeof(int));
memcpy(result[i], list1[i], sizes1[i] * sizeof(int));
memcpy(result[i] + sizes1[i], list2[i], sizes2[i] * sizeof(int));
}
return result;
}
// Function to zip character lists
char** zip_list_char(char** list1, int* sizes1, char** list2, int* sizes2, int n) {
char** result = malloc(n * sizeof(char*));
for(int i = 0; i < n; i++) {
int new_size = sizes1[i] + sizes2[i];
result[i] = malloc((new_size + 1) * sizeof(char));
memcpy(result[i], list1[i], sizes1[i] * sizeof(char));
memcpy(result[i] + sizes1[i], list2[i], sizes2[i] * sizeof(char));
result[i][new_size] = '\0';
}
return result;
}
// Helper function to compare character lists
int compare_char_lists(char** a, int* sizes_a, char** b, int* sizes_b, int n) {
for(int i = 0; i < n; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
if(memcmp(a[i], b[i], sizes_a[i] * sizeof(char)) != 0) return 0;
}
return 1;
}
// Helper function to compare integer lists
| int func0(int** a, int* sizes_a, int** b, int* sizes_b, int n) {
for(int i = 0; i < n; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
if(memcmp(a[i], b[i], sizes_a[i] * sizeof(int)) != 0) return 0;
}
return 1;
}
| int main() {
// First assert
int n1 = 3;
int sizes1_a[] = {2, 2, 2};
int sizes1_b[] = {2, 2, 3};
int row1_a1[] = {1, 3};
int row1_a2[] = {5, 7};
int row1_a3[] = {9, 11};
int* list1_a[] = {row1_a1, row1_a2, row1_a3};
int row1_b1[] = {2, 4};
int row1_b2[] = {6, 8};
int row1_b3[] = {10, 12, 14};
int* list1_b[] = {row1_b1, row1_b2, row1_b3};
int** expected1 = malloc(n1 * sizeof(int*));
int expected_sizes1[] = {4, 4, 5};
int row1_e1[] = {1, 3, 2, 4};
int row1_e2[] = {5, 7, 6, 8};
int row1_e3[] = {9, 11, 10, 12, 14};
expected1[0] = row1_e1;
expected1[1] = row1_e2;
expected1[2] = row1_e3;
int** result1 = zip_list_int(list1_a, sizes1_a, list1_b, sizes1_b, n1);
assert(func0(result1, expected1 ? expected_sizes1 : NULL, expected1, expected_sizes1, n1));
// Second assert
int n2 = 3;
int sizes2_a[] = {2, 2, 2};
int sizes2_b2[] = {2, 2, 2};
int row2_a1[] = {1, 2};
int row2_a2[] = {3, 4};
int row2_a3[] = {5, 6};
int* list2_a[] = {row2_a1, row2_a2, row2_a3};
int row2_b1[] = {7, 8};
int row2_b2[] = {9, 10};
int row2_b3[] = {11, 12};
int* list2_b[] = {row2_b1, row2_b2, row2_b3};
int** expected2 = malloc(n2 * sizeof(int*));
int expected_sizes2[] = {4, 4, 4};
int row2_e1[] = {1, 2, 7, 8};
int row2_e2[] = {3, 4, 9, 10};
int row2_e3[] = {5, 6, 11, 12};
expected2[0] = row2_e1;
expected2[1] = row2_e2;
expected2[2] = row2_e3;
int** result2 = zip_list_int(list2_a, sizes2_a, list2_b, sizes2_b2, n2);
assert(func0(result2, expected2 ? expected_sizes2 : NULL, expected2, expected_sizes2, n2));
// Third assert
int n3 = 2;
int sizes3_a[] = {2, 2};
int sizes3_b3[] = {2, 2};
char row3_a1[] = {'a', 'b'};
char row3_a2[] = {'c', 'd'};
char* list3_a[] = {row3_a1, row3_a2};
char row3_b1[] = {'e', 'f'};
char row3_b2[] = {'g', 'h'};
char* list3_b[] = {row3_b1, row3_b2};
char** expected3 = malloc(n3 * sizeof(char*));
int expected_sizes3[] = {4, 4};
char row3_e1[] = {'a', 'b', 'e', 'f'};
char row3_e2[] = {'c', 'd', 'g', 'h'};
expected3[0] = row3_e1;
expected3[1] = row3_e2;
char** result3 = zip_list_char(list3_a, sizes3_a, list3_b, sizes3_b3, n3);
assert(compare_char_lists(result3, expected_sizes3, expected3, expected_sizes3, n3));
printf("All assertions passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
test %r8d,%r8d
jle 19f4 <func0+0x84>
push %r15
mov %rdx,%r15
push %r14
mov %rdi,%r14
push %r13
xor %r13d,%r13d
push %r12
lea -0x1(%r8),%r12d
push %rbp
mov %rcx,%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
jmp 19c1 <func0+0x51>
nopl 0x0(%rax)
mov (%r15,%r13,8),%rsi
mov (%r14,%r13,8),%rdi
shl $0x2,%rdx
callq 10d0 <memcmp@plt>
test %eax,%eax
jne 19cc <func0+0x5c>
lea 0x1(%r13),%rax
cmp %r12,%r13
je 19e0 <func0+0x70>
mov %rax,%r13
movslq (%rbx,%r13,4),%rdx
cmp 0x0(%rbp,%r13,4),%edx
je 19a0 <func0+0x30>
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
add $0x8,%rsp
mov $0x1,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x1,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test r8d, r8d
jle short loc_19F4
push r15
mov r15, rdx
push r14
mov r14, rdi
push r13
mov r13, rcx
push r12
mov r12, rsi
push rbp
movsxd rbp, r8d
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_19BE
loc_19A0:
mov rsi, [r15+rbx*8]
mov rdi, [r14+rbx*8]
shl rdx, 2
call _memcmp
test eax, eax
jnz short loc_19C9
add rbx, 1
cmp rbx, rbp
jz short loc_19E0
loc_19BE:
movsxd rdx, dword ptr [r12+rbx*4]
cmp edx, [r13+rbx*4+0]
jz short loc_19A0
loc_19C9:
add rsp, 8
xor eax, eax
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_19E0:
add rsp, 8
mov eax, 1
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_19F4:
mov eax, 1
retn | long long func0(long long a1, long long a2, long long a3, long long a4, int a5)
{
long long v7; // rbp
long long i; // rbx
long long v9; // rdx
if ( a5 <= 0 )
return 1LL;
v7 = a5;
for ( i = 0LL; i != v7; ++i )
{
v9 = *(int *)(a2 + 4 * i);
if ( (_DWORD)v9 != *(_DWORD *)(a4 + 4 * i)
|| (unsigned int)memcmp(*(_QWORD *)(a1 + 8 * i), *(_QWORD *)(a3 + 8 * i), 4 * v9) )
{
return 0LL;
}
}
return 1LL;
} | func0:
ENDBR64
TEST R8D,R8D
JLE 0x001019f4
PUSH R15
MOV R15,RDX
PUSH R14
MOV R14,RDI
PUSH R13
MOV R13,RCX
PUSH R12
MOV R12,RSI
PUSH RBP
MOVSXD RBP,R8D
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x001019be
LAB_001019a0:
MOV RSI,qword ptr [R15 + RBX*0x8]
MOV RDI,qword ptr [R14 + RBX*0x8]
SHL RDX,0x2
CALL 0x001010d0
TEST EAX,EAX
JNZ 0x001019c9
ADD RBX,0x1
CMP RBX,RBP
JZ 0x001019e0
LAB_001019be:
MOVSXD RDX,dword ptr [R12 + RBX*0x4]
CMP EDX,dword ptr [R13 + RBX*0x4]
JZ 0x001019a0
LAB_001019c9:
ADD RSP,0x8
XOR EAX,EAX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001019e0:
ADD RSP,0x8
MOV EAX,0x1
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001019f4:
MOV EAX,0x1
RET | int8 func0(long param_1,long param_2,long param_3,long param_4,int param_5)
{
int iVar1;
long lVar2;
if (param_5 < 1) {
return 1;
}
lVar2 = 0;
while( true ) {
iVar1 = *(int *)(param_2 + lVar2 * 4);
if (iVar1 != *(int *)(param_4 + lVar2 * 4)) {
return 0;
}
iVar1 = memcmp(*(void **)(param_1 + lVar2 * 8),*(void **)(param_3 + lVar2 * 8),(long)iVar1 << 2)
;
if (iVar1 != 0) break;
lVar2 = lVar2 + 1;
if (lVar2 == param_5) {
return 1;
}
}
return 0;
} |
6,679 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
// Function to zip integer lists
int** zip_list_int(int** list1, int* sizes1, int** list2, int* sizes2, int n) {
int** result = malloc(n * sizeof(int*));
for(int i = 0; i < n; i++) {
int new_size = sizes1[i] + sizes2[i];
result[i] = malloc(new_size * sizeof(int));
memcpy(result[i], list1[i], sizes1[i] * sizeof(int));
memcpy(result[i] + sizes1[i], list2[i], sizes2[i] * sizeof(int));
}
return result;
}
// Function to zip character lists
char** zip_list_char(char** list1, int* sizes1, char** list2, int* sizes2, int n) {
char** result = malloc(n * sizeof(char*));
for(int i = 0; i < n; i++) {
int new_size = sizes1[i] + sizes2[i];
result[i] = malloc((new_size + 1) * sizeof(char));
memcpy(result[i], list1[i], sizes1[i] * sizeof(char));
memcpy(result[i] + sizes1[i], list2[i], sizes2[i] * sizeof(char));
result[i][new_size] = '\0';
}
return result;
}
// Helper function to compare character lists
int compare_char_lists(char** a, int* sizes_a, char** b, int* sizes_b, int n) {
for(int i = 0; i < n; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
if(memcmp(a[i], b[i], sizes_a[i] * sizeof(char)) != 0) return 0;
}
return 1;
}
// Helper function to compare integer lists
| int func0(int** a, int* sizes_a, int** b, int* sizes_b, int n) {
for(int i = 0; i < n; i++) {
if(sizes_a[i] != sizes_b[i]) return 0;
if(memcmp(a[i], b[i], sizes_a[i] * sizeof(int)) != 0) return 0;
}
return 1;
}
| int main() {
// First assert
int n1 = 3;
int sizes1_a[] = {2, 2, 2};
int sizes1_b[] = {2, 2, 3};
int row1_a1[] = {1, 3};
int row1_a2[] = {5, 7};
int row1_a3[] = {9, 11};
int* list1_a[] = {row1_a1, row1_a2, row1_a3};
int row1_b1[] = {2, 4};
int row1_b2[] = {6, 8};
int row1_b3[] = {10, 12, 14};
int* list1_b[] = {row1_b1, row1_b2, row1_b3};
int** expected1 = malloc(n1 * sizeof(int*));
int expected_sizes1[] = {4, 4, 5};
int row1_e1[] = {1, 3, 2, 4};
int row1_e2[] = {5, 7, 6, 8};
int row1_e3[] = {9, 11, 10, 12, 14};
expected1[0] = row1_e1;
expected1[1] = row1_e2;
expected1[2] = row1_e3;
int** result1 = zip_list_int(list1_a, sizes1_a, list1_b, sizes1_b, n1);
assert(func0(result1, expected1 ? expected_sizes1 : NULL, expected1, expected_sizes1, n1));
// Second assert
int n2 = 3;
int sizes2_a[] = {2, 2, 2};
int sizes2_b2[] = {2, 2, 2};
int row2_a1[] = {1, 2};
int row2_a2[] = {3, 4};
int row2_a3[] = {5, 6};
int* list2_a[] = {row2_a1, row2_a2, row2_a3};
int row2_b1[] = {7, 8};
int row2_b2[] = {9, 10};
int row2_b3[] = {11, 12};
int* list2_b[] = {row2_b1, row2_b2, row2_b3};
int** expected2 = malloc(n2 * sizeof(int*));
int expected_sizes2[] = {4, 4, 4};
int row2_e1[] = {1, 2, 7, 8};
int row2_e2[] = {3, 4, 9, 10};
int row2_e3[] = {5, 6, 11, 12};
expected2[0] = row2_e1;
expected2[1] = row2_e2;
expected2[2] = row2_e3;
int** result2 = zip_list_int(list2_a, sizes2_a, list2_b, sizes2_b2, n2);
assert(func0(result2, expected2 ? expected_sizes2 : NULL, expected2, expected_sizes2, n2));
// Third assert
int n3 = 2;
int sizes3_a[] = {2, 2};
int sizes3_b3[] = {2, 2};
char row3_a1[] = {'a', 'b'};
char row3_a2[] = {'c', 'd'};
char* list3_a[] = {row3_a1, row3_a2};
char row3_b1[] = {'e', 'f'};
char row3_b2[] = {'g', 'h'};
char* list3_b[] = {row3_b1, row3_b2};
char** expected3 = malloc(n3 * sizeof(char*));
int expected_sizes3[] = {4, 4};
char row3_e1[] = {'a', 'b', 'e', 'f'};
char row3_e2[] = {'c', 'd', 'g', 'h'};
expected3[0] = row3_e1;
expected3[1] = row3_e2;
char** result3 = zip_list_char(list3_a, sizes3_a, list3_b, sizes3_b3, n3);
assert(compare_char_lists(result3, expected_sizes3, expected3, expected_sizes3, n3));
printf("All assertions passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
test %r8d,%r8d
jle 19f4 <func0+0x84>
push %r15
mov %rdx,%r15
push %r14
mov %rdi,%r14
push %r13
xor %r13d,%r13d
push %r12
lea -0x1(%r8),%r12d
push %rbp
mov %rcx,%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
jmp 19c1 <func0+0x51>
nopl 0x0(%rax)
mov (%r15,%r13,8),%rsi
mov (%r14,%r13,8),%rdi
shl $0x2,%rdx
callq 10d0 <memcmp@plt>
test %eax,%eax
jne 19cc <func0+0x5c>
lea 0x1(%r13),%rax
cmp %r13,%r12
je 19e0 <func0+0x70>
mov %rax,%r13
movslq (%rbx,%r13,4),%rdx
cmp 0x0(%rbp,%r13,4),%edx
je 19a0 <func0+0x30>
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
add $0x8,%rsp
mov $0x1,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x1,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test r8d, r8d
jle loc_1AA4
push r15
movsxd r8, r8d
mov r15, rdx
push r14
mov r14, rdi
push r13
mov r13, rcx
push r12
mov r12, rsi
push rbp
lea rbp, ds:0[r8*4]
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_1A6E
loc_1A50:
mov rsi, [r15+rbx*2]; s2
mov rdi, [r14+rbx*2]; s1
shl rdx, 2; n
call _memcmp
test eax, eax
jnz short loc_1A79
add rbx, 4
cmp rbp, rbx
jz short loc_1A90
loc_1A6E:
movsxd rdx, dword ptr [r12+rbx]
cmp edx, [r13+rbx+0]
jz short loc_1A50
loc_1A79:
add rsp, 8
xor eax, eax
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1A90:
add rsp, 8
mov eax, 1
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1AA4:
mov eax, 1
retn | long long func0(long long a1, long long a2, long long a3, long long a4, int a5)
{
long long v7; // rbp
long long v8; // rbx
long long v9; // rdx
if ( a5 <= 0 )
return 1LL;
v7 = 4LL * a5;
v8 = 0LL;
do
{
v9 = *(int *)(a2 + v8);
if ( (_DWORD)v9 != *(_DWORD *)(a4 + v8)
|| memcmp(*(const void **)(a1 + 2 * v8), *(const void **)(a3 + 2 * v8), 4 * v9) )
{
return 0LL;
}
v8 += 4LL;
}
while ( v7 != v8 );
return 1LL;
} | func0:
ENDBR64
TEST R8D,R8D
JLE 0x00101aa4
PUSH R15
MOVSXD R8,R8D
MOV R15,RDX
PUSH R14
MOV R14,RDI
PUSH R13
MOV R13,RCX
PUSH R12
MOV R12,RSI
PUSH RBP
LEA RBP,[R8*0x4]
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x00101a6e
LAB_00101a50:
MOV RSI,qword ptr [R15 + RBX*0x2]
MOV RDI,qword ptr [R14 + RBX*0x2]
SHL RDX,0x2
CALL 0x001010d0
TEST EAX,EAX
JNZ 0x00101a79
ADD RBX,0x4
CMP RBP,RBX
JZ 0x00101a90
LAB_00101a6e:
MOVSXD RDX,dword ptr [R12 + RBX*0x1]
CMP EDX,dword ptr [R13 + RBX*0x1]
JZ 0x00101a50
LAB_00101a79:
ADD RSP,0x8
XOR EAX,EAX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101a90:
ADD RSP,0x8
MOV EAX,0x1
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101aa4:
MOV EAX,0x1
RET | int8 func0(long param_1,long param_2,long param_3,long param_4,int param_5)
{
int iVar1;
long lVar2;
if (param_5 < 1) {
return 1;
}
lVar2 = 0;
while( true ) {
if (*(int *)(param_2 + lVar2) != *(int *)(param_4 + lVar2)) {
return 0;
}
iVar1 = memcmp(*(void **)(param_1 + lVar2 * 2),*(void **)(param_3 + lVar2 * 2),
(long)*(int *)(param_2 + lVar2) << 2);
if (iVar1 != 0) break;
lVar2 = lVar2 + 4;
if ((long)param_5 * 4 - lVar2 == 0) {
return 1;
}
}
return 0;
} |
6,680 | func0 |
#include <assert.h>
| int func0(int array_nums[], int size) {
int count_even = 0;
for (int i = 0; i < size; i++) {
if (array_nums[i] % 2 == 0) {
count_even++;
}
}
return count_even;
}
| int main() {
int array1[] = {1, 2, 3, 5, 7, 8, 9, 10};
int size1 = sizeof(array1) / sizeof(array1[0]);
assert(func0(array1, size1) == 3);
int array2[] = {10, 15, 14, 13, -18, 12, -20};
int size2 = sizeof(array2) / sizeof(array2[0]);
assert(func0(array2, size2) == 5);
int array3[] = {1, 2, 4, 8, 9};
int size3 = sizeof(array3) / sizeof(array3[0]);
assert(func0(array3, size3) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ad <func0+0x44>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
jne 11a9 <func0+0x40>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11AD
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jnz short loc_11A9
add [rbp+var_8], 1
loc_11A9:
add [rbp+var_4], 1
loc_11AD:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 )
++v3;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ad
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011a9
ADD dword ptr [RBP + -0x8],0x1
LAB_001011a9:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ad:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((*(uint *)(param_1 + (long)local_c * 4) & 1) == 0) {
local_10 = local_10 + 1;
}
}
return local_10;
} |
6,681 | func0 |
#include <assert.h>
| int func0(int array_nums[], int size) {
int count_even = 0;
for (int i = 0; i < size; i++) {
if (array_nums[i] % 2 == 0) {
count_even++;
}
}
return count_even;
}
| int main() {
int array1[] = {1, 2, 3, 5, 7, 8, 9, 10};
int size1 = sizeof(array1) / sizeof(array1[0]);
assert(func0(array1, size1) == 3);
int array2[] = {10, 15, 14, 13, -18, 12, -20};
int size2 = sizeof(array2) / sizeof(array2[0]);
assert(func0(array2, size2) == 5);
int array3[] = {1, 2, 4, 8, 9};
int size3 = sizeof(array3) / sizeof(array3[0]);
assert(func0(array3, size3) == 3);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1198 <func0+0x2f>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rsi
mov $0x0,%ecx
mov (%rax),%edx
and $0x1,%edx
cmp $0x1,%edx
adc $0x0,%ecx
add $0x4,%rax
cmp %rsi,%rax
jne 1181 <func0+0x18>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1195 <func0+0x2c>
| func0:
endbr64
test esi, esi
jle short loc_1198
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*4+4]
mov ecx, 0
loc_1181:
mov edx, [rax]
and edx, 1
cmp edx, 1
adc ecx, 0
add rax, 4
cmp rax, rsi
jnz short loc_1181
loc_1195:
mov eax, ecx
retn
loc_1198:
mov ecx, 0
jmp short loc_1195 | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
long long v3; // rsi
unsigned int v4; // ecx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0;
do
v4 += (*v2++ & 1) == 0;
while ( v2 != (_DWORD *)v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101198
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x4 + 0x4]
MOV ECX,0x0
LAB_00101181:
MOV EDX,dword ptr [RAX]
AND EDX,0x1
CMP EDX,0x1
ADC ECX,0x0
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101181
LAB_00101195:
MOV EAX,ECX
RET
LAB_00101198:
MOV ECX,0x0
JMP 0x00101195 | int func0(uint *param_1,int param_2)
{
uint *puVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)((*param_1 & 1) == 0);
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return iVar2;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.