index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
7,682 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char *list1[], int n) {
int min = strlen(list1[0]);
for (int i = 0; i < n; i++) {
if (strlen(list1[i]) < min) {
min = strlen(list1[i]);
}
}
return min;
}
| int main() {
char *list1[] = {"win", "lose", "great"};
char *list2[] = {"a", "ab", "abc"};
char *list3[] = {"12", "12", "1234"};
assert(func0(list1, 3) == 3);
assert(func0(list2, 3) == 1);
assert(func0(list3, 3) == 2);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
mov (%rdi),%rdi
callq 1070 <strlen@plt>
mov %eax,%r12d
test %ebp,%ebp
jle 130b <func0+0x4b>
add $0x8,%rbx
lea -0x1(%rbp),%edx
lea (%rbx,%rdx,8),%rbp
jmp 12fc <func0+0x3c>
nopl 0x0(%rax)
mov (%rbx),%rdi
add $0x8,%rbx
callq 1070 <strlen@plt>
movslq %r12d,%rdx
cmp %rax,%rdx
cmova %eax,%r12d
cmp %rbp,%rbx
jne 12f0 <func0+0x30>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r12
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
mov rdi, [rdi]
call _strlen
mov r12d, eax
test ebp, ebp
jle short loc_130B
add rbx, 8
lea edx, [rbp-1]
lea rbp, [rbx+rdx*8]
jmp short loc_12FC
loc_12F0:
mov rdi, [rbx]
add rbx, 8
call _strlen
loc_12FC:
movsxd rdx, r12d
cmp rdx, rax
cmova r12d, eax
cmp rbx, rbp
jnz short loc_12F0
loc_130B:
mov eax, r12d
pop rbx
pop rbp
pop r12
retn | long long func0(_QWORD *a1, int a2)
{
unsigned long long v2; // rax
unsigned int v3; // r12d
long long *v4; // rbx
long long v5; // rbp
long long v6; // rdi
v2 = strlen(*a1);
v3 = v2;
if ( a2 > 0 )
{
v4 = a1 + 1;
v5 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
while ( 1 )
{
if ( (int)v3 > v2 )
v3 = v2;
if ( v4 == (long long *)v5 )
break;
v6 = *v4++;
v2 = strlen(v6);
}
}
return v3;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
CALL 0x00101070
MOV R12D,EAX
TEST EBP,EBP
JLE 0x0010130b
ADD RBX,0x8
LEA EDX,[RBP + -0x1]
LEA RBP,[RBX + RDX*0x8]
JMP 0x001012fc
LAB_001012f0:
MOV RDI,qword ptr [RBX]
ADD RBX,0x8
CALL 0x00101070
LAB_001012fc:
MOVSXD RDX,R12D
CMP RDX,RAX
CMOVA R12D,EAX
CMP RBX,RBP
JNZ 0x001012f0
LAB_0010130b:
MOV EAX,R12D
POP RBX
POP RBP
POP R12
RET | ulong func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s;
ulong uVar2;
ulong uVar3;
uVar2 = strlen((char *)*param_1);
uVar3 = uVar2 & 0xffffffff;
if (0 < param_2) {
param_1 = param_1 + 1;
puVar1 = param_1 + (param_2 - 1);
while( true ) {
if (uVar2 < (ulong)(long)(int)uVar3) {
uVar3 = uVar2 & 0xffffffff;
}
if (param_1 == puVar1) break;
__s = (char *)*param_1;
param_1 = param_1 + 1;
uVar2 = strlen(__s);
}
}
return uVar3;
} |
7,683 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char *list1[], int n) {
int min = strlen(list1[0]);
for (int i = 0; i < n; i++) {
if (strlen(list1[i]) < min) {
min = strlen(list1[i]);
}
}
return min;
}
| int main() {
char *list1[] = {"win", "lose", "great"};
char *list2[] = {"a", "ab", "abc"};
char *list3[] = {"12", "12", "1234"};
assert(func0(list1, 3) == 3);
assert(func0(list2, 3) == 1);
assert(func0(list3, 3) == 2);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
mov (%rdi),%rdi
callq 1070 <strlen@plt>
mov %eax,%r12d
test %ebp,%ebp
jle 132b <func0+0x4b>
add $0x8,%rbx
lea -0x1(%rbp),%edx
lea (%rbx,%rdx,8),%rbp
jmp 131c <func0+0x3c>
nopl 0x0(%rax)
mov (%rbx),%rdi
add $0x8,%rbx
callq 1070 <strlen@plt>
movslq %r12d,%rdx
cmp %rax,%rdx
cmova %eax,%r12d
cmp %rbp,%rbx
jne 1310 <func0+0x30>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r12
movsxd r12, esi
push rbp
push rbx
mov rbx, rdi
mov rdi, [rdi]; s
call _strlen
mov ebp, eax
test r12d, r12d
jle short loc_1322
lea r12, [rbx+r12*8]
jmp short loc_1310
loc_1308:
mov rdi, [rbx]; s
call _strlen
loc_1310:
movsxd rdx, ebp
cmp rax, rdx
cmovb ebp, eax
add rbx, 8
cmp rbx, r12
jnz short loc_1308
loc_1322:
mov eax, ebp
pop rbx
pop rbp
pop r12
retn | long long func0(const char **a1, int a2)
{
const char **v2; // rbx
size_t v3; // rax
unsigned int v4; // ebp
v2 = a1;
v3 = strlen(*a1);
v4 = v3;
if ( a2 > 0 )
{
while ( 1 )
{
if ( v3 < (int)v4 )
v4 = v3;
if ( ++v2 == &a1[a2] )
break;
v3 = strlen(*v2);
}
}
return v4;
} | func0:
ENDBR64
PUSH R12
MOVSXD R12,ESI
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
CALL 0x00101070
MOV EBP,EAX
TEST R12D,R12D
JLE 0x00101322
LEA R12,[RBX + R12*0x8]
JMP 0x00101310
LAB_00101308:
MOV RDI,qword ptr [RBX]
CALL 0x00101070
LAB_00101310:
MOVSXD RDX,EBP
CMP RAX,RDX
CMOVC EBP,EAX
ADD RBX,0x8
CMP RBX,R12
JNZ 0x00101308
LAB_00101322:
MOV EAX,EBP
POP RBX
POP RBP
POP R12
RET | ulong func0(int8 *param_1,int param_2)
{
int8 *puVar1;
ulong uVar2;
ulong uVar3;
uVar2 = strlen((char *)*param_1);
uVar3 = uVar2 & 0xffffffff;
if (0 < param_2) {
puVar1 = param_1 + param_2;
while( true ) {
if (uVar2 < (ulong)(long)(int)uVar3) {
uVar3 = uVar2 & 0xffffffff;
}
param_1 = param_1 + 1;
if (param_1 == puVar1) break;
uVar2 = strlen((char *)*param_1);
}
}
return uVar3;
} |
7,684 | func0 | #include <assert.h>
| char func0(char tup1[], int index, int size) {
if (index < 0) {
index = size + index;
}
return tup1[index];
}
| int main() {
char tuple1[] = {'w', 3, 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
int size = sizeof(tuple1) / sizeof(tuple1[0]);
assert(func0(tuple1, 3, size) == 'e');
assert(func0(tuple1, -4, size) == 'u');
assert(func0(tuple1, -3, size) == 'r');
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov %edx,-0x10(%rbp)
cmpl $0x0,-0xc(%rbp)
jns 1187 <func0+0x1e>
mov -0x10(%rbp),%eax
add %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
cmp [rbp+var_C], 0
jns short loc_1187
mov eax, [rbp+var_10]
add [rbp+var_C], eax
loc_1187:
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, [rbp+var_8]
add rax, rdx
movzx eax, byte ptr [rax]
pop rbp
retn | long long func0(long long a1, int a2, int a3)
{
int v4; // [rsp+4h] [rbp-Ch]
v4 = a2;
if ( a2 < 0 )
v4 = a3 + a2;
return *(unsigned __int8 *)(v4 + a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
CMP dword ptr [RBP + -0xc],0x0
JNS 0x00101187
MOV EAX,dword ptr [RBP + -0x10]
ADD dword ptr [RBP + -0xc],EAX
LAB_00101187:
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
POP RBP
RET | int func0(long param_1,int param_2,int param_3)
{
int4 local_14;
local_14 = param_2;
if (param_2 < 0) {
local_14 = param_2 + param_3;
}
return *(int *)(param_1 + local_14);
} |
7,685 | func0 | #include <assert.h>
| char func0(char tup1[], int index, int size) {
if (index < 0) {
index = size + index;
}
return tup1[index];
}
| int main() {
char tuple1[] = {'w', 3, 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
int size = sizeof(tuple1) / sizeof(tuple1[0]);
assert(func0(tuple1, 3, size) == 'e');
assert(func0(tuple1, -4, size) == 'u');
assert(func0(tuple1, -3, size) == 'r');
return 0;
}
| O1 | c | func0:
endbr64
add %esi,%edx
test %esi,%esi
cmovs %edx,%esi
movslq %esi,%rsi
movzbl (%rdi,%rsi,1),%eax
retq
| func0:
endbr64
add edx, esi
test esi, esi
cmovs esi, edx
movsxd rsi, esi
movzx eax, byte ptr [rdi+rsi]
retn | long long func0(long long a1, int a2, int a3)
{
int v3; // edx
v3 = a2 + a3;
if ( a2 < 0 )
a2 = v3;
return *(unsigned __int8 *)(a1 + a2);
} | func0:
ENDBR64
ADD EDX,ESI
TEST ESI,ESI
CMOVS ESI,EDX
MOVSXD RSI,ESI
MOVZX EAX,byte ptr [RDI + RSI*0x1]
RET | int1 func0(long param_1,int param_2,int param_3)
{
if (param_2 < 0) {
param_2 = param_3 + param_2;
}
return *(int1 *)(param_1 + param_2);
} |
7,686 | func0 | #include <assert.h>
| char func0(char tup1[], int index, int size) {
if (index < 0) {
index = size + index;
}
return tup1[index];
}
| int main() {
char tuple1[] = {'w', 3, 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
int size = sizeof(tuple1) / sizeof(tuple1[0]);
assert(func0(tuple1, 3, size) == 'e');
assert(func0(tuple1, -4, size) == 'u');
assert(func0(tuple1, -3, size) == 'r');
return 0;
}
| O2 | c | func0:
endbr64
add %esi,%edx
test %esi,%esi
cmovs %edx,%esi
movslq %esi,%rsi
movzbl (%rdi,%rsi,1),%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
add edx, esi
test esi, esi
cmovs esi, edx
movsxd rsi, esi
movzx eax, byte ptr [rdi+rsi]
retn | long long func0(long long a1, int a2, int a3)
{
int v3; // edx
v3 = a2 + a3;
if ( a2 < 0 )
a2 = v3;
return *(unsigned __int8 *)(a1 + a2);
} | func0:
ENDBR64
ADD EDX,ESI
TEST ESI,ESI
CMOVS ESI,EDX
MOVSXD RSI,ESI
MOVZX EAX,byte ptr [RDI + RSI*0x1]
RET | int1 func0(long param_1,int param_2,int param_3)
{
if (param_2 < 0) {
param_2 = param_3 + param_2;
}
return *(int1 *)(param_1 + param_2);
} |
7,687 | func0 | #include <assert.h>
| char func0(char tup1[], int index, int size) {
if (index < 0) {
index = size + index;
}
return tup1[index];
}
| int main() {
char tuple1[] = {'w', 3, 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
int size = sizeof(tuple1) / sizeof(tuple1[0]);
assert(func0(tuple1, 3, size) == 'e');
assert(func0(tuple1, -4, size) == 'u');
assert(func0(tuple1, -3, size) == 'r');
return 0;
}
| O3 | c | func0:
endbr64
add %esi,%edx
test %esi,%esi
cmovs %edx,%esi
movslq %esi,%rsi
movzbl (%rdi,%rsi,1),%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
add edx, esi
test esi, esi
cmovs esi, edx
movsxd rsi, esi
movzx eax, byte ptr [rdi+rsi]
retn | long long func0(long long a1, int a2, int a3)
{
int v3; // edx
v3 = a2 + a3;
if ( a2 < 0 )
a2 = v3;
return *(unsigned __int8 *)(a1 + a2);
} | func0:
ENDBR64
ADD EDX,ESI
TEST ESI,ESI
CMOVS ESI,EDX
MOVSXD RSI,ESI
MOVZX EAX,byte ptr [RDI + RSI*0x1]
RET | int func0(long param_1,int param_2,int param_3)
{
if (param_2 < 0) {
param_2 = param_3 + param_2;
}
return *(int *)(param_1 + param_2);
} |
7,688 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
// Define a tuple structure
typedef struct {
int *elements;
int size;
} Tuple;
// Function to count the total number of digits in a tuple
int count_digs(Tuple tup) {
int total = 0;
for(int i = 0; i < tup.size; i++) {
int num = tup.elements[i];
if(num == 0) {
total += 1;
} else {
while(num != 0) {
total += 1;
num /= 10;
}
}
}
return total;
}
// Comparison function for sorting tuples based on digit count
int compare_tuples(const void *a, const void *b) {
Tuple *tupA = (Tuple *)a;
Tuple *tupB = (Tuple *)b;
int countA = count_digs(*tupA);
int countB = count_digs(*tupB);
return countA - countB;
}
// Function to convert the sorted list of tuples to a string
| char* func0(Tuple *list, int list_size) {
// Sort the list based on digit counts
qsort(list, list_size, sizeof(Tuple), compare_tuples);
// Allocate memory for the resulting string
// Assuming maximum size, adjust as needed
static char result[1000];
result[0] = '\0';
strcat(result, "[");
for(int i = 0; i < list_size; i++) {
strcat(result, "(");
for(int j = 0; j < list[i].size; j++) {
char num_str[20];
sprintf(num_str, "%d", list[i].elements[j]);
strcat(result, num_str);
if(j < list[i].size - 1) {
strcat(result, ", ");
}
}
strcat(result, ")");
if(i < list_size - 1) {
strcat(result, ", ");
}
}
strcat(result, "]");
return result;
}
| int main() {
// First test case
Tuple list1[4];
int elems1_0[] = {3, 4, 6, 723};
list1[0].elements = elems1_0;
list1[0].size = 4;
int elems1_1[] = {1, 2};
list1[1].elements = elems1_1;
list1[1].size = 2;
int elems1_2[] = {12345};
list1[2].elements = elems1_2;
list1[2].size = 1;
int elems1_3[] = {134, 234, 34};
list1[3].elements = elems1_3;
list1[3].size = 3;
assert(strcmp(func0(list1, 4), "[(1, 2), (12345), (3, 4, 6, 723), (134, 234, 34)]") == 0);
// Second test case
Tuple list2[4];
int elems2_0[] = {3, 4, 8};
list2[0].elements = elems2_0;
list2[0].size = 3;
int elems2_1[] = {1, 2};
list2[1].elements = elems2_1;
list2[1].size = 2;
int elems2_2[] = {1234335};
list2[2].elements = elems2_2;
list2[2].size = 1;
int elems2_3[] = {1345, 234, 334};
list2[3].elements = elems2_3;
list2[3].size = 3;
assert(strcmp(func0(list2, 4), "[(1, 2), (3, 4, 8), (1234335), (1345, 234, 334)]") == 0);
// Third test case
Tuple list3[4];
int elems3_0[] = {34, 4, 61, 723};
list3[0].elements = elems3_0;
list3[0].size = 4;
int elems3_1[] = {1, 2};
list3[1].elements = elems3_1;
list3[1].size = 2;
int elems3_2[] = {145};
list3[2].elements = elems3_2;
list3[2].size = 1;
int elems3_3[] = {134, 23};
list3[3].elements = elems3_3;
list3[3].size = 2;
assert(strcmp(func0(list3, 4), "[(1, 2), (145), (134, 23), (34, 4, 61, 723)]") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x3c(%rbp),%eax
movslq %eax,%rsi
mov -0x38(%rbp),%rax
lea -0x91(%rip),%rcx
mov $0x10,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
movb $0x0,0x2d2e(%rip)
lea 0x2d27(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2d02(%rip),%rax
add %rdx,%rax
movw $0x5b,(%rax)
movl $0x0,-0x28(%rbp)
jmpq 14d6 <func0+0x20b>
lea 0x2ce7(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2cc2(%rip),%rax
add %rdx,%rax
movw $0x28,(%rax)
movl $0x0,-0x24(%rbp)
jmpq 143c <func0+0x171>
mov -0x28(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%edx
lea -0x20(%rbp),%rax
lea 0xc46(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 10f0 <sprintf@plt>
lea -0x20(%rbp),%rax
mov %rax,%rsi
lea 0x2c63(%rip),%rdi
callq 10e0 <strcat@plt>
mov -0x28(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%eax
sub $0x1,%eax
cmp %eax,-0x24(%rbp)
jge 1438 <func0+0x16d>
lea 0x2c39(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2c14(%rip),%rax
add %rdx,%rax
movw $0x202c,(%rax)
movb $0x0,0x2(%rax)
addl $0x1,-0x24(%rbp)
mov -0x28(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%eax
cmp %eax,-0x24(%rbp)
jl 1392 <func0+0xc7>
lea 0x2bde(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2bb9(%rip),%rax
add %rdx,%rax
movw $0x29,(%rax)
mov -0x3c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x28(%rbp)
jge 14d2 <func0+0x207>
lea 0x2b9f(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2b7a(%rip),%rax
add %rdx,%rax
movw $0x202c,(%rax)
movb $0x0,0x2(%rax)
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 1352 <func0+0x87>
lea 0x2b57(%rip),%rax
mov $0xffffffffffffffff,%rcx
mov %rax,%rdx
mov $0x0,%eax
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rdx
lea 0x2b32(%rip),%rax
add %rdx,%rax
movw $0x5d,(%rax)
lea 0x2b23(%rip),%rax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1531 <func0+0x266>
callq 10b0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+base], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_3C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare_tuples
mov rcx, rdx; compar
mov edx, 10h; size
mov rdi, rax; base
call _qsort
mov cs:result_1, 0
lea rax, result_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, result_1
add rax, rdx
mov word ptr [rax], 5Bh ; '['
mov [rbp+var_28], 0
jmp loc_14A0
loc_1362:
lea rax, result_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, result_1
add rax, rdx
mov word ptr [rax], 28h ; '('
mov [rbp+var_24], 0
jmp loc_142C
loc_138F:
mov eax, [rbp+var_28]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+base]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_24]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rax]
lea rax, [rbp+s]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
lea rax, [rbp+s]
mov rsi, rax; src
lea rax, result_1
mov rdi, rax; dest
call _strcat
mov eax, [rbp+var_28]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+base]
add rax, rdx
mov eax, [rax+8]
sub eax, 1
cmp [rbp+var_24], eax
jge short loc_1428
lea rax, result_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, result_1
add rax, rdx
mov word ptr [rax], 202Ch
mov byte ptr [rax+2], 0
loc_1428:
add [rbp+var_24], 1
loc_142C:
mov eax, [rbp+var_28]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+base]
add rax, rdx
mov eax, [rax+8]
cmp [rbp+var_24], eax
jl loc_138F
lea rax, result_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, result_1
add rax, rdx
mov word ptr [rax], 29h ; ')'
mov eax, [rbp+var_3C]
sub eax, 1
cmp [rbp+var_28], eax
jge short loc_149C
lea rax, result_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, result_1
add rax, rdx
mov word ptr [rax], 202Ch
mov byte ptr [rax+2], 0
loc_149C:
add [rbp+var_28], 1
loc_14A0:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_3C]
jl loc_1362
lea rax, result_1
mov rdi, rax; s
call _strlen
mov rdx, rax
lea rax, result_1
add rax, rdx
mov word ptr [rax], 5Dh ; ']'
lea rax, result_1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_14E8
call ___stack_chk_fail
locret_14E8:
leave
retn | char * func0(void *a1, int a2)
{
int i; // [rsp+18h] [rbp-28h]
int j; // [rsp+1Ch] [rbp-24h]
char s[24]; // [rsp+20h] [rbp-20h] BYREF
unsigned long long v6; // [rsp+38h] [rbp-8h]
v6 = __readfsqword(0x28u);
qsort(a1, a2, 0x10uLL, compare_tuples);
result_1[0] = 0;
*(_WORD *)&result_1[strlen(result_1)] = 91;
for ( i = 0; i < a2; ++i )
{
*(_WORD *)&result_1[strlen(result_1)] = 40;
for ( j = 0; j < *((_DWORD *)a1 + 4 * i + 2); ++j )
{
sprintf(s, "%d", *(_DWORD *)(4LL * j + *((_QWORD *)a1 + 2 * i)));
strcat(result_1, s);
if ( j < *((_DWORD *)a1 + 4 * i + 2) - 1 )
strcpy(&result_1[strlen(result_1)], ", ");
}
*(_WORD *)&result_1[strlen(result_1)] = 41;
if ( i < a2 - 1 )
strcpy(&result_1[strlen(result_1)], ", ");
}
*(_WORD *)&result_1[strlen(result_1)] = 93;
return result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x38]
LEA RDX,[0x10128d]
MOV RCX,RDX
MOV EDX,0x10
MOV RDI,RAX
CALL 0x001010b0
MOV byte ptr [0x00104040],0x0
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010c0
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV word ptr [RAX],0x5b
MOV dword ptr [RBP + -0x28],0x0
JMP 0x001014a0
LAB_00101362:
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010c0
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV word ptr [RAX],0x28
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0010142c
LAB_0010138f:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
LEA RAX,[RBP + -0x20]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101110
LEA RAX,[RBP + -0x20]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x00101100
MOV EAX,dword ptr [RBP + -0x28]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX + 0x8]
SUB EAX,0x1
CMP dword ptr [RBP + -0x24],EAX
JGE 0x00101428
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010c0
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV word ptr [RAX],0x202c
MOV byte ptr [RAX + 0x2],0x0
LAB_00101428:
ADD dword ptr [RBP + -0x24],0x1
LAB_0010142c:
MOV EAX,dword ptr [RBP + -0x28]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX + 0x8]
CMP dword ptr [RBP + -0x24],EAX
JL 0x0010138f
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010c0
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV word ptr [RAX],0x29
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x28],EAX
JGE 0x0010149c
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010c0
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV word ptr [RAX],0x202c
MOV byte ptr [RAX + 0x2],0x0
LAB_0010149c:
ADD dword ptr [RBP + -0x28],0x1
LAB_001014a0:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101362
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010c0
MOV RDX,RAX
LEA RAX,[0x104040]
ADD RAX,RDX
MOV word ptr [RAX],0x5d
LEA RAX,[0x104040]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001014e8
CALL 0x001010d0
LAB_001014e8:
LEAVE
RET | int1 * func0(void *param_1,int param_2)
{
size_t sVar1;
long in_FS_OFFSET;
int local_30;
int local_2c;
char local_28 [24];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
qsort(param_1,(long)param_2,0x10,compare_tuples);
result_1[0] = 0;
sVar1 = strlen(result_1);
*(int2 *)(result_1 + sVar1) = 0x5b;
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
sVar1 = strlen(result_1);
*(int2 *)(result_1 + sVar1) = 0x28;
for (local_2c = 0; local_2c < *(int *)((long)param_1 + (long)local_30 * 0x10 + 8);
local_2c = local_2c + 1) {
sprintf(local_28,"%d",
(ulong)*(uint *)(*(long *)((long)param_1 + (long)local_30 * 0x10) + (long)local_2c * 4
));
strcat(result_1,local_28);
if (local_2c < *(int *)((long)param_1 + (long)local_30 * 0x10 + 8) + -1) {
sVar1 = strlen(result_1);
*(int2 *)(result_1 + sVar1) = 0x202c;
result_1[sVar1 + 2] = 0;
}
}
sVar1 = strlen(result_1);
*(int2 *)(result_1 + sVar1) = 0x29;
if (local_30 < param_2 + -1) {
sVar1 = strlen(result_1);
*(int2 *)(result_1 + sVar1) = 0x202c;
result_1[sVar1 + 2] = 0;
}
}
sVar1 = strlen(result_1);
*(int2 *)(result_1 + sVar1) = 0x5d;
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return result_1;
} |
7,689 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
// Define a tuple structure
typedef struct {
int *elements;
int size;
} Tuple;
// Function to count the total number of digits in a tuple
int count_digs(Tuple tup) {
int total = 0;
for(int i = 0; i < tup.size; i++) {
int num = tup.elements[i];
if(num == 0) {
total += 1;
} else {
while(num != 0) {
total += 1;
num /= 10;
}
}
}
return total;
}
// Comparison function for sorting tuples based on digit count
int compare_tuples(const void *a, const void *b) {
Tuple *tupA = (Tuple *)a;
Tuple *tupB = (Tuple *)b;
int countA = count_digs(*tupA);
int countB = count_digs(*tupB);
return countA - countB;
}
// Function to convert the sorted list of tuples to a string
| char* func0(Tuple *list, int list_size) {
// Sort the list based on digit counts
qsort(list, list_size, sizeof(Tuple), compare_tuples);
// Allocate memory for the resulting string
// Assuming maximum size, adjust as needed
static char result[1000];
result[0] = '\0';
strcat(result, "[");
for(int i = 0; i < list_size; i++) {
strcat(result, "(");
for(int j = 0; j < list[i].size; j++) {
char num_str[20];
sprintf(num_str, "%d", list[i].elements[j]);
strcat(result, num_str);
if(j < list[i].size - 1) {
strcat(result, ", ");
}
}
strcat(result, ")");
if(i < list_size - 1) {
strcat(result, ", ");
}
}
strcat(result, "]");
return result;
}
| int main() {
// First test case
Tuple list1[4];
int elems1_0[] = {3, 4, 6, 723};
list1[0].elements = elems1_0;
list1[0].size = 4;
int elems1_1[] = {1, 2};
list1[1].elements = elems1_1;
list1[1].size = 2;
int elems1_2[] = {12345};
list1[2].elements = elems1_2;
list1[2].size = 1;
int elems1_3[] = {134, 234, 34};
list1[3].elements = elems1_3;
list1[3].size = 3;
assert(strcmp(func0(list1, 4), "[(1, 2), (12345), (3, 4, 6, 723), (134, 234, 34)]") == 0);
// Second test case
Tuple list2[4];
int elems2_0[] = {3, 4, 8};
list2[0].elements = elems2_0;
list2[0].size = 3;
int elems2_1[] = {1, 2};
list2[1].elements = elems2_1;
list2[1].size = 2;
int elems2_2[] = {1234335};
list2[2].elements = elems2_2;
list2[2].size = 1;
int elems2_3[] = {1345, 234, 334};
list2[3].elements = elems2_3;
list2[3].size = 3;
assert(strcmp(func0(list2, 4), "[(1, 2), (3, 4, 8), (1234335), (1345, 234, 334)]") == 0);
// Third test case
Tuple list3[4];
int elems3_0[] = {34, 4, 61, 723};
list3[0].elements = elems3_0;
list3[0].size = 4;
int elems3_1[] = {1, 2};
list3[1].elements = elems3_1;
list3[1].size = 2;
int elems3_2[] = {145};
list3[2].elements = elems3_2;
list3[2].size = 1;
int elems3_3[] = {134, 23};
list3[3].elements = elems3_3;
list3[3].size = 2;
assert(strcmp(func0(list3, 4), "[(1, 2), (145), (134, 23), (34, 4, 61, 723)]") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r13
mov %esi,%r15d
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movslq %esi,%rsi
lea -0x60(%rip),%rcx
mov $0x10,%edx
callq 10a0 <qsort@plt>
movb $0x0,0x2db5(%rip)
mov $0x3e8,%edx
lea 0xd6d(%rip),%rsi
lea 0x2da2(%rip),%rdi
callq 1090 <__strcat_chk@plt>
test %r15d,%r15d
jle 1399 <func0+0x151>
add $0x8,%r13
mov $0x0,%r14d
mov %rsp,%r12
jmpq 1353 <func0+0x10b>
mov $0x3e8,%edx
lea 0xd41(%rip),%rsi
lea 0x2d6f(%rip),%rdi
callq 1090 <__strcat_chk@plt>
add $0x1,%rbx
cmp %ebx,0x0(%rbp)
jle 1325 <func0+0xdd>
mov -0x8(%rbp),%rax
mov (%rax,%rbx,4),%r8d
lea 0xd1a(%rip),%rcx
mov $0x14,%edx
mov $0x1,%esi
mov %r12,%rdi
mov $0x0,%eax
callq 10d0 <__sprintf_chk@plt>
mov $0x3e8,%edx
mov %r12,%rsi
lea 0x2d2c(%rip),%rdi
callq 1090 <__strcat_chk@plt>
mov 0x0(%rbp),%eax
sub $0x1,%eax
cmp %ebx,%eax
jle 12d6 <func0+0x8e>
jmp 12be <func0+0x76>
mov $0x3e8,%edx
lea 0xcdd(%rip),%rsi
lea 0x2d08(%rip),%rdi
callq 1090 <__strcat_chk@plt>
lea -0x1(%r15),%eax
cmp %r14d,%eax
jg 137f <func0+0x137>
add $0x1,%r14d
add $0x10,%r13
cmp %r14d,%r15d
je 1399 <func0+0x151>
mov $0x3e8,%edx
lea 0xca7(%rip),%rsi
lea 0x2cda(%rip),%rdi
callq 1090 <__strcat_chk@plt>
mov %r13,%rbp
cmpl $0x0,0x0(%r13)
jle 1325 <func0+0xdd>
mov $0x0,%ebx
jmpq 12df <func0+0x97>
mov $0x3e8,%edx
lea 0xc80(%rip),%rsi
lea 0x2cae(%rip),%rdi
callq 1090 <__strcat_chk@plt>
jmp 1346 <func0+0xfe>
mov $0x3e8,%edx
lea 0xc6b(%rip),%rsi
lea 0x2c94(%rip),%rdi
callq 1090 <__strcat_chk@plt>
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 13d7 <func0+0x18f>
lea 0x2c78(%rip),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10b0 <__stack_chk_fail@plt>
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r15, rdi
mov ebx, esi
mov [rsp+68h+var_5C], esi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
movsxd rsi, esi
lea rcx, compare_tuples
mov edx, 10h
call _qsort
mov cs:result_1, 0
mov edx, 3E8h
lea rsi, unk_2004
lea rdi, result_1
call ___strcat_chk
test ebx, ebx
jle loc_13C0
add r15, 8
mov [rsp+68h+var_60], 0
lea r13, result_1
jmp loc_1377
loc_12E8:
add rbx, 1
cmp [rbp+0], ebx
jle short loc_1343
loc_12F1:
mov rax, [rbp-8]
mov r8d, [rax+rbx*4]
mov rcx, r14
mov edx, 14h
mov esi, 1
mov rdi, r12
mov eax, 0
call ___sprintf_chk
mov edx, 3E8h
mov rsi, r12
mov rdi, r13
call ___strcat_chk
mov eax, [rbp+0]
sub eax, 1
cmp eax, ebx
jle short loc_12E8
mov edx, 3E8h
lea rsi, unk_200B
mov rdi, r13
call ___strcat_chk
jmp short loc_12E8
loc_1343:
mov edx, 3E8h
lea rsi, unk_200E
mov rdi, r13
call ___strcat_chk
mov eax, [rsp+68h+var_5C]
sub eax, 1
cmp eax, [rsp+68h+var_60]
jg short loc_13AA
loc_1364:
add [rsp+68h+var_60], 1
mov eax, [rsp+68h+var_60]
add r15, 10h
cmp [rsp+68h+var_5C], eax
jz short loc_13C0
loc_1377:
mov edx, 3E8h
lea rsi, unk_2006
mov rdi, r13
call ___strcat_chk
mov rbp, r15
cmp dword ptr [r15], 0
jle short loc_1343
mov ebx, 0
lea r12, [rsp+68h+var_58]
lea r14, unk_2008
jmp loc_12F1
loc_13AA:
mov edx, 3E8h
lea rsi, unk_200B
mov rdi, r13
call ___strcat_chk
jmp short loc_1364
loc_13C0:
mov edx, 3E8h
lea rsi, unk_2010
lea rbx, result_1
mov rdi, rbx
call ___strcat_chk
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_13FD
mov rax, rbx
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_13FD:
call ___stack_chk_fail | char * func0(long long a1, int a2)
{
_DWORD *v2; // r15
long long v3; // rbx
int i; // [rsp+8h] [rbp-60h]
_BYTE v6[24]; // [rsp+10h] [rbp-58h] BYREF
unsigned long long v7; // [rsp+28h] [rbp-40h]
v7 = __readfsqword(0x28u);
qsort(a1, a2, 16LL, compare_tuples);
result_1 = 0;
__strcat_chk(&result_1, &unk_2004, 1000LL);
if ( a2 > 0 )
{
v2 = (_DWORD *)(a1 + 8);
for ( i = 0; i != a2; ++i )
{
__strcat_chk(&result_1, &unk_2006, 1000LL);
if ( (int)*v2 > 0 )
{
v3 = 0LL;
do
{
__sprintf_chk(v6, 1LL, 20LL, &unk_2008, *(unsigned int *)(*((_QWORD *)v2 - 1) + 4 * v3));
__strcat_chk(&result_1, v6, 1000LL);
if ( *v2 - 1 > (int)v3 )
__strcat_chk(&result_1, &unk_200B, 1000LL);
++v3;
}
while ( *v2 > (int)v3 );
}
__strcat_chk(&result_1, &unk_200E, 1000LL);
if ( a2 - 1 > i )
__strcat_chk(&result_1, &unk_200B, 1000LL);
v2 += 4;
}
}
__strcat_chk(&result_1, &unk_2010, 1000LL);
return &result_1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R15,RDI
MOV EBX,ESI
MOV dword ptr [RSP + 0xc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOVSXD RSI,ESI
LEA RCX,[0x10123a]
MOV EDX,0x10
CALL 0x001010b0
MOV byte ptr [0x00104040],0x0
MOV EDX,0x3e8
LEA RSI,[0x102004]
LEA RDI,[0x104040]
CALL 0x001010a0
TEST EBX,EBX
JLE 0x001013c0
ADD R15,0x8
MOV dword ptr [RSP + 0x8],0x0
LEA R13,[0x104040]
JMP 0x00101377
LAB_001012e8:
ADD RBX,0x1
CMP dword ptr [RBP],EBX
JLE 0x00101343
LAB_001012f1:
MOV RAX,qword ptr [RBP + -0x8]
MOV R8D,dword ptr [RAX + RBX*0x4]
MOV RCX,R14
MOV EDX,0x14
MOV ESI,0x1
MOV RDI,R12
MOV EAX,0x0
CALL 0x001010f0
MOV EDX,0x3e8
MOV RSI,R12
MOV RDI,R13
CALL 0x001010a0
MOV EAX,dword ptr [RBP]
SUB EAX,0x1
CMP EAX,EBX
JLE 0x001012e8
MOV EDX,0x3e8
LEA RSI,[0x10200b]
MOV RDI,R13
CALL 0x001010a0
JMP 0x001012e8
LAB_00101343:
MOV EDX,0x3e8
LEA RSI,[0x10200e]
MOV RDI,R13
CALL 0x001010a0
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x1
CMP EAX,dword ptr [RSP + 0x8]
JG 0x001013aa
LAB_00101364:
ADD dword ptr [RSP + 0x8],0x1
MOV EAX,dword ptr [RSP + 0x8]
ADD R15,0x10
CMP dword ptr [RSP + 0xc],EAX
JZ 0x001013c0
LAB_00101377:
MOV EDX,0x3e8
LEA RSI,[0x102006]
MOV RDI,R13
CALL 0x001010a0
MOV RBP,R15
CMP dword ptr [R15],0x0
JLE 0x00101343
MOV EBX,0x0
LEA R12,[RSP + 0x10]
LEA R14,[0x102008]
JMP 0x001012f1
LAB_001013aa:
MOV EDX,0x3e8
LEA RSI,[0x10200b]
MOV RDI,R13
CALL 0x001010a0
JMP 0x00101364
LAB_001013c0:
MOV EDX,0x3e8
LEA RSI,[0x102010]
LEA RBX,[0x104040]
MOV RDI,RBX
CALL 0x001010a0
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013fd
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001013fd:
CALL 0x001010c0 | int1 * func0(void *param_1,int param_2)
{
long lVar1;
int *piVar2;
long in_FS_OFFSET;
int local_60;
int1 local_58 [24];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
qsort(param_1,(long)param_2,0x10,compare_tuples);
result_1[0] = 0;
__strcat_chk(result_1,&DAT_00102004,1000);
if (0 < param_2) {
piVar2 = (int *)((long)param_1 + 8);
local_60 = 0;
do {
__strcat_chk(result_1,&DAT_00102006,1000);
if (0 < *piVar2) {
lVar1 = 0;
do {
__sprintf_chk(local_58,1,0x14,&DAT_00102008,
*(int4 *)(*(long *)(piVar2 + -2) + lVar1 * 4));
__strcat_chk(result_1,local_58,1000);
if ((int)lVar1 < *piVar2 + -1) {
__strcat_chk(result_1,&DAT_0010200b,1000);
}
lVar1 = lVar1 + 1;
} while ((int)lVar1 < *piVar2);
}
__strcat_chk(result_1,&DAT_0010200e,1000);
if (local_60 < param_2 + -1) {
__strcat_chk(result_1,&DAT_0010200b,1000);
}
local_60 = local_60 + 1;
piVar2 = piVar2 + 4;
} while (param_2 != local_60);
}
__strcat_chk(result_1,&DAT_00102010,1000);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return result_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,690 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
// Define a tuple structure
typedef struct {
int *elements;
int size;
} Tuple;
// Function to count the total number of digits in a tuple
int count_digs(Tuple tup) {
int total = 0;
for(int i = 0; i < tup.size; i++) {
int num = tup.elements[i];
if(num == 0) {
total += 1;
} else {
while(num != 0) {
total += 1;
num /= 10;
}
}
}
return total;
}
// Comparison function for sorting tuples based on digit count
int compare_tuples(const void *a, const void *b) {
Tuple *tupA = (Tuple *)a;
Tuple *tupB = (Tuple *)b;
int countA = count_digs(*tupA);
int countB = count_digs(*tupB);
return countA - countB;
}
// Function to convert the sorted list of tuples to a string
| char* func0(Tuple *list, int list_size) {
// Sort the list based on digit counts
qsort(list, list_size, sizeof(Tuple), compare_tuples);
// Allocate memory for the resulting string
// Assuming maximum size, adjust as needed
static char result[1000];
result[0] = '\0';
strcat(result, "[");
for(int i = 0; i < list_size; i++) {
strcat(result, "(");
for(int j = 0; j < list[i].size; j++) {
char num_str[20];
sprintf(num_str, "%d", list[i].elements[j]);
strcat(result, num_str);
if(j < list[i].size - 1) {
strcat(result, ", ");
}
}
strcat(result, ")");
if(i < list_size - 1) {
strcat(result, ", ");
}
}
strcat(result, "]");
return result;
}
| int main() {
// First test case
Tuple list1[4];
int elems1_0[] = {3, 4, 6, 723};
list1[0].elements = elems1_0;
list1[0].size = 4;
int elems1_1[] = {1, 2};
list1[1].elements = elems1_1;
list1[1].size = 2;
int elems1_2[] = {12345};
list1[2].elements = elems1_2;
list1[2].size = 1;
int elems1_3[] = {134, 234, 34};
list1[3].elements = elems1_3;
list1[3].size = 3;
assert(strcmp(func0(list1, 4), "[(1, 2), (12345), (3, 4, 6, 723), (134, 234, 34)]") == 0);
// Second test case
Tuple list2[4];
int elems2_0[] = {3, 4, 8};
list2[0].elements = elems2_0;
list2[0].size = 3;
int elems2_1[] = {1, 2};
list2[1].elements = elems2_1;
list2[1].size = 2;
int elems2_2[] = {1234335};
list2[2].elements = elems2_2;
list2[2].size = 1;
int elems2_3[] = {1345, 234, 334};
list2[3].elements = elems2_3;
list2[3].size = 3;
assert(strcmp(func0(list2, 4), "[(1, 2), (3, 4, 8), (1234335), (1345, 234, 334)]") == 0);
// Third test case
Tuple list3[4];
int elems3_0[] = {34, 4, 61, 723};
list3[0].elements = elems3_0;
list3[0].size = 4;
int elems3_1[] = {1, 2};
list3[1].elements = elems3_1;
list3[1].size = 2;
int elems3_2[] = {145};
list3[2].elements = elems3_2;
list3[2].size = 1;
int elems3_3[] = {134, 23};
list3[3].elements = elems3_3;
list3[3].size = 2;
assert(strcmp(func0(list3, 4), "[(1, 2), (145), (134, 23), (34, 4, 61, 723)]") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
movslq %esi,%rsi
mov $0x10,%edx
xor %r15d,%r15d
push %r14
lea -0x13a(%rip),%rcx
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
add $0x8,%rbp
sub $0x38,%rsp
mov %esi,0xc(%rsp)
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
callq 10c0 <qsort@plt>
mov $0x5b,%ecx
mov %ebx,%eax
sub $0x1,%ebx
mov %cx,0x29b8(%rip)
mov %ebx,0x8(%rsp)
test %eax,%eax
jle 1811 <func0+0x1e1>
nopl 0x0(%rax)
mov $0x3e8,%edx
lea 0x962(%rip),%rsi
lea 0x10(%rsp),%r13
xor %ebx,%ebx
lea 0x298e(%rip),%rdi
lea 0x2987(%rip),%r14
callq 10b0 <__strcat_chk@plt>
mov 0x0(%rbp),%edx
mov %r14,%r12
test %edx,%edx
jg 16dc <func0+0xac>
jmpq 1789 <func0+0x159>
nopl (%rax)
add $0x1,%rbx
cmp %ebx,%edx
jle 1789 <func0+0x159>
mov -0x8(%rbp),%rax
mov %r13,%rdi
mov $0x14,%edx
lea 0x919(%rip),%rcx
mov $0x1,%esi
mov (%rax,%rbx,4),%r8d
xor %eax,%eax
callq 1110 <__sprintf_chk@plt>
lea 0x293a(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 1706 <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 %r13,%rsi
sbb $0x3,%rdi
sub %r14,%rdi
add %r12,%rdi
callq 1100 <__stpcpy_chk@plt>
mov 0x0(%rbp),%edx
lea -0x1(%rdx),%ecx
cmp %ebx,%ecx
jle 16d0 <func0+0xa0>
lea 0x2cc5(%rip),%rcx
mov $0x3,%edx
mov %rax,%rdi
add $0x1,%rbx
sub %rax,%rcx
lea 0x892(%rip),%rsi
callq 10f0 <__memcpy_chk@plt>
mov 0x0(%rbp),%edx
cmp %ebx,%edx
jg 16dc <func0+0xac>
lea 0x28b0(%rip),%rcx
mov %rcx,%r12
mov %rcx,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 1796 <func0+0x166>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov %eax,%ebx
add %al,%bl
mov $0x29,%eax
sbb $0x3,%rdi
sub %rcx,%rdi
add %r12,%rdi
mov %ax,(%rdi)
add $0x1,%rdi
cmp %r15d,0x8(%rsp)
jle 17fe <func0+0x1ce>
lea 0x2c3e(%rip),%rcx
mov $0x3,%edx
lea 0x815(%rip),%rsi
sub %rdi,%rcx
callq 10f0 <__memcpy_chk@plt>
add $0x1,%r15d
add $0x10,%rbp
cmp %r15d,0xc(%rsp)
jne 1698 <func0+0x68>
mov $0x3e8,%edx
lea 0x7e7(%rip),%rsi
lea 0x281c(%rip),%rdi
callq 10b0 <__strcat_chk@plt>
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 184f <func0+0x21f>
add $0x38,%rsp
lea 0x27fc(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 10d0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r15
movsxd rsi, esi
mov edx, 10h
mov r15, rdi
push r14
lea rcx, compare_tuples
push r13
push r12
push rbp
push rbx
mov rbx, rsi
sub rsp, 38h
mov [rsp+68h+var_60], esi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
call _qsort
mov esi, 5Bh ; '['
mov cs:result_1, si
test ebx, ebx
jle loc_180F
mov eax, [rsp+68h+var_60]
mov [rsp+68h+var_64], 0
add r15, 8
lea r12, result_1
lea rbp, unk_2008
lea r14, unk_200B
sub eax, 1
mov [rsp+68h+var_5C], eax
loc_16F0:
mov edx, 3E8h
mov rdi, r12
lea rbx, [rsp+68h+var_58]
xor r13d, r13d
lea rsi, unk_2006
call ___strcat_chk
mov ecx, [r15]
test ecx, ecx
jg short loc_1721
jmp short loc_178A
loc_1718:
add r13, 1
cmp edx, r13d
jle short loc_178A
loc_1721:
mov rax, [r15-8]
mov rcx, rbp
mov edx, 14h
mov rdi, rbx
mov esi, 1
mov r8d, [rax+r13*4]
xor eax, eax
call ___sprintf_chk
mov rdi, r12
call _strlen
mov edx, 3E8h
mov rsi, rbx
lea rdi, [r12+rax]
call ___stpcpy_chk
mov edx, [r15]
lea ecx, [rdx-1]
cmp ecx, r13d
jle short loc_1718
mov edx, 3
mov rsi, r14
mov rdi, rax
add r13, 1
lea rcx, _end
sub rcx, rax
call ___memcpy_chk
mov edx, [r15]
cmp edx, r13d
jg short loc_1721
loc_178A:
mov rdi, r12
call _strlen
mov edx, 29h ; ')'
mov ebx, [rsp+68h+var_64]
add rax, r12
mov [rax], dx
lea rdi, [rax+1]
cmp [rsp+68h+var_5C], ebx
jle short loc_17C2
lea rcx, _end
mov edx, 3
mov rsi, r14
sub rcx, rdi
call ___memcpy_chk
loc_17C2:
add [rsp+68h+var_64], 1
add r15, 10h
mov eax, [rsp+68h+var_64]
cmp [rsp+68h+var_60], eax
jnz loc_16F0
loc_17D9:
mov edx, 3E8h
lea rsi, unk_2004
mov rdi, r12
call ___strcat_chk
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_1818
add rsp, 38h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_180F:
lea r12, result_1
jmp short loc_17D9
loc_1818:
call ___stack_chk_fail | __int16 * func0(long long a1, int a2)
{
_DWORD *v2; // r15
long long v3; // r13
long long v4; // rax
long long v5; // rax
_WORD *v6; // rax
int v8; // [rsp+4h] [rbp-64h]
_BYTE v9[24]; // [rsp+10h] [rbp-58h] BYREF
unsigned long long v10; // [rsp+28h] [rbp-40h]
v10 = __readfsqword(0x28u);
qsort(a1, a2, 16LL, compare_tuples);
result_1[0] = 91;
if ( a2 > 0 )
{
v8 = 0;
v2 = (_DWORD *)(a1 + 8);
do
{
v3 = 0LL;
__strcat_chk(result_1, &unk_2006, 1000LL);
if ( (int)*v2 > 0 )
{
do
{
while ( 1 )
{
__sprintf_chk(v9, 1LL, 20LL, &unk_2008, *(unsigned int *)(*((_QWORD *)v2 - 1) + 4 * v3));
v4 = strlen(result_1);
v5 = __stpcpy_chk((char *)result_1 + v4, v9, 1000LL);
if ( *v2 - 1 > (int)v3 )
break;
if ( *v2 <= (int)++v3 )
goto LABEL_8;
}
++v3;
__memcpy_chk(v5, &unk_200B, 3LL, (char *)&end - v5);
}
while ( *v2 > (int)v3 );
}
LABEL_8:
v6 = (__int16 *)((char *)result_1 + strlen(result_1));
*v6 = 41;
if ( a2 - 1 > v8 )
__memcpy_chk((char *)v6 + 1, &unk_200B, 3LL, &end - (_UNKNOWN *)((char *)v6 + 1));
++v8;
v2 += 4;
}
while ( a2 != v8 );
}
__strcat_chk(result_1, &unk_2004, 1000LL);
return result_1;
} | func0:
ENDBR64
PUSH R15
MOVSXD RSI,ESI
MOV EDX,0x10
MOV R15,RDI
PUSH R14
LEA RCX,[0x101540]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x38
MOV dword ptr [RSP + 0x8],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CALL 0x001010e0
MOV ESI,0x5b
MOV word ptr [0x00104040],SI
TEST EBX,EBX
JLE 0x0010180f
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x4],0x0
ADD R15,0x8
LEA R12,[0x104040]
LEA RBP,[0x102008]
LEA R14,[0x10200b]
SUB EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
LAB_001016f0:
MOV EDX,0x3e8
MOV RDI,R12
LEA RBX,[RSP + 0x10]
XOR R13D,R13D
LEA RSI,[0x102006]
CALL 0x001010d0
MOV ECX,dword ptr [R15]
TEST ECX,ECX
JG 0x00101721
JMP 0x0010178a
LAB_00101718:
ADD R13,0x1
CMP EDX,R13D
JLE 0x0010178a
LAB_00101721:
MOV RAX,qword ptr [R15 + -0x8]
MOV RCX,RBP
MOV EDX,0x14
MOV RDI,RBX
MOV ESI,0x1
MOV R8D,dword ptr [RAX + R13*0x4]
XOR EAX,EAX
CALL 0x00101150
MOV RDI,R12
CALL 0x001010f0
MOV EDX,0x3e8
MOV RSI,RBX
LEA RDI,[R12 + RAX*0x1]
CALL 0x00101140
MOV EDX,dword ptr [R15]
LEA ECX,[RDX + -0x1]
CMP ECX,R13D
JLE 0x00101718
MOV EDX,0x3
MOV RSI,R14
MOV RDI,RAX
ADD R13,0x1
LEA RCX,[0x104428]
SUB RCX,RAX
CALL 0x00101130
MOV EDX,dword ptr [R15]
CMP EDX,R13D
JG 0x00101721
LAB_0010178a:
MOV RDI,R12
CALL 0x001010f0
MOV EDX,0x29
MOV EBX,dword ptr [RSP + 0x4]
ADD RAX,R12
MOV word ptr [RAX],DX
LEA RDI,[RAX + 0x1]
CMP dword ptr [RSP + 0xc],EBX
JLE 0x001017c2
LEA RCX,[0x104428]
MOV EDX,0x3
MOV RSI,R14
SUB RCX,RDI
CALL 0x00101130
LAB_001017c2:
ADD dword ptr [RSP + 0x4],0x1
ADD R15,0x10
MOV EAX,dword ptr [RSP + 0x4]
CMP dword ptr [RSP + 0x8],EAX
JNZ 0x001016f0
LAB_001017d9:
MOV EDX,0x3e8
LEA RSI,[0x102004]
MOV RDI,R12
CALL 0x001010d0
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101818
ADD RSP,0x38
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010180f:
LEA R12,[0x104040]
JMP 0x001017d9
LAB_00101818:
CALL 0x00101100 | int1 * func0(void *param_1,int param_2)
{
long lVar1;
size_t sVar2;
long lVar3;
int *piVar4;
long in_FS_OFFSET;
int local_64;
int1 local_58 [24];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
qsort(param_1,(long)param_2,0x10,compare_tuples);
result_1._0_2_ = 0x5b;
if (0 < param_2) {
local_64 = 0;
piVar4 = (int *)((long)param_1 + 8);
do {
lVar3 = 0;
__strcat_chk(result_1,&DAT_00102006,1000);
if (0 < *piVar4) {
do {
while( true ) {
__sprintf_chk(local_58,1,0x14,&DAT_00102008,
*(int4 *)(*(long *)(piVar4 + -2) + lVar3 * 4));
sVar2 = strlen(result_1);
lVar1 = __stpcpy_chk(result_1 + sVar2,local_58,1000);
if (*piVar4 + -1 <= (int)lVar3) break;
lVar3 = lVar3 + 1;
__memcpy_chk(lVar1,&DAT_0010200b,3,(long)&_end - lVar1);
if (*piVar4 <= (int)lVar3) goto LAB_0010178a;
}
lVar3 = lVar3 + 1;
} while ((int)lVar3 < *piVar4);
}
LAB_0010178a:
sVar2 = strlen(result_1);
*(int2 *)(result_1 + sVar2) = 0x29;
if (local_64 < param_2 + -1) {
__memcpy_chk(sVar2 + 0x104041,&DAT_0010200b,3,(long)&_end - (sVar2 + 0x104041));
}
local_64 = local_64 + 1;
piVar4 = piVar4 + 4;
} while (param_2 != local_64);
}
__strcat_chk(result_1,&DAT_00102004,1000);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return result_1;
} |
7,691 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
// Define a tuple structure
typedef struct {
int *elements;
int size;
} Tuple;
// Function to count the total number of digits in a tuple
int count_digs(Tuple tup) {
int total = 0;
for(int i = 0; i < tup.size; i++) {
int num = tup.elements[i];
if(num == 0) {
total += 1;
} else {
while(num != 0) {
total += 1;
num /= 10;
}
}
}
return total;
}
// Comparison function for sorting tuples based on digit count
int compare_tuples(const void *a, const void *b) {
Tuple *tupA = (Tuple *)a;
Tuple *tupB = (Tuple *)b;
int countA = count_digs(*tupA);
int countB = count_digs(*tupB);
return countA - countB;
}
// Function to convert the sorted list of tuples to a string
| char* func0(Tuple *list, int list_size) {
// Sort the list based on digit counts
qsort(list, list_size, sizeof(Tuple), compare_tuples);
// Allocate memory for the resulting string
// Assuming maximum size, adjust as needed
static char result[1000];
result[0] = '\0';
strcat(result, "[");
for(int i = 0; i < list_size; i++) {
strcat(result, "(");
for(int j = 0; j < list[i].size; j++) {
char num_str[20];
sprintf(num_str, "%d", list[i].elements[j]);
strcat(result, num_str);
if(j < list[i].size - 1) {
strcat(result, ", ");
}
}
strcat(result, ")");
if(i < list_size - 1) {
strcat(result, ", ");
}
}
strcat(result, "]");
return result;
}
| int main() {
// First test case
Tuple list1[4];
int elems1_0[] = {3, 4, 6, 723};
list1[0].elements = elems1_0;
list1[0].size = 4;
int elems1_1[] = {1, 2};
list1[1].elements = elems1_1;
list1[1].size = 2;
int elems1_2[] = {12345};
list1[2].elements = elems1_2;
list1[2].size = 1;
int elems1_3[] = {134, 234, 34};
list1[3].elements = elems1_3;
list1[3].size = 3;
assert(strcmp(func0(list1, 4), "[(1, 2), (12345), (3, 4, 6, 723), (134, 234, 34)]") == 0);
// Second test case
Tuple list2[4];
int elems2_0[] = {3, 4, 8};
list2[0].elements = elems2_0;
list2[0].size = 3;
int elems2_1[] = {1, 2};
list2[1].elements = elems2_1;
list2[1].size = 2;
int elems2_2[] = {1234335};
list2[2].elements = elems2_2;
list2[2].size = 1;
int elems2_3[] = {1345, 234, 334};
list2[3].elements = elems2_3;
list2[3].size = 3;
assert(strcmp(func0(list2, 4), "[(1, 2), (3, 4, 8), (1234335), (1345, 234, 334)]") == 0);
// Third test case
Tuple list3[4];
int elems3_0[] = {34, 4, 61, 723};
list3[0].elements = elems3_0;
list3[0].size = 4;
int elems3_1[] = {1, 2};
list3[1].elements = elems3_1;
list3[1].size = 2;
int elems3_2[] = {145};
list3[2].elements = elems3_2;
list3[2].size = 1;
int elems3_3[] = {134, 23};
list3[3].elements = elems3_3;
list3[3].size = 2;
assert(strcmp(func0(list3, 4), "[(1, 2), (145), (134, 23), (34, 4, 61, 723)]") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
movslq %esi,%rsi
mov $0x10,%edx
lea -0x135(%rip),%rcx
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x38,%rsp
mov %esi,0x4(%rsp)
mov %rdi,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
callq 10c0 <qsort@plt>
mov $0x5b,%esi
mov %si,0x29e2(%rip)
test %ebx,%ebx
jle 18c9 <func0+0x2b9>
mov 0x4(%rsp),%eax
lea -0x1(%rax),%r14d
test %r14d,%r14d
jle 1978 <func0+0x368>
mov 0x8(%rsp),%rax
xor %r15d,%r15d
lea 0x10(%rsp),%rbp
lea 0x2d9d(%rip),%r12
lea 0x8(%rax),%rbx
mov $0x3e8,%edx
lea 0x96a(%rip),%rsi
lea 0x299d(%rip),%rdi
xor %r13d,%r13d
callq 10b0 <__strcat_chk@plt>
mov (%rbx),%ecx
test %ecx,%ecx
jle 173f <func0+0x12f>
nopl (%rax)
mov -0x8(%rbx),%rax
mov %rbp,%rdi
mov $0x14,%edx
lea 0x940(%rip),%rcx
mov $0x1,%esi
mov (%rax,%r13,4),%r8d
xor %eax,%eax
callq 1110 <__sprintf_chk@plt>
lea 0x295e(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 16e2 <func0+0xd2>
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 1100 <__stpcpy_chk@plt>
mov (%rbx),%edx
lea -0x1(%rdx),%ecx
cmp %r13d,%ecx
jg 1910 <func0+0x300>
add $0x1,%r13
cmp %r13d,%edx
jg 16b8 <func0+0xa8>
lea 0x28fa(%rip),%rcx
mov %rcx,%r13
mov %rcx,%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 174c <func0+0x13c>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rdi),%rdx
cmove %rdx,%rdi
mov $0x29,%edx
mov %eax,%esi
add %al,%sil
lea 0x87f(%rip),%rsi
sbb $0x3,%rdi
add $0x1,%r15d
add $0x10,%rbx
sub %rcx,%rdi
mov %r12,%rcx
add %r13,%rdi
mov %dx,(%rdi)
add $0x1,%rdi
mov $0x3,%edx
sub %rdi,%rcx
callq 10f0 <__memcpy_chk@plt>
cmp %r15d,%r14d
jg 1690 <func0+0x80>
cmp %r15d,0x4(%rsp)
jle 18c9 <func0+0x2b9>
movslq %r15d,%r12
shl $0x4,%r12
add 0x8(%rsp),%r12
nopw 0x0(%rax,%rax,1)
mov $0x3e8,%edx
lea 0x822(%rip),%rsi
lea 0x2855(%rip),%rdi
callq 10b0 <__strcat_chk@plt>
mov 0x8(%r12),%eax
test %eax,%eax
jle 189e <func0+0x28e>
lea 0x283c(%rip),%r14
xor %ebx,%ebx
lea 0x10(%rsp),%rbp
mov %r14,%r13
xchg %ax,%ax
mov (%r12),%rax
mov %rbp,%rdi
mov $0x14,%edx
lea 0x7e8(%rip),%rcx
mov $0x1,%esi
mov (%rax,%rbx,4),%r8d
xor %eax,%eax
callq 1110 <__sprintf_chk@plt>
lea 0x2806(%rip),%rdi
mov (%rdi),%edx
add $0x4,%rdi
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 183a <func0+0x22a>
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
sub %r14,%rdi
add %r13,%rdi
callq 1100 <__stpcpy_chk@plt>
mov 0x8(%r12),%edx
lea -0x1(%rdx),%ecx
cmp %ebx,%ecx
jg 1940 <func0+0x330>
add $0x1,%rbx
cmp %ebx,%edx
jg 1810 <func0+0x200>
mov $0x3e8,%edx
lea 0x764(%rip),%rsi
add $0x1,%r15d
add $0x10,%r12
lea 0x2787(%rip),%rdi
callq 10b0 <__strcat_chk@plt>
cmp %r15d,0x4(%rsp)
jg 17d8 <func0+0x1c8>
mov $0x3e8,%edx
lea 0x72f(%rip),%rsi
lea 0x2764(%rip),%rdi
callq 10b0 <__strcat_chk@plt>
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 1980 <func0+0x370>
add $0x38,%rsp
lea 0x2740(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov %r12,%rcx
mov $0x3,%edx
mov %rax,%rdi
add $0x1,%r13
sub %rax,%rcx
lea 0x6df(%rip),%rsi
callq 10f0 <__memcpy_chk@plt>
cmp %r13d,(%rbx)
jg 16b8 <func0+0xa8>
jmpq 173f <func0+0x12f>
nopl 0x0(%rax)
lea 0x2ae1(%rip),%rcx
mov $0x3,%edx
mov %rax,%rdi
add $0x1,%rbx
sub %rax,%rcx
lea 0x6ab(%rip),%rsi
callq 10f0 <__memcpy_chk@plt>
cmp %ebx,0x8(%r12)
jg 1810 <func0+0x200>
jmpq 189e <func0+0x28e>
nopw 0x0(%rax,%rax,1)
xor %r15d,%r15d
jmpq 17c6 <func0+0x1b6>
callq 10d0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
movsxd rsi, esi; nmemb
mov edx, 10h; size
lea rcx, compare_tuples; compar
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rsi
sub rsp, 38h
mov [rsp+68h+var_68], esi
mov [rsp+68h+var_60], rdi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
call _qsort
mov esi, 5Bh ; '['
mov cs:result_1, si
test ebx, ebx
jle loc_18E8
mov eax, [rsp+68h+var_68]
xor r13d, r13d
lea rbx, result_1
lea esi, [rax-1]
test esi, esi
jg loc_179E
loc_16AD:
mov r14, [rsp+68h+var_60]
movsxd r10, r13d
lea r12, unk_200B
shl r10, 4
add r14, r10
nop dword ptr [rax+rax+00h]
loc_16C8:
mov edx, 3E8h
lea rsi, unk_2006
mov rdi, rbx
call ___strcat_chk
mov eax, [r14+8]
test eax, eax
jle short loc_173E
xor ebp, ebp
lea r15, [rsp+68h+var_58]
nop dword ptr [rax+rax+00h]
loc_16F0:
mov rax, [r14]
mov rcx, r12
mov edx, 14h
mov esi, 2
mov rdi, r15
mov r8d, [rax+rbp*4]
xor eax, eax
call ___sprintf_chk
mov rdi, rbx; s
call _strlen
mov edx, 3E8h
mov rsi, r15
lea rdi, [rbx+rax]
call ___stpcpy_chk
mov edx, [r14+8]
lea ecx, [rdx-1]
cmp ecx, ebp
jg loc_1880
add rbp, 1
cmp edx, ebp
jg short loc_16F0
loc_173E:
mov edx, 3E8h
mov rdi, rbx
add r13d, 1
add r14, 10h
lea rsi, unk_200E
call ___strcat_chk
cmp [rsp+68h+var_68], r13d
jg loc_16C8
loc_1764:
mov edx, 3E8h
lea rsi, unk_2004
mov rdi, rbx
call ___strcat_chk
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz loc_18F4
add rsp, 38h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_179E:
mov rax, [rsp+68h+var_60]
mov [rsp+68h+var_64], esi
lea r12, unk_200B
lea r14, [rax+8]
loc_17B2:
mov edx, 3E8h
mov rdi, rbx
lea r15, [rsp+68h+var_58]
xor ebp, ebp
lea rsi, unk_2006
call ___strcat_chk
mov ecx, [r14]
test ecx, ecx
jle short loc_1826
nop dword ptr [rax+00h]
loc_17D8:
mov rax, [r14-8]
mov rcx, r12
mov edx, 14h
mov rdi, r15
mov esi, 2
mov r8d, [rax+rbp*4]
xor eax, eax
call ___sprintf_chk
mov rdi, rbx; s
call _strlen
mov edx, 3E8h
mov rsi, r15
lea rdi, [rbx+rax]
call ___stpcpy_chk
mov edx, [r14]
lea ecx, [rdx-1]
cmp ecx, ebp
jg loc_18B8
add rbp, 1
cmp edx, ebp
jg short loc_17D8
loc_1826:
mov rdi, rbx; s
add r13d, 1
add r14, 10h
call _strlen
mov edx, 29h ; ')'
lea rcx, _end
lea rsi, unk_2008
lea rdi, [rbx+rax]
mov [rdi], dx
add rdi, 1
mov edx, 3
sub rcx, rdi
call ___memcpy_chk
cmp [rsp+68h+var_64], r13d
jg loc_17B2
cmp [rsp+68h+var_68], r13d
jg loc_16AD
jmp loc_1764
loc_1880:
lea rcx, _end
mov edx, 3
mov rdi, rax
add rbp, 1
sub rcx, rax
lea rsi, unk_2008
call ___memcpy_chk
cmp [r14+8], ebp
jg loc_16F0
jmp loc_173E
loc_18B8:
lea rcx, _end
mov edx, 3
mov rdi, rax
add rbp, 1
sub rcx, rax
lea rsi, unk_2008
call ___memcpy_chk
cmp [r14], ebp
jg loc_17D8
jmp loc_1826
loc_18E8:
lea rbx, result_1
jmp loc_1764
loc_18F4:
call ___stack_chk_fail | char * func0(_DWORD *a1, int a2)
{
int v2; // r13d
int v3; // esi
char *v4; // r14
long long v5; // rbp
size_t v6; // rax
long long v7; // rax
int v8; // edx
_DWORD *v10; // r14
long long v11; // rbp
size_t v12; // rax
long long v13; // rax
size_t v14; // rax
_BYTE v16[24]; // [rsp+10h] [rbp-58h] BYREF
unsigned long long v17; // [rsp+28h] [rbp-40h]
v17 = __readfsqword(0x28u);
qsort(a1, a2, 0x10uLL, compare_tuples);
strcpy(result_1, "[");
if ( a2 > 0 )
{
v2 = 0;
v3 = a2 - 1;
if ( a2 - 1 <= 0 )
goto LABEL_3;
v10 = a1 + 2;
do
{
v11 = 0LL;
__strcat_chk(result_1, &unk_2006, 1000LL);
if ( (int)*v10 > 0 )
{
do
{
while ( 1 )
{
__sprintf_chk(v16, 2LL, 20LL, &unk_200B, *(unsigned int *)(*((_QWORD *)v10 - 1) + 4 * v11));
v12 = strlen(result_1);
v13 = __stpcpy_chk(&result_1[v12], v16, 1000LL);
if ( *v10 - 1 > (int)v11 )
break;
if ( *v10 <= (int)++v11 )
goto LABEL_14;
}
++v11;
__memcpy_chk(v13, &unk_2008, 3LL, (char *)&end - v13);
}
while ( *v10 > (int)v11 );
}
LABEL_14:
++v2;
v10 += 4;
v14 = strlen(result_1);
*(_WORD *)&result_1[v14] = 41;
__memcpy_chk(&result_1[v14 + 1], &unk_2008, 3LL, &end - (_UNKNOWN *)&result_1[v14 + 1]);
}
while ( v3 > v2 );
if ( a2 > v2 )
{
LABEL_3:
v4 = (char *)&a1[4 * v2];
do
{
__strcat_chk(result_1, &unk_2006, 1000LL);
if ( *((int *)v4 + 2) > 0 )
{
v5 = 0LL;
do
{
while ( 1 )
{
__sprintf_chk(v16, 2LL, 20LL, &unk_200B, *(unsigned int *)(*(_QWORD *)v4 + 4 * v5));
v6 = strlen(result_1);
v7 = __stpcpy_chk(&result_1[v6], v16, 1000LL);
v8 = *((_DWORD *)v4 + 2);
if ( v8 - 1 > (int)v5 )
break;
if ( v8 <= (int)++v5 )
goto LABEL_8;
}
++v5;
__memcpy_chk(v7, &unk_2008, 3LL, (char *)&end - v7);
}
while ( *((_DWORD *)v4 + 2) > (int)v5 );
}
LABEL_8:
++v2;
v4 += 16;
__strcat_chk(result_1, &unk_200E, 1000LL);
}
while ( a2 > v2 );
}
}
__strcat_chk(result_1, &unk_2004, 1000LL);
return result_1;
} | func0:
ENDBR64
PUSH R15
MOVSXD RSI,ESI
MOV EDX,0x10
LEA RCX,[0x101520]
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x38
MOV dword ptr [RSP],ESI
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CALL 0x001010e0
MOV ESI,0x5b
MOV word ptr [0x00104040],SI
TEST EBX,EBX
JLE 0x001018e8
MOV EAX,dword ptr [RSP]
XOR R13D,R13D
LEA RBX,[0x104040]
LEA ESI,[RAX + -0x1]
TEST ESI,ESI
JG 0x0010179e
LAB_001016ad:
MOV R14,qword ptr [RSP + 0x8]
MOVSXD R10,R13D
LEA R12,[0x10200b]
SHL R10,0x4
ADD R14,R10
NOP dword ptr [RAX + RAX*0x1]
LAB_001016c8:
MOV EDX,0x3e8
LEA RSI,[0x102006]
MOV RDI,RBX
CALL 0x001010d0
MOV EAX,dword ptr [R14 + 0x8]
TEST EAX,EAX
JLE 0x0010173e
XOR EBP,EBP
LEA R15,[RSP + 0x10]
NOP dword ptr [RAX + RAX*0x1]
LAB_001016f0:
MOV RAX,qword ptr [R14]
MOV RCX,R12
MOV EDX,0x14
MOV ESI,0x2
MOV RDI,R15
MOV R8D,dword ptr [RAX + RBP*0x4]
XOR EAX,EAX
CALL 0x00101150
MOV RDI,RBX
CALL 0x001010f0
MOV EDX,0x3e8
MOV RSI,R15
LEA RDI,[RBX + RAX*0x1]
CALL 0x00101140
MOV EDX,dword ptr [R14 + 0x8]
LEA ECX,[RDX + -0x1]
CMP ECX,EBP
JG 0x00101880
ADD RBP,0x1
CMP EDX,EBP
JG 0x001016f0
LAB_0010173e:
MOV EDX,0x3e8
MOV RDI,RBX
ADD R13D,0x1
ADD R14,0x10
LEA RSI,[0x10200e]
CALL 0x001010d0
CMP dword ptr [RSP],R13D
JG 0x001016c8
LAB_00101764:
MOV EDX,0x3e8
LEA RSI,[0x102004]
MOV RDI,RBX
CALL 0x001010d0
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001018f4
ADD RSP,0x38
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010179e:
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x4],ESI
LEA R12,[0x10200b]
LEA R14,[RAX + 0x8]
LAB_001017b2:
MOV EDX,0x3e8
MOV RDI,RBX
LEA R15,[RSP + 0x10]
XOR EBP,EBP
LEA RSI,[0x102006]
CALL 0x001010d0
MOV ECX,dword ptr [R14]
TEST ECX,ECX
JLE 0x00101826
NOP dword ptr [RAX]
LAB_001017d8:
MOV RAX,qword ptr [R14 + -0x8]
MOV RCX,R12
MOV EDX,0x14
MOV RDI,R15
MOV ESI,0x2
MOV R8D,dword ptr [RAX + RBP*0x4]
XOR EAX,EAX
CALL 0x00101150
MOV RDI,RBX
CALL 0x001010f0
MOV EDX,0x3e8
MOV RSI,R15
LEA RDI,[RBX + RAX*0x1]
CALL 0x00101140
MOV EDX,dword ptr [R14]
LEA ECX,[RDX + -0x1]
CMP ECX,EBP
JG 0x001018b8
ADD RBP,0x1
CMP EDX,EBP
JG 0x001017d8
LAB_00101826:
MOV RDI,RBX
ADD R13D,0x1
ADD R14,0x10
CALL 0x001010f0
MOV EDX,0x29
LEA RCX,[0x104428]
LEA RSI,[0x102008]
LEA RDI,[RBX + RAX*0x1]
MOV word ptr [RDI],DX
ADD RDI,0x1
MOV EDX,0x3
SUB RCX,RDI
CALL 0x00101130
CMP dword ptr [RSP + 0x4],R13D
JG 0x001017b2
CMP dword ptr [RSP],R13D
JG 0x001016ad
JMP 0x00101764
LAB_00101880:
LEA RCX,[0x104428]
MOV EDX,0x3
MOV RDI,RAX
ADD RBP,0x1
SUB RCX,RAX
LEA RSI,[0x102008]
CALL 0x00101130
CMP dword ptr [R14 + 0x8],EBP
JG 0x001016f0
JMP 0x0010173e
LAB_001018b8:
LEA RCX,[0x104428]
MOV EDX,0x3
MOV RDI,RAX
ADD RBP,0x1
SUB RCX,RAX
LEA RSI,[0x102008]
CALL 0x00101130
CMP dword ptr [R14],EBP
JG 0x001017d8
JMP 0x00101826
LAB_001018e8:
LEA RBX,[0x104040]
JMP 0x00101764
LAB_001018f4:
CALL 0x00101100 | int1 * func0(void *param_1,int param_2)
{
size_t sVar1;
long lVar2;
long lVar3;
int iVar4;
long *plVar5;
int *piVar6;
long in_FS_OFFSET;
int local_58 [24];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
qsort(param_1,(long)param_2,0x10,compare_tuples);
result_1._0_2_ = 0x5b;
if (0 < param_2) {
iVar4 = 0;
if (0 < param_2 + -1) {
piVar6 = (int *)((long)param_1 + 8);
do {
lVar3 = 0;
__strcat_chk(result_1,&DAT_00102006,1000);
if (0 < *piVar6) {
do {
while( true ) {
__sprintf_chk(local_58,2,0x14,&DAT_0010200b,
*(int4 *)(*(long *)(piVar6 + -2) + lVar3 * 4));
sVar1 = strlen(result_1);
lVar2 = __stpcpy_chk(result_1 + sVar1,local_58,1000);
if ((int)lVar3 < *piVar6 + -1) break;
lVar3 = lVar3 + 1;
if (*piVar6 <= (int)lVar3) goto LAB_00101826;
}
lVar3 = lVar3 + 1;
__memcpy_chk(lVar2,&DAT_00102008,3,(long)&_end - lVar2);
} while ((int)lVar3 < *piVar6);
}
LAB_00101826:
iVar4 = iVar4 + 1;
piVar6 = piVar6 + 4;
sVar1 = strlen(result_1);
*(int2 *)(result_1 + sVar1) = 0x29;
__memcpy_chk(sVar1 + 0x104041,&DAT_00102008,3,(long)&_end - (sVar1 + 0x104041));
} while (iVar4 < param_2 + -1);
if (param_2 <= iVar4) goto LAB_00101764;
}
plVar5 = (long *)((long)param_1 + (long)iVar4 * 0x10);
do {
__strcat_chk(result_1,&DAT_00102006,1000);
if (0 < *(int *)(plVar5 + 1)) {
lVar3 = 0;
do {
while( true ) {
__sprintf_chk(local_58,2,0x14,&DAT_0010200b,*(int4 *)(*plVar5 + lVar3 * 4));
sVar1 = strlen(result_1);
lVar2 = __stpcpy_chk(result_1 + sVar1,local_58,1000);
if ((int)lVar3 < *(int *)(plVar5 + 1) + -1) break;
lVar3 = lVar3 + 1;
if (*(int *)(plVar5 + 1) <= (int)lVar3) goto LAB_0010173e;
}
lVar3 = lVar3 + 1;
__memcpy_chk(lVar2,&DAT_00102008,3,(long)&_end - lVar2);
} while ((int)lVar3 < *(int *)(plVar5 + 1));
}
LAB_0010173e:
iVar4 = iVar4 + 1;
plVar5 = plVar5 + 2;
__strcat_chk(result_1,&DAT_0010200e,1000);
} while (iVar4 < param_2);
}
LAB_00101764:
__strcat_chk(result_1,&DAT_00102004,1000);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return result_1;
} |
7,692 | func0 |
#include <assert.h>
#include <string.h>
| const char* func0(int year) {
const char* sign;
int remainder = (year - 2000) % 12;
if (remainder < 0) {
remainder += 12;
}
switch (remainder) {
case 0:
sign = "Dragon";
break;
case 1:
sign = "Snake";
break;
case 2:
sign = "Horse";
break;
case 3:
sign = "sheep";
break;
case 4:
sign = "Monkey";
break;
case 5:
sign = "Rooster";
break;
case 6:
sign = "Dog";
break;
case 7:
sign = "Pig";
break;
case 8:
sign = "Rat";
break;
case 9:
sign = "Ox";
break;
case 10:
sign = "Tiger";
break;
default:
sign = "Hare";
break;
}
return sign;
}
| int main() {
assert(strcmp(func0(1997), "Ox") == 0);
assert(strcmp(func0(1998), "Tiger") == 0);
assert(strcmp(func0(1994), "Dog") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
lea -0x7d0(%rax),%edx
movslq %edx,%rax
imul $0x2aaaaaab,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar %ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%eax
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%ecx
mov %ecx,%eax
add %eax,%eax
add %ecx,%eax
shl $0x2,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0xc(%rbp)
cmpl $0x0,-0xc(%rbp)
jns 11b8 <func0+0x4f>
addl $0xc,-0xc(%rbp)
cmpl $0xa,-0xc(%rbp)
ja 127b <func0+0x112>
mov -0xc(%rbp),%eax
lea 0x0(,%rax,4),%rdx
lea 0xe78(%rip),%rax
mov (%rdx,%rax,1),%eax
cltq
lea 0xe6c(%rip),%rdx
add %rdx,%rax
notrack jmpq *%rax
lea 0xe1b(%rip),%rax
mov %rax,-0x8(%rbp)
jmpq 1287 <func0+0x11e>
lea 0xe12(%rip),%rax
mov %rax,-0x8(%rbp)
jmpq 1287 <func0+0x11e>
lea 0xe08(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 1287 <func0+0x11e>
lea 0xe01(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 1287 <func0+0x11e>
lea 0xdfa(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 1287 <func0+0x11e>
lea 0xdf4(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 1287 <func0+0x11e>
lea 0xdef(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 1287 <func0+0x11e>
lea 0xde6(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 1287 <func0+0x11e>
lea 0xddd(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 1287 <func0+0x11e>
lea 0xdd4(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 1287 <func0+0x11e>
lea 0xdca(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 1287 <func0+0x11e>
lea 0xdc3(%rip),%rax
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
lea edx, [rax-7D0h]
movsxd rax, edx
imul rax, 2AAAAAABh
shr rax, 20h
sar eax, 1
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
mov [rbp+var_C], eax
mov ecx, [rbp+var_C]
mov eax, ecx
add eax, eax
add eax, ecx
shl eax, 2
sub edx, eax
mov [rbp+var_C], edx
cmp [rbp+var_C], 0
jns short loc_11B2
add [rbp+var_C], 0Ch
loc_11B2:
cmp [rbp+var_C], 0Ah; switch 11 cases
ja def_11DD; jumptable 00000000000011DD default case
mov eax, [rbp+var_C]
lea rdx, ds:0[rax*4]
lea rax, jpt_11DD
mov eax, ds:(jpt_11DD - 204Ch)[rdx+rax]
cdqe
lea rdx, jpt_11DD
add rax, rdx
jmp rax; switch jump
loc_11E0:
lea rax, aDragon; jumptable 00000000000011DD case 0
mov [rbp+var_8], rax
jmp loc_1281
loc_11F0:
lea rax, aSnake; jumptable 00000000000011DD case 1
mov [rbp+var_8], rax
jmp loc_1281
loc_1200:
lea rax, aHorse; jumptable 00000000000011DD case 2
mov [rbp+var_8], rax
jmp short loc_1281
loc_120D:
lea rax, aSheep; jumptable 00000000000011DD case 3
mov [rbp+var_8], rax
jmp short loc_1281
loc_121A:
lea rax, aMonkey; jumptable 00000000000011DD case 4
mov [rbp+var_8], rax
jmp short loc_1281
loc_1227:
lea rax, aRooster; jumptable 00000000000011DD case 5
mov [rbp+var_8], rax
jmp short loc_1281
loc_1234:
lea rax, aDog; jumptable 00000000000011DD case 6
mov [rbp+var_8], rax
jmp short loc_1281
loc_1241:
lea rax, aPig; jumptable 00000000000011DD case 7
mov [rbp+var_8], rax
jmp short loc_1281
loc_124E:
lea rax, aRat; jumptable 00000000000011DD case 8
mov [rbp+var_8], rax
jmp short loc_1281
loc_125B:
lea rax, s2; jumptable 00000000000011DD case 9
mov [rbp+var_8], rax
jmp short loc_1281
loc_1268:
lea rax, aTiger; jumptable 00000000000011DD case 10
mov [rbp+var_8], rax
jmp short loc_1281
def_11DD:
lea rax, aHare; jumptable 00000000000011DD default case
mov [rbp+var_8], rax
nop
loc_1281:
mov rax, [rbp+var_8]
pop rbp
retn | const char * func0(int a1)
{
const char *v2; // [rsp+Ch] [rbp-8h]
switch ( (a1 - 2000) % 12 + ((a1 - 2000) % 12 < 0 ? 0xC : 0) )
{
case 0:
v2 = "Dragon";
break;
case 1:
v2 = "Snake";
break;
case 2:
v2 = "Horse";
break;
case 3:
v2 = "sheep";
break;
case 4:
v2 = "Monkey";
break;
case 5:
v2 = "Rooster";
break;
case 6:
v2 = "Dog";
break;
case 7:
v2 = "Pig";
break;
case 8:
v2 = "Rat";
break;
case 9:
v2 = "Ox";
break;
case 0xA:
v2 = "Tiger";
break;
default:
v2 = "Hare";
break;
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
LEA EDX,[RAX + -0x7d0]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SAR EAX,0x1
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
MOV dword ptr [RBP + -0xc],EAX
MOV ECX,dword ptr [RBP + -0xc]
MOV EAX,ECX
ADD EAX,EAX
ADD EAX,ECX
SHL EAX,0x2
SUB EDX,EAX
MOV dword ptr [RBP + -0xc],EDX
CMP dword ptr [RBP + -0xc],0x0
JNS 0x001011b2
ADD dword ptr [RBP + -0xc],0xc
LAB_001011b2:
CMP dword ptr [RBP + -0xc],0xa
JA 0x00101275
MOV EAX,dword ptr [RBP + -0xc]
LEA RDX,[RAX*0x4]
LEA RAX,[0x10204c]
MOV EAX,dword ptr [RDX + RAX*0x1]
CDQE
LEA RDX,[0x10204c]
ADD RAX,RDX
switchD:
JMP RAX
caseD_0:
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101281
caseD_1:
LEA RAX,[0x10200f]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101281
caseD_2:
LEA RAX,[0x102015]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101281
caseD_3:
LEA RAX,[0x10201b]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101281
caseD_4:
LEA RAX,[0x102021]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101281
caseD_5:
LEA RAX,[0x102028]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101281
caseD_6:
LEA RAX,[0x102030]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101281
caseD_7:
LEA RAX,[0x102034]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101281
caseD_8:
LEA RAX,[0x102038]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101281
caseD_9:
LEA RAX,[0x10203c]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101281
caseD_a:
LEA RAX,[0x10203f]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00101281
caseD_b:
LEA RAX,[0x102045]
MOV qword ptr [RBP + -0x8],RAX
NOP
LAB_00101281:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET | char * func0(int param_1)
{
int local_14;
char *local_10;
local_14 = param_1 + -2000;
local_14 = local_14 + ((local_14 / 6 + (local_14 >> 0x1f) >> 1) - (local_14 >> 0x1f)) * -0xc;
if (local_14 < 0) {
local_14 = local_14 + 0xc;
}
switch(local_14) {
case 0:
local_10 = "Dragon";
break;
case 1:
local_10 = "Snake";
break;
case 2:
local_10 = "Horse";
break;
case 3:
local_10 = "sheep";
break;
case 4:
local_10 = "Monkey";
break;
case 5:
local_10 = "Rooster";
break;
case 6:
local_10 = "Dog";
break;
case 7:
local_10 = "Pig";
break;
case 8:
local_10 = "Rat";
break;
case 9:
local_10 = "Ox";
break;
case 10:
local_10 = "Tiger";
break;
default:
local_10 = "Hare";
}
return local_10;
} |
7,693 | func0 |
#include <assert.h>
#include <string.h>
| const char* func0(int year) {
const char* sign;
int remainder = (year - 2000) % 12;
if (remainder < 0) {
remainder += 12;
}
switch (remainder) {
case 0:
sign = "Dragon";
break;
case 1:
sign = "Snake";
break;
case 2:
sign = "Horse";
break;
case 3:
sign = "sheep";
break;
case 4:
sign = "Monkey";
break;
case 5:
sign = "Rooster";
break;
case 6:
sign = "Dog";
break;
case 7:
sign = "Pig";
break;
case 8:
sign = "Rat";
break;
case 9:
sign = "Ox";
break;
case 10:
sign = "Tiger";
break;
default:
sign = "Hare";
break;
}
return sign;
}
| int main() {
assert(strcmp(func0(1997), "Ox") == 0);
assert(strcmp(func0(1998), "Tiger") == 0);
assert(strcmp(func0(1994), "Dog") == 0);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x7d0,%edi
movslq %edi,%rax
imul $0x2aaaaaab,%rax,%rax
sar $0x21,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,2),%eax
shl $0x2,%eax
sub %eax,%edi
mov %edi,%eax
lea 0xc(%rdi),%edx
cmovs %edx,%eax
cmp $0xa,%eax
ja 11c0 <func0+0x97>
mov %eax,%eax
lea 0xee2(%rip),%rdx
movslq (%rdx,%rax,4),%rax
add %rdx,%rax
notrack jmpq *%rax
lea 0xec9(%rip),%rax
retq
lea 0xe91(%rip),%rax
retq
lea 0xe8f(%rip),%rax
retq
lea 0xe8d(%rip),%rax
retq
lea 0xe8c(%rip),%rax
retq
lea 0xe8c(%rip),%rax
retq
lea 0xe88(%rip),%rax
retq
lea 0xe84(%rip),%rax
retq
lea 0xe80(%rip),%rax
retq
lea 0xe7b(%rip),%rax
retq
lea 0xe3d(%rip),%rax
retq
lea 0xe3a(%rip),%rax
retq
| func0:
endbr64
sub edi, 7D0h
movsxd rax, edi
imul rax, 2AAAAAABh
sar rax, 21h
mov edx, edi
sar edx, 1Fh
sub eax, edx
lea edx, [rax+rax*2]
shl edx, 2
mov eax, edi
sub eax, edx
lea edx, [rax+0Ch]
cmovs eax, edx
cmp eax, 0Ah; switch 11 cases
ja short def_116D; jumptable 000000000000116D default case
mov eax, eax
lea rdx, jpt_116D
movsxd rax, ds:(jpt_116D - 2048h)[rdx+rax*4]
add rax, rdx
jmp rax; switch jump
loc_1170:
lea rax, aSnake; jumptable 000000000000116D case 1
retn
loc_1178:
lea rax, aHorse; jumptable 000000000000116D case 2
retn
loc_1180:
lea rax, aSheep; jumptable 000000000000116D case 3
retn
loc_1188:
lea rax, aMonkey; jumptable 000000000000116D case 4
retn
loc_1190:
lea rax, aRooster; jumptable 000000000000116D case 5
retn
loc_1198:
lea rax, aDog; jumptable 000000000000116D case 6
retn
loc_11A0:
lea rax, aPig; jumptable 000000000000116D case 7
retn
loc_11A8:
lea rax, aRat; jumptable 000000000000116D case 8
retn
loc_11B0:
lea rax, aOx; jumptable 000000000000116D case 9
retn
loc_11B8:
lea rax, aTiger; jumptable 000000000000116D case 10
retn
def_116D:
lea rax, aHare; jumptable 000000000000116D default case
retn
loc_11C8:
lea rax, aDragon; jumptable 000000000000116D case 0
retn | const char * func0(int a1)
{
const char *result; // rax
switch ( (a1 - 2000) % 12 + ((a1 - 2000) % 12 < 0 ? 0xC : 0) )
{
case 0:
result = "Dragon";
break;
case 1:
result = "Snake";
break;
case 2:
result = "Horse";
break;
case 3:
result = "sheep";
break;
case 4:
result = "Monkey";
break;
case 5:
result = "Rooster";
break;
case 6:
result = "Dog";
break;
case 7:
result = "Pig";
break;
case 8:
result = "Rat";
break;
case 9:
result = "Ox";
break;
case 0xA:
result = "Tiger";
break;
default:
result = "Hare";
break;
}
return result;
} | func0:
ENDBR64
SUB EDI,0x7d0
MOVSXD RAX,EDI
IMUL RAX,RAX,0x2aaaaaab
SAR RAX,0x21
MOV EDX,EDI
SAR EDX,0x1f
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x2]
SHL EDX,0x2
MOV EAX,EDI
SUB EAX,EDX
LEA EDX,[RAX + 0xc]
CMOVS EAX,EDX
CMP EAX,0xa
JA 0x001011c0
MOV EAX,EAX
LEA RDX,[0x102048]
MOVSXD RAX,dword ptr [RDX + RAX*0x4]
ADD RAX,RDX
switchD:
JMP RAX
caseD_1:
LEA RAX,[0x10200b]
RET
caseD_2:
LEA RAX,[0x102011]
RET
caseD_3:
LEA RAX,[0x102017]
RET
caseD_4:
LEA RAX,[0x10201d]
RET
caseD_5:
LEA RAX,[0x102024]
RET
caseD_6:
LEA RAX,[0x10202c]
RET
caseD_7:
LEA RAX,[0x102030]
RET
caseD_8:
LEA RAX,[0x102034]
RET
caseD_9:
LEA RAX,[0x102038]
RET
caseD_a:
LEA RAX,[0x10203b]
RET
default:
LEA RAX,[0x102041]
RET
caseD_0:
LEA RAX,[0x102004]
RET | char * func0(int param_1)
{
int iVar1;
iVar1 = (param_1 + -2000) % 0xc;
if (iVar1 < 0) {
iVar1 = iVar1 + 0xc;
}
switch(iVar1) {
case 0:
return "Dragon";
case 1:
return "Snake";
case 2:
return "Horse";
case 3:
return "sheep";
case 4:
return "Monkey";
case 5:
return "Rooster";
case 6:
return "Dog";
case 7:
return "Pig";
case 8:
return "Rat";
case 9:
return "Ox";
case 10:
return "Tiger";
default:
return "Hare";
}
} |
7,694 | func0 |
#include <assert.h>
#include <string.h>
| const char* func0(int year) {
const char* sign;
int remainder = (year - 2000) % 12;
if (remainder < 0) {
remainder += 12;
}
switch (remainder) {
case 0:
sign = "Dragon";
break;
case 1:
sign = "Snake";
break;
case 2:
sign = "Horse";
break;
case 3:
sign = "sheep";
break;
case 4:
sign = "Monkey";
break;
case 5:
sign = "Rooster";
break;
case 6:
sign = "Dog";
break;
case 7:
sign = "Pig";
break;
case 8:
sign = "Rat";
break;
case 9:
sign = "Ox";
break;
case 10:
sign = "Tiger";
break;
default:
sign = "Hare";
break;
}
return sign;
}
| int main() {
assert(strcmp(func0(1997), "Ox") == 0);
assert(strcmp(func0(1998), "Tiger") == 0);
assert(strcmp(func0(1994), "Dog") == 0);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x7d0,%edi
movslq %edi,%rax
mov %edi,%edx
imul $0x2aaaaaab,%rax,%rax
sar $0x1f,%edx
sar $0x21,%rax
sub %edx,%eax
lea (%rax,%rax,2),%eax
shl $0x2,%eax
sub %eax,%edi
mov %edi,%eax
lea 0xc(%rax),%edx
test %eax,%eax
cmovs %rdx,%rax
cmp $0xa,%eax
ja 1238 <func0+0xf8>
lea 0xec6(%rip),%rdx
movslq (%rdx,%rax,4),%rax
add %rdx,%rax
notrack jmpq *%rax
nopl 0x0(%rax)
lea 0xea9(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe62(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe59(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe4f(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe63(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe4c(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe40(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe15(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe0c(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe04(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xdf8(%rip),%rax
retq
lea 0xdc5(%rip),%rax
retq
| func0:
endbr64
sub edi, 7D0h
movsxd rax, edi
mov edx, edi
imul rax, 2AAAAAABh
sar edx, 1Fh
sar rax, 21h
sub eax, edx
lea edx, [rax+rax*2]
mov eax, edi
shl edx, 2
sub eax, edx
lea edx, [rax+0Ch]
cmovs rax, rdx
cmp eax, 0Ah; switch 11 cases
ja def_1187; jumptable 0000000000001187 default case
lea rdx, jpt_1187
movsxd rax, ds:(jpt_1187 - 2048h)[rdx+rax*4]
add rax, rdx
jmp rax; switch jump
loc_1190:
lea rax, aSnake; jumptable 0000000000001187 case 1
retn
loc_11A0:
lea rax, aDragon; jumptable 0000000000001187 case 0
retn
loc_11B0:
lea rax, aHorse; jumptable 0000000000001187 case 2
retn
loc_11C0:
lea rax, aSheep; jumptable 0000000000001187 case 3
retn
loc_11D0:
lea rax, aTiger; jumptable 0000000000001187 case 10
retn
loc_11E0:
lea rax, aRat; jumptable 0000000000001187 case 8
retn
loc_11F0:
lea rax, aOx; jumptable 0000000000001187 case 9
retn
loc_1200:
lea rax, aMonkey; jumptable 0000000000001187 case 4
retn
loc_1210:
lea rax, aRooster; jumptable 0000000000001187 case 5
retn
loc_1220:
lea rax, aDog; jumptable 0000000000001187 case 6
retn
loc_1230:
lea rax, aPig; jumptable 0000000000001187 case 7
retn
def_1187:
lea rax, aHare; jumptable 0000000000001187 default case
retn | const char * func0(int a1)
{
const char *result; // rax
switch ( (a1 - 2000) % 12 + ((a1 - 2000) % 12 < 0 ? 0xC : 0) )
{
case 0:
result = "Dragon";
break;
case 1:
result = "Snake";
break;
case 2:
result = "Horse";
break;
case 3:
result = "sheep";
break;
case 4:
result = "Monkey";
break;
case 5:
result = "Rooster";
break;
case 6:
result = "Dog";
break;
case 7:
result = "Pig";
break;
case 8:
result = "Rat";
break;
case 9:
result = "Ox";
break;
case 0xA:
result = "Tiger";
break;
default:
result = "Hare";
break;
}
return result;
} | func0:
ENDBR64
SUB EDI,0x7d0
MOVSXD RAX,EDI
MOV EDX,EDI
IMUL RAX,RAX,0x2aaaaaab
SAR EDX,0x1f
SAR RAX,0x21
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x2]
MOV EAX,EDI
SHL EDX,0x2
SUB EAX,EDX
LEA EDX,[RAX + 0xc]
CMOVS RAX,RDX
CMP EAX,0xa
JA 0x00101238
LEA RDX,[0x102048]
MOVSXD RAX,dword ptr [RDX + RAX*0x4]
ADD RAX,RDX
switchD:
JMP RAX
caseD_1:
LEA RAX,[0x10200b]
RET
caseD_0:
LEA RAX,[0x102004]
RET
caseD_2:
LEA RAX,[0x102011]
RET
caseD_3:
LEA RAX,[0x102017]
RET
caseD_a:
LEA RAX,[0x10203b]
RET
caseD_8:
LEA RAX,[0x102034]
RET
caseD_9:
LEA RAX,[0x102038]
RET
caseD_4:
LEA RAX,[0x10201d]
RET
caseD_5:
LEA RAX,[0x102024]
RET
caseD_6:
LEA RAX,[0x10202c]
RET
caseD_7:
LEA RAX,[0x102030]
RET
default:
LEA RAX,[0x102041]
RET | char * func0(int param_1)
{
int iVar1;
iVar1 = (param_1 + -2000) % 0xc;
if (iVar1 < 0) {
iVar1 = iVar1 + 0xc;
}
switch(iVar1) {
case 0:
return "Dragon";
case 1:
return "Snake";
case 2:
return "Horse";
case 3:
return "sheep";
case 4:
return "Monkey";
case 5:
return "Rooster";
case 6:
return "Dog";
case 7:
return "Pig";
case 8:
return "Rat";
case 9:
return "Ox";
case 10:
return "Tiger";
default:
return "Hare";
}
} |
7,695 | func0 |
#include <assert.h>
#include <string.h>
| const char* func0(int year) {
const char* sign;
int remainder = (year - 2000) % 12;
if (remainder < 0) {
remainder += 12;
}
switch (remainder) {
case 0:
sign = "Dragon";
break;
case 1:
sign = "Snake";
break;
case 2:
sign = "Horse";
break;
case 3:
sign = "sheep";
break;
case 4:
sign = "Monkey";
break;
case 5:
sign = "Rooster";
break;
case 6:
sign = "Dog";
break;
case 7:
sign = "Pig";
break;
case 8:
sign = "Rat";
break;
case 9:
sign = "Ox";
break;
case 10:
sign = "Tiger";
break;
default:
sign = "Hare";
break;
}
return sign;
}
| int main() {
assert(strcmp(func0(1997), "Ox") == 0);
assert(strcmp(func0(1998), "Tiger") == 0);
assert(strcmp(func0(1994), "Dog") == 0);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x7d0,%edi
movslq %edi,%rax
mov %edi,%edx
imul $0x2aaaaaab,%rax,%rax
sar $0x1f,%edx
sar $0x21,%rax
sub %edx,%eax
lea (%rax,%rax,2),%eax
shl $0x2,%eax
sub %eax,%edi
mov %edi,%eax
lea 0xc(%rax),%edx
test %eax,%eax
cmovs %rdx,%rax
cmp $0xa,%eax
ja 1238 <func0+0xf8>
lea 0xec6(%rip),%rdx
movslq (%rdx,%rax,4),%rax
add %rdx,%rax
notrack jmpq *%rax
nopl 0x0(%rax)
lea 0xea9(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe62(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe59(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe4f(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe63(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe4c(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe40(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe15(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe0c(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xe04(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
lea 0xdf8(%rip),%rax
retq
lea 0xdc5(%rip),%rax
retq
| func0:
endbr64
sub edi, 7D0h
movsxd rax, edi
mov edx, edi
imul rax, 2AAAAAABh
sar edx, 1Fh
sar rax, 21h
sub eax, edx
lea edx, [rax+rax*2]
mov eax, edi
shl edx, 2
sub eax, edx
lea edx, [rax+0Ch]
cmovs rax, rdx
cmp eax, 0Ah; switch 11 cases
ja def_1187; jumptable 0000000000001187 default case
lea rdx, jpt_1187
movsxd rax, ds:(jpt_1187 - 2048h)[rdx+rax*4]
add rax, rdx
jmp rax; switch jump
loc_1190:
lea rax, aSnake; jumptable 0000000000001187 case 1
retn
loc_11A0:
lea rax, aDragon; jumptable 0000000000001187 case 0
retn
loc_11B0:
lea rax, aHorse; jumptable 0000000000001187 case 2
retn
loc_11C0:
lea rax, aSheep; jumptable 0000000000001187 case 3
retn
loc_11D0:
lea rax, aTiger; jumptable 0000000000001187 case 10
retn
loc_11E0:
lea rax, aRat; jumptable 0000000000001187 case 8
retn
loc_11F0:
lea rax, aOx; jumptable 0000000000001187 case 9
retn
loc_1200:
lea rax, aMonkey; jumptable 0000000000001187 case 4
retn
loc_1210:
lea rax, aRooster; jumptable 0000000000001187 case 5
retn
loc_1220:
lea rax, aDog; jumptable 0000000000001187 case 6
retn
loc_1230:
lea rax, aPig; jumptable 0000000000001187 case 7
retn
def_1187:
lea rax, aHare; jumptable 0000000000001187 default case
retn | const char * func0(int a1)
{
const char *result; // rax
switch ( (a1 - 2000) % 12 + ((a1 - 2000) % 12 < 0 ? 0xC : 0) )
{
case 0:
result = "Dragon";
break;
case 1:
result = "Snake";
break;
case 2:
result = "Horse";
break;
case 3:
result = "sheep";
break;
case 4:
result = "Monkey";
break;
case 5:
result = "Rooster";
break;
case 6:
result = "Dog";
break;
case 7:
result = "Pig";
break;
case 8:
result = "Rat";
break;
case 9:
result = "Ox";
break;
case 0xA:
result = "Tiger";
break;
default:
result = "Hare";
break;
}
return result;
} | func0:
ENDBR64
SUB EDI,0x7d0
MOVSXD RAX,EDI
MOV EDX,EDI
IMUL RAX,RAX,0x2aaaaaab
SAR EDX,0x1f
SAR RAX,0x21
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x2]
MOV EAX,EDI
SHL EDX,0x2
SUB EAX,EDX
LEA EDX,[RAX + 0xc]
CMOVS RAX,RDX
CMP EAX,0xa
JA 0x00101238
LEA RDX,[0x102048]
MOVSXD RAX,dword ptr [RDX + RAX*0x4]
ADD RAX,RDX
switchD:
JMP RAX
caseD_1:
LEA RAX,[0x10200b]
RET
caseD_0:
LEA RAX,[0x102004]
RET
caseD_2:
LEA RAX,[0x102011]
RET
caseD_3:
LEA RAX,[0x102017]
RET
caseD_a:
LEA RAX,[0x10203b]
RET
caseD_8:
LEA RAX,[0x102034]
RET
caseD_9:
LEA RAX,[0x102038]
RET
caseD_4:
LEA RAX,[0x10201d]
RET
caseD_5:
LEA RAX,[0x102024]
RET
caseD_6:
LEA RAX,[0x10202c]
RET
caseD_7:
LEA RAX,[0x102030]
RET
caseD_b:
LEA RAX,[0x102041]
RET | char * func0(int param_1)
{
int iVar1;
iVar1 = (param_1 + -2000) % 0xc;
if (iVar1 < 0) {
iVar1 = iVar1 + 0xc;
}
switch(iVar1) {
case 0:
return "Dragon";
case 1:
return "Snake";
case 2:
return "Horse";
case 3:
return "sheep";
case 4:
return "Monkey";
case 5:
return "Rooster";
case 6:
return "Dog";
case 7:
return "Pig";
case 8:
return "Rat";
case 9:
return "Ox";
case 10:
return "Tiger";
default:
return "Hare";
}
} |
7,696 | func0 |
#include <stdio.h>
#include <assert.h>
typedef struct {
int first;
int second;
} Pair;
| Pair* func0(Pair *test_list1, Pair *test_list2, int size) {
static Pair res[3];
for (int i = 0; i < size; i++) {
res[i].first = test_list1[i].first > test_list2[i].first ? test_list1[i].first : test_list2[i].first;
res[i].second = test_list1[i].second > test_list2[i].second ? test_list1[i].second : test_list2[i].second;
}
return res;
}
| int main() {
Pair test_list1[3] = {{2, 4}, {6, 7}, {5, 1}};
Pair test_list2[3] = {{5, 4}, {8, 10}, {8, 14}};
Pair expected1[3] = {{5, 4}, {8, 10}, {8, 14}};
Pair *result1 = func0(test_list1, test_list2, 3);
for (int i = 0; i < 3; i++) {
assert(result1[i].first == expected1[i].first && result1[i].second == expected1[i].second);
}
Pair test_list3[3] = {{3, 5}, {7, 8}, {6, 2}};
Pair test_list4[3] = {{6, 5}, {9, 11}, {9, 15}};
Pair expected2[3] = {{6, 5}, {9, 11}, {9, 15}};
Pair *result2 = func0(test_list3, test_list4, 3);
for (int i = 0; i < 3; i++) {
assert(result2[i].first == expected2[i].first && result2[i].second == expected2[i].second);
}
Pair test_list5[3] = {{4, 6}, {8, 9}, {7, 3}};
Pair test_list6[3] = {{7, 6}, {10, 12}, {10, 16}};
Pair expected3[3] = {{7, 6}, {10, 12}, {10, 16}};
Pair *result3 = func0(test_list5, test_list6, 3);
for (int i = 0; i < 3; i++) {
assert(result3[i].first == expected3[i].first && result3[i].second == expected3[i].second);
}
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)
jmpq 1220 <func0+0xb7>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
cmovge %edx,%eax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
lea 0x2e52(%rip),%rdx
mov %eax,(%rcx,%rdx,1)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov 0x4(%rax),%eax
cmp %eax,%edx
cmovge %edx,%eax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
lea 0x2e0b(%rip),%rdx
mov %eax,(%rcx,%rdx,1)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 1188 <func0+0x1f>
lea 0x2ded(%rip),%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_4], 0
jmp loc_1220
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_20]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
cmovge eax, edx
mov edx, [rbp+var_4]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
lea rdx, res_1
mov [rcx+rdx], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_20]
add rax, rdx
mov edx, [rax+4]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax+4]
cmp edx, eax
cmovge eax, edx
mov edx, [rbp+var_4]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
lea rdx, unk_4024
mov [rcx+rdx], eax
add [rbp+var_4], 1
loc_1220:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_24]
jl loc_1188
lea rax, res_1
pop rbp
retn | void * func0(long long a1, long long a2, int a3)
{
int v3; // eax
int v4; // eax
int i; // [rsp+20h] [rbp-4h]
for ( i = 0; i < a3; ++i )
{
v3 = *(_DWORD *)(8LL * i + a1);
if ( *(_DWORD *)(8LL * i + a2) >= v3 )
v3 = *(_DWORD *)(8LL * i + a2);
*((_DWORD *)&res_1 + 2 * i) = v3;
v4 = *(_DWORD *)(8LL * i + a1 + 4);
if ( *(_DWORD *)(8LL * i + a2 + 4) >= v4 )
v4 = *(_DWORD *)(8LL * i + a2 + 4);
dword_4024[2 * i] = v4;
}
return &res_1;
} | 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 0x00101220
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
CMOVGE EAX,EDX
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
LEA RDX,[0x104020]
MOV dword ptr [RCX + RDX*0x1],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RAX + 0x4]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
CMP EDX,EAX
CMOVGE EAX,EDX
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
LEA RDX,[0x104024]
MOV dword ptr [RCX + RDX*0x1],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101220:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00101188
LEA RAX,[0x104020]
POP RBP
RET | int1 * func0(long param_1,long param_2,int param_3)
{
int iVar1;
int iVar2;
int local_c;
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
iVar1 = *(int *)(param_2 + (long)local_c * 8);
iVar2 = *(int *)(param_1 + (long)local_c * 8);
if (iVar2 <= iVar1) {
iVar2 = iVar1;
}
*(int *)(res_1 + (long)local_c * 8) = iVar2;
iVar1 = *(int *)(param_2 + (long)local_c * 8 + 4);
iVar2 = *(int *)(param_1 + (long)local_c * 8 + 4);
if (iVar2 <= iVar1) {
iVar2 = iVar1;
}
*(int *)(res_1 + (long)local_c * 8 + 4) = iVar2;
}
return res_1;
} |
7,697 | func0 |
#include <stdio.h>
#include <assert.h>
typedef struct {
int first;
int second;
} Pair;
| Pair* func0(Pair *test_list1, Pair *test_list2, int size) {
static Pair res[3];
for (int i = 0; i < size; i++) {
res[i].first = test_list1[i].first > test_list2[i].first ? test_list1[i].first : test_list2[i].first;
res[i].second = test_list1[i].second > test_list2[i].second ? test_list1[i].second : test_list2[i].second;
}
return res;
}
| int main() {
Pair test_list1[3] = {{2, 4}, {6, 7}, {5, 1}};
Pair test_list2[3] = {{5, 4}, {8, 10}, {8, 14}};
Pair expected1[3] = {{5, 4}, {8, 10}, {8, 14}};
Pair *result1 = func0(test_list1, test_list2, 3);
for (int i = 0; i < 3; i++) {
assert(result1[i].first == expected1[i].first && result1[i].second == expected1[i].second);
}
Pair test_list3[3] = {{3, 5}, {7, 8}, {6, 2}};
Pair test_list4[3] = {{6, 5}, {9, 11}, {9, 15}};
Pair expected2[3] = {{6, 5}, {9, 11}, {9, 15}};
Pair *result2 = func0(test_list3, test_list4, 3);
for (int i = 0; i < 3; i++) {
assert(result2[i].first == expected2[i].first && result2[i].second == expected2[i].second);
}
Pair test_list5[3] = {{4, 6}, {8, 9}, {7, 3}};
Pair test_list6[3] = {{7, 6}, {10, 12}, {10, 16}};
Pair expected3[3] = {{7, 6}, {10, 12}, {10, 16}};
Pair *result3 = func0(test_list5, test_list6, 3);
for (int i = 0; i < 3; i++) {
assert(result3[i].first == expected3[i].first && result3[i].second == expected3[i].second);
}
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
jle 11a8 <func0+0x3f>
mov $0x0,%eax
lea 0x2ea3(%rip),%r9
lea 0x4(%r9),%r8
mov (%rdi,%rax,8),%ecx
cmp %ecx,(%rsi,%rax,8)
cmovge (%rsi,%rax,8),%ecx
mov %ecx,(%r9,%rax,8)
mov 0x4(%rdi,%rax,8),%ecx
cmp %ecx,0x4(%rsi,%rax,8)
cmovge 0x4(%rsi,%rax,8),%ecx
mov %ecx,(%r8,%rax,8)
add $0x1,%rax
cmp %eax,%edx
jg 1181 <func0+0x18>
lea 0x2e71(%rip),%rax
retq
| func0:
endbr64
test edx, edx
jle short loc_11AF
mov eax, 0
lea r10, res_1
lea r9, [r10+4]
loc_1181:
mov ecx, [rsi+rax*8]
mov r8d, [rdi+rax*8]
cmp ecx, r8d
cmovl ecx, r8d
mov [r10+rax*8], ecx
mov ecx, [rsi+rax*8+4]
mov r8d, [rdi+rax*8+4]
cmp ecx, r8d
cmovl ecx, r8d
mov [r9+rax*8], ecx
add rax, 1
cmp edx, eax
jg short loc_1181
loc_11AF:
lea rax, res_1
retn | _DWORD * func0(long long a1, long long a2, int a3)
{
long long v3; // rax
int v4; // ecx
int v5; // ecx
if ( a3 > 0 )
{
v3 = 0LL;
do
{
v4 = *(_DWORD *)(a2 + 8 * v3);
if ( v4 < *(_DWORD *)(a1 + 8 * v3) )
v4 = *(_DWORD *)(a1 + 8 * v3);
res_1[2 * v3] = v4;
v5 = *(_DWORD *)(a2 + 8 * v3 + 4);
if ( v5 < *(_DWORD *)(a1 + 8 * v3 + 4) )
v5 = *(_DWORD *)(a1 + 8 * v3 + 4);
res_1[2 * v3++ + 1] = v5;
}
while ( a3 > (int)v3 );
}
return res_1;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001011af
MOV EAX,0x0
LEA R10,[0x104020]
LEA R9,[R10 + 0x4]
LAB_00101181:
MOV ECX,dword ptr [RSI + RAX*0x8]
MOV R8D,dword ptr [RDI + RAX*0x8]
CMP ECX,R8D
CMOVL ECX,R8D
MOV dword ptr [R10 + RAX*0x8],ECX
MOV ECX,dword ptr [RSI + RAX*0x8 + 0x4]
MOV R8D,dword ptr [RDI + RAX*0x8 + 0x4]
CMP ECX,R8D
CMOVL ECX,R8D
MOV dword ptr [R9 + RAX*0x8],ECX
ADD RAX,0x1
CMP EDX,EAX
JG 0x00101181
LAB_001011af:
LEA RAX,[0x104020]
RET | int4 * func0(long param_1,long param_2,int param_3)
{
int iVar1;
long lVar2;
int iVar3;
if (0 < param_3) {
lVar2 = 0;
do {
iVar3 = *(int *)(param_2 + lVar2 * 8);
iVar1 = *(int *)(param_1 + lVar2 * 8);
if (iVar3 < iVar1) {
iVar3 = iVar1;
}
(&res_1)[lVar2 * 2] = iVar3;
iVar3 = *(int *)(param_2 + 4 + lVar2 * 8);
iVar1 = *(int *)(param_1 + 4 + lVar2 * 8);
if (iVar3 < iVar1) {
iVar3 = iVar1;
}
(&DAT_00104024)[lVar2 * 2] = iVar3;
lVar2 = lVar2 + 1;
} while ((int)lVar2 < param_3);
}
return &res_1;
} |
7,698 | func0 |
#include <stdio.h>
#include <assert.h>
typedef struct {
int first;
int second;
} Pair;
| Pair* func0(Pair *test_list1, Pair *test_list2, int size) {
static Pair res[3];
for (int i = 0; i < size; i++) {
res[i].first = test_list1[i].first > test_list2[i].first ? test_list1[i].first : test_list2[i].first;
res[i].second = test_list1[i].second > test_list2[i].second ? test_list1[i].second : test_list2[i].second;
}
return res;
}
| int main() {
Pair test_list1[3] = {{2, 4}, {6, 7}, {5, 1}};
Pair test_list2[3] = {{5, 4}, {8, 10}, {8, 14}};
Pair expected1[3] = {{5, 4}, {8, 10}, {8, 14}};
Pair *result1 = func0(test_list1, test_list2, 3);
for (int i = 0; i < 3; i++) {
assert(result1[i].first == expected1[i].first && result1[i].second == expected1[i].second);
}
Pair test_list3[3] = {{3, 5}, {7, 8}, {6, 2}};
Pair test_list4[3] = {{6, 5}, {9, 11}, {9, 15}};
Pair expected2[3] = {{6, 5}, {9, 11}, {9, 15}};
Pair *result2 = func0(test_list3, test_list4, 3);
for (int i = 0; i < 3; i++) {
assert(result2[i].first == expected2[i].first && result2[i].second == expected2[i].second);
}
Pair test_list5[3] = {{4, 6}, {8, 9}, {7, 3}};
Pair test_list6[3] = {{7, 6}, {10, 12}, {10, 16}};
Pair expected3[3] = {{7, 6}, {10, 12}, {10, 16}};
Pair *result3 = func0(test_list5, test_list6, 3);
for (int i = 0; i < 3; i++) {
assert(result3[i].first == expected3[i].first && result3[i].second == expected3[i].second);
}
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
jle 147c <func0+0x3c>
lea 0x2bd1(%rip),%r9
xor %eax,%eax
lea 0x4(%r9),%r8
mov (%rdi,%rax,8),%ecx
cmp %ecx,(%rsi,%rax,8)
cmovge (%rsi,%rax,8),%ecx
mov %ecx,(%r9,%rax,8)
mov 0x4(%rdi,%rax,8),%ecx
cmp %ecx,0x4(%rsi,%rax,8)
cmovge 0x4(%rsi,%rax,8),%ecx
mov %ecx,(%r8,%rax,8)
add $0x1,%rax
cmp %eax,%edx
jg 1455 <func0+0x15>
lea 0x2b9d(%rip),%rax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
lea r9, res_1
test edx, edx
jle short loc_1493
xor eax, eax
lea r10, [r9+4]
loc_1465:
mov r8d, [rdi+rax*8]
mov ecx, [rsi+rax*8]
cmp ecx, r8d
cmovl ecx, r8d
mov [r9+rax*8], ecx
mov ecx, [rsi+rax*8+4]
mov r8d, [rdi+rax*8+4]
cmp ecx, r8d
cmovl ecx, r8d
mov [r10+rax*8], ecx
add rax, 1
cmp edx, eax
jg short loc_1465
loc_1493:
mov rax, r9
retn | _DWORD * func0(long long a1, long long a2, int a3)
{
long long v3; // rax
int v4; // ecx
int v5; // ecx
if ( a3 > 0 )
{
v3 = 0LL;
do
{
v4 = *(_DWORD *)(a2 + 8 * v3);
if ( v4 < *(_DWORD *)(a1 + 8 * v3) )
v4 = *(_DWORD *)(a1 + 8 * v3);
res_1[2 * v3] = v4;
v5 = *(_DWORD *)(a2 + 8 * v3 + 4);
if ( v5 < *(_DWORD *)(a1 + 8 * v3 + 4) )
v5 = *(_DWORD *)(a1 + 8 * v3 + 4);
res_1[2 * v3++ + 1] = v5;
}
while ( a3 > (int)v3 );
}
return res_1;
} | func0:
ENDBR64
LEA R9,[0x104020]
TEST EDX,EDX
JLE 0x00101493
XOR EAX,EAX
LEA R10,[R9 + 0x4]
LAB_00101465:
MOV R8D,dword ptr [RDI + RAX*0x8]
MOV ECX,dword ptr [RSI + RAX*0x8]
CMP ECX,R8D
CMOVL ECX,R8D
MOV dword ptr [R9 + RAX*0x8],ECX
MOV ECX,dword ptr [RSI + RAX*0x8 + 0x4]
MOV R8D,dword ptr [RDI + RAX*0x8 + 0x4]
CMP ECX,R8D
CMOVL ECX,R8D
MOV dword ptr [R10 + RAX*0x8],ECX
ADD RAX,0x1
CMP EDX,EAX
JG 0x00101465
LAB_00101493:
MOV RAX,R9
RET | int4 * func0(long param_1,long param_2,int param_3)
{
long lVar1;
int iVar2;
int iVar3;
if (0 < param_3) {
lVar1 = 0;
do {
iVar3 = *(int *)(param_1 + lVar1 * 8);
iVar2 = *(int *)(param_2 + lVar1 * 8);
if (iVar2 < iVar3) {
iVar2 = iVar3;
}
(&res_1)[lVar1 * 2] = iVar2;
iVar3 = *(int *)(param_2 + 4 + lVar1 * 8);
iVar2 = *(int *)(param_1 + 4 + lVar1 * 8);
if (iVar3 < iVar2) {
iVar3 = iVar2;
}
(&DAT_00104024)[lVar1 * 2] = iVar3;
lVar1 = lVar1 + 1;
} while ((int)lVar1 < param_3);
}
return &res_1;
} |
7,699 | func0 |
#include <stdio.h>
#include <assert.h>
typedef struct {
int first;
int second;
} Pair;
| Pair* func0(Pair *test_list1, Pair *test_list2, int size) {
static Pair res[3];
for (int i = 0; i < size; i++) {
res[i].first = test_list1[i].first > test_list2[i].first ? test_list1[i].first : test_list2[i].first;
res[i].second = test_list1[i].second > test_list2[i].second ? test_list1[i].second : test_list2[i].second;
}
return res;
}
| int main() {
Pair test_list1[3] = {{2, 4}, {6, 7}, {5, 1}};
Pair test_list2[3] = {{5, 4}, {8, 10}, {8, 14}};
Pair expected1[3] = {{5, 4}, {8, 10}, {8, 14}};
Pair *result1 = func0(test_list1, test_list2, 3);
for (int i = 0; i < 3; i++) {
assert(result1[i].first == expected1[i].first && result1[i].second == expected1[i].second);
}
Pair test_list3[3] = {{3, 5}, {7, 8}, {6, 2}};
Pair test_list4[3] = {{6, 5}, {9, 11}, {9, 15}};
Pair expected2[3] = {{6, 5}, {9, 11}, {9, 15}};
Pair *result2 = func0(test_list3, test_list4, 3);
for (int i = 0; i < 3; i++) {
assert(result2[i].first == expected2[i].first && result2[i].second == expected2[i].second);
}
Pair test_list5[3] = {{4, 6}, {8, 9}, {7, 3}};
Pair test_list6[3] = {{7, 6}, {10, 12}, {10, 16}};
Pair expected3[3] = {{7, 6}, {10, 12}, {10, 16}};
Pair *result3 = func0(test_list5, test_list6, 3);
for (int i = 0; i < 3; i++) {
assert(result3[i].first == expected3[i].first && result3[i].second == expected3[i].second);
}
return 0;
}
| O3 | c | func0:
endbr64
mov %rdi,%r8
test %edx,%edx
jle 1431 <func0+0x91>
lea 0xf(%rdi),%rax
lea 0x2c66(%rip),%rcx
sub %rcx,%rax
cmp $0x1e,%rax
seta %dil
cmp $0x1,%edx
setne %al
test %al,%dil
je 1440 <func0+0xa0>
lea 0xf(%rsi),%rax
sub %rcx,%rax
cmp $0x1e,%rax
jbe 1440 <func0+0xa0>
movdqu (%rsi),%xmm1
movdqu (%r8),%xmm2
mov %edx,%eax
and $0xfffffffe,%eax
and $0x1,%edx
movdqa %xmm1,%xmm0
pcmpgtd %xmm2,%xmm0
pand %xmm0,%xmm1
pandn %xmm2,%xmm0
por %xmm1,%xmm0
movaps %xmm0,0x2c17(%rip)
je 1431 <func0+0x91>
mov %eax,%edi
cltq
shl $0x3,%rdi
add %rdi,%rsi
add %r8,%rdi
mov (%rdi),%edx
cmp %edx,(%rsi)
cmovge (%rsi),%edx
mov %edx,(%rcx,%rax,8)
mov 0x4(%rdi),%edx
cmp %edx,0x4(%rsi)
cmovge 0x4(%rsi),%edx
mov %edx,0x4(%rcx,%rax,8)
lea 0x2be8(%rip),%rax
retq
nopl 0x0(%rax)
mov (%r8),%eax
cmp %eax,(%rsi)
cmovge (%rsi),%eax
mov %eax,0x2bd2(%rip)
mov 0x4(%r8),%eax
cmp %eax,0x4(%rsi)
cmovge 0x4(%rsi),%eax
mov %eax,0x2bc5(%rip)
cmp $0x1,%edx
je 1431 <func0+0x91>
mov 0x8(%r8),%eax
cmp %eax,0x8(%rsi)
cmovge 0x8(%rsi),%eax
mov %eax,0x2bb3(%rip)
mov 0xc(%r8),%eax
cmp %eax,0xc(%rsi)
cmovge 0xc(%rsi),%eax
mov %eax,0x2ba6(%rip)
cmp $0x2,%edx
je 1431 <func0+0x91>
mov 0x10(%r8),%eax
cmp %eax,0x10(%rsi)
cmovge 0x10(%rsi),%eax
mov %eax,0x2b94(%rip)
mov 0x14(%r8),%eax
cmp %eax,0x14(%rsi)
cmovge 0x14(%rsi),%eax
mov %eax,0x2b87(%rip)
jmp 1431 <func0+0x91>
| func0:
endbr64
mov rax, rsi
lea r8, res_1
test edx, edx
jle short loc_11EA
cmp edx, 1
jz loc_1260
mov rcx, r8
sub rcx, rsi
sub rcx, 4
cmp rcx, 8
jbe short loc_11F0
mov rcx, r8
sub rcx, rdi
sub rcx, 4
cmp rcx, 8
jbe short loc_11F0
movdqu xmm1, xmmword ptr [rsi]
movdqu xmm2, xmmword ptr [rdi]
mov ecx, edx
and ecx, 0FFFFFFFEh
and edx, 1
movdqa xmm0, xmm1
pcmpgtd xmm0, xmm2
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movaps cs:res_1, xmm0
jz short loc_11EA
mov edx, [rsi+10h]
mov esi, [rdi+10h]
movsxd rcx, ecx
mov eax, [rax+14h]
cmp edx, esi
cmovl edx, esi
mov [r8+rcx*8], edx
mov edx, [rdi+14h]
cmp eax, edx
cmovl eax, edx
mov [r8+rcx*8+4], eax
loc_11EA:
mov rax, r8
retn
loc_11F0:
mov esi, [rax]
mov ecx, [rdi]
cmp ecx, esi
cmovl ecx, esi
mov esi, [rdi+4]
mov dword ptr cs:res_1, ecx
mov ecx, [rax+4]
cmp ecx, esi
cmovl ecx, esi
mov esi, [rdi+8]
mov dword ptr cs:res_1+4, ecx
mov ecx, [rax+8]
cmp ecx, esi
cmovl ecx, esi
mov esi, [rdi+0Ch]
mov dword ptr cs:res_1+8, ecx
mov ecx, [rax+0Ch]
cmp ecx, esi
cmovl ecx, esi
mov dword ptr cs:res_1+0Ch, ecx
cmp edx, 2
jz short loc_11EA
mov edx, [rax+10h]
mov ecx, [rdi+10h]
mov eax, [rax+14h]
cmp edx, ecx
cmovl edx, ecx
mov dword ptr cs:qword_4030, edx
mov edx, [rdi+14h]
cmp eax, edx
cmovl eax, edx
mov dword ptr cs:qword_4030+4, eax
mov rax, r8
retn
loc_1260:
mov edx, [rdi]
mov ecx, [rsi]
mov eax, [rsi+4]
cmp edx, ecx
cmovl edx, ecx
mov dword ptr cs:res_1, edx
mov edx, [rdi+4]
cmp eax, edx
cmovl eax, edx
mov dword ptr cs:res_1+4, eax
mov rax, r8
retn | __int128 * func0(const __m128i *a1, const __m128i *a2, int a3)
{
__m128i v4; // xmm1
__m128i v5; // xmm2
unsigned int v6; // ecx
__m128i v7; // xmm0
__int32 v8; // edx
__int32 v9; // eax
__int32 v11; // esi
__int32 v12; // ecx
__int32 v13; // esi
__int32 v14; // ecx
__int32 v15; // esi
__int32 v16; // ecx
__int32 v17; // esi
__int32 v18; // ecx
__int32 v19; // edx
__int32 v20; // eax
__int32 v21; // edx
__int32 v22; // eax
if ( a3 <= 0 )
return &res_1;
if ( a3 == 1 )
{
v21 = a1->m128i_i32[0];
v22 = a2->m128i_i32[1];
if ( a1->m128i_i32[0] < a2->m128i_i32[0] )
v21 = a2->m128i_i32[0];
LODWORD(res_1) = v21;
if ( v22 < a1->m128i_i32[1] )
v22 = a1->m128i_i32[1];
DWORD1(res_1) = v22;
return &res_1;
}
else
{
if ( (unsigned long long)((char *)&res_1 - (char *)a2 - 4) > 8
&& (unsigned long long)((char *)&res_1 - (char *)a1 - 4) > 8 )
{
v4 = _mm_loadu_si128(a2);
v5 = _mm_loadu_si128(a1);
v6 = a3 & 0xFFFFFFFE;
v7 = _mm_cmpgt_epi32(v4, v5);
res_1 = (__int128)_mm_or_si128(_mm_andnot_si128(v7, v5), _mm_and_si128(v4, v7));
if ( (a3 & 1) != 0 )
{
v8 = a2[1].m128i_i32[0];
v9 = a2[1].m128i_i32[1];
if ( v8 < a1[1].m128i_i32[0] )
v8 = a1[1].m128i_i32[0];
*((_DWORD *)&res_1 + 2 * (int)v6) = v8;
if ( v9 < a1[1].m128i_i32[1] )
v9 = a1[1].m128i_i32[1];
*((_DWORD *)&res_1 + 2 * (int)v6 + 1) = v9;
}
return &res_1;
}
v11 = a2->m128i_i32[0];
v12 = a1->m128i_i32[0];
if ( a1->m128i_i32[0] < v11 )
v12 = v11;
v13 = a1->m128i_i32[1];
LODWORD(res_1) = v12;
v14 = a2->m128i_i32[1];
if ( v14 < v13 )
v14 = v13;
v15 = a1->m128i_i32[2];
DWORD1(res_1) = v14;
v16 = a2->m128i_i32[2];
if ( v16 < v15 )
v16 = v15;
v17 = a1->m128i_i32[3];
DWORD2(res_1) = v16;
v18 = a2->m128i_i32[3];
if ( v18 < v17 )
v18 = v17;
HIDWORD(res_1) = v18;
if ( a3 == 2 )
return &res_1;
v19 = a2[1].m128i_i32[0];
v20 = a2[1].m128i_i32[1];
if ( v19 < a1[1].m128i_i32[0] )
v19 = a1[1].m128i_i32[0];
LODWORD(qword_4030) = v19;
if ( v20 < a1[1].m128i_i32[1] )
v20 = a1[1].m128i_i32[1];
HIDWORD(qword_4030) = v20;
return &res_1;
}
} | func0:
ENDBR64
MOV RAX,RSI
LEA R8,[0x104020]
TEST EDX,EDX
JLE 0x001011ea
CMP EDX,0x1
JZ 0x00101260
MOV RCX,R8
SUB RCX,RSI
SUB RCX,0x4
CMP RCX,0x8
JBE 0x001011f0
MOV RCX,R8
SUB RCX,RDI
SUB RCX,0x4
CMP RCX,0x8
JBE 0x001011f0
MOVDQU XMM1,xmmword ptr [RSI]
MOVDQU XMM2,xmmword ptr [RDI]
MOV ECX,EDX
AND ECX,0xfffffffe
AND EDX,0x1
MOVDQA XMM0,XMM1
PCMPGTD XMM0,XMM2
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVAPS xmmword ptr [0x00104020],XMM0
JZ 0x001011ea
MOV EDX,dword ptr [RSI + 0x10]
MOV ESI,dword ptr [RDI + 0x10]
MOVSXD RCX,ECX
MOV EAX,dword ptr [RAX + 0x14]
CMP EDX,ESI
CMOVL EDX,ESI
MOV dword ptr [R8 + RCX*0x8],EDX
MOV EDX,dword ptr [RDI + 0x14]
CMP EAX,EDX
CMOVL EAX,EDX
MOV dword ptr [R8 + RCX*0x8 + 0x4],EAX
LAB_001011ea:
MOV RAX,R8
RET
LAB_001011f0:
MOV ESI,dword ptr [RAX]
MOV ECX,dword ptr [RDI]
CMP ECX,ESI
CMOVL ECX,ESI
MOV ESI,dword ptr [RDI + 0x4]
MOV dword ptr [0x00104020],ECX
MOV ECX,dword ptr [RAX + 0x4]
CMP ECX,ESI
CMOVL ECX,ESI
MOV ESI,dword ptr [RDI + 0x8]
MOV dword ptr [0x00104024],ECX
MOV ECX,dword ptr [RAX + 0x8]
CMP ECX,ESI
CMOVL ECX,ESI
MOV ESI,dword ptr [RDI + 0xc]
MOV dword ptr [0x00104028],ECX
MOV ECX,dword ptr [RAX + 0xc]
CMP ECX,ESI
CMOVL ECX,ESI
MOV dword ptr [0x0010402c],ECX
CMP EDX,0x2
JZ 0x001011ea
MOV EDX,dword ptr [RAX + 0x10]
MOV ECX,dword ptr [RDI + 0x10]
MOV EAX,dword ptr [RAX + 0x14]
CMP EDX,ECX
CMOVL EDX,ECX
MOV dword ptr [0x00104030],EDX
MOV EDX,dword ptr [RDI + 0x14]
CMP EAX,EDX
CMOVL EAX,EDX
MOV dword ptr [0x00104034],EAX
MOV RAX,R8
RET
LAB_00101260:
MOV EDX,dword ptr [RDI]
MOV ECX,dword ptr [RSI]
MOV EAX,dword ptr [RSI + 0x4]
CMP EDX,ECX
CMOVL EDX,ECX
MOV dword ptr [0x00104020],EDX
MOV EDX,dword ptr [RDI + 0x4]
CMP EAX,EDX
CMOVL EAX,EDX
MOV dword ptr [0x00104024],EAX
MOV RAX,R8
RET | int1 * func0(uint *param_1,uint *param_2,uint param_3)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
if (0 < (int)param_3) {
if (param_3 == 1) {
res_1._0_4_ = *param_1;
if ((int)*param_1 < (int)*param_2) {
res_1._0_4_ = *param_2;
}
res_1._4_4_ = param_2[1];
if ((int)param_2[1] < (int)param_1[1]) {
res_1._4_4_ = param_1[1];
}
return res_1;
}
if ((0x10401cU - (long)param_2 < 9) || (0x10401cU - (long)param_1 < 9)) {
res_1._0_4_ = *param_1;
if ((int)*param_1 < (int)*param_2) {
res_1._0_4_ = *param_2;
}
res_1._4_4_ = param_2[1];
if ((int)param_2[1] < (int)param_1[1]) {
res_1._4_4_ = param_1[1];
}
res_1._8_4_ = param_2[2];
if ((int)param_2[2] < (int)param_1[2]) {
res_1._8_4_ = param_1[2];
}
res_1._12_4_ = param_2[3];
if ((int)param_2[3] < (int)param_1[3]) {
res_1._12_4_ = param_1[3];
}
if (param_3 != 2) {
res_1._16_4_ = param_2[4];
if ((int)param_2[4] < (int)param_1[4]) {
res_1._16_4_ = param_1[4];
}
res_1._20_4_ = param_2[5];
if ((int)param_2[5] < (int)param_1[5]) {
res_1._20_4_ = param_1[5];
}
return res_1;
}
}
else {
uVar1 = -(uint)((int)*param_1 < (int)*param_2);
uVar2 = -(uint)((int)param_1[1] < (int)param_2[1]);
uVar3 = -(uint)((int)param_1[2] < (int)param_2[2]);
uVar4 = -(uint)((int)param_1[3] < (int)param_2[3]);
res_1._0_4_ = ~uVar1 & *param_1 | *param_2 & uVar1;
res_1._4_4_ = ~uVar2 & param_1[1] | param_2[1] & uVar2;
res_1._8_4_ = ~uVar3 & param_1[2] | param_2[2] & uVar3;
res_1._12_4_ = ~uVar4 & param_1[3] | param_2[3] & uVar4;
if ((param_3 & 1) != 0) {
uVar1 = param_2[5];
uVar2 = param_2[4];
if ((int)param_2[4] < (int)param_1[4]) {
uVar2 = param_1[4];
}
*(uint *)(res_1 + (long)(int)(param_3 & 0xfffffffe) * 8) = uVar2;
if ((int)uVar1 < (int)param_1[5]) {
uVar1 = param_1[5];
}
*(uint *)(res_1 + (long)(int)(param_3 & 0xfffffffe) * 8 + 4) = uVar1;
}
}
}
return res_1;
} |
7,700 | func0 |
#include <assert.h>
| int func0(int n, int r, int p) {
if (r > n - r)
r = n - r;
int C[r + 1];
for (int i = 0; i <= r; i++)
C[i] = 0;
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < r ? i : r); j > 0; j--) {
C[j] = (C[j] + C[j - 1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(11, 3, 14) == 11);
assert(func0(18, 14, 19) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %esi,-0x48(%rbp)
mov %edx,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x44(%rbp),%eax
sub -0x48(%rbp),%eax
cmp %eax,-0x48(%rbp)
jle 11a8 <func0+0x3f>
mov -0x44(%rbp),%eax
sub -0x48(%rbp),%eax
mov %eax,-0x48(%rbp)
mov -0x48(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov %rdx,%r8
mov $0x0,%r9d
movslq %eax,%rdx
mov %rdx,%rcx
mov $0x0,%ebx
cltq
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%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 1221 <func0+0xb8>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 120a <func0+0xa1>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 124b <func0+0xe2>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x20(%rbp)
movl $0x0,-0x2c(%rbp)
jmp 127c <func0+0x113>
mov -0x20(%rbp),%rax
mov -0x2c(%rbp),%edx
movslq %edx,%rdx
movl $0x0,(%rax,%rdx,4)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x48(%rbp),%eax
jle 1267 <func0+0xfe>
mov -0x20(%rbp),%rax
movl $0x1,(%rax)
movl $0x1,-0x30(%rbp)
jmp 12e6 <func0+0x17d>
mov -0x30(%rbp),%eax
cmp %eax,-0x48(%rbp)
cmovle -0x48(%rbp),%eax
mov %eax,-0x34(%rbp)
jmp 12dc <func0+0x173>
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x34(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x20(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add %ecx,%eax
cltd
idivl -0x4c(%rbp)
mov %edx,%ecx
mov -0x20(%rbp),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rdx
mov %ecx,(%rax,%rdx,4)
subl $0x1,-0x34(%rbp)
cmpl $0x0,-0x34(%rbp)
jg 12a6 <func0+0x13d>
addl $0x1,-0x30(%rbp)
mov -0x30(%rbp),%eax
cmp -0x44(%rbp),%eax
jle 1297 <func0+0x12e>
mov -0x20(%rbp),%rax
mov -0x48(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %rsi,%rsp
mov -0x18(%rbp),%rdi
xor %fs:0x28,%rdi
je 1312 <func0+0x1a9>
callq 1060 <__stack_chk_fail@plt>
mov -0x8(%rbp),%rbx
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov [rbp+var_38], esi
mov [rbp+var_3C], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_34]
sub eax, [rbp+var_38]
cmp [rbp+var_38], eax
jle short loc_11A7
mov eax, [rbp+var_34]
sub eax, [rbp+var_38]
mov [rbp+var_38], eax
loc_11A7:
mov eax, [rbp+var_38]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov edi, 10h
mov edx, 0
div rdi
imul rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rcx
loc_11EF:
cmp rsp, rdx
jz short loc_1206
sub rsp, 1000h
or [rsp+1040h+var_48], 0
jmp short loc_11EF
loc_1206:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1230
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1230:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_24], 0
jmp short loc_1261
loc_124C:
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov dword ptr [rax+rdx*4], 0
add [rbp+var_24], 1
loc_1261:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_38]
jle short loc_124C
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
mov [rbp+var_20], 1
jmp short loc_12CC
loc_127C:
mov edx, [rbp+var_38]
mov eax, [rbp+var_20]
cmp edx, eax
cmovle eax, edx
mov [rbp+var_1C], eax
jmp short loc_12C2
loc_128C:
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov eax, [rbp+var_1C]
lea edx, [rax-1]
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add eax, ecx
cdq
idiv [rbp+var_3C]
mov ecx, edx
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov [rax+rdx*4], ecx
sub [rbp+var_1C], 1
loc_12C2:
cmp [rbp+var_1C], 0
jg short loc_128C
add [rbp+var_20], 1
loc_12CC:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_34]
jle short loc_127C
mov rax, [rbp+var_10]
mov edx, [rbp+var_38]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12F8
call ___stack_chk_fail
locret_12F8:
leave
retn | long long func0(int a1, int a2, int a3)
{
unsigned long long v3; // rax
void *v4; // rsp
int v5; // eax
_BYTE v7[4]; // [rsp+8h] [rbp-40h] BYREF
int v8; // [rsp+Ch] [rbp-3Ch]
int v9; // [rsp+10h] [rbp-38h]
int v10; // [rsp+14h] [rbp-34h]
int i; // [rsp+24h] [rbp-24h]
int j; // [rsp+28h] [rbp-20h]
int k; // [rsp+2Ch] [rbp-1Ch]
long long v14; // [rsp+30h] [rbp-18h]
_DWORD *v15; // [rsp+38h] [rbp-10h]
unsigned long long v16; // [rsp+40h] [rbp-8h]
v10 = a1;
v9 = a2;
v8 = a3;
v16 = __readfsqword(0x28u);
if ( a2 > a1 - a2 )
v9 = v10 - v9;
v14 = v9 + 1 - 1LL;
v3 = 16 * ((4LL * (v9 + 1) + 15) / 0x10uLL);
while ( v7 != &v7[-(v3 & 0xFFFFFFFFFFFFF000LL)] )
;
v4 = alloca(v3 & 0xFFF);
if ( (v3 & 0xFFF) != 0 )
*(_QWORD *)&v7[(v3 & 0xFFF) - 8] = *(_QWORD *)&v7[(v3 & 0xFFF) - 8];
v15 = v7;
for ( i = 0; i <= v9; ++i )
v15[i] = 0;
*v15 = 1;
for ( j = 1; j <= v10; ++j )
{
v5 = j;
if ( v9 <= j )
v5 = v9;
for ( k = v5; k > 0; --k )
v15[k] = (v15[k] + v15[k - 1]) % v8;
}
return (unsigned int)v15[v9];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV dword ptr [RBP + -0x38],ESI
MOV dword ptr [RBP + -0x3c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,dword ptr [RBP + -0x38]
CMP dword ptr [RBP + -0x38],EAX
JLE 0x001011a7
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x38],EAX
LAB_001011a7:
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EDI,0x10
MOV EDX,0x0
DIV RDI
IMUL RAX,RAX,0x10
MOV RCX,RAX
AND RCX,-0x1000
MOV RDX,RSP
SUB RDX,RCX
LAB_001011ef:
CMP RSP,RDX
JZ 0x00101206
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011ef
LAB_00101206:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101230
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101230:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x24],0x0
JMP 0x00101261
LAB_0010124c:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],0x0
ADD dword ptr [RBP + -0x24],0x1
LAB_00101261:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x38]
JLE 0x0010124c
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
MOV dword ptr [RBP + -0x20],0x1
JMP 0x001012cc
LAB_0010127c:
MOV EDX,dword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x20]
CMP EDX,EAX
CMOVLE EAX,EDX
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001012c2
LAB_0010128c:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
ADD EAX,ECX
CDQ
IDIV dword ptr [RBP + -0x3c]
MOV ECX,EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],ECX
SUB dword ptr [RBP + -0x1c],0x1
LAB_001012c2:
CMP dword ptr [RBP + -0x1c],0x0
JG 0x0010128c
ADD dword ptr [RBP + -0x20],0x1
LAB_001012cc:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x34]
JLE 0x0010127c
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x38]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012f8
CALL 0x00101060
LAB_001012f8:
LEAVE
RET | int4 func0(int param_1,int param_2,int param_3)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [4];
int local_44;
int local_40;
int local_3c;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
puVar3 = auStack_48;
local_3c = param_1;
local_40 = param_2;
local_44 = param_3;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 - param_2 < param_2) {
local_40 = param_1 - param_2;
}
local_20 = (long)(local_40 + 1) + -1;
uVar2 = (((long)(local_40 + 1) * 4 + 0xfU) / 0x10) * 0x10;
for (; 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_2c = 0; local_2c <= local_40; local_2c = local_2c + 1) {
*(int4 *)(puVar3 + (long)local_2c * 4 + lVar1) = 0;
}
*(int4 *)(puVar3 + lVar1) = 1;
for (local_28 = 1; local_28 <= local_3c; local_28 = local_28 + 1) {
local_24 = local_28;
if (local_40 <= local_28) {
local_24 = local_40;
}
for (; 0 < local_24; local_24 = local_24 + -1) {
*(int *)(puVar3 + (long)local_24 * 4 + lVar1) =
(*(int *)(puVar3 + (long)(local_24 + -1) * 4 + lVar1) +
*(int *)(puVar3 + (long)local_24 * 4 + lVar1)) % local_44;
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar3 + (long)local_40 * 4 + lVar1);
}
local_18 = puVar3 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,701 | func0 |
#include <assert.h>
| int func0(int n, int r, int p) {
if (r > n - r)
r = n - r;
int C[r + 1];
for (int i = 0; i <= r; i++)
C[i] = 0;
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < r ? i : r); j > 0; j--) {
C[j] = (C[j] + C[j - 1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(11, 3, 14) == 11);
assert(func0(18, 14, 19) == 1);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x10,%rsp
mov %edx,%r8d
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %edi,%r9d
sub %esi,%r9d
cmp %esi,%r9d
cmovg %esi,%r9d
lea 0x1(%r9),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 11d2 <func0+0x69>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11bb <func0+0x52>
mov %rdx,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11e8 <func0+0x7f>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r12
mov %r12,%rcx
shr $0x2,%rcx
and $0xfffffffffffffffc,%r12
mov %r12,%r11
test %r9d,%r9d
js 121a <func0+0xb1>
mov %r12,%rax
mov %r9d,%edx
lea 0x4(%r12,%rdx,4),%rdx
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 120b <func0+0xa2>
movl $0x1,0x0(,%rcx,4)
test %edi,%edi
jle 127b <func0+0x112>
lea 0x1(%rdi),%r10d
mov $0x1,%edi
lea -0x4(%r11),%rbx
jmp 1240 <func0+0xd7>
add $0x1,%edi
cmp %r10d,%edi
je 127b <func0+0x112>
cmp %edi,%r9d
mov %edi,%eax
cmovle %r9d,%eax
test %eax,%eax
jle 1238 <func0+0xcf>
movslq %eax,%rsi
shl $0x2,%rsi
lea (%r11,%rsi,1),%rcx
add %rbx,%rsi
lea -0x1(%rax),%eax
shl $0x2,%rax
sub %rax,%rsi
mov -0x4(%rcx),%eax
add (%rcx),%eax
cltd
idiv %r8d
mov %edx,(%rcx)
sub $0x4,%rcx
cmp %rsi,%rcx
jne 1265 <func0+0xfc>
jmp 1238 <func0+0xcf>
movslq %r9d,%r9
mov (%r12,%r9,4),%eax
mov -0x18(%rbp),%rbx
xor %fs:0x28,%rbx
jne 129a <func0+0x131>
lea -0x10(%rbp),%rsp
pop %rbx
pop %r12
pop %rbp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov r10d, edi
mov eax, esi
mov esi, edx
mov rdx, fs:28h
mov [rbp+var_18], rdx
xor edx, edx
mov r9d, edi
sub r9d, eax
cmp r9d, eax
cmovg r9d, eax
lea eax, [r9+1]
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11BA:
cmp rsp, rdx
jz short loc_11D1
sub rsp, 1000h
or [rsp+1020h+var_28], 0
jmp short loc_11BA
loc_11D1:
mov rax, rcx
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11E7
or [rsp+rax+20h+var_28], 0
loc_11E7:
lea r11, [rsp+20h+var_1D]
mov rcx, r11
shr rcx, 2
and r11, 0FFFFFFFFFFFFFFFCh
test r9d, r9d
js short loc_1216
mov rax, r11
lea edx, [r9+1]
lea rdx, [r11+rdx*4]
loc_1207:
mov dword ptr [rax], 0
add rax, 4
cmp rax, rdx
jnz short loc_1207
loc_1216:
mov ds:dword_0[rcx*4], 1
test r10d, r10d
jle short loc_1276
add r10d, 1
mov r8d, 1
lea rbx, [r11-4]
loc_1234:
cmp r9d, r8d
mov eax, r8d
cmovle eax, r9d
test eax, eax
jle short loc_126D
movsxd rdi, eax
shl rdi, 2
lea rcx, [r11+rdi]
add rdi, rbx
lea eax, [rax-1]
shl rax, 2
sub rdi, rax
loc_125A:
mov eax, [rcx-4]
add eax, [rcx]
cdq
idiv esi
mov [rcx], edx
sub rcx, 4
cmp rcx, rdi
jnz short loc_125A
loc_126D:
add r8d, 1
cmp r8d, r10d
jnz short loc_1234
loc_1276:
movsxd r9, r9d
mov eax, [r11+r9*4]
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jnz short loc_1292
mov rbx, [rbp+var_8]
leave
retn
loc_1292:
call ___stack_chk_fail | long long func0(int a1, int a2, int a3)
{
int v3; // r9d
signed long long v4; // rax
void *v5; // rsp
_DWORD *v6; // rax
int v7; // r10d
int v8; // r8d
int v9; // eax
long long v10; // rdi
int *v11; // rcx
int *v12; // rdi
_DWORD v15[2]; // [rsp+8h] [rbp-20h] BYREF
unsigned long long v16; // [rsp+10h] [rbp-18h]
v16 = __readfsqword(0x28u);
v3 = a1 - a2;
if ( a1 - a2 > a2 )
v3 = a2;
while ( v15 != (_DWORD *)((char *)v15 - ((4LL * (v3 + 1) + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v4 = (4 * ((_WORD)v3 + 1) + 15) & 0xFF0;
v5 = alloca(v4);
if ( ((4 * ((_WORD)v3 + 1) + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v15[-2] + v4) = *(_QWORD *)((char *)&v15[-2] + v4);
if ( v3 >= 0 )
{
v6 = v15;
do
*v6++ = 0;
while ( v6 != &v15[v3 + 1] );
}
v15[0] = 1;
if ( a1 > 0 )
{
v7 = a1 + 1;
v8 = 1;
do
{
v9 = v8;
if ( v3 <= v8 )
v9 = v3;
if ( v9 > 0 )
{
v10 = v9;
v11 = &v15[v10];
v12 = &v15[v10 - 1 - (unsigned int)(v9 - 1)];
do
{
*v11 = (*v11 + *(v11 - 1)) % a3;
--v11;
}
while ( v11 != v12 );
}
++v8;
}
while ( v8 != v7 );
}
return (unsigned int)v15[v3];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV R10D,EDI
MOV EAX,ESI
MOV ESI,EDX
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RDX
XOR EDX,EDX
MOV R9D,EDI
SUB R9D,EAX
CMP R9D,EAX
CMOVG R9D,EAX
LEA EAX,[R9 + 0x1]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011ba:
CMP RSP,RDX
JZ 0x001011d1
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011ba
LAB_001011d1:
MOV RAX,RCX
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011e7
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011e7:
LEA R11,[RSP + 0x3]
MOV RCX,R11
SHR RCX,0x2
AND R11,-0x4
TEST R9D,R9D
JS 0x00101216
MOV RAX,R11
LEA EDX,[R9 + 0x1]
LEA RDX,[R11 + RDX*0x4]
LAB_00101207:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101207
LAB_00101216:
MOV dword ptr [RCX*0x4],0x1
TEST R10D,R10D
JLE 0x00101276
ADD R10D,0x1
MOV R8D,0x1
LEA RBX,[R11 + -0x4]
LAB_00101234:
CMP R9D,R8D
MOV EAX,R8D
CMOVLE EAX,R9D
TEST EAX,EAX
JLE 0x0010126d
MOVSXD RDI,EAX
SHL RDI,0x2
LEA RCX,[R11 + RDI*0x1]
ADD RDI,RBX
LEA EAX,[RAX + -0x1]
SHL RAX,0x2
SUB RDI,RAX
LAB_0010125a:
MOV EAX,dword ptr [RCX + -0x4]
ADD EAX,dword ptr [RCX]
CDQ
IDIV ESI
MOV dword ptr [RCX],EDX
SUB RCX,0x4
CMP RCX,RDI
JNZ 0x0010125a
LAB_0010126d:
ADD R8D,0x1
CMP R8D,R10D
JNZ 0x00101234
LAB_00101276:
MOVSXD R9,R9D
MOV EAX,dword ptr [R11 + R9*0x4]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101292
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
LAB_00101292:
CALL 0x00101060 | int4 func0(int param_1,int param_2,int param_3)
{
int iVar1;
long lVar2;
int iVar3;
ulong uVar4;
int4 *puVar5;
int *piVar6;
int1 *puVar7;
int iVar8;
long in_FS_OFFSET;
int1 auStack_28 [8];
long local_20;
puVar7 = auStack_28;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = param_1 - param_2;
if (param_2 < param_1 - param_2) {
iVar1 = param_2;
}
uVar4 = (long)(iVar1 + 1) * 4 + 0xf;
for (; puVar7 != auStack_28 + -(uVar4 & 0xfffffffffffff000); puVar7 = puVar7 + -0x1000) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
uVar4 = (ulong)((uint)uVar4 & 0xff0);
lVar2 = -uVar4;
puVar5 = (int4 *)(puVar7 + lVar2);
if (uVar4 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if (-1 < iVar1) {
do {
*puVar5 = 0;
puVar5 = puVar5 + 1;
} while (puVar5 != (int4 *)(puVar7 + (ulong)(iVar1 + 1) * 4 + lVar2));
}
*(int4 *)(puVar7 + lVar2) = 1;
if (0 < param_1) {
iVar8 = 1;
do {
iVar3 = iVar8;
if (iVar1 <= iVar8) {
iVar3 = iVar1;
}
if (0 < iVar3) {
piVar6 = (int *)(puVar7 + (long)iVar3 * 4 + lVar2);
do {
*piVar6 = (piVar6[-1] + *piVar6) % param_3;
piVar6 = piVar6 + -1;
} while (piVar6 != (int *)(puVar7 + (ulong)(iVar3 - 1) * -4 + (long)iVar3 * 4 + lVar2 + -4))
;
}
iVar8 = iVar8 + 1;
} while (iVar8 != param_1 + 1);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar7 + (long)iVar1 * 4 + lVar2);
}
/* WARNING: Subroutine does not return */
*(code **)(puVar7 + lVar2 + -8) = main;
__stack_chk_fail();
} |
7,702 | func0 |
#include <assert.h>
| int func0(int n, int r, int p) {
if (r > n - r)
r = n - r;
int C[r + 1];
for (int i = 0; i <= r; i++)
C[i] = 0;
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < r ? i : r); j > 0; j--) {
C[j] = (C[j] + C[j - 1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(11, 3, 14) == 11);
assert(func0(18, 14, 19) == 1);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %edi,%r9d
mov %edx,%r8d
sub %esi,%r9d
mov %rsp,%rbp
push %r12
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
cmp %esi,%r9d
mov %rsp,%rbx
cmovg %esi,%r9d
lea 0x1(%r9),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%rdx
mov %rbx,%rax
cmp %rax,%rsp
je 147c <func0+0x6c>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1467 <func0+0x57>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1549 <func0+0x139>
lea 0x3(%rsp),%r11
movslq %r9d,%r12
mov %r11,%rcx
and $0xfffffffffffffffc,%r11
shr $0x2,%rcx
test %r9d,%r9d
js 14c7 <func0+0xb7>
movslq %r9d,%r12
mov %r11,%rax
lea 0x4(%r11,%r12,4),%rdx
nopl 0x0(%rax)
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 14b8 <func0+0xa8>
movl $0x1,0x0(,%rcx,4)
test %edi,%edi
jle 152d <func0+0x11d>
lea 0x1(%rdi),%r10d
lea -0x4(%r11),%rbx
mov $0x1,%edi
nopl 0x0(%rax,%rax,1)
cmp %edi,%r9d
mov %edi,%eax
cmovle %r9d,%eax
test %eax,%eax
jle 1525 <func0+0x115>
movslq %eax,%rsi
sub $0x1,%eax
shl $0x2,%rsi
shl $0x2,%rax
lea (%r11,%rsi,1),%rcx
add %rbx,%rsi
sub %rax,%rsi
nopl (%rax)
mov -0x4(%rcx),%eax
add (%rcx),%eax
sub $0x4,%rcx
cltd
idiv %r8d
mov %edx,0x4(%rcx)
cmp %rsi,%rcx
jne 1510 <func0+0x100>
add $0x1,%edi
cmp %r10d,%edi
jne 14e8 <func0+0xd8>
mov -0x18(%rbp),%rbx
xor %fs:0x28,%rbx
mov (%r11,%r12,4),%eax
jne 1554 <func0+0x144>
lea -0x10(%rbp),%rsp
pop %rbx
pop %r12
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 148e <func0+0x7e>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
mov r15d, edi
push r14
push r13
push r12
mov r12d, edi
push rbx
sub r12d, esi
mov ebx, edx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
cmp r12d, esi
mov rcx, rsp
cmovg r12d, esi
lea eax, [r12+1]
cdqe
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_12C2
loc_12AD:
sub rsp, 1000h
or [rsp+1040h+var_48], 0
cmp rsp, rcx
jnz short loc_12AD
loc_12C2:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1386
loc_12D4:
lea r9, [rsp+1040h+var_103D]
movsxd r13, r12d
mov r14, r9
and r9, 0FFFFFFFFFFFFFFFCh
shr r14, 2
test r12d, r12d
js short loc_1301
mov rdi, r9
lea rdx, ds:4[r13*4]
xor esi, esi
call _memset
mov r9, rax
loc_1301:
mov ds:dword_0[r14*4], 1
test r15d, r15d
jle short loc_1364
lea r8d, [r15+1]
mov edi, 1
lea r10, [r9-4]
nop
loc_1320:
cmp r12d, edi
mov eax, edi
cmovle eax, r12d
test eax, eax
jle short loc_135C
movsxd rsi, eax
sub eax, 1
shl rsi, 2
shl rax, 2
lea rcx, [r9+rsi]
add rsi, r10
sub rsi, rax
nop dword ptr [rax]
loc_1348:
mov eax, [rcx-4]
add eax, [rcx]
sub rcx, 4
cdq
idiv ebx
mov [rcx+4], edx
cmp rcx, rsi
jnz short loc_1348
loc_135C:
add edi, 1
cmp edi, r8d
jnz short loc_1320
loc_1364:
mov eax, [r9+r13*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1391
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1386:
or [rsp+rdx+1040h+var_1048], 0
jmp loc_12D4
loc_1391:
call ___stack_chk_fail | long long func0(int a1, int a2, int a3)
{
int v4; // r12d
long long v6; // rdx
_DWORD *v7; // rcx
__int16 v8; // dx
signed long long v9; // rdx
void *v10; // rsp
_DWORD *v11; // r9
int v12; // edi
int v13; // eax
long long v14; // rsi
_DWORD *v15; // rcx
long long v16; // rsi
int v17; // eax
_DWORD v20[1022]; // [rsp+8h] [rbp-1040h] BYREF
_QWORD v21[8]; // [rsp+1008h] [rbp-40h] BYREF
v4 = a1 - a2;
v21[1] = __readfsqword(0x28u);
if ( a1 - a2 > a2 )
v4 = a2;
v6 = 4LL * (v4 + 1) + 15;
v7 = (_DWORD *)((char *)v21 - (v6 & 0xFFFFFFFFFFFFF000LL));
v8 = v6 & 0xFFF0;
if ( v21 != (_QWORD *)v7 )
{
while ( v20 != v7 )
;
}
v9 = v8 & 0xFFF;
v10 = alloca(v9);
if ( v9 )
*(_QWORD *)((char *)&v20[-2] + v9) = *(_QWORD *)((char *)&v20[-2] + v9);
v11 = v20;
if ( v4 >= 0 )
v11 = (_DWORD *)memset(v20, 0LL, 4LL * v4 + 4);
v20[0] = 1;
if ( a1 > 0 )
{
v12 = 1;
do
{
v13 = v12;
if ( v4 <= v12 )
v13 = v4;
if ( v13 > 0 )
{
v14 = v13;
v15 = &v11[v14];
v16 = (long long)&v11[v14 - 1 - (unsigned int)(v13 - 1)];
do
{
v17 = *v15 + *(v15 - 1);
--v15;
v15[1] = v17 % a3;
}
while ( v15 != (_DWORD *)v16 );
}
++v12;
}
while ( v12 != a1 + 1 );
}
return (unsigned int)v11[v4];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
MOV R15D,EDI
PUSH R14
PUSH R13
PUSH R12
MOV R12D,EDI
PUSH RBX
SUB R12D,ESI
MOV EBX,EDX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
CMP R12D,ESI
MOV RCX,RSP
CMOVG R12D,ESI
LEA EAX,[R12 + 0x1]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012c2
LAB_001012ad:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001012ad
LAB_001012c2:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101386
LAB_001012d4:
LEA R9,[RSP + 0x3]
MOVSXD R13,R12D
MOV R14,R9
AND R9,-0x4
SHR R14,0x2
TEST R12D,R12D
JS 0x00101301
MOV RDI,R9
LEA RDX,[0x4 + R13*0x4]
XOR ESI,ESI
CALL 0x00101090
MOV R9,RAX
LAB_00101301:
MOV dword ptr [R14*0x4],0x1
TEST R15D,R15D
JLE 0x00101364
LEA R8D,[R15 + 0x1]
MOV EDI,0x1
LEA R10,[R9 + -0x4]
NOP
LAB_00101320:
CMP R12D,EDI
MOV EAX,EDI
CMOVLE EAX,R12D
TEST EAX,EAX
JLE 0x0010135c
MOVSXD RSI,EAX
SUB EAX,0x1
SHL RSI,0x2
SHL RAX,0x2
LEA RCX,[R9 + RSI*0x1]
ADD RSI,R10
SUB RSI,RAX
NOP dword ptr [RAX]
LAB_00101348:
MOV EAX,dword ptr [RCX + -0x4]
ADD EAX,dword ptr [RCX]
SUB RCX,0x4
CDQ
IDIV EBX
MOV dword ptr [RCX + 0x4],EDX
CMP RCX,RSI
JNZ 0x00101348
LAB_0010135c:
ADD EDI,0x1
CMP EDI,R8D
JNZ 0x00101320
LAB_00101364:
MOV EAX,dword ptr [R9 + R13*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101391
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101386:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012d4
LAB_00101391:
CALL 0x00101070 | int4 func0(int param_1,int param_2,int param_3)
{
long lVar1;
int iVar2;
int1 *puVar3;
int *piVar4;
int *piVar5;
ulong uVar6;
int1 *puVar7;
int iVar9;
int iVar10;
long in_FS_OFFSET;
int1 auStack_48 [8];
long local_40;
int1 *puVar8;
puVar7 = auStack_48;
puVar8 = auStack_48;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
iVar10 = param_1 - param_2;
if (param_2 < param_1 - param_2) {
iVar10 = param_2;
}
uVar6 = (long)(iVar10 + 1) * 4 + 0xf;
puVar3 = auStack_48;
while (puVar8 != auStack_48 + -(uVar6 & 0xfffffffffffff000)) {
puVar7 = puVar3 + -0x1000;
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
puVar8 = puVar3 + -0x1000;
puVar3 = puVar3 + -0x1000;
}
uVar6 = (ulong)((uint)uVar6 & 0xff0);
lVar1 = -uVar6;
puVar3 = puVar7 + lVar1;
if (uVar6 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if (-1 < iVar10) {
*(int8 *)(puVar7 + lVar1 + -8) = 0x1012fe;
puVar3 = (int1 *)memset(puVar7 + lVar1,0,(long)iVar10 * 4 + 4);
}
*(int4 *)(puVar7 + lVar1) = 1;
if (0 < param_1) {
iVar9 = 1;
do {
iVar2 = iVar9;
if (iVar10 <= iVar9) {
iVar2 = iVar10;
}
if (0 < iVar2) {
piVar4 = (int *)(puVar3 + (long)iVar2 * 4);
do {
piVar5 = piVar4 + -1;
*piVar4 = (piVar4[-1] + *piVar4) % param_3;
piVar4 = piVar5;
} while (piVar5 != (int *)(puVar3 + (ulong)(iVar2 - 1) * -4 + (long)iVar2 * 4 + -4));
}
iVar9 = iVar9 + 1;
} while (iVar9 != param_1 + 1);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + lVar1 + -8) = 0x101396;
__stack_chk_fail();
}
return *(int4 *)(puVar3 + (long)iVar10 * 4);
} |
7,703 | func0 |
#include <assert.h>
| int func0(int n, int r, int p) {
if (r > n - r)
r = n - r;
int C[r + 1];
for (int i = 0; i <= r; i++)
C[i] = 0;
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (i < r ? i : r); j > 0; j--) {
C[j] = (C[j] + C[j - 1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(11, 3, 14) == 11);
assert(func0(18, 14, 19) == 1);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
mov %edi,%r15d
push %r14
push %r13
push %r12
mov %edi,%r12d
push %rbx
sub %esi,%r12d
mov %edx,%ebx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
cmp %esi,%r12d
mov %rsp,%rdi
cmovg %esi,%r12d
lea 0x1(%r12),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rdi
and $0xfffffffffffffff0,%rdx
mov %rdi,%rax
cmp %rax,%rsp
je 1895 <func0+0x75>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 1880 <func0+0x60>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 1961 <func0+0x141>
lea 0x3(%rsp),%r10
movslq %r12d,%r13
mov %r10,%r14
and $0xfffffffffffffffc,%r10
shr $0x2,%r14
test %r12d,%r12d
js 18d4 <func0+0xb4>
mov %r10,%rdi
lea 0x4(,%r13,4),%rdx
xor %esi,%esi
callq 1090 <memset@plt>
mov %rax,%r10
movl $0x1,0x0(,%r14,4)
test %r15d,%r15d
jle 193f <func0+0x11f>
lea 0x1(%r15),%r9d
mov $0x1,%r8d
lea -0x4(%r10),%r11
nopl 0x0(%rax,%rax,1)
cmp %r8d,%r12d
mov %r8d,%eax
cmovle %r12d,%eax
test %eax,%eax
jle 1936 <func0+0x116>
movslq %eax,%rdi
sub $0x1,%eax
shl $0x2,%rdi
shl $0x2,%rax
lea (%r10,%rdi,1),%rcx
add %r11,%rdi
mov (%rcx),%esi
sub %rax,%rdi
mov %esi,%eax
mov -0x4(%rcx),%esi
sub $0x4,%rcx
add %esi,%eax
cltd
idiv %ebx
mov %edx,0x4(%rcx)
cmp %rdi,%rcx
jne 1920 <func0+0x100>
add $0x1,%r8d
cmp %r9d,%r8d
jne 18f8 <func0+0xd8>
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
mov (%r10,%r13,4),%eax
jne 196c <func0+0x14c>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 18a7 <func0+0x87>
callq 1070 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
mov r15d, edi
push r14
push r13
push r12
mov r12d, edi
push rbx
sub r12d, esi
mov ebx, edx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
cmp r12d, esi
mov rcx, rsp
cmovg r12d, esi
lea eax, [r12+1]
cdqe
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_12C2
loc_12AD:
sub rsp, 1000h
or [rsp+1040h+var_48], 0
cmp rsp, rcx
jnz short loc_12AD
loc_12C2:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1391
loc_12D4:
lea r10, [rsp+1040h+var_103D]
movsxd r13, r12d
mov r14, r10
and r10, 0FFFFFFFFFFFFFFFCh
shr r14, 2
test r12d, r12d
js short loc_1301
mov rdi, r10; s
lea rdx, ds:4[r13*4]; n
xor esi, esi; c
call _memset
mov r10, rax
loc_1301:
mov ds:dword_0[r14*4], 1
test r15d, r15d
jle short loc_136F
lea r9d, [r15+1]
mov r8d, 1
lea r11, [r10-4]
loc_1320:
cmp r12d, r8d
mov eax, r8d
cmovle eax, r12d
test eax, eax
jle short loc_1366
movsxd rdi, eax
sub eax, 1
shl rdi, 2
shl rax, 2
lea rcx, [r10+rdi]
add rdi, r11
mov esi, [rcx]
sub rdi, rax
nop dword ptr [rax+rax+00000000h]
loc_1350:
mov eax, esi
mov esi, [rcx-4]
sub rcx, 4
add eax, esi
cdq
idiv ebx
mov [rcx+4], edx
cmp rcx, rdi
jnz short loc_1350
loc_1366:
add r8d, 1
cmp r8d, r9d
jnz short loc_1320
loc_136F:
mov eax, [r10+r13*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_139C
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1391:
or [rsp+rdx+1040h+var_1048], 0
jmp loc_12D4
loc_139C:
call ___stack_chk_fail | long long func0(int a1, int a2, int a3)
{
int v3; // r12d
long long v5; // rdx
_DWORD *v6; // rcx
__int16 v7; // dx
signed long long v8; // rdx
void *v9; // rsp
_DWORD *v10; // r10
int v11; // r9d
int v12; // r8d
int v13; // eax
long long v14; // rdi
_DWORD *v15; // rcx
int v16; // esi
long long v17; // rdi
int v18; // eax
_DWORD v21[1022]; // [rsp+8h] [rbp-1040h] BYREF
_QWORD v22[8]; // [rsp+1008h] [rbp-40h] BYREF
v3 = a1 - a2;
v22[1] = __readfsqword(0x28u);
if ( a1 - a2 > a2 )
v3 = a2;
v5 = 4LL * (v3 + 1) + 15;
v6 = (_DWORD *)((char *)v22 - (v5 & 0xFFFFFFFFFFFFF000LL));
v7 = v5 & 0xFFF0;
if ( v22 != (_QWORD *)v6 )
{
while ( v21 != v6 )
;
}
v8 = v7 & 0xFFF;
v9 = alloca(v8);
if ( v8 )
*(_QWORD *)((char *)&v21[-2] + v8) = *(_QWORD *)((char *)&v21[-2] + v8);
v10 = v21;
if ( v3 >= 0 )
v10 = memset(v21, 0, 4LL * v3 + 4);
v21[0] = 1;
if ( a1 > 0 )
{
v11 = a1 + 1;
v12 = 1;
do
{
v13 = v12;
if ( v3 <= v12 )
v13 = v3;
if ( v13 > 0 )
{
v14 = v13;
v15 = &v10[v14];
v16 = v10[v14];
v17 = (long long)&v10[v14 - 1 - (unsigned int)(v13 - 1)];
do
{
v18 = v16;
v16 = *--v15;
v15[1] = (v16 + v18) % a3;
}
while ( v15 != (_DWORD *)v17 );
}
++v12;
}
while ( v12 != v11 );
}
return (unsigned int)v10[v3];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
MOV R15D,EDI
PUSH R14
PUSH R13
PUSH R12
MOV R12D,EDI
PUSH RBX
SUB R12D,ESI
MOV EBX,EDX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
CMP R12D,ESI
MOV RCX,RSP
CMOVG R12D,ESI
LEA EAX,[R12 + 0x1]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012c2
LAB_001012ad:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001012ad
LAB_001012c2:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101391
LAB_001012d4:
LEA R10,[RSP + 0x3]
MOVSXD R13,R12D
MOV R14,R10
AND R10,-0x4
SHR R14,0x2
TEST R12D,R12D
JS 0x00101301
MOV RDI,R10
LEA RDX,[0x4 + R13*0x4]
XOR ESI,ESI
CALL 0x00101090
MOV R10,RAX
LAB_00101301:
MOV dword ptr [R14*0x4],0x1
TEST R15D,R15D
JLE 0x0010136f
LEA R9D,[R15 + 0x1]
MOV R8D,0x1
LEA R11,[R10 + -0x4]
LAB_00101320:
CMP R12D,R8D
MOV EAX,R8D
CMOVLE EAX,R12D
TEST EAX,EAX
JLE 0x00101366
MOVSXD RDI,EAX
SUB EAX,0x1
SHL RDI,0x2
SHL RAX,0x2
LEA RCX,[R10 + RDI*0x1]
ADD RDI,R11
MOV ESI,dword ptr [RCX]
SUB RDI,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101350:
MOV EAX,ESI
MOV ESI,dword ptr [RCX + -0x4]
SUB RCX,0x4
ADD EAX,ESI
CDQ
IDIV EBX
MOV dword ptr [RCX + 0x4],EDX
CMP RCX,RDI
JNZ 0x00101350
LAB_00101366:
ADD R8D,0x1
CMP R8D,R9D
JNZ 0x00101320
LAB_0010136f:
MOV EAX,dword ptr [R10 + R13*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010139c
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101391:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x001012d4
LAB_0010139c:
CALL 0x00101070 | int4 func0(int param_1,int param_2,int param_3)
{
int *piVar1;
long lVar2;
int iVar3;
int *puVar4;
int *piVar5;
int *piVar6;
ulong uVar7;
int *puVar8;
int iVar10;
int iVar11;
int iVar12;
long in_FS_OFFSET;
int auStack_48 [8];
long local_40;
int *puVar9;
puVar8 = auStack_48;
puVar9 = auStack_48;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
iVar12 = param_1 - param_2;
if (param_2 < param_1 - param_2) {
iVar12 = param_2;
}
uVar7 = (long)(iVar12 + 1) * 4 + 0xf;
puVar4 = auStack_48;
while (puVar9 != auStack_48 + -(uVar7 & 0xfffffffffffff000)) {
puVar8 = puVar4 + -0x1000;
*(int8 *)(puVar4 + -8) = *(int8 *)(puVar4 + -8);
puVar9 = puVar4 + -0x1000;
puVar4 = puVar4 + -0x1000;
}
uVar7 = (ulong)((uint)uVar7 & 0xff0);
lVar2 = -uVar7;
puVar4 = puVar8 + lVar2;
if (uVar7 != 0) {
*(int8 *)(puVar8 + -8) = *(int8 *)(puVar8 + -8);
}
if (-1 < iVar12) {
*(int8 *)(puVar8 + lVar2 + -8) = 0x1012fe;
puVar4 = (int *)memset(puVar8 + lVar2,0,(long)iVar12 * 4 + 4);
}
*(int4 *)(puVar8 + lVar2) = 1;
if (0 < param_1) {
iVar11 = 1;
do {
iVar3 = iVar11;
if (iVar12 <= iVar11) {
iVar3 = iVar12;
}
if (0 < iVar3) {
piVar5 = (int *)(puVar4 + (long)iVar3 * 4);
iVar10 = *(int *)(puVar4 + (long)iVar3 * 4);
do {
piVar1 = piVar5 + -1;
piVar6 = piVar5 + -1;
*piVar5 = (iVar10 + *piVar1) % param_3;
piVar5 = piVar6;
iVar10 = *piVar1;
} while (piVar6 != (int *)(puVar4 + (ulong)(iVar3 - 1) * -4 + (long)iVar3 * 4 + -4));
}
iVar11 = iVar11 + 1;
} while (iVar11 != param_1 + 1);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar8 + lVar2 + -8) = 0x1013a1;
__stack_chk_fail();
}
return *(int4 *)(puVar4 + (long)iVar12 * 4);
} |
7,704 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int ar[], int n) {
int res = 0;
int i, count;
// Sorting the array
for (int step = 0; step < n - 1; ++step) {
for (int i = 0; i < n - step - 1; ++i) {
if (ar[i] > ar[i + 1]) {
int temp = ar[i];
ar[i] = ar[i + 1];
ar[i + 1] = temp;
}
}
}
// Counting maximum subset elements
i = 0;
while (i < n) {
count = 1;
while (i + 1 < n && ar[i] == ar[i + 1]) {
count++;
i++;
}
if (res < count) {
res = count;
}
i++;
}
return res;
}
| int main() {
int ar1[] = {1, 2, 3, 4};
int ar2[] = {5, 6, 9, 3, 4, 3, 4};
int ar3[] = {1, 2, 3};
assert(func0(ar1, 4) == 1);
assert(func0(ar2, 7) == 2);
assert(func0(ar3, 3) == 1);
printf("All test cases passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 126c <func0+0xe3>
movl $0x0,-0x8(%rbp)
jmpq 1256 <func0+0xcd>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x8(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 1252 <func0+0xc9>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x8(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x2c(%rbp),%eax
sub -0xc(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x8(%rbp)
jl 11b7 <func0+0x2e>
addl $0x1,-0xc(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0xc(%rbp)
jl 11ab <func0+0x22>
movl $0x0,-0x14(%rbp)
jmp 12e6 <func0+0x15d>
movl $0x1,-0x10(%rbp)
jmp 1295 <func0+0x10c>
addl $0x1,-0x10(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
add $0x1,%eax
cmp %eax,-0x2c(%rbp)
jle 12d4 <func0+0x14b>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
je 128d <func0+0x104>
mov -0x18(%rbp),%eax
cmp -0x10(%rbp),%eax
jge 12e2 <func0+0x159>
mov -0x10(%rbp),%eax
mov %eax,-0x18(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1284 <func0+0xfb>
mov -0x18(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_18], 0
mov [rbp+var_C], 0
jmp loc_126C
loc_11AB:
mov [rbp+var_8], 0
jmp loc_1256
loc_11B7:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_8]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_1252
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_8]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_8]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_8]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
loc_1252:
add [rbp+var_8], 1
loc_1256:
mov eax, [rbp+var_2C]
sub eax, [rbp+var_C]
sub eax, 1
cmp [rbp+var_8], eax
jl loc_11B7
add [rbp+var_C], 1
loc_126C:
mov eax, [rbp+var_2C]
sub eax, 1
cmp [rbp+var_C], eax
jl loc_11AB
mov [rbp+var_14], 0
jmp short loc_12E6
loc_1284:
mov [rbp+var_10], 1
jmp short loc_1295
loc_128D:
add [rbp+var_10], 1
add [rbp+var_14], 1
loc_1295:
mov eax, [rbp+var_14]
add eax, 1
cmp [rbp+var_2C], eax
jle short loc_12D4
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_14]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jz short loc_128D
loc_12D4:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_10]
jge short loc_12E2
mov eax, [rbp+var_10]
mov [rbp+var_18], eax
loc_12E2:
add [rbp+var_14], 1
loc_12E6:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl short loc_1284
mov eax, [rbp+var_18]
pop rbp
retn | long long func0(long long a1, int a2)
{
int v3; // [rsp+14h] [rbp-18h]
int k; // [rsp+18h] [rbp-14h]
int v5; // [rsp+1Ch] [rbp-10h]
int i; // [rsp+20h] [rbp-Ch]
int j; // [rsp+24h] [rbp-8h]
int v8; // [rsp+28h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2 - 1; ++i )
{
for ( j = 0; j < a2 - i - 1; ++j )
{
if ( *(_DWORD *)(4LL * j + a1) > *(_DWORD *)(4 * (j + 1LL) + a1) )
{
v8 = *(_DWORD *)(4LL * j + a1);
*(_DWORD *)(4LL * j + a1) = *(_DWORD *)(4 * (j + 1LL) + a1);
*(_DWORD *)(a1 + 4 * (j + 1LL)) = v8;
}
}
}
for ( k = 0; k < a2; ++k )
{
v5 = 1;
while ( a2 > k + 1 && *(_DWORD *)(4LL * k + a1) == *(_DWORD *)(4 * (k + 1LL) + a1) )
{
++v5;
++k;
}
if ( v3 < v5 )
v3 = v5;
}
return (unsigned int)v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010126c
LAB_001011ab:
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101256
LAB_001011b7:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x00101252
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
LAB_00101252:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101256:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
CMP dword ptr [RBP + -0x8],EAX
JL 0x001011b7
ADD dword ptr [RBP + -0xc],0x1
LAB_0010126c:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
CMP dword ptr [RBP + -0xc],EAX
JL 0x001011ab
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012e6
LAB_00101284:
MOV dword ptr [RBP + -0x10],0x1
JMP 0x00101295
LAB_0010128d:
ADD dword ptr [RBP + -0x10],0x1
ADD dword ptr [RBP + -0x14],0x1
LAB_00101295:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
CMP dword ptr [RBP + -0x2c],EAX
JLE 0x001012d4
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JZ 0x0010128d
LAB_001012d4:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x001012e2
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x18],EAX
LAB_001012e2:
ADD dword ptr [RBP + -0x14],0x1
LAB_001012e6:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101284
MOV EAX,dword ptr [RBP + -0x18]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 uVar1;
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
int4 local_10;
local_20 = 0;
for (local_14 = 0; local_14 < param_2 + -1; local_14 = local_14 + 1) {
for (local_10 = 0; local_10 < (param_2 - local_14) + -1; local_10 = local_10 + 1) {
if (*(int *)(param_1 + ((long)local_10 + 1) * 4) < *(int *)(param_1 + (long)local_10 * 4)) {
uVar1 = *(int4 *)(param_1 + (long)local_10 * 4);
*(int4 *)(param_1 + (long)local_10 * 4) =
*(int4 *)(param_1 + ((long)local_10 + 1) * 4);
*(int4 *)(((long)local_10 + 1) * 4 + param_1) = uVar1;
}
}
}
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
local_18 = 1;
while ((local_1c + 1 < param_2 &&
(*(int *)(param_1 + (long)local_1c * 4) == *(int *)(param_1 + ((long)local_1c + 1) * 4)))
) {
local_18 = local_18 + 1;
local_1c = local_1c + 1;
}
if (local_20 < local_18) {
local_20 = local_18;
}
}
return local_20;
} |
7,705 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int ar[], int n) {
int res = 0;
int i, count;
// Sorting the array
for (int step = 0; step < n - 1; ++step) {
for (int i = 0; i < n - step - 1; ++i) {
if (ar[i] > ar[i + 1]) {
int temp = ar[i];
ar[i] = ar[i + 1];
ar[i + 1] = temp;
}
}
}
// Counting maximum subset elements
i = 0;
while (i < n) {
count = 1;
while (i + 1 < n && ar[i] == ar[i + 1]) {
count++;
i++;
}
if (res < count) {
res = count;
}
i++;
}
return res;
}
| int main() {
int ar1[] = {1, 2, 3, 4};
int ar2[] = {5, 6, 9, 3, 4, 3, 4};
int ar3[] = {1, 2, 3};
assert(func0(ar1, 4) == 1);
assert(func0(ar2, 7) == 2);
assert(func0(ar3, 3) == 1);
printf("All test cases passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
lea -0x1(%rsi),%r9d
test %r9d,%r9d
jle 11cd <func0+0x44>
lea 0x4(%rdi),%r10
jmp 11bb <func0+0x32>
add $0x4,%rax
cmp %r8,%rax
je 11b5 <func0+0x2c>
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 119c <func0+0x13>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
jmp 119c <func0+0x13>
sub $0x1,%r9d
je 11cd <func0+0x44>
test %r9d,%r9d
jle 11b5 <func0+0x2c>
mov %rdi,%rax
lea -0x1(%r9),%edx
lea (%r10,%rdx,4),%r8
jmp 11a5 <func0+0x1c>
mov $0x0,%ecx
mov $0x0,%r10d
test %esi,%esi
jg 11e9 <func0+0x60>
jmp 1225 <func0+0x9c>
cmp %eax,%r10d
cmovl %eax,%r10d
cmp %ecx,%esi
jle 1225 <func0+0x9c>
lea 0x1(%rcx),%eax
cmp %eax,%esi
jle 1229 <func0+0xa0>
movslq %ecx,%rax
lea (%rdi,%rax,4),%rdx
mov %ecx,%r8d
mov %esi,%r9d
sub %ecx,%r9d
mov $0x1,%eax
lea (%rax,%r8,1),%ecx
mov 0x4(%rdx),%r11d
cmp %r11d,(%rdx)
jne 11de <func0+0x55>
add $0x1,%eax
add $0x4,%rdx
cmp %r9d,%eax
jne 1205 <func0+0x7c>
cmp %r9d,%r10d
cmovl %r9d,%r10d
mov %r10d,%eax
retq
test %r10d,%r10d
mov $0x1,%eax
cmovle %eax,%r10d
jmp 1225 <func0+0x9c>
| func0:
endbr64
mov r10, rdi
mov r8d, esi
lea edi, [rsi-1]
test edi, edi
jle short loc_11CE
lea r9, [r10+4]
jmp short loc_11BE
loc_11A0:
add rax, 4
cmp rax, rsi
jz short loc_11B9
loc_11A9:
mov edx, [rax]
mov ecx, [rax+4]
cmp edx, ecx
jle short loc_11A0
mov [rax], ecx
mov [rax+4], edx
jmp short loc_11A0
loc_11B9:
sub edi, 1
jz short loc_11CE
loc_11BE:
test edi, edi
jle short loc_11B9
mov rax, r10
lea edx, [rdi-1]
lea rsi, [r9+rdx*4]
jmp short loc_11A9
loc_11CE:
mov ecx, 0
mov r9d, 0
test r8d, r8d
jg short loc_11EC
jmp short loc_1225
loc_11E0:
cmp r9d, eax
cmovl r9d, eax
cmp r8d, ecx
jle short loc_1225
loc_11EC:
lea eax, [rcx+1]
cmp r8d, eax
jle short loc_1229
movsxd rax, ecx
lea rdx, [r10+rax*4]
mov esi, ecx
mov edi, r8d
sub edi, ecx
mov eax, 1
loc_1207:
lea ecx, [rax+rsi]
mov r11d, [rdx+4]
cmp [rdx], r11d
jnz short loc_11E0
add eax, 1
add rdx, 4
cmp eax, edi
jnz short loc_1207
cmp r9d, eax
cmovl r9d, eax
loc_1225:
mov eax, r9d
retn
loc_1229:
test r9d, r9d
mov eax, 1
cmovle r9d, eax
jmp short loc_1225 | long long func0(int *a1, int a2)
{
int v4; // edi
int *v5; // rax
int v6; // edx
int v7; // ecx
int v8; // ecx
int v9; // r9d
int *v10; // rdx
int v11; // esi
int v12; // edi
int v13; // eax
v4 = a2 - 1;
if ( a2 - 1 > 0 )
{
do
{
if ( v4 > 0 )
{
v5 = a1;
do
{
v6 = *v5;
v7 = v5[1];
if ( *v5 > v7 )
{
*v5 = v7;
v5[1] = v6;
}
++v5;
}
while ( v5 != &a1[v4 - 1 + 1] );
}
--v4;
}
while ( v4 );
}
v8 = 0;
v9 = 0;
if ( a2 > 0 )
{
while ( a2 > v8 + 1 )
{
v10 = &a1[v8];
v11 = v8;
v12 = a2 - v8;
v13 = 1;
while ( 1 )
{
v8 = v13 + v11;
if ( *v10 != v10[1] )
break;
++v13;
++v10;
if ( v13 == v12 )
{
if ( v9 < v13 )
return (unsigned int)v13;
return (unsigned int)v9;
}
}
if ( v9 < v13 )
v9 = v13;
if ( a2 <= v8 )
return (unsigned int)v9;
}
if ( v9 <= 0 )
return 1;
}
return (unsigned int)v9;
} | func0:
ENDBR64
MOV R10,RDI
MOV R8D,ESI
LEA EDI,[RSI + -0x1]
TEST EDI,EDI
JLE 0x001011ce
LEA R9,[R10 + 0x4]
JMP 0x001011be
LAB_001011a0:
ADD RAX,0x4
CMP RAX,RSI
JZ 0x001011b9
LAB_001011a9:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x001011a0
MOV dword ptr [RAX],ECX
MOV dword ptr [RAX + 0x4],EDX
JMP 0x001011a0
LAB_001011b9:
SUB EDI,0x1
JZ 0x001011ce
LAB_001011be:
TEST EDI,EDI
JLE 0x001011b9
MOV RAX,R10
LEA EDX,[RDI + -0x1]
LEA RSI,[R9 + RDX*0x4]
JMP 0x001011a9
LAB_001011ce:
MOV ECX,0x0
MOV R9D,0x0
TEST R8D,R8D
JG 0x001011ec
JMP 0x00101225
LAB_001011e0:
CMP R9D,EAX
CMOVL R9D,EAX
CMP R8D,ECX
JLE 0x00101225
LAB_001011ec:
LEA EAX,[RCX + 0x1]
CMP R8D,EAX
JLE 0x00101229
MOVSXD RAX,ECX
LEA RDX,[R10 + RAX*0x4]
MOV ESI,ECX
MOV EDI,R8D
SUB EDI,ECX
MOV EAX,0x1
LAB_00101207:
LEA ECX,[RAX + RSI*0x1]
MOV R11D,dword ptr [RDX + 0x4]
CMP dword ptr [RDX],R11D
JNZ 0x001011e0
ADD EAX,0x1
ADD RDX,0x4
CMP EAX,EDI
JNZ 0x00101207
CMP R9D,EAX
CMOVL R9D,EAX
LAB_00101225:
MOV EAX,R9D
RET
LAB_00101229:
TEST R9D,R9D
MOV EAX,0x1
CMOVLE R9D,EAX
JMP 0x00101225 | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int iVar4;
int iVar5;
iVar4 = param_2 + -1;
if (0 < iVar4) {
do {
if (0 < iVar4) {
piVar3 = param_1;
do {
iVar5 = *piVar3;
if (piVar3[1] < iVar5) {
*piVar3 = piVar3[1];
piVar3[1] = iVar5;
}
piVar3 = piVar3 + 1;
} while (piVar3 != param_1 + (ulong)(iVar4 - 1) + 1);
}
iVar4 = iVar4 + -1;
} while (iVar4 != 0);
}
iVar5 = 0;
iVar4 = 0;
if (0 < param_2) {
do {
if (param_2 <= iVar4 + 1) {
if (0 < iVar5) {
return iVar5;
}
return 1;
}
piVar3 = param_1 + iVar4;
iVar2 = 1;
while (iVar1 = iVar2 + iVar4, *piVar3 == piVar3[1]) {
iVar2 = iVar2 + 1;
piVar3 = piVar3 + 1;
if (iVar2 == param_2 - iVar4) {
if (iVar2 <= iVar5) {
return iVar5;
}
return iVar2;
}
}
if (iVar5 < iVar2) {
iVar5 = iVar2;
}
iVar4 = iVar1;
} while (iVar1 < param_2);
}
return iVar5;
} |
7,706 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int ar[], int n) {
int res = 0;
int i, count;
// Sorting the array
for (int step = 0; step < n - 1; ++step) {
for (int i = 0; i < n - step - 1; ++i) {
if (ar[i] > ar[i + 1]) {
int temp = ar[i];
ar[i] = ar[i + 1];
ar[i + 1] = temp;
}
}
}
// Counting maximum subset elements
i = 0;
while (i < n) {
count = 1;
while (i + 1 < n && ar[i] == ar[i + 1]) {
count++;
i++;
}
if (res < count) {
res = count;
}
i++;
}
return res;
}
| int main() {
int ar1[] = {1, 2, 3, 4};
int ar2[] = {5, 6, 9, 3, 4, 3, 4};
int ar3[] = {1, 2, 3};
assert(func0(ar1, 4) == 1);
assert(func0(ar2, 7) == 2);
assert(func0(ar3, 3) == 1);
printf("All test cases passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
lea -0x1(%rsi),%edx
test %edx,%edx
jle 130f <func0+0x3f>
lea 0x4(%rdi),%r10
sub $0x1,%edx
mov %rdi,%rax
mov %rdx,%r9
lea (%r10,%rdx,4),%r8
nopl (%rax)
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 12fe <func0+0x2e>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
add $0x4,%rax
cmp %rax,%r8
jne 12f0 <func0+0x20>
mov %r9d,%edx
test %r9d,%r9d
jne 12e0 <func0+0x10>
xor %ecx,%ecx
xor %r10d,%r10d
test %esi,%esi
jle 1364 <func0+0x94>
nopl 0x0(%rax,%rax,1)
lea 0x1(%rcx),%eax
cmp %eax,%esi
jle 137b <func0+0xab>
movslq %ecx,%rax
mov %esi,%r9d
mov %ecx,%r8d
lea (%rdi,%rax,4),%rdx
sub %ecx,%r9d
mov $0x1,%eax
jmp 134c <func0+0x7c>
xchg %ax,%ax
add $0x1,%eax
add $0x4,%rdx
cmp %r9d,%eax
je 1370 <func0+0xa0>
mov 0x4(%rdx),%r11d
lea (%rax,%r8,1),%ecx
cmp %r11d,(%rdx)
je 1340 <func0+0x70>
cmp %eax,%r10d
cmovl %eax,%r10d
cmp %ecx,%esi
jg 1320 <func0+0x50>
mov %r10d,%eax
retq
nopl 0x0(%rax,%rax,1)
cmp %eax,%r10d
cmovl %eax,%r10d
mov %r10d,%eax
retq
test %r10d,%r10d
mov $0x1,%eax
cmovle %eax,%r10d
jmp 1364 <func0+0x94>
nopl 0x0(%rax)
| func0:
endbr64
lea edx, [rsi-1]
mov r9, rdi
mov r8d, esi
test edx, edx
jle short loc_1315
lea r10, [rdi+4]
nop dword ptr [rax]
loc_12E8:
sub edx, 1
mov rax, r9
mov rdi, rdx
lea rsi, [r10+rdx*4]
nop dword ptr [rax]
loc_12F8:
mov edx, [rax]
mov ecx, [rax+4]
cmp edx, ecx
jle short loc_1306
mov [rax], ecx
mov [rax+4], edx
loc_1306:
add rax, 4
cmp rax, rsi
jnz short loc_12F8
mov edx, edi
test edi, edi
jnz short loc_12E8
loc_1315:
xor ecx, ecx
xor r10d, r10d
test r8d, r8d
jle short loc_1363
nop
loc_1320:
lea eax, [rcx+1]
cmp r8d, eax
jle short loc_137B
movsxd rax, ecx
mov edi, r8d
mov esi, ecx
lea rdx, [r9+rax*4]
sub edi, ecx
mov eax, 1
jmp short loc_134B
loc_1340:
add eax, 1
add rdx, 4
cmp edi, eax
jz short loc_1370
loc_134B:
mov r11d, [rdx+4]
lea ecx, [rax+rsi]
cmp [rdx], r11d
jz short loc_1340
cmp r10d, eax
cmovl r10d, eax
cmp ecx, r8d
jl short loc_1320
loc_1363:
mov eax, r10d
retn
loc_1370:
cmp r10d, edi
cmovl r10d, edi
mov eax, r10d
retn
loc_137B:
test r10d, r10d
mov eax, 1
cmovle r10d, eax
jmp short loc_1363 | long long func0(int *a1, int a2)
{
int v2; // edx
_DWORD *v5; // r10
int *v6; // rax
int v7; // edi
int *v8; // rsi
int v9; // edx
int v10; // ecx
int v11; // ecx
int v12; // r10d
int v13; // esi
int *v14; // rdx
int v15; // edi
int v16; // eax
v2 = a2 - 1;
if ( a2 - 1 > 0 )
{
v5 = a1 + 1;
do
{
v6 = a1;
v7 = v2 - 1;
v8 = &v5[v2 - 1];
do
{
v9 = *v6;
v10 = v6[1];
if ( *v6 > v10 )
{
*v6 = v10;
v6[1] = v9;
}
++v6;
}
while ( v6 != v8 );
v2 = v7;
}
while ( v7 );
}
v11 = 0;
v12 = 0;
if ( a2 > 0 )
{
while ( 2 )
{
if ( a2 <= v11 + 1 )
{
if ( v12 <= 0 )
return 1;
}
else
{
v13 = v11;
v14 = &a1[v11];
v15 = a2 - v11;
v16 = 1;
while ( 1 )
{
v11 = v16 + v13;
if ( *v14 != v14[1] )
break;
++v16;
++v14;
if ( v15 == v16 )
{
if ( v12 < v15 )
return (unsigned int)v15;
return (unsigned int)v12;
}
}
if ( v12 < v16 )
v12 = v16;
if ( v11 < a2 )
continue;
}
break;
}
}
return (unsigned int)v12;
} | func0:
ENDBR64
LEA EDX,[RSI + -0x1]
MOV R9,RDI
MOV R8D,ESI
TEST EDX,EDX
JLE 0x00101315
LEA R10,[RDI + 0x4]
NOP dword ptr [RAX]
LAB_001012e8:
SUB EDX,0x1
MOV RAX,R9
MOV RDI,RDX
LEA RSI,[R10 + RDX*0x4]
NOP dword ptr [RAX]
LAB_001012f8:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x00101306
MOV dword ptr [RAX],ECX
MOV dword ptr [RAX + 0x4],EDX
LAB_00101306:
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x001012f8
MOV EDX,EDI
TEST EDI,EDI
JNZ 0x001012e8
LAB_00101315:
XOR ECX,ECX
XOR R10D,R10D
TEST R8D,R8D
JLE 0x00101363
NOP
LAB_00101320:
LEA EAX,[RCX + 0x1]
CMP R8D,EAX
JLE 0x0010137b
MOVSXD RAX,ECX
MOV EDI,R8D
MOV ESI,ECX
LEA RDX,[R9 + RAX*0x4]
SUB EDI,ECX
MOV EAX,0x1
JMP 0x0010134b
LAB_00101340:
ADD EAX,0x1
ADD RDX,0x4
CMP EDI,EAX
JZ 0x00101370
LAB_0010134b:
MOV R11D,dword ptr [RDX + 0x4]
LEA ECX,[RAX + RSI*0x1]
CMP dword ptr [RDX],R11D
JZ 0x00101340
CMP R10D,EAX
CMOVL R10D,EAX
CMP ECX,R8D
JL 0x00101320
LAB_00101363:
MOV EAX,R10D
RET
LAB_00101370:
CMP R10D,EDI
CMOVL R10D,EDI
MOV EAX,R10D
RET
LAB_0010137b:
TEST R10D,R10D
MOV EAX,0x1
CMOVLE R10D,EAX
JMP 0x00101363 | int func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
uint uVar5;
int iVar6;
int iVar7;
uVar5 = param_2 - 1;
if (0 < (int)uVar5) {
do {
uVar5 = uVar5 - 1;
piVar2 = param_1;
do {
iVar3 = *piVar2;
if (piVar2[1] < iVar3) {
*piVar2 = piVar2[1];
piVar2[1] = iVar3;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)uVar5 + 1);
} while (uVar5 != 0);
}
iVar7 = 0;
iVar3 = 0;
if (0 < param_2) {
do {
if (param_2 <= iVar3 + 1) {
if (0 < iVar7) {
return iVar7;
}
return 1;
}
piVar2 = param_1 + iVar3;
iVar6 = param_2 - iVar3;
iVar1 = 1;
while (iVar4 = iVar1 + iVar3, *piVar2 == piVar2[1]) {
iVar1 = iVar1 + 1;
piVar2 = piVar2 + 1;
if (iVar6 == iVar1) {
if (iVar7 < iVar6) {
iVar7 = iVar6;
}
return iVar7;
}
}
if (iVar7 < iVar1) {
iVar7 = iVar1;
}
iVar3 = iVar4;
} while (iVar4 < param_2);
}
return iVar7;
} |
7,707 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| int func0(int ar[], int n) {
int res = 0;
int i, count;
// Sorting the array
for (int step = 0; step < n - 1; ++step) {
for (int i = 0; i < n - step - 1; ++i) {
if (ar[i] > ar[i + 1]) {
int temp = ar[i];
ar[i] = ar[i + 1];
ar[i + 1] = temp;
}
}
}
// Counting maximum subset elements
i = 0;
while (i < n) {
count = 1;
while (i + 1 < n && ar[i] == ar[i + 1]) {
count++;
i++;
}
if (res < count) {
res = count;
}
i++;
}
return res;
}
| int main() {
int ar1[] = {1, 2, 3, 4};
int ar2[] = {5, 6, 9, 3, 4, 3, 4};
int ar3[] = {1, 2, 3};
assert(func0(ar1, 4) == 1);
assert(func0(ar2, 7) == 2);
assert(func0(ar3, 3) == 1);
printf("All test cases passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rsi),%edx
test %edx,%edx
jle 12ff <func0+0x3f>
lea 0x4(%rdi),%r10
sub $0x1,%edx
mov %rdi,%rax
mov %rdx,%r9
lea (%r10,%rdx,4),%r8
nopl (%rax)
mov (%rax),%edx
mov 0x4(%rax),%ecx
cmp %ecx,%edx
jle 12ee <func0+0x2e>
mov %ecx,(%rax)
mov %edx,0x4(%rax)
add $0x4,%rax
cmp %rax,%r8
jne 12e0 <func0+0x20>
mov %r9d,%edx
test %r9d,%r9d
jne 12d0 <func0+0x10>
xor %ecx,%ecx
xor %r11d,%r11d
test %esi,%esi
jle 1359 <func0+0x99>
nopl 0x0(%rax,%rax,1)
lea 0x1(%rcx),%eax
cmp %eax,%esi
jle 136b <func0+0xab>
movslq %ecx,%rax
mov %esi,%r10d
mov %ecx,%r8d
lea (%rdi,%rax,4),%rdx
sub %ecx,%r10d
mov $0x1,%eax
mov (%rdx),%r9d
jmp 1344 <func0+0x84>
nopl 0x0(%rax)
add $0x1,%eax
add $0x4,%rdx
cmp %r10d,%eax
je 1360 <func0+0xa0>
lea (%rax,%r8,1),%ecx
cmp %r9d,0x4(%rdx)
je 1338 <func0+0x78>
cmp %eax,%r11d
cmovl %eax,%r11d
cmp %ecx,%esi
jg 1310 <func0+0x50>
mov %r11d,%eax
retq
nopl (%rax)
cmp %eax,%r11d
cmovl %eax,%r11d
mov %r11d,%eax
retq
test %r11d,%r11d
mov $0x1,%eax
cmovle %eax,%r11d
jmp 1359 <func0+0x99>
nopl 0x0(%rax)
| func0:
endbr64
mov r9, rdi
mov r10d, esi
cmp esi, 1
jle loc_1388
mov edi, esi
lea r8, [r9+4]
nop dword ptr [rax+00000000h]
loc_12D0:
cmp edi, 1
jle loc_1370
lea edx, [rdi-2]
mov rax, r9
lea rsi, [r8+rdx*4]
nop dword ptr [rax+rax+00h]
loc_12E8:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd edx, xmm0
movd ecx, xmm1
cmp ecx, edx
jge short loc_1306
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_1306:
add rax, 4
cmp rax, rsi
jnz short loc_12E8
sub edi, 1
cmp edi, 1
jnz short loc_12D0
xor r8d, r8d
xor r11d, r11d
nop dword ptr [rax]
loc_1320:
lea eax, [r8+1]
cmp r10d, eax
jle short loc_1378
movsxd rax, r8d
mov edi, r10d
mov edx, 1
lea rax, [r9+rax*4]
sub edi, r8d
mov ecx, [rax]
jmp short loc_134B
loc_1340:
add edx, 1
add rax, 4
cmp edx, edi
jz short loc_137D
loc_134B:
mov esi, ecx
mov ecx, [rax+4]
cmp ecx, esi
jz short loc_1340
add r8d, edx
cmp r11d, edx
cmovl r11d, edx
cmp r10d, r8d
jg short loc_1320
mov eax, r11d
retn
loc_1370:
sub edi, 1
jmp loc_12D0
loc_1378:
mov edi, 1
loc_137D:
cmp r11d, edi
cmovl r11d, edi
mov eax, r11d
retn
loc_1388:
jz short loc_1391
xor r11d, r11d
mov eax, r11d
retn
loc_1391:
mov edi, 1
xor r11d, r11d
jmp short loc_137D | long long func0(__m128i *a1, int a2)
{
int i; // edi
__m128i *v5; // rax
__m128i v6; // xmm0
int v7; // r8d
int v8; // r11d
int v9; // edx
__int32 *v10; // rax
int v11; // edi
__int32 v12; // ecx
int v13; // esi
if ( a2 <= 1 )
{
if ( a2 != 1 )
return 0LL;
v11 = 1;
v8 = 0;
}
else
{
for ( i = a2; i != 1; --i )
{
while ( i <= 1 )
--i;
v5 = a1;
do
{
v6 = _mm_loadl_epi64(v5);
if ( _mm_cvtsi128_si32(_mm_shuffle_epi32(v6, 229)) < _mm_cvtsi128_si32(v6) )
v5->m128i_i64[0] = _mm_shuffle_epi32(v6, 225).m128i_u64[0];
v5 = (__m128i *)((char *)v5 + 4);
}
while ( v5 != (__m128i *)((char *)a1->m128i_i64 + 4 * (unsigned int)(i - 2) + 4) );
}
v7 = 0;
v8 = 0;
while ( a2 > v7 + 1 )
{
v9 = 1;
v10 = &a1->m128i_i32[v7];
v11 = a2 - v7;
v12 = *v10;
while ( 1 )
{
v13 = v12;
v12 = v10[1];
if ( v12 != v13 )
break;
++v9;
++v10;
if ( v9 == v11 )
goto LABEL_20;
}
v7 += v9;
if ( v8 < v9 )
v8 = v9;
if ( a2 <= v7 )
return (unsigned int)v8;
}
v11 = 1;
}
LABEL_20:
if ( v8 < v11 )
return (unsigned int)v11;
return (unsigned int)v8;
} | func0:
ENDBR64
MOV R9,RDI
MOV R10D,ESI
CMP ESI,0x1
JLE 0x00101388
MOV EDI,ESI
LEA R8,[R9 + 0x4]
NOP dword ptr [RAX]
LAB_001012d0:
CMP EDI,0x1
JLE 0x00101370
LEA EDX,[RDI + -0x2]
MOV RAX,R9
LEA RSI,[R8 + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001012e8:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD EDX,XMM0
MOVD ECX,XMM1
CMP ECX,EDX
JGE 0x00101306
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_00101306:
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x001012e8
SUB EDI,0x1
CMP EDI,0x1
JNZ 0x001012d0
XOR R8D,R8D
XOR R11D,R11D
NOP dword ptr [RAX]
LAB_00101320:
LEA EAX,[R8 + 0x1]
CMP R10D,EAX
JLE 0x00101378
MOVSXD RAX,R8D
MOV EDI,R10D
MOV EDX,0x1
LEA RAX,[R9 + RAX*0x4]
SUB EDI,R8D
MOV ECX,dword ptr [RAX]
JMP 0x0010134b
LAB_00101340:
ADD EDX,0x1
ADD RAX,0x4
CMP EDX,EDI
JZ 0x0010137d
LAB_0010134b:
MOV ESI,ECX
MOV ECX,dword ptr [RAX + 0x4]
CMP ECX,ESI
JZ 0x00101340
ADD R8D,EDX
CMP R11D,EDX
CMOVL R11D,EDX
CMP R10D,R8D
JG 0x00101320
MOV EAX,R11D
RET
LAB_00101370:
SUB EDI,0x1
JMP 0x001012d0
LAB_00101378:
MOV EDI,0x1
LAB_0010137d:
CMP R11D,EDI
CMOVL R11D,EDI
MOV EAX,R11D
RET
LAB_00101388:
JZ 0x00101391
XOR R11D,R11D
MOV EAX,R11D
RET
LAB_00101391:
MOV EDI,0x1
XOR R11D,R11D
JMP 0x0010137d | int func0(int8 *param_1,int param_2)
{
int *piVar1;
int8 *puVar2;
int *piVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
iVar6 = param_2;
if (param_2 < 2) {
if (param_2 != 1) {
return 0;
}
iVar7 = 1;
iVar6 = 0;
}
else {
do {
for (; iVar6 < 2; iVar6 = iVar6 + -1) {
}
puVar2 = param_1;
do {
iVar7 = (int)*puVar2;
iVar8 = (int)((ulong)*puVar2 >> 0x20);
if (iVar8 < iVar7) {
*puVar2 = CONCAT44(iVar7,iVar8);
}
puVar2 = (int8 *)((long)puVar2 + 4);
} while (puVar2 != (int8 *)((long)param_1 + (ulong)(iVar6 - 2) * 4 + 4));
iVar6 = iVar6 + -1;
} while (iVar6 != 1);
iVar8 = 0;
iVar6 = 0;
while (iVar8 + 1 < param_2) {
iVar5 = 1;
piVar3 = (int *)((long)param_1 + (long)iVar8 * 4);
iVar7 = param_2 - iVar8;
iVar4 = *piVar3;
while (piVar1 = piVar3 + 1, *piVar1 == iVar4) {
iVar5 = iVar5 + 1;
piVar3 = piVar3 + 1;
iVar4 = *piVar1;
if (iVar5 == iVar7) goto LAB_0010137d;
}
iVar8 = iVar8 + iVar5;
if (iVar6 < iVar5) {
iVar6 = iVar5;
}
if (param_2 <= iVar8) {
return iVar6;
}
}
iVar7 = 1;
}
LAB_0010137d:
if (iVar6 < iVar7) {
iVar6 = iVar7;
}
return iVar6;
} |
7,708 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int actual_cost, int sale_amount) {
if (actual_cost > sale_amount) {
return actual_cost - sale_amount;
} else {
return -1; // using -1 to represent None because C does not have a None value
}
}
| int main() {
assert(func0(1500, 1200) == 300);
assert(func0(100, 200) == -1);
assert(func0(2000, 5000) == -1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jle 1167 <func0+0x1e>
mov -0x4(%rbp),%eax
sub -0x8(%rbp),%eax
jmp 116c <func0+0x23>
mov $0xffffffff,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jle short loc_1167
mov eax, [rbp+var_4]
sub eax, [rbp+var_8]
jmp short loc_116C
loc_1167:
mov eax, 0FFFFFFFFh
loc_116C:
pop rbp
retn | long long func0(int a1, int a2)
{
if ( a1 <= a2 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(a1 - a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JLE 0x00101167
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,dword ptr [RBP + -0x8]
JMP 0x0010116c
LAB_00101167:
MOV EAX,0xffffffff
LAB_0010116c:
POP RBP
RET | int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
param_1 = param_1 - param_2;
}
else {
param_1 = -1;
}
return param_1;
} |
7,709 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int actual_cost, int sale_amount) {
if (actual_cost > sale_amount) {
return actual_cost - sale_amount;
} else {
return -1; // using -1 to represent None because C does not have a None value
}
}
| int main() {
assert(func0(1500, 1200) == 300);
assert(func0(100, 200) == -1);
assert(func0(2000, 5000) == -1);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
jle 1136 <func0+0xd>
mov %edi,%eax
sub %esi,%eax
retq
mov $0xffffffff,%eax
retq
| func0:
endbr64
cmp edi, esi
jle short loc_1136
mov eax, edi
sub eax, esi
retn
loc_1136:
mov eax, 0FFFFFFFFh
retn | long long func0(int a1, int a2)
{
if ( a1 <= a2 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(a1 - a2);
} | func0:
ENDBR64
CMP EDI,ESI
JLE 0x00101136
MOV EAX,EDI
SUB EAX,ESI
RET
LAB_00101136:
MOV EAX,0xffffffff
RET | int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
return param_1 - param_2;
}
return -1;
} |
7,710 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int actual_cost, int sale_amount) {
if (actual_cost > sale_amount) {
return actual_cost - sale_amount;
} else {
return -1; // using -1 to represent None because C does not have a None value
}
}
| int main() {
assert(func0(1500, 1200) == 300);
assert(func0(100, 200) == -1);
assert(func0(2000, 5000) == -1);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
jle 1150 <func0+0x10>
mov %edi,%eax
sub %esi,%eax
retq
nopl (%rax)
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, esi
jle short loc_1150
mov eax, edi
sub eax, esi
retn
loc_1150:
mov eax, 0FFFFFFFFh
retn | long long func0(int a1, int a2)
{
if ( a1 <= a2 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(a1 - a2);
} | func0:
ENDBR64
CMP EDI,ESI
JLE 0x00101150
MOV EAX,EDI
SUB EAX,ESI
RET
LAB_00101150:
MOV EAX,0xffffffff
RET | int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
return param_1 - param_2;
}
return -1;
} |
7,711 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int actual_cost, int sale_amount) {
if (actual_cost > sale_amount) {
return actual_cost - sale_amount;
} else {
return -1; // using -1 to represent None because C does not have a None value
}
}
| int main() {
assert(func0(1500, 1200) == 300);
assert(func0(100, 200) == -1);
assert(func0(2000, 5000) == -1);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
jle 1150 <func0+0x10>
mov %edi,%eax
sub %esi,%eax
retq
nopl (%rax)
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, esi
jle short loc_1150
mov eax, edi
sub eax, esi
retn
loc_1150:
mov eax, 0FFFFFFFFh
retn | long long func0(int a1, int a2)
{
if ( a1 <= a2 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(a1 - a2);
} | func0:
ENDBR64
CMP EDI,ESI
JLE 0x00101150
MOV EAX,EDI
SUB EAX,ESI
RET
LAB_00101150:
MOV EAX,0xffffffff
RET | int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
return param_1 - param_2;
}
return -1;
} |
7,712 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int fctrsum = 0;
for (int fctr = 1; fctr < n; fctr++) {
if (n % fctr == 0) {
fctrsum += fctr;
}
}
return fctrsum > n;
}
| int main() {
assert(func0(12) == 1);
assert(func0(13) == 0);
assert(func0(9) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 117b <func0+0x32>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1177 <func0+0x2e>
mov -0x4(%rbp),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 1164 <func0+0x1b>
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
setg %al
movzbl %al,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_117B
loc_1164:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1177
mov eax, [rbp+var_4]
add [rbp+var_8], eax
loc_1177:
add [rbp+var_4], 1
loc_117B:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_14]
jl short loc_1164
mov eax, [rbp+var_8]
cmp eax, [rbp+var_14]
setnle al
movzx eax, al
pop rbp
retn | _BOOL8 func0(int a1)
{
int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 1; i < a1; ++i )
{
if ( !(a1 % i) )
v2 += i;
}
return v2 > a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010117b
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101177
MOV EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x8],EAX
LAB_00101177:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010117b:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x00101164
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x14]
SETG AL
MOVZX EAX,AL
POP RBP
RET | bool func0(int param_1)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 1; local_c < param_1; local_c = local_c + 1) {
if (param_1 % local_c == 0) {
local_10 = local_10 + local_c;
}
}
return param_1 < local_10;
} |
7,713 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int fctrsum = 0;
for (int fctr = 1; fctr < n; fctr++) {
if (n % fctr == 0) {
fctrsum += fctr;
}
}
return fctrsum > n;
}
| int main() {
assert(func0(12) == 1);
assert(func0(13) == 0);
assert(func0(9) == 0);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%edi
jle 1179 <func0+0x30>
mov $0x1,%ecx
mov $0x0,%esi
mov %edi,%eax
cltd
idiv %ecx
lea (%rsi,%rcx,1),%eax
test %edx,%edx
cmove %eax,%esi
add $0x1,%ecx
cmp %ecx,%edi
jne 115c <func0+0x13>
cmp %esi,%edi
setl %al
movzbl %al,%eax
retq
mov $0x0,%esi
jmp 1170 <func0+0x27>
| func0:
endbr64
cmp edi, 1
jle short loc_1179
mov ecx, 1
mov esi, 0
loc_115C:
mov eax, edi
cdq
idiv ecx
lea eax, [rsi+rcx]
test edx, edx
cmovz esi, eax
add ecx, 1
cmp edi, ecx
jnz short loc_115C
loc_1170:
cmp edi, esi
setl al
movzx eax, al
retn
loc_1179:
mov esi, 0
jmp short loc_1170 | _BOOL8 func0(int a1)
{
int v1; // ecx
int v2; // esi
if ( a1 <= 1 )
{
v2 = 0;
}
else
{
v1 = 1;
v2 = 0;
do
{
if ( !(a1 % v1) )
v2 += v1;
++v1;
}
while ( a1 != v1 );
}
return a1 < v2;
} | func0:
ENDBR64
CMP EDI,0x1
JLE 0x00101179
MOV ECX,0x1
MOV ESI,0x0
LAB_0010115c:
MOV EAX,EDI
CDQ
IDIV ECX
LEA EAX,[RSI + RCX*0x1]
TEST EDX,EDX
CMOVZ ESI,EAX
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x0010115c
LAB_00101170:
CMP EDI,ESI
SETL AL
MOVZX EAX,AL
RET
LAB_00101179:
MOV ESI,0x0
JMP 0x00101170 | bool func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 2) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
if (param_1 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
}
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
}
return param_1 < iVar2;
} |
7,714 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int fctrsum = 0;
for (int fctr = 1; fctr < n; fctr++) {
if (n % fctr == 0) {
fctrsum += fctr;
}
}
return fctrsum > n;
}
| int main() {
assert(func0(12) == 1);
assert(func0(13) == 0);
assert(func0(9) == 0);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%edi
jle 1270 <func0+0x30>
mov $0x1,%ecx
xor %esi,%esi
mov %edi,%eax
cltd
idiv %ecx
lea (%rsi,%rcx,1),%eax
test %edx,%edx
cmove %eax,%esi
add $0x1,%ecx
cmp %ecx,%edi
jne 1250 <func0+0x10>
xor %eax,%eax
cmp %esi,%edi
setl %al
retq
nopl 0x0(%rax)
xor %esi,%esi
xor %eax,%eax
cmp %esi,%edi
setl %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, 1
jle short loc_1270
mov ecx, 1
xor esi, esi
loc_1250:
mov eax, edi
cdq
idiv ecx
lea eax, [rsi+rcx]
test edx, edx
cmovz esi, eax
add ecx, 1
cmp edi, ecx
jnz short loc_1250
xor eax, eax
cmp edi, esi
setl al
retn
loc_1270:
xor esi, esi
xor eax, eax
cmp edi, esi
setl al
retn | _BOOL8 func0(int a1)
{
int v1; // ecx
int v2; // esi
if ( a1 <= 1 )
return a1 < 0;
v1 = 1;
v2 = 0;
do
{
if ( !(a1 % v1) )
v2 += v1;
++v1;
}
while ( a1 != v1 );
return a1 < v2;
} | func0:
ENDBR64
CMP EDI,0x1
JLE 0x00101270
MOV ECX,0x1
XOR ESI,ESI
LAB_00101250:
MOV EAX,EDI
CDQ
IDIV ECX
LEA EAX,[RSI + RCX*0x1]
TEST EDX,EDX
CMOVZ ESI,EAX
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x00101250
XOR EAX,EAX
CMP EDI,ESI
SETL AL
RET
LAB_00101270:
XOR ESI,ESI
XOR EAX,EAX
CMP EDI,ESI
SETL AL
RET | bool func0(int param_1)
{
int iVar1;
int iVar2;
if (1 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
if (param_1 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
}
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
return param_1 < iVar2;
}
return param_1 < 0;
} |
7,715 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int n) {
int fctrsum = 0;
for (int fctr = 1; fctr < n; fctr++) {
if (n % fctr == 0) {
fctrsum += fctr;
}
}
return fctrsum > n;
}
| int main() {
assert(func0(12) == 1);
assert(func0(13) == 0);
assert(func0(9) == 0);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%edi
jle 1170 <func0+0x30>
mov $0x1,%ecx
xor %esi,%esi
mov %edi,%eax
cltd
idiv %ecx
lea (%rsi,%rcx,1),%eax
test %edx,%edx
cmove %eax,%esi
add $0x1,%ecx
cmp %ecx,%edi
jne 1150 <func0+0x10>
xor %eax,%eax
cmp %esi,%edi
setl %al
retq
nopl 0x0(%rax)
xor %esi,%esi
xor %eax,%eax
cmp %esi,%edi
setl %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
cmp edi, 1
jle short loc_1170
mov ecx, 1
xor esi, esi
loc_1150:
mov eax, edi
cdq
idiv ecx
lea eax, [rsi+rcx]
test edx, edx
cmovz esi, eax
add ecx, 1
cmp edi, ecx
jnz short loc_1150
xor eax, eax
cmp edi, esi
setl al
retn
loc_1170:
xor esi, esi
xor eax, eax
cmp edi, esi
setl al
retn | _BOOL8 func0(int a1)
{
int v1; // ecx
int v2; // esi
if ( a1 <= 1 )
return a1 < 0;
v1 = 1;
v2 = 0;
do
{
if ( !(a1 % v1) )
v2 += v1;
++v1;
}
while ( a1 != v1 );
return a1 < v2;
} | func0:
ENDBR64
CMP EDI,0x1
JLE 0x00101170
MOV ECX,0x1
XOR ESI,ESI
LAB_00101150:
MOV EAX,EDI
CDQ
IDIV ECX
LEA EAX,[RSI + RCX*0x1]
TEST EDX,EDX
CMOVZ ESI,EAX
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x00101150
XOR EAX,EAX
CMP EDI,ESI
SETL AL
RET
LAB_00101170:
XOR ESI,ESI
XOR EAX,EAX
CMP EDI,ESI
SETL AL
RET | bool func0(int param_1)
{
int iVar1;
int iVar2;
if (1 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
if (param_1 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
}
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
return param_1 < iVar2;
}
return param_1 < 0;
} |
7,716 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char** func0(const char* text, int* count) {
int n = strlen(text);
char** result = malloc(n * sizeof(char*));
*count = 0;
int word_start = 0;
for (int i = 1; i <= n; i++) {
if (i == n || (isupper(text[i]) && !isupper(text[i-1]))) {
int word_length = i - word_start;
result[*count] = malloc((word_length + 1) * sizeof(char));
strncpy(result[*count], text + word_start, word_length);
result[*count][word_length] = '\0';
(*count)++;
word_start = i;
}
}
return result;
}
| int main() {
int count1, count2, count3;
char** result1 = func0("LearnToBuildAnythingWithGoogle", &count1);
char** result2 = func0("ApmlifyingTheBlack+DeveloperCommunity", &count2);
char** result3 = func0("UpdateInTheGoEcoSystem", &count3);
assert(count1 == 6);
assert(strcmp(result1[0], "Learn") == 0);
assert(strcmp(result1[1], "To") == 0);
assert(strcmp(result1[2], "Build") == 0);
assert(strcmp(result1[3], "Anything") == 0);
assert(strcmp(result1[4], "With") == 0);
assert(strcmp(result1[5], "Google") == 0);
assert(count2 == 5);
assert(strcmp(result2[0], "Apmlifying") == 0);
assert(strcmp(result2[1], "The") == 0);
assert(strcmp(result2[2], "Black+") == 0);
assert(strcmp(result2[3], "Developer") == 0);
assert(strcmp(result2[4], "Community") == 0);
assert(count3 == 6);
assert(strcmp(result3[0], "Update") == 0);
assert(strcmp(result3[1], "In") == 0);
assert(strcmp(result3[2], "The") == 0);
assert(strcmp(result3[3], "Go") == 0);
assert(strcmp(result3[4], "Eco") == 0);
assert(strcmp(result3[5], "System") == 0);
for (int i = 0; i < count1; i++) free(result1[i]);
free(result1);
for (int i = 0; i < count2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < count3; i++) free(result3[i]);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 10e0 <strlen@plt>
mov %eax,-0x20(%rbp)
mov -0x20(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1120 <malloc@plt>
mov %rax,-0x18(%rbp)
mov -0x40(%rbp),%rax
movl $0x0,(%rax)
movl $0x0,-0x28(%rbp)
movl $0x1,-0x24(%rbp)
jmpq 13a0 <func0+0x177>
mov -0x24(%rbp),%eax
cmp -0x20(%rbp),%eax
je 12f5 <func0+0xcc>
callq 1130 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x24(%rbp),%edx
movslq %edx,%rcx
mov -0x38(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 139c <func0+0x173>
callq 1130 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
lea -0x1(%rdx),%rcx
mov -0x38(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
jne 139c <func0+0x173>
mov -0x24(%rbp),%eax
sub -0x28(%rbp),%eax
mov %eax,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
add $0x1,%eax
cltq
mov -0x40(%rbp),%rdx
mov (%rdx),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x18(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 1120 <malloc@plt>
mov %rax,(%rbx)
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%eax
movslq %eax,%rcx
mov -0x38(%rbp),%rax
add %rax,%rcx
mov -0x40(%rbp),%rax
mov (%rax),%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 <strncpy@plt>
mov -0x40(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x1c(%rbp),%eax
cltq
add %rdx,%rax
movb $0x0,(%rax)
mov -0x40(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x40(%rbp),%rax
mov %edx,(%rax)
mov -0x24(%rbp),%eax
mov %eax,-0x28(%rbp)
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x20(%rbp),%eax
jle 127f <func0+0x56>
mov -0x18(%rbp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+s], rdi
mov [rbp+var_40], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov rax, [rbp+var_40]
mov dword ptr [rax], 0
mov [rbp+var_28], 0
mov [rbp+var_24], 1
jmp loc_13A0
loc_127F:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_20]
jz short loc_12F5
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_24]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz loc_139C
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_24]
movsxd rdx, edx
lea rcx, [rdx-1]
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jnz loc_139C
loc_12F5:
mov eax, [rbp+var_24]
sub eax, [rbp+var_28]
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
add eax, 1
cdqe
mov rdx, [rbp+var_40]
mov edx, [rdx]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+var_18]
lea rbx, [rcx+rdx]
mov rdi, rax; size
call _malloc
mov [rbx], rax
mov eax, [rbp+var_1C]
movsxd rdx, eax; n
mov eax, [rbp+var_28]
movsxd rcx, eax
mov rax, [rbp+s]
add rcx, rax
mov rax, [rbp+var_40]
mov eax, [rax]
cdqe
lea rsi, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rsi
mov rax, [rax]
mov rsi, rcx; src
mov rdi, rax; dest
call _strncpy
mov rax, [rbp+var_40]
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_1C]
cdqe
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+var_40]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_40]
mov [rax], edx
mov eax, [rbp+var_24]
mov [rbp+var_28], eax
loc_139C:
add [rbp+var_24], 1
loc_13A0:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_20]
jle loc_127F
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | char ** func0(const char *a1, int *a2)
{
void **v2; // rbx
int v4; // [rsp+18h] [rbp-28h]
int i; // [rsp+1Ch] [rbp-24h]
int v6; // [rsp+20h] [rbp-20h]
char **v7; // [rsp+28h] [rbp-18h]
v6 = strlen(a1);
v7 = (char **)malloc(8LL * v6);
*a2 = 0;
v4 = 0;
for ( i = 1; i <= v6; ++i )
{
if ( i == v6 || ((*__ctype_b_loc())[a1[i]] & 0x100) != 0 && ((*__ctype_b_loc())[a1[i - 1]] & 0x100) == 0 )
{
v2 = (void **)&v7[*a2];
*v2 = malloc(i - v4 + 1);
strncpy(v7[*a2], &a1[v4], i - v4);
v7[(*a2)++][i - v4] = 0;
v4 = i;
}
}
return v7;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010e0
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x24],0x1
JMP 0x001013a0
LAB_0010127f:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x20]
JZ 0x001012f5
CALL 0x00101130
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x0010139c
CALL 0x00101130
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
LEA RCX,[RDX + -0x1]
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JNZ 0x0010139c
LAB_001012f5:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
CDQE
MOV RDX,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RDX]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x18]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x00101120
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RBP + -0x28]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX]
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
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x28],EAX
LAB_0010139c:
ADD dword ptr [RBP + -0x24],0x1
LAB_001013a0:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x20]
JLE 0x0010127f
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(char *param_1,int *param_2)
{
int iVar1;
int iVar2;
int iVar3;
size_t sVar4;
void *pvVar5;
ushort **ppuVar6;
void *pvVar7;
int local_30;
int local_2c;
sVar4 = strlen(param_1);
iVar2 = (int)sVar4;
pvVar5 = malloc((long)iVar2 << 3);
*param_2 = 0;
local_30 = 0;
local_2c = 1;
do {
if (iVar2 < local_2c) {
return pvVar5;
}
if (local_2c == iVar2) {
LAB_001012f5:
iVar3 = local_2c - local_30;
iVar1 = *param_2;
pvVar7 = malloc((long)(iVar3 + 1));
*(void **)((long)iVar1 * 8 + (long)pvVar5) = pvVar7;
strncpy(*(char **)((long)pvVar5 + (long)*param_2 * 8),param_1 + local_30,(long)iVar3);
*(int *)((long)iVar3 + *(long *)((long)pvVar5 + (long)*param_2 * 8)) = 0;
*param_2 = *param_2 + 1;
local_30 = local_2c;
}
else {
ppuVar6 = __ctype_b_loc();
if (((*ppuVar6)[param_1[local_2c]] & 0x100) != 0) {
ppuVar6 = __ctype_b_loc();
if (((*ppuVar6)[param_1[(long)local_2c + -1]] & 0x100) == 0) goto LAB_001012f5;
}
}
local_2c = local_2c + 1;
} while( true );
} |
7,717 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char** func0(const char* text, int* count) {
int n = strlen(text);
char** result = malloc(n * sizeof(char*));
*count = 0;
int word_start = 0;
for (int i = 1; i <= n; i++) {
if (i == n || (isupper(text[i]) && !isupper(text[i-1]))) {
int word_length = i - word_start;
result[*count] = malloc((word_length + 1) * sizeof(char));
strncpy(result[*count], text + word_start, word_length);
result[*count][word_length] = '\0';
(*count)++;
word_start = i;
}
}
return result;
}
| int main() {
int count1, count2, count3;
char** result1 = func0("LearnToBuildAnythingWithGoogle", &count1);
char** result2 = func0("ApmlifyingTheBlack+DeveloperCommunity", &count2);
char** result3 = func0("UpdateInTheGoEcoSystem", &count3);
assert(count1 == 6);
assert(strcmp(result1[0], "Learn") == 0);
assert(strcmp(result1[1], "To") == 0);
assert(strcmp(result1[2], "Build") == 0);
assert(strcmp(result1[3], "Anything") == 0);
assert(strcmp(result1[4], "With") == 0);
assert(strcmp(result1[5], "Google") == 0);
assert(count2 == 5);
assert(strcmp(result2[0], "Apmlifying") == 0);
assert(strcmp(result2[1], "The") == 0);
assert(strcmp(result2[2], "Black+") == 0);
assert(strcmp(result2[3], "Developer") == 0);
assert(strcmp(result2[4], "Community") == 0);
assert(count3 == 6);
assert(strcmp(result3[0], "Update") == 0);
assert(strcmp(result3[1], "In") == 0);
assert(strcmp(result3[2], "The") == 0);
assert(strcmp(result3[3], "Go") == 0);
assert(strcmp(result3[4], "Eco") == 0);
assert(strcmp(result3[5], "System") == 0);
for (int i = 0; i < count1; i++) free(result1[i]);
free(result1);
for (int i = 0; i < count2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < count3; i++) free(result3[i]);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r12
mov %rsi,%rbp
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbx
mov %ebx,0x14(%rsp)
movslq %ebx,%rdi
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r14
movl $0x0,0x0(%rbp)
test %ebx,%ebx
jle 12e9 <func0+0x100>
lea -0x1(%rbx),%r15d
add $0x2,%r15
mov $0x1,%ebx
movl $0x0,0x10(%rsp)
jmp 12b9 <func0+0xd0>
mov 0xc(%rsp),%r13d
sub 0x10(%rsp),%r13d
movslq 0x0(%rbp),%rax
lea (%r14,%rax,8),%rcx
mov %rcx,0x18(%rsp)
lea 0x1(%r13),%edi
movslq %edi,%rdi
callq 10e0 <malloc@plt>
mov 0x18(%rsp),%rcx
mov %rax,(%rcx)
movslq %r13d,%r13
movslq 0x10(%rsp),%rsi
add %r12,%rsi
movslq 0x0(%rbp),%rax
mov (%r14,%rax,8),%rdi
mov %r13,%rdx
callq 10b0 <strncpy@plt>
movslq 0x0(%rbp),%rax
mov (%r14,%rax,8),%rax
movb $0x0,(%rax,%r13,1)
addl $0x1,0x0(%rbp)
mov 0xc(%rsp),%r13d
mov %r13d,0x10(%rsp)
add $0x1,%rbx
cmp %r15,%rbx
je 12e9 <func0+0x100>
mov %ebx,0xc(%rsp)
cmp %ebx,0x14(%rsp)
je 124f <func0+0x66>
callq 10f0 <__ctype_b_loc@plt>
mov (%rax),%rax
movsbq (%r12,%rbx,1),%rdx
testb $0x1,0x1(%rax,%rdx,2)
je 12b0 <func0+0xc7>
movsbq -0x1(%r12,%rbx,1),%rdx
testb $0x1,0x1(%rax,%rdx,2)
jne 12b0 <func0+0xc7>
jmpq 124f <func0+0x66>
mov %r14,%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rbp, rdi
mov r13, rsi
call _strlen
mov rbx, rax
mov [rsp+58h+var_40], eax
movsxd rdi, eax
shl rdi, 3
call _malloc
mov [rsp+58h+var_48], rax
mov dword ptr [r13+0], 0
test ebx, ebx
jle loc_1329
lea r14d, [rbx-1]
add r14, 2
mov ebx, 1
mov [rsp+58h+var_4C], 0
jmp short loc_12F8
loc_1285:
mov r12d, [rsp+58h+var_50]
sub r12d, [rsp+58h+var_4C]
movsxd rax, dword ptr [r13+0]
mov rcx, [rsp+58h+var_48]
lea r15, [rcx+rax*8]
lea edi, [r12+1]
movsxd rdi, edi
call _malloc
mov [r15], rax
movsxd r12, r12d
mov eax, [r13+0]
mov [rsp+58h+var_3C], eax
cdqe
mov rcx, [rsp+58h+var_48]
mov r15, [rcx+rax*8]
movsxd rsi, [rsp+58h+var_4C]
add rsi, rbp
mov rdx, r12
mov rdi, r15
call _strncpy
mov byte ptr [r15+r12], 0
mov eax, [rsp+58h+var_3C]
add eax, 1
mov [r13+0], eax
mov r12d, [rsp+58h+var_50]
mov [rsp+58h+var_4C], r12d
loc_12EF:
add rbx, 1
cmp rbx, r14
jz short loc_1329
loc_12F8:
mov [rsp+58h+var_50], ebx
cmp [rsp+58h+var_40], ebx
jz short loc_1285
call ___ctype_b_loc
mov rax, [rax]
movsx rdx, byte ptr [rbp+rbx+0]
test byte ptr [rax+rdx*2+1], 1
jz short loc_12EF
movsx rdx, byte ptr [rbp+rbx-1]
test byte ptr [rax+rdx*2+1], 1
jnz short loc_12EF
jmp loc_1285
loc_1329:
mov rax, [rsp+58h+var_48]
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, int *a2)
{
int v2; // ebx
long long v3; // r14
long long v4; // rbx
_QWORD *v5; // r15
long long v6; // r15
long long v7; // rax
int v9; // [rsp+Ch] [rbp-4Ch]
long long v10; // [rsp+10h] [rbp-48h]
int v11; // [rsp+18h] [rbp-40h]
int v12; // [rsp+1Ch] [rbp-3Ch]
v2 = strlen();
v11 = v2;
v10 = malloc(8LL * v2);
*a2 = 0;
if ( v2 > 0 )
{
v3 = (unsigned int)(v2 - 1) + 2LL;
v4 = 1LL;
v9 = 0;
do
{
if ( v11 == (_DWORD)v4
|| (v7 = *(_QWORD *)__ctype_b_loc(), (*(_BYTE *)(v7 + 2LL * *(char *)(a1 + v4) + 1) & 1) != 0)
&& (*(_BYTE *)(v7 + 2LL * *(char *)(a1 + v4 - 1) + 1) & 1) == 0 )
{
v5 = (_QWORD *)(v10 + 8LL * *a2);
*v5 = malloc((int)v4 - v9 + 1);
v12 = *a2;
v6 = *(_QWORD *)(v10 + 8LL * *a2);
strncpy(v6, a1 + v9, (int)v4 - v9);
*(_BYTE *)(v6 + (int)v4 - v9) = 0;
*a2 = v12 + 1;
v9 = v4;
}
++v4;
}
while ( v4 != v3 );
}
return v10;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBP,RDI
MOV R13,RSI
CALL 0x001010e0
MOV RBX,RAX
MOV dword ptr [RSP + 0x18],EAX
MOVSXD RDI,EAX
SHL RDI,0x3
CALL 0x00101120
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [R13],0x0
TEST EBX,EBX
JLE 0x00101329
LEA R14D,[RBX + -0x1]
ADD R14,0x2
MOV EBX,0x1
MOV dword ptr [RSP + 0xc],0x0
JMP 0x001012f8
LAB_00101285:
MOV R12D,dword ptr [RSP + 0x8]
SUB R12D,dword ptr [RSP + 0xc]
MOVSXD RAX,dword ptr [R13]
MOV RCX,qword ptr [RSP + 0x10]
LEA R15,[RCX + RAX*0x8]
LEA EDI,[R12 + 0x1]
MOVSXD RDI,EDI
CALL 0x00101120
MOV qword ptr [R15],RAX
MOVSXD R12,R12D
MOV EAX,dword ptr [R13]
MOV dword ptr [RSP + 0x1c],EAX
CDQE
MOV RCX,qword ptr [RSP + 0x10]
MOV R15,qword ptr [RCX + RAX*0x8]
MOVSXD RSI,dword ptr [RSP + 0xc]
ADD RSI,RBP
MOV RDX,R12
MOV RDI,R15
CALL 0x001010d0
MOV byte ptr [R15 + R12*0x1],0x0
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [R13],EAX
MOV R12D,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0xc],R12D
LAB_001012ef:
ADD RBX,0x1
CMP RBX,R14
JZ 0x00101329
LAB_001012f8:
MOV dword ptr [RSP + 0x8],EBX
CMP dword ptr [RSP + 0x18],EBX
JZ 0x00101285
CALL 0x00101130
MOV RAX,qword ptr [RAX]
MOVSX RDX,byte ptr [RBP + RBX*0x1]
TEST byte ptr [RAX + RDX*0x2 + 0x1],0x1
JZ 0x001012ef
MOVSX RDX,byte ptr [RBP + RBX*0x1 + -0x1]
TEST byte ptr [RAX + RDX*0x2 + 0x1],0x1
JNZ 0x001012ef
JMP 0x00101285
LAB_00101329:
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(char *param_1,int *param_2)
{
int iVar1;
char *__dest;
int iVar2;
size_t sVar3;
void *pvVar4;
void *pvVar5;
ushort **ppuVar6;
int iVar7;
long lVar8;
int iVar9;
int local_4c;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
pvVar4 = malloc((long)iVar2 << 3);
*param_2 = 0;
if (0 < iVar2) {
lVar8 = 1;
local_4c = 0;
do {
iVar7 = (int)lVar8;
if (iVar2 == iVar7) {
LAB_00101285:
iVar9 = iVar7 - local_4c;
iVar1 = *param_2;
pvVar5 = malloc((long)(iVar9 + 1));
*(void **)((long)pvVar4 + (long)iVar1 * 8) = pvVar5;
iVar1 = *param_2;
__dest = *(char **)((long)pvVar4 + (long)iVar1 * 8);
strncpy(__dest,param_1 + local_4c,(long)iVar9);
__dest[iVar9] = '\0';
*param_2 = iVar1 + 1;
local_4c = iVar7;
}
else {
ppuVar6 = __ctype_b_loc();
if (((*(byte *)((long)*ppuVar6 + (long)param_1[lVar8] * 2 + 1) & 1) != 0) &&
((*(byte *)((long)*ppuVar6 + (long)param_1[lVar8 + -1] * 2 + 1) & 1) == 0))
goto LAB_00101285;
}
lVar8 = lVar8 + 1;
} while (lVar8 != (ulong)(iVar2 - 1) + 2);
}
return pvVar4;
} |
7,718 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char** func0(const char* text, int* count) {
int n = strlen(text);
char** result = malloc(n * sizeof(char*));
*count = 0;
int word_start = 0;
for (int i = 1; i <= n; i++) {
if (i == n || (isupper(text[i]) && !isupper(text[i-1]))) {
int word_length = i - word_start;
result[*count] = malloc((word_length + 1) * sizeof(char));
strncpy(result[*count], text + word_start, word_length);
result[*count][word_length] = '\0';
(*count)++;
word_start = i;
}
}
return result;
}
| int main() {
int count1, count2, count3;
char** result1 = func0("LearnToBuildAnythingWithGoogle", &count1);
char** result2 = func0("ApmlifyingTheBlack+DeveloperCommunity", &count2);
char** result3 = func0("UpdateInTheGoEcoSystem", &count3);
assert(count1 == 6);
assert(strcmp(result1[0], "Learn") == 0);
assert(strcmp(result1[1], "To") == 0);
assert(strcmp(result1[2], "Build") == 0);
assert(strcmp(result1[3], "Anything") == 0);
assert(strcmp(result1[4], "With") == 0);
assert(strcmp(result1[5], "Google") == 0);
assert(count2 == 5);
assert(strcmp(result2[0], "Apmlifying") == 0);
assert(strcmp(result2[1], "The") == 0);
assert(strcmp(result2[2], "Black+") == 0);
assert(strcmp(result2[3], "Developer") == 0);
assert(strcmp(result2[4], "Community") == 0);
assert(count3 == 6);
assert(strcmp(result3[0], "Update") == 0);
assert(strcmp(result3[1], "In") == 0);
assert(strcmp(result3[2], "The") == 0);
assert(strcmp(result3[3], "Go") == 0);
assert(strcmp(result3[4], "Eco") == 0);
assert(strcmp(result3[5], "System") == 0);
for (int i = 0; i < count1; i++) free(result1[i]);
free(result1);
for (int i = 0; i < count2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < count3; i++) free(result3[i]);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x28,%rsp
callq 10d0 <strlen@plt>
movslq %eax,%rdi
mov %eax,0x4(%rsp)
mov %rax,%rbx
shl $0x3,%rdi
callq 1100 <malloc@plt>
movl $0x0,0x0(%rbp)
mov %rax,%r14
test %ebx,%ebx
jle 18a8 <func0+0xf8>
lea -0x1(%rbx),%eax
mov $0x1,%r15d
xor %ebx,%ebx
add $0x2,%rax
mov %rax,0x8(%rsp)
nopw %cs:0x0(%rax,%rax,1)
mov %r15d,%r13d
cmp %r15d,0x4(%rsp)
je 183b <func0+0x8b>
callq 1110 <__ctype_b_loc@plt>
movsbq (%r12,%r15,1),%rdx
mov (%rax),%rax
testb $0x1,0x1(%rax,%rdx,2)
je 1899 <func0+0xe9>
movsbq -0x1(%r12,%r15,1),%rdx
testb $0x1,0x1(%rax,%rdx,2)
jne 1899 <func0+0xe9>
mov %r13d,%edx
movslq 0x0(%rbp),%rax
sub %ebx,%edx
lea 0x1(%rdx),%edi
lea (%r14,%rax,8),%rsi
mov %edx,0x10(%rsp)
movslq %edi,%rdi
mov %rsi,0x18(%rsp)
callq 1100 <malloc@plt>
mov 0x18(%rsp),%rsi
movslq 0x10(%rsp),%rdx
mov %rax,(%rsi)
movslq 0x0(%rbp),%rax
movslq %ebx,%rsi
mov %r13d,%ebx
add %r12,%rsi
mov %rdx,0x10(%rsp)
mov (%r14,%rax,8),%rdi
callq 10c0 <strncpy@plt>
movslq 0x0(%rbp),%rax
mov 0x10(%rsp),%rdx
mov (%r14,%rax,8),%rax
movb $0x0,(%rax,%rdx,1)
addl $0x1,0x0(%rbp)
add $0x1,%r15
cmp 0x8(%rsp),%r15
jne 1810 <func0+0x60>
add $0x28,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
call _strlen
movsxd rdi, eax
mov [rsp+58h+var_54], eax
mov rbx, rax
shl rdi, 3
call _malloc
mov dword ptr [r13+0], 0
mov r14, rax
test ebx, ebx
jle loc_184E
lea eax, [rbx-1]
mov r15d, 1
xor ebx, ebx
add rax, 2
mov [rsp+58h+var_50], rax
nop word ptr [rax+rax+00000000h]
loc_17B0:
mov r12d, r15d
cmp [rsp+58h+var_54], r15d
jz short loc_17DC
call ___ctype_b_loc
movsx rdx, byte ptr [rbp+r15+0]
mov rax, [rax]
test byte ptr [rax+rdx*2+1], 1
jz short loc_183F
movsx rdx, byte ptr [rbp+r15-1]
test byte ptr [rax+rdx*2+1], 1
jnz short loc_183F
loc_17DC:
mov edx, r12d
movsxd rax, dword ptr [r13+0]
sub edx, ebx
lea edi, [rdx+1]
lea rsi, [r14+rax*8]
mov dword ptr [rsp+58h+var_48], edx
movsxd rdi, edi
mov [rsp+58h+var_40], rsi
call _malloc
mov rsi, [rsp+58h+var_40]
movsxd rdx, dword ptr [rsp+58h+var_48]
mov [rsi], rax
movsxd rax, dword ptr [r13+0]
movsxd rsi, ebx
mov ebx, r12d
add rsi, rbp
mov [rsp+58h+var_48], rdx
mov rdi, [r14+rax*8]
mov dword ptr [rsp+58h+var_40], eax
call _strncpy
mov r8d, dword ptr [rsp+58h+var_40]
mov rdx, [rsp+58h+var_48]
add r8d, 1
mov byte ptr [rax+rdx], 0
mov [r13+0], r8d
loc_183F:
add r15, 1
cmp r15, [rsp+58h+var_50]
jnz loc_17B0
loc_184E:
add rsp, 28h
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, int *a2)
{
long long v3; // rax
long long v4; // r14
long long v5; // r15
int v6; // ebx
long long v7; // rax
long long v8; // rsi
int v10; // [rsp+4h] [rbp-54h]
int v11; // [rsp+10h] [rbp-48h]
_QWORD *v12; // [rsp+18h] [rbp-40h]
v10 = strlen();
v3 = malloc(8LL * v10);
*a2 = 0;
v4 = v3;
if ( v10 > 0 )
{
v5 = 1LL;
v6 = 0;
do
{
if ( v10 == (_DWORD)v5
|| (v7 = *(_QWORD *)__ctype_b_loc(), (*(_BYTE *)(v7 + 2LL * *(char *)(a1 + v5) + 1) & 1) != 0)
&& (*(_BYTE *)(v7 + 2LL * *(char *)(a1 + v5 - 1) + 1) & 1) == 0 )
{
v11 = v5 - v6;
v12 = (_QWORD *)(v4 + 8LL * *a2);
*v12 = malloc((int)v5 - v6 + 1);
v8 = v6;
v6 = v5;
LODWORD(v12) = *a2;
*(_BYTE *)(strncpy(*(_QWORD *)(v4 + 8LL * *a2), a1 + v8) + v11) = 0;
*a2 = (_DWORD)v12 + 1;
}
++v5;
}
while ( v5 != (unsigned int)(v10 - 1) + 2LL );
}
return v4;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x28
CALL 0x001010e0
MOVSXD RDI,EAX
MOV dword ptr [RSP + 0x4],EAX
MOV RBX,RAX
SHL RDI,0x3
CALL 0x00101120
MOV dword ptr [R13],0x0
MOV R14,RAX
TEST EBX,EBX
JLE 0x0010184e
LEA EAX,[RBX + -0x1]
MOV R15D,0x1
XOR EBX,EBX
ADD RAX,0x2
MOV qword ptr [RSP + 0x8],RAX
NOP word ptr [RAX + RAX*0x1]
LAB_001017b0:
MOV R12D,R15D
CMP dword ptr [RSP + 0x4],R15D
JZ 0x001017dc
CALL 0x00101130
MOVSX RDX,byte ptr [RBP + R15*0x1]
MOV RAX,qword ptr [RAX]
TEST byte ptr [RAX + RDX*0x2 + 0x1],0x1
JZ 0x0010183f
MOVSX RDX,byte ptr [RBP + R15*0x1 + -0x1]
TEST byte ptr [RAX + RDX*0x2 + 0x1],0x1
JNZ 0x0010183f
LAB_001017dc:
MOV EDX,R12D
MOVSXD RAX,dword ptr [R13]
SUB EDX,EBX
LEA EDI,[RDX + 0x1]
LEA RSI,[R14 + RAX*0x8]
MOV dword ptr [RSP + 0x10],EDX
MOVSXD RDI,EDI
MOV qword ptr [RSP + 0x18],RSI
CALL 0x00101120
MOV RSI,qword ptr [RSP + 0x18]
MOVSXD RDX,dword ptr [RSP + 0x10]
MOV qword ptr [RSI],RAX
MOVSXD RAX,dword ptr [R13]
MOVSXD RSI,EBX
MOV EBX,R12D
ADD RSI,RBP
MOV qword ptr [RSP + 0x10],RDX
MOV RDI,qword ptr [R14 + RAX*0x8]
MOV dword ptr [RSP + 0x18],EAX
CALL 0x001010d0
MOV R8D,dword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
ADD R8D,0x1
MOV byte ptr [RAX + RDX*0x1],0x0
MOV dword ptr [R13],R8D
LAB_0010183f:
ADD R15,0x1
CMP R15,qword ptr [RSP + 0x8]
JNZ 0x001017b0
LAB_0010184e:
ADD RSP,0x28
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(char *param_1,int *param_2)
{
int iVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
ushort **ppuVar5;
void *pvVar6;
char *pcVar7;
int iVar8;
int iVar9;
int iVar10;
long lVar11;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
pvVar4 = malloc((long)iVar2 << 3);
*param_2 = 0;
if (0 < iVar2) {
lVar11 = 1;
iVar9 = 0;
do {
iVar10 = (int)lVar11;
if (iVar2 == iVar10) {
LAB_001017dc:
iVar1 = *param_2;
iVar8 = iVar10 - iVar9;
pvVar6 = malloc((long)(iVar8 + 1));
*(void **)((long)pvVar4 + (long)iVar1 * 8) = pvVar6;
iVar1 = *param_2;
pcVar7 = strncpy(*(char **)((long)pvVar4 + (long)iVar1 * 8),param_1 + iVar9,(long)iVar8);
pcVar7[iVar8] = '\0';
*param_2 = iVar1 + 1;
iVar9 = iVar10;
}
else {
ppuVar5 = __ctype_b_loc();
if (((*(byte *)((long)*ppuVar5 + (long)param_1[lVar11] * 2 + 1) & 1) != 0) &&
((*(byte *)((long)*ppuVar5 + (long)param_1[lVar11 + -1] * 2 + 1) & 1) == 0))
goto LAB_001017dc;
}
lVar11 = lVar11 + 1;
} while (lVar11 != (ulong)(iVar2 - 1) + 2);
}
return pvVar4;
} |
7,719 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char** func0(const char* text, int* count) {
int n = strlen(text);
char** result = malloc(n * sizeof(char*));
*count = 0;
int word_start = 0;
for (int i = 1; i <= n; i++) {
if (i == n || (isupper(text[i]) && !isupper(text[i-1]))) {
int word_length = i - word_start;
result[*count] = malloc((word_length + 1) * sizeof(char));
strncpy(result[*count], text + word_start, word_length);
result[*count][word_length] = '\0';
(*count)++;
word_start = i;
}
}
return result;
}
| int main() {
int count1, count2, count3;
char** result1 = func0("LearnToBuildAnythingWithGoogle", &count1);
char** result2 = func0("ApmlifyingTheBlack+DeveloperCommunity", &count2);
char** result3 = func0("UpdateInTheGoEcoSystem", &count3);
assert(count1 == 6);
assert(strcmp(result1[0], "Learn") == 0);
assert(strcmp(result1[1], "To") == 0);
assert(strcmp(result1[2], "Build") == 0);
assert(strcmp(result1[3], "Anything") == 0);
assert(strcmp(result1[4], "With") == 0);
assert(strcmp(result1[5], "Google") == 0);
assert(count2 == 5);
assert(strcmp(result2[0], "Apmlifying") == 0);
assert(strcmp(result2[1], "The") == 0);
assert(strcmp(result2[2], "Black+") == 0);
assert(strcmp(result2[3], "Developer") == 0);
assert(strcmp(result2[4], "Community") == 0);
assert(count3 == 6);
assert(strcmp(result3[0], "Update") == 0);
assert(strcmp(result3[1], "In") == 0);
assert(strcmp(result3[2], "The") == 0);
assert(strcmp(result3[3], "Go") == 0);
assert(strcmp(result3[4], "Eco") == 0);
assert(strcmp(result3[5], "System") == 0);
for (int i = 0; i < count1; i++) free(result1[i]);
free(result1);
for (int i = 0; i < count2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < count3; i++) free(result3[i]);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x28,%rsp
callq 10d0 <strlen@plt>
movslq %eax,%rdi
mov %eax,0x4(%rsp)
mov %rax,%rbx
shl $0x3,%rdi
callq 1100 <malloc@plt>
movl $0x0,0x0(%rbp)
mov %rax,%r14
test %ebx,%ebx
jle 1898 <func0+0xf8>
lea -0x1(%rbx),%eax
mov $0x1,%r15d
xor %ebx,%ebx
add $0x2,%rax
mov %rax,0x8(%rsp)
nopw %cs:0x0(%rax,%rax,1)
mov %r15d,%r13d
cmp %r15d,0x4(%rsp)
je 182b <func0+0x8b>
callq 1110 <__ctype_b_loc@plt>
movsbq (%r12,%r15,1),%rdx
mov (%rax),%rax
testb $0x1,0x1(%rax,%rdx,2)
je 1889 <func0+0xe9>
movsbq -0x1(%r12,%r15,1),%rdx
testb $0x1,0x1(%rax,%rdx,2)
jne 1889 <func0+0xe9>
mov %r13d,%edx
movslq 0x0(%rbp),%rax
sub %ebx,%edx
lea 0x1(%rdx),%edi
lea (%r14,%rax,8),%rsi
mov %edx,0x10(%rsp)
movslq %edi,%rdi
mov %rsi,0x18(%rsp)
callq 1100 <malloc@plt>
mov 0x18(%rsp),%rsi
movslq 0x10(%rsp),%rdx
mov %rax,(%rsi)
movslq 0x0(%rbp),%rax
movslq %ebx,%rsi
mov %r13d,%ebx
add %r12,%rsi
mov %rdx,0x10(%rsp)
mov (%r14,%rax,8),%rdi
callq 10c0 <strncpy@plt>
movslq 0x0(%rbp),%rax
mov 0x10(%rsp),%rdx
mov (%r14,%rax,8),%rax
movb $0x0,(%rax,%rdx,1)
addl $0x1,0x0(%rbp)
add $0x1,%r15
cmp %r15,0x8(%rsp)
jne 1800 <func0+0x60>
add $0x28,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
call _strlen
movsxd rdi, eax
mov rbx, rax
mov r15d, eax
shl rdi, 3; size
call _malloc
mov dword ptr [r12], 0
mov [rsp+58h+var_50], rax
test ebx, ebx
jle loc_1849
lea r13d, [rbx-1]
mov r14d, 1
xor ebx, ebx
add r13, 2
nop dword ptr [rax+00h]
loc_17A8:
cmp r15d, r14d
jz short loc_17CF
call ___ctype_b_loc
movsx rdx, byte ptr [rbp+r14+0]
mov rax, [rax]
test byte ptr [rax+rdx*2+1], 1
jz short loc_183C
movsx rdx, byte ptr [rbp+r14-1]
test byte ptr [rax+rdx*2+1], 1
jnz short loc_183C
loc_17CF:
mov edx, r14d
mov rcx, [rsp+58h+var_50]
movsxd rax, dword ptr [r12]
sub edx, ebx
lea edi, [rdx+1]
lea rsi, [rcx+rax*8]
mov dword ptr [rsp+58h+var_48], edx
movsxd rdi, edi; size
mov [rsp+58h+var_40], rsi
call _malloc
mov rsi, [rsp+58h+var_40]
mov rcx, [rsp+58h+var_50]
movsxd rdx, dword ptr [rsp+58h+var_48]; n
mov [rsi], rax
movsxd rax, dword ptr [r12]
movsxd rsi, ebx
mov ebx, r14d
add rsi, rbp; src
mov [rsp+58h+var_48], rdx
mov rdi, [rcx+rax*8]; dest
mov dword ptr [rsp+58h+var_40], eax
call _strncpy
mov r8d, dword ptr [rsp+58h+var_40]
mov rdx, [rsp+58h+var_48]
add r8d, 1
mov byte ptr [rax+rdx], 0
mov [r12], r8d
loc_183C:
add r14, 1
cmp r13, r14
jnz loc_17A8
loc_1849:
mov rax, [rsp+58h+var_50]
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | char ** func0(const char *a1, int *a2)
{
int v3; // ebx
int v4; // r15d
char **v5; // rax
long long v6; // r13
long long v7; // r14
int v8; // ebx
long long v9; // r13
const unsigned __int16 *v10; // rax
long long v11; // rsi
char **v13; // [rsp+8h] [rbp-50h]
int v14; // [rsp+10h] [rbp-48h]
void **v15; // [rsp+18h] [rbp-40h]
v3 = strlen(a1);
v4 = v3;
v5 = (char **)malloc(8LL * v3);
*a2 = 0;
v13 = v5;
if ( v3 > 0 )
{
v6 = (unsigned int)(v3 - 1);
v7 = 1LL;
v8 = 0;
v9 = v6 + 2;
do
{
if ( v4 == (_DWORD)v7 || (v10 = *__ctype_b_loc(), (v10[a1[v7]] & 0x100) != 0) && (v10[a1[v7 - 1]] & 0x100) == 0 )
{
v14 = v7 - v8;
v15 = (void **)&v13[*a2];
*v15 = malloc((int)v7 - v8 + 1);
v11 = v8;
v8 = v7;
LODWORD(v15) = *a2;
strncpy(v13[*a2], &a1[v11], v14)[v14] = 0;
*a2 = (_DWORD)v15 + 1;
}
++v7;
}
while ( v9 != v7 );
}
return v13;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x28
CALL 0x001010e0
MOVSXD RDI,EAX
MOV RBX,RAX
MOV R15D,EAX
SHL RDI,0x3
CALL 0x00101120
MOV dword ptr [R12],0x0
MOV qword ptr [RSP + 0x8],RAX
TEST EBX,EBX
JLE 0x00101849
LEA R13D,[RBX + -0x1]
MOV R14D,0x1
XOR EBX,EBX
ADD R13,0x2
NOP dword ptr [RAX]
LAB_001017a8:
CMP R15D,R14D
JZ 0x001017cf
CALL 0x00101130
MOVSX RDX,byte ptr [RBP + R14*0x1]
MOV RAX,qword ptr [RAX]
TEST byte ptr [RAX + RDX*0x2 + 0x1],0x1
JZ 0x0010183c
MOVSX RDX,byte ptr [RBP + R14*0x1 + -0x1]
TEST byte ptr [RAX + RDX*0x2 + 0x1],0x1
JNZ 0x0010183c
LAB_001017cf:
MOV EDX,R14D
MOV RCX,qword ptr [RSP + 0x8]
MOVSXD RAX,dword ptr [R12]
SUB EDX,EBX
LEA EDI,[RDX + 0x1]
LEA RSI,[RCX + RAX*0x8]
MOV dword ptr [RSP + 0x10],EDX
MOVSXD RDI,EDI
MOV qword ptr [RSP + 0x18],RSI
CALL 0x00101120
MOV RSI,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x8]
MOVSXD RDX,dword ptr [RSP + 0x10]
MOV qword ptr [RSI],RAX
MOVSXD RAX,dword ptr [R12]
MOVSXD RSI,EBX
MOV EBX,R14D
ADD RSI,RBP
MOV qword ptr [RSP + 0x10],RDX
MOV RDI,qword ptr [RCX + RAX*0x8]
MOV dword ptr [RSP + 0x18],EAX
CALL 0x001010d0
MOV R8D,dword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
ADD R8D,0x1
MOV byte ptr [RAX + RDX*0x1],0x0
MOV dword ptr [R12],R8D
LAB_0010183c:
ADD R14,0x1
CMP R13,R14
JNZ 0x001017a8
LAB_00101849:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(char *param_1,int *param_2)
{
int iVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
ushort **ppuVar5;
void *pvVar6;
char *pcVar7;
int iVar8;
int iVar9;
int iVar10;
long lVar11;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
pvVar4 = malloc((long)iVar2 << 3);
*param_2 = 0;
if (0 < iVar2) {
lVar11 = 1;
iVar9 = 0;
do {
iVar10 = (int)lVar11;
if (iVar2 == iVar10) {
LAB_001017cf:
iVar1 = *param_2;
iVar8 = iVar10 - iVar9;
pvVar6 = malloc((long)(iVar8 + 1));
*(void **)((long)pvVar4 + (long)iVar1 * 8) = pvVar6;
iVar1 = *param_2;
pcVar7 = strncpy(*(char **)((long)pvVar4 + (long)iVar1 * 8),param_1 + iVar9,(long)iVar8);
pcVar7[iVar8] = '\0';
*param_2 = iVar1 + 1;
iVar9 = iVar10;
}
else {
ppuVar5 = __ctype_b_loc();
if (((*(byte *)((long)*ppuVar5 + (long)param_1[lVar11] * 2 + 1) & 1) != 0) &&
((*(byte *)((long)*ppuVar5 + (long)param_1[lVar11 + -1] * 2 + 1) & 1) == 0))
goto LAB_001017cf;
}
lVar11 = lVar11 + 1;
} while ((ulong)(iVar2 - 1) + 2 != lVar11);
}
return pvVar4;
} |
7,720 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int n) {
return (int)(log2(n & -n) + 1);
}
| int main() {
assert(func0(12) == 3);
assert(func0(18) == 2);
assert(func0(16) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
neg %eax
and -0x4(%rbp),%eax
cvtsi2sd %eax,%xmm0
callq 1060 <log2@plt>
movsd 0xee7(%rip),%xmm1
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
neg eax
and eax, [rbp+var_4]
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
movq rax, xmm2
movq xmm0, rax; x
call _log2
movsd xmm1, cs:qword_2058
addsd xmm0, xmm1
cvttsd2si eax, xmm0
leave
retn | long long func0(int a1)
{
return (unsigned int)(int)(log2((double)(a1 & -a1)) + 1.0);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
NEG EAX
AND EAX,dword ptr [RBP + -0x4]
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
MOVQ RAX,XMM2
MOVQ XMM0,RAX
CALL 0x00101060
MOVSD XMM1,qword ptr [0x00102058]
ADDSD XMM0,XMM1
CVTTSD2SI EAX,XMM0
LEAVE
RET | int func0(uint param_1)
{
double dVar1;
dVar1 = log2((double)(int)(-param_1 & param_1));
return (int)(dVar1 + DAT_00102058);
} |
7,721 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int n) {
return (int)(log2(n & -n) + 1);
}
| int main() {
assert(func0(12) == 3);
assert(func0(18) == 2);
assert(func0(16) == 5);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
mov %edi,%eax
neg %edi
and %eax,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
callq 1060 <log2@plt>
addsd 0xeec(%rip),%xmm0
cvttsd2si %xmm0,%eax
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
mov eax, edi
neg eax
and eax, edi
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
call _log2
addsd xmm0, cs:qword_2058
cvttsd2si eax, xmm0
add rsp, 8
retn | long long func0(int a1)
{
return (unsigned int)(int)(log2((double)(a1 & -a1)) + 1.0);
} | func0:
ENDBR64
SUB RSP,0x8
MOV EAX,EDI
NEG EAX
AND EAX,EDI
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
CALL 0x00101060
ADDSD XMM0,qword ptr [0x00102058]
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint param_1)
{
double dVar1;
dVar1 = log2((double)(int)(-param_1 & param_1));
return (int)(dVar1 + _DAT_00102058);
} |
7,722 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int n) {
return (int)(log2(n & -n) + 1);
}
| int main() {
assert(func0(12) == 3);
assert(func0(18) == 2);
assert(func0(16) == 5);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%r8d
neg %edi
pxor %xmm0,%xmm0
sub $0x8,%rsp
and %r8d,%edi
cvtsi2sd %edi,%xmm0
callq 1050 <log2@plt>
addsd 0xe83(%rip),%xmm0
add $0x8,%rsp
cvttsd2si %xmm0,%eax
retq
xchg %ax,%ax
| func0:
endbr64
mov eax, edi
pxor xmm0, xmm0
sub rsp, 8
neg eax
and eax, edi
cvtsi2sd xmm0, eax
call _log2
addsd xmm0, cs:qword_2008
add rsp, 8
cvttsd2si eax, xmm0
retn | long long func0(int a1)
{
return (unsigned int)(int)(log2((double)(a1 & -a1)) + 1.0);
} | func0:
ENDBR64
MOV EAX,EDI
PXOR XMM0,XMM0
SUB RSP,0x8
NEG EAX
AND EAX,EDI
CVTSI2SD XMM0,EAX
CALL 0x00101050
ADDSD XMM0,qword ptr [0x00102008]
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint param_1)
{
double dVar1;
dVar1 = log2((double)(int)(-param_1 & param_1));
return (int)(dVar1 + _DAT_00102008);
} |
7,723 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int n) {
return (int)(log2(n & -n) + 1);
}
| int main() {
assert(func0(12) == 3);
assert(func0(18) == 2);
assert(func0(16) == 5);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%r8d
neg %edi
pxor %xmm0,%xmm0
sub $0x8,%rsp
and %r8d,%edi
cvtsi2sd %edi,%xmm0
callq 1050 <log2@plt>
addsd 0xe83(%rip),%xmm0
add $0x8,%rsp
cvttsd2si %xmm0,%eax
retq
xchg %ax,%ax
| func0:
endbr64
mov eax, edi
pxor xmm0, xmm0
sub rsp, 8
neg eax
and eax, edi
cvtsi2sd xmm0, eax; x
call _log2
addsd xmm0, cs:qword_2008
add rsp, 8
cvttsd2si eax, xmm0
retn | long long func0(int a1)
{
return (unsigned int)(int)(log2((double)(a1 & -a1)) + 1.0);
} | func0:
ENDBR64
MOV EAX,EDI
PXOR XMM0,XMM0
SUB RSP,0x8
NEG EAX
AND EAX,EDI
CVTSI2SD XMM0,EAX
CALL 0x00101050
ADDSD XMM0,qword ptr [0x00102008]
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint param_1)
{
double dVar1;
dVar1 = log2((double)(int)(-param_1 & param_1));
return (int)(dVar1 + _DAT_00102008);
} |
7,724 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int num) {
static char roman_num[100];
int val[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
char* syb[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
roman_num[0] = '\0';
int i = 0;
while (num > 0) {
while (num >= val[i]) {
strcat(roman_num, syb[i]);
num -= val[i];
}
i++;
}
return roman_num;
}
| int main() {
assert(strcmp(func0(1), "I") == 0);
assert(strcmp(func0(50), "L") == 0);
assert(strcmp(func0(4), "IV") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xd0,%rsp
mov %edi,-0xc4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x3e8,-0xb0(%rbp)
movl $0x384,-0xac(%rbp)
movl $0x1f4,-0xa8(%rbp)
movl $0x190,-0xa4(%rbp)
movl $0x64,-0xa0(%rbp)
movl $0x5a,-0x9c(%rbp)
movl $0x32,-0x98(%rbp)
movl $0x28,-0x94(%rbp)
movl $0xa,-0x90(%rbp)
movl $0x9,-0x8c(%rbp)
movl $0x5,-0x88(%rbp)
movl $0x4,-0x84(%rbp)
movl $0x1,-0x80(%rbp)
lea 0xdb5(%rip),%rax
mov %rax,-0x70(%rbp)
lea 0xdac(%rip),%rax
mov %rax,-0x68(%rbp)
lea 0xda4(%rip),%rax
mov %rax,-0x60(%rbp)
lea 0xd9b(%rip),%rax
mov %rax,-0x58(%rbp)
lea 0xd93(%rip),%rax
mov %rax,-0x50(%rbp)
lea 0xd8a(%rip),%rax
mov %rax,-0x48(%rbp)
lea 0xd82(%rip),%rax
mov %rax,-0x40(%rbp)
lea 0xd79(%rip),%rax
mov %rax,-0x38(%rbp)
lea 0xd71(%rip),%rax
mov %rax,-0x30(%rbp)
lea 0xd68(%rip),%rax
mov %rax,-0x28(%rbp)
lea 0xd60(%rip),%rax
mov %rax,-0x20(%rbp)
lea 0xd57(%rip),%rax
mov %rax,-0x18(%rbp)
lea 0xd4f(%rip),%rax
mov %rax,-0x10(%rbp)
movb $0x0,0x2d5e(%rip)
movl $0x0,-0xb4(%rbp)
jmp 133d <func0+0x194>
mov -0xb4(%rbp),%eax
cltq
mov -0x70(%rbp,%rax,8),%rax
mov %rax,%rsi
lea 0x2d3b(%rip),%rdi
callq 10b0 <strcat@plt>
mov -0xb4(%rbp),%eax
cltq
mov -0xb0(%rbp,%rax,4),%eax
sub %eax,-0xc4(%rbp)
mov -0xb4(%rbp),%eax
cltq
mov -0xb0(%rbp,%rax,4),%eax
cmp %eax,-0xc4(%rbp)
jge 12ee <func0+0x145>
addl $0x1,-0xb4(%rbp)
cmpl $0x0,-0xc4(%rbp)
jg 131f <func0+0x176>
lea 0x2cf3(%rip),%rax
mov -0x8(%rbp),%rdx
xor %fs:0x28,%rdx
je 1361 <func0+0x1b8>
callq 1080 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+var_C4], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_B0], 3E8h
mov [rbp+var_AC], 384h
mov [rbp+var_A8], 1F4h
mov [rbp+var_A4], 190h
mov [rbp+var_A0], 64h ; 'd'
mov [rbp+var_9C], 5Ah ; 'Z'
mov [rbp+var_98], 32h ; '2'
mov [rbp+var_94], 28h ; '('
mov [rbp+var_90], 0Ah
mov [rbp+var_8C], 9
mov [rbp+var_88], 5
mov [rbp+var_84], 4
mov [rbp+var_80], 1
lea rax, unk_2004
mov [rbp+src], rax
lea rax, unk_2006
mov [rbp+var_68], rax
lea rax, unk_2009
mov [rbp+var_60], rax
lea rax, unk_200B
mov [rbp+var_58], rax
lea rax, unk_200E
mov [rbp+var_50], rax
lea rax, unk_2010
mov [rbp+var_48], rax
lea rax, asc_2013; "L"
mov [rbp+var_40], rax
lea rax, aXl; "XL"
mov [rbp+var_38], rax
lea rax, asc_2018; "X"
mov [rbp+var_30], rax
lea rax, aIx; "IX"
mov [rbp+var_28], rax
lea rax, aV; "V"
mov [rbp+var_20], rax
lea rax, aIv; "IV"
mov [rbp+var_18], rax
lea rax, s2; "I"
mov [rbp+var_10], rax
mov cs:roman_num_1, 0
mov [rbp+var_B4], 0
jmp short loc_1340
loc_12EE:
mov eax, [rbp+var_B4]
cdqe
mov rax, [rbp+rax*8+src]
mov rsi, rax; src
lea rax, roman_num_1
mov rdi, rax; dest
call _strcat
mov eax, [rbp+var_B4]
cdqe
mov eax, [rbp+rax*4+var_B0]
sub [rbp+var_C4], eax
loc_1322:
mov eax, [rbp+var_B4]
cdqe
mov eax, [rbp+rax*4+var_B0]
cmp [rbp+var_C4], eax
jge short loc_12EE
add [rbp+var_B4], 1
loc_1340:
cmp [rbp+var_C4], 0
jg short loc_1322
lea rax, roman_num_1
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1364
call ___stack_chk_fail
locret_1364:
leave
retn | char * func0(int a1)
{
int v3; // [rsp+1Ch] [rbp-B4h]
_DWORD v4[16]; // [rsp+20h] [rbp-B0h]
char *src[14]; // [rsp+60h] [rbp-70h]
src[13] = (char *)__readfsqword(0x28u);
v4[0] = 1000;
v4[1] = 900;
v4[2] = 500;
v4[3] = 400;
v4[4] = 100;
v4[5] = 90;
v4[6] = 50;
v4[7] = 40;
v4[8] = 10;
v4[9] = 9;
v4[10] = 5;
v4[11] = 4;
v4[12] = 1;
src[0] = (char *)&unk_2004;
src[1] = (char *)&unk_2006;
src[2] = (char *)&unk_2009;
src[3] = (char *)&unk_200B;
src[4] = (char *)&unk_200E;
src[5] = (char *)&unk_2010;
src[6] = "L";
src[7] = "XL";
src[8] = "X";
src[9] = "IX";
src[10] = "V";
src[11] = "IV";
src[12] = "I";
roman_num_1 = 0;
v3 = 0;
while ( a1 > 0 )
{
while ( a1 >= v4[v3] )
{
strcat(&roman_num_1, src[v3]);
a1 -= v4[v3];
}
++v3;
}
return &roman_num_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV dword ptr [RBP + -0xc4],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0xb0],0x3e8
MOV dword ptr [RBP + -0xac],0x384
MOV dword ptr [RBP + -0xa8],0x1f4
MOV dword ptr [RBP + -0xa4],0x190
MOV dword ptr [RBP + -0xa0],0x64
MOV dword ptr [RBP + -0x9c],0x5a
MOV dword ptr [RBP + -0x98],0x32
MOV dword ptr [RBP + -0x94],0x28
MOV dword ptr [RBP + -0x90],0xa
MOV dword ptr [RBP + -0x8c],0x9
MOV dword ptr [RBP + -0x88],0x5
MOV dword ptr [RBP + -0x84],0x4
MOV dword ptr [RBP + -0x80],0x1
LEA RAX,[0x102004]
MOV qword ptr [RBP + -0x70],RAX
LEA RAX,[0x102006]
MOV qword ptr [RBP + -0x68],RAX
LEA RAX,[0x102009]
MOV qword ptr [RBP + -0x60],RAX
LEA RAX,[0x10200b]
MOV qword ptr [RBP + -0x58],RAX
LEA RAX,[0x10200e]
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[0x102010]
MOV qword ptr [RBP + -0x48],RAX
LEA RAX,[0x102013]
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[0x102015]
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[0x102018]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x10201a]
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[0x10201d]
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[0x10201f]
MOV qword ptr [RBP + -0x18],RAX
LEA RAX,[0x102022]
MOV qword ptr [RBP + -0x10],RAX
MOV byte ptr [0x00104040],0x0
MOV dword ptr [RBP + -0xb4],0x0
JMP 0x00101340
LAB_001012ee:
MOV EAX,dword ptr [RBP + -0xb4]
CDQE
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x70]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x001010b0
MOV EAX,dword ptr [RBP + -0xb4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0xb0]
SUB dword ptr [RBP + -0xc4],EAX
LAB_00101322:
MOV EAX,dword ptr [RBP + -0xb4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0xb0]
CMP dword ptr [RBP + -0xc4],EAX
JGE 0x001012ee
ADD dword ptr [RBP + -0xb4],0x1
LAB_00101340:
CMP dword ptr [RBP + -0xc4],0x0
JG 0x00101322
LEA RAX,[0x104040]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101364
CALL 0x00101080
LAB_00101364:
LEAVE
RET | int1 * func0(int param_1)
{
long in_FS_OFFSET;
int local_cc;
int local_bc;
int local_b8 [16];
int *local_78 [4];
int *local_58;
int *local_50;
int *local_48;
int *local_40;
int *local_38;
int *local_30;
int *local_28;
int *local_20;
int *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_b8[0] = 1000;
local_b8[1] = 900;
local_b8[2] = 500;
local_b8[3] = 400;
local_b8[4] = 100;
local_b8[5] = 0x5a;
local_b8[6] = 0x32;
local_b8[7] = 0x28;
local_b8[8] = 10;
local_b8[9] = 9;
local_b8[10] = 5;
local_b8[0xb] = 4;
local_b8[0xc] = 1;
local_78[0] = &DAT_00102004;
local_78[1] = &DAT_00102006;
local_78[2] = &DAT_00102009;
local_78[3] = &DAT_0010200b;
local_58 = &DAT_0010200e;
local_50 = &DAT_00102010;
local_48 = &DAT_00102013;
local_40 = &DAT_00102015;
local_38 = &DAT_00102018;
local_30 = &DAT_0010201a;
local_28 = &DAT_0010201d;
local_20 = &DAT_0010201f;
local_18 = &DAT_00102022;
roman_num_1[0] = 0;
local_bc = 0;
local_cc = param_1;
while (0 < local_cc) {
for (; local_b8[local_bc] <= local_cc; local_cc = local_cc - local_b8[local_bc]) {
strcat(roman_num_1,local_78[local_bc]);
}
local_bc = local_bc + 1;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return roman_num_1;
} |
7,725 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int num) {
static char roman_num[100];
int val[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
char* syb[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
roman_num[0] = '\0';
int i = 0;
while (num > 0) {
while (num >= val[i]) {
strcat(roman_num, syb[i]);
num -= val[i];
}
i++;
}
return roman_num;
}
| int main() {
assert(strcmp(func0(1), "I") == 0);
assert(strcmp(func0(50), "L") == 0);
assert(strcmp(func0(4), "IV") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
movl $0x3e8,(%rsp)
movl $0x384,0x4(%rsp)
movl $0x1f4,0x8(%rsp)
movl $0x190,0xc(%rsp)
movl $0x64,0x10(%rsp)
movl $0x5a,0x14(%rsp)
movl $0x32,0x18(%rsp)
movl $0x28,0x1c(%rsp)
movl $0xa,0x20(%rsp)
movl $0x9,0x24(%rsp)
movl $0x5,0x28(%rsp)
movl $0x4,0x2c(%rsp)
movl $0x1,0x30(%rsp)
lea 0xde8(%rip),%rax
mov %rax,0x40(%rsp)
lea 0xddb(%rip),%rax
mov %rax,0x48(%rsp)
lea 0xdd3(%rip),%rax
mov %rax,0x50(%rsp)
lea 0xdc6(%rip),%rax
mov %rax,0x58(%rsp)
lea 0xdbe(%rip),%rax
mov %rax,0x60(%rsp)
lea 0xdb1(%rip),%rax
mov %rax,0x68(%rsp)
lea 0xda9(%rip),%rax
mov %rax,0x70(%rsp)
lea 0xd9c(%rip),%rax
mov %rax,0x78(%rsp)
lea 0xd94(%rip),%rax
mov %rax,0x80(%rsp)
lea 0xd84(%rip),%rax
mov %rax,0x88(%rsp)
lea 0xd79(%rip),%rax
mov %rax,0x90(%rsp)
lea 0xd69(%rip),%rax
mov %rax,0x98(%rsp)
lea 0xd5d(%rip),%rax
mov %rax,0xa0(%rsp)
movb $0x0,0x2d78(%rip)
test %edi,%edi
jle 130b <func0+0x182>
mov %edi,%ebx
mov %rsp,%r14
lea 0x40(%rsp),%r12
lea 0x2d63(%rip),%r13
jmp 1302 <func0+0x179>
mov $0x64,%edx
mov (%r12),%rsi
mov %r13,%rdi
callq 1070 <__strcat_chk@plt>
sub %ebp,%ebx
cmp %ebp,%ebx
jge 12df <func0+0x156>
add $0x4,%r14
add $0x8,%r12
test %ebx,%ebx
jle 130b <func0+0x182>
mov (%r14),%ebp
cmp %ebx,%ebp
jle 12df <func0+0x156>
jmp 12f6 <func0+0x16d>
mov 0xa8(%rsp),%rax
xor %fs:0x28,%rax
jne 1335 <func0+0x1ac>
lea 0x2d1b(%rip),%rax
add $0xb0,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B0h
mov rax, fs:28h
mov [rsp+0D8h+var_30], rax
xor eax, eax
mov [rsp+0D8h+var_D8], 3E8h
mov [rsp+0D8h+var_D4], 384h
mov [rsp+0D8h+var_D0], 1F4h
mov [rsp+0D8h+var_CC], 190h
mov [rsp+0D8h+var_C8], 64h ; 'd'
mov [rsp+0D8h+var_C4], 5Ah ; 'Z'
mov [rsp+0D8h+var_C0], 32h ; '2'
mov [rsp+0D8h+var_BC], 28h ; '('
mov [rsp+0D8h+var_B8], 0Ah
mov [rsp+0D8h+var_B4], 9
mov [rsp+0D8h+var_B0], 5
mov [rsp+0D8h+var_AC], 4
mov [rsp+0D8h+var_A8], 1
lea rax, unk_2005
mov [rsp+0D8h+var_98], rax
lea rax, unk_2004
mov [rsp+0D8h+var_90], rax
lea rax, unk_2008
mov [rsp+0D8h+var_88], rax
lea rax, unk_2007
mov [rsp+0D8h+var_80], rax
lea rax, unk_200B
mov [rsp+0D8h+var_78], rax
lea rax, unk_200A
mov [rsp+0D8h+var_70], rax
lea rax, unk_200E
mov [rsp+0D8h+var_68], rax
lea rax, unk_200D
mov [rsp+0D8h+var_60], rax
lea rax, unk_2011
mov [rsp+0D8h+var_58], rax
lea rax, unk_2010
mov [rsp+0D8h+var_50], rax
lea rax, unk_2014
mov [rsp+0D8h+var_48], rax
lea rax, unk_2013
mov [rsp+0D8h+var_40], rax
lea rax, unk_2016
mov [rsp+0D8h+var_38], rax
mov cs:roman_num_1, 0
test edi, edi
jle short loc_132B
mov ebx, edi
mov r14, rsp
lea r12, [rsp+0D8h+var_98]
lea r13, roman_num_1
jmp short loc_1322
loc_12FF:
mov edx, 64h ; 'd'
mov rsi, [r12]
mov rdi, r13
call ___strcat_chk
sub ebx, ebp
cmp ebx, ebp
jge short loc_12FF
loc_1316:
add r14, 4
add r12, 8
test ebx, ebx
jle short loc_132B
loc_1322:
mov ebp, [r14]
cmp ebp, ebx
jle short loc_12FF
jmp short loc_1316
loc_132B:
mov rax, [rsp+0D8h+var_30]
sub rax, fs:28h
jnz short loc_1355
lea rax, roman_num_1
add rsp, 0B0h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1355:
call ___stack_chk_fail | char * func0(int a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
int v6; // ebx
long long *v7; // r14
_QWORD *v8; // r12
int i; // ebp
long long v11; // [rsp+0h] [rbp-D8h] BYREF
long long v12; // [rsp+8h] [rbp-D0h]
long long v13; // [rsp+10h] [rbp-C8h]
long long v14; // [rsp+18h] [rbp-C0h]
long long v15; // [rsp+20h] [rbp-B8h]
long long v16; // [rsp+28h] [rbp-B0h]
int v17; // [rsp+30h] [rbp-A8h]
_QWORD v18[19]; // [rsp+40h] [rbp-98h] BYREF
v18[13] = __readfsqword(0x28u);
v11 = 0x384000003E8LL;
v12 = 0x190000001F4LL;
v13 = 0x5A00000064LL;
v14 = 0x2800000032LL;
v15 = 0x90000000ALL;
v16 = 0x400000005LL;
v17 = 1;
v18[0] = &unk_2005;
v18[1] = &unk_2004;
v18[2] = &unk_2008;
v18[3] = &unk_2007;
v18[4] = &unk_200B;
v18[5] = &unk_200A;
v18[6] = &unk_200E;
v18[7] = &unk_200D;
v18[8] = &unk_2011;
v18[9] = &unk_2010;
v18[10] = &unk_2014;
v18[11] = &unk_2013;
v18[12] = &unk_2016;
roman_num_1 = 0;
if ( a1 > 0 )
{
v6 = a1;
v7 = &v11;
v8 = v18;
do
{
for ( i = *(_DWORD *)v7; v6 >= i; v6 -= i )
__strcat_chk(&roman_num_1, *v8, 100LL, a4, a5, a6, v11, v12, v13, v14, v15, v16, v17);
v7 = (long long *)((char *)v7 + 4);
++v8;
}
while ( v6 > 0 );
}
return &roman_num_1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
MOV dword ptr [RSP],0x3e8
MOV dword ptr [RSP + 0x4],0x384
MOV dword ptr [RSP + 0x8],0x1f4
MOV dword ptr [RSP + 0xc],0x190
MOV dword ptr [RSP + 0x10],0x64
MOV dword ptr [RSP + 0x14],0x5a
MOV dword ptr [RSP + 0x18],0x32
MOV dword ptr [RSP + 0x1c],0x28
MOV dword ptr [RSP + 0x20],0xa
MOV dword ptr [RSP + 0x24],0x9
MOV dword ptr [RSP + 0x28],0x5
MOV dword ptr [RSP + 0x2c],0x4
MOV dword ptr [RSP + 0x30],0x1
LEA RAX,[0x102005]
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[0x102004]
MOV qword ptr [RSP + 0x48],RAX
LEA RAX,[0x102008]
MOV qword ptr [RSP + 0x50],RAX
LEA RAX,[0x102007]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[0x10200b]
MOV qword ptr [RSP + 0x60],RAX
LEA RAX,[0x10200a]
MOV qword ptr [RSP + 0x68],RAX
LEA RAX,[0x10200e]
MOV qword ptr [RSP + 0x70],RAX
LEA RAX,[0x10200d]
MOV qword ptr [RSP + 0x78],RAX
LEA RAX,[0x102011]
MOV qword ptr [RSP + 0x80],RAX
LEA RAX,[0x102010]
MOV qword ptr [RSP + 0x88],RAX
LEA RAX,[0x102014]
MOV qword ptr [RSP + 0x90],RAX
LEA RAX,[0x102013]
MOV qword ptr [RSP + 0x98],RAX
LEA RAX,[0x102016]
MOV qword ptr [RSP + 0xa0],RAX
MOV byte ptr [0x00104040],0x0
TEST EDI,EDI
JLE 0x0010132b
MOV EBX,EDI
MOV R14,RSP
LEA R12,[RSP + 0x40]
LEA R13,[0x104040]
JMP 0x00101322
LAB_001012ff:
MOV EDX,0x64
MOV RSI,qword ptr [R12]
MOV RDI,R13
CALL 0x00101080
SUB EBX,EBP
CMP EBX,EBP
JGE 0x001012ff
LAB_00101316:
ADD R14,0x4
ADD R12,0x8
TEST EBX,EBX
JLE 0x0010132b
LAB_00101322:
MOV EBP,dword ptr [R14]
CMP EBP,EBX
JLE 0x001012ff
JMP 0x00101316
LAB_0010132b:
MOV RAX,qword ptr [RSP + 0xa8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101355
LEA RAX,[0x104040]
ADD RSP,0xb0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101355:
CALL 0x00101090 | int1 * func0(int param_1)
{
int iVar1;
int **ppuVar2;
int *piVar3;
long in_FS_OFFSET;
int local_d8 [16];
int *local_98 [4];
int *local_78;
int *local_70;
int *local_68;
int *local_60;
int *local_58;
int *local_50;
int *local_48;
int *local_40;
int *local_38;
long local_30;
piVar3 = local_d8;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_d8[0] = 1000;
local_d8[1] = 900;
local_d8[2] = 500;
local_d8[3] = 400;
local_d8[4] = 100;
local_d8[5] = 0x5a;
local_d8[6] = 0x32;
local_d8[7] = 0x28;
local_d8[8] = 10;
local_d8[9] = 9;
local_d8[10] = 5;
local_d8[0xb] = 4;
local_d8[0xc] = 1;
local_98[0] = &DAT_00102005;
local_98[1] = &DAT_00102004;
local_98[2] = &DAT_00102008;
local_98[3] = &DAT_00102007;
local_78 = &DAT_0010200b;
local_70 = &DAT_0010200a;
local_68 = &DAT_0010200e;
local_60 = &DAT_0010200d;
local_58 = &DAT_00102011;
local_50 = &DAT_00102010;
local_48 = &DAT_00102014;
local_40 = &DAT_00102013;
local_38 = &DAT_00102016;
roman_num_1[0] = 0;
if (0 < param_1) {
ppuVar2 = local_98;
do {
iVar1 = *piVar3;
for (; iVar1 <= param_1; param_1 = param_1 - iVar1) {
__strcat_chk(roman_num_1,*ppuVar2,100);
}
piVar3 = piVar3 + 1;
ppuVar2 = ppuVar2 + 1;
} while (0 < param_1);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return roman_num_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,726 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int num) {
static char roman_num[100];
int val[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
char* syb[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
roman_num[0] = '\0';
int i = 0;
while (num > 0) {
while (num >= val[i]) {
strcat(roman_num, syb[i]);
num -= val[i];
}
i++;
}
return roman_num;
}
| int main() {
assert(strcmp(func0(1), "I") == 0);
assert(strcmp(func0(50), "L") == 0);
assert(strcmp(func0(4), "IV") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
movb $0x0,0x2dc3(%rip)
movabs $0x1f400000384,%rax
mov %rax,0x4(%rsp)
movabs $0x6400000190,%rax
mov %rax,0xc(%rsp)
movabs $0x320000005a,%rax
mov %rax,0x14(%rsp)
movabs $0xa00000028,%rax
mov %rax,0x1c(%rsp)
movabs $0x500000009,%rax
mov %rax,0x24(%rsp)
movabs $0x100000004,%rax
mov %rax,0x2c(%rsp)
lea 0xd27(%rip),%rax
mov %rax,0x40(%rsp)
lea 0xd1a(%rip),%rax
mov %rax,0x48(%rsp)
lea 0xd12(%rip),%rax
mov %rax,0x50(%rsp)
lea 0xd05(%rip),%rax
mov %rax,0x58(%rsp)
lea 0xcfd(%rip),%rax
mov %rax,0x60(%rsp)
lea 0xcf0(%rip),%rax
mov %rax,0x68(%rsp)
lea 0xce8(%rip),%rax
mov %rax,0x70(%rsp)
lea 0xcdb(%rip),%rax
mov %rax,0x78(%rsp)
lea 0xcd3(%rip),%rax
mov %rax,0x80(%rsp)
lea 0xcc3(%rip),%rax
mov %rax,0x88(%rsp)
lea 0xcb8(%rip),%rax
mov %rax,0x90(%rsp)
lea 0xca8(%rip),%rax
mov %rax,0x98(%rsp)
lea 0xc9c(%rip),%rax
mov %rax,0xa0(%rsp)
test %edi,%edi
jle 13e0 <func0+0x190>
mov %edi,%ebx
mov $0x3e8,%ebp
lea 0x40(%rsp),%r14
xor %r13d,%r13d
lea 0x2ca4(%rip),%rcx
cmp %ebx,%ebp
jg 13d1 <func0+0x181>
mov (%r14,%r13,2),%r12
nopl 0x0(%rax)
mov %rcx,%rdi
mov $0x64,%edx
mov %r12,%rsi
sub %ebp,%ebx
callq 1070 <__strcat_chk@plt>
mov %rax,%rcx
cmp %ebp,%ebx
jge 13a8 <func0+0x158>
add $0x4,%r13
test %ebx,%ebx
je 13e0 <func0+0x190>
mov (%rsp,%r13,1),%ebp
cmp %ebx,%ebp
jle 13a0 <func0+0x150>
add $0x4,%r13
jmp 13c9 <func0+0x179>
nopw 0x0(%rax,%rax,1)
mov 0xa8(%rsp),%rax
xor %fs:0x28,%rax
jne 140a <func0+0x1ba>
add $0xb0,%rsp
lea 0x2c3f(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push r14
lea r8, roman_num_1
push r13
push r12
push rbp
push rbx
sub rsp, 0B0h
mov rax, fs:28h
mov [rsp+0D8h+var_30], rax
mov rax, 1F400000384h
mov cs:roman_num_1, 0
mov [rsp+0D8h+var_D4], rax
mov rax, 6400000190h
mov [rsp+0D8h+var_CC], rax
mov rax, 320000005Ah
mov [rsp+0D8h+var_C4], rax
mov rax, 0A00000028h
mov [rsp+0D8h+var_BC], rax
mov rax, 500000009h
mov [rsp+0D8h+var_B4], rax
mov rax, 100000004h
mov [rsp+0D8h+var_AC], rax
lea rax, unk_2005
mov [rsp+0D8h+var_98], rax
lea rax, unk_2004
mov [rsp+0D8h+var_90], rax
lea rax, unk_2008
mov [rsp+0D8h+var_88], rax
lea rax, unk_2007
mov [rsp+0D8h+var_80], rax
lea rax, unk_200B
mov [rsp+0D8h+var_78], rax
lea rax, unk_200A
mov [rsp+0D8h+var_70], rax
lea rax, unk_200E
mov [rsp+0D8h+var_68], rax
lea rax, unk_200D
mov [rsp+0D8h+var_60], rax
lea rax, unk_2011
mov [rsp+0D8h+var_58], rax
lea rax, unk_2010
mov [rsp+0D8h+var_50], rax
lea rax, unk_2014
mov [rsp+0D8h+var_48], rax
lea rax, unk_2013
mov [rsp+0D8h+var_40], rax
lea rax, unk_2016
mov [rsp+0D8h+var_38], rax
test edi, edi
jle short loc_13E0
mov ebx, edi
mov ebp, 3E8h
lea r14, [rsp+0D8h+var_98]
xor r13d, r13d
lea r8, roman_num_1
cmp ebp, ebx
jg short loc_13D9
nop dword ptr [rax]
loc_13A8:
mov r12, [r14+r13*2]
nop dword ptr [rax+00h]
loc_13B0:
mov rdi, r8
mov edx, 64h ; 'd'
mov rsi, r12
sub ebx, ebp
call ___strcat_chk
mov r8, rax
cmp ebp, ebx
jle short loc_13B0
add r13, 4
test ebx, ebx
jz short loc_13E0
loc_13D1:
mov ebp, [rsp+r13+0D8h+var_D8]
cmp ebp, ebx
jle short loc_13A8
loc_13D9:
add r13, 4
jmp short loc_13D1
loc_13E0:
mov rax, [rsp+0D8h+var_30]
sub rax, fs:28h
jnz short loc_1406
add rsp, 0B0h
mov rax, r8
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1406:
call ___stack_chk_fail | char * func0(int a1)
{
char *v1; // r8
int v2; // ebx
int v3; // ebp
long long v4; // r13
long long v5; // r12
int v7; // [rsp+0h] [rbp-D8h]
long long v8; // [rsp+4h] [rbp-D4h]
long long v9; // [rsp+Ch] [rbp-CCh]
long long v10; // [rsp+14h] [rbp-C4h]
long long v11; // [rsp+1Ch] [rbp-BCh]
long long v12; // [rsp+24h] [rbp-B4h]
long long v13; // [rsp+2Ch] [rbp-ACh]
_QWORD v14[19]; // [rsp+40h] [rbp-98h]
v1 = &roman_num_1;
v14[13] = __readfsqword(0x28u);
roman_num_1 = 0;
v8 = 0x1F400000384LL;
v9 = 429496730000LL;
v10 = 0x320000005ALL;
v11 = 0xA00000028LL;
v12 = 0x500000009LL;
v13 = 0x100000004LL;
v14[0] = &unk_2005;
v14[1] = &unk_2004;
v14[2] = &unk_2008;
v14[3] = &unk_2007;
v14[4] = &unk_200B;
v14[5] = &unk_200A;
v14[6] = &unk_200E;
v14[7] = &unk_200D;
v14[8] = &unk_2011;
v14[9] = &unk_2010;
v14[10] = &unk_2014;
v14[11] = &unk_2013;
v14[12] = &unk_2016;
if ( a1 > 0 )
{
v2 = a1;
v3 = 1000;
v4 = 0LL;
v1 = &roman_num_1;
if ( a1 < 1000 )
goto LABEL_7;
while ( 1 )
{
v5 = v14[v4];
do
{
v2 -= v3;
v1 = (char *)__strcat_chk(v1, v5, 100LL);
}
while ( v3 <= v2 );
++v4;
if ( !v2 )
break;
while ( 1 )
{
v3 = *(int *)((char *)&v7 + v4 * 4);
if ( v3 <= v2 )
break;
LABEL_7:
++v4;
}
}
}
return v1;
} | func0:
ENDBR64
PUSH R14
LEA R8,[0x104040]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,0x1f400000384
MOV byte ptr [0x00104040],0x0
MOV qword ptr [RSP + 0x4],RAX
MOV RAX,0x6400000190
MOV qword ptr [RSP + 0xc],RAX
MOV RAX,0x320000005a
MOV qword ptr [RSP + 0x14],RAX
MOV RAX,0xa00000028
MOV qword ptr [RSP + 0x1c],RAX
MOV RAX,0x500000009
MOV qword ptr [RSP + 0x24],RAX
MOV RAX,0x100000004
MOV qword ptr [RSP + 0x2c],RAX
LEA RAX,[0x102005]
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[0x102004]
MOV qword ptr [RSP + 0x48],RAX
LEA RAX,[0x102008]
MOV qword ptr [RSP + 0x50],RAX
LEA RAX,[0x102007]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[0x10200b]
MOV qword ptr [RSP + 0x60],RAX
LEA RAX,[0x10200a]
MOV qword ptr [RSP + 0x68],RAX
LEA RAX,[0x10200e]
MOV qword ptr [RSP + 0x70],RAX
LEA RAX,[0x10200d]
MOV qword ptr [RSP + 0x78],RAX
LEA RAX,[0x102011]
MOV qword ptr [RSP + 0x80],RAX
LEA RAX,[0x102010]
MOV qword ptr [RSP + 0x88],RAX
LEA RAX,[0x102014]
MOV qword ptr [RSP + 0x90],RAX
LEA RAX,[0x102013]
MOV qword ptr [RSP + 0x98],RAX
LEA RAX,[0x102016]
MOV qword ptr [RSP + 0xa0],RAX
TEST EDI,EDI
JLE 0x001013e0
MOV EBX,EDI
MOV EBP,0x3e8
LEA R14,[RSP + 0x40]
XOR R13D,R13D
LEA R8,[0x104040]
CMP EBP,EBX
JG 0x001013d9
NOP dword ptr [RAX]
LAB_001013a8:
MOV R12,qword ptr [R14 + R13*0x2]
NOP dword ptr [RAX]
LAB_001013b0:
MOV RDI,R8
MOV EDX,0x64
MOV RSI,R12
SUB EBX,EBP
CALL 0x00101070
MOV R8,RAX
CMP EBP,EBX
JLE 0x001013b0
ADD R13,0x4
TEST EBX,EBX
JZ 0x001013e0
LAB_001013d1:
MOV EBP,dword ptr [RSP + R13*0x1]
CMP EBP,EBX
JLE 0x001013a8
LAB_001013d9:
ADD R13,0x4
JMP 0x001013d1
LAB_001013e0:
MOV RAX,qword ptr [RSP + 0xa8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101406
ADD RSP,0xb0
MOV RAX,R8
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101406:
CALL 0x00101080 | int1 * func0(int param_1)
{
int8 uVar1;
int iVar2;
int1 *puVar3;
long lVar4;
long lVar5;
long in_FS_OFFSET;
int local_d4 [15];
int *local_98 [4];
int *local_78;
int *local_70;
int *local_68;
int *local_60;
int *local_58;
int *local_50;
int *local_48;
int *local_40;
int *local_38;
long local_30;
puVar3 = roman_num_1;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
roman_num_1[0] = 0;
local_d4[0] = 900;
local_d4[1] = 500;
local_d4[2] = 400;
local_d4[3] = 100;
local_d4[4] = 0x5a;
local_d4[5] = 0x32;
local_d4[6] = 0x28;
local_d4[7] = 10;
local_d4[8] = 9;
local_d4[9] = 5;
local_d4[10] = 4;
local_d4[0xb] = 1;
local_98[0] = &DAT_00102005;
local_98[1] = &DAT_00102004;
local_98[2] = &DAT_00102008;
local_98[3] = &DAT_00102007;
local_78 = &DAT_0010200b;
local_70 = &DAT_0010200a;
local_68 = &DAT_0010200e;
local_60 = &DAT_0010200d;
local_58 = &DAT_00102011;
local_50 = &DAT_00102010;
local_48 = &DAT_00102014;
local_40 = &DAT_00102013;
local_38 = &DAT_00102016;
if (0 < param_1) {
iVar2 = 1000;
lVar4 = 0;
puVar3 = roman_num_1;
lVar5 = lVar4;
if (param_1 < 1000) goto LAB_001013d1;
while( true ) {
uVar1 = *(int8 *)((long)local_98 + lVar4 * 2);
do {
param_1 = param_1 - iVar2;
puVar3 = (int1 *)__strcat_chk(puVar3,uVar1,100);
} while (iVar2 <= param_1);
lVar5 = lVar4;
if (param_1 == 0) break;
LAB_001013d1:
do {
lVar4 = lVar5 + 4;
iVar2 = *(int *)((long)local_d4 + lVar5);
lVar5 = lVar4;
} while (param_1 < iVar2);
}
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return puVar3;
} |
7,727 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| char* func0(int num) {
static char roman_num[100];
int val[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
char* syb[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
roman_num[0] = '\0';
int i = 0;
while (num > 0) {
while (num >= val[i]) {
strcat(roman_num, syb[i]);
num -= val[i];
}
i++;
}
return roman_num;
}
| int main() {
assert(strcmp(func0(1), "I") == 0);
assert(strcmp(func0(50), "L") == 0);
assert(strcmp(func0(4), "IV") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
lea 0xda8(%rip),%rdx
lea 0xda4(%rip),%rsi
push %r14
lea 0x2dd3(%rip),%rcx
push %r13
xor %r13d,%r13d
push %r12
push %rbp
push %rbx
mov %edi,%ebx
lea 0xd92(%rip),%rdi
sub $0xb8,%rsp
movdqa 0xe32(%rip),%xmm0
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
lea 0xd5c(%rip),%rax
lea 0x40(%rsp),%r15
mov %rsp,%r14
movaps %xmm0,(%rsp)
movdqa 0xe14(%rip),%xmm0
movq %rax,%xmm1
lea 0xd3f(%rip),%rax
movq %rax,%xmm2
lea 0xd36(%rip),%rax
movl $0x1,0x30(%rsp)
movaps %xmm0,0x10(%rsp)
movdqa 0xdf7(%rip),%xmm0
movq %rax,%xmm3
lea 0xd18(%rip),%rax
movq %rax,%xmm4
lea 0xd0f(%rip),%rax
movb $0x0,0x2d38(%rip)
movaps %xmm0,0x20(%rsp)
movq %rdx,%xmm0
movq %rax,%xmm5
lea 0xced(%rip),%rdx
punpcklqdq %xmm1,%xmm0
lea 0xcea(%rip),%rax
movaps %xmm0,0x40(%rsp)
movq %rsi,%xmm0
movq %rax,%xmm6
lea 0xccf(%rip),%rsi
punpcklqdq %xmm2,%xmm0
lea 0xccc(%rip),%rax
movaps %xmm0,0x50(%rsp)
movq %rdx,%xmm0
lea 0xcb9(%rip),%rdx
punpcklqdq %xmm3,%xmm0
mov %rax,0xa0(%rsp)
movaps %xmm0,0x60(%rsp)
movq %rsi,%xmm0
punpcklqdq %xmm4,%xmm0
movaps %xmm0,0x70(%rsp)
movq %rdi,%xmm0
punpcklqdq %xmm5,%xmm0
movaps %xmm0,0x80(%rsp)
movq %rdx,%xmm0
punpcklqdq %xmm6,%xmm0
movaps %xmm0,0x90(%rsp)
test %ebx,%ebx
jle 13d1 <func0+0x181>
mov (%r14,%r13,4),%ebp
cmp %ebx,%ebp
jg 1400 <func0+0x1b0>
mov (%r15,%r13,8),%r12
nopl 0x0(%rax)
mov %rcx,%rdi
mov $0x64,%edx
mov %r12,%rsi
sub %ebp,%ebx
callq 1070 <__strcat_chk@plt>
mov %rax,%rcx
cmp %ebp,%ebx
jge 13b0 <func0+0x160>
add $0x1,%r13
test %ebx,%ebx
jne 13a0 <func0+0x150>
mov 0xa8(%rsp),%rax
xor %fs:0x28,%rax
jne 1406 <func0+0x1b6>
add $0xb8,%rsp
lea 0x2c4e(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
add $0x1,%r13
jmp 13a0 <func0+0x150>
callq 1080 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
lea rdx, unk_2005
lea rsi, unk_2008
push r14
lea rcx, roman_num_1
push r13
push r12
push rbp
push rbx
mov ebx, edi
lea rdi, unk_2011
sub rsp, 0B8h
movdqa xmm0, cs:xmmword_2090
mov rax, fs:28h
mov [rsp+0E8h+var_40], rax
xor eax, eax
lea rax, unk_2004
mov cs:roman_num_1, 0
movaps [rsp+0E8h+var_E8], xmm0
movdqa xmm0, cs:xmmword_20A0
movq xmm1, rax
lea rax, unk_2007
movq xmm2, rax
lea rax, unk_200A
mov [rsp+0E8h+var_B8], 1
movaps [rsp+0E8h+var_D8], xmm0
movdqa xmm0, cs:xmmword_20B0
movq xmm3, rax
lea rax, unk_200D
movq xmm4, rax
lea rax, unk_2010
movaps [rsp+0E8h+var_C8], xmm0
movq xmm0, rdx
movq xmm5, rax
lea rdx, unk_200B
punpcklqdq xmm0, xmm1
lea rax, unk_2013
movaps [rsp+0E8h+var_A8], xmm0
movq xmm0, rsi
movq xmm6, rax
lea rsi, unk_200E
punpcklqdq xmm0, xmm2
lea rax, unk_2016
movaps [rsp+0E8h+var_98], xmm0
movq xmm0, rdx
lea rdx, unk_2014
punpcklqdq xmm0, xmm3
mov [rsp+0E8h+var_48], rax
movaps [rsp+0E8h+var_88], xmm0
movq xmm0, rsi
punpcklqdq xmm0, xmm4
movaps [rsp+0E8h+var_78], xmm0
movq xmm0, rdi
punpcklqdq xmm0, xmm5
movaps [rsp+0E8h+var_68], xmm0
movq xmm0, rdx
punpcklqdq xmm0, xmm6
movaps [rsp+0E8h+var_58], xmm0
test ebx, ebx
jle short loc_13E1
xor r13d, r13d
lea r15, [rsp+0E8h+var_A8]
lea rcx, roman_num_1
mov r14, rsp
nop word ptr [rax+rax+00000000h]
loc_13B0:
mov ebp, [r14+r13*4]
cmp ebp, ebx
jg short loc_1410
mov r12, [r15+r13*8]
nop dword ptr [rax+00h]
loc_13C0:
mov rdi, rcx
mov edx, 64h ; 'd'
mov rsi, r12
sub ebx, ebp
call ___strcat_chk
mov rcx, rax
cmp ebx, ebp
jge short loc_13C0
add r13, 1
test ebx, ebx
jnz short loc_13B0
loc_13E1:
mov rax, [rsp+0E8h+var_40]
sub rax, fs:28h
jnz short loc_1416
add rsp, 0B8h
mov rax, rcx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1410:
add r13, 1
jmp short loc_13B0
loc_1416:
call ___stack_chk_fail | char * func0(int a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
char *v6; // rcx
int v7; // ebx
long long v8; // r13
__int32 v9; // ebp
long long v10; // r12
__m128i si128; // [rsp+0h] [rbp-E8h]
__m128i v13; // [rsp+10h] [rbp-D8h]
__m128i v14; // [rsp+20h] [rbp-C8h]
int v15; // [rsp+30h] [rbp-B8h]
_OWORD v16[6]; // [rsp+40h] [rbp-A8h]
void *v17; // [rsp+A0h] [rbp-48h]
unsigned long long v18; // [rsp+A8h] [rbp-40h]
v6 = &roman_num_1;
v7 = a1;
v18 = __readfsqword(0x28u);
roman_num_1 = 0;
si128 = _mm_load_si128((const __m128i *)&xmmword_2090);
v15 = 1;
v13 = _mm_load_si128((const __m128i *)&xmmword_20A0);
v14 = _mm_load_si128((const __m128i *)&xmmword_20B0);
v16[0] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_2005, (__m128i)(unsigned long long)&unk_2004);
v16[1] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_2008, (__m128i)(unsigned long long)&unk_2007);
v17 = &unk_2016;
v16[2] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_200B, (__m128i)(unsigned long long)&unk_200A);
v16[3] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_200E, (__m128i)(unsigned long long)&unk_200D);
v16[4] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_2011, (__m128i)(unsigned long long)&unk_2010);
v16[5] = _mm_unpacklo_epi64((__m128i)(unsigned long long)&unk_2014, (__m128i)(unsigned long long)&unk_2013);
if ( a1 > 0 )
{
v8 = 0LL;
v6 = &roman_num_1;
do
{
while ( 1 )
{
v9 = si128.m128i_i32[v8];
if ( v9 <= v7 )
break;
++v8;
}
v10 = *((_QWORD *)v16 + v8);
do
{
v7 -= v9;
v6 = (char *)__strcat_chk(
v6,
v10,
100LL,
v6,
a5,
a6,
si128.m128i_i64[0],
si128.m128i_i64[1],
v13.m128i_i64[0],
v13.m128i_i64[1],
v14.m128i_i64[0],
v14.m128i_i64[1],
v15);
}
while ( v7 >= v9 );
++v8;
}
while ( v7 );
}
return v6;
} | func0:
ENDBR64
PUSH R15
LEA RDX,[0x102005]
LEA RSI,[0x102008]
PUSH R14
LEA RCX,[0x104040]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
LEA RDI,[0x102011]
SUB RSP,0xb8
MOVDQA XMM0,xmmword ptr [0x00102090]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
LEA RAX,[0x102004]
MOV byte ptr [0x00104040],0x0
MOVAPS xmmword ptr [RSP],XMM0
MOVDQA XMM0,xmmword ptr [0x001020a0]
MOVQ XMM1,RAX
LEA RAX,[0x102007]
MOVQ XMM2,RAX
LEA RAX,[0x10200a]
MOV dword ptr [RSP + 0x30],0x1
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVDQA XMM0,xmmword ptr [0x001020b0]
MOVQ XMM3,RAX
LEA RAX,[0x10200d]
MOVQ XMM4,RAX
LEA RAX,[0x102010]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVQ XMM0,RDX
MOVQ XMM5,RAX
LEA RDX,[0x10200b]
PUNPCKLQDQ XMM0,XMM1
LEA RAX,[0x102013]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVQ XMM0,RSI
MOVQ XMM6,RAX
LEA RSI,[0x10200e]
PUNPCKLQDQ XMM0,XMM2
LEA RAX,[0x102016]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVQ XMM0,RDX
LEA RDX,[0x102014]
PUNPCKLQDQ XMM0,XMM3
MOV qword ptr [RSP + 0xa0],RAX
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVQ XMM0,RSI
PUNPCKLQDQ XMM0,XMM4
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVQ XMM0,RDI
PUNPCKLQDQ XMM0,XMM5
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVQ XMM0,RDX
PUNPCKLQDQ XMM0,XMM6
MOVAPS xmmword ptr [RSP + 0x90],XMM0
TEST EBX,EBX
JLE 0x001013e1
XOR R13D,R13D
LEA R15,[RSP + 0x40]
LEA RCX,[0x104040]
MOV R14,RSP
NOP word ptr [RAX + RAX*0x1]
LAB_001013b0:
MOV EBP,dword ptr [R14 + R13*0x4]
CMP EBP,EBX
JG 0x00101410
MOV R12,qword ptr [R15 + R13*0x8]
NOP dword ptr [RAX]
LAB_001013c0:
MOV RDI,RCX
MOV EDX,0x64
MOV RSI,R12
SUB EBX,EBP
CALL 0x00101070
MOV RCX,RAX
CMP EBX,EBP
JGE 0x001013c0
ADD R13,0x1
TEST EBX,EBX
JNZ 0x001013b0
LAB_001013e1:
MOV RAX,qword ptr [RSP + 0xa8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101416
ADD RSP,0xb8
MOV RAX,RCX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101410:
ADD R13,0x1
JMP 0x001013b0
LAB_00101416:
CALL 0x00101080 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int1 * func0(int param_1)
{
int iVar1;
int *puVar2;
int1 *puVar3;
long lVar4;
long in_FS_OFFSET;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
int4 local_b8;
int *local_a8 [4];
int *local_88;
int *puStack_80;
int *local_78;
int *puStack_70;
int *local_68;
int *puStack_60;
int *local_58;
int *puStack_50;
int *local_48;
long local_40;
puVar3 = roman_num_1;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
roman_num_1[0] = 0;
local_e8 = _DAT_00102090;
uStack_e0 = _UNK_00102098;
local_b8 = 1;
local_d8 = _DAT_001020a0;
uStack_d0 = _UNK_001020a8;
local_c8 = _DAT_001020b0;
uStack_c0 = _UNK_001020b8;
local_a8[0] = &DAT_00102005;
local_a8[1] = &DAT_00102004;
local_a8[2] = &DAT_00102008;
local_a8[3] = &DAT_00102007;
local_48 = &DAT_00102016;
local_88 = &DAT_0010200b;
puStack_80 = &DAT_0010200a;
local_78 = &DAT_0010200e;
puStack_70 = &DAT_0010200d;
local_68 = &DAT_00102011;
puStack_60 = &DAT_00102010;
local_58 = &DAT_00102014;
puStack_50 = &DAT_00102013;
if (0 < param_1) {
lVar4 = 0;
puVar3 = roman_num_1;
do {
for (; iVar1 = *(int *)((long)&local_e8 + lVar4 * 4), param_1 < iVar1; lVar4 = lVar4 + 1) {
}
puVar2 = local_a8[lVar4];
do {
param_1 = param_1 - iVar1;
puVar3 = (int1 *)__strcat_chk(puVar3,puVar2,100);
} while (iVar1 <= param_1);
lVar4 = lVar4 + 1;
} while (param_1 != 0);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,728 | func0 |
#include <stdio.h>
#include <assert.h>
| double func0(int lst[], int len) {
int sum = 0;
for (int i = 0; i < len; i++) {
sum += lst[i];
}
return (double)sum / len;
}
| int main() {
int a[] = {15, 9, 55, 41, 35, 20, 62, 49};
int b[] = {4, 5, 1, 2, 9, 7, 10, 8};
int c[] = {1, 2, 3};
assert(func0(a, 8) == 35.75);
assert(func0(b, 8) == 5.75);
assert(func0(c, 3) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a5 <func0+0x3c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
cvtsi2sdl -0x8(%rbp),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd %xmm1,%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11A5
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_11A5:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_8]
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_1C]
divsd xmm0, xmm1
pop rbp
retn | double func0(long long a1, int a2)
{
int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 += *(_DWORD *)(4LL * i + a1);
return (double)v3 / (double)a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a5
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a5:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x8]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x1c]
DIVSD XMM0,XMM1
POP RBP
RET | double func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
return (double)local_10 / (double)param_2;
} |
7,729 | func0 |
#include <stdio.h>
#include <assert.h>
| double func0(int lst[], int len) {
int sum = 0;
for (int i = 0; i < len; i++) {
sum += lst[i];
}
return (double)sum / len;
}
| int main() {
int a[] = {15, 9, 55, 41, 35, 20, 62, 49};
int b[] = {4, 5, 1, 2, 9, 7, 10, 8};
int c[] = {1, 2, 3};
assert(func0(a, 8) == 35.75);
assert(func0(b, 8) == 5.75);
assert(func0(c, 3) == 2);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11a1 <func0+0x38>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1181 <func0+0x18>
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
mov $0x0,%edx
jmp 118c <func0+0x23>
| func0:
endbr64
test esi, esi
jle short loc_11A1
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_1181:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1181
loc_118C:
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
retn
loc_11A1:
mov edx, 0
jmp short loc_118C | double func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
int v3; // edx
if ( a2 <= 0 )
{
v3 = 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 += *v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return (double)v3 / (double)a2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a1
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_00101181:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101181
LAB_0010118c:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
RET
LAB_001011a1:
MOV EDX,0x0
JMP 0x0010118c | double func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return (double)iVar2 / (double)param_2;
} |
7,730 | func0 |
#include <stdio.h>
#include <assert.h>
| double func0(int lst[], int len) {
int sum = 0;
for (int i = 0; i < len; i++) {
sum += lst[i];
}
return (double)sum / len;
}
| int main() {
int a[] = {15, 9, 55, 41, 35, 20, 62, 49};
int b[] = {4, 5, 1, 2, 9, 7, 10, 8};
int c[] = {1, 2, 3};
assert(func0(a, 8) == 35.75);
assert(func0(b, 8) == 5.75);
assert(func0(c, 3) == 2);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1320 <func0+0x40>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
add (%rdi),%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 12f8 <func0+0x18>
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm0
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
nopl 0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1310
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_12E8:
add eax, [rdi]
add rdi, 4
cmp rdi, rdx
jnz short loc_12E8
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, eax
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
retn
loc_1310:
pxor xmm1, xmm1
pxor xmm0, xmm0
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
retn | double func0(_DWORD *a1, int a2)
{
long long v2; // rdx
int v3; // eax
if ( a2 <= 0 )
return 0.0 / (double)a2;
v2 = (long long)&a1[a2 - 1 + 1];
v3 = 0;
do
v3 += *a1++;
while ( a1 != (_DWORD *)v2 );
return (double)v3 / (double)a2;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101310
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_001012e8:
ADD EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x001012e8
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EAX
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
RET
LAB_00101310:
PXOR XMM1,XMM1
PXOR XMM0,XMM0
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
RET | double func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return (double)iVar2 / (double)param_2;
}
return 0.0 / (double)param_2;
} |
7,731 | func0 |
#include <stdio.h>
#include <assert.h>
| double func0(int lst[], int len) {
int sum = 0;
for (int i = 0; i < len; i++) {
sum += lst[i];
}
return (double)sum / len;
}
| int main() {
int a[] = {15, 9, 55, 41, 35, 20, 62, 49};
int b[] = {4, 5, 1, 2, 9, 7, 10, 8};
int c[] = {1, 2, 3};
assert(func0(a, 8) == 35.75);
assert(func0(b, 8) == 5.75);
assert(func0(c, 3) == 2);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 11f0 <func0+0xb0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 1201 <func0+0xc1>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm0,%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rdx,%rax
jne 1170 <func0+0x30>
movdqa %xmm0,%xmm1
mov %esi,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
test $0x3,%sil
je 11d7 <func0+0x97>
movslq %edx,%rcx
add (%rdi,%rcx,4),%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 11d7 <func0+0x97>
movslq %ecx,%rcx
add (%rdi,%rcx,4),%eax
lea 0x2(%rdx),%ecx
cmp %ecx,%esi
jle 11d7 <func0+0x97>
movslq %ecx,%rcx
add $0x3,%edx
add (%rdi,%rcx,4),%eax
cmp %edx,%esi
jle 11d7 <func0+0x97>
movslq %edx,%rdx
add (%rdi,%rdx,4),%eax
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm0
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
nopl 0x0(%rax)
pxor %xmm1,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
xor %edx,%edx
xor %eax,%eax
jmp 11aa <func0+0x6a>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov rcx, rdi
test esi, esi
jle loc_11E8
lea eax, [rsi-1]
cmp eax, 2
jbe loc_11F9
mov edx, esi
mov rax, rdi
pxor xmm0, xmm0
shr edx, 2
shl rdx, 4
add rdx, rdi
xchg ax, ax
loc_1170:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
cmp rax, rdx
jnz short loc_1170
movdqa xmm1, xmm0
mov edx, esi
psrldq xmm1, 8
and edx, 0FFFFFFFCh
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test sil, 3
jz short loc_11D0
loc_11AA:
movsxd rdi, edx
lea r8, ds:0[rdi*4]
add eax, [rcx+rdi*4]
lea edi, [rdx+1]
cmp esi, edi
jle short loc_11D0
add edx, 2
add eax, [rcx+r8+4]
cmp esi, edx
jle short loc_11D0
add eax, [rcx+r8+8]
loc_11D0:
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, eax
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
retn
loc_11E8:
pxor xmm1, xmm1
pxor xmm0, xmm0
cvtsi2sd xmm1, esi
divsd xmm0, xmm1
retn
loc_11F9:
xor edx, edx
xor eax, eax
jmp short loc_11AA | double func0(const __m128i *a1, int a2)
{
const __m128i *v2; // rax
__m128i v3; // xmm0
__m128i v4; // xmm2
int v5; // edx
__m128i v6; // xmm0
int v7; // eax
long long v8; // r8
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) <= 2 )
{
v5 = 0;
v7 = 0;
}
else
{
v2 = a1;
v3 = 0LL;
do
{
v4 = _mm_loadu_si128(v2++);
v3 = _mm_add_epi32(v3, v4);
}
while ( v2 != &a1[(unsigned int)a2 >> 2] );
v5 = a2 & 0x7FFFFFFC;
v6 = _mm_add_epi32(v3, _mm_srli_si128(v3, 8));
v7 = _mm_cvtsi128_si32(_mm_add_epi32(v6, _mm_srli_si128(v6, 4)));
if ( (a2 & 3) == 0 )
return (double)v7 / (double)a2;
}
v8 = v5;
v7 += a1->m128i_i32[v8];
if ( a2 > v5 + 1 )
{
v7 += a1->m128i_i32[v8 + 1];
if ( a2 > v5 + 2 )
v7 += a1->m128i_i32[v8 + 2];
}
return (double)v7 / (double)a2;
}
return 0.0 / (double)a2;
} | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x001011e8
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001011f9
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM0,XMM0
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP
LAB_00101170:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
CMP RAX,RDX
JNZ 0x00101170
MOVDQA XMM1,XMM0
MOV EDX,ESI
PSRLDQ XMM1,0x8
AND EDX,0xfffffffc
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST SIL,0x3
JZ 0x001011d0
LAB_001011aa:
MOVSXD RDI,EDX
LEA R8,[RDI*0x4]
ADD EAX,dword ptr [RCX + RDI*0x4]
LEA EDI,[RDX + 0x1]
CMP ESI,EDI
JLE 0x001011d0
ADD EDX,0x2
ADD EAX,dword ptr [RCX + R8*0x1 + 0x4]
CMP ESI,EDX
JLE 0x001011d0
ADD EAX,dword ptr [RCX + R8*0x1 + 0x8]
LAB_001011d0:
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EAX
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
RET
LAB_001011e8:
PXOR XMM1,XMM1
PXOR XMM0,XMM0
CVTSI2SD XMM1,ESI
DIVSD XMM0,XMM1
RET
LAB_001011f9:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011aa | double func0(int *param_1,uint param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
if ((int)param_2 < 1) {
return 0.0 / (double)(int)param_2;
}
if (param_2 - 1 < 3) {
uVar6 = 0;
iVar7 = 0;
}
else {
iVar7 = 0;
iVar8 = 0;
iVar9 = 0;
iVar10 = 0;
piVar5 = param_1;
do {
iVar1 = *piVar5;
piVar2 = piVar5 + 1;
piVar3 = piVar5 + 2;
piVar4 = piVar5 + 3;
piVar5 = piVar5 + 4;
iVar7 = iVar7 + iVar1;
iVar8 = iVar8 + *piVar2;
iVar9 = iVar9 + *piVar3;
iVar10 = iVar10 + *piVar4;
} while (piVar5 != param_1 + (ulong)(param_2 >> 2) * 4);
uVar6 = param_2 & 0xfffffffc;
iVar7 = iVar7 + iVar9 + iVar8 + iVar10;
if ((param_2 & 3) == 0) goto LAB_001011d0;
}
iVar7 = iVar7 + param_1[(int)uVar6];
if (((int)(uVar6 + 1) < (int)param_2) &&
(iVar7 = iVar7 + param_1[(long)(int)uVar6 + 1], (int)(uVar6 + 2) < (int)param_2)) {
iVar7 = iVar7 + param_1[(long)(int)uVar6 + 2];
}
LAB_001011d0:
return (double)iVar7 / (double)(int)param_2;
} |
7,732 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 0)
return 0;
if (n == 1)
return 1;
return func0(n - 1) + func0(n - 2);
}
| int main() {
assert(func0(4) == 3);
assert(func0(3) == 2);
assert(func0(5) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jne 1166 <func0+0x1d>
mov $0x0,%eax
jmp 1191 <func0+0x48>
cmpl $0x1,-0x14(%rbp)
jne 1173 <func0+0x2a>
mov $0x1,%eax
jmp 1191 <func0+0x48>
mov -0x14(%rbp),%eax
sub $0x1,%eax
mov %eax,%edi
callq 1149 <func0>
mov %eax,%ebx
mov -0x14(%rbp),%eax
sub $0x2,%eax
mov %eax,%edi
callq 1149 <func0>
add %ebx,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jnz short loc_1166
mov eax, 0
jmp short loc_1191
loc_1166:
cmp [rbp+var_14], 1
jnz short loc_1173
mov eax, 1
jmp short loc_1191
loc_1173:
mov eax, [rbp+var_14]
sub eax, 1
mov edi, eax
call func0
mov ebx, eax
mov eax, [rbp+var_14]
sub eax, 2
mov edi, eax
call func0
add eax, ebx
loc_1191:
mov rbx, [rbp+var_8]
leave
retn | long long func0(int a1)
{
int v2; // ebx
if ( !a1 )
return 0LL;
if ( a1 == 1 )
return 1LL;
v2 = func0((unsigned int)(a1 - 1));
return v2 + (unsigned int)func0((unsigned int)(a1 - 2));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00101166
MOV EAX,0x0
JMP 0x00101191
LAB_00101166:
CMP dword ptr [RBP + -0x14],0x1
JNZ 0x00101173
MOV EAX,0x1
JMP 0x00101191
LAB_00101173:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
MOV EDI,EAX
CALL 0x00101149
MOV EBX,EAX
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x2
MOV EDI,EAX
CALL 0x00101149
ADD EAX,EBX
LAB_00101191:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 == 0) {
iVar2 = 0;
}
else if (param_1 == 1) {
iVar2 = 1;
}
else {
iVar1 = func0(param_1 + -1);
iVar2 = func0(param_1 + -2);
iVar2 = iVar2 + iVar1;
}
return iVar2;
} |
7,733 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 0)
return 0;
if (n == 1)
return 1;
return func0(n - 1) + func0(n - 2);
}
| int main() {
assert(func0(4) == 3);
assert(func0(3) == 2);
assert(func0(5) == 5);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebx
test %edi,%edi
je 1174 <func0+0x2b>
cmp $0x1,%edi
je 1174 <func0+0x2b>
lea -0x1(%rdi),%edi
callq 1149 <func0>
mov %eax,%ebp
lea -0x2(%rbx),%edi
callq 1149 <func0>
lea 0x0(%rbp,%rax,1),%ebx
mov %ebx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov ebx, edi
test edi, edi
jz short loc_1174
cmp edi, 1
jz short loc_1174
lea edi, [rdi-1]
call func0
mov ebp, eax
lea edi, [rbx-2]
call func0
lea ebx, [rbp+rax+0]
loc_1174:
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
retn | long long func0(unsigned int a1)
{
unsigned int v1; // ebx
int v2; // ebp
v1 = a1;
if ( a1 >= 2 )
{
v2 = func0(a1 - 1);
return v2 + (unsigned int)func0(a1 - 2);
}
return v1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
TEST EDI,EDI
JZ 0x00101174
CMP EDI,0x1
JZ 0x00101174
LEA EDI,[RDI + -0x1]
CALL 0x00101149
MOV EBP,EAX
LEA EDI,[RBX + -0x2]
CALL 0x00101149
LEA EBX,[RBP + RAX*0x1]
LAB_00101174:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET | int func0(int param_1)
{
int iVar1;
if ((param_1 != 0) && (param_1 != 1)) {
iVar1 = func0(param_1 + -1);
param_1 = func0(param_1 + -2);
param_1 = iVar1 + param_1;
}
return param_1;
} |
7,734 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 0)
return 0;
if (n == 1)
return 1;
return func0(n - 1) + func0(n - 2);
}
| int main() {
assert(func0(4) == 3);
assert(func0(3) == 2);
assert(func0(5) == 5);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbx
sub $0x8,%rsp
test %edi,%edi
je 1230 <func0+0x40>
mov %edi,%ebx
cmp $0x1,%edi
je 1240 <func0+0x50>
xor %r12d,%r12d
lea -0x1(%rbx),%edi
callq 11f0 <func0>
add %eax,%r12d
sub $0x2,%ebx
je 1222 <func0+0x32>
cmp $0x1,%ebx
jne 1209 <func0+0x19>
add $0x1,%r12d
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %r12
retq
nopl (%rax)
xor %r12d,%r12d
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %r12
retq
xchg %ax,%ax
mov $0x1,%r12d
jmp 1222 <func0+0x32>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov r10d, edi
test edi, edi
jz loc_1512
cmp edi, 1
jz loc_1512
push r15
lea eax, [rdi-2]
xor r10d, r10d
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_60], eax
mov [rsp+68h+var_58], r10d
loc_1225:
mov edi, [rsp+68h+var_60]
mov eax, edi
add eax, 1
jz loc_1508
cmp eax, 1
jz loc_14ED
lea eax, [rdi-1]
xor r8d, r8d
mov [rsp+68h+var_64], eax
mov [rsp+68h+var_54], r8d
loc_124C:
mov edi, [rsp+68h+var_64]
mov eax, edi
add eax, 1
jz loc_14C6
cmp eax, 1
jz loc_14D0
lea eax, [rdi-1]
xor ecx, ecx
mov [rsp+68h+var_5C], eax
mov [rsp+68h+var_50], ecx
loc_1271:
mov edi, [rsp+68h+var_5C]
mov eax, edi
add eax, 1
jz loc_14A2
cmp eax, 1
jz loc_14AC
xor ecx, ecx
lea r8d, [rdi-1]
mov [rsp+68h+var_4C], ecx
mov ecx, r8d
loc_1296:
mov eax, ecx
add eax, 1
jz loc_13D5
cmp eax, 1
jz loc_1488
xor esi, esi
mov [rsp+68h+var_48], ecx
lea r9d, [rcx-1]
mov [rsp+68h+var_68], esi
mov r15d, r9d
loc_12BA:
mov eax, r15d
add eax, 1
jz loc_1407
cmp eax, 1
jz loc_1443
lea r12d, [r15-1]
xor ecx, ecx
mov esi, r15d
loc_12D8:
mov eax, r12d
add eax, 1
jz loc_1410
cmp eax, 1
jz loc_13EB
xor ebx, ebx
lea ebp, [r12-1]
mov edx, r12d
mov r12d, ebx
loc_12FA:
mov eax, ebp
add eax, 1
jz loc_13DD
cmp eax, 1
jz loc_139A
mov eax, ebp
lea ebx, [rbp-1]
xor r14d, r14d
mov ebp, ecx
mov ecx, eax
loc_131A:
mov r13d, ebx
add r13d, 1
jz loc_1480
cmp r13d, 1
jz short loc_1380
mov [rsp+68h+var_44], ebx
xor r15d, r15d
mov ebx, esi
loc_1336:
lea edi, [r13-1]
mov [rsp+68h+var_3C], ecx
mov [rsp+68h+var_40], edx
call func0
mov edx, [rsp+68h+var_40]
mov ecx, [rsp+68h+var_3C]
add r15d, eax
sub r13d, 2
jz loc_1438
cmp r13d, 1
jnz short loc_1336
mov esi, ebx
mov ebx, [rsp+68h+var_44]
add r15d, 1
loc_136C:
add r14d, r15d
test ebx, ebx
jz loc_1419
cmp ebx, 1
jnz loc_1480
loc_1380:
mov eax, ecx
add r14d, 1
mov ecx, ebp
mov ebp, eax
add r12d, r14d
test ebp, ebp
jz loc_142A
loc_1395:
cmp ebp, 1
jnz short loc_13DD
loc_139A:
mov ebx, r12d
mov r12d, edx
add ebx, 1
loc_13A3:
add ecx, ebx
test r12d, r12d
jnz short loc_13E5
mov r15d, esi
mov r14d, ecx
add [rsp+68h+var_68], r14d
mov esi, [rsp+68h+var_68]
test r15d, r15d
jnz short loc_1401
loc_13BC:
mov ecx, [rsp+68h+var_48]
add [rsp+68h+var_4C], esi
test ecx, ecx
jz loc_1459
loc_13CC:
cmp ecx, 1
jz loc_1488
loc_13D5:
sub ecx, 2
jmp loc_1296
loc_13DD:
sub ebp, 2
jmp loc_12FA
loc_13E5:
cmp r12d, 1
jnz short loc_1410
loc_13EB:
mov r14d, ecx
mov r15d, esi
add r14d, 1
add [rsp+68h+var_68], r14d
mov esi, [rsp+68h+var_68]
test r15d, r15d
jz short loc_13BC
loc_1401:
cmp r15d, 1
jz short loc_1443
loc_1407:
sub r15d, 2
jmp loc_12BA
loc_1410:
sub r12d, 2
jmp loc_12D8
loc_1419:
mov eax, ecx
mov ecx, ebp
add r12d, r14d
mov ebp, eax
test ebp, ebp
jnz loc_1395
loc_142A:
mov ebx, r12d
mov r12d, edx
jmp loc_13A3
loc_1438:
mov esi, ebx
mov ebx, [rsp+68h+var_44]
jmp loc_136C
loc_1443:
mov esi, [rsp+68h+var_68]
mov ecx, [rsp+68h+var_48]
add esi, 1
add [rsp+68h+var_4C], esi
test ecx, ecx
jnz loc_13CC
loc_1459:
mov ecx, [rsp+68h+var_4C]
add [rsp+68h+var_50], ecx
mov ecx, [rsp+68h+var_5C]
test ecx, ecx
jnz short loc_149B
loc_1469:
mov edx, [rsp+68h+var_64]
mov ecx, [rsp+68h+var_50]
add [rsp+68h+var_54], ecx
test edx, edx
jnz short loc_14BF
loc_1479:
mov r8d, [rsp+68h+var_54]
jmp short loc_14D9
loc_1480:
sub ebx, 2
jmp loc_131A
loc_1488:
mov ecx, [rsp+68h+var_4C]
add ecx, 1
add [rsp+68h+var_50], ecx
mov ecx, [rsp+68h+var_5C]
test ecx, ecx
jz short loc_1469
loc_149B:
cmp [rsp+68h+var_5C], 1
jz short loc_14AC
loc_14A2:
sub [rsp+68h+var_5C], 2
jmp loc_1271
loc_14AC:
mov ecx, [rsp+68h+var_50]
mov edx, [rsp+68h+var_64]
add ecx, 1
add [rsp+68h+var_54], ecx
test edx, edx
jz short loc_1479
loc_14BF:
cmp [rsp+68h+var_64], 1
jz short loc_14D0
loc_14C6:
sub [rsp+68h+var_64], 2
jmp loc_124C
loc_14D0:
mov r8d, [rsp+68h+var_54]
add r8d, 1
loc_14D9:
mov eax, [rsp+68h+var_60]
add [rsp+68h+var_58], r8d
test eax, eax
jz short loc_1516
cmp [rsp+68h+var_60], 1
jnz short loc_1508
loc_14ED:
mov r10d, [rsp+68h+var_58]
add r10d, 1
loc_14F6:
add rsp, 38h
mov eax, r10d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1508:
sub [rsp+68h+var_60], 2
jmp loc_1225
loc_1512:
mov eax, r10d
retn
loc_1516:
mov r10d, [rsp+68h+var_58]
jmp short loc_14F6 | long long func0(unsigned int a1)
{
unsigned int i; // ecx
unsigned int j; // r15d
unsigned int v3; // r12d
int v4; // ecx
unsigned int v5; // esi
unsigned int v6; // ebp
unsigned int v7; // edx
int v8; // r12d
unsigned int v9; // eax
unsigned int v10; // ebx
int v11; // r14d
int v12; // ebp
unsigned int v13; // ecx
unsigned int v14; // r13d
int v15; // r15d
int v16; // eax
unsigned int v17; // eax
int v18; // ebx
int v20; // [rsp+0h] [rbp-68h]
unsigned int v21; // [rsp+4h] [rbp-64h]
unsigned int v22; // [rsp+8h] [rbp-60h]
unsigned int v23; // [rsp+Ch] [rbp-5Ch]
int v24; // [rsp+10h] [rbp-58h]
int v25; // [rsp+14h] [rbp-54h]
int v26; // [rsp+18h] [rbp-50h]
int v27; // [rsp+1Ch] [rbp-4Ch]
unsigned int v28; // [rsp+20h] [rbp-48h]
unsigned int v29; // [rsp+28h] [rbp-40h]
unsigned int v30; // [rsp+2Ch] [rbp-3Ch]
if ( a1 < 2 )
return a1;
v22 = a1 - 2;
v24 = 0;
while ( 1 )
{
if ( v22 != -1 )
{
if ( !v22 )
break;
v21 = v22 - 1;
v25 = 0;
while ( 1 )
{
if ( v21 != -1 )
{
if ( !v21 )
break;
v23 = v21 - 1;
v26 = 0;
while ( 1 )
{
if ( v23 != -1 )
{
if ( !v23 )
break;
v27 = 0;
for ( i = v23 - 1; ; i -= 2 )
{
if ( i != -1 )
{
if ( !i )
break;
v28 = i;
v20 = 0;
for ( j = i - 1; ; j -= 2 )
{
if ( j != -1 )
{
if ( !j )
break;
v3 = j - 1;
v4 = 0;
v5 = j;
while ( 1 )
{
if ( v3 != -1 )
{
if ( !v3 )
break;
v6 = v3 - 1;
v7 = v3;
v8 = 0;
while ( 1 )
{
if ( v6 != -1 )
{
if ( !v6 )
break;
v9 = v6;
v10 = v6 - 1;
v11 = 0;
v12 = v4;
v13 = v9;
while ( 1 )
{
v14 = v10 + 1;
if ( v10 != -1 )
{
if ( !v10 )
break;
v15 = 0;
while ( 1 )
{
v30 = v13;
v29 = v7;
v16 = func0((unsigned int)(v14 - 1));
v7 = v29;
v13 = v30;
v15 += v16;
v14 -= 2;
if ( !v14 )
break;
if ( v14 == 1 )
{
++v15;
break;
}
}
v11 += v15;
if ( v10 == 1 )
break;
}
v10 -= 2;
}
v17 = v13;
v4 = v12;
v6 = v17;
v8 += v11 + 1;
if ( v17 == 1 )
break;
}
v6 -= 2;
}
v18 = v8;
v3 = v7;
v4 += v18 + 1;
if ( v7 == 1 )
break;
}
v3 -= 2;
}
j = v5;
v20 += v4 + 1;
if ( v5 == 1 )
break;
}
}
i = v28;
v27 += v20 + 1;
if ( v28 == 1 )
break;
}
}
v26 += v27 + 1;
if ( v23 == 1 )
break;
}
v23 -= 2;
}
v25 += v26 + 1;
if ( v21 == 1 )
break;
}
v21 -= 2;
}
v24 += v25 + 1;
if ( v22 == 1 )
break;
}
v22 -= 2;
}
return (unsigned int)(v24 + 1);
} | func0:
ENDBR64
MOV R10D,EDI
TEST EDI,EDI
JZ 0x00101512
CMP EDI,0x1
JZ 0x00101512
PUSH R15
LEA EAX,[RDI + -0x2]
XOR R10D,R10D
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RSP + 0x8],EAX
MOV dword ptr [RSP + 0x10],R10D
LAB_00101225:
MOV EDI,dword ptr [RSP + 0x8]
MOV EAX,EDI
ADD EAX,0x1
JZ 0x00101508
CMP EAX,0x1
JZ 0x001014ed
LEA EAX,[RDI + -0x1]
XOR R8D,R8D
MOV dword ptr [RSP + 0x4],EAX
MOV dword ptr [RSP + 0x14],R8D
LAB_0010124c:
MOV EDI,dword ptr [RSP + 0x4]
MOV EAX,EDI
ADD EAX,0x1
JZ 0x001014c6
CMP EAX,0x1
JZ 0x001014d0
LEA EAX,[RDI + -0x1]
XOR ECX,ECX
MOV dword ptr [RSP + 0xc],EAX
MOV dword ptr [RSP + 0x18],ECX
LAB_00101271:
MOV EDI,dword ptr [RSP + 0xc]
MOV EAX,EDI
ADD EAX,0x1
JZ 0x001014a2
CMP EAX,0x1
JZ 0x001014ac
XOR ECX,ECX
LEA R8D,[RDI + -0x1]
MOV dword ptr [RSP + 0x1c],ECX
MOV ECX,R8D
LAB_00101296:
MOV EAX,ECX
ADD EAX,0x1
JZ 0x001013d5
CMP EAX,0x1
JZ 0x00101488
XOR ESI,ESI
MOV dword ptr [RSP + 0x20],ECX
LEA R9D,[RCX + -0x1]
MOV dword ptr [RSP],ESI
MOV R15D,R9D
LAB_001012ba:
MOV EAX,R15D
ADD EAX,0x1
JZ 0x00101407
CMP EAX,0x1
JZ 0x00101443
LEA R12D,[R15 + -0x1]
XOR ECX,ECX
MOV ESI,R15D
LAB_001012d8:
MOV EAX,R12D
ADD EAX,0x1
JZ 0x00101410
CMP EAX,0x1
JZ 0x001013eb
XOR EBX,EBX
LEA EBP,[R12 + -0x1]
MOV EDX,R12D
MOV R12D,EBX
LAB_001012fa:
MOV EAX,EBP
ADD EAX,0x1
JZ 0x001013dd
CMP EAX,0x1
JZ 0x0010139a
MOV EAX,EBP
LEA EBX,[RBP + -0x1]
XOR R14D,R14D
MOV EBP,ECX
MOV ECX,EAX
LAB_0010131a:
MOV R13D,EBX
ADD R13D,0x1
JZ 0x00101480
CMP R13D,0x1
JZ 0x00101380
MOV dword ptr [RSP + 0x24],EBX
XOR R15D,R15D
MOV EBX,ESI
LAB_00101336:
LEA EDI,[R13 + -0x1]
MOV dword ptr [RSP + 0x2c],ECX
MOV dword ptr [RSP + 0x28],EDX
CALL 0x001011f0
MOV EDX,dword ptr [RSP + 0x28]
MOV ECX,dword ptr [RSP + 0x2c]
ADD R15D,EAX
SUB R13D,0x2
JZ 0x00101438
CMP R13D,0x1
JNZ 0x00101336
MOV ESI,EBX
MOV EBX,dword ptr [RSP + 0x24]
ADD R15D,0x1
LAB_0010136c:
ADD R14D,R15D
TEST EBX,EBX
JZ 0x00101419
CMP EBX,0x1
JNZ 0x00101480
LAB_00101380:
MOV EAX,ECX
ADD R14D,0x1
MOV ECX,EBP
MOV EBP,EAX
ADD R12D,R14D
TEST EBP,EBP
JZ 0x0010142a
LAB_00101395:
CMP EBP,0x1
JNZ 0x001013dd
LAB_0010139a:
MOV EBX,R12D
MOV R12D,EDX
ADD EBX,0x1
LAB_001013a3:
ADD ECX,EBX
TEST R12D,R12D
JNZ 0x001013e5
MOV R15D,ESI
MOV R14D,ECX
ADD dword ptr [RSP],R14D
MOV ESI,dword ptr [RSP]
TEST R15D,R15D
JNZ 0x00101401
LAB_001013bc:
MOV ECX,dword ptr [RSP + 0x20]
ADD dword ptr [RSP + 0x1c],ESI
TEST ECX,ECX
JZ 0x00101459
LAB_001013cc:
CMP ECX,0x1
JZ 0x00101488
LAB_001013d5:
SUB ECX,0x2
JMP 0x00101296
LAB_001013dd:
SUB EBP,0x2
JMP 0x001012fa
LAB_001013e5:
CMP R12D,0x1
JNZ 0x00101410
LAB_001013eb:
MOV R14D,ECX
MOV R15D,ESI
ADD R14D,0x1
ADD dword ptr [RSP],R14D
MOV ESI,dword ptr [RSP]
TEST R15D,R15D
JZ 0x001013bc
LAB_00101401:
CMP R15D,0x1
JZ 0x00101443
LAB_00101407:
SUB R15D,0x2
JMP 0x001012ba
LAB_00101410:
SUB R12D,0x2
JMP 0x001012d8
LAB_00101419:
MOV EAX,ECX
MOV ECX,EBP
ADD R12D,R14D
MOV EBP,EAX
TEST EBP,EBP
JNZ 0x00101395
LAB_0010142a:
MOV EBX,R12D
MOV R12D,EDX
JMP 0x001013a3
LAB_00101438:
MOV ESI,EBX
MOV EBX,dword ptr [RSP + 0x24]
JMP 0x0010136c
LAB_00101443:
MOV ESI,dword ptr [RSP]
MOV ECX,dword ptr [RSP + 0x20]
ADD ESI,0x1
ADD dword ptr [RSP + 0x1c],ESI
TEST ECX,ECX
JNZ 0x001013cc
LAB_00101459:
MOV ECX,dword ptr [RSP + 0x1c]
ADD dword ptr [RSP + 0x18],ECX
MOV ECX,dword ptr [RSP + 0xc]
TEST ECX,ECX
JNZ 0x0010149b
LAB_00101469:
MOV EDX,dword ptr [RSP + 0x4]
MOV ECX,dword ptr [RSP + 0x18]
ADD dword ptr [RSP + 0x14],ECX
TEST EDX,EDX
JNZ 0x001014bf
LAB_00101479:
MOV R8D,dword ptr [RSP + 0x14]
JMP 0x001014d9
LAB_00101480:
SUB EBX,0x2
JMP 0x0010131a
LAB_00101488:
MOV ECX,dword ptr [RSP + 0x1c]
ADD ECX,0x1
ADD dword ptr [RSP + 0x18],ECX
MOV ECX,dword ptr [RSP + 0xc]
TEST ECX,ECX
JZ 0x00101469
LAB_0010149b:
CMP dword ptr [RSP + 0xc],0x1
JZ 0x001014ac
LAB_001014a2:
SUB dword ptr [RSP + 0xc],0x2
JMP 0x00101271
LAB_001014ac:
MOV ECX,dword ptr [RSP + 0x18]
MOV EDX,dword ptr [RSP + 0x4]
ADD ECX,0x1
ADD dword ptr [RSP + 0x14],ECX
TEST EDX,EDX
JZ 0x00101479
LAB_001014bf:
CMP dword ptr [RSP + 0x4],0x1
JZ 0x001014d0
LAB_001014c6:
SUB dword ptr [RSP + 0x4],0x2
JMP 0x0010124c
LAB_001014d0:
MOV R8D,dword ptr [RSP + 0x14]
ADD R8D,0x1
LAB_001014d9:
MOV EAX,dword ptr [RSP + 0x8]
ADD dword ptr [RSP + 0x10],R8D
TEST EAX,EAX
JZ 0x00101516
CMP dword ptr [RSP + 0x8],0x1
JNZ 0x00101508
LAB_001014ed:
MOV R10D,dword ptr [RSP + 0x10]
ADD R10D,0x1
LAB_001014f6:
ADD RSP,0x38
MOV EAX,R10D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101508:
SUB dword ptr [RSP + 0x8],0x2
JMP 0x00101225
LAB_00101512:
MOV EAX,R10D
RET
LAB_00101516:
MOV R10D,dword ptr [RSP + 0x10]
JMP 0x001014f6 | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int local_68;
int local_64;
int local_60;
int local_5c;
int local_58;
int local_54;
int local_50;
int local_4c;
if ((param_1 == 0) || (param_1 == 1)) {
return param_1;
}
local_60 = param_1 + -2;
local_58 = 0;
LAB_00101225:
if (local_60 == -1) goto LAB_00101508;
if (local_60 != 0) {
local_64 = local_60 + -1;
local_54 = 0;
do {
if (local_64 != -1) {
if (local_64 == 0) goto LAB_001014d0;
local_5c = local_64 + -1;
local_50 = 0;
LAB_00101271:
if (local_5c == -1) goto LAB_001014a2;
if (local_5c != 0) {
iVar3 = local_5c + -1;
local_4c = 0;
do {
if (iVar3 != -1) {
if (iVar3 == 0) goto LAB_00101488;
iVar7 = iVar3 + -1;
local_68 = 0;
LAB_001012ba:
if (iVar7 == -1) goto LAB_00101407;
if (iVar7 != 0) {
iVar8 = iVar7 + -1;
iVar2 = 0;
do {
if (iVar8 != -1) {
if (iVar8 == 0) goto LAB_001013eb;
iVar6 = iVar8 + -1;
iVar4 = 0;
LAB_001012fa:
if (iVar6 == -1) goto LAB_001013dd;
if (iVar6 != 0) {
iVar5 = iVar6 + -1;
iVar10 = 0;
do {
iVar9 = iVar5 + 1;
if (iVar9 != 0) {
if (iVar9 == 1) goto LAB_00101380;
iVar11 = 0;
do {
iVar1 = func0(iVar9 + -1);
iVar11 = iVar11 + iVar1;
iVar9 = iVar9 + -2;
if (iVar9 == 0) goto LAB_0010136c;
} while (iVar9 != 1);
iVar11 = iVar11 + 1;
LAB_0010136c:
iVar10 = iVar10 + iVar11;
if (iVar5 == 0) goto joined_r0x00101424;
if (iVar5 == 1) goto LAB_00101380;
}
iVar5 = iVar5 + -2;
} while( true );
}
LAB_0010139a:
iVar4 = iVar4 + 1;
LAB_001013a3:
iVar2 = iVar2 + iVar4;
if (iVar8 == 0) goto joined_r0x001013ba;
if (iVar8 == 1) goto LAB_001013eb;
}
iVar8 = iVar8 + -2;
} while( true );
}
LAB_00101443:
local_68 = local_68 + 1;
joined_r0x001013c6:
local_4c = local_4c + local_68;
if (iVar3 == 0) goto joined_r0x00101467;
if (iVar3 == 1) goto LAB_00101488;
}
iVar3 = iVar3 + -2;
} while( true );
}
LAB_001014ac:
local_50 = local_50 + 1;
joined_r0x00101477:
local_54 = local_54 + local_50;
if (local_64 == 0) goto LAB_001014d9;
if (local_64 == 1) goto LAB_001014d0;
}
local_64 = local_64 + -2;
} while( true );
}
LAB_001014ed:
return local_58 + 1;
LAB_00101380:
iVar10 = iVar10 + 1;
joined_r0x00101424:
iVar4 = iVar4 + iVar10;
if (iVar6 == 0) goto LAB_001013a3;
if (iVar6 == 1) goto LAB_0010139a;
LAB_001013dd:
iVar6 = iVar6 + -2;
goto LAB_001012fa;
LAB_001013eb:
iVar2 = iVar2 + 1;
joined_r0x001013ba:
local_68 = local_68 + iVar2;
if (iVar7 == 0) goto joined_r0x001013c6;
if (iVar7 == 1) goto LAB_00101443;
LAB_00101407:
iVar7 = iVar7 + -2;
goto LAB_001012ba;
LAB_00101488:
local_4c = local_4c + 1;
joined_r0x00101467:
local_50 = local_50 + local_4c;
if (local_5c == 0) goto joined_r0x00101477;
if (local_5c == 1) goto LAB_001014ac;
LAB_001014a2:
local_5c = local_5c + -2;
goto LAB_00101271;
LAB_001014d0:
local_54 = local_54 + 1;
LAB_001014d9:
local_58 = local_58 + local_54;
if (local_60 == 0) {
return local_58;
}
if (local_60 == 1) goto LAB_001014ed;
LAB_00101508:
local_60 = local_60 + -2;
goto LAB_00101225;
} |
7,735 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 0)
return 0;
if (n == 1)
return 1;
return func0(n - 1) + func0(n - 2);
}
| int main() {
assert(func0(4) == 3);
assert(func0(3) == 2);
assert(func0(5) == 5);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbx
sub $0x8,%rsp
test %edi,%edi
je 1230 <func0+0x40>
mov %edi,%ebx
cmp $0x1,%edi
je 1240 <func0+0x50>
xor %r12d,%r12d
lea -0x1(%rbx),%edi
callq 11f0 <func0>
add %eax,%r12d
sub $0x2,%ebx
je 1222 <func0+0x32>
cmp $0x1,%ebx
jne 1209 <func0+0x19>
add $0x1,%r12d
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %r12
retq
nopl (%rax)
xor %r12d,%r12d
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %r12
retq
xchg %ax,%ax
mov $0x1,%r12d
jmp 1222 <func0+0x32>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
mov r12d, edi
push rbp
push rbx
sub rsp, 58h
test edi, edi
jz loc_1429
cmp edi, 1
jz loc_1429
lea r15d, [rdi-1]
xor r12d, r12d
loc_121D:
cmp r15d, 1
jz loc_1425
lea r13d, [r15-1]
xor r14d, r14d
mov [rsp+88h+var_6C], r12d
mov [rsp+88h+var_68], r13d
mov ebp, r13d
mov r12d, r14d
loc_123E:
cmp ebp, 1
jz loc_1403
mov [rsp+88h+var_64], r15d
lea ecx, [rbp-1]
xor r14d, r14d
mov [rsp+88h+var_60], ebp
mov ebp, ecx
loc_1258:
cmp ebp, 1
jz loc_13E7
mov [rsp+88h+var_58], r14d
lea edi, [rbp-1]
xor r15d, r15d
mov r13d, ebp
mov [rsp+88h+var_54], ecx
mov [rsp+88h+var_5C], r12d
mov r12d, edi
loc_127B:
cmp r12d, 1
jz loc_13C3
lea r11d, [r12-1]
xor r14d, r14d
mov [rsp+88h+var_50], r15d
mov [rsp+88h+var_78], r14d
mov ebp, r11d
mov [rsp+88h+var_4C], edi
mov [rsp+88h+var_48], r11d
mov [rsp+88h+var_44], r12d
loc_12A8:
cmp ebp, 1
jz loc_1396
lea r12d, [rbp-1]
mov [rsp+88h+var_3C], ebp
xor r15d, r15d
mov [rsp+88h+var_40], r12d
mov r14d, r12d
loc_12C4:
cmp r14d, 1
jz loc_1377
lea ebp, [r14-1]
mov [rsp+88h+var_84], r13d
xor ecx, ecx
mov [rsp+88h+var_80], ebp
mov ebx, ebp
mov [rsp+88h+var_7C], r14d
loc_12E4:
cmp ebx, 1
jz short loc_1354
lea ebp, [rbx-1]
xor r13d, r13d
mov r14d, ebp
mov edx, ebp
mov ebp, ecx
mov ecx, ebx
mov ebx, r14d
loc_12FB:
mov r14d, ebx
cmp ebx, 1
jz short loc_1342
mov [rsp+88h+var_74], ebx
xor r12d, r12d
mov ebx, edx
loc_130C:
lea edi, [r14-1]
mov [rsp+88h+var_70], ecx
call func0
mov ecx, [rsp+88h+var_70]
add r12d, eax
sub r14d, 2
jz loc_1440
cmp r14d, 1
jnz short loc_130C
mov edx, ebx
mov ebx, [rsp+88h+var_74]
add r12d, 1
loc_133A:
add r13d, r12d
sub ebx, 2
jnz short loc_12FB
loc_1342:
mov ebx, ecx
lea esi, [r13+1]
mov ecx, ebp
add ecx, esi
sub ebx, 2
cmp edx, 1
jnz short loc_12E4
loc_1354:
mov r14d, [rsp+88h+var_7C]
mov ebx, ecx
mov ebp, [rsp+88h+var_80]
add ebx, 1
mov r13d, [rsp+88h+var_84]
add r15d, ebx
sub r14d, 2
cmp ebp, 1
jnz loc_12C4
loc_1377:
mov ebp, [rsp+88h+var_3C]
mov r12d, [rsp+88h+var_40]
add r15d, 1
add [rsp+88h+var_78], r15d
sub ebp, 2
cmp r12d, 1
jnz loc_12A8
loc_1396:
mov r14d, [rsp+88h+var_78]
mov r15d, [rsp+88h+var_50]
mov r12d, [rsp+88h+var_44]
mov r11d, [rsp+88h+var_48]
add r14d, 1
mov edi, [rsp+88h+var_4C]
add r15d, r14d
sub r12d, 2
cmp r11d, 1
jnz loc_127B
loc_13C3:
mov r14d, [rsp+88h+var_58]
mov ebp, r13d
add r15d, 1
mov ecx, [rsp+88h+var_54]
mov r12d, [rsp+88h+var_5C]
sub ebp, 2
add r14d, r15d
cmp edi, 1
jnz loc_1258
loc_13E7:
mov ebp, [rsp+88h+var_60]
add r14d, 1
mov r15d, [rsp+88h+var_64]
add r12d, r14d
sub ebp, 2
cmp ecx, 1
jnz loc_123E
loc_1403:
mov r14d, r12d
mov r13d, [rsp+88h+var_68]
mov r12d, [rsp+88h+var_6C]
sub r15d, 2
add r14d, 1
add r12d, r14d
cmp r13d, 1
jnz loc_121D
loc_1425:
add r12d, 1
loc_1429:
add rsp, 58h
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1440:
mov edx, ebx
mov ebx, [rsp+88h+var_74]
jmp loc_133A | long long func0(unsigned int a1)
{
unsigned int v1; // r12d
unsigned int v2; // r15d
int v3; // r12d
unsigned int v4; // ebp
int v5; // r12d
unsigned int v6; // ecx
int v7; // r14d
unsigned int v8; // ebp
unsigned int v9; // edi
int v10; // r15d
unsigned int v11; // r13d
unsigned int v12; // r12d
unsigned int v13; // ebp
int v14; // r15d
unsigned int v15; // r14d
int v16; // ecx
unsigned int v17; // ebx
int v18; // r13d
unsigned int v19; // edx
int v20; // ebp
unsigned int v21; // ecx
unsigned int v22; // ebx
unsigned int v23; // r14d
int v24; // r12d
unsigned int v25; // ebx
int v26; // eax
unsigned int v27; // ebx
unsigned int v28; // ebx
unsigned int v30; // [rsp+4h] [rbp-84h]
unsigned int v31; // [rsp+8h] [rbp-80h]
unsigned int v32; // [rsp+Ch] [rbp-7Ch]
int v33; // [rsp+10h] [rbp-78h]
unsigned int v34; // [rsp+14h] [rbp-74h]
unsigned int v35; // [rsp+18h] [rbp-70h]
int v36; // [rsp+1Ch] [rbp-6Ch]
unsigned int v37; // [rsp+20h] [rbp-68h]
unsigned int v38; // [rsp+24h] [rbp-64h]
unsigned int v39; // [rsp+28h] [rbp-60h]
int v40; // [rsp+2Ch] [rbp-5Ch]
int v41; // [rsp+30h] [rbp-58h]
unsigned int v42; // [rsp+34h] [rbp-54h]
int v43; // [rsp+38h] [rbp-50h]
unsigned int v44; // [rsp+40h] [rbp-48h]
unsigned int v45; // [rsp+44h] [rbp-44h]
unsigned int v46; // [rsp+48h] [rbp-40h]
unsigned int v47; // [rsp+4Ch] [rbp-3Ch]
v1 = a1;
if ( a1 >= 2 )
{
v2 = a1 - 1;
v3 = 0;
do
{
if ( v2 == 1 )
break;
v36 = v3;
v37 = v2 - 1;
v4 = v2 - 1;
v5 = 0;
do
{
if ( v4 == 1 )
break;
v38 = v2;
v6 = v4 - 1;
v7 = 0;
v39 = v4;
v8 = v4 - 1;
do
{
if ( v8 == 1 )
break;
v41 = v7;
v9 = v8 - 1;
v10 = 0;
v11 = v8;
v42 = v6;
v40 = v5;
v12 = v8 - 1;
do
{
if ( v12 == 1 )
break;
v43 = v10;
v33 = 0;
v13 = v12 - 1;
v44 = v12 - 1;
v45 = v12;
do
{
if ( v13 == 1 )
break;
v47 = v13;
v14 = 0;
v46 = v13 - 1;
v15 = v13 - 1;
do
{
if ( v15 == 1 )
break;
v30 = v11;
v16 = 0;
v31 = v15 - 1;
v17 = v15 - 1;
v32 = v15;
do
{
if ( v17 == 1 )
break;
v18 = 0;
v19 = v17 - 1;
v20 = v16;
v21 = v17;
v22 = v17 - 1;
do
{
v23 = v22;
if ( v22 == 1 )
break;
v34 = v22;
v24 = 0;
v25 = v19;
while ( 1 )
{
v35 = v21;
v26 = func0(v23 - 1);
v21 = v35;
v24 += v26;
v23 -= 2;
if ( !v23 )
break;
if ( v23 == 1 )
{
v19 = v25;
v27 = v34;
++v24;
goto LABEL_22;
}
}
v19 = v25;
v27 = v34;
LABEL_22:
v18 += v24;
v22 = v27 - 2;
}
while ( v22 );
v28 = v21;
v16 = v18 + 1 + v20;
v17 = v28 - 2;
}
while ( v19 != 1 );
v11 = v30;
v14 += v16 + 1;
v15 = v32 - 2;
}
while ( v31 != 1 );
v33 += v14 + 1;
v13 = v47 - 2;
}
while ( v46 != 1 );
v10 = v33 + 1 + v43;
v12 = v45 - 2;
}
while ( v44 != 1 );
v6 = v42;
v5 = v40;
v8 = v11 - 2;
v7 = v10 + 1 + v41;
}
while ( v9 != 1 );
v2 = v38;
v5 += v7 + 1;
v4 = v39 - 2;
}
while ( v6 != 1 );
v2 -= 2;
v3 = v5 + 1 + v36;
}
while ( v37 != 1 );
return (unsigned int)(v3 + 1);
}
return v1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,EDI
PUSH RBP
PUSH RBX
SUB RSP,0x58
TEST EDI,EDI
JZ 0x00101429
CMP EDI,0x1
JZ 0x00101429
LEA R15D,[RDI + -0x1]
XOR R12D,R12D
LAB_0010121d:
CMP R15D,0x1
JZ 0x00101425
LEA R13D,[R15 + -0x1]
XOR R14D,R14D
MOV dword ptr [RSP + 0x1c],R12D
MOV dword ptr [RSP + 0x20],R13D
MOV EBP,R13D
MOV R12D,R14D
LAB_0010123e:
CMP EBP,0x1
JZ 0x00101403
MOV dword ptr [RSP + 0x24],R15D
LEA ECX,[RBP + -0x1]
XOR R14D,R14D
MOV dword ptr [RSP + 0x28],EBP
MOV EBP,ECX
LAB_00101258:
CMP EBP,0x1
JZ 0x001013e7
MOV dword ptr [RSP + 0x30],R14D
LEA EDI,[RBP + -0x1]
XOR R15D,R15D
MOV R13D,EBP
MOV dword ptr [RSP + 0x34],ECX
MOV dword ptr [RSP + 0x2c],R12D
MOV R12D,EDI
LAB_0010127b:
CMP R12D,0x1
JZ 0x001013c3
LEA R11D,[R12 + -0x1]
XOR R14D,R14D
MOV dword ptr [RSP + 0x38],R15D
MOV dword ptr [RSP + 0x10],R14D
MOV EBP,R11D
MOV dword ptr [RSP + 0x3c],EDI
MOV dword ptr [RSP + 0x40],R11D
MOV dword ptr [RSP + 0x44],R12D
LAB_001012a8:
CMP EBP,0x1
JZ 0x00101396
LEA R12D,[RBP + -0x1]
MOV dword ptr [RSP + 0x4c],EBP
XOR R15D,R15D
MOV dword ptr [RSP + 0x48],R12D
MOV R14D,R12D
LAB_001012c4:
CMP R14D,0x1
JZ 0x00101377
LEA EBP,[R14 + -0x1]
MOV dword ptr [RSP + 0x4],R13D
XOR ECX,ECX
MOV dword ptr [RSP + 0x8],EBP
MOV EBX,EBP
MOV dword ptr [RSP + 0xc],R14D
LAB_001012e4:
CMP EBX,0x1
JZ 0x00101354
LEA EBP,[RBX + -0x1]
XOR R13D,R13D
MOV R14D,EBP
MOV EDX,EBP
MOV EBP,ECX
MOV ECX,EBX
MOV EBX,R14D
LAB_001012fb:
MOV R14D,EBX
CMP EBX,0x1
JZ 0x00101342
MOV dword ptr [RSP + 0x14],EBX
XOR R12D,R12D
MOV EBX,EDX
LAB_0010130c:
LEA EDI,[R14 + -0x1]
MOV dword ptr [RSP + 0x18],ECX
CALL 0x001011f0
MOV ECX,dword ptr [RSP + 0x18]
ADD R12D,EAX
SUB R14D,0x2
JZ 0x00101440
CMP R14D,0x1
JNZ 0x0010130c
MOV EDX,EBX
MOV EBX,dword ptr [RSP + 0x14]
ADD R12D,0x1
LAB_0010133a:
ADD R13D,R12D
SUB EBX,0x2
JNZ 0x001012fb
LAB_00101342:
MOV EBX,ECX
LEA ESI,[R13 + 0x1]
MOV ECX,EBP
ADD ECX,ESI
SUB EBX,0x2
CMP EDX,0x1
JNZ 0x001012e4
LAB_00101354:
MOV R14D,dword ptr [RSP + 0xc]
MOV EBX,ECX
MOV EBP,dword ptr [RSP + 0x8]
ADD EBX,0x1
MOV R13D,dword ptr [RSP + 0x4]
ADD R15D,EBX
SUB R14D,0x2
CMP EBP,0x1
JNZ 0x001012c4
LAB_00101377:
MOV EBP,dword ptr [RSP + 0x4c]
MOV R12D,dword ptr [RSP + 0x48]
ADD R15D,0x1
ADD dword ptr [RSP + 0x10],R15D
SUB EBP,0x2
CMP R12D,0x1
JNZ 0x001012a8
LAB_00101396:
MOV R14D,dword ptr [RSP + 0x10]
MOV R15D,dword ptr [RSP + 0x38]
MOV R12D,dword ptr [RSP + 0x44]
MOV R11D,dword ptr [RSP + 0x40]
ADD R14D,0x1
MOV EDI,dword ptr [RSP + 0x3c]
ADD R15D,R14D
SUB R12D,0x2
CMP R11D,0x1
JNZ 0x0010127b
LAB_001013c3:
MOV R14D,dword ptr [RSP + 0x30]
MOV EBP,R13D
ADD R15D,0x1
MOV ECX,dword ptr [RSP + 0x34]
MOV R12D,dword ptr [RSP + 0x2c]
SUB EBP,0x2
ADD R14D,R15D
CMP EDI,0x1
JNZ 0x00101258
LAB_001013e7:
MOV EBP,dword ptr [RSP + 0x28]
ADD R14D,0x1
MOV R15D,dword ptr [RSP + 0x24]
ADD R12D,R14D
SUB EBP,0x2
CMP ECX,0x1
JNZ 0x0010123e
LAB_00101403:
MOV R14D,R12D
MOV R13D,dword ptr [RSP + 0x20]
MOV R12D,dword ptr [RSP + 0x1c]
SUB R15D,0x2
ADD R14D,0x1
ADD R12D,R14D
CMP R13D,0x1
JNZ 0x0010121d
LAB_00101425:
ADD R12D,0x1
LAB_00101429:
ADD RSP,0x58
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101440:
MOV EDX,EBX
MOV EBX,dword ptr [RSP + 0x14]
JMP 0x0010133a | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int iVar19;
int iVar20;
int iVar21;
int iVar22;
int iVar23;
int iVar24;
int local_78;
if ((param_1 != 0) && (param_1 != 1)) {
iVar24 = param_1 + -1;
param_1 = 0;
do {
if (iVar24 == 1) break;
iVar17 = iVar24 + -1;
iVar16 = 0;
iVar11 = iVar17;
do {
if (iVar11 == 1) break;
iVar1 = iVar11 + -1;
iVar19 = 0;
iVar10 = iVar1;
do {
if (iVar10 == 1) break;
iVar12 = iVar10 + -1;
iVar23 = 0;
iVar15 = iVar12;
do {
if (iVar15 == 1) break;
iVar3 = iVar15 + -1;
local_78 = 0;
iVar9 = iVar3;
do {
if (iVar9 == 1) break;
iVar13 = iVar9 + -1;
iVar22 = 0;
iVar21 = iVar13;
do {
if (iVar21 == 1) break;
iVar2 = iVar21 + -1;
iVar5 = 0;
iVar7 = iVar2;
do {
if (iVar7 == 1) break;
iVar8 = iVar7 + -1;
iVar18 = 0;
iVar6 = iVar8;
do {
if (iVar6 == 1) break;
iVar14 = 0;
iVar20 = iVar6;
do {
iVar4 = func0(iVar20 + -1);
iVar14 = iVar14 + iVar4;
iVar20 = iVar20 + -2;
if (iVar20 == 0) goto LAB_0010133a;
} while (iVar20 != 1);
iVar14 = iVar14 + 1;
LAB_0010133a:
iVar18 = iVar18 + iVar14;
iVar6 = iVar6 + -2;
} while (iVar6 != 0);
iVar5 = iVar5 + iVar18 + 1;
iVar7 = iVar7 + -2;
} while (iVar8 != 1);
iVar22 = iVar22 + iVar5 + 1;
iVar21 = iVar21 + -2;
} while (iVar2 != 1);
local_78 = local_78 + iVar22 + 1;
iVar9 = iVar9 + -2;
} while (iVar13 != 1);
iVar23 = iVar23 + local_78 + 1;
iVar15 = iVar15 + -2;
} while (iVar3 != 1);
iVar10 = iVar10 + -2;
iVar19 = iVar19 + iVar23 + 1;
} while (iVar12 != 1);
iVar16 = iVar16 + iVar19 + 1;
iVar11 = iVar11 + -2;
} while (iVar1 != 1);
iVar24 = iVar24 + -2;
param_1 = param_1 + iVar16 + 1;
} while (iVar17 != 1);
param_1 = param_1 + 1;
}
return param_1;
} |
7,736 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(char *s) {
int rom_val[256] = {0};
rom_val['I'] = 1;
rom_val['V'] = 5;
rom_val['X'] = 10;
rom_val['L'] = 50;
rom_val['C'] = 100;
rom_val['D'] = 500;
rom_val['M'] = 1000;
int int_val = 0;
int len = strlen(s);
for (int i = 0; i < len; i++) {
if (i > 0 && rom_val[s[i]] > rom_val[s[i - 1]]) {
int_val += rom_val[s[i]] - 2 * rom_val[s[i - 1]];
} else {
int_val += rom_val[s[i]];
}
}
return int_val;
}
| int main() {
assert(func0("MMMCMLXXXVI") == 3986);
assert(func0("MMMM") == 4000);
assert(func0("C") == 100);
printf("All tests passed successfully.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x430,%rsp
mov %rdi,-0x428(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x410(%rbp),%rdx
mov $0x0,%eax
mov $0x80,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x1,-0x2ec(%rbp)
movl $0x5,-0x2b8(%rbp)
movl $0xa,-0x2b0(%rbp)
movl $0x32,-0x2e0(%rbp)
movl $0x64,-0x304(%rbp)
movl $0x1f4,-0x300(%rbp)
movl $0x3e8,-0x2dc(%rbp)
movl $0x0,-0x41c(%rbp)
mov -0x428(%rbp),%rax
mov %rax,%rdi
callq 1090 <strlen@plt>
mov %eax,-0x414(%rbp)
movl $0x0,-0x418(%rbp)
jmpq 1335 <func0+0x18c>
cmpl $0x0,-0x418(%rbp)
jle 1306 <func0+0x15d>
mov -0x418(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
cltq
mov -0x410(%rbp,%rax,4),%edx
mov -0x418(%rbp),%eax
cltq
lea -0x1(%rax),%rcx
mov -0x428(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
cltq
mov -0x410(%rbp,%rax,4),%eax
cmp %eax,%edx
jle 1306 <func0+0x15d>
mov -0x418(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
cltq
mov -0x410(%rbp,%rax,4),%edx
mov -0x418(%rbp),%eax
cltq
lea -0x1(%rax),%rcx
mov -0x428(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
cltq
mov -0x410(%rbp,%rax,4),%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
add %eax,-0x41c(%rbp)
jmp 132e <func0+0x185>
mov -0x418(%rbp),%eax
movslq %eax,%rdx
mov -0x428(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
cltq
mov -0x410(%rbp,%rax,4),%eax
add %eax,-0x41c(%rbp)
addl $0x1,-0x418(%rbp)
mov -0x418(%rbp),%eax
cmp -0x414(%rbp),%eax
jl 1259 <func0+0xb0>
mov -0x41c(%rbp),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1361 <func0+0x1b8>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 430h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_410]
mov eax, 0
mov ecx, 80h
mov rdi, rdx
rep stosq
mov [rbp+var_2EC], 1
mov [rbp+var_2B8], 5
mov [rbp+var_2B0], 0Ah
mov [rbp+var_2E0], 32h ; '2'
mov [rbp+var_304], 64h ; 'd'
mov [rbp+var_300], 1F4h
mov [rbp+var_2DC], 3E8h
mov [rbp+var_41C], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_414], eax
mov [rbp+var_418], 0
jmp loc_1336
loc_1259:
cmp [rbp+var_418], 0
jle loc_1307
mov eax, [rbp+var_418]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
cdqe
mov edx, [rbp+rax*4+var_410]
mov eax, [rbp+var_418]
cdqe
lea rcx, [rax-1]
mov rax, [rbp+s]
add rax, rcx
movzx eax, byte ptr [rax]
movsx eax, al
cdqe
mov eax, [rbp+rax*4+var_410]
cmp edx, eax
jle short loc_1307
mov eax, [rbp+var_418]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
cdqe
mov ecx, [rbp+rax*4+var_410]
mov eax, [rbp+var_418]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
cdqe
mov eax, [rbp+rax*4+var_410]
lea edx, [rax+rax]
mov eax, ecx
sub eax, edx
add [rbp+var_41C], eax
jmp short loc_132F
loc_1307:
mov eax, [rbp+var_418]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
cdqe
mov eax, [rbp+rax*4+var_410]
add [rbp+var_41C], eax
loc_132F:
add [rbp+var_418], 1
loc_1336:
mov eax, [rbp+var_418]
cmp eax, [rbp+var_414]
jl loc_1259
mov eax, [rbp+var_41C]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1362
call ___stack_chk_fail
locret_1362:
leave
retn | long long func0(const char *a1)
{
unsigned int v2; // [rsp+14h] [rbp-41Ch]
int i; // [rsp+18h] [rbp-418h]
int v4; // [rsp+1Ch] [rbp-414h]
_DWORD v5[258]; // [rsp+20h] [rbp-410h] BYREF
unsigned long long v6; // [rsp+428h] [rbp-8h]
v6 = __readfsqword(0x28u);
memset(v5, 0, 0x400uLL);
v5[73] = 1;
v5[86] = 5;
v5[88] = 10;
v5[76] = 50;
v5[67] = 100;
v5[68] = 500;
v5[77] = 1000;
v2 = 0;
v4 = strlen(a1);
for ( i = 0; i < v4; ++i )
{
if ( i <= 0 || v5[a1[i]] <= v5[a1[i - 1]] )
v2 += v5[a1[i]];
else
v2 += v5[a1[i]] - 2 * v5[a1[i - 1]];
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x430
MOV qword ptr [RBP + -0x428],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0x410]
MOV EAX,0x0
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x2ec],0x1
MOV dword ptr [RBP + -0x2b8],0x5
MOV dword ptr [RBP + -0x2b0],0xa
MOV dword ptr [RBP + -0x2e0],0x32
MOV dword ptr [RBP + -0x304],0x64
MOV dword ptr [RBP + -0x300],0x1f4
MOV dword ptr [RBP + -0x2dc],0x3e8
MOV dword ptr [RBP + -0x41c],0x0
MOV RAX,qword ptr [RBP + -0x428]
MOV RDI,RAX
CALL 0x00101090
MOV dword ptr [RBP + -0x414],EAX
MOV dword ptr [RBP + -0x418],0x0
JMP 0x00101336
LAB_00101259:
CMP dword ptr [RBP + -0x418],0x0
JLE 0x00101307
MOV EAX,dword ptr [RBP + -0x418]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
CDQE
MOV EDX,dword ptr [RBP + RAX*0x4 + -0x410]
MOV EAX,dword ptr [RBP + -0x418]
CDQE
LEA RCX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x410]
CMP EDX,EAX
JLE 0x00101307
MOV EAX,dword ptr [RBP + -0x418]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
CDQE
MOV ECX,dword ptr [RBP + RAX*0x4 + -0x410]
MOV EAX,dword ptr [RBP + -0x418]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x410]
LEA EDX,[RAX + RAX*0x1]
MOV EAX,ECX
SUB EAX,EDX
ADD dword ptr [RBP + -0x41c],EAX
JMP 0x0010132f
LAB_00101307:
MOV EAX,dword ptr [RBP + -0x418]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x428]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x410]
ADD dword ptr [RBP + -0x41c],EAX
LAB_0010132f:
ADD dword ptr [RBP + -0x418],0x1
LAB_00101336:
MOV EAX,dword ptr [RBP + -0x418]
CMP EAX,dword ptr [RBP + -0x414]
JL 0x00101259
MOV EAX,dword ptr [RBP + -0x41c]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101362
CALL 0x001010a0
LAB_00101362:
LEAVE
RET | int func0(char *param_1)
{
int iVar1;
size_t sVar2;
long lVar3;
int *piVar4;
long in_FS_OFFSET;
int local_424;
int local_420;
int local_418 [67];
int4 local_30c;
int4 local_308;
int4 local_2f4;
int4 local_2e8;
int4 local_2e4;
int4 local_2c0;
int4 local_2b8;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar4 = local_418;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
piVar4[0] = 0;
piVar4[1] = 0;
piVar4 = piVar4 + 2;
}
local_2f4 = 1;
local_2c0 = 5;
local_2b8 = 10;
local_2e8 = 0x32;
local_30c = 100;
local_308 = 500;
local_2e4 = 1000;
local_424 = 0;
sVar2 = strlen(param_1);
for (local_420 = 0; local_420 < (int)sVar2; local_420 = local_420 + 1) {
if ((local_420 < 1) ||
(local_418[(int)param_1[local_420]] <= local_418[(int)param_1[(long)local_420 + -1]])) {
iVar1 = local_418[(int)param_1[local_420]];
}
else {
iVar1 = local_418[(int)param_1[local_420]] +
local_418[(int)param_1[(long)local_420 + -1]] * -2;
}
local_424 = local_424 + iVar1;
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_424;
} |
7,737 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(char *s) {
int rom_val[256] = {0};
rom_val['I'] = 1;
rom_val['V'] = 5;
rom_val['X'] = 10;
rom_val['L'] = 50;
rom_val['C'] = 100;
rom_val['D'] = 500;
rom_val['M'] = 1000;
int int_val = 0;
int len = strlen(s);
for (int i = 0; i < len; i++) {
if (i > 0 && rom_val[s[i]] > rom_val[s[i - 1]]) {
int_val += rom_val[s[i]] - 2 * rom_val[s[i - 1]];
} else {
int_val += rom_val[s[i]];
}
}
return int_val;
}
| int main() {
assert(func0("MMMCMLXXXVI") == 3986);
assert(func0("MMMM") == 4000);
assert(func0("C") == 100);
printf("All tests passed successfully.\n");
return 0;
}
| O1 | c | func0:
endbr64
sub $0x418,%rsp
mov %rdi,%rdx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x80,%ecx
rep stos %rax,%es:(%rdi)
movl $0x1,0x124(%rsp)
movl $0x5,0x158(%rsp)
movl $0xa,0x160(%rsp)
movl $0x32,0x130(%rsp)
movl $0x64,0x10c(%rsp)
movl $0x1f4,0x110(%rsp)
movl $0x3e8,0x134(%rsp)
mov $0xffffffffffffffff,%rcx
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
test %ecx,%ecx
jle 125e <func0+0xd5>
lea -0x1(%rcx),%r8d
mov $0x0,%eax
mov $0x0,%edi
jmp 123d <func0+0xb4>
movsbq (%rdx,%rax,1),%rcx
add (%rsp,%rcx,4),%edi
lea 0x1(%rax),%rcx
cmp %r8,%rax
je 1263 <func0+0xda>
mov %rcx,%rax
test %eax,%eax
jle 1229 <func0+0xa0>
movsbq (%rdx,%rax,1),%rcx
mov (%rsp,%rcx,4),%ecx
movsbq -0x1(%rdx,%rax,1),%rsi
mov (%rsp,%rsi,4),%esi
cmp %esi,%ecx
jle 1229 <func0+0xa0>
add %esi,%esi
sub %esi,%ecx
add %ecx,%edi
jmp 1231 <func0+0xa8>
mov $0x0,%edi
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 1280 <func0+0xf7>
mov %edi,%eax
add $0x418,%rsp
retq
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbx
sub rsp, 410h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 80h
rep stosq
mov [rsp+418h+var_2F4], 1
mov [rsp+418h+var_2C0], 5
mov [rsp+418h+var_2B8], 0Ah
mov [rsp+418h+var_2E8], 32h ; '2'
mov [rsp+418h+var_30C], 64h ; 'd'
mov [rsp+418h+var_308], 1F4h
mov [rsp+418h+var_2E4], 3E8h
mov rdi, rbx
call _strlen
test eax, eax
jle short loc_1273
lea edi, [rax-1]
mov eax, 0
mov esi, 0
jmp short loc_1252
loc_123E:
movsx rdx, byte ptr [rbx+rax]
add esi, [rsp+rdx*4+418h+var_418]
loc_1246:
lea rdx, [rax+1]
cmp rax, rdi
jz short loc_1278
mov rax, rdx
loc_1252:
test eax, eax
jle short loc_123E
movsx rdx, byte ptr [rbx+rax]
mov edx, [rsp+rdx*4+418h+var_418]
movsx rcx, byte ptr [rbx+rax-1]
mov ecx, [rsp+rcx*4+418h+var_418]
cmp edx, ecx
jle short loc_123E
add ecx, ecx
sub edx, ecx
add esi, edx
jmp short loc_1246
loc_1273:
mov esi, 0
loc_1278:
mov rax, [rsp+418h+var_10]
sub rax, fs:28h
jnz short loc_1296
mov eax, esi
add rsp, 410h
pop rbx
retn
loc_1296:
call ___stack_chk_fail | long long func0(long long a1)
{
int v2; // eax
long long v3; // rdi
long long v4; // rax
unsigned int v5; // esi
int v6; // edx
int v7; // ecx
_DWORD v9[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v10; // [rsp+408h] [rbp-10h]
v10 = __readfsqword(0x28u);
memset(v9, 0, 0x400uLL);
v9[73] = 1;
v9[86] = 5;
v9[88] = 10;
v9[76] = 50;
v9[67] = 100;
v9[68] = 500;
v9[77] = 1000;
v2 = strlen(a1);
if ( v2 <= 0 )
{
return 0;
}
else
{
v3 = (unsigned int)(v2 - 1);
v4 = 0LL;
v5 = 0;
while ( 1 )
{
if ( (int)v4 <= 0 || (v6 = v9[*(char *)(a1 + v4)], v7 = v9[*(char *)(a1 + v4 - 1)], v6 <= v7) )
v5 += v9[*(char *)(a1 + v4)];
else
v5 += v6 - 2 * v7;
if ( v4 == v3 )
break;
++v4;
}
}
return v5;
} | func0:
ENDBR64
PUSH RBX
SUB RSP,0x410
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x80
STOSQ.REP RDI
MOV dword ptr [RSP + 0x124],0x1
MOV dword ptr [RSP + 0x158],0x5
MOV dword ptr [RSP + 0x160],0xa
MOV dword ptr [RSP + 0x130],0x32
MOV dword ptr [RSP + 0x10c],0x64
MOV dword ptr [RSP + 0x110],0x1f4
MOV dword ptr [RSP + 0x134],0x3e8
MOV RDI,RBX
CALL 0x00101090
TEST EAX,EAX
JLE 0x00101273
LEA EDI,[RAX + -0x1]
MOV EAX,0x0
MOV ESI,0x0
JMP 0x00101252
LAB_0010123e:
MOVSX RDX,byte ptr [RBX + RAX*0x1]
ADD ESI,dword ptr [RSP + RDX*0x4]
LAB_00101246:
LEA RDX,[RAX + 0x1]
CMP RAX,RDI
JZ 0x00101278
MOV RAX,RDX
LAB_00101252:
TEST EAX,EAX
JLE 0x0010123e
MOVSX RDX,byte ptr [RBX + RAX*0x1]
MOV EDX,dword ptr [RSP + RDX*0x4]
MOVSX RCX,byte ptr [RBX + RAX*0x1 + -0x1]
MOV ECX,dword ptr [RSP + RCX*0x4]
CMP EDX,ECX
JLE 0x0010123e
ADD ECX,ECX
SUB EDX,ECX
ADD ESI,EDX
JMP 0x00101246
LAB_00101273:
MOV ESI,0x0
LAB_00101278:
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101296
MOV EAX,ESI
ADD RSP,0x410
POP RBX
RET
LAB_00101296:
CALL 0x001010a0 | int func0(char *param_1)
{
size_t sVar1;
ulong uVar2;
long lVar3;
int iVar4;
int iVar5;
int *piVar6;
long in_FS_OFFSET;
bool bVar7;
int aiStack_418 [67];
int4 local_30c;
int4 local_308;
int4 local_2f4;
int4 local_2e8;
int4 local_2e4;
int4 local_2c0;
int4 local_2b8;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar6 = aiStack_418;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)piVar6 = 0;
piVar6 = (int *)((long)piVar6 + 8);
}
local_2f4 = 1;
local_2c0 = 5;
local_2b8 = 10;
local_2e8 = 0x32;
local_30c = 100;
local_308 = 500;
local_2e4 = 1000;
sVar1 = strlen(param_1);
if ((int)sVar1 < 1) {
iVar5 = 0;
}
else {
iVar5 = 0;
uVar2 = 0;
do {
if ((int)uVar2 < 1) {
LAB_0010123e:
iVar4 = aiStack_418[param_1[uVar2]];
}
else {
if (aiStack_418[param_1[uVar2]] <= aiStack_418[param_1[uVar2 - 1]]) goto LAB_0010123e;
iVar4 = aiStack_418[param_1[uVar2]] + aiStack_418[param_1[uVar2 - 1]] * -2;
}
iVar5 = iVar5 + iVar4;
bVar7 = uVar2 != (int)sVar1 - 1;
uVar2 = uVar2 + 1;
} while (bVar7);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar5;
} |
7,738 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(char *s) {
int rom_val[256] = {0};
rom_val['I'] = 1;
rom_val['V'] = 5;
rom_val['X'] = 10;
rom_val['L'] = 50;
rom_val['C'] = 100;
rom_val['D'] = 500;
rom_val['M'] = 1000;
int int_val = 0;
int len = strlen(s);
for (int i = 0; i < len; i++) {
if (i > 0 && rom_val[s[i]] > rom_val[s[i - 1]]) {
int_val += rom_val[s[i]] - 2 * rom_val[s[i - 1]];
} else {
int_val += rom_val[s[i]];
}
}
return int_val;
}
| int main() {
assert(func0("MMMCMLXXXVI") == 3986);
assert(func0("MMMM") == 4000);
assert(func0("C") == 100);
printf("All tests passed successfully.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov $0x80,%ecx
mov %rdi,%rbx
sub $0x410,%rsp
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
mov %rbx,%rdi
movabs $0x1f400000064,%rax
movl $0x1,0x124(%rsp)
mov %rax,0x10c(%rsp)
movabs $0x3e800000032,%rax
movl $0x5,0x158(%rsp)
movl $0xa,0x160(%rsp)
mov %rax,0x130(%rsp)
callq 1090 <strlen@plt>
test %eax,%eax
jle 1350 <func0+0xf0>
lea -0x1(%rax),%edi
xor %r8d,%r8d
xor %eax,%eax
jmp 131b <func0+0xbb>
nopl 0x0(%rax,%rax,1)
movsbq (%rbx,%rax,1),%rcx
movsbq -0x1(%rbx,%rax,1),%rsi
mov %rcx,%rdx
mov (%rsp,%rsi,4),%esi
mov (%rsp,%rcx,4),%ecx
cmp %esi,%ecx
jle 1324 <func0+0xc4>
add %esi,%esi
lea 0x1(%rax),%rdx
sub %esi,%ecx
add %ecx,%r8d
cmp %rax,%rdi
je 1331 <func0+0xd1>
mov %rdx,%rax
test %rax,%rax
jne 12f0 <func0+0x90>
movsbq (%rbx),%rdx
add (%rsp,%rdx,4),%r8d
lea 0x1(%rax),%rdx
cmp %rax,%rdi
jne 1318 <func0+0xb8>
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 1355 <func0+0xf5>
add $0x410,%rsp
mov %r8d,%eax
pop %rbx
retq
xor %r8d,%r8d
jmp 1331 <func0+0xd1>
callq 10a0 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov ecx, 80h
mov rbx, rdi
sub rsp, 410h
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov rdi, rbx
mov rax, 1F400000064h
mov [rsp+418h+var_2F4], 1
mov [rsp+418h+var_30C], rax
mov rax, 3E800000032h
mov [rsp+418h+var_2E8], rax
mov [rsp+418h+var_2C0], 5
mov [rsp+418h+var_2B8], 0Ah
call _strlen
test eax, eax
jle short loc_1350
lea edi, [rax-1]
xor r8d, r8d
xor eax, eax
jmp short loc_131B
loc_12F0:
movsx rcx, byte ptr [rbx+rax]
movsx rsi, byte ptr [rbx+rax-1]
mov rdx, rcx
mov esi, [rsp+rsi*4+418h+var_418]
mov ecx, [rsp+rcx*4+418h+var_418]
cmp ecx, esi
jle short loc_1324
add esi, esi
lea rdx, [rax+1]
sub ecx, esi
add r8d, ecx
cmp rdi, rax
jz short loc_1331
loc_1318:
mov rax, rdx
loc_131B:
test rax, rax
jnz short loc_12F0
movsx rdx, byte ptr [rbx]
loc_1324:
add r8d, [rsp+rdx*4+418h+var_418]
lea rdx, [rax+1]
cmp rdi, rax
jnz short loc_1318
loc_1331:
mov rax, [rsp+418h+var_10]
sub rax, fs:28h
jnz short loc_1355
add rsp, 410h
mov eax, r8d
pop rbx
retn
loc_1350:
xor r8d, r8d
jmp short loc_1331
loc_1355:
call ___stack_chk_fail | long long func0(char *a1)
{
int v2; // eax
long long v3; // rdi
unsigned int v4; // r8d
long long i; // rax
long long v6; // rdx
int v7; // esi
int v8; // ecx
long long v9; // rdx
_QWORD v11[131]; // [rsp+0h] [rbp-418h] BYREF
v11[129] = __readfsqword(0x28u);
memset(v11, 0, 0x400uLL);
HIDWORD(v11[36]) = 1;
*(_QWORD *)((char *)&v11[33] + 4) = 0x1F400000064LL;
v11[38] = 0x3E800000032LL;
LODWORD(v11[43]) = 5;
LODWORD(v11[44]) = 10;
v2 = strlen(a1);
if ( v2 > 0 )
{
v3 = (unsigned int)(v2 - 1);
v4 = 0;
for ( i = 0LL; ; i = v9 )
{
if ( i )
{
v6 = a1[i];
v7 = *((_DWORD *)v11 + a1[i - 1]);
v8 = *((_DWORD *)v11 + v6);
if ( v8 > v7 )
{
v9 = i + 1;
v4 += v8 - 2 * v7;
if ( v3 == i )
return v4;
continue;
}
}
else
{
v6 = *a1;
}
v4 += *((_DWORD *)v11 + v6);
v9 = i + 1;
if ( v3 == i )
return v4;
}
}
return 0;
} | func0:
ENDBR64
PUSH RBX
MOV ECX,0x80
MOV RBX,RDI
SUB RSP,0x410
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV RDI,RBX
MOV RAX,0x1f400000064
MOV dword ptr [RSP + 0x124],0x1
MOV qword ptr [RSP + 0x10c],RAX
MOV RAX,0x3e800000032
MOV qword ptr [RSP + 0x130],RAX
MOV dword ptr [RSP + 0x158],0x5
MOV dword ptr [RSP + 0x160],0xa
CALL 0x00101090
TEST EAX,EAX
JLE 0x00101350
LEA EDI,[RAX + -0x1]
XOR R8D,R8D
XOR EAX,EAX
JMP 0x0010131b
LAB_001012f0:
MOVSX RCX,byte ptr [RBX + RAX*0x1]
MOVSX RSI,byte ptr [RBX + RAX*0x1 + -0x1]
MOV RDX,RCX
MOV ESI,dword ptr [RSP + RSI*0x4]
MOV ECX,dword ptr [RSP + RCX*0x4]
CMP ECX,ESI
JLE 0x00101324
ADD ESI,ESI
LEA RDX,[RAX + 0x1]
SUB ECX,ESI
ADD R8D,ECX
CMP RDI,RAX
JZ 0x00101331
LAB_00101318:
MOV RAX,RDX
LAB_0010131b:
TEST RAX,RAX
JNZ 0x001012f0
MOVSX RDX,byte ptr [RBX]
LAB_00101324:
ADD R8D,dword ptr [RSP + RDX*0x4]
LEA RDX,[RAX + 0x1]
CMP RDI,RAX
JNZ 0x00101318
LAB_00101331:
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101355
ADD RSP,0x410
MOV EAX,R8D
POP RBX
RET
LAB_00101350:
XOR R8D,R8D
JMP 0x00101331
LAB_00101355:
CALL 0x001010a0 | int func0(char *param_1)
{
size_t sVar1;
int iVar2;
long lVar3;
ulong uVar4;
int *piVar5;
int iVar6;
long in_FS_OFFSET;
int aiStack_418 [67];
int8 local_30c;
int4 local_2f4;
int8 local_2e8;
int4 local_2c0;
int4 local_2b8;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar5 = aiStack_418;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)piVar5 = 0;
piVar5 = (int *)((long)piVar5 + 8);
}
local_2f4 = 1;
local_30c = 0x1f400000064;
local_2e8 = 0x3e800000032;
local_2c0 = 5;
local_2b8 = 10;
sVar1 = strlen(param_1);
if ((int)sVar1 < 1) {
iVar6 = 0;
LAB_00101331:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar6;
}
iVar6 = 0;
uVar4 = 0;
do {
if (uVar4 == 0) {
lVar3 = (long)*param_1;
LAB_00101324:
iVar2 = aiStack_418[lVar3];
}
else {
lVar3 = (long)param_1[uVar4];
if (aiStack_418[lVar3] <= aiStack_418[param_1[uVar4 - 1]]) goto LAB_00101324;
iVar2 = aiStack_418[lVar3] + aiStack_418[param_1[uVar4 - 1]] * -2;
}
iVar6 = iVar6 + iVar2;
if ((int)sVar1 - 1 == uVar4) goto LAB_00101331;
uVar4 = uVar4 + 1;
} while( true );
} |
7,739 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(char *s) {
int rom_val[256] = {0};
rom_val['I'] = 1;
rom_val['V'] = 5;
rom_val['X'] = 10;
rom_val['L'] = 50;
rom_val['C'] = 100;
rom_val['D'] = 500;
rom_val['M'] = 1000;
int int_val = 0;
int len = strlen(s);
for (int i = 0; i < len; i++) {
if (i > 0 && rom_val[s[i]] > rom_val[s[i - 1]]) {
int_val += rom_val[s[i]] - 2 * rom_val[s[i - 1]];
} else {
int_val += rom_val[s[i]];
}
}
return int_val;
}
| int main() {
assert(func0("MMMCMLXXXVI") == 3986);
assert(func0("MMMM") == 4000);
assert(func0("C") == 100);
printf("All tests passed successfully.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov $0x80,%ecx
mov %rdi,%rbx
sub $0x410,%rsp
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
mov %rbx,%rdi
movabs $0x1f400000064,%rax
movl $0x1,0x124(%rsp)
mov %rax,0x10c(%rsp)
movabs $0x3e800000032,%rax
movl $0x5,0x158(%rsp)
movl $0xa,0x160(%rsp)
mov %rax,0x130(%rsp)
callq 1090 <strlen@plt>
test %eax,%eax
jle 1350 <func0+0xf0>
lea -0x1(%rax),%edi
xor %r8d,%r8d
xor %eax,%eax
jmp 131b <func0+0xbb>
nopl 0x0(%rax,%rax,1)
movsbq (%rbx,%rax,1),%rcx
movsbq -0x1(%rbx,%rax,1),%rsi
mov %rcx,%rdx
mov (%rsp,%rsi,4),%esi
mov (%rsp,%rcx,4),%ecx
cmp %esi,%ecx
jle 1324 <func0+0xc4>
add %esi,%esi
lea 0x1(%rax),%rdx
sub %esi,%ecx
add %ecx,%r8d
cmp %rdi,%rax
je 1331 <func0+0xd1>
mov %rdx,%rax
test %rax,%rax
jne 12f0 <func0+0x90>
movsbq (%rbx),%rdx
add (%rsp,%rdx,4),%r8d
lea 0x1(%rax),%rdx
cmp %rdi,%rax
jne 1318 <func0+0xb8>
mov 0x408(%rsp),%rax
xor %fs:0x28,%rax
jne 1355 <func0+0xf5>
add $0x410,%rsp
mov %r8d,%eax
pop %rbx
retq
xor %r8d,%r8d
jmp 1331 <func0+0xd1>
callq 10a0 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov ecx, 80h
mov rbx, rdi
sub rsp, 410h
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov rax, cs:qword_20A8
mov rdi, rbx; s
mov [rsp+418h+var_2F4], 1
mov [rsp+418h+var_2C0], 5
mov [rsp+418h+var_30C], rax
mov rax, cs:qword_20B0
mov [rsp+418h+var_2B8], 0Ah
mov [rsp+418h+var_2E8], rax
call _strlen
test eax, eax
jle short loc_1348
lea r8d, [rax-1]
xor ecx, ecx
xor eax, eax
jmp short loc_1312
loc_12E8:
movsx rsi, byte ptr [rbx+rax]
movsx rdi, byte ptr [rbx+rax-1]
mov rdx, rsi
mov edi, [rsp+rdi*4+418h+var_418]
mov esi, [rsp+rsi*4+418h+var_418]
cmp esi, edi
jle short loc_131B
add edi, edi
lea rdx, [rax+1]
sub esi, edi
add ecx, esi
cmp rax, r8
jz short loc_1327
loc_130F:
mov rax, rdx
loc_1312:
test rax, rax
jnz short loc_12E8
movsx rdx, byte ptr [rbx]
loc_131B:
add ecx, [rsp+rdx*4+418h+var_418]
lea rdx, [rax+1]
cmp rax, r8
jnz short loc_130F
loc_1327:
mov rax, [rsp+418h+var_10]
sub rax, fs:28h
jnz short loc_134C
add rsp, 410h
mov eax, ecx
pop rbx
retn
loc_1348:
xor ecx, ecx
jmp short loc_1327
loc_134C:
call ___stack_chk_fail | long long func0(char *s)
{
int v2; // eax
long long v3; // r8
unsigned int v4; // ecx
long long i; // rax
long long v6; // rdx
int v7; // edi
int v8; // esi
long long v9; // rdx
_QWORD v11[131]; // [rsp+0h] [rbp-418h] BYREF
v11[129] = __readfsqword(0x28u);
memset(v11, 0, 0x400uLL);
HIDWORD(v11[36]) = 1;
LODWORD(v11[43]) = 5;
*(_QWORD *)((char *)&v11[33] + 4) = 0x1F400000064LL;
LODWORD(v11[44]) = 10;
v11[38] = 0x3E800000032LL;
v2 = strlen(s);
if ( v2 > 0 )
{
v3 = (unsigned int)(v2 - 1);
v4 = 0;
for ( i = 0LL; ; i = v9 )
{
if ( i )
{
v6 = s[i];
v7 = *((_DWORD *)v11 + s[i - 1]);
v8 = *((_DWORD *)v11 + v6);
if ( v8 > v7 )
{
v9 = i + 1;
v4 += v8 - 2 * v7;
if ( i == v3 )
return v4;
continue;
}
}
else
{
v6 = *s;
}
v4 += *((_DWORD *)v11 + v6);
v9 = i + 1;
if ( i == v3 )
return v4;
}
}
return 0;
} | func0:
ENDBR64
PUSH RBX
MOV ECX,0x80
MOV RBX,RDI
SUB RSP,0x410
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV RAX,qword ptr [0x001020a8]
MOV RDI,RBX
MOV dword ptr [RSP + 0x124],0x1
MOV dword ptr [RSP + 0x158],0x5
MOV qword ptr [RSP + 0x10c],RAX
MOV RAX,qword ptr [0x001020b0]
MOV dword ptr [RSP + 0x160],0xa
MOV qword ptr [RSP + 0x130],RAX
CALL 0x00101090
TEST EAX,EAX
JLE 0x00101348
LEA R8D,[RAX + -0x1]
XOR ECX,ECX
XOR EAX,EAX
JMP 0x00101312
LAB_001012e8:
MOVSX RSI,byte ptr [RBX + RAX*0x1]
MOVSX RDI,byte ptr [RBX + RAX*0x1 + -0x1]
MOV RDX,RSI
MOV EDI,dword ptr [RSP + RDI*0x4]
MOV ESI,dword ptr [RSP + RSI*0x4]
CMP ESI,EDI
JLE 0x0010131b
ADD EDI,EDI
LEA RDX,[RAX + 0x1]
SUB ESI,EDI
ADD ECX,ESI
CMP RAX,R8
JZ 0x00101327
LAB_0010130f:
MOV RAX,RDX
LAB_00101312:
TEST RAX,RAX
JNZ 0x001012e8
MOVSX RDX,byte ptr [RBX]
LAB_0010131b:
ADD ECX,dword ptr [RSP + RDX*0x4]
LEA RDX,[RAX + 0x1]
CMP RAX,R8
JNZ 0x0010130f
LAB_00101327:
MOV RAX,qword ptr [RSP + 0x408]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010134c
ADD RSP,0x410
MOV EAX,ECX
POP RBX
RET
LAB_00101348:
XOR ECX,ECX
JMP 0x00101327
LAB_0010134c:
CALL 0x001010a0 | int func0(char *param_1)
{
size_t sVar1;
int iVar2;
long lVar3;
ulong uVar4;
int iVar5;
int *piVar6;
long in_FS_OFFSET;
int aiStack_418 [67];
int8 local_30c;
int4 local_2f4;
int8 local_2e8;
int4 local_2c0;
int4 local_2b8;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar6 = aiStack_418;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)piVar6 = 0;
piVar6 = (int *)((long)piVar6 + 8);
}
local_2f4 = 1;
local_2c0 = 5;
local_30c = DAT_001020a8;
local_2b8 = 10;
local_2e8 = DAT_001020b0;
sVar1 = strlen(param_1);
if ((int)sVar1 < 1) {
iVar2 = 0;
LAB_00101327:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar2;
}
iVar2 = 0;
uVar4 = 0;
do {
if (uVar4 == 0) {
lVar3 = (long)*param_1;
LAB_0010131b:
iVar5 = aiStack_418[lVar3];
}
else {
lVar3 = (long)param_1[uVar4];
if (aiStack_418[lVar3] <= aiStack_418[param_1[uVar4 - 1]]) goto LAB_0010131b;
iVar5 = aiStack_418[lVar3] + aiStack_418[param_1[uVar4 - 1]] * -2;
}
iVar2 = iVar2 + iVar5;
if (uVar4 == (int)sVar1 - 1) goto LAB_00101327;
uVar4 = uVar4 + 1;
} while( true );
} |
7,740 | func0 |
#include <assert.h>
| int func0(int l, int r) {
return r / 2 * (r / 2 + 1) - (l - 1) / 2 * (l + 1) / 2;
}
| int main() {
assert(func0(2, 5) == 6);
assert(func0(3, 8) == 18);
assert(func0(4, 6) == 10);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x8(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,%ecx
mov -0x8(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
add $0x1,%eax
imul %eax,%ecx
mov %ecx,%edx
mov -0x4(%rbp),%eax
sub $0x1,%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %ecx,%eax
sar %eax
mov %eax,%ecx
mov -0x4(%rbp),%eax
add $0x1,%eax
imul %ecx,%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %ecx,%eax
sar %eax
neg %eax
add %edx,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_8]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov ecx, eax
mov eax, [rbp+var_8]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
add eax, 1
imul ecx, eax
mov edx, ecx
mov eax, [rbp+var_4]
sub eax, 1
mov ecx, eax
shr ecx, 1Fh
add eax, ecx
sar eax, 1
mov ecx, eax
mov eax, [rbp+var_4]
add eax, 1
imul eax, ecx
mov ecx, eax
shr ecx, 1Fh
add eax, ecx
sar eax, 1
neg eax
add eax, edx
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)((a2 / 2 + 1) * (a2 / 2) + (a1 - 1) / 2 * (a1 + 1) / -2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x8]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x8]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
ADD EAX,0x1
IMUL ECX,EAX
MOV EDX,ECX
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
MOV ECX,EAX
SHR ECX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
IMUL EAX,ECX
MOV ECX,EAX
SHR ECX,0x1f
ADD EAX,ECX
SAR EAX,0x1
NEG EAX
ADD EAX,EDX
POP RBP
RET | int func0(int param_1,int param_2)
{
return (param_2 / 2) * (param_2 / 2 + 1) - ((param_1 + 1) * ((param_1 + -1) / 2)) / 2;
} |
7,741 | func0 |
#include <assert.h>
| int func0(int l, int r) {
return r / 2 * (r / 2 + 1) - (l - 1) / 2 * (l + 1) / 2;
}
| int main() {
assert(func0(2, 5) == 6);
assert(func0(3, 8) == 18);
assert(func0(4, 6) == 10);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%edx
mov %esi,%eax
shr $0x1f,%eax
lea (%rax,%rsi,1),%eax
sar %eax
mov %eax,%ecx
lea -0x1(%rdi),%eax
mov %eax,%edi
shr $0x1f,%edi
add %eax,%edi
sar %edi
add $0x1,%edx
imul %edx,%edi
mov %edi,%edx
shr $0x1f,%edx
add %edx,%edi
sar %edi
lea 0x1(%rcx),%eax
imul %ecx,%eax
sub %edi,%eax
retq
| func0:
endbr64
mov edx, edi
mov eax, esi
shr eax, 1Fh
lea ecx, [rax+rsi]
sar ecx, 1
lea eax, [rdi-1]
mov edi, eax
shr edi, 1Fh
add edi, eax
sar edi, 1
add edx, 1
imul edi, edx
mov edx, edi
shr edx, 1Fh
add edx, edi
sar edx, 1
lea eax, [rcx+1]
imul eax, ecx
sub eax, edx
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a2 / 2 * (a2 / 2 + 1) - (a1 + 1) * ((a1 - 1) / 2) / 2);
} | func0:
ENDBR64
MOV EDX,EDI
MOV EAX,ESI
SHR EAX,0x1f
LEA ECX,[RAX + RSI*0x1]
SAR ECX,0x1
LEA EAX,[RDI + -0x1]
MOV EDI,EAX
SHR EDI,0x1f
ADD EDI,EAX
SAR EDI,0x1
ADD EDX,0x1
IMUL EDI,EDX
MOV EDX,EDI
SHR EDX,0x1f
ADD EDX,EDI
SAR EDX,0x1
LEA EAX,[RCX + 0x1]
IMUL EAX,ECX
SUB EAX,EDX
RET | int func0(int param_1,int param_2)
{
return (param_2 / 2 + 1) * (param_2 / 2) - (((param_1 + -1) / 2) * (param_1 + 1)) / 2;
} |
7,742 | func0 |
#include <assert.h>
| int func0(int l, int r) {
return r / 2 * (r / 2 + 1) - (l - 1) / 2 * (l + 1) / 2;
}
| int main() {
assert(func0(2, 5) == 6);
assert(func0(3, 8) == 18);
assert(func0(4, 6) == 10);
return 0;
}
| O2 | c | func0:
endbr64
mov %esi,%eax
mov %edi,%edx
shr $0x1f,%eax
add $0x1,%edx
add %esi,%eax
sar %eax
mov %eax,%ecx
lea -0x1(%rdi),%eax
mov %eax,%edi
shr $0x1f,%edi
add %eax,%edi
lea 0x1(%rcx),%eax
sar %edi
imul %ecx,%eax
imul %edx,%edi
mov %edi,%edx
shr $0x1f,%edx
add %edx,%edi
sar %edi
sub %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, esi
mov edx, edi
shr eax, 1Fh
add edx, 1
lea ecx, [rax+rsi]
lea eax, [rdi-1]
mov edi, eax
sar ecx, 1
shr edi, 1Fh
add edi, eax
lea eax, [rcx+1]
sar edi, 1
imul eax, ecx
imul edi, edx
mov edx, edi
shr edx, 1Fh
add edx, edi
sar edx, 1
sub eax, edx
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a2 / 2 * (a2 / 2 + 1) - (a1 + 1) * ((a1 - 1) / 2) / 2);
} | func0:
ENDBR64
MOV EAX,ESI
MOV EDX,EDI
SHR EAX,0x1f
ADD EDX,0x1
LEA ECX,[RAX + RSI*0x1]
LEA EAX,[RDI + -0x1]
MOV EDI,EAX
SAR ECX,0x1
SHR EDI,0x1f
ADD EDI,EAX
LEA EAX,[RCX + 0x1]
SAR EDI,0x1
IMUL EAX,ECX
IMUL EDI,EDX
MOV EDX,EDI
SHR EDX,0x1f
ADD EDX,EDI
SAR EDX,0x1
SUB EAX,EDX
RET | int func0(int param_1,int param_2)
{
return (param_2 / 2 + 1) * (param_2 / 2) - (((param_1 + -1) / 2) * (param_1 + 1)) / 2;
} |
7,743 | func0 |
#include <assert.h>
| int func0(int l, int r) {
return r / 2 * (r / 2 + 1) - (l - 1) / 2 * (l + 1) / 2;
}
| int main() {
assert(func0(2, 5) == 6);
assert(func0(3, 8) == 18);
assert(func0(4, 6) == 10);
return 0;
}
| O3 | c | func0:
endbr64
mov %esi,%eax
mov %edi,%edx
shr $0x1f,%eax
add $0x1,%edx
add %esi,%eax
sar %eax
mov %eax,%ecx
lea -0x1(%rdi),%eax
mov %eax,%edi
shr $0x1f,%edi
add %eax,%edi
lea 0x1(%rcx),%eax
sar %edi
imul %ecx,%eax
imul %edx,%edi
mov %edi,%edx
shr $0x1f,%edx
add %edx,%edi
sar %edi
sub %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, esi
mov edx, edi
shr eax, 1Fh
add edx, 1
lea ecx, [rax+rsi]
lea eax, [rdi-1]
mov edi, eax
sar ecx, 1
shr edi, 1Fh
add edi, eax
lea eax, [rcx+1]
sar edi, 1
imul eax, ecx
imul edi, edx
mov edx, edi
shr edx, 1Fh
add edx, edi
sar edx, 1
sub eax, edx
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a2 / 2 * (a2 / 2 + 1) - (a1 + 1) * ((a1 - 1) / 2) / 2);
} | func0:
ENDBR64
MOV EAX,ESI
MOV EDX,EDI
SHR EAX,0x1f
ADD EDX,0x1
LEA ECX,[RAX + RSI*0x1]
LEA EAX,[RDI + -0x1]
MOV EDI,EAX
SAR ECX,0x1
SHR EDI,0x1f
ADD EDI,EAX
LEA EAX,[RCX + 0x1]
SAR EDI,0x1
IMUL EAX,ECX
IMUL EDI,EDX
MOV EDX,EDI
SHR EDX,0x1f
ADD EDX,EDI
SAR EDX,0x1
SUB EAX,EDX
RET | int func0(int param_1,int param_2)
{
return (param_2 / 2 + 1) * (param_2 / 2) - (((param_1 + -1) / 2) * (param_1 + 1)) / 2;
} |
7,744 | func0 | #include <assert.h>
#include <stdio.h>
#include <string.h>
typedef struct {
char *description;
int value;
} Result;
| Result func0(int x, int y, int z) {
int discriminant = (y * y) - (4 * x * z);
Result result;
if (discriminant > 0) {
result.description = "Two solutions";
result.value = discriminant;
} else if (discriminant == 0) {
result.description = "one solution";
result.value = discriminant;
} else {
result.description = "no real solution";
result.value = discriminant;
}
return result;
}
| int main() {
Result res;
res = func0(4, 8, 2);
assert(res.value == 32 && strcmp(res.description, "Two solutions") == 0);
res = func0(5, 7, 9);
assert(res.value == -131 && strcmp(res.description, "no real solution") == 0);
res = func0(0, 0, 9);
assert(res.value == 0 && strcmp(res.description, "one solution") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
mov %esi,-0x28(%rbp)
mov %edx,-0x2c(%rbp)
mov -0x28(%rbp),%eax
imul %eax,%eax
mov %eax,%edx
mov -0x24(%rbp),%eax
imul -0x2c(%rbp),%eax
shl $0x2,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jle 11ac <func0+0x43>
lea 0xe68(%rip),%rax
mov %rax,-0x10(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 11d6 <func0+0x6d>
cmpl $0x0,-0x14(%rbp)
jne 11c5 <func0+0x5c>
lea 0xe5d(%rip),%rax
mov %rax,-0x10(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 11d6 <func0+0x6d>
lea 0xe57(%rip),%rax
mov %rax,-0x10(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
mov -0x10(%rbp),%rax
mov -0x8(%rbp),%rdx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
mov [rbp+var_28], esi
mov [rbp+var_2C], edx
mov eax, [rbp+var_28]
imul eax, eax
mov ecx, eax
mov eax, [rbp+var_24]
imul eax, [rbp+var_2C]
lea edx, ds:0[rax*4]
mov eax, ecx
sub eax, edx
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jle short loc_11B0
lea rax, s2; "Two solutions"
mov [rbp+var_10], rax
mov eax, [rbp+var_14]
mov dword ptr [rbp+var_8], eax
jmp short loc_11DA
loc_11B0:
cmp [rbp+var_14], 0
jnz short loc_11C9
lea rax, aOneSolution; "one solution"
mov [rbp+var_10], rax
mov eax, [rbp+var_14]
mov dword ptr [rbp+var_8], eax
jmp short loc_11DA
loc_11C9:
lea rax, aNoRealSolution; "no real solution"
mov [rbp+var_10], rax
mov eax, [rbp+var_14]
mov dword ptr [rbp+var_8], eax
loc_11DA:
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
pop rbp
retn | const char * func0(int a1, int a2, int a3)
{
int v4; // [rsp+18h] [rbp-14h]
v4 = a2 * a2 - 4 * a3 * a1;
if ( v4 > 0 )
return "Two solutions";
if ( v4 )
return "no real solution";
return "one solution";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x28],ESI
MOV dword ptr [RBP + -0x2c],EDX
MOV EAX,dword ptr [RBP + -0x28]
IMUL EAX,EAX
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x24]
IMUL EAX,dword ptr [RBP + -0x2c]
LEA EDX,[RAX*0x4]
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JLE 0x001011b0
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011da
LAB_001011b0:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x001011c9
LEA RAX,[0x102016]
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011da
LAB_001011c9:
LEA RAX,[0x102023]
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
LAB_001011da:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
POP RBP
RET | int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
int iVar2;
char *local_18;
int4 uStack_c;
iVar2 = param_2 * param_2 + param_1 * param_3 * -4;
if (iVar2 < 1) {
if (iVar2 == 0) {
local_18 = "one solution";
}
else {
local_18 = "no real solution";
}
}
else {
local_18 = "Two solutions";
}
auVar1._8_4_ = iVar2;
auVar1._0_8_ = local_18;
auVar1._12_4_ = uStack_c;
return auVar1;
} |
7,745 | func0 | #include <assert.h>
#include <stdio.h>
#include <string.h>
typedef struct {
char *description;
int value;
} Result;
| Result func0(int x, int y, int z) {
int discriminant = (y * y) - (4 * x * z);
Result result;
if (discriminant > 0) {
result.description = "Two solutions";
result.value = discriminant;
} else if (discriminant == 0) {
result.description = "one solution";
result.value = discriminant;
} else {
result.description = "no real solution";
result.value = discriminant;
}
return result;
}
| int main() {
Result res;
res = func0(4, 8, 2);
assert(res.value == 32 && strcmp(res.description, "Two solutions") == 0);
res = func0(5, 7, 9);
assert(res.value == -131 && strcmp(res.description, "no real solution") == 0);
res = func0(0, 0, 9);
assert(res.value == 0 && strcmp(res.description, "one solution") == 0);
return 0;
}
| O1 | c | func0:
endbr64
imul %esi,%esi
imul %edx,%edi
shl $0x2,%edi
sub %edi,%esi
lea 0xec5(%rip),%rax
test %esi,%esi
jle 1146 <func0+0x1d>
mov %esi,%edx
retq
lea 0xec5(%rip),%rax
lea 0xecb(%rip),%rdx
cmovne %rdx,%rax
jmp 1143 <func0+0x1a>
| func0:
endbr64
imul esi, esi
imul edi, edx
shl edi, 2
sub esi, edi
lea rax, aTwoSolutions; "Two solutions"
test esi, esi
jle short loc_1146
loc_1143:
mov edx, esi
retn
loc_1146:
lea rax, aOneSolution; "one solution"
lea rdx, aNoRealSolution; "no real solution"
cmovnz rax, rdx
jmp short loc_1143 | const char * func0(int a1, int a2, int a3)
{
int v3; // esi
const char *result; // rax
v3 = a2 * a2 - 4 * a3 * a1;
result = "Two solutions";
if ( v3 <= 0 )
{
result = "one solution";
if ( v3 )
return "no real solution";
}
return result;
} | func0:
ENDBR64
IMUL ESI,ESI
IMUL EDI,EDX
SHL EDI,0x2
SUB ESI,EDI
LEA RAX,[0x102004]
TEST ESI,ESI
JLE 0x00101146
LAB_00101143:
MOV EDX,ESI
RET
LAB_00101146:
LEA RAX,[0x102012]
LEA RDX,[0x10201f]
CMOVNZ RAX,RDX
JMP 0x00101143 | int1 [16] func0(int param_1,int param_2,int param_3)
{
char *pcVar1;
int iVar2;
int1 auVar3 [16];
iVar2 = param_2 * param_2 + param_1 * param_3 * -4;
pcVar1 = "Two solutions";
if ((iVar2 < 1) && (pcVar1 = "one solution", iVar2 != 0)) {
pcVar1 = "no real solution";
}
auVar3._8_4_ = iVar2;
auVar3._0_8_ = pcVar1;
auVar3._12_4_ = 0;
return auVar3;
} |
7,746 | func0 | #include <assert.h>
#include <stdio.h>
#include <string.h>
typedef struct {
char *description;
int value;
} Result;
| Result func0(int x, int y, int z) {
int discriminant = (y * y) - (4 * x * z);
Result result;
if (discriminant > 0) {
result.description = "Two solutions";
result.value = discriminant;
} else if (discriminant == 0) {
result.description = "one solution";
result.value = discriminant;
} else {
result.description = "no real solution";
result.value = discriminant;
}
return result;
}
| int main() {
Result res;
res = func0(4, 8, 2);
assert(res.value == 32 && strcmp(res.description, "Two solutions") == 0);
res = func0(5, 7, 9);
assert(res.value == -131 && strcmp(res.description, "no real solution") == 0);
res = func0(0, 0, 9);
assert(res.value == 0 && strcmp(res.description, "one solution") == 0);
return 0;
}
| O2 | c | func0:
endbr64
imul %edx,%edi
lea 0xeb6(%rip),%rax
imul %esi,%esi
shl $0x2,%edi
sub %edi,%esi
test %esi,%esi
jg 116c <func0+0x2c>
lea 0xeb1(%rip),%rax
lea 0xeb7(%rip),%rdx
cmovne %rdx,%rax
mov %esi,%edx
retq
| func0:
endbr64
imul edi, edx
lea rax, aTwoSolutions; "Two solutions"
imul esi, esi
shl edi, 2
sub esi, edi
test esi, esi
jg short loc_116C
lea rax, aOneSolution; "one solution"
lea rdx, aNoRealSolution; "no real solution"
cmovnz rax, rdx
loc_116C:
mov edx, esi
retn | const char * func0(int a1, int a2, int a3)
{
const char *result; // rax
int v4; // esi
result = "Two solutions";
v4 = a2 * a2 - 4 * a3 * a1;
if ( v4 <= 0 )
{
result = "one solution";
if ( v4 )
return "no real solution";
}
return result;
} | func0:
ENDBR64
IMUL EDI,EDX
LEA RAX,[0x102004]
IMUL ESI,ESI
SHL EDI,0x2
SUB ESI,EDI
TEST ESI,ESI
JG 0x0010116c
LEA RAX,[0x102012]
LEA RDX,[0x10201f]
CMOVNZ RAX,RDX
LAB_0010116c:
MOV EDX,ESI
RET | int1 [16] func0(int param_1,int param_2,int param_3)
{
char *pcVar1;
int iVar2;
int1 auVar3 [16];
pcVar1 = "Two solutions";
iVar2 = param_2 * param_2 + param_1 * param_3 * -4;
if ((iVar2 < 1) && (pcVar1 = "one solution", iVar2 != 0)) {
pcVar1 = "no real solution";
}
auVar3._8_4_ = iVar2;
auVar3._0_8_ = pcVar1;
auVar3._12_4_ = 0;
return auVar3;
} |
7,747 | func0 | #include <assert.h>
#include <stdio.h>
#include <string.h>
typedef struct {
char *description;
int value;
} Result;
| Result func0(int x, int y, int z) {
int discriminant = (y * y) - (4 * x * z);
Result result;
if (discriminant > 0) {
result.description = "Two solutions";
result.value = discriminant;
} else if (discriminant == 0) {
result.description = "one solution";
result.value = discriminant;
} else {
result.description = "no real solution";
result.value = discriminant;
}
return result;
}
| int main() {
Result res;
res = func0(4, 8, 2);
assert(res.value == 32 && strcmp(res.description, "Two solutions") == 0);
res = func0(5, 7, 9);
assert(res.value == -131 && strcmp(res.description, "no real solution") == 0);
res = func0(0, 0, 9);
assert(res.value == 0 && strcmp(res.description, "one solution") == 0);
return 0;
}
| O3 | c | func0:
endbr64
imul %edx,%edi
lea 0xeb6(%rip),%rax
imul %esi,%esi
shl $0x2,%edi
sub %edi,%esi
test %esi,%esi
jg 116c <func0+0x2c>
lea 0xeb1(%rip),%rax
lea 0xeb7(%rip),%rdx
cmovne %rdx,%rax
mov %esi,%edx
retq
| func0:
endbr64
imul edi, edx
lea rax, aTwoSolutions; "Two solutions"
imul esi, esi
shl edi, 2
sub esi, edi
test esi, esi
jg short loc_116C
lea rax, aNoRealSolution; "no real solution"
lea rdx, aOneSolution; "one solution"
cmovz rax, rdx
loc_116C:
mov edx, esi
retn | const char * func0(int a1, int a2, int a3)
{
const char *result; // rax
int v4; // esi
result = "Two solutions";
v4 = a2 * a2 - 4 * a3 * a1;
if ( v4 <= 0 )
{
result = "no real solution";
if ( !v4 )
return "one solution";
}
return result;
} | func0:
ENDBR64
IMUL EDI,EDX
LEA RAX,[0x102004]
IMUL ESI,ESI
SHL EDI,0x2
SUB ESI,EDI
TEST ESI,ESI
JG 0x0010116c
LEA RAX,[0x10201f]
LEA RDX,[0x102012]
CMOVZ RAX,RDX
LAB_0010116c:
MOV EDX,ESI
RET | int [16] func0(int param_1,int param_2,int param_3)
{
char *pcVar1;
int iVar2;
int auVar3 [16];
pcVar1 = "Two solutions";
iVar2 = param_2 * param_2 + param_1 * param_3 * -4;
if ((iVar2 < 1) && (pcVar1 = "no real solution", iVar2 == 0)) {
pcVar1 = "one solution";
}
auVar3._8_4_ = iVar2;
auVar3._0_8_ = pcVar1;
auVar3._12_4_ = 0;
return auVar3;
} |
7,748 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(char* s) {
char *word = strtok(s, " ");
while(word != NULL) {
if(strlen(word) % 2 == 0) {
return 1;
} else {
return 0;
}
word = strtok(NULL, " ");
}
return 0;
}
| int main() {
assert(func0("program") == 0);
assert(func0("solution") == 1);
assert(func0("data") == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
lea 0xe64(%rip),%rsi
mov %rax,%rdi
callq 1090 <strtok@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
je 11d9 <func0+0x50>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
and $0x1,%eax
test %rax,%rax
jne 11d2 <func0+0x49>
mov $0x1,%eax
jmp 11de <func0+0x55>
mov $0x0,%eax
jmp 11de <func0+0x55>
mov $0x0,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
lea rdx, delim; " "
mov rsi, rdx; delim
mov rdi, rax; s
call _strtok
mov [rbp+var_8], rax
nop
cmp [rbp+var_8], 0
jz short loc_11DD
mov rax, [rbp+var_8]
mov rdi, rax; s
call _strlen
and eax, 1
test rax, rax
jnz short loc_11D6
mov eax, 1
jmp short locret_11E2
loc_11D6:
mov eax, 0
jmp short locret_11E2
loc_11DD:
mov eax, 0
locret_11E2:
leave
retn | _BOOL8 func0(char *a1)
{
const char *v2; // [rsp+18h] [rbp-8h]
v2 = strtok(a1, " ");
return v2 && (strlen(v2) & 1) == 0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x102004]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101090
MOV qword ptr [RBP + -0x8],RAX
NOP
CMP qword ptr [RBP + -0x8],0x0
JZ 0x001011dd
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101070
AND EAX,0x1
TEST RAX,RAX
JNZ 0x001011d6
MOV EAX,0x1
JMP 0x001011e2
LAB_001011d6:
MOV EAX,0x0
JMP 0x001011e2
LAB_001011dd:
MOV EAX,0x0
LAB_001011e2:
LEAVE
RET | int8 func0(char *param_1)
{
char *__s;
size_t sVar1;
int8 uVar2;
__s = strtok(param_1," ");
if (__s == (char *)0x0) {
uVar2 = 0;
}
else {
sVar1 = strlen(__s);
if ((sVar1 & 1) == 0) {
uVar2 = 1;
}
else {
uVar2 = 0;
}
}
return uVar2;
} |
7,749 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(char* s) {
char *word = strtok(s, " ");
while(word != NULL) {
if(strlen(word) % 2 == 0) {
return 1;
} else {
return 0;
}
word = strtok(NULL, " ");
}
return 0;
}
| int main() {
assert(func0("program") == 0);
assert(func0("solution") == 1);
assert(func0("data") == 1);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
lea 0xe8c(%rip),%rsi
callq 1070 <strtok@plt>
mov %rax,%rdi
mov $0x0,%eax
test %rdi,%rdi
je 119c <func0+0x33>
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
and $0x1,%eax
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
lea rsi, unk_2004
call _strtok
mov rdi, rax
mov eax, 0
test rdi, rdi
jz short loc_11B6
call _strlen
xor rax, 1
and eax, 1
loc_11B6:
add rsp, 8
retn | long long func0(long long a1)
{
long long v1; // rdi
long long result; // rax
v1 = strtok(a1, &unk_2004);
result = 0LL;
if ( v1 )
return ((unsigned __int8)strlen() ^ 1) & 1;
return result;
} | func0:
ENDBR64
SUB RSP,0x8
LEA RSI,[0x102004]
CALL 0x00101090
MOV RDI,RAX
MOV EAX,0x0
TEST RDI,RDI
JZ 0x001011b6
CALL 0x00101070
XOR RAX,0x1
AND EAX,0x1
LAB_001011b6:
ADD RSP,0x8
RET | uint func0(char *param_1)
{
uint uVar1;
char *__s;
size_t sVar2;
__s = strtok(param_1," ");
uVar1 = 0;
if (__s != (char *)0x0) {
sVar2 = strlen(__s);
uVar1 = ((uint)sVar2 ^ 1) & 1;
}
return uVar1;
} |
7,750 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(char* s) {
char *word = strtok(s, " ");
while(word != NULL) {
if(strlen(word) % 2 == 0) {
return 1;
} else {
return 0;
}
word = strtok(NULL, " ");
}
return 0;
}
| int main() {
assert(func0("program") == 0);
assert(func0("solution") == 1);
assert(func0("data") == 1);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x8,%rsp
lea 0xdc5(%rip),%rsi
callq 1090 <strtok@plt>
mov %rax,%rdi
xor %eax,%eax
test %rdi,%rdi
je 1259 <func0+0x29>
callq 1070 <strlen@plt>
not %rax
and $0x1,%eax
add $0x8,%rsp
retq
xchg %ax,%ax
| func0:
endbr64
sub rsp, 8
lea rsi, unk_2004
call _strtok
mov rdi, rax
xor eax, eax
test rdi, rdi
jz short loc_1259
call _strlen
not rax
and eax, 1
loc_1259:
add rsp, 8
retn | _BOOL8 func0(long long a1)
{
long long v1; // rdi
_BOOL8 result; // rax
v1 = strtok(a1, &unk_2004);
result = 0LL;
if ( v1 )
return (strlen() & 1) == 0;
return result;
} | func0:
ENDBR64
SUB RSP,0x8
LEA RSI,[0x102004]
CALL 0x00101090
MOV RDI,RAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101259
CALL 0x00101070
NOT RAX
AND EAX,0x1
LAB_00101259:
ADD RSP,0x8
RET | uint func0(char *param_1)
{
uint uVar1;
char *__s;
size_t sVar2;
__s = strtok(param_1," ");
uVar1 = 0;
if (__s != (char *)0x0) {
sVar2 = strlen(__s);
uVar1 = ~(uint)sVar2 & 1;
}
return uVar1;
} |
7,751 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(char* s) {
char *word = strtok(s, " ");
while(word != NULL) {
if(strlen(word) % 2 == 0) {
return 1;
} else {
return 0;
}
word = strtok(NULL, " ");
}
return 0;
}
| int main() {
assert(func0("program") == 0);
assert(func0("solution") == 1);
assert(func0("data") == 1);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x8,%rsp
lea 0xdc5(%rip),%rsi
callq 1090 <strtok@plt>
mov %rax,%rdi
xor %eax,%eax
test %rdi,%rdi
je 1259 <func0+0x29>
callq 1070 <strlen@plt>
not %rax
and $0x1,%eax
add $0x8,%rsp
retq
xchg %ax,%ax
| func0:
endbr64
sub rsp, 8
lea rsi, delim; " "
call _strtok
mov rdi, rax; s
xor eax, eax
test rdi, rdi
jz short loc_1259
call _strlen
not rax
and eax, 1
loc_1259:
add rsp, 8
retn | _BOOL8 func0(char *a1)
{
char *v1; // rdi
_BOOL8 result; // rax
v1 = strtok(a1, " ");
result = 0LL;
if ( v1 )
return (strlen(v1) & 1) == 0;
return result;
} | func0:
ENDBR64
SUB RSP,0x8
LEA RSI,[0x102004]
CALL 0x00101090
MOV RDI,RAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101259
CALL 0x00101070
NOT RAX
AND EAX,0x1
LAB_00101259:
ADD RSP,0x8
RET | uint func0(char *param_1)
{
uint uVar1;
char *__s;
size_t sVar2;
__s = strtok(param_1," ");
uVar1 = 0;
if (__s != (char *)0x0) {
sVar2 = strlen(__s);
uVar1 = ~(uint)sVar2 & 1;
}
return uVar1;
} |
7,752 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* text) {
static char buffer[100];
int i = 0, j = 0;
while (text[i] != '\0') {
if (isupper(text[i])) {
if (i != 0 && (islower(text[i-1]) || isdigit(text[i-1]))) {
buffer[j++] = '_';
}
buffer[j++] = tolower(text[i]);
} else {
buffer[j++] = text[i];
}
i++;
}
buffer[j] = '\0';
return buffer;
}
| int main() {
assert(strcmp(func0("PythonProgram"), "python_program") == 0);
assert(strcmp(func0("pythonLanguage"), "python_language") == 0);
assert(strcmp(func0("ProgrammingLanguage"), "programming_language") == 0);
printf("All assertions passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 1308 <func0+0x13f>
callq 10d0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x100,%eax
test %eax,%eax
je 12de <func0+0x115>
cmpl $0x0,-0x8(%rbp)
je 12ab <func0+0xe2>
callq 10d0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
lea -0x1(%rdx),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x200,%eax
test %eax,%eax
jne 1295 <func0+0xcc>
callq 10d0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
lea -0x1(%rdx),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x800,%eax
test %eax,%eax
je 12ab <func0+0xe2>
mov -0x4(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x4(%rbp)
cltq
lea 0x2d99(%rip),%rdx
movb $0x5f,(%rax,%rdx,1)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
mov %eax,%edi
callq 10c0 <tolower@plt>
mov %eax,%ecx
mov -0x4(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x4(%rbp)
cltq
lea 0x2d67(%rip),%rdx
mov %cl,(%rax,%rdx,1)
jmp 1304 <func0+0x13b>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x4(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x4(%rbp)
movzbl (%rcx),%edx
cltq
lea 0x2d3f(%rip),%rcx
mov %dl,(%rax,%rcx,1)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11ec <func0+0x23>
mov -0x4(%rbp),%eax
cltq
lea 0x2d14(%rip),%rdx
movb $0x0,(%rax,%rdx,1)
lea 0x2d09(%rip),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp loc_1308
loc_11EC:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rcx, edx
mov rdx, [rbp+var_18]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 100h
test eax, eax
jz loc_12DE
cmp [rbp+var_8], 0
jz loc_12AB
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rdx, edx
lea rcx, [rdx-1]
mov rdx, [rbp+var_18]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 200h
test eax, eax
jnz short loc_1295
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rdx, edx
lea rcx, [rdx-1]
mov rdx, [rbp+var_18]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 800h
test eax, eax
jz short loc_12AB
loc_1295:
mov eax, [rbp+var_4]
lea edx, [rax+1]
mov [rbp+var_4], edx
cdqe
lea rdx, buffer_1
mov byte ptr [rax+rdx], 5Fh ; '_'
loc_12AB:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
mov edi, eax; c
call _tolower
mov ecx, eax
mov eax, [rbp+var_4]
lea edx, [rax+1]
mov [rbp+var_4], edx
cdqe
lea rdx, buffer_1
mov [rax+rdx], cl
jmp short loc_1304
loc_12DE:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_4]
lea edx, [rax+1]
mov [rbp+var_4], edx
movzx edx, byte ptr [rcx]
cdqe
lea rcx, buffer_1
mov [rax+rcx], dl
loc_1304:
add [rbp+var_8], 1
loc_1308:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_11EC
mov eax, [rbp+var_4]
cdqe
lea rdx, buffer_1
mov byte ptr [rax+rdx], 0
lea rax, buffer_1
leave
retn | _BYTE * func0(long long a1)
{
int v1; // eax
char v2; // cl
int v3; // eax
int v4; // eax
int v6; // [rsp+18h] [rbp-8h]
int v7; // [rsp+1Ch] [rbp-4h]
v6 = 0;
v7 = 0;
while ( *(_BYTE *)(v6 + a1) )
{
if ( ((*__ctype_b_loc())[*(char *)(v6 + a1)] & 0x100) != 0 )
{
if ( v6
&& (((*__ctype_b_loc())[*(char *)(v6 - 1LL + a1)] & 0x200) != 0
|| ((*__ctype_b_loc())[*(char *)(v6 - 1LL + a1)] & 0x800) != 0) )
{
v1 = v7++;
buffer_1[v1] = 95;
}
v2 = tolower(*(char *)(v6 + a1));
v3 = v7++;
buffer_1[v3] = v2;
}
else
{
v4 = v7++;
buffer_1[v4] = *(_BYTE *)(v6 + a1);
}
++v6;
}
buffer_1[v7] = 0;
return buffer_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101308
LAB_001011ec:
CALL 0x001010d0
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x100
TEST EAX,EAX
JZ 0x001012de
CMP dword ptr [RBP + -0x8],0x0
JZ 0x001012ab
CALL 0x001010d0
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
LEA RCX,[RDX + -0x1]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x200
TEST EAX,EAX
JNZ 0x00101295
CALL 0x001010d0
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
LEA RCX,[RDX + -0x1]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x800
TEST EAX,EAX
JZ 0x001012ab
LAB_00101295:
MOV EAX,dword ptr [RBP + -0x4]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x4],EDX
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x5f
LAB_001012ab:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
MOV EDI,EAX
CALL 0x001010c0
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x4]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x4],EDX
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],CL
JMP 0x00101304
LAB_001012de:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x4]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x4],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
LEA RCX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_00101304:
ADD dword ptr [RBP + -0x8],0x1
LAB_00101308:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011ec
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
LEA RAX,[0x104040]
LEAVE
RET | int1 * func0(long param_1)
{
int iVar1;
ushort **ppuVar2;
int local_10;
int local_c;
local_10 = 0;
local_c = 0;
do {
if (*(char *)(param_1 + local_10) == '\0') {
buffer_1[local_c] = 0;
return buffer_1;
}
ppuVar2 = __ctype_b_loc();
if (((*ppuVar2)[*(char *)(param_1 + local_10)] & 0x100) == 0) {
buffer_1[local_c] = *(int *)(local_10 + param_1);
}
else {
if (local_10 != 0) {
ppuVar2 = __ctype_b_loc();
if (((*ppuVar2)[*(char *)(param_1 + (long)local_10 + -1)] & 0x200) == 0) {
ppuVar2 = __ctype_b_loc();
if (((*ppuVar2)[*(char *)(param_1 + (long)local_10 + -1)] & 0x800) == 0)
goto LAB_001012ab;
}
buffer_1[local_c] = 0x5f;
local_c = local_c + 1;
}
LAB_001012ab:
iVar1 = tolower((int)*(char *)(param_1 + local_10));
buffer_1[local_c] = (char)iVar1;
}
local_c = local_c + 1;
local_10 = local_10 + 1;
} while( true );
} |
7,753 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* text) {
static char buffer[100];
int i = 0, j = 0;
while (text[i] != '\0') {
if (isupper(text[i])) {
if (i != 0 && (islower(text[i-1]) || isdigit(text[i-1]))) {
buffer[j++] = '_';
}
buffer[j++] = tolower(text[i]);
} else {
buffer[j++] = text[i];
}
i++;
}
buffer[j] = '\0';
return buffer;
}
| int main() {
assert(strcmp(func0("PythonProgram"), "python_program") == 0);
assert(strcmp(func0("pythonLanguage"), "python_language") == 0);
assert(strcmp(func0("ProgrammingLanguage"), "programming_language") == 0);
printf("All assertions passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%r12d
test %r12b,%r12b
je 124c <func0+0xa3>
mov %rdi,%r13
callq 10b0 <__ctype_b_loc@plt>
mov %rax,%r14
mov $0x0,%ebx
mov $0x0,%ebp
lea 0x2e5c(%rip),%r15
jmp 1213 <func0+0x6a>
callq 10a0 <__ctype_tolower_loc@plt>
mov %rax,%rdx
movslq %ebp,%rax
movsbq 0x0(%r13,%rbx,1),%rcx
mov (%rdx),%rdx
mov (%rdx,%rcx,4),%edx
mov %dl,(%r15,%rax,1)
lea 0x1(%rbp),%ebp
add $0x1,%rbx
movzbl 0x0(%r13,%rbx,1),%r12d
test %r12b,%r12b
je 1251 <func0+0xa8>
mov (%r14),%rax
movsbq %r12b,%rdx
testb $0x1,0x1(%rax,%rdx,2)
je 1240 <func0+0x97>
test %ebx,%ebx
je 11e6 <func0+0x3d>
movsbq -0x1(%r13,%rbx,1),%rdx
testw $0xa00,(%rax,%rdx,2)
je 11e6 <func0+0x3d>
movslq %ebp,%rax
movb $0x5f,(%r15,%rax,1)
lea 0x1(%rbp),%ebp
jmp 11e6 <func0+0x3d>
movslq %ebp,%rax
mov %r12b,(%r15,%rax,1)
lea 0x1(%rbp),%ebp
jmp 1204 <func0+0x5b>
mov $0x0,%ebp
lea 0x2de8(%rip),%rax
movslq %ebp,%rbp
movb $0x0,(%rax,%rbp,1)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
movzx r12d, byte ptr [rdi]
test r12b, r12b
jz loc_126C
mov r13, rdi
call ___ctype_b_loc
mov r14, rax
mov ebx, 0
mov ebp, 0
lea r15, buffer_1
jmp short loc_1233
loc_1206:
call ___ctype_tolower_loc
mov rdx, rax
movsxd rax, ebp
movsx rcx, byte ptr [r13+rbx+0]
mov rdx, [rdx]
mov edx, [rdx+rcx*4]
mov [r15+rax], dl
lea ebp, [rbp+1]
loc_1224:
add rbx, 1
movzx r12d, byte ptr [r13+rbx+0]
test r12b, r12b
jz short loc_1271
loc_1233:
mov rax, [r14]
movsx rdx, r12b
test byte ptr [rax+rdx*2+1], 1
jz short loc_1260
test ebx, ebx
jz short loc_1206
movsx rdx, byte ptr [r13+rbx-1]
test word ptr [rax+rdx*2], 0A00h
jz short loc_1206
movsxd rax, ebp
mov byte ptr [r15+rax], 5Fh ; '_'
lea ebp, [rbp+1]
jmp short loc_1206
loc_1260:
movsxd rax, ebp
mov [r15+rax], r12b
lea ebp, [rbp+1]
jmp short loc_1224
loc_126C:
mov ebp, 0
loc_1271:
lea rax, buffer_1
movsxd rbp, ebp
mov byte ptr [rax+rbp], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | _BYTE * func0(char *a1)
{
char v1; // r12
_QWORD *v2; // r14
long long v3; // rbx
int v4; // ebp
_BYTE *result; // rax
v1 = *a1;
if ( *a1 )
{
v2 = (_QWORD *)__ctype_b_loc();
v3 = 0LL;
v4 = 0;
do
{
if ( (*(_BYTE *)(*v2 + 2LL * v1 + 1) & 1) != 0 )
{
if ( (_DWORD)v3 && (*(_WORD *)(*v2 + 2LL * a1[v3 - 1]) & 0xA00) != 0 )
buffer_1[v4++] = 95;
buffer_1[v4++] = *(_DWORD *)(*(_QWORD *)__ctype_tolower_loc() + 4LL * a1[v3]);
}
else
{
buffer_1[v4++] = v1;
}
v1 = a1[++v3];
}
while ( v1 );
}
else
{
v4 = 0;
}
result = buffer_1;
buffer_1[v4] = 0;
return result;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX R12D,byte ptr [RDI]
TEST R12B,R12B
JZ 0x0010126c
MOV R13,RDI
CALL 0x001010d0
MOV R14,RAX
MOV EBX,0x0
MOV EBP,0x0
LEA R15,[0x104040]
JMP 0x00101233
LAB_00101206:
CALL 0x001010c0
MOV RDX,RAX
MOVSXD RAX,EBP
MOVSX RCX,byte ptr [R13 + RBX*0x1]
MOV RDX,qword ptr [RDX]
MOV EDX,dword ptr [RDX + RCX*0x4]
MOV byte ptr [R15 + RAX*0x1],DL
LEA EBP,[RBP + 0x1]
LAB_00101224:
ADD RBX,0x1
MOVZX R12D,byte ptr [R13 + RBX*0x1]
TEST R12B,R12B
JZ 0x00101271
LAB_00101233:
MOV RAX,qword ptr [R14]
MOVSX RDX,R12B
TEST byte ptr [RAX + RDX*0x2 + 0x1],0x1
JZ 0x00101260
TEST EBX,EBX
JZ 0x00101206
MOVSX RDX,byte ptr [R13 + RBX*0x1 + -0x1]
TEST word ptr [RAX + RDX*0x2],0xa00
JZ 0x00101206
MOVSXD RAX,EBP
MOV byte ptr [R15 + RAX*0x1],0x5f
LEA EBP,[RBP + 0x1]
JMP 0x00101206
LAB_00101260:
MOVSXD RAX,EBP
MOV byte ptr [R15 + RAX*0x1],R12B
LEA EBP,[RBP + 0x1]
JMP 0x00101224
LAB_0010126c:
MOV EBP,0x0
LAB_00101271:
LEA RAX,[0x104040]
MOVSXD RBP,EBP
MOV byte ptr [RAX + RBP*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void func0(char *param_1)
{
ushort **ppuVar1;
__int32_t **pp_Var2;
long lVar3;
int iVar4;
char cVar5;
cVar5 = *param_1;
if (cVar5 == '\0') {
iVar4 = 0;
}
else {
ppuVar1 = __ctype_b_loc();
lVar3 = 0;
iVar4 = 0;
do {
if ((*(byte *)((long)*ppuVar1 + (long)cVar5 * 2 + 1) & 1) == 0) {
(&buffer_1)[iVar4] = cVar5;
}
else {
if (((int)lVar3 != 0) && (((*ppuVar1)[param_1[lVar3 + -1]] & 0xa00) != 0)) {
(&buffer_1)[iVar4] = 0x5f;
iVar4 = iVar4 + 1;
}
pp_Var2 = __ctype_tolower_loc();
(&buffer_1)[iVar4] = (char)(*pp_Var2)[param_1[lVar3]];
}
iVar4 = iVar4 + 1;
lVar3 = lVar3 + 1;
cVar5 = param_1[lVar3];
} while (cVar5 != '\0');
}
(&buffer_1)[iVar4] = 0;
return;
} |
7,754 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* text) {
static char buffer[100];
int i = 0, j = 0;
while (text[i] != '\0') {
if (isupper(text[i])) {
if (i != 0 && (islower(text[i-1]) || isdigit(text[i-1]))) {
buffer[j++] = '_';
}
buffer[j++] = tolower(text[i]);
} else {
buffer[j++] = text[i];
}
i++;
}
buffer[j] = '\0';
return buffer;
}
| int main() {
assert(strcmp(func0("PythonProgram"), "python_program") == 0);
assert(strcmp(func0("pythonLanguage"), "python_language") == 0);
assert(strcmp(func0("ProgrammingLanguage"), "programming_language") == 0);
printf("All assertions passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
movzbl (%rdi),%r12d
test %r12b,%r12b
je 1378 <func0+0xd8>
mov %rdi,%r14
xor %ebp,%ebp
lea 0x2d75(%rip),%r15
xor %ebx,%ebx
callq 10b0 <__ctype_b_loc@plt>
mov %rax,%rcx
jmp 1333 <func0+0x93>
nopw 0x0(%rax,%rax,1)
test %rbp,%rbp
je 1304 <func0+0x64>
movsbq -0x1(%r14,%rbp,1),%rdx
testw $0xa00,(%rax,%rdx,2)
je 1304 <func0+0x64>
movslq %ebx,%rax
movb $0x5f,(%r15,%rax,1)
lea 0x2(%rbx),%eax
movslq %r13d,%rbx
mov %eax,%r13d
mov %rcx,0x8(%rsp)
callq 10a0 <__ctype_tolower_loc@plt>
movsbq (%r14,%rbp,1),%rdx
add $0x1,%rbp
mov 0x8(%rsp),%rcx
mov (%rax),%rax
mov (%rax,%rdx,4),%eax
mov %al,(%r15,%rbx,1)
movzbl (%r14,%rbp,1),%r12d
movslq %r13d,%rbx
test %r12b,%r12b
je 135a <func0+0xba>
mov (%rcx),%rax
movsbq %r12b,%rdx
lea 0x1(%rbx),%r13d
testb $0x1,0x1(%rax,%rdx,2)
jne 12e0 <func0+0x40>
add $0x1,%rbp
mov %r12b,(%r15,%rbx,1)
movslq %r13d,%rbx
movzbl (%r14,%rbp,1),%r12d
test %r12b,%r12b
jne 1333 <func0+0x93>
movb $0x0,(%r15,%rbx,1)
add $0x18,%rsp
lea 0x2cd6(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
xor %ebx,%ebx
lea 0x2cbf(%rip),%r15
jmp 135a <func0+0xba>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
movzx r12d, byte ptr [rdi]
test r12b, r12b
jz loc_1380
mov r14, rdi
xor ebp, ebp
lea r15, buffer_1
xor ebx, ebx
call ___ctype_b_loc
mov rcx, rax
jmp short loc_133E
loc_12F0:
test rbp, rbp
jz short loc_130F
movsx rdx, byte ptr [r14+rbp-1]
test word ptr [rax+rdx*2], 0A00h
jz short loc_130F
mov byte ptr [r15+rbx], 5Fh ; '_'
movsxd rbx, r13d
lea r13d, [rbx+1]
loc_130F:
mov [rsp+48h+var_40], rcx
call ___ctype_tolower_loc
movsx rdx, byte ptr [r14+rbp]
add rbp, 1
mov rcx, [rsp+48h+var_40]
mov rax, [rax]
mov eax, [rax+rdx*4]
mov [r15+rbx], al
movzx r12d, byte ptr [r14+rbp]
movsxd rbx, r13d
test r12b, r12b
jz short loc_1365
loc_133E:
mov rax, [rcx]
movsx rdx, r12b
lea r13d, [rbx+1]
test byte ptr [rax+rdx*2+1], 1
jnz short loc_12F0
add rbp, 1
mov [r15+rbx], r12b
movsxd rbx, r13d
movzx r12d, byte ptr [r14+rbp]
test r12b, r12b
jnz short loc_133E
loc_1365:
mov byte ptr [r15+rbx], 0
add rsp, 18h
mov rax, r15
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1380:
xor ebx, ebx
lea r15, buffer_1
jmp short loc_1365 | _BYTE * func0(char *a1)
{
char v1; // r12
long long v2; // rbp
long long v3; // rbx
_QWORD *v4; // rcx
int v5; // r13d
_QWORD *v6; // rax
long long v7; // rdx
_QWORD *v9; // [rsp+8h] [rbp-40h]
v1 = *a1;
if ( *a1 )
{
v2 = 0LL;
v3 = 0LL;
v4 = (_QWORD *)__ctype_b_loc();
do
{
while ( 1 )
{
v5 = v3 + 1;
if ( (*(_BYTE *)(*v4 + 2LL * v1 + 1) & 1) != 0 )
break;
++v2;
buffer_1[v3] = v1;
v3 = v5;
v1 = a1[v2];
if ( !v1 )
goto LABEL_9;
}
if ( v2 && (*(_WORD *)(*v4 + 2LL * a1[v2 - 1]) & 0xA00) != 0 )
{
buffer_1[v3] = 95;
v3 = v5++;
}
v9 = v4;
v6 = (_QWORD *)__ctype_tolower_loc();
v7 = a1[v2++];
v4 = v9;
buffer_1[v3] = *(_DWORD *)(*v6 + 4 * v7);
v1 = a1[v2];
v3 = v5;
}
while ( v1 );
}
else
{
v3 = 0LL;
}
LABEL_9:
buffer_1[v3] = 0;
return buffer_1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOVZX R12D,byte ptr [RDI]
TEST R12B,R12B
JZ 0x00101380
MOV R14,RDI
XOR EBP,EBP
LEA R15,[0x104040]
XOR EBX,EBX
CALL 0x001010d0
MOV RCX,RAX
JMP 0x0010133e
LAB_001012f0:
TEST RBP,RBP
JZ 0x0010130f
MOVSX RDX,byte ptr [R14 + RBP*0x1 + -0x1]
TEST word ptr [RAX + RDX*0x2],0xa00
JZ 0x0010130f
MOV byte ptr [R15 + RBX*0x1],0x5f
MOVSXD RBX,R13D
LEA R13D,[RBX + 0x1]
LAB_0010130f:
MOV qword ptr [RSP + 0x8],RCX
CALL 0x001010c0
MOVSX RDX,byte ptr [R14 + RBP*0x1]
ADD RBP,0x1
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV byte ptr [R15 + RBX*0x1],AL
MOVZX R12D,byte ptr [R14 + RBP*0x1]
MOVSXD RBX,R13D
TEST R12B,R12B
JZ 0x00101365
LAB_0010133e:
MOV RAX,qword ptr [RCX]
MOVSX RDX,R12B
LEA R13D,[RBX + 0x1]
TEST byte ptr [RAX + RDX*0x2 + 0x1],0x1
JNZ 0x001012f0
ADD RBP,0x1
MOV byte ptr [R15 + RBX*0x1],R12B
MOVSXD RBX,R13D
MOVZX R12D,byte ptr [R14 + RBP*0x1]
TEST R12B,R12B
JNZ 0x0010133e
LAB_00101365:
MOV byte ptr [R15 + RBX*0x1],0x0
ADD RSP,0x18
MOV RAX,R15
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101380:
XOR EBX,EBX
LEA R15,[0x104040]
JMP 0x00101365 | int1 * func0(char *param_1)
{
char *pcVar1;
int iVar2;
ushort **ppuVar3;
__int32_t **pp_Var4;
long lVar5;
long lVar6;
char cVar7;
int iVar8;
cVar7 = *param_1;
if (cVar7 == '\0') {
lVar5 = 0;
}
else {
lVar6 = 0;
lVar5 = 0;
ppuVar3 = __ctype_b_loc();
do {
while( true ) {
iVar2 = (int)lVar5;
iVar8 = iVar2 + 1;
if ((*(byte *)((long)*ppuVar3 + (long)cVar7 * 2 + 1) & 1) != 0) break;
lVar6 = lVar6 + 1;
(&buffer_1)[lVar5] = cVar7;
lVar5 = (long)iVar8;
cVar7 = param_1[lVar6];
if (cVar7 == '\0') goto LAB_00101365;
}
if ((lVar6 != 0) && (((*ppuVar3)[param_1[lVar6 + -1]] & 0xa00) != 0)) {
(&buffer_1)[lVar5] = 0x5f;
lVar5 = (long)iVar8;
iVar8 = iVar2 + 2;
}
pp_Var4 = __ctype_tolower_loc();
pcVar1 = param_1 + lVar6;
lVar6 = lVar6 + 1;
(&buffer_1)[lVar5] = (char)(*pp_Var4)[*pcVar1];
cVar7 = param_1[lVar6];
lVar5 = (long)iVar8;
} while (cVar7 != '\0');
}
LAB_00101365:
(&buffer_1)[lVar5] = 0;
return &buffer_1;
} |
7,755 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(const char* text) {
static char buffer[100];
int i = 0, j = 0;
while (text[i] != '\0') {
if (isupper(text[i])) {
if (i != 0 && (islower(text[i-1]) || isdigit(text[i-1]))) {
buffer[j++] = '_';
}
buffer[j++] = tolower(text[i]);
} else {
buffer[j++] = text[i];
}
i++;
}
buffer[j] = '\0';
return buffer;
}
| int main() {
assert(strcmp(func0("PythonProgram"), "python_program") == 0);
assert(strcmp(func0("pythonLanguage"), "python_language") == 0);
assert(strcmp(func0("ProgrammingLanguage"), "programming_language") == 0);
printf("All assertions passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
movzbl (%rdi),%r12d
test %r12b,%r12b
je 1380 <func0+0xe0>
mov %rdi,%r15
xor %ebp,%ebp
xor %ebx,%ebx
callq 10b0 <__ctype_b_loc@plt>
lea 0x2d6e(%rip),%rdx
mov %rax,%rcx
jmp 133a <func0+0x9a>
nopw 0x0(%rax,%rax,1)
test %rbp,%rbp
je 1308 <func0+0x68>
movsbq -0x1(%r15,%rbp,1),%rsi
testw $0xa00,(%rax,%rsi,2)
je 1308 <func0+0x68>
movslq %ebx,%rax
movb $0x5f,(%rdx,%rax,1)
lea 0x2(%rbx),%eax
movsbq (%r15,%rbp,1),%r13
movslq %r14d,%rbx
mov %eax,%r14d
mov %rdx,0x8(%rsp)
add $0x1,%rbp
mov %rcx,(%rsp)
callq 10a0 <__ctype_tolower_loc@plt>
mov 0x8(%rsp),%rdx
mov (%rsp),%rcx
mov (%rax),%rax
mov (%rax,%r13,4),%eax
mov %al,(%rdx,%rbx,1)
movzbl (%r15,%rbp,1),%r12d
movslq %r14d,%rbx
test %r12b,%r12b
je 1362 <func0+0xc2>
mov (%rcx),%rax
movsbq %r12b,%r13
lea 0x1(%rbx),%r14d
testb $0x1,0x1(%rax,%r13,2)
jne 12e0 <func0+0x40>
add $0x1,%rbp
mov %r12b,(%rdx,%rbx,1)
movslq %r14d,%rbx
movzbl (%r15,%rbp,1),%r12d
test %r12b,%r12b
jne 133a <func0+0x9a>
movb $0x0,(%rdx,%rbx,1)
add $0x18,%rsp
lea 0x2ccf(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
xor %ebx,%ebx
lea 0x2cb7(%rip),%rdx
jmp 1362 <func0+0xc2>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
movzx r12d, byte ptr [rdi]
test r12b, r12b
jz loc_1388
mov r15, rdi
xor ebp, ebp
xor ebx, ebx
call ___ctype_b_loc
lea rdx, buffer_1
mov rcx, rax
jmp short loc_1345
loc_12F0:
test rbp, rbp
jz short loc_1313
movsx rsi, byte ptr [r15+rbp-1]
test word ptr [rax+rsi*2], 0A00h
jz short loc_1313
mov byte ptr [rdx+rbx], 5Fh ; '_'
movsxd rbx, r14d
movsx r13, byte ptr [r15+rbp]
lea r14d, [rbx+1]
loc_1313:
mov [rsp+48h+var_40], rdx
add rbp, 1
mov [rsp+48h+var_48], rcx
call ___ctype_tolower_loc
mov rdx, [rsp+48h+var_40]
mov rcx, [rsp+48h+var_48]
mov rax, [rax]
mov eax, [rax+r13*4]
mov [rdx+rbx], al
movzx r12d, byte ptr [r15+rbp]
movsxd rbx, r14d
test r12b, r12b
jz short loc_136D
loc_1345:
mov rax, [rcx]
movsx r13, r12b
lea r14d, [rbx+1]
test byte ptr [rax+r13*2+1], 1
jnz short loc_12F0
add rbp, 1
mov [rdx+rbx], r12b
movsxd rbx, r14d
movzx r12d, byte ptr [r15+rbp]
test r12b, r12b
jnz short loc_1345
loc_136D:
mov byte ptr [rdx+rbx], 0
add rsp, 18h
mov rax, rdx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1388:
xor ebx, ebx
lea rdx, buffer_1
jmp short loc_136D | _BYTE * func0(char *a1)
{
char v1; // r12
long long v2; // rbp
long long v3; // rbx
const unsigned __int16 **v4; // rax
_BYTE *v5; // rdx
const unsigned __int16 **v6; // rcx
long long v7; // r13
int v8; // r14d
const __int32_t **v9; // rax
const unsigned __int16 **v11; // [rsp+0h] [rbp-48h]
_BYTE *v12; // [rsp+8h] [rbp-40h]
v1 = *a1;
if ( *a1 )
{
v2 = 0LL;
v3 = 0LL;
v4 = __ctype_b_loc();
v5 = &buffer_1;
v6 = v4;
do
{
while ( 1 )
{
v7 = v1;
v8 = v3 + 1;
if ( ((*v6)[v1] & 0x100) != 0 )
break;
++v2;
v5[v3] = v1;
v3 = v8;
v1 = a1[v2];
if ( !v1 )
goto LABEL_9;
}
if ( v2 && ((*v6)[a1[v2 - 1]] & 0xA00) != 0 )
{
v5[v3] = 95;
v3 = v8;
v7 = a1[v2];
++v8;
}
v12 = v5;
++v2;
v11 = v6;
v9 = __ctype_tolower_loc();
v5 = v12;
v6 = v11;
v12[v3] = (*v9)[v7];
v1 = a1[v2];
v3 = v8;
}
while ( v1 );
}
else
{
v3 = 0LL;
v5 = &buffer_1;
}
LABEL_9:
v5[v3] = 0;
return v5;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOVZX R12D,byte ptr [RDI]
TEST R12B,R12B
JZ 0x00101388
MOV R15,RDI
XOR EBP,EBP
XOR EBX,EBX
CALL 0x001010d0
LEA RDX,[0x104040]
MOV RCX,RAX
JMP 0x00101345
LAB_001012f0:
TEST RBP,RBP
JZ 0x00101313
MOVSX RSI,byte ptr [R15 + RBP*0x1 + -0x1]
TEST word ptr [RAX + RSI*0x2],0xa00
JZ 0x00101313
MOV byte ptr [RDX + RBX*0x1],0x5f
MOVSXD RBX,R14D
MOVSX R13,byte ptr [R15 + RBP*0x1]
LEA R14D,[RBX + 0x1]
LAB_00101313:
MOV qword ptr [RSP + 0x8],RDX
ADD RBP,0x1
MOV qword ptr [RSP],RCX
CALL 0x001010c0
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + R13*0x4]
MOV byte ptr [RDX + RBX*0x1],AL
MOVZX R12D,byte ptr [R15 + RBP*0x1]
MOVSXD RBX,R14D
TEST R12B,R12B
JZ 0x0010136d
LAB_00101345:
MOV RAX,qword ptr [RCX]
MOVSX R13,R12B
LEA R14D,[RBX + 0x1]
TEST byte ptr [RAX + R13*0x2 + 0x1],0x1
JNZ 0x001012f0
ADD RBP,0x1
MOV byte ptr [RDX + RBX*0x1],R12B
MOVSXD RBX,R14D
MOVZX R12D,byte ptr [R15 + RBP*0x1]
TEST R12B,R12B
JNZ 0x00101345
LAB_0010136d:
MOV byte ptr [RDX + RBX*0x1],0x0
ADD RSP,0x18
MOV RAX,RDX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101388:
XOR EBX,EBX
LEA RDX,[0x104040]
JMP 0x0010136d | int1 * func0(char *param_1)
{
int iVar1;
ushort **ppuVar2;
__int32_t **pp_Var3;
long lVar4;
long lVar5;
char cVar6;
long lVar7;
int iVar8;
cVar6 = *param_1;
if (cVar6 == '\0') {
lVar4 = 0;
}
else {
lVar5 = 0;
lVar4 = 0;
ppuVar2 = __ctype_b_loc();
do {
while( true ) {
lVar7 = (long)cVar6;
iVar1 = (int)lVar4;
iVar8 = iVar1 + 1;
if ((*(byte *)((long)*ppuVar2 + lVar7 * 2 + 1) & 1) != 0) break;
lVar5 = lVar5 + 1;
(&buffer_1)[lVar4] = cVar6;
lVar4 = (long)iVar8;
cVar6 = param_1[lVar5];
if (cVar6 == '\0') goto LAB_0010136d;
}
if ((lVar5 != 0) && (((*ppuVar2)[param_1[lVar5 + -1]] & 0xa00) != 0)) {
(&buffer_1)[lVar4] = 0x5f;
lVar4 = (long)iVar8;
lVar7 = (long)param_1[lVar5];
iVar8 = iVar1 + 2;
}
lVar5 = lVar5 + 1;
pp_Var3 = __ctype_tolower_loc();
(&buffer_1)[lVar4] = (char)(*pp_Var3)[lVar7];
cVar6 = param_1[lVar5];
lVar4 = (long)iVar8;
} while (cVar6 != '\0');
}
LAB_0010136d:
(&buffer_1)[lVar4] = 0;
return &buffer_1;
} |
7,756 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
// Function to remove empty elements
| char** func0(char** tuple1, int size, int* new_size) {
char** result = malloc(size * sizeof(char*));
int j = 0;
for(int i = 0; i < size; i++) {
if(tuple1[i] != NULL) {
result[j++] = tuple1[i];
}
}
*new_size = j;
return result;
}
| int main() {
// First test case
char* input1[] = {NULL, NULL, "", "a,b", "a,b,c", "d"};
char* expected1[] = {"", "a,b", "a,b,c", "d"};
int new_size1;
char** output1 = func0(input1, 6, &new_size1);
assert(new_size1 == 4);
for(int i = 0; i < new_size1; i++) {
assert(output1[i] == expected1[i]);
}
// Second test case
char* input2[] = {NULL, NULL, "", "python", "program"};
char* expected2[] = {"", "python", "program"};
int new_size2;
char** output2 = func0(input2, 5, &new_size2);
assert(new_size2 == 3);
for(int i = 0; i < new_size2; i++) {
assert(output2[i] == expected2[i]);
}
// Third test case
char* input3[] = {NULL, NULL, "", "java"};
char* expected3[] = {"", "java"};
int new_size3;
char** output3 = func0(input3, 4, &new_size3);
assert(new_size3 == 2);
for(int i = 0; i < new_size3; i++) {
assert(output3[i] == expected3[i]);
}
// Free allocated memory
free(output1);
free(output2);
free(output3);
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
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 123a <func0+0x91>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
test %rax,%rax
je 1236 <func0+0x8d>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%rax
mov %rax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11e5 <func0+0x3c>
mov -0x28(%rbp),%rax
mov -0x10(%rbp),%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov eax, [rbp+var_1C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp short loc_123A
loc_11E5:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
test rax, rax
jz short loc_1236
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rdx, rax
mov rax, [rcx]
mov [rdx], rax
loc_1236:
add [rbp+var_C], 1
loc_123A:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_11E5
mov rax, [rbp+var_28]
mov edx, [rbp+var_10]
mov [rax], edx
mov rax, [rbp+var_8]
leave
retn | _QWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
int v6; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
_QWORD *v8; // [rsp+28h] [rbp-8h]
v8 = malloc(8LL * a2);
v6 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_QWORD *)(8LL * i + a1) )
{
v3 = v6++;
v8[v3] = *(_QWORD *)(8LL * i + a1);
}
}
*a3 = v6;
return v8;
} | 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]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010123a
LAB_001011e5:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00101236
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV RAX,qword ptr [RCX]
MOV qword ptr [RDX],RAX
LAB_00101236:
ADD dword ptr [RBP + -0xc],0x1
LAB_0010123a:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011e5
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x10]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int *param_3)
{
void *pvVar1;
int4 local_18;
int4 local_14;
pvVar1 = malloc((long)param_2 << 3);
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (*(long *)(param_1 + (long)local_14 * 8) != 0) {
*(int8 *)((long)local_18 * 8 + (long)pvVar1) =
*(int8 *)((long)local_14 * 8 + param_1);
local_18 = local_18 + 1;
}
}
*param_3 = local_18;
return pvVar1;
} |
7,757 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
// Function to remove empty elements
| char** func0(char** tuple1, int size, int* new_size) {
char** result = malloc(size * sizeof(char*));
int j = 0;
for(int i = 0; i < size; i++) {
if(tuple1[i] != NULL) {
result[j++] = tuple1[i];
}
}
*new_size = j;
return result;
}
| int main() {
// First test case
char* input1[] = {NULL, NULL, "", "a,b", "a,b,c", "d"};
char* expected1[] = {"", "a,b", "a,b,c", "d"};
int new_size1;
char** output1 = func0(input1, 6, &new_size1);
assert(new_size1 == 4);
for(int i = 0; i < new_size1; i++) {
assert(output1[i] == expected1[i]);
}
// Second test case
char* input2[] = {NULL, NULL, "", "python", "program"};
char* expected2[] = {"", "python", "program"};
int new_size2;
char** output2 = func0(input2, 5, &new_size2);
assert(new_size2 == 3);
for(int i = 0; i < new_size2; i++) {
assert(output2[i] == expected2[i]);
}
// Third test case
char* input3[] = {NULL, NULL, "", "java"};
char* expected3[] = {"", "java"};
int new_size3;
char** output3 = func0(input3, 4, &new_size3);
assert(new_size3 == 2);
for(int i = 0; i < new_size3; i++) {
assert(output3[i] == expected3[i]);
}
// Free allocated memory
free(output1);
free(output2);
free(output3);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %esi,%ebp
mov %rdx,%rbx
movslq %esi,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 11f8 <func0+0x4f>
mov %r12,%rdx
lea -0x1(%rbp),%ecx
lea 0x8(%r12,%rcx,8),%r8
mov $0x0,%esi
jmp 11e4 <func0+0x3b>
add $0x8,%rdx
cmp %r8,%rdx
je 11fd <func0+0x54>
mov (%rdx),%rcx
test %rcx,%rcx
je 11db <func0+0x32>
movslq %esi,%rdi
mov %rcx,(%rax,%rdi,8)
lea 0x1(%rsi),%esi
jmp 11db <func0+0x32>
mov $0x0,%esi
mov %esi,(%rbx)
pop %rbx
pop %rbp
pop %r12
retq
| func0:
endbr64
push r12
push rbp
push rbx
mov r12, rdi
mov ebp, esi
mov rbx, rdx
movsxd rdi, esi
shl rdi, 3
call _malloc
test ebp, ebp
jle short loc_11F8
mov rdx, r12
lea ecx, [rbp-1]
lea r8, [r12+rcx*8+8]
mov esi, 0
jmp short loc_11EE
loc_11DB:
movsxd rdi, esi
mov [rax+rdi*8], rcx
lea esi, [rsi+1]
loc_11E5:
add rdx, 8
cmp rdx, r8
jz short loc_11FD
loc_11EE:
mov rcx, [rdx]
test rcx, rcx
jnz short loc_11DB
jmp short loc_11E5
loc_11F8:
mov esi, 0
loc_11FD:
mov [rbx], esi
pop rbx
pop rbp
pop r12
retn | long long func0(_QWORD *a1, int a2, _DWORD *a3)
{
long long result; // rax
_QWORD *v6; // rdx
int v7; // esi
result = malloc(8LL * a2);
if ( a2 <= 0 )
{
v7 = 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
if ( *v6 )
*(_QWORD *)(result + 8LL * v7++) = *v6;
++v6;
}
while ( v6 != &a1[(unsigned int)(a2 - 1) + 1] );
}
*a3 = v7;
return result;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV EBP,ESI
MOV RBX,RDX
MOVSXD RDI,ESI
SHL RDI,0x3
CALL 0x001010b0
TEST EBP,EBP
JLE 0x001011f8
MOV RDX,R12
LEA ECX,[RBP + -0x1]
LEA R8,[R12 + RCX*0x8 + 0x8]
MOV ESI,0x0
JMP 0x001011ee
LAB_001011db:
MOVSXD RDI,ESI
MOV qword ptr [RAX + RDI*0x8],RCX
LEA ESI,[RSI + 0x1]
LAB_001011e5:
ADD RDX,0x8
CMP RDX,R8
JZ 0x001011fd
LAB_001011ee:
MOV RCX,qword ptr [RDX]
TEST RCX,RCX
JNZ 0x001011db
JMP 0x001011e5
LAB_001011f8:
MOV ESI,0x0
LAB_001011fd:
MOV dword ptr [RBX],ESI
POP RBX
POP RBP
POP R12
RET | void func0(long *param_1,int param_2,int *param_3)
{
long *plVar1;
void *pvVar2;
int iVar3;
pvVar2 = malloc((long)param_2 << 3);
if (param_2 < 1) {
iVar3 = 0;
}
else {
plVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
if (*param_1 != 0) {
*(long *)((long)pvVar2 + (long)iVar3 * 8) = *param_1;
iVar3 = iVar3 + 1;
}
param_1 = param_1 + 1;
} while (param_1 != plVar1);
}
*param_3 = iVar3;
return;
} |
7,758 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
// Function to remove empty elements
| char** func0(char** tuple1, int size, int* new_size) {
char** result = malloc(size * sizeof(char*));
int j = 0;
for(int i = 0; i < size; i++) {
if(tuple1[i] != NULL) {
result[j++] = tuple1[i];
}
}
*new_size = j;
return result;
}
| int main() {
// First test case
char* input1[] = {NULL, NULL, "", "a,b", "a,b,c", "d"};
char* expected1[] = {"", "a,b", "a,b,c", "d"};
int new_size1;
char** output1 = func0(input1, 6, &new_size1);
assert(new_size1 == 4);
for(int i = 0; i < new_size1; i++) {
assert(output1[i] == expected1[i]);
}
// Second test case
char* input2[] = {NULL, NULL, "", "python", "program"};
char* expected2[] = {"", "python", "program"};
int new_size2;
char** output2 = func0(input2, 5, &new_size2);
assert(new_size2 == 3);
for(int i = 0; i < new_size2; i++) {
assert(output2[i] == expected2[i]);
}
// Third test case
char* input3[] = {NULL, NULL, "", "java"};
char* expected3[] = {"", "java"};
int new_size3;
char** output3 = func0(input3, 4, &new_size3);
assert(new_size3 == 2);
for(int i = 0; i < new_size3; i++) {
assert(output3[i] == expected3[i]);
}
// Free allocated memory
free(output1);
free(output2);
free(output3);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x3,%rdi
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 1498 <func0+0x58>
lea -0x1(%rbp),%edx
mov %rbx,%rdi
xor %esi,%esi
lea 0x8(%rbx,%rdx,8),%r9
xchg %ax,%ax
mov (%rdi),%rcx
test %rcx,%rcx
je 1482 <func0+0x42>
movslq %esi,%r8
add $0x1,%esi
mov %rcx,(%rax,%r8,8)
add $0x8,%rdi
cmp %r9,%rdi
jne 1470 <func0+0x30>
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopl 0x0(%rax)
xor %esi,%esi
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r12
mov r12, rdx
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov rbp, rdi
shl rdi, 3
call _malloc
test ebp, ebp
jle short loc_1498
lea edx, [rbp-1]
mov rcx, rbx
xor edi, edi
lea r9, [rbx+rdx*8+8]
xchg ax, ax
loc_1470:
mov rsi, [rcx]
test rsi, rsi
jz short loc_1482
movsxd r8, edi
add edi, 1
mov [rax+r8*8], rsi
loc_1482:
add rcx, 8
cmp rcx, r9
jnz short loc_1470
pop rbx
pop rbp
mov [r12], edi
pop r12
retn
loc_1498:
xor edi, edi
pop rbx
pop rbp
mov [r12], edi
pop r12
retn | long long func0(_QWORD *a1, int a2, _DWORD *a3)
{
long long result; // rax
_QWORD *v6; // rcx
int v7; // edi
long long v8; // r8
result = malloc(8LL * a2);
if ( a2 <= 0 )
{
*a3 = 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
if ( *v6 )
{
v8 = v7++;
*(_QWORD *)(result + 8 * v8) = *v6;
}
++v6;
}
while ( v6 != &a1[(unsigned int)(a2 - 1) + 1] );
*a3 = v7;
}
return result;
} | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV RBP,RDI
SHL RDI,0x3
CALL 0x001010b0
TEST EBP,EBP
JLE 0x00101498
LEA EDX,[RBP + -0x1]
MOV RCX,RBX
XOR EDI,EDI
LEA R9,[RBX + RDX*0x8 + 0x8]
NOP
LAB_00101470:
MOV RSI,qword ptr [RCX]
TEST RSI,RSI
JZ 0x00101482
MOVSXD R8,EDI
ADD EDI,0x1
MOV qword ptr [RAX + R8*0x8],RSI
LAB_00101482:
ADD RCX,0x8
CMP RCX,R9
JNZ 0x00101470
POP RBX
POP RBP
MOV dword ptr [R12],EDI
POP R12
RET
LAB_00101498:
XOR EDI,EDI
POP RBX
POP RBP
MOV dword ptr [R12],EDI
POP R12
RET | void func0(long *param_1,int param_2,int *param_3)
{
long *plVar1;
void *pvVar2;
int iVar3;
long lVar4;
pvVar2 = malloc((long)param_2 << 3);
if (0 < param_2) {
iVar3 = 0;
plVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (*param_1 != 0) {
lVar4 = (long)iVar3;
iVar3 = iVar3 + 1;
*(long *)((long)pvVar2 + lVar4 * 8) = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != plVar1);
*param_3 = iVar3;
return;
}
*param_3 = 0;
return;
} |
7,759 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
// Function to remove empty elements
| char** func0(char** tuple1, int size, int* new_size) {
char** result = malloc(size * sizeof(char*));
int j = 0;
for(int i = 0; i < size; i++) {
if(tuple1[i] != NULL) {
result[j++] = tuple1[i];
}
}
*new_size = j;
return result;
}
| int main() {
// First test case
char* input1[] = {NULL, NULL, "", "a,b", "a,b,c", "d"};
char* expected1[] = {"", "a,b", "a,b,c", "d"};
int new_size1;
char** output1 = func0(input1, 6, &new_size1);
assert(new_size1 == 4);
for(int i = 0; i < new_size1; i++) {
assert(output1[i] == expected1[i]);
}
// Second test case
char* input2[] = {NULL, NULL, "", "python", "program"};
char* expected2[] = {"", "python", "program"};
int new_size2;
char** output2 = func0(input2, 5, &new_size2);
assert(new_size2 == 3);
for(int i = 0; i < new_size2; i++) {
assert(output2[i] == expected2[i]);
}
// Third test case
char* input3[] = {NULL, NULL, "", "java"};
char* expected3[] = {"", "java"};
int new_size3;
char** output3 = func0(input3, 4, &new_size3);
assert(new_size3 == 2);
for(int i = 0; i < new_size3; i++) {
assert(output3[i] == expected3[i]);
}
// Free allocated memory
free(output1);
free(output2);
free(output3);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x3,%rdi
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 14c8 <func0+0x58>
lea -0x1(%rbp),%edx
mov %rbx,%rdi
xor %esi,%esi
lea 0x8(%rbx,%rdx,8),%r9
xchg %ax,%ax
mov (%rdi),%rcx
test %rcx,%rcx
je 14b2 <func0+0x42>
movslq %esi,%r8
add $0x1,%esi
mov %rcx,(%rax,%r8,8)
add $0x8,%rdi
cmp %r9,%rdi
jne 14a0 <func0+0x30>
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopl 0x0(%rax)
xor %esi,%esi
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r13
movsxd r8, esi
mov r13, rdx
push r12
mov r12, r8
push rbp
lea rbp, ds:0[r8*8]
push rbx
mov rbx, rdi
mov rdi, rbp; size
sub rsp, 8
call _malloc
test r12d, r12d
jle short loc_14C0
mov rcx, rbx
lea r8, [rbx+rbp]
xor edi, edi
nop dword ptr [rax+rax+00000000h]
loc_1490:
mov rsi, [rcx]
test rsi, rsi
jz short loc_14A2
movsxd r9, edi
add edi, 1
mov [rax+r9*8], rsi
loc_14A2:
add rcx, 8
cmp rcx, r8
jnz short loc_1490
mov [r13+0], edi
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_14C0:
xor edi, edi
mov [r13+0], edi
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _QWORD * func0(_QWORD *a1, int a2, _DWORD *a3)
{
_QWORD *result; // rax
_QWORD *v6; // rcx
int v7; // edi
long long v8; // r9
result = malloc(8LL * a2);
if ( a2 <= 0 )
{
*a3 = 0;
}
else
{
v6 = a1;
v7 = 0;
do
{
if ( *v6 )
{
v8 = v7++;
result[v8] = *v6;
}
++v6;
}
while ( v6 != &a1[a2] );
*a3 = v7;
}
return result;
} | func0:
ENDBR64
PUSH R13
MOVSXD R8,ESI
MOV R13,RDX
PUSH R12
MOV R12,R8
PUSH RBP
LEA RBP,[R8*0x8]
PUSH RBX
MOV RBX,RDI
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010b0
TEST R12D,R12D
JLE 0x001014c0
MOV RCX,RBX
LEA R8,[RBX + RBP*0x1]
XOR EDI,EDI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101490:
MOV RSI,qword ptr [RCX]
TEST RSI,RSI
JZ 0x001014a2
MOVSXD R9,EDI
ADD EDI,0x1
MOV qword ptr [RAX + R9*0x8],RSI
LAB_001014a2:
ADD RCX,0x8
CMP RCX,R8
JNZ 0x00101490
MOV dword ptr [R13],EDI
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001014c0:
XOR EDI,EDI
MOV dword ptr [R13],EDI
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(long *param_1,int param_2,int *param_3)
{
long *plVar1;
void *pvVar2;
int iVar3;
long lVar4;
pvVar2 = malloc((long)param_2 * 8);
if (0 < param_2) {
plVar1 = param_1 + param_2;
iVar3 = 0;
do {
if (*param_1 != 0) {
lVar4 = (long)iVar3;
iVar3 = iVar3 + 1;
*(long *)((long)pvVar2 + lVar4 * 8) = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != plVar1);
*param_3 = iVar3;
return;
}
*param_3 = 0;
return;
} |
7,760 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| const char* func0(const char* string) {
char vowels[] = "AEIOUaeiou";
int count = 0;
int found[10] = {0}; // to track which vowels have been found
for (int i = 0; string[i] != '\0'; i++) {
for (int j = 0; j < 10; j++) {
if (string[i] == vowels[j] && found[j] == 0) {
found[j] = 1;
count++;
break;
}
}
}
if (count >= 5) {
return "accepted";
} else {
return "not accepted";
}
}
| int main() {
assert(strcmp(func0("SEEquoiaL"), "accepted") == 0);
assert(strcmp(func0("program"), "not accepted") == 0);
assert(strcmp(func0("fine"), "not accepted") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x60,%rsp
mov %rdi,-0x58(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movabs $0x696561554f494541,%rax
mov %rax,-0x13(%rbp)
movw $0x756f,-0xb(%rbp)
movb $0x0,-0x9(%rbp)
movl $0x0,-0x4c(%rbp)
movq $0x0,-0x40(%rbp)
movq $0x0,-0x38(%rbp)
movq $0x0,-0x30(%rbp)
movq $0x0,-0x28(%rbp)
movq $0x0,-0x20(%rbp)
movl $0x0,-0x48(%rbp)
jmp 124d <func0+0xc4>
movl $0x0,-0x44(%rbp)
jmp 1243 <func0+0xba>
mov -0x48(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x44(%rbp),%eax
cltq
movzbl -0x13(%rbp,%rax,1),%eax
cmp %al,%dl
jne 123f <func0+0xb6>
mov -0x44(%rbp),%eax
cltq
mov -0x40(%rbp,%rax,4),%eax
test %eax,%eax
jne 123f <func0+0xb6>
mov -0x44(%rbp),%eax
cltq
movl $0x1,-0x40(%rbp,%rax,4)
addl $0x1,-0x4c(%rbp)
jmp 1249 <func0+0xc0>
addl $0x1,-0x44(%rbp)
cmpl $0x9,-0x44(%rbp)
jle 1201 <func0+0x78>
addl $0x1,-0x48(%rbp)
mov -0x48(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 11f8 <func0+0x6f>
cmpl $0x4,-0x4c(%rbp)
jle 1270 <func0+0xe7>
lea 0xd9a(%rip),%rax
jmp 1277 <func0+0xee>
lea 0xd9a(%rip),%rax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 128b <func0+0x102>
callq 1070 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_58], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, 696561554F494541h
mov [rbp+var_13], rax
mov dword ptr [rbp+var_13+7], 756F69h
mov [rbp+var_4C], 0
pxor xmm0, xmm0
movaps [rbp+var_40], xmm0
movaps [rbp+var_30], xmm0
movq [rbp+var_20], xmm0
mov [rbp+var_48], 0
jmp short loc_1233
loc_11DE:
mov [rbp+var_44], 0
jmp short loc_1229
loc_11E7:
mov eax, [rbp+var_48]
movsxd rdx, eax
mov rax, [rbp+var_58]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_44]
cdqe
movzx eax, byte ptr [rbp+rax+var_13]
cmp dl, al
jnz short loc_1225
mov eax, [rbp+var_44]
cdqe
mov eax, dword ptr [rbp+rax*4+var_40]
test eax, eax
jnz short loc_1225
mov eax, [rbp+var_44]
cdqe
mov dword ptr [rbp+rax*4+var_40], 1
add [rbp+var_4C], 1
jmp short loc_122F
loc_1225:
add [rbp+var_44], 1
loc_1229:
cmp [rbp+var_44], 9
jle short loc_11E7
loc_122F:
add [rbp+var_48], 1
loc_1233:
mov eax, [rbp+var_48]
movsxd rdx, eax
mov rax, [rbp+var_58]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_11DE
cmp [rbp+var_4C], 4
jle short loc_1256
lea rax, s2; "accepted"
jmp short loc_125D
loc_1256:
lea rax, aNotAccepted; "not accepted"
loc_125D:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1271
call ___stack_chk_fail
locret_1271:
leave
retn | const char * func0(long long a1)
{
int v2; // [rsp+14h] [rbp-4Ch]
int i; // [rsp+18h] [rbp-48h]
int j; // [rsp+1Ch] [rbp-44h]
_OWORD v5[2]; // [rsp+20h] [rbp-40h] BYREF
long long v6; // [rsp+40h] [rbp-20h]
_BYTE v7[19]; // [rsp+4Dh] [rbp-13h] BYREF
*(_QWORD *)&v7[11] = __readfsqword(0x28u);
strcpy(v7, "AEIOUaeiou");
v2 = 0;
memset(v5, 0, sizeof(v5));
v6 = 0LL;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
for ( j = 0; j <= 9; ++j )
{
if ( *(_BYTE *)(i + a1) == v7[j] && !*((_DWORD *)v5 + j) )
{
*((_DWORD *)v5 + j) = 1;
++v2;
break;
}
}
}
if ( v2 <= 4 )
return "not accepted";
else
return "accepted";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x58],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,0x696561554f494541
MOV qword ptr [RBP + -0x13],RAX
MOV dword ptr [RBP + -0xc],0x756f69
MOV dword ptr [RBP + -0x4c],0x0
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x40],XMM0
MOVAPS xmmword ptr [RBP + -0x30],XMM0
MOVQ qword ptr [RBP + -0x20],XMM0
MOV dword ptr [RBP + -0x48],0x0
JMP 0x00101233
LAB_001011de:
MOV dword ptr [RBP + -0x44],0x0
JMP 0x00101229
LAB_001011e7:
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x44]
CDQE
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x13]
CMP DL,AL
JNZ 0x00101225
MOV EAX,dword ptr [RBP + -0x44]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x40]
TEST EAX,EAX
JNZ 0x00101225
MOV EAX,dword ptr [RBP + -0x44]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x40],0x1
ADD dword ptr [RBP + -0x4c],0x1
JMP 0x0010122f
LAB_00101225:
ADD dword ptr [RBP + -0x44],0x1
LAB_00101229:
CMP dword ptr [RBP + -0x44],0x9
JLE 0x001011e7
LAB_0010122f:
ADD dword ptr [RBP + -0x48],0x1
LAB_00101233:
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011de
CMP dword ptr [RBP + -0x4c],0x4
JLE 0x00101256
LEA RAX,[0x102008]
JMP 0x0010125d
LAB_00101256:
LEA RAX,[0x102011]
LAB_0010125d:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101271
CALL 0x00101070
LAB_00101271:
LEAVE
RET | char * func0(long param_1)
{
char *pcVar1;
long in_FS_OFFSET;
int local_54;
int local_50;
int local_4c;
int local_48 [16];
int local_38 [16];
int8 local_28;
char local_1b [11];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
builtin_strncpy(local_1b,"AEIOUaeiou",0xb);
local_54 = 0;
local_48 = (int [16])0x0;
local_38 = (int [16])0x0;
local_28 = 0;
local_50 = 0;
do {
if (*(char *)(param_1 + local_50) == '\0') {
if (local_54 < 5) {
pcVar1 = "not accepted";
}
else {
pcVar1 = "accepted";
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar1;
}
for (local_4c = 0; local_4c < 10; local_4c = local_4c + 1) {
if ((*(char *)(param_1 + local_50) == local_1b[local_4c]) &&
(*(int *)(local_48 + (long)local_4c * 4) == 0)) {
*(int4 *)(local_48 + (long)local_4c * 4) = 1;
local_54 = local_54 + 1;
break;
}
}
local_50 = local_50 + 1;
} while( true );
} |
7,761 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| const char* func0(const char* string) {
char vowels[] = "AEIOUaeiou";
int count = 0;
int found[10] = {0}; // to track which vowels have been found
for (int i = 0; string[i] != '\0'; i++) {
for (int j = 0; j < 10; j++) {
if (string[i] == vowels[j] && found[j] == 0) {
found[j] = 1;
count++;
break;
}
}
}
if (count >= 5) {
return "accepted";
} else {
return "not accepted";
}
}
| int main() {
assert(strcmp(func0("SEEquoiaL"), "accepted") == 0);
assert(strcmp(func0("program"), "not accepted") == 0);
assert(strcmp(func0("fine"), "not accepted") == 0);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movabs $0x696561554f494541,%rax
mov %rax,0x2d(%rsp)
movw $0x756f,0x35(%rsp)
movb $0x0,0x37(%rsp)
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
movzbl (%rdi),%edx
lea 0xe32(%rip),%rax
test %dl,%dl
je 1237 <func0+0xce>
add $0x1,%rdi
mov $0x0,%r9d
lea 0x2d(%rsp),%rsi
mov %rsp,%r8
jmp 121a <func0+0xb1>
add $0x1,%rax
cmp $0xa,%rax
je 120e <func0+0xa5>
cmp %dl,(%rax,%rsi,1)
jne 11ea <func0+0x81>
cmpl $0x0,(%r8,%rax,4)
jne 11ea <func0+0x81>
movslq %eax,%rcx
movl $0x1,(%rsp,%rcx,4)
add $0x1,%r9d
add $0x1,%rdi
movzbl -0x1(%rdi),%edx
test %dl,%dl
je 1221 <func0+0xb8>
mov $0x0,%eax
jmp 11f4 <func0+0x8b>
cmp $0x4,%r9d
lea 0xddc(%rip),%rax
lea 0xdd1(%rip),%rdx
cmovle %rdx,%rax
mov 0x38(%rsp),%rdi
xor %fs:0x28,%rdi
jne 124c <func0+0xe3>
add $0x48,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
sub rsp, 48h
mov rax, fs:28h
mov [rsp+48h+var_10], rax
xor eax, eax
mov rax, 696561554F494541h
mov [rsp+48h+var_1B], rax
mov [rsp+48h+var_13], 756Fh
mov [rsp+48h+var_11], 0
mov [rsp+48h+var_48], 0
mov [rsp+48h+var_40], 0
mov [rsp+48h+var_38], 0
mov [rsp+48h+var_30], 0
mov [rsp+48h+var_28], 0
movzx edx, byte ptr [rdi]
lea rax, aNotAccepted; "not accepted"
test dl, dl
jz short loc_1257
add rdi, 1
mov r9d, 0
lea rsi, [rsp+48h+var_1B]
mov r8, rsp
jmp short loc_123A
loc_120A:
add rax, 1
cmp rax, 0Ah
jz short loc_122E
loc_1214:
cmp [rax+rsi], dl
jnz short loc_120A
cmp dword ptr [r8+rax*4], 0
jnz short loc_120A
movsxd rcx, eax
mov dword ptr [rsp+rcx*4+48h+var_48], 1
add r9d, 1
loc_122E:
add rdi, 1
movzx edx, byte ptr [rdi-1]
test dl, dl
jz short loc_1241
loc_123A:
mov eax, 0
jmp short loc_1214
loc_1241:
cmp r9d, 4
lea rax, aNotAccepted+4; "accepted"
lea rdx, aNotAccepted; "not accepted"
cmovle rax, rdx
loc_1257:
mov rdx, [rsp+48h+var_10]
sub rdx, fs:28h
jnz short loc_126C
add rsp, 48h
retn
loc_126C:
call ___stack_chk_fail | char * func0(char *a1)
{
char v1; // dl
char *result; // rax
char *v3; // rdi
int v4; // r9d
long long v5; // rax
_QWORD v6[5]; // [rsp+0h] [rbp-48h] BYREF
_QWORD v7[3]; // [rsp+2Dh] [rbp-1Bh] BYREF
*(_QWORD *)((char *)&v7[1] + 3) = __readfsqword(0x28u);
strcpy((char *)v7, "AEIOUaeiou");
memset(v6, 0, sizeof(v6));
v1 = *a1;
result = "not accepted";
if ( *a1 )
{
v3 = a1 + 1;
v4 = 0;
do
{
v5 = 0LL;
while ( *((_BYTE *)v7 + v5) != v1 || *((_DWORD *)v6 + v5) )
{
if ( ++v5 == 10 )
goto LABEL_7;
}
*((_DWORD *)v6 + (int)v5) = 1;
++v4;
LABEL_7:
v1 = *v3++;
}
while ( v1 );
result = "accepted";
if ( v4 <= 4 )
return "not accepted";
}
return result;
} | func0:
ENDBR64
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV RAX,0x696561554f494541
MOV qword ptr [RSP + 0x2d],RAX
MOV word ptr [RSP + 0x35],0x756f
MOV byte ptr [RSP + 0x37],0x0
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
MOVZX EDX,byte ptr [RDI]
LEA RAX,[0x102004]
TEST DL,DL
JZ 0x00101257
ADD RDI,0x1
MOV R9D,0x0
LEA RSI,[RSP + 0x2d]
MOV R8,RSP
JMP 0x0010123a
LAB_0010120a:
ADD RAX,0x1
CMP RAX,0xa
JZ 0x0010122e
LAB_00101214:
CMP byte ptr [RAX + RSI*0x1],DL
JNZ 0x0010120a
CMP dword ptr [R8 + RAX*0x4],0x0
JNZ 0x0010120a
MOVSXD RCX,EAX
MOV dword ptr [RSP + RCX*0x4],0x1
ADD R9D,0x1
LAB_0010122e:
ADD RDI,0x1
MOVZX EDX,byte ptr [RDI + -0x1]
TEST DL,DL
JZ 0x00101241
LAB_0010123a:
MOV EAX,0x0
JMP 0x00101214
LAB_00101241:
CMP R9D,0x4
LEA RAX,[0x102008]
LEA RDX,[0x102004]
CMOVLE RAX,RDX
LAB_00101257:
MOV RDX,qword ptr [RSP + 0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010126c
ADD RSP,0x48
RET
LAB_0010126c:
CALL 0x00101070 | char * func0(char *param_1)
{
char *pcVar1;
long lVar2;
char cVar3;
int iVar4;
long in_FS_OFFSET;
int local_48 [11];
char local_1b [11];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
builtin_strncpy(local_1b,"AEIOUaeiou",0xb);
local_48[0] = 0;
local_48[1] = 0;
local_48[2] = 0;
local_48[3] = 0;
local_48[4] = 0;
local_48[5] = 0;
local_48[6] = 0;
local_48[7] = 0;
local_48[8] = 0;
local_48[9] = 0;
cVar3 = *param_1;
pcVar1 = "not accepted";
if (cVar3 != '\0') {
iVar4 = 0;
pcVar1 = param_1 + 1;
do {
lVar2 = 0;
do {
if ((local_1b[lVar2] == cVar3) && (local_48[lVar2] == 0)) {
local_48[(int)lVar2] = 1;
iVar4 = iVar4 + 1;
break;
}
lVar2 = lVar2 + 1;
} while (lVar2 != 10);
cVar3 = *pcVar1;
pcVar1 = pcVar1 + 1;
} while (cVar3 != '\0');
pcVar1 = "accepted";
if (iVar4 < 5) {
pcVar1 = "not accepted";
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
7,762 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| const char* func0(const char* string) {
char vowels[] = "AEIOUaeiou";
int count = 0;
int found[10] = {0}; // to track which vowels have been found
for (int i = 0; string[i] != '\0'; i++) {
for (int j = 0; j < 10; j++) {
if (string[i] == vowels[j] && found[j] == 0) {
found[j] = 1;
count++;
break;
}
}
}
if (count >= 5) {
return "accepted";
} else {
return "not accepted";
}
}
| int main() {
assert(strcmp(func0("SEEquoiaL"), "accepted") == 0);
assert(strcmp(func0("program"), "not accepted") == 0);
assert(strcmp(func0("fine"), "not accepted") == 0);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x48,%rsp
mov $0x756f,%ecx
pxor %xmm0,%xmm0
xor %r9d,%r9d
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
mov %cx,0x35(%rsp)
movzbl (%rdi),%ecx
mov %rsp,%r8
movabs $0x696561554f494541,%rax
movb $0x0,0x37(%rsp)
add $0x1,%rdi
mov %rax,0x2d(%rsp)
movq $0x0,0x20(%rsp)
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
test %cl,%cl
je 131d <func0+0xcd>
nopl (%rax)
xor %eax,%eax
mov $0x41,%edx
jmp 12cf <func0+0x7f>
nopl 0x0(%rax)
add $0x1,%rax
cmp $0xa,%rax
je 12f0 <func0+0xa0>
movzbl 0x2d(%rsp,%rax,1),%edx
movslq %eax,%rsi
cmp %cl,%dl
jne 12c0 <func0+0x70>
mov (%r8,%rax,4),%edx
test %edx,%edx
jne 12c0 <func0+0x70>
movl $0x1,(%rsp,%rsi,4)
add $0x1,%r9d
nopl 0x0(%rax)
movzbl (%rdi),%ecx
add $0x1,%rdi
test %cl,%cl
jne 12b0 <func0+0x60>
cmp $0x4,%r9d
jle 131d <func0+0xcd>
lea 0xd00(%rip),%rax
mov 0x38(%rsp),%rdi
xor %fs:0x28,%rdi
jne 1326 <func0+0xd6>
add $0x48,%rsp
retq
lea 0xce0(%rip),%rax
jmp 1308 <func0+0xb8>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
sub rsp, 48h
mov ecx, 756Fh
pxor xmm0, xmm0
xor r9d, r9d
mov rax, fs:28h
mov [rsp+48h+var_10], rax
mov rax, 696561554F494541h
mov [rsp+48h+var_13], cx
movzx ecx, byte ptr [rdi]
mov r8, rsp
mov [rsp+48h+var_11], 0
add rdi, 1
mov [rsp+48h+var_28], 0
movaps [rsp+48h+var_48], xmm0
movaps [rsp+48h+var_38], xmm0
mov [rsp+48h+var_1B], rax
test cl, cl
jz short loc_132D
nop dword ptr [rax+rax+00h]
loc_12C0:
xor eax, eax
mov edx, 41h ; 'A'
jmp short loc_12DF
loc_12D0:
add rax, 1
cmp rax, 0Ah
jz short loc_1300
movzx edx, byte ptr [rsp+rax+48h+var_1B]
loc_12DF:
movsxd rsi, eax
cmp dl, cl
jnz short loc_12D0
mov edx, [r8+rax*4]
test edx, edx
jnz short loc_12D0
mov dword ptr [rsp+rsi*4+48h+var_48], 1
add r9d, 1
nop dword ptr [rax+00000000h]
loc_1300:
movzx ecx, byte ptr [rdi]
add rdi, 1
test cl, cl
jnz short loc_12C0
cmp r9d, 4
jle short loc_132D
lea rax, aNotAccepted+4; "accepted"
loc_1318:
mov rdx, [rsp+48h+var_10]
sub rdx, fs:28h
jnz short loc_1336
add rsp, 48h
retn
loc_132D:
lea rax, aNotAccepted; "not accepted"
jmp short loc_1318
loc_1336:
call ___stack_chk_fail | char * func0(char *a1)
{
int v1; // r9d
char v2; // cl
char *v3; // rdi
long long v4; // rax
char i; // dl
_OWORD v7[2]; // [rsp+0h] [rbp-48h] BYREF
long long v8; // [rsp+20h] [rbp-28h]
_QWORD v9[3]; // [rsp+2Dh] [rbp-1Bh] BYREF
v1 = 0;
*(_QWORD *)((char *)&v9[1] + 3) = __readfsqword(0x28u);
v2 = *a1;
v3 = a1 + 1;
v8 = 0LL;
memset(v7, 0, sizeof(v7));
strcpy((char *)v9, "AEIOUaeiou");
if ( !v2 )
return "not accepted";
do
{
v4 = 0LL;
for ( i = 65; i != v2 || *((_DWORD *)v7 + v4); i = *((_BYTE *)v9 + v4) )
{
if ( ++v4 == 10 )
goto LABEL_8;
}
*((_DWORD *)v7 + (int)v4) = 1;
++v1;
LABEL_8:
v2 = *v3++;
}
while ( v2 );
if ( v1 > 4 )
return "accepted";
else
return "not accepted";
} | func0:
ENDBR64
SUB RSP,0x48
MOV ECX,0x756f
PXOR XMM0,XMM0
XOR R9D,R9D
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,0x696561554f494541
MOV word ptr [RSP + 0x35],CX
MOVZX ECX,byte ptr [RDI]
MOV R8,RSP
MOV byte ptr [RSP + 0x37],0x0
ADD RDI,0x1
MOV qword ptr [RSP + 0x20],0x0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x2d],RAX
TEST CL,CL
JZ 0x0010132d
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
XOR EAX,EAX
MOV EDX,0x41
JMP 0x001012df
LAB_001012d0:
ADD RAX,0x1
CMP RAX,0xa
JZ 0x00101300
MOVZX EDX,byte ptr [RSP + RAX*0x1 + 0x2d]
LAB_001012df:
MOVSXD RSI,EAX
CMP DL,CL
JNZ 0x001012d0
MOV EDX,dword ptr [R8 + RAX*0x4]
TEST EDX,EDX
JNZ 0x001012d0
MOV dword ptr [RSP + RSI*0x4],0x1
ADD R9D,0x1
NOP dword ptr [RAX]
LAB_00101300:
MOVZX ECX,byte ptr [RDI]
ADD RDI,0x1
TEST CL,CL
JNZ 0x001012c0
CMP R9D,0x4
JLE 0x0010132d
LEA RAX,[0x102008]
LAB_00101318:
MOV RDX,qword ptr [RSP + 0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101336
ADD RSP,0x48
RET
LAB_0010132d:
LEA RAX,[0x102004]
JMP 0x00101318
LAB_00101336:
CALL 0x00101070 | char * func0(char *param_1)
{
long lVar1;
char *pcVar2;
char cVar3;
char cVar4;
int iVar5;
long in_FS_OFFSET;
int1 local_48 [16];
int1 local_38 [16];
int8 local_28;
int8 local_1b;
int2 local_13;
int1 local_11;
long local_10;
iVar5 = 0;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_13 = 0x756f;
cVar3 = *param_1;
local_11 = 0;
param_1 = param_1 + 1;
local_28 = 0;
local_48 = (int1 [16])0x0;
local_38 = (int1 [16])0x0;
local_1b = 0x696561554f494541;
if (cVar3 != '\0') {
do {
cVar4 = 'A';
lVar1 = 0;
while ((cVar4 != cVar3 || (*(int *)(local_48 + lVar1 * 4) != 0))) {
if (lVar1 + 1 == 10) goto LAB_00101300;
cVar4 = *(char *)((long)&local_1b + lVar1 + 1);
lVar1 = lVar1 + 1;
}
*(int4 *)(local_48 + (long)(int)lVar1 * 4) = 1;
iVar5 = iVar5 + 1;
LAB_00101300:
cVar3 = *param_1;
param_1 = param_1 + 1;
} while (cVar3 != '\0');
if (4 < iVar5) {
pcVar2 = "accepted";
goto LAB_00101318;
}
}
pcVar2 = "not accepted";
LAB_00101318:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
7,763 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| const char* func0(const char* string) {
char vowels[] = "AEIOUaeiou";
int count = 0;
int found[10] = {0}; // to track which vowels have been found
for (int i = 0; string[i] != '\0'; i++) {
for (int j = 0; j < 10; j++) {
if (string[i] == vowels[j] && found[j] == 0) {
found[j] = 1;
count++;
break;
}
}
}
if (count >= 5) {
return "accepted";
} else {
return "not accepted";
}
}
| int main() {
assert(strcmp(func0("SEEquoiaL"), "accepted") == 0);
assert(strcmp(func0("program"), "not accepted") == 0);
assert(strcmp(func0("fine"), "not accepted") == 0);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x38,%rsp
pxor %xmm0,%xmm0
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movzbl (%rdi),%eax
movaps %xmm0,(%rsp)
movq $0x0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
test %al,%al
je 1478 <func0+0x228>
lea 0x1(%rdi),%rdx
xor %ecx,%ecx
jmp 12f3 <func0+0xa3>
nopl 0x0(%rax)
cmp $0x45,%al
je 1350 <func0+0x100>
cmp $0x49,%al
je 1370 <func0+0x120>
cmp $0x4f,%al
je 1390 <func0+0x140>
cmp $0x55,%al
je 13b8 <func0+0x168>
cmp $0x61,%al
je 13e0 <func0+0x190>
cmp $0x65,%al
je 1408 <func0+0x1b8>
cmp $0x69,%al
je 1430 <func0+0x1e0>
cmp $0x6f,%al
jne 1450 <func0+0x200>
mov 0x20(%rsp),%esi
test %esi,%esi
je 1484 <func0+0x234>
nopl 0x0(%rax)
movzbl (%rdx),%eax
add $0x1,%rdx
test %al,%al
je 1320 <func0+0xd0>
cmp $0x41,%al
jne 1298 <func0+0x48>
movslq (%rsp),%rax
test %eax,%eax
jne 12e8 <func0+0x98>
movl $0x1,(%rsp,%rax,4)
add $0x1,%ecx
nopl 0x0(%rax)
movzbl (%rdx),%eax
add $0x1,%rdx
test %al,%al
jne 12f3 <func0+0xa3>
nopl 0x0(%rax,%rax,1)
cmp $0x4,%ecx
jle 1478 <func0+0x228>
lea 0xcd8(%rip),%rax
mov 0x28(%rsp),%rsi
xor %fs:0x28,%rsi
jne 1498 <func0+0x248>
add $0x38,%rsp
retq
nopl 0x0(%rax)
mov 0x4(%rsp),%eax
test %eax,%eax
jne 12e8 <func0+0x98>
mov $0x1,%eax
add $0x1,%ecx
movl $0x1,(%rsp,%rax,4)
jmp 1310 <func0+0xc0>
nopl 0x0(%rax)
mov 0x8(%rsp),%eax
test %eax,%eax
jne 12e8 <func0+0x98>
mov $0x2,%eax
add $0x1,%ecx
movl $0x1,(%rsp,%rax,4)
jmp 1310 <func0+0xc0>
nopl (%rax)
mov 0xc(%rsp),%r11d
test %r11d,%r11d
jne 12e8 <func0+0x98>
mov $0x3,%eax
add $0x1,%ecx
movl $0x1,(%rsp,%rax,4)
jmpq 1310 <func0+0xc0>
nopw 0x0(%rax,%rax,1)
mov 0x10(%rsp),%r10d
test %r10d,%r10d
jne 12e8 <func0+0x98>
mov $0x4,%eax
add $0x1,%ecx
movl $0x1,(%rsp,%rax,4)
jmpq 1310 <func0+0xc0>
nopw 0x0(%rax,%rax,1)
mov 0x14(%rsp),%r9d
test %r9d,%r9d
jne 12e8 <func0+0x98>
mov $0x5,%eax
add $0x1,%ecx
movl $0x1,(%rsp,%rax,4)
jmpq 1310 <func0+0xc0>
nopw 0x0(%rax,%rax,1)
mov 0x18(%rsp),%r8d
test %r8d,%r8d
jne 12e8 <func0+0x98>
mov $0x6,%eax
add $0x1,%ecx
movl $0x1,(%rsp,%rax,4)
jmpq 1310 <func0+0xc0>
nopw 0x0(%rax,%rax,1)
mov 0x1c(%rsp),%edi
test %edi,%edi
jne 12e8 <func0+0x98>
mov $0x7,%eax
add $0x1,%ecx
movl $0x1,(%rsp,%rax,4)
jmpq 1310 <func0+0xc0>
cmp $0x75,%al
jne 12e8 <func0+0x98>
mov 0x24(%rsp),%eax
test %eax,%eax
jne 12e8 <func0+0x98>
mov $0x9,%eax
add $0x1,%ecx
movl $0x1,(%rsp,%rax,4)
jmpq 1310 <func0+0xc0>
lea 0xb85(%rip),%rax
jmpq 1330 <func0+0xe0>
mov $0x8,%eax
add $0x1,%ecx
movl $0x1,(%rsp,%rax,4)
jmpq 1310 <func0+0xc0>
callq 1060 <__stack_chk_fail@plt>
nopl (%rax)
| func0:
endbr64
sub rsp, 38h
pxor xmm0, xmm0
mov rax, fs:28h
mov [rsp+38h+var_10], rax
xor eax, eax
movzx eax, byte ptr [rdi]
movaps [rsp+38h+var_38], xmm0
mov [rsp+38h+var_18], 0
movaps [rsp+38h+var_28], xmm0
test al, al
jz loc_13B0
lea rdx, [rdi+1]
xor ecx, ecx
jmp short loc_12CB
loc_12A8:
cmp al, 45h ; 'E'
jnz short loc_1320
mov eax, dword ptr [rsp+38h+var_38+4]
test eax, eax
jz loc_13BC
nop dword ptr [rax+rax+00000000h]
loc_12C0:
movzx eax, byte ptr [rdx]
add rdx, 1
test al, al
jz short loc_12F0
loc_12CB:
cmp al, 41h ; 'A'
jnz short loc_12A8
movsxd rax, dword ptr [rsp+38h+var_38]
test eax, eax
jnz short loc_12C0
loc_12D7:
mov dword ptr [rsp+rax*4+38h+var_38], 1
add ecx, 1
loc_12E1:
movzx eax, byte ptr [rdx]
add rdx, 1
test al, al
jnz short loc_12CB
nop dword ptr [rax+00h]
loc_12F0:
cmp ecx, 4
jle loc_13B0
lea rax, s2+4; "accepted"
loc_1300:
mov rdx, [rsp+38h+var_10]
sub rdx, fs:28h
jnz loc_13F6
add rsp, 38h
retn
loc_1320:
cmp al, 49h ; 'I'
jnz short loc_1338
mov eax, dword ptr [rsp+38h+var_38+8]
test eax, eax
jnz short loc_12C0
mov eax, 2
jmp short loc_12D7
loc_1338:
cmp al, 4Fh ; 'O'
jz short loc_1370
cmp al, 55h ; 'U'
jz short loc_1390
cmp al, 61h ; 'a'
jnz loc_13D0
mov r9d, dword ptr [rsp+38h+var_28+4]
test r9d, r9d
jnz loc_12C0
mov eax, 5
add ecx, 1
mov dword ptr [rsp+rax*4+38h+var_38], 1
jmp loc_12E1
loc_1370:
mov r11d, dword ptr [rsp+38h+var_38+0Ch]
test r11d, r11d
jnz loc_12C0
mov eax, 3
jmp loc_12D7
loc_1390:
mov r10d, dword ptr [rsp+38h+var_28]
test r10d, r10d
jnz loc_12C0
mov eax, 4
jmp loc_12D7
loc_13B0:
lea rax, s2; "not accepted"
jmp loc_1300
loc_13BC:
mov eax, 1
add ecx, 1
mov dword ptr [rsp+rax*4+38h+var_38], 1
jmp loc_12E1
loc_13D0:
cmp al, 65h ; 'e'
jnz short loc_13FB
mov r8d, dword ptr [rsp+38h+var_28+8]
test r8d, r8d
jnz loc_12C0
mov eax, 6
add ecx, 1
mov dword ptr [rsp+rax*4+38h+var_38], 1
jmp loc_12E1
loc_13F6:
call ___stack_chk_fail
loc_13FB:
cmp al, 69h ; 'i'
jz short loc_1430
cmp al, 6Fh ; 'o'
jz short loc_1450
cmp al, 75h ; 'u'
jnz loc_12C0
mov eax, dword ptr [rsp+38h+var_18+4]
test eax, eax
jnz loc_12C0
mov eax, 9
add ecx, 1
mov dword ptr [rsp+rax*4+38h+var_38], 1
jmp loc_12E1
loc_1430:
mov edi, dword ptr [rsp+38h+var_28+0Ch]
test edi, edi
jnz loc_12C0
mov eax, 7
add ecx, 1
mov dword ptr [rsp+rax*4+38h+var_38], 1
jmp loc_12E1
loc_1450:
mov esi, dword ptr [rsp+38h+var_18]
test esi, esi
jnz loc_12C0
mov eax, 8
add ecx, 1
mov dword ptr [rsp+rax*4+38h+var_38], 1
jmp loc_12E1 | const char * func0(char *a1)
{
char v1; // al
char *v2; // rdx
int v3; // ecx
long long v4; // rax
__int128 v6; // [rsp+0h] [rbp-38h]
__int128 v7; // [rsp+10h] [rbp-28h]
long long v8; // [rsp+20h] [rbp-18h]
unsigned long long v9; // [rsp+28h] [rbp-10h]
v9 = __readfsqword(0x28u);
v1 = *a1;
v6 = 0LL;
v8 = 0LL;
v7 = 0LL;
if ( !v1 )
return "not accepted";
v2 = a1 + 1;
v3 = 0;
do
{
while ( 1 )
{
if ( v1 == 65 )
{
v4 = (int)v6;
if ( !(_DWORD)v6 )
goto LABEL_8;
goto LABEL_5;
}
if ( v1 == 69 )
break;
switch ( v1 )
{
case 'I':
if ( !DWORD2(v6) )
{
v4 = 2LL;
LABEL_8:
*((_DWORD *)&v6 + v4) = 1;
++v3;
goto LABEL_9;
}
break;
case 'O':
if ( !HIDWORD(v6) )
{
v4 = 3LL;
goto LABEL_8;
}
break;
case 'U':
if ( !(_DWORD)v7 )
{
v4 = 4LL;
goto LABEL_8;
}
break;
default:
switch ( v1 )
{
case 'a':
if ( DWORD1(v7) )
goto LABEL_5;
++v3;
DWORD1(v7) = 1;
break;
case 'e':
if ( DWORD2(v7) )
goto LABEL_5;
++v3;
DWORD2(v7) = 1;
break;
case 'i':
if ( HIDWORD(v7) )
goto LABEL_5;
++v3;
HIDWORD(v7) = 1;
break;
case 'o':
if ( (_DWORD)v8 )
goto LABEL_5;
++v3;
LODWORD(v8) = 1;
break;
default:
if ( v1 != 117 || HIDWORD(v8) )
goto LABEL_5;
++v3;
HIDWORD(v8) = 1;
break;
}
goto LABEL_9;
}
LABEL_5:
v1 = *v2++;
if ( !v1 )
goto LABEL_10;
}
if ( DWORD1(v6) )
goto LABEL_5;
++v3;
DWORD1(v6) = 1;
LABEL_9:
v1 = *v2++;
}
while ( v1 );
LABEL_10:
if ( v3 > 4 )
return "accepted";
return "not accepted";
} | func0:
ENDBR64
SUB RSP,0x38
PXOR XMM0,XMM0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOVZX EAX,byte ptr [RDI]
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x20],0x0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
TEST AL,AL
JZ 0x001013b0
LEA RDX,[RDI + 0x1]
XOR ECX,ECX
JMP 0x001012cb
LAB_001012a8:
CMP AL,0x45
JNZ 0x00101320
MOV EAX,dword ptr [RSP + 0x4]
TEST EAX,EAX
JZ 0x001013bc
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
MOVZX EAX,byte ptr [RDX]
ADD RDX,0x1
TEST AL,AL
JZ 0x001012f0
LAB_001012cb:
CMP AL,0x41
JNZ 0x001012a8
MOVSXD RAX,dword ptr [RSP]
TEST EAX,EAX
JNZ 0x001012c0
LAB_001012d7:
MOV dword ptr [RSP + RAX*0x4],0x1
ADD ECX,0x1
LAB_001012e1:
MOVZX EAX,byte ptr [RDX]
ADD RDX,0x1
TEST AL,AL
JNZ 0x001012cb
NOP dword ptr [RAX]
LAB_001012f0:
CMP ECX,0x4
JLE 0x001013b0
LEA RAX,[0x102008]
LAB_00101300:
MOV RDX,qword ptr [RSP + 0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001013f6
ADD RSP,0x38
RET
LAB_00101320:
CMP AL,0x49
JNZ 0x00101338
MOV EAX,dword ptr [RSP + 0x8]
TEST EAX,EAX
JNZ 0x001012c0
MOV EAX,0x2
JMP 0x001012d7
LAB_00101338:
CMP AL,0x4f
JZ 0x00101370
CMP AL,0x55
JZ 0x00101390
CMP AL,0x61
JNZ 0x001013d0
MOV R9D,dword ptr [RSP + 0x14]
TEST R9D,R9D
JNZ 0x001012c0
MOV EAX,0x5
ADD ECX,0x1
MOV dword ptr [RSP + RAX*0x4],0x1
JMP 0x001012e1
LAB_00101370:
MOV R11D,dword ptr [RSP + 0xc]
TEST R11D,R11D
JNZ 0x001012c0
MOV EAX,0x3
JMP 0x001012d7
LAB_00101390:
MOV R10D,dword ptr [RSP + 0x10]
TEST R10D,R10D
JNZ 0x001012c0
MOV EAX,0x4
JMP 0x001012d7
LAB_001013b0:
LEA RAX,[0x102004]
JMP 0x00101300
LAB_001013bc:
MOV EAX,0x1
ADD ECX,0x1
MOV dword ptr [RSP + RAX*0x4],0x1
JMP 0x001012e1
LAB_001013d0:
CMP AL,0x65
JNZ 0x001013fb
MOV R8D,dword ptr [RSP + 0x18]
TEST R8D,R8D
JNZ 0x001012c0
MOV EAX,0x6
ADD ECX,0x1
MOV dword ptr [RSP + RAX*0x4],0x1
JMP 0x001012e1
LAB_001013f6:
CALL 0x00101070
LAB_001013fb:
CMP AL,0x69
JZ 0x00101430
CMP AL,0x6f
JZ 0x00101450
CMP AL,0x75
JNZ 0x001012c0
MOV EAX,dword ptr [RSP + 0x24]
TEST EAX,EAX
JNZ 0x001012c0
MOV EAX,0x9
ADD ECX,0x1
MOV dword ptr [RSP + RAX*0x4],0x1
JMP 0x001012e1
LAB_00101430:
MOV EDI,dword ptr [RSP + 0x1c]
TEST EDI,EDI
JNZ 0x001012c0
MOV EAX,0x7
ADD ECX,0x1
MOV dword ptr [RSP + RAX*0x4],0x1
JMP 0x001012e1
LAB_00101450:
MOV ESI,dword ptr [RSP + 0x20]
TEST ESI,ESI
JNZ 0x001012c0
MOV EAX,0x8
ADD ECX,0x1
MOV dword ptr [RSP + RAX*0x4],0x1
JMP 0x001012e1 | char * func0(char *param_1)
{
char cVar1;
long lVar2;
char *pcVar3;
int iVar4;
long in_FS_OFFSET;
int local_38 [16];
int local_28 [16];
int8 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
cVar1 = *param_1;
local_38 = (int [16])0x0;
local_18 = 0;
local_28 = (int [16])0x0;
if (cVar1 != '\0') {
param_1 = param_1 + 1;
iVar4 = 0;
do {
while (cVar1 == 'A') {
lVar2 = (long)(int)local_38._0_4_;
if (local_38._0_4_ == 0) goto LAB_001012d7;
LAB_001012c0:
cVar1 = *param_1;
param_1 = param_1 + 1;
if (cVar1 == '\0') goto LAB_001012f0;
}
if (cVar1 == 'E') {
if (local_38._4_4_ == 0) {
local_38._4_4_ = 1;
goto LAB_001012e1;
}
goto LAB_001012c0;
}
if (cVar1 == 'I') {
if (local_38._8_4_ == 0) {
lVar2 = 2;
LAB_001012d7:
*(int4 *)(local_38 + lVar2 * 4) = 1;
goto LAB_001012e1;
}
goto LAB_001012c0;
}
if (cVar1 == 'O') {
if (local_38._12_4_ == 0) {
lVar2 = 3;
goto LAB_001012d7;
}
goto LAB_001012c0;
}
if (cVar1 == 'U') {
if (local_28._0_4_ == 0) {
lVar2 = 4;
goto LAB_001012d7;
}
goto LAB_001012c0;
}
if (cVar1 == 'a') {
if (local_28._4_4_ == 0) {
local_28._4_4_ = 1;
goto LAB_001012e1;
}
goto LAB_001012c0;
}
if (cVar1 == 'e') {
if (local_28._8_4_ == 0) {
local_28._8_4_ = 1;
goto LAB_001012e1;
}
goto LAB_001012c0;
}
if (cVar1 == 'i') {
if (local_28._12_4_ == 0) {
local_28._12_4_ = 1;
goto LAB_001012e1;
}
goto LAB_001012c0;
}
if (cVar1 == 'o') {
if ((int)local_18 == 0) {
local_18 = CONCAT44(local_18._4_4_,1);
goto LAB_001012e1;
}
goto LAB_001012c0;
}
if ((cVar1 != 'u') || (local_18._4_4_ != 0)) goto LAB_001012c0;
local_18 = CONCAT44(1,(int)local_18);
LAB_001012e1:
iVar4 = iVar4 + 1;
cVar1 = *param_1;
param_1 = param_1 + 1;
} while (cVar1 != '\0');
LAB_001012f0:
if (4 < iVar4) {
pcVar3 = "accepted";
goto LAB_00101300;
}
}
pcVar3 = "not accepted";
LAB_00101300:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar3;
} |
7,764 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int A, int B, int N) {
int x = (B - 1 < N) ? (B - 1) : N;
return (A * x) / B;
}
| int main() {
assert(func0(11, 10, 9) == 9);
assert(func0(5, 7, 4) == 2);
assert(func0(2, 2, 1) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x18(%rbp),%eax
cmp -0x1c(%rbp),%eax
jg 116a <func0+0x21>
mov -0x18(%rbp),%eax
sub $0x1,%eax
jmp 116d <func0+0x24>
mov -0x1c(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x14(%rbp),%eax
imul -0x4(%rbp),%eax
cltd
idivl -0x18(%rbp)
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 eax, [rbp+var_18]
cmp eax, [rbp+var_1C]
jg short loc_116A
mov eax, [rbp+var_18]
sub eax, 1
jmp short loc_116D
loc_116A:
mov eax, [rbp+var_1C]
loc_116D:
mov [rbp+var_4], eax
mov eax, [rbp+var_14]
imul eax, [rbp+var_4]
cdq
idiv [rbp+var_18]
pop rbp
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
if ( a2 > a3 )
v3 = a3;
else
v3 = a2 - 1;
return (unsigned int)(v3 * a1 / a2);
} | 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 EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x1c]
JG 0x0010116a
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
JMP 0x0010116d
LAB_0010116a:
MOV EAX,dword ptr [RBP + -0x1c]
LAB_0010116d:
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,dword ptr [RBP + -0x4]
CDQ
IDIV dword ptr [RBP + -0x18]
POP RBP
RET | int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_2 <= param_3) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_1 * param_3) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_1 * param_3) % (long)param_2 & 0xffffffff;
return auVar1;
} |
7,765 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int A, int B, int N) {
int x = (B - 1 < N) ? (B - 1) : N;
return (A * x) / B;
}
| int main() {
assert(func0(11, 10, 9) == 9);
assert(func0(5, 7, 4) == 2);
assert(func0(2, 2, 1) == 1);
return 0;
}
| O1 | c | func0:
endbr64
lea -0x1(%rsi),%eax
cmp %edx,%esi
cmovle %eax,%edx
mov %edx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
| func0:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp esi, eax
cmovle eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 <= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP ESI,EAX
CMOVLE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | int1 [16] func0(int param_1,int param_2,int param_3)
{
int1 auVar1 [16];
if (param_2 <= param_3) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
return auVar1;
} |
7,766 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int A, int B, int N) {
int x = (B - 1 < N) ? (B - 1) : N;
return (A * x) / B;
}
| int main() {
assert(func0(11, 10, 9) == 9);
assert(func0(5, 7, 4) == 2);
assert(func0(2, 2, 1) == 1);
return 0;
}
| O2 | c | func0:
endbr64
cmp %edx,%esi
lea -0x1(%rsi),%eax
cmovle %eax,%edx
mov %edx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp esi, eax
cmovle eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 <= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP ESI,EAX
CMOVLE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | int1 [16] func0(int param_1,int param_2,int param_3)
{
int1 auVar1 [16];
if (param_2 <= param_3) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
return auVar1;
} |
7,767 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int A, int B, int N) {
int x = (B - 1 < N) ? (B - 1) : N;
return (A * x) / B;
}
| int main() {
assert(func0(11, 10, 9) == 9);
assert(func0(5, 7, 4) == 2);
assert(func0(2, 2, 1) == 1);
return 0;
}
| O3 | c | func0:
endbr64
cmp %edx,%esi
lea -0x1(%rsi),%eax
cmovle %eax,%edx
mov %edx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp esi, eax
cmovle eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 <= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP ESI,EAX
CMOVLE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_2 <= param_3) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
return auVar1;
} |
7,768 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int size;
int *elements;
} tuple;
| tuple* func0(tuple test_list[], int list_size) {
tuple *res = malloc(sizeof(tuple) * list_size);
int res_size = 0;
for (int i = 0; i < list_size; i++) {
if (res_size > 0 && res[res_size - 1].elements[0] == test_list[i].elements[0]) {
// Resize the last tuple in res to accommodate new elements
int last_size = res[res_size - 1].size;
int this_size = test_list[i].size;
res[res_size - 1].elements = realloc(res[res_size - 1].elements, sizeof(int) * (last_size + this_size - 1));
// Copy the elements from test_list[i] except the first one
for (int j = 1; j < this_size; j++) {
res[res_size - 1].elements[last_size + j - 1] = test_list[i].elements[j];
}
res[res_size - 1].size = last_size + this_size - 1;
} else {
res[res_size].elements = malloc(sizeof(int) * test_list[i].size);
for (int j = 0; j < test_list[i].size; j++) {
res[res_size].elements[j] = test_list[i].elements[j];
}
res[res_size].size = test_list[i].size;
res_size++;
}
}
return res;
}
| int main() {
tuple list1[] = {{2, (int[]){5, 6}}, {2, (int[]){5, 7}}, {2, (int[]){6, 8}}, {2, (int[]){6, 10}}, {2, (int[]){7, 13}}};
tuple *result1 = func0(list1, 5);
assert(result1[0].size == 3 && (result1[0].elements[0] == 5 && result1[0].elements[1] == 6 && result1[0].elements[2] == 7));
assert(result1[1].size == 3 && (result1[1].elements[0] == 6 && result1[1].elements[1] == 8 && result1[1].elements[2] == 10));
assert(result1[2].size == 2 && (result1[2].elements[0] == 7 && result1[2].elements[1] == 13));
tuple list2[] = {{2, (int[]){6, 7}}, {2, (int[]){6, 8}}, {2, (int[]){7, 9}}, {2, (int[]){7, 11}}, {2, (int[]){8, 14}}};
tuple *result2 = func0(list2, 5);
assert(result2[0].size == 3 && (result2[0].elements[0] == 6 && result2[0].elements[1] == 7 && result2[0].elements[2] == 8));
assert(result2[1].size == 3 && (result2[1].elements[0] == 7 && result2[1].elements[1] == 9 && result2[1].elements[2] == 11));
assert(result2[2].size == 2 && (result2[2].elements[0] == 8 && result2[2].elements[1] == 14));
tuple list3[] = {{2, (int[]){7, 8}}, {2, (int[]){7, 9}}, {2, (int[]){8, 10}}, {2, (int[]){8, 12}}, {2, (int[]){9, 15}}};
tuple *result3 = func0(list3, 5);
assert(result3[0].size == 3 && (result3[0].elements[0] == 7 && result3[0].elements[1] == 8 && result3[0].elements[2] == 9));
assert(result3[1].size == 3 && (result3[1].elements[0] == 8 && result3[1].elements[1] == 10 && result3[1].elements[2] == 12));
assert(result3[2].size == 2 && (result3[2].elements[0] == 9 && result3[2].elements[1] == 15));
free(result1);
free(result2);
free(result3);
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 -0x3c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdi
callq 10c0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x30(%rbp)
movl $0x0,-0x2c(%rbp)
jmpq 1442 <func0+0x279>
cmpl $0x0,-0x30(%rbp)
jle 135f <func0+0x196>
mov -0x30(%rbp),%eax
cltq
shl $0x4,%rax
lea -0x10(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%rax
mov (%rax),%edx
mov -0x2c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rcx
mov -0x38(%rbp),%rax
add %rcx,%rax
mov 0x8(%rax),%rax
mov (%rax),%eax
cmp %eax,%edx
jne 135f <func0+0x196>
mov -0x30(%rbp),%eax
cltq
shl $0x4,%rax
lea -0x10(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x20(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x1c(%rbp)
mov -0x20(%rbp),%edx
mov -0x1c(%rbp),%eax
add %edx,%eax
sub $0x1,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x30(%rbp),%eax
cltq
shl $0x4,%rax
lea -0x10(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov 0x8(%rax),%rax
mov -0x30(%rbp),%ecx
movslq %ecx,%rcx
shl $0x4,%rcx
lea -0x10(%rcx),%rsi
mov -0x18(%rbp),%rcx
lea (%rsi,%rcx,1),%rbx
mov %rdx,%rsi
mov %rax,%rdi
callq 10d0 <realloc@plt>
mov %rax,0x8(%rbx)
movl $0x1,-0x28(%rbp)
jmp 1331 <func0+0x168>
mov -0x2c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%rax
mov -0x28(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
shl $0x4,%rdx
lea -0x10(%rdx),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov 0x8(%rdx),%rdx
mov -0x20(%rbp),%esi
mov -0x28(%rbp),%ecx
add %esi,%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
sub $0x4,%rcx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 12d6 <func0+0x10d>
mov -0x20(%rbp),%edx
mov -0x1c(%rbp),%eax
add %eax,%edx
mov -0x30(%rbp),%eax
cltq
shl $0x4,%rax
lea -0x10(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
sub $0x1,%edx
mov %edx,(%rax)
jmpq 143e <func0+0x275>
mov -0x2c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltq
shl $0x2,%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
mov %rdx,%rcx
shl $0x4,%rcx
mov -0x18(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 10c0 <malloc@plt>
mov %rax,0x8(%rbx)
movl $0x0,-0x24(%rbp)
jmp 13f5 <func0+0x22c>
mov -0x2c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov 0x8(%rax),%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
mov %rdx,%rcx
shl $0x4,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov 0x8(%rdx),%rdx
mov -0x24(%rbp),%ecx
movslq %ecx,%rcx
shl $0x2,%rcx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x24(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x24(%rbp)
jl 13a4 <func0+0x1db>
mov -0x2c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov -0x30(%rbp),%edx
movslq %edx,%rdx
mov %rdx,%rcx
shl $0x4,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x30(%rbp)
addl $0x1,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 1205 <func0+0x3c>
mov -0x18(%rbp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov eax, [rbp+var_3C]
cdqe
shl rax, 4
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_30], 0
mov [rbp+var_2C], 0
jmp loc_1442
loc_1205:
cmp [rbp+var_30], 0
jle loc_135F
mov eax, [rbp+var_30]
cdqe
shl rax, 4
lea rdx, [rax-10h]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax+8]
mov edx, [rax]
mov eax, [rbp+var_2C]
cdqe
shl rax, 4
mov rcx, rax
mov rax, [rbp+var_38]
add rax, rcx
mov rax, [rax+8]
mov eax, [rax]
cmp edx, eax
jnz loc_135F
mov eax, [rbp+var_30]
cdqe
shl rax, 4
lea rdx, [rax-10h]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_20], eax
mov eax, [rbp+var_2C]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
mov [rbp+var_1C], eax
mov edx, [rbp+var_20]
mov eax, [rbp+var_1C]
add eax, edx
sub eax, 1
cdqe
lea rdx, ds:0[rax*4]
mov eax, [rbp+var_30]
cdqe
shl rax, 4
lea rcx, [rax-10h]
mov rax, [rbp+var_18]
add rax, rcx
mov rax, [rax+8]
mov ecx, [rbp+var_30]
movsxd rcx, ecx
shl rcx, 4
lea rsi, [rcx-10h]
mov rcx, [rbp+var_18]
lea rbx, [rsi+rcx]
mov rsi, rdx; size
mov rdi, rax; ptr
call _realloc
mov [rbx+8], rax
mov [rbp+var_28], 1
jmp short loc_1331
loc_12D6:
mov eax, [rbp+var_2C]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax+8]
mov edx, [rbp+var_28]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rbp+var_30]
movsxd rdx, edx
shl rdx, 4
lea rcx, [rdx-10h]
mov rdx, [rbp+var_18]
add rdx, rcx
mov rdx, [rdx+8]
mov esi, [rbp+var_20]
mov ecx, [rbp+var_28]
add ecx, esi
movsxd rcx, ecx
shl rcx, 2
sub rcx, 4
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_28], 1
loc_1331:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_1C]
jl short loc_12D6
mov edx, [rbp+var_20]
mov eax, [rbp+var_1C]
add edx, eax
mov eax, [rbp+var_30]
cdqe
shl rax, 4
lea rcx, [rax-10h]
mov rax, [rbp+var_18]
add rax, rcx
sub edx, 1
mov [rax], edx
jmp loc_143E
loc_135F:
mov eax, [rbp+var_2C]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
cdqe
shl rax, 2
mov edx, [rbp+var_30]
movsxd rdx, edx
mov rcx, rdx
shl rcx, 4
mov rdx, [rbp+var_18]
lea rbx, [rcx+rdx]
mov rdi, rax; size
call _malloc
mov [rbx+8], rax
mov [rbp+var_24], 0
jmp short loc_13F5
loc_13A4:
mov eax, [rbp+var_2C]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_38]
add rax, rdx
mov rax, [rax+8]
mov edx, [rbp+var_24]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov edx, [rbp+var_30]
movsxd rdx, edx
mov rcx, rdx
shl rcx, 4
mov rdx, [rbp+var_18]
add rdx, rcx
mov rdx, [rdx+8]
mov ecx, [rbp+var_24]
movsxd rcx, ecx
shl rcx, 2
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_24], 1
loc_13F5:
mov eax, [rbp+var_2C]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_38]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_24], eax
jl short loc_13A4
mov eax, [rbp+var_2C]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_38]
add rax, rdx
mov edx, [rbp+var_30]
movsxd rdx, edx
mov rcx, rdx
shl rcx, 4
mov rdx, [rbp+var_18]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_30], 1
loc_143E:
add [rbp+var_2C], 1
loc_1442:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_3C]
jl loc_1205
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-30h]
int i; // [rsp+14h] [rbp-2Ch]
int j; // [rsp+18h] [rbp-28h]
int k; // [rsp+1Ch] [rbp-24h]
int v7; // [rsp+20h] [rbp-20h]
int v8; // [rsp+24h] [rbp-1Ch]
_DWORD *v9; // [rsp+28h] [rbp-18h]
v9 = malloc(16LL * a2);
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( v3 > 0 && **(_DWORD **)&v9[4 * v3 - 2] == **(_DWORD **)(16LL * i + a1 + 8) )
{
v7 = v9[4 * v3 - 4];
v8 = *(_DWORD *)(16LL * i + a1);
*(_QWORD *)&v9[4 * v3 - 2] = realloc(*(void **)&v9[4 * v3 - 2], 4LL * (v7 + v8 - 1));
for ( j = 1; j < v8; ++j )
*(_DWORD *)(4LL * (v7 + j) - 4 + *(_QWORD *)&v9[4 * v3 - 2]) = *(_DWORD *)(4LL * j
+ *(_QWORD *)(16LL * i + a1 + 8));
v9[4 * v3 - 4] = v8 + v7 - 1;
}
else
{
*(_QWORD *)&v9[4 * v3 + 2] = malloc(4LL * *(int *)(16LL * i + a1));
for ( k = 0; k < *(_DWORD *)(16LL * i + a1); ++k )
*(_DWORD *)(4LL * k + *(_QWORD *)&v9[4 * v3 + 2]) = *(_DWORD *)(4LL * k + *(_QWORD *)(16LL * i + a1 + 8));
v9[4 * v3++] = *(_DWORD *)(16LL * i + a1);
}
}
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x4
MOV RDI,RAX
CALL 0x001010c0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x00101442
LAB_00101205:
CMP dword ptr [RBP + -0x30],0x0
JLE 0x0010135f
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x4
LEA RDX,[RAX + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX + 0x8]
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x4
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x0010135f
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x4
LEA RDX,[RAX + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
MOV EDX,dword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EDX
SUB EAX,0x1
CDQE
LEA RDX,[RAX*0x4]
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x4
LEA RCX,[RAX + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x30]
MOVSXD RCX,ECX
SHL RCX,0x4
LEA RSI,[RCX + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
LEA RBX,[RSI + RCX*0x1]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBP + -0x28],0x1
JMP 0x00101331
LAB_001012d6:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX + 0x8]
MOV EDX,dword ptr [RBP + -0x28]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
SHL RDX,0x4
LEA RCX,[RDX + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV RDX,qword ptr [RDX + 0x8]
MOV ESI,dword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x28]
ADD ECX,ESI
MOVSXD RCX,ECX
SHL RCX,0x2
SUB RCX,0x4
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x28],0x1
LAB_00101331:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001012d6
MOV EDX,dword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x1c]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x4
LEA RCX,[RAX + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
SUB EDX,0x1
MOV dword ptr [RAX],EDX
JMP 0x0010143e
LAB_0010135f:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQE
SHL RAX,0x2
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
MOV RCX,RDX
SHL RCX,0x4
MOV RDX,qword ptr [RBP + -0x18]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x001010c0
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBP + -0x24],0x0
JMP 0x001013f5
LAB_001013a4:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RAX,qword ptr [RAX + 0x8]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
MOV RCX,RDX
SHL RCX,0x4
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV RDX,qword ptr [RDX + 0x8]
MOV ECX,dword ptr [RBP + -0x24]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x24],0x1
LAB_001013f5:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x24],EAX
JL 0x001013a4
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x30]
MOVSXD RDX,EDX
MOV RCX,RDX
SHL RCX,0x4
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x30],0x1
LAB_0010143e:
ADD dword ptr [RBP + -0x2c],0x1
LAB_00101442:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x00101205
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
void *pvVar3;
void *pvVar4;
int local_38;
int local_34;
int local_30;
int local_2c;
pvVar3 = malloc((long)param_2 << 4);
local_38 = 0;
for (local_34 = 0; local_34 < param_2; local_34 = local_34 + 1) {
if ((local_38 < 1) ||
(**(int **)((long)pvVar3 + (long)local_38 * 0x10 + -8) !=
**(int **)(param_1 + (long)local_34 * 0x10 + 8))) {
pvVar4 = malloc((long)*(int *)(param_1 + (long)local_34 * 0x10) << 2);
*(void **)((long)pvVar3 + (long)local_38 * 0x10 + 8) = pvVar4;
for (local_2c = 0; local_2c < *(int *)(param_1 + (long)local_34 * 0x10);
local_2c = local_2c + 1) {
*(int4 *)(*(long *)((long)pvVar3 + (long)local_38 * 0x10 + 8) + (long)local_2c * 4) =
*(int4 *)(*(long *)(param_1 + (long)local_34 * 0x10 + 8) + (long)local_2c * 4);
}
*(int4 *)((long)pvVar3 + (long)local_38 * 0x10) =
*(int4 *)(param_1 + (long)local_34 * 0x10);
local_38 = local_38 + 1;
}
else {
iVar1 = *(int *)((long)pvVar3 + (long)local_38 * 0x10 + -0x10);
iVar2 = *(int *)(param_1 + (long)local_34 * 0x10);
pvVar4 = realloc(*(void **)((long)pvVar3 + (long)local_38 * 0x10 + -8),
(long)(iVar2 + iVar1 + -1) * 4);
*(void **)((long)pvVar3 + (long)local_38 * 0x10 + -8) = pvVar4;
for (local_30 = 1; local_30 < iVar2; local_30 = local_30 + 1) {
*(int4 *)
(*(long *)((long)pvVar3 + (long)local_38 * 0x10 + -8) + (long)(local_30 + iVar1) * 4 + -4)
= *(int4 *)(*(long *)(param_1 + (long)local_34 * 0x10 + 8) + (long)local_30 * 4);
}
*(int *)((long)pvVar3 + (long)local_38 * 0x10 + -0x10) = iVar1 + iVar2 + -1;
}
}
return pvVar3;
} |
7,769 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int size;
int *elements;
} tuple;
| tuple* func0(tuple test_list[], int list_size) {
tuple *res = malloc(sizeof(tuple) * list_size);
int res_size = 0;
for (int i = 0; i < list_size; i++) {
if (res_size > 0 && res[res_size - 1].elements[0] == test_list[i].elements[0]) {
// Resize the last tuple in res to accommodate new elements
int last_size = res[res_size - 1].size;
int this_size = test_list[i].size;
res[res_size - 1].elements = realloc(res[res_size - 1].elements, sizeof(int) * (last_size + this_size - 1));
// Copy the elements from test_list[i] except the first one
for (int j = 1; j < this_size; j++) {
res[res_size - 1].elements[last_size + j - 1] = test_list[i].elements[j];
}
res[res_size - 1].size = last_size + this_size - 1;
} else {
res[res_size].elements = malloc(sizeof(int) * test_list[i].size);
for (int j = 0; j < test_list[i].size; j++) {
res[res_size].elements[j] = test_list[i].elements[j];
}
res[res_size].size = test_list[i].size;
res_size++;
}
}
return res;
}
| int main() {
tuple list1[] = {{2, (int[]){5, 6}}, {2, (int[]){5, 7}}, {2, (int[]){6, 8}}, {2, (int[]){6, 10}}, {2, (int[]){7, 13}}};
tuple *result1 = func0(list1, 5);
assert(result1[0].size == 3 && (result1[0].elements[0] == 5 && result1[0].elements[1] == 6 && result1[0].elements[2] == 7));
assert(result1[1].size == 3 && (result1[1].elements[0] == 6 && result1[1].elements[1] == 8 && result1[1].elements[2] == 10));
assert(result1[2].size == 2 && (result1[2].elements[0] == 7 && result1[2].elements[1] == 13));
tuple list2[] = {{2, (int[]){6, 7}}, {2, (int[]){6, 8}}, {2, (int[]){7, 9}}, {2, (int[]){7, 11}}, {2, (int[]){8, 14}}};
tuple *result2 = func0(list2, 5);
assert(result2[0].size == 3 && (result2[0].elements[0] == 6 && result2[0].elements[1] == 7 && result2[0].elements[2] == 8));
assert(result2[1].size == 3 && (result2[1].elements[0] == 7 && result2[1].elements[1] == 9 && result2[1].elements[2] == 11));
assert(result2[2].size == 2 && (result2[2].elements[0] == 8 && result2[2].elements[1] == 14));
tuple list3[] = {{2, (int[]){7, 8}}, {2, (int[]){7, 9}}, {2, (int[]){8, 10}}, {2, (int[]){8, 12}}, {2, (int[]){9, 15}}};
tuple *result3 = func0(list3, 5);
assert(result3[0].size == 3 && (result3[0].elements[0] == 7 && result3[0].elements[1] == 8 && result3[0].elements[2] == 9));
assert(result3[1].size == 3 && (result3[1].elements[0] == 8 && result3[1].elements[1] == 10 && result3[1].elements[2] == 12));
assert(result3[2].size == 2 && (result3[2].elements[0] == 9 && result3[2].elements[1] == 15));
free(result1);
free(result2);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %esi,%ebx
movslq %esi,%rdi
shl $0x4,%rdi
callq 10c0 <malloc@plt>
mov %rax,%r15
test %ebx,%ebx
jle 12f9 <func0+0x130>
mov %rbp,%r13
lea -0x1(%rbx),%eax
shl $0x4,%rax
lea 0x10(%rbp,%rax,1),%rax
mov %rax,(%rsp)
mov $0x0,%r14d
jmp 126d <func0+0xa4>
mov %r13,%rbp
mov 0x0(%r13),%ebx
movslq %r14d,%r12
shl $0x4,%r12
add %r15,%r12
movslq %ebx,%rdi
shl $0x2,%rdi
callq 10c0 <malloc@plt>
mov %rax,0x8(%r12)
test %ebx,%ebx
jle 1257 <func0+0x8e>
mov $0x0,%eax
mov 0x8(%rbp),%rdx
mov (%rdx,%rax,4),%ecx
mov 0x8(%r12),%rdx
mov %ecx,(%rdx,%rax,4)
mov 0x0(%rbp),%ebx
add $0x1,%rax
cmp %eax,%ebx
jg 123d <func0+0x74>
mov %ebx,(%r12)
add $0x1,%r14d
add $0x10,%r13
cmp (%rsp),%r13
je 12f9 <func0+0x130>
test %r14d,%r14d
jle 1212 <func0+0x49>
movslq %r14d,%rax
shl $0x4,%rax
lea -0x10(%r15,%rax,1),%rbx
mov 0x8(%rbx),%rdi
mov %r13,%rbp
mov 0x8(%r13),%rax
mov (%rax),%eax
cmp %eax,(%rdi)
jne 1212 <func0+0x49>
mov (%rbx),%eax
mov 0x0(%r13),%r12d
mov %eax,0xc(%rsp)
lea -0x1(%rax,%r12,1),%eax
mov %eax,0x8(%rsp)
movslq %eax,%rsi
shl $0x2,%rsi
callq 10d0 <realloc@plt>
mov %rax,0x8(%rbx)
cmp $0x1,%r12d
jle 12ee <func0+0x125>
lea -0x2(%r12),%eax
lea 0x8(,%rax,4),%rdi
movslq 0xc(%rsp),%rsi
shl $0x2,%rsi
mov $0x4,%eax
mov 0x8(%rbp),%rdx
mov (%rdx,%rax,1),%ecx
mov %rax,%rdx
add 0x8(%rbx),%rdx
mov %ecx,-0x4(%rsi,%rdx,1)
add $0x4,%rax
cmp %rdi,%rax
jne 12d3 <func0+0x10a>
mov 0x8(%rsp),%eax
mov %eax,(%rbx)
jmpq 125f <func0+0x96>
mov %r15,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
mov ebx, esi
movsxd rdi, esi
shl rdi, 4
call _malloc
mov r15, rax
test ebx, ebx
jle loc_12F3
mov r13, rbp
lea eax, [rbx-1]
shl rax, 4
lea rax, [rbp+rax+10h]
mov [rsp+48h+var_48], rax
mov r14d, 0
jmp short loc_126D
loc_1212:
mov rbp, r13
mov ebx, [r13+0]
movsxd r12, r14d
shl r12, 4
add r12, r15
movsxd rdi, ebx
shl rdi, 2
call _malloc
mov [r12+8], rax
test ebx, ebx
jle short loc_1257
mov eax, 0
loc_123D:
mov rdx, [rbp+8]
mov ecx, [rdx+rax*4]
mov rdx, [r12+8]
mov [rdx+rax*4], ecx
mov ebx, [rbp+0]
add rax, 1
cmp ebx, eax
jg short loc_123D
loc_1257:
mov [r12], ebx
add r14d, 1
loc_125F:
add r13, 10h
cmp r13, [rsp+48h+var_48]
jz loc_12F3
loc_126D:
test r14d, r14d
jle short loc_1212
movsxd rax, r14d
shl rax, 4
lea rbx, [r15+rax-10h]
mov rdi, [rbx+8]
mov rbp, r13
mov rax, [r13+8]
mov eax, [rax]
cmp [rdi], eax
jnz short loc_1212
mov eax, [rbx]
mov r12d, [r13+0]
mov [rsp+48h+var_3C], eax
lea eax, [rax+r12-1]
mov [rsp+48h+var_40], eax
movsxd rsi, eax
shl rsi, 2
call _realloc
mov [rbx+8], rax
cmp r12d, 1
jle short loc_12E8
mov r12d, r12d
shl r12, 2
movsxd rsi, [rsp+48h+var_3C]
shl rsi, 2
mov eax, 4
loc_12CD:
mov rdx, [rbp+8]
mov ecx, [rdx+rax]
mov rdx, rax
add rdx, [rbx+8]
mov [rsi+rdx-4], ecx
add rax, 4
cmp rax, r12
jnz short loc_12CD
loc_12E8:
mov eax, [rsp+48h+var_40]
mov [rbx], eax
jmp loc_125F
loc_12F3:
mov rax, r15
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(int *a1, int a2)
{
long long v2; // r15
int *v3; // r13
int v4; // r14d
int v5; // ebx
long long v6; // r12
long long v7; // rax
long long v8; // rbx
_DWORD *v9; // rdi
int v10; // r12d
long long v11; // r12
long long v12; // rax
long long v14; // [rsp+0h] [rbp-48h]
int v15; // [rsp+8h] [rbp-40h]
int v16; // [rsp+Ch] [rbp-3Ch]
v2 = malloc(16LL * a2);
if ( a2 > 0 )
{
v3 = a1;
v14 = (long long)&a1[4 * (a2 - 1) + 4];
v4 = 0;
do
{
if ( v4 > 0 && (v8 = v2 + 16LL * v4 - 16, v9 = *(_DWORD **)(v8 + 8), *v9 == **((_DWORD **)v3 + 1)) )
{
v10 = *v3;
v16 = *(_DWORD *)v8;
v15 = *(_DWORD *)v8 + *v3 - 1;
*(_QWORD *)(v8 + 8) = realloc(v9, 4LL * v15);
if ( v10 > 1 )
{
v11 = 4LL * (unsigned int)v10;
v12 = 4LL;
do
{
*(_DWORD *)(4LL * v16 + *(_QWORD *)(v8 + 8) + v12 - 4) = *(_DWORD *)(*((_QWORD *)v3 + 1) + v12);
v12 += 4LL;
}
while ( v12 != v11 );
}
*(_DWORD *)v8 = v15;
}
else
{
v5 = *v3;
v6 = v2 + 16LL * v4;
*(_QWORD *)(v6 + 8) = malloc(4LL * *v3);
if ( v5 > 0 )
{
v7 = 0LL;
do
{
*(_DWORD *)(*(_QWORD *)(v6 + 8) + 4 * v7) = *(_DWORD *)(*((_QWORD *)v3 + 1) + 4 * v7);
v5 = *v3;
++v7;
}
while ( *v3 > (int)v7 );
}
*(_DWORD *)v6 = v5;
++v4;
}
v3 += 4;
}
while ( v3 != (int *)v14 );
}
return v2;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
MOV EBX,ESI
MOVSXD RDI,ESI
SHL RDI,0x4
CALL 0x001010c0
MOV R15,RAX
TEST EBX,EBX
JLE 0x001012f3
MOV R13,RBP
LEA EAX,[RBX + -0x1]
SHL RAX,0x4
LEA RAX,[RBP + RAX*0x1 + 0x10]
MOV qword ptr [RSP],RAX
MOV R14D,0x0
JMP 0x0010126d
LAB_00101212:
MOV RBP,R13
MOV EBX,dword ptr [R13]
MOVSXD R12,R14D
SHL R12,0x4
ADD R12,R15
MOVSXD RDI,EBX
SHL RDI,0x2
CALL 0x001010c0
MOV qword ptr [R12 + 0x8],RAX
TEST EBX,EBX
JLE 0x00101257
MOV EAX,0x0
LAB_0010123d:
MOV RDX,qword ptr [RBP + 0x8]
MOV ECX,dword ptr [RDX + RAX*0x4]
MOV RDX,qword ptr [R12 + 0x8]
MOV dword ptr [RDX + RAX*0x4],ECX
MOV EBX,dword ptr [RBP]
ADD RAX,0x1
CMP EBX,EAX
JG 0x0010123d
LAB_00101257:
MOV dword ptr [R12],EBX
ADD R14D,0x1
LAB_0010125f:
ADD R13,0x10
CMP R13,qword ptr [RSP]
JZ 0x001012f3
LAB_0010126d:
TEST R14D,R14D
JLE 0x00101212
MOVSXD RAX,R14D
SHL RAX,0x4
LEA RBX,[R15 + RAX*0x1 + -0x10]
MOV RDI,qword ptr [RBX + 0x8]
MOV RBP,R13
MOV RAX,qword ptr [R13 + 0x8]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RDI],EAX
JNZ 0x00101212
MOV EAX,dword ptr [RBX]
MOV R12D,dword ptr [R13]
MOV dword ptr [RSP + 0xc],EAX
LEA EAX,[RAX + R12*0x1 + -0x1]
MOV dword ptr [RSP + 0x8],EAX
MOVSXD RSI,EAX
SHL RSI,0x2
CALL 0x001010d0
MOV qword ptr [RBX + 0x8],RAX
CMP R12D,0x1
JLE 0x001012e8
MOV R12D,R12D
SHL R12,0x2
MOVSXD RSI,dword ptr [RSP + 0xc]
SHL RSI,0x2
MOV EAX,0x4
LAB_001012cd:
MOV RDX,qword ptr [RBP + 0x8]
MOV ECX,dword ptr [RDX + RAX*0x1]
MOV RDX,RAX
ADD RDX,qword ptr [RBX + 0x8]
MOV dword ptr [RSI + RDX*0x1 + -0x4],ECX
ADD RAX,0x4
CMP RAX,R12
JNZ 0x001012cd
LAB_001012e8:
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [RBX],EAX
JMP 0x0010125f
LAB_001012f3:
MOV RAX,R15
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(uint *param_1,int param_2)
{
int iVar1;
uint *puVar2;
int *piVar3;
int iVar4;
void *pvVar5;
void *pvVar6;
long lVar7;
uint uVar8;
uint *puVar9;
int iVar10;
pvVar5 = malloc((long)param_2 << 4);
if (0 < param_2) {
puVar2 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
iVar10 = 0;
do {
if (iVar10 < 1) {
LAB_00101212:
uVar8 = *param_1;
puVar9 = (uint *)((long)iVar10 * 0x10 + (long)pvVar5);
pvVar6 = malloc((long)(int)uVar8 << 2);
*(void **)(puVar9 + 2) = pvVar6;
if (0 < (int)uVar8) {
lVar7 = 0;
do {
*(int4 *)(*(long *)(puVar9 + 2) + lVar7 * 4) =
*(int4 *)(*(long *)(param_1 + 2) + lVar7 * 4);
uVar8 = *param_1;
lVar7 = lVar7 + 1;
} while ((int)lVar7 < (int)uVar8);
}
*puVar9 = uVar8;
iVar10 = iVar10 + 1;
}
else {
piVar3 = (int *)((long)pvVar5 + (long)iVar10 * 0x10 + -0x10);
if (**(int **)(piVar3 + 2) != **(int **)(param_1 + 2)) goto LAB_00101212;
iVar4 = *piVar3;
uVar8 = *param_1;
iVar1 = iVar4 + -1 + uVar8;
pvVar6 = realloc(*(int **)(piVar3 + 2),(long)iVar1 << 2);
*(void **)(piVar3 + 2) = pvVar6;
if (1 < (int)uVar8) {
lVar7 = 4;
do {
*(int4 *)((long)iVar4 * 4 + -4 + lVar7 + *(long *)(piVar3 + 2)) =
*(int4 *)(*(long *)(param_1 + 2) + lVar7);
lVar7 = lVar7 + 4;
} while (lVar7 != (ulong)uVar8 << 2);
}
*piVar3 = iVar1;
}
param_1 = param_1 + 4;
} while (param_1 != puVar2);
}
return pvVar5;
} |
7,770 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int size;
int *elements;
} tuple;
| tuple* func0(tuple test_list[], int list_size) {
tuple *res = malloc(sizeof(tuple) * list_size);
int res_size = 0;
for (int i = 0; i < list_size; i++) {
if (res_size > 0 && res[res_size - 1].elements[0] == test_list[i].elements[0]) {
// Resize the last tuple in res to accommodate new elements
int last_size = res[res_size - 1].size;
int this_size = test_list[i].size;
res[res_size - 1].elements = realloc(res[res_size - 1].elements, sizeof(int) * (last_size + this_size - 1));
// Copy the elements from test_list[i] except the first one
for (int j = 1; j < this_size; j++) {
res[res_size - 1].elements[last_size + j - 1] = test_list[i].elements[j];
}
res[res_size - 1].size = last_size + this_size - 1;
} else {
res[res_size].elements = malloc(sizeof(int) * test_list[i].size);
for (int j = 0; j < test_list[i].size; j++) {
res[res_size].elements[j] = test_list[i].elements[j];
}
res[res_size].size = test_list[i].size;
res_size++;
}
}
return res;
}
| int main() {
tuple list1[] = {{2, (int[]){5, 6}}, {2, (int[]){5, 7}}, {2, (int[]){6, 8}}, {2, (int[]){6, 10}}, {2, (int[]){7, 13}}};
tuple *result1 = func0(list1, 5);
assert(result1[0].size == 3 && (result1[0].elements[0] == 5 && result1[0].elements[1] == 6 && result1[0].elements[2] == 7));
assert(result1[1].size == 3 && (result1[1].elements[0] == 6 && result1[1].elements[1] == 8 && result1[1].elements[2] == 10));
assert(result1[2].size == 2 && (result1[2].elements[0] == 7 && result1[2].elements[1] == 13));
tuple list2[] = {{2, (int[]){6, 7}}, {2, (int[]){6, 8}}, {2, (int[]){7, 9}}, {2, (int[]){7, 11}}, {2, (int[]){8, 14}}};
tuple *result2 = func0(list2, 5);
assert(result2[0].size == 3 && (result2[0].elements[0] == 6 && result2[0].elements[1] == 7 && result2[0].elements[2] == 8));
assert(result2[1].size == 3 && (result2[1].elements[0] == 7 && result2[1].elements[1] == 9 && result2[1].elements[2] == 11));
assert(result2[2].size == 2 && (result2[2].elements[0] == 8 && result2[2].elements[1] == 14));
tuple list3[] = {{2, (int[]){7, 8}}, {2, (int[]){7, 9}}, {2, (int[]){8, 10}}, {2, (int[]){8, 12}}, {2, (int[]){9, 15}}};
tuple *result3 = func0(list3, 5);
assert(result3[0].size == 3 && (result3[0].elements[0] == 7 && result3[0].elements[1] == 8 && result3[0].elements[2] == 9));
assert(result3[1].size == 3 && (result3[1].elements[0] == 8 && result3[1].elements[1] == 10 && result3[1].elements[2] == 12));
assert(result3[2].size == 2 && (result3[2].elements[0] == 9 && result3[2].elements[1] == 15));
free(result1);
free(result2);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
movslq %esi,%rdi
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
shl $0x4,%rdi
sub $0x18,%rsp
callq 10c0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 17f2 <func0+0xb2>
lea -0x1(%rbx),%eax
lea 0x8(%r13),%rbp
shl $0x4,%rax
lea 0x18(%r13,%rax,1),%rbx
xor %r13d,%r13d
nopw 0x0(%rax,%rax,1)
movslq %r13d,%rax
mov -0x8(%rbp),%r14d
shl $0x4,%rax
test %r13d,%r13d
je 17ab <func0+0x6b>
lea -0x10(%r12,%rax,1),%r15
mov 0x0(%rbp),%rdx
mov 0x8(%r15),%rdi
mov (%rdx),%esi
cmp %esi,(%rdi)
je 1808 <func0+0xc8>
movslq %r14d,%rdi
lea (%r12,%rax,1),%r15
shl $0x2,%rdi
callq 10c0 <malloc@plt>
mov %rax,0x8(%r15)
test %r14d,%r14d
jle 17e2 <func0+0xa2>
mov 0x0(%rbp),%rdi
lea -0x1(%r14),%esi
xor %edx,%edx
xchg %ax,%ax
mov (%rdi,%rdx,4),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rcx,%rsi
jne 17d0 <func0+0x90>
mov %r14d,(%r15)
add $0x1,%r13d
add $0x10,%rbp
cmp %rbx,%rbp
jne 1788 <func0+0x48>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov (%r15),%edx
lea -0x1(%rdx,%r14,1),%r8d
mov %edx,0xc(%rsp)
movslq %r8d,%rsi
mov %r8d,0x8(%rsp)
shl $0x2,%rsi
callq 10d0 <realloc@plt>
cmp $0x1,%r14d
mov 0x8(%rsp),%r8d
movslq 0xc(%rsp),%rdx
mov %rax,0x8(%r15)
jle 1860 <func0+0x120>
lea -0x2(%r14),%ecx
mov 0x0(%rbp),%rdi
lea (%rax,%rdx,4),%rsi
mov $0x1,%eax
add $0x2,%rcx
xchg %ax,%ax
mov (%rdi,%rax,4),%edx
mov %edx,-0x4(%rsi,%rax,4)
add $0x1,%rax
cmp %rax,%rcx
jne 1850 <func0+0x110>
mov %r8d,(%r15)
jmp 17e9 <func0+0xa9>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
movsxd rdi, esi
push rbx
mov rbx, rdi
shl rdi, 4
sub rsp, 18h
call _malloc
mov r12, rax
test ebx, ebx
jle loc_1801
lea eax, [rbx-1]
lea r13, [rbp+8]
xor r14d, r14d
shl rax, 4
lea rax, [rbp+rax+18h]
mov [rsp+48h+var_48], rax
nop word ptr [rax+rax+00000000h]
loc_1790:
movsxd rax, r14d
movsxd r15, dword ptr [r13-8]
shl rax, 4
test r14d, r14d
jz short loc_17B3
lea rbx, [r12+rax-10h]
mov rdx, [r13+0]
mov rdi, [rbx+8]
mov esi, [rdx]
cmp [rdi], esi
jz short loc_1818
loc_17B3:
movsxd rbx, r15d
lea rbp, [r12+rax]
lea rdi, ds:0[rbx*4]
call _malloc
mov [rbp+8], rax
test r15d, r15d
jle short loc_17EF
mov rsi, [r13+0]
xor edx, edx
nop word ptr [rax+rax+00000000h]
loc_17E0:
mov ecx, [rsi+rdx*4]
mov [rax+rdx*4], ecx
add rdx, 1
cmp rbx, rdx
jnz short loc_17E0
loc_17EF:
mov [rbp+0], r15d
add r14d, 1
loc_17F7:
add r13, 10h
cmp r13, [rsp+48h+var_48]
jnz short loc_1790
loc_1801:
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1818:
mov edx, [rbx]
lea ebp, [rdx+r15-1]
mov [rsp+48h+var_3C], edx
movsxd rsi, ebp
shl rsi, 2
call _realloc
cmp r15d, 1
movsxd rdx, [rsp+48h+var_3C]
mov [rbx+8], rax
jle short loc_1860
mov rsi, [r13+0]
lea rcx, [rax+rdx*4]
mov eax, 1
nop dword ptr [rax+rax+00h]
loc_1850:
mov edx, [rsi+rax*4]
mov [rcx+rax*4-4], edx
add rax, 1
cmp r15, rax
jnz short loc_1850
loc_1860:
mov [rbx], ebp
jmp short loc_17F7 | long long func0(long long a1, int a2)
{
long long v2; // r12
_QWORD *v3; // r13
int v4; // r14d
long long v5; // r15
long long v6; // rax
long long v7; // rbx
_DWORD *v8; // rdi
long long v9; // rbp
long long v10; // rax
_DWORD *v11; // rsi
long long v12; // rdx
int v14; // ebp
long long v15; // rax
_DWORD *v16; // rsi
long long v17; // rcx
long long i; // rax
long long v19; // [rsp+0h] [rbp-48h]
int v20; // [rsp+Ch] [rbp-3Ch]
v2 = malloc(16LL * a2);
if ( a2 > 0 )
{
v3 = (_QWORD *)(a1 + 8);
v4 = 0;
v19 = a1 + 16LL * (unsigned int)(a2 - 1) + 24;
do
{
v5 = *((int *)v3 - 2);
v6 = 16LL * v4;
if ( v4 && (v7 = v2 + v6 - 16, v8 = *(_DWORD **)(v7 + 8), *v8 == *(_DWORD *)*v3) )
{
v14 = *(_DWORD *)v7 + v5 - 1;
v20 = *(_DWORD *)v7;
v15 = realloc(v8, 4LL * v14);
*(_QWORD *)(v7 + 8) = v15;
if ( (int)v5 > 1 )
{
v16 = (_DWORD *)*v3;
v17 = v15 + 4LL * v20;
for ( i = 1LL; i != v5; ++i )
*(_DWORD *)(v17 + 4 * i - 4) = v16[i];
}
*(_DWORD *)v7 = v14;
}
else
{
v9 = v2 + v6;
v10 = malloc(4LL * (int)v5);
*(_QWORD *)(v9 + 8) = v10;
if ( (int)v5 > 0 )
{
v11 = (_DWORD *)*v3;
v12 = 0LL;
do
{
*(_DWORD *)(v10 + 4 * v12) = v11[v12];
++v12;
}
while ( (int)v5 != v12 );
}
*(_DWORD *)v9 = v5;
++v4;
}
v3 += 2;
}
while ( v3 != (_QWORD *)v19 );
}
return v2;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,ESI
PUSH RBX
MOV RBX,RDI
SHL RDI,0x4
SUB RSP,0x18
CALL 0x001010c0
MOV R12,RAX
TEST EBX,EBX
JLE 0x00101801
LEA EAX,[RBX + -0x1]
LEA R13,[RBP + 0x8]
XOR R14D,R14D
SHL RAX,0x4
LEA RAX,[RBP + RAX*0x1 + 0x18]
MOV qword ptr [RSP],RAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101790:
MOVSXD RAX,R14D
MOVSXD R15,dword ptr [R13 + -0x8]
SHL RAX,0x4
TEST R14D,R14D
JZ 0x001017b3
LEA RBX,[R12 + RAX*0x1 + -0x10]
MOV RDX,qword ptr [R13]
MOV RDI,qword ptr [RBX + 0x8]
MOV ESI,dword ptr [RDX]
CMP dword ptr [RDI],ESI
JZ 0x00101818
LAB_001017b3:
MOVSXD RBX,R15D
LEA RBP,[R12 + RAX*0x1]
LEA RDI,[RBX*0x4]
CALL 0x001010c0
MOV qword ptr [RBP + 0x8],RAX
TEST R15D,R15D
JLE 0x001017ef
MOV RSI,qword ptr [R13]
XOR EDX,EDX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001017e0:
MOV ECX,dword ptr [RSI + RDX*0x4]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP RBX,RDX
JNZ 0x001017e0
LAB_001017ef:
MOV dword ptr [RBP],R15D
ADD R14D,0x1
LAB_001017f7:
ADD R13,0x10
CMP R13,qword ptr [RSP]
JNZ 0x00101790
LAB_00101801:
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101818:
MOV EDX,dword ptr [RBX]
LEA EBP,[RDX + R15*0x1 + -0x1]
MOV dword ptr [RSP + 0xc],EDX
MOVSXD RSI,EBP
SHL RSI,0x2
CALL 0x001010d0
CMP R15D,0x1
MOVSXD RDX,dword ptr [RSP + 0xc]
MOV qword ptr [RBX + 0x8],RAX
JLE 0x00101860
MOV RSI,qword ptr [R13]
LEA RCX,[RAX + RDX*0x4]
MOV EAX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101850:
MOV EDX,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RCX + RAX*0x4 + -0x4],EDX
ADD RAX,0x1
CMP R15,RAX
JNZ 0x00101850
LAB_00101860:
MOV dword ptr [RBX],EBP
JMP 0x001017f7 | void * func0(long param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
long lVar4;
void *pvVar5;
void *pvVar6;
long lVar7;
int iVar8;
long *plVar9;
int iVar10;
pvVar5 = malloc((long)param_2 << 4);
if (0 < param_2) {
plVar9 = (long *)(param_1 + 8);
iVar10 = 0;
do {
iVar2 = (int)plVar9[-1];
if (iVar10 == 0) {
LAB_001017b3:
piVar1 = (int *)((long)pvVar5 + (long)iVar10 * 0x10);
pvVar6 = malloc((long)iVar2 * 4);
*(void **)(piVar1 + 2) = pvVar6;
if (0 < iVar2) {
lVar4 = *plVar9;
lVar7 = 0;
do {
*(int4 *)((long)pvVar6 + lVar7 * 4) = *(int4 *)(lVar4 + lVar7 * 4);
lVar7 = lVar7 + 1;
} while (iVar2 != lVar7);
}
*piVar1 = iVar2;
iVar10 = iVar10 + 1;
}
else {
piVar1 = (int *)((long)pvVar5 + (long)iVar10 * 0x10 + -0x10);
if (**(int **)(piVar1 + 2) != *(int *)*plVar9) goto LAB_001017b3;
iVar3 = *piVar1;
iVar8 = iVar3 + -1 + iVar2;
pvVar6 = realloc(*(int **)(piVar1 + 2),(long)iVar8 << 2);
*(void **)(piVar1 + 2) = pvVar6;
if (1 < iVar2) {
lVar4 = *plVar9;
lVar7 = 1;
do {
*(int4 *)((long)pvVar6 + lVar7 * 4 + (long)iVar3 * 4 + -4) =
*(int4 *)(lVar4 + lVar7 * 4);
lVar7 = lVar7 + 1;
} while (iVar2 != lVar7);
}
*piVar1 = iVar8;
}
plVar9 = plVar9 + 2;
} while (plVar9 != (long *)(param_1 + 0x18 + (ulong)(param_2 - 1) * 0x10));
}
return pvVar5;
} |
7,771 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int size;
int *elements;
} tuple;
| tuple* func0(tuple test_list[], int list_size) {
tuple *res = malloc(sizeof(tuple) * list_size);
int res_size = 0;
for (int i = 0; i < list_size; i++) {
if (res_size > 0 && res[res_size - 1].elements[0] == test_list[i].elements[0]) {
// Resize the last tuple in res to accommodate new elements
int last_size = res[res_size - 1].size;
int this_size = test_list[i].size;
res[res_size - 1].elements = realloc(res[res_size - 1].elements, sizeof(int) * (last_size + this_size - 1));
// Copy the elements from test_list[i] except the first one
for (int j = 1; j < this_size; j++) {
res[res_size - 1].elements[last_size + j - 1] = test_list[i].elements[j];
}
res[res_size - 1].size = last_size + this_size - 1;
} else {
res[res_size].elements = malloc(sizeof(int) * test_list[i].size);
for (int j = 0; j < test_list[i].size; j++) {
res[res_size].elements[j] = test_list[i].elements[j];
}
res[res_size].size = test_list[i].size;
res_size++;
}
}
return res;
}
| int main() {
tuple list1[] = {{2, (int[]){5, 6}}, {2, (int[]){5, 7}}, {2, (int[]){6, 8}}, {2, (int[]){6, 10}}, {2, (int[]){7, 13}}};
tuple *result1 = func0(list1, 5);
assert(result1[0].size == 3 && (result1[0].elements[0] == 5 && result1[0].elements[1] == 6 && result1[0].elements[2] == 7));
assert(result1[1].size == 3 && (result1[1].elements[0] == 6 && result1[1].elements[1] == 8 && result1[1].elements[2] == 10));
assert(result1[2].size == 2 && (result1[2].elements[0] == 7 && result1[2].elements[1] == 13));
tuple list2[] = {{2, (int[]){6, 7}}, {2, (int[]){6, 8}}, {2, (int[]){7, 9}}, {2, (int[]){7, 11}}, {2, (int[]){8, 14}}};
tuple *result2 = func0(list2, 5);
assert(result2[0].size == 3 && (result2[0].elements[0] == 6 && result2[0].elements[1] == 7 && result2[0].elements[2] == 8));
assert(result2[1].size == 3 && (result2[1].elements[0] == 7 && result2[1].elements[1] == 9 && result2[1].elements[2] == 11));
assert(result2[2].size == 2 && (result2[2].elements[0] == 8 && result2[2].elements[1] == 14));
tuple list3[] = {{2, (int[]){7, 8}}, {2, (int[]){7, 9}}, {2, (int[]){8, 10}}, {2, (int[]){8, 12}}, {2, (int[]){9, 15}}};
tuple *result3 = func0(list3, 5);
assert(result3[0].size == 3 && (result3[0].elements[0] == 7 && result3[0].elements[1] == 8 && result3[0].elements[2] == 9));
assert(result3[1].size == 3 && (result3[1].elements[0] == 8 && result3[1].elements[1] == 10 && result3[1].elements[2] == 12));
assert(result3[2].size == 2 && (result3[2].elements[0] == 9 && result3[2].elements[1] == 15));
free(result1);
free(result2);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x4,%rdi
sub $0x18,%rsp
callq 10c0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 1858 <func0+0x118>
lea -0x1(%rbx),%eax
lea 0x8(%rbp),%r13
xor %r14d,%r14d
shl $0x4,%rax
lea 0x18(%rbp,%rax,1),%rbp
nopw 0x0(%rax,%rax,1)
movslq %r14d,%rax
mov -0x8(%r13),%ebx
shl $0x4,%rax
test %r14d,%r14d
je 17af <func0+0x6f>
lea -0x10(%r12,%rax,1),%r15
mov 0x0(%r13),%rdx
mov 0x8(%r15),%rdi
mov (%rdx),%ecx
cmp %ecx,(%rdi)
je 1870 <func0+0x130>
movslq %ebx,%rdi
lea (%r12,%rax,1),%r15
shl $0x2,%rdi
callq 10c0 <malloc@plt>
mov %rax,0x8(%r15)
test %ebx,%ebx
jle 1844 <func0+0x104>
mov 0x0(%r13),%rcx
lea 0xf(%rax),%rsi
lea -0x1(%rbx),%edx
sub %rcx,%rsi
cmp $0x1e,%rsi
jbe 1960 <func0+0x220>
cmp $0x3,%edx
jbe 1960 <func0+0x220>
mov %ebx,%esi
xor %edx,%edx
shr $0x2,%esi
shl $0x4,%rsi
nopl 0x0(%rax,%rax,1)
movdqu (%rcx,%rdx,1),%xmm0
movups %xmm0,(%rax,%rdx,1)
add $0x10,%rdx
cmp %rsi,%rdx
jne 17f8 <func0+0xb8>
mov %ebx,%edx
and $0xfffffffc,%edx
test $0x3,%bl
je 1844 <func0+0x104>
mov %edx,%edi
mov (%rcx,%rdi,4),%r8d
lea 0x0(,%rdi,4),%rsi
mov %r8d,(%rax,%rdi,4)
lea 0x1(%rdx),%edi
cmp %edi,%ebx
jle 1844 <func0+0x104>
mov 0x4(%rcx,%rsi,1),%edi
add $0x2,%edx
mov %edi,0x4(%rax,%rsi,1)
cmp %edx,%ebx
jle 1844 <func0+0x104>
mov 0x8(%rcx,%rsi,1),%edx
mov %edx,0x8(%rax,%rsi,1)
mov %ebx,(%r15)
add $0x1,%r14d
add $0x10,%r13
cmp %rbp,%r13
jne 1788 <func0+0x48>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov (%r15),%r9d
lea -0x1(%r9,%rbx,1),%r8d
mov %r9d,0xc(%rsp)
movslq %r8d,%rsi
mov %r8d,0x8(%rsp)
shl $0x2,%rsi
callq 10d0 <realloc@plt>
cmp $0x1,%ebx
mov 0x8(%rsp),%r8d
mov 0xc(%rsp),%r9d
mov %rax,0x8(%r15)
jle 1957 <func0+0x217>
mov 0x0(%r13),%rcx
movslq %r9d,%rsi
lea -0x2(%rbx),%edx
lea 0x10(%rax,%rsi,4),%r10
lea (%rax,%rsi,4),%rdi
lea 0x4(%rcx),%r11
cmp %r10,%r11
lea 0x14(%rcx),%r10
setae %r11b
cmp %r10,%rdi
setae %r10b
or %r10b,%r11b
je 197f <func0+0x23f>
cmp $0x3,%edx
jbe 197f <func0+0x23f>
lea -0x1(%rbx),%r10d
xor %edx,%edx
mov %r10d,%esi
shr $0x2,%esi
shl $0x4,%rsi
movdqu 0x4(%rcx,%rdx,1),%xmm1
movups %xmm1,(%rdi,%rdx,1)
add $0x10,%rdx
cmp %rsi,%rdx
jne 18f0 <func0+0x1b0>
mov %r10d,%edx
and $0xfffffffc,%edx
lea 0x1(%rdx),%esi
cmp %edx,%r10d
je 1957 <func0+0x217>
movslq %esi,%r10
add %r9d,%esi
lea 0x0(,%r10,4),%rdi
mov (%rcx,%r10,4),%r10d
movslq %esi,%rsi
mov %r10d,-0x4(%rax,%rsi,4)
lea 0x2(%rdx),%esi
cmp %ebx,%esi
jge 1957 <func0+0x217>
mov 0x4(%rcx,%rdi,1),%r10d
add %r9d,%esi
add $0x3,%edx
movslq %esi,%rsi
mov %r10d,-0x4(%rax,%rsi,4)
cmp %ebx,%edx
jge 1957 <func0+0x217>
mov 0x8(%rcx,%rdi,1),%ecx
add %r9d,%edx
movslq %edx,%rdx
mov %ecx,-0x4(%rax,%rdx,4)
mov %r8d,(%r15)
jmpq 184b <func0+0x10b>
mov %edx,%esi
xor %edx,%edx
nopl 0x0(%rax)
mov (%rcx,%rdx,4),%edi
mov %edi,(%rax,%rdx,4)
mov %rdx,%rdi
add $0x1,%rdx
cmp %rsi,%rdi
jne 1968 <func0+0x228>
jmpq 1844 <func0+0x104>
lea (%rax,%rsi,4),%rdi
add $0x2,%rdx
mov $0x1,%eax
nopl 0x0(%rax)
mov (%rcx,%rax,4),%esi
mov %esi,-0x4(%rdi,%rax,4)
add $0x1,%rax
cmp %rax,%rdx
jne 1990 <func0+0x250>
jmp 1957 <func0+0x217>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
movsxd rbp, esi
push rbx
mov r12, rbp
shl rbp, 4
mov rdi, rbp; size
sub rsp, 28h
call _malloc
mov rbx, rax
lea rax, [r14+rbp]
mov [rsp+58h+var_50], rax
test r12d, r12d
jle loc_17D7
xor ebp, ebp
xchg ax, ax
loc_1740:
movsxd rdx, ebp
mov r12d, [r14]
mov r15, rdx
shl r15, 4
test ebp, ebp
jle short loc_1768
loc_1751:
lea r13, [rbx+r15-10h]
mov rax, [r14+8]
mov rdi, [r13+8]; ptr
mov eax, [rax]
cmp [rdi], eax
jz loc_1870
loc_1768:
movsxd r13, r12d
add r15, rbx
shl r13, 2
mov rdi, r13; size
call _malloc
mov [r15+8], rax
mov rdx, rax
test r12d, r12d
jle short loc_17BF
lea eax, [r12-1]
mov rsi, [r14+8]
cmp eax, 2
jbe loc_1860
lea rax, [rsi+4]
mov rcx, rdx
sub rcx, rax
xor eax, eax
cmp rcx, 8
ja short loc_17F0
nop word ptr [rax+rax+00h]
loc_17B0:
mov ecx, [rsi+rax]
mov [rdx+rax], ecx
add rax, 4
cmp r13, rax
jnz short loc_17B0
loc_17BF:
mov rax, [rsp+58h+var_50]
add r14, 10h
mov [r15], r12d
add ebp, 1
cmp r14, rax
jnz loc_1740
loc_17D7:
add rsp, 28h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_17F0:
mov ecx, r12d
shr ecx, 2
shl rcx, 4
nop word ptr [rax+rax+00h]
loc_1800:
movdqu xmm0, xmmword ptr [rsi+rax]
movups xmmword ptr [rdx+rax], xmm0
add rax, 10h
cmp rax, rcx
jnz short loc_1800
mov eax, r12d
and eax, 0FFFFFFFCh
test r12b, 3
jz short loc_17BF
mov edi, eax
mov r9d, [rsi+rdi*4]
lea rcx, ds:0[rdi*4]
mov [rdx+rdi*4], r9d
lea edi, [rax+1]
cmp r12d, edi
jle short loc_17BF
mov edi, [rsi+rcx+4]
add eax, 2
mov [rdx+rcx+4], edi
cmp r12d, eax
jle loc_17BF
mov eax, [rsi+rcx+8]
mov [rdx+rcx+8], eax
jmp loc_17BF
loc_1860:
xor eax, eax
jmp loc_17B0
loc_1870:
mov r9d, [r13+0]
mov [rsp+58h+var_40], rdx
lea r15d, [r9+r12-1]
mov [rsp+58h+var_44], r9d
movsxd rsi, r15d
shl rsi, 2; size
call _realloc
cmp r12d, 1
mov r9d, [rsp+58h+var_44]
mov rdx, [rsp+58h+var_40]
mov [r13+8], rax
mov rsi, rax
jle short loc_18E8
lea eax, [r12-2]
mov rcx, [r14+8]
cmp eax, 2
movsxd rax, r9d
jbe short loc_18CB
lea r10, [rsi+rax*4]
lea r11, [rcx+8]
mov rdi, r10
sub rdi, r11
cmp rdi, 8
ja short loc_190D
loc_18CB:
lea rdi, [rsi+rax*4]
mov eax, 1
nop dword ptr [rax+00h]
loc_18D8:
mov esi, [rcx+rax*4]
mov [rdi+rax*4-4], esi
add rax, 1
cmp r12, rax
jnz short loc_18D8
loc_18E8:
mov rax, [rsp+58h+var_50]
add r14, 10h
mov [r13+0], r15d
cmp r14, rax
jz loc_17D7
mov r15, rdx
mov r12d, [r14]
shl r15, 4
jmp loc_1751
loc_190D:
lea r11d, [r12-1]
xor eax, eax
mov edi, r11d
shr edi, 2
shl rdi, 4
xchg ax, ax
loc_1920:
movdqu xmm1, xmmword ptr [rcx+rax+4]
movups xmmword ptr [r10+rax], xmm1
add rax, 10h
cmp rdi, rax
jnz short loc_1920
mov eax, r11d
and eax, 0FFFFFFFCh
and r11d, 3
lea edi, [rax+1]
jz short loc_18E8
movsxd r11, edi
add edi, r9d
lea r10, ds:0[r11*4]
mov r11d, [rcx+r11*4]
movsxd rdi, edi
mov [rsi+rdi*4-4], r11d
lea edi, [rax+2]
cmp edi, r12d
jge short loc_18E8
mov r11d, [rcx+r10+4]
add edi, r9d
add eax, 3
movsxd rdi, edi
mov [rsi+rdi*4-4], r11d
cmp eax, r12d
jge loc_18E8
mov ecx, [rcx+r10+8]
add eax, r9d
cdqe
mov [rsi+rax*4-4], ecx
jmp loc_18E8 | char * func0(unsigned int *a1, int a2)
{
unsigned int *v2; // r14
char *v3; // rbx
int v4; // ebp
long long v5; // rdx
long long v6; // r12
long long v7; // r15
long long v8; // r13
_DWORD *v9; // rdi
char *v10; // r15
char *v11; // rax
char *v12; // rdx
long long v13; // rsi
long long v14; // rax
unsigned int v16; // eax
long long v17; // rcx
int v18; // r15d
_DWORD *v19; // rax
_DWORD *v20; // rsi
long long v21; // rcx
long long i; // rax
int v23; // r11d
long long v24; // rax
unsigned int v25; // eax
signed int v26; // edi
long long v27; // r10
unsigned int v28; // edi
int v29; // eax
unsigned int *v30; // [rsp+8h] [rbp-50h]
int v31; // [rsp+14h] [rbp-44h]
long long v32; // [rsp+18h] [rbp-40h]
v2 = a1;
v3 = (char *)malloc(16LL * a2);
v30 = &a1[4 * a2];
if ( a2 > 0 )
{
v4 = 0;
do
{
v5 = v4;
v6 = *v2;
v7 = 16LL * v4;
if ( v4 > 0 )
{
while ( 1 )
{
v8 = (long long)&v3[v7 - 16];
v9 = *(_DWORD **)(v8 + 8);
if ( *v9 != **((_DWORD **)v2 + 1) )
break;
v32 = v5;
v18 = *(_DWORD *)v8 + v6 - 1;
v31 = *(_DWORD *)v8;
v19 = realloc(v9, 4LL * v18);
v5 = v32;
*(_QWORD *)(v8 + 8) = v19;
v20 = v19;
if ( (int)v6 > 1 )
{
v21 = *((_QWORD *)v2 + 1);
if ( (unsigned int)(v6 - 2) > 2 && (unsigned long long)&v19[v31 - 2] - v21 > 8 )
{
v23 = v6 - 1;
v24 = 0LL;
do
{
*(__m128i *)&v20[v31 + v24] = _mm_loadu_si128((const __m128i *)(v21 + v24 * 4 + 4));
v24 += 4LL;
}
while ( 4LL * ((unsigned int)(v6 - 1) >> 2) != v24 );
v25 = v23 & 0xFFFFFFFC;
v26 = (v23 & 0xFFFFFFFC) + 1;
if ( (v23 & 3) != 0 )
{
v27 = 4LL * v26;
v20[v31 - 1 + v26] = *(_DWORD *)(v21 + v27);
v28 = v25 + 2;
if ( (int)(v25 + 2) < (int)v6 )
{
v29 = v25 + 3;
v20[v31 + v28 - 1] = *(_DWORD *)(v21 + v27 + 4);
if ( v29 < (int)v6 )
v20[v31 - 1 + v29] = *(_DWORD *)(v21 + v27 + 8);
}
}
}
else
{
for ( i = 1LL; i != v6; ++i )
v20[v31 - 1 + i] = *(_DWORD *)(v21 + 4 * i);
}
}
v2 += 4;
*(_DWORD *)v8 = v18;
if ( v2 == v30 )
return v3;
v6 = *v2;
v7 = 16 * v32;
}
}
v10 = &v3[v7];
v11 = (char *)malloc(4LL * (int)v6);
*((_QWORD *)v10 + 1) = v11;
v12 = v11;
if ( (int)v6 <= 0 )
goto LABEL_9;
v13 = *((_QWORD *)v2 + 1);
if ( (unsigned int)(v6 - 1) <= 2 )
{
v14 = 0LL;
}
else
{
v14 = 0LL;
if ( (unsigned long long)&v12[-v13 - 4] > 8 )
{
do
{
*(__m128i *)&v12[v14] = _mm_loadu_si128((const __m128i *)(v13 + v14));
v14 += 16LL;
}
while ( v14 != 16LL * ((unsigned int)v6 >> 2) );
v16 = v6 & 0x7FFFFFFC;
if ( (v6 & 3) != 0 )
{
v17 = 4LL * v16;
*(_DWORD *)&v12[v17] = *(_DWORD *)(v13 + v17);
if ( (int)v6 > (int)(v16 + 1) )
{
*(_DWORD *)&v12[v17 + 4] = *(_DWORD *)(v13 + v17 + 4);
if ( (int)v6 > (int)(v16 + 2) )
*(_DWORD *)&v12[v17 + 8] = *(_DWORD *)(v13 + v17 + 8);
}
}
goto LABEL_9;
}
}
do
{
*(_DWORD *)&v12[v14] = *(_DWORD *)(v13 + v14);
v14 += 4LL;
}
while ( 4LL * (int)v6 != v14 );
LABEL_9:
v2 += 4;
*(_DWORD *)v10 = v6;
++v4;
}
while ( v2 != v30 );
}
return v3;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV R12,RBP
SHL RBP,0x4
MOV RDI,RBP
SUB RSP,0x28
CALL 0x001010c0
MOV RBX,RAX
LEA RAX,[R14 + RBP*0x1]
MOV qword ptr [RSP + 0x8],RAX
TEST R12D,R12D
JLE 0x001017d7
XOR EBP,EBP
NOP
LAB_00101740:
MOVSXD RDX,EBP
MOV R12D,dword ptr [R14]
MOV R15,RDX
SHL R15,0x4
TEST EBP,EBP
JLE 0x00101768
LAB_00101751:
LEA R13,[RBX + R15*0x1 + -0x10]
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,qword ptr [R13 + 0x8]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RDI],EAX
JZ 0x00101870
LAB_00101768:
MOVSXD R13,R12D
ADD R15,RBX
SHL R13,0x2
MOV RDI,R13
CALL 0x001010c0
MOV qword ptr [R15 + 0x8],RAX
MOV RDX,RAX
TEST R12D,R12D
JLE 0x001017bf
LEA EAX,[R12 + -0x1]
MOV RSI,qword ptr [R14 + 0x8]
CMP EAX,0x2
JBE 0x00101860
LEA RAX,[RSI + 0x4]
MOV RCX,RDX
SUB RCX,RAX
XOR EAX,EAX
CMP RCX,0x8
JA 0x001017f0
NOP word ptr [RAX + RAX*0x1]
LAB_001017b0:
MOV ECX,dword ptr [RSI + RAX*0x1]
MOV dword ptr [RDX + RAX*0x1],ECX
ADD RAX,0x4
CMP R13,RAX
JNZ 0x001017b0
LAB_001017bf:
MOV RAX,qword ptr [RSP + 0x8]
ADD R14,0x10
MOV dword ptr [R15],R12D
ADD EBP,0x1
CMP R14,RAX
JNZ 0x00101740
LAB_001017d7:
ADD RSP,0x28
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001017f0:
MOV ECX,R12D
SHR ECX,0x2
SHL RCX,0x4
NOP word ptr [RAX + RAX*0x1]
LAB_00101800:
MOVDQU XMM0,xmmword ptr [RSI + RAX*0x1]
MOVUPS xmmword ptr [RDX + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,RCX
JNZ 0x00101800
MOV EAX,R12D
AND EAX,0xfffffffc
TEST R12B,0x3
JZ 0x001017bf
MOV EDI,EAX
MOV R9D,dword ptr [RSI + RDI*0x4]
LEA RCX,[RDI*0x4]
MOV dword ptr [RDX + RDI*0x4],R9D
LEA EDI,[RAX + 0x1]
CMP R12D,EDI
JLE 0x001017bf
MOV EDI,dword ptr [RSI + RCX*0x1 + 0x4]
ADD EAX,0x2
MOV dword ptr [RDX + RCX*0x1 + 0x4],EDI
CMP R12D,EAX
JLE 0x001017bf
MOV EAX,dword ptr [RSI + RCX*0x1 + 0x8]
MOV dword ptr [RDX + RCX*0x1 + 0x8],EAX
JMP 0x001017bf
LAB_00101860:
XOR EAX,EAX
JMP 0x001017b0
LAB_00101870:
MOV R9D,dword ptr [R13]
MOV qword ptr [RSP + 0x18],RDX
LEA R15D,[R9 + R12*0x1 + -0x1]
MOV dword ptr [RSP + 0x14],R9D
MOVSXD RSI,R15D
SHL RSI,0x2
CALL 0x001010d0
CMP R12D,0x1
MOV R9D,dword ptr [RSP + 0x14]
MOV RDX,qword ptr [RSP + 0x18]
MOV qword ptr [R13 + 0x8],RAX
MOV RSI,RAX
JLE 0x001018e8
LEA EAX,[R12 + -0x2]
MOV RCX,qword ptr [R14 + 0x8]
CMP EAX,0x2
MOVSXD RAX,R9D
JBE 0x001018cb
LEA R10,[RSI + RAX*0x4]
LEA R11,[RCX + 0x8]
MOV RDI,R10
SUB RDI,R11
CMP RDI,0x8
JA 0x0010190d
LAB_001018cb:
LEA RDI,[RSI + RAX*0x4]
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_001018d8:
MOV ESI,dword ptr [RCX + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4 + -0x4],ESI
ADD RAX,0x1
CMP R12,RAX
JNZ 0x001018d8
LAB_001018e8:
MOV RAX,qword ptr [RSP + 0x8]
ADD R14,0x10
MOV dword ptr [R13],R15D
CMP R14,RAX
JZ 0x001017d7
MOV R15,RDX
MOV R12D,dword ptr [R14]
SHL R15,0x4
JMP 0x00101751
LAB_0010190d:
LEA R11D,[R12 + -0x1]
XOR EAX,EAX
MOV EDI,R11D
SHR EDI,0x2
SHL RDI,0x4
NOP
LAB_00101920:
MOVDQU XMM1,xmmword ptr [RCX + RAX*0x1 + 0x4]
MOVUPS xmmword ptr [R10 + RAX*0x1],XMM1
ADD RAX,0x10
CMP RDI,RAX
JNZ 0x00101920
MOV EAX,R11D
AND EAX,0xfffffffc
AND R11D,0x3
LEA EDI,[RAX + 0x1]
JZ 0x001018e8
MOVSXD R11,EDI
ADD EDI,R9D
LEA R10,[R11*0x4]
MOV R11D,dword ptr [RCX + R11*0x4]
MOVSXD RDI,EDI
MOV dword ptr [RSI + RDI*0x4 + -0x4],R11D
LEA EDI,[RAX + 0x2]
CMP EDI,R12D
JGE 0x001018e8
MOV R11D,dword ptr [RCX + R10*0x1 + 0x4]
ADD EDI,R9D
ADD EAX,0x3
MOVSXD RDI,EDI
MOV dword ptr [RSI + RDI*0x4 + -0x4],R11D
CMP EAX,R12D
JGE 0x001018e8
MOV ECX,dword ptr [RCX + R10*0x1 + 0x8]
ADD EAX,R9D
CDQE
MOV dword ptr [RSI + RAX*0x4 + -0x4],ECX
JMP 0x001018e8 | void * func0(uint *param_1,int param_2)
{
int iVar1;
uint *puVar2;
int8 *puVar3;
int *piVar4;
int8 *puVar5;
int iVar6;
int iVar7;
int8 uVar8;
uint uVar9;
void *pvVar10;
void *pvVar11;
size_t sVar12;
long lVar13;
ulong uVar14;
long lVar15;
int iVar16;
ulong uVar17;
uint uVar18;
int iVar19;
long lVar20;
pvVar10 = malloc((long)param_2 * 0x10);
puVar2 = param_1 + (long)param_2 * 4;
if (0 < param_2) {
iVar16 = 0;
do {
uVar17 = (ulong)*param_1;
lVar20 = (long)iVar16 << 4;
if (0 < iVar16) {
while( true ) {
lVar20 = (long)iVar16 * 0x10;
piVar4 = (int *)((long)pvVar10 + lVar20 + -0x10);
if (**(int **)(piVar4 + 2) != **(int **)(param_1 + 2)) break;
iVar6 = *piVar4;
iVar7 = (int)uVar17;
iVar19 = iVar6 + -1 + iVar7;
pvVar11 = realloc(*(int **)(piVar4 + 2),(long)iVar19 << 2);
*(void **)(piVar4 + 2) = pvVar11;
if (1 < iVar7) {
lVar20 = *(long *)(param_1 + 2);
lVar13 = (long)iVar6;
if ((iVar7 - 2U < 3) || ((ulong)((long)pvVar11 + (lVar13 * 4 - (lVar20 + 8))) < 9)) {
uVar14 = 1;
do {
*(int4 *)((long)pvVar11 + uVar14 * 4 + lVar13 * 4 + -4) =
*(int4 *)(lVar20 + uVar14 * 4);
uVar14 = uVar14 + 1;
} while (uVar17 != uVar14);
}
else {
uVar18 = iVar7 - 1;
lVar15 = 0;
do {
puVar5 = (int8 *)(lVar20 + 4 + lVar15);
uVar8 = puVar5[1];
puVar3 = (int8 *)((long)pvVar11 + lVar15 + lVar13 * 4);
*puVar3 = *puVar5;
puVar3[1] = uVar8;
lVar15 = lVar15 + 0x10;
} while ((ulong)(uVar18 >> 2) << 4 != lVar15);
uVar9 = uVar18 & 0xfffffffc;
iVar1 = uVar9 + 1;
if ((uVar18 & 3) != 0) {
lVar13 = (long)iVar1 * 4;
*(int4 *)((long)pvVar11 + (long)(iVar1 + iVar6) * 4 + -4) =
*(int4 *)(lVar20 + (long)iVar1 * 4);
if ((int)(uVar9 + 2) < iVar7) {
*(int4 *)((long)pvVar11 + (long)(int)(uVar9 + 2 + iVar6) * 4 + -4) =
*(int4 *)(lVar20 + 4 + lVar13);
if ((int)(uVar9 + 3) < iVar7) {
*(int4 *)((long)pvVar11 + (long)(int)(uVar9 + 3 + iVar6) * 4 + -4) =
*(int4 *)(lVar20 + 8 + lVar13);
}
}
}
}
}
param_1 = param_1 + 4;
*piVar4 = iVar19;
if (param_1 == puVar2) {
return pvVar10;
}
uVar17 = (ulong)*param_1;
}
}
uVar18 = (uint)uVar17;
pvVar11 = malloc((long)(int)uVar18 * 4);
*(void **)((uint *)(lVar20 + (long)pvVar10) + 2) = pvVar11;
if (0 < (int)uVar18) {
lVar13 = *(long *)(param_1 + 2);
if (uVar18 - 1 < 3) {
sVar12 = 0;
}
else {
sVar12 = 0;
if (8 < (ulong)((long)pvVar11 - (lVar13 + 4))) {
do {
uVar8 = ((int8 *)(lVar13 + sVar12))[1];
*(int8 *)((long)pvVar11 + sVar12) = *(int8 *)(lVar13 + sVar12);
((int8 *)((long)pvVar11 + sVar12))[1] = uVar8;
sVar12 = sVar12 + 0x10;
} while (sVar12 != (uVar17 >> 2) << 4);
uVar9 = uVar18 & 0xfffffffc;
if ((uVar17 & 3) != 0) {
uVar17 = (ulong)uVar9;
lVar15 = uVar17 * 4;
*(int4 *)((long)pvVar11 + uVar17 * 4) = *(int4 *)(lVar13 + uVar17 * 4);
if (((int)(uVar9 + 1) < (int)uVar18) &&
(*(int4 *)((long)pvVar11 + lVar15 + 4) = *(int4 *)(lVar13 + 4 + lVar15)
, (int)(uVar9 + 2) < (int)uVar18)) {
*(int4 *)((long)pvVar11 + lVar15 + 8) = *(int4 *)(lVar13 + 8 + lVar15);
}
}
goto LAB_001017bf;
}
}
do {
*(int4 *)((long)pvVar11 + sVar12) = *(int4 *)(lVar13 + sVar12);
sVar12 = sVar12 + 4;
} while ((long)(int)uVar18 * 4 != sVar12);
}
LAB_001017bf:
param_1 = param_1 + 4;
*(uint *)(lVar20 + (long)pvVar10) = uVar18;
iVar16 = iVar16 + 1;
} while (param_1 != puVar2);
}
return pvVar10;
} |
7,772 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x < y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 10);
assert(func0(19, 15) == 15);
assert(func0(-10, -20) == -20);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jge 1164 <func0+0x1b>
mov -0x4(%rbp),%eax
jmp 1167 <func0+0x1e>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jge short loc_1164
mov eax, [rbp+var_4]
jmp short loc_1167
loc_1164:
mov eax, [rbp+var_8]
loc_1167:
pop rbp
retn | long long func0(unsigned int a1, unsigned int a2)
{
if ( (int)a1 >= (int)a2 )
return a2;
else
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JGE 0x00101164
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x00101167
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
LAB_00101167:
POP RBP
RET | int func0(int param_1,int param_2)
{
if (param_1 < param_2) {
param_2 = param_1;
}
return param_2;
} |
7,773 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x < y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 10);
assert(func0(19, 15) == 15);
assert(func0(-10, -20) == -20);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovle %edi,%eax
retq
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovle eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 <= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVLE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
7,774 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x < y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 10);
assert(func0(19, 15) == 15);
assert(func0(-10, -20) == -20);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovle %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovle eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 <= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVLE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
7,775 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x < y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 10);
assert(func0(19, 15) == 15);
assert(func0(-10, -20) == -20);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovle %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovle eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 <= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVLE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
7,776 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int n, int a, int b, int c) {
int dp[n + 10];
for (int i = 0; i < n + 10; i++) {
dp[i] = -1;
}
dp[0] = 0;
for (int i = 0; i <= n; i++) {
if (dp[i] != -1) {
if (i + a <= n) {
dp[i + a] = (dp[i] + 1 > dp[i + a]) ? dp[i] + 1 : dp[i + a];
}
if (i + b <= n) {
dp[i + b] = (dp[i] + 1 > dp[i + b]) ? dp[i] + 1 : dp[i + b];
}
if (i + c <= n) {
dp[i + c] = (dp[i] + 1 > dp[i + c]) ? dp[i] + 1 : dp[i + c];
}
}
}
return dp[n];
}
| int main() {
assert(func0(7, 5, 2, 5) == 2);
assert(func0(17, 2, 1, 3) == 17);
assert(func0(18, 16, 3, 6) == 6);
printf("All test cases passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov %esi,-0x28(%rbp)
mov %edx,-0x2c(%rbp)
mov %ecx,-0x30(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x24(%rbp),%eax
add $0xa,%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
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,%rdi
sub %rdx,%rdi
mov %rdi,%rdx
cmp %rdx,%rsp
je 1230 <func0+0xa7>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1219 <func0+0x90>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 125a <func0+0xd1>
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,-0x10(%rbp)
movl $0x0,-0x1c(%rbp)
jmp 128b <func0+0x102>
mov -0x10(%rbp),%rax
mov -0x1c(%rbp),%edx
movslq %edx,%rdx
movl $0xffffffff,(%rax,%rdx,4)
addl $0x1,-0x1c(%rbp)
mov -0x24(%rbp),%eax
add $0x9,%eax
cmp %eax,-0x1c(%rbp)
jle 1276 <func0+0xed>
mov -0x10(%rbp),%rax
movl $0x0,(%rax)
movl $0x0,-0x20(%rbp)
jmpq 13f8 <func0+0x26f>
mov -0x10(%rbp),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp $0xffffffff,%eax
je 13f4 <func0+0x26b>
mov -0x20(%rbp),%edx
mov -0x28(%rbp),%eax
add %edx,%eax
cmp %eax,-0x24(%rbp)
jl 1328 <func0+0x19f>
mov -0x10(%rbp),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x20(%rbp),%edx
mov -0x28(%rbp),%eax
add %eax,%edx
mov -0x10(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,%ecx
jl 1304 <func0+0x17b>
mov -0x10(%rbp),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add $0x1,%eax
jmp 1316 <func0+0x18d>
mov -0x20(%rbp),%edx
mov -0x28(%rbp),%eax
add %eax,%edx
mov -0x10(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov -0x20(%rbp),%ecx
mov -0x28(%rbp),%edx
add %edx,%ecx
mov -0x10(%rbp),%rdx
movslq %ecx,%rcx
mov %eax,(%rdx,%rcx,4)
mov -0x20(%rbp),%edx
mov -0x2c(%rbp),%eax
add %edx,%eax
cmp %eax,-0x24(%rbp)
jl 138e <func0+0x205>
mov -0x10(%rbp),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x20(%rbp),%edx
mov -0x2c(%rbp),%eax
add %eax,%edx
mov -0x10(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,%ecx
jl 136a <func0+0x1e1>
mov -0x10(%rbp),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add $0x1,%eax
jmp 137c <func0+0x1f3>
mov -0x20(%rbp),%edx
mov -0x2c(%rbp),%eax
add %eax,%edx
mov -0x10(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov -0x20(%rbp),%ecx
mov -0x2c(%rbp),%edx
add %edx,%ecx
mov -0x10(%rbp),%rdx
movslq %ecx,%rcx
mov %eax,(%rdx,%rcx,4)
mov -0x20(%rbp),%edx
mov -0x30(%rbp),%eax
add %edx,%eax
cmp %eax,-0x24(%rbp)
jl 13f4 <func0+0x26b>
mov -0x10(%rbp),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%ecx
mov -0x20(%rbp),%edx
mov -0x30(%rbp),%eax
add %eax,%edx
mov -0x10(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
cmp %eax,%ecx
jl 13d0 <func0+0x247>
mov -0x10(%rbp),%rax
mov -0x20(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
add $0x1,%eax
jmp 13e2 <func0+0x259>
mov -0x20(%rbp),%edx
mov -0x30(%rbp),%eax
add %eax,%edx
mov -0x10(%rbp),%rax
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov -0x20(%rbp),%ecx
mov -0x30(%rbp),%edx
add %edx,%ecx
mov -0x10(%rbp),%rdx
movslq %ecx,%rcx
mov %eax,(%rdx,%rcx,4)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp -0x24(%rbp),%eax
jle 12ac <func0+0x123>
mov -0x10(%rbp),%rax
mov -0x24(%rbp),%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
mov %rsi,%rsp
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1428 <func0+0x29f>
callq 1080 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_28], esi
mov [rbp+var_2C], edx
mov [rbp+var_30], ecx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_24]
add eax, 0Ah
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_11FE:
cmp rsp, rdx
jz short loc_1215
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_11FE
loc_1215:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_123F
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_123F:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_10], rax
mov [rbp+var_20], 0
jmp short loc_1270
loc_125B:
mov rax, [rbp+var_10]
mov edx, [rbp+var_20]
movsxd rdx, edx
mov dword ptr [rax+rdx*4], 0FFFFFFFFh
add [rbp+var_20], 1
loc_1270:
mov eax, [rbp+var_24]
add eax, 9
cmp [rbp+var_20], eax
jle short loc_125B
mov rax, [rbp+var_10]
mov dword ptr [rax], 0
mov [rbp+var_1C], 0
jmp loc_13DD
loc_1291:
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp eax, 0FFFFFFFFh
jz loc_13D9
mov edx, [rbp+var_1C]
mov eax, [rbp+var_28]
add eax, edx
cmp [rbp+var_24], eax
jl short loc_130D
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov edx, [rbp+var_1C]
mov eax, [rbp+var_28]
add edx, eax
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp ecx, eax
jl short loc_12E9
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add eax, 1
jmp short loc_12FB
loc_12E9:
mov edx, [rbp+var_1C]
mov eax, [rbp+var_28]
add edx, eax
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
loc_12FB:
mov ecx, [rbp+var_1C]
mov edx, [rbp+var_28]
add ecx, edx
mov rdx, [rbp+var_10]
movsxd rcx, ecx
mov [rdx+rcx*4], eax
loc_130D:
mov edx, [rbp+var_1C]
mov eax, [rbp+var_2C]
add eax, edx
cmp [rbp+var_24], eax
jl short loc_1373
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov edx, [rbp+var_1C]
mov eax, [rbp+var_2C]
add edx, eax
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp ecx, eax
jl short loc_134F
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add eax, 1
jmp short loc_1361
loc_134F:
mov edx, [rbp+var_1C]
mov eax, [rbp+var_2C]
add edx, eax
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
loc_1361:
mov ecx, [rbp+var_1C]
mov edx, [rbp+var_2C]
add ecx, edx
mov rdx, [rbp+var_10]
movsxd rcx, ecx
mov [rdx+rcx*4], eax
loc_1373:
mov edx, [rbp+var_1C]
mov eax, [rbp+var_30]
add eax, edx
cmp [rbp+var_24], eax
jl short loc_13D9
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov ecx, [rax+rdx*4]
mov edx, [rbp+var_1C]
mov eax, [rbp+var_30]
add edx, eax
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
cmp ecx, eax
jl short loc_13B5
mov rax, [rbp+var_10]
mov edx, [rbp+var_1C]
movsxd rdx, edx
mov eax, [rax+rdx*4]
add eax, 1
jmp short loc_13C7
loc_13B5:
mov edx, [rbp+var_1C]
mov eax, [rbp+var_30]
add edx, eax
mov rax, [rbp+var_10]
movsxd rdx, edx
mov eax, [rax+rdx*4]
loc_13C7:
mov ecx, [rbp+var_1C]
mov edx, [rbp+var_30]
add ecx, edx
mov rdx, [rbp+var_10]
movsxd rcx, ecx
mov [rdx+rcx*4], eax
loc_13D9:
add [rbp+var_1C], 1
loc_13DD:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_24]
jle loc_1291
mov rax, [rbp+var_10]
mov edx, [rbp+var_24]
movsxd rdx, edx
mov eax, [rax+rdx*4]
mov rsp, rsi
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_140D
call ___stack_chk_fail
locret_140D:
leave
retn | long long func0(int a1, int a2, int a3, int a4)
{
unsigned long long v4; // rax
void *v5; // rsp
int v6; // eax
int v7; // eax
int v8; // eax
int v10; // [rsp+8h] [rbp-30h] BYREF
int v11; // [rsp+Ch] [rbp-2Ch]
int v12; // [rsp+10h] [rbp-28h]
int v13; // [rsp+14h] [rbp-24h]
int i; // [rsp+18h] [rbp-20h]
int j; // [rsp+1Ch] [rbp-1Ch]
long long v16; // [rsp+20h] [rbp-18h]
int *v17; // [rsp+28h] [rbp-10h]
unsigned long long v18; // [rsp+30h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v18 = __readfsqword(0x28u);
v16 = a1 + 10 - 1LL;
v4 = 16 * ((4LL * (a1 + 10) + 15) / 0x10uLL);
while ( &v10 != (int *)((char *)&v10 - (v4 & 0xFFFFFFFFFFFFF000LL)) )
;
v5 = alloca(v4 & 0xFFF);
if ( (v4 & 0xFFF) != 0 )
*(_QWORD *)((char *)&v10 + (v4 & 0xFFF) - 8) = *(_QWORD *)((char *)&v10 + (v4 & 0xFFF) - 8);
v17 = &v10;
for ( i = 0; i <= v13 + 9; ++i )
v17[i] = -1;
*v17 = 0;
for ( j = 0; j <= v13; ++j )
{
if ( v17[j] != -1 )
{
if ( v13 >= j + v12 )
{
if ( v17[j] < v17[v12 + j] )
v6 = v17[v12 + j];
else
v6 = v17[j] + 1;
v17[v12 + j] = v6;
}
if ( v13 >= j + v11 )
{
if ( v17[j] < v17[v11 + j] )
v7 = v17[v11 + j];
else
v7 = v17[j] + 1;
v17[v11 + j] = v7;
}
if ( v13 >= j + v10 )
{
if ( v17[j] < v17[v10 + j] )
v8 = v17[v10 + j];
else
v8 = v17[j] + 1;
v17[v10 + j] = v8;
}
}
}
return (unsigned int)v17[v13];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x28],ESI
MOV dword ptr [RBP + -0x2c],EDX
MOV dword ptr [RBP + -0x30],ECX
MOV 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 + -0x24]
ADD EAX,0xa
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_001011fe:
CMP RSP,RDX
JZ 0x00101215
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011fe
LAB_00101215:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x0010123f
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_0010123f:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x20],0x0
JMP 0x00101270
LAB_0010125b:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOVSXD RDX,EDX
MOV dword ptr [RAX + RDX*0x4],0xffffffff
ADD dword ptr [RBP + -0x20],0x1
LAB_00101270:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x9
CMP dword ptr [RBP + -0x20],EAX
JLE 0x0010125b
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001013dd
LAB_00101291:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP EAX,-0x1
JZ 0x001013d9
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,EDX
CMP dword ptr [RBP + -0x24],EAX
JL 0x0010130d
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x28]
ADD EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP ECX,EAX
JL 0x001012e9
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
JMP 0x001012fb
LAB_001012e9:
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x28]
ADD EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
LAB_001012fb:
MOV ECX,dword ptr [RBP + -0x1c]
MOV EDX,dword ptr [RBP + -0x28]
ADD ECX,EDX
MOV RDX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
MOV dword ptr [RDX + RCX*0x4],EAX
LAB_0010130d:
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,EDX
CMP dword ptr [RBP + -0x24],EAX
JL 0x00101373
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x2c]
ADD EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP ECX,EAX
JL 0x0010134f
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
JMP 0x00101361
LAB_0010134f:
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x2c]
ADD EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
LAB_00101361:
MOV ECX,dword ptr [RBP + -0x1c]
MOV EDX,dword ptr [RBP + -0x2c]
ADD ECX,EDX
MOV RDX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
MOV dword ptr [RDX + RCX*0x4],EAX
LAB_00101373:
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,EDX
CMP dword ptr [RBP + -0x24],EAX
JL 0x001013d9
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RAX + RDX*0x4]
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x30]
ADD EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
CMP ECX,EAX
JL 0x001013b5
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
JMP 0x001013c7
LAB_001013b5:
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x30]
ADD EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
LAB_001013c7:
MOV ECX,dword ptr [RBP + -0x1c]
MOV EDX,dword ptr [RBP + -0x30]
ADD ECX,EDX
MOV RDX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
MOV dword ptr [RDX + RCX*0x4],EAX
LAB_001013d9:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001013dd:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x24]
JLE 0x00101291
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,RSI
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010140d
CALL 0x00101080
LAB_0010140d:
LEAVE
RET | int4 func0(int param_1,int param_2,int param_3,int param_4)
{
long lVar1;
int iVar2;
ulong uVar3;
int *piVar4;
long in_FS_OFFSET;
int local_38;
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_2c = param_1;
local_30 = param_2;
local_34 = param_3;
local_38 = param_4;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (long)(param_1 + 10) + -1;
uVar3 = (((long)(param_1 + 10) * 4 + 0xfU) / 0x10) * 0x10;
for (piVar4 = &local_38; piVar4 != (int *)((long)&local_38 - (uVar3 & 0xfffffffffffff000));
piVar4 = (int *)((long)piVar4 + -0x1000)) {
*(int8 *)((long)piVar4 + -8) = *(int8 *)((long)piVar4 + -8);
}
lVar1 = -(ulong)((uint)uVar3 & 0xfff);
if ((uVar3 & 0xfff) != 0) {
*(int8 *)((long)piVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1) =
*(int8 *)((long)piVar4 + ((ulong)((uint)uVar3 & 0xfff) - 8) + lVar1);
}
for (local_28 = 0; local_28 <= local_2c + 9; local_28 = local_28 + 1) {
*(int4 *)((long)piVar4 + (long)local_28 * 4 + lVar1) = 0xffffffff;
}
*(int4 *)((long)piVar4 + lVar1) = 0;
for (local_24 = 0; local_24 <= local_2c; local_24 = local_24 + 1) {
if (*(int *)((long)piVar4 + (long)local_24 * 4 + lVar1) != -1) {
if (local_30 + local_24 <= local_2c) {
if (*(int *)((long)piVar4 + (long)local_24 * 4 + lVar1) <
*(int *)((long)piVar4 + (long)(local_24 + local_30) * 4 + lVar1)) {
iVar2 = *(int *)((long)piVar4 + (long)(local_24 + local_30) * 4 + lVar1);
}
else {
iVar2 = *(int *)((long)piVar4 + (long)local_24 * 4 + lVar1) + 1;
}
*(int *)((long)piVar4 + (long)(local_24 + local_30) * 4 + lVar1) = iVar2;
}
if (local_34 + local_24 <= local_2c) {
if (*(int *)((long)piVar4 + (long)local_24 * 4 + lVar1) <
*(int *)((long)piVar4 + (long)(local_24 + local_34) * 4 + lVar1)) {
iVar2 = *(int *)((long)piVar4 + (long)(local_24 + local_34) * 4 + lVar1);
}
else {
iVar2 = *(int *)((long)piVar4 + (long)local_24 * 4 + lVar1) + 1;
}
*(int *)((long)piVar4 + (long)(local_24 + local_34) * 4 + lVar1) = iVar2;
}
if (local_38 + local_24 <= local_2c) {
if (*(int *)((long)piVar4 + (long)local_24 * 4 + lVar1) <
*(int *)((long)piVar4 + (long)(local_24 + local_38) * 4 + lVar1)) {
iVar2 = *(int *)((long)piVar4 + (long)(local_24 + local_38) * 4 + lVar1);
}
else {
iVar2 = *(int *)((long)piVar4 + (long)local_24 * 4 + lVar1) + 1;
}
*(int *)((long)piVar4 + (long)(local_24 + local_38) * 4 + lVar1) = iVar2;
}
}
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
local_18 = (int *)((long)piVar4 + lVar1);
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)((long)piVar4 + (long)local_2c * 4 + lVar1);
} |
7,777 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int n, int a, int b, int c) {
int dp[n + 10];
for (int i = 0; i < n + 10; i++) {
dp[i] = -1;
}
dp[0] = 0;
for (int i = 0; i <= n; i++) {
if (dp[i] != -1) {
if (i + a <= n) {
dp[i + a] = (dp[i] + 1 > dp[i + a]) ? dp[i] + 1 : dp[i + a];
}
if (i + b <= n) {
dp[i + b] = (dp[i] + 1 > dp[i + b]) ? dp[i] + 1 : dp[i + b];
}
if (i + c <= n) {
dp[i + c] = (dp[i] + 1 > dp[i + c]) ? dp[i] + 1 : dp[i + c];
}
}
}
return dp[n];
}
| int main() {
assert(func0(7, 5, 2, 5) == 2);
assert(func0(17, 2, 1, 3) == 17);
assert(func0(18, 16, 3, 6) == 6);
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r14
push %r13
push %r12
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
lea 0xa(%rdi),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%r8
and $0xfffffffffffffff0,%r8
and $0xfffffffffffff000,%rax
mov %rsp,%rbx
sub %rax,%rbx
mov %rbx,%rax
cmp %rax,%rsp
je 11e5 <func0+0x5c>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 11ce <func0+0x45>
mov %r8,%rax
and $0xfff,%eax
sub %rax,%rsp
test %rax,%rax
je 11fb <func0+0x72>
orq $0x0,-0x8(%rsp,%rax,1)
lea 0x3(%rsp),%r11
mov %r11,%r10
shr $0x2,%r10
and $0xfffffffffffffffc,%r11
mov %r11,%r9
cmp $0xfffffff7,%edi
jl 122e <func0+0xa5>
mov %r11,%rax
lea 0x9(%rdi),%r8d
lea 0x4(%r11,%r8,4),%r8
movl $0xffffffff,(%rax)
add $0x4,%rax
cmp %r8,%rax
jne 121f <func0+0x96>
movl $0x0,0x0(,%r10,4)
test %edi,%edi
js 12dc <func0+0x153>
mov %edi,%ebx
mov $0x0,%eax
jmp 125b <func0+0xd2>
lea 0x1(%rax),%r8
cmp %rbx,%rax
je 12dc <func0+0x153>
mov %r8,%rax
mov (%r9,%rax,4),%r10d
cmp $0xffffffff,%r10d
je 124b <func0+0xc2>
mov %eax,%r8d
lea (%rsi,%rax,1),%r12d
cmp %r12d,%edi
jl 128b <func0+0x102>
movslq %r12d,%r12
lea (%r9,%r12,4),%r13
mov 0x0(%r13),%r12d
lea 0x1(%r10),%r14d
cmp %r12d,%r10d
cmovge %r14d,%r12d
mov %r12d,0x0(%r13)
lea (%rdx,%r8,1),%r10d
cmp %r10d,%edi
jl 12b2 <func0+0x129>
mov (%r9,%rax,4),%r13d
movslq %r10d,%r10
lea (%r9,%r10,4),%r12
mov (%r12),%r10d
lea 0x1(%r13),%r14d
cmp %r10d,%r13d
cmovge %r14d,%r10d
mov %r10d,(%r12)
add %ecx,%r8d
cmp %r8d,%edi
jl 124b <func0+0xc2>
mov (%r9,%rax,4),%r12d
movslq %r8d,%r8
lea (%r9,%r8,4),%r10
mov (%r10),%r8d
lea 0x1(%r12),%r13d
cmp %r8d,%r12d
cmovge %r13d,%r8d
mov %r8d,(%r10)
jmpq 124b <func0+0xc2>
movslq %edi,%rdi
mov (%r11,%rdi,4),%eax
mov -0x28(%rbp),%rdx
xor %fs:0x28,%rdx
jne 12ff <func0+0x176>
lea -0x20(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %rbp
retq
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 18h
mov r10d, esi
mov r8d, ecx
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea eax, [rdi+0Ah]
cdqe
lea rax, ds:0Fh[rax*4]
mov rsi, rax
and rsi, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rcx, rsp
sub rcx, rax
loc_11CF:
cmp rsp, rcx
jz short loc_11E6
sub rsp, 1000h
or [rsp+1030h+var_38], 0
jmp short loc_11CF
loc_11E6:
mov rax, rsi
and eax, 0FFFh
sub rsp, rax
test rax, rax
jz short loc_11FC
or [rsp+rax+30h+var_38], 0
loc_11FC:
lea r9, [rsp+30h+var_2D]
mov r11, r9
shr r11, 2
and r9, 0FFFFFFFFFFFFFFFCh
cmp edi, 0FFFFFFF7h
jl short loc_122B
mov rax, r9
lea ecx, [rdi+9]
lea rsi, [r9+rcx*4+4]
loc_121C:
mov dword ptr [rax], 0FFFFFFFFh
add rax, 4
cmp rax, rsi
jnz short loc_121C
loc_122B:
mov ds:dword_0[r11*4], 0
test edi, edi
js loc_12CE
mov rsi, r9
mov eax, r8d
mov ecx, edx
mov edx, r10d
lea ebx, [rdi+r8+1]
jmp short loc_1262
loc_1251:
add rsi, 4
add eax, 1
add ecx, 1
add edx, 1
cmp eax, ebx
jz short loc_12CE
loc_1262:
mov r10, rsi
mov r8d, [rsi]
cmp r8d, 0FFFFFFFFh
jz short loc_1251
cmp edx, edi
jg short loc_128B
movsxd r12, edx
mov r12d, [r9+r12*4]
lea r13d, [r8+1]
cmp r8d, r12d
cmovge r12d, r13d
movsxd r11, edx
mov [r9+r11*4], r12d
loc_128B:
cmp ecx, edi
jg short loc_12AC
mov r12d, [r10]
movsxd r11, ecx
mov r11d, [r9+r11*4]
lea r13d, [r12+1]
cmp r12d, r11d
cmovge r11d, r13d
movsxd r8, ecx
mov [r9+r8*4], r11d
loc_12AC:
cmp eax, edi
jg short loc_1251
mov r11d, [r10]
movsxd r10, eax
mov r10d, [r9+r10*4]
lea r12d, [r11+1]
cmp r11d, r10d
cmovge r10d, r12d
movsxd r8, eax
mov [r9+r8*4], r10d
jmp short loc_1251
loc_12CE:
movsxd rdi, edi
mov eax, [r9+rdi*4]
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jnz short loc_12EF
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn
loc_12EF:
call ___stack_chk_fail | long long func0(int a1, int a2, int a3, int a4)
{
signed long long v6; // rax
void *v7; // rsp
_DWORD *v8; // rax
int *v9; // rsi
int v10; // eax
int v12; // edx
int v13; // ebx
int v14; // r8d
int v15; // r12d
int v16; // r11d
int v17; // r10d
_DWORD v20[2]; // [rsp+8h] [rbp-30h] BYREF
unsigned long long v21; // [rsp+10h] [rbp-28h]
v21 = __readfsqword(0x28u);
while ( v20 != (_DWORD *)((char *)v20 - ((4LL * (a1 + 10) + 15) & 0xFFFFFFFFFFFFF000LL)) )
;
v6 = (4 * ((_WORD)a1 + 10) + 15) & 0xFF0;
v7 = alloca(v6);
if ( ((4 * ((_WORD)a1 + 10) + 15) & 0xFF0) != 0 )
*(_QWORD *)((char *)&v20[-2] + v6) = *(_QWORD *)((char *)&v20[-2] + v6);
if ( a1 >= -9 )
{
v8 = v20;
do
*v8++ = -1;
while ( v8 != &v20[a1 + 9 + 1] );
}
v20[0] = 0;
if ( a1 >= 0 )
{
v9 = v20;
v10 = a4;
v12 = a2;
v13 = a1 + a4 + 1;
do
{
v14 = *v9;
if ( *v9 != -1 )
{
if ( v12 <= a1 )
{
v15 = v20[v12];
if ( v14 >= v15 )
v15 = v14 + 1;
v20[v12] = v15;
}
if ( a3 <= a1 )
{
v16 = v20[a3];
if ( *v9 >= v16 )
v16 = *v9 + 1;
v20[a3] = v16;
}
if ( v10 <= a1 )
{
v17 = v20[v10];
if ( *v9 >= v17 )
v17 = *v9 + 1;
v20[v10] = v17;
}
}
++v9;
++v10;
++a3;
++v12;
}
while ( v10 != v13 );
}
return (unsigned int)v20[a1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R10D,ESI
MOV R8D,ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0xa]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RSI,RAX
AND RSI,-0x10
AND RAX,-0x1000
MOV RCX,RSP
SUB RCX,RAX
LAB_001011cf:
CMP RSP,RCX
JZ 0x001011e6
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x001011cf
LAB_001011e6:
MOV RAX,RSI
AND EAX,0xfff
SUB RSP,RAX
TEST RAX,RAX
JZ 0x001011fc
OR qword ptr [RSP + RAX*0x1 + -0x8],0x0
LAB_001011fc:
LEA R9,[RSP + 0x3]
MOV R11,R9
SHR R11,0x2
AND R9,-0x4
CMP EDI,-0x9
JL 0x0010122b
MOV RAX,R9
LEA ECX,[RDI + 0x9]
LEA RSI,[R9 + RCX*0x4 + 0x4]
LAB_0010121c:
MOV dword ptr [RAX],0xffffffff
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x0010121c
LAB_0010122b:
MOV dword ptr [R11*0x4],0x0
TEST EDI,EDI
JS 0x001012ce
MOV RSI,R9
MOV EAX,R8D
MOV ECX,EDX
MOV EDX,R10D
LEA EBX,[RDI + R8*0x1 + 0x1]
JMP 0x00101262
LAB_00101251:
ADD RSI,0x4
ADD EAX,0x1
ADD ECX,0x1
ADD EDX,0x1
CMP EAX,EBX
JZ 0x001012ce
LAB_00101262:
MOV R10,RSI
MOV R8D,dword ptr [RSI]
CMP R8D,-0x1
JZ 0x00101251
CMP EDX,EDI
JG 0x0010128b
MOVSXD R12,EDX
MOV R12D,dword ptr [R9 + R12*0x4]
LEA R13D,[R8 + 0x1]
CMP R8D,R12D
CMOVGE R12D,R13D
MOVSXD R11,EDX
MOV dword ptr [R9 + R11*0x4],R12D
LAB_0010128b:
CMP ECX,EDI
JG 0x001012ac
MOV R12D,dword ptr [R10]
MOVSXD R11,ECX
MOV R11D,dword ptr [R9 + R11*0x4]
LEA R13D,[R12 + 0x1]
CMP R12D,R11D
CMOVGE R11D,R13D
MOVSXD R8,ECX
MOV dword ptr [R9 + R8*0x4],R11D
LAB_001012ac:
CMP EAX,EDI
JG 0x00101251
MOV R11D,dword ptr [R10]
MOVSXD R10,EAX
MOV R10D,dword ptr [R9 + R10*0x4]
LEA R12D,[R11 + 0x1]
CMP R11D,R10D
CMOVGE R10D,R12D
MOVSXD R8,EAX
MOV dword ptr [R9 + R8*0x4],R10D
JMP 0x00101251
LAB_001012ce:
MOVSXD RDI,EDI
MOV EAX,dword ptr [R9 + RDI*0x4]
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012ef
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET
LAB_001012ef:
CALL 0x00101080 | int4 func0(int param_1,int param_2,int param_3,int param_4)
{
long lVar1;
int iVar2;
ulong uVar3;
int4 *puVar4;
int iVar5;
int1 *puVar6;
int *piVar7;
int iVar8;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (long)(param_1 + 10) * 4 + 0xf;
for (puVar6 = auStack_38; puVar6 != auStack_38 + -(uVar3 & 0xfffffffffffff000);
puVar6 = puVar6 + -0x1000) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar3 = (ulong)((uint)uVar3 & 0xff0);
lVar1 = -uVar3;
puVar4 = (int4 *)(puVar6 + lVar1);
piVar7 = (int *)(puVar6 + lVar1);
if (uVar3 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (-10 < param_1) {
do {
*puVar4 = 0xffffffff;
puVar4 = puVar4 + 1;
} while (puVar4 != (int4 *)(puVar6 + (ulong)(param_1 + 9) * 4 + lVar1 + 4));
}
*(int4 *)(puVar6 + lVar1) = 0;
if (-1 < param_1) {
iVar5 = param_1 + 1 + param_4;
do {
iVar8 = *piVar7;
if (iVar8 != -1) {
if (param_2 <= param_1) {
iVar2 = *(int *)(puVar6 + (long)param_2 * 4 + lVar1);
if (*(int *)(puVar6 + (long)param_2 * 4 + lVar1) <= iVar8) {
iVar2 = iVar8 + 1;
}
*(int *)(puVar6 + (long)param_2 * 4 + lVar1) = iVar2;
}
if (param_3 <= param_1) {
iVar8 = *(int *)(puVar6 + (long)param_3 * 4 + lVar1);
if (*(int *)(puVar6 + (long)param_3 * 4 + lVar1) <= *piVar7) {
iVar8 = *piVar7 + 1;
}
*(int *)(puVar6 + (long)param_3 * 4 + lVar1) = iVar8;
}
if (param_4 <= param_1) {
iVar8 = *(int *)(puVar6 + (long)param_4 * 4 + lVar1);
if (*(int *)(puVar6 + (long)param_4 * 4 + lVar1) <= *piVar7) {
iVar8 = *piVar7 + 1;
}
*(int *)(puVar6 + (long)param_4 * 4 + lVar1) = iVar8;
}
}
piVar7 = piVar7 + 1;
param_4 = param_4 + 1;
param_3 = param_3 + 1;
param_2 = param_2 + 1;
} while (param_4 != iVar5);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return *(int4 *)(puVar6 + (long)param_1 * 4 + lVar1);
}
/* WARNING: Subroutine does not return */
*(code **)(puVar6 + lVar1 + -8) = main;
__stack_chk_fail();
} |
7,778 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int n, int a, int b, int c) {
int dp[n + 10];
for (int i = 0; i < n + 10; i++) {
dp[i] = -1;
}
dp[0] = 0;
for (int i = 0; i <= n; i++) {
if (dp[i] != -1) {
if (i + a <= n) {
dp[i + a] = (dp[i] + 1 > dp[i + a]) ? dp[i] + 1 : dp[i + a];
}
if (i + b <= n) {
dp[i + b] = (dp[i] + 1 > dp[i + b]) ? dp[i] + 1 : dp[i + b];
}
if (i + c <= n) {
dp[i + c] = (dp[i] + 1 > dp[i + c]) ? dp[i] + 1 : dp[i + c];
}
}
}
return dp[n];
}
| int main() {
assert(func0(7, 5, 2, 5) == 2);
assert(func0(17, 2, 1, 3) == 17);
assert(func0(18, 16, 3, 6) == 6);
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
lea 0xa(%rdi),%eax
mov %rsp,%rbx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%r8
and $0xfffffffffffff000,%rax
sub %rax,%rbx
and $0xfffffffffffffff0,%r8
mov %rbx,%rax
cmp %rax,%rsp
je 12cd <func0+0x5d>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 12b8 <func0+0x48>
and $0xfff,%r8d
sub %r8,%rsp
test %r8,%r8
jne 13e0 <func0+0x170>
lea 0x3(%rsp),%r9
mov %r9,%r10
and $0xfffffffffffffffc,%r9
shr $0x2,%r10
cmp $0xfffffff7,%edi
jl 1317 <func0+0xa7>
lea 0x9(%rdi),%r8d
mov %r9,%rax
lea 0x4(%r9,%r8,4),%r8
nopl 0x0(%rax)
movl $0xffffffff,(%rax)
add $0x4,%rax
cmp %r8,%rax
jne 1308 <func0+0x98>
movl $0x0,0x0(,%r10,4)
movslq %edi,%r11
xor %eax,%eax
xor %r10d,%r10d
test %edi,%edi
jns 133f <func0+0xcf>
jmpq 13c0 <func0+0x150>
nopl 0x0(%rax)
mov (%r9,%r8,4),%r10d
mov %r8,%rax
cmp $0xffffffff,%r10d
je 13b3 <func0+0x143>
lea (%rsi,%rax,1),%ebx
mov %eax,%r8d
cmp %ebx,%edi
jl 1369 <func0+0xf9>
movslq %ebx,%rbx
lea 0x1(%r10),%r13d
lea (%r9,%rbx,4),%r12
mov (%r12),%ebx
cmp %ebx,%r10d
cmovge %r13d,%ebx
mov %ebx,(%r12)
lea (%rdx,%r8,1),%r10d
cmp %r10d,%edi
jl 138f <func0+0x11f>
movslq %r10d,%r10
mov (%r9,%rax,4),%r12d
lea (%r9,%r10,4),%rbx
mov (%rbx),%r10d
lea 0x1(%r12),%r13d
cmp %r10d,%r12d
cmovge %r13d,%r10d
mov %r10d,(%rbx)
add %ecx,%r8d
cmp %r8d,%edi
jl 13b3 <func0+0x143>
movslq %r8d,%r8
mov (%r9,%rax,4),%ebx
lea (%r9,%r8,4),%r10
mov (%r10),%r8d
lea 0x1(%rbx),%r12d
cmp %r8d,%ebx
cmovge %r12d,%r8d
mov %r8d,(%r10)
lea 0x1(%rax),%r8
cmp %rax,%r11
jne 1338 <func0+0xc8>
mov -0x28(%rbp),%rdx
xor %fs:0x28,%rdx
mov (%r9,%r11,4),%eax
jne 13eb <func0+0x17b>
lea -0x18(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %rbp
retq
xchg %ax,%ax
orq $0x0,-0x8(%rsp,%r8,1)
jmpq 12e0 <func0+0x70>
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
mov r14d, edi
push r13
mov r13d, ecx
push r12
mov r12d, edx
push rbx
mov ebx, esi
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea eax, [rdi+0Ah]
mov rcx, rsp
cdqe
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rcx
jz short loc_12F9
loc_12E4:
sub rsp, 1000h
or [rsp+1040h+var_48], 0
cmp rsp, rcx
jnz short loc_12E4
loc_12F9:
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jnz loc_1408
loc_130B:
lea r8, [rsp+1040h+var_103D]
mov r15, r8
and r8, 0FFFFFFFFFFFFFFFCh
shr r15, 2
cmp r14d, 0FFFFFFF7h
jl short loc_133D
lea eax, [r14+9]
mov rdi, r8
mov esi, 0FFh
lea rdx, ds:4[rax*4]
call _memset
mov r8, rax
loc_133D:
mov ds:dword_0[r15*4], 0
test r14d, r14d
js loc_1418
mov edx, ebx
movsxd rbx, r14d
mov rax, r8
mov esi, r13d
mov ecx, r12d
lea r10, [r8+rbx*4]
xor edi, edi
jmp short loc_1377
loc_1370:
mov edi, [rax+4]
add rax, 4
loc_1377:
cmp edi, 0FFFFFFFFh
jz short loc_13D3
cmp edx, r14d
jg short loc_1397
movsxd r11, edx
lea r12d, [rdi+1]
mov r9d, [r8+r11*4]
cmp r9d, edi
cmovle r9d, r12d
mov [r8+r11*4], r9d
loc_1397:
cmp ecx, r14d
jg short loc_13B5
movsxd r9, ecx
mov r11d, [rax]
mov edi, [r8+r9*4]
lea r12d, [r11+1]
cmp r11d, edi
cmovge edi, r12d
mov [r8+r9*4], edi
loc_13B5:
cmp esi, r14d
jg short loc_13D3
movsxd r9, esi
mov r11d, [rax]
mov edi, [r8+r9*4]
lea r12d, [r11+1]
cmp r11d, edi
cmovge edi, r12d
mov [r8+r9*4], edi
loc_13D3:
add esi, 1
add ecx, 1
add edx, 1
cmp rax, r10
jnz short loc_1370
loc_13E1:
mov eax, [r8+rbx*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_141D
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1408:
or [rsp+rdx+1040h+var_1048], 0
jmp loc_130B
loc_1418:
movsxd rbx, r14d
jmp short loc_13E1
loc_141D:
call ___stack_chk_fail | long long func0(int a1, int a2, int a3, int a4)
{
long long v7; // rdx
_DWORD *v8; // rcx
__int16 v9; // dx
signed long long v10; // rdx
void *v11; // rsp
int *v12; // r8
long long v14; // rbx
int *v15; // rax
int v16; // esi
int v17; // ecx
int v18; // edi
int v19; // r9d
int v20; // edi
int v21; // edi
_DWORD v24[1022]; // [rsp+8h] [rbp-1040h] BYREF
_QWORD v25[8]; // [rsp+1008h] [rbp-40h] BYREF
v25[1] = __readfsqword(0x28u);
v7 = 4LL * (a1 + 10) + 15;
v8 = (_DWORD *)((char *)v25 - (v7 & 0xFFFFFFFFFFFFF000LL));
v9 = v7 & 0xFFF0;
if ( v25 != (_QWORD *)v8 )
{
while ( v24 != v8 )
;
}
v10 = v9 & 0xFFF;
v11 = alloca(v10);
if ( v10 )
*(_QWORD *)((char *)&v24[-2] + v10) = *(_QWORD *)((char *)&v24[-2] + v10);
v12 = v24;
if ( a1 >= -9 )
v12 = (int *)memset(v24, 255LL, 4LL * (unsigned int)(a1 + 9) + 4);
v24[0] = 0;
if ( a1 < 0 )
{
v14 = a1;
}
else
{
v14 = a1;
v15 = v12;
v16 = a4;
v17 = a3;
v18 = 0;
while ( 1 )
{
if ( v18 != -1 )
{
if ( a2 <= a1 )
{
v19 = v12[a2];
if ( v19 <= v18 )
v19 = v18 + 1;
v12[a2] = v19;
}
if ( v17 <= a1 )
{
v20 = v12[v17];
if ( *v15 >= v20 )
v20 = *v15 + 1;
v12[v17] = v20;
}
if ( v16 <= a1 )
{
v21 = v12[v16];
if ( *v15 >= v21 )
v21 = *v15 + 1;
v12[v16] = v21;
}
}
++v16;
++v17;
++a2;
if ( v15 == &v12[a1] )
break;
v18 = v15[1];
++v15;
}
}
return (unsigned int)v12[v14];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
MOV R14D,EDI
PUSH R13
MOV R13D,ECX
PUSH R12
MOV R12D,EDX
PUSH RBX
MOV EBX,ESI
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0xa]
MOV RCX,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001012f9
LAB_001012e4:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RCX
JNZ 0x001012e4
LAB_001012f9:
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JNZ 0x00101408
LAB_0010130b:
LEA R8,[RSP + 0x3]
MOV R15,R8
AND R8,-0x4
SHR R15,0x2
CMP R14D,-0x9
JL 0x0010133d
LEA EAX,[R14 + 0x9]
MOV RDI,R8
MOV ESI,0xff
LEA RDX,[0x4 + RAX*0x4]
CALL 0x001010b0
MOV R8,RAX
LAB_0010133d:
MOV dword ptr [R15*0x4],0x0
TEST R14D,R14D
JS 0x00101418
MOV EDX,EBX
MOVSXD RBX,R14D
MOV RAX,R8
MOV ESI,R13D
MOV ECX,R12D
LEA R10,[R8 + RBX*0x4]
XOR EDI,EDI
JMP 0x00101377
LAB_00101370:
MOV EDI,dword ptr [RAX + 0x4]
ADD RAX,0x4
LAB_00101377:
CMP EDI,-0x1
JZ 0x001013d3
CMP EDX,R14D
JG 0x00101397
MOVSXD R11,EDX
LEA R12D,[RDI + 0x1]
MOV R9D,dword ptr [R8 + R11*0x4]
CMP R9D,EDI
CMOVLE R9D,R12D
MOV dword ptr [R8 + R11*0x4],R9D
LAB_00101397:
CMP ECX,R14D
JG 0x001013b5
MOVSXD R9,ECX
MOV R11D,dword ptr [RAX]
MOV EDI,dword ptr [R8 + R9*0x4]
LEA R12D,[R11 + 0x1]
CMP R11D,EDI
CMOVGE EDI,R12D
MOV dword ptr [R8 + R9*0x4],EDI
LAB_001013b5:
CMP ESI,R14D
JG 0x001013d3
MOVSXD R9,ESI
MOV R11D,dword ptr [RAX]
MOV EDI,dword ptr [R8 + R9*0x4]
LEA R12D,[R11 + 0x1]
CMP R11D,EDI
CMOVGE EDI,R12D
MOV dword ptr [R8 + R9*0x4],EDI
LAB_001013d3:
ADD ESI,0x1
ADD ECX,0x1
ADD EDX,0x1
CMP RAX,R10
JNZ 0x00101370
LAB_001013e1:
MOV EAX,dword ptr [R8 + RBX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010141d
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101408:
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
JMP 0x0010130b
LAB_00101418:
MOVSXD RBX,R14D
JMP 0x001013e1
LAB_0010141d:
CALL 0x00101090 | int func0(int param_1,int param_2,int param_3,int param_4)
{
long lVar1;
int1 *puVar2;
int *piVar3;
int *piVar4;
ulong uVar5;
int1 *puVar6;
int iVar8;
int iVar9;
long in_FS_OFFSET;
int1 auStack_48 [8];
long local_40;
int1 *puVar7;
puVar6 = auStack_48;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar5 = (long)(param_1 + 10) * 4 + 0xf;
puVar7 = auStack_48;
puVar2 = auStack_48;
while (puVar7 != auStack_48 + -(uVar5 & 0xfffffffffffff000)) {
puVar6 = puVar2 + -0x1000;
*(int8 *)(puVar2 + -8) = *(int8 *)(puVar2 + -8);
puVar7 = puVar2 + -0x1000;
puVar2 = puVar2 + -0x1000;
}
uVar5 = (ulong)((uint)uVar5 & 0xff0);
lVar1 = -uVar5;
piVar3 = (int *)(puVar6 + lVar1);
if (uVar5 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (-10 < param_1) {
*(int8 *)(puVar6 + lVar1 + -8) = 0x10133a;
piVar3 = (int *)memset(puVar6 + lVar1,0xff,(ulong)(param_1 + 9) * 4 + 4);
}
*(int4 *)(puVar6 + lVar1) = 0;
if (-1 < param_1) {
iVar8 = 0;
piVar4 = piVar3;
while( true ) {
if (iVar8 != -1) {
if (param_2 <= param_1) {
iVar9 = piVar3[param_2];
if (piVar3[param_2] <= iVar8) {
iVar9 = iVar8 + 1;
}
piVar3[param_2] = iVar9;
}
if (param_3 <= param_1) {
iVar8 = piVar3[param_3];
if (piVar3[param_3] <= *piVar4) {
iVar8 = *piVar4 + 1;
}
piVar3[param_3] = iVar8;
}
if (param_4 <= param_1) {
iVar8 = piVar3[param_4];
if (piVar3[param_4] <= *piVar4) {
iVar8 = *piVar4 + 1;
}
piVar3[param_4] = iVar8;
}
}
param_4 = param_4 + 1;
param_3 = param_3 + 1;
param_2 = param_2 + 1;
if (piVar4 == piVar3 + param_1) break;
iVar8 = piVar4[1];
piVar4 = piVar4 + 1;
}
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return piVar3[param_1];
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar6 + lVar1 + -8) = 0x101422;
__stack_chk_fail();
} |
7,779 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int n, int a, int b, int c) {
int dp[n + 10];
for (int i = 0; i < n + 10; i++) {
dp[i] = -1;
}
dp[0] = 0;
for (int i = 0; i <= n; i++) {
if (dp[i] != -1) {
if (i + a <= n) {
dp[i + a] = (dp[i] + 1 > dp[i + a]) ? dp[i] + 1 : dp[i + a];
}
if (i + b <= n) {
dp[i + b] = (dp[i] + 1 > dp[i + b]) ? dp[i] + 1 : dp[i + b];
}
if (i + c <= n) {
dp[i + c] = (dp[i] + 1 > dp[i + c]) ? dp[i] + 1 : dp[i + c];
}
}
}
return dp[n];
}
| int main() {
assert(func0(7, 5, 2, 5) == 2);
assert(func0(17, 2, 1, 3) == 17);
assert(func0(18, 16, 3, 6) == 6);
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
mov %ecx,%r15d
push %r14
push %r13
mov %edx,%r13d
push %r12
mov %esi,%r12d
push %rbx
mov %edi,%ebx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea 0xa(%rdi),%eax
mov %rsp,%rdi
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rdi
and $0xfffffffffffffff0,%rdx
mov %rdi,%rax
cmp %rax,%rsp
je 12fc <func0+0x6c>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
cmp %rax,%rsp
jne 12e7 <func0+0x57>
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
jne 13f8 <func0+0x168>
lea 0x3(%rsp),%rdi
mov %rdi,%r14
and $0xfffffffffffffffc,%rdi
shr $0x2,%r14
cmp $0xfffffff7,%ebx
jl 133b <func0+0xab>
lea 0x9(%rbx),%eax
mov $0xff,%esi
lea 0x4(,%rax,4),%rdx
callq 10b0 <memset@plt>
mov %rax,%rdi
movl $0x0,0x0(,%r14,4)
movslq %ebx,%r8
xor %eax,%eax
test %ebx,%ebx
jns 135b <func0+0xcb>
jmp 13cf <func0+0x13f>
nopw 0x0(%rax,%rax,1)
mov %rdx,%rax
mov (%rdi,%rax,4),%ecx
cmp $0xffffffff,%ecx
je 13c6 <func0+0x136>
lea (%r12,%rax,1),%esi
mov %eax,%edx
cmp %esi,%ebx
jl 1384 <func0+0xf4>
movslq %esi,%rsi
lea 0x1(%rcx),%r10d
lea (%rdi,%rsi,4),%r9
mov (%r9),%esi
cmp %esi,%ecx
cmovge %r10d,%esi
mov %esi,(%r9)
lea 0x0(%r13,%rdx,1),%ecx
cmp %ebx,%ecx
jg 13a7 <func0+0x117>
movslq %ecx,%rcx
mov (%rdi,%rax,4),%r9d
lea (%rdi,%rcx,4),%rsi
mov (%rsi),%ecx
lea 0x1(%r9),%r10d
cmp %ecx,%r9d
cmovge %r10d,%ecx
mov %ecx,(%rsi)
add %r15d,%edx
cmp %edx,%ebx
jl 13c6 <func0+0x136>
movslq %edx,%rdx
mov (%rdi,%rax,4),%esi
lea (%rdi,%rdx,4),%rcx
mov (%rcx),%edx
lea 0x1(%rsi),%r9d
cmp %edx,%esi
cmovge %r9d,%edx
mov %edx,(%rcx)
lea 0x1(%rax),%rdx
cmp %rax,%r8
jne 1358 <func0+0xc8>
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
mov (%rdi,%r8,4),%eax
jne 1403 <func0+0x173>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
nopl 0x0(%rax)
orq $0x0,-0x8(%rsp,%rdx,1)
jmpq 130e <func0+0x7e>
callq 1090 <__stack_chk_fail@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
movsxd r14, edi
push r13
mov r13d, edx
lea edx, [r14+0Ah]
push r12
mov r12d, esi
push rbx
mov ebx, ecx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, edx
mov rsi, rsp
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rsi, rax
and rcx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rsi
jz short loc_12FB
loc_12E6:
sub rsp, 1000h
or [rsp+1040h+var_48], 0
cmp rsp, rsi
jnz short loc_12E6
loc_12FB:
and ecx, 0FFFh
sub rsp, rcx
test rcx, rcx
jnz loc_13F0
loc_130D:
lea rcx, [rsp+1040h+var_103D]
mov r15, rcx
and rcx, 0FFFFFFFFFFFFFFFCh
shr r15, 2
cmp r14d, 0FFFFFFF7h
jl loc_13FB
mov edx, edx
mov rdi, rcx; s
mov esi, 0FFh; c
shl rdx, 2; n
call _memset
lea r8d, [rbx+r14+1]
mov ds:dword_0[r15*4], 0
mov rcx, rax
mov rdx, rax
mov eax, ebx
test r14d, r14d
js short loc_13CD
nop dword ptr [rax+rax+00000000h]
loc_1360:
mov esi, [rdx]
cmp esi, 0FFFFFFFFh
jz short loc_13B9
cmp r12d, r14d
jg short loc_1381
movsxd r9, r12d
lea r10d, [rsi+1]
mov edi, [rcx+r9*4]
cmp esi, edi
cmovge edi, r10d
mov [rcx+r9*4], edi
loc_1381:
cmp r13d, r14d
jg short loc_139D
movsxd rdi, r13d
mov r9d, [rdx]
mov esi, [rcx+rdi*4]
lea r10d, [r9+1]
cmp r9d, esi
cmovge esi, r10d
mov [rcx+rdi*4], esi
loc_139D:
cmp eax, r14d
jg short loc_13B9
movsxd rdi, eax
mov r9d, [rdx]
mov esi, [rcx+rdi*4]
lea r10d, [r9+1]
cmp r9d, esi
cmovge esi, r10d
mov [rcx+rdi*4], esi
loc_13B9:
add eax, 1
add rdx, 4
add r13d, 1
add r12d, 1
cmp r8d, eax
jnz short loc_1360
loc_13CD:
mov eax, [rcx+r14*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1409
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_13F0:
or [rsp+rcx+1040h+var_1048], 0
jmp loc_130D
loc_13FB:
mov ds:dword_0[r15*4], 0
jmp short loc_13CD
loc_1409:
call ___stack_chk_fail | long long func0(int a1, int a2, int a3, int a4)
{
long long v4; // r14
long long v8; // rcx
_DWORD *v9; // rsi
__int16 v10; // cx
signed long long v11; // rcx
void *v12; // rsp
_DWORD *v13; // rcx
_DWORD *v14; // rax
int *v15; // rdx
int v16; // eax
int v17; // esi
int v18; // edi
int v19; // esi
int v20; // esi
_DWORD v23[1022]; // [rsp+8h] [rbp-1040h] BYREF
_QWORD v24[8]; // [rsp+1008h] [rbp-40h] BYREF
v4 = a1;
v24[1] = __readfsqword(0x28u);
v8 = 4LL * (a1 + 10) + 15;
v9 = (_DWORD *)((char *)v24 - (v8 & 0xFFFFFFFFFFFFF000LL));
v10 = v8 & 0xFFF0;
if ( v24 != (_QWORD *)v9 )
{
while ( v23 != v9 )
;
}
v11 = v10 & 0xFFF;
v12 = alloca(v11);
if ( v11 )
*(_QWORD *)((char *)&v23[-2] + v11) = *(_QWORD *)((char *)&v23[-2] + v11);
v13 = v23;
if ( a1 < -9 )
{
v23[0] = 0;
}
else
{
v14 = memset(v23, 255, 4LL * (unsigned int)(a1 + 10));
v23[0] = 0;
v13 = v14;
v15 = v14;
v16 = a4;
if ( a1 >= 0 )
{
do
{
v17 = *v15;
if ( *v15 != -1 )
{
if ( a2 <= (int)v4 )
{
v18 = v13[a2];
if ( v17 >= v18 )
v18 = v17 + 1;
v13[a2] = v18;
}
if ( a3 <= (int)v4 )
{
v19 = v13[a3];
if ( *v15 >= v19 )
v19 = *v15 + 1;
v13[a3] = v19;
}
if ( v16 <= (int)v4 )
{
v20 = v13[v16];
if ( *v15 >= v20 )
v20 = *v15 + 1;
v13[v16] = v20;
}
}
++v16;
++v15;
++a3;
++a2;
}
while ( a4 + (_DWORD)v4 + 1 != v16 );
}
}
return (unsigned int)v13[v4];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
MOVSXD R14,EDI
PUSH R13
MOV R13D,EDX
LEA EDX,[R14 + 0xa]
PUSH R12
MOV R12D,ESI
PUSH RBX
MOV EBX,ECX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,EDX
MOV RSI,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RAX,-0x1000
SUB RSI,RAX
AND RCX,-0x10
CMP RSP,RSI
JZ 0x001012fb
LAB_001012e6:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
CMP RSP,RSI
JNZ 0x001012e6
LAB_001012fb:
AND ECX,0xfff
SUB RSP,RCX
TEST RCX,RCX
JNZ 0x001013f0
LAB_0010130d:
LEA RCX,[RSP + 0x3]
MOV R15,RCX
AND RCX,-0x4
SHR R15,0x2
CMP R14D,-0x9
JL 0x001013fb
MOV EDX,EDX
MOV RDI,RCX
MOV ESI,0xff
SHL RDX,0x2
CALL 0x001010b0
LEA R8D,[RBX + R14*0x1 + 0x1]
MOV dword ptr [R15*0x4],0x0
MOV RCX,RAX
MOV RDX,RAX
MOV EAX,EBX
TEST R14D,R14D
JS 0x001013cd
NOP dword ptr [RAX + RAX*0x1]
LAB_00101360:
MOV ESI,dword ptr [RDX]
CMP ESI,-0x1
JZ 0x001013b9
CMP R12D,R14D
JG 0x00101381
MOVSXD R9,R12D
LEA R10D,[RSI + 0x1]
MOV EDI,dword ptr [RCX + R9*0x4]
CMP ESI,EDI
CMOVGE EDI,R10D
MOV dword ptr [RCX + R9*0x4],EDI
LAB_00101381:
CMP R13D,R14D
JG 0x0010139d
MOVSXD RDI,R13D
MOV R9D,dword ptr [RDX]
MOV ESI,dword ptr [RCX + RDI*0x4]
LEA R10D,[R9 + 0x1]
CMP R9D,ESI
CMOVGE ESI,R10D
MOV dword ptr [RCX + RDI*0x4],ESI
LAB_0010139d:
CMP EAX,R14D
JG 0x001013b9
MOVSXD RDI,EAX
MOV R9D,dword ptr [RDX]
MOV ESI,dword ptr [RCX + RDI*0x4]
LEA R10D,[R9 + 0x1]
CMP R9D,ESI
CMOVGE ESI,R10D
MOV dword ptr [RCX + RDI*0x4],ESI
LAB_001013b9:
ADD EAX,0x1
ADD RDX,0x4
ADD R13D,0x1
ADD R12D,0x1
CMP R8D,EAX
JNZ 0x00101360
LAB_001013cd:
MOV EAX,dword ptr [RCX + R14*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101409
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001013f0:
OR qword ptr [RSP + RCX*0x1 + -0x8],0x0
JMP 0x0010130d
LAB_001013fb:
MOV dword ptr [R15*0x4],0x0
JMP 0x001013cd
LAB_00101409:
CALL 0x00101090 | int func0(int param_1,int param_2,int param_3,int param_4)
{
long lVar1;
int iVar2;
int *puVar3;
int *piVar4;
ulong uVar5;
int *piVar6;
int *puVar7;
int iVar9;
int iVar10;
long in_FS_OFFSET;
int auStack_48 [8];
long local_40;
int *puVar8;
puVar7 = auStack_48;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar5 = (long)(int)(param_1 + 10U) * 4 + 0xf;
puVar8 = auStack_48;
puVar3 = auStack_48;
while (puVar8 != auStack_48 + -(uVar5 & 0xfffffffffffff000)) {
puVar7 = puVar3 + -0x1000;
*(int8 *)(puVar3 + -8) = *(int8 *)(puVar3 + -8);
puVar8 = puVar3 + -0x1000;
puVar3 = puVar3 + -0x1000;
}
uVar5 = (ulong)((uint)uVar5 & 0xff0);
lVar1 = -uVar5;
piVar4 = (int *)(puVar7 + lVar1);
if (uVar5 != 0) {
*(int8 *)(puVar7 + -8) = *(int8 *)(puVar7 + -8);
}
if (param_1 < -9) {
*(int4 *)(((ulong)(puVar7 + lVar1 + 3) >> 2) * 4) = 0;
}
else {
*(int8 *)(puVar7 + lVar1 + -8) = 0x10133a;
piVar4 = (int *)memset(puVar7 + lVar1,0xff,(ulong)(param_1 + 10U) << 2);
iVar2 = param_4 + 1;
*(int4 *)(((ulong)(puVar7 + lVar1 + 3) >> 2) * 4) = 0;
piVar6 = piVar4;
if (-1 < param_1) {
do {
iVar9 = *piVar6;
if (iVar9 != -1) {
if (param_2 <= param_1) {
iVar10 = piVar4[param_2];
if (piVar4[param_2] <= iVar9) {
iVar10 = iVar9 + 1;
}
piVar4[param_2] = iVar10;
}
if (param_3 <= param_1) {
iVar9 = piVar4[param_3];
if (piVar4[param_3] <= *piVar6) {
iVar9 = *piVar6 + 1;
}
piVar4[param_3] = iVar9;
}
if (param_4 <= param_1) {
iVar9 = piVar4[param_4];
if (piVar4[param_4] <= *piVar6) {
iVar9 = *piVar6 + 1;
}
piVar4[param_4] = iVar9;
}
}
param_4 = param_4 + 1;
param_3 = param_3 + 1;
param_2 = param_2 + 1;
piVar6 = piVar6 + 1;
} while (iVar2 + param_1 != param_4);
}
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return piVar4[param_1];
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar7 + lVar1 + -8) = 0x10140e;
__stack_chk_fail();
} |
7,780 | func0 | #include <stdio.h>
#include <assert.h>
typedef struct {
int a;
int b;
int c;
int d;
} Tuple;
| Tuple func0(Tuple test_tup1, Tuple test_tup2) {
Tuple res;
res.a = test_tup1.a;
res.b = test_tup1.b;
res = (Tuple){res.a, res.b, test_tup2.a, test_tup2.b};
return res;
}
| int main() {
Tuple t1 = {3, 4};
Tuple t2 = {5, 6};
Tuple result = func0(t1, t2);
assert(result.a == 3 && result.b == 4 && result.c == 5 && result.d == 6);
Tuple t3 = {1, 2};
Tuple t4 = {3, 4};
result = func0(t3, t4);
assert(result.a == 1 && result.b == 2 && result.c == 3 && result.d == 4);
Tuple t5 = {4, 5};
Tuple t6 = {6, 8};
result = func0(t5, t6);
assert(result.a == 4 && result.b == 5 && result.c == 6 && result.d == 8);
printf("All tests passed successfully.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
mov %rsi,%rax
mov %rdi,%r8
mov %r8,%rsi
mov %r9,%rdi
mov %rax,%rdi
mov %rsi,-0x30(%rbp)
mov %rdi,-0x28(%rbp)
mov %rdx,-0x40(%rbp)
mov %rcx,-0x38(%rbp)
mov -0x30(%rbp),%eax
mov %eax,-0x20(%rbp)
mov -0x2c(%rbp),%eax
mov %eax,-0x1c(%rbp)
mov -0x20(%rbp),%esi
mov -0x1c(%rbp),%ecx
mov -0x40(%rbp),%edx
mov -0x3c(%rbp),%eax
mov %esi,-0x20(%rbp)
mov %ecx,-0x1c(%rbp)
mov %edx,-0x18(%rbp)
mov %eax,-0x14(%rbp)
mov -0x20(%rbp),%rax
mov -0x18(%rbp),%rdx
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
mov rax, rdi
mov r8, rsi
mov rsi, rax
mov rdi, rdx
mov rdi, r8
mov [rbp+var_30], rsi
mov [rbp+var_28], rdi
mov [rbp+var_40], rdx
mov [rbp+var_38], rcx
mov eax, dword ptr [rbp+var_30]
mov dword ptr [rbp+var_20], eax
mov eax, dword ptr [rbp+var_30+4]
mov dword ptr [rbp+var_20+4], eax
mov esi, dword ptr [rbp+var_20]
mov ecx, dword ptr [rbp+var_20+4]
mov edx, dword ptr [rbp+var_40]
mov eax, dword ptr [rbp+var_40+4]
mov dword ptr [rbp+var_20], esi
mov dword ptr [rbp+var_20+4], ecx
mov dword ptr [rbp+var_18], edx
mov dword ptr [rbp+var_18+4], eax
mov rax, [rbp+var_20]
mov rdx, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1)
{
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV RAX,RDI
MOV R8,RSI
MOV RSI,RAX
MOV RDI,RDX
MOV RDI,R8
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x40],RDX
MOV qword ptr [RBP + -0x38],RCX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x1c],EAX
MOV ESI,dword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x1c]
MOV EDX,dword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x20],ESI
MOV dword ptr [RBP + -0x1c],ECX
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int [16] func0(int8 param_1,int8 param_2,int8 param_3)
{
int auVar1 [16];
int4 local_48;
int4 uStack_44;
local_48 = (int4)param_3;
uStack_44 = (int4)((ulong)param_3 >> 0x20);
auVar1._8_4_ = local_48;
auVar1._0_8_ = param_1;
auVar1._12_4_ = uStack_44;
return auVar1;
} |
7,781 | func0 | #include <stdio.h>
#include <assert.h>
typedef struct {
int a;
int b;
int c;
int d;
} Tuple;
| Tuple func0(Tuple test_tup1, Tuple test_tup2) {
Tuple res;
res.a = test_tup1.a;
res.b = test_tup1.b;
res = (Tuple){res.a, res.b, test_tup2.a, test_tup2.b};
return res;
}
| int main() {
Tuple t1 = {3, 4};
Tuple t2 = {5, 6};
Tuple result = func0(t1, t2);
assert(result.a == 3 && result.b == 4 && result.c == 5 && result.d == 6);
Tuple t3 = {1, 2};
Tuple t4 = {3, 4};
result = func0(t3, t4);
assert(result.a == 1 && result.b == 2 && result.c == 3 && result.d == 4);
Tuple t5 = {4, 5};
Tuple t6 = {6, 8};
result = func0(t5, t6);
assert(result.a == 4 && result.b == 5 && result.c == 6 && result.d == 8);
printf("All tests passed successfully.\n");
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rax
shr $0x20,%rax
shl $0x20,%rax
mov %rax,%rcx
mov %edi,%eax
or %rcx,%rax
mov %rdx,%rcx
shr $0x20,%rcx
shl $0x20,%rcx
mov %edx,%edx
or %rcx,%rdx
retq
| func0:
endbr64
mov rcx, rdi
shr rcx, 20h
shl rcx, 20h
mov eax, edi
or rax, rcx
mov rcx, rdx
shr rcx, 20h
shl rcx, 20h
mov edx, edx
or rdx, rcx
retn | unsigned long long func0(unsigned long long a1)
{
return (HIDWORD(a1) << 32) | (unsigned int)a1;
} | func0:
ENDBR64
MOV RCX,RDI
SHR RCX,0x20
SHL RCX,0x20
MOV EAX,EDI
OR RAX,RCX
MOV RCX,RDX
SHR RCX,0x20
SHL RCX,0x20
MOV EDX,EDX
OR RDX,RCX
RET | int1 [16] func0(int8 param_1,int8 param_2,int8 param_3)
{
int1 auVar1 [16];
auVar1._8_8_ = param_3;
auVar1._0_8_ = param_1;
return auVar1;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.